dolphindb 2.0.901 → 2.0.903

package/docs.zh.json

@@ -11113,7 +11113,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`cond` 条件表达式/返回值是布尔类型的函数。需要包含输入表中的字段，不支持常量/常量表达式。",
+                            "`cond` 布尔表达式/返回值是布尔类型的函数。需要包含输入表中的字段，不支持常量/常量表达式。",
                             "",
                             "`trueValue` 计算公式。计算结果将作为 *cond* 为 true 时的输出值。",
                             "",
@@ -14282,7 +14282,7 @@
                             "",
                             ".. _updateRightTableLSJ:",
                             "",
-                            "`updateRightTable` 可选参数，布尔值，默认为 false，表示右表存在多条相同 matchingColumn 的记录时，是保留第一条（true）还是最后一条记录（false）。"
+                            "`updateRightTable` 可选参数，布尔值，默认为 false，表示右表存在多条相同 matchingColumn 的记录时，是保留第一条（false）还是最后一条记录（true）。"
                         ]
                     }
                 ]
@@ -15057,7 +15057,7 @@
                             "",
                             ".. _keyPurgeFilter_rs:",
                             "",
-                            "`keyPurgeFilter` 可选参数，是一个由条件表达式组成的元代码，表示清理条件。各表达式只能引用 *outputTable* 中的字段。",
+                            "`keyPurgeFilter` 可选参数，是一个由布尔表达式组成的元代码，表示清理条件。各表达式只能引用 *outputTable* 中的字段。",
                             "",
                             ".. _keyPurgeFreqInSecond_rs:",
                             "",
@@ -23260,7 +23260,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "从表中删除指定的列。请注意，对于分布式表，不支持分区列的删除。"
+                            "从表中删除指定的列。请注意，对于分布式表，不支持分区列和 SYMBOL 类型列的删除。"
                         ]
                     }
                 ]
@@ -25279,15 +25279,17 @@
                         "value": [
                             "`table` 是一个空的流数据表。",
                             "",
-                            "`asynWrite` 是一个布尔值。它是可选参数，表示表是否以异步模式保存。默认值为true。",
+                            "`asynWrite` 是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。",
                             "",
-                            "`compress` 是一个布尔值。它是可选参数，表示是否以压缩模式模式保存至硬盘。默认值为true。",
+                            "注意：持久化数据到磁盘包含两个步骤：（1）写内存数据到操作系统缓存；（2）写缓存数据到磁盘（是否开启同步刷盘由参数 flushMode 决定）。",
                             "",
-                            "`cacheSize` 是长整型数据类型(long)的整数。它是一个可选参数，表示流数据表在内存中最多保留多少行。默认值为-1。如果它为0或者没有指定（默认值为-1），所有记录行都会保存在内存中。如果 *cacheSize* 是小于100,000的正整数，它会被自动调整为100,000.",
+                            "`compress` 是一个布尔值。它是可选参数，表示是否以压缩模式模式保存至磁盘。默认值为 true。",
                             "",
-                            "`retentionMinutes` 是一个整数，表示log文件的保留时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。",
+                            "`cacheSize` 是长整型数据类型（long）的整数。它是一个可选参数，表示流数据表在内存中最多保留多少行。默认值为-1。如果它为0或者没有指定（默认值为-1），所有记录行都会保存在内存中。如果 *cacheSize* 是小于100,000的正整数，它会被自动调整为100,000。",
                             "",
-                            "`flushMode` 是一个整数，取值只能为0或1。默认值是0，表示流数据首先写入操作系统缓存，不立刻写入到磁盘上。如果 *flushMode* =1 ，流数据会立刻写入到磁盘上。"
+                            "`retentionMinutes` 是一个整数，表示 log 文件的保留时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。",
+                            "",
+                            "`flushMode` 是一个整数，表示是否开启同步刷盘，取值只能为0或1。默认值是0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。"
                         ]
                     }
                 ]
