ordered-binary 1.5.1 → 1.5.2

package/dist/index.cjs

@@ -2,8 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('constants');
-
 /*
 control character types:
 1 - metadata
@@ -16,6 +14,9 @@ control character types:
 0 - multipart separator
 > 27 normal string characters
 */
+/*
+* Convert arbitrary scalar values to buffer bytes with type preservation and type-appropriate ordering
+*/
 
 const float64Array = new Float64Array(2);
 const int32Array = new Int32Array(float64Array.buffer, 0, 4);
@@ -176,7 +177,6 @@ function writeKey(key, target, position, inSequence) {
 
 let position;
 function readKey(buffer, start, end, inSequence) {
-	buffer[end] = 0; // make sure it is null terminated
 	position = start;
 	let controlByte = buffer[position];
 	let value;
@@ -190,7 +190,7 @@ function readKey(buffer, start, end, inSequence) {
 			} else if (controlByte == 0) {
 				value = null;
 			} else if (controlByte == 2) {
-				value = Symbol.for(readString(buffer));
+				value = Symbol.for(readStringSafely(buffer, end));
 			} else
 				return Uint8Array.prototype.slice.call(buffer, start, end)
 		} else {
@@ -209,7 +209,7 @@ function readKey(buffer, start, end, inSequence) {
 				lowInt = dataView.getInt32(position + 4);
 				highInt |= lowInt >>> 28;
 				if (size <= 6) { // clear the last bits
-					lowInt &= -0x1000;
+					lowInt &= -0x10000;
 				}
 				lowInt = lowInt << 4;
 				if (size > 8) {
@@ -242,15 +242,7 @@ function readKey(buffer, start, end, inSequence) {
 		if (controlByte == 27) {
 			position++;
 		}
-		value = readString(buffer);
-		/*let strStart = position
-		let strEnd = end
-		for (; position < end; position++) {
-			if (buffer[position] == 0) {
-			break
-			}
-		}
-		value = buffer.toString('utf8', strStart, position++)*/
+		value = readStringSafely(buffer, end);
 	}
 	while (position < end) {
 		if (buffer[position] === 0)
@@ -379,7 +371,19 @@ const readString =
 			'getPosition() { return position },' +
 			'readString }'))(fromCharCode)) :
 		eval(makeStringBuilder());
-
+function readStringSafely(source, end) {
+	if (source[end] > 0) {
+		let previous = source[end];
+		try {
+			// read string expects a null terminator, that is a 0 or undefined from reading past the end of the buffer, so we
+			// have to ensure that, but do so safely, restoring the buffer to its original state
+			source[end] = 0;
+			return readString(source)
+		} finally {
+			source[end] = previous;
+		}
+	} else return readString(source);
+}
 function compareKeys(a, b) {
 	// compare with type consistency that matches binary comparison
 	if (typeof a == 'object') {

package/index.js

@@ -14,8 +14,6 @@ control character types:
 * Convert arbitrary scalar values to buffer bytes with type preservation and type-appropriate ordering
 */
 
-import exp from "constants"
-
 const float64Array = new Float64Array(2)
 const int32Array = new Int32Array(float64Array.buffer, 0, 4)
 let nullTerminate = false
@@ -175,7 +173,6 @@ export function writeKey(key, target, position, inSequence) {
 
 let position
 export function readKey(buffer, start, end, inSequence) {
-	buffer[end] = 0 // make sure it is null terminated
 	position = start
 	let controlByte = buffer[position]
 	let value
@@ -189,7 +186,7 @@ export function readKey(buffer, start, end, inSequence) {
 			} else if (controlByte == 0) {
 				value = null
 			} else if (controlByte == 2) {
-				value = Symbol.for(readString(buffer))
+				value = Symbol.for(readStringSafely(buffer, end))
 			} else
 				return Uint8Array.prototype.slice.call(buffer, start, end)
 		} else {
@@ -208,7 +205,7 @@ export function readKey(buffer, start, end, inSequence) {
 				lowInt = dataView.getInt32(position + 4)
 				highInt |= lowInt >>> 28
 				if (size <= 6) { // clear the last bits
-					lowInt &= -0x1000
+					lowInt &= -0x10000
 				}
 				lowInt = lowInt << 4
 				if (size > 8) {
@@ -241,15 +238,7 @@ export function readKey(buffer, start, end, inSequence) {
 		if (controlByte == 27) {
 			position++
 		}
-		value = readString(buffer)
-		/*let strStart = position
-		let strEnd = end
-		for (; position < end; position++) {
-			if (buffer[position] == 0) {
-			break
-			}
-		}
-		value = buffer.toString('utf8', strStart, position++)*/
+		value = readStringSafely(buffer, end)
 	}
 	while (position < end) {
 		if (buffer[position] === 0)
@@ -378,7 +367,19 @@ const readString =
 			'getPosition() { return position },' +
 			'readString }'))(fromCharCode)) :
 		eval(makeStringBuilder())
-
+function readStringSafely(source, end) {
+	if (source[end] > 0) {
+		let previous = source[end]
+		try {
+			// read string expects a null terminator, that is a 0 or undefined from reading past the end of the buffer, so we
+			// have to ensure that, but do so safely, restoring the buffer to its original state
+			source[end] = 0
+			return readString(source)
+		} finally {
+			source[end] = previous
+		}
+	} else return readString(source);
+}
 export function compareKeys(a, b) {
 	// compare with type consistency that matches binary comparison
 	if (typeof a == 'object') {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ordered-binary",
   "author": "Kris Zyp",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "Conversion of JavaScript primitives to and from Buffer with binary order matching natural primitive order",
   "license": "MIT",
   "repository": {

package/tests/test.js

@@ -27,6 +27,7 @@ suite('key buffers', () => {
     assert.strictEqual(fromBufferKey(toBufferKey(-4)), -4)
     assert.strictEqual(fromBufferKey(toBufferKey(3.4)), 3.4)
     assert.strictEqual(fromBufferKey(toBufferKey(Math.PI)), Math.PI)
+    assert.strictEqual(fromBufferKey(toBufferKey(2002225)), 2002225)
     assert.strictEqual(fromBufferKey(toBufferKey(9377288)), 9377288)
     assert.strictEqual(fromBufferKey(toBufferKey(1503579323825)), 1503579323825)
     assert.strictEqual(fromBufferKey(toBufferKey(1503579323825.3523532)), 1503579323825.3523532)
@@ -35,6 +36,18 @@ suite('key buffers', () => {
     assert.strictEqual(fromBufferKey(toBufferKey(-0.00005032)), -0.00005032)
     assert.strictEqual(fromBufferKey(toBufferKey(0.00000000000000000000000005431)), 0.00000000000000000000000005431)
   })
+  test('within buffer equivalence', () => {
+    let buffer = Buffer.alloc(1024, 0xff);
+    let length = writeKey(2002225, buffer, 0);
+    let position = length;
+    buffer[position++] = 0xff;
+    buffer[position++] = 0xff;
+    assert.strictEqual(readKey(buffer, 0, length), 2002225);
+    length = writeKey('hello, world', buffer, 0);
+    assert.strictEqual(readKey(buffer, 0, length), 'hello, world');
+    // ensure that reading the string didn't modify the buffer after the string (or is restored at least)
+    assert.strictEqual(buffer[length], 0xff);
+  });
   test('number comparison', () => {
     assertBufferComparison(toBufferKey(4), toBufferKey(5))
     assertBufferComparison(toBufferKey(1503579323824), toBufferKey(1503579323825))
@@ -68,6 +81,9 @@ suite('key buffers', () => {
   test('bigint comparison', () => {
     assertBufferComparison(toBufferKey(0xfffffffffffffffffffffn), toBufferKey(0x100fffffffffffffffffffn))
     assertBufferComparison(toBufferKey(12345678901234567890), toBufferKey(12345678901234567890n))
+    assertBufferComparison(toBufferKey(6135421331404949076605986n), toBufferKey(6135421331404949076605987n))
+    assertBufferComparison(toBufferKey(-6135421331404949076605986n), toBufferKey(-6135421331404949076605985n))
+    assertBufferComparison(toBufferKey(-35913040084491349n), toBufferKey(-35913040084491348n))
   })
 
   test('string equivalence', () => {