@o3co/ts.hocon 1.12.0 → 1.14.0

package/dist/adapters/env.cjs

@@ -1,1677 +1,26 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }
 
-// src/adapters/env.ts
-var env_exports = {};
-__export(env_exports, {
-  loadEnv: () => loadEnv,
-  parseDotEnv: () => parseDotEnv
-});
-module.exports = __toCommonJS(env_exports);
+var _chunkGBNQADHTcjs = require('../chunk-GBNQADHT.cjs');
 
-// 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);
-}
-var DURATION_UNITS = {
-  ns: 1e-6,
-  nanosecond: 1e-6,
-  nanoseconds: 1e-6,
-  us: 1e-3,
-  microsecond: 1e-3,
-  microseconds: 1e-3,
-  ms: 1,
-  millisecond: 1,
-  milliseconds: 1,
-  s: 1e3,
-  second: 1e3,
-  seconds: 1e3,
-  m: 6e4,
-  minute: 6e4,
-  minutes: 6e4,
-  h: 36e5,
-  hour: 36e5,
-  hours: 36e5,
-  d: 864e5,
-  day: 864e5,
-  days: 864e5
-};
-var OUTPUT_DURATION_UNITS = {
-  ns: 1e-6,
-  us: 1e-3,
-  ms: 1,
-  s: 1e3,
-  m: 6e4,
-  h: 36e5,
-  d: 864e5
-};
-function parseDuration(value, outputUnit = "ms") {
-  const trimmed = trimHoconWs(value);
-  let i = 0;
-  while (i < trimmed.length) {
-    const ch = trimmed[i];
-    if (i === 0 && (ch === "-" || ch === "+")) {
-      i++;
-      continue;
-    }
-    if (ch !== "." && (ch < "0" || ch > "9")) break;
-    i++;
-  }
-  if (i === 0) return NaN;
-  const num = Number(trimmed.slice(0, i));
-  if (Number.isNaN(num)) return NaN;
-  const unit = trimHoconWs(trimmed.slice(i));
-  const divisor = OUTPUT_DURATION_UNITS[outputUnit];
-  if (divisor === void 0) return NaN;
-  if (unit === "") {
-    return num / divisor;
-  }
-  const mult = DURATION_UNITS[unit];
-  if (mult === void 0) return NaN;
-  const ms = num * mult;
-  return ms / divisor;
-}
-var BYTE_UNITS = {
-  B: 1,
-  byte: 1,
-  bytes: 1,
-  KB: 1e3,
-  kilobyte: 1e3,
-  kilobytes: 1e3,
-  KiB: 1024,
-  kibibyte: 1024,
-  kibibytes: 1024,
-  MB: 1e6,
-  megabyte: 1e6,
-  megabytes: 1e6,
-  MiB: 1048576,
-  mebibyte: 1048576,
-  mebibytes: 1048576,
-  GB: 1e9,
-  gigabyte: 1e9,
-  gigabytes: 1e9,
-  GiB: 1073741824,
-  gibibyte: 1073741824,
-  gibibytes: 1073741824,
-  TB: 1e12,
-  terabyte: 1e12,
-  terabytes: 1e12,
-  TiB: 1099511627776,
-  tebibyte: 1099511627776,
-  tebibytes: 1099511627776,
-  // S21.4 — HOCON.md L1385: single-letter abbreviations → powers of two (java -Xmx convention).
-  // Lightbend typesafe-config 1.4.3 verified: 1K=1024, 1M=1048576, etc.
-  // Both upper- and lowercase accepted per Lightbend behaviour.
-  // Z/Y (2^70/2^80) are deferred — they overflow MAX_SAFE_INTEGER and require BigInt accessor.
-  K: 1024,
-  k: 1024,
-  M: 1024 ** 2,
-  m: 1024 ** 2,
-  G: 1024 ** 3,
-  g: 1024 ** 3,
-  T: 1024 ** 4,
-  t: 1024 ** 4,
-  P: 1024 ** 5,
-  p: 1024 ** 5,
-  E: 1024 ** 6,
-  e: 1024 ** 6,
-  // lowercase short-form aliases
-  b: 1,
-  kb: 1e3,
-  kib: 1024,
-  mb: 1e6,
-  mib: 1048576,
-  gb: 1e9,
-  gib: 1073741824,
-  tb: 1e12,
-  tib: 1099511627776
-};
-var OUTPUT_BYTE_UNITS = {
-  B: 1,
-  KB: 1e3,
-  KiB: 1024,
-  MB: 1e6,
-  MiB: 1048576,
-  GB: 1e9,
-  GiB: 1073741824,
-  TB: 1e12,
-  TiB: 1099511627776
-};
-function parseBytes(value, outputUnit = "B") {
-  const trimmed = trimHoconWs(value);
-  let i = 0;
-  while (i < trimmed.length) {
-    const ch = trimmed[i];
-    if (i === 0 && (ch === "-" || ch === "+")) {
-      i++;
-      continue;
-    }
-    if (ch !== "." && (ch < "0" || ch > "9")) break;
-    i++;
-  }
-  if (i === 0) return NaN;
-  const num = Number(trimmed.slice(0, i));
-  if (Number.isNaN(num)) return NaN;
-  const unit = trimHoconWs(trimmed.slice(i));
-  const divisor = OUTPUT_BYTE_UNITS[outputUnit];
-  if (divisor === void 0) return NaN;
-  if (unit === "") {
-    const bytes2 = Math.trunc(num);
-    if (Math.abs(bytes2) > Number.MAX_SAFE_INTEGER) {
-      throw new RangeError("byte size overflows representable range (max 2^53-1 bytes)");
-    }
-    return bytes2 / divisor;
-  }
-  let mult = BYTE_UNITS[unit];
-  if (mult === void 0) {
-    mult = BYTE_UNITS[unit.toLowerCase()];
-  }
-  if (mult === void 0) return NaN;
-  const bytes = num * mult;
-  if (Math.abs(bytes) > Number.MAX_SAFE_INTEGER) {
-    throw new RangeError("byte size overflows representable range (max 2^53-1 bytes)");
-  }
-  const result = bytes / divisor;
-  return outputUnit === "B" ? Math.round(result) : result;
-}
 
