dolphindb 3.0.2 → 3.0.20

package/index.js

@@ -1,24 +1,131 @@
-// import { table, getBorderCharacters, type TableUserConfig } from 'table'
 import dayjs from 'dayjs';
 import DayjsCustomParseFormat from 'dayjs/plugin/customParseFormat.js';
 dayjs.extend(DayjsCustomParseFormat);
 import ipaddrjs from 'ipaddr.js';
 const { fromByteArray: buf2ipaddr } = ipaddrjs;
-import { concat, assert, inspect, typed_array_to_buffer, connect_websocket, Lock, genid, WebSocketOpen, WebSocketClosed, WebSocketClosing } from 'xshell';
+import { concat, assert, inspect, typed_array_to_buffer, connect_websocket, Lock, genid, seq, zip_object, WebSocketOpen, WebSocketClosed, WebSocketClosing, } from 'xshell';
 import { t } from './i18n/index.js';
-import { DdbDecimal128Serializor } from './data-types/decimal-128.js';
-import { BigInt128Array } from './shared/bigint-128-array.js';
-import { is_decimal_type, is_decimal_null_value, get_duration_unit } from './shared/utils.js';
-import { nulls, DdbChartType, DdbDurationUnit, DdbForm, DdbFunctionType, DdbType, DdbVoidType, dictables } from './shared/constants.js';
-export * from './shared/constants.js';
-// Simulate other TypedArray behavior in nodejs
-BigInt128Array.prototype[inspect.custom] = function () {
-    const values = [];
-    for (const value of this)
-        values.push(value);
-    const value_str = values.length ? ` ${values.map(v => String(v) + 'n').join(', ')} ` : '';
-    return `${this[Symbol.toStringTag]}(${this.length}) [${value_str}]`;
+export const nulls = {
+    int8: -0x80, // -128
+    int16: -0x80_00, // -32768
+    int32: -0x80_00_00_00, // -21_4748_3648
+    int64: -0x8000000000000000n, // -922_3372_0368_5477_5808
+    int128: -0x80000000000000000000000000000000n, // -170_1411_8346_0469_2317_3168_7303_7158_8410_5728
+    float32: -3.4028234663852886e+38,
+    /** -Number.MAX_VALUE */
+    double: -Number.MAX_VALUE,
+    bytes16: Uint8Array.from(new Array(16).fill(0))
 };
+export var DdbForm;
+(function (DdbForm) {
+    DdbForm[DdbForm["scalar"] = 0] = "scalar";
+    DdbForm[DdbForm["vector"] = 1] = "vector";
+    DdbForm[DdbForm["pair"] = 2] = "pair";
+    DdbForm[DdbForm["matrix"] = 3] = "matrix";
+    DdbForm[DdbForm["set"] = 4] = "set";
+    DdbForm[DdbForm["dict"] = 5] = "dict";
+    DdbForm[DdbForm["table"] = 6] = "table";
+    DdbForm[DdbForm["chart"] = 7] = "chart";
+    /** 节点内部通信可能会使用，调用函数执行脚本一般不会返回这种类型 */
+    DdbForm[DdbForm["chunk"] = 8] = "chunk";
+    /** sysobj */
+    DdbForm[DdbForm["object"] = 9] = "object";
+})(DdbForm || (DdbForm = {}));
+/** DolphinDB DataType
+    对应的 array vector 类型为 64 + 基本类型
+    对应的 extended 类型为 128 + 基本类型 */
+export var DdbType;
+(function (DdbType) {
+    DdbType[DdbType["void"] = 0] = "void";
+    DdbType[DdbType["bool"] = 1] = "bool";
+    DdbType[DdbType["char"] = 2] = "char";
+    DdbType[DdbType["short"] = 3] = "short";
+    DdbType[DdbType["int"] = 4] = "int";
+    DdbType[DdbType["long"] = 5] = "long";
+    DdbType[DdbType["date"] = 6] = "date";
+    DdbType[DdbType["month"] = 7] = "month";
+    DdbType[DdbType["time"] = 8] = "time";
+    DdbType[DdbType["minute"] = 9] = "minute";
+    DdbType[DdbType["second"] = 10] = "second";
+    DdbType[DdbType["datetime"] = 11] = "datetime";
+    DdbType[DdbType["timestamp"] = 12] = "timestamp";
+    DdbType[DdbType["nanotime"] = 13] = "nanotime";
+    DdbType[DdbType["nanotimestamp"] = 14] = "nanotimestamp";
+    DdbType[DdbType["float"] = 15] = "float";
+    DdbType[DdbType["double"] = 16] = "double";
+    DdbType[DdbType["symbol"] = 17] = "symbol";
+    DdbType[DdbType["string"] = 18] = "string";
+    DdbType[DdbType["uuid"] = 19] = "uuid";
+    DdbType[DdbType["functiondef"] = 20] = "functiondef";
+    DdbType[DdbType["handle"] = 21] = "handle";
+    DdbType[DdbType["code"] = 22] = "code";
+    DdbType[DdbType["datasource"] = 23] = "datasource";
+    DdbType[DdbType["resource"] = 24] = "resource";
+    DdbType[DdbType["any"] = 25] = "any";
+    DdbType[DdbType["compressed"] = 26] = "compressed";
+    DdbType[DdbType["dict"] = 27] = "dict";
+    DdbType[DdbType["datehour"] = 28] = "datehour";
+    DdbType[DdbType["ipaddr"] = 30] = "ipaddr";
+    DdbType[DdbType["int128"] = 31] = "int128";
+    DdbType[DdbType["blob"] = 32] = "blob";
+    DdbType[DdbType["complex"] = 34] = "complex";
+    DdbType[DdbType["point"] = 35] = "point";
+    DdbType[DdbType["duration"] = 36] = "duration";
+    DdbType[DdbType["decimal32"] = 37] = "decimal32";
+    DdbType[DdbType["decimal64"] = 38] = "decimal64";
+    DdbType[DdbType["decimal128"] = 39] = "decimal128";
+    DdbType[DdbType["object"] = 40] = "object";
+    DdbType[DdbType["pynone"] = 41] = "pynone";
+    DdbType[DdbType["symbol_extended"] = 145] = "symbol_extended";
+})(DdbType || (DdbType = {}));
+export var DdbFunctionType;
+(function (DdbFunctionType) {
+    DdbFunctionType[DdbFunctionType["SystemFunc"] = 0] = "SystemFunc";
+    DdbFunctionType[DdbFunctionType["SystemProc"] = 1] = "SystemProc";
+    DdbFunctionType[DdbFunctionType["OperatorFunc"] = 2] = "OperatorFunc";
+    DdbFunctionType[DdbFunctionType["UserDefinedFunc"] = 3] = "UserDefinedFunc";
+    DdbFunctionType[DdbFunctionType["PartialFunc"] = 4] = "PartialFunc";
+    DdbFunctionType[DdbFunctionType["DynamicFunc"] = 5] = "DynamicFunc";
+    DdbFunctionType[DdbFunctionType["PiecewiseFunc"] = 6] = "PiecewiseFunc";
+    DdbFunctionType[DdbFunctionType["JitFunc"] = 7] = "JitFunc";
+    DdbFunctionType[DdbFunctionType["JitPartialFunc"] = 8] = "JitPartialFunc";
+})(DdbFunctionType || (DdbFunctionType = {}));
+export var DdbDurationUnit;
+(function (DdbDurationUnit) {
+    DdbDurationUnit[DdbDurationUnit["ns"] = 0] = "ns";
+    DdbDurationUnit[DdbDurationUnit["us"] = 1] = "us";
+    DdbDurationUnit[DdbDurationUnit["ms"] = 2] = "ms";
+    DdbDurationUnit[DdbDurationUnit["s"] = 3] = "s";
+    DdbDurationUnit[DdbDurationUnit["m"] = 4] = "m";
+    DdbDurationUnit[DdbDurationUnit["H"] = 5] = "H";
+    DdbDurationUnit[DdbDurationUnit["d"] = 6] = "d";
+    DdbDurationUnit[DdbDurationUnit["w"] = 7] = "w";
+    DdbDurationUnit[DdbDurationUnit["M"] = 8] = "M";
+    DdbDurationUnit[DdbDurationUnit["y"] = 9] = "y";
+    DdbDurationUnit[DdbDurationUnit["B"] = 10] = "B";
+})(DdbDurationUnit || (DdbDurationUnit = {}));
+export var DdbChartType;
+(function (DdbChartType) {
+    DdbChartType[DdbChartType["area"] = 0] = "area";
+    DdbChartType[DdbChartType["bar"] = 1] = "bar";
+    DdbChartType[DdbChartType["column"] = 2] = "column";
+    DdbChartType[DdbChartType["histogram"] = 3] = "histogram";
+    DdbChartType[DdbChartType["line"] = 4] = "line";
+    DdbChartType[DdbChartType["pie"] = 5] = "pie";
+    DdbChartType[DdbChartType["scatter"] = 6] = "scatter";
+    DdbChartType[DdbChartType["trend"] = 7] = "trend";
+    DdbChartType[DdbChartType["kline"] = 8] = "kline";
+})(DdbChartType || (DdbChartType = {}));
+// server 实现中区分了 0: NULL (nothing), 1: NULL (null), 2: DFLT (default)
+// Void::serialize()
+//     (isNothing() ? 0 : 1) + (isDefault_ ? 2 : 0);
+export var DdbVoidType;
+(function (DdbVoidType) {
+    DdbVoidType[DdbVoidType["undefined"] = 0] = "undefined";
+    DdbVoidType[DdbVoidType["null"] = 1] = "null";
+    DdbVoidType[DdbVoidType["default"] = 2] = "default";
+})(DdbVoidType || (DdbVoidType = {}));
+export const dictables = new Set([DdbType.any, DdbType.string, DdbType.double, DdbType.float, DdbType.int, DdbType.long]);
 /** 可以表示所有 DolphinDB 数据库中的数据类型  Can represent data types in all DolphinDB databases */
 export class DdbObj {
     static dec = new TextDecoder('utf-8');
@@ -39,15 +146,13 @@ export class DdbObj {
     length;
     /** table name / column name */
     name;
-    /**
-        最低维、第 1 维
+    /** 最低维、第 1 维
         - vector: rows = n, cols = 1
         - pair:   rows = 2, cols = 1
         - matrix: rows = n, cols = m
         - set:    同 vector
         - dict:   包含 keys, values 向量
-        - table:  同 matrix
-    */
+        - table:  同 matrix */
     rows;
     /** 第 2 维 */
     cols;
@@ -127,7 +232,7 @@ export class DdbObj {
                 let i_start = i_items_start + len_items;
                 for (let i = 0; i < cols; i++) {
                     const type = buf_data[i_start];
-                    if (type === DdbType.compress)
+                    if (type === DdbType.compressed)
                         throw new Error(t('{{form}}<{{type}}> 暂时不支持解析', { form: 'table', type: 'compress' }));
                     let col = this.parse_vector(buf_data.subarray(i_start + 2), le, type);
                     col.length += 2;
@@ -376,20 +481,21 @@ export class DdbObj {
                 return [12, { scale: dv.getInt32(0, le), data: data === nulls.int64 ? null : data }];
             }
             case DdbType.decimal128: {
-                return DdbDecimal128Serializor.parse_as_scalar(buf, le);
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                const data = get_big_int_128(dv, 4, le);
+                return [20, { scale: dv.getInt32(0, le), data: data === nulls.int128 ? null : data }];
             }
             default:
                 throw new Error(String(DdbType[type] || type) + t(' 暂时不支持解析'));
         }
     }
     /** parse: rows, cols, items
-        返回的 ddbobj.length 不包括 vector 的 type 和 form
-    */
+        返回的 ddbobj.length 不包括 vector 的 type 和 form */
     static parse_vector(buf, le, type) {
         const dv = new DataView(buf.buffer, buf.byteOffset);
         const rows = dv.getUint32(0, le);
         let i_items_start = 8;
-        if (type < 64 || type >= 128) {
+        if (type < 64 || type >= 128) { // 普通数组
             const [len_items, value] = this.parse_vector_items(buf.subarray(i_items_start), le, type, rows);
             return new this({
                 le,
@@ -401,119 +507,121 @@ export class DdbObj {
                 value,
             });
         }
-        // array vector
-        // av = array(INT[], 0, 3)
-        // append!(av, [1..4])
-        // append!(av, [1..70000])
-        // av
-        // <Buffer 44 01  type = array vector, form = vector
-        // 02 00 00 00 74 11 01 00 rows = 2, cols = 70004 (0x011174)
-        // block 0
-        // 01 00 block.rows = 1
-        // 04 block.unit = 4
-        // 00 reserved
-        // 04 00 00 00 block.lengths = [4]
-        // 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 block.data
-        // block 1
-        // 01 00 block.rows = 1
-        // 04 block.unit = 4
-        // 00 reserved
-        // 70 11 01 00 block.lengths = [70000 (0x00011170)]
-        // 01 00 00 00 02 00 00 00 ... 279992 more bytes> block.data
-        // decimal array vector
-        // a = array(DECIMAL32(2)[], 0, 10)
-        // append!(a, [
-        //     [1, 2, 3], 
-        //     [4, 5], 
-        //     [6, 7, 8],
-        //     [9, 10]
-        // ])
-        // print(a)
-        // a
-        // [[1.00,2.00,3.00],[4.00,5.00],[6.00,7.00,8.00],[9.00,10.00]]
-        // <Buffer 65 01 type = 101 = 64 + 37 (decimal32) , form = vector
-        // 04 00 00 00 0a 00 00 00 rows = 4, cols = 10
-        // scale (只有 decimal32 才有)
-        // 02 00 00 00 scale = 2
-        // block 0
-        // 04 00 block.rows = 4
-        // 01 block.unit = 1
-        // 00 reserved
-        // 03 02 03 02 block.lengths = [3, 2, 3, 2]
-        // 64 00 00 00 c8 00 00 00 2c 01 00 00 90 01 00 00 f4 01 00 00 58 02 00 00 bc 02 00 00 ... 12 more bytes> [100, 200, 300, ...]
-        // block 1
-        // ...
-        const type_ = type - 64;
-        const cols = dv.getUint32(4, le);
-        let blocks = [];
-        // decimal 会在所有 blocks 之前多一个 scale
-        if (is_decimal_type(type_)) {
-            blocks.scale = dv.getInt32(i_items_start, le);
-            i_items_start += 4;
-        }
-        let i_block_start = i_items_start;
-        // 解析一个 block
-        for (let i_row = 0; i_row < rows;) {
-            /** 对应 array vector 中元素个数 */
-            const rows = dv.getUint16(i_block_start, le);
-            /** 每个 length 占用的字节数 */
-            const unit = dv.getUint8(i_block_start + 2);
-            /** array vector 每个元素的子元素长度 */
-            let lengths;
-            const i_lengths_start = i_block_start + 4;
-            const i_data_start = i_lengths_start + rows * unit;
-            const lengths_buf = buf.slice(i_lengths_start, i_data_start);
-            switch (unit) {
-                case 1:
-                    lengths = lengths_buf;
-                    break;
-                case 2:
-                    lengths = new Uint16Array(lengths_buf.buffer);
-                    break;
-                case 4:
-                    lengths = new Uint32Array(lengths_buf.buffer);
-                    break;
-                default:
-                    throw new Error(t('array vector 存在非法 unit: {{unit}}', { unit }));
+        else { // array vector
+            // av = array(INT[], 0, 3)
+            // append!(av, [1..4])
+            // append!(av, [1..70000])
+            // av
+            // <Buffer 44 01  type = array vector, form = vector
+            // 02 00 00 00 74 11 01 00 rows = 2, cols = 70004 (0x011174)
+            // block 0
+            // 01 00 block.rows = 1
+            // 04 block.unit = 4
+            // 00 reserved
+            // 04 00 00 00 block.lengths = [4]
+            // 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 block.data
+            // block 1
+            // 01 00 block.rows = 1
+            // 04 block.unit = 4
+            // 00 reserved
+            // 70 11 01 00 block.lengths = [70000 (0x00011170)]
+            // 01 00 00 00 02 00 00 00 ... 279992 more bytes> block.data
+            // decimal array vector
+            // a = array(DECIMAL32(2)[], 0, 10)
+            // append!(a, [
+            //     [1, 2, 3], 
+            //     [4, 5], 
+            //     [6, 7, 8],
+            //     [9, 10]
+            // ])
+            // print(a)
+            // a
+            // [[1.00,2.00,3.00],[4.00,5.00],[6.00,7.00,8.00],[9.00,10.00]]
+            // <Buffer 65 01 type = 101 = 64 + 37 (decimal32) , form = vector
+            // 04 00 00 00 0a 00 00 00 rows = 4, cols = 10
+            // scale (只有 decimal32 才有)
+            // 02 00 00 00 scale = 2
+            // block 0
+            // 04 00 block.rows = 4
+            // 01 block.unit = 1
+            // 00 reserved
+            // 03 02 03 02 block.lengths = [3, 2, 3, 2]
+            // 64 00 00 00 c8 00 00 00 2c 01 00 00 90 01 00 00 f4 01 00 00 58 02 00 00 bc 02 00 00 ... 12 more bytes> [100, 200, 300, ...]
+            // block 1
+            // ...
+            const type_ = type - 64;
+            const cols = dv.getUint32(4, le);
+            let blocks = [];
+            // decimal 会在所有 blocks 之前多一个 scale
+            if (is_decimal_type(type_)) {
+                blocks.scale = dv.getInt32(i_items_start, le);
+                i_items_start += 4;
             }
-            let total_length = 0;
-            for (const x of lengths)
-                total_length += x;
-            let len_items;
-            let data;
-            switch (type_) {
-                case DdbType.decimal32:
-                    len_items = total_length * 4;
-                    data = new Int32Array(buf.buffer.slice(buf.byteOffset + i_data_start, buf.byteOffset + i_data_start + len_items));
-                    break;
-                case DdbType.decimal64:
-                    len_items = total_length * 8;
-                    data = new BigInt64Array(buf.buffer.slice(buf.byteOffset + i_data_start, buf.byteOffset + i_data_start + len_items));
-                    break;
-                case DdbType.decimal128:
-                    [len_items, data] = DdbDecimal128Serializor.parse_as_same_type_vector_values(buf, i_data_start, total_length);
-                    break;
-                default:
-                    [len_items, data] = this.parse_vector_items(buf.subarray(i_data_start), le, type - 64, total_length);
+            let i_block_start = i_items_start;
+            // 解析一个 block
+            for (let i_row = 0; i_row < rows;) {
+                /** 对应 array vector 中元素个数 */
+                const rows = dv.getUint16(i_block_start, le);
+                /** 每个 length 占用的字节数 */
+                const unit = dv.getUint8(i_block_start + 2);
+                /** array vector 每个元素的子元素长度 */
+                let lengths;
+                const i_lengths_start = i_block_start + 4;
+                const i_data_start = i_lengths_start + rows * unit;
+                const lengths_buf = buf.slice(i_lengths_start, i_data_start);
+                switch (unit) {
+                    case 1:
+                        lengths = lengths_buf;
+                        break;
+                    case 2:
+                        lengths = new Uint16Array(lengths_buf.buffer);
+                        break;
+                    case 4:
+                        lengths = new Uint32Array(lengths_buf.buffer);
+                        break;
+                    default:
+                        throw new Error(t('array vector 存在非法 unit: {{unit}}', { unit }));
+                }
+                let total_length = 0;
+                for (const x of lengths)
+                    total_length += x;
+                let len_items;
+                let data;
+                switch (type_) {
+                    case DdbType.decimal32:
+                        len_items = total_length * 4;
+                        data = new Int32Array(buf.buffer.slice(buf.byteOffset + i_data_start, buf.byteOffset + i_data_start + len_items));
+                        break;
+                    case DdbType.decimal64:
+                        len_items = total_length * 8;
+                        data = new BigInt64Array(buf.buffer.slice(buf.byteOffset + i_data_start, buf.byteOffset + i_data_start + len_items));
+                        break;
+                    case DdbType.decimal128:
+                        len_items = total_length * 16;
+                        data = new BigInt128Array(buf.buffer.slice(buf.byteOffset + i_data_start, buf.byteOffset + i_data_start + len_items));
+                        break;
+                    default:
+                        [len_items, data] = this.parse_vector_items(buf.subarray(i_data_start), le, type - 64, total_length);
+                }
+                blocks.push({
+                    unit,
+                    rows,
+                    lengths,
+                    data: data
+                });
+                i_block_start = i_data_start + len_items;
+                i_row += rows;
             }
-            blocks.push({
-                unit,
+            return new this({
+                le,
+                form: DdbForm.vector,
+                type,
+                length: i_block_start,
+                cols,
                 rows,
-                lengths,
-                data: data
+                value: blocks
             });
-            i_block_start = i_data_start + len_items;
-            i_row += rows;
         }
-        return new this({
-            le,
-            form: DdbForm.vector,
-            type,
-            length: i_block_start,
-            cols,
-            rows,
-            value: blocks
-        });
     }
     /** 有可能没有字节对齐，不能直接使用原有 message 的 arraybuffer, 统一复制出来，让原有 arraybuffer 被回收掉比较好 */
     static parse_vector_items(buf, le, type, length) {
@@ -685,8 +793,16 @@ export class DdbObj {
                     }
                 ];
             }
-            case DdbType.decimal128:
-                return DdbDecimal128Serializor.parse_as_vector_items(buf, length, le);
+            case DdbType.decimal128: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                return [
+                    4 + 16 * length,
+                    {
+                        scale: dv.getInt32(0, le),
+                        data: new BigInt128Array(buf.buffer.slice(buf.byteOffset + 4, buf.byteOffset + 4 + 16 * length))
+                    }
+                ];
+            }
             // 以下情况时, DdbType.duration 实际会返回一个 any vector
             // [2y, 1M, 3d, 7H, 11m, 12s, 15ms, 16us, 17ns]
             // <Buffer 19 01 type = any, form = vector
@@ -710,16 +826,13 @@ export class DdbObj {
                     });
                 return [8 * length, durations];
             }
-            case DdbType.compress:
+            case DdbType.compressed:
                 return [
                     length,
                     new Uint8Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + length))
                 ];
             default:
-                throw new Error(t('{{form}}<{{type}}> 暂时不支持解析', {
-                    form: 'vector',
-                    type: String(DdbType[type] || type)
-                }));
+                throw new Error(t('{{form}}<{{type}}> 暂时不支持解析', { form: 'vector', type: get_type_name(type) }));
         }
     }
     pack() {
@@ -831,8 +944,10 @@ export class DdbObj {
                             const { scale, data } = this.value;
                             return [Int32Array.of(scale), BigInt64Array.of(data === null ? nulls.int64 : data)];
                         }
-                        case DdbType.decimal128:
-                            return DdbDecimal128Serializor.pack(this.value);
+                        case DdbType.decimal128: {
+                            const { scale, data } = value;
+                            return [Int32Array.of(scale), BigInt128Array.of(data === null ? nulls.int128 : data)];
+                        }
                         default:
                             throw new Error(String(DdbType[type] || type) + t(' 暂时不支持序列化'));
                     }
@@ -899,7 +1014,7 @@ export class DdbObj {
                     ];
                 }
                 default:
-                    throw new Error(t('vector {{type}} 暂不支持序列化', { type: DdbType[type] || type }));
+                    throw new Error(t('vector {{type}} 暂不支持序列化', { type: get_type_name(type) }));
             }
         })();
         if (!body)
