hexo-theme-stellar 1.44.0 → 2.0.0-rc.2

package/source/js/utils.js

@@ -3,47 +3,6 @@
   if (window.__stellarUtilsLoaded) return;
   window.__stellarUtilsLoaded = true;
 
-  function RunItem() {
-    this.list = []; // 存放回调函数
-    this.start = () => {
-      for (var i = 0; i < this.list.length; i++) {
-        this.list[i].run();
-      }
-    };
-    this.push = (fn, name, setRequestAnimationFrame = true) => {
-      let myfn = fn
-      if (setRequestAnimationFrame) {
-        myfn = () => {
-          utils.requestAnimationFrame(fn)
-        }
-      }
-      var f = new Item(myfn, name);
-      this.list.push(f);
-    };
-    this.remove = (name) => {
-      // 倒序遍历避免 splice 后的索引问题
-      for (let index = this.list.length - 1; index >= 0; index--) {
-        const e = this.list[index];
-        if (e.name === name) {
-          this.list.splice(index, 1);
-        }
-      }
-    }
-    // 构造一个可以run的对象
-    function Item(fn, name) {
-      // 函数名称
-      this.name = name || fn.name;
-      // run方法
-      this.run = () => {
-        try {
-          fn()
-        } catch (error) {
-          console.log(error);
-        }
-      };
-    }
-  }
-
   const utils = {
     // 已加载样式缓存
     _loadedStyles: new Set(),
@@ -320,329 +279,6 @@
         }
       }
     },