@@ -25299,18 +25301,18 @@
                     {
                         "type": "text",
                         "value": [
-                            "该命令把共享的流计算表保存到硬盘上。",
+                            "该命令把共享的流计算表保存到磁盘上。",
                             "",
-                            "为了保证该命令能够正常执行，我们需要指定配置参数 *persistenceDir* 。流数据表在磁盘上的存储目录是<PERSISTENCE_DIR>/<TABLE_NAME>。目录包含两种类型的文件：数据文件（名称类型 *data0.log, data1.log...* ）和索引文件 *index.log* 。把这些数据保存到硬盘后，如果重启系统，该命令会把硬盘中的数据加载到内存中。",
+                            "为了保证该命令能够正常执行，我们需要指定配置参数 *persistenceDir* 。流数据表在磁盘上的存储目录是<PERSISTENCE_DIR>/<TABLE_NAME>。目录包含两种类型的文件：数据文件（名称类型 *data0.log, data1.log...* ）和索引文件 *index.log* 。把这些数据保存到磁盘后，如果重启系统，该命令会把磁盘中的数据加载到内存中。",
                             "",
-                            "参数 *asyn* 会告知系统是否以异步模式保存表。在异步模式中，追加的数据会被放进队列，之后用于保存的工作线程把数据写入硬盘。在同步模式中，表的追加数据操作直到追加数据被保存到硬盘中才完成。该参数的默认值是true，即为异步模式。通常情况下，异步模式实现更高的吞吐量，但是如果服务器崩溃，可能会丢失最后追加的行。在异步模式中，保存表的工作是由单个工作线程完成，并且一个工作线程可能处理多个表。如果只保存一个表，增加工作线程的数量并不会提升性能。",
+                            "参数 *asynWrite* 会告知系统是否以异步模式保存表。在异步模式中，追加的数据会被放进队列，之后用于保存的工作线程把数据写入磁盘。在同步模式中，表的追加数据操作直到追加数据被保存到磁盘中才完成。该参数的默认值是 true，即为异步模式。通常情况下，异步模式实现更高的吞吐量，但是如果服务器崩溃，可能会丢失最后追加的行。在异步模式中，保存表的工作是由单个工作线程完成，并且一个工作线程可能处理多个表。如果只保存一个表，增加工作线程的数量并不会提升性能。",
                             "",
-                            "默认情况下，流数据表把所有数据保存在内存中。如果流数据表太大，系统可能会出现内存不足的情况。为了避免内存不足的问题，我们可以设置一个界限。如果流数据表的行数达到这个界限，前面一半的记录行会从内存中清理。",
+                            "默认情况下，流数据表把所有数据保存在内存中。如果流数据表太大，系统可能会出现内存不足的情况。为了避免内存不足的问题，可以配置 *cacheSize* 参数，以设置内存中最多保留的记录数。如果流数据表的行数达到 *cacheSize* 设置的阈值，则系统会自动清理当前内存中 50% 的旧记录行。",
                             "",
                             "注：",
                             "",
-                            "* 如果手动重启server，建议先把缓存区的数据写入磁盘再kill进程。",
-                            "* 如果设置flushMode=0，则server发生crash时可能会丢失一部分数据。"
+                            "* 如果手动重启 server，建议调用 :doc:`/FunctionsandCommands/CommandsReferences/f/fflush` 函数先把缓存区的数据写入磁盘再 kill 进程。",
+                            "* 如果设置 flushMode=0，则 server 发生 crash 时可能会丢失一部分数据。"
                         ]
                     }
                 ]
