@o3co/ts.hocon 1.8.0 → 1.10.0

package/dist/adapters/jsonc.js

@@ -0,0 +1,1574 @@
+// 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
+import { createRequire } from "module";
+import * as nodePath from "path";
+var _require = createRequire(import.meta.url);
+
+// 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(hoconToJs);
+    }
+    if (v.kind !== "array") throw new ConfigError(`expected array at ${path}`, path);
+    return v.items.map(hoconToJs);
+  }
+  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
+    });
+  }
+  toObject() {
+    return hoconToJs(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) {
+  switch (v.kind) {
+    case "scalar":
+      return scalarToJs(v.raw, v.valueType);
+    case "array":
+      return v.items.map(hoconToJs);
+    case "object": {
+      const obj = /* @__PURE__ */ Object.create(null);
+      for (const [k, val] of v.fields) obj[k] = hoconToJs(val);
+      return Object.assign({}, obj);
+    }
+  }
+}
+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 = coerceObject(values, "");
+  const root = { kind: "object", fields };
+  return Config._fromResolvedValue(root, { originDescription });
+}
+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: String(v), valueType: "number" };
+    }
+    case "boolean":
+      return { kind: "scalar", raw: v ? "true" : "false", valueType: "boolean" };
+    case "bigint": {
+      if (v > BigInt(Number.MAX_SAFE_INTEGER) || v < BigInt(Number.MIN_SAFE_INTEGER)) {
+        throw new ConfigError(
+          `fromMap: bigint ${v} exceeds Number.MAX_SAFE_INTEGER (not representable as HOCON number) 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
+      );
+  }
+}
+
+// src/adapters/jsonc.ts
+function parseJsonc(input, originDescription) {
+  const doc = JSON.parse(stripTrailingCommas(stripComments(input)));
+  if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+    throw new ConfigError(
+      `jsonc: document root is ${Array.isArray(doc) ? "an array" : typeof doc}, but a config root must be an object (spec F0.3)`,
+      ""
+    );
+  }
+  return fromMap(doc, originDescription);
+}
+function stripComments(src) {
+  let out = "";
+  for (let i = 0; i < src.length; ) {
+    const c = src[i];
+    if (c === '"') {
+      const end = endOfString(src, i);
+      out += src.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "/") {
+      while (i < src.length && src[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "*") {
+      const end = src.indexOf("*/", i + 2);
+      if (end === -1) throw new ConfigError("jsonc: unterminated block comment", "");
+      for (const ch of src.slice(i, end + 2)) if (ch === "\n") out += "\n";
+      i = end + 2;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+function endOfString(src, i) {
+  for (let j = i + 1; j < src.length; j++) {
+    if (src[j] === "\\") j++;
+    else if (src[j] === '"') return j + 1;
+  }
+  throw new ConfigError("jsonc: unterminated string literal", "");
+}
+function stripTrailingCommas(src) {
+  let out = "";
+  for (let i = 0; i < src.length; ) {
+    const c = src[i];
+    if (c === '"') {
+      const end = endOfString(src, i);
+      out += src.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (c === ",") {
+      let j = i + 1;
+      while (j < src.length && /\s/.test(src[j])) j++;
+      if (src[j] === "}" || src[j] === "]") {
+        i++;
+        continue;
+      }
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+export {
+  parseJsonc,
+  stripComments
+};