dolphindb 2.0.933 → 2.0.934

package/docs.en.json

@@ -13541,6 +13541,11 @@
     "createEqualJoinEngine": {
         "title": "createEqualJoinEngine",
         "type": "function",
+        "children": []
+    },
+    "createEquiJoinEngine": {
+        "title": "createEquiJoinEngine",
+        "type": "function",
         "children": [
             {
                 "title": "Syntax",
@@ -13549,7 +13554,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "createEqualJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, timeColumn, [garbageSize=5000], [maxDelayedTime])"
+                            "createEquiJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, timeColumn, [garbageSize=5000], [maxDelayedTime])"
                         ]
                     }
                 ]
@@ -13585,7 +13590,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "Create an equal join engine and return a table object after :doc:`/SQLStatements/TableJoiners/equaljoin` of the left and right table. Generally it is used in conjunction with :doc:`../s/subscribeTable`.",
+                            "Create an equal join engine and return a table object after :doc:`/SQLStatements/TableJoiners/equijoin` of the left and right table. Generally it is used in conjunction with :doc:`../s/subscribeTable`.",
                             "",
                             "* Both the left table and the right table are sorted in chronological order according to timeColumn, and the key value of the combination of the timeColumn and the matchingColumn returns a unique result."
                         ]
@@ -13611,7 +13616,7 @@
                             "   $ leftTable=keyedTable(`time`sym, 1:0, `time`sym`price, [SECOND, SYMBOL, DOUBLE])",
                             "   $ rightTable=keyedTable(`time`sym, 1:0, `time`sym`val, [SECOND, SYMBOL, DOUBLE])",
                             "   $ output=table(100:0, `time`sym`total, [SECOND, SYMBOL, DOUBLE])",
-                            "   $ ejEngine=createEqualJoinEngine(\"test1\", leftTable, rightTable, output, <price+val>, `sym, `time)",
+                            "   $ ejEngine=createEquiJoinEngine(\"test1\", leftTable, rightTable, output, <price+val>, `sym, `time)",
                             "   $ tmp1=table(take(13:30:10, 20) as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)",
                             "   $ appendForJoin(ejEngine, true, tmp1)",
                             "   $ leftTable.append!(tmp1)",
@@ -13640,7 +13645,7 @@
                             "   $ share streamTable(5000000:0, `timestamp`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable",
                             "   $ share streamTable(5000000:0, `timestamp`sym`val, [TIMESTAMP, SYMBOL, DOUBLE]) as rightTable",
                             "   $ share table(5000000:0, `timestamp`sym`price`val`total`diff`ratio, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE]) as output",
-                            "   $ ejEngine=createEqualJoinEngine(\"test1\", leftTable, rightTable, output, <[price, val, price+val, price-val, price/val]>, `sym, `timestamp, 5000)",
+                            "   $ ejEngine=createEquiJoinEngine(\"test1\", leftTable, rightTable, output, <[price, val, price+val, price-val, price/val]>, `sym, `timestamp, 5000)",
                             "   $ topic1=subscribeTable(tableName=\"leftTable\", actionName=\"writeLeft\", offset=0, handler=appendForJoin{ejEngine, true}, batchSize=10000, throttle=1)",
                             "   $ topic2=subscribeTable(tableName=\"rightTable\", actionName=\"writeRight\", offset=0, handler=appendForJoin{ejEngine, false}, batchSize=10000, throttle=1)",
                             "   $ def writeLeftTable(mutable tb){",
@@ -32095,7 +32100,7 @@
                             "",
                             "* createAsofJoinEngine",
                             "",
-                            "* createEqualJoinEngine",
+                            "* createEquiJoinEngine",
                             "",
                             "* createLookupJoinEngine",
                             "",
@@ -33806,7 +33811,7 @@
                             "",
                             "* createAsofJoinEngine",
                             "",
-                            "* createEqualJoinEngine",
+                            "* createEquiJoinEngine",
                             "",
                             "* createLookupJoinEngine",
                             "",
@@ -43656,7 +43661,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "Merge X and Y. The result has the same data type as X. "
+                            "Merge X and Y."
                         ]
                     }
                 ]
@@ -73332,6 +73337,19 @@
                     }
                 ]
             },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` is a matrix or an array vector.",
+                            "`Y` is a vector or an array vector with the same number of rows as *X*."
+                        ]
+                    }
+                ]
+            },
             {
                 "title": "Details",
                 "type": "detail",
@@ -73339,7 +73357,10 @@
                     {
                         "type": "text",
                         "value": [
-                            "Retrieve the element in each row of X based on the index specified by the corresponding element of Y. Return a vector with the same length as the number of input rows."
+                            "- *Y* is a vector: each element in *Y* indicates the column index for *X*. Retrieve the corresponding element at each row in *X* and return a vector of the same size as *Y*.  ",
+                            "- *Y* is an array vector: each row in *Y* indicates the column index for *X*. Retrieve the corresponding element(s) at each row in *X* and return an array vector of the same dimension as *Y*.",
+                            "",
+                            "Note: If no element is found at the position specified by *Y*, a NULL value is returned."
                         ]
                     }
                 ]
@@ -73358,14 +73379,15 @@
                             "    $ rowAt(m, index)",
                             "    [7.1,4.5,2.2]",
                             "",
-                            "    $ trades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])",
-                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)",
-                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)",
-                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)",
-                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)",
-                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)",
-                            "    $ select rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price1, rowAt(matrix(p1, p2, p3, p4, p5), rowImax(vol1, vol2, vol3, vol4, vol5)) as price2 from trades",
-                            ""
+                            "    $ index = array(INT[], 0, 10).append!([0 1, 2 4, 3 4 5])",
+                            "    $ rowAt(m, index)",
+                            "    [[3.1,4.2],[7.1,8.4],[5.3,3.5,]]",
+                            "",
+                            "    $ x = array(DOUBLE[], 0, 10).append!([3.3 3.6 3.8, 3.7 3.4 3.5, 3.4 3.4 3.5])",
+                            "    $ index = array(INT[], 0, 10).append!([0 1, 2, 0 2])",
+                            "    $ rowAt(x, index)",
+                            "    [[3.3,3.6],[3.5],[3.4,3.5]]",
+                            "    "
                         ]
                     },
                     {
@@ -94960,7 +94982,7 @@
                         "value": [
                             "For the first scenario, combine 2 tables into a single table. The result is an unpartitioned in-memory table.",
                             "",
-                            "For the first scenario, combine multiple tables into a single table. If `partitioned` is set to \"false\", the result is an unpartitioned in-memory table; if `partitioned` is set to \"true\", the result is a partitioned in-memory table with sequential domain. The default value is \"true\".",
+                            "For the second scenario, combine multiple tables into a single table. If `partitioned` is set to \"false\", the result is an unpartitioned in-memory table; if `partitioned` is set to \"true\", the result is a partitioned in-memory table with sequential domain. The default value is \"true\".",
                             "",
                             "If `byColName` =false, all tables to be combined must have identical number of columns.",
                             "",

package/docs.zh.json

@@ -2562,7 +2562,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`engine` 是流数据 join 引擎，即 :doc:`../c/createAsofJoinEngine` 等函数返回的抽象表对象。目前支持流数据 asof join 引擎和流数据 equal join 引擎、流数据 window join 引擎和流数据 lookup join 引擎。",
+                            "`engine` 是流数据 join 引擎，即 :doc:`../c/createAsofJoinEngine` 等函数返回的抽象表对象。目前支持流数据 asof join 引擎和流数据 equi join 引擎、流数据 window join 引擎和流数据 lookup join 引擎。",
                             "",
                             "`isLeftTable` 布尔类型，插入左表还是右表。",
                             "",
@@ -3504,7 +3504,7 @@
                             "",
                             "* 如果 *index* 是布尔表达式，``at`` 函数返回 *X* 中 *index* 为 true 的位置的元素。 ``at`` 函数等价于中括号运算符 []. 比如，\"X.at(X>3)\" 和 \"X[X>3]\" 相同。",
                             "* 如果 *index* 是向量，以向量中的值作为索引值，寻找 *X* 中该索引位置的值并返回。",
-                            "* 如果 *index* 是元组，则元组只能包含两个元素，表示行列索引，寻找 *X* 中该索引位置的值并返回。",
+                            "* 如果 *index* 是元组，则元组的元素作为 X 每个维度的索引，寻找 *X* 中该索引位置的值并返回。",
                             "* 如果 *index* 是数据对，如 a:b, 则表示索引范围为 [a,b)，寻找 *X* 中该范围的值并返回。",
                             "* 如果 *index* 是数组向量，则 *X* 只能为向量，对于 *index* 中的每行元素都作为一个索引值，寻找 *X* 中对应该索引位置的元素，然后返回一个和 *index* 结构相同的数组向量。",
                             "",
@@ -14036,6 +14036,11 @@
     "createEqualJoinEngine": {
         "title": "createEqualJoinEngine",
         "type": "function",
+        "children": []
+    },
+    "createEquiJoinEngine": {
+        "title": "createEquiJoinEngine",
+        "type": "function",
         "children": [
             {
                 "title": "语法",
@@ -14044,7 +14049,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "createEqualJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, timeColumn, [garbageSize=5000], [maxDelayedTime])"
+                            "createEquiJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, timeColumn, [garbageSize=5000], [maxDelayedTime])",
+                            "",
+                            "别名：createEqualJoinEngine"
                         ]
                     }
                 ]
@@ -14056,7 +14063,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "创建流数据等值连接引擎。返回一个左、右两表 equal join 后的表对象。注入等值连接引擎的左、右两表将以 :ref:`matchingColumn <mc_aj>` + :ref:`timeColumn <tc_ej>` 作为连接列，返回两表中连接字段相等的行。",
+                            "创建流数据等值连接引擎。返回一个左、右两表 equi join 后的表对象。注入等值连接引擎的左、右两表将以 :ref:`matchingColumn <mc_aj>` + :ref:`timeColumn <tc_ej>` 作为连接列，返回两表中连接字段相等的行。",
                             "",
                             "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
                         ]
@@ -14082,11 +14089,11 @@
                     {
                         "type": "text",
                         "value": [
-                            "equal join 引擎的部分参数和 asof join 引擎相同，请参照 :doc:`createAsofJoinEngine` 中参数介绍。下面介绍不同的参数：",
+                            "equi join 引擎的部分参数和 asof join 引擎相同，请参照 :doc:`createAsofJoinEngine` 中参数介绍。下面介绍不同的参数：",
                             "",
                             ".. _name_ej:",
                             "",
-                            "`name` 字符串标量，表示 equal join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
+                            "`name` 字符串标量，表示 equi join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
                             "",
                             ".. _tc_ej:",
                             "",
@@ -14128,7 +14135,7 @@
                             "   $ share streamTable(1:0, `time`sym`price, [SECOND, SYMBOL, DOUBLE]) as leftTable",
                             "   $ share streamTable(1:0, `time`sym`val, [SECOND, SYMBOL, DOUBLE]) as rightTable",
                             "   $ output=table(100:0, `time`sym`price`val`total, [SECOND, SYMBOL, DOUBLE, DOUBLE, DOUBLE])",