@@ -25405,19 +25407,21 @@
                         "value": [
                             "`table` 是一个空的流数据表。",
                             "",
-                            "`tableName` 是一个字符串，表示table共享后的名称。",
+                            "`tableName` 是一个字符串，表示 table d共享后的名称。",
+                            "",
+                            "`asynWrite` 是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。",
                             "",
-                            "`asynWrite` 是一个布尔值。它是可选参数，表示表是否以异步模式保存。默认值为true。",
+                            "注意：持久化数据到磁盘包含两个步骤：（1）写内存数据到操作系统缓存；（2）写缓存数据到磁盘（是否开启同步刷盘由参数 flushMode 决定）。",
                             "",
-                            "`compress` 是一个布尔值。它是可选参数，表示是否以压缩模式模式保存至硬盘。默认值为true。",
+                            "`compress` 是一个布尔值。它是可选参数，表示是否以压缩模式模式保存至磁盘。默认值为 true。",
                             "",
-                            "`cacheSize` 是长整型数据类型(long)的整数。它是一个可选参数，表示流数据表在内存中最多保留多少行。如果它为0或者没有指定，所有记录行都会保存在内存中。默认值为-1。如果 *cacheSize* 是小于100,000的正整数，它会被自动调整为100,000.",
+                            "`cacheSize` 是长整型数据类型（long）的整数。它是一个可选参数，表示流数据表在内存中最多保留多少行。如果它为0或者没有指定，所有记录行都会保存在内存中。默认值为-1。如果 *cacheSize* 是小于100,000的正整数，它会被自动调整为100,000.",
                             "",
-                            "`retentionMinutes` 是一个整数，表示log文件的保留时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。",
+                            "`retentionMinutes` 是一个整数，表示 log 文件的保留时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。",
                             "",
-                            "`flushMode` 是一个整数，取值只能为0或1。默认值是0，表示流数据首先写入操作系统缓存，不立刻写入到磁盘上。如果 *flushMode=1*，流数据会立刻写入到磁盘上。",
+                            "`flushMode` 是一个整数，表示是否开启同步刷盘，取值只能为0或1。默认值是0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。",
                             "",
-                            "`preCache` 是一个整数，表示从硬盘加载到内存的记录条数。如果没有指定该参数，默认会把所有记录加载到内存中。"
+                            "`preCache` 是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，默认会把所有记录加载到内存中。"
                         ]
                     }
                 ]
@@ -25429,18 +25433,18 @@
                     {
                         "type": "text",
                         "value": [
-                            "该命令把流数据表共享，并把它持久化到硬盘上。",
+                            "该命令把流数据表共享，并把它持久化到磁盘上。",
                             "",
-                            "为了保证该命令能够正常执行，需要指定配置参数 *persistenceDir*。流数据表在磁盘上的存储目录是<PERSISTENCE_DIR>/<TABLE_NAME>。目录包含两种类型的文件：数据文件（名称类型 *data0.log, data1.log...* ）和索引文件 *index.log*。把这些数据保存到硬盘后，如果重启系统，再次执行该命令会把硬盘中的数据加载到内存中，加载的记录条数由参数 *preCache* 指定，但是实际加载的记录条数有可能会超过 *preCache*。",
+                            "为了保证该命令能够正常执行，需要指定配置参数 *persistenceDir*。流数据表在磁盘上的存储目录是<PERSISTENCE_DIR>/<TABLE_NAME>。目录包含两种类型的文件：数据文件（名称类型 *data0.log, data1.log...* ）和索引文件 *index.log*。把这些数据保存到磁盘后，如果重启系统，再次执行该命令会把磁盘中的数据加载到内存中，加载的记录条数由参数 *preCache* 指定，但是实际加载的记录条数有可能会超过 *preCache*。",
                             "",
-                            "参数 *asyn* 会告知系统是否以异步模式保存表。在异步模式中，追加的数据会被放进队列，之后用于保存的工作线程把数据写入硬盘。在同步模式中，表的追加数据操作直到追加数据被保存到硬盘中才完成。该参数的默认值是true，即为异步模式。通常情况下，异步模式实现更高的吞吐量，但是如果服务器崩溃，可能会丢失最后追加的行。在异步模式中，保存表的工作是由单个工作线程完成，并且一个工作线程可能处理多个表。如果只保存一个表，增加工作线程的数量并不会提升性能。",
+                            "参数 *asynWrite* 会告知系统是否以异步模式保存表。在异步模式中，追加的数据会被放进队列，之后用于保存的工作线程把数据写入磁盘。在同步模式中，表的追加数据操作直到追加数据被保存到磁盘中才完成。该参数的默认值是 true，即为异步模式。通常情况下，异步模式实现更高的吞吐量，但是如果服务器崩溃，可能会丢失最后追加的行。在异步模式中，保存表的工作是由单个工作线程完成，并且一个工作线程可能处理多个表。如果只保存一个表，增加工作线程的数量并不会提升性能。",
                             "",
-                            "默认情况下，流计算的表把所有数据保存在内存中。如果流数据表太大，系统可能会出现内存不足的情况。为了避免内存不足的问题，可以设置一个界限。如果流数据表的行数达到这个界限，前面一半的记录行会从内存中清理。",
+                            "默认情况下，流数据表把所有数据保存在内存中。如果流数据表太大，系统可能会出现内存不足的情况。为了避免内存不足的问题，可以配置 *cacheSize* 参数，以设置内存中最多保留的记录数。如果流数据表的行数达到 *cacheSize* 设置的阈值，则系统会自动清理当前内存中 50% 的旧记录行。",
                             "",
                             "注：",
                             "",
-                            "* 如果手动重启server，建议先把缓存区的数据写入磁盘再kill进程。",
-                            "* 如果设置flushMode=0，则server发生crash时可能会丢失一部分数据。"
+                            "* 如果手动重启 server，建议调用 :doc:`/FunctionsandCommands/CommandsReferences/f/fflush` 函数先把缓存区的数据写入磁盘再 kill 进程。",
+                            "* 如果设置 flushMode=0，则 server 发生 crash 时可能会丢失一部分数据。"
                         ]
                     }
                 ]