-    /********************** data cache ********************************/
-    // 动态数据本地缓存：TTL 未过期直接命中；过期后先显示缓存再后台刷新（stale-while-revalidate）
-    _cacheEnabled: true,
-    _cacheMaxEntryBytes: 200 * 1024,
-    // 同 URL 并发请求去重：页面内多个组件请求同一接口时共享一次 fetch
-    _pendingRequests: {},
-    _fetchShared: (url, options) => {
-      const key = (options && options.method || 'GET') + ' ' + url;
-      if (utils._pendingRequests[key]) {
-        return utils._pendingRequests[key].then(resp => resp.clone());
-      }
-      const promise = fetch(url, options).then(resp => {
-        if (!resp.ok) throw new Error('响应失败');
-        return resp;
-      }).finally(() => {
-        delete utils._pendingRequests[key];
-      });
-      utils._pendingRequests[key] = promise;
-      // 每个调用方各自 clone，避免 Response body 被消费后其他调用方取不到数据
-      return promise.then(resp => resp.clone());
-    },
-    // 延迟执行：缓存写入等非关键操作让出主线程
-    _defer: (fn) => {
-      if (window.requestIdleCallback) {
-        window.requestIdleCallback(fn, { timeout: 3000 });
-      } else {
-        setTimeout(fn, 0);
-      }
-    },
-    cache: {
-      prefix: 'Stellar.data_cache.v1.',
-      enabled: () => !!def.data_cache?.enable && utils._cacheEnabled,
-      serviceId: (el, options) => {
-        if (options && options.service) return options.service;
-        if (el) {
-          const match = String(el.className || '').match(/\bds-([\w-]+)\b/);
-          if (match) return match[1];
-        }
-        return null;
-      },
-      ttl: (el, options) => {
-        const conf = def.data_cache || {};
-        const id = utils.cache.serviceId(el, options);
-        const value = id && conf.ttl && conf.ttl[id] != null ? conf.ttl[id] : conf.default_ttl;
-        return typeof value === 'number' && value > 0 ? value : 0;
-      },
-      shouldCache: (url, options) => {
-        if (!utils.cache.enabled()) return false;
-        if (options && (options.cache === false || options.cache === 'no-store')) return false;
-        if (options && options.method && options.method !== 'GET') return false;
-        // 带时间戳缓存破坏参数的请求不缓存（如 mdrender 的 ?t=）
-        if (/[?&]t=\d{10,}/.test(url)) return false;
-        return true;
-      },
-      get: (url) => {
-        try {
-          const raw = localStorage.getItem(utils.cache.prefix + url);
-          if (!raw) return null;
-          const entry = JSON.parse(raw);
-          if (!entry || typeof entry.text !== 'string' || typeof entry.ts !== 'number') return null;
-          return entry;
-        } catch (e) {
-          console.warn('[cache] 读取失败:', url, e);
-          return null;
-        }
-      },
-      set: (url, text, contentType, ttl) => {
-        if (!(ttl > 0)) return;
-        if (text.length > utils._cacheMaxEntryBytes) return;
-        const entry = JSON.stringify({
-          text: text,
-          contentType: contentType || 'application/json',
-          ts: Date.now(),
-          ttl: ttl
-        });
-        const trySet = () => {
-          try {
-            localStorage.setItem(utils.cache.prefix + url, entry);
-            utils.cache.trim();
-            return true;
-          } catch (e) {
-            return false;
-          }
-        };
-        if (!trySet()) {
-          // 配额不足时淘汰最旧条目后重试一次，仍失败则本会话禁用缓存
-          utils.cache.evictOldest(url);
-          if (!trySet()) {
-            console.warn('[cache] 写入失败，本会话禁用缓存:', url);
-            utils._cacheEnabled = false;
-          }
-        }
-      },
-      trim: () => {
-        try {
-          const max = (def.data_cache && def.data_cache.max_entries) || 200;
-          const keys = [];
-          for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (key && key.indexOf(utils.cache.prefix) === 0) keys.push(key);
-          }
-          if (keys.length <= max) return;
-          const sorted = keys.map((key) => {
-            let ts = 0;
-            try {
-              const entry = JSON.parse(localStorage.getItem(key) || 'null');
-              if (entry && typeof entry.ts === 'number') ts = entry.ts;
-            } catch (e) {}
-            return { key, ts };
-          }).sort((a, b) => a.ts - b.ts);
-          for (let i = 0; i < sorted.length - max; i++) {
-            localStorage.removeItem(sorted[i].key);
-          }
-        } catch (e) {
-          console.warn('[cache] 清理失败:', e);
-        }
-      },
-      evictOldest: (exceptUrl) => {
-        try {
-          let oldestKey = null;
-          let oldestTs = Infinity;
-          const exceptKey = utils.cache.prefix + exceptUrl;
-          for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (!key || key.indexOf(utils.cache.prefix) !== 0 || key === exceptKey) continue;
-            let ts = 0;
-            try {
-              const entry = JSON.parse(localStorage.getItem(key) || 'null');
-              if (entry && typeof entry.ts === 'number') ts = entry.ts;
-            } catch (e) {}
-            if (ts < oldestTs) {
-              oldestTs = ts;
-              oldestKey = key;
-            }
-          }
-          if (oldestKey) localStorage.removeItem(oldestKey);
-        } catch (e) {}
-      },
-      isFresh: (entry) => {
-        if (!entry || typeof entry.ts !== 'number' || typeof entry.ttl !== 'number') return false;
-        if (!(entry.ttl > 0)) return false;
-        return Date.now() - entry.ts < entry.ttl * 1000;
-      },
-      // 用缓存文本重建 Response，兼容回调中的 resp.json() / resp.text()
-      toResponse: (entry) => new Response(entry.text, {
-        status: 200,
-        statusText: 'OK',
-        headers: { 'Content-Type': entry.contentType }
-      })
-    },
-    request: (el, url, callback, onFailure, options) => {
-      // 检查元素实例是否已加载 (而不是检查属性)
-      if (el && utils._loadedElements.has(el)) {
-        return;
-      }
-      const maxRetry = 3;
-      let retryCount = 0;
-      const ttl = utils.cache.ttl(el, options);
-      const cacheable = utils.cache.shouldCache(url, options) && ttl > 0;
-      const cached = cacheable ? utils.cache.get(url) : null;
-      // 缓存渲染前的初始结构，后台刷新渲染前恢复，避免重复渲染
-      let initialHTML = null;
-      // 缓存渲染完成后（或超时兜底）再启动后台刷新，避免异步渲染未结束就清空重绘
-      let cacheRenderDone = null;
-
-      if (cached) {
-        if (el) {
-          // 已有缓存时不显示加载动画
-          utils.onLoadSuccess?.(el);
-          initialHTML = el.innerHTML;
-        }
-        try {
-          cacheRenderDone = Promise.resolve(callback(utils.cache.toResponse(cached))).catch(e => {
-            console.warn('[request] 缓存渲染失败:', url, e);
-          });
-        } catch (e) {
-          console.warn('[request] 缓存渲染失败:', url, e);
-        }
-        // 缓存未过期：直接完成，不发请求
-        if (utils.cache.isFresh(cached)) {
-          if (el) utils._loadedElements.add(el);
-          return Promise.resolve(cached.text);
-        }
-      } else {
-        utils.onLoading?.(el);
-      }
-
-      return new Promise((resolve, reject) => {
-        const load = () => {
-          let timedOut = false;
-          const timeout = setTimeout(() => {
-            timedOut = true;
-            console.warn('[request] 超时:', url);
-
-            if (++retryCount >= maxRetry) {
-              if (cached) {
-                // 已有缓存渲染，保留缓存内容，不显示失败
-                resolve(cached.text);
-              } else {
-                utils.onLoadFailure?.(el);
-                onFailure?.();
-                reject('请求超时');
-              }
-            } else {
-              setTimeout(load, 1000);
-            }
-          }, 5000);
-
-          utils._fetchShared(url).then(resp => {
-            if (timedOut) return;
-            clearTimeout(timeout);
-            return resp;
-          }).then(data => {
-            if (timedOut) return;
-            // 标记元素实例为已加载
-            if (el) utils._loadedElements.add(el);
-            // 写入缓存：回调会立即消费 data 的 body，必须先同步 clone 再延迟读取
-            if (cacheable && data.ok) {
-              const cacheClone = data.clone();
-              const contentType = data.headers.get('Content-Type') || 'application/json';
-              utils._defer(() => {
-                cacheClone.text().then(text => {
-                  utils.cache.set(url, text, contentType, ttl);
-                }).catch(() => {});
-              });
-            }
-            // 后台刷新渲染前恢复初始结构，避免缓存渲染的内容重复
-            if (el && initialHTML !== null) {
-              el.innerHTML = initialHTML;
-            }
-            utils.onLoadSuccess?.(el);
-            callback(data);
-            resolve(data);
-          }).catch(err => {
-            clearTimeout(timeout);
-            console.warn('[request] 错误:', err);
-
-            if (++retryCount >= maxRetry) {
-              if (cached) {
-                resolve(cached.text);
-              } else {
-                utils.onLoadFailure?.(el);
-                onFailure?.();
-                reject(err);
-              }
-            } else {
-              setTimeout(load, 1000);
-            }
-          });
-        };
-
-        if (cacheRenderDone) {
-          Promise.race([
-            cacheRenderDone,
-            new Promise(resolve => setTimeout(resolve, 5000))
-          ]).then(load);
-        } else {
-          load();
-        }
-      });
-    },
-    requestWithoutLoading: (url, options = {}, maxRetry = 2, timeout = 5000) => {
-      const ttl = utils.cache.ttl(null, options);
-      const cacheable = utils.cache.shouldCache(url, options) && ttl > 0;
-      const cached = cacheable ? utils.cache.get(url) : null;
-
-      if (cached && utils.cache.isFresh(cached)) {
-        return Promise.resolve(utils.cache.toResponse(cached));
-      }
-
-      return new Promise((resolve, reject) => {
-        let retryCount = 0;
-        // 与 request 保持一致：最终失败时回退 stale 缓存，避免闪失败态
-        const fallback = () => {
-          if (cached) {
-            resolve(utils.cache.toResponse(cached));
-          } else {
-            reject('timeout');
-          }
-        };
-
-        const tryRequest = () => {
-          let timedOut = false;
-          const timer = setTimeout(() => {
-            timedOut = true;
-            if (++retryCount > maxRetry) fallback();
-            else tryRequest();
-          }, timeout);
-
-          utils._fetchShared(url, options)
-            .then(resp => {
-              clearTimeout(timer);
-              if (timedOut) return;
-              if (cacheable) {
-                // 调用方会消费 resp 的 body，必须先同步 clone 再延迟读取
-                const cacheClone = resp.clone();
-                const contentType = resp.headers.get('Content-Type') || 'application/json';
-                utils._defer(() => {
-                  cacheClone.text().then(text => {
-                    utils.cache.set(url, text, contentType, ttl);
-                  }).catch(() => {});
-                });
-              }
-              resolve(resp);
-            })
-            .catch(err => {
-              clearTimeout(timer);
-              if (timedOut) return;
-              if (++retryCount > maxRetry) {
-                if (cached) {
-                  resolve(utils.cache.toResponse(cached));
-                } else {
-                  reject(err);
-                }
-              } else {
-                setTimeout(tryRequest, 500);
-              }
-            });
-        };
-
-        tryRequest();
-      });
-    },
     /********************** requestAnimationFrame ********************************/
     // 1、requestAnimationFrame 会把每一帧中的所有 DOM 操作集中起来，在一次重绘或回流中就完成，并且重绘或回流的时间间隔紧紧跟随浏览器的刷新频率，一般来说，这个频率为每秒60帧。
     // 2、在隐藏或不可见的元素中，requestAnimationFrame 将不会进行重绘或回流，这当然就意味着更少的的 cpu，gpu 和内存使用量。
