@o3co/ts.hocon 1.11.0 → 1.13.0

package/dist/adapters/json5.cjs

@@ -0,0 +1,2450 @@
+"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/json5.ts
+var json5_exports = {};
+__export(json5_exports, {
+  parseJson5: () => parseJson5
+});
+module.exports = __toCommonJS(json5_exports);
+
+// 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, "");
+}
+
+// src/value/numeric-array.ts
+function numericObjectToArray(value) {
+  if (value.kind !== "object") return null;
+  if (value.fields.size === 0) return null;
+  const canonicalInt = /^(0|[1-9][0-9]*)$/;
+  const eligible = [];
+  for (const [key, val] of value.fields) {
+    if (!canonicalInt.test(key)) continue;
+    const n = Number(key);
+    if (!Number.isInteger(n) || n > 2147483647) continue;
+    eligible.push({ n, v: val });
+  }
+  if (eligible.length === 0) return null;
+  eligible.sort((a, b) => a.n - b.n);
+  return eligible.map((e) => e.v);
+}
+
+// src/internal/resolver/substitution-resolver.ts
+var SubstitutionResolver = class {
+  constructor(root, opts) {
+    this.root = root;
+    this.opts = opts;
+    this.resolving = /* @__PURE__ */ new Set();
+    this.cache = /* @__PURE__ */ new Map();
+    // Tracks ConcatPlaceholder nodes currently being iterated by resolveConcat.
+    // Used by isSelfRef detection: fires only when found === a concat currently
+    // mid-iteration (i.e. we are inside found's own resolution), preventing the
+    // "foofoo" double-count without misfiring when an external field looks up the
+    // same concat via a substitution (multi-reviewer convergence fix).
+    //
+    // Spec deviation: the S13a.13 spec ★1 decision #1 specified path-equality
+    // preservation for self-ref detection. Round-2 multi-agent-review surfaced a
+    // false-positive on external lookups (`a = ${?a}foo; b = ${a}`), so the
+    // criterion was tightened to node-membership-in-iterating-set — strictly
+    // narrower than path-equality. Spec amendment deferred to a follow-up
+    // xx.hocon PR (see Phase 6 #3f close-out notes).
+    this.resolvingConcats = /* @__PURE__ */ new WeakSet();
+    // Path stack tracking the full dotted path of the field currently being
+    // assigned in `resolveResObj`. Leaf keys are pushed on entry to each
+    // `(key, val)` iteration and popped on exit, so nested objects build up
+    // the full path (e.g. `["o", "history"]` while resolving `o.history`).
+    //
+    // Used to tighten self-ref detection at the L192 found-lookup site:
+    // a substitution `${X}` whose looked-up value contains a Subst pointing
+    // at `X` is only a true self-reference when the field currently being
+    // assigned is `X` (or a descendant of `X`). Without this guard, an
+    // external lookup like `b = ${o}` (where o has a self-referential
+    // field) would mis-fire and short-circuit to o's prior, returning the
+    // wrong value for b. The is_owner gate (rfp prefix-matches s.segments)
+    // narrows the check to the owner case only.
+    //
+    // Cross-impl with rs.hocon v1.5.1's resolving_field_path (same purpose,
+    // same prefix-match semantics).
+    this.resolvingFieldPath = [];
+    // S13a.12 recursion guard: field keys whose prior is currently being
+    // resolved through the prefix-self-ref branch. Saved priors are
+    // prefix-self-ref-free by the fold invariant, so re-entry only happens on
+    // a shape the fold could not see through (a live subst mid-navigation) —
+    // report it as a cycle instead of recursing forever.
+    this.resolvingPrefixPriors = /* @__PURE__ */ new Set();
+  }
+  /** Returns a prefix for error messages, including origin info when set. */
+  originPrefix() {
+    return this.opts.originDescription ? `${this.opts.originDescription}: ` : "";
+  }
+  resolve() {
+    return this.resolveResObj(this.root);
+  }
+  resolveResObj(obj) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, val] of obj.fields) {
+      this.resolvingFieldPath.push(key);
+      const fullCacheKey = stringSegmentsToKey(this.resolvingFieldPath);
+      this.cache.delete(fullCacheKey);
+      try {
+        const resolved = this.resolveVal(val, obj);
+        if (resolved !== void 0) {
+          if (resolved.kind === "object") {
+            const prior = obj.priorValues.get(key);
+            if (prior !== void 0) {
+              const priorResolved = this.resolveVal(prior, obj);
+              if (priorResolved !== void 0 && priorResolved.kind === "object") {
+                const finalValue = deepMergeHoconValues(
+                  priorResolved,
+                  resolved
+                );
+                result.set(key, finalValue);
+                this.cache.set(fullCacheKey, finalValue);
+                this.cacheDescendants(fullCacheKey, finalValue);
+                continue;
+              }
+            }
+          }
+          result.set(key, resolved);
+          this.cache.set(fullCacheKey, resolved);
+          this.cacheDescendants(fullCacheKey, resolved);
+        } else {
+          const prior = obj.priorValues.get(key);
+          if (prior !== void 0) {
+            const priorResolved = this.resolveVal(prior, obj);
+            if (priorResolved !== void 0) {
+              result.set(key, priorResolved);
+              this.cache.set(fullCacheKey, priorResolved);
+              this.cacheDescendants(fullCacheKey, priorResolved);
+            }
+          }
+        }
+      } finally {
+        this.resolvingFieldPath.pop();
+      }
+    }
+    return { kind: "object", fields: result };
+  }
+  /** S13a.12: walk resolved-object fields by segment text. A missing segment
+   * or a walk into a scalar/array is path-absent → undefined. */
+  navigateResolved(v, remainder) {
+    let cur = v;
+    for (const seg of remainder) {
+      if (cur.kind !== "object") return void 0;
+      const next = cur.fields.get(seg);
+      if (next === void 0) return void 0;
+      cur = next;
+    }
+    return cur;
+  }
+  cacheDescendants(prefix, value) {
+    if (value.kind !== "object") return;
+    for (const [key, child] of value.fields) {
+      const childKey = `${prefix}.${stringSegmentsToKey([key])}`;
+      this.cache.set(childKey, child);
+      this.cacheDescendants(childKey, child);
+    }
+  }
+  resolveVal(v, scope) {
+    if (isSubst(v)) return this.resolveSubst(v, scope);
+    if (isConcat(v)) {
+      this.resolvingConcats.add(v);
+      try {
+        const concatResult = this.resolveConcat(v.nodes, scope, v.line, v.col);
+        return concatResult;
+      } finally {
+        this.resolvingConcats.delete(v);
+      }
+    }
+    if (isResObj(v)) return this.resolveResObj(v);
+    const hv = v;
+    if (hv.kind === "array") {
+      const items = [];
+      for (const item of hv.items) {
+        const resolved = this.resolveVal(item, scope);
+        if (resolved === void 0) continue;
+        items.push(resolved);
+      }
+      return { kind: "array", items };
+    }
+    return hv;
+  }
+  resolveSubst(s, scope) {
+    if (s.knownAbsent) {
+      if (!s.optional) {
+        if (this.opts.allowUnresolved) return s;
+        const k = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
+        throw new ResolveError(
+          `${this.originPrefix()}could not resolve substitution: \${${k}}`,
+          k,
+          s.line,
+          s.col
+        );
+      }
+      return void 0;
+    }
+    {
+      const rfp = this.resolvingFieldPath;
+      const sTexts = s.segments.map((seg) => seg.text);
+      if (rfp.length > 0 && rfp.length < sTexts.length && stringSegmentsToKey(sTexts.slice(0, rfp.length)) === stringSegmentsToKey(rfp)) {
+        const guardKey = stringSegmentsToKey(rfp);
+        const prior = scope.priorValues.get(rfp[rfp.length - 1]);
+        if (prior !== void 0 && !this.resolvingPrefixPriors.has(guardKey)) {
+          this.resolvingPrefixPriors.add(guardKey);
+          try {
+            const priorResolved = this.resolveVal(prior, scope);
+            if (priorResolved !== void 0) {
+              const navigated = this.navigateResolved(priorResolved, sTexts.slice(rfp.length));
+              if (navigated !== void 0) return navigated;
+            }
+          } finally {
+            this.resolvingPrefixPriors.delete(guardKey);
+          }
+        }
+        if (s.optional) return void 0;
+        if (this.opts.allowUnresolved) return s;
+        const k = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
+        throw new ResolveError(
+          `${this.originPrefix()}could not resolve substitution: \${${k}}`,
+          k,
+          s.line,
+          s.col
+        );
+      }
+    }
+    const key = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
+    if (this.cache.has(key)) return this.cache.get(key);
+    if (this.resolving.has(key)) {
+      let prior;
+      if (s.segments.length > 1) {
+        const leafSeg = 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
+      );
+  }
+}
+
+// src/adapters/json5.ts
+function parseJson5(input, originDescription) {
+  const p = new Parser(stripBom(input), originDescription);
+  const doc = guardStackDepth(
+    () => p.parseDocument(),
+    (msg) => depthError(`json5: ${describe(originDescription)}: ${msg}`)
+  );
+  if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+    throw new ConfigError(
+      `json5: ${describe(originDescription)}: document root is ${rootKind(doc)}, but a config root must be an object (spec F0.3)`,
+      ""
+    );
+  }
+  return fromMap(doc, originDescription);
+}
+function describe(origin) {
+  return origin === void 0 || origin === "" ? "document" : origin;
+}
+function rootKind(doc) {
+  if (doc === null) return "null";
+  if (Array.isArray(doc)) return "an array";
+  return typeof doc;
+}
+var INT64_MAX2 = 9223372036854775807n;
+var INT64_MIN2 = -9223372036854775808n;
+function isLineTerminator(cp) {
+  return cp === 10 || cp === 13 || cp === 8232 || cp === 8233;
+}
+var ZS_RE = /^\p{Zs}$/u;
+function isJson5Space(cp) {
+  switch (cp) {
+    case 9:
+    case 11:
+    case 12:
+    case 32:
+    case 160:
+    case 65279:
+      return true;
+    default:
+      return ZS_RE.test(String.fromCodePoint(cp));
+  }
+}
+var IDENT_START_RE = /^[\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Lo}\p{Nl}]$/u;
+var IDENT_PART_EXTRA_RE = /^[\p{Mn}\p{Mc}\p{Nd}\p{Pc}]$/u;
+function isIdentStart(cp) {
+  return cp === 36 || cp === 95 || IDENT_START_RE.test(String.fromCodePoint(cp));
+}
+function isIdentPart(cp) {
+  return isIdentStart(cp) || cp === 8204 || cp === 8205 || IDENT_PART_EXTRA_RE.test(String.fromCodePoint(cp));
+}
+function continuesIdentifier(s, i) {
+  if (i >= s.length) return false;
+  return isIdentPart(s.codePointAt(i));
+}
+function isHexDigit(c) {
+  return c >= "0" && c <= "9" || c >= "a" && c <= "f" || c >= "A" && c <= "F";
+}
+var hex4 = (cp) => cp.toString(16).toUpperCase().padStart(4, "0");
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeObjects(dst, src) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [k, v] of Object.entries(dst)) out[k] = v;
+  for (const [k, v] of Object.entries(src)) {
+    const prev = k in out ? out[k] : void 0;
+    if (prev !== void 0 && isPlainObject(prev) && isPlainObject(v)) {
+      out[k] = mergeObjects(prev, v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var Parser = class {
+  // code unit offset where the current line starts
+  constructor(src, origin) {
+    this.src = src;
+    this.origin = origin;
+    this.pos = 0;
+    // UTF-16 code unit offset
+    this.line = 0;
+    // 0-based; reported 1-based
+    this.lineAt = 0;
+  }
+  errf(msg) {
+    const col = [...this.src.slice(this.lineAt, this.pos)].length + 1;
+    return new ConfigError(
+      `json5: ${describe(this.origin)}: line ${this.line + 1} col ${col}: ${msg}`,
+      ""
+    );
+  }
+  /** The code point at `pos` (caller guarantees `pos < src.length`). */
+  rune() {
+    const cp = this.src.codePointAt(this.pos);
+    return { cp, size: cp > 65535 ? 2 : 1 };
+  }
+  advance(cp, size) {
+    this.pos += size;
+    if (isLineTerminator(cp)) {
+      if (cp === 13 && this.src[this.pos] === "\n") this.pos++;
+      this.line++;
+      this.lineAt = this.pos;
+    }
+  }
+  /**
+   * Parse exactly one JSON5 value, allowing only whitespace and comments after
+   * it (the F3.2 strictness rule).
+   */
+  parseDocument() {
+    this.skipSpace();
+    const v = this.parseValue();
+    this.skipSpace();
+    if (this.pos < this.src.length) {
+      throw this.errf("unexpected content after top-level value");
+    }
+    return v;
+  }
+  /** Consume whitespace, line terminators, and both comment forms. */
+  skipSpace() {
+    while (this.pos < this.src.length) {
+      const { cp, size } = this.rune();
+      if (isJson5Space(cp) || isLineTerminator(cp)) {
+        this.advance(cp, size);
+        continue;
+      }
+      if (cp === 47 && this.src[this.pos + 1] === "/") {
+        this.pos += 2;
+        while (this.pos < this.src.length) {
+          const cp2 = this.src.codePointAt(this.pos);
+          if (isLineTerminator(cp2)) break;
+          this.pos += cp2 > 65535 ? 2 : 1;
+        }
+        continue;
+      }
+      if (cp === 47 && this.src[this.pos + 1] === "*") {
+        this.pos += 2;
+        let closed = false;
+        while (this.pos < this.src.length) {
+          const r2 = this.rune();
+          if (r2.cp === 42 && this.src[this.pos + 1] === "/") {
+            this.pos += 2;
+            closed = true;
+            break;
+          }
+          this.advance(r2.cp, r2.size);
+        }
+        if (!closed) throw this.errf("unterminated /* comment");
+        continue;
+      }
+      return;
+    }
+  }
+  parseValue() {
+    if (this.pos >= this.src.length) {
+      throw this.errf("unexpected end of input, expected a value");
+    }
+    const c = this.src[this.pos];
+    if (c === "{") return this.parseObject();
+    if (c === "[") return this.parseArray();
+    if (c === '"' || c === "'") return this.parseString(c);
+    if (c === "+" || c === "-" || c === "." || c >= "0" && c <= "9") return this.parseNumber();
+    return this.parseKeyword();
+  }
+  /**
+   * Handle true/false/null, and reject Infinity/NaN by name so the error
+   * explains itself (spec F0.6).
+   */
+  parseKeyword() {
+    const rest = this.src.slice(this.pos);
+    for (const [kw, v] of [
+      ["true", true],
+      ["false", false],
+      ["null", null]
+    ]) {
+      if (rest.startsWith(kw) && !continuesIdentifier(rest, kw.length)) {
+        this.pos += kw.length;
+        return v;
+      }
+    }
+    for (const kw of ["Infinity", "NaN"]) {
+      if (rest.startsWith(kw) && !continuesIdentifier(rest, kw.length)) {
+        throw this.errf(`${kw} is not representable in the HOCON number model (spec F0.6)`);
+      }
+    }
+    const first = String.fromCodePoint(rest.codePointAt(0));
+    throw this.errf(`unexpected character ${JSON.stringify(first)}`);
+  }
+  // ── Objects and arrays ──────────────────────────────────────────────────────
+  parseObject() {
+    this.pos++;
+    const obj = /* @__PURE__ */ Object.create(null);
+    for (; ; ) {
+      this.skipSpace();
+      if (this.pos >= this.src.length) throw this.errf("unterminated object, expected '}'");
+      if (this.src[this.pos] === "}") {
+        this.pos++;
+        return obj;
+      }
+      const key = this.parseMemberName();
+      this.skipSpace();
+      if (this.pos >= this.src.length || this.src[this.pos] !== ":") {
+        throw this.errf(`expected ':' after object key ${JSON.stringify(key)}`);
+      }
+      this.pos++;
+      this.skipSpace();
+      let val = this.parseValue();
+      if (key in obj) {
+        const prev = obj[key];
+        if (isPlainObject(prev) && isPlainObject(val)) val = mergeObjects(prev, val);
+      }
+      obj[key] = val;
+      this.skipSpace();
+      if (this.pos >= this.src.length) throw this.errf("unterminated object, expected ',' or '}'");
+      const c = this.src[this.pos];
+      if (c === ",") {
+        this.pos++;
+      } else if (c === "}") {
+        this.pos++;
+        return obj;
+      } else {
+        throw this.errf("expected ',' or '}' in object");
+      }
+    }
+  }
+  parseArray() {
+    this.pos++;
+    const arr = [];
+    for (; ; ) {
+      this.skipSpace();
+      if (this.pos >= this.src.length) throw this.errf("unterminated array, expected ']'");
+      if (this.src[this.pos] === "]") {
+        this.pos++;
+        return arr;
+      }
+      arr.push(this.parseValue());
+      this.skipSpace();
+      if (this.pos >= this.src.length) throw this.errf("unterminated array, expected ',' or ']'");
+      const c = this.src[this.pos];
+      if (c === ",") {
+        this.pos++;
+      } else if (c === "]") {
+        this.pos++;
+        return arr;
+      } else {
+        throw this.errf("expected ',' or ']' in array");
+      }
+    }
+  }
+  // ── Member names (quoted or ES5 IdentifierName) ─────────────────────────────
+  parseMemberName() {
+    const c = this.src[this.pos];
+    if (c === '"' || c === "'") return this.parseString(c);
+    return this.parseIdentifier();
+  }
+  /**
+   * Scan an ES5 IdentifierName, honouring `\uXXXX` escapes in the name (the
+   * escaped codepoint must itself be a legal identifier character for its
+   * position, per ES5 — `1` cannot start a key).
+   */
+  parseIdentifier() {
+    let name = "";
+    let first = true;
+    while (this.pos < this.src.length) {
+      const r = this.rune();
+      let cp = r.cp;
+      let escaped = false;
+      if (cp === 92) {
+        if (this.src[this.pos + 1] !== "u") {
+          throw this.errf("only \\uXXXX escapes are allowed in identifiers");
+        }
+        this.pos += 2;
+        cp = this.readHex4();
+        escaped = true;
+      }
+      const legal = first ? isIdentStart(cp) : isIdentPart(cp);
+      if (!legal) {
+        if (escaped) {
+          throw this.errf(`escape \\u${hex4(cp)} is not a valid identifier character here`);
+        }
+        if (first) {
+          throw this.errf(`expected an object key, got ${JSON.stringify(String.fromCodePoint(cp))}`);
+        }
+        break;
+      }
+      name += String.fromCodePoint(cp);
+      if (!escaped) this.pos += r.size;
+      first = false;
+    }
+    if (name.length === 0) throw this.errf("expected an object key");
+    return name;
+  }
+  /** Read exactly four hex digits at `pos` and return the code point. */
+  readHex4() {
+    if (this.pos + 4 > this.src.length) throw this.errf("truncated \\u escape");
+    const quad = this.src.slice(this.pos, this.pos + 4);
+    if (!/^[0-9a-fA-F]{4}$/.test(quad)) {
+      throw this.errf(`invalid \\u escape ${JSON.stringify("\\u" + quad)}`);
+    }
+    this.pos += 4;
+    return parseInt(quad, 16);
+  }
+  // ── Strings ─────────────────────────────────────────────────────────────────
+  /**
+   * Scan a single- or double-quoted JSON5 string. `quote` is the opening quote
+   * character. JSON5 differences from JSON: either quote character, `\xHH`
+   * escapes, `\v`, `\0`, line continuations (backslash before a line
+   * terminator, including CRLF as one), any other non-digit character escaping
+   * to itself, and unescaped LS/PS allowed inside the string.
+   */
+  parseString(quote) {
+    this.pos++;
+    let out = "";
+    for (; ; ) {
+      if (this.pos >= this.src.length) throw this.errf("unterminated string");
+      const { cp, size } = this.rune();
+      if (this.src[this.pos] === quote) {
+        this.pos++;
+        return out;
+      }
+      if (cp === 10 || cp === 13) {
+        throw this.errf("unescaped line terminator in string");
+      }
+      if (cp === 92) {
+        this.pos++;
+        out += this.readEscape();
+        continue;
+      }
+      out += this.src.slice(this.pos, this.pos + size);
+      this.advance(cp, size);
+    }
+  }
+  /**
+   * Consume one escape sequence (the backslash is already consumed) and return
+   * its value.
+   */
+  readEscape() {
+    if (this.pos >= this.src.length) throw this.errf("unterminated escape sequence");
+    const { cp, size } = this.rune();
+    if (isLineTerminator(cp)) {
+      this.advance(cp, size);
+      return "";
+    }
+    const ch = String.fromCodePoint(cp);
+    switch (ch) {
+      case "n":
+        this.pos++;
+        return "\n";
+      case "t":
+        this.pos++;
+        return "	";
+      case "r":
+        this.pos++;
+        return "\r";
+      case "b":
+        this.pos++;
+        return "\b";
+      case "f":
+        this.pos++;
+        return "\f";
+      case "v":
+        this.pos++;
+        return "\v";
+      case "0": {
+        const next = this.src[this.pos + 1];
+        if (next !== void 0 && next >= "0" && next <= "9") {
+          throw this.errf("octal escape sequences are not allowed");
+        }
+        this.pos++;
+        return "\0";
+      }
+      case "1":
+      case "2":
+      case "3":
+      case "4":
+      case "5":
+      case "6":
+      case "7":
+      case "8":
+      case "9":
+        throw this.errf(`escape \\${ch} is not allowed (digits cannot be escaped)`);
+      case "x": {
+        this.pos++;
+        if (this.pos + 2 > this.src.length) throw this.errf("truncated \\x escape");
+        const hh = this.src.slice(this.pos, this.pos + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(hh)) throw this.errf("invalid \\x escape");
+        this.pos += 2;
+        return String.fromCharCode(parseInt(hh, 16));
+      }
+      case "u": {
+        this.pos++;
+        const hi = this.readHex4();
+        if (hi >= 55296 && hi <= 57343) {
+          if (this.pos + 6 <= this.src.length && this.src[this.pos] === "\\" && this.src[this.pos + 1] === "u") {
+            this.pos += 2;
+            const lo = this.readHex4();
+            if (hi <= 56319 && lo >= 56320 && lo <= 57343) {
+              return String.fromCodePoint(65536 + (hi - 55296 << 10) + (lo - 56320));
+            }
+            throw this.errf(`unpaired \\u${hex4(hi)} surrogate (spec F3.5)`);
+          }
+          throw this.errf(`unpaired \\u${hex4(hi)} surrogate (spec F3.5)`);
+        }
+        return String.fromCharCode(hi);
+      }
+      default:
+        this.advance(cp, size);
+        return ch;
+    }
+  }
+  // ── Numbers ─────────────────────────────────────────────────────────────────
+  /**
+   * Scan a JSON5 numeric literal: optional sign, then a hex integer or a
+   * decimal with optional leading/trailing point and exponent. Signed
+   * Infinity/NaN are routed to the F0.6 error here.
+   */
+  parseNumber() {
+    const start = this.pos;
+    let neg = false;
+    const sign = this.src[this.pos];
+    if (sign === "+" || sign === "-") {
+      neg = sign === "-";
+      this.pos++;
+    }
+    const rest = this.src.slice(this.pos);
+    for (const kw of ["Infinity", "NaN"]) {
+      if (rest.startsWith(kw) && !continuesIdentifier(rest, kw.length)) {
+        throw this.errf(`${kw} is not representable in the HOCON number model (spec F0.6)`);
+      }
+    }
+    if (rest.startsWith("0x") || rest.startsWith("0X")) {
+      this.pos += 2;
+      const ds = this.pos;
+      while (this.pos < this.src.length && isHexDigit(this.src[this.pos])) this.pos++;
+      if (this.pos === ds) throw this.errf("hex literal needs at least one digit");
+      const mag = BigInt("0x" + this.src.slice(ds, this.pos));
+      const limit = neg ? 1n << 63n : (1n << 63n) - 1n;
+      if (mag > limit) {
+        throw this.errf(`integer ${this.src.slice(start, this.pos)} does not fit in int64 (spec F0.5)`);
+      }
+      if (neg && mag === 0n) return -0;
+      return integerValue(neg ? -mag : mag);
+    }
+    let sawDigit = false;
+    let sawDot = false;
+    let sawExp = false;
+    while (this.pos < this.src.length) {
+      const c = this.src[this.pos];
+      if (c >= "0" && c <= "9") {
+        sawDigit = true;
+      } else if (c === "." && !sawDot && !sawExp) {
+        sawDot = true;
+      } else if ((c === "e" || c === "E") && sawDigit && !sawExp) {
+        sawExp = true;
+        const n = this.src[this.pos + 1];
+        if (n === "+" || n === "-") this.pos++;
+      } else {
+        break;
+      }
+      this.pos++;
+    }
+    const text = this.src.slice(start, this.pos);
+    if (!sawDigit) throw this.errf(`malformed number ${JSON.stringify(text)}`);
+    if (sawDot || sawExp) {
+      const f = Number(text);
+      if (Number.isNaN(f) || !Number.isFinite(f)) {
+        throw this.errf(`malformed number ${JSON.stringify(text)}`);
+      }
+      return f;
+    }
+    const digits = text.startsWith("+") ? text.slice(1) : text;
+    const i = BigInt(digits);
+    if (i > INT64_MAX2 || i < INT64_MIN2) {
+      throw this.errf(`integer ${text} does not fit in int64 (spec F0.5)`);
+    }
+    if (i >= -9007199254740991n && i <= 9007199254740991n) return Number(digits);
+    return i;
+  }
+};
+function integerValue(v) {
+  if (v >= -9007199254740991n && v <= 9007199254740991n) return Number(v);
+  return v;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseJson5
+});