Upload 30 files

Dockerfile

@@ -0,0 +1,25 @@
+FROM fabiocicerchia/nginx-lua:1.27.5-alpine3.21.3
+LABEL maintainer="LibreTV Team"
+LABEL description="LibreTV - 免费在线视频搜索与观看平台"
+
+# 复制应用文件
+COPY . /usr/share/nginx/html
+
+# 复制Nginx配置文件
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+
+# 添加执行权限并设置为入口点脚本
+COPY docker-entrypoint.sh /
+RUN chmod +x /docker-entrypoint.sh
+
+# 暴露端口
+EXPOSE 80
+
+# 设置入口点
+ENTRYPOINT ["/docker-entrypoint.sh"]
+
+# 启动nginx
+CMD ["nginx", "-g", "daemon off;"]
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=3s CMD wget --quiet --tries=1 --spider http://localhost/ || exit 1

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 LibreTV Team
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

about.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>关于我们 - LibreTV</title>
+	<script src="https://cdn.tailwindcss.com"></script>
+	<link rel="stylesheet" href="css/styles.css">
+
+</head>
+<body class="page-bg text-white">
+	<div class="container mx-auto px-4 py-8">
+		<header class="text-center mb-8">
+			<h1 class="text-5xl font-bold gradient-text">关于我们</h1>
+		</header>
+		<main class="text-center">
+			<p class="text-gray-300 mb-4">
+				本项目代码托管在 GitHub 上，欢迎访问我们的仓库：
+				<a href="https://github.com/LibreSpark/LibreTV" class="text-blue-400 hover:underline" target="_blank" rel="noopener">https://github.com/LibreSpark/LibreTV</a>
+			</p>
+			<p class="text-gray-300 mb-8">
+				LibreTV 是一个免费的在线视频搜索平台，提供视频搜索和播放服务，致力于为用户带来最佳体验。
+			</p>
+			
+			<!-- 版权声明与投诉机制 -->
+			<div class="mt-12 mb-8 max-w-2xl mx-auto border border-gray-700 rounded-lg p-6 bg-[#111]">
+				<h2 class="text-xl font-semibold mb-4 text-blue-400">版权声明与投诉机制</h2>
+				<p class="text-gray-300 mb-4 text-left">
+					LibreTV 仅提供视频搜索服务，不直接提供、存储或上传任何视频内容。所有搜索结果均来自第三方公开接口。用户在使用本站服务时，须遵守相关法律法规，不得利用搜索结果从事侵权行为，如下载、传播未经授权的作品等。
+				</p>
+				<p class="text-gray-300 mb-4 text-left">
+					若您是版权方或相关权利人，发现本站搜索结果中存在侵犯您合法权益的内容，请通过以下渠道向我们反馈：
+				</p>
+				<div class="bg-[#1a1a1a] p-4 rounded-md mb-4 text-left">
+					<p class="text-gray-300"><span class="font-semibold">投诉邮箱：</span><a href="mailto:troll@pissmail.com" class="text-blue-400 hover:underline">troll@pissmail.com</a></p>
+				</div>
+				<p class="text-gray-300 text-left">
+					请在投诉邮件中提供：您的身份证明、权利证明、侵权内容的具体链接及相关说明。我们将在收到投诉后尽快处理，对于确认侵权的内容，将立即断开相关链接，停止展示侵权内容，并将处理结果反馈给您。
+				</p>
+			</div>
+		</main>
+		<footer class="mt-12 text-center">
+			<a href="index.html" class="text-gray-400 hover:text-white transition-colors">回到首页</a>
+		</footer>
+	</div>
+</body>
+</html>

api/proxy/[...path].mjs