@@ -652,90 +288,29 @@
       }
       window.requestAnimationFrame(fn)
     },
-    dark: {},
-
-    // 插件初始化管理器 - 统一处理 DOMContentLoaded 事件
-    _pluginInitializers: [],
-    _pluginCleanups: new Map(), // 存储每个插件的清理函数
-    
-    initPlugin: (initFn, name, options = {}) => {
-      if (!initFn || typeof initFn !== 'function') return;
-      
-      // 避免重复注册
-      const pluginName = name || initFn.name;
-      if (utils._pluginInitializers.some(p => p.name === pluginName)) return;
-      
-      // 包装初始化函数，添加防重复执行的保护
-      const wrappedInit = () => {
-        try {
-          // 在执行前先清理旧的资源
-          if (utils._pluginCleanups.has(pluginName)) {
-            const cleanup = utils._pluginCleanups.get(pluginName);
-            if (typeof cleanup === 'function') {
-              cleanup();
-            }
-          }
-          
-          // 执行初始化，可能返回清理函数
-          const cleanup = initFn();
-          
-          // 如果初始化函数返回了清理函数，保存它
-          if (typeof cleanup === 'function') {
-            utils._pluginCleanups.set(pluginName, cleanup);
-          }
-        } catch (error) {
-          console.error(`[Plugin ${pluginName}] 初始化失败:`, error);
-        }
-      };
-      
-      utils._pluginInitializers.push({ 
-        fn: wrappedInit, 
-        name: pluginName,
-        options: options 
-      });
-      
-      // 如果 DOM 已经加载完成，立即执行
-      if (document.readyState === 'complete' || document.readyState === 'interactive') {
-        wrappedInit();
-      } else {
-        // 否则等待 DOMContentLoaded
-        window.addEventListener('DOMContentLoaded', wrappedInit, { once: true });
-      }
-    },
-
-    // 清理所有插件资源
-    cleanupPlugins: () => {
-      utils._pluginCleanups.forEach((cleanup, name) => {
-        try {
-          cleanup();
-        } catch (error) {
-          console.error(`[Plugin ${name}] 清理失败:`, error);
-        }
-      });
-      utils._pluginCleanups.clear();
-    },
-    
-    // 清理所有资源（用于页面卸载或重置）
-    cleanupAll: () => {
-      utils.cleanupPlugins();
-    },
   };
 
