wip

Author: ljharb

.github/workflows/node-aught.yml

@@ -16,7 +16,14 @@ var isView = ArrayBuffer.isView || function isView(obj) {
 var useUint8Array = typeof Uint8Array !== 'undefined';
 var useArrayBuffer = typeof ArrayBuffer !== 'undefined'
 	&& typeof Uint8Array !== 'undefined';
-var useFromArrayBuffer = useArrayBuffer && (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT);
+// Check if we're on a big-endian system
+var isBigEndian = (function() {
+	var buffer = new ArrayBuffer(2);
+	new DataView(buffer).setInt16(0, 256, true); // little-endian
+	return new Int16Array(buffer)[0] !== 256;
+})();
+
+var useFromArrayBuffer = useArrayBuffer && (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT) && !isBigEndian;
 
 module.exports = function toBuffer(data, encoding) {
 	if (Buffer.isBuffer(data)) {
@@ -54,7 +61,55 @@ module.exports = function toBuffer(data, encoding) {
 		}
 
 		// Convert to Uint8Array bytes and then to Buffer
-		var uint8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+		var uint8;
+		if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
+			// These are already byte arrays, no endianness issues
+			uint8 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+		} else {
+			// For multi-byte TypedArrays, ensure consistent little-endian byte order
+			// Create a new buffer and use DataView to read elements in little-endian format
+			var elemSize = data.BYTES_PER_ELEMENT;
+			var elemCount = data.length;
+			uint8 = new Uint8Array(data.byteLength);
+			var outputView = new DataView(uint8.buffer);
+			var inputView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+			// Copy each element, reading in native order and writing in little-endian
+			for (var j = 0; j < elemCount; j++) {
+				var offset = j * elemSize;
+				var value;
+
+				// Read the value in platform's native endianness, write in little-endian
+				if (elemSize === 1) {
+					// 8-bit values have no endianness
+					value = inputView.getUint8(offset);
+					outputView.setUint8(offset, value);
+				} else if (elemSize === 2) {
+					// 16-bit values: read native, write little-endian
+					value = inputView.getUint16(offset); // native endianness
+					outputView.setUint16(offset, value, true); // true = little-endian
+				} else if (elemSize === 4) {
+					// 32-bit values - check if it's float or int by examining the original array
+					if (data instanceof Float32Array) {
+						value = inputView.getFloat32(offset); // native endianness
+						outputView.setFloat32(offset, value, true);
+					} else {
+						value = inputView.getUint32(offset); // native endianness
+						outputView.setUint32(offset, value, true);
+					}
+				} else if (elemSize === 8) {
+					// 64-bit values
+					if (data instanceof Float64Array) {
+						value = inputView.getFloat64(offset); // native endianness
+						outputView.setFloat64(offset, value, true);
+					} else {
+						value = inputView.getBigUint64(offset); // native endianness
+						outputView.setBigUint64(offset, value, true);
+					}
+				}
+			}
+		}
+
 		var result = Buffer.from(uint8);
 
 		/*