hbsig 0.0.1

package/cjs/httpsig2.js

@@ -0,0 +1,1160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.verifyContentDigest = exports.toBuffer = exports.hasValidSignature = exports.getSignatureNames = exports.from = exports.extractKeys = void 0;
+var _ramda = require("ramda");
+var _signerUtils = require("./signer-utils.js");
+var _base64url = _interopRequireDefault(require("base64url"));
+var _utils = require("./utils.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Get multipart boundary from content-type header
+ */
+var getBoundary = function getBoundary(http) {
+  var ctype = http.headers["content-type"];
+  if (ctype && /^multipart\/form-data;/.test((0, _ramda.trim)(ctype))) {
+    var _iterator = _createForOfIteratorHelper((0, _ramda.trim)(ctype).split(";").slice(1)),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var v = _step.value;
+        var sp2 = v.split("=");
+        if ((0, _ramda.trim)(sp2[0]) === "boundary") return (0, _ramda.trim)(sp2[1]).replace(/"/g, "");
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return null;
+};
+
+/**
+ * Extract specified components from HTTP message
+ * @param {Object} http - HTTP message object with headers and optional body
+ * @param {Array} components - Array of component names to extract
+ * @returns {Object} Extracted components with their values
+ */
+var extract = function extract(http, components) {
+  var extracted = {};
+  var needsBody = components.some(function (c) {
+    return c.replace(/"/g, "").toLowerCase() === "content-digest";
+  });
+
+  // First extract ao-types if it's signed
+  var hasAoTypes = components.some(function (c) {
+    return c.replace(/"/g, "").toLowerCase() === "ao-types";
+  });
+  if (hasAoTypes) {
+    var aoTypes = http.headers["ao-types"] || http.headers["Ao-Types"];
+    if (aoTypes) {
+      extracted["ao-types"] = aoTypes;
+    }
+  }
+
+  // Extract ao-ids if it's signed
+  var hasAoIds = components.some(function (c) {
+    return c.replace(/"/g, "").toLowerCase() === "ao-ids";
+  });
+  if (hasAoIds) {
+    var aoIds = http.headers["ao-ids"] || http.headers["Ao-Ids"];
+    if (aoIds) {
+      extracted["ao-ids"] = aoIds;
+    }
+  }
+  var _iterator2 = _createForOfIteratorHelper(components),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var component = _step2.value;
+      var cleanComponent = component.replace(/"/g, "");
+      if (cleanComponent.startsWith("@")) {
+        // Handle derived components
+        switch (cleanComponent) {
+          case "@method":
+            extracted[cleanComponent] = http.method || "GET";
+            break;
+          case "@target-uri":
+            extracted[cleanComponent] = http.url || "";
+            break;
+          case "@authority":
+            extracted[cleanComponent] = http.headers.host || "";
+            break;
+          case "@scheme":
+            if (http.url) {
+              var url = new URL(http.url);
+              extracted[cleanComponent] = url.protocol.replace(":", "");
+            }
+            break;
+          case "@request-target":
+            if (http.url) {
+              var _url = new URL(http.url);
+              extracted[cleanComponent] = _url.pathname + _url.search;
+            }
+            break;
+          case "@path":
+            if (http.url) {
+              var _url2 = new URL(http.url);
+              extracted[cleanComponent] = _url2.pathname;
+            }
+            break;
+          case "@query":
+            if (http.url) {
+              var _url3 = new URL(http.url);
+              extracted[cleanComponent] = _url3.search;
+            }
+            break;
+          case "@status":
+            extracted[cleanComponent] = String(http.status || http["@status"] || "");
+            break;
+          case "@query-param":
+            // This would need additional parsing logic for specific query parameters
+            break;
+        }
+      } else {
+        // Handle regular headers - try both exact case and lowercase
+        var headerValue = http.headers[cleanComponent] || http.headers[cleanComponent.toLowerCase()];
+        if (headerValue !== null && headerValue !== undefined) {
+          extracted[cleanComponent] = headerValue;
+        }
+      }
+    }
+
+    // If content-digest is signed, we need to include the body
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (needsBody && http.body !== undefined) {
+    extracted["body"] = http.body;
+  }
+
+  // Add flag if body is needed but missing
+  if (needsBody && http.body === undefined) {
+    extracted["__bodyRequired__"] = true;
+  }
+  return extracted;
+};
+
+/**
+ * Convert body to Buffer from various sources
+ * @param {string|Buffer|ArrayBuffer} body - The body to convert
+ * @returns {Buffer} The body as a Buffer
+ */
+var toBuffer = exports.toBuffer = function toBuffer(body) {
+  if (!body) {
+    return Buffer.alloc(0);
+  }
+
+  // If it's already a Buffer, return it
+  if (Buffer.isBuffer(body)) {
+    return body;
+  }
+
+  // If it's a string, convert to Buffer
+  if (typeof body === "string") {
+    return Buffer.from(body, "utf-8");
+  }
+
+  // If it's an ArrayBuffer or TypedArray
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+    return Buffer.from(body);
+  }
+  throw new Error("Unsupported body type");
+};
+
+/**
+ * Parse ao-ids dictionary
+ * @param {string} aoIds - The ao-ids header value
+ * @returns {Object} Parsed ID mappings
+ */
+var parseAoIds = function parseAoIds(aoIds) {
+  var result = {};
+
+  // Match pattern: ID="value"
+  var regex = /([A-Za-z0-9_-]{43})="([^"]*)"/g;
+  var match;
+  while ((match = regex.exec(aoIds)) !== null) {
+    var _match = match,
+      _match2 = _slicedToArray(_match, 3),
+      id = _match2[1],
+      value = _match2[2];
+    result[id] = value;
+  }
+  return result;
+};
+
+/**
+ * Convert message to JSON with proper type conversions
+ * Following the logic from dev_codec_structured, dev_codec_httpsig_conv, and dev_codec_flat
+ * @param {Object} msg - The message to convert
+ * @returns {Object} JSON representation
+ */
+var _toJSON = function toJSON(msg) {
+  if (!msg || _typeof(msg) !== "object") {
+    return msg;
+  }
+  var result = _objectSpread({}, msg);
+
+  // Handle ao-ids parsing
+  if (result["ao-ids"]) {
+    var parsedIds = parseAoIds(result["ao-ids"]);
+    // Remove the ao-ids header and merge the parsed IDs
+    delete result["ao-ids"];
+    result = _objectSpread(_objectSpread({}, result), parsedIds);
+  }
+
+  // First, handle the multipart body if present
+  var contentType = result["content-type"];
+  var body = result.body;
+  if (body && contentType && contentType.includes("multipart/form-data")) {
+    var boundary = getBoundary({
+      headers: {
+        "content-type": contentType
+      }
+    });
+    if (boundary) {
+      // Parse multipart body
+      var parts = parseMultipartBody(body, boundary);
+
+      // Remove the raw body since we've parsed it
+      delete result.body;
+
+      // Merge parsed parts into result
+      for (var _i = 0, _Object$entries = Object.entries(parts); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          partName = _Object$entries$_i[0],
+          partData = _Object$entries$_i[1];
+        // Parse ao-types from part data if present
+        var partTypes = {};
+        if (partData["ao-types"]) {
+          // Updated regex to handle spaces and trim the key
+          var matches = _toConsumableArray(partData["ao-types"].matchAll(/([^=,]+)="([^"]+)"/g));
+          var _iterator3 = _createForOfIteratorHelper(matches),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var _step3$value = _slicedToArray(_step3.value, 3),
+                _ = _step3$value[0],
+                key = _step3$value[1],
+                type = _step3$value[2];
+              partTypes[key.trim()] = type;
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+
+        // Apply type conversions to part data
+        var convertedPartData = {};
+        for (var _i2 = 0, _Object$entries2 = Object.entries(partData); _i2 < _Object$entries2.length; _i2++) {
+          var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+            _key = _Object$entries2$_i[0],
+            value = _Object$entries2$_i[1];
+          if (_key === "ao-types" || _key === "content-disposition") continue;
+          var _type = partTypes[_key];
+          if (_type && typeof value === "string") {
+            convertedPartData[_key] = convertByType(value, _type);
+          } else {
+            convertedPartData[_key] = value;
+          }
+        }
+
+        // Store the result
+        if (Object.keys(convertedPartData).length > 0) {
+          // Check if the part name suggests it's an array element (ends with /number)
+          var isArrayElement = /\/\d+$/.test(partName);
+
+          // For top-level parts (no slash in name) with objects, keep the structure
+          var isTopLevel = !partName.includes("/");
+
+          // Check if this is a nested path that will be unflattened
+          var isNestedPath = partName.includes("/") && !isArrayElement;
+          if (isArrayElement || isNestedPath) {
+            // Array elements and nested paths keep their structure
+            result[partName] = convertedPartData;
+          } else if (isTopLevel || Object.keys(convertedPartData).length > 1) {
+            // Top-level objects or multi-field objects keep their structure
+            result[partName] = convertedPartData;
+          } else {
+            // Only lift single values for simple cases
+            result[partName] = convertedPartData[Object.keys(convertedPartData)[0]];
+          }
+        }
+
+        // Store type information for nested fields
+        if (Object.keys(partTypes).length > 0) {
+          for (var _i3 = 0, _Object$entries3 = Object.entries(partTypes); _i3 < _Object$entries3.length; _i3++) {
+            var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+              fieldKey = _Object$entries3$_i[0],
+              fieldType = _Object$entries3$_i[1];
+            if (fieldKey !== "ao-types" && fieldKey !== "content-disposition") {
+              // Add to global typeMap with the full path
+              var fullPath = partName + "/" + fieldKey;
+              // Store in the ao-types for later use
+              if (!result["__typeMap"]) result["__typeMap"] = {};
+              result["__typeMap"][fullPath] = fieldType;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Parse global ao-types to get type information
+  var typeMap = {};
+  if (result["ao-types"]) {
+    // Updated regex to handle spaces and trim the key
+    var _matches = _toConsumableArray(result["ao-types"].matchAll(/([^=,]+)="([^"]+)"/g));
+    var _iterator4 = _createForOfIteratorHelper(_matches),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _step4$value = _slicedToArray(_step4.value, 3),
+          _2 = _step4$value[0],
+          _key2 = _step4$value[1],
+          _type2 = _step4$value[2];
+        typeMap[_key2.trim()] = _type2;
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+  }
+
+  // Merge in types from multipart parsing
+  if (result["__typeMap"]) {
+    Object.assign(typeMap, result["__typeMap"]);
+    delete result["__typeMap"];
+  }
+
+  // Also collect types from multipart parts for nested fields
+  for (var _i4 = 0, _Object$entries4 = Object.entries(result); _i4 < _Object$entries4.length; _i4++) {
+    var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
+      _key3 = _Object$entries4$_i[0],
+      _value = _Object$entries4$_i[1];
+    if (_key3.includes("/") && _typeof(_value) === "object" && _value !== null && _value.__partTypes) {
+      // This is a multipart part with type information
+      for (var _i5 = 0, _Object$entries5 = Object.entries(_value.__partTypes); _i5 < _Object$entries5.length; _i5++) {
+        var _Object$entries5$_i = _slicedToArray(_Object$entries5[_i5], 2),
+          _fieldKey = _Object$entries5$_i[0],
+          _fieldType = _Object$entries5$_i[1];
+        // Create the full path for the type
+        var _fullPath = "".concat(_key3, "/").concat(_fieldKey);
+        typeMap[_fullPath] = _fieldType;
+      }
+      // Remove the __partTypes after processing
+      delete _value.__partTypes;
+    }
+  }
+
+  // Add empty values for fields that are in ao-types but not in result
+  for (var _i6 = 0, _Object$entries6 = Object.entries(typeMap); _i6 < _Object$entries6.length; _i6++) {
+    var _Object$entries6$_i = _slicedToArray(_Object$entries6[_i6], 2),
+      _key4 = _Object$entries6$_i[0],
+      _type3 = _Object$entries6$_i[1];
+    if (!(_key4 in result) && _type3.startsWith("empty-")) {
+      result[_key4] = convertByType("", _type3);
+    }
+  }
+
+  // Apply type conversions and build final result
+  var finalResult = {};
+  for (var _i7 = 0, _Object$entries7 = Object.entries(result); _i7 < _Object$entries7.length; _i7++) {
+    var _Object$entries7$_i = _slicedToArray(_Object$entries7[_i7], 2),
+      _key5 = _Object$entries7$_i[0],
+      _value2 = _Object$entries7$_i[1];
+    // Skip internal keys and headers we don't want in the final result
+    if (_key5.startsWith("__")) continue;
+
+    // Skip @ fields EXCEPT @path which we want to include
+    if (_key5.startsWith("@") && _key5 !== "@path") continue;
+    if (_key5 === "ao-types") continue;
+    if (_key5 === "content-type") continue;
+    if (_key5 === "content-digest") continue;
+    if (_key5 === "signature") continue;
+    if (_key5 === "signature-input") continue;
+    if (_key5 === "body-keys") continue;
+
+    // Get the type for this key
+    var _type4 = typeMap[_key5];
+
+    // Special handling for objects that should be lists
+    if (_type4 === "list" && _typeof(_value2) === "object" && _value2 !== null && !Array.isArray(_value2)) {
+      // This is an object that should be converted to a list
+      var converted = maybeConvertToArray(_value2);
+      finalResult[_key5] = converted;
+    } else if (_type4 && typeof _value2 === "string") {
+      // Convert based on type
+      finalResult[_key5] = convertByType(_value2, _type4);
+    } else if (_type4 && _value2 === undefined) {
+      // Handle empty types
+      finalResult[_key5] = convertByType("", _type4);
+    } else if (_typeof(_value2) === "object" && _value2 !== null && !Array.isArray(_value2)) {
+      // For objects without a specific type, keep them as objects
+      // Only recurse for processing nested values
+      var processedObj = {};
+      for (var _i8 = 0, _Object$entries8 = Object.entries(_value2); _i8 < _Object$entries8.length; _i8++) {
+        var _Object$entries8$_i = _slicedToArray(_Object$entries8[_i8], 2),
+          k = _Object$entries8$_i[0],
+          v = _Object$entries8$_i[1];
+        if (Array.isArray(v)) {
+          // Keep arrays as arrays
+          processedObj[k] = v;
+        } else if (_typeof(v) === "object" && v !== null) {
+          processedObj[k] = _toJSON(v);
+        } else {
+          processedObj[k] = v;
+        }
+      }
+      finalResult[_key5] = processedObj;
+    } else {
+      // Keep as-is (including arrays)
+      finalResult[_key5] = _value2;
+    }
+  }
+
+  // Handle flattened paths - pass typeMap for context
+  return unflattenPaths(finalResult, typeMap);
+};
+
+/**
+ * Convert objects with numeric keys to arrays
+ */
+var maybeConvertToArray = function maybeConvertToArray(obj) {
+  if (Array.isArray(obj)) return obj;
+  var keys = Object.keys(obj);
+  var numericKeys = keys.filter(function (k) {
+    return /^\d+$/.test(k);
+  });
+
+  // If all keys are numeric and sequential starting from 1
+  if (numericKeys.length > 0 && numericKeys.length === keys.length) {
+    var sortedNumericKeys = numericKeys.map(Number).sort(function (a, b) {
+      return a - b;
+    });
+    var maxIndex = Math.max.apply(Math, _toConsumableArray(sortedNumericKeys));
+    var arr = [];
+
+    // Fill array based on numeric keys (1-based to 0-based)
+    for (var i = 1; i <= maxIndex; i++) {
+      if (obj[String(i)] !== undefined) {
+        arr[i - 1] = obj[String(i)];
+      }
+    }
+    return arr;
+  }
+  return obj;
+};
+
+/**
+ * Convert value based on its type
+ */
+var convertByType = function convertByType(value, type) {
+  switch (type) {
+    case "integer":
+      // Handle structured field integer format
+      if (typeof value === "string" && value.match(/^"?\(ao-type-integer\)\s+(\d+)"?$/)) {
+        var match = value.match(/(\d+)/);
+        return parseInt(match[1], 10);
+      }
+      return parseInt(value, 10);
+    case "float":
+    case "decimal":
+      return parseFloat(value);
+    case "boolean":
+      return value === "true" || value === "?1";
+    case "atom":
+      // Remove quotes from atom values
+      var atomValue = value;
+
+      // Remove any surrounding quotes (single or double)
+      if (atomValue.startsWith('"') && atomValue.endsWith('"') || atomValue.startsWith("'") && atomValue.endsWith("'")) {
+        atomValue = atomValue.slice(1, -1);
+      }
+
+      // Also handle escaped quotes
+      atomValue = atomValue.replace(/\\"/g, '"').replace(/\\'/g, "'");
+
+      // Handle special atom values
+      if (atomValue === "true") return true;
+      if (atomValue === "false") return false;
+      if (atomValue === "null") return null;
+
+      // For other atoms, return as Symbol
+      return Symbol["for"](atomValue);
+    case "list":
+      // Handle case where list is a comma-separated string
+      if (typeof value === "string" && !value.startsWith("(")) {
+        var items = [];
+        var current = "";
+        var inQuotes = false;
+        var depth = 0;
+        for (var i = 0; i < value.length; i++) {
+          var _char = value[i];
+          var prevChar = value[i - 1];
+          if (_char === '"' && prevChar !== "\\") {
+            inQuotes = !inQuotes;
+          }
+          if (!inQuotes) {
+            if (_char === "(") {
+              depth++;
+            } else if (_char === ")") {
+              depth--;
+            } else if (_char === "," && depth === 0) {
+              if (current.trim()) {
+                // Parse the item to handle type annotations
+                items.push(parseStructuredItem(current.trim()));
+              }
+              current = "";
+              continue;
+            }
+          }
+          current += _char;
+        }
+        if (current.trim()) {
+          items.push(parseStructuredItem(current.trim()));
+        }
+        return items;
+      }
+      return parseStructuredList(value);
+    case "map":
+    case "dictionary":
+      return parseStructuredDict(value);
+    case "empty-binary":
+      return "";
+    case "empty-list":
+      return [];
+    case "empty-message":
+      return {};
+    default:
+      return value;
+  }
+};
+
+/**
+ * Parse structured field list
+ */
+var parseStructuredList = function parseStructuredList(value) {
+  if (!value || value === "()") return [];
+
+  // Remove outer quotes if present
+  var content = value.trim();
+  if (content.startsWith('"') && content.endsWith('"')) {
+    content = content.slice(1, -1);
+  }
+  var items = [];
+  var current = "";
+  var inQuotes = false;
+  var depth = 0;
+  for (var i = 0; i < content.length; i++) {
+    var _char2 = content[i];
+    var prevChar = content[i - 1];
+    if (_char2 === '"' && prevChar !== "\\") {
+      inQuotes = !inQuotes;
+      current += _char2;
+    } else if (!inQuotes) {
+      if (_char2 === "(") {
+        depth++;
+        current += _char2;
+      } else if (_char2 === ")") {
+        depth--;
+        current += _char2;
+      } else if (_char2 === "," && depth === 0) {
+        if (current.trim()) {
+          items.push(parseStructuredItem(current.trim()));
+        }
+        current = "";
+      } else {
+        current += _char2;
+      }
+    } else {
+      current += _char2;
+    }
+  }
+  if (current.trim()) {
+    items.push(parseStructuredItem(current.trim()));
+  }
+  return items;
+};
+
+/**
+ * Parse structured field item
+ */
+var parseStructuredItem = function parseStructuredItem(item) {
+  // Quoted string - handle first to properly process inner content
+  if (item.startsWith('"') && item.endsWith('"')) {
+    var inner = item.slice(1, -1).replace(/\\"/g, '"');
+
+    // Check if the inner content is ao-type encoded
+    var innerAoTypeMatch = inner.match(/^\(ao-type-(\w+)\)\s+(.+)$/);
+    if (innerAoTypeMatch) {
+      var _innerAoTypeMatch = _slicedToArray(innerAoTypeMatch, 3),
+        type = _innerAoTypeMatch[1],
+        value = _innerAoTypeMatch[2];
+      // The value here has already had escaped quotes converted to real quotes
+      // If it's wrapped in quotes, remove them
+      var cleanValue = value;
+      if (cleanValue.startsWith('"') && cleanValue.endsWith('"') || cleanValue.startsWith("'") && cleanValue.endsWith("'")) {
+        cleanValue = cleanValue.slice(1, -1);
+      }
+      return convertByType(cleanValue, type);
+    }
+    return inner;
+  }
+
+  // Handle ao-type encoded items without outer quotes
+  var aoTypeMatch = item.match(/^\(ao-type-(\w+)\)\s+(.+)$/);
+  if (aoTypeMatch) {
+    var _aoTypeMatch = _slicedToArray(aoTypeMatch, 3),
+      _type5 = _aoTypeMatch[1],
+      _value3 = _aoTypeMatch[2];
+    var _cleanValue = _value3;
+    // Handle escaped quotes
+    _cleanValue = _cleanValue.replace(/\\"/g, '"');
+    // If wrapped in quotes, remove them
+    if (_cleanValue.startsWith('"') && _cleanValue.endsWith('"') || _cleanValue.startsWith("'") && _cleanValue.endsWith("'")) {
+      _cleanValue = _cleanValue.slice(1, -1);
+    }
+    return convertByType(_cleanValue, _type5);
+  }
+
+  // Boolean
+  if (item === "?1") return true;
+  if (item === "?0") return false;
+
+  // Number
+  if (/^-?\d+$/.test(item)) {
+    return parseInt(item, 10);
+  }
+  if (/^-?\d+\.\d+$/.test(item)) {
+    return parseFloat(item);
+  }
+
+  // Nested list
+  if (item.startsWith("(") && item.endsWith(")")) {
+    return parseStructuredList(item);
+  }
+  return item;
+};
+
+/**
+ * Parse structured field dictionary
+ */
+var parseStructuredDict = function parseStructuredDict(value) {
+  var decoded = (0, _signerUtils.decodeSigInput)(value);
+  var result = {};
+  for (var _i9 = 0, _Object$entries9 = Object.entries(decoded); _i9 < _Object$entries9.length; _i9++) {
+    var _Object$entries9$_i = _slicedToArray(_Object$entries9[_i9], 2),
+      key = _Object$entries9$_i[0],
+      info = _Object$entries9$_i[1];
+    if (info && info.components && info.components.length > 0) {
+      result[key] = parseStructuredItem(info.components[0]);
+    } else {
+      result[key] = true;
+    }
+  }
+  return result;
+};
+
+/**
+ * Parse body-keys list
+ */
+var parseBodyKeysList = function parseBodyKeysList(value) {
+  var matches = _toConsumableArray(value.matchAll(/"([^"]+)"/g));
+  return matches.map(function (m) {
+    return m[1];
+  });
+};
+
+/**
+ * Parse multipart body
+ */
+var parseMultipartBody = function parseMultipartBody(body, boundary) {
+  var result = {};
+
+  // Split by boundary lines
+  var parts = body.split("--".concat(boundary));
+  for (var i = 0; i < parts.length; i++) {
+    var part = parts[i];
+
+    // Skip empty parts and the terminating part
+    if (!part || part === "--" || part === "--\r\n" || part.trim() === "") continue;
+
+    // Remove leading \r\n if present
+    var content = part;
+    if (content.startsWith("\r\n")) {
+      content = content.substring(2);
+    }
+
+    // Remove trailing \r\n or -- if present
+    if (content.endsWith("\r\n")) {
+      content = content.substring(0, content.length - 2);
+    }
+    if (!content) continue;
+
+    // Parse all lines
+    var lines = content.split("\r\n");
+    var partData = {};
+    var partName = null;
+    var _iterator5 = _createForOfIteratorHelper(lines),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var line = _step5.value;
+        if (!line) continue;
+        var colonIndex = line.indexOf(": ");
+        if (colonIndex > -1) {
+          var name = line.substring(0, colonIndex);
+          var value = line.substring(colonIndex + 2);
+
+          // Check if this is content-disposition to extract part name
+          if (name.toLowerCase() === "content-disposition") {
+            var nameMatch = value.match(/name="([^"]+)"/);
+            if (nameMatch) {
+              partName = nameMatch[1];
+            }
+          } else {
+            // Store all other headers/fields
+            partData[name] = value;
+          }
+        }
+      }
+
+      // Store the part data under its name
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+    if (partName && Object.keys(partData).length > 0) {
+      result[partName] = partData;
+    }
+  }
+  return result;
+};
+
+/**
+ * Unflatten paths with '/'
+ */
+var unflattenPaths = function unflattenPaths(obj) {
+  var typeMap = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var result = {};
+
+  // Check if there are any paths to unflatten
+  var hasPathsToUnflatten = Object.keys(obj).some(function (key) {
+    return key.includes("/");
+  });
+
+  // If no paths to unflatten, return the object as-is
+  if (!hasPathsToUnflatten) {
+    return obj;
+  }
+
+  // First pass: collect all keys and sort them to process parents before children
+  var sortedKeys = Object.keys(obj).sort();
+  var _iterator6 = _createForOfIteratorHelper(sortedKeys),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var key = _step6.value;
+      var value = obj[key];
+      if (key.includes("/")) {
+        var parts = key.split("/");
+        var current = result;
+        var i = 0;
+        while (i < parts.length - 1) {
+          var part = parts[i];
+
+          // Check if we have consecutive empty parts (multiple slashes)
+          if (part === "" && i + 1 < parts.length && parts[i + 1] === "") {
+            // Skip empty parts until we find a non-empty one or reach the end
+            var j = i;
+            while (j < parts.length && parts[j] === "") {
+              j++;
+            }
+            // Use "/" as the key for multiple slashes
+            part = "/";
+            i = j - 1; // Will be incremented at the end of loop
+          } else if (part === "") {
+            // Single empty part at the beginning or middle, skip it
+            i++;
+            continue;
+          }
+          if (!current[part]) {
+            current[part] = {};
+          }
+          current = current[part];
+          i++;
+        }
+
+        // Handle the final part
+        var finalPart = parts[parts.length - 1];
+        current[finalPart] = value;
+      } else {
+        result[key] = value;
+      }
+    }
+
+    // Second pass: convert objects with numeric keys to arrays only if they have type="list"
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  var _convertToArraysRecursive = function convertToArraysRecursive(obj) {
+    var parentKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    if (Array.isArray(obj)) {
+      return obj.map(function (item, index) {
+        return _convertToArraysRecursive(item, "".concat(parentKey, "/").concat(index + 1));
+      });
+    } else if (obj && _typeof(obj) === "object") {
+      // Check if this object has type="list" in typeMap
+      var hasListType = typeMap[parentKey] === "list";
+
+      // Only convert to array if it has numeric keys AND type="list"
+      if (hasListType) {
+        var converted = maybeConvertToArray(obj);
+        if (Array.isArray(converted)) {
+          return converted.map(function (item, index) {
+            return _convertToArraysRecursive(item, "".concat(parentKey, "/").concat(index + 1));
+          });
+        }
+      }
+
+      // Otherwise, keep as object and recurse
+      var _result = {};
+      for (var _i0 = 0, _Object$entries0 = Object.entries(obj); _i0 < _Object$entries0.length; _i0++) {
+        var _Object$entries0$_i = _slicedToArray(_Object$entries0[_i0], 2),
+          key = _Object$entries0$_i[0],
+          value = _Object$entries0$_i[1];
+        var childKey = parentKey ? "".concat(parentKey, "/").concat(key) : key;
+        _result[key] = _convertToArraysRecursive(value, childKey);
+      }
+      return _result;
+    }
+    return obj;
+  };
+  return _convertToArraysRecursive(result);
+};
+
+/**
+ * Helper to check if a key pattern suggests an array structure
+ */
+var isArrayKey = function isArrayKey(obj, currentKey, partIndex) {
+  var parts = currentKey.split("/");
+  var prefix = parts.slice(0, partIndex + 1).join("/");
+
+  // Check if there are other keys with the same prefix but numeric suffixes
+  for (var _i1 = 0, _Object$keys = Object.keys(obj); _i1 < _Object$keys.length; _i1++) {
+    var key = _Object$keys[_i1];
+    if (key.startsWith(prefix + "/") && key !== currentKey) {
+      var otherParts = key.split("/");
+      if (otherParts.length > partIndex + 1 && /^\d+$/.test(otherParts[partIndex + 1])) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+/**
+ * Check if a string contains binary data (non-printable characters)
+ * @param {string} str - The string to check
+ * @returns {boolean} True if binary data detected
+ */
+var isBinaryString = function isBinaryString(str) {
+  if (!str || typeof str !== "string") return false;
+
+  // Check for non-printable characters (excluding common whitespace)
+  for (var i = 0; i < str.length; i++) {
+    var code = str.charCodeAt(i);
+    // Allow tab (9), newline (10), carriage return (13), and printable ASCII (32-126)
+    if (code < 9 || code > 13 && code < 32 || code > 126) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Convert binary string to Buffer
+ * @param {string} str - Binary string to convert
+ * @returns {Buffer} Buffer representation of the string
+ */
+var stringToBuffer = function stringToBuffer(str) {
+  var buffer = Buffer.alloc(str.length);
+  for (var i = 0; i < str.length; i++) {
+    buffer[i] = str.charCodeAt(i);
+  }
+  return buffer;
+};
+var from = exports.from = function from(http) {
+  var input = http.headers["signature-input"] || http.headers["Signature-Input"];
+  if (!input) {
+    return null;
+  }
+
+  // Decode signature inputs
+  var inputs = (0, _signerUtils.decodeSigInput)(input);
+  // Process the first signature (following the original logic)
+  for (var k in inputs) {
+    var _sigData$params$tag, _sigData$params;
+    var sigData = inputs[k];
+    // Extract only the signed components
+    var extractedComponents = extract(http, sigData.components);
+    var ret = {
+      hashpath: (_sigData$params$tag = sigData === null || sigData === void 0 || (_sigData$params = sigData.params) === null || _sigData$params === void 0 ? void 0 : _sigData$params.tag) !== null && _sigData$params$tag !== void 0 ? _sigData$params$tag : null
+    };
+    try {
+      ret.signer = (0, _utils.toAddr)(sigData.params.keyid);
+    } catch (e) {}
+
+    // Check if @path was in the signed components
+    var hasPathComponent = sigData.components.some(function (c) {
+      return c.replace(/"/g, "") === "@path";
+    });
+
+    // If @path is signed, add the path header to extracted components
+    if (hasPathComponent) {
+      extractedComponents["path"] = http.headers.path;
+    }
+
+    // Check if ao-result header is present
+    var aoResult = http.headers["ao-result"] || http.headers["Ao-Result"];
+
+    // Handle ao-result pointing to body
+    if (aoResult === "body") {
+      // Handle empty body case
+      if (!extractedComponents.body) {
+        return _objectSpread({
+          out: ""
+        }, ret); // Return empty string for empty body
+      }
+      // Check if body is binary data
+      if (isBinaryString(extractedComponents.body)) {
+        return _objectSpread({
+          out: stringToBuffer(extractedComponents.body)
+        }, ret);
+      }
+      // Return body as-is if it's not binary
+      return _objectSpread({
+        out: extractedComponents.body
+      }, ret);
+    }
+
+    // Convert the extracted components to JSON format
+    var result = _toJSON(extractedComponents);
+
+    // Handle ao-result if present and pointing to other fields
+    if (aoResult && aoResult !== "body") {
+      // Return the value of the key specified by ao-result
+      // If the key doesn't exist, return undefined (or could return null/empty string)
+      return _objectSpread({
+        out: result[aoResult] !== undefined ? result[aoResult] : ""
+      }, ret);
+    }
+    return _objectSpread({
+      out: result
+    }, ret);
+  }
+  return {
+    out: null,
+    hashpath: null
+  };
+};
+
+/**
+ * Extract all keys and signature information from HTTP signature message
+ * @param {Object} http - HTTP message object with headers and body
+ * @returns {Object} Object containing all extracted signature data
+ */
+var extractKeys = exports.extractKeys = function extractKeys(http) {
+  var result = {
+    signatures: {},
+    keys: {},
+    boundary: null,
+    requiresBody: false,
+    body: http.body ? toBuffer(http.body) : null,
+    bodyText: typeof http.body === "string" ? http.body : null
+  };
+
+  // Get multipart boundary if present
+  result.boundary = getBoundary(http);
+
+  // Get signature header
+  var signatureHeader = http.headers.signature || http.headers.Signature;
+  if (!signatureHeader) {
+    return result;
+  }
+
+  // Get signature-input header
+  var signatureInput = http.headers["signature-input"] || http.headers["Signature-Input"];
+  if (!signatureInput) {
+    return result;
+  }
+
+  // Decode all signature inputs
+  var inputs = (0, _signerUtils.decodeSigInput)(signatureInput);
+
+  // Parse signature header to extract actual signatures
+  // Format: sig1=:base64signature:, sig2=:base64signature:
+  var signatures = {};
+  var sigPattern = /([a-zA-Z0-9-]+)=:([^:]+):/g;
+  var match;
+  while ((match = sigPattern.exec(signatureHeader)) !== null) {
+    signatures[match[1]] = match[2];
+  }
+
+  // Process each signature
+  for (var _i10 = 0, _Object$entries1 = Object.entries(inputs); _i10 < _Object$entries1.length; _i10++) {
+    var _Object$entries1$_i = _slicedToArray(_Object$entries1[_i10], 2),
+      sigName = _Object$entries1$_i[0],
+      sigData = _Object$entries1$_i[1];
+    var extractedValues = extract(http, sigData.components);
+
+    // Check if body is required
+    if (extractedValues.__bodyRequired__) {
+      result.requiresBody = true;
+    }
+    var signatureInfo = {
+      name: sigName,
+      signature: signatures[sigName] || null,
+      components: sigData.components,
+      params: sigData.params,
+      extractedValues: extractedValues,
+      hasContentDigest: sigData.components.some(function (c) {
+        return c.replace(/"/g, "").toLowerCase() === "content-digest";
+      })
+    };
+
+    // If has content-digest, verify it
+    if (signatureInfo.hasContentDigest && result.body) {
+      var contentDigest = http.headers["content-digest"] || http.headers["Content-Digest"];
+      if (contentDigest) {
+        signatureInfo.contentDigestVerification = verifyContentDigest(contentDigest, result.body);
+      }
+    }
+
+    // Extract key information from params
+    if (sigData.params.keyid) {
+      try {
+        var keyBuffer = _base64url["default"].toBuffer(sigData.params.keyid);
+        result.keys[sigName] = {
+          keyid: sigData.params.keyid,
+          keyBuffer: keyBuffer,
+          algorithm: sigData.params.alg || "unknown"
+        };
+      } catch (e) {
+        // If keyid is not base64url encoded, store as-is
+        result.keys[sigName] = {
+          keyid: sigData.params.keyid,
+          algorithm: sigData.params.alg || "unknown"
+        };
+      }
+    }
+    result.signatures[sigName] = signatureInfo;
+  }
+  return result;
+};
+
+/**
+ * Verify if a message has valid HTTP signature structure
+ * @param {Object} http - HTTP message object
+ * @returns {boolean} True if message has valid signature structure
+ */
+var hasValidSignature = exports.hasValidSignature = function hasValidSignature(http) {
+  var hasSignature = (http.headers.signature || http.headers.Signature) !== undefined;
+  var hasSignatureInput = (http.headers["signature-input"] || http.headers["Signature-Input"]) !== undefined;
+  return hasSignature && hasSignatureInput;
+};
+
+/**
+ * Verify content-digest header against body
+ * @param {string} contentDigest - Content-Digest header value
+ * @param {string|Buffer} body - Request/response body
+ * @returns {Object} Verification result with digest info
+ */
+var verifyContentDigest = exports.verifyContentDigest = function verifyContentDigest(contentDigest, body) {
+  // Parse content-digest header format: algorithm=:base64digest:
+  var match = contentDigest.match(/([^=]+)=:([^:]+):/);
+  if (!match) {
+    return {
+      valid: false,
+      error: "Invalid content-digest format"
+    };
+  }
+  var _match3 = _slicedToArray(match, 3),
+    algorithm = _match3[1],
+    expectedDigest = _match3[2];
+  try {
+    // Convert body to Buffer if needed
+    var bodyBuffer = typeof body === "string" ? Buffer.from(body, "utf-8") : body;
+
+    // Calculate digest based on algorithm
+    var actualDigest;
+    var crypto = require("crypto");
+    if (algorithm === "sha-256") {
+      var hash = crypto.createHash("sha256");
+      hash.update(bodyBuffer);
+      actualDigest = hash.digest("base64");
+    } else if (algorithm === "sha-512") {
+      var _hash = crypto.createHash("sha512");
+      _hash.update(bodyBuffer);
+      actualDigest = _hash.digest("base64");
+    } else {
+      return {
+        valid: false,
+        error: "Unsupported algorithm: ".concat(algorithm)
+      };
+    }
+    return {
+      valid: actualDigest === expectedDigest,
+      algorithm: algorithm,
+      expectedDigest: expectedDigest,
+      actualDigest: actualDigest,
+      matches: actualDigest === expectedDigest
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error.message
+    };
+  }
+};
+
+/**
+ * Get all signature names from a message
+ * @param {Object} http - HTTP message object
+ * @returns {Array} Array of signature names
+ */
+var getSignatureNames = exports.getSignatureNames = function getSignatureNames(http) {
+  var signatureInput = http.headers["signature-input"] || http.headers["Signature-Input"];
+  if (!signatureInput) return [];
+  var inputs = (0, _signerUtils.decodeSigInput)(signatureInput);
+  return Object.keys(inputs);
+};