@@ -0,0 +1,451 @@
+// /api/proxy/[...path].mjs - Vercel Serverless Function (ES Module)
+
+import fetch from 'node-fetch';
+import { URL } from 'url'; // 使用 Node.js 内置 URL 处理
+
+// --- 配置 (从环境变量读取) ---
+const DEBUG_ENABLED = process.env.DEBUG === 'true';
+const CACHE_TTL = parseInt(process.env.CACHE_TTL || '86400', 10); // 默认 24 小时
+const MAX_RECURSION = parseInt(process.env.MAX_RECURSION || '5', 10); // 默认 5 层
+
+// --- User Agent 处理 ---
+// 默认 User Agent 列表
+let USER_AGENTS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15'
+];
+// 尝试从环境变量读取并解析 USER_AGENTS_JSON
+try {
+    const agentsJsonString = process.env.USER_AGENTS_JSON;
+    if (agentsJsonString) {
+        const parsedAgents = JSON.parse(agentsJsonString);
+        // 检查解析结果是否为非空数组
+        if (Array.isArray(parsedAgents) && parsedAgents.length > 0) {
+            USER_AGENTS = parsedAgents; // 使用环境变量中的数组
+            console.log(`[代理日志] 已从环境变量加载 ${USER_AGENTS.length} 个 User Agent。`);
+        } else {
+            console.warn("[代理日志] 环境变量 USER_AGENTS_JSON 不是有效的非空数组，使用默认值。");
+        }
+    } else {
+        console.log("[代理日志] 未设置环境变量 USER_AGENTS_JSON，使用默认 User Agent。");
+    }
+} catch (e) {
+    // 如果 JSON 解析失败，记录错误并使用默认值
+    console.error(`[代理日志] 解析环境变量 USER_AGENTS_JSON 出错: ${e.message}。使用默认 User Agent。`);
+}
+
+// 广告过滤在代理中禁用，由播放器处理
+const FILTER_DISCONTINUITY = false;
+
+
+// --- 辅助函数 ---
+
+function logDebug(message) {
+    if (DEBUG_ENABLED) {
+        console.log(`[代理日志] ${message}`);
+    }
+}
+
+/**
+ * 从代理请求路径中提取编码后的目标 URL。
+ * @param {string} encodedPath - URL 编码后的路径部分 (例如 "https%3A%2F%2F...")
+ * @returns {string|null} 解码后的目标 URL，如果无效则返回 null。
+ */
+function getTargetUrlFromPath(encodedPath) {
+    if (!encodedPath) {
+        logDebug("getTargetUrlFromPath 收到空路径。");
+        return null;
+    }
+    try {
+        const decodedUrl = decodeURIComponent(encodedPath);
+        // 基础检查，看是否像一个 HTTP/HTTPS URL
+        if (decodedUrl.match(/^https?:\/\/.+/i)) {
+            return decodedUrl;
+        } else {
+            logDebug(`无效的解码 URL 格式: ${decodedUrl}`);
+            // 备选检查：原始路径是否未编码但看起来像 URL？
+            if (encodedPath.match(/^https?:\/\/.+/i)) {
+                logDebug(`警告: 路径未编码但看起来像 URL: ${encodedPath}`);
+                return encodedPath;
+            }
+            return null;
+        }
+    } catch (e) {
+        // 捕获解码错误 (例如格式错误的 URI)
+        logDebug(`解码目标 URL 出错: ${encodedPath} - ${e.message}`);
+        return null;
+    }
+}
+
+function getBaseUrl(urlStr) {
+    if (!urlStr) return '';
+    try {
+        const parsedUrl = new URL(urlStr);
+        // 处理根目录或只有文件名的情况
+        const pathSegments = parsedUrl.pathname.split('/').filter(Boolean); // 移除空字符串
+        if (pathSegments.length <= 1) {
+            return `${parsedUrl.origin}/`;
+        }
+        pathSegments.pop(); // 移除最后一段
+        return `${parsedUrl.origin}/${pathSegments.join('/')}/`;
+    } catch (e) {
+        logDebug(`获取 BaseUrl 失败: "${urlStr}": ${e.message}`);
+        // 备用方法：查找最后一个斜杠
+        const lastSlashIndex = urlStr.lastIndexOf('/');
+        if (lastSlashIndex > urlStr.indexOf('://') + 2) { // 确保不是协议部分的斜杠
+            return urlStr.substring(0, lastSlashIndex + 1);
+        }
+        return urlStr + '/'; // 如果没有路径，添加斜杠
+    }
+}
+
+function resolveUrl(baseUrl, relativeUrl) {
+    if (!relativeUrl) return ''; // 处理空的 relativeUrl
+    if (relativeUrl.match(/^https?:\/\/.+/i)) {
+        return relativeUrl; // 已经是绝对 URL
+    }
+    if (!baseUrl) return relativeUrl; // 没有基础 URL 无法解析
+
+    try {
+        // 使用 Node.js 的 URL 构造函数处理相对路径
+        return new URL(relativeUrl, baseUrl).toString();
+    } catch (e) {
+        logDebug(`URL 解析失败: base="${baseUrl}", relative="${relativeUrl}". 错误: ${e.message}`);
+        // 简单的备用逻辑
+        if (relativeUrl.startsWith('/')) {
+             try {
+                const baseOrigin = new URL(baseUrl).origin;
+                return `${baseOrigin}${relativeUrl}`;
+             } catch { return relativeUrl; } // 如果 baseUrl 也无效，返回原始相对路径
+        } else {
+            // 假设相对于包含基础 URL ���源的目录
+            return `${baseUrl.substring(0, baseUrl.lastIndexOf('/') + 1)}${relativeUrl}`;
+        }
+    }
+}
+
+// ** 已修正：确保生成 /proxy/ 前缀的链接 **
+function rewriteUrlToProxy(targetUrl) {
+    if (!targetUrl || typeof targetUrl !== 'string') return '';
+    // 返回与 vercel.json 的 "source" 和前端 PROXY_URL 一致的路径
+    return `/proxy/${encodeURIComponent(targetUrl)}`;
+}
+
+function getRandomUserAgent() {
+    return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+}
+
+async function fetchContentWithType(targetUrl, requestHeaders) {
+    // 准备请求头
+    const headers = {
+        'User-Agent': getRandomUserAgent(),
+        'Accept': requestHeaders['accept'] || '*/*', // 传递原始 Accept 头（如果有）
+        'Accept-Language': requestHeaders['accept-language'] || 'zh-CN,zh;q=0.9,en;q=0.8',
+        // 尝试设置一个合理的 Referer
+        'Referer': requestHeaders['referer'] || new URL(targetUrl).origin,
+    };
+    // 清理空值的头
+    Object.keys(headers).forEach(key => headers[key] === undefined || headers[key] === null || headers[key] === '' ? delete headers[key] : {});
+
+    logDebug(`准备请求目标: ${targetUrl}，请求头: ${JSON.stringify(headers)}`);
+
+    try {
+        // 发起 fetch 请求
+        const response = await fetch(targetUrl, { headers, redirect: 'follow' });
+
+        // 检查响应是否成功
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => ''); // 尝试获取错误响应体
+            logDebug(`请求失败: ${response.status} ${response.statusText} - ${targetUrl}`);
+            // 创建一个包含状态码的错误对象
+            const err = new Error(`HTTP 错误 ${response.status}: ${response.statusText}. URL: ${targetUrl}. Body: ${errorBody.substring(0, 200)}`);
+            err.status = response.status; // 将状态码附加到错误对象
+            throw err; // 抛出错误
+        }
+
+        // 读取响应内容
+        const content = await response.text();
+        const contentType = response.headers.get('content-type') || '';
+        logDebug(`请求成功: ${targetUrl}, Content-Type: ${contentType}, 内容长度: ${content.length}`);
+        // 返回结果
+        return { content, contentType, responseHeaders: response.headers };
+
+    } catch (error) {
+        // 捕获 fetch 本身的错误（网络、超时等）或上面抛出的 HTTP 错误
+        logDebug(`请求异常 ${targetUrl}: ${error.message}`);
+        // 重新抛出，确保包含原始错误信息
+        throw new Error(`请求目标 URL 失败 ${targetUrl}: ${error.message}`);
+    }
+}
+
+function isM3u8Content(content, contentType) {
+    if (contentType && (contentType.includes('application/vnd.apple.mpegurl') || contentType.includes('application/x-mpegurl') || contentType.includes('audio/mpegurl'))) {
+        return true;
+    }
+    return content && typeof content === 'string' && content.trim().startsWith('#EXTM3U');
+}
+
+function processKeyLine(line, baseUrl) {
+    return line.replace(/URI="([^"]+)"/, (match, uri) => {
+        const absoluteUri = resolveUrl(baseUrl, uri);
+        logDebug(`处理 KEY URI: 原始='${uri}', 绝对='${absoluteUri}'`);
+        return `URI="${rewriteUrlToProxy(absoluteUri)}"`;
+    });
+}
+
+function processMapLine(line, baseUrl) {
+     return line.replace(/URI="([^"]+)"/, (match, uri) => {
+        const absoluteUri = resolveUrl(baseUrl, uri);
+        logDebug(`处理 MAP URI: 原始='${uri}', 绝对='${absoluteUri}'`);
+        return `URI="${rewriteUrlToProxy(absoluteUri)}"`;
+     });
+ }
+
+function processMediaPlaylist(url, content) {
+    const baseUrl = getBaseUrl(url);
+    if (!baseUrl) {
+        logDebug(`无法确定媒体列表的 Base URL: ${url}，相对路径可能无法处理。`);
+    }
+    const lines = content.split('\n');
+    const output = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // 保留最后一个空行
+        if (!line && i === lines.length - 1) { output.push(line); continue; }
+        if (!line) continue; // 跳过中间空行
+        // 广告过滤已禁用
+        if (line.startsWith('#EXT-X-KEY')) { output.push(processKeyLine(line, baseUrl)); continue; }
+        if (line.startsWith('#EXT-X-MAP')) { output.push(processMapLine(line, baseUrl)); continue; }
+        if (line.startsWith('#EXTINF')) { output.push(line); continue; }
+        // 处理 URL 行
+        if (!line.startsWith('#')) {
+            const absoluteUrl = resolveUrl(baseUrl, line);
+            logDebug(`重写媒体片段: 原始='${line}', 解析后='${absoluteUrl}'`);
+            output.push(rewriteUrlToProxy(absoluteUrl)); continue;
+        }
+        // 保留其他 M3U8 标签
+        output.push(line);
+    }
+    return output.join('\n');
+}
+
+async function processM3u8Content(targetUrl, content, recursionDepth = 0) {
+    // 判断是主列表还是媒体列表
+    if (content.includes('#EXT-X-STREAM-INF') || content.includes('#EXT-X-MEDIA:')) {
+        logDebug(`检测到主播放列表: ${targetUrl} (深度: ${recursionDepth})`);
+        return await processMasterPlaylist(targetUrl, content, recursionDepth);
+    }
+    logDebug(`检测到媒体播放列表: ${targetUrl} (深度: ${recursionDepth})`);
+    return processMediaPlaylist(targetUrl, content);
+}
+
+async function processMasterPlaylist(url, content, recursionDepth) {
+    // 检查递归深度
+    if (recursionDepth > MAX_RECURSION) {
+        throw new Error(`处理主播放列表时，递归深度超过最大限制 (${MAX_RECURSION}): ${url}`);
+    }
+    const baseUrl = getBaseUrl(url);
+    const lines = content.split('\n');
+    let highestBandwidth = -1;
+    let bestVariantUrl = '';
+
+    // 查找最高带宽的流
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].startsWith('#EXT-X-STREAM-INF')) {
+            const bandwidthMatch = lines[i].match(/BANDWIDTH=(\d+)/);
+            const currentBandwidth = bandwidthMatch ? parseInt(bandwidthMatch[1], 10) : 0;
+            let variantUriLine = '';
+            // 找到下一行的 URI
+            for (let j = i + 1; j < lines.length; j++) {
+                const line = lines[j].trim();
+                if (line && !line.startsWith('#')) { variantUriLine = line; i = j; break; }
+            }
+            if (variantUriLine && currentBandwidth >= highestBandwidth) {
+                highestBandwidth = currentBandwidth;
+                bestVariantUrl = resolveUrl(baseUrl, variantUriLine);
+            }
+        }
+    }
+    // 如果没有找到带宽信息，尝试查找第一个 .m3u8 链接
+    if (!bestVariantUrl) {
+        logDebug(`主播放列表中未找到 BANDWIDTH 信息，尝试查找第一个 URI: ${url}`);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+             // 更可靠地匹配 .m3u8 链接
+            if (line && !line.startsWith('#') && line.match(/\.m3u8($|\?.*)/i)) {
+                bestVariantUrl = resolveUrl(baseUrl, line);
+                logDebug(`备选方案: 找到第一个子播放列表 URI: ${bestVariantUrl}`);
+                break;
+            }
+        }
+    }
+    // 如果仍然没有找到子列表 URL
+    if (!bestVariantUrl) {
+        logDebug(`在主播放列表 ${url} 中未找到有效的子列表 URI，将其作为媒体列表处理。`);
+        return processMediaPlaylist(url, content);
+    }
+
+    logDebug(`选择的子播放列表 (带宽: ${highestBandwidth}): ${bestVariantUrl}`);
+    // 请求选定的子播放列表内容 (注意：这里传递 {} 作为请求头，不传递客户端的原始请求头)
+    const { content: variantContent, contentType: variantContentType } = await fetchContentWithType(bestVariantUrl, {});
+
+    // 检查获取的内容是否是 M3U8
+    if (!isM3u8Content(variantContent, variantContentType)) {
+        logDebug(`获取的子播放列表 ${bestVariantUrl} 不是 M3U8 (类型: ${variantContentType})，将其作为媒体列表处理。`);
+        return processMediaPlaylist(bestVariantUrl, variantContent);
+    }
+
+    // 递归处理获取到的子 M3U8 内容
+    return await processM3u8Content(bestVariantUrl, variantContent, recursionDepth + 1);
+}
+
+
+// --- Vercel Handler 函数 ---
+export default async function handler(req, res) {
+    // --- 记录请求开始 ---
+    console.info('--- Vercel 代理请求开始 ---');
+    console.info('时间:', new Date().toISOString());
+    console.info('方法:', req.method);
+    console.info('URL:', req.url); // 原始请求 URL (例如 /proxy/...)
+    console.info('查询参数:', JSON.stringify(req.query)); // Vercel 解析的查询参数
+
+    // --- 提前设置 CORS 头 ---
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', '*'); // 允许所有请求头
+
+    // --- 处理 OPTIONS 预检请求 ---
+    if (req.method === 'OPTIONS') {
+        console.info("处理 OPTIONS 预检请求");
+        res.status(204).setHeader('Access-Control-Max-Age', '86400').end(); // 缓存预检结果 24 小时
+        return;
+    }
+
+    let targetUrl = null; // 初始化目标 URL
+
+    try { // ---- 开始主处理逻辑的 try 块 ----
+
+        // --- 提取目标 URL (主要依赖 req.query["...path"]) ---
+        // Vercel 将 :path* 捕获的内容（可能包含斜杠）放入 req.query["...path"] 数组
+        const pathData = req.query["...path"]; // 使用正确的键名
+        let encodedUrlPath = '';
+
+        if (pathData) {
+            if (Array.isArray(pathData)) {
+                encodedUrlPath = pathData.join('/'); // 重新组合
+                console.info(`从 req.query["...path"] (数组) 组合的编码路径: ${encodedUrlPath}`);
+            } else if (typeof pathData === 'string') {
+                encodedUrlPath = pathData; // 也处理 Vercel 可能只返回字符串的情况
+                console.info(`从 req.query["...path"] (字符串) 获取的编码路径: ${encodedUrlPath}`);
+            } else {
+                console.warn(`[代理警告] req.query["...path"] 类型未知: ${typeof pathData}`);
+            }
+        } else {
+            console.warn(`[代理警告] req.query["...path"] 为空或未定义。`);
+            // 备选：尝试从 req.url 提取（如果需要）
+            if (req.url && req.url.startsWith('/proxy/')) {
+                encodedUrlPath = req.url.substring('/proxy/'.length);
+                console.info(`使用备选方法从 req.url 提取的编码路径: ${encodedUrlPath}`);
+            }
+        }
+
+        // 如果仍然为空，则无法继续
+        if (!encodedUrlPath) {
+             throw new Error("无法从请求中确定编码后的目标路径。");
+        }
+
+        // 解析目标 URL
+        targetUrl = getTargetUrlFromPath(encodedUrlPath);
+        console.info(`解析出的目标 URL: ${targetUrl || 'null'}`); // 记录解析结果
+
+        // 检查目标 URL 是否有效
+        if (!targetUrl) {
+            // 抛出包含更多上下文的错误
+            throw new Error(`无效的代理请求路径。无法从组合路径 "${encodedUrlPath}" 中提取有效的目标 URL。`);
+        }
+
+        console.info(`开始处理目标 URL 的代理请求: ${targetUrl}`);
+
+        // --- 获取并处理目标内容 ---
+        const { content, contentType, responseHeaders } = await fetchContentWithType(targetUrl, req.headers);
+
+        // --- 如果是 M3U8，处理并返回 ---
+        if (isM3u8Content(content, contentType)) {
+            console.info(`正在处理 M3U8 内容: ${targetUrl}`);
+            const processedM3u8 = await processM3u8Content(targetUrl, content);
+
+            console.info(`成功处理 M3U8: ${targetUrl}`);
+            // 发送处理后的 M3U8 响应
+            res.status(200)
+                .setHeader('Content-Type', 'application/vnd.apple.mpegurl;charset=utf-8')
+                .setHeader('Cache-Control', `public, max-age=${CACHE_TTL}`)
+                // 移除可能导致问题的原始响应头
+                .removeHeader('content-encoding') // 很重要！node-fetch 已解压
+                .removeHeader('content-length')   // 长度已改变
+                .send(processedM3u8); // 发送 M3U8 文本
+
+        } else {
+            // --- 如果不是 M3U8，直接返回原始内容 ---
+            console.info(`直接返回非 M3U8 内容: ${targetUrl}, 类型: ${contentType}`);
+
+            // 设置原始响应头，但排除有问题的头和 CORS 头（已设置）
+            responseHeaders.forEach((value, key) => {
+                 const lowerKey = key.toLowerCase();
+                 if (!lowerKey.startsWith('access-control-') &&
+                     lowerKey !== 'content-encoding' && // 很重要！
+                     lowerKey !== 'content-length') {   // 很重要！
+                     res.setHeader(key, value); // 设置其他原始头
+                 }
+             });
+            // 设置我们自己的缓存策略
+            res.setHeader('Cache-Control', `public, max-age=${CACHE_TTL}`);
+
+            // 发送原始（已解压）内容
+            res.status(200).send(content);
+        }
+
+    // ---- 结束主处理逻辑的 try 块 ----
+    } catch (error) { // ---- 捕获处理过程中的任何错误 ----
+        // **检查这个错误是否是 "Assignment to constant variable"**
+        console.error(`[代理错误处理 V3] 捕获错误！目标: ${targetUrl || '解析失败'} | 错误类型: ${error.constructor.name} | 错误消息: ${error.message}`);
+        console.error(`[代理错误堆栈 V3] ${error.stack}`); // 记录完整的错误堆栈信息
+
+        // 特别标记 "Assignment to constant variable" 错误
+        if (error instanceof TypeError && error.message.includes("Assignment to constant variable")) {
+             console.error("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+             console.error("捕获到 'Assignment to constant variable' 错误!");
+             console.error("请再次检查函数代码及所有辅助函数中，是否有 const 声明的变量被重新赋值。");
+             console.error("错误堆栈指向:", error.stack);
+             console.error("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+        }
+
+        // 尝试从错误对象获取状态码，否则默认为 500
+        const statusCode = error.status || 500;
+
+        // 确保在发送错误响应前没有发送过响应头
+        if (!res.headersSent) {
+             res.setHeader('Content-Type', 'application/json');
+             // CORS 头应该已经在前面设置好了
+             res.status(statusCode).json({
+                success: false,
+                error: `代理处理错误: ${error.message}`, // 返回错误消息给前端
+                targetUrl: targetUrl // 包含目标 URL 以便调试
+            });
+        } else {
+            // 如果响应头已发送，无法��发送 JSON 错误
+            console.error("[代理错误处理 V3] 响应头已发送，无法发送 JSON 错误响应。");
+            // 尝试结束响应
+             if (!res.writableEnded) {
+                 res.end();
+             }
+        }
+    } finally {
+         // 记录请求处理结束
+         console.info('--- Vercel 代理请求结束 ---');
+    }
+}
+
+// --- [确保所有辅助函数定义都在这里] ---
+// getTargetUrlFromPath, getBaseUrl, resolveUrl, rewriteUrlToProxy, getRandomUserAgent,
+// fetchContentWithType, isM3u8Content, processKeyLine, processMapLine,
+// processMediaPlaylist, processM3u8Content, processMasterPlaylist

css/styles.css

@@ -0,0 +1,784 @@
+:root {
+    /* 赛博影视主题配色方案 - 柔和版 */
+    --primary-color: #00ccff;       /* 霓虹蓝主色调 */
+    --primary-light: #33d6ff;       /* 浅霓虹蓝变体 */
+    --secondary-color: #0f1622;     /* 深蓝黑背景色 */
+    --accent-color: #ff3c78;        /* 霓虹粉强调色 */
+    --text-color: #e6f2ff;          /* 柔和的蓝白色文本 */
+    --text-muted: #8599b2;          /* 淡蓝灰色次级文本 */
+    --border-color: rgba(0, 204, 255, 0.15);
+    --page-gradient-start: #0f1622; /* 深蓝黑起始色 */
+    --page-gradient-end: #192231;   /* 深靛蓝结束色 */
+    --card-gradient-start: #121b29; /* 卡片起始色 */
+    --card-gradient-end: #1c2939;   /* 卡片结束色 */
+    --card-accent: rgba(0, 204, 255, 0.12); /* 霓虹蓝卡片强调色 */
+    --card-hover-border: rgba(0, 204, 255, 0.5); /* 悬停边框颜色 */
+}
+
+.page-bg {
+    background: linear-gradient(180deg, var(--page-gradient-start), var(--page-gradient-end));
+    min-height: 100vh;
+    /* 柔和赛博点状背景 */
+    background-image: 
+        linear-gradient(180deg, var(--page-gradient-start), var(--page-gradient-end)),
+        radial-gradient(circle at 25px 25px, rgba(0, 204, 255, 0.04) 2px, transparent 3px),
+        radial-gradient(circle at 75px 75px, rgba(255, 60, 120, 0.02) 1px, transparent 2px),
+        radial-gradient(circle at 50px 50px, rgba(150, 255, 250, 0.015) 1px, transparent 2px);
+    background-blend-mode: normal;
+    background-size: cover, 100px 100px, 50px 50px, 75px 75px;
+}
+
+button, .card-hover {
+    transition: all 0.3s ease;
+}
+
+/* 改进卡片适应不同内容长度 */
+.card-hover {
+    border: 1px solid var(--border-color);
+    background: linear-gradient(135deg, var(--card-gradient-start), var(--card-gradient-end));
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.5);
+    position: relative;
+    overflow: hidden;
+    border-radius: 6px;
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+}
+
+/* 确保卡片内容区域高度一致性 */
+.card-hover .flex-grow {
+    min-height: 90px;
+    display: flex;
+    flex-direction: column;
+}
+
+/* 针对不同长度的标题优化显示 */
+.card-hover h3 {
+    min-height: 3rem;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    -webkit-line-clamp: 2;
+    max-height: 3rem; /* 确保最多显示两行 */
+    line-height: 1.5rem; /* 设定行高以确保两行文本的一致性 */
+    word-break: break-word; /* 允许在任何字符间断行 */
+    hyphens: auto; /* 允许断词 */
+}
+
+.card-hover::before {
+    content: "";
+    position: absolute;
+    top: 0;
+    left: -100%;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(90deg, transparent, var(--card-accent), transparent);
+    transition: left 0.6s ease;
+}
+
+.card-hover:hover {
+    border-color: var(--card-hover-border);
+    transform: translateY(-3px);
+    box-shadow: 0 6px 12px rgba(0, 0, 0, 0.5);
+}
+
+.card-hover:hover::before {
+    left: 100%;
+}
+
+.gradient-text {
+    background: linear-gradient(to right, var(--primary-color), var(--accent-color));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+}
+
+/* 改进设置面板样式 */
+.settings-panel {
+    scrollbar-width: thin;
+    scrollbar-color: #444 #222;
+    transform: translateX(100%);
+    transition: transform 0.3s ease;
+    background: linear-gradient(135deg, var(--page-gradient-end), var(--page-gradient-start));
+    border-left: 1px solid var(--primary-color);
+}
+
+.settings-panel.show {
+    transform: translateX(0);
+}
+
+.settings-panel::-webkit-scrollbar {
+    width: 6px;
+}
+
+.settings-panel::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+.settings-panel::-webkit-scrollbar-thumb {
+    background-color: #444;
+    border-radius: 4px;
+}
+
+/* 设置面板区块样式 */
+.settings-panel .shadow-inner {
+    box-shadow: inset 0 2px 4px rgba(0,0,0,0.3);
+    transition: all 0.2s ease-in-out;
+}
+
+.settings-panel .shadow-inner:hover {
+    box-shadow: inset 0 2px 8px rgba(0,0,0,0.4);
+}
+
+.search-button {
+    background: var(--primary-color);
+    color: var(--text-color);
+}
+
+.search-button:hover {
+    background: var(--primary-light);
+}
+
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: #111;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb {
+    background: #333;
+    border-radius: 4px;
+    transition: all 0.3s ease;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #444;
+}
+
+* {
+    scrollbar-width: thin;
+    scrollbar-color: #333 #111;
+}
+
+.search-tag {
+    background: linear-gradient(135deg, var(--card-gradient-start), var(--card-gradient-end));
+    color: var(--text-color);
+    padding: 0.5rem 1rem;
+    border-radius: 0.5rem;
+    font-size: 0.875rem;
+    border: 1px solid var(--border-color);
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+}
+
+.search-tag:hover {
+    background: linear-gradient(135deg, var(--card-gradient-end), var(--card-gradient-start));
+    border-color: var(--primary-color);
+}
+
+.footer {
+    width: 100%;
+    transition: all 0.3s ease;
+    margin-top: auto;
+    background: linear-gradient(to bottom, transparent, var(--page-gradient-start));
+    border-top: 1px solid var(--border-color);
+}
+
+.footer a:hover {
+    text-decoration: underline;
+}
+
+body {
+    display: flex;
+    flex-direction: column;
+    min-height: 100vh;
+}
+
+.container {
+    flex: 1;
+}
+
+@media screen and (min-height: 800px) {
+    body {
+        display: flex;
+        flex-direction: column;
+        min-height: 100vh;
+    }
+    
+    .container {
+        flex: 1;
+    }
+    
+    .footer {
+        margin-top: auto;
+    }
+}
+
+@media screen and (max-width: 640px) {
+    .footer {
+        padding-bottom: 2rem;
+    }
+}
+
+/* 移动端布局优化 */
+@media screen and (max-width: 768px) {
+    .card-hover h3 {
+        min-height: 2.5rem;
+    }
+    
+    .card-hover .flex-grow {
+        min-height: 80px;
+    }
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+@keyframes fadeOut {
+    from { opacity: 1; }
+    to { opacity: 0; }
+}
+
+#modal.show {
+    animation: fadeIn 0.3s forwards;
+}
+
+#modal.hide {
+    animation: fadeOut 0.3s forwards;
+}
+
+#modal > div {
+    background: linear-gradient(135deg, var(--card-gradient-start), var(--card-gradient-end));
+    border: 1px solid var(--primary-color);
+    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.7), 0 0 15px rgba(0, 204, 255, 0.1);
+    border-radius: 8px;
+}
+
+#modalContent button {
+    background: rgba(0, 204, 255, 0.08);
+    border: 1px solid rgba(0, 204, 255, 0.2);
+    transition: all 0.2s ease;
+}
+
+#modalContent button:hover {
+    background: rgba(0, 204, 255, 0.15);
+    border-color: var(--primary-color);
+    box-shadow: 0 0 8px rgba(0, 204, 255, 0.3);
+}
+
+#yellowFilterToggle:checked + .toggle-bg {
+    background-color: var(--primary-color);
+}
+
+#yellowFilterToggle:checked ~ .toggle-dot {
+    transform: translateX(1.5rem);
+}
+
+#yellowFilterToggle:focus + .toggle-bg,
+#yellowFilterToggle:hover + .toggle-bg {
+    box-shadow: 0 0 0 2px rgba(0, 204, 255, 0.3);
+}
+
+/* 添加广告过滤开关的CSS */
+#adFilterToggle:checked + .toggle-bg {
+    background-color: var(--primary-color);
+}
+
+#adFilterToggle:checked ~ .toggle-dot {
+    transform: translateX(1.5rem);
+}
+
+#adFilterToggle:focus + .toggle-bg,
+#adFilterToggle:hover + .toggle-bg {
+    box-shadow: 0 0 0 2px rgba(0, 204, 255, 0.3);
+}
+
+.toggle-dot {
+    transition: transform 0.3s ease-in-out;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+}
+
+.toggle-bg {
+    transition: background-color 0.3s ease-in-out;
+}
+
+#yellowFilterToggle:checked ~ .toggle-dot {
+    box-shadow: 0 2px 4px rgba(0, 204, 255, 0.3);
+}
+
+#adFilterToggle:checked ~ .toggle-dot {
+    box-shadow: 0 2px 4px rgba(0, 204, 255, 0.3);
+}
+
+/* 添加API复选框样式 */
+.form-checkbox {
+    appearance: none;
+    -webkit-appearance: none;
+    -moz-appearance: none;
+    height: 14px;
+    width: 14px;
+    background-color: #222;
+    border: 1px solid #333;
+    border-radius: 3px;
+    cursor: pointer;
+    position: relative;
+    outline: none;
+}
+
+.form-checkbox:checked {
+    background-color: var(--primary-color);
+    border-color: var(--primary-color);
+}
+
+.form-checkbox:checked::after {
+    content: '';
+    position: absolute;
+    left: 4px;
+    top: 1px;
+    width: 4px;
+    height: 8px;
+    border: solid white;
+    border-width: 0 2px 2px 0;
+    transform: rotate(45deg);
+}
+
+/* API滚动区域美化 */
+#apiCheckboxes {
+    scrollbar-width: thin;
+    scrollbar-color: #444 #222;
+}
+
+#apiCheckboxes::-webkit-scrollbar {
+    width: 6px;
+}
+
+#apiCheckboxes::-webkit-scrollbar-track {
+    background: #222;
+    border-radius: 4px;
+}
+
+#apiCheckboxes::-webkit-scrollbar-thumb {
+    background-color: #444;
+    border-radius: 4px;
+}
+
+/* 自定义API列表样式 */
+#customApisList {
+    scrollbar-width: thin;
+    scrollbar-color: #444 #222;
+}
+
+#customApisList::-webkit-scrollbar {
+    width: 6px;
+}
+
+#customApisList::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+#customApisList::-webkit-scrollbar-thumb {
+    background-color: #444;
+    border-radius: 4px;
+}
+
+/* 设置面板滚动样式 */
+.settings-panel {
+    scrollbar-width: thin;
+    scrollbar-color: #444 #222;
+}
+
+.settings-panel::-webkit-scrollbar {
+    width: 6px;
+}
+
+.settings-panel::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+.settings-panel::-webkit-scrollbar-thumb {
+    background-color: #444;
+    border-radius: 4px;
+}
+
+/* 添加自定义API表单动画 */
+#addCustomApiForm {
+    transition: all 0.3s ease;
+    max-height: 0;
+    opacity: 0;
+    overflow: hidden;
+}
+
+#addCustomApiForm.hidden {
+    max-height: 0;
+    padding: 0;
+    opacity: 0;
+}
+
+#addCustomApiForm:not(.hidden) {
+    max-height: 230px;
+    opacity: 1;
+}
+
+/* 成人内容API标记样式 */
+.api-adult + label {
+    color: #ff6b8b !important;
+}
+
+/* 添加警告图标和标签样式 */
+.adult-warning {
+    display: inline-flex;
+    align-items: center;
+    margin-left: 0.25rem;
+    color: #ff6b8b;
+}
+
+.adult-warning svg {
+    width: 12px;
+    height: 12px;
+    margin-right: 4px;
+}
+
+/* 过滤器禁用样式 */
+.filter-disabled {
+    opacity: 0.5;
+    pointer-events: none;
+    cursor: not-allowed;
+}
+
+/* API组标题样式 */
+.api-group-title {
+    grid-column: span 2;
+    padding: 0.25rem 0;
+    margin-top: 0.5rem;
+    border-top: 1px solid #333;
+    color: #8599b2;
+    font-size: 0.75rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.api-group-title.adult {
+    color: #ff6b8b;
+}
+
+/* 过滤器禁用样式 - 改进版本 */
+.filter-disabled {
+    position: relative;
+}
+
+.filter-disabled::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0,0,0,0.4);
+    border-radius: 0.5rem;
+    z-index: 5;
+}
+
+.filter-disabled > * {
+    opacity: 0.7;
+}
+
+.filter-disabled .toggle-bg {
+    background-color: #333 !important;
+}
+
+.filter-disabled .toggle-dot {
+    transform: translateX(0) !important;
+    background-color: #666 !important;
+}
+
+/* 改进过滤器禁用样式 */
+.filter-disabled .filter-description {
+    color: #ff6b8b !important;
+    font-style: italic;
+    font-weight: 500;
+}
+
+/* 修改过滤器禁用样式，确保文字清晰可见 */
+.filter-disabled {
+    position: relative;
+}
+
+.filter-disabled::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0,0,0,0.3);
+    border-radius: 0.5rem;
+    z-index: 5;
+}
+
+.filter-disabled > * {
+    opacity: 1; /* 提高子元素不透明度，保证可见性 */
+    z-index: 6; /* 确保内容在遮罩上方 */
+    position: relative;
+}
+
+/* 改进过滤器禁用状态下的描述样式 */
+.filter-disabled .filter-description {
+    color: #ff7b9d !important; /* 更亮的粉色 */
+    font-style: italic;
+    font-weight: 500;
+    text-shadow: 0 0 2px rgba(0,0,0,0.8); /* 添加文字阴影提高对比度 */
+}
+
+/* 开关的禁用样式 */
+.filter-disabled .toggle-bg {
+    background-color: #444 !important;
+    opacity: 0.8;
+}
+
+.filter-disabled .toggle-dot {
+    transform: translateX(0) ;
+    background-color: #777 ;
+    opacity: 0.9;
+}
+
+/* 警告提示样式改进 */
+.filter-tooltip {
+    background-color: rgba(255, 61, 87, 0.1);
+    border: 1px solid rgba(255, 61, 87, 0.2);
+    border-radius: 0.25rem;
+    padding: 0.5rem;
+    margin-top: 0.5rem;
+    display: flex;
+    align-items: center;
+    font-size: 0.75rem;
+    line-height: 1.25;
+    position: relative;
+    z-index: 10;
+}
+
+.filter-tooltip svg {
+    flex-shrink: 0;
+    width: 14px;
+    height: 14px;
+    margin-right: 0.35rem;
+}
+
+/* 编辑按钮样式 */
+.custom-api-edit {
+    color: #3b82f6;
+    transition: color 0.2s ease;
+}
+
+.custom-api-edit:hover {
+    color: #2563eb;
+}
+
+/* 自定义API条目样式改进 */
+#customApisList .api-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.25rem 0.5rem;
+    margin-bottom: 0.25rem;
+    background-color: #222;
+    border-radius: 0.25rem;
+    transition: background-color 0.2s ease;
+}
+
+#customApisList .api-item:hover {
+    background-color: #2a2a2a;
+}
+
+/* 成人内容标签样式 */
+.adult-tag {
+    display: inline-flex;
+    align-items: center;
+    color: #ff6b8b;
+    font-size: 0.7rem;
+    font-weight: 500;
+    margin-right: 0.35rem;
+}
+
+/* 历史记录面板样式 */
+.history-panel {
+    box-shadow: 2px 0 10px rgba(0,0,0,0.5);
+    transition: transform 0.3s ease-in-out;
+    overflow-y: scroll; /* 始终显示滚动条，防止宽度变化 */
+    overflow-x: hidden; /* 防止水平滚动 */
+    width: 320px; /* 固定宽度 */
+    box-sizing: border-box; /* 确保padding不影响总宽度 */
+    scrollbar-gutter: stable; /* 现代浏览器：为滚动条预留空间 */
+}
+
+.history-panel.show {
+    transform: translateX(0);
+}
+
+#historyList {
+    padding-right: 6px; /* 为滚动条预留空间，确保内容不被挤压 */
+}
+
+/* 历史记录项样式优化 */
+.history-item {
+    background: #1a1a1a;
+    border-radius: 6px; /* 减小圆角 */
+    border: 1px solid #333;
+    overflow: hidden;
+    transition: all 0.2s ease;
+    padding: 10px 14px;
+    position: relative;
+    margin-bottom: 8px; /* 减小底部间距 */
+    width: 100%; /* 确保宽度一致 */
+}
+
+.history-item:hover {
+    transform: translateY(-2px);
+    border-color: #444;
+    box-shadow: 0 4px 8px rgba(0,0,0,0.2);
+}
+
+/* 添加组悬停效果，使删除按钮在悬停时显示 */
+.history-item .delete-btn {
+    opacity: 0;
+    transition: opacity 0.2s ease;
+}
+
+.history-item:hover .delete-btn {
+    opacity: 1;
+}
+
+.history-info {
+    padding: 0; /* 移除额外的内边距 */
+    min-height: 70px;
+}
+
+.history-title {
+    font-weight: 500;
+    font-size: 0.95rem; /* 减小字体大小 */
+    margin-bottom: 2px; /* 减小底部边距 */
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.history-meta {
+    color: #bbb;
+    font-size: 0.75rem; /* 减小字体大小 */
+    display: flex;
+    flex-wrap: wrap;
+    margin-bottom: 1px; /* 减小边距 */
+}
+
+.history-episode {
+    color: #3b82f6;
+}
+
+.history-source {
+    color: #10b981;
+}
+
+.history-time {
+    color: #888;
+    font-size: 0.7rem; /* 减小字体大小 */
+    margin-top: 1px; /* 减小顶部边距 */
+}
+
+.history-separator {
+    color: #666;
+}
+
+.history-thumbnail {
+    width: 100%;
+    height: 90px;
+    background-color: #222;
+    overflow: hidden;
+}
+
+.history-thumbnail img {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+}
+
+.history-info {
+    padding: 10px;
+}
+
+.history-time {
+    color: #888;
+    font-size: 0.8rem;
+    margin-top: 4px;
+}
+
+.history-title {
+    font-weight: 500;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* 添加播放进度条样式 */
+.history-progress {
+    margin: 5px 0;
+}
+
+.progress-bar {
+    height: 3px;
+    background-color: rgba(255, 255, 255, 0.1);
+    border-radius: 2px;
+    overflow: hidden;
+    margin-bottom: 2px;
+}
+
+.progress-filled {
+    height: 100%;
+    background: linear-gradient(to right, #00ccff, #3b82f6);
+    border-radius: 2px;
+}
+
+.progress-text {
+    font-size: 10px;
+    color: #888;
+    text-align: right;
+}
+
+/* 添加恢复播放提示样式 */
+.position-restore-hint {
+    position: absolute;
+    bottom: 60px;
+    left: 50%;
+    transform: translateX(-50%) translateY(20px);
+    background-color: rgba(0, 0, 0, 0.7);
+    color: white;
+    padding: 8px 16px;
+    border-radius: 4px;
+    font-size: 14px;
+    z-index: 100;
+    opacity: 0;
+    transition: all 0.3s ease;
+}
+
+.position-restore-hint.show {
+    opacity: 1;
+    transform: translateX(-50%) translateY(0);
+}
+
+/* 锁定控制时屏蔽交互 */
+.player-container.controls-locked .dplayer-controller,
+.player-container.controls-locked .dplayer-mask,
+.player-container.controls-locked .dplayer-bar-wrap,
+.player-container.controls-locked .dplayer-statusbar,
+.player-container.controls-locked .shortcut-hint {
+    opacity: 0 !important;
+    pointer-events: none !important;
+}
+/* 保留锁按钮可见可点 */
+.player-container.controls-locked #lockToggle {
+    opacity: 1 !important;
+    pointer-events: auto !important;
+}

docker-compose.yml

@@ -0,0 +1,10 @@
+version: '3'
+services:
+  libretv:
+    image: bestzwei/libretv:latest
+    container_name: libretv
+    ports:
+      - "8899:80"
+    environment:
+      - PASSWORD=111111
+    restart: unless-stopped

docker-entrypoint.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+set -e
+
+# Function to hash a string with SHA-256
+hash_password() {
+  if [ -z "$1" ]; then
+    echo ""
+  else
+    echo -n "$1" | sha256sum | cut -d ' ' -f 1
+  fi
+}
+
+# Function to replace environment variables in HTML files
+replace_env_vars() {
+  # Hash the password if it exists
+  local password_hash=""
+  if [ -n "$PASSWORD" ]; then
+    password_hash=$(hash_password "$PASSWORD")
+  fi
+
+  # Replace the password placeholder in all HTML files with the hashed password
+  find /usr/share/nginx/html -type f -name "*.html" -exec sed -i "s/window.__ENV__.PASSWORD = \"{{PASSWORD}}\";/window.__ENV__.PASSWORD = \"${password_hash}\";/g" {} \;
+  
+  echo "Environment variables have been injected into HTML files."
+}
+
+# Replace environment variables in HTML files
+replace_env_vars
+
+# Execute the command provided as arguments
+exec "$@"

functions/_middleware.js

@@ -0,0 +1,37 @@
+import { sha256 } from '../js/sha256.js'; // 需新建或引入SHA-256实现
+
+// Cloudflare Pages Middleware to inject environment variables
+export async function onRequest(context) {
+  const { request, env, next } = context;
+  
+  // Proceed to the next middleware or route handler
+  const response = await next();
+  
+  // Check if the response is HTML
+  const contentType = response.headers.get("content-type") || "";
+  
+  if (contentType.includes("text/html")) {
+    // Get the original HTML content
+    let html = await response.text();
+    
+    // Replace the placeholder with actual environment variable value
+    // If PASSWORD is not set, replace with empty string
+    const password = env.PASSWORD || "";
+    let passwordHash = "";
+    if (password) {
+      passwordHash = await sha256(password);
+    }
+    html = html.replace('window.__ENV__.PASSWORD = "{{PASSWORD}}";', 
+                        `window.__ENV__.PASSWORD = "${passwordHash}"; // SHA-256 hash`);
+    
+    // Create a new response with the modified HTML
+    return new Response(html, {
+      headers: response.headers,
+      status: response.status,
+      statusText: response.statusText,
+    });
+  }
+  
+  // Return the original response for non-HTML content
+  return response;
+}

functions/proxy/[[path]].js

@@ -0,0 +1,519 @@
+// functions/proxy/[[path]].js
+
+// --- 配置 (现在从 Cloudflare 环境变量读取) ---
+// 在 Cloudflare Pages 设置 -> 函数 -> 环境变量绑定 中设置以下变量:
+// CACHE_TTL (例如 86400)
+// MAX_RECURSION (例如 5)
+// FILTER_DISCONTINUITY (不再需要，设为 false 或移除)
+// USER_AGENTS_JSON (例如 ["UA1", "UA2"]) - JSON 字符串数组
+// DEBUG (例如 false 或 true)
+// --- 配置结束 ---
+
+// --- 常量 (之前在 config.js 中，现在移到这里，因为它们与代理逻辑相关) ---
+const MEDIA_FILE_EXTENSIONS = [
+    '.mp4', '.webm', '.mkv', '.avi', '.mov', '.wmv', '.flv', '.f4v', '.m4v', '.3gp', '.3g2', '.ts', '.mts', '.m2ts',
+    '.mp3', '.wav', '.ogg', '.aac', '.m4a', '.flac', '.wma', '.alac', '.aiff', '.opus',
+    '.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.tiff', '.svg', '.avif', '.heic'
+];
+const MEDIA_CONTENT_TYPES = ['video/', 'audio/', 'image/'];
+// --- 常量结束 ---
+
+
+/**
+ * 主要的 Pages Function 处理函数
+ * 拦截发往 /proxy/* 的请求
+ */
+export async function onRequest(context) {
+    const { request, env, next, waitUntil } = context; // next 和 waitUntil 可能需要
+    const url = new URL(request.url);
+
+    // --- 从环境变量读取配置 ---
+    const DEBUG_ENABLED = (env.DEBUG === 'true');
+    const CACHE_TTL = parseInt(env.CACHE_TTL || '86400'); // 默认 24 小时
+    const MAX_RECURSION = parseInt(env.MAX_RECURSION || '5'); // 默认 5 层
+    // 广告过滤已移至播放器处理，代理不再执行
+    let USER_AGENTS = [ // 提供一个基础的默认值
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    ];
+    try {
+        // 尝试从环境变量解析 USER_AGENTS_JSON
+        const agentsJson = env.USER_AGENTS_JSON;
+        if (agentsJson) {
+            const parsedAgents = JSON.parse(agentsJson);
+            if (Array.isArray(parsedAgents) && parsedAgents.length > 0) {
+                USER_AGENTS = parsedAgents;
+            } else {
+                 logDebug("环境变量 USER_AGENTS_JSON 格式无效或为空，使用默认值");
+            }
+        }
+    } catch (e) {
+        logDebug(`解析环境变量 USER_AGENTS_JSON 失败: ${e.message}，使用默认值`);
+    }
+    // --- 配置读取结束 ---
+
+
+    // --- 辅助函数 ---
+
+    // 输出调试日志 (需要设置 DEBUG: true 环境变量)
+    function logDebug(message) {
+        if (DEBUG_ENABLED) {
+            console.log(`[Proxy Func] ${message}`);
+        }
+    }
+
+    // 从请求路径中提取目标 URL
+    function getTargetUrlFromPath(pathname) {
+        // 路径格式: /proxy/经过编码的URL
+        // 例如: /proxy/https%3A%2F%2Fexample.com%2Fplaylist.m3u8
+        const encodedUrl = pathname.replace(/^\/proxy\//, '');
+        if (!encodedUrl) return null;
+        try {
+            // 解码
+            let decodedUrl = decodeURIComponent(encodedUrl);
+
+             // 简单检查解码后是否是有效的 http/https URL
+             if (!decodedUrl.match(/^https?:\/\//i)) {
+                 // 也许原始路径就没有编码？如果看起来像URL就直接用
+                 if (encodedUrl.match(/^https?:\/\//i)) {
+                     decodedUrl = encodedUrl;
+                     logDebug(`Warning: Path was not encoded but looks like URL: ${decodedUrl}`);
+                 } else {
+                    logDebug(`无效的目标URL格式 (解码后): ${decodedUrl}`);
+                    return null;
+                 }
+             }
+             return decodedUrl;
+
+        } catch (e) {
+            logDebug(`解码目标URL时出错: ${encodedUrl} - ${e.message}`);
+            return null;
+        }
+    }
+
+    // 创建标准化的响应
+    function createResponse(body, status = 200, headers = {}) {
+        const responseHeaders = new Headers(headers);
+        // 关键：添加 CORS 跨域头，允许前端 JS 访问代理后的响应
+        responseHeaders.set("Access-Control-Allow-Origin", "*"); // 允许任何来源访问
+        responseHeaders.set("Access-Control-Allow-Methods", "GET, HEAD, POST, OPTIONS"); // 允许的方法
+        responseHeaders.set("Access-Control-Allow-Headers", "*"); // 允许所有请求头
+
+        // 处理 CORS 预检请求 (OPTIONS) - 放在这里确保所有响应都处理
+         if (request.method === "OPTIONS") {
+             // 使用下面的 onOptions 函数可以更规范，但在这里处理也可以
+             return new Response(null, {
+                 status: 204, // No Content
+                 headers: responseHeaders // 包含上面设置的 CORS 头
+             });
+         }
+
+        return new Response(body, { status, headers: responseHeaders });
+    }
+
+    // 创建 M3U8 类型的响应
+    function createM3u8Response(content) {
+        return createResponse(content, 200, {
+            "Content-Type": "application/vnd.apple.mpegurl", // M3U8 的标准 MIME 类型
+            "Cache-Control": `public, max-age=${CACHE_TTL}` // 允许浏览器和CDN缓存
+        });
+    }
+
+    // 获取随机 User-Agent
+    function getRandomUserAgent() {
+        return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+    }
+
+    // 获取 URL 的基础路径 (用于解析相对路径)
+    function getBaseUrl(urlStr) {
+        try {
+            const parsedUrl = new URL(urlStr);
+            // 如果路径是根目录，或者没有斜杠，直接返回 origin + /
+            if (!parsedUrl.pathname || parsedUrl.pathname === '/') {
+                return `${parsedUrl.origin}/`;
+            }
+            const pathParts = parsedUrl.pathname.split('/');
+            pathParts.pop(); // 移除文件名或最后一个路径段
+            return `${parsedUrl.origin}${pathParts.join('/')}/`;
+        } catch (e) {
+            logDebug(`获取 BaseUrl 时出错: ${urlStr} - ${e.message}`);
+            // 备用方法：找到最后一个斜杠
+            const lastSlashIndex = urlStr.lastIndexOf('/');
+            // 确保不是协议部分的斜杠 (http://)
+            return lastSlashIndex > urlStr.indexOf('://') + 2 ? urlStr.substring(0, lastSlashIndex + 1) : urlStr + '/';
+        }
+    }
+
+
+    // 将相对 URL 转换为绝对 URL
+    function resolveUrl(baseUrl, relativeUrl) {
+        // 如果已经是绝对 URL，直接返回
+        if (relativeUrl.match(/^https?:\/\//i)) {
+            return relativeUrl;
+        }
+        try {
+            // 使用 URL 对象来处理相对路径
+            return new URL(relativeUrl, baseUrl).toString();
+        } catch (e) {
+            logDebug(`解析 URL 失败: baseUrl=${baseUrl}, relativeUrl=${relativeUrl}, error=${e.message}`);
+            // 简单的备用方法
+            if (relativeUrl.startsWith('/')) {
+                // 处理根路径相对 URL
+                const urlObj = new URL(baseUrl);
+                return `${urlObj.origin}${relativeUrl}`;
+            }
+            // 处理同级目录相对 URL
+            return `${baseUrl.replace(/\/[^/]*$/, '/')}${relativeUrl}`; // 确保baseUrl以 / 结尾
+        }
+    }
+
+    // 将目标 URL 重写为内部代理路径 (/proxy/...)
+    function rewriteUrlToProxy(targetUrl) {
+        // 确保目标URL被正确编码，以便作为路径的一部分
+        return `/proxy/${encodeURIComponent(targetUrl)}`;
+    }
+
+    // 获取远程内容及其类型
+    async function fetchContentWithType(targetUrl) {
+        const headers = new Headers({
+            'User-Agent': getRandomUserAgent(),
+            'Accept': '*/*',
+            // 尝试传递一些原始请求的头信息
+            'Accept-Language': request.headers.get('Accept-Language') || 'zh-CN,zh;q=0.9,en;q=0.8',
+            // 尝试设置 Referer 为目标网站的域名，或者传递原始 Referer
+            'Referer': request.headers.get('Referer') || new URL(targetUrl).origin
+        });
+
+        try {
+            // 直接请求目标 URL
+            logDebug(`开始直接请求: ${targetUrl}`);
+            // Cloudflare Functions 的 fetch 默认支持重定向
+            const response = await fetch(targetUrl, { headers, redirect: 'follow' });
+
+            if (!response.ok) {
+                 const errorBody = await response.text().catch(() => '');
+                 logDebug(`请求失败: ${response.status} ${response.statusText} - ${targetUrl}`);
+                 throw new Error(`HTTP error ${response.status}: ${response.statusText}. URL: ${targetUrl}. Body: ${errorBody.substring(0, 150)}`);
+            }
+
+            // 读取响应内容为文本
+            const content = await response.text();
+            const contentType = response.headers.get('Content-Type') || '';
+            logDebug(`请求成功: ${targetUrl}, Content-Type: ${contentType}, 内容长度: ${content.length}`);
+            return { content, contentType, responseHeaders: response.headers }; // 同时返回原始响应头
+
+        } catch (error) {
+             logDebug(`请求彻底失败: ${targetUrl}: ${error.message}`);
+            // 抛出更详细的错误
+            throw new Error(`请求目标URL失败 ${targetUrl}: ${error.message}`);
+        }
+    }
+
+    // 判断是否是 M3U8 内容
+    function isM3u8Content(content, contentType) {
+        // 检查 Content-Type
+        if (contentType && (contentType.includes('application/vnd.apple.mpegurl') || contentType.includes('application/x-mpegurl') || contentType.includes('audio/mpegurl'))) {
+            return true;
+        }
+        // 检查内容本身是否以 #EXTM3U 开头
+        return content && typeof content === 'string' && content.trim().startsWith('#EXTM3U');
+    }
+
+    // 判断是否是媒体文件 (根据扩展名和 Content-Type) - 这部分在此代理中似乎未使用，但保留
+    function isMediaFile(url, contentType) {
+        if (contentType) {
+            for (const mediaType of MEDIA_CONTENT_TYPES) {
+                if (contentType.toLowerCase().startsWith(mediaType)) {
+                    return true;
+                }
+            }
+        }
+        const urlLower = url.toLowerCase();
+        for (const ext of MEDIA_FILE_EXTENSIONS) {
+            if (urlLower.endsWith(ext) || urlLower.includes(`${ext}?`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // 处理 M3U8 中的 #EXT-X-KEY 行 (加密密钥)
+    function processKeyLine(line, baseUrl) {
+        return line.replace(/URI="([^"]+)"/, (match, uri) => {
+            const absoluteUri = resolveUrl(baseUrl, uri);
+            logDebug(`处理 KEY URI: 原始='${uri}', 绝对='${absoluteUri}'`);
+            return `URI="${rewriteUrlToProxy(absoluteUri)}"`; // 重写为代理路径
+        });
+    }
+
+    // 处理 M3U8 中的 #EXT-X-MAP 行 (初始化片段)
+    function processMapLine(line, baseUrl) {
+         return line.replace(/URI="([^"]+)"/, (match, uri) => {
+             const absoluteUri = resolveUrl(baseUrl, uri);
+             logDebug(`处理 MAP URI: 原始='${uri}', 绝对='${absoluteUri}'`);
+             return `URI="${rewriteUrlToProxy(absoluteUri)}"`; // 重写为代理路径
+         });
+     }
+
+    // 处理媒体 M3U8 播放列表 (包含视频/音频片段)
+    function processMediaPlaylist(url, content) {
+        const baseUrl = getBaseUrl(url);
+        const lines = content.split('\n');
+        const output = [];
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            // 保留最后的空行
+            if (!line && i === lines.length - 1) {
+                output.push(line);
+                continue;
+            }
+            if (!line) continue; // 跳过中间的空行
+
+            if (line.startsWith('#EXT-X-KEY')) {
+                output.push(processKeyLine(line, baseUrl));
+                continue;
+            }
+            if (line.startsWith('#EXT-X-MAP')) {
+                output.push(processMapLine(line, baseUrl));
+                 continue;
+            }
+             if (line.startsWith('#EXTINF')) {
+                 output.push(line);
+                 continue;
+             }
+             if (!line.startsWith('#')) {
+                 const absoluteUrl = resolveUrl(baseUrl, line);
+                 logDebug(`重写媒体片段: 原始='${line}', 绝对='${absoluteUrl}'`);
+                 output.push(rewriteUrlToProxy(absoluteUrl));
+                 continue;
+             }
+             // 其他 M3U8 标签直接添加
+             output.push(line);
+        }
+        return output.join('\n');
+    }
+
+    // 递归处理 M3U8 内容
+     async function processM3u8Content(targetUrl, content, recursionDepth = 0, env) {
+         if (content.includes('#EXT-X-STREAM-INF') || content.includes('#EXT-X-MEDIA:')) {
+             logDebug(`检测到主播放列表: ${targetUrl}`);
+             return await processMasterPlaylist(targetUrl, content, recursionDepth, env);
+         }
+         logDebug(`检测到媒体播放列表: ${targetUrl}`);
+         return processMediaPlaylist(targetUrl, content);
+     }
+
+    // 处理主 M3U8 播放列表
+    async function processMasterPlaylist(url, content, recursionDepth, env) {
+        if (recursionDepth > MAX_RECURSION) {
+            throw new Error(`处理主列表时递归层数过多 (${MAX_RECURSION}): ${url}`);
+        }
+
+        const baseUrl = getBaseUrl(url);
+        const lines = content.split('\n');
+        let highestBandwidth = -1;
+        let bestVariantUrl = '';
+
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].startsWith('#EXT-X-STREAM-INF')) {
+                const bandwidthMatch = lines[i].match(/BANDWIDTH=(\d+)/);
+                const currentBandwidth = bandwidthMatch ? parseInt(bandwidthMatch[1], 10) : 0;
+
+                 let variantUriLine = '';
+                 for (let j = i + 1; j < lines.length; j++) {
+                     const line = lines[j].trim();
+                     if (line && !line.startsWith('#')) {
+                         variantUriLine = line;
+                         i = j;
+                         break;
+                     }
+                 }
+
+                 if (variantUriLine && currentBandwidth >= highestBandwidth) {
+                     highestBandwidth = currentBandwidth;
+                     bestVariantUrl = resolveUrl(baseUrl, variantUriLine);
+                 }
+            }
+        }
+
+         if (!bestVariantUrl) {
+             logDebug(`主列表中未找到 BANDWIDTH 或 STREAM-INF，尝试查找第一个子列表引用: ${url}`);
+             for (let i = 0; i < lines.length; i++) {
+                 const line = lines[i].trim();
+                 if (line && !line.startsWith('#') && (line.endsWith('.m3u8') || line.includes('.m3u8?'))) { // 修复：检查是否包含 .m3u8?
+                    bestVariantUrl = resolveUrl(baseUrl, line);
+                     logDebug(`备选方案：找到第一个子列表引用: ${bestVariantUrl}`);
+                     break;
+                 }
+             }
+         }
+
+        if (!bestVariantUrl) {
+            logDebug(`在主列表 ${url} 中未找到任何有效的子播放列表 URL。可能格式有问题或仅包含音频/字幕。将尝试按媒体列表处理原始内容。`);
+            return processMediaPlaylist(url, content);
+        }
+
+        // --- 获取并处理选中的子 M3U8 ---
+
+        const cacheKey = `m3u8_processed:${bestVariantUrl}`; // 使用处理后的缓存键
+
+        let kvNamespace = null;
+        try {
+            kvNamespace = env.LIBRETV_PROXY_KV; // 从环境获取 KV 命名空间 (变量名在 Cloudflare 设置)
+            if (!kvNamespace) throw new Error("KV 命名空间未绑定");
+        } catch (e) {
+            logDebug(`KV 命名空间 'LIBRETV_PROXY_KV' 访问出错或未绑定: ${e.message}`);
+            kvNamespace = null; // 确保设为 null
+        }
+
+        if (kvNamespace) {
+            try {
+                const cachedContent = await kvNamespace.get(cacheKey);
+                if (cachedContent) {
+                    logDebug(`[缓存命中] 主列表的子列表: ${bestVariantUrl}`);
+                    return cachedContent;
+                } else {
+                    logDebug(`[缓存未命中] 主列表的子列表: ${bestVariantUrl}`);
+                }
+            } catch (kvError) {
+                logDebug(`从 KV 读取缓存失败 (${cacheKey}): ${kvError.message}`);
+                // 出错则继续执行，不影响功能
+            }
+        }
+
+        logDebug(`选择的子列表 (带宽: ${highestBandwidth}): ${bestVariantUrl}`);
+        const { content: variantContent, contentType: variantContentType } = await fetchContentWithType(bestVariantUrl);
+
+        if (!isM3u8Content(variantContent, variantContentType)) {
+            logDebug(`获取到的子列表 ${bestVariantUrl} 不是 M3U8 内容 (类型: ${variantContentType})。可能直接是媒体文件，返回原始内容。`);
+             // 如果不是M3U8，但看起来像媒体内容，直接返回代理后的内容
+             // 注意：这里可能需要决定是否直接代理这个非 M3U8 的 URL
+             // 为了简化，我们假设如果不是 M3U8，则流程中断或按原样处理
+             // 或者，尝试将其作为媒体列表处理？（当前行为）
+             // return createResponse(variantContent, 200, { 'Content-Type': variantContentType || 'application/octet-stream' });
+             // 尝试按媒体列表处理，以防万一
+             return processMediaPlaylist(bestVariantUrl, variantContent);
+
+        }
+
+        const processedVariant = await processM3u8Content(bestVariantUrl, variantContent, recursionDepth + 1, env);
+
+        if (kvNamespace) {
+             try {
+                 // 使用 waitUntil 异步写入缓存，不阻塞响应返回
+                 // 注意 KV 的写入限制 (免费版每天 1000 次)
+                 waitUntil(kvNamespace.put(cacheKey, processedVariant, { expirationTtl: CACHE_TTL }));
+                 logDebug(`已将处理后的子列表写入缓存: ${bestVariantUrl}`);
+             } catch (kvError) {
+                 logDebug(`向 KV 写入缓存失败 (${cacheKey}): ${kvError.message}`);
+                 // 写入失败不影响返回结果
+             }
+        }
+
+        return processedVariant;
+    }
+
+    // --- 主要请求处理逻辑 ---
+
+    try {
+        const targetUrl = getTargetUrlFromPath(url.pathname);
+
+        if (!targetUrl) {
+            logDebug(`无效的代理请求路径: ${url.pathname}`);
+            return createResponse("无效的代理请求。路径应为 /proxy/<经过编码的URL>", 400);
+        }
+
+        logDebug(`收到代理请求: ${targetUrl}`);
+
+        // --- 缓存检查 (KV) ---
+        const cacheKey = `proxy_raw:${targetUrl}`; // 使用原始内容的缓存键
+        let kvNamespace = null;
+        try {
+            kvNamespace = env.LIBRETV_PROXY_KV;
+            if (!kvNamespace) throw new Error("KV 命名空间未绑定");
+        } catch (e) {
+            logDebug(`KV 命名空间 'LIBRETV_PROXY_KV' 访问出错或未绑定: ${e.message}`);
+            kvNamespace = null;
+        }
+
+        if (kvNamespace) {
+            try {
+                const cachedDataJson = await kvNamespace.get(cacheKey); // 直接获取字符串
+                if (cachedDataJson) {
+                    logDebug(`[缓存命中] 原始内容: ${targetUrl}`);
+                    const cachedData = JSON.parse(cachedDataJson); // 解析 JSON
+                    const content = cachedData.body;
+                    let headers = {};
+                    try { headers = JSON.parse(cachedData.headers); } catch(e){} // 解析头部
+                    const contentType = headers['content-type'] || headers['Content-Type'] || '';
+
+                    if (isM3u8Content(content, contentType)) {
+                        logDebug(`缓存内容是 M3U8，重新处理: ${targetUrl}`);
+                        const processedM3u8 = await processM3u8Content(targetUrl, content, 0, env);
+                        return createM3u8Response(processedM3u8);
+                    } else {
+                        logDebug(`从缓存返回非 M3U8 内容: ${targetUrl}`);
+                        return createResponse(content, 200, new Headers(headers));
+                    }
+                } else {
+                     logDebug(`[缓存未命中] 原始内容: ${targetUrl}`);
+                 }
+            } catch (kvError) {
+                 logDebug(`从 KV 读取或解析缓存失败 (${cacheKey}): ${kvError.message}`);
+                 // 出错则继续执行，不影响功能
+            }
+        }
+
+        // --- 实际请求 ---
+        const { content, contentType, responseHeaders } = await fetchContentWithType(targetUrl);
+
+        // --- 写入缓存 (KV) ---
+        if (kvNamespace) {
+             try {
+                 const headersToCache = {};
+                 responseHeaders.forEach((value, key) => { headersToCache[key.toLowerCase()] = value; });
+                 const cacheValue = { body: content, headers: JSON.stringify(headersToCache) };
+                 // 注意 KV 写入限制
+                 waitUntil(kvNamespace.put(cacheKey, JSON.stringify(cacheValue), { expirationTtl: CACHE_TTL }));
+                 logDebug(`已将原始内容写入缓存: ${targetUrl}`);
+            } catch (kvError) {
+                 logDebug(`向 KV 写入缓存失败 (${cacheKey}): ${kvError.message}`);
+                 // 写入失败不影响返回结果
+            }
+        }
+
+        // --- 处理响应 ---
+        if (isM3u8Content(content, contentType)) {
+            logDebug(`内容是 M3U8，开始处理: ${targetUrl}`);
+            const processedM3u8 = await processM3u8Content(targetUrl, content, 0, env);
+            return createM3u8Response(processedM3u8);
+        } else {
+            logDebug(`内容不是 M3U8 (类型: ${contentType})，直接返回: ${targetUrl}`);
+            const finalHeaders = new Headers(responseHeaders);
+            finalHeaders.set('Cache-Control', `public, max-age=${CACHE_TTL}`);
+            // 添加 CORS 头，确保非 M3U8 内容也能跨域访问（例如图片、字幕文件等）
+            finalHeaders.set("Access-Control-Allow-Origin", "*");
+            finalHeaders.set("Access-Control-Allow-Methods", "GET, HEAD, POST, OPTIONS");
+            finalHeaders.set("Access-Control-Allow-Headers", "*");
+            return createResponse(content, 200, finalHeaders);
+        }
+
+    } catch (error) {
+        logDebug(`处理代理请求时发生严重错误: ${error.message} \n ${error.stack}`);
+        return createResponse(`代理处理错误: ${error.message}`, 500);
+    }
+}
+
+// 处理 OPTIONS 预检请求的函数
+export async function onOptions(context) {
+    // 直接返回允许跨域的头信息
+    return new Response(null, {
+        status: 204, // No Content
+        headers: {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, HEAD, POST, OPTIONS",
+            "Access-Control-Allow-Headers": "*", // 允许所有请求头
+            "Access-Control-Max-Age": "86400", // 预检请求结果缓存一天
+        },
+    });
+}

