@o3co/ts.hocon 1.13.0 → 1.14.1

package/dist/chunk-L3D2RE2U.cjs

@@ -0,0 +1,3801 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/internal/exact-ratio.ts
+var EXACT_LIMIT = 2n ** 53n;
+function bitLength(n) {
+  return n.toString(2).length;
+}
+function timesPowerOfTwo(x, e) {
+  while (e > 1e3) {
+    x *= 2 ** 1e3;
+    e -= 1e3;
+  }
+  while (e < -1e3) {
+    x *= 2 ** -1e3;
+    e += 1e3;
+  }
+  return x * 2 ** e;
+}
+function ratioToNumber(n, d) {
+  if (n === 0n) return 0;
+  if (n <= EXACT_LIMIT && n >= -EXACT_LIMIT && d <= EXACT_LIMIT) return Number(n) / Number(d);
+  const negative = n < 0n;
+  const a = negative ? -n : n;
+  let shift = 65 - (bitLength(a) - bitLength(d));
+  for (; ; ) {
+    const num = shift >= 0 ? a << BigInt(shift) : a;
+    const den = shift >= 0 ? d : d << BigInt(-shift);
+    const q = num / den;
+    const length = bitLength(q);
+    if (length > 65) {
+      shift--;
+      continue;
+    }
+    if (length < 65) {
+      shift++;
+      continue;
+    }
+    const value = shift > 1086 ? subnormalRatio(a, d) : timesPowerOfTwo(Number(q | (num % den === 0n ? 0n : 1n)), -shift);
+    return negative ? -value : value;
+  }
+}
+function subnormalRatio(a, d) {
+  const num = a << 1074n;
+  let k = num / d;
+  const twice = num % d * 2n;
+  if (twice > d || twice === d && (k & 1n) === 1n) k++;
+  return Number(k) * 2 ** -1074;
+}
+
+// src/coerce.ts
+var DECIMAL_NUMBER_RE = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+function isHoconWs(cp) {
+  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 trimHoconWs(s) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && isHoconWs(s.charCodeAt(start))) {
+    start++;
+  }
+  while (end > start && isHoconWs(s.charCodeAt(end - 1))) {
+    end--;
+  }
+  return s.slice(start, end);
+}
+var TRUTHY = /* @__PURE__ */ new Set(["true", "yes", "on"]);
+var FALSY = /* @__PURE__ */ new Set(["false", "no", "off"]);
+function coerceBoolean(value) {
+  const lower = value.toLowerCase();
+  if (TRUTHY.has(lower)) return true;
+  if (FALSY.has(lower)) return false;
+  return void 0;
+}
+function coerceNumber(value) {
+  if (!DECIMAL_NUMBER_RE.test(value)) return void 0;
+  return Number(value);
+}
+function isDigitChar(ch) {
+  return ch !== void 0 && ch >= "0" && ch <= "9";
+}
+function splitUnitText(value) {
+  const t = trimHoconWs(value);
+  let i = 0;
+  const negative = t[0] === "-";
+  if (t[0] === "-" || t[0] === "+") i++;
+  const intStart = i;
+  while (isDigitChar(t[i])) i++;
+  const intDigits = t.slice(intStart, i);
+  let fraction = "";
+  if (t[i] === ".") {
+    const fracStart = ++i;
+    while (isDigitChar(t[i])) i++;
+    fraction = t.slice(fracStart, i);
+  }
+  if (intDigits === "" && fraction === "") return void 0;
+  let exponent = 0;
+  if (t[i] === "e" || t[i] === "E") {
+    let j = i + 1;
+    if (t[j] === "+" || t[j] === "-") j++;
+    if (isDigitChar(t[j])) {
+      const expStart = j;
+      while (isDigitChar(t[j])) j++;
+      const digits = t.slice(expStart, j).replace(/^0+(?=\d)/, "");
+      const magnitude2 = digits.length > 12 ? 1e12 : Number(digits);
+      exponent = t[i + 1] === "-" ? -magnitude2 : magnitude2;
+      i = j;
+    }
+  }
+  const magnitude = BigInt(intDigits + fraction || "0");
+  return {
+    mantissa: negative ? -magnitude : magnitude,
+    scale: fraction.length - exponent,
+    unit: trimHoconWs(t.slice(i))
+  };
+}
+function decimalMagnitude(text) {
+  if (text.mantissa === 0n) return void 0;
+  const digits = (text.mantissa < 0n ? -text.mantissa : text.mantissa).toString().length;
+  return digits - 1 - text.scale;
+}
+function scaledRatio(text, factor) {
+  return text.scale >= 0 ? [text.mantissa * factor, 10n ** BigInt(text.scale)] : [text.mantissa * factor * 10n ** BigInt(-text.scale), 1n];
+}
+var DURATION_UNITS = new Map([
+  // S19.1–S19.3: the bare nano/micro/milli (+plural) aliases are part of the
+  // spec's unit lists (HOCON.md L1307–L1309) and accepted by Lightbend
+  // (typesafe-config 1.4.6 probe, 2026-08-18).
+  ...["ns", "nano", "nanos", "nanosecond", "nanoseconds"].map((u) => [u, 1n]),
+  ...["us", "micro", "micros", "microsecond", "microseconds"].map((u) => [u, 1000n]),
+  ...["ms", "milli", "millis", "millisecond", "milliseconds"].map((u) => [u, 1000000n]),
+  ...["s", "second", "seconds"].map((u) => [u, 1000000000n]),
+  ...["m", "minute", "minutes"].map((u) => [u, 60000000000n]),
+  ...["h", "hour", "hours"].map((u) => [u, 3600000000000n]),
+  ...["d", "day", "days"].map((u) => [u, 86400000000000n])
+]);
+var OUTPUT_DURATION_UNITS = /* @__PURE__ */ new Map([
+  ["ns", 1n],
+  ["us", 1000n],
+  ["ms", 1000000n],
+  ["s", 1000000000n],
+  ["m", 60000000000n],
+  ["h", 3600000000000n],
+  ["d", 86400000000000n]
+]);
+function parseDuration(value, outputUnit = "ms") {
+  const text = splitUnitText(value);
+  if (text === void 0) return NaN;
+  const per = OUTPUT_DURATION_UNITS.get(outputUnit);
+  if (per === void 0) return NaN;
+  const unit = text.unit === "" ? 1000000n : DURATION_UNITS.get(text.unit);
+  if (unit === void 0) return NaN;
+  const magnitude = decimalMagnitude(text);
+  if (magnitude === void 0) return 0;
+  if (magnitude > 330) return text.mantissa < 0n ? -Infinity : Infinity;
+  if (magnitude < -345) return text.mantissa < 0n ? -0 : 0;
+  const [n, d] = scaledRatio(text, unit);
+  return ratioToNumber(n, d * per);
+}
+var BYTE_UNITS = new Map([
+  // S21.1–S21.4 — the EXACT Lightbend/typesafe-config unit set (1.4.6 probe,
+  // 2026-08-18). Multi-letter units are case-sensitive: the SI decimal short
+  // form is `kB` (NOT `KB`/`kb` — Lightbend rejects both), higher decimals
+  // are `MB`…`YB`, binary prefixes are `Ki`/`KiB`…`Yi`/`YiB` with capital
+  // first letter, and long forms are lowercase only (`kilobyte`, never
+  // `Kilobyte`). Only the bare byte unit (`B`/`b`) and the single-letter
+  // -Xmx forms accept both cases.
+  ...["B", "b", "byte", "bytes"].map((u) => [u, 1n]),
+  ...[
+    ["kB", "kilo"],
+    ["MB", "mega"],
+    ["GB", "giga"],
+    ["TB", "tera"],
+    ["PB", "peta"],
+    ["EB", "exa"],
+    ["ZB", "zetta"],
+    ["YB", "yotta"]
+  ].flatMap(([short, prefix], i) => {
+    const size = 1000n ** BigInt(i + 1);
+    return [[short, size], [`${prefix}byte`, size], [`${prefix}bytes`, size]];
+  }),
+  ...[
+    ["K", "kibi"],
+    ["M", "mebi"],
+    ["G", "gibi"],
+    ["T", "tebi"],
+    ["P", "pebi"],
+    ["E", "exbi"],
+    ["Z", "zebi"],
+    ["Y", "yobi"]
+  ].flatMap(([letter, prefix], i) => {
+    const size = 1024n ** BigInt(i + 1);
+    return [
+      [`${letter}i`, size],
+      [`${letter}iB`, size],
+      [`${prefix}byte`, size],
+      [`${prefix}bytes`, size],
+      // S21.4 — single letters are powers of two (java -Xmx convention), in
+      // both cases, through the full ladder.
+      [letter, size],
+      [letter.toLowerCase(), size]
+    ];
+  })
+]);
+var OUTPUT_BYTE_UNITS = /* @__PURE__ */ new Map([
+  ["B", 1],
+  ["KB", 1e3],
+  ["KiB", 1024],
+  ["MB", 1e6],
+  ["MiB", 1048576],
+  ["GB", 1e9],
+  ["GiB", 1073741824],
+  ["TB", 1e12],
+  ["TiB", 1099511627776]
+]);
+var BYTE_SIZE_OVERFLOW = "byte size overflows representable range (max 2^53-1 bytes)";
+function byteSizeOverflow() {
+  return new RangeError(BYTE_SIZE_OVERFLOW);
+}
+function parseBytes(value, outputUnit = "B") {
+  const text = splitUnitText(value);
+  if (text === void 0) return NaN;
+  const per = OUTPUT_BYTE_UNITS.get(outputUnit);
+  if (per === void 0) return NaN;
+  const unit = text.unit === "" ? 1n : BYTE_UNITS.get(text.unit);
+  if (unit === void 0) return NaN;
+  const magnitude = decimalMagnitude(text);
+  if (magnitude === void 0) return 0;
+  if (magnitude >= 16) throw byteSizeOverflow();
+  if (magnitude < -25) return 0;
+  const [n, d] = scaledRatio(text, unit);
+  const bytes = n / d;
+  if (bytes > MAX_SAFE_BYTES || bytes < -MAX_SAFE_BYTES) throw byteSizeOverflow();
+  return Number(bytes) / per;
+}
+var MAX_SAFE_BYTES = BigInt(Number.MAX_SAFE_INTEGER);
+function readDuration(text, outputUnit) {
+  const value = parseDuration(text, outputUnit);
+  if (Number.isNaN(value)) return { ok: false, problem: "invalid" };
+  if (!Number.isFinite(value)) return { ok: false, problem: "overflow" };
+  return { ok: true, value };
+}
+function readBytes(text, outputUnit) {
+  let value;
+  try {
+    value = parseBytes(text, outputUnit);
+  } catch (err) {
+    if (err instanceof RangeError && err.message === BYTE_SIZE_OVERFLOW) {
+      return { ok: false, problem: "overflow" };
+    }
+    throw err;
+  }
+  if (Number.isNaN(value)) return { ok: false, problem: "invalid" };
+  if (value < 0) return { ok: false, problem: "negative" };
+  return { ok: true, value };
+}
+var PERIOD_UNITS = /* @__PURE__ */ new Map([
+  ["", { field: "days", factor: 1 }],
+  ["d", { field: "days", factor: 1 }],
+  ["day", { field: "days", factor: 1 }],
+  ["days", { field: "days", factor: 1 }],
+  ["w", { field: "days", factor: 7 }],
+  ["week", { field: "days", factor: 7 }],
+  ["weeks", { field: "days", factor: 7 }],
+  ["m", { field: "months", factor: 1 }],
+  ["mo", { field: "months", factor: 1 }],
+  ["month", { field: "months", factor: 1 }],
+  ["months", { field: "months", factor: 1 }],
+  ["y", { field: "years", factor: 1 }],
+  ["year", { field: "years", factor: 1 }],
+  ["years", { field: "years", factor: 1 }]
+]);
+var I32_MIN = -(2 ** 31);
+var I32_MAX = 2 ** 31 - 1;
+function readPeriod(text) {
+  const trimmed = trimHoconWs(text);
+  let i = 0;
+  while (i < trimmed.length && "+-0123456789".includes(trimmed[i])) i++;
+  const digits = trimmed.slice(0, i);
+  const unit = PERIOD_UNITS.get(trimHoconWs(trimmed.slice(i)));
+  if (!/^[+-]?\d+$/.test(digits) || unit === void 0) return { ok: false, problem: "invalid" };
+  const n = Number(digits) * unit.factor;
+  if (n < I32_MIN || n > I32_MAX) return { ok: false, problem: "invalid" };
+  const value = { years: 0, months: 0, days: 0, [unit.field]: n === 0 ? 0 : n };
+  return { ok: true, value };
+}
+
+// src/errors.ts
+var ParseError = class extends Error {
+  constructor(message, line, col, file) {
+    super(message);
+    this.line = line;
+    this.col = col;
+    this.file = file;
+    this.name = "ParseError";
+  }
+};
+var ResolveError = class extends Error {
+  constructor(message, path, line, col, file) {
+    super(message);
+    this.path = path;
+    this.line = line;
+    this.col = col;
+    this.file = file;
+    this.name = "ResolveError";
+  }
+};
+var PackageLookupError = class extends ResolveError {
+  constructor(message, identifier, packageFile, line, col) {
+    super(message, `${identifier}/${packageFile}`, line, col);
+    this.identifier = identifier;
+    this.packageFile = packageFile;
+    this.name = "PackageLookupError";
+  }
+};
+var ConfigError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "ConfigError";
+  }
+};
+var NotResolvedError = class extends ConfigError {
+  constructor(path) {
+    super(`value at path "${path}" is not resolved (call resolve() first)`, path);
+    this.name = "NotResolvedError";
+  }
+};
+
+// src/internal/strip-bom.ts
+function stripBom(input) {
+  return input.charCodeAt(0) === 65279 ? input.slice(1) : input;
+}
+
+// src/internal/depth.ts
+var MAX_PATH_SEGMENTS = 64;
+function tooDeep(segments) {
+  return segments > MAX_PATH_SEGMENTS;
+}
+function guardStackDepth(fn, wrap) {
+  try {
+    return fn();
+  } catch (e) {
+    if (!isStackOverflow(e)) throw e;
+    throw wrap(STACK_MESSAGE);
+  }
+}
+var STACK_MESSAGE = "input is nested too deeply for this engine's stack, or contains a cycle (flatten the document, or break the cycle)";
+function isStackOverflow(e) {
+  if (!(e instanceof RangeError)) return false;
+  const m = e.message.toLowerCase();
+  return m.includes("call stack") || // V8: "Maximum call stack size exceeded"
+  m.includes("recursion") || // SpiderMonkey: "too much recursion"
+  m.includes("stack overflow");
+}
+function depthError(message) {
+  return new ConfigError(message, "");
+}
+async function guardStackDepthAsync(fn, wrap) {
+  try {
+    return await fn();
+  } catch (e) {
+    if (!isStackOverflow(e)) throw e;
+    throw wrap(STACK_MESSAGE);
+  }
+}
+
+// src/internal/properties/properties.ts
+function parseProperties(input) {
+  const pairs = [];
+  for (const { text, line } of logicalLines(stripBom(input))) {
+    const [rawKey, rawValue] = splitKeyValue(text);
+    const key = unescapeProps(rawKey, line);
+    if (key === "") continue;
+    const segments = key.split(".");
+    if (tooDeep(segments.length)) {
+      throw new ParseError(
+        `key maps to a path ${segments.length} segments deep, over the limit of ${MAX_PATH_SEGMENTS}`,
+        line,
+        1
+      );
+    }
+    pairs.push([segments, unescapeProps(rawValue, line)]);
+  }
+  return nestPairs(pairs);
+}
+function nestPairs(pairs) {
+  const root = /* @__PURE__ */ Object.create(null);
+  const sorted = [...pairs].sort(([a], [b]) => compareSegments(a, b));
+  for (const [segments, value] of sorted) {
+    setNested(root, segments, value);
+  }
+  return root;
+}
+function compareSegments(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  return a.length - b.length;
+}
+function pathKey(segments) {
+  return JSON.stringify(segments);
+}
+function logicalLines(input) {
+  const natural = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const out = [];
+  for (let i = 0; i < natural.length; i++) {
+    let text = trimLeadingSpace(_nullishCoalesce(natural[i], () => ( "")));
+    if (text === "" || text.startsWith("#") || text.startsWith("!")) continue;
+    const start = i + 1;
+    while (endsWithContinuation(text)) {
+      text = text.slice(0, -1);
+      if (i + 1 >= natural.length) break;
+      i++;
+      text += trimLeadingSpace(_nullishCoalesce(natural[i], () => ( "")));
+    }
+    out.push({ text, line: start });
+  }
+  return out;
+}
+function trimLeadingSpace(s) {
+  return s.replace(/^[ \t\f]+/, "");
+}
+function endsWithContinuation(line) {
+  let n = 0;
+  for (let i = line.length - 1; i >= 0 && line[i] === "\\"; i--) n++;
+  return n % 2 === 1;
+}
+function splitKeyValue(line) {
+  let key = "";
+  let i = 0;
+  for (; i < line.length; i++) {
+    const c = line[i];
+    if (c === "\\" && i + 1 < line.length) {
+      key += c + line[i + 1];
+      i++;
+      continue;
+    }
+    if (c === "=" || c === ":" || isPropsSpace(c)) break;
+    key += c;
+  }
+  while (i < line.length && isPropsSpace(line[i])) i++;
+  if (i < line.length && (line[i] === "=" || line[i] === ":")) {
+    i++;
+    while (i < line.length && isPropsSpace(line[i])) i++;
+  }
+  return [key, line.slice(i)];
+}
+function isPropsSpace(c) {
+  return c === " " || c === "	" || c === "\f";
+}
+function unescapeProps(s, line) {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] !== "\\") {
+      out += s[i];
+      continue;
+    }
+    i++;
+    if (i >= s.length) break;
+    const e = s[i];
+    switch (e) {
+      case "t":
+        out += "	";
+        break;
+      case "n":
+        out += "\n";
+        break;
+      case "r":
+        out += "\r";
+        break;
+      case "f":
+        out += "\f";
+        break;
+      case "u": {
+        const hex = s.slice(i + 1, i + 5);
+        if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+          throw new ParseError(`malformed \\u escape in .properties: \\u${hex}`, line, i + 1);
+        }
+        out += String.fromCharCode(parseInt(hex, 16));
+        i += 4;
+        break;
+      }
+      default:
+        out += e;
+    }
+  }
+  return out;
+}
+function setNested(obj, segments, value) {
+  let current = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (!(seg in current) || typeof current[seg] !== "object" || current[seg] === null) {
+      current[seg] = /* @__PURE__ */ Object.create(null);
+    }
+    current = current[seg];
+  }
+  const last = segments[segments.length - 1];
+  if (typeof current[last] === "object" && current[last] !== null) return;
+  current[last] = value;
+}
+function propertiesToHoconValue(input) {
+  const parsed = parseProperties(input);
+  return recordToHoconValue(parsed);
+}
+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 { kind: "object", fields };
+}
+
+// src/internal/resolver/fold-self-ref.ts
+function substFullKey(s) {
+  return stringSegmentsToKey(s.segments.map((seg) => seg.text));
+}
+function stringSegmentsToKey(segments) {
+  return segments.map((t) => {
+    if (t === "" || /[^a-zA-Z0-9\-_]/.test(t)) {
+      return `"${t.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return t;
+  }).join(".");
+}
+function prefixSelfRefRemainder(s, fullKey) {
+  const texts = s.segments.map((seg) => seg.text);
+  if (!stringSegmentsToKey(texts).startsWith(fullKey + ".")) return null;
+  for (let n = 1; n < texts.length; n++) {
+    if (stringSegmentsToKey(texts.slice(0, n)) === fullKey) return texts.slice(n);
+  }
+  return null;
+}
+function navigateResolverValue(v, remainder) {
+  let cur = v;
+  for (const seg of remainder) {
+    if (isSubst(cur) || isConcat(cur)) return null;
+    if (isResObj(cur)) {
+      const next = cur.fields.get(seg);
+      if (next === void 0) return void 0;
+      cur = next;
+      continue;
+    }
+    const hv = cur;
+    if (hv.kind === "object") {
+      const next = hv.fields.get(seg);
+      if (next === void 0) return void 0;
+      cur = next;
+      continue;
+    }
+    return void 0;
+  }
+  return cur;
+}
+function foldPrefixSelfRef(s, replacement, remainder) {
+  const navigated = navigateResolverValue(replacement, remainder);
+  if (navigated === null) return s;
+  if (navigated === void 0) {
+    return {
+      _kind: "subst-placeholder",
+      segments: s.segments.map((seg) => ({ text: seg.text, line: seg.line, col: seg.col })),
+      optional: s.optional,
+      knownAbsent: true,
+      listSuffix: s.listSuffix,
+      line: s.line,
+      col: s.col,
+      prefixLen: s.prefixLen
+    };
+  }
+  return cloneResolverValue(navigated);
+}
+function mergeResObjLayers(base, top) {
+  const fields = new Map(base.fields);
+  for (const [k, tv] of top.fields) {
+    const bv = fields.get(k);
+    if (bv !== void 0 && isResObj(bv) && isResObj(tv)) {
+      fields.set(k, mergeResObjLayers(bv, tv));
+    } else {
+      fields.set(k, tv);
+    }
+  }
+  const priorValues = new Map(base.priorValues);
+  for (const [k, pv] of top.priorValues) priorValues.set(k, pv);
+  const resetKeys = new Set(base.resetKeys);
+  for (const k of top.resetKeys) resetKeys.add(k);
+  return {
+    _kind: "res-obj",
+    fields,
+    priorValues,
+    resetKeys
+  };
+}
+function containsSelfRef(v, fullKey) {
+  return containsSelfRefInner(v, fullKey, true);
+}
+function containsSelfRefInner(v, fullKey, allowPrefix) {
+  if (isSubst(v))
+    return !v.knownAbsent && (substFullKey(v) === fullKey || allowPrefix && prefixSelfRefRemainder(v, fullKey) !== null);
+  if (isConcat(v)) return v.nodes.some((n) => containsSelfRefInner(n, fullKey, allowPrefix));
+  if (isResObj(v)) {
+    for (const f of v.fields.values()) {
+      if (containsSelfRefInner(f, fullKey, false)) return true;
+    }
+    return false;
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    return hv.items.some((item) => containsSelfRefInner(item, fullKey, allowPrefix));
+  }
+  if (hv.kind === "object") {
+    for (const f of hv.fields.values()) {
+      if (containsSelfRefInner(f, fullKey, false)) return true;
+    }
+    return false;
+  }
+  return false;
+}
+function foldSelfRef(v, fullKey, replacement) {
+  return foldSelfRefInner(v, fullKey, replacement, true);
+}
+function foldSelfRefInner(v, fullKey, replacement, allowPrefix) {
+  if (isSubst(v)) {
+    if (substFullKey(v) === fullKey) return replacement;
+    if (allowPrefix) {
+      const remainder = prefixSelfRefRemainder(v, fullKey);
+      if (remainder !== null) return foldPrefixSelfRef(v, replacement, remainder);
+    }
+    return v;
+  }
+  if (isConcat(v)) {
+    return {
+      _kind: "concat-placeholder",
+      nodes: v.nodes.map((n) => foldSelfRefInner(n, fullKey, replacement, allowPrefix)),
+      line: v.line,
+      col: v.col
+    };
+  }
+  if (isResObj(v)) {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of v.fields) {
+      newFields.set(k, foldSelfRefInner(val, fullKey, replacement, false));
+    }
+    return { _kind: "res-obj", fields: newFields, priorValues: new Map(v.priorValues), resetKeys: new Set(v.resetKeys) };
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    return {
+      kind: "array",
+      items: hv.items.map(
+        (item) => foldSelfRefInner(item, fullKey, replacement, allowPrefix)
+      )
+    };
+  }
+  if (hv.kind === "object") {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of hv.fields) {
+      newFields.set(k, foldSelfRefInner(val, fullKey, replacement, false));
+    }
+    return { kind: "object", fields: newFields };
+  }
+  return v;
+}
+function foldKnownAbsentSelfRef(v, fullKey, replacement) {
+  if (isSubst(v)) {
+    return v.knownAbsent && substFullKey(v) === fullKey ? replacement : v;
+  }
+  if (isConcat(v)) {
+    return {
+      _kind: "concat-placeholder",
+      nodes: v.nodes.map((n) => foldKnownAbsentSelfRef(n, fullKey, replacement)),
+      line: v.line,
+      col: v.col
+    };
+  }
+  if (isResObj(v)) {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of v.fields) {
+      newFields.set(k, foldKnownAbsentSelfRef(val, fullKey, replacement));
+    }
+    return { _kind: "res-obj", fields: newFields, priorValues: new Map(v.priorValues), resetKeys: new Set(v.resetKeys) };
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    return {
+      kind: "array",
+      items: hv.items.map((item) => foldKnownAbsentSelfRef(item, fullKey, replacement))
+    };
+  }
+  if (hv.kind === "object") {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of hv.fields) {
+      newFields.set(k, foldKnownAbsentSelfRef(val, fullKey, replacement));
+    }
+    return { kind: "object", fields: newFields };
+  }
+  return v;
+}
+function foldOrSkipPrior(prior, fullKey, old) {
+  if (!containsSelfRef(prior, fullKey)) return cloneResolverValue(prior);
+  if (old === void 0) return foldOptionalSelfRefAbsent(prior, fullKey);
+  if (isSubst(prior)) {
+    const remainder = prefixSelfRefRemainder(prior, fullKey);
+    if (remainder !== null) {
+      const navigated = navigateResolverValue(old, remainder);
+      if (navigated === void 0 && prior.optional) return cloneResolverValue(old);
+      if (navigated !== null && navigated !== void 0 && isResObj(navigated) && isResObj(old)) {
+        return mergeResObjLayers(
+          cloneResolverValue(old),
+          cloneResolverValue(navigated)
+        );
+      }
+    }
+  }
+  return foldSelfRef(prior, fullKey, old);
+}
+function foldOptionalSelfRefAbsent(v, fullKey) {
+  return foldOptionalSelfRefAbsentInner(v, fullKey, true);
+}
+function foldOptionalSelfRefAbsentInner(v, fullKey, allowPrefix) {
+  if (isSubst(v) && (substFullKey(v) === fullKey || allowPrefix && prefixSelfRefRemainder(v, fullKey) !== null)) {
+    if (!v.optional) return void 0;
+    return {
+      _kind: "subst-placeholder",
+      segments: v.segments.map((seg) => ({ text: seg.text, line: seg.line, col: seg.col })),
+      optional: v.optional,
+      knownAbsent: true,
+      listSuffix: v.listSuffix,
+      line: v.line,
+      col: v.col,
+      prefixLen: v.prefixLen
+    };
+  }
+  if (isConcat(v)) {
+    const nodes = [];
+    for (const node of v.nodes) {
+      const folded = foldOptionalSelfRefAbsentInner(node, fullKey, allowPrefix);
+      if (folded === void 0) return void 0;
+      nodes.push(folded);
+    }
+    return { _kind: "concat-placeholder", nodes, line: v.line, col: v.col };
+  }
+  if (isResObj(v)) {
+    const fields = /* @__PURE__ */ new Map();
+    for (const [key, value] of v.fields) {
+      const folded = foldOptionalSelfRefAbsentInner(value, fullKey, false);
+      if (folded === void 0) return void 0;
+      fields.set(key, folded);
+    }
+    return { _kind: "res-obj", fields, priorValues: new Map(v.priorValues), resetKeys: new Set(v.resetKeys) };
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    const items = [];
+    for (const item of hv.items) {
+      const folded = foldOptionalSelfRefAbsentInner(item, fullKey, allowPrefix);
+      if (folded === void 0) return void 0;
+      items.push(folded);
+    }
+    return { kind: "array", items };
+  }
+  if (hv.kind === "object") {
+    const fields = /* @__PURE__ */ new Map();
+    for (const [key, value] of hv.fields) {
+      const folded = foldOptionalSelfRefAbsentInner(value, fullKey, false);
+      if (folded === void 0) return void 0;
+      fields.set(key, folded);
+    }
+    return { kind: "object", fields };
+  }
+  return cloneResolverValue(v);
+}
+function cloneResolverValue(v) {
+  if (isSubst(v)) {
+    return {
+      _kind: "subst-placeholder",
+      segments: v.segments.map((seg) => ({ text: seg.text, line: seg.line, col: seg.col })),
+      optional: v.optional,
+      knownAbsent: v.knownAbsent,
+      listSuffix: v.listSuffix,
+      line: v.line,
+      col: v.col,
+      prefixLen: v.prefixLen
+    };
+  }
+  if (isConcat(v)) {
+    return {
+      _kind: "concat-placeholder",
+      nodes: v.nodes.map((n) => cloneResolverValue(n)),
+      line: v.line,
+      col: v.col
+    };
+  }
+  if (isResObj(v)) {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of v.fields) newFields.set(k, cloneResolverValue(val));
+    const newPriors = /* @__PURE__ */ new Map();
+    for (const [k, val] of v.priorValues) newPriors.set(k, cloneResolverValue(val));
+    return { _kind: "res-obj", fields: newFields, priorValues: newPriors, resetKeys: new Set(v.resetKeys) };
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    return {
+      kind: "array",
+      items: hv.items.map((item) => cloneResolverValue(item))
+    };
+  }
+  if (hv.kind === "object") {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of hv.fields) {
+      newFields.set(k, cloneResolverValue(val));
+    }
+    return { kind: "object", fields: newFields };
+  }
+  return hv;
+}
+function foldNestedSelfRefs(v, pathPrefix) {
+  if (!isResObj(v)) return v;
+  const newFields = /* @__PURE__ */ new Map();
+  for (const [k, fieldVal] of v.fields) {
+    const childPath = [...pathPrefix, k];
+    const fullKey = stringSegmentsToKey(childPath);
+    const folded = foldNestedSelfRefs(fieldVal, childPath);
+    let finalVal = folded;
+    if (containsSelfRef(folded, fullKey)) {
+      const leafPrior = v.priorValues.get(k);
+      if (leafPrior !== void 0) {
+        const leafPriorFolded = foldNestedSelfRefs(leafPrior, childPath);
+        finalVal = foldSelfRef(folded, fullKey, leafPriorFolded);
+      }
+    }
+    newFields.set(k, finalVal);
+  }
+  return { _kind: "res-obj", fields: newFields, priorValues: new Map(v.priorValues), resetKeys: new Set(v.resetKeys) };
+}
+function containsSubstByPath(v, target) {
+  if (isSubst(v)) return !v.knownAbsent && segmentsTextEqual(v.segments, target);
+  if (isConcat(v)) return v.nodes.some((n) => containsSubstByPath(n, target));
+  if (isResObj(v)) {
+    for (const f of v.fields.values()) {
+      if (containsSubstByPath(f, target)) return true;
+    }
+    return false;
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    return hv.items.some((item) => containsSubstByPath(item, target));
+  }
+  if (hv.kind === "object") {
+    for (const f of hv.fields.values()) {
+      if (containsSubstByPath(f, target)) return true;
+    }
+    return false;
+  }
+  return false;
+}
+function segmentsTextEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    if (ai === void 0 || bi === void 0 || ai.text !== bi.text) return false;
+  }
+  return true;
+}
+
+// src/internal/resolver/types.ts
+var separatorValues = /* @__PURE__ */ new WeakSet();
+function isSubst(v) {
+  return v._kind === "subst-placeholder";
+}
+function isConcat(v) {
+  return v._kind === "concat-placeholder";
+}
+function isResObj(v) {
+  return v._kind === "res-obj";
+}
+function makeResObj() {
+  return { _kind: "res-obj", fields: /* @__PURE__ */ new Map(), priorValues: /* @__PURE__ */ new Map(), resetKeys: /* @__PURE__ */ new Set() };
+}
+function mergeUnresolved(receiver, fallback) {
+  const result = makeResObj();
+  for (const [k, v] of fallback.fields) {
+    result.fields.set(k, v);
+  }
+  for (const [k, v] of fallback.priorValues) {
+    result.priorValues.set(k, v);
+  }
+  for (const [k, rv] of receiver.fields) {
+    const existing = result.fields.get(k);
+    if (existing !== void 0) {
+      const recPrior = receiver.priorValues.get(k);
+      if (recPrior !== void 0 && !isResObj(recPrior)) {
+        result.fields.set(k, rv);
+        continue;
+      }
+      if (isResObj(rv) && isResObj(existing)) {
+        result.fields.set(k, mergeUnresolved(rv, existing));
+        continue;
+      }
+      const foldedPrior = foldOrSkipPrior(existing, k, void 0);
+      if (foldedPrior !== void 0) result.priorValues.set(k, foldedPrior);
+    }
+    result.fields.set(k, rv);
+  }
+  for (const [k, v] of receiver.priorValues) {
+    if (receiver.fields.has(k)) {
+      result.priorValues.set(k, v);
+    }
+  }
+  return result;
+}
+
+// src/internal/resolver/utils.ts
+function segmentsToKey(segments) {
+  return segments.map((s) => {
+    const t = s.text;
+    if (t === "" || /[^a-zA-Z0-9\-_]/.test(t)) {
+      return `"${t.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return t;
+  }).join(".");
+}
+function lookupPath(root, segments) {
+  const [head, ...tail] = segments;
+  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);
+  return void 0;
+}
+function lookupResObj(root, segments) {
+  let cur = root;
+  for (const seg of segments) {
+    const val = cur.fields.get(seg.text);
+    if (val === void 0 || !isResObj(val)) return void 0;
+    cur = val;
+  }
+  return cur;
+}
+function deepMergeHoconValues(base, overlay) {
+  const merged = new Map(base.fields);
+  for (const [k, v] of overlay.fields) {
+    const existing = merged.get(k);
+    if (_optionalChain([existing, 'optionalAccess', _ => _.kind]) === "object" && v.kind === "object") {
+      merged.set(k, deepMergeHoconValues(existing, v));
+    } else {
+      merged.set(k, v);
+    }
+  }
+  return { kind: "object", fields: merged };
+}
+function deepMergeResObjInto(dst, src, pathPrefix = []) {
+  for (const [k, srcVal] of src.fields) {
+    const childPrefix = [...pathPrefix, k];
+    const fullKey = stringSegmentsToKey(childPrefix);
+    const dstVal = dst.fields.get(k);
+    if (dstVal !== void 0 && isResObj(dstVal) && isResObj(srcVal)) {
+      const priorExisting = dst.priorValues.get(k);
+      const prior = foldOrSkipPrior(dstVal, fullKey, priorExisting);
+      if (prior !== void 0) dst.priorValues.set(k, prior);
+      deepMergeResObjInto(dstVal, srcVal, childPrefix);
+    } else {
+      if (dstVal !== void 0) {
+        if (src.resetKeys.has(k)) {
+          dst.priorValues.delete(k);
+        } else {
+          const dstFolded = foldOrSkipPrior(dstVal, fullKey, dst.priorValues.get(k));
+          if (dstFolded !== void 0) {
+            const srcPrior = src.priorValues.get(k);
+            if (srcPrior !== void 0) {
+              dst.priorValues.set(k, foldKnownAbsentSelfRef(srcPrior, fullKey, dstFolded));
+            } else {
+              dst.priorValues.set(k, dstFolded);
+            }
+          }
+        }
+      }
+      dst.fields.set(k, srcVal);
+    }
+  }
+  for (const [k, srcPrior] of src.priorValues) {
+    if (!dst.priorValues.has(k)) {
+      dst.priorValues.set(k, srcPrior);
+    }
+  }
+  for (const k of src.resetKeys) dst.resetKeys.add(k);
+}
+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 {
+      obj.fields.set(key, val);
+    }
+  }
+  return obj;
+}
+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
+var _module = require('module'); var nodeModule = _interopRequireWildcard(_module);
+var _path = require('path'); var nodePath = _interopRequireWildcard(_path);
+var _url = require('url'); var nodeUrl = _interopRequireWildcard(_url);
+
+// src/internal/lexer/lexer.ts
+function isHoconWhitespace(ch) {
+  const cp = _nullishCoalesce(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",
+  "[": "lbracket",
+  "]": "rbracket",
+  ",": "comma",
+  ":": "colon"
+};
+var Lexer = class {
+  constructor(input) {
+    this.input = input;
+    this.pos = 0;
+    this.line = 1;
+    this.col = 1;
+    this.hadSpace = false;
+    // Accumulates literal whitespace chars consumed between tokens. Reset on every
+    // token push. Used so the parser can preserve path-expression whitespace
+    // (xx.hocon#42, E13) — e.g. tab vs space adjacent to dots in key paths.
+    // Comment text is NOT accumulated; only the actual WS chars.
+    this.whitespaceBuffer = "";
+    this.tokens = [];
+    if (input.charCodeAt(0) === 65279) this.input = input.slice(1);
+  }
+  tokenize() {
+    while (this.pos < this.input.length) {
+      const sl = this.line, sc = this.col;
+      const ch = this.peek();
+      if (isHoconNewline(ch)) {
+        this.advance();
+        if (_optionalChain([this, 'access', _2 => _2.tokens, 'access', _3 => _3[this.tokens.length - 1], 'optionalAccess', _4 => _4.kind]) !== "newline") {
+          this.push("newline", "\n", sl, sc);
+        }
+        continue;
+      }
+      if (isHoconWhitespace(ch)) {
+        this.whitespaceBuffer += 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;
+        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 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) === '"') {
+        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;
+            }
+            for (let i = 0; i < quoteCount; i++) value += '"';
+            continue;
+          }
+          value += this.advance();
+        }
+        if (!closed) {
+          throw new ParseError("unterminated triple-quoted string", sl, sc);
+        }
+        this.push("triple_string", value, sl, sc, true);
+        continue;
+      }
+      if (ch === '"') {
+        this.advance();
+        const value = this.readQuotedStringBody(sl, sc);
+        this.push("string", value, sl, sc, true);
+        continue;
+      }
+      if (isUnquotedStart(ch)) {
+        const plusAllowedUntil = this.numberRunEnd(sl, sc);
+        let value = "";
+        while (this.pos < this.input.length && isUnquotedContinue(this.peek(), () => this.peek(1))) {
+          if (this.peek() === "+" && this.pos >= plusAllowedUntil) throw reservedPlus(this.line, this.col);
+          value += this.advance();
+        }
+        this.push("unquoted", value.trimEnd(), sl, sc);
+        continue;
+      }
+      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, precedingWhitespace: "" });
+    return this.tokens;
+  }
+  /**
+   * S8.1 + E8 step 4: outside quotes, `+` is reserved except as the exponent
+   * sign of a numeric literal (the Lightbend 1.4.6 behaviour). Where a token
+   * starts like a number (a digit or `-`: Lightbend's `firstNumberChars`),
+   * `pullNumber` takes the maximal `[0-9.eE+-]` run; when that run is a number
+   * (`1e+5`, `-.5e+3`), a `+` inside it is the exponent sign. A run that
+   * contains `+` and is not a number is an error right here — this also covers
+   * `1+= 2`, where the run swallows the `+` of `+=` in Lightbend. Returns the
+   * input index up to which a `+` is allowed: the end of a number run, else
+   * the token start, so the caller rejects every other `+` (`abc+1`, `1x+2`).
+   */
+  numberRunEnd(line, col) {
+    const first = this.peek();
+    if (!isDecimalDigit(first) && first !== "-") return this.pos;
+    let end = this.pos;
+    while (end < this.input.length && NUMBER_RUN_CHARS.includes(this.input[end])) end++;
+    const run = this.input.slice(this.pos, end);
+    if (JAVA_NUMBER_RE.test(run)) return end;
+    if (run.includes("+")) throw reservedPlus(line, col);
+    return this.pos;
+  }
+  peek(offset = 0) {
+    return _nullishCoalesce(this.input[this.pos + offset], () => ( ""));
+  }
+  advance() {
+    const ch = _nullishCoalesce(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, precedingWhitespace: this.whitespaceBuffer });
+    this.hadSpace = false;
+    this.whitespaceBuffer = "";
+  }
+  pushSubst(payload, value, l, c) {
+    this.tokens.push({ kind: "subst", value, line: l, col: c, isQuoted: false, precedingSpace: this.hadSpace, precedingWhitespace: this.whitespaceBuffer, subst: payload });
+    this.hadSpace = false;
+    this.whitespaceBuffer = "";
+  }
+  /**
+   * 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.
+   *
+   * S13c extension: if the segment-collection loop encounters `[`, it delegates to
+   * `parseListSuffix()` which consumes the literal `[]` and sets `listSuffix=true`.
+   * ASCII space/tab before `[` is buffered in `pendingWs` and discarded (E7).
+   */
+  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;
+    let listSuffix = false;
+    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 === "[") {
+        if (!curStarted) {
+          throw new ParseError("empty segment before '[]' suffix in substitution path", startLine, this.col);
+        }
+        for (const w of pendingWs) {
+          if (w !== " " && w !== "	") {
+            throw new ParseError(
+              `only ASCII space or tab allowed between substitution path and '[]' suffix (got ${JSON.stringify(w)}, HOCON extra-spec E7)`,
+              startLine,
+              this.col
+            );
+          }
+        }
+        segments.push({ text: curText, line: curLine, col: curCol });
+        pendingWs = "";
+        listSuffix = this.parseListSuffix(startLine);
+        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 (!listSuffix) {
+      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] = _nullishCoalesce(lastDot, () => ( [startLine, startCol]));
+        throw new ParseError("empty segment in path", errLine, errCol);
+      }
+    }
+    return { segments, optional, listSuffix };
+  }
+  /**
+   * Consume the literal `[]` suffix inside a substitution body.
+   * Called after the `[` has been detected (but not yet consumed).
+   * Requires the next character to be `[`, then exactly `]`, then `}`.
+   * Whitespace inside `[]` is not permitted (per spec Decision §1).
+   * Returns true (always — only called when listSuffix path is taken).
+   */
+  parseListSuffix(startLine) {
+    this.advance();
+    const afterBracket = this.peek();
+    if (afterBracket !== "]") {
+      const desc = afterBracket === "" ? "EOF" : JSON.stringify(afterBracket);
+      throw new ParseError(
+        `expected ']' after '[' in substitution list suffix (got ${desc})`,
+        startLine,
+        this.col
+      );
+    }
+    this.advance();
+    if (this.peek() !== "}") {
+      const desc = this.peek() === "" ? "EOF" : JSON.stringify(this.peek());
+      throw new ParseError(
+        `expected '}' after '[]' in substitution list suffix (got ${desc})`,
+        startLine,
+        this.col
+      );
+    }
+    this.advance();
+    return true;
+  }
+};
+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";
+}
+var NUMBER_RUN_CHARS = "0123456789.eE+-";
+var JAVA_NUMBER_RE = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+function reservedPlus(line, col) {
+  return new ParseError(`reserved character '+' is not allowed outside quotes (quote the value)`, line, col);
+}
+function isUnquotedStart(ch) {
+  if (ch === "" || isHoconWhitespace(ch)) return false;
+  if ('{}[],:=+#"$?!@*&^`\\'.includes(ch)) return false;
+  return true;
+}
+function isUnquotedContinue(ch, nextFn) {
+  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, precedingWhitespace: "", subst: void 0 };
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.pos = 0;
+  }
+  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 remaining2 = this.peek();
+      if (remaining2.kind !== "eof") {
+        throw new ParseError(`Unexpected token '${remaining2.value}' after closing brace`, remaining2.line, remaining2.col);
+      }
+      return { kind: "object", fields: allFields, pos: first.pos };
+    }
+    if (t.kind === "lbracket") {
+      this.advance();
+      const arr = this.parseArray();
+      this.skip("newline");
+      const remaining2 = this.peek();
+      if (remaining2.kind !== "eof") {
+        throw new ParseError(`Unexpected token '${remaining2.value}' after root array`, remaining2.line, remaining2.col);
+      }
+      return { ...arr, pos: { line: t.line, col: t.col } };
+    }
+    const root = this.parseObject(false);
+    this.skip("newline");
+    const remaining = this.peek();
+    if (remaining.kind !== "eof") {
+      throw new ParseError(`Unexpected token '${remaining.value}' after root content`, remaining.line, remaining.col);
+    }
+    return root;
+  }
+  peek(offset = 0) {
+    return _nullishCoalesce(this.tokens[this.pos + offset], () => ( EOF_TOKEN));
+  }
+  advance() {
+    const t = this.tokens[this.pos];
+    if (this.pos < this.tokens.length) this.pos++;
+    return _nullishCoalesce(t, () => ( EOF_TOKEN));
+  }
+  skip(...kinds) {
+    while (kinds.includes(this.peek().kind)) this.advance();
+  }
+  currentPos() {
+    const t = this.peek();
+    return { line: t.line, col: t.col };
+  }
+  parseObject(expectClosingBrace) {
+    const p = this.currentPos();
+    const fields = [];
+    while (true) {
+      this.skip("newline");
+      const t = this.peek();
+      if (t.kind === "eof" || t.kind === "rbrace") break;
+      if (t.kind === "unquoted" && t.value === "include") {
+        const next = this.peek(1);
+        if (next.kind === "equals" || next.kind === "colon" || next.kind === "plus_equals" || next.kind === "lbrace") {
+          throw new ParseError(
+            `'include' is reserved at the start of a key path expression; use "include" (quoted) to use it as a key`,
+            t.line,
+            t.col
+          );
+        }
+        this.advance();
+        fields.push(this.parseInclude());
+        this.skip("newline");
+        if (this.peek().kind === "comma") this.advance();
+        this.skip("newline");
+        continue;
+      }
+      const keyPos = this.currentPos();
+      const { segments: key, firstWasQuoted } = this.parseKey();
+      if (key[0] === "include" && !firstWasQuoted) {
+        throw new ParseError(
+          `'include' is reserved at the start of a key path expression; use "include".foo (quoted) or rename the key`,
+          keyPos.line,
+          keyPos.col
+        );
+      }
+      this.skip("newline");
+      let append = false;
+      const sep = this.peek();
+      if (sep.kind === "equals") this.advance();
+      else if (sep.kind === "plus_equals") {
+        this.advance();
+        append = true;
+      } 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);
+      }
+      this.skip("newline");
+      const value = this.parseValue();
+      fields.push({ key, value, append, pos: keyPos });
+      this.skip("newline");
+      if (this.peek().kind === "comma") this.advance();
+      this.skip("newline");
+    }
+    if (expectClosingBrace) {
+      const t = this.peek();
+      if (t.kind !== "rbrace") throw new ParseError("expected }", t.line, t.col);
+      this.advance();
+    }
+    return { kind: "object", fields, pos: p };
+  }
+  parseKey() {
+    const segments = [];
+    let trailingDot = false;
+    let firstWasQuoted = false;
+    let spaceConcat = false;
+    let postDotPrefix = "";
+    while (true) {
+      const t = this.peek();
+      if (t.kind === "string") {
+        this.advance();
+        if (segments.length === 0) firstWasQuoted = true;
+        if (spaceConcat) {
+          segments[segments.length - 1] = `${segments[segments.length - 1]}${t.precedingWhitespace}${t.value}`;
+        } else if (postDotPrefix !== "") {
+          segments.push(`${postDotPrefix}${t.value}`);
+          postDotPrefix = "";
+        } else {
+          segments.push(t.value);
+        }
+        trailingDot = false;
+      } else if (t.kind === "unquoted") {
+        this.advance();
+        const raw = t.value.startsWith(".") && segments.length > 0 && !t.precedingSpace ? t.value.slice(1) : t.value;
+        const parts = raw.split(".");
+        const leadingDotIsSeparator = spaceConcat || postDotPrefix !== "";
+        for (let i = 0; i < parts.length; i++) {
+          if (parts[i] !== "") continue;
+          if (i === parts.length - 1) continue;
+          if (i === 0 && leadingDotIsSeparator) continue;
+          throw new ParseError(
+            `path has ${i === 0 ? "a leading period '.'" : "two adjacent periods '.'"} \u2014 empty key segment not allowed, use quoted "" (HOCON.md path rules)`,
+            t.line,
+            t.col
+          );
+        }
+        const filtered = parts.filter((s) => s.length > 0);
+        if (spaceConcat) {
+          segments[segments.length - 1] = `${segments[segments.length - 1]}${t.precedingWhitespace}`;
+          if (raw.startsWith(".")) {
+            segments.push(...filtered);
+          } else if (filtered.length > 0) {
+            const [head, ...tail] = filtered;
+            segments[segments.length - 1] = `${segments[segments.length - 1]}${head}`;
+            segments.push(...tail);
+          }
+        } else if (postDotPrefix !== "" && raw.startsWith(".")) {
+          segments.push(postDotPrefix);
+          postDotPrefix = "";
+          segments.push(...filtered);
+        } else if (postDotPrefix !== "" && filtered.length > 0) {
+          const [head, ...tail] = filtered;
+          segments.push(`${postDotPrefix}${head}`, ...tail);
+          postDotPrefix = "";
+        } else {
+          segments.push(...filtered);
+        }
+        trailingDot = raw.endsWith(".");
+      } else {
+        if (segments.length === 0) throw new ParseError(`expected key, got ${t.kind}`, t.line, t.col);
+        break;
+      }
+      spaceConcat = false;
+      if (trailingDot) {
+        const next2 = this.peek();
+        if ((next2.kind === "unquoted" || next2.kind === "string") && next2.precedingWhitespace.length > 0) {
+          postDotPrefix = next2.precedingWhitespace;
+        } else {
+          postDotPrefix = "";
+        }
+        continue;
+      }
+      const next = this.peek();
+      if (next.kind === "unquoted" && next.value === "." && !next.precedingSpace) {
+        this.advance();
+        trailingDot = true;
+        const afterDot = this.peek();
+        if ((afterDot.kind === "unquoted" || afterDot.kind === "string") && afterDot.precedingWhitespace.length > 0) {
+          postDotPrefix = afterDot.precedingWhitespace;
+        }
+        continue;
+      }
+      if (next.kind === "unquoted" && next.value.startsWith(".") && !next.precedingSpace) {
+        trailingDot = true;
+        continue;
+      }
+      if ((next.kind === "unquoted" || next.kind === "string") && next.precedingSpace) {
+        spaceConcat = true;
+        continue;
+      }
+      break;
+    }
+    if (trailingDot) {
+      const here = this.peek();
+      throw new ParseError(
+        `path has a trailing period '.' \u2014 empty key segment not allowed (HOCON.md path rules)`,
+        here.line,
+        here.col
+      );
+    }
+    return { segments, firstWasQuoted };
+  }
+  parseInclude() {
+    const p = this.currentPos();
+    this.skip("newline");
+    const t = this.peek();
+    if (t.kind === "unquoted" && (t.value === "required(" || t.value === "required" || t.value.startsWith("required("))) {
+      if (t.value === "required") {
+        const next = this.peek(1);
+        if (next.kind !== "unquoted" || !next.value.startsWith("(")) {
+          throw new ParseError("include required must be followed by (", t.line, t.col);
+        }
+      }
+      this.advance();
+      const innerPrefix = t.value.startsWith("required(") ? t.value.slice("required(".length) : "";
+      if (innerPrefix === "url" || innerPrefix.startsWith("url(") || innerPrefix === "classpath" || innerPrefix.startsWith("classpath(")) {
+        throw new ParseError("include url(...) and classpath(...) are not supported", t.line, t.col);
+      }
+      const nextTok = this.peek();
+      if (innerPrefix === "package" || innerPrefix.startsWith("package(") || innerPrefix === "" && nextTok.kind === "unquoted" && (nextTok.value === "package(" || nextTok.value.startsWith("package("))) {
+        const consumePackageToken = innerPrefix === "";
+        const { qualifier, path: path2 } = this.parsePackageArgs(consumePackageToken);
+        return this.makeIncludeField(qualifier, path2, true, p);
+      }
+      if (innerPrefix === "file" || innerPrefix.startsWith("file(") || innerPrefix === "" && nextTok.kind === "unquoted" && (nextTok.value === "file(" || nextTok.value === "file")) {
+        if (innerPrefix === "") {
+          this.advance();
+        }
+        const path2 = this.parseQuotedPathSkipWrapper(t);
+        return this.makeIncludeField({ kind: "file" }, path2, true, p);
+      }
+      if (innerPrefix === "" && nextTok.kind === "unquoted" && (nextTok.value === "url" || nextTok.value.startsWith("url(") || nextTok.value === "classpath" || nextTok.value.startsWith("classpath("))) {
+        throw new ParseError("include url(...) and classpath(...) are not supported", nextTok.line, nextTok.col);
+      }
+      if (innerPrefix !== "") {
+        if (innerPrefix === ")") {
+          throw new ParseError("include required(...) must contain a path", t.line, t.col);
+        }
+        const name = innerPrefix.replace(/\(.*$/, "").replace(/\).*$/, "");
+        throw new ParseError(`unknown include qualifier inside required(): "${name}"`, t.line, t.col);
+      }
+      const path = this.parseQuotedPathSkipWrapper(t);
+      return this.makeIncludeField({ kind: "bare" }, path, true, p);
+    }
+    if (t.kind === "string") {
+      const path = this.advance().value;
+      return this.makeIncludeField({ kind: "bare" }, path, false, p);
+    }
+    if (t.kind === "unquoted" && (t.value === "file(" || t.value === "file")) {
+      this.advance();
+      const path = this.parseQuotedPathSkipWrapper(t);
+      return this.makeIncludeField({ kind: "file" }, path, false, p);
+    }
+    if (t.kind === "unquoted" && (t.value === "package(" || t.value.startsWith("package("))) {
+      const { qualifier, path } = this.parsePackageArgs();
+      return this.makeIncludeField(qualifier, path, false, p);
+    }
+    if (t.kind === "unquoted" && (t.value === "url" || t.value.startsWith("url("))) {
+      throw new ParseError("include url(...) is not supported", t.line, t.col);
+    }
+    if (t.kind === "unquoted" && (t.value === "classpath" || t.value.startsWith("classpath("))) {
+      throw new ParseError("include classpath(...) is not supported", t.line, t.col);
+    }
+    throw new ParseError(`expected include path, got ${t.kind}`, t.line, t.col);
+  }
+  makeIncludeField(qualifier, path, required, pos) {
+    return { key: [], value: { kind: "include", qualifier, path, required, pos }, append: false, pos };
+  }
+  /**
+   * Skip past include-syntax wrapper tokens to find the quoted path string.
+   * Strict: only allows `(`, `)`, and bare qualifier keywords (file / file( /
+   * package / package( / url / url( / classpath / classpath() between the
+   * directive and the quoted path. Anything else is a parse error rather than
+   * silently swallowed (see ts#113).
+   */
+  parseQuotedPathSkipWrapper(errTok) {
+    while (this.isIncludeWrapperToken(this.peek())) this.advance();
+    if (this.peek().kind !== "string") {
+      const tok = this.peek();
+      if (tok.kind === "eof") throw new ParseError("expected include path", errTok.line, errTok.col);
+      const desc = tok.kind === "unquoted" ? `unquoted "${tok.value}"` : tok.kind;
+      throw new ParseError(`expected quoted include path, got ${desc}`, tok.line, tok.col);
+    }
+    const path = this.advance().value;
+    while (this.peek().kind === "unquoted" && (this.peek().value === ")" || this.peek().value === "))")) {
+      this.advance();
+    }
+    const after = this.peek();
+    if (after.kind !== "newline" && after.kind !== "rbrace" && after.kind !== "eof" && after.kind !== "comma") {
+      const desc = after.kind === "unquoted" ? `unquoted "${after.value}"` : after.kind;
+      throw new ParseError(`unexpected token after include path: ${desc}`, after.line, after.col);
+    }
+    return path;
+  }
+  isIncludeWrapperToken(tok) {
+    return tok.kind === "unquoted" && tok.value === "(";
+  }
+  /**
+   * Parse the body of `package("identifier", "file")`.
+   *
+   * @param consumePackageToken - When true (default), the current token is `package(` and
+   *   must be consumed first. When false, the lexer already bundled `package(` into the
+   *   preceding token (e.g. `required(package("`), so we are already positioned at the
+   *   first string argument.
+   */
+  parsePackageArgs(consumePackageToken = true) {
+    const pkgTok = consumePackageToken ? this.advance() : this.peek();
+    this.skip("newline");
+    const idTok = this.peek();
+    if (idTok.kind !== "string") {
+      throw new ParseError("include package: expected quoted identifier as first argument", pkgTok.line, pkgTok.col);
+    }
+    const identifier = this.advance().value;
+    this.skip("newline");
+    if (this.peek().kind !== "comma") {
+      const after = this.peek();
+      throw new ParseError(
+        after.kind === "string" ? "include package: missing comma between identifier and file arguments" : "include package: requires exactly two arguments (identifier, file) \u2014 one-arg form is not supported",
+        pkgTok.line,
+        pkgTok.col
+      );
+    }
+    this.advance();
+    this.skip("newline");
+    const fileTok = this.peek();
+    if (fileTok.kind !== "string") {
+      throw new ParseError(
+        "include package: requires exactly two arguments (identifier, file) \u2014 one-arg form is not supported",
+        pkgTok.line,
+        pkgTok.col
+      );
+    }
+    const filePath = this.advance().value;
+    while (this.peek().kind !== "newline" && this.peek().kind !== "rbrace" && this.peek().kind !== "eof" && this.peek().kind !== "comma") {
+      this.advance();
+    }
+    return { qualifier: { kind: "package", identifier }, path: filePath };
+  }
+  parseValue() {
+    const p = this.currentPos();
+    const parts = [];
+    while (true) {
+      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 (t.kind === "lbrace") {
+        this.advance();
+        node = this.parseObject(true);
+      } else if (t.kind === "lbracket") {
+        this.advance();
+        node = this.parseArray();
+      } else if (t.kind === "subst") {
+        this.advance();
+        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, listSuffix: payload.listSuffix, 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, t.line, t.col), 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) {
+        const sep = t.precedingWhitespace.length > 0 ? t.precedingWhitespace : " ";
+        parts.push({ kind: "scalar", raw: sep, valueType: "string", pos: { line: t.line, col: t.col }, _separator: true });
+      }
+      parts.push(node);
+    }
+    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 };
+  }
+  parseArray() {
+    const p = this.currentPos();
+    const items = [];
+    while (true) {
+      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 };
+  }
+  scalarValueType(raw, line, col) {
+    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)) {
+        if (!Number.isFinite(Number(raw))) {
+          throw new ParseError(`invalid float "${raw}"`, line, col);
+        }
+        return "number";
+      }
+    }
+    return "string";
+  }
+};
+function parseTokens(tokens) {
+  return new Parser(tokens).parse();
+}
+
+// src/internal/resolver/include-loader.ts
+var _require;
+function getRequire() {
+  if (_require === void 0) {
+    _require = pickRequire(
+      typeof __require === "function" ? __require : void 0,
+      void 0
+    );
+  }
+  return _require;
+}
+function pickRequire(candidate, metaUrl) {
+  if (typeof _optionalChain([candidate, 'optionalAccess', _5 => _5.resolve]) === "function") {
+    return candidate;
+  }
+  return nodeModule.createRequire(_nullishCoalesce(metaUrl, () => ( nodeUrl.pathToFileURL(nodePath.join(process.cwd(), "noop.js")))));
+}
+function isPnpPath(p) {
+  return p.includes(".yarn/cache") || p.includes(".pnp.cjs") || p.includes(".pnp.loader");
+}
+function assertObjectRootedInclude(ast, sourcePath) {
+  if (ast.kind === "array") {
+    throw new ResolveError(
+      `included file has array at file root \u2014 an included file must contain an object, not an array (HOCON.md L993-994): ${sourcePath}`,
+      sourcePath,
+      ast.pos.line,
+      ast.pos.col
+    );
+  }
+}
+function validatePackageFile(file, identifier) {
+  if (file.length === 0) {
+    throw new ParseError(`include package("${identifier}", ...): file argument must be non-empty`, 0, 0);
+  }
+  if (file.includes("\\")) {
+    throw new ParseError(
+      `include package("${identifier}", "${file}"): backslash not allowed in file argument (use forward slash)`,
+      0,
+      0
+    );
+  }
+  if (file.startsWith("/")) {
+    throw new ParseError(
+      `include package("${identifier}", "${file}"): absolute path not allowed in file argument`,
+      0,
+      0
+    );
+  }
+  if (/(?:^|\/)\.\.?(?:\/|$)/u.test(file)) {
+    throw new ParseError(
+      `include package("${identifier}", "${file}"): path traversal (. or ..) not allowed in file argument`,
+      0,
+      0
+    );
+  }
+  if (file.includes("//")) {
+    throw new ParseError(
+      `include package("${identifier}", "${file}"): consecutive slashes not allowed in file argument`,
+      0,
+      0
+    );
+  }
+}
+function validatePackageIdentifier(identifier) {
+  if (identifier.length === 0) {
+    throw new ParseError("include package: identifier argument must be non-empty", 0, 0);
+  }
+}
+function defaultPackageResolver(identifier, file, includingFile, baseDir, resolveFrom) {
+  const from = resolveFrom ? Array.isArray(resolveFrom) ? resolveFrom : [resolveFrom] : baseDir ? [baseDir] : includingFile ? [nodePath.dirname(includingFile)] : [process.cwd()];
+  let resolved;
+  try {
+    resolved = getRequire().resolve(`${identifier}/${file}`, { paths: from });
+  } catch (e2) {
+    throw new PackageLookupError(
+      `include package("${identifier}", "${file}"): module not found (starting from: ${from.join(", ")})`,
+      identifier,
+      file,
+      0,
+      0
+    );
+  }
+  if (isPnpPath(resolved)) {
+    throw new ResolveError(
+      `include package("${identifier}", "${file}"): Yarn Berry PnP store paths are not supported. Provide a custom packageResolver option to handle PnP resolution.`,
+      `${identifier}/${file}`,
+      0,
+      0
+    );
+  }
+  const fileParts = file.split("/");
+  const expectedBasename = _nullishCoalesce(fileParts[fileParts.length - 1], () => ( file));
+  const resolvedBasename = nodePath.basename(resolved);
+  if (resolvedBasename !== expectedBasename) {
+    throw new PackageLookupError(
+      `include package("${identifier}", "${file}"): case mismatch \u2014 resolved "${resolvedBasename}" but expected "${expectedBasename}" (E11 decision 5: case-sensitive)`,
+      identifier,
+      file,
+      0,
+      0
+    );
+  }
+  return resolved;
+}
+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);
+      }
+      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;
+      }
+    }
+    if (!foundAny && required) {
+      throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
+    }
+    return merged;
+  }
+  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;
+  }
+  /**
+   * Resolve and load `include package("identifier", "file")`.
+   * Validates the identifier and file arguments, resolves via the package resolver,
+   * performs cycle detection using a JSON-serialised cycle key, and parses the content.
+   */
+  // `required` is reserved for future optional-package semantics (E11 decision 7);
+  // currently all package lookup failures throw regardless of this flag.
+  loadPackage(identifier, file, _required) {
+    validatePackageIdentifier(identifier);
+    validatePackageFile(file, identifier);
+    const { includeStack = [], baseDir, resolveFrom, packageResolver, readFileSync } = this.opts;
+    const cycleKey = JSON.stringify(["package", identifier, file]);
+    if (includeStack.includes(cycleKey)) {
+      throw new ResolveError(
+        `circular include: package("${identifier}", "${file}")`,
+        `${identifier}/${file}`,
+        0,
+        0
+      );
+    }
+    if (includeStack.length >= 50) {
+      throw new ResolveError(`include depth limit exceeded (max 50)`, `${identifier}/${file}`, 0, 0);
+    }
+    const resolver = _nullishCoalesce(packageResolver, () => ( ((id, f, includingFile, bDir) => defaultPackageResolver(id, f, includingFile, bDir, resolveFrom))));
+    const resolvedPath = resolver(identifier, file, void 0, baseDir);
+    const content = readFileSync(resolvedPath);
+    const tokens = tokenize(content);
+    const ast = parseTokens(tokens);
+    assertObjectRootedInclude(ast, resolvedPath);
+    return this.onBuildResObj(ast, {
+      ...this.opts,
+      baseDir: nodePath.dirname(resolvedPath),
+      includeStack: [...includeStack, cycleKey]
+    });
+  }
+  /**
+   * Async variant of `loadPackage`.
+   */
+  async loadPackageAsync(identifier, file, _required) {
+    validatePackageIdentifier(identifier);
+    validatePackageFile(file, identifier);
+    const { includeStack = [], baseDir, resolveFrom, packageResolver, readFile, readFileSync } = this.opts;
+    const cycleKey = JSON.stringify(["package", identifier, file]);
+    if (includeStack.includes(cycleKey)) {
+      throw new ResolveError(
+        `circular include: package("${identifier}", "${file}")`,
+        `${identifier}/${file}`,
+        0,
+        0
+      );
+    }
+    if (includeStack.length >= 50) {
+      throw new ResolveError(`include depth limit exceeded (max 50)`, `${identifier}/${file}`, 0, 0);
+    }
+    const resolver = _nullishCoalesce(packageResolver, () => ( ((id, f, includingFile, bDir) => defaultPackageResolver(id, f, includingFile, bDir, resolveFrom))));
+    const resolvedPath = resolver(identifier, file, void 0, baseDir);
+    const read = readFile ? async (p) => readFile(p) : async (p) => readFileSync(p);
+    const content = await read(resolvedPath);
+    const tokens = tokenize(content);
+    const ast = parseTokens(tokens);
+    assertObjectRootedInclude(ast, resolvedPath);
+    return this.onBuildResObjAsync(ast, {
+      ...this.opts,
+      baseDir: nodePath.dirname(resolvedPath),
+      includeStack: [...includeStack, cycleKey]
+    });
+  }
+  loadSingle(candidate) {
+    const { readFileSync, includeStack = [] } = this.opts;
+    if (includeStack.includes(candidate)) {
+      throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0);
+    }
+    let content;
+    try {
+      content = readFileSync(candidate);
+    } catch (e) {
+      if (isFileNotFoundError(e)) return void 0;
+      throw e;
+    }
+    if (candidate.endsWith(".properties")) {
+      return hoconValueToResObj(propertiesToHoconValue(content));
+    }
+    const tokens = tokenize(content);
+    const ast = parseTokens(tokens);
+    assertObjectRootedInclude(ast, candidate);
+    return this.onBuildResObj(ast, {
+      ...this.opts,
+      baseDir: nodePath.dirname(candidate),
+      includeStack: [...includeStack, candidate]
+    });
+  }
+  async loadSingleAsync(candidate) {
+    const { readFile, readFileSync, includeStack = [] } = this.opts;
+    const read = readFile ? async (p) => readFile(p) : async (p) => readFileSync(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 tokens = tokenize(content);
+    const ast = parseTokens(tokens);
+    assertObjectRootedInclude(ast, candidate);
+    return this.onBuildResObjAsync(ast, {
+      ...this.opts,
+      baseDir: nodePath.dirname(candidate),
+      includeStack: [...includeStack, candidate]
+    });
+  }
+};
+
+// src/internal/resolver/structure-builder.ts
+var StructureBuilder = class _StructureBuilder {
+  constructor(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 { qualifier, path, required } = field.value;
+      let included;
+      if (qualifier.kind === "package") {
+        included = this.loader.loadPackage(qualifier.identifier, path, required);
+      } else {
+        included = this.loader.load(path, required, qualifier.kind === "file");
+      }
+      if (pathPrefix.length > 0) {
+        this.relativizeResObj(included, pathPrefix);
+      }
+      deepMergeResObjInto(obj, included, pathPrefix);
+      return;
+    }
+    const [head, ...tail] = field.key;
+    if (head === void 0) 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];
+    const fullKey = stringSegmentsToKey(childPrefix);
+    if (field.append) {
+      const synthetic = this.desugarAppend(field, childPrefix);
+      this.applyField(obj, synthetic, pathPrefix);
+      return;
+    }
+    const existing = obj.fields.get(head);
+    const newVal = this.astToResolverValue(field.value, childPrefix);
+    if (!containsSelfRef(newVal, fullKey)) {
+      obj.resetKeys.add(head);
+    }
+    if (existing !== void 0) {
+      const oldPrior = obj.priorValues.get(head);
+      const priorInput = isResObj(existing) ? foldNestedSelfRefs(existing, childPrefix) : existing;
+      const prior = foldOrSkipPrior(priorInput, fullKey, oldPrior);
+      if (prior !== void 0) obj.priorValues.set(head, prior);
+    }
+    if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
+      deepMergeResObjInto(existing, newVal, childPrefix);
+      return;
+    }
+    obj.fields.set(head, newVal);
+  }
+  async applyFieldAsync(obj, field, pathPrefix) {
+    if (field.key.length === 0 && field.value.kind === "include") {
+      const { qualifier, path, required } = field.value;
+      let included;
+      if (qualifier.kind === "package") {
+        included = await this.loader.loadPackageAsync(qualifier.identifier, path, required);
+      } else {
+        included = await this.loader.loadAsync(path, required, qualifier.kind === "file");
+      }
+      if (pathPrefix.length > 0) {
+        this.relativizeResObj(included, pathPrefix);
+      }
+      deepMergeResObjInto(obj, included, pathPrefix);
+      return;
+    }
+    const [head, ...tail] = field.key;
+    if (head === void 0) 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];
+    const fullKey = stringSegmentsToKey(childPrefix);
+    if (field.append) {
+      const synthetic = this.desugarAppend(field, childPrefix);
+      await this.applyFieldAsync(obj, synthetic, pathPrefix);
+      return;
+    }
+    const existing = obj.fields.get(head);
+    const newVal = await this.astToResolverValueAsync(field.value, childPrefix);
+    if (!containsSelfRef(newVal, fullKey)) {
+      obj.resetKeys.add(head);
+    }
+    if (existing !== void 0) {
+      const oldPrior = obj.priorValues.get(head);
+      const priorInput = isResObj(existing) ? foldNestedSelfRefs(existing, childPrefix) : existing;
+      const prior = foldOrSkipPrior(priorInput, fullKey, oldPrior);
+      if (prior !== void 0) obj.priorValues.set(head, prior);
+    }
+    if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
+      deepMergeResObjInto(existing, newVal, childPrefix);
+      return;
+    }
+    obj.fields.set(head, newVal);
+  }
+  /** Builds the `key = ${?fullkey} [value]` field that `key += value` desugars
+   * to (S13b.2, HOCON.md L732). `childPrefix` is the field's fully-qualified
+   * path (pathPrefix + key), so a nested `srv { items += x }` references
+   * `${?srv.items}`; include relativization rewrites it under a mount prefix.
+   * `field.key` is already single-segment here (multi-segment keys are split
+   * into nested objects upstream). Returns a NEW AstField (append=false);
+   * positions inherit from the original field so resolve-time errors (the
+   * S13b.2 non-array check, now via the scalar+array concat) keep a location. */
+  desugarAppend(field, childPrefix) {
+    const segments = childPrefix.map((text) => ({ text, line: field.pos.line, col: field.pos.col }));
+    const subst = { kind: "subst", segments, optional: true, listSuffix: false, pos: field.pos };
+    const elemArray = { kind: "array", items: [field.value], pos: field.pos };
+    const synthetic = { kind: "concat", nodes: [subst, elemArray], pos: field.pos };
+    return { key: field.key, value: synthetic, append: false, pos: field.pos };
+  }
+  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: ast.segments, optional: ast.optional, knownAbsent: false, listSuffix: ast.listSuffix, 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)), line: ast.pos.line, col: ast.pos.col };
+      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: ast.segments, optional: ast.optional, knownAbsent: false, listSuffix: ast.listSuffix, 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, line: ast.pos.line, col: ast.pos.col };
+      }
+      case "include":
+        return { kind: "scalar", raw: "null", valueType: "null" };
+    }
+  }
+  // ---- Relativize substitution paths for nested includes ----
+  relativizeSubstPaths(val, prefixSegments) {
+    if (isSubst(val)) {
+      const prefixAsSegments = prefixSegments.map((text) => ({ text, line: 0, col: 0 }));
+      val.segments = [...prefixAsSegments, ...val.segments];
+      val.prefixLen += prefixSegments.length;
+      return;
+    }
+    if (isConcat(val)) {
+      for (const node of val.nodes) {
+        this.relativizeSubstPaths(node, 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/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/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();
+    // Tracks ConcatPlaceholder nodes currently being iterated by resolveConcat.
+    // Used by isSelfRef detection: fires only when found === a concat currently
+    // mid-iteration (i.e. we are inside found's own resolution), preventing the
+    // "foofoo" double-count without misfiring when an external field looks up the
+    // same concat via a substitution (multi-reviewer convergence fix).
+    //
+    // Spec deviation: the S13a.13 spec ★1 decision #1 specified path-equality
+    // preservation for self-ref detection. Round-2 multi-agent-review surfaced a
+    // false-positive on external lookups (`a = ${?a}foo; b = ${a}`), so the
+    // criterion was tightened to node-membership-in-iterating-set — strictly
+    // narrower than path-equality. Spec amendment deferred to a follow-up
+    // xx.hocon PR (see Phase 6 #3f close-out notes).
+    this.resolvingConcats = /* @__PURE__ */ new WeakSet();
+    // Path stack tracking the full dotted path of the field currently being
+    // assigned in `resolveResObj`. Leaf keys are pushed on entry to each
+    // `(key, val)` iteration and popped on exit, so nested objects build up
+    // the full path (e.g. `["o", "history"]` while resolving `o.history`).
+    //
+    // Used to tighten self-ref detection at the L192 found-lookup site:
+    // a substitution `${X}` whose looked-up value contains a Subst pointing
+    // at `X` is only a true self-reference when the field currently being
+    // assigned is `X` (or a descendant of `X`). Without this guard, an
+    // external lookup like `b = ${o}` (where o has a self-referential
+    // field) would mis-fire and short-circuit to o's prior, returning the
+    // wrong value for b. The is_owner gate (rfp prefix-matches s.segments)
+    // narrows the check to the owner case only.
+    //
+    // Cross-impl with rs.hocon v1.5.1's resolving_field_path (same purpose,
+    // same prefix-match semantics).
+    this.resolvingFieldPath = [];
+    // S13a.12 recursion guard: field keys whose prior is currently being
+    // resolved through the prefix-self-ref branch. Saved priors are
+    // prefix-self-ref-free by the fold invariant, so re-entry only happens on
+    // a shape the fold could not see through (a live subst mid-navigation) —
+    // report it as a cycle instead of recursing forever.
+    this.resolvingPrefixPriors = /* @__PURE__ */ new Set();
+  }
+  /** Returns a prefix for error messages, including origin info when set. */
+  originPrefix() {
+    return this.opts.originDescription ? `${this.opts.originDescription}: ` : "";
+  }
+  resolve() {
+    return this.resolveResObj(this.root);
+  }
+  resolveResObj(obj) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, val] of obj.fields) {
+      this.resolvingFieldPath.push(key);
+      const fullCacheKey = stringSegmentsToKey(this.resolvingFieldPath);
+      this.cache.delete(fullCacheKey);
+      try {
+        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") {
+                const finalValue = deepMergeHoconValues(
+                  priorResolved,
+                  resolved
+                );
+                result.set(key, finalValue);
+                this.cache.set(fullCacheKey, finalValue);
+                this.cacheDescendants(fullCacheKey, finalValue);
+                continue;
+              }
+            }
+          }
+          result.set(key, resolved);
+          this.cache.set(fullCacheKey, resolved);
+          this.cacheDescendants(fullCacheKey, 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);
+              this.cache.set(fullCacheKey, priorResolved);
+              this.cacheDescendants(fullCacheKey, priorResolved);
+            }
+          }
+        }
+      } finally {
+        this.resolvingFieldPath.pop();
+      }
+    }
+    return { kind: "object", fields: result };
+  }
+  /** S13a.12: walk resolved-object fields by segment text. A missing segment
+   * or a walk into a scalar/array is path-absent → undefined. */
+  navigateResolved(v, remainder) {
+    let cur = v;
+    for (const seg of remainder) {
+      if (cur.kind !== "object") return void 0;
+      const next = cur.fields.get(seg);
+      if (next === void 0) return void 0;
+      cur = next;
+    }
+    return cur;
+  }
+  cacheDescendants(prefix, value) {
+    if (value.kind !== "object") return;
+    for (const [key, child] of value.fields) {
+      const childKey = `${prefix}.${stringSegmentsToKey([key])}`;
+      this.cache.set(childKey, child);
+      this.cacheDescendants(childKey, child);
+    }
+  }
+  resolveVal(v, scope) {
+    if (isSubst(v)) return this.resolveSubst(v, scope);
+    if (isConcat(v)) {
+      this.resolvingConcats.add(v);
+      try {
+        const concatResult = this.resolveConcat(v.nodes, scope, v.line, v.col);
+        return concatResult;
+      } finally {
+        this.resolvingConcats.delete(v);
+      }
+    }
+    if (isResObj(v)) return this.resolveResObj(v);
+    const hv = v;
+    if (hv.kind === "array") {
+      const items = [];
+      for (const item of hv.items) {
+        const resolved = this.resolveVal(item, scope);
+        if (resolved === void 0) continue;
+        items.push(resolved);
+      }
+      return { kind: "array", items };
+    }
+    return hv;
+  }
+  resolveSubst(s, scope) {
+    if (s.knownAbsent) {
+      if (!s.optional) {
+        if (this.opts.allowUnresolved) return s;
+        const k = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
+        throw new ResolveError(
+          `${this.originPrefix()}could not resolve substitution: \${${k}}`,
+          k,
+          s.line,
+          s.col
+        );
+      }
+      return void 0;
+    }
+    {
+      const rfp = this.resolvingFieldPath;
+      const sTexts = s.segments.map((seg) => seg.text);
+      if (rfp.length > 0 && rfp.length < sTexts.length && stringSegmentsToKey(sTexts.slice(0, rfp.length)) === stringSegmentsToKey(rfp)) {
+        const guardKey = stringSegmentsToKey(rfp);
+        const prior = scope.priorValues.get(rfp[rfp.length - 1]);
+        if (prior !== void 0 && !this.resolvingPrefixPriors.has(guardKey)) {
+          this.resolvingPrefixPriors.add(guardKey);
+          try {
+            const priorResolved = this.resolveVal(prior, scope);
+            if (priorResolved !== void 0) {
+              const navigated = this.navigateResolved(priorResolved, sTexts.slice(rfp.length));
+              if (navigated !== void 0) return navigated;
+            }
+          } finally {
+            this.resolvingPrefixPriors.delete(guardKey);
+          }
+        }
+        if (s.optional) return void 0;
+        if (this.opts.allowUnresolved) return s;
+        const k = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
+        throw new ResolveError(
+          `${this.originPrefix()}could not resolve substitution: \${${k}}`,
+          k,
+          s.line,
+          s.col
+        );
+      }
+    }
+    const key = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
+    if (this.cache.has(key)) return this.cache.get(key);
+    if (this.resolving.has(key)) {
+      let prior;
+      if (s.segments.length > 1) {
+        const leafSeg = _nullishCoalesce(_optionalChain([s, 'access', _6 => _6.segments, 'access', _7 => _7[s.segments.length - 1], 'optionalAccess', _8 => _8.text]), () => ( ""));
+        const parentScope = lookupResObj(
+          this.root,
+          s.segments.slice(0, s.segments.length - 1)
+        );
+        prior = _optionalChain([parentScope, 'optionalAccess', _9 => _9.priorValues, 'access', _10 => _10.get, 'call', _11 => _11(leafSeg)]);
+      } else {
+        const rootSeg = _nullishCoalesce(_optionalChain([s, 'access', _12 => _12.segments, 'access', _13 => _13[0], 'optionalAccess', _14 => _14.text]), () => ( ""));
+        prior = _nullishCoalesce(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(
+        this.originPrefix() + `circular substitution: ${key}`,
+        key,
+        s.line,
+        s.col
+      );
+    }
+    this.resolving.add(key);
+    try {
+      const found = lookupPath(this.root, s.segments);
+      if (found !== void 0) {
+        const rfp = this.resolvingFieldPath;
+        const isOwner = rfp.length >= s.segments.length && s.segments.every((seg, i) => rfp[i] === seg.text);
+        const isSelfRef = isConcat(found) && this.resolvingConcats.has(found) || isOwner && containsSubstByPath(found, s.segments);
+        if (isSelfRef) {
+          let prior;
+          if (s.segments.length > 1) {
+            const leafSeg = _nullishCoalesce(_optionalChain([s, 'access', _15 => _15.segments, 'access', _16 => _16[s.segments.length - 1], 'optionalAccess', _17 => _17.text]), () => ( ""));
+            const parentScope = lookupResObj(
+              this.root,
+              s.segments.slice(0, s.segments.length - 1)
+            );
+            prior = _optionalChain([parentScope, 'optionalAccess', _18 => _18.priorValues, 'access', _19 => _19.get, 'call', _20 => _20(leafSeg)]);
+          } else {
+            const rootSeg = _nullishCoalesce(_optionalChain([s, 'access', _21 => _21.segments, 'access', _22 => _22[0], 'optionalAccess', _23 => _23.text]), () => ( ""));
+            prior = _nullishCoalesce(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;
+          }
+          if (s.optional) return void 0;
+          throw new ResolveError(
+            `${this.originPrefix()}could not resolve substitution: \${${key}}`,
+            key,
+            s.line,
+            s.col
+          );
+        }
+        let result = this.resolveVal(found, scope);
+        const effectiveLen = s.segments.length - s.prefixLen;
+        if (effectiveLen === 1 && result !== void 0 && result.kind === "object") {
+          const leafSeg = _nullishCoalesce(_optionalChain([s, 'access', _24 => _24.segments, 'access', _25 => _25[s.segments.length - 1], 'optionalAccess', _26 => _26.text]), () => ( ""));
+          let prior;
+          if (s.prefixLen > 0) {
+            const parentScope = lookupResObj(
+              this.root,
+              s.segments.slice(0, s.segments.length - 1)
+            );
+            prior = _optionalChain([parentScope, 'optionalAccess', _27 => _27.priorValues, 'access', _28 => _28.get, 'call', _29 => _29(leafSeg)]);
+          } else {
+            prior = _nullishCoalesce(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;
+      }
+      if (s.prefixLen > 0 && s.segments.length > s.prefixLen) {
+        const originalSegments = s.segments.slice(s.prefixLen);
+        const fallbackFound = lookupPath(this.root, originalSegments);
+        if (fallbackFound !== void 0) {
+          let result = this.resolveVal(fallbackFound, scope);
+          if (originalSegments.length === 1 && result !== void 0 && result.kind === "object") {
+            const rootSeg = _nullishCoalesce(_optionalChain([originalSegments, 'access', _30 => _30[0], 'optionalAccess', _31 => _31.text]), () => ( ""));
+            const prior = this.root.priorValues.get(rootSeg);
+            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;
+        }
+      }
+      if (s.listSuffix && this.opts.useSystemEnvironment !== false) {
+        const result = this.resolveEnvList(s);
+        if (result !== void 0) {
+          this.cache.set(key, result);
+          return result;
+        }
+        if (s.optional) return void 0;
+        const envBase = s.segments.map((seg) => seg.text).join(".");
+        throw new ResolveError(
+          `${this.originPrefix()}could not resolve substitution: \${${key}} (no environment variables ${envBase}_0, ${envBase}_1, \u2026 set)`,
+          key,
+          s.line,
+          s.col
+        );
+      } else if (s.listSuffix) {
+        if (s.optional) return void 0;
+        if (this.opts.allowUnresolved) return s;
+        throw new ResolveError(
+          `${this.originPrefix()}could not resolve substitution: \${${key}}`,
+          key,
+          s.line,
+          s.col
+        );
+      }
+      if (this.opts.useSystemEnvironment !== false) {
+        const envKey = s.segments.map((seg) => seg.text).join(".");
+        const envVal = _nullishCoalesce(this.envVar(envKey), () => ( (s.prefixLen > 0 ? this.envVar(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);
+          return result;
+        }
+      }
+      if (s.optional) return void 0;
+      if (this.opts.allowUnresolved) {
+        return s;
+      }
+      throw new ResolveError(
+        `${this.originPrefix()}could not resolve substitution: \${${key}}`,
+        key,
+        s.line,
+        s.col
+      );
+    } finally {
+      this.resolving.delete(key);
+    }
+  }
+  /**
+   * S13c: scan environment for NAME_0, NAME_1, … and return an Array<Scalar(String)>.
+   *
+   * Candidate bases follow the same fully-qualified→bare order used by the scalar
+   * env fallback. The first base whose _0 key is present wins entirely — no
+   * cross-base merging (spec §Relativized fallback precedence rules).
+   *
+   * Returns the HoconValue Array if any candidate base has _0, or undefined if
+   * none do (caller applies optional/required handling).
+   */
+  resolveEnvList(s) {
+    const bases = this.candidateBases(s);
+    for (const base of bases) {
+      const key0 = base + "_0";
+      if (this.envVar(key0) === void 0) continue;
+      const items = [];
+      for (let i = 0; ; i++) {
+        const v = this.envVar(base + "_" + i);
+        if (v === void 0) break;
+        items.push({ kind: "scalar", raw: v, valueType: "string" });
+      }
+      return { kind: "array", items };
+    }
+    return void 0;
+  }
+  /**
+   * The environment variable `name`, or undefined when it is not set. Own keys
+   * only: the environment is a plain object (process.env, or the caller's
+   * `env`), so `env[name]` would answer `${?constructor}` or `${?toString}`
+   * from Object.prototype (#228).
+   */
+  envVar(name) {
+    return Object.prototype.hasOwnProperty.call(this.opts.env, name) ? this.opts.env[name] : void 0;
+  }
+  /**
+   * Return the candidate base names for env-var-list lookup, in precedence order.
+   * Mirrors the fully-qualified→bare fallback used by the scalar env path.
+   */
+  candidateBases(s) {
+    const full = s.segments.map((seg) => seg.text).join(".");
+    if (s.prefixLen === 0) return [full];
+    const bare = s.segments.slice(s.prefixLen).map((seg) => seg.text).join(".");
+    return [full, bare];
+  }
+  resolveConcat(nodes, scope, line = 0, col = 0) {
+    const rawResolved = nodes.map((n) => this.resolveVal(n, scope));
+    if (this.opts.allowUnresolved) {
+      for (const v of rawResolved) {
+        if (v !== void 0 && isSubst(v)) {
+          return v;
+        }
+      }
+    }
+    const resolved = rawResolved.filter((v) => v !== void 0);
+    if (resolved.length === 0) return void 0;
+    if (resolved.length === 1) return resolved[0];
+    const nonSep = resolved.filter((v) => !separatorValues.has(v));
+    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] };
+        }
+        throw new ResolveError(
+          "cannot concatenate array with object: value concatenation requires same-kind operands (S10.4)",
+          "",
+          line,
+          col
+        );
+      }
+      if (left.kind === "object" && right.kind === "array") {
+        const converted = numericObjectToArray(left);
+        if (converted !== null) {
+          return { kind: "array", items: [...converted, ...right.items] };
+        }
+        throw new ResolveError(
+          "cannot concatenate object with array: value concatenation requires same-kind operands (S10.4)",
+          "",
+          line,
+          col
+        );
+      }
+      if (left.kind === "array" && right.kind === "array") {
+        return { kind: "array", items: [...left.items, ...right.items] };
+      }
+      if (left.kind === "array" || right.kind === "array") {
+        throw new ResolveError(
+          `cannot concatenate ${left.kind} with ${right.kind}: arrays and objects may not appear in string value concatenation (S10.13)`,
+          "",
+          line,
+          col
+        );
+      }
+      if (left.kind === "object" || right.kind === "object") {
+        throw new ResolveError(
+          `cannot concatenate ${left.kind} with ${right.kind}: arrays and objects may not appear in string value concatenation (S10.13)`,
+          "",
+          line,
+          col
+        );
+      }
+      return { kind: "scalar", raw: left.raw + right.raw, 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" };
+    }
+    return folded;
+  }
+};
+
+// src/internal/resolver/resolver.ts
+function buildTree(ast, opts) {
+  return new StructureBuilder(opts).build(ast);
+}
+function buildTreeAsync(ast, opts) {
+  return new StructureBuilder(opts).buildAsync(ast);
+}
+function resolveTree(tree, opts) {
+  return new SubstitutionResolver(tree, opts).resolve();
+}
+function containsPlaceholders(tree) {
+  for (const val of tree.fields.values()) {
+    if (valContainsPlaceholders(val)) return true;
+  }
+  return false;
+}
+function valContainsPlaceholders(v) {
+  const rv = v;
+  if (isSubst(rv) || isConcat(rv)) return true;
+  if (isResObj(rv)) return containsPlaceholders(rv);
+  const hv = v;
+  if (_optionalChain([hv, 'optionalAccess', _32 => _32.kind]) === "array") {
+    return hv.items.some((item) => valContainsPlaceholders(item));
+  }
+  if (_optionalChain([hv, 'optionalAccess', _33 => _33.kind]) === "object") {
+    for (const field of hv.fields.values()) if (valContainsPlaceholders(field)) return true;
+  }
+  return false;
+}
+function buildPartialHoconFromResObj(tree) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [k, v] of tree.fields) {
+    if (!isSubst(v) && !isConcat(v)) {
+      if (isResObj(v)) {
+        fields.set(k, buildPartialHoconFromResObj(v));
+      } else {
+        if (!valContainsPlaceholders(v)) {
+          fields.set(k, partialValue(v));
+        }
+      }
+    }
+  }
+  return { kind: "object", fields };
+}
+function partialValue(v) {
+  if (isResObj(v)) return buildPartialHoconFromResObj(v);
+  if (v.kind === "array") return { kind: "array", items: v.items.map((item) => partialValue(item)) };
+  return v;
+}
+function hoconValueToResObj2(value) {
+  const obj = makeResObj();
+  for (const [k, v] of value.fields) {
+    if (v.kind === "object") {
+      obj.fields.set(k, hoconValueToResObj2(v));
+    } else {
+      obj.fields.set(k, v);
+    }
+  }
+  return obj;
+}
+function resolve2(ast, opts) {
+  const tree = buildTree(ast, opts);
+  return resolveTree(tree, { ...opts, useSystemEnvironment: true, allowUnresolved: false });
+}
+async function resolveAsync(ast, opts) {
+  const root = await buildTreeAsync(ast, opts);
+  return resolveTree(root, { ...opts, useSystemEnvironment: true, allowUnresolved: false });
+}
+
+// src/render-hocon.ts
+function renderHoconFromRoot(root) {
+  const out = [];
+  renderObjectBody(out, root, 0);
+  return out.join("");
+}
+function renderObjectBody(out, o, depth) {
+  const indent = "  ".repeat(depth);
+  for (const [k, v] of o.fields) {
+    out.push(indent, renderKey(k));
+    if (v.kind === "object") {
+      out.push(" {");
+      if (v.fields.size === 0) {
+        out.push("}\n");
+        continue;
+      }
+      out.push("\n");
+      renderObjectBody(out, v, depth + 1);
+      out.push(indent, "}\n");
+    } else {
+      out.push(" = ");
+      renderValue(out, v, depth);
+      out.push("\n");
+    }
+  }
+}
+function renderValue(out, v, depth) {
+  switch (v.kind) {
+    case "object": {
+      if (v.fields.size === 0) {
+        out.push("{}");
+        return;
+      }
+      out.push("{\n");
+      renderObjectBody(out, v, depth + 1);
+      out.push("  ".repeat(depth), "}");
+      return;
+    }
+    case "array":
+      renderArray(out, v, depth);
+      return;
+    case "scalar":
+      out.push(renderScalar(v));
+      return;
+    default:
+      throw new ConfigError(
+        "renderHocon: unrenderable value (config must be resolved data)",
+        ""
+      );
+  }
+}
+function renderArray(out, a, depth) {
+  if (a.items.length === 0) {
+    out.push("[]");
+    return;
+  }
+  const inner = "  ".repeat(depth + 1);
+  out.push("[\n");
+  for (const e of a.items) {
+    out.push(inner);
+    renderValue(out, e, depth + 1);
+    out.push("\n");
+  }
+  out.push("  ".repeat(depth), "]");
+}
+function renderScalar(s) {
+  switch (s.valueType) {
+    case "null":
+      return "null";
+    case "boolean":
+    case "number":
+      return s.raw;
+    case "string":
+      return renderString(s.raw);
+  }
+}
+var SAFE_UNQUOTED_KEY = /^[A-Za-z0-9_-]+$/;
+function renderKey(k) {
+  if (k === "include") return quoteString(k);
+  return SAFE_UNQUOTED_KEY.test(k) ? k : quoteString(k);
+}
+var SAFE_BARE_STRING = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var STRING_KEYWORDS = /* @__PURE__ */ new Set(["true", "false", "null", "yes", "no", "on", "off"]);
+function renderString(s) {
+  return SAFE_BARE_STRING.test(s) && !STRING_KEYWORDS.has(s.toLowerCase()) ? s : quoteString(s);
+}
+function quoteString(s) {
+  if (s.includes("\n") && !s.includes("\r") && !s.includes('"""') && !s.endsWith('"')) {
+    return `"""${s}"""`;
+  }
+  let b = '"';
+  for (const ch of s) {
+    switch (ch) {
+      case '"':
+        b += '\\"';
+        break;
+      case "\\":
+        b += "\\\\";
+        break;
+      case "\n":
+        b += "\\n";
+        break;
+      case "\r":
+        b += "\\r";
+        break;
+      case "	":
+        b += "\\t";
+        break;
+      default:
+        b += ch;
+    }
+  }
+  return b + '"';
+}
+
+// src/config.ts
+var Config = class _Config {
+  constructor(root, opts) {
+    this.root = root;
+    this._resolved = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _34 => _34.resolved]), () => ( true));
+    this._parseBaseDir = _optionalChain([opts, 'optionalAccess', _35 => _35.parseBaseDir]);
+    this._originDescription = _optionalChain([opts, 'optionalAccess', _36 => _36.originDescription]);
+    this._resObjRoot = _optionalChain([opts, 'optionalAccess', _37 => _37.resObjRoot]);
+    this._pendingRoot = _optionalChain([opts, 'optionalAccess', _38 => _38.pendingRoot]);
+    this._resolveOpts = _optionalChain([opts, 'optionalAccess', _39 => _39.resolveOpts]);
+  }
+  /** Returns true when the Config's value tree contains no unresolved
+   *  substitution placeholders. Whole-config granularity (E12 decision 11). */
+  isResolved() {
+    return this._resolved;
+  }
+  /** @internal Test-only: construct a resolved Config from a HoconValue. */
+  static _fromResolvedValue(root, opts) {
+    return new _Config(root, { resolved: true, originDescription: _optionalChain([opts, 'optionalAccess', _40 => _40.originDescription]) });
+  }
+  /** @internal Construct an unresolved Config carrying a ResObj tree.
+   *  Used by parseStringWithOptions (deferred path) in T6. */
+  static _fromUnresolvedResObj(tree, opts) {
+    const partialRoot = buildPartialHoconFromResObj(tree);
+    return new _Config(partialRoot, {
+      resolved: opts.resolved,
+      parseBaseDir: opts.parseBaseDir,
+      originDescription: opts.originDescription,
+      resObjRoot: tree,
+      resolveOpts: opts.resolveOpts
+    });
+  }
+  get(path) {
+    const v = this.lookupNode(path);
+    if (v === void 0) return void 0;
+    return hoconToJs(v);
+  }
+  /**
+   * Returns the raw {@link HoconValue} node at `path` as a deeply-immutable
+   * {@link ReadonlyHoconValue} view, or `undefined` if the path is absent. Unlike
+   * `get` (which decodes to a plain JS value), this exposes the value tree for
+   * structural introspection via the `value.ts` accessors (`asString`, `asObject`,
+   * `isScalar`, …).
+   *
+   * `getValue('')` returns the root object node.
+   *
+   * Throws {@link NotResolvedError} when the node (or its subtree) is unresolved:
+   * the `HoconValue` union has no placeholder variant, so an unresolved value
+   * cannot be represented. This matches `getConfig` / `getList`.
+   */
+  getValue(path) {
+    const v = this.lookupNode(path);
+    if (v === void 0) {
+      if (!this._resolved && this._subtreeHasPlaceholders(path)) {
+        throw new NotResolvedError(path);
+      }
+      return void 0;
+    }
+    if (v.kind !== "scalar" && !this._resolved && this._subtreeHasPlaceholders(path)) {
+      throw new NotResolvedError(path);
+    }
+    return v;
+  }
+  /**
+   * The scalar at `path` as its text: a number or boolean comes back as written
+   * (`8080`, `true`).
+   *
+   * @throws {@link NotResolvedError} when the value is an unresolved substitution.
+   * @throws {@link ConfigError} when `path` is missing or is not a scalar, or the value is
+   *   `null`.
+   */
+  getString(path) {
+    const v = this.requireScalar(path);
+    if (v.valueType === "null") {
+      throw new ConfigError(`expected string at ${path}, got ${v.valueType}`, path);
+    }
+    return v.raw;
+  }
+  /**
+   * The scalar at `path` as a number. A string that reads as a decimal number
+   * (`"8080"`, `"1.5e3"`) is accepted.
+   *
+   * @throws {@link NotResolvedError} when the value is an unresolved substitution.
+   * @throws {@link ConfigError} when `path` is missing or is not a scalar, or the value is not a
+   *   number.
+   */
+  getNumber(path) {
+    const v = this.requireScalar(path);
+    const coerced = coerceNumber(v.raw);
+    if (coerced !== void 0) return coerced;
+    throw new ConfigError(`expected number at ${path}, got ${v.valueType}`, path);
+  }
+  /**
+   * The scalar at `path` as a boolean: `true` / `yes` / `on` and `false` /
+   * `no` / `off`, in any case.
+   *
+   * @throws {@link NotResolvedError} when the value is an unresolved substitution.
+   * @throws {@link ConfigError} when `path` is missing or is not a scalar, or the value is not one
+   *   of those words.
+   */
+  getBoolean(path) {
+    const v = this.requireScalar(path);
+    const coerced = coerceBoolean(v.raw);
+    if (coerced !== void 0) return coerced;
+    throw new ConfigError(`expected boolean at ${path}, got ${v.valueType}`, path);
+  }
+  /**
+   * The duration at `path` in `unit` (default `ms`): a string with a unit
+   * (`"30s"`, `"1.5h"`), or a number or unit-less string, which is
+   * milliseconds. The number is read exactly and rounded once in `unit` (E20).
+   * Negative durations are allowed.
+   *
+   * @throws {@link NotResolvedError} when the value is an unresolved substitution.
+   * @throws {@link ConfigError} when `path` is missing or is not a string or number, the text is
+   *   not a duration, or the result is not a finite number (E21).
+   */
+  getDuration(path, unit) {
+    const v = this.requireScalar(path);
+    if (v.valueType !== "string" && v.valueType !== "number") {
+      throw new ConfigError(`expected duration at ${path}, got ${v.valueType}`, path);
+    }
+    const reading = readDuration(v.raw, unit);
+    if (reading.ok) return reading.value;
+    switch (reading.problem) {
+      case "invalid":
+        throw new ConfigError(`invalid duration at ${path}: ${JSON.stringify(v.raw)}`, path);
+      case "overflow":
+        throw new ConfigError(`duration overflows the representable range at ${path}: ${JSON.stringify(v.raw)}`, path);
+    }
+  }
+  /**
+   * The byte size at `path` in `unit` (default `B`): a string with a unit
+   * (`"64KiB"`, `"1.5MB"`), or a number or unit-less string, which is bytes.
+   * The exact size is truncated toward zero to whole bytes, then converted to
+   * `unit` (E20).
+   *
+   * @throws {@link NotResolvedError} when the value is an unresolved substitution.
+   * @throws {@link ConfigError} when `path` is missing or is not a string or number, the text is
+   *   not a byte size, the size is negative, or it exceeds 2^53-1 bytes (the
+   *   largest integer a JS number holds exactly).
+   */
+  getBytes(path, unit) {
+    const v = this.requireScalar(path);
+    if (v.valueType !== "string" && v.valueType !== "number") {
+      throw new ConfigError(`expected byte size at ${path}, got ${v.valueType}`, path);
+    }
+    const reading = readBytes(v.raw, unit);
+    if (reading.ok) return reading.value;
+    switch (reading.problem) {
+      case "invalid":
+        throw new ConfigError(`invalid byte size at ${path}: ${JSON.stringify(v.raw)}`, path);
+      case "negative":
+        throw new ConfigError(`byte size must be non-negative at ${path}: ${JSON.stringify(v.raw)}`, path);
+      case "overflow":
+        throw new ConfigError(
+          `byte size overflows the representable range at ${path}: ${JSON.stringify(v.raw)}`,
+          path
+        );
+    }
+  }
+  /**
+   * The calendar period at `path` (`7d`, `2w`, `3m`, `1y`; a bare integer is
+   * days). Integer only, unlike {@link getDuration} / {@link getBytes}.
+   *
+   * @throws {@link NotResolvedError} when the value is an unresolved substitution.
+   * @throws {@link ConfigError} when `path` is missing or is not a string or number, or the text
+   *   is not a period.
+   */
+  getPeriod(path) {
+    const v = this.requireScalar(path);
+    if (v.valueType !== "string" && v.valueType !== "number") {
+      throw new ConfigError(`expected period at ${path}, got ${v.valueType}`, path);
+    }
+    const reading = readPeriod(v.raw);
+    if (reading.ok) return reading.value;
+    switch (reading.problem) {
+      case "invalid":
+        throw new ConfigError(`invalid period at ${path}: ${JSON.stringify(v.raw)}`, path);
+    }
+  }
+  /**
+   * The object at `path` as a Config of its own, with paths relative to it.
+   *
+   * @throws {@link NotResolvedError} when the object holds an unresolved substitution.
+   * @throws {@link ConfigError} when `path` is missing or is not an object.
+   */
+  getConfig(path) {
+    const v = this.lookupNode(path);
+    if (v === void 0) {
+      if (!this._resolved && this._subtreeHasPlaceholders(path)) {
+        throw new NotResolvedError(path);
+      }
+      throw new ConfigError(`path not found: ${path}`, path);
+    }
+    if (v.kind !== "object") throw new ConfigError(`expected object at ${path}`, path);
+    if (!this._resolved && this._subtreeHasPlaceholders(path)) {
+      throw new NotResolvedError(path);
+    }
+    return new _Config(v, { resolved: true });
+  }
+  /**
+   * The list at `path` as plain values (see {@link get}). An object with integer
+   * keys (`"0"`, `"1"`, …) is read as a list too, in key order with gaps closed
+   * up; its other keys are ignored (S15).
+   *
+   * @throws {@link NotResolvedError} when the list holds an unresolved substitution.
+   * @throws {@link ConfigError} when `path` is missing or is not a list.
+   */
+  getList(path) {
+    const v = this.lookupNode(path);
+    if (v === void 0) {
+      if (!this._resolved && this._subtreeHasPlaceholders(path)) {
+        throw new NotResolvedError(path);
+      }
+      throw new ConfigError(`path not found: ${path}`, path);
+    }
+    if (!this._resolved && this._subtreeHasPlaceholders(path)) {
+      throw new NotResolvedError(path);
+    }
+    if (v.kind === "object") {
+      const converted = numericObjectToArray(v);
+      if (converted !== null) return converted.map((item) => hoconToJs(item));
+    }
+    if (v.kind !== "array") throw new ConfigError(`expected array at ${path}`, path);
+    return v.items.map((item) => hoconToJs(item));
+  }
+  /**
+   * Whether `path` is present. A path whose value is still an unresolved
+   * substitution is present too (`true`, no throw), as in go.hocon; reading it
+   * throws {@link NotResolvedError}. A path *under* such a value is not known
+   * yet and answers `false`.
+   */
+  has(path) {
+    if (this.lookupNode(path) !== void 0) return true;
+    return !this._resolved && this._unresolvedTreeHas(path);
+  }
+  keys() {
+    return [...this.root.fields.keys()];
+  }
+  withFallback(fallback) {
+    if (fallback == null) return this;
+    const selfTree = _nullishCoalesce(this._resObjRoot, () => ( hoconValueToResObj2(this.root)));
+    const fbTree = _nullishCoalesce(fallback._resObjRoot, () => ( hoconValueToResObj2(fallback.root)));
+    const merged = mergeUnresolved(selfTree, fbTree);
+    const hasPlaceholders = containsPlaceholders(merged);
+    const partialRoot = buildPartialHoconFromResObj(merged);
+    return new _Config(partialRoot, {
+      resolved: !hasPlaceholders,
+      parseBaseDir: this._parseBaseDir,
+      originDescription: this._originDescription,
+      resObjRoot: merged,
+      resolveOpts: _nullishCoalesce(this._resolveOpts, () => ( fallback._resolveOpts))
+    });
+  }
+  /**
+   * Runs substitution resolution (phase 2) on the stored unresolved tree.
+   * Idempotent: calling resolve() on an already-resolved Config returns an
+   * equivalent resolved Config.
+   *
+   * opts.allowUnresolved (default false) — when true, leaves unresolved
+   * non-optional placeholders in place rather than throwing.
+   * opts.useSystemEnvironment (default true) — when false, env var lookups
+   * are suppressed (hermetic resolution).
+   *
+   * E12 decision 3.
+   */
+  resolve(opts = {}) {
+    if (this._resolved) {
+      return new _Config(this.root, {
+        resolved: true,
+        parseBaseDir: this._parseBaseDir,
+        originDescription: this._originDescription
+      });
+    }
+    const tree = this._resObjRoot;
+    if (!tree) {
+      return new _Config(this.root, { resolved: true });
+    }
+    const resolveOpts = {
+      ..._nullishCoalesce(this._resolveOpts, () => ( { env: {}, baseDir: void 0, readFileSync: () => {
+        throw new Error("no files");
+      } })),
+      allowUnresolved: _nullishCoalesce(opts.allowUnresolved, () => ( false)),
+      useSystemEnvironment: _nullishCoalesce(opts.useSystemEnvironment, () => ( true)),
+      originDescription: this._originDescription
+    };
+    const resolved = resolveTree(tree, resolveOpts);
+    if (resolved.kind !== "object") throw new Error("resolve: expected object root");
+    if (opts.allowUnresolved) {
+      const { stripped, hadPlaceholders } = stripPlaceholderFields(resolved);
+      return new _Config(stripped, {
+        resolved: !hadPlaceholders,
+        parseBaseDir: this._parseBaseDir,
+        originDescription: this._originDescription,
+        resObjRoot: hadPlaceholders ? tree : void 0,
+        pendingRoot: hadPlaceholders ? hoconValueToResObj2(resolved) : void 0,
+        resolveOpts: hadPlaceholders ? resolveOpts : void 0
+      });
+    }
+    return new _Config(resolved, {
+      resolved: true,
+      parseBaseDir: this._parseBaseDir,
+      originDescription: this._originDescription
+    });
+  }
+  /**
+   * Resolves receiver substitutions using source as lookup context.
+   * Source's keys are NOT merged into the result — differs from
+   * `this.withFallback(source).resolve()` which includes source keys.
+   *
+   * Precondition (E12 decision 10): source must be resolved. If
+   * source.isResolved() is false, throws NotResolvedError.
+   *
+   * On an already-resolved receiver, resolveWith is a no-op (returns an
+   * equivalent resolved Config, source keys not included).
+   *
+   * E12 decisions 9, 10.
+   */
+  resolveWith(source, opts = {}) {
+    if (!source.isResolved()) {
+      throw new NotResolvedError("source");
+    }
+    if (this._resolved) {
+      return new _Config(this.root, {
+        resolved: true,
+        parseBaseDir: this._parseBaseDir,
+        originDescription: this._originDescription
+      });
+    }
+    const receiverTree = _nullishCoalesce(this._resObjRoot, () => ( hoconValueToResObj2(this.root)));
+    const srcTree = hoconValueToResObj2(source.root);
+    const merged = mergeUnresolved(receiverTree, srcTree);
+    const resolveOpts = {
+      ..._nullishCoalesce(this._resolveOpts, () => ( { env: {}, baseDir: void 0, readFileSync: () => {
+        throw new Error("no files");
+      } })),
+      allowUnresolved: _nullishCoalesce(opts.allowUnresolved, () => ( false)),
+      useSystemEnvironment: _nullishCoalesce(opts.useSystemEnvironment, () => ( true)),
+      originDescription: this._originDescription
+    };
+    const resolved = resolveTree(merged, resolveOpts);
+    if (resolved.kind !== "object") throw new Error("resolveWith: expected object root");
+    const receiverShapeForFilter = resObjToKeyShape(receiverTree);
+    const filtered = filterByReceiverShape(resolved, receiverShapeForFilter);
+    if (opts.allowUnresolved) {
+      const { stripped, hadPlaceholders } = stripPlaceholderFields(filtered);
+      return new _Config(stripped, {
+        resolved: !hadPlaceholders,
+        parseBaseDir: this._parseBaseDir,
+        originDescription: this._originDescription,
+        resObjRoot: hadPlaceholders ? receiverTree : void 0,
+        pendingRoot: hadPlaceholders ? hoconValueToResObj2(filtered) : void 0,
+        resolveOpts: hadPlaceholders ? resolveOpts : void 0
+      });
+    }
+    return new _Config(filtered, {
+      resolved: true,
+      parseBaseDir: this._parseBaseDir,
+      originDescription: this._originDescription
+    });
+  }
+  /**
+   * The whole config as plain JS data: objects, arrays, strings, numbers,
+   * booleans and `null`.
+   *
+   * Keys are reproduced exactly as the config carries them, `__proto__`,
+   * `constructor` and `prototype` included: each is defined as an **own data
+   * property**, so the returned object's prototype is always
+   * `Object.prototype`, and this call writes nothing to the global one.
+   *
+   * ### Passing the result to other code
+   *
+   * A config file — especially a `.properties` file or an env namespace you
+   * merged in — can therefore hand you an own `__proto__` key, and what happens
+   * next depends entirely on how the consumer copies it:
+   *
+   * ```ts
+   * const data = cfg.toObject()
+   * { ...data }                  // safe — own properties are copied as data
+   * structuredClone(data)        // safe
+   * Object.assign({}, data)      // NOT safe — [[Set]] on the {} target hits
+   *                              // Object.prototype's __proto__ setter: the key
+   *                              // vanishes and config data becomes the result's
+   *                              // prototype
+   * deepMerge({}, data)          // NOT safe — a naive recursive merge reads
+   *                              // target['__proto__'], gets Object.prototype,
+   *                              // and writes to it: global pollution
+   * for (const k in data) …      // prefer Object.entries / Object.keys
+   * ```
+   *
+   * Those two hazards come from the **destination** object's prototype, so no
+   * option here can disarm them — copy with spread or `structuredClone` instead.
+   *
+   * What `{ nullPrototype: true }` does give you is a result that inherits
+   * nothing: every object comes back with a `null` prototype, so reading
+   * `x.__proto__`, `x.constructor` or `x.toString` yields config data or
+   * `undefined` rather than something from `Object.prototype`, and code that
+   * merges *into* this object cannot climb out of it. Keys are all still
+   * present. The trade-off is the usual one for prototype-less objects: not
+   * `instanceof Object`, and no `hasOwnProperty` of their own.
+   *
+   * Numbers follow the JS number model, so an integer wider than 2^53 rounds
+   * here even when the config holds it exactly — read those with
+   * {@link Config.getString} instead.
+   */
+  toObject(opts) {
+    return hoconToJs(this.root, _optionalChain([opts, 'optionalAccess', _41 => _41.nullPrototype]) === true);
+  }
+  /**
+   * Renders this resolved Config as HOCON text (E18; lockstep with go.hocon's
+   * `Config.RenderHOCON`, v1.11.0).
+   *
+   * The output round-trips: parsing it back yields the same value tree. That
+   * is the correctness contract, not byte-for-byte formatting — a scalar is
+   * quoted whenever leaving it bare would re-parse as a different type (a
+   * string `"8080"` becomes `"8080"`, not `8080`), and left bare only when it
+   * provably cannot.
+   *
+   * The Config must be resolved and hold only data (objects, arrays, string /
+   * number / boolean / null scalars) — exactly what {@link fromMap} and the
+   * format adapters produce. An unresolved placeholder throws
+   * {@link ConfigError}; substitutions have no textual round trip through a
+   * value tree.
+   *
+   * The root object's fields are emitted without enclosing braces, nested
+   * objects as `key { … }`, arrays as newline-separated `[ … ]`, indented two
+   * spaces. Source comments are not represented — a value tree does not carry
+   * them.
+   */
+  renderHocon() {
+    if (!this._resolved) {
+      throw new ConfigError(
+        "renderHocon: unrenderable unresolved substitution (config must be resolved data)",
+        ""
+      );
+    }
+    return renderHoconFromRoot(this.root);
+  }
+  /**
+   * @internal Test-only: renders this resolved Config's value tree as canonical
+   * JSON (sorted keys, no whitespace). Used by Layer-2 fixture tests to compare
+   * against Lightbend ground truth. NOT part of the public API.
+   *
+   * Throws if the Config is unresolved (contains placeholders).
+   */
+  _renderJSONForTest() {
+    return renderHoconAsJSON(this.root);
+  }
+  lookupNode(path) {
+    const segments = splitConfigPath(path);
+    let current = this.root;
+    for (const seg of segments) {
+      if (current.kind !== "object") return void 0;
+      const next = current.fields.get(seg);
+      if (next === void 0) return void 0;
+      current = next;
+    }
+    return current;
+  }
+  /** Whether `path` names a field in the unresolved tree (a placeholder included). */
+  _unresolvedTreeHas(path) {
+    let cur = _nullishCoalesce(this._pendingRoot, () => ( this._resObjRoot));
+    const segments = splitConfigPath(path);
+    for (let i = 0; cur !== void 0 && i < segments.length; i++) {
+      const val = cur.fields.get(segments[i]);
+      if (val === void 0) return false;
+      if (i === segments.length - 1) return true;
+      cur = isResObj(val) ? val : void 0;
+    }
+    return false;
+  }
+  /**
+   * _subtreeHasPlaceholders — walk the unresolved tree (`_pendingRoot` after a
+   * partial resolve, else `_resObjRoot`) to the given path and return true if
+   * the subtree there contains any unresolved placeholder.
+   * Used by getConfig / getList (T2) to detect transitive unresolved placeholders
+   * in object / array subtrees that would otherwise appear to be "resolved" in the
+   * partial HoconValue root (because individual leaf fields are omitted rather than
+   * the whole subtree when their value is a direct placeholder scalar, but object
+   * sub-containers are retained in the partial root with the placeholder-keyed
+   * fields omitted from them — so the object appears "present but empty-ish").
+   */
+  _subtreeHasPlaceholders(path) {
+    const tree = _nullishCoalesce(this._pendingRoot, () => ( this._resObjRoot));
+    if (!tree) return false;
+    const segments = splitConfigPath(path);
+    let cur = tree;
+    for (const seg of segments) {
+      const val = cur.fields.get(seg);
+      if (val === void 0) return false;
+      if (isResObj(val)) {
+        cur = val;
+      } else {
+        return valContainsPlaceholders(val);
+      }
+    }
+    return containsPlaceholders(cur);
+  }
+  requireScalar(path) {
+    const v = this.lookupNode(path);
+    if (v === void 0) {
+      if (!this._resolved && this._subtreeHasPlaceholders(path)) {
+        throw new NotResolvedError(path);
+      }
+      throw new ConfigError(`path not found: ${path}`, path);
+    }
+    if (v.kind !== "scalar") throw new ConfigError(`expected scalar at ${path}, got ${v.kind}`, path);
+    return v;
+  }
+};
+function splitConfigPath(path) {
+  const segments = [];
+  let i = 0;
+  while (i < path.length) {
+    if (path[i] === '"') {
+      i++;
+      let segment = "";
+      let closed = false;
+      while (i < path.length) {
+        const ch = path[i];
+        if (ch === "\\" && i + 1 < path.length) {
+          const next = path[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: ${path}`, path);
+      segments.push(segment);
+      if (i < path.length && path[i] === ".") i++;
+    } else {
+      const dot = path.indexOf(".", i);
+      if (dot === -1) {
+        segments.push(path.slice(i));
+        break;
+      }
+      segments.push(path.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, nullPrototype = false) {
+  switch (v.kind) {
+    case "scalar":
+      return scalarToJs(v.raw, v.valueType);
+    case "array":
+      return v.items.map((item) => hoconToJs(item, nullPrototype));
+    case "object": {
+      const entries = Array.from(v.fields, ([k, val]) => [k, hoconToJs(val, nullPrototype)]);
+      if (nullPrototype) {
+        const obj = /* @__PURE__ */ Object.create(null);
+        for (const [k, val] of entries) Object.defineProperty(obj, k, {
+          value: val,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+        return obj;
+      }
+      return Object.fromEntries(entries);
+    }
+  }
+}
+function resObjToKeyShape(tree) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [k, v] of tree.fields) {
+    if (isSubst(v) || isConcat(v)) {
+      fields.set(k, { kind: "scalar", raw: "", valueType: "null" });
+    } else if (isResObj(v)) {
+      fields.set(k, resObjToKeyShape(v));
+    } else {
+      fields.set(k, v);
+    }
+  }
+  return { kind: "object", fields };
+}
+function stripPlaceholderFields(v) {
+  const fields = /* @__PURE__ */ new Map();
+  let hadPlaceholders = false;
+  for (const [k, val] of v.fields) {
+    if (val._kind === "subst-placeholder" || val._kind === "concat-placeholder") {
+      hadPlaceholders = true;
+    } else if (val.kind === "object") {
+      const inner = stripPlaceholderFields(val);
+      if (inner.hadPlaceholders) hadPlaceholders = true;
+      fields.set(k, inner.stripped);
+    } else if (val.kind === "array" && valContainsPlaceholders(val)) {
+      hadPlaceholders = true;
+    } else {
+      fields.set(k, val);
+    }
+  }
+  return { stripped: { kind: "object", fields }, hadPlaceholders };
+}
+function filterByReceiverShape(resolved, receiverShape) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [k, rv] of resolved.fields) {
+    if (!receiverShape.fields.has(k)) continue;
+    const receiverVal = receiverShape.fields.get(k);
+    if (rv.kind === "object" && receiverVal.kind === "object") {
+      fields.set(k, filterByReceiverShape(rv, receiverVal));
+    } else {
+      fields.set(k, rv);
+    }
+  }
+  return { kind: "object", fields };
+}
+function renderHoconAsJSON(v) {
+  switch (v.kind) {
+    case "scalar": {
+      switch (v.valueType) {
+        case "null":
+          return "null";
+        case "boolean":
+          return v.raw;
+        case "number": {
+          const norm = completeJsonNumber(normalizeLeadingZeroNumber(v.raw));
+          return JSON_NUMBER_RE.test(norm) ? norm : JSON.stringify(v.raw);
+        }
+        case "string":
+          return JSON.stringify(v.raw);
+      }
+      break;
+    }
+    case "array": {
+      const items = v.items.map(renderHoconAsJSON);
+      return `[${items.join(",")}]`;
+    }
+    case "object": {
+      const keys = [...v.fields.keys()].sort();
+      const pairs = keys.map((k) => {
+        const val = v.fields.get(k);
+        return `${JSON.stringify(k)}:${renderHoconAsJSON(val)}`;
+      });
+      return `{${pairs.join(",")}}`;
+    }
+  }
+  throw new Error(`renderHoconAsJSON: unsupported value kind (unresolved placeholder?)`);
+}
+var JSON_NUMBER_RE = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+function normalizeLeadingZeroNumber(raw) {
+  return raw.replace(/^([+-]?)0+(\d)/, "$1$2");
+}
+function completeJsonNumber(raw) {
+  return raw.replace(/^([+-]?)\./, "$10.").replace(/\.(?=[eE]|$)/, ".0");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.coerceBoolean = coerceBoolean; exports.coerceNumber = coerceNumber; exports.readDuration = readDuration; exports.readBytes = readBytes; exports.readPeriod = readPeriod; exports.ParseError = ParseError; exports.ResolveError = ResolveError; exports.PackageLookupError = PackageLookupError; exports.ConfigError = ConfigError; exports.NotResolvedError = NotResolvedError; exports.tokenize = tokenize; exports.parseTokens = parseTokens; exports.stripBom = stripBom; exports.MAX_PATH_SEGMENTS = MAX_PATH_SEGMENTS; exports.tooDeep = tooDeep; exports.guardStackDepth = guardStackDepth; exports.depthError = depthError; exports.guardStackDepthAsync = guardStackDepthAsync; exports.parseProperties = parseProperties; exports.nestPairs = nestPairs; exports.pathKey = pathKey; exports.buildTree = buildTree; exports.buildTreeAsync = buildTreeAsync; exports.containsPlaceholders = containsPlaceholders; exports.resolve = resolve2; exports.resolveAsync = resolveAsync; exports.Config = Config;