hbsig 0.0.1

package/cjs/bin_to_str.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = bin_to_str;
+/**
+ * Convert a Buffer to string if it contains valid UTF-8 text
+ * @param {Buffer} buffer - Buffer to check and potentially convert
+ * @returns {string|Buffer} - String if valid UTF-8, otherwise original Buffer
+ */
+function bin_to_str(buffer) {
+  if (!Buffer.isBuffer(buffer)) {
+    return buffer;
+  }
+
+  // Empty buffer stays as buffer
+  if (buffer.length === 0) {
+    return buffer;
+  }
+  try {
+    var str = buffer.toString("utf8");
+    // Check if it's valid UTF-8 by seeing if it round-trips correctly
+    if (Buffer.from(str, "utf8").equals(buffer)) {
+      // Additional check: ensure all characters are printable or common whitespace
+      // This prevents converting binary data that happens to be valid UTF-8
+      var isPrintable = true;
+      for (var i = 0; i < str.length; i++) {
+        var code = str.charCodeAt(i);
+        // Allow printable ASCII (32-126) and common whitespace (tab, newline, carriage return)
+        if (!(code >= 32 && code <= 126) && code !== 9 && code !== 10 && code !== 13) {
+          isPrintable = false;
+          break;
+        }
+      }
+      if (isPrintable) {
+        return str;
+      }
+    }
+  } catch (e) {
+    // Not valid UTF-8, return original buffer
+  }
+  return buffer;
+}

package/cjs/collect-body-keys.js