@@ -38497,7 +38501,7 @@
                         "value": [
                             "`cond` 是布尔标量、向量或矩阵。可为产生布尔标量、向量或矩阵的表达式。",
                             "",
-                            "`trueResult` 和 `falseResult` 可以是标量、与 *cond* 等长的向量或与 *cond* 维度相同的矩阵。",
+                            "`trueResult` 和 `falseResult` 可以是标量、与 *cond* 等长的向量或与 *cond* 维度相同的矩阵。",
                             ""
                         ]
                     }
@@ -38603,7 +38607,7 @@
                             "5  14",
                             "== ==",
                             "",
-                            "当配置了nullAsMinValueForComparison=true时，在比较运算中，NULL元素取相应数据类型的最小值。使用 :doc:`/Functionalprogramming/TemplateFunctions/nullCompare` 可以保持iif条件表语句里的NULL值。",
+                            "当配置了nullAsMinValueForComparison=true时，在比较运算中，NULL元素取相应数据类型的最小值。使用 :doc:`/Functionalprogramming/TemplateFunctions/nullCompare` 可以保持 iif 条件语句里的 NULL 值。",
                             ""
                         ]
                     },
@@ -43394,7 +43398,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`X` 可以是标量或向量。"
+                            "`X` 可以是系统支持的任意数据形式。"
                         ]
                     }
                 ]
@@ -43428,7 +43432,10 @@
                             "",
                             "   // 和 isNull 相比",
                             "   $ isNull(1 NULL 2);",
-                            "   [0,1,0]"
+                            "   [0,1,0]",
+                            "",
+                            "   $ isVoid(matrix(NULL 2 NULL, NULL 2 1))",
+                            "   0"
                         ]
                     }
                 ]
@@ -51375,7 +51382,7 @@
                         "value": [
                             "`X` 是一个标量、向量或矩阵。",
                             "",
-                            "`Y` 是一个条件表达式。"
+                            "`Y` 是一个布尔表达式。"
                         ]
                     }
                 ]
@@ -69709,7 +69716,7 @@
                             "* 当 *X* 是向量时，*Y* 是表示标签的字符串。",
                             "* 当 *X* 是矩阵时，如果 *Z* 没有指定，则 *Y* 是列标签；如果 *Z* 指定了，*Y* 是行标签，而 *Z* 是列标签。列标签和行标签的长度分别需要等于 *X* 的列数和行数。*Y* 和 *Z* 可以是任意数据类型。",
                             "* 当 *X* 是非共享内存表时，*Y* 和 *Z* 是字符串标量或向量。如果 *Z* 没有指定，则 *Y* 从左到右是新的列名，用户应该确保新的列名的数量小于或等于表中列的总数；如果 *Z* 指定了，则 *Y* 是旧的列名，*Z* 是对应的新的列名。",
