{
    "schemaVersion": 1,
    "metadata": {
        "plugin": "dataview",
        "version": "2.0.0",
        "title": "Dataview",
        "description": "Complex data views for the data-obsessed.",
        "language": "zh-cn",
        "supportedVersions": "0.5.68",
        "author": ""
    },
    "dict": {
        "main.js": {
            "ast": [],
            "regex": [
                {
                    "source": "name: \"Dataview Indexer \"",
                    "target": "name: \"Dataview 索引器 \""
                },
                {
                    "source": "name: \"Force refresh all views and blocks\"",
                    "target": "name: \"强制刷新所有视图和块\""
                },
                {
                    "source": "name: \"Drop all cached file metadata\"",
                    "target": "name: \"清除所有缓存的文件元数据\""
                },
                {
                    "source": "name: \"Rebuild current view\"",
                    "target": "name: \"重建当前视图\""
                },
                {
                    "source": "description: \"Cache metadata about files and sections in the dataview index.\"",
                    "target": "description: \"缓存 dataview 索引中文件和部分的元数据。\""
                },
                {
                    "source": ".setName(\"Enable inline queries\")",
                    "target": ".setName(\"启用内联查询\")"
                },
                {
                    "source": ".setName(\"Enable JavaScript queries\")",
                    "target": ".setName(\"启用 JavaScript 查询\")"
                },
                {
                    "source": ".setName(\"Enable inline JavaScript queries\")",
                    "target": ".setName(\"启用内联JavaScript查询\")"
                },
                {
                    "source": ".setName(\"Enable inline field highlighting in reading view\")",
                    "target": ".setName(\"在阅读视图中启用内联字段高亮显示\")"
                },
                {
                    "source": ".setName(\"Enable inline field highlighting in Live Preview\")",
                    "target": ".setName(\"在实时预览中启用内联字段高亮显示\")"
                },
                {
                    "source": ".setName(\"Codeblocks\")",
                    "target": ".setName(\"代码块\")"
                },
                {
                    "source": ".setName(\"DataviewJS keyword\")",
                    "target": ".setName(\"数据视图JS关键字\")"
                },
                {
                    "source": ".setName(\"Inline query prefix\")",
                    "target": ".setName(\"内联查询前缀\")"
                },
                {
                    "source": ".setName(\"JavaScript inline query prefix\")",
                    "target": ".setName(\"JavaScript 内联查询前缀\")"
                },
                {
                    "source": ".setName(\"Code block inline queries\")",
                    "target": ".setName(\"代码块内查询\")"
                },
                {
                    "source": ".setName(\"View\")",
                    "target": ".setName(\"查看\")"
                },
                {
                    "source": ".setName(\"Display result count\")",
                    "target": ".setName(\"显示结果数量\")"
                },
                {
                    "source": ".setName(\"Warn on empty result\")",
                    "target": ".setName(\"在结果为空时警告\")"
                },
                {
                    "source": ".setName(\"Render null as\")",
                    "target": ".setName(\"将 null 渲染为\")"
                },
                {
                    "source": ".setName(\"Automatic view refreshing\")",
                    "target": ".setName(\"自动视图刷新\")"
                },
                {
                    "source": ".setName(\"Refresh interval\")",
                    "target": ".setName(\"刷新间隔\")"
                },
                {
                    "source": ".setName(\"Date format\")",
                    "target": ".setName(\"日期格式\")"
                },
                {
                    "source": ".setName(\"Date + time format\")",
                    "target": ".setName(\"日期 + 时间格式\")"
                },
                {
                    "source": ".setName(\"Tables\")",
                    "target": ".setName(\"表格\")"
                },
                {
                    "source": ".setName(\"Primary column name\")",
                    "target": ".setName(\"主列名称\")"
                },
                {
                    "source": ".setName(\"Grouped column name\")",
                    "target": ".setName(\"分组列名称\")"
                },
                {
                    "source": ".setName(\"Tasks\")",
                    "target": ".setName(\"任务\")"
                },
                {
                    "source": ".setName(\"Automatic task completion tracking\")",
                    "target": ".setName(\"自动任务完成跟踪\")"
                },
                {
                    "source": ".setName(\"Use emoji shorthand for completion\")",
                    "target": ".setName(\"使用表情符号简写完成任务\")"
                },
                {
                    "source": ".setName(\"Completion field name\")",
                    "target": ".setName(\"完成字段名称\")"
                },
                {
                    "source": ".setName(\"Completion date format\")",
                    "target": ".setName(\"完成日期格式\")"
                },
                {
                    "source": ".setName(\"Recursive sub-task completion\")",
                    "target": ".setName(\"递归子任务完成\")"
                },
                {
                    "source": ".setDesc(\"Enable or disable executing regular inline Dataview queries.\")",
                    "target": ".setDesc(\"启用或禁用执行常规的内联 Dataview 查询。\")"
                },
                {
                    "source": ".setDesc(\"Enable or disable executing DataviewJS queries.\")",
                    "target": ".setDesc(\"启用或禁用执行 DataviewJS 查询。\")"
                },
                {
                    "source": ".setDesc(\"Enable or disable executing inline DataviewJS queries. Requires that DataviewJS queries are enabled.\")",
                    "target": ".setDesc(\"启用或禁用执行内联 DataviewJS 查询。需要 DataviewJS 查询已启用。\")"
                },
                {
                    "source": ".setDesc(\"Enables or disables visual highlighting / pretty rendering for inline fields in reading view.\")",
                    "target": ".setDesc(\"在阅读视图中启用或禁用内联字段的视觉高亮显示/美观渲染。\")"
                },
                {
                    "source": ".setDesc(\"Enables or disables visual highlighting / pretty rendering for inline fields in Live Preview.\")",
                    "target": ".setDesc(\"启用或禁用实时预览中内联字段的视觉高亮显示/美化渲染。\")"
                },
                {
                    "source": ".setDesc(\"Keyword for DataviewJS blocks. Defaults to 'dataviewjs'. Reload required for changes to take effect.\")",
                    "target": ".setDesc(\"数据视图JS块的关键字。默认为'dataviewjs'。更改后需要重新加载以生效。\")"
                },
                {
                    "source": ".setDesc(\"The prefix to inline queries (to mark them as Dataview queries). Defaults to '='.\")",
                    "target": ".setDesc(\"内联查询的前缀（用于标记为Dataview查询）。默认为'='。\")"
                },
                {
                    "source": ".setDesc(\"The prefix to JavaScript inline queries (to mark them as DataviewJS queries). Defaults to '$='.\")",
                    "target": ".setDesc(\"JavaScript 内联查询的前缀（用于将其标记为 DataviewJS 查询）。默认值为 '$='。\")"
                },
                {
                    "source": ".setDesc(\"If toggled off, the small number in the result header of TASK and TABLE queries will be hidden.\")",
                    "target": ".setDesc(\"如果切换关闭，TASK 和 TABLE 查询结果头部的小数字将被隐藏。\")"
                },
                {
                    "source": ".setDesc(\"If set, queries which return 0 results will render a warning message.\")",
                    "target": ".setDesc(\"如果设置了该选项，返回0结果的查询将显示警告信息。\")"
                },
                {
                    "source": ".setDesc(\"What null/non-existent should show up as in tables, by default. This supports Markdown notation.\")",
                    "target": ".setDesc(\"在表格中默认应显示什么为空/不存在。这支持Markdown语法。\")"
                },
                {
                    "source": ".setDesc(\"If enabled, views will automatically refresh when files in your vault change; this can negatively affect\" +\n            \" some functionality like embeds in views, so turn it off if such functionality is not working.\")",
                    "target": ".setDesc(\"如果启用,当保险库中的文件更改时,视图将自动刷新;这可能会产生负面影响。\" +\n            \" 如果某些功能,比如视图中的嵌入功能无法正常工作,请关闭它们。\")"
                },
                {
                    "source": ".setDesc(\"How long to wait (in milliseconds) for files to stop changing before updating views.\")",
                    "target": ".setDesc(\"在更新视图之前，等待文件停止更改的时间（以毫秒为单位）。\")"
                },
                {
                    "source": ".setDesc(\"The name of the default ID column in tables; this is the auto-generated first column that links to the source file.\")",
                    "target": ".setDesc(\"表格中默认ID列的名称；这是自动生成的第一列，用于链接到源文件。\")"
                },
                {
                    "source": ".setDesc(\"The name of the default ID column in tables, when the table is on grouped data; this is the auto-generated first column\" +\n            \"that links to the source file/group.\")",
                    "target": ".setDesc(\"在表格对分组数据进行操作时,默认ID列的名称;这是自动生成的第一列\" +\n            \"链接到file/groupp.\")"
                },
                {
                    "source": ".setDesc(\"If enabled, completing a task in a Dataview will automatically complete its subtasks too.\")",
                    "target": ".setDesc(\"如果启用，在数据视图中完成一个任务将自动完成其子任务。\")"
                },
                {
                    "source": ".appendText(\"Example with default field name and date format: - [x] my task [completion:: 2022-01-01]\")",
                    "target": ".appendText(\"默认的文件名与日期格式 : - [x] 我的任务 [completion:: 2022-01-01]\")"
                },
                {
                    "source": ".appendText('If enabled, will use emoji shorthand instead of inline field formatting to fill out implicit task field \"completion\".')",
                    "target": ".appendText('如果启用，将使用表情符号简写代替内联字段格式来填写隐式任务字段“完成”。')"
                },
                {
                    "source": ".appendText(\"Example: - [x] my task ✅ 2022-01-01\")",
                    "target": ".appendText(\"- [x] 我的任务 ✅ 2022-01-01\")"
                },
                {
                    "source": ".appendText(\"Text used as inline field key for task completion date when toggling a task's checkbox in a Dataview view.\")",
                    "target": ".appendText(\"在 Dataview 视图中切换任务复选框时用作内联字段键的任务完成日期。\")"
                },
                {
                    "source": "\"that links to the source file/group.\")",
                    "target": "\"链接到源文件/组.\")"
                },
                {
                    "source": "\" Currently: \" +",
                    "target": "\" 当前: \" +"
                },
                {
                    "source": "return \"Got the end of the input\"",
                    "target": "return \"得到输入的结尾\""
                },
                {
                    "source": "\"Expected one of the following:",
                    "target": "\"预期出现以下情况之一:"
                },
                {
                    "source": "\"Not a comment\"",
                    "target": "\"非释义\""
                },
                {
                    "source": "\"-- PARSING FAILED \"",
                    "target": "\"-- 解析失败 \""
                },
                {
                    "source": "message: \"Dataview: No results to show for list query.\"",
                    "target": "message: \"数据视图: 列表查询没有结果显示。\""
                },
                {
                    "source": "message: \"Dataview: No results to show for task query.\"",
                    "target": "message: \"数据视图: 任务查询没有结果显示。\""
                },
                {
                    "source": "message: \"Dataview: No results to show for table query.\"",
                    "target": "message: \"数据视图: 表查询没有结果显示。\""
                },
                {
                    "source": "Error(\"Super expression must either be null or a function\"",
                    "target": "Error(\"超表达式必须为 null 或函数\""
                },
                {
                    "source": "Error(\"Invalid unit value \"",
                    "target": "Error(\"单位值无效\""
                },
                {
                    "source": "Error(\"Value format \"",
                    "target": "Error(\"值格式\""
                },
                {
                    "source": "Error(\"Unknown duration argument \"",
                    "target": "Error(\"未知持续时间参数\""
                },
                {
                    "source": "Error(\"need to specify a reason the Duration is invalid\"",
                    "target": "Error(\"需要指定持续时间无效的原因\""
                },
                {
                    "source": "Error(\"need to specify a reason the Interval is invalid\"",
                    "target": "Error(\"需要指定间隔无效的原因\""
                },
                {
                    "source": "Error(\"Can't include meridiem when specifying 24-hour format\"",
                    "target": "Error(\"指定24小时格式时不能包含子午线\""
                },
                {
                    "source": "Error(\"fromSeconds requires a numerical input\"",
                    "target": "Error(\"fromSeconds 需要数字输入\""
                },
                {
                    "source": "Error(\"Can't mix weekYear/weekNumber units with year/month/day or ordinals\"",
                    "target": "Error(\"不能将周年/周数字单位与年/月/日或序数混合使用\""
                },
                {
                    "source": "Error(\"Can't mix ordinal dates with month/day\"",
                    "target": "Error(\"不能将序号日期与月/日混合使用\""
                },
                {
                    "source": "Error(\"fromFormat requires an input string and a format\"",
                    "target": "Error(\"fromFormat 需要输入字符串和格式\""
                },
                {
                    "source": "Error(\"need to specify a reason the DateTime is invalid\"",
                    "target": "Error(\"需要指定 DateTime 无效的原因\""
                },
                {
                    "source": "Error(\"min requires all arguments be DateTimes\"",
                    "target": "Error(\"min 要求所有参数都是 DateTimes\""
                },
                {
                    "source": "Error(\"max requires all arguments be DateTimes\"",
                    "target": "Error(\"max 要求所有参数都是 DateTimes\""
                },
                {
                    "source": "Error(\"Unknown datetime argument: \"",
                    "target": "Error(\"未知日期时间参数:\""
                },
                {
                    "source": "Error(\"The bits [\"",
                    "target": "Error(\"比特[\""
                },
                {
                    "source": "Error(\"not a parser: \"",
                    "target": "Error(\"不是解析器:\""
                },
                {
                    "source": "Error(\"not a number: \"",
                    "target": "Error(\"不是数字:\""
                },
                {
                    "source": "Error(\"not a function: \"",
                    "target": "Error(\"不是函数:\""
                },
                {
                    "source": "Error(\"not a string: \"",
                    "target": "Error(\"不是字符串:\""
                },
                {
                    "source": "Error(\"seqMap needs at least one argument\"",
                    "target": "Error(\"seqMap 至少需要一个参数\""
                },
                {
                    "source": "Error(\"not a regexp: \"",
                    "target": "Error(\"不是正则表达式:\""
                },
                {
                    "source": "Error('unsupported regexp flag \"'",
                    "target": "Error('不支持的正则表达式标志\"'"
                },
                {
                    "source": "Error(\"not a string, regexp, or parser: \"",
                    "target": "Error(\"不是字符串, 正则表达式或解析器:\""
                },
                {
                    "source": "Error(\".parse must be called with a string or Buffer as its argument\"",
                    "target": "Error(\".parse 必须以字符串或 Buffer 作为参数调用\""
                },
                {
                    "source": "Error(\"infinite loop detected in .many() parser --- calling .many() on a parser which can accept zero characters is usually the cause\"",
                    "target": "Error(\"在.many()解析器中检测到无限循环——通常是在可以接受零字符的解析器上调用.mony()\""
                },
                {
                    "source": "Error(\"not an array: \"",
                    "target": "Error(\"不是数组:\""
                },
                {
                    "source": "Error(\"seqObj: duplicate key \"",
                    "target": "Error(\"seqObj:重复密钥\""
                },
                {
                    "source": "Error(\"duplicate key in bitSeqObj: \"",
                    "target": "Error(\"bitSeqObj 中的重复密钥:\""
                },
                {
                    "source": "Error(\"Value specified to byte constructor (\"",
                    "target": "Error(\"为字节构造函数指定的值(\""
                },
                {
                    "source": "Error(\"Option columns is empty\"",
                    "target": "Error(\"选项列为空\""
                },
                {
                    "source": "Error(\"Unable to serialize unrecognized input\"",
                    "target": "Error(\"无法序列化无法识别的输入\""
                },
                {
                    "source": "Error(\"Comment character same as delimiter\"",
                    "target": "Error(\"注释字符与分隔符相同\""
                },
                {
                    "source": "Error(\"Input must be a string\"",
                    "target": "Error(\"输入必须是字符串\""
                },
                {
                    "source": "Error(\"Not implemented.\"",
                    "target": "Error(\"未执行。\""
                },
                {
                    "source": "Error(\"Unrecognized transferable value: \"",
                    "target": "Error(\"无法识别的可转让价值:\""
                },
                {
                    "source": "Error(\"Cannot find module '\"",
                    "target": "Error(\"找不到模块'\""
                },
                {
                    "source": "Error('resolver must be a function'",
                    "target": "Error('解析器必须是一个函数'"
                },
                {
                    "source": "Error('Cannot resolve promise with itself'",
                    "target": "Error('无法自行解析 promise'"
                },
                {
                    "source": "Error('must be an array'",
                    "target": "Error('必须是数组'"
                },
                {
                    "source": "Error(\"Cannot call a class as a function\"",
                    "target": "Error(\"不能将类作为函数调用\""
                },
                {
                    "source": "Error('Failed to get type for BinaryArray'",
                    "target": "Error('无法获取 BinaryArray 的类型'"
                },
                {
                    "source": "error(\"Couldn't convert value into a JSON string: \"",
                    "target": "error(\"无法将值转换为 JSON 字符串:\""
                },
                {
                    "source": "Error('Unkown type: '",
                    "target": "Error('未知类型:'"
                },
                {
                    "source": "Error('Database version must be a number.'",
                    "target": "Error('数据库版本必须是数字。'"
                },
                {
                    "source": "Error('Driver not found.'",
                    "target": "Error('找不到驱动程序。'"
                },
                {
                    "source": "Error('No available storage method found.'",
                    "target": "Error('找不到可用的存储方法。'"
                },
                {
                    "source": "Error(`Unrecognized argument type for argument '${arg}'`",
                    "target": "Error(`参数'${arg}'的参数类型无法识别`"
                },
                {
                    "source": "Error(`No implementation of '${this.name}' found for arguments: ${types.join(\", \")}`",
                    "target": "Error(`找不到参数'${this.name}'的实现: ${types.join(\", \")}`"
                },
                {
                    "source": "Error(\"object() requires an even number of arguments\"",
                    "target": "Error(\"object()需要偶数个参数\""
                },
                {
                    "source": "Error(\"keys should be of type string for object(key1, value1, ...)\"",
                    "target": "Error(\"对象的键应为字符串类型(key1, value1, …)\""
                },
                {
                    "source": "Error(\"extract(object, key1, ...) must be called with string keys\"",
                    "target": "Error(\"必须使用字符串键调用 extract(object, key1, …)\""
                },
                {
                    "source": "Error(`Invalid regexp '${pat}' in regexreplace`",
                    "target": "Error(`regexreplace 中的正则表达式'${pat}'无效`"
                },
                {
                    "source": "Error('Invalid argument expected string'",
                    "target": "Error('预期的字符串参数无效'"
                },
                {
                    "source": "Error(`Invalid argument not valid semver ('${v}' received)`",
                    "target": "Error(`无效参数无效 semver(收到('${v}')`"
                },
                {
                    "source": "Error('Function called outside component initialization'",
                    "target": "Error('调用外部组件初始化的函数'"
                },
                {
                    "source": "Error(`The number of headers (${headers.length}) must match the number of columns (${values[0].length})`",
                    "target": "Error(`标头的数量(${headers.length})必须与列的数量(${values[0].length})匹配`"
                },
                {
                    "source": "Error(\"reduce(array, op) supports '+', '-', '/', '*', '&', and '|'\"",
                    "target": "Error(\"reduce(array, op)支持'+', '-', '/', '*', '&'和'|'\""
                },
                {
                    "source": "Error(`Unrecognized level '${level}' (expected 1, 2, 3, 4, 5, or 6)`",
                    "target": "Error(`无法识别的级别 '${level}' (应为1, 2, 3, 4, 5或6)`"
                },
                {
                    "source": "Error(`Could not find CSV for path '${path}' (relative to origin '${originFile !== null && originFile !== void 0 ? originFile : \"/\"}')`",
                    "target": "Error(`找不到路径'${path}'的 CSV(相对于源'${originFile !== null && originFile !== void 0 ? originFile : \"/\"}')`"
                },
                {
                    "source": "Error(`Failed to parse query in 'pagePaths': ${ex}`",
                    "target": "Error(`无法解析'页面路径'${ex}中的查询`"
                },
                {
                    "source": ".desc(\"whitespace\"",
                    "target": ".desc(\"空白符\""
                },
                {
                    "source": ".desc(\"a digit\"",
                    "target": ".desc(\"一个数字\""
                },
                {
                    "source": ".desc(\"optional digits\"",
                    "target": ".desc(\"可选数字\""
                },
                {
                    "source": ".desc(\"a letter\"",
                    "target": ".desc(\"一封信\""
                },
                {
                    "source": ".desc(\"optional letters\"",
                    "target": ".desc(\"可选字母\""
                },
                {
                    "source": ".desc(\"optional whitespace\"",
                    "target": ".desc(\"可选空格\""
                },
                {
                    "source": ".desc(\"none of '\"",
                    "target": ".desc(\"没有 '\""
                },
                {
                    "source": ".desc(\"boolean ('true' or 'false')\"",
                    "target": ".desc(\"boolean('true' 或 'false')\""
                },
                {
                    "source": ".desc(\"tag ('#hello/stuff')\"",
                    "target": ".desc(\"标签('#hello/stuff')\""
                },
                {
                    "source": ".desc(\"variable identifier\"",
                    "target": ".desc(\"变量标识符\""
                },
                {
                    "source": ".desc(\"file link\"",
                    "target": ".desc(\"文件链接\""
                },
                {
                    "source": ".desc(\"'+' or '-'\"",
                    "target": ".desc(\"'+' 或 '-'\""
                },
                {
                    "source": ".desc(\"'*' or '/' or '%'\"",
                    "target": ".desc(\"'*' 或 '/' 或 '%'\""
                },
                {
                    "source": ".desc(\"'>=' or '<=' or '!=' or '=' or '>' or '<'\"",
                    "target": ".desc(\"'>=' 或 '<=' 或 '!=' 或 '=' 或 '>' 或 '<\""
                },
                {
                    "source": ".desc(\"'and' or 'or'\"",
                    "target": ".desc(\"'and' 或 'or'\""
                },
                {
                    "source": ".desc(\"date in format YYYY-MM[-DDTHH-MM-SS.MS]\"",
                    "target": ".desc(\"日期格式为 YYYY-MM[-DDTHH-MM-SS.MS]\""
                },
                {
                    "source": ".desc(\"date in format YYYY-MM[-DDTHH-MM-SS.MS] or in shorthand\"",
                    "target": ".desc(\"日期格式为 YYYY-MM[-DDTHH-MM-SS.MS]或简写\""
                },
                {
                    "source": ".desc(\"duration like 4hr2min\"",
                    "target": ".desc(\"持续时间约为4小时2分钟\""
                },
                {
                    "source": ".desc(\"list ('[1, 2, 3]')\"",
                    "target": ".desc(\"列表('[1, 2, 3]')\""
                },
                {
                    "source": ".desc(\"object ('{ a: 1, b: 2 }')\"",
                    "target": ".desc(\"对象('{ a: 1, b: 2 }')\""
                },
                {
                    "source": ".desc(\"negated field\"",
                    "target": ".desc(\"否定字段\""
                },
                {
                    "source": ".desc(\"TABLE or LIST or TASK or CALENDAR\"",
                    "target": ".desc(\"表格, 列表, 任务或日历\""
                },
                {
                    "source": ".desc(\"WHERE <expression>\"",
                    "target": ".desc(\"WHERE<表达式>\""
                },
                {
                    "source": ".desc(\"LIMIT <value>\"",
                    "target": ".desc(\"LIMIT <value>极限<值>\""
                },
                {
                    "source": ".desc(\"FLATTEN <value> [AS <name>]\"",
                    "target": ".desc(\"FLATTEN<value>[AS<name>]  扁平化<字段名>[AS<替换后的字段名>]\""
                },
                {
                    "source": ".desc(\"GROUP BY <value> [AS <name>]\"",
                    "target": ".desc(\"GROUP BY <value> [AS <name>]  按<值>分组[AS<替换后的值>]\""
                },
                {
                    "source": "\"Evaluation Error: \"",
                    "target": "\"评估错误: \""
                },
                {
                    "source": "super(`Invalid DateTime: ${reason.toMessage()}`);",
                    "target": "super(`无效的 DateTime: ${reason.toMessage()}`);"
                },
                {
                    "source": "super(`Invalid Interval: ${reason.toMessage()}`);",
                    "target": "super(`无效的 Interval: ${reason.toMessage()}`);"
                },
                {
                    "source": "super(`Invalid Duration: ${reason.toMessage()}`);",
                    "target": "super(`无效的 Duration: ${reason.toMessage()}`);"
                },
                {
                    "source": "super(`Invalid unit ${unit}`);",
                    "target": "super(`无效的单位 ${unit}`);"
                },
                {
                    "source": "super(\"Zone is an abstract class\");",
                    "target": "super(\"Zone 是一个抽象类\");"
                },
                {
                    "source": "Error(`Invalid unit value ${value}`)",
                    "target": "Error(`无效的单位值 ${value}`)"
                },
                {
                    "source": "Error(`Value format ${format} is out of range for property format`)",
                    "target": "Error(`值格式 ${format} 超出了属性格式的范围`)"
                },
                {
                    "source": "Error(`Unrecognized transfer type '${transferable[\"___transfer-type\"]}'`)",
                    "target": "Error(`未识别的传输类型 '${transferable[\"___transfer-type\"]}'`)"
                },
                {
                    "source": "Error('Could not dynamically require \"' + path + '\". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.')",
                    "target": "Error('无法动态加载 \"' + path + '\"。请适当配置 @rollup/plugin-commonjs 的 dynamicRequireTargets 或/和 ignoreDynamicRequires 选项以使此 require 调用生效。')"
                },
                {
                    "source": "Error(\"Can't call config() after localforage \" + 'has been used.')",
                    "target": "Error(\"在使用 localforage 之后不能调用 config()\")"
                },
                {
                    "source": "Error(\"Not a number for format( (${ f }): ${ d }\")",
                    "target": "Error(\"不是数字,格式为 (${ f }): ${ d }\")"
                },
                {
                    "source": "Error(`Can't handle format (${f}) on date string (${d})`)",
                    "target": "Error(`无法处理日期字符串 (${d}) 上的格式 (${f})`)"
                },
                {
                    "source": "Error(`Could not find CSV for path '${path}' (relative to origin '${originFile ?? \"/\"}')`)",
                    "target": "Error(`无法找到路径 '${path}' 的 CSV 文件(相对于源 '${originFile ?? \"/\"}')`)"
                },
                {
                    "source": "Error(\n        `Duration.fromObject: argument expected to be an object, got ${\n          obj === null ? \"null\" : typeof obj\n        }`",
                    "target": "Error(\n        `Duration.fromObject: 参数应为对象,实际得到 ${\n          obj === null ? \"null\" : typeof obj\n        }`"
                },
                {
                    "source": "Error(\n        `Unknown duration argument ${durationLike} of type ${typeof durationLike}`",
                    "target": "Error(\n        `未知的持续时间参数 ${durationLike},类型为 ${typeof durationLike}`"
                },
                {
                    "source": "Error(\n        \"Can't include meridiem when specifying 24-hour format\"",
                    "target": "Error(\n        \"在指定24小时格式时不能包含上午/下午标记\""
                },
                {
                    "source": "Error(\n        `fromMillis requires a numerical input, but received a ${typeof milliseconds} with value ${milliseconds}`",
                    "target": "Error(\n        `fromMillis 需要数值输入,但接收到的是 ${typeof milliseconds} 类型的值 ${milliseconds}`"
                },
                {
                    "source": "Error(\n        \"Can't mix weekYear/weekNumber units with year/month/day or ordinals\"",
                    "target": "Error(\n        \"不能将 weekYear/weekNumber 单位与 year/month/day 或序数混合使用\""
                },
                {
                    "source": "Error(\n      `Unknown datetime argument: ${dateTimeish}, of type ${typeof dateTimeish}`",
                    "target": "Error(\n        `未知的 datetime 参数: ${dateTimeish},类型为 ${typeof dateTimeish}`"
                },
                {
                    "source": "Error(n+\" requires integer length in range [0, 6].\")",
                    "target": "Error(n+\" 需要范围在 [0, 6] 内的整数长度。\")"
                },
                {
                    "source": "Error('Method ' + methodName + ' is not implemented by the current driver')",
                    "target": "Error('方法 ' + methodName + ' 尚未由当前驱动程序实现')"
                },
                {
                    "source": "Error(\n      `Invalid operator type, expected string but got ${typeof op}`",
                    "target": "Error(\n      `无效的操作符类型,期望字符串但得到 ${typeof op}`"
                },
                {
                    "source": "Error(\n      `Invalid operator, expected one of ${allowedOperators.join('|')}`",
                    "target": "Error(\n      `无效的操作符,期望以下之一: ${allowedOperators.join('|')}`"
                },
                {
                    "source": ".warn(key + ' used as a key, but it is not a string.')",
                    "target": ".warn(key + ' 用作键,但它不是一个字符串。')"
                },
                {
                    "source": ".warn('The database \"' + dbInfo.name + '\"' + ' has been upgraded from version ' + e.oldVersion + ' to version ' + e.newVersion + ', but the storage \"' + dbInfo.storeName + '\" already exists.')",
                    "target": ".warn('The database \"' + dbInfo.name + '\"' + ' 已从版本 ' + e.oldVersion + ' 升级到版本 ' + e.newVersion + ',但存储 \"' + dbInfo.storeName + '\" 已存在。')"
                },
                {
                    "source": ".warn('The database \"' + dbInfo.name + '\"' + \" can't be downgraded from version \" + dbInfo.db.version + ' to version ' + dbInfo.version + '.')",
                    "target": ".warn('The database \"' + dbInfo.name + '\"' + \" 不能从版本 \" + dbInfo.db.version + ' 降级到版本 ' + dbInfo.version + '。')"
                },
                {
                    "source": ".warn('dropInstance blocked for database \"' + options.name + '\" until all open connections are closed')",
                    "target": ".warn('dropInstance 被阻塞,直到数据库 \"' + options.name + '\" 的所有打开连接关闭')"
                },
                {
                    "source": "invalid(\"unparsable\", `the input \"${text}\" can't be parsed as ISO 8601`)",
                    "target": "invalid(\"无法解析\", `输入 \"${text}\" 无法解析为 ISO 8601`)"
                },
                {
                    "source": "invalid(\"missing or invalid start\")",
                    "target": "invalid(\"缺少或无效的开始\")"
                },
                {
                    "source": "invalid(\"missing or invalid end\")",
                    "target": "invalid(\"缺少或无效的结束\")"
                },
                {
                    "source": "invalid(\n      \"end before start\",\n      `The end of an interval must be after its start, but you had start=${start.toISO()} and end=${end.toISO()}`\n    )",
                    "target": "invalid(\n      \"结束早于开始\",\n      `区间结束时间必须在其开始时间之后,但你提供的开始时间为 ${start.toISO()},结束时间为 ${end.toISO()}`\n    )"
                },
                {
                    "source": "Invalid(\n    \"unit out of range\",\n    `you specified ${value} (of type ${typeof value}) as a ${unit}, which is invalid`\n  )",
                    "target": "Invalid(\n    \"单位超出范围\",\n    `你指定了 ${value}(类型为 ${typeof value})作为 ${unit},这是无效的`\n  )"
                },
                {
                    "source": "Invalid(\"unsupported zone\", `the zone \"${zone.name}\" is not supported`)",
                    "target": "Invalid(\"不支持的时区\", `时区 \"${zone.name}\" 不被支持`)"
                },
                {
                    "source": "Invalid(\"unparsable\", `the input \"${text}\" can't be parsed as ${format}`)",
                    "target": "Invalid(\"无法解析\", `输入 \"${text}\" 无法解析为 ${format}`)"
                },
                {
                    "source": "invalid(\"invalid input\")",
                    "target": "invalid(\"无效输入\")"
                },
                {
                    "source": "Invalid(\"invalid input\")",
                    "target": "Invalid(\"无效输入\")"
                },
                {
                    "source": "invalid(\"Timestamp out of range\")",
                    "target": "invalid(\"时间戳超出范围\")"
                },
                {
                    "source": "invalid(\n        \"mismatched weekday\",\n        `you can't specify both a weekday of ${normalized.weekday} and a date of ${inst.toISO()}`\n      )",
                    "target": "invalid(\n        \"不匹配的星期几\",\n        `你不能同时指定星期几为 ${normalized.weekday} 和日期为 ${inst.toISO()}`\n      )"
                },
                {
                    "source": "invalid(\"created by diffing an invalid DateTime\")",
                    "target": "invalid(\"由无效的 DateTime 计算差异创建\")"
                },
                {
                    "source": ".failure(`Failed to load data from path '${path}'.`)",
                    "target": ".failure(`未能从路径 '${path}' 加载数据。`)"
                },
                {
                    "source": ".failure(`Could not find file \"${source.file}\" during link lookup - does it exist?`)",
                    "target": ".failure(`在链接查找期间未找到文件 \"${source.file}\" - 文件是否存在？`)"
                },
                {
                    "source": ".failure(`Unrecognized operator '${source.op}'.`)",
                    "target": ".failure(`未识别的操作符 '${source.op}'。`)"
                },
                {
                    "source": ".failure(`Unrecognized value '${left}'`)",
                    "target": ".failure(`未识别的值 '${left}'`)"
                },
                {
                    "source": ".failure(`Unrecognized value '${right}'`)",
                    "target": ".failure(`未识别的值 '${right}'`)"
                },
                {
                    "source": ".failure(`No implementation found for '${leftType} ${op} ${rightType}'`)",
                    "target": ".failure(`未找到 '${leftType} ${op} ${rightType}' 的实现`)"
                },
                {
                    "source": ".failure(`Unrecognized function name '${func}'`)",
                    "target": ".failure(`未识别的函数名 '${func}'`)"
                },
                {
                    "source": ".failure(`Cannot call type '${Values.typeOf(func)}' as a function`)",
                    "target": ".failure(`不能将类型 '${Values.typeOf(func)}' 作为函数调用`)"
                },
                {
                    "source": ".failure(\"Can only index with a string or number\")",
                    "target": ".failure(\"只能使用字符串或数字进行索引\")"
                },
                {
                    "source": ".failure(\"Unrecognized object to index into: \" + object)",
                    "target": ".failure(\"未识别的对象用于索引: \" + object)"
                },
                {
                    "source": ".failure('can only index into objects with strings (a.b or a[\"b\"])')",
                    "target": ".failure('只能使用字符串对对象进行索引 (a.b 或 a[\"b\"])')"
                },
                {
                    "source": ".failure('can only index into links with strings (a.b or a[\"b\"])')",
                    "target": ".failure('只能使用字符串对链接进行索引 (a.b 或 a[\"b\"])')"
                },
                {
                    "source": ".failure(\"Array indexing requires either a number (to get a specific element), or a string (to map all elements inside the array)\")",
                    "target": ".failure(\"数组索引需要一个数字(获取特定元素)或一个字符串(映射数组中的所有元素)\")"
                },
                {
                    "source": ".failure(\"string indexing requires a numeric index (string[index])\")",
                    "target": ".failure(\"字符串索引需要一个数字索引 (string[index])\")"
                },
                {
                    "source": ".failure(\"date indexing requires a string representing the unit\")",
                    "target": ".failure(\"日期索引需要一个表示单位的字符串\")"
                },
                {
                    "source": ".failure(\"duration indexing requires a string representing the unit\")",
                    "target": ".failure(\"持续时间索引需要一个表示单位的字符串\")"
                },
                {
                    "source": ".failure(\"Failed to execute 'limit' statement: \" + limiting.error)",
                    "target": ".failure(\"执行 'limit' 语句失败: \" + limiting.error)"
                },
                {
                    "source": ".failure(`Failed to execute 'limit' statement: limit should be a number, but got '${Values.typeOf(limiting.value)}' (${limiting.value})`)",
                    "target": ".failure(`执行 'limit' 语句失败: limit 应该是一个数字,但得到了 '${Values.typeOf(limiting.value)}' (${limiting.value})`)"
                },
                {
                    "source": ".failure(\"Unrecognized query operation '\" + op.type + \"'\")",
                    "target": ".failure(\"未识别的查询操作 '\" + op.type + \"'\")"
                },
                {
                    "source": ".failure(`Every row during operation '${op.type}' failed with an error; first",
                    "target": ".failure(`在操作 '${op.type}' 过程中每一行都失败并出现错误;第一个"
                },
                {
                    "source": ".failure(`Every row during final data extraction failed with an error; first",
                    "target": ".failure(`在最终数据提取过程中每一行都失败并出现错误;第一个"
                },
                {
                    "source": ".failure(`Failed to parse expression \"${expression}\"`)",
                    "target": ".failure(`未能解析表达式 \"${expression}\"`)"
                },
                {
                    "source": ".failure(\"Cannot render calendar queries to markdown.\")",
                    "target": ".failure(\"无法将日历查询渲染为 Markdown。\")"
                },
                {
                    "source": "\"Dataview: Query returned 0 results.\"",
                    "target": "\"Dataview: 查询返回 0 结果.\""
                },
                {
                    "source": "missing Intl.DateTimeFormat.formatToParts support",
                    "target": "缺少 Intl.DateTimeFormat.formatToParts 支持"
                },
                {
                    "source": ".info('Redefining LocalForage driver: ' + driverName)",
                    "target": ".info('重新定义 LocalForage 驱动程序: ' + driverName)"
                },
                {
                    "source": ".fail(`Unrecognized query type '${type}'`)",
                    "target": ".fail(`未识别的查询类型 '${type}'`)"
                },
                {
                    "source": "`Dataview: custom view not found for '${simpleViewPath}' or '${complexViewPath}'.`",
                    "target": "`Dataview: 未找到自定义视图 '${simpleViewPath}' 或 '${complexViewPath}'.`"
                },
                {
                    "source": "`Dataview: Failed to execute view '${viewFile.path}'.\n\n${ex}`",
                    "target": "`Dataview: 执行视图 '${viewFile.path}' 失败.\n\n${ex}`"
                },
                {
                    "source": "\"Dataview JS queries are disabled. You can enable them in the Dataview settings.\"",
                    "target": "\"Dataview JS 查询已禁用。您可以在 Dataview 设置中启用它们。\""
                },
                {
                    "source": "\"Dataview (for inline JS query '\" + this.script + \"'): \"",
                    "target": "\"Dataview (用于内联 JS 查询 '\" + this.script + \"'): \""
                },
                {
                    "source": "\"Dataview (for inline query '\" + this.fieldText + \"'): \"",
                    "target": "\"Dataview(用于内联查询 '\" + this.fieldText + \"'):\""
                },
                {
                    "source": "`Dataview (inline field '${potentialField}'): ${field.error}`",
                    "target": "`Dataview(内联字段 '${potentialField}'): ${field.error}`"
                },
                {
                    "source": "`Dataview (inline field '${code}'): ${field.error}`",
                    "target": "`Dataview(内联字段 '${code}'): ${field.error}`"
                },
                {
                    "source": "`Dataview (for inline query '${fieldValue}'): ${intermediateResult.error}`",
                    "target": "`Dataview(用于内联查询 '${fieldValue}'): ${intermediateResult.error}`"
                },
                {
                    "source": "\"Date-time format for task completion date when toggling a task's checkbox in a Dataview view (see Luxon date format options).\"",
                    "target": "\"在 Dataview 视图中切换任务复选框时的任务完成日期格式(请参见 Luxon 日期格式选项)。\""
                },
                {
                    "source": "'Only available when \"automatic task completion tracking\" is enabled and \"use emoji shorthand for completion\" is disabled.'",
                    "target": "'仅在启用 \"自动任务完成跟踪\" 且禁用 \"使用表情符号简写表示完成\" 时可用。'"
                },
                {
                    "source": "\"Currently: \"",
                    "target": "\"当前:\""
                },
                {
                    "source": "\"(disabled; enable in settings)\"",
                    "target": "\"(已禁用;在设置中启用)\""
                },
                {
                    "source": "`Dataview (for inline JS query '${code}'): ${e}`",
                    "target": "`Dataview(用于内联 JS 查询 '${code}'): ${e}`"
                },
                {
                    "source": ".setDesc(\"If enabled, views will automatically refresh when files in your vault change; this can negatively affect\" +\n            \" some functionality like embeds in views, so turn it off if such functionality is not working.\")",
                    "target": ".setDesc(\"如果启用，当保险库中的文件更改时，视图将自动刷新；这可能会产生负面影响。\" +\n            \" 如果某些功能，比如视图中的嵌入功能无法正常工作，请关闭它们。\")"
                },
                {
                    "source": ".setDesc(\"The name of the default ID column in tables, when the table is on grouped data; this is the auto-generated first column\" +\n            \"that links to the source file/group.\")",
                    "target": ".setDesc(\"在表格对分组数据进行操作时，默认ID列的名称；这是自动生成的第一列\" +\n            \"链接到file/groupp.\")"
                },
                {
                    "source": "Error('Could not dynamically require \"'",
                    "target": "Error('无法动态要求\"'"
                },
                {
                    "source": "Error(\"Can't call config() after localforage \"",
                    "target": "Error(\"无法在 localfeed 之后调用 config()\""
                },
                {
                    "source": "Error('Method '",
                    "target": "Error('方法'"
                },
                {
                    "source": " .setDesc(\"If enabled, inline queries will also be evaluated inside full code blocks.\")",
                    "target": " .setDesc(\"如果启用，内联查询也将在完整代码块中进行评估。\")"
                },
                {
                    "source": ".setDesc(\"The default date format (see Luxon date format options).\" ",
                    "target": ".setDesc(\"默认日期格式（参见Luxon日期格式选项）。\" "
                },
                {
                    "source": ".setDesc(\"The default date and time format (see Luxon date format options).\" +",
                    "target": ".setDesc(\"默认日期和时间格式（参见Luxon日期格式选项）。\" +"
                },
                {
                    "source": "setDesc(\"The name of the default ID column in tables, when the table is on grouped data; this is the auto-generated first column\"",
                    "target": "setDesc(\"当表格基于分组数据时，默认 ID 列的名称；这是自动生成的第一列。\""
                },
                {
                    "source": ".appendText(\"If enabled, Dataview will automatically append tasks with their completion date when they are checked in Dataview views.\");",
                    "target": ".appendText(\"如果启用，Dataview将在Dataview视图中自动附加已完成任务的完成日期。\");"
                },
                {
                    "source": ".appendText(\"Disable this to customize the completion date format or field name, or to use Dataview inline field formatting.\");",
                    "target": ".appendText(\"禁用此选项以自定义完成日期格式或字段名称，或使用Dataview内联字段格式。\");"
                },
                {
                    "source": ".appendText('Only available when \"automatic task completion tracking\" is enabled.');",
                    "target": ".appendText('仅在启用“自动任务完成跟踪”时可用。');"
                },
                {
                    "source": ".setDesc('Only available when \"automatic task completion tracking\" is enabled.');",
                    "target": ".setDesc('仅在启用“自动任务完成跟踪”时可用。');"
                },
                {
                    "source": ".log(`Dataview: Encountered a circular list (line number ${lineno}; children ${this.listItems[lineno].children.join(\", \")",
                    "target": ".log(`Dataview: Encountered a circular list (line number ${lineno}; children ${this.listItems[lineno].children.join(\", \")"
                },
                {
                    "source": ".log(`Dataview: re-initialized index with ${files.length} files (${(Date.now()",
                    "target": ".log(`Dataview: re-initialized index with ${files.length} files (${(Date.now()"
                },
                {
                    "source": ".log(`Dataview: all ${files.length} files have been indexed in ${(Date.now()",
                    "target": ".log(`Dataview: all ${files.length} files have been indexed in ${(Date.now()"
                },
                {
                    "source": ".log(`Dataview: Dropped cache entries for ${remaining.size} deleted files.`)",
                    "target": ".log(`Dataview：已清除 ${remaining.size} 个删除文件的缓存条目。`)"
                },
                {
                    "source": ".log(`Dataview: version ${this.manifest.version} (requires obsidian ${this.manifest.minAppVersion})",
                    "target": ".log(`Dataview: 版本${this.manifest.version} (需要Obsidian ${this.manifest.minAppVersion})"
                },
                {
                    "source": ".log(`Dataview: version ${this.manifest.version} unloaded.`)",
                    "target": ".log(`Dataview：版本 ${this.manifest.version} 已卸载。`)"
                },
                {
                    "source": ".error(\"remove-markdown encountered error: %s\", e)",
                    "target": ".error(\"remove-markdown encountered error: %s\", e)"
                },
                {
                    "source": ".error(\"Couldn't convert value into a JSON string: \", value)",
                    "target": ".error(\"无法将值转换为JSON字符串：\", value)"
                },
                {
                    "source": ".setDesc(\"If enabled, inline queries will also be evaluated inside full code blocks.\")",
                    "target": ".setDesc(\"如果启用，内联查询也将在完整代码块内进行评估。\")"
                },
                {
                    "source": ".setDesc('Only available when \"automatic task completion tracking\" is enabled.')",
                    "target": ".setDesc('仅在启用“自动任务完成跟踪”时可用。')"
                },
                {
                    "source": ".setDesc('Only available when \"automatic task completion tracking\" is enabled and \"use emoji shorthand for completion\" is disabled.')",
                    "target": ".setDesc('仅在启用“自动任务完成跟踪”且禁用“使用快捷emoji表示完成”时可用。')"
                },
                {
                    "source": ".setPlaceholder(\"File\")",
                    "target": ".setPlaceholder(\"File\")"
                },
                {
                    "source": ".setPlaceholder(\"Group\")",
                    "target": ".setPlaceholder(\"Group\")"
                },
                {
                    "source": ".appendText(\"If enabled, Dataview will automatically append tasks with their completion date when they are checked in Dataview views.\")",
                    "target": ".appendText(\"如果启用，Dataview 在 Dataview 视图中勾选任务时会自动将完成日期附加到这些任务上。\")"
                },
                {
                    "source": ".appendText(\"Disable this to customize the completion date format or field name, or to use Dataview inline field formatting.\")",
                    "target": ".appendText(\"禁用此选项可自定义完成日期格式或字段名称，或使用 Dataview 内联字段格式化。\")"
                },
                {
                    "source": ".appendText('Only available when \"automatic task completion tracking\" is enabled.')",
                    "target": ".appendText('仅在启用“自动任务完成跟踪”时可用。')"
                },
                {
                    "source": ".appendText('Only available when \"automatic task completion tracking\" is enabled and \"use emoji shorthand for completion\" is disabled.')",
                    "target": ".appendText('当启用“自动任务完成跟踪”并禁用“使用表情快捷方式标记完成”时可用。')"
                },
                {
                    "source": ".innerText = \"(disabled; enable in settings)\"",
                    "target": ".innerText = \"(disabled; enable in settings)\""
                }
            ]
        }
    }
}