ordered-binary 1.5.1 → 1.5.3

package/README.md

@@ -1,7 +1,6 @@
 [![npm version](https://img.shields.io/npm/dw/ordered-binary)](https://www.npmjs.org/package/ordered-binary)
 [![npm version](https://img.shields.io/npm/v/ordered-binary.svg?style=flat-square)](https://www.npmjs.org/package/ordered-binary)
 [![license](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
-<a href="https://dev.doctorevidence.com/"><img src="./assets/powers-dre.png" width="203" /></a>
 
 The ordered-binary package provides a representation of JavaScript primitives, serialized into binary format (NodeJS Buffers or Uint8Arrays), such that the binary values are naturally ordered such that it matches the natural ordering or values. For example, since -2.0321 > -2.04, then `toBufferKey(-2.0321)` will be greater than `toBufferKey(-2.04)` as a binary representation, in left-to-right evaluation. This is particular useful for storing keys as binaries with something like LMDB or LevelDB, to avoid any custom sorting.
 

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);
@@ -68,7 +69,7 @@ function writeKey(key, target, position, inSequence) {
 			}
 		} else {
 			if (target.utf8Write)
-				position += target.utf8Write(key, position, 0xffffffff);
+				position += target.utf8Write(key, position, target.byteLength - position);
 			else
 				position += textEncoder.encodeInto(key, target.subarray(position)).written;
 			if (position > target.length - 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
@@ -67,7 +65,7 @@ export function writeKey(key, target, position, inSequence) {
 			}
 		} else {
 			if (target.utf8Write)
-				position += target.utf8Write(key, position, 0xffffffff)
+				position += target.utf8Write(key, position, target.byteLength - position)
 			else
 				position += textEncoder.encodeInto(key, target.subarray(position)).written
 			if (position > target.length - 4)
@@ -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.3",
   "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', () => {