-                            "* 当 *X* 分布式表时，*Y* 和 *Z* 只能是字符串。若不指定 *Z*，则 *Y* 从左到右表示新的列名（用户应该确保新的列名数小于或等于表的列数）；若指定了 *Z*，则 *Y* 表示指定的旧列名，*Z* 是对应的新列名。"
+                            "* 当 *X* 分布式表时，必须指定 *Y* 和 *Z* 且只能是字符串标量。其中 *Y* 表示指定的旧列名，*Z* 是对应的新列名。分布式表不支持批量修改列名。"
                         ]
                     }
                 ]
@@ -70673,7 +70680,11 @@
                             "========== ============== ============== ============ ==========",
                             "month      DATE           6              ",
                             "x          INT            4              ",
-                            "========== ============== ============== ============ ==========   "
+                            "========== ============== ============== ============ ==========   ",
+                            "",
+                            "",
+                            ".. meta::",
+                            "   :keywords: replace, column, col"
                         ]
                     }
                 ]
@@ -79732,6 +79743,8 @@
                         "value": [
                             "设置数据保留策略以及 :doc:`/DatabaseandDistributedComputing/Database/TieredStorage` 策略。若用户只通过该函数配置分级存储策略，建议将参数 *retentionHours* 指定为一个尽可能大的值。",
                             "",
+                            "分级存储和数据保留策略都以分区为单位进行，因此 retentionHours 和 hoursToColdVolume 配置的时间必须是分区精度的倍数，如按天分区，则需要为 24 的整数倍。",
+                            "",
                             "数据库会根据当前系统的机器时间，保留数据时间戳为最近 *retentionHours* 小时的数据。其中最新 *hoursToColdVolume* 小时的数据将继续存储在 volumes 中。在 [当前时间 - hoursToColdVolume - 10天，当前时间 - hoursToColdVolume) 范围内的数据将被迁移到 *coldVolumes*。若 *coldVolumes* 配置了多个路径，则数据将随机分布在各个存储路径下 。",
                             "",
                             "对于保留时间外的数据，只会删除 [当前时间 - retentionHours - 10 天, 当前时间 - retentionHours) 范围的数据。若需要删除之前的数据，可以调用 :doc:`../d/dropPartition` 函数实现。",
@@ -83536,7 +83549,7 @@
                             "",
                             "定义一个响应式状态引擎，并按 sym 列分组进行计算。组内的计算逻辑如下：",
                             "",
-                            "* 前 initalWindow 行记录，计算公式为 `factor[k]=initial[k]`，因此 factor[0], factor[1], factor[2] 均将 val1 列的值直接作为 factor 列的输出。",
+                            "* 前 initialWindow 行记录，计算公式为 `factor[k]=initial[k]`，因此 factor[0], factor[1], factor[2] 均将 val1 列的值直接作为 factor 列的输出。",
                             "* 之后的记录，对应计算公式为 `factor[k]=0.5*val0[k]+0.5*msum(factor, 3)[k-1]`。以计算 sym=`A，val0=4 这条记录为例，此时 factor 列仅有前 3 条数据的输出，即 factor=[10, 10, 10]，k=3，带入计算公式即 `0.5*4+0.5*msum([10, 10, 10], 3)[2]=17`。同理 sym=`A，val0=5 这条记录带入计算公式即 `0.5*5+0.5*msum([10, 10, 10, 17], 3)[3]=21`，以此类推。",
                             ""
                         ]

package/i18n/dict.json

