whatap 0.5.26 → 1.0.0

package/lib/io/data-outputx.js

@@ -4,23 +4,21 @@
  * can be found in the LICENSE file.
  */
 
-var constants   = require('../env/constants'),
-    util        = require('../util/utils'),
-    Long        = require('long'),
-    Logger      = require('../logger');
-
-var BYTE1_MAX_UVALUE = 0xff,
-    BYTE2_MAX_UVALUE = 0xffff,
-    BYTE4_MAX_UVALUE = 0xffffffff,
-    BYTE8_MAX_UVALUE = 0xffffffffffffffff,
-    BYTE1_MAX_VALUE = Math.floor( BYTE1_MAX_UVALUE / 2 ),
-    BYTE1_MIN_VALUE = Math.floor( -BYTE1_MAX_UVALUE / 2 ),
-    BYTE2_MAX_VALUE = Math.floor( BYTE2_MAX_UVALUE / 2 ),
-    BYTE2_MIN_VALUE = Math.floor( -BYTE2_MAX_UVALUE / 2 ),
-    BYTE4_MAX_VALUE = Math.floor( BYTE4_MAX_UVALUE / 2 ),
-    BYTE4_MIN_VALUE = Math.floor( -BYTE4_MAX_UVALUE / 2 ),
-    BYTE8_MAX_VALUE = Math.floor( BYTE8_MAX_UVALUE / 2 ),
-    BYTE8_MIN_VALUE = Math.floor( -BYTE8_MAX_UVALUE / 2 );
+var util = require('../util/utils'),
+    Logger = require('../logger');
+
+const BYTE_MIN_VALUE = -128;
+const BYTE_MAX_VALUE = 127;
+const SHORT_MIN_VALUE = -32768;
+const SHORT_MAX_VALUE = 32767;
+const INT3_MIN_VALUE = -0x800000;
+const INT3_MAX_VALUE = 0x007fffff;
+const INT_MIN_VALUE = -0x80000000;
+const INT_MAX_VALUE = 0x7fffffff;
+const LONG5_MIN_VALUE = -0x8000000000;
+const LONG5_MAX_VALUE = 0x0000007fffffffff;
+const LONG_MIN_VALUE = -0x8000000000000000;
+const LONG_MAX_VALUE = 0x7fffffffffffffff;
 
 function isNumOk(n) {
     return n != null && n !== undefined && isNaN(n) == false;
@@ -33,9 +31,9 @@ function isNotNull(n) {
 function DataOutputX(size) {
     this.buf = undefined;
     if (size == undefined) {
-        this.buf = Buffer.alloc(32 , 0);
+        this.buf = Buffer.alloc(32, 0);
     } else {
-        this.buf = Buffer.alloc(size , 0);
+        this.buf = Buffer.alloc(size, 0);
     }
     this.offset = 0;
 }
@@ -59,9 +57,8 @@ DataOutputX.prototype.grow = function(minCapacity) {
         newCapacity = 2147483647;
     }
     var oldBuffer = this.buf;
-    this.buf = Buffer.alloc(newCapacity,0);
+    this.buf = Buffer.alloc(newCapacity, 0);
     oldBuffer.copy(this.buf);
-
 };
 
 DataOutputX.prototype.reset = function() {
@@ -69,16 +66,17 @@ DataOutputX.prototype.reset = function() {
 };
 
 DataOutputX.prototype.size = function() {
-    return this.buf.length;
+    return this.offset;
 };
 
-DataOutputX.prototype.writeIntBytes = function(b){
-    if( !b || b.length == 0 ){
+DataOutputX.prototype.writeIntBytes = function(b) {
+    if (!b || b.length == 0) {
         this.writeInt(0);
-    } else{
+    } else {
         this.writeInt(b.length);
         this.writeBytes(b);
     }
+    return this;
 };
 
 DataOutputX.prototype.writeShortBytes = function(b) {
@@ -91,7 +89,7 @@ DataOutputX.prototype.writeBlob = function(value) {
     if (isNotNull(value) == false) {
         this.writeByte(0);
     } else {
-        if((value instanceof Buffer) == false) {
+        if ((value instanceof Buffer) == false) {
             throw new Error('Write Blob parameter must be buffer instance');
         }
         var len = value.length;
@@ -115,17 +113,16 @@ DataOutputX.prototype.copy = function(inputBuff) {
     this.ensureCapacity(this.offset + inputBuff.length);
     inputBuff.copy(this.buf, this.offset, 0, inputBuff.length);
     this.offset += inputBuff.length;
-    inputBuff = null;
-
 };
 
 DataOutputX.prototype.toByteArray = function() {
     var returnBuffer = Buffer.alloc(this.offset);
-    this.buf.copy(returnBuffer);
+    this.buf.copy(returnBuffer, 0, 0, this.offset);
     return returnBuffer;
 };
 
 DataOutputX.prototype.writeByte = function(b) {
+    b = b & 0xFF;
     this.ensureCapacity(this.offset + 1);
     this.buf[this.offset] = b;
     this.offset += 1;
@@ -138,7 +135,7 @@ DataOutputX.prototype.writeBytes = function(bytes) {
     }
 
     this.ensureCapacity(this.offset + bytes.length);
-    for ( var i = 0; i < bytes.length; i++) {
+    for (var i = 0; i < bytes.length; i++) {
         this.buf[this.offset] = bytes[i];
         this.offset += 1;
     }
@@ -147,55 +144,51 @@ DataOutputX.prototype.writeBytes = function(bytes) {
 };
 
 DataOutputX.prototype.writeDecimal = function(value) {
-    if(value instanceof Long) {
-        this.writeByte(8);
-        this.writeLong(value);
-        return this;
-    }
-
     if (isNumOk(value) == false) {
         this.writeByte(0);
-    } else if (constants.numType.INT8_MIN <= value
-        && value <= constants.numType.INT8_MAX) {
+    } else if (BYTE_MIN_VALUE <= value && value <= BYTE_MAX_VALUE) {
         this.writeByte(1);
-        this.writeInt8(value);
-    } else if (constants.numType.INT16_MIN <= value
-        && value <= constants.numType.INT16_MAX) {
+        this.writeByte(value);
+    } else if (SHORT_MIN_VALUE <= value && value <= SHORT_MAX_VALUE) {
         this.writeByte(2);
-        this.writeInt16BE(value);
-    } else if (constants.numType.INT24_MIN <= value
-        && value <= constants.numType.INT24_MAX) {
+        this.writeShort(value);
+    } else if (INT3_MIN_VALUE <= value && value <= INT3_MAX_VALUE) {
         this.writeByte(3);
-        this.writeInt24BE(value);
-    } else if (constants.numType.INT32_MIN <= value
-        && value <= constants.numType.INT32_MAX) {
+        this.writeInt3(value);
+    } else if (INT_MIN_VALUE <= value && value <= INT_MAX_VALUE) {
         this.writeByte(4);
-        this.writeInt32BE(value);
-    } else if(constants.numType.INT40_MIN <= value && value <=
-        constants.numType.INT40_MAX) {
+        this.writeInt(value);
+    } else if (LONG5_MIN_VALUE <= value && value <= LONG5_MAX_VALUE) {
         this.writeByte(5);
-        this.writeInt40BE(value);
-    } else if (constants.numType.INT64_MIN <= value
-        && value <= constants.numType.INT64_MAX) {
-        var longVal = Long.fromNumber(value);
+        this.writeLong5(value);
+    } else if (LONG_MIN_VALUE <= value && value <= LONG_MAX_VALUE) {
         this.writeByte(8);
-        this.writeLong(longVal);
+        this.writeLong(value);
     }
     return this;
 };
 
-DataOutputX.prototype.write = function(value /* byte[] */, off /* int */, len /* int */){
-    this.writeBytes(value);
+DataOutputX.prototype.write = function(value) {
+    if (Buffer.isBuffer(value)) {
+        this.ensureCapacity(this.offset + value.length);
+        value.copy(this.buf, this.offset);
+        this.offset += value.length;
+    } else if (Array.isArray(value)) {
+        this.writeBytes(value);
+    }
+    return this;
 };
 
-DataOutputX.prototype.writeInt = function(value){
+DataOutputX.prototype.writeInt = function(value) {
     this.writeInt32BE(value);
+    return this;
 };
 
 DataOutputX.prototype.writeInt8 = function(value) {
     if (isNumOk(value) == false) {
         value = 0;
     }
+    value = value & 0xFF;
     this.ensureCapacity(this.offset + 1);
     this.buf[this.offset] = value;
     this.offset += 1;
@@ -206,42 +199,37 @@ DataOutputX.prototype.writeUInt8 = function(value) {
     if (isNumOk(value) == false) {
         value = 0;
     }
+    value = value & 0xFF;
     this.ensureCapacity(this.offset + 1);
-    // this.buf[this.offset] = value;
-    this.buf.writeUInt8(value,this.offset);
+    this.buf.writeUInt8(value, this.offset);
     this.offset += 1;
     return this;
 };
 
 DataOutputX.prototype.writeShort = function(value) {
-    this.writeInt16BE(value);
-};
-
-DataOutputX.prototype.writeInt16BE = function(value) {
     if (isNumOk(value) == false) {
         value = 0;
     }
+    value = value & 0xFFFF;
     this.ensureCapacity(this.offset + 2);
-    this.buf.writeInt16BE(value, this.offset);
+    this.buf.writeUInt16BE(value, this.offset);
     this.offset += 2;
     return this;
 };
 
+DataOutputX.prototype.writeInt16BE = function(value) {
+    return this.writeShort(value);
+};
+
 DataOutputX.prototype.writeUInt16BE = function(value) {
-    if (isNumOk(value) == false) {
-        value = 0;
-    }
-    this.ensureCapacity(this.offset + 2);
-    this.buf.writeUInt16BE(value, this.offset);
-    this.offset += 2;
-    return this;
+    return this.writeShort(value);
 };
 
-DataOutputX.prototype.writeInt24BE = function(value) {
+DataOutputX.prototype.writeInt3 = function(value) {
     if (isNumOk(value) == false) {
         value = 0;
     }
-    this.ensureCapacity(this.offset + 1);
+    this.ensureCapacity(this.offset + 3);
     this.buf[this.offset] = (value >>> 16) & 0xff;
     this.buf[this.offset + 1] = (value >>> 8) & 0xff;
     this.buf[this.offset + 2] = (value >>> 0) & 0xff;
@@ -249,87 +237,85 @@ DataOutputX.prototype.writeInt24BE = function(value) {
     return this;
 };
 
+DataOutputX.prototype.writeInt24BE = function(value) {
+    return this.writeInt3(value);
+};
+
 DataOutputX.prototype.writeInt32BE = function(value) {
     if (isNumOk(value) == false) {
         value = 0;
     }
+    // Convert to unsigned 32-bit integer to handle negative values
+    value = (value & 0xFFFFFFFF) >>> 0;
     this.ensureCapacity(this.offset + 4);
-    this.buf.writeInt32BE(value, this.offset);
+    this.buf.writeUInt32BE(value, this.offset);
     this.offset += 4;
     return this;
 };
 
 DataOutputX.prototype.writeUInt32BE = function(value) {
+    return this.writeInt32BE(value);
+};
+
+DataOutputX.prototype.writeLong5 = function(value) {
     if (isNumOk(value) == false) {
         value = 0;
     }
-    this.ensureCapacity(this.offset + 4);
-    this.buf.writeUInt32BE(value, this.offset);
-    this.offset += 4;
+    this.ensureCapacity(this.offset + 5);
+    this.buf[this.offset] = ((value >> 32) & 0xFF);
+    this.buf[this.offset + 1] = ((value >> 24) & 0xFF);
+    this.buf[this.offset + 2] = ((value >> 16) & 0xFF);
+    this.buf[this.offset + 3] = ((value >> 8) & 0xFF);
+    this.buf[this.offset + 4] = ((value >> 0) & 0xFF);
+    this.offset += 5;
     return this;
 };
 
 DataOutputX.prototype.writeInt40BE = function(value) {
+    return this.writeLong5(value);
+};
+
+// 새롭게 구현된 writeLong - Python 구현과 동일하게 작동
+DataOutputX.prototype.writeLong = function(value) {
     if (isNumOk(value) == false) {
         value = 0;
     }
-    var lo = value % 0x100000000;
-    var hi = value / 0x100000000;
-    hi = hi | 0;
 
-    this.writeByte((hi >>> 0) & 0xff);
-    this.writeByte((lo >>> 24) & 0xff);
-    this.writeByte((lo >>> 16) & 0xff);
-    this.writeByte((lo >>> 8) & 0xff);
-    this.writeByte((lo >>> 0) & 0xff);
+    this.ensureCapacity(this.offset + 8);
 
-    return this;
-};
+    // BigInt를 사용하여 64비트 연산을 정확히 처리
+    try {
+        // 음수든 양수든 BigInt로 변환하면 64비트 표현으로 보존됨
+        const bigValue = BigInt(value);
 
-DataOutputX.prototype.writeLong = function(value){
-    var v = value;
-    if(typeof value == 'string'){
-        v = Long.fromString(value);
-    } else if(typeof value == 'number') {
-        v = Long.fromNumber(value);
-    }
+        // 64비트 마스킹
+        const maskedValue = bigValue & 0xFFFFFFFFFFFFFFFFn;
 
-    if(v.constructor == Long){
-        this.writeInt32BE(v.getHighBits())
-        this.writeInt32BE(v.getLowBits())
-    }else{
-        this.ensureCapacity(this.offset + 8);
+        // BigInt 값을 버퍼에 씀
+        this.buf.writeBigUInt64BE(maskedValue, this.offset);
         this.offset += 8;
-    }
-    return this;
-};
+    } catch (e) {
+        // BigInt를 지원하지 않는 환경이나 에러 발생 시 대체 처리
+        // 하위/상위 32비트 별도 처리
+        let hi, lo;
+        if (value < 0) {
+            // 2의 보수 로직으로 음수 처리
+            const absValue = Math.abs(value + 1);
+            hi = ~Math.floor(absValue / 0x100000000) & 0xFFFFFFFF;
+            lo = ~(absValue % 0x100000000) & 0xFFFFFFFF;
+        } else {
+            hi = Math.floor(value / 0x100000000) & 0xFFFFFFFF;
+            lo = value % 0x100000000;
+        }
 
-DataOutputX.prototype.writeInt64BE = function(value) {
-    if (isNumOk(value) == false) {
-        value = 0;
+        this.buf.writeUInt32BE(hi, this.offset);
+        this.buf.writeUInt32BE(lo, this.offset + 4);
+        this.offset += 8;
     }
-    var lo = value % 0x10000000;
-    var hi = value / 0x10000000;
-    hi = hi | 0;
-
-    this.writeByte((hi >>> 24) & 0xff);
-    this.writeByte((hi >>> 16) & 0xff);
-    this.writeByte((hi >>> 8) & 0xff);
-    this.writeByte((hi >>> 0) & 0xff);
-    this.writeByte((lo >>> 24) & 0xff);
-    this.writeByte((lo >>> 16) & 0xff);
-    this.writeByte((lo >>> 8) & 0xff);
-    this.writeByte((lo >>> 0) & 0xff);
 
     return this;
 };
 
-DataOutputX.prototype.writeTXID = function(int64) {
-    int64.copy(this.buf, this.offset);
-    this.offset += 8;
-    return this;
-};
-
 DataOutputX.prototype.writeFloat = function(value) {
     if (isNumOk(value) == false) {
         value = 0.0;
@@ -350,201 +336,153 @@ DataOutputX.prototype.writeDouble = function(value) {
     return this;
 };
 
-DataOutputX.prototype.writeString = function(value) {
-    var length = value.length;
-    this.ensureCapacity(this.offset + length);
-    this.buf.write(value, this.offset, length);
-    this.offset += length;
-    return this;
-
-};
-
 DataOutputX.prototype.writeText = function(value) {
     if (isNotNull(value) == false) {
         this.writeByte(0);
     } else {
+        const bytes = Buffer.from(value, 'utf-8');
+        const len = bytes.length;
 
-        if(typeof value === 'string') {
-            value = util.toUTF8(value);
-        }
-        if(Array.isArray(value)) {
-            var len = value.length;
-            if (len <= 253) {
-                this.writeUInt8(len);
-                this.writeBytes(value);
-            } else if (len <= 65535) {
-                this.writeUInt8(255);
-                this.writeUInt16BE(len);
-                this.writeBytes(value);
-            } else {
-                this.writeUInt8(254);
-                this.writeUInt32BE(len);
-                this.writeBytes(value);
-            }
+        if (len <= 253) {
+            this.writeUInt8(len);
+            this.write(bytes);
+        } else if (len <= 65535) {
+            this.writeUInt8(255);
+            this.writeUInt16BE(len);
+            this.write(bytes);
         } else {
-            this.writeByte(0);
+            this.writeUInt8(254);
+            this.writeUInt32BE(len);
+            this.write(bytes);
         }
     }
     return this;
 };
 
-DataOutputX.prototype.print = function() {
-    for ( var i = 0; i < this.offset; i++) {
-        console.log(i + ': ' + this.buf[i].toString(16));
+DataOutputX.prototype.writeUTF = function(value) {
+    if (isNotNull(value) == false) {
+        value = "";
     }
-};
 
-DataOutputX.prototype.writePack = function(pack) {
-    this.writeInt16BE(pack.getPackType());
-    pack.write(this);
-    return this;
-};
+    const bytes = Buffer.from(value, 'utf-8');
+    const truncatedBytes = bytes.length > 65535 ? bytes.slice(0, 65535) : bytes;
 
-DataOutputX.prototype.writeValue = function(value) {
-    if(value == null){
-        // value = NullValue
-    }
-    try{
-        this.writeByte(value.getValueType());
-        value.write(this);
-    } catch (e){
-        Logger.printError('WHATAP-251', 'DataOutputX writeValue Error', e);
-    }
+    this.writeUInt16BE(truncatedBytes.length);
+    this.write(truncatedBytes);
 
     return this;
 };
 
-DataOutputX.prototype.writeStep = function(step) {
-    this.writeByte(step.getStepType());
-    step.write(this);
+DataOutputX.prototype.writeBoolean = function(value) {
+    this.writeByte(value ? 1 : 0);
     return this;
 };
 
-DataOutputX.prototype.writeBoolean = function(value) {
-    if(typeof value == 'boolean') {
-        this.writeByte(value ? 1 : 0);
-        return this;
+DataOutputX.prototype.writeFloatArray = function(values) {
+    if (!values || !Array.isArray(values)) {
+        this.writeShort(0);
     } else {
-        this.writeByte(0);
-        return this;
+        this.writeShort(values.length);
+        for (let i = 0; i < values.length; i++) {
+            this.writeFloat(values[i]);
+        }
     }
+    return this;
 };
 
-DataOutputX.prototype.writeFloatArray = function(value) {
-    if(value == null || Array.isArray(value) == false) {
+DataOutputX.prototype.writeIntArray = function(values) {
+    if (!values || !Array.isArray(values)) {
         this.writeShort(0);
     } else {
-        var length = value.length;
-        this.writeShort(length);
-        for(var i=0; i<length; i++) {
-            this.writeFloat(value[i]);
+        this.writeShort(values.length);
+        for (let i = 0; i < values.length; i++) {
+            this.writeInt(values[i]);
         }
     }
     return this;
 };
 
-DataOutputX.prototype.writeIntArray = function(value) {
-    if(value == null || Array.isArray(value) == false) {
+DataOutputX.prototype.writeLongArray = function(values) {
+    if (!values || !Array.isArray(values)) {
         this.writeShort(0);
     } else {
-        var length = value.length;
-        this.writeShort(length);
-        for(var i=0; i<length; i++) {
-            this.writeInt(value[i]);
+        this.writeShort(values.length);
+        for (let i = 0; i < values.length; i++) {
+            this.writeLong(values[i]);
         }
     }
     return this;
 };
 
-DataOutputX.prototype.writeLongArray = function(value) {
-    if(value == null || Array.isArray(value) == false) {
+DataOutputX.prototype.writeDecimalArray = function(values) {
+    if (!values || !Array.isArray(values)) {
         this.writeShort(0);
     } else {
-        var length = value.length;
-        this.writeShort(length);
-        for(var i=0; i<length; i++) {
-            var long = value[i];
-            if(long instanceof Long) {
-                this.writeLong(value[i]);
-            } else {
-                this.writeLong(Long.fromInt(0));
-            }
+        this.writeShort(values.length);
+        for (let i = 0; i < values.length; i++) {
+            this.writeDecimal(values[i]);
         }
     }
+    return this;
 };
 
-DataOutputX.toBytes = function(v) {
-    var buf = new Array(4);
-    buf[0] = ((v >>> 24) & 0xFF);
-    buf[1] = ((v >>> 16) & 0xFF);
-    buf[2] = ((v >>> 8) & 0xFF);
-    buf[3] = ((v >>> 0) & 0xFF);
-    return buf;
+DataOutputX.prototype.writeToPos = function(pos, value) {
+    if (isNumOk(value) == false) {
+        value = 0;
+    }
+    this.buf.writeUInt32BE(value, pos);
+    return this;
 };
 
-DataOutputX.toBytesLong = function(value) {
-    var v = value;
-    if(v.constructor == String){
-        v = Long.fromString(value);
-    }
+DataOutputX.prototype.writePack = function(pack, ln_fmt) {
+    this.writeShort(pack.getPackType());
+    pack.write(this);
 
-    var tmp = Buffer.alloc(8);
-    if(v.constructor == Long){
-        tmp.writeInt32BE(v.getHighBits(), 0);
-        tmp.writeInt32BE(v.getLowBits(), 4);
-    }else{
-        tmp.writeInt32BE(0);
-        tmp.writeInt32BE(0);
+    if (ln_fmt) {
+        const remainder = this.offset % ln_fmt;
+        if (remainder !== 0) {
+            this.write(Buffer.alloc(ln_fmt - remainder));
+        }
     }
-    var high = tmp.readInt32BE(0);
-    var low = tmp.readInt32BE(4);
-    return tmp;
-};
-
-// DataOutputX.toByteArray = function(v, byteLength){
-//     var buf;
-//     if( byteLength == 2 && (BYTE2_MIN_VALUE <= v && v <= BYTE2_MAX_VALUE) ){
-//         byteLength = byteLength || 2;
-//         buf = new Buffer(byteLength);
-//         buf[0] = ((v >>> 8) & 0xFF);
-//         buf[1] = ((v >>> 0) & 0xFF);
-//     }else if( byteLength == 4 && (BYTE4_MIN_VALUE <= v && v <= BYTE4_MAX_VALUE) ){
-//         byteLength = byteLength || 4;
-//         buf = new Buffer(byteLength);
-//         buf[0] = ((v >>> 24) & 0xFF);
-//         buf[1] = ((v >>> 16) & 0xFF);
-//         buf[2] = ((v >>> 8) & 0xFF);
-//         buf[3] = ((v >>> 0) & 0xFF);
-//     }else if( byteLength == 8 && (BYTE8_MIN_VALUE <= v && v <= BYTE8_MAX_VALUE) ){
-//         byteLength = byteLength || 8;
-//         buf = new Buffer(byteLength);
-//         buf[0] = (v >>> 56);
-//         buf[1] = (v >>> 48);
-//         buf[2] = (v >>> 40);
-//         buf[3] = (v >>> 32);
-//         buf[4] = (v >>> 24);
-//         buf[5] = (v >>> 16);
-//         buf[6] = (v >>> 8);
-//         buf[7] = (v >>> 0);
-//     }
-//     return buf;
-// };
-
-DataOutputX.set = function(dest, pos, src){
-    src.copy(dest, 0, pos, src.length);
-    return dest;
-};
-
-DataOutputX.toBytesPack = function(pack, fmtLen) {
-    if(fmtLen == undefined ) {
-        return new DataOutputX().writePack(pack).toByteArray();
+
+    return this;
+};
+
+DataOutputX.prototype.writeValue = function(value) {
+    if (value == null) {
+        // NullValue 처리
+        value = new NullValue();
     }
-    var out = new DataOutputX().writePack(pack);
-    var remainder = out.size() % (fmtLen||0);
-    if (remainder != 0) {
-        out.write(Buffer.alloc(fmtLen - remainder));
+
+    try {
+        this.writeByte(value.getValueType());
+        value.write(this);
+    } catch (e) {
+        Logger.printError('WHATAP-503', 'DataOutputX writeValue Error', e);
     }
+
+    return this;
+};
+
+DataOutputX.toBytes = function(v) {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(v & 0xFFFFFFFF, 0);
+    return buf;
+};
+
+DataOutputX.toBytesLong = function(v) {
+    const buf = Buffer.alloc(8);
+    const hi = Math.floor(v / 0x100000000);
+    const lo = v % 0x100000000;
+
+    buf.writeUInt32BE(hi, 0);
+    buf.writeUInt32BE(lo, 4);
+    return buf;
+};
+
+DataOutputX.toBytesPack = function(pack, ln_fmt) {
+    const out = new DataOutputX().writePack(pack, ln_fmt);
     return out.toByteArray();
-}
+};
 
 module.exports = DataOutputX;