-// src/errors.ts
-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 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/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 containsSelfRef(v, fullKey) {
-  if (isSubst(v)) return !v.knownAbsent && substFullKey(v) === fullKey;
-  if (isConcat(v)) return v.nodes.some((n) => containsSelfRef(n, fullKey));
-  if (isResObj(v)) {
-    for (const f of v.fields.values()) {
-      if (containsSelfRef(f, fullKey)) return true;
-    }
-    return false;
-  }
-  const hv = v;
-  if (hv.kind === "array") {
-    return hv.items.some((item) => containsSelfRef(item, fullKey));
-  }
-  if (hv.kind === "object") {
-    for (const f of hv.fields.values()) {
-      if (containsSelfRef(f, fullKey)) return true;
-    }
-    return false;
-  }
-  return false;
-}
-function foldSelfRef(v, fullKey, replacement) {
-  if (isSubst(v)) {
-    return substFullKey(v) === fullKey ? replacement : v;
-  }
-  if (isConcat(v)) {
-    return {
-      _kind: "concat-placeholder",
-      nodes: v.nodes.map((n) => foldSelfRef(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, foldSelfRef(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) => foldSelfRef(item, fullKey, replacement))
-    };
-  }
-  if (hv.kind === "object") {
-    const newFields = /* @__PURE__ */ new Map();
-    for (const [k, val] of hv.fields) {
-      newFields.set(k, foldSelfRef(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);
-  return foldSelfRef(prior, fullKey, old);
-}
-function foldOptionalSelfRefAbsent(v, fullKey) {
-  if (isSubst(v) && substFullKey(v) === fullKey) {
-    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 = foldOptionalSelfRefAbsent(node, fullKey);
-      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 = foldOptionalSelfRefAbsent(value, fullKey);
-      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 = foldOptionalSelfRefAbsent(item, fullKey);
-      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 = foldOptionalSelfRefAbsent(value, fullKey);
-      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 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 (existing?.kind === "object" && v.kind === "object") {
-      merged.set(k, deepMergeHoconValues(existing, v));
-    } else {
-      merged.set(k, v);
-    }
-  }
-  return { kind: "object", fields: merged };
-}
 
-// src/internal/resolver/include-loader.ts
-var import_node_module = require("module");
-var nodePath = __toESM(require("path"), 1);
-var import_node_url = require("url");
 
-// 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, "");
-}
-
-// src/internal/properties/properties.ts
-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 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;
-}
-
-// 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 = [];
-  }
-  /** 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);
-      let resolved;
-      try {
-        resolved = this.resolveVal(val, obj);
-      } finally {
-        this.resolvingFieldPath.pop();
-      }
-      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);
-          }
-        }
-      }
-    }
-    return { kind: "object", fields: result };
-  }
-  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") {
-      return {
-        kind: "array",
-        items: hv.items.map(
-          (item) => this.resolveVal(item, scope) ?? { kind: "scalar", raw: "null", valueType: "null" }
-        )
-      };
-    }
-    return hv;
-  }
-  resolveSubst(s, scope) {
-    if (s.knownAbsent) return void 0;
-    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 = s.segments[s.segments.length - 1]?.text ?? "";
-        const parentScope = lookupResObj(
-          this.root,
-          s.segments.slice(0, s.segments.length - 1)
-        );
-        prior = parentScope?.priorValues.get(leafSeg);
-      } else {
-        const rootSeg = s.segments[0]?.text ?? "";
-        prior = scope.priorValues.get(rootSeg) ?? this.root.priorValues.get(rootSeg);
-      }
-      if (prior !== void 0) {
-        const saved = this.resolving;
-        this.resolving = new Set(saved);
-        try {
-          return this.resolveVal(prior, scope);
-        } finally {
-          this.resolving = saved;
-        }
-      }
-      if (s.optional) return void 0;
-      throw new ResolveError(
-        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 = s.segments[s.segments.length - 1]?.text ?? "";
-            const parentScope = lookupResObj(
-              this.root,
-              s.segments.slice(0, s.segments.length - 1)
-            );
-            prior = parentScope?.priorValues.get(leafSeg);
-          } else {
-            const rootSeg = s.segments[0]?.text ?? "";
-            prior = scope.priorValues.get(rootSeg) ?? this.root.priorValues.get(rootSeg);
-          }
-          if (prior !== void 0) {
-            const result2 = this.resolveVal(prior, scope);
-            if (result2 !== void 0) this.cache.set(key, result2);
-            return result2;
-          }
-          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 = s.segments[s.segments.length - 1]?.text ?? "";
-          let prior;
-          if (s.prefixLen > 0) {
-            const parentScope = lookupResObj(
-              this.root,
-              s.segments.slice(0, s.segments.length - 1)
-            );
-            prior = parentScope?.priorValues.get(leafSeg);
-          } else {
-            prior = scope.priorValues.get(leafSeg) ?? this.root.priorValues.get(leafSeg);
-          }
-          if (prior !== void 0) {
-            const priorResolved = this.resolveVal(prior, scope);
-            if (priorResolved !== void 0 && priorResolved.kind === "object") {
-              result = deepMergeHoconValues(
-                priorResolved,
-                result
-              );
-            }
-          }
-        }
-        if (result !== void 0) this.cache.set(key, result);
-        return result;
-      }
-      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 = originalSegments[0]?.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 = this.opts.env[envKey] ?? (s.prefixLen > 0 ? this.opts.env[s.segments.slice(s.prefixLen).map((seg) => seg.text).join(".")] : void 0);
-        if (envVal !== void 0) {
-          const result = { kind: "scalar", raw: envVal, valueType: "string" };
-          this.cache.set(key, result);
-          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 (!(key0 in this.opts.env)) continue;
-      const items = [];
-      for (let i = 0; ; i++) {
-        const k = base + "_" + i;
-        if (!(k in this.opts.env)) break;
-        items.push({ kind: "scalar", raw: this.opts.env[k], valueType: "string" });
-      }
-      return { kind: "array", items };
-    }
-    return 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 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 (hv?.kind === "array") {
-    return hv.items.some((item) => valContainsPlaceholders(item));
-  }
-  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, v);
-        }
-      }
-    }
-  }
-  return { kind: "object", fields };
-}
-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;
-}
-
-// src/config.ts
-var Config = class _Config {
-  constructor(root, opts) {
-    this.root = root;
-    this._resolved = opts?.resolved ?? true;
-    this._parseBaseDir = opts?.parseBaseDir;
-    this._originDescription = opts?.originDescription;
-    this._resObjRoot = opts?.resObjRoot;
-    this._resolveOpts = opts?.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: opts?.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._resObjRootSubtreeHasPlaceholders(path)) {
-        throw new NotResolvedError(path);
-      }
-      return void 0;
-    }
-    if (v.kind !== "scalar" && !this._resolved && this._resObjRootSubtreeHasPlaceholders(path)) {
-      throw new NotResolvedError(path);
-    }
-    return v;
-  }
-  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;
-  }
-  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);
-  }
-  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);
-  }
-  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 result = parseDuration(v.raw, unit);
-    if (Number.isNaN(result)) throw new ConfigError(`invalid duration at ${path}: ${JSON.stringify(v.raw)}`, path);
-    return result;
-  }
-  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 result = parseBytes(v.raw, unit);
-    if (Number.isNaN(result)) throw new ConfigError(`invalid byte size at ${path}: ${JSON.stringify(v.raw)}`, path);
-    if (result < 0) throw new ConfigError(`byte size must be non-negative at ${path}: ${JSON.stringify(v.raw)}`, path);
-    return result;
-  }
-  getConfig(path) {
-    const v = this.lookupNode(path);
-    if (v === void 0) {
-      if (!this._resolved && this._resObjRootSubtreeHasPlaceholders(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._resObjRootSubtreeHasPlaceholders(path)) {
-      throw new NotResolvedError(path);
-    }
-    return new _Config(v, { resolved: this._resolved });
-  }
-  getList(path) {
-    const v = this.lookupNode(path);
-    if (v === void 0) {
-      if (!this._resolved && this._resObjRootSubtreeHasPlaceholders(path)) {
-        throw new NotResolvedError(path);
-      }
-      throw new ConfigError(`path not found: ${path}`, path);
-    }
-    if (!this._resolved && this._resObjRootSubtreeHasPlaceholders(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));
-  }
-  has(path) {
-    return this.lookupNode(path) !== void 0;
-  }
-  keys() {
-    return [...this.root.fields.keys()];
-  }
-  withFallback(fallback) {
-    if (fallback == null) return this;
-    const selfTree = this._resObjRoot ?? hoconValueToResObj2(this.root);
-    const fbTree = 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: 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 = {
-      ...this._resolveOpts ?? { env: {}, baseDir: void 0, readFileSync: () => {
-        throw new Error("no files");
-      } },
-      allowUnresolved: opts.allowUnresolved ?? false,
-      useSystemEnvironment: 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,
-        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 = this._resObjRoot ?? hoconValueToResObj2(this.root);
-    const srcTree = hoconValueToResObj2(source.root);
-    const merged = mergeUnresolved(receiverTree, srcTree);
-    const resolveOpts = {
-      ...this._resolveOpts ?? { env: {}, baseDir: void 0, readFileSync: () => {
-        throw new Error("no files");
-      } },
-      allowUnresolved: opts.allowUnresolved ?? false,
-      useSystemEnvironment: 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,
-        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, opts?.nullPrototype === true);
-  }
-  /**
-   * @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;
-  }
-  /**
-   * _resObjRootSubtreeHasPlaceholders — walk _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").
-   */
-  _resObjRootSubtreeHasPlaceholders(path) {
-    const tree = 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._resObjRootSubtreeHasPlaceholders(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 {
-      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 = 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");
-}
-
-// src/value-factory.ts
-function fromMap(values, originDescription) {
-  const fields = guardStackDepth(
-    () => coerceObject(values, ""),
-    (msg) => depthError(`fromMap: ${msg}`)
-  );
-  const root = { kind: "object", fields };
-  return Config._fromResolvedValue(root, { originDescription });
-}
-var INT64_MAX = 9223372036854775807n;
-var INT64_MIN = -9223372036854775808n;
-function coerceObject(obj, atPath) {
-  const fields = /* @__PURE__ */ new Map();
-  for (const [k, v] of Object.entries(obj)) {
-    const childPath = atPath ? `${atPath}.${k}` : k;
-    fields.set(k, coerceValue(v, childPath));
-  }
-  return fields;
-}
-function coerceValue(v, atPath) {
-  if (v === null) {
-    return { kind: "scalar", raw: "null", valueType: "null" };
-  }
-  if (v === void 0) {
-    throw new ConfigError(
-      `fromMap: undefined is not a valid HOCON value at path "${atPath}"`,
-      atPath
-    );
-  }
-  switch (typeof v) {
-    case "string":
-      return { kind: "scalar", raw: v, valueType: "string" };
-    case "number": {
-      if (Number.isNaN(v) || !Number.isFinite(v)) {
-        throw new ConfigError(
-          `fromMap: ${v} is not representable in HOCON (NaN/Infinity not allowed) at path "${atPath}"`,
-          atPath
-        );
-      }
-      return { kind: "scalar", raw: Object.is(v, -0) ? "-0" : String(v), valueType: "number" };
-    }
-    case "boolean":
-      return { kind: "scalar", raw: v ? "true" : "false", valueType: "boolean" };
-    case "bigint": {
-      if (v > INT64_MAX || v < INT64_MIN) {
-        throw new ConfigError(
-          `fromMap: integer ${v} is out of int64 range (HOCON integers are int64; spec F0.5) at path "${atPath}"`,
-          atPath
-        );
-      }
-      return { kind: "scalar", raw: String(v), valueType: "number" };
-    }
-    case "object": {
-      if (Array.isArray(v)) {
-        const items = v.map((item, i) => coerceValue(item, `${atPath}[${i}]`));
-        return { kind: "array", items };
-      }
-      const fields = coerceObject(v, atPath);
-      return { kind: "object", fields };
-    }
-    default:
-      throw new ConfigError(
-        `fromMap: unsupported value type "${typeof v}" at path "${atPath}"`,
-        atPath
-      );
-  }
-}
+var _chunkRO4D6BH7cjs = require('../chunk-RO4D6BH7.cjs');
 
 // src/adapters/env.ts
 var SEPARATOR = "__";
 function loadEnv(opts = {}) {
-  const prefix = opts.prefix ?? "";
+  const prefix = _nullishCoalesce(opts.prefix, () => ( ""));
   if (prefix === "") {
-    throw new ConfigError(
+    throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
       "loadEnv: a prefix is required when mounting the environment (spec F1.1)",
       ""
     );
   }
-  const source = opts.env ?? globalThis.process?.env ?? {};
+  const source = _nullishCoalesce(_nullishCoalesce(opts.env, () => ( _optionalChain([globalThis, 'access', _ => _.process, 'optionalAccess', _2 => _2.env]))), () => ( {}));
   const names = Object.keys(source).sort();
   const seen = /* @__PURE__ */ new Map();
   const pairs = [];
@@ -1680,44 +29,44 @@ function loadEnv(opts = {}) {
     const value = source[name];
     if (value === void 0) continue;
     const path = toPath(name.slice(prefix.length));
-    const key = pathKey(path);
+    const key = _chunkRO4D6BH7cjs.pathKey.call(void 0, path);
     const prev = seen.get(key);
     if (prev !== void 0) {
-      throw new ConfigError(`loadEnv: ${prev} and ${name} both map to "${path.join(".")}"`, path.join("."));
+      throw new (0, _chunkRO4D6BH7cjs.ConfigError)(`loadEnv: ${prev} and ${name} both map to "${path.join(".")}"`, path.join("."));
     }
     seen.set(key, name);
     pairs.push([path, value]);
   }
-  return fromMap(nestPairs(pairs), opts.originDescription ?? "environment variables");
+  return _chunkGBNQADHTcjs.fromMap.call(void 0, _chunkRO4D6BH7cjs.nestPairs.call(void 0, pairs), _nullishCoalesce(opts.originDescription, () => ( "environment variables")));
 }
 function parseDotEnv(input, opts = {}) {
-  const origin = opts.originDescription ?? ".env";
-  const prefix = opts.prefix ?? "";
+  const origin = _nullishCoalesce(opts.originDescription, () => ( ".env"));
+  const prefix = _nullishCoalesce(opts.prefix, () => ( ""));
   const pairs = [];
-  const lines = stripBom(input).replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const lines = _chunkRO4D6BH7cjs.stripBom.call(void 0, input).replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
   for (let i = 0; i < lines.length; i++) {
-    const raw = (lines[i] ?? "").trim();
+    const raw = (_nullishCoalesce(lines[i], () => ( ""))).trim();
     if (raw === "" || raw.startsWith("#")) continue;
     const line = stripExport(raw);
     const eq = line.indexOf("=");
-    if (eq === -1) throw new ConfigError(`${origin}:${i + 1}: expected NAME=value`, "");
+    if (eq === -1) throw new (0, _chunkRO4D6BH7cjs.ConfigError)(`${origin}:${i + 1}: expected NAME=value`, "");
     const name = line.slice(0, eq).trim();
-    if (name === "") throw new ConfigError(`${origin}:${i + 1}: empty variable name`, "");
+    if (name === "") throw new (0, _chunkRO4D6BH7cjs.ConfigError)(`${origin}:${i + 1}: empty variable name`, "");
     if (!name.startsWith(prefix)) continue;
     checkName(name, origin, i + 1);
     const value = dotEnvValue(line.slice(eq + 1).replace(/^[ \t]+/, ""), origin, i + 1, name);
     pairs.push([toPath(name.slice(prefix.length)), value]);
   }
-  return fromMap(nestPairs(pairs), origin);
+  return _chunkGBNQADHTcjs.fromMap.call(void 0, _chunkRO4D6BH7cjs.nestPairs.call(void 0, pairs), origin);
 }
 function toPath(name) {
   const segs = name.split(SEPARATOR).map(asciiLower);
   if (segs.some((s) => s === "")) {
-    throw new ConfigError(`env: "${name}" produces an empty path segment`, name);
+    throw new (0, _chunkRO4D6BH7cjs.ConfigError)(`env: "${name}" produces an empty path segment`, name);
   }
-  if (tooDeep(segs.length)) {
-    throw new ConfigError(
-      `env: "${name}" maps to a path ${segs.length} segments deep, over the limit of ${MAX_PATH_SEGMENTS}`,
+  if (_chunkRO4D6BH7cjs.tooDeep.call(void 0, segs.length)) {
+    throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
+      `env: "${name}" maps to a path ${segs.length} segments deep, over the limit of ${_chunkRO4D6BH7cjs.MAX_PATH_SEGMENTS}`,
       name
     );
   }
@@ -1728,7 +77,7 @@ function asciiLower(s) {
 }
 function dotEnvValue(v, origin, line, name) {
   const fail = (msg) => {
-    throw new ConfigError(`${origin}:${line}: ${name}: ${msg}`, name);
+    throw new (0, _chunkRO4D6BH7cjs.ConfigError)(`${origin}:${line}: ${name}: ${msg}`, name);
   };
   if (v.startsWith("'")) {
     const end = v.indexOf("'", 1);
@@ -1774,14 +123,13 @@ function checkName(name, origin, line) {
   const bad = /\p{White_Space}|#/u.exec(name);
   if (bad) {
     const what = bad[0] === "#" ? "'#'" : "whitespace";
-    throw new ConfigError(
+    throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
       `${origin}:${line}: variable name "${name}" contains ${what}; the line is not NAME=value (spec F1.7)`,
       name
     );
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  loadEnv,
-  parseDotEnv
-});
+
+
+
+exports.loadEnv = loadEnv; exports.parseDotEnv = parseDotEnv;