index.html

@@ -0,0 +1,431 @@
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>LibreTV - 免费在线视频搜索与观看平台</title>
+    <meta name="description" content="LibreTV是一个免费的在线视频搜索平台，无广告、安全，提供来自多个视频源的内容搜索与观看服务，无需注册即可使用。">
+    <meta name="keywords" content="在线视频,免费视频,视频搜索,电影,电视剧,LibreTV">
+    <meta name="author" content="LibreTV Team">
+    <meta name="robots" content="index, follow">
+    
+    <!-- Open Graph / Facebook -->
+    <meta property="og:type" content="website">
+    <meta property="og:url" content="https://libretv.is-an.org/">
+    <meta property="og:title" content="LibreTV - 免费在线视频搜索与观看平台">
+    <meta property="og:description" content="搜索并观看来自多个视频源的内容，支持多种设备，无需注册即可使用。">
+    <meta property="og:image" content="https://images.icon-icons.com/38/PNG/512/retrotv_5520.png">
+    
+    <!-- Twitter -->
+    <meta property="twitter:card" content="summary_large_image">
+    <meta property="twitter:url" content="https://libretv.is-an.org/">
+    <meta property="twitter:title" content="LibreTV - 免费在线视频搜索与观看平台">
+    <meta property="twitter:description" content="搜索并观看来自多个视频源的内容，支持多种设备，无需注册即可使用。">
+    <meta property="twitter:image" content="https://images.icon-icons.com/38/PNG/512/retrotv_5520.png">
+    
+    <!-- Favicon -->
+    <link rel="icon" href="https://images.icon-icons.com/38/PNG/512/retrotv_5520.png">
+    <link rel="apple-touch-icon" href="https://images.icon-icons.com/38/PNG/512/retrotv_5520.png">
+    
+    <!-- Canonical URL -->
+    <link rel="canonical" href="https://libretv.is-an.org/">
+    
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link rel="stylesheet" href="css/styles.css">
+</head>
+<body class="page-bg text-white">
+    <!-- 将历史记录按钮移到左上角，并缩小尺寸 -->
+    <div class="fixed top-4 left-4 z-50">
+        <button onclick="toggleHistory(event)" class="bg-[#222] hover:bg-[#333] border border-[#333] hover:border-white rounded-lg px-3 py-1.5 transition-colors" aria-label="观看历史">
+            <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24" aria-hidden="true">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+            </svg>
+        </button>
+    </div>
+
+    <!-- 设置按钮保留在右上角，并缩小尺寸 -->
+    <div class="fixed top-4 right-4 z-50">
+        <button onclick="toggleSettings(event)" class="bg-[#222] hover:bg-[#333] border border-[#333] hover:border-white rounded-lg px-3 py-1.5 transition-colors" aria-label="打开设置">
+            <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24" aria-hidden="true">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37.996.608 2.296.07 2.572-1.065z"></path>
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"></path>
+            </svg>
+        </button>
+    </div>
+    
+    <!-- 历史记录面板 - 标题居中 -->
+    <div id="historyPanel" class="history-panel fixed left-0 top-0 h-full bg-[#111] border-r border-[#333] p-6 z-40 transform -translate-x-full transition-transform duration-300" aria-label="观看历史" aria-hidden="true">
+        <div class="flex justify-between items-center mb-6">
+            <button onclick="toggleHistory()" class="text-gray-400 hover:text-white" aria-label="关闭历史">&times;</button>
+            <h3 class="text-xl font-bold gradient-text mx-auto">观看历史</h3>
+            <div class="w-4"></div> <!-- 添加一个占位元素以确保标题居中 -->
+        </div>
+        <div id="historyList" class="pb-4">
+            <!-- 历史记录将在这里动态显示 -->
+            <div class="text-center text-gray-500 py-8">暂无观看记录</div>
+        </div>
+        <div class="mt-4 text-center sticky bottom-0 pb-2 pt-2 bg-[#111]">
+            <button onclick="clearViewingHistory()" class="px-4 py-2 w-full bg-gradient-to-r from-indigo-500 via-purple-500 to-pink-500 hover:from-indigo-600 hover:via-purple-600 hover:to-pink-600 text-white rounded-lg text-sm transition-all duration-300 shadow-md hover:shadow-lg">
+                清空历史记录
+            </button>
+        </div>
+    </div>
+
+    <!-- 设置面板 -->
+    <div id="settingsPanel" class="settings-panel fixed right-0 top-0 h-full w-80 bg-[#111] border-l border-[#333] p-6 z-40 overflow-y-auto" aria-label="设置面板" aria-hidden="true">
+        <div class="flex justify-between items-center mb-6">
+            <h3 class="text-xl font-bold gradient-text">设置</h3>
+            <button onclick="toggleSettings()" class="text-gray-400 hover:text-white" aria-label="关闭设置">&times;</button>
+        </div>
+        <div class="space-y-5">
+            <!-- 数据源设置区域 -->
+            <div class="p-3 bg-[#151515] rounded-lg shadow-inner">
+                <label class="block text-sm font-medium text-gray-400 mb-3 border-b border-[#333] pb-1">数据源设置</label>
+                
+                <!-- 批量操作按钮 -->
+                <div class="flex space-x-2 mb-3">
+                    <button onclick="selectAllAPIs(true)" class="px-2 py-1 bg-[#333] hover:bg-[#444] text-white text-xs rounded">全选</button>
+                    <button onclick="selectAllAPIs(false)" class="px-2 py-1 bg-[#333] hover:bg-[#444] text-white text-xs rounded">全不选</button>
+                    <button onclick="selectAllAPIs(true, true)" class="px-2 py-1 bg-[#333] hover:bg-[#444] text-white text-xs rounded">全选普通资源</button>
+                </div>
+                
+                <!-- API选择区域 - 使用滚动区域 -->
+                <div class="max-h-40 overflow-y-auto bg-[#191919] p-2 rounded-lg mb-3">
+                    <div id="apiCheckboxes" class="grid grid-cols-2 gap-2">
+                        <!-- 这里将动态插入API复选框 -->
+                    </div>
+                </div>
+                
+                <!-- API信息显示 -->
+                <div class="text-xs text-gray-500 flex justify-between items-center">
+                    <span>已选API数量：<span id="selectedApiCount" class="text-white">0</span></span>
+                    <span id="siteStatus" class="ml-2"></span>
+                </div>
+            </div>
+
+            <!-- 自定义API管理区域 -->
+            <div class="p-3 bg-[#151515] rounded-lg shadow-inner">
+                <div class="flex justify-between items-center mb-2">
+                    <label class="block text-sm font-medium text-gray-400 border-b border-[#333] w-full pb-1">自定义API</label>
+                    <button onclick="showAddCustomApiForm()" class="bg-[#333] hover:bg-[#444] text-white w-6 h-6 rounded-full text-center leading-none text-lg ml-1">+</button>
+                </div>
+                <div id="customApisList" class="max-h-32 overflow-y-auto mb-2">
+                    <!-- 自定义API将显示在这里 -->
+                </div>
+                
+                <!-- 添加自定义API表单 (默认隐藏) -->
+                <div id="addCustomApiForm" class="hidden mt-2 p-2 bg-[#191919] rounded-lg">
+                    <input type="text" id="customApiName" placeholder="API名称" class="w-full bg-[#222] border border-[#333] text-white px-2 py-1 rounded mb-2" autocomplete="off">
+                    <input type="text" id="customApiUrl" placeholder="https://abc.com" class="w-full bg-[#222] border border-[#333] text-white px-2 py-1 rounded mb-2" autocomplete="off">
+                    <!-- 添加成人内容切换 -->
+                    <div class="flex items-center mb-2">
+                        <input type="checkbox" id="customApiIsAdult" class="form-checkbox h-4 w-4 text-pink-500 bg-[#222] border border-[#333]">
+                        <label for="customApiIsAdult" class="ml-2 text-xs text-pink-400">黄色资源站</label>
+                    </div>
+                    <div class="flex space-x-2">
+                        <button onclick="addCustomApi()" class="bg-blue-600 hover:bg-blue-700 text-white px-3 py-1 rounded text-xs">添加</button>
+                        <button onclick="cancelAddCustomApi()" class="bg-[#444] hover:bg-[#555] text-white px-3 py-1 rounded text-xs">取消</button>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- 内容过滤设置区域 -->
+            <div class="p-3 bg-[#151515] rounded-lg shadow-inner">
+                <label class="block text-sm font-medium text-gray-400 mb-3 border-b border-[#333] pb-1">功能开关</label>
+                
+                <!-- 黄色内容过滤开关 -->
+                <div class="flex flex-col mb-3 pb-3 border-b border-[#222] relative">
+                    <div class="flex items-center justify-between">
+                        <div>
+                            <label class="text-sm font-medium text-gray-400">黄色内容过滤</label>
+                            <p class="text-xs text-gray-500 mt-1 filter-description">过滤"伦理片"等黄色内容</p>
+                        </div>
+                        <div class="relative inline-block w-12 align-middle select-none">
+                            <input type="checkbox" id="yellowFilterToggle" class="opacity-0 absolute w-full h-full cursor-pointer z-10">
+                            <div class="toggle-bg bg-[#333] w-12 h-6 rounded-full transition-colors duration-300 ease-in-out"></div>
+                            <div class="toggle-dot absolute w-5 h-5 bg-white rounded-full top-0.5 left-0.5 transition-transform duration-300 ease-in-out"></div>
+                        </div>
+                    </div>
+                    <!-- 警告提示将在这里动态插入 -->
+                </div>
+                
+                <!-- 广告过滤开关 -->
+                <div class="flex items-center justify-between mb-3 pb-3 border-b border-[#222]">
+                    <div>
+                        <label class="text-sm font-medium text-gray-400">分片广告过滤</label>
+                        <p class="text-xs text-gray-500 mt-1">关闭可减少旧版浏览器卡顿</p>
+                    </div>
+                    <div class="relative inline-block w-12 align-middle select-none">
+                        <input type="checkbox" id="adFilterToggle" class="opacity-0 absolute w-full h-full cursor-pointer z-10">
+                        <div class="toggle-bg bg-[#333] w-12 h-6 rounded-full transition-colors duration-300 ease-in-out"></div>
+                        <div class="toggle-dot absolute w-5 h-5 bg-white rounded-full top-0.5 left-0.5 transition-transform duration-300 ease-in-out"></div>
+                    </div>
+                </div>
+                
+                <!-- 豆瓣热门开关 -->
+                <div class="flex items-center justify-between">
+                    <div>
+                        <label class="text-sm font-medium text-gray-400">豆瓣热门推荐</label>
+                        <p class="text-xs text-gray-500 mt-1">首页显示豆瓣热门影视内容</p>
+                    </div>
+                    <div class="relative inline-block w-12 align-middle select-none">
+                        <input type="checkbox" id="doubanToggle" class="opacity-0 absolute w-full h-full cursor-pointer z-10">
+                        <div class="toggle-bg bg-[#333] w-12 h-6 rounded-full transition-colors duration-300 ease-in-out"></div>
+                        <div class="toggle-dot absolute w-5 h-5 bg-white rounded-full top-0.5 left-0.5 transition-transform duration-300 ease-in-out"></div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div class="container mx-auto px-4 py-8 flex flex-col h-screen">
+        <div class="flex-1 flex flex-col">
+            <!-- 网站标志和口号 -->
+            <header class="text-center mb-2">
+                <div class="flex justify-center items-center mb-4">
+                    <a href="#" onclick="resetToHome(); return false;" class="flex items-center">
+                        <svg class="w-10 h-10 mr-2" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 10l4.553-2.276A1 1 0 0121 8.618v6.764a1 1 0 01-1.447.894L15 14M5 18h8a2 2 0 002-2V8a2 2 0 00-2-2H5a2 2 0 00-2 2v8a2 2 0 002 2z"></path>
+                        </svg>
+                        <h1 class="text-5xl font-bold gradient-text">LibreTV</h1>
+                    </a>
+                </div>
+                <p class="text-gray-400 mb-8">自由观影，畅享精彩</p>
+            </header>
+            
+
+            <div id="searchArea" class="flex-1 flex flex-col items-center justify-center">
+                <div class="w-full max-w-2xl">
+                    <div class="flex items-stretch mb-3 h-14 shadow-lg rounded-lg overflow-hidden">
+                        <!-- 首页按钮 -->
+                        <button onclick="resetToHome()" 
+                                class="w-20 sm:w-24 flex items-center justify-center bg-white text-black font-medium hover:bg-gray-200 transition-colors" 
+                                aria-label="返回首页" title="返回首页">
+                            首页
+                        </button>
+                        <!-- 搜索输入 -->
+                        <input type="text" 
+                               id="searchInput" 
+                               class="flex-1 bg-[#111] border-y border-[#333] text-white px-6 py-0 focus:outline-none transition-colors" 
+                               placeholder="搜索你喜欢的视频..." 
+                               autocomplete="off"
+                               aria-label="视频搜索框">
+                        <!-- 搜索按钮 -->
+                        <button onclick="search()" 
+                                class="w-20 sm:w-24 flex items-center justify-center bg-white text-black font-medium hover:bg-gray-200 transition-colors" 
+                                aria-label="搜索按钮">
+                            搜索
+                        </button>
+                    </div>
+                    
+                    <!-- 添加最近搜索记录部分 -->
+                    <div id="recentSearches" class="mt-4 flex flex-wrap gap-2" aria-label="最近搜索记录">
+                        <!-- 这里会动态插入最近的搜索记录 -->
+                    </div>
+                </div>
+            </div>
+            
+            <!-- 豆瓣热门推荐区域: 默认隐藏，现在位于搜索区域下方，调整宽度 -->
+            <div id="doubanArea" class="w-full my-8 hidden">
+                <div class="mx-auto max-w-screen-xl px-2">
+                    <!-- 改进标题和标签区域布局 -->
+                    <div class="mb-4">
+                        <!-- 标题和刷新按钮一行 -->
+                        <div class="flex items-center justify-between mb-3">
+                            <h2 class="text-xl font-bold text-white">豆瓣热门</h2>
+                            <button id="douban-refresh" class="text-sm px-3 py-1 bg-pink-600 hover:bg-pink-700 text-white rounded-lg flex items-center gap-1">
+                                <span>换一批</span>
+                                <svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
+                                </svg>
+                            </button>
+                        </div>
+                        <!-- 分类标签独立成行，添加滚动支持以适应移动设备 -->
+                        <div class="overflow-x-auto pb-2">
+                            <div id="douban-tags" class="flex space-x-2 min-w-max"></div>
+                        </div>
+                    </div>
+                    
+                    <!-- 推荐内容 -->
+                    <div id="douban-results" class="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-6 xl:grid-cols-8 gap-3"></div>
+                </div>
+            </div>
+            
+            <!-- 搜索结果：初始隐藏 -->
+            <div id="resultsArea" class="w-full hidden">
+                <div class="mx-auto max-w-7xl px-2"> <!-- 添加最大宽度限制并居中 -->
+                    <div class="flex justify-end items-center mb-4">
+                        <div class="text-sm text-gray-400">
+                            <span id="searchResultsCount">0</span> 个结果
+                        </div>
+                    </div>
+                    <div id="results" class="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-6 gap-3">
+                        <!-- 结果将在这里动态生成 -->
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 页脚区域 -->
+    <footer class="footer mt-8 py-6 border-t border-[#333] bg-[#0a0a0a]">
+        <div class="container mx-auto px-4">
+            <div class="flex flex-col md:flex-row justify-between items-center">
+                <div class="mb-4 md:mb-0">
+                    <div class="flex items-center justify-center md:justify-start">
+                        <svg class="w-6 h-6 mr-2" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 10l4.553-2.276A1 1 0 0121 8.618v6.764a1 1 0 01-1.447.894L15 14M5 18h8a2 2 0 002-2V8a2 2 0 00-2-2H5a2 2 0 00-2 2v8a2 2 0 002 2z"></path>
+                        </svg>
+                        <span class="gradient-text font-bold">LibreTV</span>
+                    </div>
+                    <p class="text-gray-500 text-sm mt-2 text-center md:text-left">© 2025 LibreTV - 自由观影，畅享精彩</p>
+                </div>
+                
+                <div class="text-center md:text-right">
+                    <p class="text-gray-500 text-sm max-w-md">
+                        免责声明：本站仅为视频搜索工具，不存储、上传或分发任何视频内容。
+                        所有视频均来自第三方API接口。如有侵权，请联系相关内容提供方。
+                    </p>
+                    <div class="mt-2 flex justify-center md:justify-end space-x-4">
+                        <a href="about.html" class="text-gray-400 hover:text-white text-sm transition-colors">关于我们</a>
+                        <a href="privacy.html" class="text-gray-400 hover:text-white text-sm transition-colors">隐私政策</a>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </footer>
+
+    <!-- 详情模态框 -->
+    <div id="modal" class="fixed inset-0 bg-black/95 hidden flex items-center justify-center transition-opacity duration-300">
+        <div class="bg-[#111] p-8 rounded-lg w-11/12 max-w-4xl border border-[#333] max-h-[90vh] flex flex-col">
+            <div class="flex justify-between items-center mb-6 flex-none">
+                <h2 id="modalTitle" class="text-2xl font-bold gradient-text break-words pr-4 max-w-[80%]"></h2>
+                <button onclick="closeModal()" class="text-gray-400 hover:text-white text-2xl transition-colors flex-shrink-0">&times;</button>
+            </div>
+            <div id="modalContent" class="overflow-auto flex-1 min-h-0">
+                <div class="grid grid-cols-2 sm:grid-cols-4 md:grid-cols-6 lg:grid-cols-8 gap-2">
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 密码验证弹窗 -->
+    <div id="passwordModal" class="fixed inset-0 bg-black/95 hidden items-center justify-center z-[65] transition-opacity duration-300">
+        <div class="bg-[#111] p-8 rounded-lg w-11/12 max-w-md border border-[#333] max-h-[90vh] flex flex-col">
+            <div class="flex justify-between items-center mb-6 flex-none">
+                <h2 class="text-2xl font-bold gradient-text">访问验证</h2>
+            </div>
+            <div class="mb-6">
+                <p class="text-gray-300 mb-4">请输入密码继续访问</p>
+                <form id="passwordForm" onsubmit="handlePasswordSubmit(); return false;">
+                    <input type="text" name="username" id="username" autocomplete="username" style="display:none" tabindex="-1" aria-hidden="true">
+                    <input type="password" id="passwordInput" class="w-full bg-[#111] border border-[#333] text-white px-4 py-3 rounded-lg focus:outline-none focus:border-white transition-colors" placeholder="密码..." autocomplete="new-password">
+                    <button id="passwordSubmitBtn" type="submit" class="mt-4 w-full bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded">提交</button>
+                </form>
+                <p id="passwordError" class="text-red-500 mt-2 hidden">密码错误，请重试</p>
+            </div>
+        </div>
+    </div>
+
+    <!-- 版权声明弹窗 -->
+    <div id="disclaimerModal" class="fixed inset-0 bg-black/90 hidden items-center justify-center z-[60]">
+        <div class="bg-[#111] p-8 rounded-lg border border-[#333] w-11/12 max-w-2xl max-h-[90vh] overflow-y-auto">
+            <h2 class="text-2xl font-bold gradient-text mb-6 text-center">使用声明</h2>
+            <div class="text-gray-300 space-y-4">
+                <p>
+                    欢迎使用 LibreTV。在开始使用前，请您了解并同意以下条款：
+                </p>
+                <p>
+                    <strong class="text-blue-400">服务性质：</strong> LibreTV 仅提供视频搜索服务，不直接提供、存储或上传任何视频内容。所有搜索结果均来自第三方公开接口。
+                </p>
+                <p>
+                    <strong class="text-blue-400">用户责任：</strong> 用户在使用本站服务时，须遵守相关法律法规，不得利用搜索结果从事侵权行为，如下载、传播未经授权的作品等。
+                </p>
+                <p>
+                    <strong class="text-blue-400">侵权投诉：</strong> 若您是版权方或相关权利人，发现搜索结果中存在侵犯您合法权益的内容，请通过 <a href="mailto:troll@pissmail.com" class="text-blue-400 hover:underline">troll@pissmail.com</a> 向我们反馈。我们将在收到投诉后尽快核实处理。
+                </p>
+            </div>
+            <div class="mt-6 flex justify-center">
+                <button id="acceptDisclaimerBtn" class="px-6 py-3 bg-gradient-to-r from-indigo-500 via-purple-500 to-pink-500 text-white font-semibold rounded-lg hover:shadow-lg transition-all duration-300">
+                    我已了解并接受
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 错误提示框 -->
+    <div id="toast" class="fixed top-4 left-1/2 -translate-x-1/2 bg-red-500 text-white px-6 py-3 rounded-lg shadow-lg transform transition-all duration-300 opacity-0 -translate-y-full">
+        <p id="toastMessage"></p>
+    </div>
+
+    <!-- 添加 loading 提示框 -->
+    <div id="loading" class="fixed inset-0 bg-black/80 hidden items-center justify-center z-50">
+        <div class="bg-[#111] p-8 rounded-lg border border-[#333] flex items-center space-x-4">
+            <div class="w-8 h-8 border-4 border-white border-t-transparent rounded-full animate-spin"></div>
+            <p class="text-white text-lg">加载中...</p>
+        </div>
+    </div>
+
+    <!-- JSON-LD 结构化数据 -->
+    <script type="application/ld+json">
+    {
+        "@context": "https://schema.org",
+        "@type": "WebSite",
+        "name": "LibreTV",
+        "url": "https://libretv.is-an.org/",
+        "description": "免费在线视频搜索与观看平台",
+        "potentialAction": {
+            "@type": "SearchAction",
+            "target": "https://libretv.is-an.org/?s={search_term_string}",
+            "query-input": "required name=search_term_string"
+        }
+    }
+    </script>
+
+    <!-- 引入纯 JS sha256（HTTP 下依然可用） -->
+    <script src="https://cdn.jsdelivr.net/npm/js-sha256@0.9.0/build/sha256.min.js"></script>
+    <script>
+        // 保存原始 js‑sha256 实现，避免被 password.js 覆盖
+        window._jsSha256 = window.sha256;
+    </script>
+    <script src="js/config.js"></script>
+    <script src="js/ui.js"></script>
+    <script src="js/api.js"></script>
+    <script src="js/douban.js"></script>
+    <script src="js/password.js"></script>
+    <script src="js/app.js"></script>
+
+    <!-- 环境变量注入脚本 -->
+    <script>
+        // 创建全局环境变量对象
+        window.__ENV__ = window.__ENV__ || {};
+        
+        // 注入服务器端环境变量 (将由服务器端替换)
+        // PASSWORD 变量将在这里被服务器端注入
+        window.__ENV__.PASSWORD = "{{PASSWORD}}";
+    </script>
+
+    <!-- 弹窗显示脚本 -->
+    <script>
+        // 在页面加载完成后检查用户是否首次访问
+        document.addEventListener('DOMContentLoaded', function() {
+            // 检查用户是否已经看过声明
+            const hasSeenDisclaimer = localStorage.getItem('hasSeenDisclaimer');
+            
+            if (!hasSeenDisclaimer) {
+                // 显示弹窗
+                const disclaimerModal = document.getElementById('disclaimerModal');
+                disclaimerModal.style.display = 'flex';
+                
+                // 添加接受按钮事件
+                document.getElementById('acceptDisclaimerBtn').addEventListener('click', function() {
+                    // 保存用户已看过声明的状态
+                    localStorage.setItem('hasSeenDisclaimer', 'true');
+                    // 隐藏弹窗
+                    disclaimerModal.style.display = 'none';
+                });
+            }
+        });
+    </script>
+</body>
+</html>

js/api.js

