@o3co/ts.hocon 0.1.5 → 1.1.0

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/coerce.ts
+var DECIMAL_NUMBER_RE = /^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
 var TRUTHY = /* @__PURE__ */ new Set(["true", "yes", "on"]);
 var FALSY = /* @__PURE__ */ new Set(["false", "no", "off"]);
 function coerceBoolean(value) {
@@ -8,9 +9,133 @@ function coerceBoolean(value) {
   return void 0;
 }
 function coerceNumber(value) {
-  if (!/^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)) return void 0;
+  if (!DECIMAL_NUMBER_RE.test(value)) return void 0;
   return Number(value);
 }
+var DURATION_UNITS = {
+  ns: 1e-6,
+  nanosecond: 1e-6,
+  nanoseconds: 1e-6,
+  us: 1e-3,
+  microsecond: 1e-3,
+  microseconds: 1e-3,
+  ms: 1,
+  millisecond: 1,
+  milliseconds: 1,
+  s: 1e3,
+  second: 1e3,
+  seconds: 1e3,
+  m: 6e4,
+  minute: 6e4,
+  minutes: 6e4,
+  h: 36e5,
+  hour: 36e5,
+  hours: 36e5,
+  d: 864e5,
+  day: 864e5,
+  days: 864e5
+};
+var OUTPUT_DURATION_UNITS = {
+  ns: 1e-6,
+  us: 1e-3,
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function parseDuration(value, outputUnit = "ms") {
+  const trimmed = value.trim();
+  let i = 0;
+  while (i < trimmed.length) {
+    const ch = trimmed[i];
+    if (ch !== "-" && ch !== "." && (ch < "0" || ch > "9")) break;
+    i++;
+  }
+  if (i === 0) return NaN;
+  const num = Number(trimmed.slice(0, i));
+  if (Number.isNaN(num)) return NaN;
+  const unit = trimmed.slice(i).trim().toLowerCase();
+  const mult = DURATION_UNITS[unit];
+  if (mult === void 0) return NaN;
+  const ms = num * mult;
+  const divisor = OUTPUT_DURATION_UNITS[outputUnit];
+  if (divisor === void 0) return NaN;
+  return ms / divisor;
+}
+var BYTE_UNITS = {
+  B: 1,
+  byte: 1,
+  bytes: 1,
+  KB: 1e3,
+  kilobyte: 1e3,
+  kilobytes: 1e3,
+  KiB: 1024,
+  kibibyte: 1024,
+  kibibytes: 1024,
+  MB: 1e6,
+  megabyte: 1e6,
+  megabytes: 1e6,
+  MiB: 1048576,
+  mebibyte: 1048576,
+  mebibytes: 1048576,
+  GB: 1e9,
+  gigabyte: 1e9,
+  gigabytes: 1e9,
+  GiB: 1073741824,
+  gibibyte: 1073741824,
+  gibibytes: 1073741824,
+  TB: 1e12,
+  terabyte: 1e12,
+  terabytes: 1e12,
+  TiB: 1099511627776,
+  tebibyte: 1099511627776,
+  tebibytes: 1099511627776,
+  // lowercase short-form aliases
+  b: 1,
+  kb: 1e3,
+  kib: 1024,
+  mb: 1e6,
+  mib: 1048576,
+  gb: 1e9,
+  gib: 1073741824,
+  tb: 1e12,
+  tib: 1099511627776
+};
+var OUTPUT_BYTE_UNITS = {
+  B: 1,
+  KB: 1e3,
+  KiB: 1024,
+  MB: 1e6,
+  MiB: 1048576,
+  GB: 1e9,
+  GiB: 1073741824,
+  TB: 1e12,
+  TiB: 1099511627776
+};
+function parseBytes(value, outputUnit = "B") {
+  const trimmed = value.trim();
+  let i = 0;
+  while (i < trimmed.length) {
+    const ch = trimmed[i];
+    if (ch !== "-" && ch !== "." && (ch < "0" || ch > "9")) break;
+    i++;
+  }
+  if (i === 0) return NaN;
+  const num = Number(trimmed.slice(0, i));
+  if (Number.isNaN(num)) return NaN;
+  const unit = trimmed.slice(i).trim();
+  let mult = BYTE_UNITS[unit];
+  if (mult === void 0) {
+    mult = BYTE_UNITS[unit.toLowerCase()];
+  }
+  if (mult === void 0) return NaN;
+  const bytes = num * mult;
+  const divisor = OUTPUT_BYTE_UNITS[outputUnit];
+  if (divisor === void 0) return NaN;
+  const result = bytes / divisor;
+  return outputUnit === "B" ? Math.round(result) : result;
+}
 
 // src/errors.ts
 var ParseError = class extends Error {
@@ -52,26 +177,37 @@ var Config = class _Config {
   }
   getString(path2) {
     const v = this.requireScalar(path2);
-    if (typeof v !== "string") throw new ConfigError(`expected string at ${path2}, got ${typeof v}`, path2);
-    return v;
+    return v.raw;
   }
   getNumber(path2) {
     const v = this.requireScalar(path2);
-    if (typeof v === "number") return v;
-    if (typeof v === "string") {
-      const coerced = coerceNumber(v);
-      if (coerced !== void 0) return coerced;
-    }
-    throw new ConfigError(`expected number at ${path2}, got ${typeof v}`, path2);
+    const coerced = coerceNumber(v.raw);
+    if (coerced !== void 0) return coerced;
+    throw new ConfigError(`expected number at ${path2}, got ${v.valueType}`, path2);
   }
   getBoolean(path2) {
     const v = this.requireScalar(path2);
-    if (typeof v === "boolean") return v;
-    if (typeof v === "string") {
-      const coerced = coerceBoolean(v);
-      if (coerced !== void 0) return coerced;
+    const coerced = coerceBoolean(v.raw);
+    if (coerced !== void 0) return coerced;
+    throw new ConfigError(`expected boolean at ${path2}, got ${v.valueType}`, path2);
+  }
+  getDuration(path2, unit) {
+    const v = this.requireScalar(path2);
+    if (v.valueType !== "string" && v.valueType !== "number") {
+      throw new ConfigError(`expected duration at ${path2}, got ${v.valueType}`, path2);
+    }
+    const result = parseDuration(v.raw, unit);
+    if (Number.isNaN(result)) throw new ConfigError(`invalid duration at ${path2}: ${JSON.stringify(v.raw)}`, path2);
+    return result;
+  }
+  getBytes(path2, unit) {
+    const v = this.requireScalar(path2);
+    if (v.valueType !== "string" && v.valueType !== "number") {
+      throw new ConfigError(`expected byte size at ${path2}, got ${v.valueType}`, path2);
     }
-    throw new ConfigError(`expected boolean at ${path2}, got ${typeof v}`, path2);
+    const result = parseBytes(v.raw, unit);
+    if (Number.isNaN(result)) throw new ConfigError(`invalid byte size at ${path2}: ${JSON.stringify(v.raw)}`, path2);
+    return result;
   }
   getConfig(path2) {
     const v = this.lookupNode(path2);
@@ -99,7 +235,7 @@ var Config = class _Config {
     return hoconToJs(this.root);
   }
   lookupNode(path2) {
-    const segments = path2.split(".");
+    const segments = splitConfigPath(path2);
     let current = this.root;
     for (const seg of segments) {
       if (current.kind !== "object") return void 0;
@@ -113,13 +249,64 @@ var Config = class _Config {
     const v = this.lookupNode(path2);
     if (v === void 0) throw new ConfigError(`path not found: ${path2}`, path2);
     if (v.kind !== "scalar") throw new ConfigError(`expected scalar at ${path2}, got ${v.kind}`, path2);
-    return v.value;
+    return v;
   }
 };
+function splitConfigPath(path2) {
+  const segments = [];
+  let i = 0;
+  while (i < path2.length) {
+    if (path2[i] === '"') {
+      i++;
+      let segment = "";
+      let closed = false;
+      while (i < path2.length) {
+        const ch = path2[i];
+        if (ch === "\\" && i + 1 < path2.length) {
+          const next = path2[i + 1];
+          segment += next;
+          i += 2;
+          continue;
+        }
+        if (ch === '"') {
+          closed = true;
+          i++;
+          break;
+        }
+        segment += ch;
+        i++;
+      }
+      if (!closed) throw new ConfigError(`unterminated quoted path segment: ${path2}`, path2);
+      segments.push(segment);
+      if (i < path2.length && path2[i] === ".") i++;
+    } else {
+      const dot = path2.indexOf(".", i);
+      if (dot === -1) {
+        segments.push(path2.slice(i));
+        break;
+      }
+      segments.push(path2.slice(i, dot));
+      i = dot + 1;
+    }
+  }
+  return segments;
+}
+function scalarToJs(raw, valueType) {
+  switch (valueType) {
+    case "null":
+      return null;
+    case "boolean":
+      return raw === "true";
+    case "number":
+      return Number(raw);
+    case "string":
+      return raw;
+  }
+}
 function hoconToJs(v) {
   switch (v.kind) {
     case "scalar":
-      return v.value;
+      return scalarToJs(v.raw, v.valueType);
     case "array":
       return v.items.map(hoconToJs);
     case "object": {
@@ -143,270 +330,329 @@ function deepMergeHocon(receiver, fallback) {
 }
 
 // src/internal/lexer/lexer.ts
-function tokenize(input) {
-  if (input.charCodeAt(0) === 65279) input = input.slice(1);
-  const tokens = [];
-  let pos = 0;
-  let line = 1;
-  let col = 1;
-  let hadSpace = false;
-  function peek(offset = 0) {
-    return input[pos + offset] ?? "";
-  }
-  function advance() {
-    const ch = input[pos++] ?? "";
-    if (ch === "\n") {
-      line++;
-      col = 1;
-    } else {
-      col++;
-    }
-    return ch;
-  }
-  function push(kind, value, l, c, isQuoted = false) {
-    tokens.push({ kind, value, line: l, col: c, isQuoted, precedingSpace: hadSpace });
-    hadSpace = false;
+var SINGLE_CHAR_TOKENS = {
+  "{": "lbrace",
+  "}": "rbrace",
+  "[": "lbracket",
+  "]": "rbracket",
+  ",": "comma",
+  ":": "colon"
+};
+var Lexer = class {
+  constructor(input) {
+    this.input = input;
+    this.pos = 0;
+    this.line = 1;
+    this.col = 1;
+    this.hadSpace = false;
+    this.tokens = [];
+    if (input.charCodeAt(0) === 65279) this.input = input.slice(1);
   }
-  while (pos < input.length) {
-    const sl = line, sc = col;
-    const ch = peek();
-    if (ch === " " || ch === "	" || ch === "\r") {
-      advance();
-      hadSpace = true;
-      continue;
-    }
-    if (ch === "\n") {
-      advance();
-      if (tokens[tokens.length - 1]?.kind !== "newline") {
-        push("newline", "\n", sl, sc);
-      }
-      continue;
-    }
-    if (ch === "/" && peek(1) === "/") {
-      while (pos < input.length && peek() !== "\n") advance();
-      hadSpace = true;
-      continue;
-    }
-    if (ch === "#") {
-      while (pos < input.length && peek() !== "\n") advance();
-      hadSpace = true;
-      continue;
-    }
-    const single = { "{": "lbrace", "}": "rbrace", "[": "lbracket", "]": "rbracket", ",": "comma", ":": "colon" };
-    if (ch in single) {
-      advance();
-      push(single[ch], ch, sl, sc);
-      continue;
-    }
-    if (ch === "=") {
-      advance();
-      push("equals", "=", sl, sc);
-      continue;
-    }
-    if (ch === "+" && peek(1) === "=") {
-      advance();
-      advance();
-      push("plus_equals", "+=", sl, sc);
-      continue;
-    }
-    if (ch === "$" && peek(1) === "{") {
-      advance();
-      advance();
-      const optional = peek() === "?";
-      if (optional) advance();
-      let path2 = "";
-      while (pos < input.length && peek() !== "}") {
-        if (peek() === "\n") throw new ParseError("unterminated substitution", sl, sc);
-        path2 += advance();
-      }
-      if (peek() !== "}") throw new ParseError("unterminated substitution", sl, sc);
-      advance();
-      push(optional ? "opt_subst" : "subst", path2.trim(), sl, sc);
-      continue;
-    }
-    if (ch === '"' && peek(1) === '"' && peek(2) === '"') {
-      advance();
-      advance();
-      advance();
-      let value = "";
-      while (pos < input.length) {
-        if (peek() === '"') {
-          let quoteCount = 0;
-          while (pos < input.length && peek() === '"') {
-            quoteCount++;
-            advance();
-          }
-          if (quoteCount >= 3) {
-            for (let i = 0; i < quoteCount - 3; i++) value += '"';
-            break;
-          }
-          for (let i = 0; i < quoteCount; i++) value += '"';
-          continue;
+  tokenize() {
+    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") {
+        this.advance();
+        if (this.tokens[this.tokens.length - 1]?.kind !== "newline") {
+          this.push("newline", "\n", sl, sc);
         }
-        value += advance();
-      }
-      if (value.startsWith("\n")) value = value.slice(1);
-      push("triple_string", value, sl, sc, true);
-      continue;
-    }
-    if (ch === '"') {
-      advance();
-      let value = "";
-      while (pos < input.length && peek() !== '"') {
-        if (peek() === "\n") throw new ParseError("unterminated string", sl, sc);
-        if (peek() === "\\") {
-          advance();
-          const esc = 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": {
-              const hex = input.slice(pos, pos + 4);
-              value += String.fromCharCode(parseInt(hex, 16));
-              for (let i = 0; i < 4; i++) advance();
+        continue;
+      }
+      if (ch === "/" && this.peek(1) === "/") {
+        while (this.pos < this.input.length && this.peek() !== "\n") this.advance();
+        this.hadSpace = true;
+        continue;
+      }
+      if (ch === "#") {
+        while (this.pos < this.input.length && this.peek() !== "\n") this.advance();
+        this.hadSpace = true;
+        continue;
+      }
+      if (ch in SINGLE_CHAR_TOKENS) {
+        this.advance();
+        this.push(SINGLE_CHAR_TOKENS[ch], ch, sl, sc);
+        continue;
+      }
+      if (ch === "=") {
+        this.advance();
+        this.push("equals", "=", sl, sc);
+        continue;
+      }
+      if (ch === "+" && this.peek(1) === "=") {
+        this.advance();
+        this.advance();
+        this.push("plus_equals", "+=", sl, sc);
+        continue;
+      }
+      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);
+        continue;
+      }
+      if (ch === '"' && this.peek(1) === '"' && this.peek(2) === '"') {
+        this.advance();
+        this.advance();
+        this.advance();
+        let value = "";
+        let closed = false;
+        while (this.pos < this.input.length) {
+          if (this.peek() === '"') {
+            let quoteCount = 0;
+            while (this.pos < this.input.length && this.peek() === '"') {
+              quoteCount++;
+              this.advance();
+            }
+            if (quoteCount >= 3) {
+              for (let i = 0; i < quoteCount - 3; i++) value += '"';
+              closed = true;
               break;
             }
-            default:
-              value += esc;
+            for (let i = 0; i < quoteCount; i++) value += '"';
+            continue;
           }
-        } else {
-          value += advance();
+          value += this.advance();
         }
+        if (!closed) {
+          throw new ParseError("unterminated triple-quoted string", sl, sc);
+        }
+        if (value.startsWith("\n")) value = value.slice(1);
+        this.push("triple_string", value, sl, sc, true);
+        continue;
       }
-      if (peek() !== '"') throw new ParseError("unterminated string", sl, sc);
-      advance();
-      push("string", value, sl, sc, true);
-      continue;
-    }
-    if (isUnquotedStart(ch)) {
-      let value = "";
-      while (pos < input.length && isUnquotedContinue(peek(), () => peek(1))) {
-        value += advance();
+      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();
+        this.push("string", value, sl, sc, true);
+        continue;
       }
-      push("unquoted", value.trimEnd(), sl, sc);
-      continue;
+      if (isUnquotedStart(ch)) {
+        let value = "";
+        while (this.pos < this.input.length && isUnquotedContinue(this.peek(), () => this.peek(1))) {
+          value += this.advance();
+        }
+        this.push("unquoted", value.trimEnd(), sl, sc);
+        continue;
+      }
+      throw new ParseError(`unexpected character: ${JSON.stringify(ch)}`, sl, sc);
     }
-    throw new ParseError(`unexpected character: ${JSON.stringify(ch)}`, sl, sc);
+    this.tokens.push({ kind: "eof", value: "", line: this.line, col: this.col, isQuoted: false, precedingSpace: false });
+    return this.tokens;
+  }
+  peek(offset = 0) {
+    return this.input[this.pos + offset] ?? "";
   }
-  tokens.push({ kind: "eof", value: "", line, col, isQuoted: false, precedingSpace: false });
-  return tokens;
+  advance() {
+    const ch = this.input[this.pos++] ?? "";
+    if (ch === "\n") {
+      this.line++;
+      this.col = 1;
+    } else {
+      this.col++;
+    }
+    return ch;
+  }
+  push(kind, value, l, c, isQuoted = false) {
+    this.tokens.push({ kind, value, line: l, col: c, isQuoted, precedingSpace: this.hadSpace });
+    this.hadSpace = false;
+  }
+};
+function tokenize(input) {
+  return new Lexer(input).tokenize();
 }
 function isUnquotedStart(ch) {
-  return ch !== "" && !'{}[],:=+#\n\r	 "$'.includes(ch);
+  return ch !== "" && !'{}[],:=+#\n\r	 "$?!@*&^\\'.includes(ch);
 }
 function isUnquotedContinue(ch, nextFn) {
-  if (ch === "" || '{}[],:=\n\r	 #"$'.includes(ch) || ch === " ") return false;
+  if (ch === "" || '{}[],:=\n\r	 #"$?!@*&^\\'.includes(ch) || ch === " ") return false;
   if (ch === "+" && nextFn() === "=") return false;
   if (ch === "/" && nextFn() === "/") return false;
   return true;
 }
 
 // src/internal/parser/parser.ts
-function parseTokens(tokens) {
-  let pos = 0;
-  function peek() {
-    return tokens[pos] ?? { 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 };
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.pos = 0;
   }
-  function advance() {
-    const t2 = tokens[pos];
-    if (pos < tokens.length) pos++;
-    return t2 ?? { kind: "eof", value: "", line: 0, col: 0, isQuoted: false, precedingSpace: false };
+  parse() {
+    this.skip("newline");
+    const t = this.peek();
+    if (t.kind === "lbrace") {
+      this.advance();
+      const first = this.parseObject(true);
+      const allFields = first.kind === "object" ? [...first.fields] : [];
+      while (true) {
+        this.skip("newline");
+        if (this.peek().kind === "eof") break;
+        if (this.peek().kind === "lbrace") {
+          this.advance();
+          const extra = this.parseObject(true);
+          if (extra.kind === "object") allFields.push(...extra.fields);
+        } else {
+          const rest = this.parseObject(false);
+          if (rest.kind === "object") allFields.push(...rest.fields);
+          break;
+        }
+      }
+      this.skip("newline");
+      const remaining = this.peek();
+      if (remaining.kind !== "eof") {
+        throw new ParseError(`Unexpected token '${remaining.value}' after closing brace`, remaining.line, remaining.col);
+      }
+      return { kind: "object", fields: allFields, pos: first.pos };
+    }
+    return this.parseObject(false);
+  }
+  peek(offset = 0) {
+    return this.tokens[this.pos + offset] ?? EOF_TOKEN;
   }
-  function skip(...kinds) {
-    while (kinds.includes(peek().kind)) advance();
+  advance() {
+    const t = this.tokens[this.pos];
+    if (this.pos < this.tokens.length) this.pos++;
+    return t ?? EOF_TOKEN;
   }
-  function currentPos() {
-    const t2 = peek();
-    return { line: t2.line, col: t2.col };
+  skip(...kinds) {
+    while (kinds.includes(this.peek().kind)) this.advance();
   }
-  function parseObject(expectClosingBrace) {
-    const p = currentPos();
+  currentPos() {
+    const t = this.peek();
+    return { line: t.line, col: t.col };
+  }
+  parseObject(expectClosingBrace) {
+    const p = this.currentPos();
     const fields = [];
     while (true) {
-      skip("newline");
-      const t2 = peek();
-      if (t2.kind === "eof" || t2.kind === "rbrace") break;
-      if (t2.kind === "unquoted" && t2.value === "include") {
-        advance();
-        fields.push(parseInclude());
-        skip("newline");
-        if (peek().kind === "comma") advance();
-        skip("newline");
+      this.skip("newline");
+      const t = this.peek();
+      if (t.kind === "eof" || t.kind === "rbrace") break;
+      if (t.kind === "unquoted" && t.value === "include") {
+        this.advance();
+        fields.push(this.parseInclude());
+        this.skip("newline");
+        if (this.peek().kind === "comma") this.advance();
+        this.skip("newline");
         continue;
       }
-      const keyPos = currentPos();
-      const key = parseKey();
-      skip("newline");
+      const keyPos = this.currentPos();
+      const key = this.parseKey();
+      this.skip("newline");
       let append = false;
-      const sep = peek();
-      if (sep.kind === "equals") advance();
+      const sep = this.peek();
+      if (sep.kind === "equals") this.advance();
       else if (sep.kind === "plus_equals") {
-        advance();
+        this.advance();
         append = true;
-      } else if (sep.kind === "colon") advance();
+      } else if (sep.kind === "colon") this.advance();
       else if (sep.kind === "lbrace") {
       } else if (sep.kind !== "newline" && sep.kind !== "eof") {
         throw new ParseError(`unexpected token after key: ${sep.kind}`, sep.line, sep.col);
       }
-      skip("newline");
-      const value = parseValue();
+      this.skip("newline");
+      const value = this.parseValue();
       fields.push({ key, value, append, pos: keyPos });
-      skip("newline");
-      if (peek().kind === "comma") advance();
-      skip("newline");
+      this.skip("newline");
+      if (this.peek().kind === "comma") this.advance();
+      this.skip("newline");
     }
     if (expectClosingBrace) {
-      const t2 = peek();
-      if (t2.kind !== "rbrace") throw new ParseError("expected }", t2.line, t2.col);
-      advance();
+      const t = this.peek();
+      if (t.kind !== "rbrace") throw new ParseError("expected }", t.line, t.col);
+      this.advance();
     }
     return { kind: "object", fields, pos: p };
   }
-  function parseKey() {
+  parseKey() {
     const segments = [];
     let trailingDot = false;
     while (true) {
-      const t2 = peek();
-      if (t2.kind === "string") {
-        advance();
-        segments.push(t2.value);
+      const t = this.peek();
+      if (t.kind === "string") {
+        this.advance();
+        segments.push(t.value);
         trailingDot = false;
-      } else if (t2.kind === "unquoted") {
-        advance();
-        const parts = t2.value.split(".");
+      } else if (t.kind === "unquoted") {
+        this.advance();
+        const parts = t.value.split(".");
         const filtered = parts.filter((s) => s.length > 0);
         segments.push(...filtered);
-        trailingDot = t2.value.endsWith(".");
+        trailingDot = t.value.endsWith(".");
       } else {
-        if (segments.length === 0) throw new ParseError(`expected key, got ${t2.kind}`, t2.line, t2.col);
+        if (segments.length === 0) throw new ParseError(`expected key, got ${t.kind}`, t.line, t.col);
         break;
       }
       if (trailingDot) continue;
-      const next = peek();
+      const next = this.peek();
       if (next.kind === "unquoted" && next.value === "." && !next.precedingSpace) {
-        advance();
+        this.advance();
         trailingDot = true;
         continue;
       }
@@ -414,102 +660,132 @@ function parseTokens(tokens) {
     }
     return segments;
   }
-  function parseInclude() {
-    const p = currentPos();
-    skip("newline");
-    const t2 = peek();
+  parseInclude() {
+    const p = this.currentPos();
+    this.skip("newline");
+    const t = this.peek();
     let path2;
-    if (t2.kind === "string") {
-      path2 = advance().value;
-    } else if (t2.kind === "unquoted" && (t2.value === "file(" || t2.value === "file")) {
-      advance();
-      while (peek().kind !== "string" && peek().kind !== "eof") advance();
-      if (peek().kind === "eof") throw new ParseError("expected include path", t2.line, t2.col);
-      path2 = advance().value;
-      while (peek().kind !== "newline" && peek().kind !== "rbrace" && peek().kind !== "eof") advance();
+    let required = false;
+    let isFile = false;
+    if (t.kind === "unquoted" && (t.value === "required(" || t.value === "required" || t.value.startsWith("required("))) {
+      if (t.value === "required") {
+        const next2 = this.peek(1);
+        if (next2.kind !== "unquoted" || !next2.value.startsWith("(")) {
+          throw new ParseError("include required must be followed by (", t.line, t.col);
+        }
+      }
+      required = true;
+      this.advance();
+      const innerPrefix = t.value.startsWith("required(") ? t.value.slice("required(".length) : "";
+      if (innerPrefix.startsWith("url") || innerPrefix.startsWith("classpath")) {
+        throw new ParseError("include url(...) and classpath(...) are not supported", t.line, t.col);
+      }
+      if (innerPrefix.startsWith("file")) {
+        isFile = true;
+      }
+      const next = this.peek();
+      if (next.kind === "unquoted" && (next.value === "url" || next.value.startsWith("url(") || next.value === "classpath" || next.value.startsWith("classpath("))) {
+        throw new ParseError("include url(...) and classpath(...) are not supported", next.line, next.col);
+      }
+      if (next.kind === "unquoted" && (next.value === "file(" || next.value === "file" || next.value.startsWith("file("))) {
+        isFile = true;
+      }
+      while (this.peek().kind !== "string" && this.peek().kind !== "eof") this.advance();
+      if (this.peek().kind === "eof") throw new ParseError("expected include path", t.line, t.col);
+      path2 = this.advance().value;
+      while (this.peek().kind !== "newline" && this.peek().kind !== "rbrace" && this.peek().kind !== "eof" && this.peek().kind !== "comma") this.advance();
+    } else if (t.kind === "string") {
+      path2 = this.advance().value;
+    } else if (t.kind === "unquoted" && (t.value === "file(" || t.value === "file")) {
+      isFile = true;
+      this.advance();
+      while (this.peek().kind !== "string" && this.peek().kind !== "eof") this.advance();
+      if (this.peek().kind === "eof") throw new ParseError("expected include path", t.line, t.col);
+      path2 = this.advance().value;
+      while (this.peek().kind !== "newline" && this.peek().kind !== "rbrace" && this.peek().kind !== "eof" && this.peek().kind !== "comma") this.advance();
+    } else if (t.kind === "unquoted" && (t.value === "url" || t.value.startsWith("url("))) {
+      throw new ParseError("include url(...) is not supported", t.line, t.col);
+    } else if (t.kind === "unquoted" && (t.value === "classpath" || t.value.startsWith("classpath("))) {
+      throw new ParseError("include classpath(...) is not supported", t.line, t.col);
     } else {
-      throw new ParseError(`expected include path, got ${t2.kind}`, t2.line, t2.col);
+      throw new ParseError(`expected include path, got ${t.kind}`, t.line, t.col);
     }
     return {
       key: [],
-      value: { kind: "include", path: path2, pos: p },
+      value: { kind: "include", path: path2, required, ...isFile ? { isFile: true } : {}, pos: p },
       append: false,
       pos: p
     };
   }
-  function parseValue() {
-    const p = currentPos();
+  parseValue() {
+    const p = this.currentPos();
     const parts = [];
     while (true) {
-      const t2 = peek();
-      if (t2.kind === "eof" || t2.kind === "newline" || t2.kind === "rbrace" || t2.kind === "rbracket" || t2.kind === "comma") break;
-      const hadSpace = t2.precedingSpace && parts.length > 0;
+      const t = this.peek();
+      if (t.kind === "eof" || t.kind === "newline" || t.kind === "rbrace" || t.kind === "rbracket" || t.kind === "comma") break;
+      const hadSpace = t.precedingSpace && parts.length > 0;
       let node;
-      if (t2.kind === "lbrace") {
-        advance();
-        node = parseObject(true);
-      } else if (t2.kind === "lbracket") {
-        advance();
-        node = parseArray();
-      } else if (t2.kind === "subst" || t2.kind === "opt_subst") {
-        advance();
-        node = { kind: "subst", path: t2.value, optional: t2.kind === "opt_subst", pos: { line: t2.line, col: t2.col } };
-      } else if (t2.kind === "string" || t2.kind === "triple_string") {
-        advance();
-        node = { kind: "scalar", value: t2.value, pos: { line: t2.line, col: t2.col } };
-      } else if (t2.kind === "unquoted") {
-        advance();
-        node = { kind: "scalar", value: parseScalarValue(t2.value), pos: { line: t2.line, col: t2.col } };
-      } else if ((t2.kind === "colon" || t2.kind === "equals") && parts.length > 0) {
-        advance();
-        node = { kind: "scalar", value: t2.value, pos: { line: t2.line, col: t2.col } };
+      if (t.kind === "lbrace") {
+        this.advance();
+        node = this.parseObject(true);
+      } else if (t.kind === "lbracket") {
+        this.advance();
+        node = this.parseArray();
+      } else if (t.kind === "subst" || t.kind === "opt_subst") {
+        this.advance();
+        node = { kind: "subst", path: t.value, optional: t.kind === "opt_subst", 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 } };
+      } else if (t.kind === "unquoted") {
+        this.advance();
+        node = { kind: "scalar", raw: t.value, valueType: this.scalarValueType(t.value), pos: { line: t.line, col: t.col } };
+      } else if ((t.kind === "colon" || t.kind === "equals") && parts.length > 0) {
+        this.advance();
+        node = { kind: "scalar", raw: t.value, valueType: "string", pos: { line: t.line, col: t.col } };
       } else {
         break;
       }
       if (hadSpace) {
-        parts.push({ kind: "scalar", value: " ", pos: { line: t2.line, col: t2.col } });
+        parts.push({ kind: "scalar", raw: " ", valueType: "string", pos: { line: t.line, col: t.col }, _separator: true });
       }
       parts.push(node);
     }
-    if (parts.length === 0) throw new ParseError("expected value", peek().line, peek().col);
+    if (parts.length === 0) throw new ParseError("expected value", this.peek().line, this.peek().col);
     if (parts.length === 1) return parts[0];
     return { kind: "concat", nodes: parts, pos: p };
   }
-  function parseArray() {
-    const p = currentPos();
+  parseArray() {
+    const p = this.currentPos();
     const items = [];
     while (true) {
-      skip("newline");
-      if (peek().kind === "rbracket" || peek().kind === "eof") break;
-      items.push(parseValue());
-      skip("newline");
-      if (peek().kind === "comma") advance();
-      skip("newline");
-    }
-    const t2 = peek();
-    if (t2.kind !== "rbracket") throw new ParseError("expected ]", t2.line, t2.col);
-    advance();
+      this.skip("newline");
+      if (this.peek().kind === "rbracket" || this.peek().kind === "eof") break;
+      items.push(this.parseValue());
+      this.skip("newline");
+      if (this.peek().kind === "comma") this.advance();
+      this.skip("newline");
+    }
+    const t = this.peek();
+    if (t.kind !== "rbracket") throw new ParseError("expected ]", t.line, t.col);
+    this.advance();
     return { kind: "array", items, pos: p };
   }
-  function parseScalarValue(raw) {
-    if (raw === "true") return true;
-    if (raw === "false") return false;
-    if (raw === "null") return null;
-    const n = Number(raw);
-    if (!isNaN(n) && raw.trim() !== "") return n;
-    return raw;
-  }
-  skip("newline");
-  const t = peek();
-  if (t.kind === "lbrace") {
-    advance();
-    return parseObject(true);
+  scalarValueType(raw) {
+    if (raw === "true" || raw === "false") return "boolean";
+    if (raw === "null") return "null";
+    if (raw.length > 0 && (raw.charCodeAt(0) >= 48 && raw.charCodeAt(0) <= 57 || raw.charCodeAt(0) === 45)) {
+      if (DECIMAL_NUMBER_RE.test(raw)) return "number";
+    }
+    return "string";
   }
-  return parseObject(false);
+};
+function parseTokens(tokens) {
+  return new Parser(tokens).parse();
 }
 
-// src/internal/resolver/resolver.ts
-import * as nodePath from "path";
+// src/internal/resolver/types.ts
+var separatorValues = /* @__PURE__ */ new WeakSet();
 function isSubst(v) {
   return v._kind === "subst-placeholder";
 }
@@ -525,77 +801,91 @@ function isResObj(v) {
 function makeResObj() {
   return { _kind: "res-obj", fields: /* @__PURE__ */ new Map(), priorValues: /* @__PURE__ */ new Map() };
 }
-function resolve2(ast, opts) {
-  const root = buildResObj(ast, opts);
-  const resolving = /* @__PURE__ */ new Set();
-  const resolvedCache = /* @__PURE__ */ new Map();
-  return resolveResObj(root, root, resolving, resolvedCache, opts);
-}
-function buildResObj(ast, opts) {
-  if (ast.kind !== "object") {
-    throw new ResolveError("root AST must be an object", "", ast.pos.line, ast.pos.col);
-  }
-  const obj = makeResObj();
-  for (const field of ast.fields) {
-    applyField(obj, field, opts);
+
+// 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 obj;
+  return segments;
 }
-function applyField(obj, field, opts) {
-  if (field.key.length === 0 && field.value.kind === "include") {
-    const included = loadInclude(field.value.path, opts);
-    deepMergeResObjInto(obj, included);
-    return;
-  }
-  const [head, ...tail] = field.key;
-  if (!head) return;
-  if (tail.length > 0) {
-    const syntheticAst = {
-      kind: "object",
-      fields: [{ key: tail, value: field.value, append: field.append, pos: field.pos }],
-      pos: field.pos
-    };
-    applyField(obj, { key: [head], value: syntheticAst, append: false, pos: field.pos }, opts);
-    return;
-  }
-  if (field.append) {
-    const existing2 = obj.fields.get(head) ?? { kind: "array", items: [] };
-    obj.priorValues.set(head, existing2);
-    obj.fields.set(head, {
-      _kind: "append-placeholder",
-      existing: existing2,
-      elem: astToResolverValue(field.value, opts)
-    });
-    return;
-  }
-  const existing = obj.fields.get(head);
-  const newVal = astToResolverValue(field.value, opts);
-  if (existing !== void 0) {
-    obj.priorValues.set(head, existing);
+function segmentsToKey(segments) {
+  return segments.map((s) => {
+    if (s === "" || /[^a-zA-Z0-9\-_]/.test(s)) {
+      return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return s;
+  }).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;
   }
-  if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
-    deepMergeResObjInto(existing, newVal);
-    return;
+  const val = root.fields.get(head);
+  if (val === void 0) return void 0;
+  if (tail.length === 0) return val;
+  if (isResObj(val)) return lookupPath(val, tail);
+  return void 0;
+}
+function lookupResObj(root, segments) {
+  let cur = root;
+  for (const seg of segments) {
+    const val = cur.fields.get(seg);
+    if (val === void 0 || !isResObj(val)) return void 0;
+    cur = val;
   }
-  obj.fields.set(head, newVal);
+  return cur;
 }
-function astToResolverValue(ast, opts) {
-  switch (ast.kind) {
-    case "scalar":
-      return { kind: "scalar", value: ast.value };
-    case "array":
-      return { kind: "array", items: ast.items.map((i) => astToResolverValue(i, opts)) };
-    case "object": {
-      const inner = buildResObj(ast, opts);
-      return inner;
+function deepMergeHoconValues(base, overlay) {
+  const merged = new Map(base.fields);
+  for (const [k, v] of overlay.fields) {
+    const existing = merged.get(k);
+    if (existing?.kind === "object" && v.kind === "object") {
+      merged.set(k, deepMergeHoconValues(existing, v));
+    } else {
+      merged.set(k, v);
     }
-    case "subst":
-      return { _kind: "subst-placeholder", path: ast.path, optional: ast.optional, line: ast.pos.line, col: ast.pos.col };
-    case "concat":
-      return { _kind: "concat-placeholder", nodes: ast.nodes.map((n) => astToResolverValue(n, opts)) };
-    case "include":
-      return { kind: "scalar", value: null };
   }
+  return { kind: "object", fields: merged };
 }
 function deepMergeResObjInto(dst, src) {
   for (const [k, srcVal] of src.fields) {
@@ -607,191 +897,635 @@ function deepMergeResObjInto(dst, src) {
       dst.fields.set(k, srcVal);
     }
   }
+  for (const [k, srcPrior] of src.priorValues) {
+    if (!dst.priorValues.has(k)) {
+      dst.priorValues.set(k, srcPrior);
+    }
+  }
 }
-function resolveResObj(obj, root, resolving, resolvedCache, opts) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [key, val] of obj.fields) {
-    const resolved = resolveVal(val, obj, root, resolving, resolvedCache, opts);
-    if (resolved !== void 0) {
-      result.set(key, resolved);
+function hoconValueToResObj(hv) {
+  const obj = makeResObj();
+  if (hv.kind !== "object") return obj;
+  for (const [key, val] of hv.fields) {
+    if (val.kind === "object") {
+      obj.fields.set(key, hoconValueToResObj(val));
     } else {
-      const prior = obj.priorValues.get(key);
-      if (prior !== void 0) {
-        const priorResolved = resolveVal(prior, obj, root, resolving, resolvedCache, opts);
-        if (priorResolved !== void 0) result.set(key, priorResolved);
-      }
+      obj.fields.set(key, val);
     }
   }
-  return { kind: "object", fields: result };
+  return obj;
 }
-function resolveVal(v, scope, root, resolving, resolvedCache, opts) {
-  if (isSubst(v)) return resolveSubst(v, scope, root, resolving, resolvedCache, opts);
-  if (isConcat(v)) return resolveConcat(v.nodes, scope, root, resolving, resolvedCache, opts);
-  if (isAppend(v)) return resolveAppend(v, scope, root, resolving, resolvedCache, opts);
-  if (isResObj(v)) return resolveResObj(v, root, resolving, resolvedCache, opts);
-  const hv = v;
-  if (hv.kind === "array") {
-    return {
-      kind: "array",
-      items: hv.items.map(
-        (item) => resolveVal(item, scope, root, resolving, resolvedCache, opts) ?? { kind: "scalar", value: null }
-      )
-    };
+function isFileNotFoundError(e) {
+  if (!(e instanceof Error)) return false;
+  const code = e.code;
+  if (code === "ENOENT" || code === "MODULE_NOT_FOUND") return true;
+  const msg = e.message.toLowerCase();
+  return msg.includes("not found") || msg.includes("no such file") || msg.includes("enoent");
+}
+
+// src/internal/resolver/include-loader.ts
+import * as nodePath from "path";
+
+// src/internal/properties/properties.ts
+function parseProperties(input) {
+  const root = /* @__PURE__ */ Object.create(null);
+  for (const line of input.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#") || trimmed.startsWith("!")) continue;
+    const sepIdx = findSeparator(trimmed);
+    if (sepIdx === -1) continue;
+    const key = trimmed.slice(0, sepIdx).trim();
+    const value = trimmed.slice(sepIdx + 1).trim();
+    if (key === "") continue;
+    setNested(root, key.split("."), value);
   }
-  return hv;
-}
-function resolveSubst(s, scope, root, resolving, resolvedCache, opts) {
-  if (resolvedCache.has(s.path)) return resolvedCache.get(s.path);
-  if (resolving.has(s.path)) {
-    const rootSeg = parseSubstPath(s.path)[0] ?? "";
-    const prior = scope.priorValues.get(rootSeg) ?? root.priorValues.get(rootSeg);
-    if (prior !== void 0) {
-      return resolveVal(prior, scope, root, new Set(resolving), resolvedCache, opts);
-    }
-    if (s.optional) return void 0;
-    throw new ResolveError(`circular substitution: ${s.path}`, s.path, s.line, s.col);
-  }
-  resolving.add(s.path);
-  try {
-    const found = lookupPath(root, parseSubstPath(s.path));
-    if (found !== void 0) {
-      if (isSubst(found) || isConcat(found)) {
-        const rootSeg = parseSubstPath(s.path)[0] ?? "";
-        const prior = scope.priorValues.get(rootSeg) ?? root.priorValues.get(rootSeg);
-        if (prior !== void 0) {
-          const result2 = resolveVal(prior, scope, root, resolving, resolvedCache, opts);
-          if (result2 !== void 0) resolvedCache.set(s.path, result2);
-          return result2;
-        }
-      }
-      const result = resolveVal(found, scope, root, resolving, resolvedCache, opts);
-      if (result !== void 0) resolvedCache.set(s.path, result);
-      return result;
-    }
-    const envVal = opts.env[s.path];
-    if (envVal !== void 0) {
-      const result = { kind: "scalar", value: envVal };
-      resolvedCache.set(s.path, result);
-      return result;
-    }
-    if (s.optional) return void 0;
-    throw new ResolveError(`could not resolve substitution: \${${s.path}}`, s.path, s.line, s.col);
-  } finally {
-    resolving.delete(s.path);
-  }
-}
-function resolveConcat(nodes, scope, root, resolving, resolvedCache, opts) {
-  const resolved = nodes.map((n) => resolveVal(n, scope, root, resolving, resolvedCache, opts)).filter((v) => v !== void 0);
-  if (resolved.length === 0) return { kind: "scalar", value: null };
-  if (resolved.length === 1) return resolved[0];
-  if (resolved.every((v) => v.kind === "object")) {
-    const merged = /* @__PURE__ */ new Map();
-    for (const v of resolved) {
-      if (v.kind === "object") {
-        for (const [k, val] of v.fields) {
-          merged.set(k, val);
-        }
-      }
-    }
-    return { kind: "object", fields: merged };
+  return root;
+}
+function findSeparator(line) {
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] === "=" || line[i] === ":") return i;
   }
-  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);
+  return -1;
+}
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function setNested(obj, segments, value) {
+  let current = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (seg === void 0 || DANGEROUS_KEYS.has(seg)) return;
+    if (!(seg in current) || typeof current[seg] !== "object" || current[seg] === null) {
+      current[seg] = /* @__PURE__ */ Object.create(null);
     }
-    return { kind: "array", items };
+    current = current[seg];
   }
-  const str = resolved.map((v) => v.kind === "scalar" ? String(v.value) : JSON.stringify(v)).join("");
-  return { kind: "scalar", value: str };
+  const last = segments[segments.length - 1];
+  if (last === void 0 || DANGEROUS_KEYS.has(last)) return;
+  current[last] = value;
 }
-function resolveAppend(a, scope, root, resolving, resolvedCache, opts) {
-  const existing = resolveVal(a.existing, scope, root, resolving, resolvedCache, opts) ?? { kind: "array", items: [] };
-  const elem = resolveVal(a.elem, scope, root, resolving, resolvedCache, opts);
-  const items = existing.kind === "array" ? [...existing.items] : [existing];
-  if (elem !== void 0) items.push(elem);
-  return { kind: "array", items };
+function propertiesToHoconValue(input) {
+  const parsed = parseProperties(input);
+  return recordToHoconValue(parsed);
 }
-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;
+function recordToHoconValue(obj) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [key, val] of Object.entries(obj)) {
+    if (typeof val === "string") {
+      fields.set(key, { kind: "scalar", raw: val, valueType: "string" });
+    } else if (val !== null && typeof val === "object") {
+      fields.set(key, recordToHoconValue(val));
     }
-    return void 0;
   }
-  const val = root.fields.get(head);
-  if (val === void 0) return void 0;
-  if (tail.length === 0) return val;
-  if (isResObj(val)) return lookupPath(val, tail);
-  return void 0;
+  return { kind: "object", fields };
 }
-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] !== '"') {
-        seg += raw[i];
-        i++;
+
+// src/internal/resolver/include-loader.ts
+var IncludeLoader = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Resolve an include path to an absolute path.
+   * - file() includes resolve relative to CWD (or as absolute paths),
+   *   NOT relative to the including file's directory.
+   * - Bare includes resolve relative to the including file's directory (baseDir).
+   */
+  resolveIncludePath(includePath, baseDir, isFile) {
+    return isFile ? nodePath.resolve(includePath) : baseDir ? nodePath.resolve(baseDir, includePath) : nodePath.resolve(includePath);
+  }
+  load(includePath, required, isFile) {
+    const { baseDir, includeStack = [] } = this.opts;
+    const absPath = this.resolveIncludePath(includePath, baseDir, !!isFile);
+    if (includeStack.includes(absPath)) {
+      throw new ResolveError(`circular include: ${absPath}`, absPath, 0, 0);
+    }
+    if (includeStack.length >= 50) {
+      throw new ResolveError(`include depth limit exceeded (max 50)`, includePath, 0, 0);
+    }
+    const hasExplicitExt = absPath.endsWith(".conf") || absPath.endsWith(".json") || absPath.endsWith(".properties");
+    if (hasExplicitExt) {
+      const result = this.loadSingle(absPath);
+      if (result !== void 0) return result;
+      if (required) {
+        throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
       }
-      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++;
+      return makeResObj();
+    }
+    const merged = makeResObj();
+    let foundAny = false;
+    const probeExts = [".properties", ".json", ".conf"];
+    for (const ext of probeExts) {
+      const obj = this.loadSingle(`${absPath}${ext}`);
+      if (obj !== void 0) {
+        deepMergeResObjInto(merged, obj);
+        foundAny = true;
       }
-      segments.push(seg.trim());
-      if (i < raw.length && raw[i] === ".") i++;
     }
+    if (!foundAny && required) {
+      throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
+    }
+    return merged;
   }
-  return segments;
-}
-function loadInclude(includePath, opts) {
-  const { baseDir, readFileSync: readFileSync2, includeStack = [], env } = opts;
-  const absPath = baseDir ? nodePath.resolve(baseDir, includePath) : nodePath.resolve(includePath);
-  if (includeStack.includes(absPath)) {
-    throw new ResolveError(`circular include: ${absPath}`, absPath, 0, 0);
-  }
-  const candidates = [absPath];
-  if (!absPath.endsWith(".conf") && !absPath.endsWith(".json") && !absPath.endsWith(".properties")) {
-    candidates.push(absPath + ".conf", absPath + ".json");
+  async loadAsync(includePath, required, isFile) {
+    const { baseDir, includeStack = [] } = this.opts;
+    const absPath = this.resolveIncludePath(includePath, baseDir, !!isFile);
+    if (includeStack.includes(absPath)) {
+      throw new ResolveError(`circular include: ${absPath}`, absPath, 0, 0);
+    }
+    if (includeStack.length >= 50) {
+      throw new ResolveError(`include depth limit exceeded (max 50)`, includePath, 0, 0);
+    }
+    const hasExplicitExt = absPath.endsWith(".conf") || absPath.endsWith(".json") || absPath.endsWith(".properties");
+    if (hasExplicitExt) {
+      const result = await this.loadSingleAsync(absPath);
+      if (result !== void 0) return result;
+      if (required) {
+        throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
+      }
+      return makeResObj();
+    }
+    const merged = makeResObj();
+    let foundAny = false;
+    const probeExts = [".properties", ".json", ".conf"];
+    for (const ext of probeExts) {
+      const obj = await this.loadSingleAsync(`${absPath}${ext}`);
+      if (obj !== void 0) {
+        deepMergeResObjInto(merged, obj);
+        foundAny = true;
+      }
+    }
+    if (!foundAny && required) {
+      throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
+    }
+    return merged;
   }
-  for (const candidate of candidates) {
+  loadSingle(candidate) {
+    const { readFileSync: readFileSync2, includeStack = [], env } = this.opts;
+    if (includeStack.includes(candidate)) {
+      throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0);
+    }
     let content;
     try {
       content = readFileSync2(candidate);
-    } catch {
-      continue;
+    } catch (e) {
+      if (isFileNotFoundError(e)) return void 0;
+      throw e;
+    }
+    if (candidate.endsWith(".properties")) {
+      return hoconValueToResObj(propertiesToHoconValue(content));
     }
+    const ast = parseTokens(tokenize(content));
+    return this.onBuildResObj(ast, {
+      env,
+      baseDir: nodePath.dirname(candidate),
+      readFileSync: readFileSync2,
+      includeStack: [...includeStack, candidate]
+    });
+  }
+  async loadSingleAsync(candidate) {
+    const { readFile, readFileSync: readFileSync2, includeStack = [], env } = this.opts;
+    const read = readFile ? async (p) => readFile(p) : async (p) => readFileSync2(p);
     if (includeStack.includes(candidate)) {
       throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0);
     }
+    let content;
+    try {
+      content = await read(candidate);
+    } catch (e) {
+      if (isFileNotFoundError(e)) return void 0;
+      throw e;
+    }
+    if (candidate.endsWith(".properties")) {
+      return hoconValueToResObj(propertiesToHoconValue(content));
+    }
     const ast = parseTokens(tokenize(content));
-    return buildResObj(ast, {
+    return this.onBuildResObjAsync(ast, {
       env,
       baseDir: nodePath.dirname(candidate),
       readFileSync: readFileSync2,
+      readFile,
       includeStack: [...includeStack, candidate]
     });
   }
-  return makeResObj();
+};
+
+// src/internal/resolver/structure-builder.ts
+var StructureBuilder = class _StructureBuilder {
+  constructor(opts) {
+    this.opts = opts;
+    this.loader = new IncludeLoader(opts);
+    this.loader.onBuildResObj = (a, o) => new _StructureBuilder(o).build(a);
+    this.loader.onBuildResObjAsync = async (a, o) => new _StructureBuilder(o).buildAsync(a);
+  }
+  build(ast, pathPrefix = []) {
+    if (ast.kind !== "object") {
+      throw new ResolveError("root AST must be an object", "", ast.pos.line, ast.pos.col);
+    }
+    const obj = makeResObj();
+    for (const field of ast.fields) {
+      this.applyField(obj, field, pathPrefix);
+    }
+    return obj;
+  }
+  async buildAsync(ast, pathPrefix = []) {
+    if (ast.kind !== "object") {
+      throw new ResolveError("root AST must be an object", "", ast.pos.line, ast.pos.col);
+    }
+    const obj = makeResObj();
+    for (const field of ast.fields) {
+      await this.applyFieldAsync(obj, field, pathPrefix);
+    }
+    return obj;
+  }
+  applyField(obj, field, pathPrefix) {
+    if (field.key.length === 0 && field.value.kind === "include") {
+      const included = this.loader.load(field.value.path, field.value.required, field.value.isFile);
+      if (pathPrefix.length > 0) {
+        this.relativizeResObj(included, pathPrefix);
+      }
+      deepMergeResObjInto(obj, included);
+      return;
+    }
+    const [head, ...tail] = field.key;
+    if (!head) return;
+    if (tail.length > 0) {
+      const syntheticAst = {
+        kind: "object",
+        fields: [{ key: tail, value: field.value, append: field.append, pos: field.pos }],
+        pos: field.pos
+      };
+      this.applyField(obj, { key: [head], value: syntheticAst, append: false, pos: field.pos }, pathPrefix);
+      return;
+    }
+    const childPrefix = [...pathPrefix, head];
+    if (field.append) {
+      const existing2 = obj.fields.get(head) ?? { kind: "array", items: [] };
+      obj.priorValues.set(head, existing2);
+      obj.fields.set(head, {
+        _kind: "append-placeholder",
+        existing: existing2,
+        elem: this.astToResolverValue(field.value, childPrefix)
+      });
+      return;
+    }
+    const existing = obj.fields.get(head);
+    const newVal = this.astToResolverValue(field.value, childPrefix);
+    if (existing !== void 0) {
+      obj.priorValues.set(head, existing);
+    }
+    if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
+      deepMergeResObjInto(existing, newVal);
+      return;
+    }
+    obj.fields.set(head, newVal);
+  }
+  async applyFieldAsync(obj, field, pathPrefix) {
+    if (field.key.length === 0 && field.value.kind === "include") {
+      const included = await this.loader.loadAsync(field.value.path, field.value.required, field.value.isFile);
+      if (pathPrefix.length > 0) {
+        this.relativizeResObj(included, pathPrefix);
+      }
+      deepMergeResObjInto(obj, included);
+      return;
+    }
+    const [head, ...tail] = field.key;
+    if (!head) return;
+    if (tail.length > 0) {
+      const syntheticAst = {
+        kind: "object",
+        fields: [{ key: tail, value: field.value, append: field.append, pos: field.pos }],
+        pos: field.pos
+      };
+      await this.applyFieldAsync(obj, { key: [head], value: syntheticAst, append: false, pos: field.pos }, pathPrefix);
+      return;
+    }
+    const childPrefix = [...pathPrefix, head];
+    if (field.append) {
+      const existing2 = obj.fields.get(head) ?? { kind: "array", items: [] };
+      obj.priorValues.set(head, existing2);
+      obj.fields.set(head, {
+        _kind: "append-placeholder",
+        existing: existing2,
+        elem: await this.astToResolverValueAsync(field.value, childPrefix)
+      });
+      return;
+    }
+    const existing = obj.fields.get(head);
+    const newVal = await this.astToResolverValueAsync(field.value, childPrefix);
+    if (existing !== void 0) {
+      obj.priorValues.set(head, existing);
+    }
+    if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
+      deepMergeResObjInto(existing, newVal);
+      return;
+    }
+    obj.fields.set(head, newVal);
+  }
+  astToResolverValue(ast, pathPrefix) {
+    switch (ast.kind) {
+      case "scalar": {
+        const sv = { kind: "scalar", raw: ast.raw, valueType: ast.valueType };
+        if (ast._separator) separatorValues.add(sv);
+        return sv;
+      }
+      case "array":
+        return { kind: "array", items: ast.items.map((i) => this.astToResolverValue(i, pathPrefix)) };
+      case "object": {
+        const inner = this.build(ast, pathPrefix);
+        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 };
+      case "concat":
+        return { _kind: "concat-placeholder", nodes: ast.nodes.map((n) => this.astToResolverValue(n, pathPrefix)) };
+      case "include":
+        return { kind: "scalar", raw: "null", valueType: "null" };
+    }
+  }
+  async astToResolverValueAsync(ast, pathPrefix) {
+    switch (ast.kind) {
+      case "scalar": {
+        const sv = { kind: "scalar", raw: ast.raw, valueType: ast.valueType };
+        if (ast._separator) separatorValues.add(sv);
+        return sv;
+      }
+      case "array": {
+        const items = [];
+        for (const i of ast.items) {
+          items.push(await this.astToResolverValueAsync(i, pathPrefix));
+        }
+        return { kind: "array", items };
+      }
+      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 };
+      case "concat": {
+        const nodes = [];
+        for (const n of ast.nodes) {
+          nodes.push(await this.astToResolverValueAsync(n, pathPrefix));
+        }
+        return { _kind: "concat-placeholder", nodes };
+      }
+      case "include":
+        return { kind: "scalar", raw: "null", valueType: "null" };
+    }
+  }
+  // ---- Relativize substitution paths for nested includes ----
+  relativizeSubstPaths(val, prefixSegments) {
+    if (isSubst(val)) {
+      val.segments = [...prefixSegments, ...val.segments];
+      val.prefixLen += prefixSegments.length;
+      return;
+    }
+    if (isConcat(val)) {
+      for (const node of val.nodes) {
+        this.relativizeSubstPaths(node, prefixSegments);
+      }
+      return;
+    }
+    if (isAppend(val)) {
+      this.relativizeSubstPaths(val.existing, prefixSegments);
+      this.relativizeSubstPaths(val.elem, prefixSegments);
+      return;
+    }
+    if (isResObj(val)) {
+      this.relativizeResObj(val, prefixSegments);
+      return;
+    }
+    const hv = val;
+    if (hv.kind === "array") {
+      for (const item of hv.items) {
+        this.relativizeSubstPaths(item, prefixSegments);
+      }
+    }
+  }
+  relativizeResObj(obj, prefixSegments) {
+    for (const val of obj.fields.values()) {
+      this.relativizeSubstPaths(val, prefixSegments);
+    }
+    for (const val of obj.priorValues.values()) {
+      this.relativizeSubstPaths(val, prefixSegments);
+    }
+  }
+};
+
+// src/internal/resolver/substitution-resolver.ts
+var SubstitutionResolver = class {
+  constructor(root, opts) {
+    this.root = root;
+    this.opts = opts;
+    this.resolving = /* @__PURE__ */ new Set();
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  resolve() {
+    return this.resolveResObj(this.root);
+  }
+  resolveResObj(obj) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, val] of obj.fields) {
+      const resolved = this.resolveVal(val, obj);
+      if (resolved !== void 0) {
+        if (resolved.kind === "object") {
+          const prior = obj.priorValues.get(key);
+          if (prior !== void 0) {
+            const priorResolved = this.resolveVal(prior, obj);
+            if (priorResolved !== void 0 && priorResolved.kind === "object") {
+              result.set(
+                key,
+                deepMergeHoconValues(
+                  priorResolved,
+                  resolved
+                )
+              );
+              continue;
+            }
+          }
+        }
+        result.set(key, resolved);
+      } else {
+        const prior = obj.priorValues.get(key);
+        if (prior !== void 0) {
+          const priorResolved = this.resolveVal(prior, obj);
+          if (priorResolved !== void 0) result.set(key, priorResolved);
+        }
+      }
+    }
+    return { kind: "object", fields: result };
+  }
+  resolveVal(v, scope) {
+    if (isSubst(v)) return this.resolveSubst(v, scope);
+    if (isConcat(v)) return this.resolveConcat(v.nodes, scope);
+    if (isAppend(v)) return this.resolveAppend(v, scope);
+    if (isResObj(v)) return this.resolveResObj(v);
+    const hv = v;
+    if (hv.kind === "array") {
+      return {
+        kind: "array",
+        items: hv.items.map(
+          (item) => this.resolveVal(item, scope) ?? { kind: "scalar", raw: "null", valueType: "null" }
+        )
+      };
+    }
+    return hv;
+  }
+  segmentsEqual(a, b) {
+    return a.length === b.length && a.every((seg, i) => seg === b[i]);
+  }
+  resolveSubst(s, scope) {
+    const key = segmentsToKey(s.segments);
+    if (this.cache.has(key)) return this.cache.get(key);
+    if (this.resolving.has(key)) {
+      let prior;
+      if (s.prefixLen > 0) {
+        const leafSeg = s.segments[s.segments.length - 1] ?? "";
+        const parentScope = lookupResObj(
+          this.root,
+          s.segments.slice(0, s.segments.length - 1)
+        );
+        prior = parentScope?.priorValues.get(leafSeg);
+      } else {
+        const rootSeg = s.segments[0] ?? "";
+        prior = scope.priorValues.get(rootSeg) ?? this.root.priorValues.get(rootSeg);
+      }
+      if (prior !== void 0) {
+        const saved = this.resolving;
+        this.resolving = new Set(saved);
+        try {
+          return this.resolveVal(prior, scope);
+        } finally {
+          this.resolving = saved;
+        }
+      }
+      if (s.optional) return void 0;
+      throw new ResolveError(
+        `circular substitution: ${key}`,
+        key,
+        s.line,
+        s.col
+      );
+    }
+    this.resolving.add(key);
+    try {
+      const found = lookupPath(this.root, s.segments);
+      if (found !== void 0) {
+        if (isSubst(found) || isConcat(found)) {
+          const isSelfRef = isSubst(found) ? this.segmentsEqual(found.segments, s.segments) : isConcat(found) && found.nodes.some(
+            (n) => isSubst(n) && this.segmentsEqual(n.segments, s.segments)
+          );
+          if (isSelfRef) {
+            let prior;
+            if (s.prefixLen > 0) {
+              const leafSeg = s.segments[s.segments.length - 1] ?? "";
+              const parentScope = lookupResObj(
+                this.root,
+                s.segments.slice(0, s.segments.length - 1)
+              );
+              prior = parentScope?.priorValues.get(leafSeg);
+            } else {
+              const rootSeg = s.segments[0] ?? "";
+              prior = scope.priorValues.get(rootSeg) ?? this.root.priorValues.get(rootSeg);
+            }
+            if (prior !== void 0) {
+              const result2 = this.resolveVal(prior, scope);
+              if (result2 !== void 0) this.cache.set(key, result2);
+              return result2;
+            }
+          }
+        }
+        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] ?? "";
+          let prior;
+          if (s.prefixLen > 0) {
+            const parentScope = lookupResObj(
+              this.root,
+              s.segments.slice(0, s.segments.length - 1)
+            );
+            prior = parentScope?.priorValues.get(leafSeg);
+          } else {
+            prior = scope.priorValues.get(leafSeg) ?? this.root.priorValues.get(leafSeg);
+          }
+          if (prior !== void 0) {
+            const priorResolved = this.resolveVal(prior, scope);
+            if (priorResolved !== void 0 && priorResolved.kind === "object") {
+              result = deepMergeHoconValues(
+                priorResolved,
+                result
+              );
+            }
+          }
+        }
+        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);
+      if (envVal !== void 0) {
+        const result = { kind: "scalar", raw: envVal, valueType: "string" };
+        this.cache.set(key, result);
+        return result;
+      }
+      if (s.optional) return void 0;
+      throw new ResolveError(
+        `could not resolve substitution: \${${key}}`,
+        key,
+        s.line,
+        s.col
+      );
+    } finally {
+      this.resolving.delete(key);
+    }
+  }
+  resolveConcat(nodes, scope) {
+    const resolved = nodes.map((n) => this.resolveVal(n, scope)).filter((v) => v !== void 0);
+    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);
+            }
+          }
+        }
+      }
+      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);
+      }
+      return { kind: "array", items };
+    }
+    const str = resolved.map((v) => v.kind === "scalar" ? v.raw : JSON.stringify(v)).join("");
+    return { kind: "scalar", raw: str, valueType: "string" };
+  }
+  resolveAppend(a, scope) {
+    const existing = this.resolveVal(a.existing, scope) ?? { kind: "array", items: [] };
+    const elem = this.resolveVal(a.elem, scope);
+    const items = existing.kind === "array" ? [...existing.items] : [existing];
+    if (elem !== void 0) items.push(elem);
+    return { kind: "array", items };
+  }
+};
+
+// src/internal/resolver/resolver.ts
+function resolve2(ast, opts) {
+  const root = new StructureBuilder(opts).build(ast);
+  return new SubstitutionResolver(root, opts).resolve();
+}
+async function resolveAsync(ast, opts) {
+  const root = await new StructureBuilder(opts).buildAsync(ast);
+  return new SubstitutionResolver(root, opts).resolve();
 }
 
 // src/parse.ts
@@ -808,20 +1542,28 @@ function defaultReadFileSync(filePath) {
 async function defaultReadFile(filePath) {
   return fs.promises.readFile(filePath, "utf-8");
 }
-function parse(input, opts = {}) {
+function buildResolveContext(input, opts) {
   const tokens = tokenize(input);
   const ast = parseTokens(tokens);
   const resolveOpts = {
     env: getEnv(opts),
     baseDir: opts.baseDir,
-    readFileSync: opts.readFileSync ?? defaultReadFileSync
+    readFileSync: opts.readFileSync ?? defaultReadFileSync,
+    readFile: opts.readFile
   };
+  return { ast, resolveOpts };
+}
+function parse(input, opts = {}) {
+  const { ast, resolveOpts } = buildResolveContext(input, opts);
   const value = resolve2(ast, resolveOpts);
   if (value.kind !== "object") throw new Error("resolved value is not an object");
   return new Config(value);
 }
 async function parseAsync(input, opts = {}) {
-  return Promise.resolve(parse(input, opts));
+  const { ast, resolveOpts } = buildResolveContext(input, opts);
+  const value = await resolveAsync(ast, resolveOpts);
+  if (value.kind !== "object") throw new Error("resolved value is not an object");
+  return new Config(value);
 }
 function parseFile(filePath, opts = {}) {
   if (typeof process === "undefined" && !opts.readFileSync) {
@@ -843,9 +1585,10 @@ async function parseFileAsync(filePath, opts = {}) {
   const resolvedPath = path.resolve(filePath);
   const readFile = opts.readFile ?? defaultReadFile;
   const input = await readFile(resolvedPath);
-  return parse(input, {
+  return parseAsync(input, {
     ...opts,
     baseDir: opts.baseDir ?? path.dirname(resolvedPath),
+    readFile,
     readFileSync: opts.readFileSync ?? defaultReadFileSync
   });
 }