-  // utils.dark.mode 当前模式 dark or light
-  // utils.dark.toggle() 暗黑模式触发器
-  // utils.dark.push(callBack[,"callBackName"]) 传入触发器回调函数
-  utils.dark.method = {
-    toggle: new RunItem(),
-  };
-  utils.dark = Object.assign(utils.dark, {
-    push: utils.dark.method.toggle.push,
+  // 自定义注入脚本可能在 type=module runtime 执行前调用 request；以 Promise 接缝排队，
+  // runtime 安装真实 adapter 后统一放行，不在经典脚本中复制任何网络或缓存算法。
+  var requestBridge = {};
+  requestBridge.ready = new Promise(function (resolve) {
+    requestBridge.resolve = resolve;
   });
+  utils.request = function () {
+    var args = arguments;
+    return requestBridge.ready.then(function (adapter) {
+      return adapter.request.apply(null, args);
+    });
+  };
+  utils.requestWithoutLoading = function () {
+    var args = arguments;
+    return requestBridge.ready.then(function (adapter) {
+      return adapter.requestWithoutLoading.apply(null, args);
+    });
+  };
 
-  // 暴露到 window：页尾插件片段经裸标识符 utils 即可使用
+  // 暴露到 window：迁移期经典核心脚本与 ESM runtime 的兼容接缝。
+  window.__stellarRequestBridge = requestBridge;
   window.utils = utils;
 
-  // 补跑解析期注册的插件队列
-  if (window.stellar && typeof window.stellar._flushPlugins === 'function') {
-    window.stellar._flushPlugins();
-  }
 })();