@@ -0,0 +1,613 @@
+// 改进的API请求处理函数
+async function handleApiRequest(url) {
+    const customApi = url.searchParams.get('customApi') || '';
+    const source = url.searchParams.get('source') || 'heimuer';
+    
+    try {
+        if (url.pathname === '/api/search') {
+            const searchQuery = url.searchParams.get('wd');
+            if (!searchQuery) {
+                throw new Error('缺少搜索参数');
+            }
+            
+            // 验证API和source的有效性
+            if (source === 'custom' && !customApi) {
+                throw new Error('使用自定义API时必须提供API地址');
+            }
+            
+            if (!API_SITES[source] && source !== 'custom') {
+                throw new Error('无效的API来源');
+            }
+            
+            const apiUrl = customApi
+                ? `${customApi}${API_CONFIG.search.path}${encodeURIComponent(searchQuery)}`
+                : `${API_SITES[source].api}${API_CONFIG.search.path}${encodeURIComponent(searchQuery)}`;
+            
+            // 添加超时处理
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 10000);
+            
+            try {
+                const response = await fetch(PROXY_URL + encodeURIComponent(apiUrl), {
+                    headers: API_CONFIG.search.headers,
+                    signal: controller.signal
+                });
+                
+                clearTimeout(timeoutId);
+                
+                if (!response.ok) {
+                    throw new Error(`API请求失败: ${response.status}`);
+                }
+                
+                const data = await response.json();
+                
+                // 检查JSON格式的有效性
+                if (!data || !Array.isArray(data.list)) {
+                    throw new Error('API返回的数据格式无效');
+                }
+                
+                // 添加源信息到每个结果
+                data.list.forEach(item => {
+                    item.source_name = source === 'custom' ? '自定义源' : API_SITES[source].name;
+                    item.source_code = source;
+                    // 对于自定义源，添加API URL信息
+                    if (source === 'custom') {
+                        item.api_url = customApi;
+                    }
+                });
+                
+                return JSON.stringify({
+                    code: 200,
+                    list: data.list || [],
+                });
+            } catch (fetchError) {
+                clearTimeout(timeoutId);
+                throw fetchError;
+            }
+        }
+
+        // 详情处理
+        if (url.pathname === '/api/detail') {
+            const id = url.searchParams.get('id');
+            const sourceCode = url.searchParams.get('source') || 'heimuer'; // 获取源代码
+            
+            if (!id) {
+                throw new Error('缺少视频ID参数');
+            }
+            
+            // 验证ID格式 - 只允许数字和有限的特殊字符
+            if (!/^[\w-]+$/.test(id)) {
+                throw new Error('无效的视频ID格式');
+            }
+
+            // 验证API和source的有效性
+            if (sourceCode === 'custom' && !customApi) {
+                throw new Error('使用自定义API时必须提供API地址');
+            }
+            
+            if (!API_SITES[sourceCode] && sourceCode !== 'custom') {
+                throw new Error('无效的API来源');
+            }
+
+            // 对于特殊源，使用特殊处理方式
+            if ((sourceCode === 'ffzy' || sourceCode === 'jisu' || sourceCode === 'huangcang') && API_SITES[sourceCode].detail) {
+                return await handleSpecialSourceDetail(id, sourceCode);
+            }
+            
+            // 如果是自定义API，并且传递了detail参数，尝试特殊处理
+            if (sourceCode === 'custom' && url.searchParams.get('useDetail') === 'true') {
+                return await handleCustomApiSpecialDetail(id, customApi);
+            }
+            
+            const detailUrl = customApi
+                ? `${customApi}${API_CONFIG.detail.path}${id}`
+                : `${API_SITES[sourceCode].api}${API_CONFIG.detail.path}${id}`;
+            
+            // 添加超时处理
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 10000);
+            
+            try {
+                const response = await fetch(PROXY_URL + encodeURIComponent(detailUrl), {
+                    headers: API_CONFIG.detail.headers,
+                    signal: controller.signal
+                });
+                
+                clearTimeout(timeoutId);
+                
+                if (!response.ok) {
+                    throw new Error(`详情请求失败: ${response.status}`);
+                }
+                
+                // 解析JSON
+                const data = await response.json();
+                
+                // 检查返回的数据是否有效
+                if (!data || !data.list || !Array.isArray(data.list) || data.list.length === 0) {
+                    throw new Error('获取到的详情内容无效');
+                }
+                
+                // 获取第一个匹配的视频详情
+                const videoDetail = data.list[0];
+                
+                // 提取播放地址
+                let episodes = [];
+                
+                if (videoDetail.vod_play_url) {
+                    // 分割不同播放源
+                    const playSources = videoDetail.vod_play_url.split('$$$');
+                    
+                    // 提取第一个播放源的集数（通常为主要源）
+                    if (playSources.length > 0) {
+                        const mainSource = playSources[0];
+                        const episodeList = mainSource.split('#');
+                        
+                        // 从每个集数中提取URL
+                        episodes = episodeList.map(ep => {
+                            const parts = ep.split('$');
+                            // 返回URL部分(通常是第二部分，如果有的话)
+                            return parts.length > 1 ? parts[1] : '';
+                        }).filter(url => url && (url.startsWith('http://') || url.startsWith('https://')));
+                    }
+                }
+                
+                // 如果没有找到播放地址，尝试使用正则表达式查找m3u8链接
+                if (episodes.length === 0 && videoDetail.vod_content) {
+                    const matches = videoDetail.vod_content.match(M3U8_PATTERN) || [];
+                    episodes = matches.map(link => link.replace(/^\$/, ''));
+                }
+                
+                return JSON.stringify({
+                    code: 200,
+                    episodes: episodes,
+                    detailUrl: detailUrl,
+                    videoInfo: {
+                        title: videoDetail.vod_name,
+                        cover: videoDetail.vod_pic,
+                        desc: videoDetail.vod_content,
+                        type: videoDetail.type_name,
+                        year: videoDetail.vod_year,
+                        area: videoDetail.vod_area,
+                        director: videoDetail.vod_director,
+                        actor: videoDetail.vod_actor,
+                        remarks: videoDetail.vod_remarks,
+                        // 添加源信息
+                        source_name: sourceCode === 'custom' ? '自定义源' : API_SITES[sourceCode].name,
+                        source_code: sourceCode
+                    }
+                });
+            } catch (fetchError) {
+                clearTimeout(timeoutId);
+                throw fetchError;
+            }
+        }
+
+        throw new Error('未知的API路径');
+    } catch (error) {
+        console.error('API处理错误:', error);
+        return JSON.stringify({
+            code: 400,
+            msg: error.message || '请求处理失败',
+            list: [],
+            episodes: [],
+        });
+    }
+}
+
+// 处理自定义API的特殊详情页
+async function handleCustomApiSpecialDetail(id, customApi) {
+    try {
+        // 构建详情页URL
+        const detailUrl = `${customApi}/index.php/vod/detail/id/${id}.html`;
+        
+        // 添加超时处理
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000);
+        
+        // 获取详情页HTML
+        const response = await fetch(PROXY_URL + encodeURIComponent(detailUrl), {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+            },
+            signal: controller.signal
+        });
+        
+        clearTimeout(timeoutId);
+        
+        if (!response.ok) {
+            throw new Error(`自定义API详情页请求失败: ${response.status}`);
+        }
+        
+        // 获取HTML内容
+        const html = await response.text();
+        
+        // 使用通用模式提取m3u8链接
+        const generalPattern = /\$(https?:\/\/[^"'\s]+?\.m3u8)/g;
+        let matches = html.match(generalPattern) || [];
+        
+        // 处理链接
+        matches = matches.map(link => {
+            link = link.substring(1, link.length);
+            const parenIndex = link.indexOf('(');
+            return parenIndex > 0 ? link.substring(0, parenIndex) : link;
+        });
+        
+        // 提取基本信息
+        const titleMatch = html.match(/<h1[^>]*>([^<]+)<\/h1>/);
+        const titleText = titleMatch ? titleMatch[1].trim() : '';
+        
+        const descMatch = html.match(/<div[^>]*class=["']sketch["'][^>]*>([\s\S]*?)<\/div>/);
+        const descText = descMatch ? descMatch[1].replace(/<[^>]+>/g, ' ').trim() : '';
+        
+        return JSON.stringify({
+            code: 200,
+            episodes: matches,
+            detailUrl: detailUrl,
+            videoInfo: {
+                title: titleText,
+                desc: descText,
+                source_name: '自定义源',
+                source_code: 'custom'
+            }
+        });
+    } catch (error) {
+        console.error(`自定义API详情获取失败:`, error);
+        throw error;
+    }
+}
+
+// 处理极速资源详情的特殊函数
+async function handleJisuDetail(id, sourceCode) {
+    // 直接复用通用的特殊源处理函数，传入相应参数
+    return await handleSpecialSourceDetail(id, sourceCode);
+}
+
+// 处理非凡影视详情的特殊函数
+async function handleFFZYDetail(id, sourceCode) {
+    // 直接复用通用的特殊源处理函数，传入相应参数
+    return await handleSpecialSourceDetail(id, sourceCode);
+}
+
+// 通用特殊源详情处理函数
+async function handleSpecialSourceDetail(id, sourceCode) {
+    try {
+        // 构建详情页URL（使用配置中的detail URL而不是api URL）
+        const detailUrl = `${API_SITES[sourceCode].detail}/index.php/vod/detail/id/${id}.html`;
+        
+        // 添加超时处理
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000);
+        
+        // 获取详情页HTML
+        const response = await fetch(PROXY_URL + encodeURIComponent(detailUrl), {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+            },
+            signal: controller.signal
+        });
+        
+        clearTimeout(timeoutId);
+        
+        if (!response.ok) {
+            throw new Error(`详情页请求失败: ${response.status}`);
+        }
+        
+        // 获取HTML内容
+        const html = await response.text();
+        
+        // 根据不同源类型使用不同的正则表达式
+        let matches = [];
+        
+        if (sourceCode === 'ffzy') {
+            // 非凡影视使用特定的正则表达式
+            const ffzyPattern = /\$(https?:\/\/[^"'\s]+?\/\d{8}\/\d+_[a-f0-9]+\/index\.m3u8)/g;
+            matches = html.match(ffzyPattern) || [];
+        }
+        
+        // 如果没有找到链接或者是其他源类型，尝试一个更通用的模式
+        if (matches.length === 0) {
+            const generalPattern = /\$(https?:\/\/[^"'\s]+?\.m3u8)/g;
+            matches = html.match(generalPattern) || [];
+        }
+        // 去重处理，避免一个播放源多集显示
+        matches = [...new Set(matches)];
+        // 处理链接
+        matches = matches.map(link => {
+            link = link.substring(1, link.length);
+            const parenIndex = link.indexOf('(');
+            return parenIndex > 0 ? link.substring(0, parenIndex) : link;
+        });
+        
+        // 提取可能存在的标题、简介等基本信息
+        const titleMatch = html.match(/<h1[^>]*>([^<]+)<\/h1>/);
+        const titleText = titleMatch ? titleMatch[1].trim() : '';
+        
+        const descMatch = html.match(/<div[^>]*class=["']sketch["'][^>]*>([\s\S]*?)<\/div>/);
+        const descText = descMatch ? descMatch[1].replace(/<[^>]+>/g, ' ').trim() : '';
+        
+        return JSON.stringify({
+            code: 200,
+            episodes: matches,
+            detailUrl: detailUrl,
+            videoInfo: {
+                title: titleText,
+                desc: descText,
+                source_name: API_SITES[sourceCode].name,
+                source_code: sourceCode
+            }
+        });
+    } catch (error) {
+        console.error(`${API_SITES[sourceCode].name}详情获取失败:`, error);
+        throw error;
+    }
+}
+
+// 处理聚合搜索
+async function handleAggregatedSearch(searchQuery) {
+    // 获取可用的API源列表（排除aggregated和custom）
+    const availableSources = Object.keys(API_SITES).filter(key => 
+        key !== 'aggregated' && key !== 'custom'
+    );
+    
+    if (availableSources.length === 0) {
+        throw new Error('没有可用的API源');
+    }
+    
+    // 创建所有API源的搜索请求
+    const searchPromises = availableSources.map(async (source) => {
+        try {
+            const apiUrl = `${API_SITES[source].api}${API_CONFIG.search.path}${encodeURIComponent(searchQuery)}`;
+            
+            // 使用Promise.race添加超时处理
+            const timeoutPromise = new Promise((_, reject) => 
+                setTimeout(() => reject(new Error(`${source}源搜索超时`)), 8000)
+            );
+            
+            const fetchPromise = fetch(PROXY_URL + encodeURIComponent(apiUrl), {
+                headers: API_CONFIG.search.headers
+            });
+            
+            const response = await Promise.race([fetchPromise, timeoutPromise]);
+            
+            if (!response.ok) {
+                throw new Error(`${source}源请求失败: ${response.status}`);
+            }
+            
+            const data = await response.json();
+            
+            if (!data || !Array.isArray(data.list)) {
+                throw new Error(`${source}源返回的数据格式无效`);
+            }
+            
+            // 为搜索结果添加源信息
+            const results = data.list.map(item => ({
+                ...item,
+                source_name: API_SITES[source].name,
+                source_code: source
+            }));
+            
+            return results;
+        } catch (error) {
+            console.warn(`${source}源搜索失败:`, error);
+            return []; // 返回空数组表示该源搜索失败
+        }
+    });
+    
+    try {
+        // 并行执行所有搜索请求
+        const resultsArray = await Promise.all(searchPromises);
+        
+        // 合并所有结果
+        let allResults = [];
+        resultsArray.forEach(results => {
+            if (Array.isArray(results) && results.length > 0) {
+                allResults = allResults.concat(results);
+            }
+        });
+        
+        // 如果没有搜索结果，返回空结果
+        if (allResults.length === 0) {
+            return JSON.stringify({
+                code: 200,
+                list: [],
+                msg: '所有源均无搜索结果'
+            });
+        }
+        
+        // 去重（根据vod_id和source_code组合）
+        const uniqueResults = [];
+        const seen = new Set();
+        
+        allResults.forEach(item => {
+            const key = `${item.source_code}_${item.vod_id}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                uniqueResults.push(item);
+            }
+        });
+        
+        // 按照视频名称和来源排序
+        uniqueResults.sort((a, b) => {
+            // 首先按照视频名称排序
+            const nameCompare = (a.vod_name || '').localeCompare(b.vod_name || '');
+            if (nameCompare !== 0) return nameCompare;
+            
+            // 如果名称相同，则按照来源排序
+            return (a.source_name || '').localeCompare(b.source_name || '');
+        });
+        
+        return JSON.stringify({
+            code: 200,
+            list: uniqueResults,
+        });
+    } catch (error) {
+        console.error('聚合搜索处理错误:', error);
+        return JSON.stringify({
+            code: 400,
+            msg: '聚合搜索处理失败: ' + error.message,
+            list: []
+        });
+    }
+}
+
+// 处理多个自定义API源的聚合搜索
+async function handleMultipleCustomSearch(searchQuery, customApiUrls) {
+    // 解析自定义API列表
+    const apiUrls = customApiUrls.split(CUSTOM_API_CONFIG.separator)
+        .map(url => url.trim())
+        .filter(url => url.length > 0 && /^https?:\/\//.test(url))
+        .slice(0, CUSTOM_API_CONFIG.maxSources);
+    
+    if (apiUrls.length === 0) {
+        throw new Error('没有提供有效的自定义API地址');
+    }
+    
+    // 为每个API创建搜索请求
+    const searchPromises = apiUrls.map(async (apiUrl, index) => {
+        try {
+            const fullUrl = `${apiUrl}${API_CONFIG.search.path}${encodeURIComponent(searchQuery)}`;
+            
+            // 使用Promise.race添加超时处理
+            const timeoutPromise = new Promise((_, reject) => 
+                setTimeout(() => reject(new Error(`自定义API ${index+1} 搜索超时`)), 8000)
+            );
+            
+            const fetchPromise = fetch(PROXY_URL + encodeURIComponent(fullUrl), {
+                headers: API_CONFIG.search.headers
+            });
+            
+            const response = await Promise.race([fetchPromise, timeoutPromise]);
+            
+            if (!response.ok) {
+                throw new Error(`自定义API ${index+1} 请求失败: ${response.status}`);
+            }
+            
+            const data = await response.json();
+            
+            if (!data || !Array.isArray(data.list)) {
+                throw new Error(`自定义API ${index+1} 返回的数据格式无效`);
+            }
+            
+            // 为搜索结果添加源信息
+            const results = data.list.map(item => ({
+                ...item,
+                source_name: `${CUSTOM_API_CONFIG.namePrefix}${index+1}`,
+                source_code: 'custom',
+                api_url: apiUrl // 保存API URL以便详情获取
+            }));
+            
+            return results;
+        } catch (error) {
+            console.warn(`自定义API ${index+1} 搜索失败:`, error);
+            return []; // 返回空数组表示该源搜索失败
+        }
+    });
+    
+    try {
+        // 并行执行所有搜索请求
+        const resultsArray = await Promise.all(searchPromises);
+        
+        // 合并所有结果
+        let allResults = [];
+        resultsArray.forEach(results => {
+            if (Array.isArray(results) && results.length > 0) {
+                allResults = allResults.concat(results);
+            }
+        });
+        
+        // 如果没有搜索结果，返回空结果
+        if (allResults.length === 0) {
+            return JSON.stringify({
+                code: 200,
+                list: [],
+                msg: '所有自定义API源均无搜索结果'
+            });
+        }
+        
+        // 去重（根据vod_id和api_url组合）
+        const uniqueResults = [];
+        const seen = new Set();
+        
+        allResults.forEach(item => {
+            const key = `${item.api_url || ''}_${item.vod_id}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                uniqueResults.push(item);
+            }
+        });
+        
+        return JSON.stringify({
+            code: 200,
+            list: uniqueResults,
+        });
+    } catch (error) {
+        console.error('自定义API聚合搜索处理错误:', error);
+        return JSON.stringify({
+            code: 400,
+            msg: '自定义API聚合搜索处理失败: ' + error.message,
+            list: []
+        });
+    }
+}
+
+// 拦截API请求
+(function() {
+    const originalFetch = window.fetch;
+    
+    window.fetch = async function(input, init) {
+        const requestUrl = typeof input === 'string' ? new URL(input, window.location.origin) : input.url;
+        
+        if (requestUrl.pathname.startsWith('/api/')) {
+            if (window.isPasswordProtected && window.isPasswordVerified) {
+                if (window.isPasswordProtected() && !window.isPasswordVerified()) {
+                    return;
+                }
+            }
+            try {
+                const data = await handleApiRequest(requestUrl);
+                return new Response(data, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Access-Control-Allow-Origin': '*',
+                    },
+                });
+            } catch (error) {
+                return new Response(JSON.stringify({
+                    code: 500,
+                    msg: '服务器内部错误',
+                }), {
+                    status: 500,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+            }
+        }
+        
+        // 非API请求使用原始fetch
+        return originalFetch.apply(this, arguments);
+    };
+})();
+
+async function testSiteAvailability(apiUrl) {
+    try {
+        // 使用更简单的测试查询
+        const response = await fetch('/api/search?wd=test&customApi=' + encodeURIComponent(apiUrl), {
+            // 添加超时
+            signal: AbortSignal.timeout(5000)
+        });
+        
+        // 检查响应状态
+        if (!response.ok) {
+            return false;
+        }
+        
+        const data = await response.json();
+        
+        // 检查API响应的有效性
+        return data && data.code !== 400 && Array.isArray(data.list);
+    } catch (error) {
+        console.error('站点可用性测试失败:', error);
+        return false;
+    }
+}

js/app.js

@@ -0,0 +1,1011 @@
+// 全局变量
+let selectedAPIs = JSON.parse(localStorage.getItem('selectedAPIs') || '["heimuer", "dbzy"]'); // 默认选中黑木耳和豆瓣资源
+let customAPIs = JSON.parse(localStorage.getItem('customAPIs') || '[]'); // 存储自定义API列表
+
+// 添加当前播放的集数索引
+let currentEpisodeIndex = 0;
+// 添加当前视频的所有集数
+let currentEpisodes = [];
+// 添加当前视频的标题
+let currentVideoTitle = '';
+// 全局变量用于倒序状态
+let episodesReversed = false;
+
+// 页面初始化
+document.addEventListener('DOMContentLoaded', function() {
+    // 初始化API复选框
+    initAPICheckboxes();
+    
+    // 初始化自定义API列表
+    renderCustomAPIsList();
+    
+    // 初始化显示选中的API数量
+    updateSelectedApiCount();
+    
+    // 渲染搜索历史
+    renderSearchHistory();
+    
+    // 设置默认API选择（如果是第一次加载）
+    if (!localStorage.getItem('hasInitializedDefaults')) {
+        // 仅选择黑木耳源和豆瓣资源
+        selectedAPIs = ["heimuer", "dbzy"];
+        localStorage.setItem('selectedAPIs', JSON.stringify(selectedAPIs));
+        
+        // 默认选中过滤开关
+        localStorage.setItem('yellowFilterEnabled', 'true');
+        localStorage.setItem(PLAYER_CONFIG.adFilteringStorage, 'true');
+        
+        // 标记已初始化默认值
+        localStorage.setItem('hasInitializedDefaults', 'true');
+    }
+    
+    // 设置黄色内容过滤开关初始状态
+    const yellowFilterToggle = document.getElementById('yellowFilterToggle');
+    if (yellowFilterToggle) {
+        yellowFilterToggle.checked = localStorage.getItem('yellowFilterEnabled') === 'true';
+    }
+    
+    // 设置广告过滤开关初始状态
+    const adFilterToggle = document.getElementById('adFilterToggle');
+    if (adFilterToggle) {
+        adFilterToggle.checked = localStorage.getItem(PLAYER_CONFIG.adFilteringStorage) !== 'false'; // 默认为true
+    }
+    
+    // 设置事件监听器
+    setupEventListeners();
+    
+    // 初始检查成人API选中状态
+    setTimeout(checkAdultAPIsSelected, 100);
+});
+
+// 初始化API复选框
+function initAPICheckboxes() {
+    const container = document.getElementById('apiCheckboxes');
+    container.innerHTML = '';
+
+    // 添加普通API组标题
+    const normalTitle = document.createElement('div');
+    normalTitle.className = 'api-group-title';
+    normalTitle.textContent = '普通资源';
+    container.appendChild(normalTitle);
+    
+    // 创建普通API源的复选框
+    Object.keys(API_SITES).forEach(apiKey => {
+        const api = API_SITES[apiKey];
+        if (api.adult) return; // 跳过成人内容API，稍后添加
+        
+        const checked = selectedAPIs.includes(apiKey);
+        
+        const checkbox = document.createElement('div');
+        checkbox.className = 'flex items-center';
+        checkbox.innerHTML = `
+            <input type="checkbox" id="api_${apiKey}" 
+                   class="form-checkbox h-3 w-3 text-blue-600 bg-[#222] border border-[#333]" 
+                   ${checked ? 'checked' : ''} 
+                   data-api="${apiKey}">
+            <label for="api_${apiKey}" class="ml-1 text-xs text-gray-400 truncate">${api.name}</label>
+        `;
+        container.appendChild(checkbox);
+        
+        // 添加事件监听器
+        checkbox.querySelector('input').addEventListener('change', function() {
+            updateSelectedAPIs();
+            checkAdultAPIsSelected();
+        });
+    });
+    
+    // 仅在隐藏设置为false时添加成人API组
+    if (!HIDE_BUILTIN_ADULT_APIS) {
+        // 添加成人API组标题
+        const adultTitle = document.createElement('div');
+        adultTitle.className = 'api-group-title adult';
+        adultTitle.innerHTML = `黄色资源采集站 <span class="adult-warning">
+            <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+            </svg>
+        </span>`;
+        container.appendChild(adultTitle);
+        
+        // 创建成人API源的复选框
+        Object.keys(API_SITES).forEach(apiKey => {
+            const api = API_SITES[apiKey];
+            if (!api.adult) return; // 仅添加成人内容API
+            
+            const checked = selectedAPIs.includes(apiKey);
+            
+            const checkbox = document.createElement('div');
+            checkbox.className = 'flex items-center';
+            checkbox.innerHTML = `
+                <input type="checkbox" id="api_${apiKey}" 
+                       class="form-checkbox h-3 w-3 text-blue-600 bg-[#222] border border-[#333] api-adult" 
+                       ${checked ? 'checked' : ''} 
+                       data-api="${apiKey}">
+                <label for="api_${apiKey}" class="ml-1 text-xs text-pink-400 truncate">${api.name}</label>
+            `;
+            container.appendChild(checkbox);
+            
+            // 添加事件监听器
+            checkbox.querySelector('input').addEventListener('change', function() {
+                updateSelectedAPIs();
+                checkAdultAPIsSelected();
+            });
+        });
+    }
+    
+    // 初始检查成人内容状态
+    checkAdultAPIsSelected();
+}
+
+// 检查是否有成人API被选中
+function checkAdultAPIsSelected() {
+    // 查找所有内置成人API复选框
+    const adultBuiltinCheckboxes = document.querySelectorAll('#apiCheckboxes .api-adult:checked');
+    
+    // 查找所有自定义成人API复选框
+    const customApiCheckboxes = document.querySelectorAll('#customApisList .api-adult:checked');
+    
+    const hasAdultSelected = adultBuiltinCheckboxes.length > 0 || customApiCheckboxes.length > 0;
+    
+    const yellowFilterToggle = document.getElementById('yellowFilterToggle');
+    const yellowFilterContainer = yellowFilterToggle.closest('div').parentNode;
+    const filterDescription = yellowFilterContainer.querySelector('p.filter-description');
+    
+    // 如果选择了成人API，禁用黄色内容过滤器
+    if (hasAdultSelected) {
+        yellowFilterToggle.checked = false;
+        yellowFilterToggle.disabled = true;
+        localStorage.setItem('yellowFilterEnabled', 'false');
+        
+        // 添加禁用样式
+        yellowFilterContainer.classList.add('filter-disabled');
+        
+        // 修改描述文字
+        if (filterDescription) {
+            filterDescription.innerHTML = '<strong class="text-pink-300">选中黄色资源站时无法启用此过滤</strong>';
+        }
+        
+        // 移除提示信息（如果存在）
+        const existingTooltip = yellowFilterContainer.querySelector('.filter-tooltip');
+        if (existingTooltip) {
+            existingTooltip.remove();
+        }
+    } else {
+        // 启用黄色内容过滤器
+        yellowFilterToggle.disabled = false;
+        yellowFilterContainer.classList.remove('filter-disabled');
+        
+        // 恢复原来的描述文字
+        if (filterDescription) {
+            filterDescription.innerHTML = '过滤"伦理片"等黄色内容';
+        }
+        
+        // 移除提示信息
+        const existingTooltip = yellowFilterContainer.querySelector('.filter-tooltip');
+        if (existingTooltip) {
+            existingTooltip.remove();
+        }
+    }
+}
+
+// 渲染自定义API列表
+function renderCustomAPIsList() {
+    const container = document.getElementById('customApisList');
+    if (!container) return;
+    
+    if (customAPIs.length === 0) {
+        container.innerHTML = '<p class="text-xs text-gray-500 text-center my-2">未添加自定义API</p>';
+        return;
+    }
+    
+    container.innerHTML = '';
+    customAPIs.forEach((api, index) => {
+        const apiItem = document.createElement('div');
+        apiItem.className = 'flex items-center justify-between p-1 mb-1 bg-[#222] rounded';
+        
+        // 根据是否是成人内容设置不同的样式
+        const textColorClass = api.isAdult ? 'text-pink-400' : 'text-white';
+        
+        // 将(18+)标记移到最前面
+        const adultTag = api.isAdult ? '<span class="text-xs text-pink-400 mr-1">(18+)</span>' : '';
+        
+        apiItem.innerHTML = `
+            <div class="flex items-center flex-1 min-w-0">
+                <input type="checkbox" id="custom_api_${index}" 
+                       class="form-checkbox h-3 w-3 text-blue-600 mr-1 ${api.isAdult ? 'api-adult' : ''}" 
+                       ${selectedAPIs.includes('custom_' + index) ? 'checked' : ''} 
+                       data-custom-index="${index}">
+                <div class="flex-1 min-w-0">
+                    <div class="text-xs font-medium ${textColorClass} truncate">
+                        ${adultTag}${api.name}
+                    </div>
+                    <div class="text-xs text-gray-500 truncate">${api.url}</div>
+                </div>
+            </div>
+            <div class="flex items-center">
+                <button class="text-blue-500 hover:text-blue-700 text-xs px-1" onclick="editCustomApi(${index})">✎</button>
+                <button class="text-red-500 hover:text-red-700 text-xs px-1" onclick="removeCustomApi(${index})">✕</button>
+            </div>
+        `;
+        container.appendChild(apiItem);
+        
+        // 添加事件监听器
+        apiItem.querySelector('input').addEventListener('change', function() {
+            updateSelectedAPIs();
+            checkAdultAPIsSelected();
+        });
+    });
+}
+
+// 编辑自定义API
+function editCustomApi(index) {
+    if (index < 0 || index >= customAPIs.length) return;
+    
+    const api = customAPIs[index];
+    
+    // 填充表单数据
+    const nameInput = document.getElementById('customApiName');
+    const urlInput = document.getElementById('customApiUrl');
+    const isAdultInput = document.getElementById('customApiIsAdult');
+    
+    nameInput.value = api.name;
+    urlInput.value = api.url;
+    if (isAdultInput) isAdultInput.checked = api.isAdult || false;
+    
+    // 显示表单
+    const form = document.getElementById('addCustomApiForm');
+    if (form) {
+        form.classList.remove('hidden');
+        
+        // 替换表单按钮操作
+        const buttonContainer = form.querySelector('div:last-child');
+        buttonContainer.innerHTML = `
+            <button onclick="updateCustomApi(${index})" class="bg-blue-600 hover:bg-blue-700 text-white px-3 py-1 rounded text-xs">更新</button>
+            <button onclick="cancelEditCustomApi()" class="bg-[#444] hover:bg-[#555] text-white px-3 py-1 rounded text-xs">取消</button>
+        `;
+    }
+}
+
+// 更新自定义API
+function updateCustomApi(index) {
+    if (index < 0 || index >= customAPIs.length) return;
+    
+    const nameInput = document.getElementById('customApiName');
+    const urlInput = document.getElementById('customApiUrl');
+    const isAdultInput = document.getElementById('customApiIsAdult');
+    
+    const name = nameInput.value.trim();
+    let url = urlInput.value.trim();
+    const isAdult = isAdultInput ? isAdultInput.checked : false;
+    
+    if (!name || !url) {
+        showToast('请输入API名称和链接', 'warning');
+        return;
+    }
+    
+    // 确保URL格式正确
+    if (!/^https?:\/\/.+/.test(url)) {
+        showToast('API链接格式不正确，需以http://或https://开头', 'warning');
+        return;
+    }
+    
+    // 移除URL末尾的斜杠
+    if (url.endsWith('/')) {
+        url = url.slice(0, -1);
+    }
+    
+    // 更新API信息
+    customAPIs[index] = { name, url, isAdult };
+    localStorage.setItem('customAPIs', JSON.stringify(customAPIs));
+    
+    // 重新渲染自定义API列表
+    renderCustomAPIsList();
+    
+    // 重新检查成人API选中状态
+    checkAdultAPIsSelected();
+    
+    // 恢复添加按钮
+    restoreAddCustomApiButtons();
+    
+    // 清空表单并隐藏
+    nameInput.value = '';
+    urlInput.value = '';
+    if (isAdultInput) isAdultInput.checked = false;
+    document.getElementById('addCustomApiForm').classList.add('hidden');
+    
+    showToast('已更新自定义API: ' + name, 'success');
+}
+
+// 取消编辑自定义API
+function cancelEditCustomApi() {
+    // 清空表单
+    document.getElementById('customApiName').value = '';
+    document.getElementById('customApiUrl').value = '';
+    const isAdultInput = document.getElementById('customApiIsAdult');
+    if (isAdultInput) isAdultInput.checked = false;
+    
+    // 隐藏表单
+    document.getElementById('addCustomApiForm').classList.add('hidden');
+    
+    // 恢复添加按钮
+    restoreAddCustomApiButtons();
+}
+
+// 恢复自定义API添加按钮
+function restoreAddCustomApiButtons() {
+    const form = document.getElementById('addCustomApiForm');
+    const buttonContainer = form.querySelector('div:last-child');
+    buttonContainer.innerHTML = `
+        <button onclick="addCustomApi()" class="bg-blue-600 hover:bg-blue-700 text-white px-3 py-1 rounded text-xs">添加</button>
+        <button onclick="cancelAddCustomApi()" class="bg-[#444] hover:bg-[#555] text-white px-3 py-1 rounded text-xs">取消</button>
+    `;
+}
+
+// 更新选中的API列表
+function updateSelectedAPIs() {
+    // 获取所有内置API复选框
+    const builtInApiCheckboxes = document.querySelectorAll('#apiCheckboxes input:checked');
+    
+    // 获取选中的内置API
+    const builtInApis = Array.from(builtInApiCheckboxes).map(input => input.dataset.api);
+    
+    // 获取选中的自定义API
+    const customApiCheckboxes = document.querySelectorAll('#customApisList input:checked');
+    const customApiIndices = Array.from(customApiCheckboxes).map(input => 'custom_' + input.dataset.customIndex);
+    
+    // 合并内置和自定义API
+    selectedAPIs = [...builtInApis, ...customApiIndices];
+    
+    // 保存到localStorage
+    localStorage.setItem('selectedAPIs', JSON.stringify(selectedAPIs));
+    
+    // 更新显示选中的API数量
+    updateSelectedApiCount();
+}
+
+// 更新选中的API数量显示
+function updateSelectedApiCount() {
+    const countEl = document.getElementById('selectedApiCount');
+    if (countEl) {
+        countEl.textContent = selectedAPIs.length;
+    }
+}
+
+// 全选或取消全选API
+function selectAllAPIs(selectAll = true, excludeAdult = false) {
+    const checkboxes = document.querySelectorAll('#apiCheckboxes input[type="checkbox"]');
+    
+    checkboxes.forEach(checkbox => {
+        if (excludeAdult && checkbox.classList.contains('api-adult')) {
+            checkbox.checked = false;
+        } else {
+            checkbox.checked = selectAll;
+        }
+    });
+    
+    updateSelectedAPIs();
+    checkAdultAPIsSelected();
+}
+
+// 显示添加自定义API表单
+function showAddCustomApiForm() {
+    const form = document.getElementById('addCustomApiForm');
+    if (form) {
+        form.classList.remove('hidden');
+    }
+}
+
+// 取消添加自定义API - 修改函数来重用恢复按钮逻辑
+function cancelAddCustomApi() {
+    const form = document.getElementById('addCustomApiForm');
+    if (form) {
+        form.classList.add('hidden');
+        document.getElementById('customApiName').value = '';
+        document.getElementById('customApiUrl').value = '';
+        const isAdultInput = document.getElementById('customApiIsAdult');
+        if (isAdultInput) isAdultInput.checked = false;
+        
+        // 确保按钮是添加按钮
+        restoreAddCustomApiButtons();
+    }
+}
+
+// 添加自定义API
+function addCustomApi() {
+    const nameInput = document.getElementById('customApiName');
+    const urlInput = document.getElementById('customApiUrl');
+    const isAdultInput = document.getElementById('customApiIsAdult');
+    
+    const name = nameInput.value.trim();
+    let url = urlInput.value.trim();
+    const isAdult = isAdultInput ? isAdultInput.checked : false;
+    
+    if (!name || !url) {
+        showToast('请输入API名称和链接', 'warning');
+        return;
+    }
+    
+    // 确保URL格式正确
+    if (!/^https?:\/\/.+/.test(url)) {
+        showToast('API链接格式不正确，需以http://或https://开头', 'warning');
+        return;
+    }
+    
+    // 移除URL末尾的斜杠
+    if (url.endsWith('/')) {
+        url = url.slice(0, -1);
+    }
+    
+    // 添加到自定义API列表 - 增加isAdult属性
+    customAPIs.push({ name, url, isAdult });
+    localStorage.setItem('customAPIs', JSON.stringify(customAPIs));
+    
+    // 默认选中新添加的API
+    const newApiIndex = customAPIs.length - 1;
+    selectedAPIs.push('custom_' + newApiIndex);
+    localStorage.setItem('selectedAPIs', JSON.stringify(selectedAPIs));
+    
+    // 重新渲染自定义API列表
+    renderCustomAPIsList();
+    
+    // 更新选中的API数量
+    updateSelectedApiCount();
+    
+    // 重新检查成人API选中状态
+    checkAdultAPIsSelected();
+    
+    // 清空表单并隐藏
+    nameInput.value = '';
+    urlInput.value = '';
+    if (isAdultInput) isAdultInput.checked = false;
+    document.getElementById('addCustomApiForm').classList.add('hidden');
+    
+    showToast('已添加自定义API: ' + name, 'success');
+}
+
+// 移除自定义API
+function removeCustomApi(index) {
+    if (index < 0 || index >= customAPIs.length) return;
+    
+    const apiName = customAPIs[index].name;
+    
+    // 从列表中移除API
+    customAPIs.splice(index, 1);
+    localStorage.setItem('customAPIs', JSON.stringify(customAPIs));
+    
+    // 从选中列表中移除此API
+    const customApiId = 'custom_' + index;
+    selectedAPIs = selectedAPIs.filter(id => id !== customApiId);
+    
+    // 更新大于此索引的自定义API索引
+    selectedAPIs = selectedAPIs.map(id => {
+        if (id.startsWith('custom_')) {
+            const currentIndex = parseInt(id.replace('custom_', ''));
+            if (currentIndex > index) {
+                return 'custom_' + (currentIndex - 1);
+            }
+        }
+        return id;
+    });
+    
+    localStorage.setItem('selectedAPIs', JSON.stringify(selectedAPIs));
+    
+    // 重新渲染自定义API列表
+    renderCustomAPIsList();
+    
+    // 更新选中的API数量
+    updateSelectedApiCount();
+    
+    // 重新检查成人API选中状态
+    checkAdultAPIsSelected();
+    
+    showToast('已移除自定义API: ' + apiName, 'info');
+}
+
+// 设置事件监听器
+function setupEventListeners() {
+    // 回车搜索
+    document.getElementById('searchInput').addEventListener('keypress', function(e) {
+        if (e.key === 'Enter') {
+            search();
+        }
+    });
+
+    // 点击外部关闭设置面板
+    document.addEventListener('click', function(e) {
+        const panel = document.getElementById('settingsPanel');
+        const settingsButton = document.querySelector('button[onclick="toggleSettings(event)"]');
+        
+        if (!panel.contains(e.target) && !settingsButton.contains(e.target) && panel.classList.contains('show')) {
+            panel.classList.remove('show');
+        }
+    });
+    
+    // 黄色内容过滤开关事件绑定
+    const yellowFilterToggle = document.getElementById('yellowFilterToggle');
+    if (yellowFilterToggle) {
+        yellowFilterToggle.addEventListener('change', function(e) {
+            localStorage.setItem('yellowFilterEnabled', e.target.checked);
+        });
+    }
+    
+    // 广告过滤开关事件绑定
+    const adFilterToggle = document.getElementById('adFilterToggle');
+    if (adFilterToggle) {
+        adFilterToggle.addEventListener('change', function(e) {
+            localStorage.setItem(PLAYER_CONFIG.adFilteringStorage, e.target.checked);
+        });
+    }
+}
+
+// 重置搜索区域
+function resetSearchArea() {
+    // 清理搜索结果
+    document.getElementById('results').innerHTML = '';
+    document.getElementById('searchInput').value = '';
+    
+    // 恢复搜索区域��样式
+    document.getElementById('searchArea').classList.add('flex-1');
+    document.getElementById('searchArea').classList.remove('mb-8');
+    document.getElementById('resultsArea').classList.add('hidden');
+    
+    // 确保页脚正确显示，移除相对定位
+    const footer = document.querySelector('.footer');
+    if (footer) {
+        footer.style.position = '';
+    }
+    
+    // 如果有豆瓣功能，检查是否需要显示豆瓣推荐区域
+    if (typeof updateDoubanVisibility === 'function') {
+        updateDoubanVisibility();
+    }
+}
+
+// 获取自定义API信息
+function getCustomApiInfo(customApiIndex) {
+    const index = parseInt(customApiIndex);
+    if (isNaN(index) || index < 0 || index >= customAPIs.length) {
+        return null;
+    }
+    return customAPIs[index];
+}
+
+// 搜索功能 - 修改为支持多选API
+async function search() {
+    // 密码保护校验
+    if (window.isPasswordProtected && window.isPasswordVerified) {
+        if (window.isPasswordProtected() && !window.isPasswordVerified()) {
+            showPasswordModal && showPasswordModal();
+            return;
+        }
+    }
+    const query = document.getElementById('searchInput').value.trim();
+    
+    if (!query) {
+        showToast('请输入搜索内容', 'info');
+        return;
+    }
+    
+    if (selectedAPIs.length === 0) {
+        showToast('请至少选择一个API源', 'warning');
+        return;
+    }
+    
+    showLoading();
+    
+    try {
+        // 保存搜索历史
+        saveSearchHistory(query);
+        
+        // 从所有选中的API源搜索
+        let allResults = [];
+        const searchPromises = selectedAPIs.map(async (apiId) => {
+            try {
+                let apiUrl, apiName;
+                
+                // 处理自定义API
+                if (apiId.startsWith('custom_')) {
+                    const customIndex = apiId.replace('custom_', '');
+                    const customApi = getCustomApiInfo(customIndex);
+                    if (!customApi) return [];
+                    
+                    apiUrl = customApi.url + API_CONFIG.search.path + encodeURIComponent(query);
+                    apiName = customApi.name;
+                } else {
+                    // 内置API
+                    if (!API_SITES[apiId]) return [];
+                    apiUrl = API_SITES[apiId].api + API_CONFIG.search.path + encodeURIComponent(query);
+                    apiName = API_SITES[apiId].name;
+                }
+                
+                // 添加超时处理
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 8000);
+                
+                const response = await fetch(PROXY_URL + encodeURIComponent(apiUrl), {
+                    headers: API_CONFIG.search.headers,
+                    signal: controller.signal
+                });
+                
+                clearTimeout(timeoutId);
+                
+                if (!response.ok) {
+                    return [];
+                }
+                
+                const data = await response.json();
+                
+                if (!data || !data.list || !Array.isArray(data.list) || data.list.length === 0) {
+                    return [];
+                }
+                
+                // 添加源信息到每个结果
+                const results = data.list.map(item => ({
+                    ...item,
+                    source_name: apiName,
+                    source_code: apiId,
+                    api_url: apiId.startsWith('custom_') ? getCustomApiInfo(apiId.replace('custom_', ''))?.url : undefined
+                }));
+                
+                return results;
+            } catch (error) {
+                console.warn(`API ${apiId} 搜索失败:`, error);
+                return [];
+            }
+        });
+        
+        // 等待所有搜索请求完成
+        const resultsArray = await Promise.all(searchPromises);
+        
+        // 合并所有结果
+        resultsArray.forEach(results => {
+            if (Array.isArray(results) && results.length > 0) {
+                allResults = allResults.concat(results);
+            }
+        });
+        
+        // 更新搜索结果计数
+        const searchResultsCount = document.getElementById('searchResultsCount');
+        if (searchResultsCount) {
+            searchResultsCount.textContent = allResults.length;
+        }
+        
+        // 显示结果区域，调整搜索区域
+        document.getElementById('searchArea').classList.remove('flex-1');
+        document.getElementById('searchArea').classList.add('mb-8');
+        document.getElementById('resultsArea').classList.remove('hidden');
+        
+        // 隐藏豆瓣推荐区域（如果存在）
+        const doubanArea = document.getElementById('doubanArea');
+        if (doubanArea) {
+            doubanArea.classList.add('hidden');
+        }
+        
+        const resultsDiv = document.getElementById('results');
+        
+        // 如果没有结果
+        if (!allResults || allResults.length === 0) {
+            resultsDiv.innerHTML = `
+                <div class="col-span-full text-center py-16">
+                    <svg class="mx-auto h-12 w-12 text-gray-500" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" 
+                              d="M9.172 16.172a4 4 0 015.656 0M9 10h.01M15 10h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+                    </svg>
+                    <h3 class="mt-2 text-lg font-medium text-gray-400">没有找到匹配的结果</h3>
+                    <p class="mt-1 text-sm text-gray-500">请尝试其他关键词或更换数据源</p>
+                </div>
+            `;
+            hideLoading();
+            return;
+        }
+
+        // 处理搜索结果过滤：如果启用了黄色内容过滤，则过滤掉分类含有敏感内容的项目
+        const yellowFilterEnabled = localStorage.getItem('yellowFilterEnabled') === 'true';
+        if (yellowFilterEnabled) {
+            const banned = ['伦理片','门事件','萝莉少女','制服诱惑','国产传媒','cosplay','黑丝诱惑','无码','日本无码','有码','日本有码','SWAG','网红主播', '色情片','同性片','福利视频','福利片'];
+            allResults = allResults.filter(item => {
+                const typeName = item.type_name || '';
+                return !banned.some(keyword => typeName.includes(keyword));
+            });
+        }
+
+        // 添加XSS保护，使用textContent和属性转义
+        resultsDiv.innerHTML = allResults.map(item => {
+            const safeId = item.vod_id ? item.vod_id.toString().replace(/[^\w-]/g, '') : '';
+            const safeName = (item.vod_name || '').toString()
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;');
+            const sourceInfo = item.source_name ? 
+                `<span class="bg-[#222] text-xs px-1.5 py-0.5 rounded-full">${item.source_name}</span>` : '';
+            const sourceCode = item.source_code || '';
+            
+            // 添加API URL属性，用于详情获取
+            const apiUrlAttr = item.api_url ? 
+                `data-api-url="${item.api_url.replace(/"/g, '&quot;')}"` : '';
+            
+            // 更紧凑的卡片布局
+            const hasCover = item.vod_pic && item.vod_pic.startsWith('http');
+            
+            return `
+                <div class="card-hover bg-[#111] rounded-lg overflow-hidden cursor-pointer transition-all hover:scale-[1.02] h-full shadow-sm hover:shadow-md" 
+                     onclick="showDetails('${safeId}','${safeName}','${sourceCode}')" ${apiUrlAttr}>
+                    <div class="flex flex-col h-full">
+                        ${hasCover ? `
+                        <div class="relative overflow-hidden" style="height: 160px;">
+                            <img src="${item.vod_pic}" alt="${safeName}" 
+                                 class="w-full h-full object-cover transition-transform hover:scale-110" 
+                                 onerror="this.onerror=null; this.src='https://via.placeholder.com/300x450?text=无封面'; this.classList.add('object-contain');" 
+                                 loading="lazy">
+                            <div class="absolute inset-0 bg-gradient-to-t from-[#111] to-transparent opacity-60"></div>
+                        </div>` : ''}
+                        
+                        <div class="p-2 flex flex-col flex-grow">
+                            <div class="flex-grow">
+                                <h3 class="text-sm font-semibold mb-1 break-words line-clamp-2 text-center" title="${safeName}">${safeName}</h3>
+                                
+                                <div class="flex flex-wrap justify-center gap-1 mb-1">
+                                    ${(item.type_name || '').toString().replace(/</g, '&lt;') ? 
+                                      `<span class="text-xs py-0 px-1 rounded bg-opacity-20 bg-blue-500 text-blue-300">
+                                          ${(item.type_name || '').toString().replace(/</g, '&lt;')}
+                                      </span>` : ''}
+                                    ${(item.vod_year || '') ? 
+                                      `<span class="text-xs py-0 px-1 rounded bg-opacity-20 bg-purple-500 text-purple-300">
+                                          ${item.vod_year}
+                                      </span>` : ''}
+                                </div>
+                                <p class="text-gray-400 text-xs line-clamp-1 overflow-hidden text-center">
+                                    ${(item.vod_remarks || '暂无介绍').toString().replace(/</g, '&lt;')}
+                                </p>
+                            </div>
+                            
+                            <div class="flex justify-between items-center mt-1 pt-1 border-t border-gray-800 text-xs">
+                                ${sourceInfo ? `<div>${sourceInfo}</div>` : '<div></div>'}
+                                <div>
+                                    <span class="text-xs text-gray-500 flex items-center">
+                                        <svg xmlns="http://www.w3.org/2000/svg" class="h-3 w-3 mr-0.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14.752 11.168l-3.197-2.132A1 1 0 0010 9.87v4.263a1 1 0 001.555.832l3.197-2.132a1 1 0 000-1.664z" />
+                                        </svg>
+                                        播放
+                                    </span>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            `;
+        }).join('');
+    } catch (error) {
+        console.error('搜索错误:', error);
+        if (error.name === 'AbortError') {
+            showToast('搜索请求超时，请检查网络连接', 'error');
+        } else {
+            showToast('搜索请求失败，请稍后重试', 'error');
+        }
+    } finally {
+        hideLoading();
+    }
+}
+
+// 显示详情 - 修改为支持自定义API
+async function showDetails(id, vod_name, sourceCode) {
+    // 密码保护校验
+    if (window.isPasswordProtected && window.isPasswordVerified) {
+        if (window.isPasswordProtected() && !window.isPasswordVerified()) {
+            showPasswordModal && showPasswordModal();
+            return;
+        }
+    }
+    if (!id) {
+        showToast('视频ID无效', 'error');
+        return;
+    }
+    
+    showLoading();
+    try {
+        // 构建API参数
+        let apiParams = '';
+        
+        // 处理自定义API源
+        if (sourceCode.startsWith('custom_')) {
+            const customIndex = sourceCode.replace('custom_', '');
+            const customApi = getCustomApiInfo(customIndex);
+            if (!customApi) {
+                showToast('自定义API配置无效', 'error');
+                hideLoading();
+                return;
+            }
+            
+            apiParams = '&customApi=' + encodeURIComponent(customApi.url) + '&source=custom';
+        } else {
+            // 内置API
+            apiParams = '&source=' + sourceCode;
+        }
+        
+        const response = await fetch('/api/detail?id=' + encodeURIComponent(id) + apiParams);
+        
+        const data = await response.json();
+        
+        const modal = document.getElementById('modal');
+        const modalTitle = document.getElementById('modalTitle');
+        const modalContent = document.getElementById('modalContent');
+        
+        // 显示来源信息
+        const sourceName = data.videoInfo && data.videoInfo.source_name ? 
+            ` <span class="text-sm font-normal text-gray-400">(${data.videoInfo.source_name})</span>` : '';
+        
+        // 不对标题进行截断处理，允许完整显示
+        modalTitle.innerHTML = `<span class="break-words">${vod_name || '未知视频'}</span>${sourceName}`;
+        currentVideoTitle = vod_name || '未知视频';
+        
+        if (data.episodes && data.episodes.length > 0) {
+            // 安全处理集数URL
+            const safeEpisodes = data.episodes.map(url => {
+                try {
+                    // 确保URL是有效的并且是http或https开头
+                    return url && (url.startsWith('http://') || url.startsWith('https://'))
+                        ? url.replace(/"/g, '&quot;')
+                        : '';
+                } catch (e) {
+                    return '';
+                }
+            }).filter(url => url); // 过滤掉空URL
+            
+            // 保存当前视频的所有集数
+            currentEpisodes = safeEpisodes;
+            episodesReversed = false; // 默认正序
+            modalContent.innerHTML = `
+                <div class="flex justify-end mb-2">
+                    <button onclick="toggleEpisodeOrder()" class="px-4 py-2 bg-gradient-to-r from-indigo-500 via-purple-500 to-pink-500 text-white font-semibold rounded-full shadow-lg hover:shadow-xl transition-all duration-300 transform hover:-translate-y-1 flex items-center justify-center space-x-2">
+                        <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5" viewBox="0 0 20 20" fill="currentColor">
+                            <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm1-11a1 1 0 10-2 0v3.586L7.707 9.293a1 1 0 00-1.414 1.414l3 3a1 1 0 001.414 0l3-3a1 1 0 00-1.414-1.414L11 10.586V7z" clip-rule="evenodd" />
+                        </svg>
+                        <span>倒序排列</span>
+                    </button>
+                </div>
+                <div id="episodesGrid" class="grid grid-cols-2 sm:grid-cols-4 md:grid-cols-6 lg:grid-cols-8 gap-2">
+                    ${renderEpisodes(vod_name)}
+                </div>
+            `;
+        } else {
+            modalContent.innerHTML = '<p class="text-center text-gray-400 py-8">没有找到可播放的视频</p>';
+        }
+        
+        modal.classList.remove('hidden');
+    } catch (error) {
+        console.error('获取详情错误:', error);
+        showToast('获取详情失败，请稍后重试', 'error');
+    } finally {
+        hideLoading();
+    }
+}
+
+// 更新播放视频函数，修改为在新标签页中打开播放页面，并保存到历史记录
+function playVideo(url, vod_name, episodeIndex = 0) {
+    // 密码保护校验
+    if (window.isPasswordProtected && window.isPasswordVerified) {
+        if (window.isPasswordProtected() && !window.isPasswordVerified()) {
+            showPasswordModal && showPasswordModal();
+            return;
+        }
+    }
+    if (!url) {
+        showToast('无效的视频链接', 'error');
+        return;
+    }
+    
+    // 获取当前视频来源名称（从模态框标题中提取）
+    let sourceName = '';
+    const modalTitle = document.getElementById('modalTitle');
+    if (modalTitle) {
+        const sourceSpan = modalTitle.querySelector('span.text-gray-400');
+        if (sourceSpan) {
+            // 提取括号内的来源名称, 例如从 "(黑木耳)" 提取 "黑木耳"
+            const sourceText = sourceSpan.textContent;
+            const match = sourceText.match(/\(([^)]+)\)/);
+            if (match && match[1]) {
+                sourceName = match[1].trim();
+            }
+        }
+    }
+    
+    // 保存当前状态到localStorage，让播放页面可以获取
+    const currentVideoTitle = vod_name;
+    localStorage.setItem('currentVideoTitle', currentVideoTitle);
+    localStorage.setItem('currentEpisodeIndex', episodeIndex);
+    localStorage.setItem('currentEpisodes', JSON.stringify(currentEpisodes));
+    localStorage.setItem('episodesReversed', episodesReversed);
+    
+    // 构建视频信息对象，使用标题作为唯一标识
+    const videoTitle = vod_name || currentVideoTitle;
+    const videoInfo = {
+        title: videoTitle,
+        url: url,
+        episodeIndex: episodeIndex,
+        sourceName: sourceName,
+        timestamp: Date.now(),
+        // 重要：将完整的剧集信息也添加到历史记录中
+        episodes: currentEpisodes && currentEpisodes.length > 0 ? [...currentEpisodes] : []
+    };
+    
+    // 保存到观看历史，添加sourceName
+    if (typeof addToViewingHistory === 'function') {
+        addToViewingHistory(videoInfo);
+    }
+    
+    // 构建播放页面URL，传递必要参数
+    const playerUrl = `player.html?url=${encodeURIComponent(url)}&title=${encodeURIComponent(videoTitle)}&index=${episodeIndex}&source=${encodeURIComponent(sourceName)}`;
+    
+    // 在新标签页中打开播放页面
+    window.open(playerUrl, '_blank');
+}
+
+// 播放上一集
+function playPreviousEpisode() {
+    if (currentEpisodeIndex > 0) {
+        const prevIndex = currentEpisodeIndex - 1;
+        const prevUrl = currentEpisodes[prevIndex];
+        playVideo(prevUrl, currentVideoTitle, prevIndex);
+    }
+}
+
+// 播放下一集
+function playNextEpisode() {
+    if (currentEpisodeIndex < currentEpisodes.length - 1) {
+        const nextIndex = currentEpisodeIndex + 1;
+        const nextUrl = currentEpisodes[nextIndex];
+        playVideo(nextUrl, currentVideoTitle, nextIndex);
+    }
+}
+
+// 处理播放器加载错误
+function handlePlayerError() {
+    hideLoading();
+    showToast('视频播放加载失败，请尝试其他视频源', 'error');
+}
+
+// 辅助函数用于渲染剧集按钮（使用当前的排序状态）
+function renderEpisodes(vodName) {
+    const episodes = episodesReversed ? [...currentEpisodes].reverse() : currentEpisodes;
+    return episodes.map((episode, index) => {
+        // 根据倒序状态计算真实的剧集索引
+        const realIndex = episodesReversed ? currentEpisodes.length - 1 - index : index;
+        return `
+            <button id="episode-${realIndex}" onclick="playVideo('${episode}','${vodName.replace(/"/g, '&quot;')}', ${realIndex})" 
+                    class="px-4 py-2 bg-[#222] hover:bg-[#333] border border-[#333] rounded-lg transition-colors text-center episode-btn">
+                第${realIndex + 1}集
+            </button>
+        `;
+    }).join('');
+}
+
+// 切换排序状态的函数
+function toggleEpisodeOrder() {
+    episodesReversed = !episodesReversed;
+    // 重新渲染剧集区域，使用 currentVideoTitle 作为视频标题
+    const episodesGrid = document.getElementById('episodesGrid');
+    if (episodesGrid) {
+        episodesGrid.innerHTML = renderEpisodes(currentVideoTitle);
+    }
+    
+    // 更新按钮文本和箭头方向
+    const toggleBtn = document.querySelector('button[onclick="toggleEpisodeOrder()"]');
+    if (toggleBtn) {
+        toggleBtn.querySelector('span').textContent = episodesReversed ? '正序排列' : '倒序排列';
+        const arrowIcon = toggleBtn.querySelector('svg');
+        if (arrowIcon) {
+            arrowIcon.style.transform = episodesReversed ? 'rotate(180deg)' : 'rotate(0deg)';
+        }
+    }
+}
+
+// app.js 或路由文件中
+const authMiddleware = require('./middleware/auth');
+const config = require('./config');
+
+// 对所有请求启用鉴权（按需调整作用范围）
+if (config.auth.enabled) {
+  app.use(authMiddleware);
+}
+
+// 或者针对特定路由
+app.use('/api', authMiddleware);

js/config.js

@@ -0,0 +1,205 @@
+// 全局常量配置
+const PROXY_URL = '/proxy/';    // 适用于 Cloudflare, Netlify (带重写), Vercel (带重写)
+// const HOPLAYER_URL = 'https://hoplayer.com/index.html';
+const SEARCH_HISTORY_KEY = 'videoSearchHistory';
+const MAX_HISTORY_ITEMS = 5;
+
+// 密码保护配置
+const PASSWORD_CONFIG = {
+    localStorageKey: 'passwordVerified',  // 存储验证状态的键名
+    verificationTTL: 90 * 24 * 60 * 60 * 1000,  // 验证有效期（90天，约3个月）
+};
+
+// 网站信息配置
+const SITE_CONFIG = {
+    name: 'LibreTV',
+    url: 'https://libretv.is-an.org',
+    description: '免费在线视频搜索与观看平台',
+    logo: 'https://images.icon-icons.com/38/PNG/512/retrotv_5520.png',
+    version: '1.0.3'
+};
+
+// API站点配置
+const API_SITES = {
+    heimuer: {
+        api: 'https://json.heimuer.xyz',
+        name: '黑木耳',
+        detail: 'https://heimuer.tv'
+    },
+    ffzy: {
+        api: 'http://ffzy5.tv',
+        name: '非凡影视',
+        detail: 'http://ffzy5.tv'
+    },
+    tyyszy: {
+        api: 'https://tyyszy.com',
+        name: '天涯资源',
+    },
+    ckzy: {
+        api: 'https://www.ckzy1.com',
+        name: 'CK资源',
+        adult: true
+    },
+    zy360: {
+        api: 'https://360zy.com',
+        name: '360资源',
+    },
+    wolong: {
+        api: 'https://wolongzyw.com',
+        name: '卧龙资源',
+    },
+    cjhw: {
+        api: 'https://cjhwba.com',
+        name: '新华为',
+    },
+    hwba: {
+        api: 'https://cjwba.com',
+        name: '华为吧资源',
+    },
+    jisu: {
+        api: 'https://jszyapi.com',
+        name: '极速资源',
+        detail: 'https://jszyapi.com'
+    },
+    dbzy: {
+        api: 'https://dbzy.com',
+        name: '豆瓣资源',
+    },
+    bfzy: {
+        api: 'https://bfzyapi.com',
+        name: '暴风资源',
+    },
+    mozhua: {
+        api: 'https://mozhuazy.com',
+        name: '魔爪资源',
+    },
+    mdzy: {
+        api: 'https://www.mdzyapi.com',
+        name: '魔都资源',
+    },
+    ruyi: {
+        api: 'https://cj.rycjapi.com',
+        name: '如意资源',
+    },
+    jkun: {
+        api: 'https://jkunzyapi.com',
+        name: 'jkun资源',
+        adult: true
+    },
+    bwzy: {
+        api: 'https://api.bwzym3u8.com',
+        name: '百万资源',
+        adult: true
+    },
+    souav: {
+        api: 'https://api.souavzy.vip',
+        name: 'souav资源',
+        adult: true
+    },
+    r155: {
+        api: 'https://155api.com',
+        name: '155资源',
+        adult: true
+    },
+    lsb: {
+        api: 'https://apilsbzy1.com',
+        name: 'lsb资源',
+        adult: true
+    },
+    huangcang: {
+        api: 'https://hsckzy.vip',
+        name: '黄色仓库',
+        adult: true,
+        detail: 'https://hsckzy.vip'
+    },
+    zuid: {
+        api: 'https://api.zuidapi.com',
+        name: '最大资源'
+    },
+    yutu: {
+        api: 'https://yutuzy10.com',
+        name: '玉兔资源',
+        adult: true
+    }
+    // 您可以按需添加更多源
+};
+
+// 添加聚合搜索的配置选项
+const AGGREGATED_SEARCH_CONFIG = {
+    enabled: true,             // 是否启用聚合搜索
+    timeout: 8000,            // 单个源超时时间（毫秒）
+    maxResults: 10000,          // 最大结果数量
+    parallelRequests: true,   // 是否并行请求所有源
+    showSourceBadges: true    // 是否显示来源徽章
+};
+
+// 抽象API请求配置
+const API_CONFIG = {
+    search: {
+    	// 修改搜索接口为返回更多详细数据（包括视频封面、简介和播放列表）
+        path: '/api.php/provide/vod/?ac=videolist&wd=',
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+            'Accept': 'application/json'
+        }
+    },
+    detail: {
+    	// 修改详情接口也使用videolist接口，但是通过ID查询，减少请求次数
+        path: '/api.php/provide/vod/?ac=videolist&ids=',
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+            'Accept': 'application/json'
+        }
+    }
+};
+
+// 优化后的正则表达式模式
+const M3U8_PATTERN = /\$https?:\/\/[^"'\s]+?\.m3u8/g;
+
+// 添加自定义播放器URL
+const CUSTOM_PLAYER_URL = 'player.html'; // 使用相对路径引用本地player.html
+
+// 增加视频播放相关配置
+const PLAYER_CONFIG = {
+    autoplay: true,
+    allowFullscreen: true,
+    width: '100%',
+    height: '600',
+    timeout: 15000,  // 播放器加载超时时间
+    filterAds: true,  // 是否启用广告过滤
+    autoPlayNext: true,  // 默认启用自动连播功能
+    adFilteringEnabled: true, // 默认开启分片广告过滤
+    adFilteringStorage: 'adFilteringEnabled' // 存储广告过滤设置的键名
+};
+
+// 增加错误信息本地化
+const ERROR_MESSAGES = {
+    NETWORK_ERROR: '网络连接错误，请检查网络设置',
+    TIMEOUT_ERROR: '请求超时，服务器响应时间过长',
+    API_ERROR: 'API接口返回错误，请尝试更换数据源',
+    PLAYER_ERROR: '播放器加载失败，请尝试其他视频源',
+    UNKNOWN_ERROR: '发生未知错误，请刷新页面重试'
+};
+
+// 添加进一步安全设置
+const SECURITY_CONFIG = {
+    enableXSSProtection: true,  // 是否启用XSS保护
+    sanitizeUrls: true,         // 是否清理URL
+    maxQueryLength: 100,        // 最大搜索长度
+    // allowedApiDomains 不再需要，因为所有请求都通过内部代理
+};
+
+// 添加多个自定义API源的配置
+const CUSTOM_API_CONFIG = {
+    separator: ',',           // 分隔符
+    maxSources: 5,            // 最大允许的自定义源数量
+    testTimeout: 5000,        // 测试超时时间(毫秒)
+    namePrefix: 'Custom-',    // 自定义源名称前缀
+    validateUrl: true,        // 验证URL格式
+    cacheResults: true,       // 缓存测试结果
+    cacheExpiry: 5184000000,  // 缓存过期时间(2个月)
+    adultPropName: 'isAdult' // 用于标记成人内容的属性名
+};
+
+// 新增隐藏内置黄色采集站API的变量，默认为true
+const HIDE_BUILTIN_ADULT_APIS = true;

js/douban.js

@@ -0,0 +1,361 @@
+// 豆瓣热门电影电视剧推荐功能
+
+// 豆瓣标签列表
+const doubanTags = ['热门', '最新', '经典', '豆瓣高分','古装剧', '冷门佳片', '科幻' ,'喜剧', '综艺', '欧美', '电视剧', '韩国', '日本', '动漫','动画片'];
+let doubanCurrentTag = localStorage.getItem('doubanCurrentTag') || '热门';
+let doubanPageStart = 0;
+const doubanPageSize = 16; // 一次显示的项目数量
+
+// 初始化豆瓣功能
+function initDouban() {
+    // 设置豆瓣开关的初始状态
+    const doubanToggle = document.getElementById('doubanToggle');
+    if (doubanToggle) {
+        const isEnabled = localStorage.getItem('doubanEnabled') === 'true';
+        doubanToggle.checked = isEnabled;
+        
+        // 设置开关外观
+        const toggleBg = doubanToggle.nextElementSibling;
+        const toggleDot = toggleBg.nextElementSibling;
+        if (isEnabled) {
+            toggleBg.classList.add('bg-pink-600');
+            toggleDot.classList.add('translate-x-6');
+        }
+        
+        // 添加事件监听
+        doubanToggle.addEventListener('change', function(e) {
+            const isChecked = e.target.checked;
+            localStorage.setItem('doubanEnabled', isChecked);
+            
+            // 更新开关外观
+            if (isChecked) {
+                toggleBg.classList.add('bg-pink-600');
+                toggleDot.classList.add('translate-x-6');
+            } else {
+                toggleBg.classList.remove('bg-pink-600');
+                toggleDot.classList.remove('translate-x-6');
+            }
+            
+            // 更新显示状态
+            updateDoubanVisibility();
+        });
+        
+        // 初始更新显示状态
+        updateDoubanVisibility();
+    }
+    
+    // 渲染豆瓣标签
+    renderDoubanTags();
+    
+    // 换一批按钮事件监听
+    setupDoubanRefreshBtn();
+    
+    // 初始加载热门内容
+    if (localStorage.getItem('doubanEnabled') === 'true') {
+        renderRecommend(doubanCurrentTag, doubanPageSize, doubanPageStart);
+    }
+}
+
+// 根据设置更新豆瓣区域的显示状态
+function updateDoubanVisibility() {
+    const doubanArea = document.getElementById('doubanArea');
+    if (!doubanArea) return;
+    
+    const isEnabled = localStorage.getItem('doubanEnabled') === 'true';
+    const isSearching = document.getElementById('resultsArea') && 
+        !document.getElementById('resultsArea').classList.contains('hidden');
+    
+    // 只有在启用且没有搜索结果显示时才显示豆瓣区域
+    if (isEnabled && !isSearching) {
+        doubanArea.classList.remove('hidden');
+        // 如果豆瓣结果为空，重新加载
+        if (document.getElementById('douban-results').children.length === 0) {
+            renderRecommend(doubanCurrentTag, doubanPageSize, doubanPageStart);
+        }
+    } else {
+        doubanArea.classList.add('hidden');
+    }
+}
+
+// 只填充搜索框，不执行搜索，让用户自主决定搜索时机
+function fillSearchInput(title) {
+    if (!title) return;
+    
+    // 安全处理标题，防止XSS
+    const safeTitle = title
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+    
+    const input = document.getElementById('searchInput');
+    if (input) {
+        input.value = safeTitle;
+        
+        // 聚焦搜索框，便于用户立即使用键盘操作
+        input.focus();
+        
+        // 显示一个提示，告知用户点击搜索按钮进行搜索
+        showToast('已填充搜索内容，点击搜索按钮开始搜索', 'info');
+    }
+}
+
+// 填充搜索框并执行搜索
+function fillAndSearch(title) {
+    if (!title) return;
+    
+    // 安全处理标题，防止XSS
+    const safeTitle = title
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+    
+    const input = document.getElementById('searchInput');
+    if (input) {
+        input.value = safeTitle;
+        search(); // 使用已有的search函数执行搜索
+    }
+}
+
+// 填充搜索框，确保豆瓣资源API被选中，然后执行搜索
+function fillAndSearchWithDouban(title) {
+    if (!title) return;
+    
+    // 安全处理标题，防止XSS
+    const safeTitle = title
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+    
+    // 确保豆瓣资源API被选中
+    if (typeof selectedAPIs !== 'undefined' && !selectedAPIs.includes('dbzy')) {
+        // 在设置中勾选豆瓣资源API复选框
+        const doubanCheckbox = document.querySelector('input[id="api_dbzy"]');
+        if (doubanCheckbox) {
+            doubanCheckbox.checked = true;
+            
+            // 触发updateSelectedAPIs函数以更新状态
+            if (typeof updateSelectedAPIs === 'function') {
+                updateSelectedAPIs();
+            } else {
+                // 如果函数不可用，则手动添加到selectedAPIs
+                selectedAPIs.push('dbzy');
+                localStorage.setItem('selectedAPIs', JSON.stringify(selectedAPIs));
+                
+                // 更新选中API计数（如果有这个元素）
+                const countEl = document.getElementById('selectedAPICount');
+                if (countEl) {
+                    countEl.textContent = selectedAPIs.length;
+                }
+            }
+            
+            showToast('已自动选择豆瓣资源API', 'info');
+        }
+    }
+    
+    // 填充搜索框并执行搜索
+    const input = document.getElementById('searchInput');
+    if (input) {
+        input.value = safeTitle;
+        search(); // 使用已有的search函数执行搜索
+    }
+}
+
+// 渲染豆瓣标签选择器
+function renderDoubanTags() {
+    const tagContainer = document.getElementById('douban-tags');
+    if (!tagContainer) return;
+    
+    tagContainer.innerHTML = '';
+    
+    doubanTags.forEach(tag => {
+        const btn = document.createElement('button');
+        // 更新标签样式：统一高度，添加过渡效果，改进颜色对比度
+        btn.className = 'py-1.5 px-3.5 rounded text-sm font-medium transition-all duration-300 ' + 
+            (tag === doubanCurrentTag ? 
+                'bg-pink-600 text-white shadow-md' : 
+                'bg-[#1a1a1a] text-gray-300 hover:bg-pink-700 hover:text-white');
+        
+        btn.textContent = tag;
+        
+        btn.onclick = function() {
+            if (doubanCurrentTag !== tag) {
+                doubanCurrentTag = tag;
+                localStorage.setItem('doubanCurrentTag', tag);
+                doubanPageStart = 0;
+                renderRecommend(doubanCurrentTag, doubanPageSize, doubanPageStart);
+                renderDoubanTags();
+            }
+        };
+        
+        tagContainer.appendChild(btn);
+    });
+}
+
+// 设置换一批按钮事件
+function setupDoubanRefreshBtn() {
+    // 修复ID，使用正确的ID douban-refresh 而不是 douban-refresh-btn
+    const btn = document.getElementById('douban-refresh');
+    if (!btn) return;
+    
+    btn.onclick = function() {
+        doubanPageStart += doubanPageSize;
+        if (doubanPageStart > 9 * doubanPageSize) {
+            doubanPageStart = 0;
+        }
+        
+        renderRecommend(doubanCurrentTag, doubanPageSize, doubanPageStart);
+    };
+}
+
+// 渲染热门推荐内容
+function renderRecommend(tag, pageLimit, pageStart) {
+    const container = document.getElementById("douban-results");
+    if (!container) return;
+    
+    // 显示加载状态
+    container.innerHTML = `
+        <div class="col-span-full text-center py-10">
+            <div class="w-6 h-6 border-2 border-pink-500 border-t-transparent rounded-full animate-spin mr-2 inline-block"></div>
+            <span class="text-pink-500">加载中...</span>
+        </div>
+    `;
+    
+    const target = `https://movie.douban.com/j/search_subjects?type=movie&tag=${tag}&sort=recommend&page_limit=${pageLimit}&page_start=${pageStart}`;
+    
+    // 添加超时控制
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10秒超时
+    
+    // 设置请求选项，包括信号和头部
+    const fetchOptions = {
+        signal: controller.signal,
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
+            'Referer': 'https://movie.douban.com/',
+            'Accept': 'application/json, text/plain, */*',
+        }
+    };
+
+    // 尝试直接访问（豆瓣API可能允许部分CORS请求）
+    fetch(PROXY_URL + encodeURIComponent(target), fetchOptions)
+        .then(response => {
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`HTTP error! Status: ${response.status}`);
+            }
+            return response.json();
+        })
+        .then(data => {
+            renderDoubanCards(data, container);
+        })
+        .catch(err => {
+            console.error("豆瓣 API 请求失败（直接代理）：", err);
+            
+            // 失败后尝试备用方法：作为备选
+            const fallbackUrl = `https://api.allorigins.win/get?url=${encodeURIComponent(target)}`;
+            
+            fetch(fallbackUrl)
+                .then(response => {
+                    if (!response.ok) throw new Error(`备用API请求失败! 状态: ${response.status}`);
+                    return response.json();
+                })
+                .then(data => {
+                    // 解析原始内容
+                    if (data && data.contents) {
+                        const doubanData = JSON.parse(data.contents);
+                        renderDoubanCards(doubanData, container);
+                    } else {
+                        throw new Error("无法获取有效数据");
+                    }
+                })
+                .catch(fallbackErr => {
+                    console.error("��瓣 API 备用请求也失败：", fallbackErr);
+                    container.innerHTML = `
+                        <div class="col-span-full text-center py-8">
+                            <div class="text-red-400">❌ 获取豆瓣数据失败，请稍后重试</div>
+                            <div class="text-gray-500 text-sm mt-2">提示：使用VPN可能有助于解决此问题</div>
+                        </div>
+                    `;
+                });
+        });
+}
+
+// 抽取渲染豆瓣卡片的逻辑到单独函数
+function renderDoubanCards(data, container) {
+    // 创建文档片段以提高性能
+    const fragment = document.createDocumentFragment();
+    
+    // 如果没有数据
+    if (!data.subjects || data.subjects.length === 0) {
+        const emptyEl = document.createElement("div");
+        emptyEl.className = "col-span-full text-center py-8";
+        emptyEl.innerHTML = `
+            <div class="text-pink-500">❌ 暂无数据，请尝试其他分类或刷新</div>
+        `;
+        fragment.appendChild(emptyEl);
+    } else {
+        // 循环创建每个影视卡片
+        data.subjects.forEach(item => {
+            const card = document.createElement("div");
+            card.className = "bg-[#111] hover:bg-[#222] transition-all duration-300 rounded-lg overflow-hidden flex flex-col transform hover:scale-105 shadow-md hover:shadow-lg";
+            
+            // 生成卡片内容，确保安全显示（防止XSS）
+            const safeTitle = item.title
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;');
+            
+            const safeRate = (item.rate || "暂无")
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;');
+            
+            // 处理图片URL
+            // 1. 直接使用豆瓣图片URL (添加no-referrer属性)
+            const originalCoverUrl = item.cover;
+            
+            // 2. 也准备代理URL作为备选
+            const proxiedCoverUrl = PROXY_URL + encodeURIComponent(originalCoverUrl);
+            
+            // 为不同设备优化卡片布局
+            card.innerHTML = `
+                <div class="relative w-full aspect-[2/3] overflow-hidden cursor-pointer" onclick="fillAndSearchWithDouban('${safeTitle}')">
+                    <img src="${originalCoverUrl}" alt="${safeTitle}" 
+                        class="w-full h-full object-cover transition-transform duration-500 hover:scale-110"
+                        onerror="this.onerror=null; this.src='${proxiedCoverUrl}'; this.classList.add('object-contain');"
+                        loading="lazy" referrerpolicy="no-referrer">
+                    <div class="absolute inset-0 bg-gradient-to-t from-black to-transparent opacity-60"></div>
+                    <div class="absolute bottom-2 left-2 bg-black/70 text-white text-xs px-2 py-1 rounded-sm">
+                        <span class="text-yellow-400">★</span> ${safeRate}
+                    </div>
+                    <div class="absolute bottom-2 right-2 bg-black/70 text-white text-xs px-2 py-1 rounded-sm hover:bg-[#333] transition-colors">
+                        <a href="${item.url}" target="_blank" rel="noopener noreferrer" title="在豆瓣查看">
+                            🔗
+                        </a>
+                    </div>
+                </div>
+                <div class="p-2 text-center bg-[#111]">
+                    <button onclick="fillAndSearchWithDouban('${safeTitle}')" 
+                            class="text-sm font-medium text-white truncate w-full hover:text-pink-400 transition"
+                            title="${safeTitle}">
+                        ${safeTitle}
+                    </button>
+                </div>
+            `;
+            
+            fragment.appendChild(card);
+        });
+    }
+    
+    // 清空并添加所有新元素
+    container.innerHTML = "";
+    container.appendChild(fragment);
+}
+
+// 重置到首页
+function resetToHome() {
+    resetSearchArea();
+    updateDoubanVisibility();
+}
+
+// 加载豆瓣首页内容
+document.addEventListener('DOMContentLoaded', initDouban);

