whatap 1.0.1 → 1.0.2

package/lib/io/data-outputx.js

@@ -4,21 +4,23 @@
  * can be found in the LICENSE file.
  */
 
-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;
+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 );
 
 function isNumOk(n) {
     return n != null && n !== undefined && isNaN(n) == false;
@@ -31,9 +33,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;
 }
@@ -57,8 +59,9 @@ 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() {
@@ -66,17 +69,16 @@ DataOutputX.prototype.reset = function() {
 };
 
 DataOutputX.prototype.size = function() {
-    return this.offset;
+    return this.buf.length;
 };
 
-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) {
@@ -89,7 +91,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;
@@ -113,16 +115,17 @@ 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, 0, 0, this.offset);
+    this.buf.copy(returnBuffer);
     return returnBuffer;
 };
 
 DataOutputX.prototype.writeByte = function(b) {
-    b = b & 0xFF;
     this.ensureCapacity(this.offset + 1);
     this.buf[this.offset] = b;
     this.offset += 1;
@@ -135,7 +138,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;
     }
@@ -144,51 +147,55 @@ 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 (BYTE_MIN_VALUE <= value && value <= BYTE_MAX_VALUE) {
+    } else if (constants.numType.INT8_MIN <= value
+        && value <= constants.numType.INT8_MAX) {
         this.writeByte(1);
-        this.writeByte(value);
-    } else if (SHORT_MIN_VALUE <= value && value <= SHORT_MAX_VALUE) {
+        this.writeInt8(value);
+    } else if (constants.numType.INT16_MIN <= value
+        && value <= constants.numType.INT16_MAX) {
         this.writeByte(2);
-        this.writeShort(value);
-    } else if (INT3_MIN_VALUE <= value && value <= INT3_MAX_VALUE) {
+        this.writeInt16BE(value);
+    } else if (constants.numType.INT24_MIN <= value
+        && value <= constants.numType.INT24_MAX) {
         this.writeByte(3);
-        this.writeInt3(value);
-    } else if (INT_MIN_VALUE <= value && value <= INT_MAX_VALUE) {
+        this.writeInt24BE(value);
+    } else if (constants.numType.INT32_MIN <= value
+        && value <= constants.numType.INT32_MAX) {
         this.writeByte(4);
-        this.writeInt(value);
-    } else if (LONG5_MIN_VALUE <= value && value <= LONG5_MAX_VALUE) {
+        this.writeInt32BE(value);
+    } else if(constants.numType.INT40_MIN <= value && value <=
+        constants.numType.INT40_MAX) {
         this.writeByte(5);
-        this.writeLong5(value);
-    } else if (LONG_MIN_VALUE <= value && value <= LONG_MAX_VALUE) {
+        this.writeInt40BE(value);
+    } else if (constants.numType.INT64_MIN <= value
+        && value <= constants.numType.INT64_MAX) {
+        var longVal = Long.fromNumber(value);
         this.writeByte(8);
-        this.writeLong(value);
+        this.writeLong(longVal);
     }
     return this;
 };
 
-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.write = function(value /* byte[] */, off /* int */, len /* int */){
+    this.writeBytes(value);
 };
 
-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;
@@ -199,37 +206,42 @@ DataOutputX.prototype.writeUInt8 = function(value) {
     if (isNumOk(value) == false) {
         value = 0;
     }
-    value = value & 0xFF;
     this.ensureCapacity(this.offset + 1);
-    this.buf.writeUInt8(value, this.offset);
+    // this.buf[this.offset] = value;
+    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.writeUInt16BE(value, this.offset);
+    this.buf.writeInt16BE(value, this.offset);
     this.offset += 2;
     return this;
 };
 
-DataOutputX.prototype.writeInt16BE = function(value) {
-    return this.writeShort(value);
-};
-
 DataOutputX.prototype.writeUInt16BE = function(value) {
-    return this.writeShort(value);
+    if (isNumOk(value) == false) {
+        value = 0;
+    }
+    this.ensureCapacity(this.offset + 2);
+    this.buf.writeUInt16BE(value, this.offset);
+    this.offset += 2;
+    return this;
 };
 
-DataOutputX.prototype.writeInt3 = function(value) {
+DataOutputX.prototype.writeInt24BE = function(value) {
     if (isNumOk(value) == false) {
         value = 0;
     }
-    this.ensureCapacity(this.offset + 3);
+    this.ensureCapacity(this.offset + 1);
     this.buf[this.offset] = (value >>> 16) & 0xff;
     this.buf[this.offset + 1] = (value >>> 8) & 0xff;
     this.buf[this.offset + 2] = (value >>> 0) & 0xff;
@@ -237,85 +249,87 @@ DataOutputX.prototype.writeInt3 = 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.writeUInt32BE(value, this.offset);
+    this.buf.writeInt32BE(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 + 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;
+    this.ensureCapacity(this.offset + 4);
+    this.buf.writeUInt32BE(value, this.offset);
+    this.offset += 4;
     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.ensureCapacity(this.offset + 8);
+    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);
 
-    // BigInt를 사용하여 64비트 연산을 정확히 처리
-    try {
-        // 음수든 양수든 BigInt로 변환하면 64비트 표현으로 보존됨
-        const bigValue = BigInt(value);
+    return this;
+};
 
-        // 64비트 마스킹
-        const maskedValue = bigValue & 0xFFFFFFFFFFFFFFFFn;
+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);
+    }
 