-                            "   $ ejEngine=createEqualJoinEngine(\"test1\", leftTable, rightTable, output, [<price>, <val>, <price*val>], `sym, `time)",
+                            "   $ ejEngine=createEquiJoinEngine(\"test1\", leftTable, rightTable, output, [<price>, <val>, <price*val>], `sym, `time)",
                             "   $ subscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{ejEngine, true}, msgAsTable=true)",
                             "   $ subscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{ejEngine, false}, msgAsTable=true)",
                             "",
@@ -14157,7 +14164,7 @@
                             "   $ share streamTable(5000000:0, `timestamp`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable",
                             "   $ share streamTable(5000000:0, `timestamp`sym`val, [TIMESTAMP, SYMBOL, DOUBLE]) as rightTable",
                             "   $ share table(5000000:0, `timestamp`sym`price`val`total`diff`ratio, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE]) as output",
-                            "   $ ejEngine=createEqualJoinEngine(\"test1\", leftTable, rightTable, output, <[price, val, price+val, price-val, price/val]>, `sym, `timestamp, 5000)",
+                            "   $ ejEngine=createEquiJoinEngine(\"test1\", leftTable, rightTable, output, <[price, val, price+val, price-val, price/val]>, `sym, `timestamp, 5000)",
                             "   $ topic1=subscribeTable(tableName=\"leftTable\", actionName=\"writeLeft\", offset=0, handler=appendForJoin{ejEngine, true}, batchSize=10000, throttle=1)",
                             "   $ topic2=subscribeTable(tableName=\"rightTable\", actionName=\"writeRight\", offset=0, handler=appendForJoin{ejEngine, false}, batchSize=10000, throttle=1)",
                             "   $ def writeLeftTable(mutable tb){",
@@ -22471,7 +22478,7 @@
                             "",
                             "对于第二种情形，`keyType` 是字典键的数据类型，`valueType` 是字典值的数据类型。系统支持以下键的数据类型：Logical, Integral, Floating和Temporal。字典中的值不支持 COMPLEX, POINT 和 Decimal 类别。",
                             "",
-                            "ordered 一个布尔值，默认为 false，表示创建一个无序字典。当 ordered = true 时，创建一个有序字典。无序字典在输出或进行遍历时，其键值对不保留输入时的顺序；有序字典在输出或进行遍历时，键值对的顺序与输入顺序保持一致。"
+                            "`ordered` 一个布尔值，默认为 false，表示创建一个无序字典。当 ordered = true 时，创建一个有序字典。无序字典在输出或进行遍历时，其键值对不保留输入时的顺序；有序字典在输出或进行遍历时，键值对的顺序与输入顺序保持一致。"
                         ]
                     }
                 ]
@@ -32383,7 +32390,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "获取每个节点的多个配置和性能监控度量值。它只能在控制节点上执行。 注意：代理节点的 `connectionNum` 是一个随机值，可以忽略。",
+                            "获取每个节点的多个配置和性能监控度量值。它只能在控制节点上执行。注意：代理节点的 `connectionNum` 是一个随机值，可以忽略。",
                             "",
                             "返回一个表对象，包含以下几列：",
                             "",
@@ -32403,10 +32410,10 @@
                             "* memoryAlloc：系统已分配给当前节点的内存（单位：字节）。",
                             "* cpuUsage：CPU 使用率。",
                             "* avgLoad：CPU 平均负载。",
-                            "* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：纳秒）。",
-                            "* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：纳秒）。",
-                            "* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：纳秒）。",
-                            "* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：纳秒）。",
+                            "* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：纳秒）。注意：必须指定 perfMonitoring=1 才会返回该字段。",
+                            "* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：纳秒）。注意：必须指定 perfMonitoring=1 才会返回该字段。",
+                            "* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：纳秒）。注意：必须指定 perfMonitoring=1 才会返回该字段。",
+                            "* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：纳秒）。注意：必须指定 perfMonitoring=1 才会返回该字段。",
                             "* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：纳秒）。",
                             "* runningJobs：正在执行中的 Job 个数。",
                             "* queuedJobs：队列中的 Job 个数。",
@@ -34206,7 +34213,7 @@
                             "`joinEngine` 创建连接引擎返回的对象。目前 DolphinDB 支持的连接引擎有：",
                             "",
                             "* createAsofJoinEngine",
-                            "* createEqualJoinEngine",
+                            "* createEquiJoinEngine",
                             "* createLookupJoinEngine",
                             "* createWindowJoinEngine"
                         ]
@@ -35998,7 +36005,7 @@
                             "",
                             "* alias：type 是 node 时，为该节点别名，否则为空",
                             "",
-                            "* usedMem：节点或物理机已使用内存",
+                            "* usedMem：节点或物理机已使用内存，单位为 GB",
                             "",
                             "* usedCores：节点或物理机已使用内核数量",
                             "",
@@ -36006,7 +36013,7 @@
                             "",
                             "* lastUpdate：type 是 node 时，表述最后一次给节点分配资源的时间；type 是 machine 时，表示最后一次给物理机上所有节点分配资源时间",
                             "",
-                            "该函数只能由管理员在 licenseServer 上调用。"
+                            "该函数只能由管理员在 license Server 上调用。"
                         ]
                     }
                 ]
@@ -36021,7 +36028,7 @@
                         "value": [
                             "",
                             "    $ getRegisteredNodeInfo()",
-                            "    type \thost\t        port\talias\t        usedMem\t     usedCores\tbindCores\tlastedUpdateTime",
+                            "    type \thost\t        port\talias\t        usedMem\t     usedCores\tbindCores\tlastUpdate",
                             "    node\t10.6.0.12\t33,795\ttest33\t        4\t     2\t\t                2023.02.15T15:23:54.487",
                             "    node\t10.6.0.12\t33,785\tdatanode3\t4\t     2\t\t                2023.02.15T15:11:48.454",
                             "    machine\t10.6.0.12\t\t\t        8\t     4\t\t                2023.02.15T15:23:54.487",
@@ -36061,7 +36068,7 @@
                             "`joinEngine` 创建连接引擎返回的对象。目前 DolphinDB 支持的连接引擎有：",
                             "",
                             "* createAsofJoinEngine",
-                            "* createEqualJoinEngine",
+                            "* createEquiJoinEngine",
                             "* createLookupJoinEngine",
                             "* createWindowJoinEngine"
                         ]
