[Item] AF2N 中文模版，将书籍、长文献批注分章节结构化输出到笔记，支持剪贴板 md 到 obsidian

[aidecameron]

Description

本模版适合对书籍、长文献总结批注。

本模版将 文献/书籍 的批注（annotation）直接转化为一篇有文档结构的笔记，依靠不同高亮颜色，以高度可控的方式。配置、定制极为简单。

文档结构由灰色的批注控制。并支持词句拼接、列表拼接、脑图生成、生成 Obsidian 友好的内容（到剪贴板）等功能。

本模版自带 handlebar 引擎解释器，生成的格式高度可定制。（语法参考 GitHub 项目文档）

通过使用此模版，不用手工维护笔记的文档结构。最佳实践是在文档内用批注和用户注释（comment）辅助阅读。笔记为自动生成的结果。

Screenshots

输出笔记效果如下：

在打开 markdown 复制到剪贴板的控制后，结果拷贝到 Obsidian 的效果。（如需可视化脑图，需 Obsidian 安装支持 markmap 语法的 Mindmap Nextgen 插件），效果如下：

Test on Zotero version

7.0.26

Test on Better Notes version

2.5.8

Template Type

Item

Template Share Code

# This template is specifically for importing/sharing, using better 
# notes 'import from clipboard': copy the content and
# goto Zotero menu bar, click Tools->New Template from Clipboard.  
# Author: https://github.com/aidecameron
# Do not copy-paste this to better notes template editor directly.
name: "[item]AF2N中文"
zoteroVersion: "7.0.26"
pluginVersion: "2.5.8"
savedAt: "2025-10-17T14:05:27.862Z"
content: |-
  
  
  
  // @beforeloop-begin
  
  ${{
  
  if(globalThis.TemplateEngine){
      delete globalThis.TemplateEngine;
  }
  
  const console = Zotero.getMainWindow().console;
  
  
  (function() {
      'use strict';
  
  class GlobalTemplateEngine {
  	
          constructor() {
              if (GlobalTemplateEngine.instance) {
                  return GlobalTemplateEngine.instance;
              }
          
              this.parsers = new Map();
              // 初始化转义规则配置
              this.escapeRules = new Map([
                  ['\\', '\\\\'], 
                  ['*', '\\*'],               // Markdown 斜体（会自动处理 ** 粗体）
                  ['_', '\\_'],               // Markdown 下划线
                  ['`', '\\`'],               // Markdown 代码
                  ['#', '\\#'],               // Markdown 标题
                  ['[', '\\['],               // Markdown 链接开始
                  [']', '\\]'],               // Markdown 链接结束
                  ['(', '\\('],               // Markdown 链接括号开始
                  [')', '\\)'],               // Markdown 链接括号结束
                  ['>', '\\>'],               // Markdown 引用
                  ['|', '\\|'],               // Markdown 表格
                  ['~', '\\~'],               // Markdown 删除线
                  ['^', '\\^']                // Markdown 上标
              ]);
              this.initDefaultParsers();
              GlobalTemplateEngine.instance = this;
          }
  
  		
          
          // 评估方法调用表达式
          evaluateMethodCall(expression, data) {
              try {
                  // 检查是否是 has 函数调用
                  const hasMatch = expression.match(/^has\(([^,]+),\s*['"]([^'"]+)['"],\s*['"]([^'"]+)['"]\)$/);
                  if (hasMatch) {
                      const [, objectPath, propertyName, targetValue] = hasMatch;
                      return this.evaluateHasFunction(objectPath.trim(), propertyName, targetValue, data);
                  }
                  
                  // 解析方法调用表达式，如 "this.comment.startsWith('bb')"
                  const methodCallMatch = expression.match(/^(.+?)\.([^.()]+)\(([^)]*)\)$/);
                  if (!methodCallMatch) {
                      return false;
                  }
                  
                  const [, objectPath, methodName, argsStr] = methodCallMatch;
                  
                  // 获取对象
                  const obj = this.getNestedValue(data, objectPath);
                  
                  if (!obj) {
                      return false;
                  }
                  
                  // 检查方法是否存在
                  if (typeof obj[methodName] !== 'function') {
                      return false;
                  }
                  
                  // 解析参数
                  const args = this.parseMethodArguments(argsStr);
                  
                  // 执行方法调用
                  const result = obj[methodName].apply(obj, args);
                  
                  // 返回布尔值结果
                  return Boolean(result);
                  
              } catch (error) {
                  return false;
              }
          }
          
          // 实现 has 函数：仅在指定对象及其子级中查找 annotations
          evaluateHasFunction(objectPath, propertyName, targetValue, data) {
              try {
                  // 获取目标对象
                  let targetObject;
                  if (objectPath === 'this') {
                      // 如果路径是 'this'，直接使用当前上下文对象
                      // 注意：这里的 data 是当前循环中的 item，不是整个数据结构
                      targetObject = data.this || data;
                  } else {
                      targetObject = this.getNestedValue(data, objectPath);
                  }
                  
                  if (!targetObject) {
                      return false;
                  }
                  
                  // 仅在目标对象及其子级中递归查找 annotations
                  return this.searchAnnotationsRecursively(targetObject, propertyName, targetValue);
              } catch (error) {
                  return false;
              }
          }
          
          // 搜索 annotations 的辅助方法（递归搜索指定对象及其所有子级）
          searchAnnotationsRecursively(obj, propertyName, targetValue) {
              if (!obj || typeof obj !== 'object') {
                  return false;
              }
              
              // 如果当前对象有 annotations 数组，检查其中的每个 annotation
              if (Array.isArray(obj.annotations)) {
                  for (const annotation of obj.annotations) {
                      if (this.checkAnnotationProperty(annotation, propertyName, targetValue)) {
                          return true;
                      }
                  }
              }
              
              // 递归检查对象的所有属性（除了 annotations 本身）
              for (const key in obj) {
                  if (obj.hasOwnProperty(key) && key !== 'annotations') {
                      const value = obj[key];
                      
                      // 如果是数组，检查数组中的每个元素
                      if (Array.isArray(value)) {
                          for (const item of value) {
                              if (this.searchAnnotationsRecursively(item, propertyName, targetValue)) {
                                  return true;
                              }
                          }
                      }
                      // 如果是对象，递归检查
                      else if (value && typeof value === 'object') {
                          if (this.searchAnnotationsRecursively(value, propertyName, targetValue)) {
                              return true;
                          }
                      }
                  }
              }
              
              return false;
          }
          
          // 检查单个 annotation 的属性
          checkAnnotationProperty(annotation, propertyName, targetValue) {
              if (!annotation || typeof annotation !== 'object') {
                  return false;
              }
              
              const propertyValue = annotation[propertyName];
              if (propertyValue === undefined || propertyValue === null) {
                  return false;
              }
              
              // 如果属性是 ctrl，使用包含匹配
              if (propertyName === 'ctrl') {
                  return String(propertyValue).includes(targetValue);
              }
              
              // 其他属性使用完全匹配
              return String(propertyValue) === targetValue;
          }
          
          // 解析方法参数
          parseMethodArguments(argsStr) {
              if (!argsStr.trim()) {
                  return [];
              }
              
              const args = [];
              const trimmed = argsStr.trim();
              
              // 简单的参数解析，支持字符串和数字
              const parts = trimmed.split(',').map(part => part.trim());
              
              for (const part of parts) {
                  if (part.startsWith('"') && part.endsWith('"')) {
                      // 双引号字符串
                      args.push(part.slice(1, -1));
                  } else if (part.startsWith("'") && part.endsWith("'")) {
                      // 单引号字符串
                      args.push(part.slice(1, -1));
                  } else if (!isNaN(part)) {
                      // 数字
                      args.push(Number(part));
                  } else if (part === 'true') {
                      args.push(true);
                  } else if (part === 'false') {
                      args.push(false);
                  } else if (part === 'null') {
                      args.push(null);
                  } else {
                      // 其他情况当作字符串处理
                      args.push(part);
                  }
              }
              
              return args;
          }
          
          // Markdown 转义方法
          escapeMarkdown(text) {
              if (!text || typeof text !== 'string') {
                  return text;
              }
              
              let result = text;
              
              // 按照转义规则进行替换
              for (const [pattern, replacement] of this.escapeRules) {
                  // 直接使用字符串替换，避免正则表达式的额外转义
                  result = result.replaceAll(pattern, replacement);
              }
              
              return result;
          }
          
          // 移除模板中的行注释
          removeComments(template) {
              if (!template || typeof template !== 'string') {
                  return template;
              }
              
              // 按行分割模板
              const lines = template.split('\n');
              const processedLines = [];
              
              for (const line of lines) {
                  // 查找 //// 注释的位置
                  const commentIndex = line.indexOf('////');
                  
                  if (commentIndex === -1) {
                      // 没有注释，保留整行
                      processedLines.push(line);
                  } else {
                      // 有注释，只保留注释前的部分
                      const beforeComment = line.substring(0, commentIndex);
                      processedLines.push(beforeComment);
                  }
              }
              
              // 重新组合成字符串
              return processedLines.join('\n');
          }
          
          // 初始化默认解析器
          initDefaultParsers() {
              // 代码块语法解析器 {{<code>type}} - 优先执行
              this.parsers.set('code', {
                  pattern: /\{\{<code>([^}]*)\}\}/g,
                  handler: (match, codeType, content, data) => {
                      const type = codeType.trim();
                      return '' + type + '\n';
                  }
              });
              
              // escape 函数解析器 {{escape(variable)}} - 优先执行
              this.parsers.set('escape', {
                  pattern: /\{\{escape\(([^)]+)\)\}\}/g,
                  handler: function(match, path, content, data) {
                      const value = this.getNestedValue(data, path.trim());
                      return value !== undefined ? this.escapeMarkdown(String(value)) : '';
                  }
              });
              
              // 变量替换解析器 {{variable}} - 最后执行
              this.parsers.set('variable', {
                  pattern: /\{\{([^#\/<][^}]*)\}\}/g,
                  handler: function(match, path, content, data) {
                      const value = this.getNestedValue(data, path.trim());
                      return value !== undefined ? String(value) : '';
                  }
              });
              
              // 条件语句解析器 {{#if condition}}...{{/if}} - 先执行
              this.parsers.set('if', {
                  pattern: /\{\{#if\s+([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g,
                  handler: function(match, condition, content, data) {
                      const conditionValue = this.evaluateCondition(condition, data);
                      return conditionValue ? this.render(content, data) : '';
                  }
              });
              
              // 循环语句解析器 {{#each array}}...{{/each}} - 先执行
              this.parsers.set('each', {
                  pattern: /\{\{#each\s+([^}]+)\}\}([\s\S]*?)\{\{\/each\}\}/g,
                  handler: function(match, arrayPath, content, data) {
                      let array;
                      
                      // 检查是否是 lines() 内联函数调用
                      const linesMatch = arrayPath.match(/^lines\(([^)]+)\)$/);
                      if (linesMatch) {
                          // 处理 lines() 函数
                          const textPath = linesMatch[1].trim();
                          const text = this.getNestedValue(data, textPath);
                          if (typeof text === 'string') {
                              // 按行分割并去除每行的首尾空白字符
                              array = text.split('\n').map(line => line.trim()).filter(line => line.length > 0);
                          } else {
                              array = [];
                          }
                      } else {
                          // 普通的数组路径
                          array = this.getNestedValue(data, arrayPath);
                          if (!Array.isArray(array)) return '';
                      }
                      
                      // 渲染每个数组项
                      
                      const results = array.map((item, index) => {
                           const itemData = { ...data, this: item, index: index, first: index === 0, last: index === array.length - 1 };
                           const rendered = this.render(content, itemData);
                           return rendered;
                       });
                      
                      // 直接连接结果，不添加额外的分隔符，保留模板中原有的换行符
                      const joined = results.join('');
                      return joined;
                  }
              });
          }
          
          // 添加或覆盖解析器
          addParser(name, pattern, handler) {
              this.parsers.set(name, { pattern, handler });
              return this;
          }
          
          // 删除解析器
          removeParser(name) {
              return this.parsers.delete(name);
          }
          
          // 获取所有解析器名称
          getParserNames() {
              return Array.from(this.parsers.keys());
          }
          
          
          preprocess_data(data = {}){
              // 如果数据中没有 items，直接返回
              if (!data.items || !Array.isArray(data.items)) {
                  return data;
              }
              
              const deepcopy = (obj) => JSON.parse(JSON.stringify(obj));
  
              const MINDMAP_COLOR = '粉色';
              const MINDMAP_COLOR2 = 'magenta'
  
              const TITLE_COLOR = '灰色';
              const TITLE_COLOR2 = 'gray'
  
              // 定义 ctrl 字符常量
              const CTRL_CONCAT = '@';
              // const CTRL_JUMP_CONCAT = '@@';
              const CTRL_MM_ROOT = '!';
              const CTRL_MM_NODE = '#';
              const CTRL_LIST = '-';
              const CTRL_ORDER_LIST = 'o';
              const CTRL_MM_BLOCK = 'b';
              const CTRL_END = '<'; //结束拼接
              
              // 处理每个 item 的 attachments
              for (let item of data.items) {
                  if (!item.attachments || !Array.isArray(item.attachments)) {
                      continue;
                  }
                  
                  for (let attachment of item.attachments) {
                      if (!attachment.annotations || !Array.isArray(attachment.annotations)) {
                          continue;
                      }
                      
                      // 第一步：为每个 annotation 提取 ctrl 字段
                      const rawAnnotations = attachment.annotations.map(annotation => {
                          const comment = annotation.comment || '';
                          
                          // 提取 ctrl 字段
                          let ctrl = '';
                          if (comment.startsWith('#') || comment.startsWith('!') || comment.startsWith('@') || 
                              comment.startsWith('b') || comment.startsWith('-') || comment.startsWith('o') ) {
                              const match = comment.match(/^[#!@b\-o<]+/);
                              if (match) {
                                  ctrl = match[0];
                                  // 如果 ctrl中含有空格，只取空格前的部分
                                  if (ctrl.includes(' ')) {
                                      ctrl = ctrl.split(' ')[0];
                                  }
                              }
                          }
                          
                          // 真实的 comment 是去掉 ctrl 字符后的内容
                          const realComment = comment.replace(ctrl, '').trim();
                          
                          return {
                              ...annotation,
                              comment: realComment,
                              ctrl: ctrl
                          };
                      });
                      
                      // 第二步：处理拼接逻辑
                      const processedAnnotations = [];
                      let concating = '';
                      let in_concat = false;
                      
                      for (let i = 0; i < rawAnnotations.length; i++) {
                          const annotation = rawAnnotations[i];
                          
                          if (annotation.ctrl.includes(CTRL_CONCAT)) {
                              // 拼接注释文本
                              in_concat = true;
                              concating += annotation.text;
                              
                              // 检查是否需要结束拼接
                              const isLastAnnotation = i === rawAnnotations.length - 1;
                              const nextAnnotation = isLastAnnotation ? null : rawAnnotations[i + 1];
                              const shouldEndConcat = isLastAnnotation || 
                                                    annotation.color !== nextAnnotation?.color ||
                                                    annotation.ctrl.includes(CTRL_END) ||
                                                    !nextAnnotation?.ctrl.includes(CTRL_CONCAT);
                              
                              if (shouldEndConcat) {
                                  // 结束拼接，创建合并后的注释
                                  processedAnnotations.push({
                                      ...annotation,
                                      text: concating,
                                      comment: annotation.comment,
                                      // 在 ctrl中删除 拼接字符
                                      ctrl: annotation.ctrl.replace(CTRL_CONCAT+CTRL_END, '').replace(CTRL_CONCAT, '')
                                  });
                                  concating = '';
                                  in_concat = false;
                              }
                          } else {
                              // 普通注释，直接添加
                              processedAnnotations.push(annotation);
                          }
                      }
  
                      // 判断一个字符串是否以数字，或者小数开头，如 1, 1., 1.1
                      // 用于判断是否是 orderlist item
                      const startWithNumber = (str) => /^\d+(\.\d+)?\.?/.test(str);
                      // 把字符串的序号提取出来，如 1.1, 2.3 等 ，返回 1.1, 2.3
                      const extractOrderNumber = (str) => str.match(/^\d+(\.\d+)?\.?/)[0];
  
                      //拼接 list 和 orderlist
                      const processedAnnotations1 = [];
                      for (let i=0; i<processedAnnotations.length;) {
                          const annotation = processedAnnotations[i];
                          if(annotation.ctrl.includes(CTRL_LIST) ){
                              let listText = annotation.text;
                              let listComment = annotation.comment;
                              // 寻找后面相邻的 list
                              let j=i;
                              while(j+1 < processedAnnotations.length 
                                  && processedAnnotations[j+1].color === annotation.color
                                  && processedAnnotations[j+1].ctrl.includes(CTRL_LIST)){
                                  listText += '\n';
                                  // 有多少个 CTRL_LIST，就有多少个 tab
                                  const tabCount = processedAnnotations[j+1].ctrl.split(CTRL_LIST).length - 1;
                                  listText += '\t'.repeat(tabCount);
                                  listText += CTRL_LIST + ' ' +processedAnnotations[j+1].text;
                                  listComment += '\n' + processedAnnotations[j+1].comment;
                                  j++;
                              }
  
                              // 合并 listText 到 annotation
                              annotation.text = listText;
                              annotation.comment = listComment.trim();
                              annotation.ctrl = annotation.ctrl.replace(CTRL_LIST, '');
                              i = j;
                          }else if(annotation.ctrl.includes(CTRL_ORDER_LIST)){
                              // 处理 orderlist
                              let listText = annotation.text;
                              let listComment = annotation.comment;
                              // 寻找后面相邻的 orderlist
                              let j=i;
                              while(j+1 < processedAnnotations.length 
                                  && processedAnnotations[j+1].color === annotation.color
                                  && (processedAnnotations[j+1].ctrl.includes(CTRL_ORDER_LIST)
                                  || startWithNumber(processedAnnotations[j+1].comment))){
                                  listText += '\n';
                                  // 有多少个 CTRL_ORDER_LIST，就有多少个 tab
                                  const tabCount = processedAnnotations[j+1].ctrl.split(CTRL_ORDER_LIST).length - 1;
                                  listText += '\t'.repeat(tabCount);
                                  let prefix = '';
                                  if(startWithNumber(processedAnnotations[j+1].comment)){
                                      prefix = extractOrderNumber(processedAnnotations[j+1].comment);
                                  }else{
                                      prefix = (j-i+1) + '.';
                                  }
                                  listText += prefix + ' ' +processedAnnotations[j+1].text;
                                  listComment += '\n' + processedAnnotations[j+1].comment;
                                  j++;
                              }
                              // 合并 listText 到 annotation
                              annotation.text = listText;
                              annotation.comment = listComment.trim();
                              i = j;
                              annotation.ctrl = annotation.ctrl.replace(CTRL_ORDER_LIST, '');
                          }
                          processedAnnotations1.push(annotation);
                          i++;
                      }
  
  
                      // 预处理 mindmap的 annotation，将它们单独处理
                      const processedAnnotations2 = [];
                      const mindAnnotations = [];
  
                      // 先看有没有显示指明根节点
                      let isThereRoot = false;
                      for (let annotation of processedAnnotations1) {
                          if(annotation.ctrl.includes(CTRL_MM_ROOT)){
                                  isThereRoot = true;
                          }
                      }
                      for (let annotation of processedAnnotations1) {
                          if (annotation.color === MINDMAP_COLOR || annotation.color === MINDMAP_COLOR2) {
                              // mindmap 注释
                              if(annotation.ctrl.includes(CTRL_MM_ROOT)){
                                  annotation.ctrl = annotation.ctrl.replace(CTRL_MM_ROOT, CTRL_MM_NODE);
                                  mindAnnotations.unshift(annotation);
                              }else{
                                  // 非根节点，直接添加，这样把根节点调到最前
                                  // processedAnnotations2.push(annotation);
                                  if(isThereRoot){
                                      if(annotation.ctrl.includes(CTRL_MM_NODE)){
                                          //递推一级 # 变 ##
                                          annotation.ctrl = annotation.ctrl + CTRL_MM_NODE;
                                      }
                                  }
                                  mindAnnotations.push(annotation);
                              }
                              
                          }else if(annotation.color == TITLE_COLOR || annotation.color == TITLE_COLOR2){
                              //处理 title，title 用 comment 修正 text，可添加序号等
                              annotation.text = annotation.comment + ' ' + annotation.text;
                              annotation.comment = '';
                              processedAnnotations2.push(annotation);
                          }else{
                              // 非 mindmap 注释，添加到 processedAnnotations2
                              processedAnnotations2.push(annotation);
                          } 
                      }
                      
                      //再次遍历 mindAnnotations，为 block 添加 占位的 annotation
                      //比如说原先结构是这样：
                      // # 根节点
                      // ## 子节点1
                      // b block1
                      // b block2
                      // ### 孙节点2
                      // 我们需要在 子节点 1 后面添加一个占位的 annotation，变成：
                      // #根节点
                      // ## 子节点1
                      // ###
                      // b block1
                      // b block2
                      // ### 孙节点2
                      // 以便在渲染时，block1 和 block2 能够正确显示
                      const rectifiedMindAnnotations = [];
                      for (let i = 0; i < mindAnnotations.length;) {
                          const annotation = mindAnnotations[i];
                          //如果是 node 节点，直接添加
                          if(annotation.ctrl.includes(CTRL_MM_NODE)){
                              rectifiedMindAnnotations.push(annotation);
                              i++;
                              continue;
                          }
  
                          // 如果是 block，找到连续 block 的结束位置
                          if(annotation.ctrl.includes(CTRL_MM_BLOCK)){
                              // 找到连续 block 的结束位置
                              let blockEndIndex = i;
                              while(blockEndIndex < mindAnnotations.length && 
                                    mindAnnotations[blockEndIndex].ctrl.includes(CTRL_MM_BLOCK)){
                                  blockEndIndex++;
                              }
                              blockEndIndex--; // 回退到最后一个 block 的位置
                              
                              // 在 block 的前、后找标题 node 的 ctrl 长度
                              let prevCtrlLen = 0;
                              let nextCtrlLen = 0;
                              
                              if(i > 0){
                                  prevCtrlLen = mindAnnotations[i-1].ctrl.length;
                              }
                              
                              // 检查 block 后面的下一个节点
                              if(blockEndIndex + 1 < mindAnnotations.length){
                                  nextCtrlLen = mindAnnotations[blockEndIndex + 1].ctrl.length;
                              }
  
                              // 如果前短后长，说明是子节点，需要在 block 前添加一个占位的 annotation
                              if(prevCtrlLen < nextCtrlLen){
                                  // 获取下一个节点的 ctrl 作为占位符的 ctrl
                                  const nextNodeCtrl = (blockEndIndex + 1 < mindAnnotations.length) ? 
                                      mindAnnotations[blockEndIndex + 1].ctrl : 
                                      annotation.ctrl; // 如果没有下一个节点，使用当前 block 的 ctrl
                                  
                                  // 在 block 前面添加一个占位的 annotation
                                  rectifiedMindAnnotations.push({
                                      color: annotation.color,
                                      text: '',
                                      comment: '',
                                      ctrl: nextNodeCtrl
                                  });
                              }
                              
                              // 正常搬移所有连续的 block，把 CTRL_MM_BLOCK 替换为 tab
                              for(let j = i; j <= blockEndIndex && j < mindAnnotations.length; j++){
                                  rectifiedMindAnnotations.push({
                                      ...mindAnnotations[j],
                                      ctrl: mindAnnotations[j].ctrl.replaceAll(CTRL_MM_BLOCK, '\t')
                                  }); 
                              }
                              
                              // 移动到下一个非 block 元素
                              i = blockEndIndex + 1;
                          } else {
                              // 既不是 node 也不是 block，直接添加并递增
                              rectifiedMindAnnotations.push(annotation);
                              i++;
                          }
                      }
  
                      //遍历 processedAnnotations2, 如果有 annotation 的 ctrl 包含 CTRL_MM_BLOCK，
                      // 则将其 ctrl 替换为 tab
                      for(let j = 0; j < processedAnnotations2.length; j++){
                          if(processedAnnotations2[j].ctrl.includes(CTRL_MM_BLOCK)){
                              processedAnnotations2[j].ctrl = processedAnnotations2[j].ctrl.replaceAll(CTRL_MM_BLOCK, '\t');
                          }
                      }
  
                      // 更新 attachment 的 annotations
                      attachment.annotations = processedAnnotations2;
  
                      if(mindAnnotations.length > 0){
                          attachment.mindAnnotations = rectifiedMindAnnotations;
                      }
                  }
              }
              //更新 totalAnnotations，它是每个 item 中所有 attachment 的注释总数
              data.totalAnnotations = data.items.reduce((total, item) => {
                  return total + item.attachments.reduce((sum, attachment) => {
                      return sum + attachment.annotations.length;
                  }, 0);
              }, 0);
  
              data.totalMindAnnotations = data.items.reduce((total, item) => {
                  return total + item.attachments.reduce((sum, attachment) => {
                      return sum + (attachment.mindAnnotations?.length || 0);
                  }, 0);
              }, 0);
              return data;
          }
  
          // 预处理模板，去除独占行的模板标签周围的空格和换行符
          preprocessTemplate(template) {
              // 按行分割模板
              const lines = template.split('\n');
              const processedLines = [];
              
              for (let i = 0; i < lines.length; i++) {
                  const line = lines[i];
                  
                  // 如果是空行，直接保留
                  if (line.trim() === '') {
                      processedLines.push(line);
                      continue;
                  }
                  
                  // 检查是否包含模板标记
                  if (!line.includes('{{') || !line.includes('}}')) {
                      processedLines.push(line);
                      continue;
                  }
                  
                  // 查找所有模板标记的位置
                  const templateMatches = [];
                  let searchIndex = 0;
                  while (searchIndex < line.length) {
                      const startIndex = line.indexOf('{{', searchIndex);
                      if (startIndex === -1) break;
                      
                      const endIndex = line.indexOf('}}', startIndex);
                      if (endIndex === -1) break;
                      
                      templateMatches.push({
                          start: startIndex,
                          end: endIndex + 2
                      });
                      
                      searchIndex = endIndex + 2;
                  }
                  
                  if (templateMatches.length === 0) {
                      processedLines.push(line);
                      continue;
                  }
                  
                  // 获取第一个模板标记之前和最后一个模板标记之后的内容
                  const firstTemplateStart = templateMatches[0].start;
                  const lastTemplateEnd = templateMatches[templateMatches.length - 1].end;
                  
                  const lineStart = line.substring(0, firstTemplateStart);
                  const lineEnd = line.substring(lastTemplateEnd);
                  
                  // 检查行开始字符串是否只包含空格和tab
                  const lineStartOnlyWhitespace = /^[ \t]*$/.test(lineStart);
                  // 检查行尾字符串是否只包含空格和tab
                  const lineEndOnlyWhitespace = /^[ \t]*$/.test(lineEnd);
                  
                  // 如果行开始和行尾都只有空格和tab，则认为是独占行
                  if (lineStartOnlyWhitespace && lineEndOnlyWhitespace) {
                      // 提取所有模板内容（从第一个{{到最后一个}}）
                      const templateContent = line.substring(firstTemplateStart, lastTemplateEnd);
                      
                      // 检查是否包含 {{<code>}} 相关指令
                      const hasCodeTag = /\{\{<code[^}]*\}\}/.test(templateContent);
                      
                      if (hasCodeTag) {
                          // {{<code>}} 指令：只保留模板内容，不添加额外换行符
                          processedLines.push(templateContent);
                      } else {
                          // 独占行的普通模板标签：保留模板内容和原始的行首空白字符
                          processedLines.push({ content: templateContent, isStandalone: true, indent: lineStart });
                      }
                  } else {
                      // 不是独占行（行开始或行尾包含非空格tab字符），保留原样
                      processedLines.push(line);
                  }
              }
              
              // 重新组合，特殊处理独占行
              let result = '';
              
              for (let i = 0; i < processedLines.length; i++) {
                  const item = processedLines[i];
                  
                  if (typeof item === 'object' && item.isStandalone) {
                      // 独占行：只添加模板内容，不添加缩进和换行符
                      // 独占行的定义就是前后只有空格，所以应该移除这些空格
                      result += item.content;
                      
                      // 检查下一个元素是否存在且不是独占行
                      const nextItem = i + 1 < processedLines.length ? processedLines[i + 1] : null;
                      if (nextItem && !(typeof nextItem === 'object' && nextItem.isStandalone)) {
                          // 如果下一个元素不是独占行，则不添加换行符，让下一个元素直接连接
                          // 这样可以实现 "变量名 - 变量值 (字符串)b" 的效果
                      }
                  } else {
                      // 普通行：添加内容
                      result += item;
                      
                      // 只有在不是最后一行时才添加换行符
                      if (i < processedLines.length - 1) {
                          result += '\n';
  					}
                  }
              }
              
              // 去除模板末尾的换行符，避免额外的空行
              // 但是要保留原始模板中的空行结构
              // 不要去除末尾的换行符，因为这可能是模板中有意的空行
              // if (result.endsWith('\n')) {
              //     result = result.substring(0, result.length - 1);
              // }
              
              return result;
          }
  
          // 渲染模板 - 完全重写，使用递归下降解析
          render(template, data = {}) {
              // 首先移除模板中的行注释
              template = this.removeComments(template);
              return this.parseTemplate(template, data);
          }
          
          // 解析模板的主方法
          parseTemplate(template, data, depth = 0) {
              // 只在顶层预处理模板，去除单行模板标签后的换行符
              if (depth === 0) {
                  template = this.preprocessTemplate(template);
              }
              
              let result = '';
              let i = 0;
              
              while (i < template.length) {
                  if (template.substring(i, i + 2) === '{{') {
                      // 找到模板标记的结束位置
                      const endIndex = template.indexOf('}}', i);
                      if (endIndex === -1) {
                          result += template.substring(i);
                          break;
                      }
                      
                      const tag = template.substring(i + 2, endIndex).trim();
                      
                      // 检查是否为单行模板标记（前后都是换行符或开始/结束位置）
                      const isStandaloneLine = this.isStandaloneTemplateLine(template, i, endIndex + 2);
                      
                      if (tag.startsWith('<code>')) {
                          // 处理 code 语法 - 简化版本，不需要结束标签
                          const codeContent = tag.substring(6); // 移除 '<code>' 前缀，获取代码内容
                          
                          // 输出格式：```代码内容<换行>
                          result += '```' + codeContent + '\n';
                          i = endIndex + 2;
                          
                          // 跳过code标签后的换行符，避免多余的空行
                          if (i < template.length && template[i] === '\n') {
                              i++;
                          }
                      } else if (tag.startsWith('escape(') && tag.endsWith(')')) {
                          // 处理 escape 函数
                          const path = tag.substring(7, tag.length - 1).trim(); // 移除 'escape(' 和 ')' 
                          const value = this.getNestedValue(data, path);
                          result += value !== undefined ? this.escapeMarkdown(String(value)) : '';
                          i = endIndex + 2;
                          // escape 函数不跳过换行符，保持原有格式
                      } else if (tag.startsWith('#each ')) {
                          // 处理 each 循环
                          const arrayPath = tag.substring(6).trim();
                          const { content, nextIndex } = this.findBlockContent(template, endIndex + 2, 'each');
                          
                          // 在处理each循环前，检查并移除result末尾的多余空格（但保留换行符）
                          // 这样可以避免缩进累积问题
                          while (result.endsWith('  ') && result.length >= 2) {
                              // 检查倒数第三个字符是否为换行符或者是字符串开头
                              if (result.length === 2 || result[result.length - 3] === '\n') {
                                  // 移除末尾的两个空格，但保留换行符
                                  result = result.substring(0, result.length - 2);
                              } else {
                                  break; // 如果不是换行符后的空格，则停止移除
                              }
                          }
                          
                          let array;
                          // 检查是否是 lines() 内联函数调用
                          const linesMatch = arrayPath.match(/^lines\(([^)]+)\)$/);
                          if (linesMatch) {
                              // 处理 lines() 函数
                              const textPath = linesMatch[1].trim();
                              const text = this.getNestedValue(data, textPath);
                              if (typeof text === 'string') {
                                  // 按行分割并去除每行的首尾空白字符
                                  array = text.split('\n').map(line => line.trim()).filter(line => line.length > 0);
                              } else {
                                  array = [];
                              }
                          } else {
                              // 普通的数组路径
                              array = this.getNestedValue(data, arrayPath);
                          }
                          
                          if (Array.isArray(array)) {
                              // 处理循环内容
                              let loopContent = content;
                              
                              for (let idx = 0; idx < array.length; idx++) {
                                  const currentItem = array[idx];
                                  const itemData = {
                                      ...data,
                                      this: currentItem,
                                      index: idx,
                                      first: idx === 0,
                                      last: idx === array.length - 1,
                                      parent: data  // 父级上下文就是当前的数据上下文
                                  };
                                  
                                  // 在递归调用前，不要预处理循环内容，保持原始缩进
                                  let itemResult = this.parseTemplate(loopContent, itemData, depth + 1);
                                  
                                  // 只移除末尾的多个连续空格（2个或以上），保留单个空格和有意义的分隔符
                                  const beforeSpaceRemoval = itemResult;
                                  itemResult = itemResult.replace(/[ ]{2,}$/, '');
                                  
                                  // 移除每个项目开头的换行符，避免额外的空行
                                  if (itemResult.startsWith('\n')) {
                                      itemResult = itemResult.substring(1);
                                  }
                                  
                                  result += itemResult;
                                  
                                  // 不再在项目之间添加额外的换行符，因为每个项目的结果已经包含了正确的换行符
                                  // 如果不是最后一项，且循环内容以三个换行符结尾，保持换行符结构
                                  // if (idx < array.length - 1 && loopContent.endsWith('\n\n\n')) {
                                  //     result += '\n';
                                  // }
                              }
                              
                              // 如果循环内容以多个换行符结尾，确保在循环结束后保留这些换行符
                              // 检查循环内容的末尾换行符数量
                              const loopEndingNewlines = loopContent.match(/\n*$/);
                              if (loopEndingNewlines && loopEndingNewlines[0].length > 0) {
                                  const expectedEndingNewlines = loopEndingNewlines[0].length;
                                  const currentEndingNewlines = result.match(/\n*$/)[0].length;
                                  if (currentEndingNewlines < expectedEndingNewlines) {
                                      const toAdd = expectedEndingNewlines - currentEndingNewlines;
                                      result += '\n'.repeat(toAdd);
                                  }
                              }
                              
                              // 不再强制移除最后一个换行符，让preprocessTemplate处理独占行的换行符
                              // 只移除多余的空行，但保留必要的换行符
                              // 不移除连续的换行符，保持模板中原有的换行结构
                              // result = result.replace(/\n{3,}/g, '\n\n');
                          }
                          i = nextIndex;
                          // each 循环不应用单行标记逻辑，因为循环内容的换行符应该被保留
                          // 不跳过后面的换行符
                          
                          // 检查循环结束后是否需要添加换行符
                          // 特别处理嵌套循环的情况
                          if (i < template.length) {
                              // 跳过循环结束标签后的空白字符
                              let nextNonWhitespace = i;
                              while (nextNonWhitespace < template.length && 
                                     (template[nextNonWhitespace] === ' ' || template[nextNonWhitespace] === '\t')) {
                                  nextNonWhitespace++;
                              }
                              
                              // 如果下一个非空白字符不是换行符，且不是文件结尾，添加换行符
                              // 但要排除模板结束标签的情况
                              if (nextNonWhitespace < template.length && 
                                  template[nextNonWhitespace] !== '\n' && 
                                  !result.endsWith('\n') &&
                                  !template.substring(nextNonWhitespace).startsWith('{{/each}}')) {
                                  result += '\n';
                              }
                          }
                      } else if (tag.startsWith('#switch ')) {
                          // 处理 switch 语句
                          const switchVariable = tag.substring(8).trim();
                          const { content, nextIndex } = this.findBlockContent(template, endIndex + 2, 'switch');
                          
                          // 解析 switch 内容，查找 case 和 default 块
                          const switchResult = this.parseSwitchContent(content, switchVariable, data);
                          result += switchResult;
                          
                          i = nextIndex;
                      } else if (tag.startsWith('#if ')) {
                          // 处理 if 条件 - 需要检查是否包含 else
                          const condition = tag.substring(4).trim();
                          const { content, nextIndex } = this.findBlockContent(template, endIndex + 2, 'if');
                          
                          // 检查内容中是否包含同级的 {{else}} 或 {{#else}}
                          const elseResult = this.findSameLevelElse(content);
                          if (elseResult.index !== -1) {
                              // 包含 else，分割内容
                              const ifContent = content.substring(0, elseResult.index);
                              const elseContent = content.substring(elseResult.index + elseResult.length);
                              
                              const conditionValue = this.evaluateCondition(condition, data);
                              let selectedContent = conditionValue ? ifContent : elseContent;
                              
                              // 处理选中内容的换行符
                              const startsWithNewline = selectedContent.startsWith('\n');
                              const endsWithNewline = selectedContent.endsWith('\n');
                              
                              // 移除开头和结尾的换行符，避免额外空行
                              if (startsWithNewline) {
                                  selectedContent = selectedContent.substring(1);
                              }
                              if (endsWithNewline) {
                                  selectedContent = selectedContent.substring(0, selectedContent.length - 1);
                              }
                              
                              const selectedResult = this.parseTemplate(selectedContent, data, depth + 1);
                              result += selectedResult;
                              
                              // 如果原来结尾有换行符且有内容，在最后添加换行符
                              if (selectedResult.length > 0 && endsWithNewline) {
                                  result += '\n';
                              }
                          } else {
                              // 不包含 else，按原逻辑处理
                              const conditionValue = this.evaluateCondition(condition, data);
                              
                              if (conditionValue) {
                                  const ifResult = this.parseTemplate(content, data, depth + 1);
                                  result += ifResult;
                              }
                          }
                          i = nextIndex;
                          // if 条件不应用单行标记逻辑，因为条件内容的换行符应该被保留
                          // 不跳过后面的换行符
                      } else if (!tag.startsWith('/')) {
                          // 处理变量替换
                          const value = this.getNestedValue(data, tag);
                          // 处理 null 值，将其转换为空字符串
                          if (value === null || value === undefined) {
                              result += '';
                          } else {
                              result += String(value);
                          }
                          i = endIndex + 2;
                          // 变量替换：不跳过换行符，保持原有格式
                          // 换行符的处理应该由 preprocessTemplate 统一管理
                      } else {
                          // 跳过结束标记（这些应该被 findBlockContent 处理）
                          i = endIndex + 2;
                          // 如果结束标记是单行标记，跳过后面的换行符
                          if (isStandaloneLine && i < template.length && template[i] === '\n') {
                              i++;
                          }
                      }
                  } else {
                      // 普通文本
                      result += template[i];
                      i++;
                  }
              }
              
              // 不再自动移除末尾的换行符，保持模板中原有的换行结构
              // 这样可以确保模板中的空行被正确保留
              // while (result.endsWith('\n\n\n')) {
              //     result = result.substring(0, result.length - 1);
              // }
              
              return result;
          }
          
          // 检查模板标记是否为单独占一行
          isStandaloneTemplateLine(template, startIndex, endIndex) {
              // 找到行的开始和结束
              let lineStart = startIndex;
              while (lineStart > 0 && template[lineStart - 1] !== '\n') {
                  lineStart--;
              }
              
              let lineEnd = endIndex;
              while (lineEnd < template.length && template[lineEnd] !== '\n') {
                  lineEnd++;
              }
              
              const line = template.substring(lineStart, lineEnd);
              
              // 找到第一个{{的位置（相对于行开始）
              const firstBraceStart = line.indexOf('{{');
              if (firstBraceStart === -1) return false;
              
              // 找到最后一个}}的位置（相对于行开始）
              const lastBraceEnd = line.lastIndexOf('}}');
              if (lastBraceEnd === -1) return false;
              
              // 检查第一个{{前的内容是否只有空格和tab
              const beforeFirstBrace = line.substring(0, firstBraceStart);
              const trimmedBefore = beforeFirstBrace.replace(/[ \t]/g, '');
              
              // 检查最后一个}}后的内容是否只有空格和tab
              const afterLastBrace = line.substring(lastBraceEnd + 2);
              const trimmedAfter = afterLastBrace.replace(/[ \t]/g, '');
              
              // 如果第一个{{前和最后一个}}后都只有空格和tab，则为独占行
              return trimmedBefore === '' && trimmedAfter === '';
          }
          
          // 查找同级的 else 标记位置
          findSameLevelElse(content) {
              let depth = 0;
              let i = 0;
              
              while (i < content.length) {
                  if (content.substring(i, i + 2) === '{{') {
                      const endIndex = content.indexOf('}}', i);
                      if (endIndex === -1) {
                          break;
                      }
                      
                      const tag = content.substring(i + 2, endIndex).trim();
                      
                      if (tag.startsWith('#if ')) {
                          depth++;
                      } else if (tag === '/if') {
                          depth--;
                      } else if (tag === 'else' && depth === 0) {
                          // 找到同级的 else
                          return { index: i, length: 8 }; // {{else}} 长度为 8
                      } else if (tag === '#else' && depth === 0) {
                          // 找到同级的 #else
                          return { index: i, length: 9 }; // {{#else}} 长度为 9
                      }
                      
                      i = endIndex + 2;
                  } else {
                      i++;
                  }
              }
              
              return { index: -1, length: 0 }; // 没有找到同级的 else
          }
          
          // 查找块内容（如 {{#each}}...{{/each}} 之间的内容）
          findBlockContent(template, startIndex, blockType) {
              let depth = 1;
              let i = startIndex;
              let content = '';
              
              while (i < template.length && depth > 0) {
                  if (template.substring(i, i + 2) === '{{') {
                      const endIndex = template.indexOf('}}', i);
                      if (endIndex === -1) {
                          break;
                      }
                      
                      const tag = template.substring(i + 2, endIndex).trim();
                      
                      if (tag === `#${blockType}` || tag.startsWith(`#${blockType} `)) {
                          depth++;
                      } else if (tag === `/${blockType}` || (blockType === 'code' && tag.startsWith('<code'))) {
                          depth--;
                          if (depth === 0) {
                              // 对于 code 块，不包含结束标签
                              if (blockType === 'code') {
                                  // 只去除内容末尾的制表符，保留空格和换行符
                                  content = content.replace(/\t+$/, '');
                                  return { content, nextIndex: endIndex + 2 };
                              } else {
                                  // 其他块类型的处理保持不变
                                  content = content.replace(/\t+$/, '');
                                  return { content, nextIndex: endIndex + 2 };
                              }
                          }
                      }
                      
                      if (depth > 0) {
                          // 对于 code 块，不包含开始和结束标签
                          if (blockType === 'code' && (tag.startsWith('<code') || tag === '/code')) {
                              // 跳过 code 标签，不添加到内容中
                          } else {
                              content += template.substring(i, endIndex + 2);
                          }
                      }
                      i = endIndex + 2;
                  } else {
                      if (depth > 0) {
                          content += template[i];
                      }
                      i++;
                  }
              }
              
              return { content, nextIndex: i };
          }
          
          // 解析 switch 内容，查找 case 和 default 块
          parseSwitchContent(content, switchVariable, data) {
              const switchValue = this.getNestedValue(data, switchVariable);
              const switchValueStr = String(switchValue);
              
              let result = '';
              let i = 0;
              let foundMatch = false;
              let defaultContent = '';
              
              while (i < content.length) {
                  if (content.substring(i, i + 2) === '{{') {
                      const endIndex = content.indexOf('}}', i);
                      if (endIndex === -1) {
                          break;
                      }
                      
                      const tag = content.substring(i + 2, endIndex).trim();
                      
                      if (tag.startsWith('#case ')) {
                          // 处理 case 块
                          const caseValue = tag.substring(6).trim();
                          const { content: caseContent, nextIndex } = this.findBlockContent(content, endIndex + 2, 'case');
                          
                          // 解析 case 值（支持字符串字面量）
                          let parsedCaseValue = caseValue;
                          if ((caseValue.startsWith('"') && caseValue.endsWith('"')) || 
                              (caseValue.startsWith("'") && caseValue.endsWith("'"))) {
                              parsedCaseValue = caseValue.slice(1, -1);
                          }
                          
                          // 检查是否匹配
                          if (!foundMatch && switchValueStr === parsedCaseValue) {
                              result = this.parseTemplate(caseContent, data);
                              foundMatch = true;
                          }
                          
                          i = nextIndex;
                      } else if (tag === '#default') {
                          // 处理 default 块
                          const { content: defContent, nextIndex } = this.findBlockContent(content, endIndex + 2, 'default');
                          defaultContent = defContent;
                          i = nextIndex;
                      } else {
                          i = endIndex + 2;
                      }
                  } else {
                      i++;
                  }
              }
              
              // 如果没有找到匹配的 case，使用 default
              if (!foundMatch && defaultContent) {
                  result = this.parseTemplate(defaultContent, data);
              }
              
              return result;
          }
          
          // 简单渲染（处理一层嵌套结构）
          renderSimple(template, data = {}) {
              let result = template;
              
              // 1. 处理 each 循环
              result = result.replace(/\{\{#each\s+([^}]+)\}\}([\s\S]*?)\{\{\/each\}\}/g, (match, arrayPath, content) => {
                  const array = this.getNestedValue(data, arrayPath);
                  if (!Array.isArray(array) || array.length === 0) return '';
                  
                  return array.map((item, index) => {
                           const itemData = { ...data, this: item, index: index, first: index === 0, last: index === array.length - 1 };
                           return this.renderSimple(content, itemData);  // 使用 renderSimple 而不是 render
                       }).join('');
              });
              
              // 2. 处理 if-else 条件（先处理 if-else，再处理简单 if）
              let maxIterations = 10; // 防止无限循环
              while (maxIterations-- > 0) {
                  const beforeReplace = result;
                  
                  // 先处理 if-else 结构 - 使用更精确的匹配模式
                  result = result.replace(/\{\{#if\s+([^}]+)\}\}((?:(?!\{\{#if|\{\{else\}\}|\{\{\/if\}\}).)*)\{\{else\}\}((?:(?!\{\{#if|\{\{\/if\}\}).)*)\{\{\/if\}\}/g, (match, condition, ifContent, elseContent) => {
                      const conditionValue = this.evaluateCondition(condition, data);
                      if (conditionValue) {
                          return ifContent; // 直接返回内容，不递归调用
                      } else {
                          return elseContent; // 直接返回内容，不递归调用
                      }
                  });
                  
                  // 再处理简单 if 结构（不包含 else 的）
                  result = result.replace(/\{\{#if\s+([^}]+)\}\}((?:(?!\{\{#if|\{\{else\}\}|\{\{\/if\}\}).)*)\{\{\/if\}\}/g, (match, condition, content) => {
                      const conditionValue = this.evaluateCondition(condition, data);
                      if (conditionValue) {
                          return content; // 直接返回内容，不递归调用
                      }
                      return '';
                  });
                  
                  // 如果没有变化，跳出循环
                  if (beforeReplace === result) {
                      break;
                  }
              }
              
              // 3. 处理变量替换
              result = result.replace(/\{\{([^#\/][^}]*)\}\}/g, (match, path) => {
                  const value = this.getNestedValue(data, path.trim());
                  return value !== undefined ? String(value) : '';
              });
              
              return result;
          }
          
          // 获取嵌套对象值
          getNestedValue(obj, path) {
              if (!path || typeof path !== 'string') {
                  return undefined;
              }
              
              // 处理父级上下文访问 ../
              if (path.startsWith('../')) {
                  const parentPath = path.substring(3); // 移除 '../' 前缀
                  // 在父级上下文中查找，如果有 parent 属性
                  if (obj.parent) {
                      // 首先尝试在 parent.this 中查找
                      if (obj.parent.this && typeof obj.parent.this === 'object') {
                          const result = this.getNestedValue(obj.parent.this, parentPath);
                          if (result !== undefined) {
                              return result;
                          }
                      }
                      // 如果在 parent.this 中找不到，再在 parent 中查找
                      return this.getNestedValue(obj.parent, parentPath);
                  }
                  return undefined;
              }
              
              // 如果路径以 'this.' 开头，处理 this 对象访问
              if (path.startsWith('this.')) {
                  const thisPath = path.substring(5); // 移除 'this.' 前缀
                  if (thisPath === '') {
                      return obj.this || obj;
                  }
                  
                  // 优先在 this 对象中查找
                  if (obj.this) {
                      const keys = thisPath.split('.');
                      let current = obj.this;
                      
                      for (const key of keys) {
                          if (current == null || typeof current !== 'object') {
                              break;
                          }
                          current = current[key];
                      }
                      
                      if (current !== undefined) {
                          return current;
                      }
                  }
                  
                  // 如果在 this 对象中找不到，尝试在主对象中查找
                  const keys = thisPath.split('.');
                  let current = obj;
                  
                  for (const key of keys) {
                      if (current == null || typeof current !== 'object') {
                          return undefined;
                      }
                      current = current[key];
                  }
                  
                  return current;
              }
              
              // 在主对象中查找（包括 this 属性本身）
              const keys = path.split('.');
              let current = obj;
              
              for (const key of keys) {
                  if (current == null || typeof current !== 'object') {
                      return undefined;
                  }
                  current = current[key];
              }
              
              return current;
          }
          
          // 评估条件表达式
          evaluateCondition(condition, data) {
              const trimmedCondition = condition.trim();
              
              // 优先检查是否包含逻辑操作符（&&, ||）
              if (trimmedCondition.includes('&&') || trimmedCondition.includes('||')) {
                  return this.evaluateLogicalExpression(trimmedCondition, data);
              }
              
              // 检查是否包含方法调用（包含括号但不是逻辑表达式）
              if (trimmedCondition.includes('(') && trimmedCondition.includes(')')) {
                  // 如果包含逻辑操作符，应该已经在上面处理了
                  // 这里只处理真正的方法调用
                  return this.evaluateMethodCall(trimmedCondition, data);
              }
              
              // 检查是否包含比较操作符
              if (trimmedCondition.includes('>') || trimmedCondition.includes('<') || 
                  trimmedCondition.includes('===') || trimmedCondition.includes('!==') ||
                  trimmedCondition.includes('==') || trimmedCondition.includes('!=') ||
                  trimmedCondition.includes('>=') || trimmedCondition.includes('<=')) {
                  return this.evaluateComparison(trimmedCondition, data);
              }
              
              // 简单的字段存在性检查
              const value = this.getNestedValue(data, trimmedCondition);
              const result = Boolean(value && (Array.isArray(value) ? value.length > 0 : true));
              return result;
          }
          
          // 评估比较表达式
          evaluateComparison(expression, data) {
              // 支持的比较操作符（按长度排序，避免匹配错误）
              const operators = ['===', '!==', '>=', '<=', '==', '!=', '>', '<'];
              
              for (const op of operators) {
                  if (expression.includes(op)) {
                      const parts = expression.split(op).map(p => p.trim());
                      if (parts.length === 2) {
                          const leftValue = this.evaluateValue(parts[0], data);
                          const rightValue = this.evaluateValue(parts[1], data);
                          
                          switch (op) {
                              case '>':
                                  return Number(leftValue) > Number(rightValue);
                              case '<':
                                  return Number(leftValue) < Number(rightValue);
                              case '>=':
                                  return Number(leftValue) >= Number(rightValue);
                              case '<=':
                                  return Number(leftValue) <= Number(rightValue);
                              case '===':
                                  return String(leftValue) === String(rightValue);
                              case '!==':
                                  return String(leftValue) !== String(rightValue);
                              case '==':
                                  return String(leftValue) === String(rightValue);
                              case '!=':
                                  return String(leftValue) !== String(rightValue);
                          }
                      }
                      break;
                  }
              }
              return false;
          }
          
          // 评估逻辑表达式
          evaluateLogicalExpression(expression, data) {
              // 处理括号表达式
              if (expression.includes('(') && expression.includes(')')) {
                  // 简单的括号处理：找到最外层括号并递归处理
                  const parenMatch = expression.match(/\(([^)]+)\)/);
                  if (parenMatch) {
                      const innerExpression = parenMatch[1];
                      const innerResult = this.evaluateCondition(innerExpression, data);
                      
                      // 替换括号表达式为结果，然后继续处理
                      const replacedExpression = expression.replace(parenMatch[0], innerResult.toString());
                      
                      // 如果替换后的表达式仍包含逻辑运算符，继续递归处理
                      if (replacedExpression.includes('&&') || replacedExpression.includes('||')) {
                          return this.evaluateLogicalExpression(replacedExpression, data);
                      } else {
                          // 否则直接评估替换后的表达式
                          return this.evaluateCondition(replacedExpression, data);
                      }
                  }
              }
              
              // 处理 && 操作符
              if (expression.includes('&&')) {
                  const parts = expression.split('&&').map(p => p.trim());
                  return parts.every(part => {
                      // 如果部分是布尔字符串，直接转换
                      if (part === 'true') return true;
                      if (part === 'false') return false;
                      return this.evaluateCondition(part, data);
                  });
              }
              
              // 处理 || 操作符
              if (expression.includes('||')) {
                  const parts = expression.split('||').map(p => p.trim());
                  return parts.some(part => {
                      // 如果部分是布尔字符串，直接转换
                      if (part === 'true') return true;
                      if (part === 'false') return false;
                      return this.evaluateCondition(part, data);
                  });
              }
              
              return false;
          }
          
          // 评估值（可能是变量、字符串或数字）
          evaluateValue(value, data) {
              const trimmed = value.trim();
              
              // 字符串字面量
              if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
                  (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
                  return trimmed.slice(1, -1);
              }
              
              // 布尔字面量
              if (trimmed === 'true') {
                  return true;
              }
              if (trimmed === 'false') {
                  return false;
              }
              
              // 数字字面量
              if (!isNaN(trimmed) && trimmed !== '') {
                  return Number(trimmed);
              }
              
              // 变量
              return this.getNestedValue(data, trimmed);
          }
          
          // 评估方法调用表达式
          evaluateMethodCall(expression, data) {
              try {
                  // 检查是否是 has 函数调用
                  const hasMatch = expression.match(/^has\(([^,]+),\s*['"]([^'"]+)['"],\s*['"]([^'"]+)['"]\)$/);
                  if (hasMatch) {
                      const [, objectPath, propertyName, targetValue] = hasMatch;
                      return this.evaluateHasFunction(objectPath.trim(), propertyName, targetValue, data);
                  }
                  
                  // 解析方法调用表达式，如 "this.comment.startsWith('bb')"
                  const methodCallMatch = expression.match(/^(.+?)\.([^.()]+)\(([^)]*)\)$/);
                  if (!methodCallMatch) {
                      return false;
                  }
                  
                  const [, objectPath, methodName, argsStr] = methodCallMatch;
                  
                  // 获取对象
                  const obj = this.getNestedValue(data, objectPath);
                  
                  if (!obj) {
                      return false;
                  }
                  
                  // 检查方法是否存在
                  if (typeof obj[methodName] !== 'function') {
                      return false;
                  }
                  
                  // 解析参数
                  const args = this.parseMethodArguments(argsStr);
                  
                  // 执行方法调用
                  const result = obj[methodName].apply(obj, args);
                  
                  // 返回布尔值结果
                  return Boolean(result);
                  
              } catch (error) {
                  return false;
              }
          }
          
          // 解析方法参数
          parseMethodArguments(argsStr) {
              if (!argsStr.trim()) {
                  return [];
              }
              
              const args = [];
              const trimmed = argsStr.trim();
              
              // 简单的参数解析，支持字符串和数字
              const parts = trimmed.split(',').map(part => part.trim());
              
              for (const part of parts) {
                  if (part.startsWith('"') && part.endsWith('"')) {
                      // 双引号字符串
                      args.push(part.slice(1, -1));
                  } else if (part.startsWith("'") && part.endsWith("'")) {
                      // 单引号字符串
                      args.push(part.slice(1, -1));
                  } else if (!isNaN(part)) {
                      // 数字
                      args.push(Number(part));
                  } else if (part === 'true') {
                      args.push(true);
                  } else if (part === 'false') {
                      args.push(false);
                  } else if (part === 'null') {
                      args.push(null);
                  } else {
                      // 其他情况当作字符串处理
                      args.push(part);
                  }
              }
              
              return args;
          }
          
          // 重置引擎（清除所有自定义解析器，恢复默认）
          reset() {
              this.parsers.clear();
              this.initDefaultParsers();
              return this;
          }
          
          // 销毁单例实例
          static destroy() {
              if (GlobalTemplateEngine.instance) {
                  delete globalThis.TemplateEngine;
                  GlobalTemplateEngine.instance = null;
              }
          }
      }
      
      // 将单例实例添加到 globalThis
      if (!globalThis.TemplateEngine) {
          globalThis.TemplateEngine = new GlobalTemplateEngine();
      }
      
      // 提供便捷的销毁方法
      globalThis.TemplateEngine.destroy = GlobalTemplateEngine.destroy;
      
      // Node.js 环境下的导出
      if (typeof module !== 'undefined' && module.exports) {
          module.exports = GlobalTemplateEngine;
      }
      
  })();
  
  return "";
  
  }}$
  
  
  
  // @beforeloop-end
  
  // @default-begin
  
  ${{
  
  const console = Zotero.getMainWindow().console;
  
  
  
  await (async function() {
  
  sharedObj.itemData = {
                  id: topItem.id,
                  key: topItem.key,
                  title: topItem.getField('title'),
                  attachments: []
              };
  
  // 获取该 item 的所有附件
              const attachments = await topItem.getAttachments();
              
              
              for (let attachmentID of attachments) {
                  
                  const attachment = await Zotero.Items.getAsync(attachmentID);
                  
                  // 检查是否是 PDF 附件
                  // if (attachment.attachmentContentType !== 'application/pdf') {
                  //     continue;
                  // }
                  
                  const attachmentTitle = attachment.getField('title') || 'Untitled PDF';
                  
                  const attachmentData = {
                      id: attachment.id,
                      key: attachment.key,
                      title: attachmentTitle,
                      annotations: []
                  };
                  
                  // 获取该附件的所有 annotations
                  const annotations = attachment.getAnnotations();
                  
                  if (annotations.length === 0) {
                      //console.log("  该附件没有 annotations");
                      //sharedObj.itemData.attachments.push(attachmentData);
                      continue;
                  }
                  
                  // 格式化颜色映射
                  const colorMap = {
                      '#ffd400': '黄色',
                      '#ff6666': '红色',
                      '#5fb236': '绿色',
                      '#2ea8e5': '蓝色',
                      '#a28ae5': '紫色',
                      '#e56eee': '粉色',
                      '#f19837': '橙色',
                      '#aaaaaa': '灰色'
                  };
                  
                  // 收集原始 annotation 数据
                  for (let annotation of annotations) {
                      // 获取 annotation 的基本信息
                      const color = annotation.annotationColor || 'default';
                      const text = annotation.annotationText || '';
                      const comment = annotation.annotationComment || '';
                      
                      // 获取页码信息
                      let pageNumber = 1;
                      if (annotation.annotationPageLabel) {
                          pageNumber = annotation.annotationPageLabel;
                      } else if (annotation.annotationPosition && annotation.annotationPosition.pageIndex !== undefined) {
                          pageNumber = annotation.annotationPosition.pageIndex + 1;
                      }
                      
                      const colorName = colorMap[color] || color || '默认';
                      
                      // 添加到 attachmentData.annotations 数组
                      attachmentData.annotations.push({
                          id: annotation.id,
                          key: annotation.key,
                          pageNumber: pageNumber,
                          color: colorName,
                          text: text,
                          comment: comment
                      });
                  }
  
                  sharedObj.itemData.attachments.push(attachmentData);
  
              }
  
  
  })();
  
  return "";
  
  }}$
  
  // @default-end
  
  
  // @afterloop-begin
  
  ${{
  
  const console = Zotero.getMainWindow().console;
  
  
  
  const markdownTemplate = `{{#each items}}
      {{#each this.attachments}}
  # 条目：[{{../title}}](zotero://select/library/items/{{../key}}) 
  - 文件：[{{this.title}}](zotero://select/library/items/{{this.key}})
  
          {{#if this.mindAnnotations}}
  # 内容纲要
  
              {{<code>markmap}}
                  {{#each this.mindAnnotations}}
                  {{this.ctrl}} {{escape(this.text)}}
  
                  {{/each}}
              {{<code>}}
          {{/if}}  //// end of mindmap
  
  # 注记
  
          {{#each this.annotations}}
              {{#each lines(this.text)}}
  {{#if ../color == '绿色'}}>{{/if}}{{../ctrl}} {{#if ../color == '绿色'}}【引例】 _{{/if}}{{#if ../color == '橙色'}}【金句】**_{{/if}}{{escape(this)}}{{#if ../color == '橙色'}}_**{{/if}}{{#if ../color == '绿色'}}_{{/if}}
  
  {{#if ../color == '橙色' || ../color == '红色' || ../color == '蓝色'}}[({{../../../title}}, {{../pageNumber}})](zotero://open-pdf/library/items/{{../../key}}?page={{../pageNumber}}&annotation={{../key}})
  {{/if}}
              {{/each}}
              {{#if this.comment}}
  
              {{/if}}
              {{#each lines(this.comment)}}
  【批注】 **{{this}}**
              {{/each}}
  
  
  ---
          {{/each}}  //// end of annotations
  
      {{/each}}   //// end of attachments
  {{/each}}  //// end of items
  `;
  
        let rendered ="";
          try {
              // 在渲染模板之前，先调用 preprocess_data 处理数据
  			const reportData = {
              itemCount: 1,
              items: []
          	};
  			reportData.items.push(sharedObj.itemData);
              const processedData = globalThis.TemplateEngine.preprocess_data(reportData);
              rendered = globalThis.TemplateEngine.render(markdownTemplate, processedData);
  			//const clipboard = Components.classes["@mozilla.org/widget/clipboardhelper;1"]
              //.getService(Components.interfaces.nsIClipboardHelper);
          	//clipboard.copyString(rendered);
  			rendered = Zotero.BetterNotes.api.convert.md2html(rendered);
  
          } catch (templateError) {
              console.error("模板渲染出错:", templateError);
              console.log("使用简化输出格式：");
              
              
          }
  
  return rendered;
          
  }}$
  
  
  // @afterloop-end

Anything else

使用技巧

1 颜色含义

• 黄色：普通批注，在笔记中正体显示
• 红色：普通批注带引用链接
• 绿色：引语，在笔记中斜体包裹显示
• 蓝色：引语，带引用链接
• 粉色：脑图，出现在笔记“内容大纲”中
• 橙色：金句名言，在笔记中粗体显示
• 灰色：用于笔记结构分割、标题高亮

这些颜色的意义，以及它们如何转化为具体格式，可使用模版实现的 handlebar 语言更改。

2 控制生成 note 的内容

除颜色外，控制生成 note 的内容格式主要依靠在批注时给每个 annotation 的 comment 加一些特殊字符。

• @代表向后拼接 @<表示拼接结束（或者到最后一个没有 @ 注释的同色高亮）。可将散乱的高亮批注在笔记中拼接为一整段。下面的例子中，两个批注最终在笔记中输出为一句话。

• - 表示无序列表开始，--表示无序列表的内容。o表示有序列表的开始，oo表示有序列表的内容，模版会为有序列表自动编号。以下是例子。

这是笔记中的列表拼接结果：

• 灰色用于控制章节分段，给它加上#、 ## 这样的注释，可以让章节更有层次感，也可以在后面跟上一个章节号，使笔记内容的索引更加清晰。下面是例子。

生成到笔记中的结果：

• 粉色（洋红色）做脑图线索分割。#代表第一级，##代表第二级，!代表根（可选）。可以用 b 和 bb 前缀注释将一段粉色内容放进脑图，一个 b 表示缩进一格。脑图在缺省的模版中显示在“内容大纲”部分，不在正文中重复显示。

脑图在 Zotero 笔记中没法渲染，以下是在 Obsidian 中通过插件的渲染结果：

注意，comment 里的控制字符必须位于 comment 开始。最好控制字符和用户自己要加入的 comment 之间有个空格（不强求）。comment 控制格式的方式并不影响最终笔记将真正的注释输出。

事实上，用户的 comment 会在笔记中粗体显示。

下图的右下角【批注】后面的内容来自用户 comment：

5. 如何定制

在模版源代码的大约 1700 行左右，有markdownTemplate 这个变量，里面存放了 handlebar 语法的笔记生成母板。

笔记母板的语法可参考https://github.com/aidecameron/zotero-af2n/blob/main/af2n_template_guide.md

6. 如何将结果以 markdown 格式拷贝到 Obsidian

在模版源代码的最后，把复制到剪贴板的几行注释打开，保存模版。即可开启复制生成的笔记到剪贴板功能。在以下的版本中，是 1775 到 1777 这三行，把这三行开始的//去掉即可，记得保存模版才会生效。

作者

欢迎访问作者博客 http://blog.aidecameron.com，公众号“ai的十日谈”。

关于代码 bug 与提升可以到 https://github.com/aidecameron/zotero-af2n