-        // BigInt 값을 버퍼에 씀
-        this.buf.writeBigUInt64BE(maskedValue, this.offset);
+    if(v.constructor == Long){
+        this.writeInt32BE(v.getHighBits())
+        this.writeInt32BE(v.getLowBits())
+    }else{
+        this.ensureCapacity(this.offset + 8);
         this.offset += 8;
-    } 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;
-        }
+    }
+    return this;
+};
 
-        this.buf.writeUInt32BE(hi, this.offset);
-        this.buf.writeUInt32BE(lo, this.offset + 4);
-        this.offset += 8;
+DataOutputX.prototype.writeInt64BE = function(value) {
+    if (isNumOk(value) == false) {
+        value = 0;
     }
+    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;
@@ -336,153 +350,201 @@ 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 (len <= 253) {
-            this.writeUInt8(len);
-            this.write(bytes);
-        } else if (len <= 65535) {
-            this.writeUInt8(255);
-            this.writeUInt16BE(len);
-            this.write(bytes);
+        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);
+            }
         } else {
-            this.writeUInt8(254);
-            this.writeUInt32BE(len);
-            this.write(bytes);
+            this.writeByte(0);
         }
     }
     return this;
 };
 
-DataOutputX.prototype.writeUTF = function(value) {
-    if (isNotNull(value) == false) {
-        value = "";
+DataOutputX.prototype.print = function() {
+    for ( var i = 0; i < this.offset; i++) {
+        console.log(i + ': ' + this.buf[i].toString(16));
     }
+};
 
-    const bytes = Buffer.from(value, 'utf-8');
-    const truncatedBytes = bytes.length > 65535 ? bytes.slice(0, 65535) : bytes;
+DataOutputX.prototype.writePack = function(pack) {
+    this.writeInt16BE(pack.getPackType());
+    pack.write(this);
+    return this;
+};
 
-    this.writeUInt16BE(truncatedBytes.length);
-    this.write(truncatedBytes);
+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);
+    }
 
     return this;
 };
 
-DataOutputX.prototype.writeBoolean = function(value) {
-    this.writeByte(value ? 1 : 0);
+DataOutputX.prototype.writeStep = function(step) {
+    this.writeByte(step.getStepType());
+    step.write(this);
     return this;
 };
 
-DataOutputX.prototype.writeFloatArray = function(values) {
-    if (!values || !Array.isArray(values)) {
-        this.writeShort(0);
+DataOutputX.prototype.writeBoolean = function(value) {
+    if(typeof value == 'boolean') {
+        this.writeByte(value ? 1 : 0);
+        return this;
     } else {
-        this.writeShort(values.length);
-        for (let i = 0; i < values.length; i++) {
-            this.writeFloat(values[i]);
-        }
+        this.writeByte(0);
+        return this;
     }
-    return this;
 };
 
-DataOutputX.prototype.writeIntArray = function(values) {
-    if (!values || !Array.isArray(values)) {
+DataOutputX.prototype.writeFloatArray = function(value) {
+    if(value == null || Array.isArray(value) == false) {
         this.writeShort(0);
     } else {
-        this.writeShort(values.length);
-        for (let i = 0; i < values.length; i++) {
-            this.writeInt(values[i]);
+        var length = value.length;
+        this.writeShort(length);
+        for(var i=0; i<length; i++) {
+            this.writeFloat(value[i]);
         }
     }
     return this;
 };
 
-DataOutputX.prototype.writeLongArray = function(values) {
-    if (!values || !Array.isArray(values)) {
+DataOutputX.prototype.writeIntArray = function(value) {
+    if(value == null || Array.isArray(value) == false) {
         this.writeShort(0);
     } else {
-        this.writeShort(values.length);
-        for (let i = 0; i < values.length; i++) {
-            this.writeLong(values[i]);
+        var length = value.length;
+        this.writeShort(length);
+        for(var i=0; i<length; i++) {
+            this.writeInt(value[i]);
         }
     }
     return this;
 };
 
-DataOutputX.prototype.writeDecimalArray = function(values) {
-    if (!values || !Array.isArray(values)) {
+DataOutputX.prototype.writeLongArray = function(value) {
+    if(value == null || Array.isArray(value) == false) {
         this.writeShort(0);
     } else {
-        this.writeShort(values.length);
-        for (let i = 0; i < values.length; i++) {
-            this.writeDecimal(values[i]);
+        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));
+            }
         }
     }
-    return this;
 };
 
-DataOutputX.prototype.writeToPos = function(pos, value) {
-    if (isNumOk(value) == false) {
-        value = 0;
-    }
-    this.buf.writeUInt32BE(value, pos);
-    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.writePack = function(pack, ln_fmt) {
-    this.writeShort(pack.getPackType());
-    pack.write(this);
-
-    if (ln_fmt) {
-        const remainder = this.offset % ln_fmt;
-        if (remainder !== 0) {
-            this.write(Buffer.alloc(ln_fmt - remainder));
-        }
+DataOutputX.toBytesLong = function(value) {
+    var v = value;
+    if(v.constructor == String){
+        v = Long.fromString(value);
     }
 
-    return this;
-};
-
-DataOutputX.prototype.writeValue = function(value) {
-    if (value == null) {
-        // NullValue 처리
-        value = new NullValue();
+    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);
     }
-
-    try {
-        this.writeByte(value.getValueType());
-        value.write(this);
-    } catch (e) {
-        Logger.printError('WHATAP-503', 'DataOutputX writeValue Error', e);
+    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();
+    }
+    var out = new DataOutputX().writePack(pack);
+    var remainder = out.size() % (fmtLen||0);
+    if (remainder != 0) {
+        out.write(Buffer.alloc(fmtLen - remainder));
     }
-
-    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;