package/.claude/skills/stellar-theme-dev/SKILL.md

@@ -1,51 +0,0 @@
----
-name: stellar-theme-dev
-description: 主题仓库（hexo-theme-stellar）开发全流程：方案 → 开发 → 验证 → 提交 → 发版。当任务涉及本仓库主题文件、构建验证、知识库更新或主题发版时使用。
----
-
-# Stellar Theme Dev
-
-主题仓库（hexo-theme-stellar）开发全流程。开始前先读仓库根 `AGENTS.md`（唯一权威）；本文件只给出执行顺序与完成条件。涉及主题代码、配置或行为问题时，先查 `docs/knowledge/` 对应领域，再读源码确认。
-
-## 流程
-
-### 1. 方案
-
-- 先读 `AGENTS.md`「架构总览」（§6）与 `docs/knowledge/00-总览与安装配置/overview.md` 建立整体认知、定位改动范围。
-- 在 `docs/designs/{YYYY-MM-DD}-{功能简称}/` 下建方案文档（模板 `docs/designs/_template/`，含 `spec.md` / `plan.md` / `checklist.md`）。
-- 方案需写明：要解决的问题、技术方案与实现思路、影响范围、需同步的知识库页面与文档。
-- 知识库文档遵循“设计语义、行为契约、修改依据”分层；新增具体数值时说明语义和作用范围，普通 CSS 实现值以源码为准，不在多个页面重复维护。
-- 完成条件：方案文档已就位；改动范围与受影响维度已确认。
-
-### 2. 开发
-
-- 新增功能覆盖全部相关维度：`layout/` + `scripts/` + `source/css/` + `source/js/`（如需）+ `languages/`（如需）+ `docs/`。
-- 新增或重构标签插件先读 `docs/guides/tag-plugins-style-guide.md`；代码遵循 `AGENTS.md` 编码规范。
-- 完成条件：改动文件清单覆盖全部相关维度；涉及行为或配置变更时已同步 `docs/knowledge/` 并在 `VERIFICATION.md` 登记。
-
-### 3. 验证
-
-命令按需执行：
-
-- `scripts/` 有改动 → 必须在主工程（xaoxuu.com）执行 `npm run g` 全量验证（已含 `hexo clean && hexo generate && npx gulp minify`）；`npm run s` 是按需渲染，不能替代。
-- 新增/修改纯函数 → 补充单测并跑 `npm run check`（lint + 单测 + 依赖声明检查 + 知识库硬事实核查）。
-- 知识库有改动 → `python3 docs/knowledge/tools/verify.py` 硬事实核查。
-- UI 方面（样式、模板、前端交互等）改动量不大时无需自检流程，除非用户明确要求。
-- 检查所有受影响页面类型（首页、文章页、Wiki 页等），验证结果记录在方案目录 `checklist.md`。
-- 完成条件：应执行的命令全部通过；新增 `require` 均已声明或为 Node 内置模块（test/ 禁止幽灵依赖）；首页、文章页、Wiki 页等受影响页面类型均检查通过。
-
-### 4. 提交
-
-- 任务完成后**不自动提交**：改动保留在工作区供用户审查。
-- 仅在用户明确要求提交时执行；提交前须通过第 3 步中应执行的验证。
-- 使用 Conventional Commits，一次提交对应一个需求点；如果几个需求任务逻辑相似，可以合并为一次提交；类型与格式见 `AGENTS.md`「Git 规范」（§7）。
-- 合并代码时，把合并提交 / PR 标题改为 Conventional Commits 格式（见 `AGENTS.md`「Git 规范」§7），不保留默认的 `Merge branch ...` / `Merge pull request ...` 标题。
-- 改动只提交在本仓库（stellar）；仅当用户明确要求时 push。
-- 完成条件：改动已通过应执行的验证并保留在工作区；如用户要求提交，提交符合规范；如用户要求 push，已推送且远端为最新。
-
-### 5. 发版
-
-- 由用户触发时执行：分析自上一 tag 起的 commit 确定版本号 → 在 `CHANGELOG.md` 写入对应非空章节（H2 版本号 + H3 分类）→ 向用户确认版本号与变更摘要 → `npm run release:dry -- <version>` 预演 → 正式发版。
-- 发版前核对：`npm run check` 内含提交登记完整性检查，自上一 tag 起涉及主题代码/配置/行为变化的非合并提交须在 `docs/knowledge/VERIFICATION.md`「提交登记（发版前核对）」表登记短 SHA（纯文档 / CI 改动无需登记）；缺失先补登记再发版。
-- 详见 `docs/guides/release-process.md` 与 `AGENTS.md`「发版规范」（§8）。
-- 完成条件：版本号与变更摘要已获用户确认；dry-run 通过后完成正式发版。