@@ -36310,23 +36317,13 @@
                         "value": [
                             "获取会话的内存占用状态，返回一张表包含以下字段：",
                             "",
-                            "+----------------+---------------------------------------------------+",
-                            "| 参数           | 含义                                              |",
-                            "+================+===================================================+",
-                            "| userId         | 用户 ID 或缓存类型的标识符（形如：\\_\\_xxx\\_\\_）。 |",
-                            "+----------------+---------------------------------------------------+",
-                            "| sessionId      | 会话 ID。                                         |",
-                            "+----------------+---------------------------------------------------+",
-                            "| memSize        | 会话所占用的内存，单位为字节。                    |",
-                            "+----------------+---------------------------------------------------+",
-                            "| remoteIP       | 发起会话的客户端的 IP。                           |",
-                            "+----------------+---------------------------------------------------+",
-                            "| remotePort     | 发起会话的客户端的端口号。                        |",
-                            "+----------------+---------------------------------------------------+",
-                            "| createTime     | 会话创建的时间，为 TIMESTAMP 类型。               |",
-                            "+----------------+---------------------------------------------------+",
-                            "| lastActiveTime | 会话最近一次执行脚本的时间戳。                    |",
-                            "+----------------+---------------------------------------------------+",
+                            "* userId：用户 ID 或缓存类型的标识符（形如：\\_\\_xxx\\_\\_）。 ",
+                            "* sessionId：会话 ID。                          ",
+                            "* memSize：会话所占用的内存，单位为字节。     ",
+                            "* remoteIP：发起会话的客户端的 IP。            ",
+                            "* remotePort：发起会话的客户端的端口号。         ",
+                            "* createTime：会话创建的时间，为 TIMESTAMP 类型。",
+                            "* lastActiveTime：会话最近一次执行脚本的时间戳。     ",
                             "",
                             "缓存类型说明:",
                             "",
@@ -36754,21 +36751,21 @@
                             "memoryUsed          asof join 引擎所占用内存量，单位为字节",
                             "================== =================================================",
                             "",
-                            "* 表 EqualJoinEngine 返回 equal join 引擎的状态。它包含以下列：",
+                            "* 表 equiJoinEngine 返回 equi join 引擎的状态。它包含以下列：",
                             "",
                             "================== =================================================",
                             "列名                含义          ",
                             "================== =================================================",
-                            "name                equal join 引擎的名称",
-                            "user                创建 equal join 引擎的用户名",
-                            "status              equal join 引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用",
+                            "name                equi join 引擎的名称",
+                            "user                创建 equi join 引擎的用户名",
+                            "status              equi join 引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用",
                             "lastErrmsg          最后一条错误信息    ",
                             "garbageSize         触发内存清理的阈值",
-                            "leftTableNumRows    equal join 引擎左表中的记录行数",
-                            "rightTableNumRows   equal join 引擎右表中的记录行数",
-                            "numMetrics          equal join 引擎使用的聚合指标的数量",
-                            "metrics             equal join 引擎使用的聚合指标的元代码",
-                            "memoryUsed          equal join 引擎所占用内存量，单位为字节",
+                            "leftTableNumRows    equi join 引擎左表中的记录行数",
+                            "rightTableNumRows   equi join 引擎右表中的记录行数",
+                            "numMetrics          equi join 引擎使用的聚合指标的数量",
+                            "metrics             equi join 引擎使用的聚合指标的元代码",
+                            "memoryUsed          equi join 引擎所占用内存量，单位为字节",
                             "================== =================================================",
                             "",
                             "* 表 StreamFilter 返回流数据过滤引擎的状态。它包含以下列：",
@@ -45977,7 +45974,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "合并 *X* 和 *Y*。返回结果与 *X* 的数据类型相同。"
+                            "合并 *X* 和 *Y*。"
                         ]
                     }
                 ]
@@ -53207,7 +53204,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "对于输入的多个 *args*，将它们的值组合为一个 BLOB 标量或向量。返回的结果可用作字典或集合的 key。"
+                            "对于输入的多个 *args*，将它们的值组合为一个 BLOB 标量或向量。返回的结果可用作字典或集合的 key。相较于 makeOrderedKey，makeKey 不会会保存组合值的排序结果。"
                         ]
                     }
                 ]
@@ -90370,7 +90367,7 @@
                             "",
                             "`sharedName` 为一个字符串。指定后此字典会被共享，共享的字典名为sharedName。",
                             "",
-                            "ordered 一个布尔值，默认为 false，表示创建一个无序字典。当 ordered = true 时，创建一个有序字典。无序字典在输出或进行遍历时，其键值对不保留输入时的顺序；有序字典在输出或进行遍历时，键值对的顺序与输入顺序保持一致。",
+                            "`ordered` 一个布尔值，默认为 false，表示创建一个无序字典。当 ordered = true 时，创建一个有序字典。无序字典在输出或进行遍历时，其键值对不保留输入时的顺序；有序字典在输出或进行遍历时，键值对的顺序与输入顺序保持一致。",
                             ""
                         ]
                     }
@@ -91969,8 +91966,8 @@
                             "",
                             "`unit` 是一个字符串标量。它表示 *duration* 的单位或用户自定义交易日历的标识。",
                             "",
-                            "- 若为 *duration* 单位，它的取值可以是：\"ns\"(nanosecond), \"us\"(microsecond), \"ms\"(millisecond), \"s\"(second), \"m\"(minute), \"H\"(hour), \"d\"(day), \"w\"(week), \"M\"(month), \"y\"(year), “B”(business day)。",
-                            "- 若需要根据交易日历的规则进行计算，须填写 *marketHolidayDir* 保存的文件名（即交易日历的标识）。",
+                            "- 若为 *duration* 的单位，它的取值可以是：\"ns\"(nanosecond), \"us\"(microsecond), \"ms\"(millisecond), \"s\"(second), \"m\"(minute), \"H\"(hour), \"d\"(day), \"w\"(week), \"M\"(month), \"y\"(year), “B”(business day)。",
+                            "- 若需要基于交易日历增加值，须填写 *marketHolidayDir* 保存的文件名（即交易日历的标识）。",
                             "- 当 *duration* 取 DURATION 类型数据时，该参数无需设置。",
                             "",
                             "注：时间单位为 year 或 month 时，计算结果与 mysql 保持一致。Pandas 提供了一个时间偏移对象（Date offsets）来完成时间偏移工作，当 DateOffset 参数取 months 或 years 时，与 ``temporalAdd`` 单位为 M 或 y 的计算结果也一致。"
@@ -92040,6 +92037,24 @@
                             ""
                         ]
                     },
