wao 0.36.6 → 0.37.0

package/cjs/httpsig-utils.js

@@ -1,1159 +0,0 @@
-"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 _hbsig = require("hbsig");
-var _base64url = _interopRequireDefault(require("base64url"));
-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, _hbsig.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 _i10 = 0, _Object$entries10 = Object.entries(obj); _i10 < _Object$entries10.length; _i10++) {
-        var _Object$entries10$_i = _slicedToArray(_Object$entries10[_i10], 2),
-          key = _Object$entries10$_i[0],
-          value = _Object$entries10$_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 _i11 = 0, _Object$keys = Object.keys(obj); _i11 < _Object$keys.length; _i11++) {
-    var key = _Object$keys[_i11];
-    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, _hbsig.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, _hbsig.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, _hbsig.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 _i12 = 0, _Object$entries11 = Object.entries(inputs); _i12 < _Object$entries11.length; _i12++) {
-    var _Object$entries11$_i = _slicedToArray(_Object$entries11[_i12], 2),
-      sigName = _Object$entries11$_i[0],
-      sigData = _Object$entries11$_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, _hbsig.decodeSigInput)(signatureInput);
-  return Object.keys(inputs);
-};