js/password.js

@@ -0,0 +1,179 @@
+// 密码保护功能
+
+/**
+ * 检查是否设置了密码保护
+ * 通过读取页面上嵌入的环境变量来检查
+ */
+function isPasswordProtected() {
+    // 检查页面上嵌入的环境变量
+    const pwd = window.__ENV__ && window.__ENV__.PASSWORD;
+    // 只有当密码 hash 存在且为64位（SHA-256十六进制长度）才认为启用密码保护
+    return typeof pwd === 'string' && pwd.length === 64 && !/^0+$/.test(pwd);
+}
+
+/**
+ * 检查用户是否已通过密码验证
+ * 检查localStorage中的验证状态和时间戳是否有效，并确认密码哈希未更改
+ */
+function isPasswordVerified() {
+    try {
+        // 如果没有设置密码保护，则视为已验证
+        if (!isPasswordProtected()) {
+            return true;
+        }
+
+        const verificationData = JSON.parse(localStorage.getItem(PASSWORD_CONFIG.localStorageKey) || '{}');
+        const { verified, timestamp, passwordHash } = verificationData;
+        
+        // 获取当前环境中的密码哈希
+        const currentHash = window.__ENV__ && window.__ENV__.PASSWORD;
+        
+        // 验证是否已验证、未过期，且密码哈希未更改
+        if (verified && timestamp && passwordHash === currentHash) {
+            const now = Date.now();
+            const expiry = timestamp + PASSWORD_CONFIG.verificationTTL;
+            return now < expiry;
+        }
+        
+        return false;
+    } catch (error) {
+        console.error('验证密码状态时出错:', error);
+        return false;
+    }
+}
+
+window.isPasswordProtected = isPasswordProtected;
+window.isPasswordVerified = isPasswordVerified;
+
+/**
+ * 验证用户输入的密码是否正确（异步，使用SHA-256哈希）
+ */
+async function verifyPassword(password) {
+    const correctHash = window.__ENV__ && window.__ENV__.PASSWORD;
+    if (!correctHash) return false;
+    const inputHash = await sha256(password);
+    const isValid = inputHash === correctHash;
+    if (isValid) {
+        const verificationData = {
+            verified: true,
+            timestamp: Date.now(),
+            passwordHash: correctHash // 保存当前密码的哈希值
+        };
+        localStorage.setItem(PASSWORD_CONFIG.localStorageKey, JSON.stringify(verificationData));
+    }
+    return isValid;
+}
+
+// SHA-256实现，可用Web Crypto API
+async function sha256(message) {
+    if (window.crypto && crypto.subtle && crypto.subtle.digest) {
+        const msgBuffer = new TextEncoder().encode(message);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    // HTTP 下调用原始 js‑sha256
+    if (typeof window._jsSha256 === 'function') {
+        return window._jsSha256(message);
+    }
+    throw new Error('No SHA-256 implementation available.');
+}
+
+/**
+ * 显示密码验证弹窗
+ */
+function showPasswordModal() {
+    const passwordModal = document.getElementById('passwordModal');
+    if (passwordModal) {
+        passwordModal.style.display = 'flex';
+        
+        // 确保输入框获取焦点
+        setTimeout(() => {
+            const passwordInput = document.getElementById('passwordInput');
+            if (passwordInput) {
+                passwordInput.focus();
+            }
+        }, 100);
+    }
+}
+
+/**
+ * 隐藏密码验证弹窗
+ */
+function hidePasswordModal() {
+    const passwordModal = document.getElementById('passwordModal');
+    if (passwordModal) {
+        passwordModal.style.display = 'none';
+    }
+}
+
+/**
+ * 显示密码错误信息
+ */
+function showPasswordError() {
+    const errorElement = document.getElementById('passwordError');
+    if (errorElement) {
+        errorElement.classList.remove('hidden');
+    }
+}
+
+/**
+ * 隐藏密码错误信息
+ */
+function hidePasswordError() {
+    const errorElement = document.getElementById('passwordError');
+    if (errorElement) {
+        errorElement.classList.add('hidden');
+    }
+}
+
+/**
+ * 处理密码提交事件（异步）
+ */
+async function handlePasswordSubmit() {
+    const passwordInput = document.getElementById('passwordInput');
+    const password = passwordInput ? passwordInput.value.trim() : '';
+    if (await verifyPassword(password)) {
+        hidePasswordError();
+        hidePasswordModal();
+    } else {
+        showPasswordError();
+        if (passwordInput) {
+            passwordInput.value = '';
+            passwordInput.focus();
+        }
+    }
+}
+
+/**
+ * 初始化密码验证系统（需适配异步事件）
+ */
+function initPasswordProtection() {
+    if (!isPasswordProtected()) {
+        return; // 如果未设置密码保护，则不进行任何操作
+    }
+    
+    // 如果未验证密码，则显示密码验证弹窗
+    if (!isPasswordVerified()) {
+        showPasswordModal();
+        
+        // 设置密码提交按钮事件监听
+        const submitButton = document.getElementById('passwordSubmitBtn');
+        if (submitButton) {
+            submitButton.addEventListener('click', handlePasswordSubmit);
+        }
+        
+        // 设置密码输入框回车键监听
+        const passwordInput = document.getElementById('passwordInput');
+        if (passwordInput) {
+            passwordInput.addEventListener('keypress', function(e) {
+                if (e.key === 'Enter') {
+                    handlePasswordSubmit();
+                }
+            });
+        }
+    }
+}
+
+// 在页面加载完成后初始化密码保护
+document.addEventListener('DOMContentLoaded', initPasswordProtection);

js/sha256.js

@@ -0,0 +1,6 @@
+export async function sha256(message) {
+    const msgBuffer = new TextEncoder().encode(message);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+}

js/ui.js

@@ -0,0 +1,621 @@
+// UI相关函数
+function toggleSettings(e) {
+    // 密码保护校验
+    if (window.isPasswordProtected && window.isPasswordVerified) {
+        if (window.isPasswordProtected() && !window.isPasswordVerified()) {
+            showPasswordModal && showPasswordModal();
+            return;
+        }
+    }
+    // 阻止事件冒泡，防止触发document的点击事件
+    e && e.stopPropagation();
+    const panel = document.getElementById('settingsPanel');
+    panel.classList.toggle('show');
+}
+
+// 改进的Toast显示函数 - 支持队列显示多个Toast
+const toastQueue = [];
+let isShowingToast = false;
+
+function showToast(message, type = 'error') {
+    // 将新的toast添加到队列
+    toastQueue.push({ message, type });
+    
+    // 如果当前没有显示中的toast，则开始显示
+    if (!isShowingToast) {
+        showNextToast();
+    }
+}
+
+function showNextToast() {
+    if (toastQueue.length === 0) {
+        isShowingToast = false;
+        return;
+    }
+    
+    isShowingToast = true;
+    const { message, type } = toastQueue.shift();
+    
+    const toast = document.getElementById('toast');
+    const toastMessage = document.getElementById('toastMessage');
+    
+    const bgColors = {
+        'error': 'bg-red-500',
+        'success': 'bg-green-500',
+        'info': 'bg-blue-500',
+        'warning': 'bg-yellow-500'
+    };
+    
+    const bgColor = bgColors[type] || bgColors.error;
+    toast.className = `fixed top-4 left-1/2 -translate-x-1/2 px-6 py-3 rounded-lg shadow-lg transform transition-all duration-300 ${bgColor} text-white`;
+    toastMessage.textContent = message;
+    
+    // 显示提示
+    toast.style.opacity = '1';
+    toast.style.transform = 'translateX(-50%) translateY(0)';
+    
+    // 3秒后自动隐藏
+    setTimeout(() => {
+        toast.style.opacity = '0';
+        toast.style.transform = 'translateX(-50%) translateY(-100%)';
+        
+        // 等待动画完成后显示下一个toast
+        setTimeout(() => {
+            showNextToast();
+        }, 300);
+    }, 3000);
+}
+
+// 添加显示/隐藏 loading 的函数
+let loadingTimeoutId = null;
+
+function showLoading(message = '加载中...') {
+    // 清除任何现有的超时
+    if (loadingTimeoutId) {
+        clearTimeout(loadingTimeoutId);
+    }
+    
+    const loading = document.getElementById('loading');
+    const messageEl = loading.querySelector('p');
+    messageEl.textContent = message;
+    loading.style.display = 'flex';
+    
+    // 设置30秒后自动关闭loading，防止无限loading
+    loadingTimeoutId = setTimeout(() => {
+        hideLoading();
+        showToast('操作超时，请稍后重试', 'warning');
+    }, 30000);
+}
+
+function hideLoading() {
+    // 清除超时
+    if (loadingTimeoutId) {
+        clearTimeout(loadingTimeoutId);
+        loadingTimeoutId = null;
+    }
+    
+    const loading = document.getElementById('loading');
+    loading.style.display = 'none';
+}
+
+function updateSiteStatus(isAvailable) {
+    const statusEl = document.getElementById('siteStatus');
+    if (isAvailable) {
+        statusEl.innerHTML = '<span class="text-green-500">●</span> 可用';
+    } else {
+        statusEl.innerHTML = '<span class="text-red-500">●</span> 不可用';
+    }
+}
+
+function closeModal() {
+    document.getElementById('modal').classList.add('hidden');
+    // 清除 iframe 内容
+    document.getElementById('modalContent').innerHTML = '';
+}
+
+// 获取搜索历史的增强版本 - 支持新旧格式
+function getSearchHistory() {
+    try {
+        const data = localStorage.getItem(SEARCH_HISTORY_KEY);
+        if (!data) return [];
+        
+        const parsed = JSON.parse(data);
+        
+        // 检查是否是数组
+        if (!Array.isArray(parsed)) return [];
+        
+        // 支持旧格式（字符串数组）和新格式（对象数组）
+        return parsed.map(item => {
+            if (typeof item === 'string') {
+                return { text: item, timestamp: 0 };
+            }
+            return item;
+        }).filter(item => item && item.text);
+    } catch (e) {
+        console.error('获取搜索历史出错:', e);
+        return [];
+    }
+}
+
+// 保存搜索历史的增强版本 - 添加时间戳和最大数量限制，现在缓存2个月
+function saveSearchHistory(query) {
+    if (!query || !query.trim()) return;
+    
+    // 清理输入，防止XSS
+    query = query.trim().substring(0, 50).replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    
+    let history = getSearchHistory();
+    
+    // 获取当前时间
+    const now = Date.now();
+    
+    // 过滤掉超过2个月的记录（约60天，60*24*60*60*1000 = 5184000000毫秒）
+    history = history.filter(item => 
+        typeof item === 'object' && item.timestamp && (now - item.timestamp < 5184000000)
+    );
+    
+    // 删除已存在的相同项
+    history = history.filter(item => 
+        typeof item === 'object' ? item.text !== query : item !== query
+    );
+    
+    // 新项���加到开头，包含时间戳
+    history.unshift({
+        text: query,
+        timestamp: now
+    });
+    
+    // 限制历史记录数量
+    if (history.length > MAX_HISTORY_ITEMS) {
+        history = history.slice(0, MAX_HISTORY_ITEMS);
+    }
+    
+    try {
+        localStorage.setItem(SEARCH_HISTORY_KEY, JSON.stringify(history));
+    } catch (e) {
+        console.error('保存搜索历史失败:', e);
+        // 如果存储失败（可能是localStorage已满），尝试清理旧数据
+        try {
+            localStorage.removeItem(SEARCH_HISTORY_KEY);
+            localStorage.setItem(SEARCH_HISTORY_KEY, JSON.stringify(history.slice(0, 3)));
+        } catch (e2) {
+            console.error('再次保存搜索历史失败:', e2);
+        }
+    }
+    
+    renderSearchHistory();
+}
+
+// 渲染最近搜索历史的增强版本
+function renderSearchHistory() {
+    const historyContainer = document.getElementById('recentSearches');
+    if (!historyContainer) return;
+    
+    const history = getSearchHistory();
+    
+    if (history.length === 0) {
+        historyContainer.innerHTML = '';
+        return;
+    }
+    
+    // 创建一个包含标题和清除按钮的行
+    historyContainer.innerHTML = `
+        <div class="flex justify-between items-center w-full mb-2">
+            <div class="text-gray-500">最近搜索:</div>
+            <button id="clearHistoryBtn" class="text-gray-500 hover:text-white transition-colors" 
+                    onclick="clearSearchHistory()" aria-label="清除搜索历史">
+                清除搜索历史
+            </button>
+        </div>
+    `;
+    
+    history.forEach(item => {
+        const tag = document.createElement('button');
+        tag.className = 'search-tag';
+        tag.textContent = item.text;
+        
+        // 添加时间提示（如果有时间戳）
+        if (item.timestamp) {
+            const date = new Date(item.timestamp);
+            tag.title = `搜索于: ${date.toLocaleString()}`;
+        }
+        
+        tag.onclick = function() {
+            document.getElementById('searchInput').value = item.text;
+            search();
+        };
+        historyContainer.appendChild(tag);
+    });
+}
+
+// 增加清除搜索历史功能
+function clearSearchHistory() {
+    // 密码保护校验
+    if (window.isPasswordProtected && window.isPasswordVerified) {
+        if (window.isPasswordProtected() && !window.isPasswordVerified()) {
+            showPasswordModal && showPasswordModal();
+            return;
+        }
+    }
+    try {
+        localStorage.removeItem(SEARCH_HISTORY_KEY);
+        renderSearchHistory();
+        showToast('搜索历史已清除', 'success');
+    } catch (e) {
+        console.error('清除搜索历史失败:', e);
+        showToast('清除搜索历史失败:', 'error');
+    }
+}
+
+// 历史面板相关函数
+function toggleHistory(e) {
+    // 密码保护校验
+    if (window.isPasswordProtected && window.isPasswordVerified) {
+        if (window.isPasswordProtected() && !window.isPasswordVerified()) {
+            showPasswordModal && showPasswordModal();
+            return;
+        }
+    }
+    if (e) e.stopPropagation();
+    
+    const panel = document.getElementById('historyPanel');
+    if (panel) {
+        panel.classList.toggle('show');
+        
+        // 如果打开了历史记录面板，则加载历史数据
+        if (panel.classList.contains('show')) {
+            loadViewingHistory();
+        }
+        
+        // 如果设置面板是打开的，则关闭它
+        const settingsPanel = document.getElementById('settingsPanel');
+        if (settingsPanel && settingsPanel.classList.contains('show')) {
+            settingsPanel.classList.remove('show');
+        }
+    }
+}
+
+// 格式化时间戳为友好的日期时间格式
+function formatTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    const now = new Date();
+    const diff = now - date;
+    
+    // 小于1小时，显示"X分钟前"
+    if (diff < 3600000) {
+        const minutes = Math.floor(diff / 60000);
+        return minutes <= 0 ? '刚刚' : `${minutes}分钟前`;
+    }
+    
+    // 小于24小时，显示"X小时前"
+    if (diff < 86400000) {
+        const hours = Math.floor(diff / 3600000);
+        return `${hours}小时前`;
+    }
+    
+    // 小于7天，显示"X天前"
+    if (diff < 604800000) {
+        const days = Math.floor(diff / 86400000);
+        return `${days}天前`;
+    }
+    
+    // 其他情况，显示完整日期
+    const year = date.getFullYear();
+    const month = (date.getMonth() + 1).toString().padStart(2, '0');
+    const day = date.getDate().toString().padStart(2, '0');
+    const hour = date.getHours().toString().padStart(2, '0');
+    const minute = date.getMinutes().toString().padStart(2, '0');
+    
+    return `${year}-${month}-${day} ${hour}:${minute}`;
+}
+
+// 获取观看历史记录
+function getViewingHistory() {
+    try {
+        const data = localStorage.getItem('viewingHistory');
+        return data ? JSON.parse(data) : [];
+    } catch (e) {
+        console.error('获取观看历史失败:', e);
+        return [];
+    }
+}
+
+// 加载观看历史并渲染
+function loadViewingHistory() {
+    const historyList = document.getElementById('historyList');
+    if (!historyList) return;
+    
+    const history = getViewingHistory();
+    
+    if (history.length === 0) {
+        historyList.innerHTML = `<div class="text-center text-gray-500 py-8">暂无观看记录</div>`;
+        return;
+    }
+    
+    // 渲染历史记录
+    historyList.innerHTML = history.map(item => {
+        // 防止XSS
+        const safeTitle = item.title
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;');
+        
+        const safeSource = item.sourceName ? 
+            item.sourceName.replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;') : 
+            '未知来源';
+            
+        const episodeText = item.episodeIndex !== undefined ? 
+            `第${item.episodeIndex + 1}集` : '';
+        
+        // 格式化进度信息
+        let progressHtml = '';
+        if (item.playbackPosition && item.duration && item.playbackPosition > 10 && item.playbackPosition < item.duration * 0.95) {
+            const percent = Math.round((item.playbackPosition / item.duration) * 100);
+            const formattedTime = formatPlaybackTime(item.playbackPosition);
+            const formattedDuration = formatPlaybackTime(item.duration);
+            
+            progressHtml = `
+                <div class="history-progress">
+                    <div class="progress-bar">
+                        <div class="progress-filled" style="width:${percent}%"></div>
+                    </div>
+                    <div class="progress-text">${formattedTime} / ${formattedDuration}</div>
+                </div>
+            `;
+        }
+        
+        // 为防止XSS，使用encodeURIComponent编码URL
+        const safeURL = encodeURIComponent(item.url);
+        
+        // 构建历史记录项HTML，添加删除按钮，需要放在position:relative的容器中
+        return `
+            <div class="history-item cursor-pointer relative group" onclick="playFromHistory('${item.url}', '${safeTitle}', ${item.episodeIndex || 0}, ${item.playbackPosition || 0})">
+                <button onclick="event.stopPropagation(); deleteHistoryItem('${safeURL}')" 
+                        class="absolute right-2 top-2 opacity-0 group-hover:opacity-100 transition-opacity duration-200 text-gray-400 hover:text-red-400 p-1 rounded-full hover:bg-gray-800 z-10"
+                        title="删除记录">
+                    <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
+                    </svg>
+                </button>
+                <div class="history-info">
+                    <div class="history-title">${safeTitle}</div>
+                    <div class="history-meta">
+                        <span class="history-episode">${episodeText}</span>
+                        ${episodeText ? '<span class="history-separator mx-1">·</span>' : ''}
+                        <span class="history-source">${safeSource}</span>
+                    </div>
+                    ${progressHtml}
+                    <div class="history-time">${formatTimestamp(item.timestamp)}</div>
+                </div>
+            </div>
+        `;
+    }).join('');
+    
+    // 检查是否存在较多历史记录，添加底部边距确保底部按钮不会挡住内容
+    if (history.length > 5) {
+        historyList.classList.add('pb-4');
+    }
+}
+
+// 格式化播放时间为 mm:ss 格式
+function formatPlaybackTime(seconds) {
+    if (!seconds || isNaN(seconds)) return '00:00';
+    
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = Math.floor(seconds % 60);
+    
+    return `${minutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}`;
+}
+
+// 删除单个历史记录项
+function deleteHistoryItem(encodedUrl) {
+    try {
+        // 解码URL
+        const url = decodeURIComponent(encodedUrl);
+        
+        // 获取当前历史记录
+        const history = getViewingHistory();
+        
+        // 过滤掉要删除的项
+        const newHistory = history.filter(item => item.url !== url);
+        
+        // 保存回localStorage
+        localStorage.setItem('viewingHistory', JSON.stringify(newHistory));
+        
+        // 重新加载历史记录显示
+        loadViewingHistory();
+        
+        // 显示成功提示
+        showToast('已删除该记录', 'success');
+    } catch (e) {
+        console.error('删除历史记录项失败:', e);
+        showToast('删除记录失败', 'error');
+    }
+}
+
+// 从历史记录播放
+function playFromHistory(url, title, episodeIndex, playbackPosition = 0) {
+    try {
+        // 尝试从localStorage获取当前视频的集数信息
+        let episodesList = [];
+        
+        // 检查viewingHistory，查找匹配的项以获取其集数数据
+        const historyRaw = localStorage.getItem('viewingHistory');
+        if (historyRaw) {
+            const history = JSON.parse(historyRaw);
+            // 根据标题查找匹配的历史记录
+            const historyItem = history.find(item => item.title === title);
+            
+            // 如果找到了匹配的历史记录，尝试获取该条目的集数数据
+            if (historyItem && historyItem.episodes && Array.isArray(historyItem.episodes)) {
+                episodesList = historyItem.episodes;
+                console.log(`从历史记录找到视频 ${title} 的集数数据:`, episodesList.length);
+            }
+        }
+        
+        // 如果在历史记录中没找到，尝试使用上一个会话的集数数据
+        if (episodesList.length === 0) {
+            try {
+                const storedEpisodes = JSON.parse(localStorage.getItem('currentEpisodes') || '[]');
+                if (storedEpisodes.length > 0) {
+                    episodesList = storedEpisodes;
+                    console.log(`使用localStorage中的集数数据:`, episodesList.length);
+                }
+            } catch (e) {
+                console.error('解析currentEpisodes失败:', e);
+            }
+        }
+        
+        // 将剧集列表保存到localStorage，避免过长的URL
+        if (episodesList.length > 0) {
+            localStorage.setItem('currentEpisodes', JSON.stringify(episodesList));
+            console.log(`已将剧集列表保存到localStorage，共 ${episodesList.length} 集`);
+        }
+        // 构造带播放进度参数的URL
+        const positionParam = playbackPosition > 10 ? `&position=${Math.floor(playbackPosition)}` : '';
+        
+        if (url.includes('?')) {
+            // URL已有参数，添加索引和位置参数
+            let playUrl = url;
+            if (!url.includes('index=') && episodeIndex > 0) {
+                playUrl += `&index=${episodeIndex}`;
+            }
+            if (playbackPosition > 10) {
+                playUrl += positionParam;
+            }
+            window.open(playUrl, '_blank');
+        } else {
+            // 原始URL，构造player页面链接
+            const playerUrl = `player.html?url=${encodeURIComponent(url)}&title=${encodeURIComponent(title)}&index=${episodeIndex}${positionParam}`;
+            window.open(playerUrl, '_blank');
+        }
+    } catch (e) {
+        console.error('从历史记录播放失败:', e);
+        // 回退到原始简单URL
+        const simpleUrl = `player.html?url=${encodeURIComponent(url)}&title=${encodeURIComponent(title)}&index=${episodeIndex}`;
+        window.open(simpleUrl, '_blank');
+    }
+}
+
+// 添加观看历史 - 确保每个视频标题只有一条记录
+function addToViewingHistory(videoInfo) {
+    // 密码保护校验
+    if (window.isPasswordProtected && window.isPasswordVerified) {
+        if (window.isPasswordProtected() && !window.isPasswordVerified()) {
+            showPasswordModal && showPasswordModal();
+            return;
+        }
+    }
+    try {
+        const history = getViewingHistory();
+        
+        // 检查是否已经存在相同标题的记录（同一视频的不同集数）
+        const existingIndex = history.findIndex(item => item.title === videoInfo.title);
+        if (existingIndex !== -1) {
+            // 存在则更新现有记录的集数和时间戳
+            const existingItem = history[existingIndex];
+            existingItem.episodeIndex = videoInfo.episodeIndex;
+            existingItem.timestamp = Date.now();
+            
+            // 确保来源信息保留
+            if (videoInfo.sourceName && !existingItem.sourceName) {
+                existingItem.sourceName = videoInfo.sourceName;
+            }
+            
+            // 更新播放进度信息，仅当新进度有效且大于10秒时
+            if (videoInfo.playbackPosition && videoInfo.playbackPosition > 10) {
+                existingItem.playbackPosition = videoInfo.playbackPosition;
+                existingItem.duration = videoInfo.duration || existingItem.duration;
+            }
+            
+            // 更新URL，确保能够跳转到正确的集数
+            existingItem.url = videoInfo.url;
+            
+            // 重要：确保episodes数据与当前视频匹配
+            // 只有当videoInfo中包含有效的episodes数据时才更新
+            if (videoInfo.episodes && Array.isArray(videoInfo.episodes) && videoInfo.episodes.length > 0) {
+                // 如果传入的集数数据与当前保存的不同，则更新
+                if (!existingItem.episodes || 
+                    !Array.isArray(existingItem.episodes) || 
+                    existingItem.episodes.length !== videoInfo.episodes.length) {
+                    console.log(`更新 "${videoInfo.title}" 的剧集数据: ${videoInfo.episodes.length}集`);
+                    existingItem.episodes = [...videoInfo.episodes]; // 使用深拷贝
+                }
+            }
+            
+            // 移到最前面
+            history.splice(existingIndex, 1);
+            history.unshift(existingItem);
+        } else {
+            // 添加新记录到最前面，确保包含剧集数据
+            const newItem = {
+                ...videoInfo,
+                timestamp: Date.now()
+            };
+            
+            // 确保episodes字段是一个数组
+            if (videoInfo.episodes && Array.isArray(videoInfo.episodes)) {
+                newItem.episodes = [...videoInfo.episodes]; // 使用深拷贝
+                console.log(`保存新视频 "${videoInfo.title}" 的剧集数据: ${videoInfo.episodes.length}集`);
+            } else {
+                // 如果没有提供episodes，初始化为空数组
+                newItem.episodes = [];
+            }
+            
+            history.unshift(newItem);
+        }
+        
+        // 限制历史记录数量为50条
+        const maxHistoryItems = 50;
+        if (history.length > maxHistoryItems) {
+            history.splice(maxHistoryItems);
+        }
+        
+        // 保存到本地存储
+        localStorage.setItem('viewingHistory', JSON.stringify(history));
+    } catch (e) {
+        console.error('保存观看历史失败:', e);
+    }
+}
+
+// 清空观看历史
+function clearViewingHistory() {
+    try {
+        localStorage.removeItem('viewingHistory');
+        loadViewingHistory(); // 重新加载空的历史记录
+        showToast('观看历史已清空', 'success');
+    } catch (e) {
+        console.error('清除观看历史失败:', e);
+        showToast('清除观看历史失败', 'error');
+    }
+}
+
+// 更新toggleSettings函数以处理历史面板互动
+const originalToggleSettings = toggleSettings;
+toggleSettings = function(e) {
+    if (e) e.stopPropagation();
+    
+    // 原始设置面板切换逻辑
+    originalToggleSettings(e);
+    
+    // 如果历史记录面板是打开的，则关闭它
+    const historyPanel = document.getElementById('historyPanel');
+    if (historyPanel && historyPanel.classList.contains('show')) {
+        historyPanel.classList.remove('show');
+    }
+};
+
+// 点击外部关闭历史面板
+document.addEventListener('DOMContentLoaded', function() {
+    document.addEventListener('click', function(e) {
+        const historyPanel = document.getElementById('historyPanel');
+        const historyButton = document.querySelector('button[onclick="toggleHistory(event)"]');
+        
+        if (historyPanel && historyButton && 
+            !historyPanel.contains(e.target) && 
+            !historyButton.contains(e.target) && 
+            historyPanel.classList.contains('show')) {
+            historyPanel.classList.remove('show');
+        }
+    });
+});