+                    {
+                        "type": "text",
+                        "value": [
+                            "按照 CFFEX 的交易日历，为 date 增加2个交易日。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ date=[2023.01.01, 2023.01.02, 2023.01.03, 2023.01.04]",
+                            "    $ temporalAdd(index,2,`CFFEX)",
+                            "    [2023.01.04,2023.01.04,2023.01.05,2023.01.06]",
+                            ""
+                        ]
+                    },
                     {
                         "type": "code",
                         "language": "console",

package/language.d.ts

@@ -1,5 +1,5 @@
 export declare const keywords: string[];
-export declare const constants: readonly ["NULL", "true", "false", "pi", "e", "SCALAR", "VECTOR", "PAIR", "MATRIX", "SET", "DICT", "TABLE", "VOID", "BOOL", "CHAR", "SHORT", "INT", "INDEX", "LONG", "DATE", "MONTH", "TIME", "MINUTE", "SECOND", "DATETIME", "TIMESTAMP", "NANOTIME", "NANOTIMESTAMP", "FLOAT", "DOUBLE", "SYMBOL", "STRING", "UUID", "FUNCTIONDEF", "HANDLE", "CODE", "DATASOURCE", "RESOURCE", "ANY", "DICTIONARY", "DATEHOUR", "IPADDR", "INT128", "BLOB", "COMPLEX", "POINT", "DURATION", "OBJECT", "DECIMAL32", "DECIMAL64", "SEQ", "RANGE", "HASH", "VALUE", "LIST", "COMPO", "VAR", "SHARED", "DEF", "GLOBAL", "TABLE_READ", "TABLE_WRITE", "DBOBJ_CREATE", "DBOBJ_DELETE", "DB_MANAGE", "DB_OWNER", "VIEW_EXEC", "SCRIPT_EXEC", "TEST_EXEC", "HINT_HASH", "HINT_SNAPSHOT", "HINT_KEEPORDER", "HINT_SEQ", "HINT_EXPLAIN", "HINT_VECTORIZED", "HEAD", "CURRENT", "TAIL", "LINE", "PIE", "COLUMN", "BAR", "AREA", "SCATTER", "HISTOGRAM", "KLINE", "DEBUG", "INFO", "WARNING", "ERROR", "FIRST", "LAST", "ALL", "NONE", "HASH_PTN", "True", "False", "None"];
+export declare const constants: readonly ["NULL", "true", "false", "pi", "e", "SCALAR", "VECTOR", "PAIR", "MATRIX", "SET", "DICT", "TABLE", "VOID", "BOOL", "CHAR", "SHORT", "INT", "INDEX", "LONG", "DATE", "MONTH", "TIME", "MINUTE", "SECOND", "DATETIME", "TIMESTAMP", "NANOTIME", "NANOTIMESTAMP", "FLOAT", "DOUBLE", "SYMBOL", "STRING", "UUID", "FUNCTIONDEF", "HANDLE", "CODE", "DATASOURCE", "RESOURCE", "ANY", "DICTIONARY", "DATEHOUR", "IPADDR", "INT128", "BLOB", "COMPLEX", "POINT", "DURATION", "OBJECT", "DECIMAL32", "DECIMAL64", "SEQ", "RANGE", "HASH", "VALUE", "LIST", "COMPO", "VAR", "SHARED", "DEF", "GLOBAL", "TABLE_READ", "TABLE_WRITE", "TABLE_INSERT", "TABLE_UPDATE", "TABLE_DELETE", "DBOBJ_CREATE", "DBOBJ_DELETE", "DB_DELETE", "DB_INSERT", "DB_MANAGE", "DB_OWNER", "DB_READ", "DB_UPDATE", "DB_WRITE", "SCRIPT_EXEC", "TASK_GROUP_MEM_LIMIT", "TEST_EXEC", "VIEW_EXEC", "QUERY_RESULT_MEM_LIMIT", "HINT_HASH", "HINT_SNAPSHOT", "HINT_KEEPORDER", "HINT_SEQ", "HINT_EXPLAIN", "HINT_VECTORIZED", "HEAD", "CURRENT", "TAIL", "LINE", "PIE", "COLUMN", "BAR", "AREA", "SCATTER", "HISTOGRAM", "KLINE", "DEBUG", "INFO", "WARNING", "ERROR", "FIRST", "LAST", "ALL", "NONE", "HASH_PTN", "True", "False", "None"];
 export declare const tm_language: Block;
 interface Block {
     patterns: Pattern[];

package/language.js

@@ -159,16 +159,27 @@ export const constants = [
     'DEF',
     'GLOBAL',
     // 用户权限管理
+    // https://www.dolphindb.cn/cn/help/200/SystemManagement/UserAccessControl.html
     // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/CommandsReferences/d/deny.html
     'TABLE_READ',
     'TABLE_WRITE',
+    'TABLE_INSERT',
+    'TABLE_UPDATE',
+    'TABLE_DELETE',
     'DBOBJ_CREATE',
     'DBOBJ_DELETE',
+    'DB_DELETE',
+    'DB_INSERT',
     'DB_MANAGE',
     'DB_OWNER',
-    'VIEW_EXEC',
+    'DB_READ',
+    'DB_UPDATE',
+    'DB_WRITE',
     'SCRIPT_EXEC',
+    'TASK_GROUP_MEM_LIMIT',
     'TEST_EXEC',
+    'VIEW_EXEC',
+    'QUERY_RESULT_MEM_LIMIT',
     // hint
     // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/FunctionReferences/s/sql.html
     'HINT_HASH',
@@ -730,9 +741,13 @@ export const tm_language = {
                     name: 'keyword.operator.bitwise.shift.dolphindb'
                 },
                 {
-                    match: '!=|<=|>=|==',
+                    match: '!=|<=|>=|==|>|<',
                     name: 'keyword.operator.comparison.dolphindb'
                 },
+                {
+                    match: '<-|->',
+                    name: 'keyword.operator.join.dolphindb'
+                },
                 {
                     match: '&&|!|\\|\\|',
                     name: 'keyword.operator.logical.dolphindb'

package/language.js.map

@@ -1 +1 @@
-{"version":3,"file":"language.js","sourceRoot":"","sources":["language.ts"],"names":[],"mappings":"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","sourcesContent":["export const keywords = [\n    'assert',\n    \n    'const',\n    'mutable',\n    \n    'def',\n    'defg',\n    \n    'map',\n    'mapr',\n    \n    'timer',\n    \n    // 流程控制\n    'if',\n    'else',\n    'do',\n    'for',\n    'while',\n    'return',\n    'continue',\n    'break',\n    'try',\n    'catch',\n    'throw',\n    'go',\n    \n    // 模块\n    'use',\n    'module',\n    \n    \n    // 仅 Python 有的\n    'async',\n    'await',\n    'class',\n    'del',\n    'elif',\n    'except',\n    'finally',\n    'global',\n    'import',\n    'is',\n    'lambda',\n    'nonlocal',\n    'not',\n    'or',\n    'pass',\n    'raise',\n    'yield',\n    \n    \n    \n    // --- SQL\n    'select',\n    'exec',\n    'update',\n    'insert',\n    'create',\n    'alter',\n    'delete',\n    \n    'transaction',\n    \n    'inner join',\n    'full join',\n    'left join',\n    'right join',\n    'left semijoin',\n    'cross join',\n    \n    'context by',\n    'partitioned by',\n    'group by',\n    'pivot by',\n    'order by',\n    'cgroup by',\n    \n    'csort',\n    'limit',\n    'top',\n    \n    'into',\n    'from',\n    'where',\n    'having',\n    'with',\n    'set',\n    'as',\n    'in',\n    'on',\n    'values',\n    'exists',\n    'distinct',\n    \n    'between', 'and', // between ... and ...\n    \n    'is null', 'is not null',\n    \n    // case when ... then ... end\n    'case', 'when', 'then', 'end',\n    \n    'union', 'union all',\n    \n    'nulls first', 'nulls last',\n    \n    'asc', 'desc',\n].sort((l, r) => {  // 长的在前面，正则表达式先匹配全部，而不是部分单词，防止高亮显示不正确\n    const delta_len = l.length - r.length\n    if (delta_len !== 0)\n        return -delta_len\n    \n    return 0 // 否则保留原本顺序\n})\n\n\nexport const constants = [\n    'NULL',\n    'true',\n    'false',\n    'pi',\n    'e',\n    \n    // --- form\n    'SCALAR',\n    'VECTOR',\n    'PAIR',\n    'MATRIX',\n    'SET',\n    'DICT',\n    'TABLE',\n    // 'CHART',\n    // 'CHUNK',\n    \n    // --- type\n    'VOID',\n    'BOOL',\n    'CHAR',\n    'SHORT',\n    'INT', 'INDEX',\n    'LONG',\n    'DATE',\n    'MONTH',\n    'TIME',\n    'MINUTE',\n    'SECOND',\n    'DATETIME',\n    'TIMESTAMP',\n    'NANOTIME',\n    'NANOTIMESTAMP',\n    'FLOAT',\n    'DOUBLE',\n    'SYMBOL',\n    'STRING',\n    'UUID',\n    'FUNCTIONDEF',\n    'HANDLE',\n    'CODE',\n    'DATASOURCE',\n    'RESOURCE',\n    'ANY',\n    // 'COMPRESS',\n    'DICTIONARY',\n    'DATEHOUR',\n    'IPADDR',\n    'INT128',\n    'BLOB',\n    'COMPLEX',\n    'POINT',\n    'DURATION',\n    'OBJECT',\n    'DECIMAL32',\n    'DECIMAL64',\n    \n    // partition type\n    'SEQ',\n    'RANGE',\n    'HASH',\n    'VALUE',\n    'LIST',\n    'COMPO',\n    \n    \n    // defined\n    // https://www.dolphindb.cn/cn/help/FunctionsandCommands/FunctionReferences/d/defined.html\n    'VAR',\n    'SHARED',\n    'DEF',\n    'GLOBAL',\n    \n    \n    // 用户权限管理\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/CommandsReferences/d/deny.html\n    'TABLE_READ',\n    'TABLE_WRITE',\n    'DBOBJ_CREATE',\n    'DBOBJ_DELETE',\n    'DB_MANAGE',\n    'DB_OWNER',\n    'VIEW_EXEC',\n    'SCRIPT_EXEC',\n    'TEST_EXEC',\n    \n    \n    // hint\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/FunctionReferences/s/sql.html\n    'HINT_HASH',\n    'HINT_SNAPSHOT',\n    'HINT_KEEPORDER',\n    'HINT_SEQ',\n    'HINT_EXPLAIN',\n    'HINT_VECTORIZED',\n    \n    \n    // --- seek mode\n    'HEAD',\n    'CURRENT',\n    'TAIL',\n    \n    // --- chart type\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/FunctionReferences/p/plot.html\n    'LINE',\n    'PIE',\n    'COLUMN',\n    'BAR',\n    'AREA',\n    'SCATTER',\n    'HISTOGRAM',\n    'KLINE',\n    \n    \n    // --- log level\n    'DEBUG',\n    'INFO',\n    'WARNING',\n    'ERROR',\n    \n    // keep duplicates\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/FunctionReferences/c/createPartitionedTable.html?highlight=first\n    'FIRST',\n    'LAST',\n    'ALL',\n    \n    // keep\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/FunctionReferences/i/isDuplicated.html?highlight=none\n    'NONE',\n    \n    'HASH_PTN',\n    \n    // 仅 Python 有的\n    'True',\n    'False',\n    'None',\n    \n] as const\n\n\n\nexport const tm_language = {\n    '$schema': 'https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json',\n    \n    name: 'DolphinDB',\n    \n    scopeName: 'source.dolphindb',\n    \n    patterns: [\n        {\n            match: '\\\\.\\\\.\\\\.',\n            name: 'invalid.ellipsis.dolphindb'\n        },\n        {\n            include: '#keyword'\n        },\n        {\n            include: '#literal'\n        },\n        {\n            include: '#comment'\n        },\n        {\n            include: '#decorator'\n        },\n        {\n            include: '#variable'\n        },\n        {\n            include: '#operator'\n        },\n        {\n            include: '#method_call'\n        },\n        {\n            include: '#function_call'\n        },\n        {\n            include: '#property'\n        },\n        {\n            match: ';',\n            name: 'punctuation.terminator.statement.dolphindb'\n        },\n        {\n            match: ',',\n            name: 'punctuation.separator.commma.dolphindb'\n        }\n    ],\n    \n    \n    repository: {\n        keyword: {\n            // \\b: word boundary\n            // (?<![.$]): boundary 不是 . 或 $\n            // ?!\\s*: 不是 label\n            match: `\\\\b(?<![.$])(${keywords.join('|')})(?!(\\\\s*:|\\\\())\\\\b`,\n            name: 'keyword.control.dolphindb'\n        },\n        \n        literal: {\n            patterns: [\n                { include: '#constant' },\n                { include: '#datetime' },\n                { include: '#string' },\n                { include: '#number' },\n            ]\n        },\n        \n        constant: {\n            match: `\\\\b(?<![.$])(${constants.join('|')})(?!\\\\s*:)\\\\b`,\n            name: 'constant.language.int.dolphindb'\n        },\n        \n        decorator: {\n            match: '^@testing',\n            name: 'meta.decorator.dolphindb',\n        },\n        \n        datetime: {\n            patterns: [\n                {\n                    match: '\\\\b[0-9]{4}[.][0-9]{2}[.][0-9]{2}[T ][0-9]{2}:[0-9]{2}:[0-9]{2}([.][0-9]{3,9})?\\\\b',\n                    name: 'constant.numeric.datetime.datetime.dolphindb',\n                },\n                {\n                    match: '\\\\b[0-9]{4}\\\\.[0-9]{2}M\\\\b',\n                    name: 'constant.numeric.datetime.month.dolphindb',\n                },\n                {\n                    match: '\\\\b[0-9]{4}\\\\.[0-9]{2}\\\\.[0-9]{2}\\\\b',\n                    name: 'constant.numeric.datetime.date.dolphindb',\n                },\n                {\n                    match: '\\\\b[0-9]{2}:[0-9]{2}:[0-9]{2}([.][0-9]{3,9})?\\\\b',\n                    name: 'constant.numeric.datetime.time.dolphindb',\n                },\n                {\n                    match: '\\\\b[0-9]{2}:[0-9]{2}m\\\\b',\n                    name: 'constant.numeric.datetime.minute.dolphindb',\n                },\n            ]\n        },\n        \n        string: {\n            patterns: [\n                {\n                    include: '#string_single_quoted'\n                },\n                {\n                    include: '#string_double_quoted'\n                },\n                {\n                    begin: \"'''\",\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        }\n                    },\n                    end: \"'''\",\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    },\n                    name: 'string.quoted.single.heredoc.dolphindb',\n                    patterns: [\n                        {\n                            captures: {\n                                1: {\n                                    name: 'punctuation.definition.escape.backslash.dolphindb'\n                                }\n                            },\n                            match: '(\\\\\\\\).',\n                            name: 'constant.character.escape.backslash.dolphindb'\n                        }\n                    ]\n                },\n                {\n                    begin: '\"\"\"',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        }\n                    },\n                    end: '\"\"\"',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    },\n                    name: 'string.quoted.double.heredoc.dolphindb',\n                    patterns: [\n                        {\n                            captures: {\n                                1: {\n                                    name: 'punctuation.definition.escape.backslash.dolphindb'\n                                }\n                            },\n                            match: '(\\\\\\\\).',\n                            name: 'constant.character.escape.backslash.dolphindb'\n                        },\n                        {\n                            include: '#interpolated_dolphindb'\n                        }\n                    ]\n                },\n                {\n                    match: '`[\\\\w\\\\.]+',\n                    name: 'string.quoted.other.dolphindb'\n                },\n                {\n                    match: '(`)(.*)(`)',\n                    name: 'string.quoted.script.dolphindb',\n                    captures: {\n                        1: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        },\n                        2: {\n                            name: 'source.js.embedded.dolphindb',\n                            patterns: [\n                                {\n                                    include: 'source.js'\n                                }\n                            ]\n                        },\n                        3: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    }\n                }\n            ]\n        },\n        \n        number: {\n            patterns: [\n                {\n                    match: '\\\\b[01]+[bB]\\\\b',\n                    name: 'constant.numeric.binary.dolphindb'\n                },\n                {\n                    // 97c\n                    match: '\\\\b[0-9]+([clhsmyM]|ms)\\\\b',\n                    name: 'constant.numeric.dolphindb'\n                },\n                {\n                    // 1.2f, 1f\n                    match: '\\\\b[0-9]+(\\\\.[0-9]+)?f\\\\b',\n                    name: 'constant.numeric.dolphindb'\n                },\n                {\n                    match: \n                        '(?x)\\n' +\n                        '(?:\\n' +\n                        '  (?:\\\\b[0-9]+(\\\\.)[0-9]+[eE][+-]?[0-9]+\\\\b)| # 1.1E+3\\n' +\n                        '  (?:\\\\b[0-9]+(\\\\.)[eE][+-]?[0-9]+\\\\b)|       # 1.E+3\\n' +\n                        '  (?:\\\\b(\\\\.)[0-9]+[eE][+-]?[0-9]+\\\\b)|       # .1E+3\\n' +\n                        '  (?:\\\\b[0-9]+[eE][+-]?[0-9]+\\\\b)|            # 1E+3\\n' +\n                        '  (?:\\\\b[0-9]+(\\\\.)[0-9]+\\\\b)|                # 1.1\\n' +\n                        '  (?:\\\\b[0-9]+(?=\\\\.{2,3}))|                  # 1 followed by a slice\\n' +\n                        '  (?:\\\\b[0-9]+(\\\\.)\\\\b)|                      # 1.\\n' +\n                        '  (?:\\\\b(\\\\.)[0-9]+\\\\b)|                      # .1\\n' +\n                        '  (?:\\\\b[0-9]+\\\\b(?!\\\\.))                     # 1\\n' +\n                        ')\\n',\n                    \n                    captures: {\n                        0: {\n                            name: 'constant.numeric.decimal.dolphindb'\n                        },\n                        1: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        2: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        3: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        4: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        5: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        6: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        }\n                    }\n                },\n            ]\n        },\n        \n        string_single_quoted: {\n            patterns: [\n                {\n                    begin: \"'\",\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        }\n                    },\n                    end: \"'\",\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    },\n                    name: 'string.quoted.single.dolphindb',\n                    patterns: [\n                        {\n                            captures: {\n                                1: {\n                                    name: 'punctuation.definition.escape.backslash.dolphindb'\n                                }\n                            },\n                            match: '(\\\\\\\\)(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.)',\n                            name: 'constant.character.escape.backslash.dolphindb'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        string_double_quoted: {\n            patterns: [\n                {\n                    begin: '\"',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        }\n                    },\n                    end: '\"',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    },\n                    name: 'string.quoted.double.dolphindb',\n                    patterns: [\n                        {\n                            captures: {\n                                1: {\n                                    name: 'punctuation.definition.escape.backslash.dolphindb'\n                                }\n                            },\n                            match: '(\\\\\\\\)(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]|37[0-7]?|[4-7][0-7]?|.)',\n                            name: 'constant.character.escape.backslash.dolphindb'\n                        },\n                        {\n                            include: '#interpolated_dolphindb'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        function_call: {\n            patterns: [\n                {\n                    begin: '(@)?([\\\\w$]+!?)\\\\s*(?=\\\\()',\n                    beginCaptures: {\n                        1: {\n                            name: 'variable.other.readwrite.instance.dolphindb'\n                        },\n                        2: {\n                            patterns: [\n                                {\n                                    include: '#function_name'\n                                }\n                            ]\n                        }\n                    },\n                    end: '(?<=\\\\))',\n                    name: 'meta.function-call.dolphindb',\n                    patterns: [\n                        {\n                            include: '#arguments'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        function_name: {\n            patterns: [\n                {\n                    match: '[a-zA-Z_$][\\\\w$]*',\n                    name: 'entity.name.function.dolphindb'\n                },\n                {\n                    match: '\\\\d[\\\\w$]*',\n                    name: 'invalid.illegal.identifier.dolphindb'\n                }\n            ]\n        },\n        \n        function_params: {\n            patterns: [\n                {\n                    begin: '\\\\(',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.parameters.begin.bracket.round.dolphindb'\n                        }\n                    },\n                    end: '\\\\)',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.parameters.end.bracket.round.dolphindb'\n                        }\n                    },\n                    name: 'meta.parameters.dolphindb',\n                    patterns: [\n                        {\n                            include: '#variable'\n                        },\n                        {\n                            match: '(@(?:[a-zA-Z_$][\\\\w$]*)?)(\\\\.\\\\.\\\\.)?',\n                            captures: {\n                                1: {\n                                    name: 'variable.parameter.function.readwrite.instance.dolphindb'\n                                },\n                                2: {\n                                    name: 'keyword.operator.splat.dolphindb'\n                                }\n                            }\n                        },\n                        {\n                            include: '$self'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        comment: {\n            patterns: [\n                {\n                    begin: '/\\\\*',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.comment.dolphindb'\n                        }\n                    },\n                    end: '\\\\*/',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.comment.dolphindb'\n                        }\n                    },\n                    name: 'comment.block.dolphindb'\n                },\n                {\n                    begin: '//',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.comment.dolphindb'\n                        }\n                    },\n                    end: '$',\n                    name: 'comment.line.number-sign.dolphindb'\n                },\n                {\n                    begin: '#',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.comment.dolphindb'\n                        }\n                    },\n                    end: '$',\n                    name: 'comment.line.number-sign.dolphindb'\n                }\n            ]\n        },\n        \n        arguments: {\n            patterns: [\n                {\n                    begin: '\\\\(',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.arguments.begin.bracket.round.dolphindb'\n                        }\n                    },\n                    end: '\\\\)',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.arguments.end.bracket.round.dolphindb'\n                        }\n                    },\n                    name: 'meta.arguments.dolphindb',\n                    patterns: [\n                        {\n                            include: '$self'\n                        },\n                        {\n                            include: '#literal'\n                        },\n                        {\n                            include: '#variable'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        variable: {\n            patterns: [\n                {\n                    match: '(@)([a-zA-Z_\\\\$]\\\\w*)?',\n                    name: 'variable.other.readwrite.instance.dolphindb'\n                }\n            ]\n        },\n        \n        interpolated_dolphindb: {\n            patterns: [\n                {\n                    begin: '\\\\#\\\\{',\n                    captures: {\n                        0: {\n                            name: 'punctuation.section.embedded.dolphindb'\n                        }\n                    },\n                    end: '\\\\}',\n                    name: 'source.dolphindb.embedded.source',\n                    patterns: [\n                        {\n                            include: '$self'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        method_call: {\n            patterns: [\n                {\n                    begin: '(?:(\\\\.)|(::))\\\\s*([\\\\w$]+!?)(?=\\\\()',\n                    beginCaptures: {\n                        1: {\n                            name: 'punctuation.separator.method.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            patterns: [\n                                {\n                                    include: '#method_name'\n                                }\n                            ]\n                        }\n                    },\n                    end: '(?<=\\\\))',\n                    name: 'meta.method-call.dolphindb',\n                    patterns: [\n                        {\n                            include: '#arguments'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        method_name: {\n            patterns: [\n                {\n                    match: '[a-zA-Z_$][\\\\w$]*',\n                    name: 'entity.name.function.dolphindb'\n                },\n                {\n                    match: '\\\\d[\\\\w$]*',\n                    name: 'invalid.illegal.identifier.dolphindb'\n                }\n            ]\n        },\n        \n        operator: {\n            patterns: [\n                {\n                    match: '<<|>>',\n                    name: 'keyword.operator.bitwise.shift.dolphindb'\n                },\n                {\n                    match: '!=|<=|>=|==',\n                    name: 'keyword.operator.comparison.dolphindb'\n                },\n                {\n                    match: '&&|!|\\\\|\\\\|',\n                    name: 'keyword.operator.logical.dolphindb'\n                },\n                {\n                    match: '&|\\\\||\\\\^',\n                    name: 'keyword.operator.bitwise.dolphindb'\n                },\n                {\n                    match: '\\\\.\\\\.',\n                    name: 'keyword.operator.splat.dolphindb'\n                },\n                {\n                    match: '\\\\?',\n                    name: 'keyword.operator.existential.dolphindb'\n                },\n                {\n                    match: '/|<-|%|\\\\*|/|-|\\\\$|\\\\+',\n                    name: 'keyword.operator.dolphindb'\n                },\n                {\n                    match: '([a-zA-Z$_][\\\\w$]*)?\\\\s*(=|:(?!:))(?![>=])',\n                    captures: {\n                        1: {\n                            name: 'variable.assignment.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.assignment.dolphindb'\n                        }\n                    }\n                }\n            ]\n        },\n        \n        property: {\n            patterns: [\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*([A-Z][A-Z0-9_$]*\\\\b\\\\$*)(?=\\\\s*\\\\??(\\\\.\\\\s*[a-zA-Z_$]\\\\w*|::))',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'constant.other.object.property.dolphindb'\n                        }\n                    }\n                },\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*(\\\\$*[a-zA-Z_$][\\\\w$]*)(?=\\\\s*\\\\??(\\\\.\\\\s*[a-zA-Z_$]\\\\w*|::))',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'variable.other.object.property.dolphindb'\n                        }\n                    }\n                },\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*([A-Z][A-Z0-9_$]*\\\\b\\\\$*)',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'constant.other.property.dolphindb'\n                        }\n                    }\n                },\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*(\\\\$*[a-zA-Z_$][\\\\w$]*)',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'variable.other.property.dolphindb'\n                        }\n                    }\n                },\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*([0-9][\\\\w$]*)',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'invalid.illegal.identifier.dolphindb'\n                        }\n                    }\n                }\n            ]\n        }\n    }\n} as Block\n\n\ninterface Block {\n    patterns: Pattern[]\n    repository?: Record<string, Pattern | Block>\n}\n\ntype Pattern = Match | Include | Block\n\ntype Match = MatchOne | MatchBeginEnd\n\ninterface MatchOne {\n    /** a single-line regular expression */\n    match: RegExp | string\n    \n    /** This is the scope that will be applied to the matched text */\n    name?: string\n    \n    /** This use of the captures > patterns structure is extremely important. \n        Without it, a stretch of text matched by a match rule is considered finished, and \n        TextMate’s search proceeds to the rest of the line after the matched text. \n        With it, the stretch of matched text itself becomes a candidate for further matches. \n    */\n    captures?: Captures\n}\n\ninterface MatchBeginEnd {\n    begin: RegExp | string\n    \n    end: RegExp | string\n    \n    /** This is the scope (or an expression evaluating to a scope) to be applied to \n        the entire matched stretch(es) of text starting at the start of the begin match.\n    */\n    name?: string\n    \n    /** This is the scope to be applied to what’s between the begin match and the end match (or the end of the document). */\n    contentName?: string\n    \n    /** it applies to the region between the begin and end matches. */\n    patterns?: Pattern[]\n    \n    beginCaptures?: Captures\n    \n    endCaptures?: Captures\n    \n    whileCaptures?: Captures\n    \n    /** If the name or number of the matched group happens to be the same for both the begin pattern and the other pattern, \n        you can (if appropriate) use captures as a shorthand to avoid saying the same thing twice.\n    */\n    captures?: Captures\n    \n    applyEndPatternLast?: 1\n}\n\ninterface Include {\n    include: string\n}\n\ntype Captures = Record<string | number, {\n    /** This is the scope that will be assigned to the matched group text. */\n    name?: string\n    \n    /** This is a list of match rules to be sought within the matched group text \n        — thus permitting the search for matches to continue inside the matched text.\n    */\n    patterns?: Pattern[]\n}>\n\n"]}
+{"version":3,"file":"language.js","sourceRoot":"","sources":["language.ts"],"names":[],"mappings":"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","sourcesContent":["export const keywords = [\n    'assert',\n    \n    'const',\n    'mutable',\n    \n    'def',\n    'defg',\n    \n    'map',\n    'mapr',\n    \n    'timer',\n    \n    // 流程控制\n    'if',\n    'else',\n    'do',\n    'for',\n    'while',\n    'return',\n    'continue',\n    'break',\n    'try',\n    'catch',\n    'throw',\n    'go',\n    \n    // 模块\n    'use',\n    'module',\n    \n    \n    // 仅 Python 有的\n    'async',\n    'await',\n    'class',\n    'del',\n    'elif',\n    'except',\n    'finally',\n    'global',\n    'import',\n    'is',\n    'lambda',\n    'nonlocal',\n    'not',\n    'or',\n    'pass',\n    'raise',\n    'yield',\n    \n    \n    \n    // --- SQL\n    'select',\n    'exec',\n    'update',\n    'insert',\n    'create',\n    'alter',\n    'delete',\n    \n    'transaction',\n    \n    'inner join',\n    'full join',\n    'left join',\n    'right join',\n    'left semijoin',\n    'cross join',\n    \n    'context by',\n    'partitioned by',\n    'group by',\n    'pivot by',\n    'order by',\n    'cgroup by',\n    \n    'csort',\n    'limit',\n    'top',\n    \n    'into',\n    'from',\n    'where',\n    'having',\n    'with',\n    'set',\n    'as',\n    'in',\n    'on',\n    'values',\n    'exists',\n    'distinct',\n    \n    'between', 'and', // between ... and ...\n    \n    'is null', 'is not null',\n    \n    // case when ... then ... end\n    'case', 'when', 'then', 'end',\n    \n    'union', 'union all',\n    \n    'nulls first', 'nulls last',\n    \n    'asc', 'desc',\n].sort((l, r) => {  // 长的在前面，正则表达式先匹配全部，而不是部分单词，防止高亮显示不正确\n    const delta_len = l.length - r.length\n    if (delta_len !== 0)\n        return -delta_len\n    \n    return 0 // 否则保留原本顺序\n})\n\n\nexport const constants = [\n    'NULL',\n    'true',\n    'false',\n    'pi',\n    'e',\n    \n    // --- form\n    'SCALAR',\n    'VECTOR',\n    'PAIR',\n    'MATRIX',\n    'SET',\n    'DICT',\n    'TABLE',\n    // 'CHART',\n    // 'CHUNK',\n    \n    // --- type\n    'VOID',\n    'BOOL',\n    'CHAR',\n    'SHORT',\n    'INT', 'INDEX',\n    'LONG',\n    'DATE',\n    'MONTH',\n    'TIME',\n    'MINUTE',\n    'SECOND',\n    'DATETIME',\n    'TIMESTAMP',\n    'NANOTIME',\n    'NANOTIMESTAMP',\n    'FLOAT',\n    'DOUBLE',\n    'SYMBOL',\n    'STRING',\n    'UUID',\n    'FUNCTIONDEF',\n    'HANDLE',\n    'CODE',\n    'DATASOURCE',\n    'RESOURCE',\n    'ANY',\n    // 'COMPRESS',\n    'DICTIONARY',\n    'DATEHOUR',\n    'IPADDR',\n    'INT128',\n    'BLOB',\n    'COMPLEX',\n    'POINT',\n    'DURATION',\n    'OBJECT',\n    'DECIMAL32',\n    'DECIMAL64',\n    \n    // partition type\n    'SEQ',\n    'RANGE',\n    'HASH',\n    'VALUE',\n    'LIST',\n    'COMPO',\n    \n    \n    // defined\n    // https://www.dolphindb.cn/cn/help/FunctionsandCommands/FunctionReferences/d/defined.html\n    'VAR',\n    'SHARED',\n    'DEF',\n    'GLOBAL',\n    \n    \n    // 用户权限管理\n    // https://www.dolphindb.cn/cn/help/200/SystemManagement/UserAccessControl.html\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/CommandsReferences/d/deny.html\n    'TABLE_READ',\n    'TABLE_WRITE',\n    'TABLE_INSERT',\n    'TABLE_UPDATE',\n    'TABLE_DELETE',\n    \n    'DBOBJ_CREATE',\n    'DBOBJ_DELETE',\n    \n    'DB_DELETE',\n    'DB_INSERT',\n    'DB_MANAGE',\n    'DB_OWNER',\n    'DB_READ',\n    'DB_UPDATE',\n    'DB_WRITE',\n    \n    'SCRIPT_EXEC',\n    'TASK_GROUP_MEM_LIMIT',\n    'TEST_EXEC',\n    'VIEW_EXEC',\n    'QUERY_RESULT_MEM_LIMIT',\n    \n    \n    // hint\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/FunctionReferences/s/sql.html\n    'HINT_HASH',\n    'HINT_SNAPSHOT',\n    'HINT_KEEPORDER',\n    'HINT_SEQ',\n    'HINT_EXPLAIN',\n    'HINT_VECTORIZED',\n    \n    \n    // --- seek mode\n    'HEAD',\n    'CURRENT',\n    'TAIL',\n    \n    // --- chart type\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/FunctionReferences/p/plot.html\n    'LINE',\n    'PIE',\n    'COLUMN',\n    'BAR',\n    'AREA',\n    'SCATTER',\n    'HISTOGRAM',\n    'KLINE',\n    \n    \n    // --- log level\n    'DEBUG',\n    'INFO',\n    'WARNING',\n    'ERROR',\n    \n    // keep duplicates\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/FunctionReferences/c/createPartitionedTable.html?highlight=first\n    'FIRST',\n    'LAST',\n    'ALL',\n    \n    // keep\n    // https://www.dolphindb.cn/cn/help/200/FunctionsandCommands/FunctionReferences/i/isDuplicated.html?highlight=none\n    'NONE',\n    \n    'HASH_PTN',\n    \n    // 仅 Python 有的\n    'True',\n    'False',\n    'None',\n    \n] as const\n\n\n\nexport const tm_language = {\n    '$schema': 'https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json',\n    \n    name: 'DolphinDB',\n    \n    scopeName: 'source.dolphindb',\n    \n    patterns: [\n        {\n            match: '\\\\.\\\\.\\\\.',\n            name: 'invalid.ellipsis.dolphindb'\n        },\n        {\n            include: '#keyword'\n        },\n        {\n            include: '#literal'\n        },\n        {\n            include: '#comment'\n        },\n        {\n            include: '#decorator'\n        },\n        {\n            include: '#variable'\n        },\n        {\n            include: '#operator'\n        },\n        {\n            include: '#method_call'\n        },\n        {\n            include: '#function_call'\n        },\n        {\n            include: '#property'\n        },\n        {\n            match: ';',\n            name: 'punctuation.terminator.statement.dolphindb'\n        },\n        {\n            match: ',',\n            name: 'punctuation.separator.commma.dolphindb'\n        }\n    ],\n    \n    \n    repository: {\n        keyword: {\n            // \\b: word boundary\n            // (?<![.$]): boundary 不是 . 或 $\n            // ?!\\s*: 不是 label\n            match: `\\\\b(?<![.$])(${keywords.join('|')})(?!(\\\\s*:|\\\\())\\\\b`,\n            name: 'keyword.control.dolphindb'\n        },\n        \n        literal: {\n            patterns: [\n                { include: '#constant' },\n                { include: '#datetime' },\n                { include: '#string' },\n                { include: '#number' },\n            ]\n        },\n        \n        constant: {\n            match: `\\\\b(?<![.$])(${constants.join('|')})(?!\\\\s*:)\\\\b`,\n            name: 'constant.language.int.dolphindb'\n        },\n        \n        decorator: {\n            match: '^@testing',\n            name: 'meta.decorator.dolphindb',\n        },\n        \n        datetime: {\n            patterns: [\n                {\n                    match: '\\\\b[0-9]{4}[.][0-9]{2}[.][0-9]{2}[T ][0-9]{2}:[0-9]{2}:[0-9]{2}([.][0-9]{3,9})?\\\\b',\n                    name: 'constant.numeric.datetime.datetime.dolphindb',\n                },\n                {\n                    match: '\\\\b[0-9]{4}\\\\.[0-9]{2}M\\\\b',\n                    name: 'constant.numeric.datetime.month.dolphindb',\n                },\n                {\n                    match: '\\\\b[0-9]{4}\\\\.[0-9]{2}\\\\.[0-9]{2}\\\\b',\n                    name: 'constant.numeric.datetime.date.dolphindb',\n                },\n                {\n                    match: '\\\\b[0-9]{2}:[0-9]{2}:[0-9]{2}([.][0-9]{3,9})?\\\\b',\n                    name: 'constant.numeric.datetime.time.dolphindb',\n                },\n                {\n                    match: '\\\\b[0-9]{2}:[0-9]{2}m\\\\b',\n                    name: 'constant.numeric.datetime.minute.dolphindb',\n                },\n            ]\n        },\n        \n        string: {\n            patterns: [\n                {\n                    include: '#string_single_quoted'\n                },\n                {\n                    include: '#string_double_quoted'\n                },\n                {\n                    begin: \"'''\",\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        }\n                    },\n                    end: \"'''\",\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    },\n                    name: 'string.quoted.single.heredoc.dolphindb',\n                    patterns: [\n                        {\n                            captures: {\n                                1: {\n                                    name: 'punctuation.definition.escape.backslash.dolphindb'\n                                }\n                            },\n                            match: '(\\\\\\\\).',\n                            name: 'constant.character.escape.backslash.dolphindb'\n                        }\n                    ]\n                },\n                {\n                    begin: '\"\"\"',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        }\n                    },\n                    end: '\"\"\"',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    },\n                    name: 'string.quoted.double.heredoc.dolphindb',\n                    patterns: [\n                        {\n                            captures: {\n                                1: {\n                                    name: 'punctuation.definition.escape.backslash.dolphindb'\n                                }\n                            },\n                            match: '(\\\\\\\\).',\n                            name: 'constant.character.escape.backslash.dolphindb'\n                        },\n                        {\n                            include: '#interpolated_dolphindb'\n                        }\n                    ]\n                },\n                {\n                    match: '`[\\\\w\\\\.]+',\n                    name: 'string.quoted.other.dolphindb'\n                },\n                {\n                    match: '(`)(.*)(`)',\n                    name: 'string.quoted.script.dolphindb',\n                    captures: {\n                        1: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        },\n                        2: {\n                            name: 'source.js.embedded.dolphindb',\n                            patterns: [\n                                {\n                                    include: 'source.js'\n                                }\n                            ]\n                        },\n                        3: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    }\n                }\n            ]\n        },\n        \n        number: {\n            patterns: [\n                {\n                    match: '\\\\b[01]+[bB]\\\\b',\n                    name: 'constant.numeric.binary.dolphindb'\n                },\n                {\n                    // 97c\n                    match: '\\\\b[0-9]+([clhsmyM]|ms)\\\\b',\n                    name: 'constant.numeric.dolphindb'\n                },\n                {\n                    // 1.2f, 1f\n                    match: '\\\\b[0-9]+(\\\\.[0-9]+)?f\\\\b',\n                    name: 'constant.numeric.dolphindb'\n                },\n                {\n                    match: \n                        '(?x)\\n' +\n                        '(?:\\n' +\n                        '  (?:\\\\b[0-9]+(\\\\.)[0-9]+[eE][+-]?[0-9]+\\\\b)| # 1.1E+3\\n' +\n                        '  (?:\\\\b[0-9]+(\\\\.)[eE][+-]?[0-9]+\\\\b)|       # 1.E+3\\n' +\n                        '  (?:\\\\b(\\\\.)[0-9]+[eE][+-]?[0-9]+\\\\b)|       # .1E+3\\n' +\n                        '  (?:\\\\b[0-9]+[eE][+-]?[0-9]+\\\\b)|            # 1E+3\\n' +\n                        '  (?:\\\\b[0-9]+(\\\\.)[0-9]+\\\\b)|                # 1.1\\n' +\n                        '  (?:\\\\b[0-9]+(?=\\\\.{2,3}))|                  # 1 followed by a slice\\n' +\n                        '  (?:\\\\b[0-9]+(\\\\.)\\\\b)|                      # 1.\\n' +\n                        '  (?:\\\\b(\\\\.)[0-9]+\\\\b)|                      # .1\\n' +\n                        '  (?:\\\\b[0-9]+\\\\b(?!\\\\.))                     # 1\\n' +\n                        ')\\n',\n                    \n                    captures: {\n                        0: {\n                            name: 'constant.numeric.decimal.dolphindb'\n                        },\n                        1: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        2: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        3: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        4: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        5: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        },\n                        6: {\n                            name: 'punctuation.separator.decimal.period.dolphindb'\n                        }\n                    }\n                },\n            ]\n        },\n        \n        string_single_quoted: {\n            patterns: [\n                {\n                    begin: \"'\",\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        }\n                    },\n                    end: \"'\",\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    },\n                    name: 'string.quoted.single.dolphindb',\n                    patterns: [\n                        {\n                            captures: {\n                                1: {\n                                    name: 'punctuation.definition.escape.backslash.dolphindb'\n                                }\n                            },\n                            match: '(\\\\\\\\)(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.)',\n                            name: 'constant.character.escape.backslash.dolphindb'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        string_double_quoted: {\n            patterns: [\n                {\n                    begin: '\"',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.begin.dolphindb'\n                        }\n                    },\n                    end: '\"',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.string.end.dolphindb'\n                        }\n                    },\n                    name: 'string.quoted.double.dolphindb',\n                    patterns: [\n                        {\n                            captures: {\n                                1: {\n                                    name: 'punctuation.definition.escape.backslash.dolphindb'\n                                }\n                            },\n                            match: '(\\\\\\\\)(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]|37[0-7]?|[4-7][0-7]?|.)',\n                            name: 'constant.character.escape.backslash.dolphindb'\n                        },\n                        {\n                            include: '#interpolated_dolphindb'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        function_call: {\n            patterns: [\n                {\n                    begin: '(@)?([\\\\w$]+!?)\\\\s*(?=\\\\()',\n                    beginCaptures: {\n                        1: {\n                            name: 'variable.other.readwrite.instance.dolphindb'\n                        },\n                        2: {\n                            patterns: [\n                                {\n                                    include: '#function_name'\n                                }\n                            ]\n                        }\n                    },\n                    end: '(?<=\\\\))',\n                    name: 'meta.function-call.dolphindb',\n                    patterns: [\n                        {\n                            include: '#arguments'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        function_name: {\n            patterns: [\n                {\n                    match: '[a-zA-Z_$][\\\\w$]*',\n                    name: 'entity.name.function.dolphindb'\n                },\n                {\n                    match: '\\\\d[\\\\w$]*',\n                    name: 'invalid.illegal.identifier.dolphindb'\n                }\n            ]\n        },\n        \n        function_params: {\n            patterns: [\n                {\n                    begin: '\\\\(',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.parameters.begin.bracket.round.dolphindb'\n                        }\n                    },\n                    end: '\\\\)',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.parameters.end.bracket.round.dolphindb'\n                        }\n                    },\n                    name: 'meta.parameters.dolphindb',\n                    patterns: [\n                        {\n                            include: '#variable'\n                        },\n                        {\n                            match: '(@(?:[a-zA-Z_$][\\\\w$]*)?)(\\\\.\\\\.\\\\.)?',\n                            captures: {\n                                1: {\n                                    name: 'variable.parameter.function.readwrite.instance.dolphindb'\n                                },\n                                2: {\n                                    name: 'keyword.operator.splat.dolphindb'\n                                }\n                            }\n                        },\n                        {\n                            include: '$self'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        comment: {\n            patterns: [\n                {\n                    begin: '/\\\\*',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.comment.dolphindb'\n                        }\n                    },\n                    end: '\\\\*/',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.comment.dolphindb'\n                        }\n                    },\n                    name: 'comment.block.dolphindb'\n                },\n                {\n                    begin: '//',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.comment.dolphindb'\n                        }\n                    },\n                    end: '$',\n                    name: 'comment.line.number-sign.dolphindb'\n                },\n                {\n                    begin: '#',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.comment.dolphindb'\n                        }\n                    },\n                    end: '$',\n                    name: 'comment.line.number-sign.dolphindb'\n                }\n            ]\n        },\n        \n        arguments: {\n            patterns: [\n                {\n                    begin: '\\\\(',\n                    beginCaptures: {\n                        0: {\n                            name: 'punctuation.definition.arguments.begin.bracket.round.dolphindb'\n                        }\n                    },\n                    end: '\\\\)',\n                    endCaptures: {\n                        0: {\n                            name: 'punctuation.definition.arguments.end.bracket.round.dolphindb'\n                        }\n                    },\n                    name: 'meta.arguments.dolphindb',\n                    patterns: [\n                        {\n                            include: '$self'\n                        },\n                        {\n                            include: '#literal'\n                        },\n                        {\n                            include: '#variable'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        variable: {\n            patterns: [\n                {\n                    match: '(@)([a-zA-Z_\\\\$]\\\\w*)?',\n                    name: 'variable.other.readwrite.instance.dolphindb'\n                }\n            ]\n        },\n        \n        interpolated_dolphindb: {\n            patterns: [\n                {\n                    begin: '\\\\#\\\\{',\n                    captures: {\n                        0: {\n                            name: 'punctuation.section.embedded.dolphindb'\n                        }\n                    },\n                    end: '\\\\}',\n                    name: 'source.dolphindb.embedded.source',\n                    patterns: [\n                        {\n                            include: '$self'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        method_call: {\n            patterns: [\n                {\n                    begin: '(?:(\\\\.)|(::))\\\\s*([\\\\w$]+!?)(?=\\\\()',\n                    beginCaptures: {\n                        1: {\n                            name: 'punctuation.separator.method.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            patterns: [\n                                {\n                                    include: '#method_name'\n                                }\n                            ]\n                        }\n                    },\n                    end: '(?<=\\\\))',\n                    name: 'meta.method-call.dolphindb',\n                    patterns: [\n                        {\n                            include: '#arguments'\n                        }\n                    ]\n                }\n            ]\n        },\n        \n        method_name: {\n            patterns: [\n                {\n                    match: '[a-zA-Z_$][\\\\w$]*',\n                    name: 'entity.name.function.dolphindb'\n                },\n                {\n                    match: '\\\\d[\\\\w$]*',\n                    name: 'invalid.illegal.identifier.dolphindb'\n                }\n            ]\n        },\n        \n        operator: {\n            patterns: [\n                {\n                    match: '<<|>>',\n                    name: 'keyword.operator.bitwise.shift.dolphindb'\n                },\n                {\n                    match: '!=|<=|>=|==|>|<',\n                    name: 'keyword.operator.comparison.dolphindb'\n                },\n                {\n                    match: '<-|->',\n                    name: 'keyword.operator.join.dolphindb'\n                },\n                {\n                    match: '&&|!|\\\\|\\\\|',\n                    name: 'keyword.operator.logical.dolphindb'\n                },\n                {\n                    match: '&|\\\\||\\\\^',\n                    name: 'keyword.operator.bitwise.dolphindb'\n                },\n                {\n                    match: '\\\\.\\\\.',\n                    name: 'keyword.operator.splat.dolphindb'\n                },\n                {\n                    match: '\\\\?',\n                    name: 'keyword.operator.existential.dolphindb'\n                },\n                {\n                    match: '/|<-|%|\\\\*|/|-|\\\\$|\\\\+',\n                    name: 'keyword.operator.dolphindb'\n                },\n                {\n                    match: '([a-zA-Z$_][\\\\w$]*)?\\\\s*(=|:(?!:))(?![>=])',\n                    captures: {\n                        1: {\n                            name: 'variable.assignment.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.assignment.dolphindb'\n                        }\n                    }\n                }\n            ]\n        },\n        \n        property: {\n            patterns: [\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*([A-Z][A-Z0-9_$]*\\\\b\\\\$*)(?=\\\\s*\\\\??(\\\\.\\\\s*[a-zA-Z_$]\\\\w*|::))',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'constant.other.object.property.dolphindb'\n                        }\n                    }\n                },\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*(\\\\$*[a-zA-Z_$][\\\\w$]*)(?=\\\\s*\\\\??(\\\\.\\\\s*[a-zA-Z_$]\\\\w*|::))',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'variable.other.object.property.dolphindb'\n                        }\n                    }\n                },\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*([A-Z][A-Z0-9_$]*\\\\b\\\\$*)',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'constant.other.property.dolphindb'\n                        }\n                    }\n                },\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*(\\\\$*[a-zA-Z_$][\\\\w$]*)',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'variable.other.property.dolphindb'\n                        }\n                    }\n                },\n                {\n                    match: '(?:(\\\\.)|(::))\\\\s*([0-9][\\\\w$]*)',\n                    captures: {\n                        1: {\n                            name: 'punctuation.separator.property.period.dolphindb'\n                        },\n                        2: {\n                            name: 'keyword.operator.prototype.dolphindb'\n                        },\n                        3: {\n                            name: 'invalid.illegal.identifier.dolphindb'\n                        }\n                    }\n                }\n            ]\n        }\n    }\n} as Block\n\n\ninterface Block {\n    patterns: Pattern[]\n    repository?: Record<string, Pattern | Block>\n}\n\ntype Pattern = Match | Include | Block\n\ntype Match = MatchOne | MatchBeginEnd\n\ninterface MatchOne {\n    /** a single-line regular expression */\n    match: RegExp | string\n    \n    /** This is the scope that will be applied to the matched text */\n    name?: string\n    \n    /** This use of the captures > patterns structure is extremely important. \n        Without it, a stretch of text matched by a match rule is considered finished, and \n        TextMate’s search proceeds to the rest of the line after the matched text. \n        With it, the stretch of matched text itself becomes a candidate for further matches. \n    */\n    captures?: Captures\n}\n\ninterface MatchBeginEnd {\n    begin: RegExp | string\n    \n    end: RegExp | string\n    \n    /** This is the scope (or an expression evaluating to a scope) to be applied to \n        the entire matched stretch(es) of text starting at the start of the begin match.\n    */\n    name?: string\n    \n    /** This is the scope to be applied to what’s between the begin match and the end match (or the end of the document). */\n    contentName?: string\n    \n    /** it applies to the region between the begin and end matches. */\n    patterns?: Pattern[]\n    \n    beginCaptures?: Captures\n    \n    endCaptures?: Captures\n    \n    whileCaptures?: Captures\n    \n    /** If the name or number of the matched group happens to be the same for both the begin pattern and the other pattern, \n        you can (if appropriate) use captures as a shorthand to avoid saying the same thing twice.\n    */\n    captures?: Captures\n    \n    applyEndPatternLast?: 1\n}\n\ninterface Include {\n    include: string\n}\n\ntype Captures = Record<string | number, {\n    /** This is the scope that will be assigned to the matched group text. */\n    name?: string\n    \n    /** This is a list of match rules to be sought within the matched group text \n        — thus permitting the search for matches to continue inside the matched text.\n    */\n    patterns?: Pattern[]\n}>\n\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dolphindb",
   "description": "DolphinDB JavaScript API",
-  "version": "2.0.933",
+  "version": "2.0.934",
   "type": "module",
   "main": "./index.js",
   "browser": "./browser.js",