@o3co/ts.hocon 1.13.0 → 1.14.0

package/dist/adapters/toml.cjs

@@ -1,1974 +1,21 @@
-"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);
-
-// src/adapters/toml.ts
-var toml_exports = {};
-__export(toml_exports, {
-  parseTomlConfig: () => parseTomlConfig
-});
-module.exports = __toCommonJS(toml_exports);
-var import_smol_toml = require("smol-toml");
-
-// 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 = {
-  // 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); they were missing here.
-  ns: 1e-6,
-  nano: 1e-6,
-  nanos: 1e-6,
-  nanosecond: 1e-6,
-  nanoseconds: 1e-6,
-  us: 1e-3,
-  micro: 1e-3,
-  micros: 1e-3,
-  microsecond: 1e-3,
-  microseconds: 1e-3,
-  ms: 1,
-  milli: 1,
-  millis: 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 = {
-  // 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. The old case-insensitive fallback and the
-  // lowercase alias rows accepted spellings Lightbend rejects — removed.
-  B: 1,
-  b: 1,
-  byte: 1,
-  bytes: 1,
-  kB: 1e3,
-  kilobyte: 1e3,
-  kilobytes: 1e3,
-  MB: 1e6,
-  megabyte: 1e6,
-  megabytes: 1e6,
-  GB: 1e9,
-  gigabyte: 1e9,
-  gigabytes: 1e9,
-  TB: 1e12,
-  terabyte: 1e12,
-  terabytes: 1e12,
-  PB: 1e15,
-  petabyte: 1e15,
-  petabytes: 1e15,
-  EB: 1e18,
-  exabyte: 1e18,
-  exabytes: 1e18,
-  ZB: 1e21,
-  zettabyte: 1e21,
-  zettabytes: 1e21,
-  YB: 1e24,
-  yottabyte: 1e24,
-  yottabytes: 1e24,
-  Ki: 1024,
-  KiB: 1024,
-  kibibyte: 1024,
-  kibibytes: 1024,
-  Mi: 1048576,
-  MiB: 1048576,
-  mebibyte: 1048576,
-  mebibytes: 1048576,
-  Gi: 1073741824,
-  GiB: 1073741824,
-  gibibyte: 1073741824,
-  gibibytes: 1073741824,
-  Ti: 1099511627776,
-  TiB: 1099511627776,
-  tebibyte: 1099511627776,
-  tebibytes: 1099511627776,
-  Pi: 1024 ** 5,
-  PiB: 1024 ** 5,
-  pebibyte: 1024 ** 5,
-  pebibytes: 1024 ** 5,
-  Ei: 1024 ** 6,
-  EiB: 1024 ** 6,
-  exbibyte: 1024 ** 6,
-  exbibytes: 1024 ** 6,
-  Zi: 1024 ** 7,
-  ZiB: 1024 ** 7,
-  zebibyte: 1024 ** 7,
-  zebibytes: 1024 ** 7,
-  Yi: 1024 ** 8,
-  YiB: 1024 ** 8,
-  yobibyte: 1024 ** 8,
-  yobibytes: 1024 ** 8,
-  // S21.4 — single-letter abbreviations → powers of two (java -Xmx
-  // convention); Lightbend accepts BOTH cases here, through the full ladder.
-  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,
-  Z: 1024 ** 7,
-  z: 1024 ** 7,
-  Y: 1024 ** 8,
-  y: 1024 ** 8
-};
-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;
-  }
-  const mult = BYTE_UNITS[unit];
-  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 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 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 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
-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, "");
-}
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// 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);
-}
+var _chunkGBNQADHTcjs = require('../chunk-GBNQADHT.cjs');
 
-// 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 = 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/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 = 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);
-  }
-  /**
-   * 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;
-  }
-  /**
-   * _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/toml.ts
+var _smoltoml = require('smol-toml');
 function parseTomlConfig(input, originDescription) {
-  const doc = (0, import_smol_toml.parse)(stripBom(input));
-  return fromMap(
-    guardStackDepth(
+  const doc = _smoltoml.parse.call(void 0, _chunkRO4D6BH7cjs.stripBom.call(void 0, input));
+  return _chunkGBNQADHTcjs.fromMap.call(void 0, 
+    _chunkRO4D6BH7cjs.guardStackDepth.call(void 0, 
       () => convert(doc, ""),
-      (msg) => depthError(`toml: ${msg}`)
+      (msg) => _chunkRO4D6BH7cjs.depthError.call(void 0, `toml: ${msg}`)
     ),
     originDescription
   );
@@ -1986,14 +33,13 @@ function convert(v, atPath) {
     );
   }
   if (typeof v === "number" && !Number.isFinite(v)) {
-    throw new ConfigError(
+    throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
       `toml: ${v} at "${atPath}" is not representable in HOCON (spec F0.6)`,
       atPath
     );
   }
   return v;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  parseTomlConfig
-});
+
+
+exports.parseTomlConfig = parseTomlConfig;