middleware.js

@@ -0,0 +1,48 @@
+import { sha256 } from './js/sha256.js'; // 需新建或引入SHA-256实现
+
+// Vercel Middleware to inject environment variables
+export default async function middleware(request) {
+  // Get the URL from the request
+  const url = new URL(request.url);
+  
+  // Only process HTML pages
+  const isHtmlPage = url.pathname.endsWith('.html') || url.pathname.endsWith('/');
+  if (!isHtmlPage) {
+    return; // Let the request pass through unchanged
+  }
+
+  // Fetch the original response
+  const response = await fetch(request);
+  
+  // Check if it's an HTML response
+  const contentType = response.headers.get('content-type') || '';
+  if (!contentType.includes('text/html')) {
+    return response; // Return the original response if not HTML
+  }
+
+  // Get the HTML content
+  const originalHtml = await response.text();
+  
+  // Replace the placeholder with actual environment variable
+  // If PASSWORD is not set, replace with empty string
+  const password = process.env.PASSWORD || '';
+  let passwordHash = '';
+  if (password) {
+    passwordHash = await sha256(password);
+  }
+  const modifiedHtml = originalHtml.replace(
+    'window.__ENV__.PASSWORD = "{{PASSWORD}}";',
+    `window.__ENV__.PASSWORD = "${passwordHash}"; // SHA-256 hash`
+  );
+  
+  // Create a new response with the modified HTML
+  return new Response(modifiedHtml, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+
+export const config = {
+  matcher: ['/', '/((?!api|_next/static|_vercel|favicon.ico).*)'],
+};

netlify.toml

@@ -0,0 +1,19 @@
+# netlify.toml
+
+[build]
+  # 如果你的项目不需要构建步骤 (纯静态 + functions)，可以省略 publish
+  # publish = "." # 假设你的 HTML/CSS/JS 文件在根目录
+  functions = "netlify/functions" # 指定 Netlify 函数目录
+
+# 配置重写规则，将 /proxy/* 的请求路由到 proxy 函数
+# 这样前端的 PROXY_URL 仍然可以是 '/proxy/'
+[[redirects]]
+  from = "/proxy/*"
+  to = "/.netlify/functions/proxy/:splat" # 将路径参数传递给函数
+  status = 200 # 重要：这是代理，不是重定向
+
+# （可选）为其他静态文件设置缓存头等
+# [[headers]]
+#   for = "/*"
+#   [headers.values]
+#     # Add any global headers here

netlify/functions/proxy.mjs

@@ -0,0 +1,274 @@
+// /netlify/functions/proxy.mjs - Netlify Function (ES Module)
+
+import fetch from 'node-fetch';
+import { URL } from 'url'; // Use Node.js built-in URL
+
+// --- Configuration (Read from Environment Variables) ---
+const DEBUG_ENABLED = process.env.DEBUG === 'true';
+const CACHE_TTL = parseInt(process.env.CACHE_TTL || '86400', 10); // Default 24 hours
+const MAX_RECURSION = parseInt(process.env.MAX_RECURSION || '5', 10); // Default 5 levels
+
+// --- User Agent Handling ---
+let USER_AGENTS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15'
+];
+try {
+    const agentsJsonString = process.env.USER_AGENTS_JSON;
+    if (agentsJsonString) {
+        const parsedAgents = JSON.parse(agentsJsonString);
+        if (Array.isArray(parsedAgents) && parsedAgents.length > 0) {
+            USER_AGENTS = parsedAgents;
+            console.log(`[Proxy Log Netlify] Loaded ${USER_AGENTS.length} user agents from environment variable.`);
+        } else {
+            console.warn("[Proxy Log Netlify] USER_AGENTS_JSON environment variable is not a valid non-empty array, using default.");
+        }
+    } else {
+        console.log("[Proxy Log Netlify] USER_AGENTS_JSON environment variable not set, using default user agents.");
+    }
+} catch (e) {
+    console.error(`[Proxy Log Netlify] Error parsing USER_AGENTS_JSON environment variable: ${e.message}. Using default user agents.`);
+}
+const FILTER_DISCONTINUITY = false; // Ad filtering disabled
+
+// --- Helper Functions (Same as Vercel version, except rewriteUrlToProxy) ---
+
+function logDebug(message) {
+    if (DEBUG_ENABLED) {
+        console.log(`[Proxy Log Netlify] ${message}`);
+    }
+}
+
+function getTargetUrlFromPath(encodedPath) {
+    if (!encodedPath) { logDebug("getTargetUrlFromPath received empty path."); return null; }
+    try {
+        const decodedUrl = decodeURIComponent(encodedPath);
+        if (decodedUrl.match(/^https?:\/\/.+/i)) { return decodedUrl; }
+        else {
+            logDebug(`Invalid decoded URL format: ${decodedUrl}`);
+            if (encodedPath.match(/^https?:\/\/.+/i)) { logDebug(`Warning: Path was not encoded but looks like URL: ${encodedPath}`); return encodedPath; }
+            return null;
+        }
+    } catch (e) { logDebug(`Error decoding target URL: ${encodedPath} - ${e.message}`); return null; }
+}
+
+function getBaseUrl(urlStr) {
+    if (!urlStr) return '';
+    try {
+        const parsedUrl = new URL(urlStr);
+        const pathSegments = parsedUrl.pathname.split('/').filter(Boolean);
+        if (pathSegments.length <= 1) { return `${parsedUrl.origin}/`; }
+        pathSegments.pop(); return `${parsedUrl.origin}/${pathSegments.join('/')}/`;
+    } catch (e) {
+        logDebug(`Getting BaseUrl failed for "${urlStr}": ${e.message}`);
+        const lastSlashIndex = urlStr.lastIndexOf('/');
+        if (lastSlashIndex > urlStr.indexOf('://') + 2) { return urlStr.substring(0, lastSlashIndex + 1); }
+        return urlStr + '/';
+    }
+}
+
+function resolveUrl(baseUrl, relativeUrl) {
+    if (!relativeUrl) return ''; if (relativeUrl.match(/^https?:\/\/.+/i)) { return relativeUrl; } if (!baseUrl) return relativeUrl;
+    try { return new URL(relativeUrl, baseUrl).toString(); }
+    catch (e) {
+        logDebug(`URL resolution failed: base="${baseUrl}", relative="${relativeUrl}". Error: ${e.message}`);
+        if (relativeUrl.startsWith('/')) { try { const baseOrigin = new URL(baseUrl).origin; return `${baseOrigin}${relativeUrl}`; } catch { return relativeUrl; } }
+        else { return `${baseUrl.substring(0, baseUrl.lastIndexOf('/') + 1)}${relativeUrl}`; }
+    }
+}
+
+// ** MODIFIED for Netlify redirect **
+function rewriteUrlToProxy(targetUrl) {
+    if (!targetUrl || typeof targetUrl !== 'string') return '';
+    // Use the path defined in netlify.toml 'from' field
+    return `/proxy/${encodeURIComponent(targetUrl)}`;
+}
+
+function getRandomUserAgent() { return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)]; }
+
+async function fetchContentWithType(targetUrl, requestHeaders) {
+    const headers = {
+        'User-Agent': getRandomUserAgent(),
+        'Accept': requestHeaders['accept'] || '*/*',
+        'Accept-Language': requestHeaders['accept-language'] || 'zh-CN,zh;q=0.9,en;q=0.8',
+        'Referer': requestHeaders['referer'] || new URL(targetUrl).origin,
+    };
+    Object.keys(headers).forEach(key => headers[key] === undefined || headers[key] === null || headers[key] === '' ? delete headers[key] : {});
+    logDebug(`Fetching target: ${targetUrl} with headers: ${JSON.stringify(headers)}`);
+    try {
+        const response = await fetch(targetUrl, { headers, redirect: 'follow' });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => '');
+            logDebug(`Fetch failed: ${response.status} ${response.statusText} - ${targetUrl}`);
+            const err = new Error(`HTTP error ${response.status}: ${response.statusText}. URL: ${targetUrl}. Body: ${errorBody.substring(0, 200)}`);
+            err.status = response.status; throw err;
+        }
+        const content = await response.text();
+        const contentType = response.headers.get('content-type') || '';
+        logDebug(`Fetch success: ${targetUrl}, Content-Type: ${contentType}, Length: ${content.length}`);
+        return { content, contentType, responseHeaders: response.headers };
+    } catch (error) {
+        logDebug(`Fetch exception for ${targetUrl}: ${error.message}`);
+        throw new Error(`Failed to fetch target URL ${targetUrl}: ${error.message}`);
+    }
+}
+
+function isM3u8Content(content, contentType) {
+    if (contentType && (contentType.includes('application/vnd.apple.mpegurl') || contentType.includes('application/x-mpegurl') || contentType.includes('audio/mpegurl'))) { return true; }
+    return content && typeof content === 'string' && content.trim().startsWith('#EXTM3U');
+}
+
+function processKeyLine(line, baseUrl) { return line.replace(/URI="([^"]+)"/, (match, uri) => { const absoluteUri = resolveUrl(baseUrl, uri); logDebug(`Processing KEY URI: Original='${uri}', Absolute='${absoluteUri}'`); return `URI="${rewriteUrlToProxy(absoluteUri)}"`; }); }
+function processMapLine(line, baseUrl) { return line.replace(/URI="([^"]+)"/, (match, uri) => { const absoluteUri = resolveUrl(baseUrl, uri); logDebug(`Processing MAP URI: Original='${uri}', Absolute='${absoluteUri}'`); return `URI="${rewriteUrlToProxy(absoluteUri)}"`; }); }
+function processMediaPlaylist(url, content) {
+    const baseUrl = getBaseUrl(url); if (!baseUrl) { logDebug(`Could not determine base URL for media playlist: ${url}. Cannot process relative paths.`); }
+    const lines = content.split('\n'); const output = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim(); if (!line && i === lines.length - 1) { output.push(line); continue; } if (!line) continue;
+        if (line.startsWith('#EXT-X-KEY')) { output.push(processKeyLine(line, baseUrl)); continue; }
+        if (line.startsWith('#EXT-X-MAP')) { output.push(processMapLine(line, baseUrl)); continue; }
+        if (line.startsWith('#EXTINF')) { output.push(line); continue; }
+        if (!line.startsWith('#')) { const absoluteUrl = resolveUrl(baseUrl, line); logDebug(`Rewriting media segment: Original='${line}', Resolved='${absoluteUrl}'`); output.push(rewriteUrlToProxy(absoluteUrl)); continue; }
+        output.push(line);
+    } return output.join('\n');
+}
+async function processM3u8Content(targetUrl, content, recursionDepth = 0) {
+    if (content.includes('#EXT-X-STREAM-INF') || content.includes('#EXT-X-MEDIA:')) { logDebug(`Detected master playlist: ${targetUrl} (Depth: ${recursionDepth})`); return await processMasterPlaylist(targetUrl, content, recursionDepth); }
+    logDebug(`Detected media playlist: ${targetUrl} (Depth: ${recursionDepth})`); return processMediaPlaylist(targetUrl, content);
+}
+async function processMasterPlaylist(url, content, recursionDepth) {
+    if (recursionDepth > MAX_RECURSION) { throw new Error(`Max recursion depth (${MAX_RECURSION}) exceeded for master playlist: ${url}`); }
+    const baseUrl = getBaseUrl(url); const lines = content.split('\n'); let highestBandwidth = -1; let bestVariantUrl = '';
+    for (let i = 0; i < lines.length; i++) { if (lines[i].startsWith('#EXT-X-STREAM-INF')) { const bandwidthMatch = lines[i].match(/BANDWIDTH=(\d+)/); const currentBandwidth = bandwidthMatch ? parseInt(bandwidthMatch[1], 10) : 0; let variantUriLine = ''; for (let j = i + 1; j < lines.length; j++) { const line = lines[j].trim(); if (line && !line.startsWith('#')) { variantUriLine = line; i = j; break; } } if (variantUriLine && currentBandwidth >= highestBandwidth) { highestBandwidth = currentBandwidth; bestVariantUrl = resolveUrl(baseUrl, variantUriLine); } } }
+    if (!bestVariantUrl) { logDebug(`No BANDWIDTH found, trying first URI in: ${url}`); for (let i = 0; i < lines.length; i++) { const line = lines[i].trim(); if (line && !line.startsWith('#') && line.match(/\.m3u8($|\?.*)/i)) { bestVariantUrl = resolveUrl(baseUrl, line); logDebug(`Fallback: Found first sub-playlist URI: ${bestVariantUrl}`); break; } } }
+    if (!bestVariantUrl) { logDebug(`No valid sub-playlist URI found in master: ${url}. Processing as media playlist.`); return processMediaPlaylist(url, content); }
+    logDebug(`Selected sub-playlist (Bandwidth: ${highestBandwidth}): ${bestVariantUrl}`);
+    const { content: variantContent, contentType: variantContentType } = await fetchContentWithType(bestVariantUrl, {});
+    if (!isM3u8Content(variantContent, variantContentType)) { logDebug(`Fetched sub-playlist ${bestVariantUrl} is not M3U8 (Type: ${variantContentType}). Treating as media playlist.`); return processMediaPlaylist(bestVariantUrl, variantContent); }
+    return await processM3u8Content(bestVariantUrl, variantContent, recursionDepth + 1);
+}
+
+
+// --- Netlify Handler ---
+export const handler = async (event, context) => {
+    console.log('--- Netlify Proxy Request ---');
+    console.log('Time:', new Date().toISOString());
+    console.log('Method:', event.httpMethod);
+    console.log('Path:', event.path);
+    // Note: event.queryStringParameters contains query params if any
+    // Note: event.headers contains incoming headers
+
+    // --- CORS Headers (for all responses) ---
+    const corsHeaders = {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, HEAD, OPTIONS',
+        'Access-Control-Allow-Headers': '*', // Allow all headers client might send
+    };
+
+    // --- Handle OPTIONS Preflight Request ---
+    if (event.httpMethod === 'OPTIONS') {
+        logDebug("Handling OPTIONS request");
+        return {
+            statusCode: 204,
+            headers: {
+                ...corsHeaders,
+                'Access-Control-Max-Age': '86400', // Cache preflight for 24 hours
+            },
+            body: '',
+        };
+    }
+
+    // --- Extract Target URL ---
+    // Based on netlify.toml rewrite: from = "/proxy/*" to = "/.netlify/functions/proxy/:splat"
+    // The :splat part should be available in event.path after the base path
+    let encodedUrlPath = '';
+    const proxyPrefix = '/proxy/'; // Match the 'from' path in netlify.toml
+    if (event.path && event.path.startsWith(proxyPrefix)) {
+        encodedUrlPath = event.path.substring(proxyPrefix.length);
+        logDebug(`Extracted encoded path from event.path: ${encodedUrlPath}`);
+    } else {
+        logDebug(`Could not extract encoded path from event.path: ${event.path}`);
+        // Potentially handle direct calls too? Less likely needed.
+        // const functionPath = '/.netlify/functions/proxy/';
+        // if (event.path && event.path.startsWith(functionPath)) {
+        //     encodedUrlPath = event.path.substring(functionPath.length);
+        // }
+    }
+
+    const targetUrl = getTargetUrlFromPath(encodedUrlPath);
+    logDebug(`Resolved target URL: ${targetUrl || 'null'}`);
+
+    if (!targetUrl) {
+        logDebug('Error: Invalid proxy request path.');
+        return {
+            statusCode: 400,
+            headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ success: false, error: "Invalid proxy request path. Could not extract target URL." }),
+        };
+    }
+
+    logDebug(`Processing proxy request for target: ${targetUrl}`);
+
+    try {
+        // Fetch Original Content (Pass Netlify event headers)
+        const { content, contentType, responseHeaders } = await fetchContentWithType(targetUrl, event.headers);
+
+        // --- Process if M3U8 ---
+        if (isM3u8Content(content, contentType)) {
+            logDebug(`Processing M3U8 content: ${targetUrl}`);
+            const processedM3u8 = await processM3u8Content(targetUrl, content);
+
+            logDebug(`Successfully processed M3U8 for ${targetUrl}`);
+            return {
+                statusCode: 200,
+                headers: {
+                    ...corsHeaders, // Include CORS headers
+                    'Content-Type': 'application/vnd.apple.mpegurl;charset=utf-8',
+                    'Cache-Control': `public, max-age=${CACHE_TTL}`,
+                    // Note: Do NOT include content-encoding or content-length from original response
+                    // as node-fetch likely decompressed it and length changed.
+                },
+                body: processedM3u8, // Netlify expects body as string
+            };
+        } else {
+            // --- Return Original Content (Non-M3U8) ---
+            logDebug(`Returning non-M3U8 content directly: ${targetUrl}, Type: ${contentType}`);
+
+            // Prepare headers for Netlify response object
+            const netlifyHeaders = { ...corsHeaders };
+            responseHeaders.forEach((value, key) => {
+                 const lowerKey = key.toLowerCase();
+                 // Exclude problematic headers and CORS headers (already added)
+                 if (!lowerKey.startsWith('access-control-') &&
+                     lowerKey !== 'content-encoding' &&
+                     lowerKey !== 'content-length') {
+                     netlifyHeaders[key] = value; // Add other original headers
+                 }
+             });
+            netlifyHeaders['Cache-Control'] = `public, max-age=${CACHE_TTL}`; // Set our cache policy
+
+            return {
+                statusCode: 200,
+                headers: netlifyHeaders,
+                body: content, // Body as string
+                // isBase64Encoded: false, // Set true only if returning binary data as base64
+            };
+        }
+
+    } catch (error) {
+        logDebug(`ERROR in proxy processing for ${targetUrl}: ${error.message}`);
+        console.error(`[Proxy Error Stack Netlify] ${error.stack}`); // Log full stack
+
+        const statusCode = error.status || 500; // Get status from error if available
+
+        return {
+            statusCode: statusCode,
+            headers: { ...corsHeaders, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                success: false,
+                error: `Proxy processing error: ${error.message}`,
+                targetUrl: targetUrl
+            }),
+        };
+    }
+};

