@o3co/ts.hocon 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -208,6 +208,23 @@ var ConfigError = class extends Error {
   }
 };
 
+// src/value/numeric-array.ts
+function numericObjectToArray(value) {
+  if (value.kind !== "object") return null;
+  if (value.fields.size === 0) return null;
+  const canonicalInt = /^(0|[1-9][0-9]*)$/;
+  const eligible = [];
+  for (const [key, val] of value.fields) {
+    if (!canonicalInt.test(key)) continue;
+    const n = Number(key);
+    if (!Number.isInteger(n) || n > 2147483647) continue;
+    eligible.push({ n, v: val });
+  }
+  if (eligible.length === 0) return null;
+  eligible.sort((a, b) => a.n - b.n);
+  return eligible.map((e) => e.v);
+}
+
 // src/config.ts
 var Config = class _Config {
   constructor(root) {
@@ -261,6 +278,10 @@ var Config = class _Config {
   getList(path2) {
     const v = this.lookupNode(path2);
     if (v === void 0) throw new ConfigError(`path not found: ${path2}`, path2);
+    if (v.kind === "object") {
+      const converted = numericObjectToArray(v);
+      if (converted !== null) return converted.map(hoconToJs);
+    }
     if (v.kind !== "array") throw new ConfigError(`expected array at ${path2}`, path2);
     return v.items.map(hoconToJs);
   }
@@ -373,6 +394,20 @@ function deepMergeHocon(receiver, fallback) {
 }
 
 // src/internal/lexer/lexer.ts
+function isHoconWhitespace(ch) {
+  const cp = ch.codePointAt(0) ?? -1;
+  if (cp === 9 || cp === 10 || cp === 11 || cp === 12 || cp === 13) return true;
+  if (cp >= 28 && cp <= 31) return true;
+  if (cp === 32 || cp === 160 || cp === 65279) return true;
+  if (cp === 5760) return true;
+  if (cp >= 8192 && cp <= 8202) return true;
+  if (cp === 8232 || cp === 8233 || cp === 8239 || cp === 8287) return true;
+  if (cp === 12288) return true;
+  return false;
+}
+function isHoconNewline(ch) {
+  return ch === "\n";
+}
 var SINGLE_CHAR_TOKENS = {
   "{": "lbrace",
   "}": "rbrace",
@@ -395,18 +430,18 @@ var Lexer = class {
     while (this.pos < this.input.length) {
       const sl = this.line, sc = this.col;
       const ch = this.peek();
-      if (ch === " " || ch === "	" || ch === "\r") {
-        this.advance();
-        this.hadSpace = true;
-        continue;
-      }
-      if (ch === "\n") {
+      if (isHoconNewline(ch)) {
         this.advance();
         if (this.tokens[this.tokens.length - 1]?.kind !== "newline") {
           this.push("newline", "\n", sl, sc);
         }
         continue;
       }
+      if (isHoconWhitespace(ch)) {
+        this.advance();
+        this.hadSpace = true;
+        continue;
+      }
       if (ch === "/" && this.peek(1) === "/") {
         while (this.pos < this.input.length && this.peek() !== "\n") this.advance();
         this.hadSpace = true;
@@ -436,16 +471,16 @@ var Lexer = class {
       if (ch === "$" && this.peek(1) === "{") {
         this.advance();
         this.advance();
-        const optional = this.peek() === "?";
-        if (optional) this.advance();
-        let path2 = "";
-        while (this.pos < this.input.length && this.peek() !== "}") {
-          if (this.peek() === "\n") throw new ParseError("unterminated substitution", sl, sc);
-          path2 += this.advance();
-        }
-        if (this.peek() !== "}") throw new ParseError("unterminated substitution", sl, sc);
-        this.advance();
-        this.push(optional ? "opt_subst" : "subst", path2.trim(), sl, sc);
+        const payload = this.parseSubstBody(sl, sc);
+        const value = payload.segments.map((s) => {
+          const t = s.text;
+          if (t === "" || t.includes(".") || t.includes(" ") || t.includes("	") || t.includes('"') || t.includes("\\") || t !== t.trim()) {
+            const escaped = t.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            return `"${escaped}"`;
+          }
+          return t;
+        }).join(".");
+        this.pushSubst(payload, value, sl, sc);
         continue;
       }
       if (ch === '"' && this.peek(1) === '"' && this.peek(2) === '"') {
@@ -480,62 +515,19 @@ var Lexer = class {
       }
       if (ch === '"') {
         this.advance();
-        let value = "";
-        while (this.pos < this.input.length && this.peek() !== '"') {
-          if (this.peek() === "\n") throw new ParseError("unterminated string", sl, sc);
-          if (this.peek() === "\\") {
-            this.advance();
-            const esc = this.advance();
-            switch (esc) {
-              case "n":
-                value += "\n";
-                break;
-              case "t":
-                value += "	";
-                break;
-              case "r":
-                value += "\r";
-                break;
-              case '"':
-                value += '"';
-                break;
-              case "\\":
-                value += "\\";
-                break;
-              case "/":
-                value += "/";
-                break;
-              case "b":
-                value += "\b";
-                break;
-              case "f":
-                value += "\f";
-                break;
-              case "u": {
-                if (this.pos + 4 > this.input.length) {
-                  throw new ParseError("Invalid unicode escape: not enough characters", this.line, this.col);
-                }
-                const hex = this.input.slice(this.pos, this.pos + 4);
-                if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
-                  throw new ParseError(`Invalid unicode escape: \\u${hex}`, this.line, this.col);
-                }
-                value += String.fromCharCode(parseInt(hex, 16));
-                for (let i = 0; i < 4; i++) this.advance();
-                break;
-              }
-              default:
-                throw new ParseError(`Unknown escape sequence: \\${esc}`, this.line, this.col);
-            }
-          } else {
-            value += this.advance();
-          }
-        }
-        if (this.peek() !== '"') throw new ParseError("unterminated string", sl, sc);
-        this.advance();
+        const value = this.readQuotedStringBody(sl, sc);
         this.push("string", value, sl, sc, true);
         continue;
       }
       if (isUnquotedStart(ch)) {
+        if (ch === "-" && !isDecimalDigit(this.peek(1))) {
+          const after = this.peek(1) === "" ? "EOF" : JSON.stringify(this.peek(1));
+          throw new ParseError(
+            `unquoted string cannot begin with '-' unless followed by a digit (got '-' then ${after}, HOCON.md L270-276)`,
+            sl,
+            sc
+          );
+        }
         let value = "";
         while (this.pos < this.input.length && isUnquotedContinue(this.peek(), () => this.peek(1))) {
           value += this.advance();
@@ -565,22 +557,201 @@ var Lexer = class {
     this.tokens.push({ kind, value, line: l, col: c, isQuoted, precedingSpace: this.hadSpace });
     this.hadSpace = false;
   }
+  pushSubst(payload, value, l, c) {
+    this.tokens.push({ kind: "subst", value, line: l, col: c, isQuoted: false, precedingSpace: this.hadSpace, subst: payload });
+    this.hadSpace = false;
+  }
+  /**
+   * Read body of a quoted string. Opening `"` must already be consumed.
+   * Returns decoded string. Throws ParseError on unterminated/invalid-escape.
+   * openLine/openCol are the position of the opening `"` for error reporting.
+   */
+  readQuotedStringBody(openLine, openCol) {
+    let value = "";
+    while (this.pos < this.input.length && this.peek() !== '"') {
+      if (this.peek() === "\n") throw new ParseError("unterminated string", openLine, openCol);
+      if (this.peek() === "\\") {
+        const escCol = this.col;
+        this.advance();
+        if (this.pos >= this.input.length) {
+          throw new ParseError("unterminated string", openLine, openCol);
+        }
+        const esc = this.advance();
+        switch (esc) {
+          case "n":
+            value += "\n";
+            break;
+          case "t":
+            value += "	";
+            break;
+          case "r":
+            value += "\r";
+            break;
+          case '"':
+            value += '"';
+            break;
+          case "\\":
+            value += "\\";
+            break;
+          case "/":
+            value += "/";
+            break;
+          case "b":
+            value += "\b";
+            break;
+          case "f":
+            value += "\f";
+            break;
+          case "u": {
+            if (this.pos + 4 > this.input.length) {
+              throw new ParseError("invalid unicode escape", openLine, escCol);
+            }
+            const hex = this.input.slice(this.pos, this.pos + 4);
+            if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+              throw new ParseError("invalid unicode escape", openLine, escCol);
+            }
+            const code = parseInt(hex, 16);
+            value += String.fromCharCode(code);
+            for (let i = 0; i < 4; i++) this.advance();
+            break;
+          }
+          default:
+            throw new ParseError(`unknown escape sequence: \\${esc}`, openLine, escCol);
+        }
+      } else {
+        value += this.advance();
+      }
+    }
+    if (this.pos >= this.input.length || this.peek() !== '"') {
+      throw new ParseError("unterminated string", openLine, openCol);
+    }
+    this.advance();
+    return value;
+  }
+  /**
+   * Parse the body of a `${...}` substitution (called after `${` has been consumed).
+   * Implements Appendix A state machine from the cross-language spec.
+   */
+  parseSubstBody(startLine, startCol) {
+    let optional = false;
+    if (this.peek() === "?") {
+      this.advance();
+      optional = true;
+    }
+    let curText = "";
+    let curStarted = false;
+    let curLine = 0;
+    let curCol = 0;
+    let pendingWs = "";
+    const segments = [];
+    let lastDot = null;
+    while (true) {
+      if (this.pos >= this.input.length) {
+        throw new ParseError("unterminated substitution", startLine, startCol);
+      }
+      const ch = this.peek();
+      if (ch === "}") {
+        this.advance();
+        pendingWs = "";
+        break;
+      } else if (ch === '"') {
+        const qLine = startLine;
+        const qCol = this.col;
+        if (curStarted) {
+          curText += pendingWs;
+        }
+        pendingWs = "";
+        this.advance();
+        const decoded = this.readQuotedStringBody(qLine, qCol);
+        curText += decoded;
+        if (!curStarted) {
+          curLine = qLine;
+          curCol = qCol;
+          curStarted = true;
+        }
+      } else if (isUnquotedSubstChar(ch)) {
+        if (ch === "-" && !curStarted && !isDecimalDigit(this.peek(1))) {
+          const after = this.peek(1) === "" ? "EOF" : JSON.stringify(this.peek(1));
+          throw new ParseError(
+            `unquoted path segment cannot begin with '-' unless followed by a digit (got '-' then ${after}, HOCON.md L270-276)`,
+            startLine,
+            this.col
+          );
+        }
+        const uCol = this.col;
+        if (curStarted) {
+          curText += pendingWs;
+        }
+        pendingWs = "";
+        if (!curStarted) {
+          curLine = startLine;
+          curCol = uCol;
+          curStarted = true;
+        }
+        while (this.pos < this.input.length && isUnquotedSubstChar(this.peek())) {
+          curText += this.advance();
+        }
+      } else if (ch === ".") {
+        const dotCol = this.col;
+        pendingWs = "";
+        if (!curStarted) {
+          throw new ParseError("empty segment in path", startLine, dotCol);
+        }
+        segments.push({ text: curText, line: curLine, col: curCol });
+        curText = "";
+        curStarted = false;
+        curLine = 0;
+        curCol = 0;
+        lastDot = [startLine, dotCol];
+        this.advance();
+      } else if (isHoconNewline(ch)) {
+        throw new ParseError("unterminated substitution", startLine, startCol);
+      } else if (isHoconWhitespace(ch)) {
+        pendingWs += ch;
+        this.advance();
+      } else {
+        throw new ParseError(`unexpected character in substitution path: ${JSON.stringify(ch)}`, startLine, this.col);
+      }
+    }
+    if (curStarted) {
+      segments.push({ text: curText, line: curLine, col: curCol });
+    } else if (segments.length === 0) {
+      throw new ParseError("empty substitution path", startLine, startCol);
+    } else {
+      const [errLine, errCol] = lastDot ?? [startLine, startCol];
+      throw new ParseError("empty segment in path", errLine, errCol);
+    }
+    return { segments, optional };
+  }
 };
 function tokenize(input) {
   return new Lexer(input).tokenize();
 }
+function isUnquotedSubstChar(ch) {
+  if (ch === "" || isHoconWhitespace(ch)) return false;
+  if ('"\\'.includes(ch)) return false;
+  if ("{}[]".includes(ch)) return false;
+  if (":=,+#`^?!@*&$.".includes(ch)) return false;
+  return true;
+}
+function isDecimalDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
 function isUnquotedStart(ch) {
-  return ch !== "" && !'{}[],:=+#\n\r	 "$?!@*&^\\'.includes(ch);
+  if (ch === "" || isHoconWhitespace(ch)) return false;
+  if ('{}[],:=+#"$?!@*&^\\'.includes(ch)) return false;
+  return true;
 }
 function isUnquotedContinue(ch, nextFn) {
-  if (ch === "" || '{}[],:=\n\r	 #"$?!@*&^\\'.includes(ch) || ch === " ") return false;
+  if (ch === "" || isHoconWhitespace(ch)) return false;
+  if ('{}[],:=#"$?!@*&^\\'.includes(ch)) return false;
   if (ch === "+" && nextFn() === "=") return false;
   if (ch === "/" && nextFn() === "/") return false;
   return true;
 }
 
 // src/internal/parser/parser.ts
-var EOF_TOKEN = { kind: "eof", value: "", line: 0, col: 0, isQuoted: false, precedingSpace: false };
+var EOF_TOKEN = { kind: "eof", value: "", line: 0, col: 0, isQuoted: false, precedingSpace: false, subst: void 0 };
 var Parser = class {
   constructor(tokens) {
     this.tokens = tokens;
@@ -684,10 +855,21 @@ var Parser = class {
         trailingDot = false;
       } else if (t.kind === "unquoted") {
         this.advance();
-        const parts = t.value.split(".");
+        const raw = t.value.startsWith(".") && segments.length > 0 && !t.precedingSpace ? t.value.slice(1) : t.value;
+        const parts = raw.split(".");
         const filtered = parts.filter((s) => s.length > 0);
+        for (const seg of filtered) {
+          if (seg[0] === "-" && !(seg.length >= 2 && seg[1] >= "0" && seg[1] <= "9")) {
+            const after = seg.length >= 2 ? JSON.stringify(seg[1]) : "EOF";
+            throw new ParseError(
+              `unquoted key segment cannot begin with '-' unless followed by a digit (got '-' then ${after} in ${JSON.stringify(seg)}, HOCON.md L270-276)`,
+              t.line,
+              t.col
+            );
+          }
+        }
         segments.push(...filtered);
-        trailingDot = t.value.endsWith(".");
+        trailingDot = raw.endsWith(".");
       } else {
         if (segments.length === 0) throw new ParseError(`expected key, got ${t.kind}`, t.line, t.col);
         break;
@@ -699,6 +881,10 @@ var Parser = class {
         trailingDot = true;
         continue;
       }
+      if (next.kind === "unquoted" && next.value.startsWith(".") && !next.precedingSpace) {
+        trailingDot = true;
+        continue;
+      }
       break;
     }
     return segments;
@@ -774,9 +960,13 @@ var Parser = class {
       } else if (t.kind === "lbracket") {
         this.advance();
         node = this.parseArray();
-      } else if (t.kind === "subst" || t.kind === "opt_subst") {
+      } else if (t.kind === "subst") {
         this.advance();
-        node = { kind: "subst", path: t.value, optional: t.kind === "opt_subst", pos: { line: t.line, col: t.col } };
+        if (!t.subst) {
+          throw new ParseError(`internal: subst token missing payload`, t.line, t.col);
+        }
+        const payload = t.subst;
+        node = { kind: "subst", segments: payload.segments, optional: payload.optional, pos: { line: t.line, col: t.col } };
       } else if (t.kind === "string" || t.kind === "triple_string") {
         this.advance();
         node = { kind: "scalar", raw: t.value, valueType: "string", pos: { line: t.line, col: t.col } };
@@ -846,64 +1036,20 @@ function makeResObj() {
 }
 
 // src/internal/resolver/utils.ts
-function parseSubstPath(raw) {
-  const segments = [];
-  let i = 0;
-  while (i < raw.length) {
-    while (i < raw.length && (raw[i] === " " || raw[i] === "	")) i++;
-    if (i >= raw.length) break;
-    if (raw[i] === '"') {
-      i++;
-      let seg = "";
-      while (i < raw.length && raw[i] !== '"') {
-        if (raw[i] === "\\" && i + 1 < raw.length && (raw[i + 1] === '"' || raw[i + 1] === "\\")) {
-          seg += raw[i + 1];
-          i += 2;
-        } else {
-          seg += raw[i];
-          i++;
-        }
-      }
-      if (i < raw.length) i++;
-      segments.push(seg);
-      while (i < raw.length && (raw[i] === " " || raw[i] === "	")) i++;
-      if (i < raw.length && raw[i] === ".") i++;
-    } else if (raw[i] === ".") {
-      segments.push("");
-      i++;
-    } else {
-      let seg = "";
-      while (i < raw.length && raw[i] !== ".") {
-        seg += raw[i];
-        i++;
-      }
-      segments.push(seg.trim());
-      if (i < raw.length && raw[i] === ".") i++;
-    }
-  }
-  return segments;
-}
 function segmentsToKey(segments) {
   return segments.map((s) => {
-    if (s === "" || /[^a-zA-Z0-9\-_]/.test(s)) {
-      return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    const t = s.text;
+    if (t === "" || /[^a-zA-Z0-9\-_]/.test(t)) {
+      return `"${t.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
     }
-    return s;
+    return t;
   }).join(".");
 }
 function lookupPath(root, segments) {
   const [head, ...tail] = segments;
-  if (head === void 0 || head === "") {
-    if (segments.length > 0) {
-      const val2 = root.fields.get("");
-      if (val2 === void 0) return void 0;
-      if (tail.length === 0) return val2;
-      if (isResObj(val2)) return lookupPath(val2, tail);
-      return void 0;
-    }
-    return void 0;
-  }
-  const val = root.fields.get(head);
+  if (head === void 0) return void 0;
+  const key = head.text;
+  const val = root.fields.get(key);
   if (val === void 0) return void 0;
   if (tail.length === 0) return val;
   if (isResObj(val)) return lookupPath(val, tail);
@@ -912,7 +1058,7 @@ function lookupPath(root, segments) {
 function lookupResObj(root, segments) {
   let cur = root;
   for (const seg of segments) {
-    const val = cur.fields.get(seg);
+    const val = cur.fields.get(seg.text);
     if (val === void 0 || !isResObj(val)) return void 0;
     cur = val;
   }
@@ -1189,7 +1335,7 @@ var StructureBuilder = class _StructureBuilder {
       return;
     }
     const [head, ...tail] = field.key;
-    if (!head) return;
+    if (head === void 0) return;
     if (tail.length > 0) {
       const syntheticAst = {
         kind: "object",
@@ -1231,7 +1377,7 @@ var StructureBuilder = class _StructureBuilder {
       return;
     }
     const [head, ...tail] = field.key;
-    if (!head) return;
+    if (head === void 0) return;
     if (tail.length > 0) {
       const syntheticAst = {
         kind: "object",
@@ -1277,7 +1423,7 @@ var StructureBuilder = class _StructureBuilder {
         return inner;
       }
       case "subst":
-        return { _kind: "subst-placeholder", segments: parseSubstPath(ast.path), optional: ast.optional, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
+        return { _kind: "subst-placeholder", segments: ast.segments, optional: ast.optional, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
       case "concat":
         return { _kind: "concat-placeholder", nodes: ast.nodes.map((n) => this.astToResolverValue(n, pathPrefix)) };
       case "include":
@@ -1301,7 +1447,7 @@ var StructureBuilder = class _StructureBuilder {
       case "object":
         return await this.buildAsync(ast, pathPrefix);
       case "subst":
-        return { _kind: "subst-placeholder", segments: parseSubstPath(ast.path), optional: ast.optional, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
+        return { _kind: "subst-placeholder", segments: ast.segments, optional: ast.optional, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
       case "concat": {
         const nodes = [];
         for (const n of ast.nodes) {
@@ -1316,7 +1462,8 @@ var StructureBuilder = class _StructureBuilder {
   // ---- Relativize substitution paths for nested includes ----
   relativizeSubstPaths(val, prefixSegments) {
     if (isSubst(val)) {
-      val.segments = [...prefixSegments, ...val.segments];
+      const prefixAsSegments = prefixSegments.map((text) => ({ text, line: 0, col: 0 }));
+      val.segments = [...prefixAsSegments, ...val.segments];
       val.prefixLen += prefixSegments.length;
       return;
     }
@@ -1412,7 +1559,7 @@ var SubstitutionResolver = class {
     return hv;
   }
   segmentsEqual(a, b) {
-    return a.length === b.length && a.every((seg, i) => seg === b[i]);
+    return a.length === b.length && a.every((seg, i) => seg.text === b[i]?.text);
   }
   resolveSubst(s, scope) {
     const key = segmentsToKey(s.segments);
@@ -1420,14 +1567,14 @@ var SubstitutionResolver = class {
     if (this.resolving.has(key)) {
       let prior;
       if (s.prefixLen > 0) {
-        const leafSeg = s.segments[s.segments.length - 1] ?? "";
+        const leafSeg = s.segments[s.segments.length - 1]?.text ?? "";
         const parentScope = lookupResObj(
           this.root,
           s.segments.slice(0, s.segments.length - 1)
         );
         prior = parentScope?.priorValues.get(leafSeg);
       } else {
-        const rootSeg = s.segments[0] ?? "";
+        const rootSeg = s.segments[0]?.text ?? "";
         prior = scope.priorValues.get(rootSeg) ?? this.root.priorValues.get(rootSeg);
       }
       if (prior !== void 0) {
@@ -1458,14 +1605,14 @@ var SubstitutionResolver = class {
           if (isSelfRef) {
             let prior;
             if (s.prefixLen > 0) {
-              const leafSeg = s.segments[s.segments.length - 1] ?? "";
+              const leafSeg = s.segments[s.segments.length - 1]?.text ?? "";
               const parentScope = lookupResObj(
                 this.root,
                 s.segments.slice(0, s.segments.length - 1)
               );
               prior = parentScope?.priorValues.get(leafSeg);
             } else {
-              const rootSeg = s.segments[0] ?? "";
+              const rootSeg = s.segments[0]?.text ?? "";
               prior = scope.priorValues.get(rootSeg) ?? this.root.priorValues.get(rootSeg);
             }
             if (prior !== void 0) {
@@ -1478,7 +1625,7 @@ var SubstitutionResolver = class {
         let result = this.resolveVal(found, scope);
         const effectiveLen = s.segments.length - s.prefixLen;
         if (effectiveLen === 1 && result !== void 0 && result.kind === "object") {
-          const leafSeg = s.segments[s.segments.length - 1] ?? "";
+          const leafSeg = s.segments[s.segments.length - 1]?.text ?? "";
           let prior;
           if (s.prefixLen > 0) {
             const parentScope = lookupResObj(
@@ -1502,8 +1649,8 @@ var SubstitutionResolver = class {
         if (result !== void 0) this.cache.set(key, result);
         return result;
       }
-      const envKey = s.segments.join(".");
-      const envVal = this.opts.env[envKey] ?? (s.prefixLen > 0 ? this.opts.env[s.segments.slice(s.prefixLen).join(".")] : void 0);
+      const envKey = s.segments.map((seg) => seg.text).join(".");
+      const envVal = this.opts.env[envKey] ?? (s.prefixLen > 0 ? this.opts.env[s.segments.slice(s.prefixLen).map((seg) => seg.text).join(".")] : void 0);
       if (envVal !== void 0) {
         const result = { kind: "scalar", raw: envVal, valueType: "string" };
         this.cache.set(key, result);
@@ -1525,32 +1672,48 @@ var SubstitutionResolver = class {
     if (resolved.length === 0) return { kind: "scalar", raw: "null", valueType: "null" };
     if (resolved.length === 1) return resolved[0];
     const nonSep = resolved.filter((v) => !separatorValues.has(v));
-    if (nonSep.length > 0 && nonSep.every((v) => v.kind === "object")) {
-      const merged = /* @__PURE__ */ new Map();
-      for (const v of nonSep) {
-        if (v.kind === "object") {
-          for (const [k, val] of v.fields) {
-            const existing = merged.get(k);
-            if (existing?.kind === "object" && val.kind === "object") {
-              merged.set(k, deepMergeHoconValues(existing, val));
-            } else {
-              merged.set(k, val);
-            }
-          }
+    if (nonSep.length === 0) {
+      const str = resolved.map((v) => v.kind === "scalar" ? v.raw : JSON.stringify(v)).join("");
+      return { kind: "scalar", raw: str, valueType: "string" };
+    }
+    const joinPair = (left, right) => {
+      if (left.kind === "object" && right.kind === "object") {
+        return deepMergeHoconValues(left, right);
+      }
+      if (left.kind === "array" && right.kind === "object") {
+        const converted = numericObjectToArray(right);
+        if (converted !== null) {
+          return { kind: "array", items: [...left.items, ...converted] };
         }
+        return { kind: "array", items: [...left.items, right] };
       }
-      return { kind: "object", fields: merged };
-    }
-    if (resolved.some((v) => v.kind === "array")) {
-      const items = [];
-      for (const v of resolved) {
-        if (v.kind === "array") items.push(...v.items);
-        else items.push(v);
+      if (left.kind === "object" && right.kind === "array") {
+        const converted = numericObjectToArray(left);
+        if (converted !== null) {
+          return { kind: "array", items: [...converted, ...right.items] };
+        }
+        return { kind: "array", items: [left, ...right.items] };
+      }
+      if (left.kind === "array" && right.kind === "array") {
+        return { kind: "array", items: [...left.items, ...right.items] };
       }
-      return { kind: "array", items };
+      if (left.kind === "array") {
+        return { kind: "array", items: [...left.items, right] };
+      }
+      if (right.kind === "array") {
+        return { kind: "array", items: [left, ...right.items] };
+      }
+      const leftStr = left.kind === "scalar" ? left.raw : JSON.stringify(left);
+      const rightStr = right.kind === "scalar" ? right.raw : JSON.stringify(right);
+      return { kind: "scalar", raw: leftStr + rightStr, valueType: "string" };
+    };
+    const [head, ...tail] = nonSep;
+    const folded = tail.reduce(joinPair, head);
+    if (folded.kind === "scalar") {
+      const str = resolved.map((v) => v.kind === "scalar" ? v.raw : JSON.stringify(v)).join("");
+      return { kind: "scalar", raw: str, valueType: "string" };
     }
-    const str = resolved.map((v) => v.kind === "scalar" ? v.raw : JSON.stringify(v)).join("");
-    return { kind: "scalar", raw: str, valueType: "string" };
+    return folded;
   }
   resolveAppend(a, scope) {
     const existing = this.resolveVal(a.existing, scope) ?? { kind: "array", items: [] };