@@ -950,7 +1065,7 @@ export class DdbObj {
             case DdbType.uuid:
             case DdbType.ipaddr:
             case DdbType.int128:
-            case DdbType.compress:
+            case DdbType.compressed:
                 return [value];
             case DdbType.blob: {
                 let bufs = new Array(length * 2);
@@ -1004,20 +1119,61 @@ export class DdbObj {
                 return [Int32Array.of(scale), data];
             }
             default:
-                throw new Error(t('vector {{type}} 暂不支持序列化', { type: String(DdbType[type] || type) }));
+                throw new Error(t('vector {{type}} 暂不支持序列化', { type: get_type_name(type) }));
+        }
+    }
+    data() {
+        const { form, type, value, le, rows, name } = this;
+        switch (form) {
+            case DdbForm.scalar:
+                return convert(type, value, le);
+            case DdbForm.vector:
+            case DdbForm.pair:
+            case DdbForm.set: {
+                const data = converts(type, value, rows, le);
+                return (form === DdbForm.set ? new Set(data) : data);
+            }
+            case DdbForm.table: {
+                const cols = value;
+                const jscols = cols.map(col => col.data());
+                const keys = cols.map(({ name }) => name);
+                return {
+                    name: name || '',
+                    columns: cols.map(({ name }) => name),
+                    types: cols.map(({ type }) => type),
+                    data: seq(rows, i => zip_object(keys, seq(cols.length, j => jscols[j][i])))
+                };
+            }
+            case DdbForm.dict: {
+                const [keys, values] = value;
+                return zip_object(keys.data(), values.data());
+            }
+            case DdbForm.chart:
+                return value;
+            case DdbForm.matrix: {
+                const ncolumns = this.cols;
+                const { rows: _rows, cols: _cols, data } = value;
+                const jsdata = converts(type, data, rows * ncolumns, le);
+                return {
+                    type,
+                    nrows: rows,
+                    ncolumns,
+                    rows: _rows?.data(),
+                    columns: _cols?.data(),
+                    data: seq(rows, i => seq(ncolumns, j => jsdata[j * rows + i]))
+                };
+            }
+            default:
+                throw new Error(t('{{form}} {{type}} 暂不支持 data()', { form, type: get_type_name(type) }));
         }
     }
     [inspect.custom](depth, _options, _inspect) {
-        const options = { nullstr: true, quote: true, ..._options };
+        const options = { nullstr: true, ..._options };
         const type = this.inspect_type();
         const data = (() => {
             switch (this.form) {
                 case DdbForm.scalar:
-                    // 如果类型为 string, 则不进行格式化处理
-                    if (this.type === DdbType.string)
-                        return this.value;
-                    else
-                        return format(this.type, this.value, this.le, options);
+                    return format(this.type, this.value, this.le, options);
                 case DdbForm.vector:
                 case DdbForm.pair:
                 case DdbForm.set: {
@@ -1131,7 +1287,7 @@ export class DdbObj {
                             return format_array(items, data.length > limit);
                         }
                         default: {
-                            const limit = this.type === DdbType.compress ? 5 : 50;
+                            const limit = this.type === DdbType.compressed ? 5 : 50;
                             let items = new Array(Math.min(limit, this.value.length));
                             for (let i = 0; i < items.length; i++)
                                 items[i] = format(this.type, this.value[i], this.le, options);
@@ -1195,7 +1351,8 @@ export class DdbObj {
     static to_ddbobjs(values) {
         return values.map(value => this.to_ddbobj(value));
     }
-    /** 将 table 转换为 rows，空值转换为 null */
+    /** 将 table 转换为 rows，空值转换为 null
+        @deprecated 用 data() */
     to_rows() {
         assert(this.form === DdbForm.table, t('form 必须是 DdbForm.table, 否则不能 to_rows'));
         let rows = new Array(this.rows);
@@ -1285,6 +1442,25 @@ export class DdbObj {
         return obj;
     }
 }
+/** 根据 DdbType 获取其名称，array vector type 自动在后面加上 [] */
+export function get_type_name(type) {
+    return `${DdbType[type] || type}${64 <= type && type < 128 ? '[]' : ''}`;
+}
+export function is_decimal_type(type) {
+    return type === DdbType.decimal32 || type === DdbType.decimal64 || type === DdbType.decimal128;
+}
+export function is_decimal_null_value(type, value) {
+    return ((value === nulls.int128 && type === DdbType.decimal128) ||
+        (value === nulls.int64 && type === DdbType.decimal64) ||
+        (value === nulls.int32 && type === DdbType.decimal32));
+}
+export function get_duration_unit(code) {
+    let str = String.fromCharCode((code >> 24) & 0xff);
+    str += String.fromCharCode((code >> 16) & 0xff);
+    str += String.fromCharCode((code >> 8) & 0xff);
+    str += String.fromCharCode(code & 0xff);
+    return str;
+}
 /** 整数一定用这个 number formatter, InspectOptions.decimals 不传也用这个 */
 let default_formatter = new Intl.NumberFormat('en-US', { maximumFractionDigits: 20 });
 let _decimals = 20;
@@ -1389,7 +1565,7 @@ export function format(type, value, le, options = {}) {
         case DdbType.nanotimestamp:
             return format_time(nanotimestamp2str, nulls.int64);
         case DdbType.float:
-            return (value === null || value === nulls.float32) ?
+            return value === null || value === nulls.float32 ?
                 inspect(null, options)
                 :
                     options.colors ?
@@ -1397,7 +1573,7 @@ export function format(type, value, le, options = {}) {
                         :
                             formatter.format(value);
         case DdbType.double:
-            return (value === null || value === nulls.double) ?
+            return value === null || value === nulls.double ?
                 inspect(null, options)
                 :
                     options.colors ?
@@ -1406,6 +1582,10 @@ export function format(type, value, le, options = {}) {
                             formatter.format(value);
         case DdbType.symbol:
         case DdbType.string:
+        case DdbType.handle:
+        case DdbType.datasource:
+        case DdbType.code:
+        case DdbType.resource:
             return inspect(value, options);
         case DdbType.uuid:
             return options.colors ?
@@ -1414,11 +1594,6 @@ export function format(type, value, le, options = {}) {
                     uuid2str(value, le);
         case DdbType.functiondef:
             return inspect(value.name, options);
-        case DdbType.handle:
-        case DdbType.datasource:
-        case DdbType.code:
-        case DdbType.resource:
-            return inspect(value, options);
         case DdbType.datehour:
             return format_time(datehour2str, nulls.int32);
         case DdbType.ipaddr:
@@ -1467,7 +1642,43 @@ export function format(type, value, le, options = {}) {
 /** 格式化向量、集合中的第 index 项为字符串，空值返回 'null' 字符串  formatted vector, the index-th item in the collection is a string, a null value returns a 'null' string */
 export function formati(obj, index, options = {}) {
     assert(index < obj.rows, 'index < obj.rows');
-    if (64 <= obj.type && obj.type < 128) { // array vector
+    if (obj.type < 64 || obj.type >= 128) // 普通数组
+        switch (obj.type) {
+            case DdbType.symbol_extended: {
+                const { base, data } = obj.value;
+                return format(DdbType.string, base[data[index]], obj.le, options);
+            }
+            case DdbType.void:
+                return format(obj.type, obj.value, obj.le, options);
+            case DdbType.uuid:
+            case DdbType.int128:
+            case DdbType.ipaddr:
+                return format(obj.type, obj.value.subarray(16 * index, 16 * (index + 1)), obj.le, options);
+            case DdbType.blob: {
+                const value = obj.value[index];
+                return value.length > 100 ?
+                    DdbObj.dec.decode(value.subarray(0, 98)) + '…'
+                    :
+                        DdbObj.dec.decode(value);
+            }
+            case DdbType.complex:
+            case DdbType.point:
+                return format(obj.type, obj.value.subarray(2 * index, 2 * (index + 1)), obj.le, options);
+            case DdbType.decimal32:
+            case DdbType.decimal64:
+            case DdbType.decimal128: {
+                const { scale, data } = obj.value;
+                const x = data[index];
+                if (is_decimal_null_value(obj.type, x))
+                    return '';
+                const s = String(x < 0 ? -x : x).padStart(scale, '0');
+                const str = (x < 0 ? '-' : '') + (scale ? `${s.slice(0, -scale) || '0'}.${s.slice(-scale)}` : s);
+                return options.colors ? str.green : str;
+            }
+            default:
+                return format(obj.type, obj.value[index], obj.le, options);
+        }
+    else { // array vector
         // 因为 array vector 目前只支持：Logical, Integral（不包括 INT128, COMPRESS 类型）, Floating, Temporal
         // 都对应 TypedArray 中的一格，所以 lengths.length 等于 block 中的 row 的个数
         // av = array(INT[], 0, 5)
@@ -1530,40 +1741,155 @@ export function formati(obj, index, options = {}) {
             }
         }
     }
-    switch (obj.type) {
-        case DdbType.symbol_extended: {
-            const { base, data } = obj.value;
-            return format(DdbType.string, base[data[index]], obj.le, options);
-        }
+}
+export function convert(type, value, le) {
+    switch (type) {
         case DdbType.void:
-            return format(obj.type, obj.value, obj.le, options);
+            return value === DdbVoidType.null ? null : undefined;
+        case DdbType.char:
+            return value === null || value === nulls.int8 ? '' : String.fromCharCode(value);
+        case DdbType.bool:
+            return value === null || value === nulls.int8 ? null : Boolean(value);
+        case DdbType.short:
+            return value === null || value === nulls.int16 ? null : value;
+        case DdbType.int:
+            return value === null || value === nulls.int32 ? null : value;
+        case DdbType.float:
+            return value === null || value === nulls.float32 ? null : value;
+        case DdbType.double:
+            return value === null || value === nulls.double ? null : value;
+        case DdbType.long:
+            return value === null || value === nulls.int64 ? null : value;
+        case DdbType.functiondef:
+            return value.name;
+        case DdbType.string:
+        case DdbType.symbol:
+        case DdbType.code:
+        case DdbType.handle:
+        case DdbType.datasource:
+        case DdbType.resource:
+        case DdbType.blob:
+            return value;
+        case DdbType.complex:
+        case DdbType.point: {
+            const [x, y] = value;
+            return [
+                x === null || x === nulls.double ? null : x,
+                y === null || y === nulls.double ? null : y,
+            ];
+        }
+        case DdbType.date:
+        case DdbType.month:
+        case DdbType.time:
+        case DdbType.minute:
+        case DdbType.second:
+        case DdbType.datetime:
+        case DdbType.datehour:
+        case DdbType.timestamp:
+        case DdbType.nanotime:
+        case DdbType.nanotimestamp:
+        case DdbType.duration:
         case DdbType.uuid:
-        case DdbType.int128:
         case DdbType.ipaddr:
-            return format(obj.type, obj.value.subarray(16 * index, 16 * (index + 1)), obj.le, options);
-        case DdbType.blob: {
-            const value = obj.value[index];
-            return value.length > 100 ?
-                DdbObj.dec.decode(value.subarray(0, 98)) + '…'
-                :
-                    DdbObj.dec.decode(value);
-        }
-        case DdbType.complex:
-        case DdbType.point:
-            return format(obj.type, obj.value.subarray(2 * index, 2 * (index + 1)), obj.le, options);
+        case DdbType.int128:
+        // decimal 类型转换为固定位数小数的 string 不丢失精度，一般也是展示用
         case DdbType.decimal32:
         case DdbType.decimal64:
-        case DdbType.decimal128: {
-            const { scale, data } = obj.value;
-            const x = data[index];
-            if (is_decimal_null_value(obj.type, x))
-                return '';
-            const s = String(x < 0 ? -x : x).padStart(scale, '0');
-            const str = (x < 0 ? '-' : '') + (scale ? `${s.slice(0, -scale) || '0'}.${s.slice(-scale)}` : s);
-            return options.colors ? str.green : str;
-        }
+        case DdbType.decimal128:
+            return format(type, value, le, { colors: false });
         default:
-            return format(obj.type, obj.value[index], obj.le, options);
+            throw new Error(String(DdbType[type] || type) + t(' 暂时不支持转换为 js 对象'));
+    }
+}
+/** 转换一个向量到 js 原生数组 */
+export function converts(type, value, rows, le) {
+    if (type < 64 || type >= 128)
+        switch (type) {
+            // 可以直接用下标取值再转换的类型
+            case DdbType.bool:
+            case DdbType.char:
+            case DdbType.short:
+            case DdbType.int:
+            case DdbType.float:
+            case DdbType.double:
+            case DdbType.long:
+            case DdbType.date:
+            case DdbType.month:
+            case DdbType.time:
+            case DdbType.minute:
+            case DdbType.second:
+            case DdbType.datetime:
+            case DdbType.datehour:
+            case DdbType.timestamp:
+            case DdbType.nanotime:
+            case DdbType.nanotimestamp:
+            case DdbType.duration:
+            case DdbType.string:
+            case DdbType.symbol:
+            case DdbType.code:
+            case DdbType.handle:
+            case DdbType.datasource:
+            case DdbType.resource:
+            case DdbType.functiondef:
+            case DdbType.blob:
+                return Array.prototype.map.call(value, (x) => convert(type, x, le));
+            case DdbType.void:
+                return [];
+            case DdbType.symbol_extended: {
+                const { base, data } = value;
+                return Array.prototype.map.call(data, (x) => base[x]);
+            }
+            case DdbType.complex:
+            case DdbType.point:
+                return seq(rows, i => [value[2 * i], value[2 * (i + 1)]]);
+            case DdbType.uuid:
+            case DdbType.ipaddr:
+            case DdbType.int128:
+                return seq(rows, i => convert(type, value.subarray(16 * i, 16 * (i + 1)), le));
+            case DdbType.decimal32:
+            case DdbType.decimal64:
+            case DdbType.decimal128: {
+                const { scale, data } = value;
+                // todo: 用 Array.prototype.map.call 时对 BigInt128Array 这个代理对象无效？为什么只能通过下标访问？
+                return seq(rows, i => {
+                    const x = data[i];
+                    if (is_decimal_null_value(type, x))
+                        return '';
+                    const s = String(x < 0 ? -x : x).padStart(scale, '0');
+                    return (x < 0 ? '-' : '') + (scale ? `${s.slice(0, -scale) || '0'}.${s.slice(-scale)}` : s);
+                });
+            }
+            case DdbType.any:
+                return value.map(x => x.data());
+            default:
+                throw new Error(String(DdbType[type] || type) + '[]' + t(' 暂时不支持转换为 js 对象'));
+        }
+    else { // array vector
+        const type_ = type - 64;
+        return value.map(({ lengths, data, rows }) => {
+            let acc_len = 0;
+            return Array.prototype.map.call(lengths, (length) => {
+                const result = (() => {
+                    switch (type_) {
+                        case DdbType.decimal32:
+                        case DdbType.decimal64:
+                        case DdbType.decimal128:
+                            return converts(type_, { scale: value.scale, data: data.subarray(acc_len, acc_len + length) }, length, le);
+                        case DdbType.complex:
+                        case DdbType.point:
+                            return converts(type_, data.subarray(acc_len, acc_len + 2 * length), length, le);
+                        case DdbType.uuid:
+                        case DdbType.int128:
+                        case DdbType.ipaddr:
+                            return converts(type_, data.subarray(acc_len, acc_len + 16 * length), length, le);
+                        default:
+                            return converts(type_, data.subarray(acc_len, acc_len + length), length, le);
+                    }
+                })();
+                acc_len += length;
+                return result;
+            });
+        }).flat();
     }
 }
 export class DdbVoid extends DdbObj {
@@ -2186,7 +2512,6 @@ export class DDB {
     print_object_buffer = false;
     print_message = true;
     parse_object = true;
-    pnode_run_defined = false;
     /** 在 websocket 收到的第一个 error 时，
         在 connect_websocket 的 on_error 回调中构造 DdbConnectionError 并保存到 DDB 对象上，
         这个 error 的错误信息最准确 */
@@ -2197,6 +2522,8 @@ export class DDB {
     pconnect;
     /** 首次定义 pnode_run 的 promise，保证并发调用 rpc 时只定义一次 pnode_run */
     ppnode_run;
+    /** 首次定义 invoke 的 promise，保证并发调用 rpc 时只定义一次 invoke */
+    pinvoke;
     get connected() {
         return !this.error && this.lwebsocket.resource?.readyState === WebSocketOpen;
     }
@@ -2529,8 +2856,7 @@ export class DDB {
                 不做解析，以便后续转发、序列化
                 Set parse_object during this rpc, and restore the original after the end.
                 When it is false, the returned DdbObj only contains buffer and le without parsing,
-                so as to facilitate subsequent forwarding and serialization
-    */
+                so as to facilitate subsequent forwarding and serialization */
     async eval(script, { urgent, listener, parse_object, } = {}) {
         return this.rpc('script', { script, urgent, listener, parse_object });
     }
@@ -2595,6 +2921,45 @@ export class DDB {
             on_more_messages
         });
     }
+    /** 调用 dolphindb 函数，传入 js 原生数组作为参数，返回 js 原生对象或值（调用 DdbObj.data() 后的结果）
+        - func: 函数名
+        - args?: `[ ]` 调用参数，可以是 js 原生数组
+        - options?: 调用选项
+            - urgent?: 紧急 flag。使用 urgent worker 执行，防止被其它作业阻塞
+            - node?: 设置结点 alias 时发送到集群中对应的结点执行 (使用 DolphinDB 中的 rpc 方法)
+            - nodes?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
+            - func_type?: 设置 node 参数且参数数组为空时必传，需指定函数类型，其它情况下不传
+            - add_node_alias?: 设置 nodes 参数时选传，其它情况不传
+            - listener?: 处理本次 rpc 期间的消息 (DdbMessage) */
+    async invoke(func, args, options) {
+        await (this.pinvoke ??= this.eval(this.python ?
+            '\n' +
+                'def invoke (func_name, args_json):\n' +
+                '    args = fromStdJson(args_json)\n' +
+                '    if type(args) != ANY:\n' +
+                '        args = cast(args, ANY)\n' +
+                '    return unifiedCall(funcByName(func_name), args)\n'
+            :
+                '\n' +
+                    'def invoke (func_name, args_json) {\n' +
+                    '    args = fromStdJson(args_json)\n' +
+                    '    if (type(args) != ANY)\n' +
+                    '        args = cast(args, ANY)\n' +
+                    '    return unifiedCall(funcByName(func_name), args)\n' +
+                    '}\n', { urgent: true }));
+        if (options?.node)
+            options.func_type = DdbFunctionType.UserDefinedFunc;
+        return (await this.call(args?.length ? 'invoke' : func, args?.length ? [func, JSON.stringify(args)] : undefined, options)).data();
+    }
+    /** 执行 dolphindb 脚本，返回 js 原生对象或值（调用 DdbObj.data() 后的结果）
+        - script?: 执行的脚本
+        - options?: 执行选项
+            - urgent?: 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞
+            - listener?: 处理本次 rpc 期间的消息 (DdbMessage) */
+    async execute(script, options) {
+        return (await this.eval(script, options))
+            .data();
+    }
     /** upload variable through websocket (variable command) */
     async upload(
     /** 上传的变量名  Uploaded variables' name */
@@ -2744,4 +3109,195 @@ export class DDB {
         colnames);
     }
 }
+export class BigInt128Array {
+    static of(...items) {
+        return new BigInt128Array(items);
+    }
+    static from(arrayLike, mapfn, thisArg) {
+        if (mapfn) {
+            const array = [];
+            for (let i = 0; i < arrayLike.length; i++)
+                array.push(mapfn.call(thisArg, arrayLike[i], i));
+            return new BigInt128Array(array);
+        }
+        else {
+            const v = new BigInt128Array(arrayLike.length);
+            v.set(arrayLike);
+        }
+    }
+    BYTES_PER_ELEMENT = 16;
+    buffer;
+    byteLength;
+    byteOffset;
+    constructor(fisrtArg, byteOffset, length) {
+        if (typeof fisrtArg === 'number') {
+            const length = fisrtArg;
+            this.buffer = new ArrayBuffer(length * this.BYTES_PER_ELEMENT);
+            this.byteOffset = 0;
+            this.byteLength = length * this.BYTES_PER_ELEMENT;
+        }
+        else if (fisrtArg instanceof ArrayBuffer || fisrtArg instanceof SharedArrayBuffer) {
+            this.buffer = fisrtArg;
+            this.byteOffset = byteOffset ?? 0;
+            let byteLength = 0;
+            if (length !== undefined) {
+                byteLength = length * this.BYTES_PER_ELEMENT;
+                if (byteLength + this.byteOffset > fisrtArg.byteLength)
+                    throw new RangeError(`valid typed array length: ${length}`);
+            }
+            else {
+                byteLength = fisrtArg.byteLength - this.byteOffset;
+                if (byteLength % this.BYTES_PER_ELEMENT !== 0)
+                    throw new RangeError('byte length of BigInt128Array should be a multiple of 16');
+            }
+            this.byteLength = byteLength;
+        }
+        else {
+            const array = [];
+            for (const value of fisrtArg)
+                array.push(value);
+            this.buffer = new ArrayBuffer(array.length * this.BYTES_PER_ELEMENT);
+            this.byteOffset = 0;
+            this.byteLength = array.length * this.BYTES_PER_ELEMENT;
+            this.set(array);
+        }
+        return new Proxy(this, {
+            get(target, key) {
+                if (typeof key === 'string') {
+                    const index = Number(key);
+                    // only positive integer index is allowed
+                    if (Number.isInteger(index) && index >= 0 && index < target.length)
+                        return target.at(index);
+                }
+                return Reflect.get(target, key);
+            },
+            set(target, key, value) {
+                if (typeof key === 'string') {
+                    const index = Number(key);
+                    if (Number.isInteger(index) && index >= 0 && index < target.length)
+                        target.set([value], index);
+                    // ignore invalid number index setter, and never set value to target
+                    return true;
+                }
+                return Reflect.set(target, key, value);
+            }
+        });
+    }
+    get length() {
+        return this.byteLength / this.BYTES_PER_ELEMENT;
+    }
+    set(array, offset = 0) {
+        if (offset + array.length > this.length)
+            throw new RangeError('offset is out of bounds');
+        const dv = new DataView(this.buffer);
+        for (let i = 0; i < array.length; i++) {
+            const byteOffset = this.byteOffset + (offset + i) * this.BYTES_PER_ELEMENT;
+            set_big_int_128(dv, byteOffset, array[i]);
+        }
+    }
+    at(index) {
+        const length = this.length;
+        if (index < 0)
+            index += length;
+        if (index >= length || index < 0)
+            return undefined;
+        const dv = new DataView(this.buffer);
+        return get_big_int_128(dv, this.byteOffset + index * this.BYTES_PER_ELEMENT);
+    }
+    subarray(begin = 0, end = this.length) {
+        const length = this.length;
+        // subarray arguments should be the same behavior as other TypedArray
+        // https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray#%E8%AF%B4%E6%98%8E
+        if (begin < 0)
+            begin += length;
+        if (end < 0)
+            end += length;
+        if (begin < 0)
+            begin = 0;
+        else if (begin > length)
+            begin = length;
+        if (end < 0)
+            end = 0;
+        else if (end > length)
+            end = length;
+        const newLength = Math.max(end - begin, 0);
+        return new BigInt128Array(this.buffer, this.byteOffset + begin * this.BYTES_PER_ELEMENT, newLength);
+    }
+    [Symbol.iterator]() {
+        let index = 0;
+        const array = this;
+        return {
+            next() {
+                if (index < array.length)
+                    return { value: array.at(index++), done: false };
+                else
+                    return { done: true };
+            },
+        };
+    }
+    toString() {
+        const values = [];
+        for (const value of this)
+            values.push(value);
+        return values.join(',');
+    }
+    // Simulate other TypedArray behavior in nodejs
+    [inspect.custom]() {
+        const values = [];
+        for (const value of this)
+            values.push(value);
+        const value_str = values.length ? ` ${values.map(v => String(v) + 'n').join(', ')} ` : '';
+        return `${this[Symbol.toStringTag]}(${this.length}) [${value_str}]`;
+    }
+}
+Object.defineProperty(BigInt128Array.prototype, Symbol.toStringTag, {
+    configurable: false,
+    writable: false,
+    enumerable: false,
+    value: 'BigInt128Array',
+});
+// DataView Extends for bigint 128 operations
+function get_big_uint_128(dataview, byte_offset, le = true) {
+    let cursor = byte_offset + (le ? 15 : 0);
+    const end = byte_offset + (le ? -1 : 16);
+    const step = le ? -1 : 1;
+    let value = 0n;
+    while (cursor !== end) {
+        value = value << 8n | BigInt(dataview.getUint8(cursor));
+        cursor += step;
+    }
+    return value;
+}
+function get_big_int_128(dataview, byte_offset, le = true) {
+    return BigInt.asIntN(128, get_big_uint_128(dataview, byte_offset, le));
+}
+function set_big_uint_128(dataView, byte_offset, value, le = true) {
+    let cursor = byte_offset + (le ? 0 : 15);
+    const end = byte_offset + (le ? 16 : -1);
+    const step = le ? 1 : -1;
+    while (cursor !== end) {
+        dataView.setUint8(cursor, Number(value & 0xffn));
+        value = value >> 8n;
+        cursor += step;
+    }
+}
+function set_big_int_128(dataview, byte_offset, value, le = true) {
+    set_big_uint_128(dataview, byte_offset, value, le);
+}
+// 大端
+// const dataBE = new ArrayBuffer(16)
+// const dataViewBE = new DataView(dataBE)
+// set_big_int_128(dataViewBE, 0, -34355n, false)
+// console.log(dataViewBE.buffer)
+// const bigInt128BE = get_big_int_128(dataViewBE, 0, false)
+// const bigUint128BE = get_big_uint_128(dataViewBE, 0, false)
+// console.log(bigInt128BE.toString(), bigUint128BE.toString())
+// 小端
+// const dataLE = new ArrayBuffer(16)
+// const dataViewLE = new DataView(dataLE)
+// set_big_int_128(dataViewLE, 0, -34355n, true)
+// console.log(dataViewLE.buffer)
+// const bigInt128LE = get_big_int_128(dataViewLE, 0, true)
+// const bigUint128LE = get_big_uint_128(dataViewLE, 0, true)
+// console.log(bigInt128LE.toString(), bigUint128LE.toString())
 //# sourceMappingURL=index.js.map