hbsig 0.0.1

package/cjs/erl_str.js

@@ -0,0 +1,1037 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.erl_str_from = erl_str_from;
+exports.erl_str_to = erl_str_to;
+exports.parse_body = parse_body;
+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 _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 _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 _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 _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 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); }
+/**
+ * Erlang term string parser and formatter
+ * Converts between Erlang term strings and JavaScript values
+ */
+
+/**
+ * Parse an Erlang term string into JavaScript values
+ * @param {string} str - Erlang term string
+ * @param {boolean} binaryMode - If true, keep binaries as Buffers; if false, convert to strings
+ * @returns {*} JavaScript value
+ */
+function erl_str_from(str) {
+  var binaryMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  // Handle the new response format
+  if (str.startsWith("#erl_response{")) {
+    var rawMatch = str.match(/#erl_response\{raw=([^]*?),formatted=([^]*?)\}$/);
+    if (rawMatch && rawMatch[1] && rawMatch[2]) {
+      var rawStr = rawMatch[1];
+      var formattedStr = rawMatch[2];
+      if (binaryMode) {
+        // In binary mode, just parse formatted
+        var _parser = new ErlangParser(formattedStr, true);
+        return _parser.parse();
+      } else {
+        // Build a type map from raw, then parse formatted with type info
+        var typeMap = buildTypeMap(rawStr);
+        var _parser2 = new TypeAwareParser(formattedStr, typeMap);
+        return _parser2.parse();
+      }
+    }
+  }
+
+  // Fallback for non-response format
+  var parser = new ErlangParser(str, binaryMode);
+  return parser.parse();
+}
+
+/**
+ * Parse body field specially - convert to string only for multipart bodies
+ * @param {*} parsed - Parsed Erlang term object
+ * @returns {*} Object with body field potentially converted to string
+ */
+function parse_body(parsed) {
+  if (!parsed || _typeof(parsed) !== "object") {
+    return parsed;
+  }
+
+  // If there's a body field
+  if ("body" in parsed) {
+    if (Buffer.isBuffer(parsed.body)) {
+      // Check if this looks like a multipart body
+      // Multipart bodies start with "--" boundary
+      var bodyStart = parsed.body.toString("binary", 0, Math.min(100, parsed.body.length));
+      if (bodyStart.startsWith("--") && parsed["content-type"] && parsed["content-type"].includes("multipart")) {
+        // It's a multipart body, convert to string
+        return _objectSpread(_objectSpread({}, parsed), {}, {
+          body: parsed.body.toString("binary")
+        });
+      }
+      // Not multipart, keep as Buffer
+      return parsed;
+    }
+    // Already a string, return as-is
+    return parsed;
+  }
+  return parsed;
+}
+
+// Build a map of paths to types by analyzing the raw string
+function buildTypeMap(rawStr) {
+  var typeMap = new Map();
+  function detectBinaryType(str, startPos) {
+    // Check what follows <<
+    var pos = startPos + 2;
+    while (pos < str.length && /\s/.test(str[pos])) pos++;
+    if (pos < str.length && str[pos] === '"') {
+      // It looks like a string, but check if it has escape sequences
+      // If it has \NNN octal escapes, it's actually a binary that Erlang formatted as string
+      var scanPos = pos + 1;
+      var hasOctalEscapes = false;
+      while (scanPos < str.length && !(str[scanPos] === '"' && str[scanPos + 1] === ">" && str[scanPos + 2] === ">")) {
+        if (str[scanPos] === "\\" && scanPos + 1 < str.length) {
+          var nextChar = str[scanPos + 1];
+          // Check for octal escape \NNN
+          if (/[0-7]/.test(nextChar)) {
+            hasOctalEscapes = true;
+            break;
+          }
+          scanPos += 2;
+        } else {
+          scanPos++;
+        }
+      }
+
+      // If it has octal escapes, treat as binary
+      if (hasOctalEscapes) {
+        return "binary";
+      }
+      return "string";
+    }
+    return "binary";
+  }
+  function scanValue(str, pos, path) {
+    while (pos < str.length && /\s/.test(str[pos])) pos++;
+    if (pos >= str.length) return pos;
+    if (str[pos] === "#" && str[pos + 1] === "{") {
+      // Map
+      pos += 2;
+      var mapIndex = 0;
+      while (pos < str.length) {
+        while (pos < str.length && /\s/.test(str[pos])) pos++;
+        if (str[pos] === "}") return pos + 1;
+
+        // Parse key
+        var keyStart = pos;
+        if (str[pos] === "<" && str[pos + 1] === "<") {
+          // Binary key
+          var keyType = detectBinaryType(str, pos);
+          var keyEnd = pos + 2;
+          if (keyType === "string") {
+            keyEnd++; // skip "
+            while (keyEnd < str.length && !(str[keyEnd] === '"' && str[keyEnd + 1] === ">" && str[keyEnd + 2] === ">")) {
+              if (str[keyEnd] === "\\") keyEnd++;
+              keyEnd++;
+            }
+            keyEnd += 3;
+          } else {
+            var depth = 1;
+            while (depth > 0 && keyEnd < str.length) {
+              if (str[keyEnd] === "<" && str[keyEnd + 1] === "<") {
+                depth++;
+                keyEnd += 2;
+              } else if (str[keyEnd] === ">" && str[keyEnd + 1] === ">") {
+                depth--;
+                keyEnd += 2;
+              } else {
+                keyEnd++;
+              }
+            }
+          }
+          pos = keyEnd;
+        } else {
+          // Regular key
+          while (pos < str.length && !/[\s=,}]/.test(str[pos])) pos++;
+        }
+
+        // Skip =>
+        while (pos < str.length && /\s/.test(str[pos])) pos++;
+        if (str[pos] === "=" && str[pos + 1] === ">") pos += 2;
+        while (pos < str.length && /\s/.test(str[pos])) pos++;
+
+        // Parse value and record type if binary
+        if (str[pos] === "<" && str[pos + 1] === "<") {
+          var type = detectBinaryType(str, pos);
+          var pathKey = [].concat(_toConsumableArray(path), [mapIndex]).join(".");
+          typeMap.set(pathKey, type);
+        }
+        pos = scanValue(str, pos, [].concat(_toConsumableArray(path), [mapIndex]));
+        mapIndex++;
+
+        // Skip comma
+        while (pos < str.length && /\s/.test(str[pos])) pos++;
+        if (str[pos] === ",") pos++;
+      }
+    } else if (str[pos] === "<" && str[pos + 1] === "<") {
+      // Binary
+      var _type = detectBinaryType(str, pos);
+      var _pathKey = path.join(".");
+      typeMap.set(_pathKey, _type);
+      pos += 2;
+      if (_type === "string" || str[pos] === '"') {
+        // Skip past string literal
+        if (str[pos] === '"') pos++; // skip opening quote
+        while (pos < str.length && !(str[pos] === '"' && str[pos + 1] === ">" && str[pos + 2] === ">")) {
+          if (str[pos] === "\\") pos++;
+          pos++;
+        }
+        return pos + 3;
+      } else {
+        var _depth = 1;
+        while (_depth > 0 && pos < str.length) {
+          if (str[pos] === "<" && str[pos + 1] === "<") {
+            _depth++;
+            pos += 2;
+          } else if (str[pos] === ">" && str[pos + 1] === ">") {
+            _depth--;
+            pos += 2;
+          } else {
+            pos++;
+          }
+        }
+        return pos;
+      }
+    } else if (str[pos] === "[") {
+      // List
+      pos++;
+      var listIndex = 0;
+      while (pos < str.length) {
+        while (pos < str.length && /\s/.test(str[pos])) pos++;
+        if (str[pos] === "]") return pos + 1;
+        pos = scanValue(str, pos, [].concat(_toConsumableArray(path), [listIndex]));
+        listIndex++;
+        while (pos < str.length && /\s/.test(str[pos])) pos++;
+        if (str[pos] === ",") pos++;
+      }
+    } else {
+      // Skip other values
+      while (pos < str.length && !/[\s,\]}=>]/.test(str[pos])) {
+        pos++;
+      }
+      return pos;
+    }
+    return pos;
+  }
+  scanValue(rawStr, 0, []);
+  return typeMap;
+}
+
+// Parser that uses type information
+var TypeAwareParser = /*#__PURE__*/function () {
+  function TypeAwareParser(str, typeMap) {
+    _classCallCheck(this, TypeAwareParser);
+    this.str = str;
+    this.typeMap = typeMap;
+    this.pos = 0;
+    this.path = [];
+  }
+  return _createClass(TypeAwareParser, [{
+    key: "parse",
+    value: function parse() {
+      var result = this.parseValue();
+      this.skipWhitespace();
+      if (this.pos < this.str.length) {
+        throw new Error("Unexpected content at position ".concat(this.pos));
+      }
+      return result;
+    }
+  }, {
+    key: "peek",
+    value: function peek() {
+      var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      return this.str[this.pos + offset] || "";
+    }
+  }, {
+    key: "advance",
+    value: function advance() {
+      var count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      this.pos += count;
+    }
+  }, {
+    key: "skipWhitespace",
+    value: function skipWhitespace() {
+      while (this.pos < this.str.length && /\s/.test(this.peek())) {
+        this.advance();
+      }
+    }
+  }, {
+    key: "parseValue",
+    value: function parseValue() {
+      this.skipWhitespace();
+      var ch = this.peek();
+      var ch2 = this.peek(1);
+      if (ch === "#" && ch2 === "{") {
+        return this.parseMap();
+      }
+      if (ch === "<" && ch2 === "<") {
+        return this.parseBinary();
+      }
+      if (ch === "[") {
+        return this.parseList();
+      }
+      if (ch === "'") {
+        return this.parseQuotedAtom();
+      }
+      if (ch === '"') {
+        return this.parseQuotedString();
+      }
+      return this.parseAtomOrNumber();
+    }
+  }, {
+    key: "parseMap",
+    value: function parseMap() {
+      this.advance(2); // skip #{
+      var map = {};
+      var mapIndex = 0;
+      while (true) {
+        this.skipWhitespace();
+        if (this.peek() === "}") {
+          this.advance();
+          break;
+        }
+        this.path.push(mapIndex);
+        var key = this.parseValue();
+        this.path.pop();
+        this.skipWhitespace();
+        if (this.peek() !== "=" || this.peek(1) !== ">") {
+          throw new Error("Expected =>");
+        }
+        this.advance(2);
+        this.skipWhitespace();
+        this.path.push(mapIndex);
+        var value = this.parseValue();
+        this.path.pop();
+        var jsKey = key instanceof Buffer ? key.toString("utf8") : _typeof(key) === "symbol" ? Symbol.keyFor(key) || String(key) : String(key);
+        map[jsKey] = value;
+        mapIndex++;
+        this.skipWhitespace();
+        if (this.peek() === ",") {
+          this.advance();
+        }
+      }
+      return map;
+    }
+  }, {
+    key: "parseBinary",
+    value: function parseBinary() {
+      var currentPath = this.path.join(".");
+      var type = this.typeMap.get(currentPath) || "binary";
+
+      // Parse the formatted version (always byte format)
+      this.advance(2); // skip <<
+
+      if (this.peek() === ">" && this.peek(1) === ">") {
+        this.advance(2);
+        return Buffer.alloc(0);
+      }
+      var bytes = [];
+      while (!(this.peek() === ">" && this.peek(1) === ">")) {
+        this.skipWhitespace();
+        var num = "";
+        while (/\d/.test(this.peek())) {
+          num += this.peek();
+          this.advance();
+        }
+        if (num) bytes.push(parseInt(num, 10));
+        this.skipWhitespace();
+        if (this.peek() === ",") this.advance();
+      }
+      this.advance(2); // skip >>
+
+      var buffer = Buffer.from(bytes);
+
+      // If it was a string literal in raw, convert to string
+      if (type === "string") {
+        return buffer.toString("utf8");
+      }
+
+      // For binaries that are not explicitly marked as strings, check if they're valid UTF-8
+      // that contains reasonable string content (no control characters except \t, \n, \r)
+      try {
+        var str = buffer.toString("utf8");
+        // Check if the string round-trips correctly
+        if (Buffer.from(str, "utf8").equals(buffer)) {
+          // It's valid UTF-8, but also check if it contains reasonable characters
+          var hasReasonableChars = true;
+          for (var i = 0; i < str.length; i++) {
+            var code = str.charCodeAt(i);
+            // Allow printable chars, space, tab, newline, carriage return, and Unicode
+            if (code < 0x20 && code !== 0x09 && code !== 0x0a && code !== 0x0d) {
+              hasReasonableChars = false;
+              break;
+            }
+          }
+          if (hasReasonableChars) {
+            return str;
+          }
+        }
+      } catch (e) {
+        // Not valid UTF-8, keep as buffer
+      }
+      return buffer;
+    }
+  }, {
+    key: "parseQuotedString",
+    value: function parseQuotedString() {
+      this.advance(); // skip opening "
+      var str = "";
+      while (this.peek() !== '"') {
+        if (this.peek() === "\\") {
+          this.advance();
+          var escaped = this.peek();
+          switch (escaped) {
+            case '"':
+              str += '"';
+              break;
+            case "\\":
+              str += "\\";
+              break;
+            case "n":
+              str += "\n";
+              break;
+            case "r":
+              str += "\r";
+              break;
+            case "t":
+              str += "\t";
+              break;
+            default:
+              str += escaped;
+          }
+          this.advance();
+        } else {
+          str += this.peek();
+          this.advance();
+        }
+      }
+      this.advance(); // skip closing "
+      return str;
+    }
+  }, {
+    key: "parseList",
+    value: function parseList() {
+      this.advance(); // skip [
+      var list = [];
+      var listIndex = 0;
+      while (true) {
+        this.skipWhitespace();
+        if (this.peek() === "]") {
+          this.advance();
+          break;
+        }
+        this.path.push(listIndex);
+        list.push(this.parseValue());
+        this.path.pop();
+        listIndex++;
+        this.skipWhitespace();
+        if (this.peek() === ",") {
+          this.advance();
+        }
+      }
+      return list;
+    }
+  }, {
+    key: "parseQuotedAtom",
+    value: function parseQuotedAtom() {
+      this.advance(); // skip '
+
+      var atom = "";
+      while (this.peek() !== "'") {
+        if (this.peek() === "\\") {
+          this.advance();
+          var escaped = this.peek();
+          switch (escaped) {
+            case "'":
+              atom += "'";
+              break;
+            case "\\":
+              atom += "\\";
+              break;
+            case "n":
+              atom += "\n";
+              break;
+            case "r":
+              atom += "\r";
+              break;
+            case "t":
+              atom += "\t";
+              break;
+            default:
+              atom += escaped;
+          }
+          this.advance();
+        } else {
+          atom += this.peek();
+          this.advance();
+        }
+      }
+      this.advance(); // skip closing '
+
+      if (atom === "null") return null;
+      if (atom === "true") return true;
+      if (atom === "false") return false;
+      return Symbol["for"](atom);
+    }
+  }, {
+    key: "parseAtomOrNumber",
+    value: function parseAtomOrNumber() {
+      var token = "";
+
+      // Parse unquoted atom/number
+      while (this.pos < this.str.length) {
+        var ch = this.peek();
+        if (ch === "," || ch === "]" || ch === "}" || ch === ")" || ch === "=" && this.peek(1) === ">") {
+          break;
+        }
+        if (/\s/.test(ch)) {
+          var i = this.pos;
+          while (i < this.str.length && /\s/.test(this.str[i])) i++;
+          if (i >= this.str.length) break;
+          var nextCh = this.str[i];
+          if (nextCh === "," || nextCh === "]" || nextCh === "}" || nextCh === ")" || nextCh === "=" && i + 1 < this.str.length && this.str[i + 1] === ">") {
+            break;
+          }
+        }
+        token += ch;
+        this.advance();
+      }
+      token = token.trim();
+      if (token === "null") return null;
+      if (token === "true") return true;
+      if (token === "false") return false;
+      if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(token)) {
+        return parseFloat(token);
+      }
+      return Symbol["for"](token);
+    }
+  }]);
+}(); // Parser implementation
+var ErlangParser = /*#__PURE__*/function () {
+  function ErlangParser(str) {
+    var binaryMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, ErlangParser);
+    this.str = str;
+    this.pos = 0;
+    this.binaryMode = binaryMode;
+  }
+  return _createClass(ErlangParser, [{
+    key: "parse",
+    value: function parse() {
+      var result = this.parseValue();
+      this.skipWhitespace();
+      if (this.pos < this.str.length) {
+        throw new Error("Unexpected content at position ".concat(this.pos, ": ").concat(this.str.slice(this.pos, this.pos + 50)));
+      }
+      return result;
+    }
+  }, {
+    key: "peek",
+    value: function peek() {
+      var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      return this.str[this.pos + offset] || "";
+    }
+  }, {
+    key: "advance",
+    value: function advance() {
+      var count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      this.pos += count;
+    }
+  }, {
+    key: "skipWhitespace",
+    value: function skipWhitespace() {
+      while (this.pos < this.str.length && /\s/.test(this.peek())) {
+        this.advance();
+      }
+    }
+  }, {
+    key: "parseValue",
+    value: function parseValue() {
+      this.skipWhitespace();
+      var ch = this.peek();
+      var ch2 = this.peek(1);
+
+      // Map: #{...}
+      if (ch === "#" && ch2 === "{") {
+        return this.parseMap();
+      }
+
+      // Binary: <<...>>
+      if (ch === "<" && ch2 === "<") {
+        return this.parseBinary();
+      }
+
+      // List: [...]
+      if (ch === "[") {
+        return this.parseList();
+      }
+
+      // Quoted atom: 'atom'
+      if (ch === "'") {
+        return this.parseQuotedAtom();
+      }
+
+      // Quoted string: "..."
+      if (ch === '"') {
+        return this.parseQuotedString();
+      }
+
+      // Number or unquoted atom
+      return this.parseAtomOrNumber();
+    }
+  }, {
+    key: "parseMap",
+    value: function parseMap() {
+      this.advance(2); // skip #{
+      var map = {};
+      while (true) {
+        this.skipWhitespace();
+        if (this.peek() === "}") {
+          this.advance();
+          break;
+        }
+
+        // Parse key
+        var key = this.parseValue();
+        this.skipWhitespace();
+
+        // Expect =>
+        if (this.peek() !== "=" || this.peek(1) !== ">") {
+          throw new Error("Expected => at position ".concat(this.pos));
+        }
+        this.advance(2);
+        this.skipWhitespace();
+
+        // Parse value
+        var value = this.parseValue();
+
+        // Convert key to string
+        var jsKey = void 0;
+        if (key instanceof Buffer) {
+          jsKey = key.toString("utf8");
+        } else if (_typeof(key) === "symbol") {
+          jsKey = Symbol.keyFor(key) || key.description || String(key);
+        } else {
+          jsKey = String(key);
+        }
+        map[jsKey] = value;
+        this.skipWhitespace();
+        if (this.peek() === ",") {
+          this.advance();
+        }
+      }
+      return map;
+    }
+  }, {
+    key: "parseBinary",
+    value: function parseBinary() {
+      this.advance(2); // skip <<
+
+      // String binary: <<"...">>
+      if (this.peek() === '"') {
+        this.advance(); // skip "
+        var content = "";
+        while (!(this.peek() === '"' && this.peek(1) === ">" && this.peek(2) === ">")) {
+          if (this.pos >= this.str.length) {
+            throw new Error("Unterminated string binary");
+          }
+          if (this.peek() === "\\") {
+            this.advance();
+            var escaped = this.peek();
+
+            // Check for octal escape sequences \NNN
+            if (/[0-7]/.test(escaped)) {
+              var octal = escaped;
+              this.advance();
+
+              // Get up to 2 more octal digits
+              if (/[0-7]/.test(this.peek())) {
+                octal += this.peek();
+                this.advance();
+                if (/[0-7]/.test(this.peek())) {
+                  octal += this.peek();
+                  this.advance();
+                }
+              }
+
+              // Convert octal to character
+              var charCode = parseInt(octal, 8);
+              content += String.fromCharCode(charCode);
+            } else {
+              // Regular escape sequences
+              switch (escaped) {
+                case '"':
+                  content += '"';
+                  break;
+                case "\\":
+                  content += "\\";
+                  break;
+                case "n":
+                  content += "\n";
+                  break;
+                case "r":
+                  content += "\r";
+                  break;
+                case "t":
+                  content += "\t";
+                  break;
+                default:
+                  content += escaped;
+              }
+              this.advance();
+            }
+          } else {
+            content += this.peek();
+            this.advance();
+          }
+        }
+        this.advance(3); // skip ">>
+
+        // Check for structured field format
+        if (content.startsWith(":") && content.endsWith(":") && content.length >= 2) {
+          if (content === "::") {
+            return Buffer.alloc(0);
+          }
+          try {
+            var base64 = content.slice(1, -1);
+            return Buffer.from(base64, "base64");
+          } catch (e) {
+            // Not valid base64, treat as regular string
+          }
+        }
+
+        // In binary mode, return as Buffer; otherwise check if it's printable
+        if (this.binaryMode) {
+          return Buffer.from(content, "utf8");
+        } else {
+          // Check if the content is printable
+          var _bytes = Buffer.from(content, "utf8");
+          var isPrintable = Array.from(_bytes).every(function (b) {
+            return b >= 32 && b <= 126;
+          });
+
+          // If it contains non-printable characters, return as Buffer
+          if (!isPrintable) {
+            return _bytes;
+          }
+
+          // Otherwise return as string
+          return content;
+        }
+      }
+
+      // Empty binary: <<>>
+      if (this.peek() === ">" && this.peek(1) === ">") {
+        this.advance(2);
+        return Buffer.alloc(0);
+      }
+
+      // Byte binary: <<1,2,3>>
+      var bytes = [];
+      while (!(this.peek() === ">" && this.peek(1) === ">")) {
+        if (this.pos >= this.str.length) {
+          throw new Error("Unterminated byte binary");
+        }
+        this.skipWhitespace();
+        var num = "";
+        while (/\d/.test(this.peek())) {
+          num += this.peek();
+          this.advance();
+        }
+        if (num) {
+          bytes.push(parseInt(num, 10));
+        }
+        this.skipWhitespace();
+        if (this.peek() === ",") {
+          this.advance();
+        }
+      }
+      this.advance(2); // skip >>
+      return Buffer.from(bytes);
+    }
+  }, {
+    key: "parseQuotedString",
+    value: function parseQuotedString() {
+      this.advance(); // skip "
+      var str = "";
+      while (this.peek() !== '"') {
+        if (this.peek() === "\\") {
+          this.advance();
+          var escaped = this.peek();
+          switch (escaped) {
+            case '"':
+              str += '"';
+              break;
+            case "\\":
+              str += "\\";
+              break;
+            case "n":
+              str += "\n";
+              break;
+            case "r":
+              str += "\r";
+              break;
+            case "t":
+              str += "\t";
+              break;
+            default:
+              str += escaped;
+          }
+          this.advance();
+        } else {
+          str += this.peek();
+          this.advance();
+        }
+      }
+      this.advance(); // skip closing "
+      return str;
+    }
+  }, {
+    key: "parseList",
+    value: function parseList() {
+      this.advance(); // skip [
+      var list = [];
+      while (true) {
+        this.skipWhitespace();
+        if (this.peek() === "]") {
+          this.advance();
+          break;
+        }
+        list.push(this.parseValue());
+        this.skipWhitespace();
+        if (this.peek() === ",") {
+          this.advance();
+        }
+      }
+      return list;
+    }
+  }, {
+    key: "parseQuotedAtom",
+    value: function parseQuotedAtom() {
+      this.advance(); // skip '
+      var atom = "";
+      while (this.peek() !== "'") {
+        if (this.pos >= this.str.length) {
+          throw new Error("Unterminated quoted atom");
+        }
+        if (this.peek() === "\\") {
+          this.advance();
+          var escaped = this.peek();
+          switch (escaped) {
+            case "'":
+              atom += "'";
+              break;
+            case "\\":
+              atom += "\\";
+              break;
+            case "n":
+              atom += "\n";
+              break;
+            // Literal newline
+            case "r":
+              atom += "\r";
+              break;
+            case "t":
+              atom += "\t";
+              break;
+            default:
+              atom += escaped;
+          }
+          this.advance();
+        } else {
+          atom += this.peek();
+          this.advance();
+        }
+      }
+      this.advance(); // skip closing '
+
+      // Special atoms that become JS primitives
+      if (atom === "null") return null;
+      if (atom === "true") return true;
+      if (atom === "false") return false;
+      return Symbol["for"](atom);
+    }
+  }, {
+    key: "parseAtomOrNumber",
+    value: function parseAtomOrNumber() {
+      var startPos = this.pos;
+      var token = "";
+
+      // Simple approach: collect until we hit a known delimiter
+      while (this.pos < this.str.length) {
+        var ch = this.peek();
+        var ch2 = this.peek(1);
+
+        // Stop at these delimiters
+        if (ch === ",") break;
+        if (ch === "]") break;
+        if (ch === "}") break;
+        if (ch === ")") break;
+        if (ch === "=" && ch2 === ">") break;
+
+        // Handle backslash specially
+        if (ch === "\\") {
+          // In unquoted atoms, backslash is just a regular character
+          token += ch;
+          this.advance();
+
+          // Don't try to interpret the next character as an escape
+          if (this.pos < this.str.length) {
+            token += this.peek();
+            this.advance();
+          }
+          continue;
+        }
+
+        // For whitespace, check if it's trailing
+        if (/\s/.test(ch)) {
+          // Scan ahead to find next non-whitespace
+          var i = this.pos;
+          while (i < this.str.length && /\s/.test(this.str[i])) {
+            i++;
+          }
+
+          // Check what comes after whitespace
+          if (i >= this.str.length) {
+            // Hit end of string
+            break;
+          }
+          var nextCh = this.str[i];
+          if (nextCh === "," || nextCh === "]" || nextCh === "}" || nextCh === ")") {
+            // This whitespace is trailing, not part of atom
+            break;
+          }
+          if (nextCh === "=" && i + 1 < this.str.length && this.str[i + 1] === ">") {
+            // Whitespace before =>
+            break;
+          }
+        }
+
+        // Include this character in the atom
+        token += ch;
+        this.advance();
+
+        // Safety check to prevent infinite loops
+        if (this.pos - startPos > 1000) {
+          throw new Error("Atom too long at position ".concat(startPos));
+        }
+      }
+
+      // Trim only trailing whitespace
+      token = token.trimEnd();
+      if (!token) {
+        throw new Error("Empty atom at position ".concat(this.pos));
+      }
+
+      // Handle special atoms
+      if (token === "null") return null;
+      if (token === "true") return true;
+      if (token === "false") return false;
+
+      // Try to parse as number
+      if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(token)) {
+        return parseFloat(token);
+      }
+
+      // Return as atom
+      return Symbol["for"](token);
+    }
+  }]);
+}();
+/**
+ * Format JavaScript values as Erlang term strings
+ * @param {*} value - JavaScript value
+ * @returns {string} Erlang term string
+ */
+function erl_str_to(value) {
+  return formatValue(value);
+}
+
+// Formatter implementation
+function formatValue(value) {
+  if (value === null) return "null";
+  if (value === undefined) return "undefined";
+  if (typeof value === "boolean") return value.toString();
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "string") {
+    // Format as string binary
+    return "<<\"".concat(escapeString(value), "\">>");
+  }
+  if (_typeof(value) === "symbol") {
+    var key = Symbol.keyFor(value);
+    var name = key || value.description || "";
+
+    // Special symbols
+    if (name === "null") return "null";
+    if (name === "true") return "true";
+    if (name === "false") return "false";
+    if (name === "undefined") return "undefined";
+
+    // Check if needs quoting
+    if (/^[a-z][a-zA-Z0-9_]*$/.test(name)) {
+      return name;
+    } else {
+      return "'".concat(escapeString(name), "'");
+    }
+  }
+  if (value instanceof Buffer || value instanceof Uint8Array) {
+    var bytes = Array.from(value);
+
+    // Check if it's printable
+    var isPrintable = bytes.every(function (b) {
+      return b >= 32 && b <= 126;
+    });
+    if (isPrintable) {
+      var str = Buffer.from(value).toString();
+      return "<<\"".concat(escapeString(str), "\">>");
+    } else {
+      return "<<".concat(bytes.join(","), ">>");
+    }
+  }
+  if (Array.isArray(value)) {
+    var items = value.map(formatValue);
+    return "[".concat(items.join(","), "]");
+  }
+  if (_typeof(value) === "object" && value !== null) {
+    var entries = Object.entries(value).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        k = _ref2[0],
+        v = _ref2[1];
+      var key = "<<\"".concat(escapeString(k), "\">>");
+      return "".concat(key, " => ").concat(formatValue(v));
+    });
+    return "#{".concat(entries.join(","), "}");
+  }
+  return String(value);
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}