hbsig 0.2.4 → 0.2.5

package/cjs/httpsig.js

@@ -348,48 +348,36 @@ function encodeBodyPart(partName, bodyPart, inlineKey) {
   return "";
 }
 
-// Improved helper to detect if data is likely binary
-function isBinaryData(data) {
-  var buf;
-  if (typeof data === "string") {
-    // Convert string to buffer using binary encoding to check byte values
-    buf = Buffer.from(data, "binary");
-  } else if (Buffer.isBuffer(data)) {
-    buf = data;
-  } else {
-    return false;
+// Helper to detect if a Buffer contains binary data
+function isBinaryData(buf) {
+  // Check first 512 bytes for binary indicators
+  var checkLength = Math.min(buf.length, 512);
+
+  // Any null byte means binary
+  for (var i = 0; i < checkLength; i++) {
+    if (buf[i] === 0) return true;
   }
 
-  // Check a larger sample - double to 1024 bytes for better detection
-  var sampleSize = Math.min(buf.length, 1024);
-  var nullCount = 0;
+  // Count non-text bytes
   var controlCount = 0;
   var highByteCount = 0;
-  for (var i = 0; i < sampleSize; i++) {
-    var _byte = buf[i];
-
-    // Null bytes are a strong indicator of binary
-    if (_byte === 0) {
-      nullCount++;
-      if (nullCount > 0) return true; // Even one null byte indicates binary
-    }
-
-    // Control characters (except common text ones: TAB, LF, CR)
+  for (var _i8 = 0; _i8 < checkLength; _i8++) {
+    var _byte = buf[_i8];
+    // Non-printable chars (except CR/LF/TAB)
     if (_byte < 32 && _byte !== 9 && _byte !== 10 && _byte !== 13) {
       controlCount++;
     }
-
-    // High byte values that aren't valid UTF-8 continuation bytes
+    // High byte range
     if (_byte > 127) {
       highByteCount++;
     }
   }
 
-  // If more than 10% of bytes are control chars, likely binary
-  if (controlCount / sampleSize > 0.1) return true;
+  // If more than 5% are control chars, likely binary
+  if (controlCount / checkLength > 0.05) return true;
 
-  // If more than 30% are high bytes without valid UTF-8 sequences, likely binary
-  if (highByteCount / sampleSize > 0.3) return true;
+  // If more than 20% are high bytes, likely binary
+  if (highByteCount / checkLength > 0.2) return true;
   return false;
 }
 
@@ -488,32 +476,30 @@ function parseMultipart(contentType, body) {
           searchPos = nextNewline + 1;
         }
 
-        // Extract the value
+        // Extract the value - valueEnd points to \n which is NOT part of the value
         var value = headerBlock.substring(valueStart, valueEnd);
 
-        // Only trim trailing newlines if we actually found a next header
-        // (valueEnd < headerBlock.length means we found a boundary)
-        if (valueEnd < headerBlock.length) {
-          // Trim trailing CRLF or LF only at the boundary
-          if (value.endsWith("\r\n")) {
-            value = value.substring(0, value.length - 2);
-          } else if (value.endsWith("\n")) {
-            value = value.substring(0, value.length - 1);
-          } else if (value.endsWith("\r")) {
+        // Determine if this is binary data FIRST (before trimming)
+        var isBinary = value.length > 0 && isBinaryData(Buffer.from(value, "binary"));
+        if (isBinary) {
+          // Binary data: only remove trailing \r if it's part of CRLF separator
+          // (when valueEnd points to \n and value ends with \r)
+          if (valueEnd < headerBlock.length && headerBlock[valueEnd] === "\n" && value.endsWith("\r")) {
             value = value.substring(0, value.length - 1);
           }
-        }
-
-        // Determine if this is binary data
-        if (value.length > 0 && isBinaryData(value)) {
           headers[name] = Buffer.from(value, "binary");
         } else {
+          // Text data: remove all trailing CRLF/LF (these are line separators, not data)
+          value = value.replace(/[\r\n]+$/, "");
           headers[name] = value;
         }
 
         // Move to the end of this header's value
-        currentPos = valueEnd + 1;
-        if (headerBlock[valueEnd] === "\r") {
+        currentPos = valueEnd;
+        if (currentPos < headerBlock.length && headerBlock[currentPos] === "\n") {
+          currentPos++;
+        }
+        if (currentPos < headerBlock.length && headerBlock[currentPos] === "\r") {
           currentPos++;
         }
       }
@@ -530,8 +516,8 @@ function parseMultipart(contentType, body) {
         delete restHeaders["content-disposition"];
 
         // Add each header from the inline part to the top level of result
-        for (var _i8 = 0, _Object$entries8 = Object.entries(restHeaders); _i8 < _Object$entries8.length; _i8++) {
-          var _Object$entries8$_i = _slicedToArray(_Object$entries8[_i8], 2),
+        for (var _i9 = 0, _Object$entries8 = Object.entries(restHeaders); _i9 < _Object$entries8.length; _i9++) {
+          var _Object$entries8$_i = _slicedToArray(_Object$entries8[_i9], 2),
             key = _Object$entries8$_i[0],
             _value2 = _Object$entries8$_i[1];
           result[key] = _value2;
@@ -539,8 +525,8 @@ function parseMultipart(contentType, body) {
 
         // If there's body content in the inline part, add it as 'body'
         if (partBody) {
-          // Keep as Buffer if it's binary data
-          result[partName] = isBinaryData(partBody) ? Buffer.from(partBody, "binary") : partBody;
+          // Keep as string unless it's binary data
+          result[partName] = isBinaryData(Buffer.from(partBody, "binary")) ? Buffer.from(partBody, "binary") : partBody;
         }
       } else {
         // Handle named form-data parts
@@ -554,15 +540,15 @@ function parseMultipart(contentType, body) {
         var _restHeaders = _objectSpread({}, headers);
         delete _restHeaders["content-disposition"];
         if (Object.keys(_restHeaders).length === 0) {
-          // Keep as Buffer if it's binary data
-          result[partName] = isBinaryData(partBody) ? Buffer.from(partBody, "binary") : partBody;
+          // Keep as string unless it's binary data
+          result[partName] = isBinaryData(Buffer.from(partBody, "binary")) ? Buffer.from(partBody, "binary") : partBody;
         } else if (!partBody) {
           // ao-types should stay with this part, not be extracted
           result[partName] = _restHeaders;
         } else {
-          // Keep as Buffer if it's binary data
+          // Keep as string unless it's binary data
           result[partName] = _objectSpread(_objectSpread({}, _restHeaders), {}, {
-            body: isBinaryData(partBody) ? Buffer.from(partBody, "binary") : partBody
+            body: isBinaryData(Buffer.from(partBody, "binary")) ? Buffer.from(partBody, "binary") : partBody
           });
         }
       }
@@ -639,8 +625,8 @@ function httpsig_from(http) {
     // Convert flat structure to nested using flat.js
     var flat = {};
     var nonFlat = {};
-    for (var _i9 = 0, _Object$entries9 = Object.entries(withBodyKeys); _i9 < _Object$entries9.length; _i9++) {
-      var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i9], 2),
+    for (var _i0 = 0, _Object$entries9 = Object.entries(withBodyKeys); _i0 < _Object$entries9.length; _i0++) {
+      var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i0], 2),
         key = _Object$entries9$_i[0],
         value = _Object$entries9$_i[1];
       if (key.includes("/")) {
@@ -675,8 +661,8 @@ function httpsig_from(http) {
   delete result["content-digest"];
 
   // Extract hashpaths if any
-  for (var _i0 = 0, _Object$keys = Object.keys(result); _i0 < _Object$keys.length; _i0++) {
-    var _key2 = _Object$keys[_i0];
+  for (var _i1 = 0, _Object$keys = Object.keys(result); _i1 < _Object$keys.length; _i1++) {
+    var _key2 = _Object$keys[_i1];
     if (_key2.startsWith("hashpath")) {
       delete result[_key2];
     }
@@ -716,8 +702,8 @@ function httpsig_to(tabm) {
     // For flat structures, just return with normalized keys
     // This matches Erlang which returns the map unchanged
     var result = _objectSpread({}, inlineFieldHdrs);
-    for (var _i1 = 0, _Object$entries0 = Object.entries(stripped); _i1 < _Object$entries0.length; _i1++) {
-      var _Object$entries0$_i = _slicedToArray(_Object$entries0[_i1], 2),
+    for (var _i10 = 0, _Object$entries0 = Object.entries(stripped); _i10 < _Object$entries0.length; _i10++) {
+      var _Object$entries0$_i = _slicedToArray(_Object$entries0[_i10], 2),
         key = _Object$entries0$_i[0],
         value = _Object$entries0$_i[1];
       // Keep Buffers as Buffers - don't convert to strings
@@ -742,8 +728,8 @@ function httpsig_to(tabm) {
   var headers = _objectSpread({}, inlineFieldHdrs);
 
   // Process each field - ao-types at top level should go to headers
-  for (var _i10 = 0, _Object$entries1 = Object.entries(stripped); _i10 < _Object$entries1.length; _i10++) {
-    var _Object$entries1$_i = _slicedToArray(_Object$entries1[_i10], 2),
+  for (var _i11 = 0, _Object$entries1 = Object.entries(stripped); _i11 < _Object$entries1.length; _i11++) {
+    var _Object$entries1$_i = _slicedToArray(_Object$entries1[_i11], 2),
       _key3 = _Object$entries1$_i[0],
       _value3 = _Object$entries1$_i[1];
     if (_key3 === "ao-types") {

package/esm/httpsig.js

@@ -291,50 +291,37 @@ function encodeBodyPart(partName, bodyPart, inlineKey) {
   return ""
 }
 
-// Improved helper to detect if data is likely binary
-function isBinaryData(data) {
-  let buf
-
-  if (typeof data === "string") {
-    // Convert string to buffer using binary encoding to check byte values
-    buf = Buffer.from(data, "binary")
-  } else if (Buffer.isBuffer(data)) {
-    buf = data
-  } else {
-    return false
+// Helper to detect if a Buffer contains binary data
+function isBinaryData(buf) {
+  // Check first 512 bytes for binary indicators
+  const checkLength = Math.min(buf.length, 512)
+
+  // Any null byte means binary
+  for (let i = 0; i < checkLength; i++) {
+    if (buf[i] === 0) return true
   }
 
-  // Check a larger sample - double to 1024 bytes for better detection
-  const sampleSize = Math.min(buf.length, 1024)
-  let nullCount = 0
+  // Count non-text bytes
   let controlCount = 0
   let highByteCount = 0
 
-  for (let i = 0; i < sampleSize; i++) {
+  for (let i = 0; i < checkLength; i++) {
     const byte = buf[i]
-
-    // Null bytes are a strong indicator of binary
-    if (byte === 0) {
-      nullCount++
-      if (nullCount > 0) return true // Even one null byte indicates binary
-    }
-
-    // Control characters (except common text ones: TAB, LF, CR)
+    // Non-printable chars (except CR/LF/TAB)
     if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) {
       controlCount++
     }
-
-    // High byte values that aren't valid UTF-8 continuation bytes
+    // High byte range
     if (byte > 127) {
       highByteCount++
     }
   }
 
-  // If more than 10% of bytes are control chars, likely binary
-  if (controlCount / sampleSize > 0.1) return true
+  // If more than 5% are control chars, likely binary
+  if (controlCount / checkLength > 0.05) return true
 
-  // If more than 30% are high bytes without valid UTF-8 sequences, likely binary
-  if (highByteCount / sampleSize > 0.3) return true
+  // If more than 20% are high bytes, likely binary
+  if (highByteCount / checkLength > 0.2) return true
 
   return false
 }
@@ -445,32 +432,36 @@ function parseMultipart(contentType, body) {
         searchPos = nextNewline + 1
       }
 
-      // Extract the value
+      // Extract the value - valueEnd points to \n which is NOT part of the value
       let value = headerBlock.substring(valueStart, valueEnd)
 
-      // Only trim trailing newlines if we actually found a next header
-      // (valueEnd < headerBlock.length means we found a boundary)
-      if (valueEnd < headerBlock.length) {
-        // Trim trailing CRLF or LF only at the boundary
-        if (value.endsWith("\r\n")) {
-          value = value.substring(0, value.length - 2)
-        } else if (value.endsWith("\n")) {
-          value = value.substring(0, value.length - 1)
-        } else if (value.endsWith("\r")) {
+      // Determine if this is binary data FIRST (before trimming)
+      const isBinary =
+        value.length > 0 && isBinaryData(Buffer.from(value, "binary"))
+
+      if (isBinary) {
+        // Binary data: only remove trailing \r if it's part of CRLF separator
+        // (when valueEnd points to \n and value ends with \r)
+        if (
+          valueEnd < headerBlock.length &&
+          headerBlock[valueEnd] === "\n" &&
+          value.endsWith("\r")
+        ) {
           value = value.substring(0, value.length - 1)
         }
-      }
-
-      // Determine if this is binary data
-      if (value.length > 0 && isBinaryData(value)) {
         headers[name] = Buffer.from(value, "binary")
       } else {
+        // Text data: remove all trailing CRLF/LF (these are line separators, not data)
+        value = value.replace(/[\r\n]+$/, "")
         headers[name] = value
       }
 
       // Move to the end of this header's value
-      currentPos = valueEnd + 1
-      if (headerBlock[valueEnd] === "\r") {
+      currentPos = valueEnd
+      if (currentPos < headerBlock.length && headerBlock[currentPos] === "\n") {
+        currentPos++
+      }
+      if (currentPos < headerBlock.length && headerBlock[currentPos] === "\r") {
         currentPos++
       }
     }
@@ -495,8 +486,8 @@ function parseMultipart(contentType, body) {
 
       // If there's body content in the inline part, add it as 'body'
       if (partBody) {
-        // Keep as Buffer if it's binary data
-        result[partName] = isBinaryData(partBody)
+        // Keep as string unless it's binary data
+        result[partName] = isBinaryData(Buffer.from(partBody, "binary"))
           ? Buffer.from(partBody, "binary")
           : partBody
       }
@@ -515,18 +506,18 @@ function parseMultipart(contentType, body) {
       delete restHeaders["content-disposition"]
 
       if (Object.keys(restHeaders).length === 0) {
-        // Keep as Buffer if it's binary data
-        result[partName] = isBinaryData(partBody)
+        // Keep as string unless it's binary data
+        result[partName] = isBinaryData(Buffer.from(partBody, "binary"))
           ? Buffer.from(partBody, "binary")
           : partBody
       } else if (!partBody) {
         // ao-types should stay with this part, not be extracted
         result[partName] = restHeaders
       } else {
-        // Keep as Buffer if it's binary data
+        // Keep as string unless it's binary data
         result[partName] = {
           ...restHeaders,
-          body: isBinaryData(partBody)
+          body: isBinaryData(Buffer.from(partBody, "binary"))
             ? Buffer.from(partBody, "binary")
             : partBody,
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hbsig",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "main": "cjs/index.js",
   "license": "MIT",
   "devDependencies": {