nginx.conf

@@ -0,0 +1,86 @@
+server {
+    listen       80;
+    server_name  localhost;
+
+    #access_log  /var/log/nginx/host.access.log  main;
+
+    resolver 114.114.114.114 8.8.8.8 valid=300s;
+    resolver_timeout 5s;
+
+    # 创建代理路由
+    location /proxy/ {
+        # 设置CORS头部
+        add_header 'Access-Control-Allow-Origin' '*';
+        add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
+        add_header 'Access-Control-Allow-Headers' 'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range';
+        add_header 'Access-Control-Expose-Headers' 'Content-Length,Content-Range';
+
+        # OPTIONS请求处理
+        if ($request_method = 'OPTIONS') {
+            add_header 'Access-Control-Max-Age' 1728000;
+            add_header 'Content-Type' 'text/plain charset=UTF-8';
+            add_header 'Content-Length' 0;
+            return 204;
+        }
+
+        set $target_url '';
+
+        # 执行Lua脚本解析URL
+        rewrite_by_lua_file /usr/share/nginx/html/proxy.lua;
+
+        proxy_ssl_server_name on;
+        proxy_ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
+
+        # 设置代理头信息
+        # 不设置Host，让Nginx自动根据目标URL设置
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        # 处理可能的重定向
+        proxy_redirect off;
+        proxy_buffering off;
+        # 代理超时设置
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 60s;
+
+        proxy_pass $target_url;
+    }
+
+    location / {
+        root   /usr/share/nginx/html;
+        index  index.html index.htm;
+    }
+
+    #error_page  404              /404.html;
+
+    # redirect server error pages to the static page /50x.html
+    #
+    error_page   500 502 503 504  /50x.html;
+    location = /50x.html {
+        root   /usr/share/nginx/html;
+    }
+
+    # proxy the PHP scripts to Apache listening on 127.0.0.1:80
+    #
+    #location ~ \.php$ {
+    #    proxy_pass   http://127.0.0.1;
+    #}
+
+    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
+    #
+    #location ~ \.php$ {
+    #    root           html;
+    #    fastcgi_pass   127.0.0.1:9000;
+    #    fastcgi_index  index.php;
+    #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
+    #    include        fastcgi_params;
+    #}
+
+    # deny access to .htaccess files, if Apache's document root
+    # concurs with nginx's one
+    #
+    #location ~ /\.ht {
+    #    deny  all;
+    #}
+}

package-lock.json

@@ -0,0 +1,106 @@
+{
+  "name": "libretv",
+  "version": "1.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "libretv",
+      "version": "1.1.0",
+      "license": "MIT",
+      "dependencies": {
+        "node-fetch": "^3.3.2"
+      }
+    },
+    "node_modules/data-uri-to-buffer": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/fetch-blob": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "paypal",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "node-domexception": "^1.0.0",
+        "web-streams-polyfill": "^3.0.3"
+      },
+      "engines": {
+        "node": "^12.20 || >= 14.13"
+      }
+    },
+    "node_modules/formdata-polyfill": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+      "license": "MIT",
+      "dependencies": {
+        "fetch-blob": "^3.1.2"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
+      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+      "license": "MIT",
+      "dependencies": {
+        "data-uri-to-buffer": "^4.0.0",
+        "fetch-blob": "^3.1.4",
+        "formdata-polyfill": "^4.0.10"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-fetch"
+      }
+    },
+    "node_modules/web-streams-polyfill": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
+      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,15 @@
+{
+  "name": "libretv",
+  "version": "1.1.0",
+  "description": "免费在线视频搜索与观看平台",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "node-fetch": "^3.3.2"
+  },
+  "author": "bestZwei",
+  "license": "MIT"
+}

player.html