@@ -0,0 +1,470 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = collectBodyKeys;
+var _encodeUtils = require("./encode-utils.js");
+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 _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 _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), 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 _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; }
+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); }
+// Helper functions
+var isEmpty = function isEmpty(value) {
+  if (typeof value === "string") return value === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if ((0, _encodeUtils.isPojo)(value)) return Object.keys(value).length === 0;
+  if ((0, _encodeUtils.isBytes)(value)) return value.length === 0 || value.byteLength === 0;
+  return false;
+};
+var hasOnlyEmptyValues = function hasOnlyEmptyValues(obj) {
+  if (!(0, _encodeUtils.isPojo)(obj)) return false;
+  return Object.values(obj).every(function (v) {
+    return typeof v === "string" && v === "" || Array.isArray(v) && v.length === 0 || (0, _encodeUtils.isPojo)(v) && Object.keys(v).length === 0;
+  });
+};
+var isSimpleValue = function isSimpleValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || value === undefined || _typeof(value) === "symbol";
+};
+var getValueByPath = function getValueByPath(obj, path) {
+  var parts = path.split("/");
+  var value = obj;
+  var _iterator = _createForOfIteratorHelper(parts),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      if (/^\d+$/.test(part)) {
+        value = value[parseInt(part) - 1];
+      } else {
+        value = value[part];
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return value;
+};
+var canArrayBeInHeader = function canArrayBeInHeader(array) {
+  // Empty arrays can be in headers
+  if (array.length === 0) return true;
+
+  // Arrays with objects must go to body
+  if (array.some(function (item) {
+    return (0, _encodeUtils.isPojo)(item);
+  })) return false;
+
+  // Arrays with binary data must go to body
+  if (array.some(function (item) {
+    return (0, _encodeUtils.isBytes)(item) && item.length > 0;
+  })) return false;
+
+  // Arrays with non-ASCII strings must go to body
+  if (array.some(function (item) {
+    return typeof item === "string" && (0, _encodeUtils.hasNonAscii)(item);
+  })) return false;
+
+  // Arrays with nested arrays must go to body (to match original behavior)
+  if (array.some(function (item) {
+    return Array.isArray(item);
+  })) return false;
+
+  // Arrays with nested arrays that have objects must go to body
+  if (array.some(function (item) {
+    return Array.isArray(item) && item.some(function (subItem) {
+      return (0, _encodeUtils.isPojo)(subItem);
+    });
+  })) return false;
+
+  // Simple arrays of primitives can stay in headers
+  return true;
+};
+
+// Array analysis helper
+var analyzeArray = function analyzeArray(array) {
+  var analysis = {
+    hasObjects: false,
+    hasArrays: false,
+    hasNonObjects: false,
+    hasArraysOfObjects: false,
+    hasEmptyStrings: false,
+    hasEmptyObjects: false,
+    hasNonEmptyObjects: false,
+    hasObjectsWithOnlyEmptyValues: false,
+    hasOnlyEmptyElements: true
+  };
+  var _iterator2 = _createForOfIteratorHelper(array),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var item = _step2.value;
+      if ((0, _encodeUtils.isPojo)(item)) {
+        analysis.hasObjects = true;
+        if (Object.keys(item).length === 0) {
+          analysis.hasEmptyObjects = true;
+        } else {
+          analysis.hasNonEmptyObjects = true;
+          if (hasOnlyEmptyValues(item)) {
+            analysis.hasObjectsWithOnlyEmptyValues = true;
+          }
+        }
+      } else if (Array.isArray(item)) {
+        analysis.hasArrays = true;
+        if (item.some(function (subItem) {
+          return (0, _encodeUtils.isPojo)(subItem);
+        })) {
+          analysis.hasArraysOfObjects = true;
+        }
+      } else {
+        analysis.hasNonObjects = true;
+      }
+      if (typeof item === "string" && item === "") {
+        analysis.hasEmptyStrings = true;
+      }
+      if (!isEmpty(item)) {
+        analysis.hasOnlyEmptyElements = false;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return analysis;
+};
+
+// Body key collector class
+var BodyKeyCollector = /*#__PURE__*/function () {
+  function BodyKeyCollector(obj) {
+    _classCallCheck(this, BodyKeyCollector);
+    this.obj = obj;
+    this.keys = [];
+  }
+  return _createClass(BodyKeyCollector, [{
+    key: "collect",
+    value: function collect() {
+      this.processRootObject();
+      return this.deduplicateAndFilter();
+    }
+
+    // Process top-level object
+  }, {
+    key: "processRootObject",
+    value: function processRootObject() {
+      var objKeys = Object.keys(this.obj);
+      for (var _i = 0, _Object$entries = Object.entries(this.obj); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          key = _Object$entries$_i[0],
+          value = _Object$entries$_i[1];
+        if (this.isSpecialDataBodyField(key, value, objKeys)) {
+          this.keys.push(key);
+        } else if (Array.isArray(value) && value.length > 0) {
+          // Check if array can stay in header
+          if (!canArrayBeInHeader(value)) {
+            this.processRootArray(key, value);
+          }
+        } else if ((0, _encodeUtils.isPojo)(value)) {
+          this.processRootNestedObject(key, value);
+        } else if (this.needsBodyKey(key, value)) {
+          this.keys.push(key);
+        }
+      }
+    }
+
+    // Check if field is special data/body field
+  }, {
+    key: "isSpecialDataBodyField",
+    value: function isSpecialDataBodyField(key, value, objKeys) {
+      if ((key === "data" || key === "body") && isSimpleValue(value) && objKeys.length > 1) {
+        var otherKey = key === "data" ? "body" : "data";
+        var otherValue = this.obj[otherKey];
+        if (otherValue && (0, _encodeUtils.isPojo)(otherValue) && Object.keys(otherValue).length > 0) {
+          return false;
+        }
+        return true;
+      }
+      return false;
+    }
+
+    // Check if value needs a body key
+  }, {
+    key: "needsBodyKey",
+    value: function needsBodyKey(key, value) {
+      return (0, _encodeUtils.isBytes)(value) && value.length > 0 || typeof value === "string" && value.includes("\n") || typeof value === "string" && (0, _encodeUtils.hasNonAscii)(value);
+    }
+
+    // Process root-level arrays
+  }, {
+    key: "processRootArray",
+    value: function processRootArray(key, array) {
+      var _this = this;
+      var analysis = analyzeArray(array);
+      var bodyPartCounter = 1;
+      if (analysis.hasArraysOfObjects) {
+        // Handle arrays of arrays containing objects
+        array.forEach(function (item, index) {
+          if (Array.isArray(item)) {
+            item.forEach(function (subItem, subIndex) {
+              if ((0, _encodeUtils.isPojo)(subItem)) {
+                _this.keys.push("".concat(key, "/").concat(index + 1, "/").concat(subIndex + 1));
+              }
+            });
+          }
+        });
+        this.keys.push(key);
+      } else if (analysis.hasObjects && (analysis.hasEmptyStrings || analysis.hasEmptyObjects) && !analysis.hasObjectsWithOnlyEmptyValues) {
+        // Mixed array: only non-empty objects get parts
+        array.forEach(function (item) {
+          if ((0, _encodeUtils.isPojo)(item) && Object.keys(item).length > 0) {
+            var path = "".concat(key, "/").concat(bodyPartCounter);
+            _this.keys.push(path);
+            _this.addNestedObjectPaths(item, path);
+          }
+          bodyPartCounter++;
+        });
+        this.keys.push(key);
+      } else if (analysis.hasObjects) {
+        // Regular array with objects
+        var skipEmptyObjects = analysis.hasOnlyEmptyElements;
+        array.forEach(function (item) {
+          if ((0, _encodeUtils.isPojo)(item)) {
+            if (!(skipEmptyObjects && Object.keys(item).length === 0)) {
+              var path = "".concat(key, "/").concat(bodyPartCounter);
+              _this.keys.push(path);
+              if (Object.keys(item).length > 0) {
+                _this.addNestedObjectPaths(item, path);
+              }
+            }
+          } else if (typeof item === "string" && item === "") {
+            _this.keys.push("".concat(key, "/").concat(bodyPartCounter));
+          }
+          bodyPartCounter++;
+        });
+
+        // Add main array key conditionally
+        if (!analysis.hasObjectsWithOnlyEmptyValues || analysis.hasNonObjects) {
+          if (!analysis.hasOnlyEmptyElements) {
+            this.keys.push(key);
+          }
+        }
+      } else {
+        // Simple array without objects
+        var hasOnlyEmptyArraysOrObjects = array.every(function (item) {
+          return isEmpty(item) && (Array.isArray(item) || (0, _encodeUtils.isPojo)(item) || typeof item === "string");
+        });
+        if (hasOnlyEmptyArraysOrObjects || !array.every(isEmpty)) {
+          this.keys.push(key);
+        }
+      }
+    }
+
+    // Add paths for nested objects within an object
+  }, {
+    key: "addNestedObjectPaths",
+    value: function addNestedObjectPaths(obj, basePath) {
+      for (var _i2 = 0, _Object$entries2 = Object.entries(obj); _i2 < _Object$entries2.length; _i2++) {
+        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          nestedKey = _Object$entries2$_i[0],
+          nestedValue = _Object$entries2$_i[1];
+        if ((0, _encodeUtils.isPojo)(nestedValue) && Object.keys(nestedValue).length > 0) {
+          this.keys.push("".concat(basePath, "/").concat(nestedKey));
+        }
+      }
+    }
+
+    // Process root-level nested object
+  }, {
+    key: "processRootNestedObject",
+    value: function processRootNestedObject(key, obj) {
+      // Check for arrays with only empty elements
+      for (var _i3 = 0, _Object$entries3 = Object.entries(obj); _i3 < _Object$entries3.length; _i3++) {
+        var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+          k = _Object$entries3$_i[0],
+          v = _Object$entries3$_i[1];
+        if (Array.isArray(v) && v.length > 0 && v.every(isEmpty)) {
+          this.keys.push("".concat(key, "/").concat(k));
+        }
+      }
+
+      // Traverse the object
+      this.traverse(obj, key);
+    }
+
+    // Traverse nested structures
+  }, {
+    key: "traverse",
+    value: function traverse(current, path) {
+      var hasSimpleFields = false;
+      var nestedPaths = [];
+      var hasArraysWithObjects = false;
+
+      // First pass: analyze structure
+      for (var _i4 = 0, _Object$entries4 = Object.entries(current); _i4 < _Object$entries4.length; _i4++) {
+        var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
+          key = _Object$entries4$_i[0],
+          value = _Object$entries4$_i[1];
+        var fullPath = path ? "".concat(path, "/").concat(key) : key;
+        var result = this.analyzeFieldInTraversal(value, fullPath, nestedPaths);
+        hasSimpleFields = hasSimpleFields || result.hasSimpleFields;
+        hasArraysWithObjects = hasArraysWithObjects || result.hasArraysWithObjects;
+      }
+
+      // Add current path if needed
+      if (hasSimpleFields || hasArraysWithObjects && path) {
+        this.keys.push(path);
+      }
+
+      // Second pass: check for arrays with only empty elements
+      for (var _i5 = 0, _Object$entries5 = Object.entries(current); _i5 < _Object$entries5.length; _i5++) {
+        var _Object$entries5$_i = _slicedToArray(_Object$entries5[_i5], 2),
+          _key = _Object$entries5$_i[0],
+          _value = _Object$entries5$_i[1];
+        var _fullPath = path ? "".concat(path, "/").concat(_key) : _key;
+        if (Array.isArray(_value) && _value.length > 0 && _value.every(isEmpty)) {
+          this.keys.push(_fullPath);
+        }
+      }
+
+      // Traverse nested objects
+      for (var _i6 = 0, _nestedPaths = nestedPaths; _i6 < _nestedPaths.length; _i6++) {
+        var nestedPath = _nestedPaths[_i6];
+        var nestedObj = getValueByPath(this.obj, nestedPath);
+        if ((0, _encodeUtils.isPojo)(nestedObj)) {
+          this.traverse(nestedObj, nestedPath);
+        }
+      }
+    }
+
+    // Analyze a field during traversal
+  }, {
+    key: "analyzeFieldInTraversal",
+    value: function analyzeFieldInTraversal(value, fullPath, nestedPaths) {
+      var hasSimpleFields = false;
+      var hasArraysWithObjects = false;
+      if (Array.isArray(value)) {
+        if (value.length === 0) {
+          hasSimpleFields = true;
+        } else {
+          var analysis = analyzeArray(value);
+          if (analysis.hasObjects) {
+            hasArraysWithObjects = true;
+            this.processArrayInTraversal(value, fullPath, nestedPaths, analysis);
+            if (analysis.hasNonObjects) {
+              hasSimpleFields = true;
+              // Only add to keys if array can't be in header
+              if (!canArrayBeInHeader(value)) {
+                this.keys.push(fullPath);
+              }
+            }
+          } else {
+            hasSimpleFields = true;
+          }
+        }
+      } else if ((0, _encodeUtils.isPojo)(value)) {
+        if (Object.keys(value).length === 0) {
+          hasSimpleFields = true;
+        } else if (hasOnlyEmptyValues(value)) {
+          this.keys.push(fullPath);
+        } else {
+          var hasArraysWithOnlyEmptyElements = Object.entries(value).some(function (_ref) {
+            var _ref2 = _slicedToArray(_ref, 2),
+              k = _ref2[0],
+              v = _ref2[1];
+            return Array.isArray(v) && v.length > 0 && v.every(isEmpty);
+          });
+          if (hasArraysWithOnlyEmptyElements) {
+            this.keys.push(fullPath);
+          }
+          nestedPaths.push(fullPath);
+        }
+      } else if ((0, _encodeUtils.isBytes)(value) && value.length > 0 || isSimpleValue(value)) {
+        hasSimpleFields = true;
+      }
+      return {
+        hasSimpleFields: hasSimpleFields,
+        hasArraysWithObjects: hasArraysWithObjects
+      };
+    }
+
+    // Process arrays found during traversal
+  }, {
+    key: "processArrayInTraversal",
+    value: function processArrayInTraversal(array, fullPath, nestedPaths, analysis) {
+      var _this2 = this;
+      if ((analysis.hasEmptyStrings || analysis.hasEmptyObjects) && analysis.hasNonEmptyObjects) {
+        // Special case: only non-empty objects get parts
+        array.forEach(function (item, index) {
+          if ((0, _encodeUtils.isPojo)(item) && Object.keys(item).length > 0) {
+            var itemPath = "".concat(fullPath, "/").concat(index + 1);
+            _this2.keys.push(itemPath);
+            nestedPaths.push(itemPath);
+          }
+        });
+      } else if (analysis.hasObjectsWithOnlyEmptyValues && !analysis.hasNonObjects) {
+        // Objects with only empty values
+        array.forEach(function (item, index) {
+          if ((0, _encodeUtils.isPojo)(item)) {
+            var itemPath = "".concat(fullPath, "/").concat(index + 1);
+            _this2.keys.push(itemPath);
+            if (Object.keys(item).length > 0) {
+              nestedPaths.push(itemPath);
+            }
+          }
+        });
+      } else {
+        // Normal case
+        array.forEach(function (item, index) {
+          if ((0, _encodeUtils.isPojo)(item)) {
+            var itemPath = "".concat(fullPath, "/").concat(index + 1);
+            _this2.keys.push(itemPath);
+            if (Object.keys(item).length > 0) {
+              nestedPaths.push(itemPath);
+            }
+          }
+        });
+      }
+    }
+
+    // Deduplicate and filter results
+  }, {
+    key: "deduplicateAndFilter",
+    value: function deduplicateAndFilter() {
+      var _this3 = this;
+      var uniqueKeys = _toConsumableArray(new Set(this.keys));
+      return uniqueKeys.filter(function (k) {
+        if (!k) return false;
+
+        // Check if this is a path to an element inside an array with only empty elements
+        var parts = k.split("/");
+        if (parts.length >= 2 && /^\d+$/.test(parts[parts.length - 1])) {
+          var arrayPath = parts.slice(0, -1).join("/");
+          var arrayValue = getValueByPath(_this3.obj, arrayPath);
+          if (Array.isArray(arrayValue) && arrayValue.every(isEmpty)) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+  }]);
+}();
+function collectBodyKeys(obj) {
+  var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+  var collector = new BodyKeyCollector(obj);
+  return collector.collect();
+}

package/cjs/encode-array-item.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = encodeArrayItem;
+var _encodeUtils = require("./encode-utils.js");
+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); }
+// Helper to generate the correct number of backslashes for a given nesting level
+function getBackslashes(level) {
+  return "\\".repeat(Math.pow(2, level) - 1);
+}
+
+// Helper to encode primitive values at a specific nesting level
+function encodePrimitiveAtLevel(value, level) {
+  var bs = getBackslashes(level);
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) {
+      return "".concat(bs, "\"(ao-type-integer) ").concat(value).concat(bs, "\"");
+    } else {
+      return "".concat(bs, "\"(ao-type-float) ").concat((0, _encodeUtils.formatFloat)(value)).concat(bs, "\"");
+    }
+  } else if (typeof value === "string") {
+    return "".concat(bs, "\"").concat(value).concat(bs, "\"");
+  } else if (value === null) {
+    var innerBs = getBackslashes(level + 1);
+    return "".concat(bs, "\"(ao-type-atom) ").concat(innerBs, "\"null").concat(innerBs, "\"").concat(bs, "\"");
+  } else if (value === undefined) {
+    var _innerBs = getBackslashes(level + 1);
+    return "".concat(bs, "\"(ao-type-atom) ").concat(_innerBs, "\"undefined").concat(_innerBs, "\"").concat(bs, "\"");
+  } else if (_typeof(value) === "symbol") {
+    var desc = value.description || "Symbol.for()";
+    var _innerBs2 = getBackslashes(level + 1);
+    return "".concat(bs, "\"(ao-type-atom) ").concat(_innerBs2, "\"").concat(desc).concat(_innerBs2, "\"").concat(bs, "\"");
+  } else if (typeof value === "boolean") {
+    var _innerBs3 = getBackslashes(level + 1);
+    return "".concat(bs, "\"(ao-type-atom) ").concat(_innerBs3, "\"").concat(value).concat(_innerBs3, "\"").concat(bs, "\"");
+  } else {
+    return "".concat(bs, "\"").concat(String(value)).concat(bs, "\"");
+  }
+}
+
+// Recursive function to handle arrays at any nesting level
+function encodeArrayAtLevel(items, level) {
+  // The original code only goes 3 levels deep for arrays
+  if (level >= 3) {
+    var bs = getBackslashes(level);
+    var stringItems = items.map(function (item) {
+      if (typeof item === "number") {
+        if (Number.isInteger(item)) {
+          return "".concat(bs, "\"(ao-type-integer) ").concat(item).concat(bs, "\"");
+        } else {
+          return "".concat(bs, "\"(ao-type-float) ").concat((0, _encodeUtils.formatFloat)(item)).concat(bs, "\"");
+        }
+      } else if (typeof item === "string") {
+        return "".concat(bs, "\"").concat(item).concat(bs, "\"");
+      } else {
+        return "".concat(bs, "\"").concat(String(item)).concat(bs, "\"");
+      }
+    }).join(", ");
+    return "".concat(getBackslashes(level - 1), "\"(ao-type-list) ").concat(stringItems).concat(getBackslashes(level - 1), "\"");
+  }
+  var encodedItems = items.map(function (item) {
+    if (Array.isArray(item)) {
+      return encodeArrayAtLevel(item, level + 1);
+    } else {
+      return encodePrimitiveAtLevel(item, level);
+    }
+  }).join(", ");
+  if (level === 0) {
+    return "\"(ao-type-list) ".concat(encodedItems, "\"");
+  } else {
+    var _bs = getBackslashes(level - 1);
+    return "".concat(_bs, "\"(ao-type-list) ").concat(encodedItems).concat(_bs, "\"");
+  }
+}
+function encodeArrayItem(item) {
+  if (typeof item === "number") {
+    if (Number.isInteger(item)) {
+      return "\"(ao-type-integer) ".concat(item, "\"");
+    } else {
+      return "\"(ao-type-float) ".concat((0, _encodeUtils.formatFloat)(item), "\"");
+    }
+  } else if (typeof item === "string") {
+    return "\"".concat(item, "\"");
+  } else if (item === null) {
+    return "\"(ao-type-atom) \\\"null\\\"\"";
+  } else if (item === undefined) {
+    return "\"(ao-type-atom) \\\"undefined\\\"\"";
+  } else if (_typeof(item) === "symbol") {
+    var desc = item.description || "Symbol.for()";
+    return "\"(ao-type-atom) \\\"".concat(desc, "\\\"\"");
+  } else if (typeof item === "boolean") {
+    return "\"(ao-type-atom) \\\"".concat(item, "\\\"\"");
+  } else if (Array.isArray(item)) {
+    return encodeArrayAtLevel(item, 1);
+  } else if ((0, _encodeUtils.isBytes)(item)) {
+    var buffer = (0, _encodeUtils.toBuffer)(item);
+    if (buffer.length === 0 || buffer.byteLength === 0) {
+      return "\"\"";
+    }
+    return "\"(ao-type-binary)\"";
+  } else if ((0, _encodeUtils.isPojo)(item)) {
+    var json = JSON.stringify(item);
+    var escaped = json.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return "\"(ao-type-map) ".concat(escaped, "\"");
+  } else {
+    return "\"".concat(String(item), "\"");
+  }
+}