@@ -0,0 +1,65 @@
+{
+    "暂时不支持序列化": {
+        "en": "serialization is not currently supported"
+    },
+    "不能自动转换 {{type}} 至 DdbObj": {
+        "en": "cannot automatically convert {{type}} to DdbObj"
+    },
+    "form 必须是 DdbForm.table, 否则不能 to_rows": {
+        "en": "form must be DdbForm.table, otherwise it cannot to_rows"
+    },
+    "this.form 必须是 DdbForm.dict, 否则不能调用 to_dict 转换为 js object": {
+        "en": "this.form must be DdbForm.dict, otherwise to_dict cannot be called to convert to js object"
+    },
+    "当前只支持自动转换 dict<string, any> 为 js object": {
+        "en": "currently api only supports automatic conversion of dict<string, any> to js object"
+    },
+    "deep = true 时必须设置 strip = true": {
+        "en": "strip = true must be set when deep = true"
+    },
+    "timestamp 字符串长度必须等于格式串长度": {
+        "en": "the length of the timestamp string must be equal to the length of the format string"
+    },
+    "格式串必须包含秒的格式 (ss)": {
+        "en": "the format string must contain the format for seconds (ss)"
+    },
+    "格式串必须包含纳秒的格式 (SSSSSSSSS)": {
+        "en": "format string must contain nanosecond format (SSSSSSSSS)"
+    },
+    "nanotimestamp 字符串长度必须等于格式串长度": {
+        "en": "nanotimestamp string length must be equal to format string length"
+    },
+    "websocket 连接已断开": {
+        "en": "websocket is disconnected"
+    },
+    "指定 node 时必须设置 func_type": {
+        "en": "func_type must be set when specifying node"
+    },
+    "variable 指令参数不能为空且参数名不能为空，且数量应该匹配": {
+        "en": "variable command parameter cannot be empty and parameter name cannot be empty, and the number should match"
+    },
+    "session id 从 {{sid}} 变为 {{sid_}}": {
+        "en": "session id changed from {{sid}} to {{sid_}}"
+    },
+    "订阅流表成功": {
+        "en": "subscribed to streaming table"
+    },
+    "vector {{type}} 暂不支持序列化": {
+        "en": "vector {{type}} serialization is not currently supported"
+    },
+    "form 必须是 DdbForm.table, 否则不能 to_cols": {
+        "en": "form must be DdbForm.table, otherwise it cannot to_cols"
+    },
+    "这是在调用 this.rpc 之前默认的 on_message, 不应该被调用到，除非建立连接后 server 先推送了 message": {
+        "en": "This is the default on_message before calling this.rpc, it should not be called unless the server pushes the message first after the connection is established"
+    },
+    " 暂时不支持解析": {
+        "en": " parsing is currently not supported"
+    },
+    "array vector 存在非法 unit: {{unit}}": {
+        "en": "array vector has invalid unit: {{unit}}"
+    },
+    " 暂时不支持序列化": {
+        "en": " serialization is currently not supported"
+    }
+}

package/i18n/index.d.ts

@@ -0,0 +1,9 @@
+import { I18N } from 'xshell/i18n/index.js';
+export declare let i18n: I18N;
+declare const t: (text: string, options?: {
+    [key: string]: any;
+    language?: import("xshell/i18n/index.js").Language;
+    context?: string;
+    count?: number;
+}) => string, language: import("xshell/i18n/index.js").Language;
+export { t, language };

package/i18n/index.js

@@ -0,0 +1,6 @@
+import { I18N } from 'xshell/i18n/index.js';
+import _dict from './dict.json' assert { type: 'json' };
+export let i18n = new I18N(_dict);
+const { t, language } = i18n;
+export { t, language };
+//# sourceMappingURL=index.js.map

package/i18n/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAC3C,OAAO,KAAK,MAAM,aAAa,CAAC,SAAS,IAAI,EAAE,MAAM,EAAE,CAAA;AAEvD,MAAM,CAAC,IAAI,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAA;AACjC,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAA;AAC5B,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAA","sourcesContent":["import { I18N } from 'xshell/i18n/index.js'\nimport _dict from './dict.json' assert { type: 'json' }\n\nexport let i18n = new I18N(_dict)\nconst { t, language } = i18n\nexport { t, language }\n"]}