@@ -0,0 +1,1403 @@
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>LibreTV 播放器</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link rel="stylesheet" href="css/styles.css">
+    <style>
+        body, html {
+            margin: 0;
+            padding: 0;
+            width: 100%;
+            height: 100%;
+            background-color: #0f1622;
+            color: white;
+        }
+        .player-container {
+            width: 100%;
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        #player {
+            width: 100%;
+            height: 60vh; /* 视频播放器高度 */
+        }
+        .loading-container {
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background-color: rgba(0, 0, 0, 0.7);
+            color: white;
+            z-index: 100;
+            flex-direction: column;
+        }
+        .loading-spinner {
+            width: 50px;
+            height: 50px;
+            border: 4px solid rgba(255, 255, 255, 0.3);
+            border-radius: 50%;
+            border-top-color: white;
+            animation: spin 1s ease-in-out infinite;
+            margin-bottom: 10px;
+        }
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        .error-container {
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            display: none;
+            align-items: center;
+            justify-content: center;
+            background-color: rgba(0, 0, 0, 0.7);
+            color: white;
+            z-index: 100;
+            flex-direction: column;
+            text-align: center;
+            padding: 1rem;
+        }
+        .error-icon {
+            font-size: 48px;
+            margin-bottom: 10px;
+        }
+        .episode-active {
+            background-color: #3b82f6 !important;
+            border-color: #60a5fa !important;
+        }
+        .episode-grid {
+            max-height: 30vh;
+            overflow-y: auto;
+            padding: 1rem 0;
+        }
+        .switch {
+            position: relative;
+            display: inline-block;
+            width: 46px;
+            height: 24px;
+        }
+        .switch input {
+            opacity: 0;
+            width: 0;
+            height: 0;
+        }
+        .slider {
+            position: absolute;
+            cursor: pointer;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background-color: #333;
+            transition: .4s;
+            border-radius: 24px;
+        }
+        .slider:before {
+            position: absolute;
+            content: "";
+            height: 18px;
+            width: 18px;
+            left: 3px;
+            bottom: 3px;
+            background-color: white;
+            transition: .4s;
+            border-radius: 50%;
+        }
+        input:checked + .slider {
+            background-color: #00ccff;
+        }
+        input:checked + .slider:before {
+            transform: translateX(22px);
+        }
+        /* 添加快捷键提示样式 */
+        .shortcut-hint {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background-color: rgba(0, 0, 0, 0.8);
+            color: white;
+            padding: 1rem 2rem;
+            border-radius: 0.5rem;
+            font-size: 1.5rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            z-index: 1000;
+            opacity: 0;
+            transition: opacity 0.3s ease;
+        }
+        .shortcut-hint.show {
+            opacity: 1;
+        }
+
+        /* 原生全屏时，播放器容器铺满 */
+        .player-container:-webkit-full-screen,
+        .player-container:fullscreen {
+            position: fixed;
+            top: 0; left: 0;
+            width: 100vw; height: 100vh;
+            z-index: 10000;
+            background-color: #000;
+        }
+        .player-container:-webkit-full-screen #player,
+        .player-container:fullscreen #player {
+            width: 100%; height: 100%;
+        }
+    </style>
+</head>
+<body>
+    <header class="bg-[#111] p-4 flex justify-between items-center border-b border-[#333]">
+        <div class="flex items-center">
+            <a href="index.html" class="flex items-center">
+                <svg class="w-8 h-8 mr-2 text-[#00ccff]" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 10l4.553-2.276A1 1 0 0121 8.618v6.764a1 1 0 01-1.447.894L15 14M5 18h8a2 2 0 002-2V8a2 2 0 00-2-2H5a2 2 0 00-2 2v8a2 2 0 002 2z"></path>
+                </svg>
+                <h1 class="text-xl font-bold gradient-text">LibreTV</h1>
+            </a>
+        </div>
+        <h2 id="videoTitle" class="text-xl font-semibold truncate flex-1 text-center"></h2>
+        <a href="index.html" class="px-4 py-2 bg-[#222] hover:bg-[#333] border border-[#333] rounded-lg transition-colors">
+            返回首页
+        </a>
+    </header>
+
+    <main class="container mx-auto px-4 py-4">
+        <!-- 视频播放区 -->
+        <div id="playerContainer" class="player-container">
+            <div class="relative">
+                <div id="player"></div>
+                <div class="loading-container" id="loading">
+                    <div class="loading-spinner"></div>
+                    <div>正在加载视频...</div>
+                </div>
+                <div class="error-container" id="error">
+                    <div class="error-icon">⚠️</div>
+                    <div id="error-message">视频加载失败</div>
+                    <div style="margin-top: 10px; font-size: 14px; color: #aaa;">请尝试其他视频源或稍后重试</div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 集数导航 -->
+        <div class="player-container">
+            <div class="flex justify-between items-center my-4">
+                <button onclick="playPreviousEpisode()" id="prevButton" class="px-4 py-2 bg-[#222] hover:bg-[#333] border border-[#333] rounded-lg transition-colors">
+                    <svg class="w-5 h-5 inline-block" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7"></path>
+                    </svg>
+                    上一集
+                </button>
+                <span class="text-gray-400" id="episodeInfo">加载中...</span>
+                <button onclick="playNextEpisode()" id="nextButton" class="px-4 py-2 bg-[#222] hover:bg-[#333] border border-[#333] rounded-lg transition-colors">
+                    下一集
+                    <svg class="w-5 h-5 inline-block" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"></path>
+                    </svg>
+                </button>
+            </div>
+        </div>
+
+        <!-- 添加自动播放开关和排序按钮 -->
+        <div class="player-container">
+            <div class="flex justify-end items-center mb-4 gap-2">
+                <span class="text-gray-400 text-sm">自动连播</span>
+                <label class="switch">
+                    <input type="checkbox" id="autoplayToggle">
+                    <span class="slider"></span>
+                </label>
+                <button onclick="toggleEpisodeOrder()" class="ml-4 px-4 py-2 bg-gradient-to-r from-indigo-500 via-purple-500 to-pink-500 text-white font-semibold rounded-full shadow-lg hover:shadow-xl transition-all duration-300 flex items-center justify-center space-x-2">
+                    <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5" id="orderIcon" viewBox="0 0 20 20" fill="currentColor">
+                        <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm1-11a1 1 0 10-2 0v3.586L7.707 9.293a1 1 0 00-1.414 1.414l3 3a1 1 0 001.414 0l3-3a1 1 0 00-1.414-1.414L11 10.586V7z" clip-rule="evenodd" />
+                    </svg>
+                    <span id="orderText">倒序排列</span>
+                </button>
+                <button id="lockToggle" onclick="toggleControlsLock()" title="锁定控制" 
+                        class="px-2 py-1 bg-[#333] hover:bg-[#444] text-white rounded-full transition">
+                    <svg id="lockIcon" class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <!-- 默认状态：未锁图标 -->
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                              d="M15 11V7a3 3 0 00-6 0v4m-3 4h12v6H6v-6z" />
+                    </svg>
+                </button>
+            </div>
+        </div>
+
+        <!-- 集数网格 -->
+        <div class="player-container">
+            <div class="episode-grid" id="episodesGrid">
+                <div class="grid grid-cols-2 sm:grid-cols-4 md:grid-cols-6 lg:grid-cols-8 gap-2" id="episodesList">
+                    <!-- 集数将在这里动态加载 -->
+                    <div class="col-span-full text-center text-gray-400 py-8">加载中...</div>
+                </div>
+            </div>
+        </div>
+    </main>
+
+    <!-- 添加快捷键提示元素 -->
+    <div class="shortcut-hint" id="shortcutHint">
+        <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24" id="shortcutIcon">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7"></path>
+        </svg>
+        <span id="shortcutText"></span>
+    </div>
+
+    <script src="https://s4.zstatic.net/ajax/libs/hls.js/1.5.6/hls.min.js" integrity="sha256-X1GmLMzVcTBRiGjEau+gxGpjRK96atNczcLBg5w6hKA=" crossorigin="anonymous"></script>
+    <script src="https://s4.zstatic.net/ajax/libs/dplayer/1.26.0/DPlayer.min.js" integrity="sha256-OJg03lDZP0NAcl3waC9OT5jEa8XZ8SM2n081Ik953o4=" crossorigin="anonymous"></script>
+    <script src="js/config.js"></script>
+    <script>
+        // 全局变量
+        let currentVideoTitle = '';
+        let currentEpisodeIndex = 0;
+        let currentEpisodes = [];
+        let episodesReversed = false;
+        let dp = null;
+        let currentHls = null; // 跟踪当前HLS实例
+        let autoplayEnabled = true; // 默认开启自动连播
+        let isUserSeeking = false; // 跟踪用户是否正在拖动进度条
+        let videoHasEnded = false; // 跟踪视频是否已经自然结束
+        let userClickedPosition = null; // 记录用户点击的位置
+        let shortcutHintTimeout = null; // 用于控制快捷键提示显示时间
+        let adFilteringEnabled = true; // 默认开启广告过滤
+        let progressSaveInterval = null; // 定期保存进度的计时器
+
+        // 页面加载
+        document.addEventListener('DOMContentLoaded', function() {
+            // 解析URL参数
+            const urlParams = new URLSearchParams(window.location.search);
+            const videoUrl = urlParams.get('url');
+            const title = urlParams.get('title');
+            let index = parseInt(urlParams.get('index') || '0');
+            const episodesList = urlParams.get('episodes'); // 新增：从URL获取集数信息
+
+            // 从localStorage获取数据
+            currentVideoTitle = title || localStorage.getItem('currentVideoTitle') || '未知视频';
+            currentEpisodeIndex = index;
+            
+            // 设置自动连播开关状态
+            autoplayEnabled = localStorage.getItem('autoplayEnabled') !== 'false'; // 默认为true
+            document.getElementById('autoplayToggle').checked = autoplayEnabled;
+            
+            // 获取广告过滤设置
+            adFilteringEnabled = localStorage.getItem(PLAYER_CONFIG.adFilteringStorage) !== 'false'; // 默认为true
+            
+            // 监听自动连播开关变化
+            document.getElementById('autoplayToggle').addEventListener('change', function(e) {
+                autoplayEnabled = e.target.checked;
+                localStorage.setItem('autoplayEnabled', autoplayEnabled);
+            });
+            
+            // 优先使用URL传递的集数信息，否则从localStorage获取
+            try {
+                if (episodesList) {
+                    // 如果URL中有集数数据，优先使用它
+                    currentEpisodes = JSON.parse(decodeURIComponent(episodesList));
+                    console.log('从URL恢复集数信息:', currentEpisodes.length);
+                } else {
+                    // 否则从localStorage获取
+                    currentEpisodes = JSON.parse(localStorage.getItem('currentEpisodes') || '[]');
+                    console.log('从localStorage恢复集数信息:', currentEpisodes.length);
+                }
+                
+                // 检查集数索引是否有效，如果无效则调整为0
+                if (index < 0 || (currentEpisodes.length > 0 && index >= currentEpisodes.length)) {
+                    console.warn(`无效的剧集索引 ${index}，调整为范围内的值`);
+                    
+                    // 如果索引太大，则使用最大有效索引
+                    if (index >= currentEpisodes.length && currentEpisodes.length > 0) {
+                        index = currentEpisodes.length - 1;
+                    } else {
+                        index = 0;
+                    }
+                    
+                    // 更新URL以反映修正后的索引
+                    const newUrl = new URL(window.location.href);
+                    newUrl.searchParams.set('index', index);
+                    window.history.replaceState({}, '', newUrl);
+                }
+                
+                // 更新当前索引为验证过的值
+                currentEpisodeIndex = index;
+                
+                episodesReversed = localStorage.getItem('episodesReversed') === 'true';
+            } catch (e) {
+                console.error('获取集数信息失败:', e);
+                currentEpisodes = [];
+                currentEpisodeIndex = 0;
+                episodesReversed = false;
+            }
+
+            // 设置页面标题
+            document.title = currentVideoTitle + ' - LibreTV播放器';
+            document.getElementById('videoTitle').textContent = currentVideoTitle;
+            
+            // 初始化播放器
+            if (videoUrl) {
+                initPlayer(videoUrl);
+                
+                // 尝试从URL参数中恢复播放位置
+                const position = urlParams.get('position');
+                if (position) {
+                    setTimeout(() => {
+                        if (dp && dp.video) {
+                            const positionNum = parseInt(position);
+                            if (!isNaN(positionNum) && positionNum > 0) {
+                                dp.seek(positionNum);
+                                showPositionRestoreHint(positionNum);
+                            }
+                        }
+                    }, 1500);
+                }
+            } else {
+                showError('无效的视频链接');
+            }
+
+            // 更新集数信息
+            updateEpisodeInfo();
+            
+            // 渲染集数列表
+            renderEpisodes();
+            
+            // 更新按钮状态
+            updateButtonStates();
+            
+            // 更新排序按钮状态
+            updateOrderButton();
+
+            // 添加对进度条的监听，确保点击准确跳转
+            setTimeout(() => {
+                setupProgressBarPreciseClicks();
+            }, 1000);
+
+            // 添加键盘快捷键事件监听
+            document.addEventListener('keydown', handleKeyboardShortcuts);
+
+            // 添加页面离开事件监听，保存播放位置
+            window.addEventListener('beforeunload', saveCurrentProgress);
+
+            // 新增：页面隐藏（切后台/切标签）时也保存
+            document.addEventListener('visibilitychange', function() {
+                if (document.visibilityState === 'hidden') {
+                    saveCurrentProgress();
+                }
+            });
+
+            // 新增：视频暂停时也保存
+            // 需确保 dp.video 已初始化
+            const waitForVideo = setInterval(() => {
+                if (dp && dp.video) {
+                    dp.video.addEventListener('pause', saveCurrentProgress);
+
+                    // 新增：播放进度变化时节流保存
+                    let lastSave = 0;
+                    dp.video.addEventListener('timeupdate', function() {
+                        const now = Date.now();
+                        if (now - lastSave > 5000) { // 每5秒最多保存一次
+                            saveCurrentProgress();
+                            lastSave = now;
+                        }
+                    });
+
+                    clearInterval(waitForVideo);
+                }
+            }, 200);
+        });
+
+        // 处理键盘快捷键
+        function handleKeyboardShortcuts(e) {
+            // 忽略输入框中的按键事件
+            if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') return;
+
+            // Alt + 左箭头 = 上一集
+            if (e.altKey && e.key === 'ArrowLeft') {
+                if (currentEpisodeIndex > 0) {
+                    playPreviousEpisode();
+                    showShortcutHint('上一集', 'left');
+                    e.preventDefault();
+                }
+            }
+            
+            // Alt + 右箭头 = 下一集
+            if (e.altKey && e.key === 'ArrowRight') {
+                if (currentEpisodeIndex < currentEpisodes.length - 1) {
+                    playNextEpisode();
+                    showShortcutHint('下一集', 'right');
+                    e.preventDefault();
+                }
+            }
+        }
+
+        // 显示快捷键提示
+        function showShortcutHint(text, direction) {
+            const hintElement = document.getElementById('shortcutHint');
+            const textElement = document.getElementById('shortcutText');
+            const iconElement = document.getElementById('shortcutIcon');
+            
+            // 清除之前的超时
+            if (shortcutHintTimeout) {
+                clearTimeout(shortcutHintTimeout);
+            }
+            
+            // 设置文本和图标方向
+            textElement.textContent = text;
+            
+            if (direction === 'left') {
+                iconElement.innerHTML = '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7"></path>';
+            } else {
+                iconElement.innerHTML = '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"></path>';
+            }
+            
+            // 显示提示
+            hintElement.classList.add('show');
+            
+            // 两秒后隐藏
+            shortcutHintTimeout = setTimeout(() => {
+                hintElement.classList.remove('show');
+            }, 2000);
+        }
+
+        // 初始化播放器
+        function initPlayer(videoUrl) {
+            if (!videoUrl) return;
+
+            // 配置HLS.js选项
+            const hlsConfig = {
+                debug: false,
+                loader: adFilteringEnabled ? CustomHlsJsLoader : Hls.DefaultConfig.loader,
+                enableWorker: true,
+                lowLatencyMode: false,
+                backBufferLength: 90,
+                maxBufferLength: 30,
+                maxMaxBufferLength: 60,
+                maxBufferSize: 30 * 1000 * 1000,
+                maxBufferHole: 0.5,
+                fragLoadingMaxRetry: 6,
+                fragLoadingMaxRetryTimeout: 64000,
+                fragLoadingRetryDelay: 1000,
+                manifestLoadingMaxRetry: 3,
+                manifestLoadingRetryDelay: 1000,
+                levelLoadingMaxRetry: 4,
+                levelLoadingRetryDelay: 1000,
+                startLevel: -1,
+                abrEwmaDefaultEstimate: 500000,
+                abrBandWidthFactor: 0.95,
+                abrBandWidthUpFactor: 0.7,
+                abrMaxWithRealBitrate: true,
+                stretchShortVideoTrack: true,
+                appendErrorMaxRetry: 5,  // 增加尝试次数
+                liveSyncDurationCount: 3,
+                liveDurationInfinity: false
+            };
+            
+            // 创建DPlayer实例
+            dp = new DPlayer({
+                container: document.getElementById('player'),
+                autoplay: true,
+                theme: '#00ccff',
+                preload: 'auto',
+                loop: false,
+                lang: 'zh-cn',
+                hotkey: true,        // 启用键盘控制，包括空格暂停/播放、方向键控制进度和音量
+                mutex: true,
+                volume: 0.7,
+                screenshot: true,                // 启用截图功能
+                preventClickToggle: false,       // 允许点击视频切换播放/暂停
+                airplay: true,                   // 在Safari中启用AirPlay功能
+                chromecast: true,                // 启用Chromecast投屏功能
+                contextmenu: [                   // 自定义右键菜单
+                    {
+                        text: '关于 LibreTV',
+                        link: 'https://github.com/bestzwei/LibreTV'
+                    },
+                    {
+                        text: '问题反馈',
+                        click: (player) => {
+                            window.open('https://github.com/bestzwei/LibreTV/issues', '_blank');
+                        }
+                    }
+                ],
+                video: {
+                    url: videoUrl,
+                    type: 'hls',
+                    pic: 'https://img.picgo.net/2025/04/12/image362e7d38b4af4a74.png', // 设置视频封面图
+                    customType: {
+                        hls: function(video, player) {
+                            // 清理之前的HLS实例
+                            if (currentHls && currentHls.destroy) {
+                                try {
+                                    currentHls.destroy();
+                                } catch (e) {
+                                    console.warn('销毁旧HLS实例出错:', e);
+                                }
+                            }
+                            
+                            // 创建新的HLS实例
+                            const hls = new Hls(hlsConfig);
+                            currentHls = hls;
+                            
+                            // 跟踪是否已经显示错误
+                            let errorDisplayed = false;
+                            // 跟踪是否有错误发生
+                            let errorCount = 0;
+                            // 跟踪视频是否开始播放
+                            let playbackStarted = false;
+                            // 跟踪视频是否出现bufferAppendError
+                            let bufferAppendErrorCount = 0;
+                            
+                            // 监听视频播放事件
+                            video.addEventListener('playing', function() {
+                                playbackStarted = true;
+                                document.getElementById('loading').style.display = 'none';
+                                document.getElementById('error').style.display = 'none';
+                            });
+                            
+                            // 监听视频进度事件
+                            video.addEventListener('timeupdate', function() {
+                                if (video.currentTime > 1) {
+                                    // 视频进度超过1秒，隐藏错误（如果存在）
+                                    document.getElementById('error').style.display = 'none';
+                                }
+                            });
+                            
+                            hls.loadSource(video.src);
+                            hls.attachMedia(video);
+                            
+                            hls.on(Hls.Events.MANIFEST_PARSED, function() {
+                                video.play().catch(e => {
+                                    console.warn('自动播放被阻止:', e);
+                                });
+                            });
+                            
+                            hls.on(Hls.Events.ERROR, function(event, data) {
+                                console.log('HLS事件:', event, '数据:', data);
+                                
+                                // 增加错误计数
+                                errorCount++;
+                                
+                                // 处理bufferAppendError
+                                if (data.details === 'bufferAppendError') {
+                                    bufferAppendErrorCount++;
+                                    console.warn(`bufferAppendError 发生 ${bufferAppendErrorCount} 次`);
+                                    
+                                    // 如果视频已经开始播放，则忽略这个错误
+                                    if (playbackStarted) {
+                                        console.log('视频已在播放中，忽略bufferAppendError');
+                                        return;
+                                    }
+                                    
+                                    // 如果出现多次bufferAppendError但视频未播放，尝试恢复
+                                    if (bufferAppendErrorCount >= 3) {
+                                        hls.recoverMediaError();
+                                    }
+                                }
+                                
+                                // 如果是致命错误，且视频未播放
+                                if (data.fatal && !playbackStarted) {
+                                    console.error('致命HLS错误:', data);
+                                    
+                                    // 尝试恢复错误
+                                    switch(data.type) {
+                                        case Hls.ErrorTypes.NETWORK_ERROR:
+                                            console.log("尝试恢复网络错误");
+                                            hls.startLoad();
+                                            break;
+                                        case Hls.ErrorTypes.MEDIA_ERROR:
+                                            console.log("尝试恢复媒体错误");
+                                            hls.recoverMediaError();
+                                            break;
+                                        default:
+                                            // 仅在多次恢复尝试后显示错误
+                                            if (errorCount > 3 && !errorDisplayed) {
+                                                errorDisplayed = true;
+                                                showError('视频加载失败，可能是格式不兼容或源不可用');
+                                            }
+                                            break;
+                                    }
+                                }
+                            });
+                            
+                            // 监听分段加载事件
+                            hls.on(Hls.Events.FRAG_LOADED, function() {
+                                document.getElementById('loading').style.display = 'none';
+                            });
+                            
+                            // 监听级别加载事件
+                            hls.on(Hls.Events.LEVEL_LOADED, function() {
+                                document.getElementById('loading').style.display = 'none';
+                            });
+
+                            // --- 体验加强版：黑屏快进跳广告 ---
+                            let tmp_time_add = 0.1;
+                            const tmp_max_buffer_length = hls.config.maxBufferLength;
+                            hls.on(Hls.Events.FRAG_PARSED, (event, data) => {
+                                if (data.frag.endList) {
+                                    const cur = hls.media.currentTime;
+                                    const dur = hls.media.duration || 0;
+                                    if (cur < dur) {
+                                        data.frag.endList = undefined;
+                                        // 根据 tmp_time_add 调整 buffer 长度
+                                        hls.config.maxBufferLength = tmp_time_add < 1
+                                            ? 2
+                                            : tmp_max_buffer_length;
+                                        // 重新加载并跳转
+                                        hls.loadSource(video.src);
+                                        hls.attachMedia(video);
+                                        hls.media.currentTime = cur + tmp_time_add;
+                                        // 切换下次跳转时长：0.1 ↔ 5
+                                        tmp_time_add = tmp_time_add < 1 ? 5 : 0.1;
+                                        player.video.play().catch(() => {});
+                                    } else {
+                                        player.video.pause();
+                                    }
+                                }
+                            });
+                        }
+                    }
+                }
+            });
+            // 全屏模式下锁定横屏
+            dp.on('fullscreen', () => {
+                if (window.screen.orientation && window.screen.orientation.lock) {
+                    window.screen.orientation.lock('landscape')
+                    .then(() => {
+                        console.log('屏幕已锁定为横向模式');
+                    })
+                    .catch((error) => {
+                        console.warn('无法锁定屏幕方向，请手动旋转设备:', error);
+                    });
+                } else {
+                    console.warn('当前浏览器不支持锁定屏幕方向，请手动旋转设备。');
+                }
+            });
+            
+            // 全屏取消时解锁屏幕方向
+            dp.on('fullscreen_cancel', () => {
+                if (window.screen.orientation && window.screen.orientation.unlock) {
+                    window.screen.orientation.unlock();
+                }
+            });
+            
+            dp.on('loadedmetadata', function() {
+                document.getElementById('loading').style.display = 'none';
+                videoHasEnded = false; // 视频加载时重置结束标志
+                
+                // 视频加载完成后重新设置进度条点击监听
+                setupProgressBarPreciseClicks();
+                
+                // 视频加载成功后，在稍微延迟后将其添加到观看历史
+                setTimeout(saveToHistory, 3000);
+                
+                // 启动定期保存播放进度
+                startProgressSaveInterval();
+            });
+
+            dp.on('error', function() {
+                // 检查视频是否已经在播放
+                if (dp.video && dp.video.currentTime > 1) {
+                    console.log('发生错误，但视频已在播放中，忽略');
+                    return;
+                }
+                showError('视频播放失败，请检查视频源或网络连接');
+            });
+            
+            // 添加seeking和seeked事件监听器，以检测用户是否在拖动进度条
+            dp.on('seeking', function() {
+                isUserSeeking = true;
+                videoHasEnded = false; // 重置视频结束标志
+                
+                // 如果是用户通过点击进度条设置的位置，确保准确跳转
+                if (userClickedPosition !== null && dp.video) {
+                    // 确保用户的点击位置被正确应用，避免自动跳至视频末尾
+                    const clickedTime = userClickedPosition;
+                    
+                    // 防止跳转到视频结尾
+                    if (Math.abs(dp.video.duration - clickedTime) < 0.5) {
+                        // 如果点击的位置非常接近结尾，稍微减少一点时间
+                        dp.video.currentTime = Math.max(0, clickedTime - 0.5);
+                    } else {
+                        dp.video.currentTime = clickedTime;
+                    }
+                    
+                    // 清除记录的位置
+                    setTimeout(() => {
+                        userClickedPosition = null;
+                    }, 200);
+                }
+            });
+            
+            // 改进seeked事件处理
+            dp.on('seeked', function() {
+                // 如果视频跳转到了非常接近结尾的位置(小于0.3秒)，且不是自然播放到此处
+                if (dp.video && dp.video.duration > 0) {
+                    const timeFromEnd = dp.video.duration - dp.video.currentTime;
+                    if (timeFromEnd < 0.3 && isUserSeeking) {
+                        // 将播放时间往回移动一点点，避免触发结束事件
+                        dp.video.currentTime = Math.max(0, dp.video.currentTime - 1);
+                    }
+                }
+                
+                // 延迟重置seeking标志，以便于区分自然播放结束和用户拖拽
+                setTimeout(() => {
+                    isUserSeeking = false;
+                }, 200);
+            });
+            
+            // 修改视频结束事件监听器，添加额外检查
+            dp.on('ended', function() {
+                videoHasEnded = true; // 标记视频已自然结束
+                
+                // 视频已播放完，清除播放进度记录
+                clearVideoProgress();
+                
+                // 如果启用了自动连播，并且有下一集可播放，则自动播放下一集
+                if (autoplayEnabled && currentEpisodeIndex < currentEpisodes.length - 1) {
+                    console.log('视频播放结束，自动播放下一集');
+                    // 稍长延迟以确保所有事件处理完成
+                    setTimeout(() => {
+                        // 确认不是因为用户拖拽导致的假结束事件
+                        if (videoHasEnded && !isUserSeeking) {
+                            playNextEpisode();
+                            videoHasEnded = false; // 重置标志
+                        }
+                    }, 1000);
+                } else {
+                    console.log('视频播放结束，无下一集或未启用自动连播');
+                }
+            });
+            
+            // 添加事件监听以检测近视频末尾的点击拖动
+            dp.on('timeupdate', function() {
+                if (dp.video && dp.duration > 0) {
+                    // 如果视频接近结尾但不是自然播放到结尾，重置自然结束标志
+                    if (isUserSeeking && dp.video.currentTime > dp.video.duration * 0.95) {
+                        videoHasEnded = false;
+                    }
+                }
+            });
+            
+            // 10秒后如果仍在加载，但不立即显示错误
+            setTimeout(function() {
+                // 如果视频已经播放开始，则不显示错误
+                if (dp && dp.video && dp.video.currentTime > 0) {
+                    return;
+                }
+                
+                if (document.getElementById('loading').style.display !== 'none') {
+                    document.getElementById('loading').innerHTML = `
+                        <div class="loading-spinner"></div>
+                        <div>视频加载时间较长，请耐心等待...</div>
+                        <div style="font-size: 12px; color: #aaa; margin-top: 10px;">如长时间无响应，请尝试其他视频源</div>
+                    `;
+                }
+            }, 10000);
+
+            // 绑定原生全屏：DPlayer 触发全屏时调用 requestFullscreen
+            (function(){
+                const fsContainer = document.getElementById('playerContainer');
+                dp.on('fullscreen', () => {
+                    if (fsContainer.requestFullscreen) {
+                        fsContainer.requestFullscreen().catch(err => console.warn('原生全屏失败:', err));
+                    }
+                });
+                dp.on('fullscreen_cancel', () => {
+                    if (document.fullscreenElement) {
+                        document.exitFullscreen();
+                    }
+                });
+            })();
+        }
+
+        // 自定义M3U8 Loader用于过滤广告
+        class CustomHlsJsLoader extends Hls.DefaultConfig.loader {
+            constructor(config) {
+                super(config);
+                const load = this.load.bind(this);
+                this.load = function(context, config, callbacks) {
+                    // 拦截manifest和level请求
+                    if (context.type === 'manifest' || context.type === 'level') {
+                        const onSuccess = callbacks.onSuccess;
+                        callbacks.onSuccess = function(response, stats, context) {
+                            // 如果是m3u8文件，处理内容以移除广告分段
+                            if (response.data && typeof response.data === 'string') {
+                                // 过滤掉广告段 - 实现更精确的广告过滤逻辑
+                                response.data = filterAdsFromM3U8(response.data, true);
+                            }
+                            return onSuccess(response, stats, context);
+                        };
+                    }
+                    // 执行原始load方法
+                    load(context, config, callbacks);
+                };
+            }
+        }
+
+        // M3U8清单广告过滤函数
+        function filterAdsFromM3U8(m3u8Content, strictMode = false) {
+            if (!m3u8Content) return '';
+            
+            // 按行分割M3U8内容
+            const lines = m3u8Content.split('\n');
+            const filteredLines = [];
+            
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                
+                // 只过滤#EXT-X-DISCONTINUITY标识
+                if (!line.includes('#EXT-X-DISCONTINUITY')) {
+                    filteredLines.push(line);
+                }
+            }
+            
+            return filteredLines.join('\n');
+        }
+
+        // 显示错误
+        function showError(message) {
+            // 在视频已经播放的情况下不显示错误
+            if (dp && dp.video && dp.video.currentTime > 1) {
+                console.log('忽略错误:', message);
+                return;
+            }
+            
+            document.getElementById('loading').style.display = 'none';
+            document.getElementById('error').style.display = 'flex';
+            document.getElementById('error-message').textContent = message;
+        }
+
+        // 更新集数信息
+        function updateEpisodeInfo() {
+            if (currentEpisodes.length > 0) {
+                document.getElementById('episodeInfo').textContent = `第 ${currentEpisodeIndex + 1}/${currentEpisodes.length} 集`;
+            } else {
+                document.getElementById('episodeInfo').textContent = '无集数信息';
+            }
+        }
+
+        // 更新按钮状态
+        function updateButtonStates() {
+            const prevButton = document.getElementById('prevButton');
+            const nextButton = document.getElementById('nextButton');
+            
+            // 处理上一集按钮
+            if (currentEpisodeIndex > 0) {
+                prevButton.classList.remove('bg-gray-700', 'cursor-not-allowed');
+                prevButton.classList.add('bg-[#222]', 'hover:bg-[#333]');
+                prevButton.removeAttribute('disabled');
+            } else {
+                prevButton.classList.add('bg-gray-700', 'cursor-not-allowed');
+                prevButton.classList.remove('bg-[#222]', 'hover:bg-[#333]');
+                prevButton.setAttribute('disabled', '');
+            }
+            
+            // 处理下一集按钮
+            if (currentEpisodeIndex < currentEpisodes.length - 1) {
+                nextButton.classList.remove('bg-gray-700', 'cursor-not-allowed');
+                nextButton.classList.add('bg-[#222]', 'hover:bg-[#333]');
+                nextButton.removeAttribute('disabled');
+            } else {
+                nextButton.classList.add('bg-gray-700', 'cursor-not-allowed');
+                nextButton.classList.remove('bg-[#222]', 'hover:bg-[#333]');
+                nextButton.setAttribute('disabled', '');
+            }
+        }
+
+        // 渲染集数按钮
+        function renderEpisodes() {
+            const episodesList = document.getElementById('episodesList');
+            if (!episodesList) return;
+            
+            if (!currentEpisodes || currentEpisodes.length === 0) {
+                episodesList.innerHTML = '<div class="col-span-full text-center text-gray-400 py-8">没有可用的集数</div>';
+                return;
+            }
+            
+            const episodes = episodesReversed ? [...currentEpisodes].reverse() : currentEpisodes;
+            let html = '';
+            
+            episodes.forEach((episode, index) => {
+                // 根据倒序状态计算真实的剧集索引
+                const realIndex = episodesReversed ? currentEpisodes.length - 1 - index : index;
+                const isActive = realIndex === currentEpisodeIndex;
+                
+                html += `
+                    <button id="episode-${realIndex}" 
+                            onclick="playEpisode(${realIndex})" 
+                            class="px-4 py-2 ${isActive ? 'episode-active' : 'bg-[#222] hover:bg-[#333]'} border ${isActive ? 'border-blue-500' : 'border-[#333]'} rounded-lg transition-colors text-center episode-btn">
+                        第${realIndex + 1}集
+                    </button>
+                `;
+            });
+            
+            episodesList.innerHTML = html;
+        }
+
+        // 播放指定集数
+        function playEpisode(index) {
+            // 确保index在有效范围内
+            if (index < 0 || index >= currentEpisodes.length) {
+                console.error(`无效的剧集索引: ${index}, 当前剧集数量: ${currentEpisodes.length}`);
+                showToast(`无效的剧集索引: ${index + 1}，当前剧集总数: ${currentEpisodes.length}`);
+                return;
+            }
+            
+            // 保存当前播放进度（如果正在播放）
+            if (dp && dp.video && !dp.video.paused && !videoHasEnded) {
+                saveCurrentProgress();
+            }
+            
+            // 清除进度保存计时器
+            if (progressSaveInterval) {
+                clearInterval(progressSaveInterval);
+                progressSaveInterval = null;
+            }
+            
+            // 首先隐藏之前可能显示的错误
+            document.getElementById('error').style.display = 'none';
+            // 显示加载指示器
+            document.getElementById('loading').style.display = 'flex';
+            document.getElementById('loading').innerHTML = `
+                <div class="loading-spinner"></div>
+                <div>正在加载视频...</div>
+            `;
+            
+            const url = currentEpisodes[index];
+            currentEpisodeIndex = index;
+            videoHasEnded = false; // 重置视频结束标志
+            
+            // 获取当前URL参数，保留source参数
+            const urlParams = new URLSearchParams(window.location.search);
+            const sourceName = urlParams.get('source') || '';
+            
+            // 更新URL，不刷新页面，保留source参数
+            const newUrl = new URL(window.location.href);
+            newUrl.searchParams.set('index', index);
+            newUrl.searchParams.set('url', url);
+            if (sourceName) {
+                newUrl.searchParams.set('source', sourceName);
+            }
+            window.history.pushState({}, '', newUrl);
+            
+            // 更新播放器
+            if (dp) {
+                try {
+                    dp.switchVideo({
+                        url: url,
+                        type: 'hls'
+                    });
+                    
+                    // 确保播放开始
+                    const playPromise = dp.play();
+                    if (playPromise !== undefined) {
+                        playPromise.catch(error => {
+                            console.warn('播放失败，尝试重新初始化:', error);
+                            // 如果切换视频失败，重新初始化播放器
+                            initPlayer(url);
+                        });
+                    }
+                } catch (e) {
+                    console.error('切换视频出错，尝试重新初始化:', e);
+                    // 如果出错，重新初始化播放器
+                    initPlayer(url);
+                }
+            } else {
+                initPlayer(url);
+            }
+            
+            // 更新UI
+            updateEpisodeInfo();
+            updateButtonStates();
+            renderEpisodes();
+
+            // 重置用户点击位置记录
+            userClickedPosition = null;
+            
+            // 三秒后保存到历史记录
+            setTimeout(() => saveToHistory(), 3000);
+        }
+
+        // 播放上一集
+        function playPreviousEpisode() {
+            if (currentEpisodeIndex > 0) {
+                playEpisode(currentEpisodeIndex - 1);
+            }
+        }
+
+        // 播放下一集
+        function playNextEpisode() {
+            if (currentEpisodeIndex < currentEpisodes.length - 1) {
+                playEpisode(currentEpisodeIndex + 1);
+            }
+        }
+
+        // 切换集数排序
+        function toggleEpisodeOrder() {
+            episodesReversed = !episodesReversed;
+            
+            // 保存到localStorage
+            localStorage.setItem('episodesReversed', episodesReversed);
+            
+            // 重新渲染集数列表
+            renderEpisodes();
+            
+            // 更新排序按钮
+            updateOrderButton();
+        }
+
+        // 更新排序按钮状态
+        function updateOrderButton() {
+            const orderText = document.getElementById('orderText');
+            const orderIcon = document.getElementById('orderIcon');
+            
+            if (orderText && orderIcon) {
+                orderText.textContent = episodesReversed ? '正序排列' : '倒序排列';
+                orderIcon.style.transform = episodesReversed ? 'rotate(180deg)' : '';
+            }
+        }
+
+        // 设置进度条准确点击处理
+        function setupProgressBarPreciseClicks() {
+            // 查找DPlayer的进度条元素
+            const progressBar = document.querySelector('.dplayer-bar-wrap');
+            if (!progressBar || !dp || !dp.video) return;
+            
+            // 移除可能存在的旧事件监听器
+            progressBar.removeEventListener('mousedown', handleProgressBarClick);
+            
+            // 添加新的事件监听器
+            progressBar.addEventListener('mousedown', handleProgressBarClick);
+            
+            // 在移动端也添加触摸事件支持
+            progressBar.removeEventListener('touchstart', handleProgressBarTouch);
+            progressBar.addEventListener('touchstart', handleProgressBarTouch);
+            
+            console.log('进度条精确点击监听器已设置');
+        }
+
+        // 处理进度条点击
+        function handleProgressBarClick(e) {
+            if (!dp || !dp.video) return;
+            
+            // 计算点击位置相对于进度条的比例
+            const rect = e.currentTarget.getBoundingClientRect();
+            const percentage = (e.clientX - rect.left) / rect.width;
+            
+            // 计算点击位置对应的视频时间
+            const duration = dp.video.duration;
+            let clickTime = percentage * duration;
+            
+            // 处理视频接近结尾的情况
+            if (duration - clickTime < 1) {
+                // 如果点击位置非常接近结尾，稍微往前移一点
+                clickTime = Math.min(clickTime, duration - 1.5);
+                console.log(`进度条点击接近结尾，调整时间为 ${clickTime.toFixed(2)}/${duration.toFixed(2)}`);
+            }
+            
+            // 记录用户点击的位置
+            userClickedPosition = clickTime;
+            
+            // 输出调试信息
+            console.log(`进度条点击: ${percentage.toFixed(4)}, 时间: ${clickTime.toFixed(2)}/${duration.toFixed(2)}`);
+            
+            // 阻止默认事件传播，避免DPlayer内部逻辑将视频跳至末尾
+            e.stopPropagation();
+            
+            // 直接设置视频时间
+            dp.seek(clickTime);
+        }
+
+        // 处理移动端触摸事件
+        function handleProgressBarTouch(e) {
+            if (!dp || !dp.video || !e.touches[0]) return;
+            
+            const touch = e.touches[0];
+            const rect = e.currentTarget.getBoundingClientRect();
+            const percentage = (touch.clientX - rect.left) / rect.width;
+            
+            const duration = dp.video.duration;
+            let clickTime = percentage * duration;
+            
+            // 处理视频接近结尾的情况
+            if (duration - clickTime < 1) {
+                clickTime = Math.min(clickTime, duration - 1.5);
+            }
+            
+            // 记录用户点击的位置
+            userClickedPosition = clickTime;
+            
+            console.log(`进度条触摸: ${percentage.toFixed(4)}, 时间: ${clickTime.toFixed(2)}/${duration.toFixed(2)}`);
+            
+            e.stopPropagation();
+            dp.seek(clickTime);
+        }
+        
+        // 在播放器初始化后添加视频到历史记录
+        function saveToHistory() {
+            // 确保 currentEpisodes 非空
+            if (!currentEpisodes || currentEpisodes.length === 0) {
+                console.warn('没有可用的剧集列表，无法保存完整的历史记录');
+            }
+            
+            // 尝试从URL中获取参数
+            const urlParams = new URLSearchParams(window.location.search);
+            const sourceName = urlParams.get('source') || '';
+
+            // 获取当前播放进度
+            let currentPosition = 0;
+            let videoDuration = 0;
+            
+            if (dp && dp.video) {
+                currentPosition = dp.video.currentTime;
+                videoDuration = dp.video.duration;
+            }
+
+            // 构建要保存的视频信息对象
+            const videoInfo = {
+                title: currentVideoTitle,
+                // 创建基础URL，使用标题作为唯一标识符
+                url: `player.html?title=${encodeURIComponent(currentVideoTitle)}&source=${encodeURIComponent(sourceName)}`,
+                episodeIndex: currentEpisodeIndex,
+                sourceName: sourceName,
+                timestamp: Date.now(),
+                // 添加播放进度信息
+                playbackPosition: currentPosition > 10 ? currentPosition : 0,
+                duration: videoDuration,
+                // 重要：保存完整的集数列表，确保进行深拷贝
+                episodes: currentEpisodes && currentEpisodes.length > 0 ? [...currentEpisodes] : []
+            };
+            
+            // 如果外部定义了addToViewingHistory函数，则调用它
+            if (typeof addToViewingHistory === 'function') {
+                addToViewingHistory(videoInfo);
+                console.log(`已保存 "${currentVideoTitle}" 的历史记录, 集数数据: ${currentEpisodes.length}集`);
+            } else {
+                // 否则直接使用本地实现
+                try {
+                    const history = JSON.parse(localStorage.getItem('viewingHistory') || '[]');
+                    
+                    // 检查是否已经存在相同标题的记录（同一视频的不同集数）
+                    const existingIndex = history.findIndex(item => item.title === videoInfo.title);
+                    if (existingIndex !== -1) {
+                        // 存在则更新现有记录的集数、时间戳和URL
+                        history[existingIndex].episodeIndex = currentEpisodeIndex;
+                        history[existingIndex].timestamp = Date.now();
+                        // 更新播放进度信息
+                        history[existingIndex].playbackPosition = currentPosition > 10 ? currentPosition : history[existingIndex].playbackPosition;
+                        history[existingIndex].duration = videoDuration || history[existingIndex].duration;
+                        // 同时更新URL以保存当前的集数状态
+                        history[existingIndex].url = window.location.href;
+                        // 更新集数列表（如果有且与当前不同）
+                        if (currentEpisodes && currentEpisodes.length > 0) {
+                            // 检查是否需要更新集数数据（针对不同长度的集数列表）
+                            if (!history[existingIndex].episodes || 
+                                !Array.isArray(history[existingIndex].episodes) || 
+                                history[existingIndex].episodes.length !== currentEpisodes.length) {
+                                history[existingIndex].episodes = [...currentEpisodes]; // 深拷贝
+                                console.log(`更新 "${currentVideoTitle}" 的剧集数据: ${currentEpisodes.length}集`);
+                            }
+                        }
+                        
+                        // 移到最前面
+                        const updatedItem = history.splice(existingIndex, 1)[0];
+                        history.unshift(updatedItem);
+                    } else {
+                        // 添加新记录到最前面，但保存完整URL以便能直接打开到正确的集数
+                        videoInfo.url = window.location.href;
+                        console.log(`创建新的历史记录: "${currentVideoTitle}", ${currentEpisodes.length}集`);
+                        history.unshift(videoInfo);
+                    }
+                    
+                    // 限制历史记录数量为50条
+                    if (history.length > 50) history.splice(50);
+                    
+                    localStorage.setItem('viewingHistory', JSON.stringify(history));
+                } catch (e) {
+                    console.error('保存观看历史失败:', e);
+                }
+            }
+        }
+
+        // 显示恢复位置提示
+        function showPositionRestoreHint(position) {
+            if (!position || position < 10) return;
+            
+            // 创建提示元素
+            const hint = document.createElement('div');
+            hint.className = 'position-restore-hint';
+            hint.innerHTML = `
+                <div class="hint-content">
+                    已从 ${formatTime(position)} 继续播放
+                </div>
+            `;
+            
+            // 添加到播放器容器
+            const playerContainer = document.querySelector('.player-container');
+            playerContainer.appendChild(hint);
+            
+            // 显示提示
+            setTimeout(() => {
+                hint.classList.add('show');
+                
+                // 3秒后隐藏
+                setTimeout(() => {
+                    hint.classList.remove('show');
+                    setTimeout(() => hint.remove(), 300);
+                }, 3000);
+            }, 100);
+        }
+        
+        // 格式化时间为 mm:ss 格式
+        function formatTime(seconds) {
+            if (isNaN(seconds)) return '00:00';
+            
+            const minutes = Math.floor(seconds / 60);
+            const remainingSeconds = Math.floor(seconds % 60);
+            
+            return `${minutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}`;
+        }
+        
+        // 开始定期保存播放进度
+        function startProgressSaveInterval() {
+            // 清除可能存在的旧计时器
+            if (progressSaveInterval) {
+                clearInterval(progressSaveInterval);
+            }
+            
+            // 每30秒保存一次播放进度
+            progressSaveInterval = setInterval(saveCurrentProgress, 30000);
+        }
+        
+        // 保存当前播放进度
+        function saveCurrentProgress() {
+            if (!dp || !dp.video) return;
+            const currentTime = dp.video.currentTime;
+            const duration = dp.video.duration;
+            if (!duration || currentTime < 1) return;
+
+            // 在localStorage中保存进度
+            const progressKey = `videoProgress_${getVideoId()}`;
+            const progressData = {
+                position: currentTime,
+                duration: duration,
+                timestamp: Date.now()
+            };
+            try {
+                localStorage.setItem(progressKey, JSON.stringify(progressData));
+                // --- 新增：同步更新 viewingHistory 中的进度 ---
+                try {
+                    const historyRaw = localStorage.getItem('viewingHistory');
+                    if (historyRaw) {
+                        const history = JSON.parse(historyRaw);
+                        // 用 title + 集数索引唯一标识
+                        const idx = history.findIndex(item =>
+                            item.title === currentVideoTitle &&
+                            (item.episodeIndex === undefined || item.episodeIndex === currentEpisodeIndex)
+                        );
+                        if (idx !== -1) {
+                            // 只在进度有明显变化时才更新，减少写入
+                            if (
+                                Math.abs((history[idx].playbackPosition || 0) - currentTime) > 2 ||
+                                Math.abs((history[idx].duration || 0) - duration) > 2
+                            ) {
+                                history[idx].playbackPosition = currentTime;
+                                history[idx].duration = duration;
+                                history[idx].timestamp = Date.now();
+                                localStorage.setItem('viewingHistory', JSON.stringify(history));
+                            }
+                        }
+                    }
+                } catch (e) {
+                    // 忽略 viewingHistory 更新错误
+                }
+            } catch (e) {
+                console.error('保存播放进度失败', e);
+            }
+        }
+        
+        // 清除视频进度记录
+        function clearVideoProgress() {
+            const progressKey = `videoProgress_${getVideoId()}`;
+            try {
+                localStorage.removeItem(progressKey);
+                console.log('已清除播放进度记录');
+            } catch (e) {
+                console.error('清除播放进度记录失败', e);
+            }
+        }
+        
+        // 获取视频唯一标识
+        function getVideoId() {
+            // 使用视频标题和集数索引作为唯一标识
+            return `${encodeURIComponent(currentVideoTitle)}_${currentEpisodeIndex}`;
+        }
+
+        // 简单的Toast消息提示函数
+        function showToast(message, type = 'error') {
+            // 如果已有Toast，先移除它
+            const existingToast = document.getElementById('custom-toast');
+            if (existingToast) {
+                document.body.removeChild(existingToast);
+            }
+            
+            // 创建新的Toast元素
+            const toast = document.createElement('div');
+            toast.id = 'custom-toast';
+            
+            // 设置Toast样式
+            toast.style.position = 'fixed';
+            toast.style.top = '20px';
+            toast.style.left = '50%';
+            toast.style.transform = 'translateX(-50%)';
+            toast.style.backgroundColor = type === 'error' ? '#f44336' : '#4caf50';
+            toast.style.color = 'white';
+            toast.style.padding = '12px 20px';
+            toast.style.borderRadius = '4px';
+            toast.style.zIndex = '10000';
+            toast.style.boxShadow = '0 2px 8px rgba(0, 0, 0, 0.3)';
+            toast.style.opacity = '0';
+            toast.style.transition = 'opacity 0.3s ease-in-out';
+            
+            // 设置Toast内容
+            toast.textContent = message;
+            
+            // 添加到页面
+            document.body.appendChild(toast);
+            
+            // 显示Toast
+            setTimeout(() => {
+                toast.style.opacity = '1';
+                
+                // 3秒后隐藏并移除
+                setTimeout(() => {
+                    toast.style.opacity = '0';
+                    setTimeout(() => {
+                        if (toast.parentNode) {
+                            document.body.removeChild(toast);
+                        }
+                    }, 300);
+                }, 3000);
+            }, 10);
+        }
+
+        let controlsLocked = false;
+        function toggleControlsLock() {
+            const container = document.getElementById('playerContainer');
+            controlsLocked = !controlsLocked;
+            container.classList.toggle('controls-locked', controlsLocked);
+            const icon = document.getElementById('lockIcon');
+            // 切换图标：锁 / 解锁
+            icon.innerHTML = controlsLocked
+                ? '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d=\"M12 15v2m0-8V7a4 4 0 00-8 0v2m8 0H4v8h16v-8h-4z\"/>'
+                : '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d=\"M15 11V7a3 3 0 00-6 0v4m-3 4h12v6H6v-6z\"/>';
+        }
+    </script>
+</body>
+</html>

privacy.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>隐私政策 - LibreTV</title>
+	<script src="https://cdn.tailwindcss.com"></script>
+	<link rel="stylesheet" href="css/styles.css">
+</head>
+<body class="page-bg text-white">
+	<div class="container mx-auto px-4 py-8">
+		<header class="text-center mb-8">
+			<h1 class="text-5xl font-bold gradient-text">隐私政策</h1>
+		</header>
+		<main class="text-center">
+			<p class="text-gray-300 mb-4">
+				我们尊重并保护您的隐私。LibreTV 不收集任何个人数据，且不会限制访问或使用本网站。
+			</p>
+			<p class="text-gray-300">
+				本平台仅用于提供在线视频搜索与播放服务。所有数据均由第三方接口提供，我们不会存储或追踪用户信息。
+			</p>
+		</main>
+		<footer class="mt-12 text-center">
+			<a href="index.html" class="text-gray-400 hover:text-white transition-colors">回到首页</a>
+		</footer>
+	</div>
+</body>
+</html>

proxy.lua

@@ -0,0 +1,38 @@
+-- 解码URL函数
+local function decode_uri(uri)
+    local decoded = ngx.unescape_uri(uri)
+    return decoded
+end
+
+-- 直接从请求URI获取完整URL
+local request_uri = ngx.var.request_uri
+ngx.log(ngx.DEBUG, "完整请求URI: ", request_uri)
+
+-- 提取/proxy/后面的部分
+local _, _, target_path = string.find(request_uri, "^/proxy/(.*)")
+ngx.log(ngx.DEBUG, "提取的目标路径: ", target_path or "nil")
+
+if not target_path or target_path == "" then
+    ngx.status = 400
+    ngx.say("错误: 未提供目标URL")
+    return ngx.exit(400)
+end
+
+-- 解码URL
+local target_url = decode_uri(target_path)
+ngx.log(ngx.DEBUG, "解码后的目标URL: ", target_url)
+
+if not target_url or target_url == "" then
+    ngx.status = 400
+    ngx.say("错误: 无法解析目标URL")
+    return ngx.exit(400)
+end
+
+-- 记录日志
+ngx.log(ngx.STDERR, "代理请求: ", target_url)
+
+-- 设置目标URL变量供Nginx使用
+ngx.var.target_url = target_url
+
+-- 继续执行Nginx配置的其余部分
+return

robots.txt

@@ -0,0 +1,6 @@
+User-agent: *
+Allow: /
+Disallow: /js/
+Disallow: /css/
+
+Sitemap: https://libretv.is-an.org/sitemap.xml

sitemap.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+   <url>
+      <loc>https://libretv.is-an.org/</loc>
+      <lastmod>2025-04-06</lastmod>
+      <changefreq>weekly</changefreq>
+      <priority>1.0</priority>
+   </url>
+   <url>
+      <loc>https://libretv.is-an.org/about.html</loc>
+      <lastmod>2025-04-06</lastmod>
+      <changefreq>monthly</changefreq>
+      <priority>0.8</priority>
+   </url>
+   <url>
+      <loc>https://libretv.is-an.org/privacy.html</loc>
+      <lastmod>2025-04-06</lastmod>
+      <changefreq>monthly</changefreq>
+      <priority>0.5</priority>
+   </url>
+</urlset>

vercel.json

@@ -0,0 +1,8 @@
+{
+  "rewrites": [
+    {
+      "source": "/proxy/:path*",
+      "destination": "/api/proxy/:path*"
+    }
+  ]
+}

watch.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="refresh" content="0; url=player.html">
+    <title>重定向到播放器</title>
+</head>
+<body>
+    <p>如果您没有被自动重定向，请<a href="player.html">点击这里</a>前往播放页面。</p>
+</body>
+</html>