package/layout/_partial/comments/artalk/script.ejs

@@ -1,76 +0,0 @@
-<script type="module">
-  (function() {
-    
-    function initArtalk() {
-      const el = document.getElementById('artalk_container');
-      if (!el) return;
-
-      // artalk 邮件通知链接携带 ?atk_comment=<id> / #atk-comment-<id> 定位目标，
-      // 命中时跳过视口懒加载立即初始化，让 Artalk 自身的 list-goto 逻辑完成定位。
-      const hasAtkTarget = /[?&]atk_comment=\d+/.test(window.location.search) || /#atk-comment-\d+/.test(window.location.hash);
-      
-      function load_artalk() {
-        utils.css('<%- url_for('/css/comments/artalk.css') %>?v=<%- stellar_info('version') %>');
-        utils.css('<%- theme.comments.artalk.css %>');
-        utils.js('<%- theme.comments.artalk.js %>', {defer: true}).then(function () {
-          // 监听 Artalk 事件
-          // FIXME: Artalk开启了懒加载会导致评论输入预览框里的图也变成data-src，导致看不到图
-          // Artalk.use((ctx) => {
-          //   ctx.on('list-loaded', () => window.lazyLoadInstance?.update())
-          // })
-          // 邮件通知链接以 ?atk_comment=<id> 定位，Artalk 在 list-loaded 时才重新读取 URL，
-          // 固定延时清理会与之竞态（#598）。先把评论 id 改写到 hash（Artalk 读取优先级高于 query），
-          // 同时立即移除 atk_comment 查询参数，避免其 hash 监听干扰目录定位；
-          // atk_notify_key 保留到 list-loaded 完成定位与已读回执后再清理。
-          const atkComment = window.location.search.match(/[?&]atk_comment=(\d+)/);
-          if (atkComment && !/#atk-comment-\d+/.test(window.location.hash)) {
-            const params = new URLSearchParams(window.location.search);
-            const notifyKey = params.get('atk_notify_key');
-            const query = notifyKey ? '?atk_notify_key=' + encodeURIComponent(notifyKey) : '';
-            window.history.replaceState(null, '', window.location.pathname + query + '#atk-comment-' + atkComment[1]);
-          }
-          const path = el.getAttribute('comment_id') ?? decodeURI(window.location.pathname);
-          const artalk = Artalk.init({
-            el: '#artalk_container',
-            pageKey: path,
-            pageTitle: '<%= page.title %>',
-            server: '<%= theme.comments.artalk.server %>',
-            site: '<%= theme.comments.artalk.site %>',
-            darkMode: '<%= theme.comments.artalk.darkMode %>',
-            <% if (theme.comments.artalk.imageUploader?.api) { %>
-            imgUploader: function(file) {
-              let headers = new Headers();
-              headers.set('Accept', 'application/json');
-              <% if (theme.comments.artalk.imageUploader?.token) { %>
-                headers.set('Authorization', '<%- theme.comments.artalk.imageUploader?.token %>')
-              <% } %>
-              let formData = new FormData();
-              formData.append('file', file);
-              return fetch('<%- theme.comments.artalk.imageUploader?.api %>',{
-                method: 'POST',
-                body: formData,
-                headers: headers
-                }).then((resp) => resp.json())
-                  .then((resp) => resp.<%- theme.comments.artalk.imageUploader?.resp %>)
-              },
-            <% } %>
-          });
-          // list-loaded 时 Artalk 已读取 atk_comment / atk_notify_key 并触发定位与已读回执，
-          // 此时再清理残留的 ?atk_* 参数，避免固定延时与异步加载竞态（#598）。
-          if (hasAtkTarget && window.location.search.indexOf('atk_') !== -1) {
-            artalk.on('list-loaded', function () {
-              window.setTimeout(function () {
-                window.history.replaceState(null, '', window.location.pathname + window.location.hash);
-              }, 0);
-            });
-          }
-        });
-      }
-      
-      util.viewportLazyload(el, load_artalk, !hasAtkTarget);
-    }
-    
-    // Initialize on page load
-    initArtalk();
-  })();
-</script>

package/layout/_partial/comments/beaudar/script.ejs

@@ -1,33 +0,0 @@
-<script type="module">
-  (function() {
-    
-    function initBeaudar() {
-      const el = document.querySelector('#comments #beaudar');
-      if (!el) return;
-      
-      function load_beaudar() {
-        utils.css('<%- url_for('/css/comments/beaudar.css') %>?v=<%- stellar_info('version') %>');
-        try {
-          el.innerHTML = '';
-        } catch (error) {
-          console.error(error);
-        }
-        const script = document.createElement('script');
-        script.src = 'https://beaudar.lipk.org/client.js';
-        script.async = true;
-        for (const key of Object.keys(el.attributes)) {
-          const attr = el.attributes[key];
-          if (['class', 'id'].includes(attr.name) === false) {
-            script.setAttribute(attr.name, attr.value);
-          }
-        }
-        el.appendChild(script);
-      }
-      
-      util.viewportLazyload(el, load_beaudar);
-    }
-    
-    // Initialize on page load
-    initBeaudar();
-  })();
-</script>

package/layout/_partial/comments/giscus/script.ejs

@@ -1,31 +0,0 @@
-<script type="module">
-  (function() {
-    
-    function initGiscus() {
-      const el = document.querySelector('#comments #giscus');
-      if (!el) return;
-      
-      function load_giscus() {
-        try {
-          el.innerHTML = '';
-        } catch (error) {
-          console.error(error);
-        }
-        const script = document.createElement('script');
-        script.async = true;
-        for (const key of Object.keys(el.attributes)) {
-          const attr = el.attributes[key];
-          if (['class', 'id'].includes(attr.name) === false) {
-            script.setAttribute(attr.name, attr.value);
-          }
-        }
-        el.appendChild(script);
-      }
-      
-      util.viewportLazyload(el, load_giscus);
-    }
-    
-    // Initialize on page load
-    initGiscus();
-  })();
-</script>

package/layout/_partial/comments/script.ejs

@@ -1,3 +0,0 @@
-<% if (page.cmt && page.cmt.service && page.cmt.service.length > 0) { %>
-  <%- partial(page.cmt.service + '/script') %>
-<% } %>