@o3co/ts.hocon 1.10.0 → 1.12.0

package/dist/adapters/yaml.cjs

@@ -551,8 +551,33 @@ function deepMergeHoconValues(base, overlay) {
 // src/internal/resolver/include-loader.ts
 var import_node_module = require("module");
 var nodePath = __toESM(require("path"), 1);
-var import_meta = {};
-var _require = (0, import_node_module.createRequire)(import_meta.url);
+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) {
@@ -1141,10 +1166,10 @@ var Config = class _Config {
     }
     if (v.kind === "object") {
       const converted = numericObjectToArray(v);
-      if (converted !== null) return converted.map(hoconToJs);
+      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(hoconToJs);
+    return v.items.map((item) => hoconToJs(item));
   }
   has(path) {
     return this.lookupNode(path) !== void 0;
@@ -1272,8 +1297,52 @@ var Config = class _Config {
       originDescription: this._originDescription
     });
   }
-  toObject() {
-    return hoconToJs(this.root);
+  /**
+   * The whole config as plain JS data: objects, arrays, strings, numbers,
+   * booleans and `null`.
+   *
+   * Keys are reproduced exactly as the config carries them, `__proto__`,
+   * `constructor` and `prototype` included: each is defined as an **own data
+   * property**, so the returned object's prototype is always
+   * `Object.prototype`, and this call writes nothing to the global one.
+   *
+   * ### Passing the result to other code
+   *
+   * A config file — especially a `.properties` file or an env namespace you
+   * merged in — can therefore hand you an own `__proto__` key, and what happens
+   * next depends entirely on how the consumer copies it:
+   *
+   * ```ts
+   * const data = cfg.toObject()
+   * { ...data }                  // safe — own properties are copied as data
+   * structuredClone(data)        // safe
+   * Object.assign({}, data)      // NOT safe — [[Set]] on the {} target hits
+   *                              // Object.prototype's __proto__ setter: the key
+   *                              // vanishes and config data becomes the result's
+   *                              // prototype
+   * deepMerge({}, data)          // NOT safe — a naive recursive merge reads
+   *                              // target['__proto__'], gets Object.prototype,
+   *                              // and writes to it: global pollution
+   * for (const k in data) …      // prefer Object.entries / Object.keys
+   * ```
+   *
+   * Those two hazards come from the **destination** object's prototype, so no
+   * option here can disarm them — copy with spread or `structuredClone` instead.
+   *
+   * What `{ nullPrototype: true }` does give you is a result that inherits
+   * nothing: every object comes back with a `null` prototype, so reading
+   * `x.__proto__`, `x.constructor` or `x.toString` yields config data or
+   * `undefined` rather than something from `Object.prototype`, and code that
+   * merges *into* this object cannot climb out of it. Keys are all still
+   * present. The trade-off is the usual one for prototype-less objects: not
+   * `instanceof Object`, and no `hasOwnProperty` of their own.
+   *
+   * Numbers follow the JS number model, so an integer wider than 2^53 rounds
+   * here even when the config holds it exactly — read those with
+   * {@link Config.getString} instead.
+   */
+  toObject(opts) {
+    return hoconToJs(this.root, opts?.nullPrototype === true);
   }
   /**
    * @internal Test-only: renders this resolved Config's value tree as canonical
@@ -1385,16 +1454,25 @@ function scalarToJs(raw, valueType) {
       return raw;
   }
 }
-function hoconToJs(v) {
+function hoconToJs(v, nullPrototype = false) {
   switch (v.kind) {
     case "scalar":
       return scalarToJs(v.raw, v.valueType);
     case "array":
-      return v.items.map(hoconToJs);
+      return v.items.map((item) => hoconToJs(item, nullPrototype));
     case "object": {
-      const obj = /* @__PURE__ */ Object.create(null);
-      for (const [k, val] of v.fields) obj[k] = hoconToJs(val);
-      return Object.assign({}, obj);
+      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);
     }
   }
 }
@@ -1479,10 +1557,15 @@ function normalizeLeadingZeroNumber(raw) {
 
 // src/value-factory.ts
 function fromMap(values, originDescription) {
-  const fields = coerceObject(values, "");
+  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)) {
@@ -1511,14 +1594,14 @@ function coerceValue(v, atPath) {
           atPath
         );
       }
-      return { kind: "scalar", raw: String(v), valueType: "number" };
+      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 > BigInt(Number.MAX_SAFE_INTEGER) || v < BigInt(Number.MIN_SAFE_INTEGER)) {
+      if (v > INT64_MAX || v < INT64_MIN) {
         throw new ConfigError(
-          `fromMap: bigint ${v} exceeds Number.MAX_SAFE_INTEGER (not representable as HOCON number) at path "${atPath}"`,
+          `fromMap: integer ${v} is out of int64 range (HOCON integers are int64; spec F0.5) at path "${atPath}"`,
           atPath
         );
       }
@@ -1542,7 +1625,7 @@ function coerceValue(v, atPath) {
 
 // src/adapters/yaml.ts
 function parseYaml(input, originDescription) {
-  const docs = import_yaml.default.parseAllDocuments(input, { version: "1.2", merge: true });
+  const docs = import_yaml.default.parseAllDocuments(stripBom(input), { version: "1.2", merge: true, intAsBigInt: true });
   if (docs.length > 1) {
     throw new ConfigError(
       "yaml: multi-document streams are not supported (spec F5.7); a config is one document",
@@ -1554,11 +1637,14 @@ function parseYaml(input, originDescription) {
   if (doc.errors.length > 0) {
     throw new ConfigError(`yaml: ${doc.errors[0]?.message ?? "parse error"}`, "");
   }
-  return fromYamlValue(doc.toJS({ mapAsMap: false }), originDescription);
+  return fromYamlValue(doc.toJS({ mapAsMap: true }), originDescription);
 }
 function fromYamlValue(value, originDescription) {
   if (value === null || value === void 0) return fromMap({}, originDescription);
-  const normalized = convert(value, "");
+  const normalized = guardStackDepth(
+    () => convert(value, ""),
+    (msg) => depthError(`yaml: ${msg}`)
+  );
   if (typeof normalized !== "object" || normalized === null || Array.isArray(normalized)) {
     throw new ConfigError(
       `yaml: document root is ${Array.isArray(normalized) ? "an array" : typeof normalized}, but a config root must be an object (spec F0.3)`,
@@ -1573,7 +1659,8 @@ function convert(v, atPath) {
     return v.toISOString();
   }
   if (v instanceof Map) {
-    const out = {};
+    const entries = [];
+    const seen = /* @__PURE__ */ new Map();
     for (const [k, e] of v) {
       if (k !== null && typeof k === "object") {
         throw new ConfigError(
@@ -1581,19 +1668,27 @@ function convert(v, atPath) {
           atPath
         );
       }
-      out[String(k)] = convert(e, atPath === "" ? String(k) : `${atPath}.${String(k)}`);
+      const key = String(k);
+      if (seen.has(key)) {
+        throw new ConfigError(
+          `yaml: sibling mapping keys ${keyForm(seen.get(key))} and ${keyForm(k)} both give the key "${key}"${atPath === "" ? "" : ` at "${atPath}"`}; rename one of them, because one of the two values would otherwise be lost. Quoting a non-string key helps only where that changes the key text, as 0x10 does and 1 does not (spec F5.3)`,
+          atPath
+        );
+      }
+      seen.set(key, k);
+      entries.push([key, convert(e, atPath === "" ? key : `${atPath}.${key}`)]);
     }
-    return out;
+    return Object.fromEntries(entries);
   }
   if (v instanceof Uint8Array) {
-    return btoa(String.fromCharCode(...v));
+    return bytesToBase64(v);
   }
   if (v !== null && typeof v === "object") {
-    const out = {};
-    for (const [k, e] of Object.entries(v)) {
-      out[k] = convert(e, atPath === "" ? k : `${atPath}.${k}`);
-    }
-    return out;
+    return Object.fromEntries(
+      Object.entries(v).map(
+        ([k, e]) => [k, convert(e, atPath === "" ? k : `${atPath}.${k}`)]
+      )
+    );
   }
   if (typeof v === "number" && !Number.isFinite(v)) {
     throw new ConfigError(
@@ -1601,8 +1696,28 @@ function convert(v, atPath) {
       atPath
     );
   }
+  if (typeof v === "bigint") {
+    return isSafeIntegerBigInt(v) ? Number(v) : v;
+  }
   return v;
 }
+function bytesToBase64(bytes) {
+  const CHUNK = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+}
+function keyForm(k) {
+  if (typeof k === "string") return JSON.stringify(k);
+  return `${String(k)} (${k === null ? "null" : typeof k})`;
+}
+var MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+var MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
+function isSafeIntegerBigInt(v) {
+  return v <= MAX_SAFE && v >= MIN_SAFE;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   fromYamlValue,

package/dist/adapters/yaml.d.cts

@@ -1,4 +1,4 @@
-import { C as Config } from '../config-PdhVgeLS.cjs';
+import { C as Config } from '../config-Dlq6rF3w.cjs';
 
 /**
  * Read a YAML document as HOCON config.
@@ -23,7 +23,14 @@ import { C as Config } from '../config-PdhVgeLS.cjs';
  * const cfg = fromYamlValue(jsy.load(src), 'their-file.yml')
  * ```
  *
- * See docs/specs/format-ingestion-mapping.md items F5.x in the hocon scope.
+ * Integers are ingested losslessly (F0.5): the document is decoded with
+ * `intAsBigInt`, so a literal too wide for a JS `number` keeps its digits —
+ * `getString` returns them exactly — and one outside int64 is refused rather
+ * than rounded. `getNumber` and `toObject` still apply the JS number model, so
+ * read large identifiers with `getString`.
+ *
+ * See the F5.x items in the format-ingestion mapping spec:
+ * https://github.com/o3co/xx.hocon/blob/main/docs/format-ingestion-mapping.md
  */
 declare function parseYaml(input: string, originDescription?: string): Config;
 /**
@@ -36,7 +43,9 @@ declare function parseYaml(input: string, originDescription?: string): Config;
  * only the default one: a `Map` (eemeli with `mapAsMap`) has its scalar keys
  * stringified per F5.3, a `Date` (js-yaml 4 timestamps) becomes its ISO string
  * — the same reasoning as F4.2 for TOML dates — and a `Uint8Array` becomes
- * base64 (F5.5).
+ * base64 (F5.5), at any size. A `bigint` (a library decoding integers widely)
+ * narrows to a number where a double is exact and otherwise keeps its digits,
+ * bounded by int64 (F0.5).
  */
 declare function fromYamlValue(value: unknown, originDescription?: string): Config;
 

package/dist/adapters/yaml.d.ts

@@ -1,4 +1,4 @@
-import { C as Config } from '../config-PdhVgeLS.js';
+import { C as Config } from '../config-Dlq6rF3w.js';
 
 /**
  * Read a YAML document as HOCON config.
@@ -23,7 +23,14 @@ import { C as Config } from '../config-PdhVgeLS.js';
  * const cfg = fromYamlValue(jsy.load(src), 'their-file.yml')
  * ```
  *
- * See docs/specs/format-ingestion-mapping.md items F5.x in the hocon scope.
+ * Integers are ingested losslessly (F0.5): the document is decoded with
+ * `intAsBigInt`, so a literal too wide for a JS `number` keeps its digits —
+ * `getString` returns them exactly — and one outside int64 is refused rather
+ * than rounded. `getNumber` and `toObject` still apply the JS number model, so
+ * read large identifiers with `getString`.
+ *
+ * See the F5.x items in the format-ingestion mapping spec:
+ * https://github.com/o3co/xx.hocon/blob/main/docs/format-ingestion-mapping.md
  */
 declare function parseYaml(input: string, originDescription?: string): Config;
 /**
@@ -36,7 +43,9 @@ declare function parseYaml(input: string, originDescription?: string): Config;
  * only the default one: a `Map` (eemeli with `mapAsMap`) has its scalar keys
  * stringified per F5.3, a `Date` (js-yaml 4 timestamps) becomes its ISO string
  * — the same reasoning as F4.2 for TOML dates — and a `Uint8Array` becomes
- * base64 (F5.5).
+ * base64 (F5.5), at any size. A `bigint` (a library decoding integers widely)
+ * narrows to a number where a double is exact and otherwise keeps its digits,
+ * bounded by int64 (F0.5).
  */
 declare function fromYamlValue(value: unknown, originDescription?: string): Config;
 

package/dist/adapters/yaml.js

@@ -516,7 +516,33 @@ function deepMergeHoconValues(base, overlay) {
 // src/internal/resolver/include-loader.ts
 import { createRequire } from "module";
 import * as nodePath from "path";
-var _require = createRequire(import.meta.url);
+import { pathToFileURL } from "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) {
@@ -1105,10 +1131,10 @@ var Config = class _Config {
     }
     if (v.kind === "object") {
       const converted = numericObjectToArray(v);
-      if (converted !== null) return converted.map(hoconToJs);
+      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(hoconToJs);
+    return v.items.map((item) => hoconToJs(item));
   }
   has(path) {
     return this.lookupNode(path) !== void 0;
@@ -1236,8 +1262,52 @@ var Config = class _Config {
       originDescription: this._originDescription
     });
   }
-  toObject() {
-    return hoconToJs(this.root);
+  /**
+   * The whole config as plain JS data: objects, arrays, strings, numbers,
+   * booleans and `null`.
+   *
+   * Keys are reproduced exactly as the config carries them, `__proto__`,
+   * `constructor` and `prototype` included: each is defined as an **own data
+   * property**, so the returned object's prototype is always
+   * `Object.prototype`, and this call writes nothing to the global one.
+   *
+   * ### Passing the result to other code
+   *
+   * A config file — especially a `.properties` file or an env namespace you
+   * merged in — can therefore hand you an own `__proto__` key, and what happens
+   * next depends entirely on how the consumer copies it:
+   *
+   * ```ts
+   * const data = cfg.toObject()
+   * { ...data }                  // safe — own properties are copied as data
+   * structuredClone(data)        // safe
+   * Object.assign({}, data)      // NOT safe — [[Set]] on the {} target hits
+   *                              // Object.prototype's __proto__ setter: the key
+   *                              // vanishes and config data becomes the result's
+   *                              // prototype
+   * deepMerge({}, data)          // NOT safe — a naive recursive merge reads
+   *                              // target['__proto__'], gets Object.prototype,
+   *                              // and writes to it: global pollution
+   * for (const k in data) …      // prefer Object.entries / Object.keys
+   * ```
+   *
+   * Those two hazards come from the **destination** object's prototype, so no
+   * option here can disarm them — copy with spread or `structuredClone` instead.
+   *
+   * What `{ nullPrototype: true }` does give you is a result that inherits
+   * nothing: every object comes back with a `null` prototype, so reading
+   * `x.__proto__`, `x.constructor` or `x.toString` yields config data or
+   * `undefined` rather than something from `Object.prototype`, and code that
+   * merges *into* this object cannot climb out of it. Keys are all still
+   * present. The trade-off is the usual one for prototype-less objects: not
+   * `instanceof Object`, and no `hasOwnProperty` of their own.
+   *
+   * Numbers follow the JS number model, so an integer wider than 2^53 rounds
+   * here even when the config holds it exactly — read those with
+   * {@link Config.getString} instead.
+   */
+  toObject(opts) {
+    return hoconToJs(this.root, opts?.nullPrototype === true);
   }
   /**
    * @internal Test-only: renders this resolved Config's value tree as canonical
@@ -1349,16 +1419,25 @@ function scalarToJs(raw, valueType) {
       return raw;
   }
 }
-function hoconToJs(v) {
+function hoconToJs(v, nullPrototype = false) {
   switch (v.kind) {
     case "scalar":
       return scalarToJs(v.raw, v.valueType);
     case "array":
-      return v.items.map(hoconToJs);
+      return v.items.map((item) => hoconToJs(item, nullPrototype));
     case "object": {
-      const obj = /* @__PURE__ */ Object.create(null);
-      for (const [k, val] of v.fields) obj[k] = hoconToJs(val);
-      return Object.assign({}, obj);
+      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);
     }
   }
 }
@@ -1443,10 +1522,15 @@ function normalizeLeadingZeroNumber(raw) {
 
 // src/value-factory.ts
 function fromMap(values, originDescription) {
-  const fields = coerceObject(values, "");
+  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)) {
@@ -1475,14 +1559,14 @@ function coerceValue(v, atPath) {
           atPath
         );
       }
-      return { kind: "scalar", raw: String(v), valueType: "number" };
+      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 > BigInt(Number.MAX_SAFE_INTEGER) || v < BigInt(Number.MIN_SAFE_INTEGER)) {
+      if (v > INT64_MAX || v < INT64_MIN) {
         throw new ConfigError(
-          `fromMap: bigint ${v} exceeds Number.MAX_SAFE_INTEGER (not representable as HOCON number) at path "${atPath}"`,
+          `fromMap: integer ${v} is out of int64 range (HOCON integers are int64; spec F0.5) at path "${atPath}"`,
           atPath
         );
       }
@@ -1506,7 +1590,7 @@ function coerceValue(v, atPath) {
 
 // src/adapters/yaml.ts
 function parseYaml(input, originDescription) {
-  const docs = YAML.parseAllDocuments(input, { version: "1.2", merge: true });
+  const docs = YAML.parseAllDocuments(stripBom(input), { version: "1.2", merge: true, intAsBigInt: true });
   if (docs.length > 1) {
     throw new ConfigError(
       "yaml: multi-document streams are not supported (spec F5.7); a config is one document",
@@ -1518,11 +1602,14 @@ function parseYaml(input, originDescription) {
   if (doc.errors.length > 0) {
     throw new ConfigError(`yaml: ${doc.errors[0]?.message ?? "parse error"}`, "");
   }
-  return fromYamlValue(doc.toJS({ mapAsMap: false }), originDescription);
+  return fromYamlValue(doc.toJS({ mapAsMap: true }), originDescription);
 }
 function fromYamlValue(value, originDescription) {
   if (value === null || value === void 0) return fromMap({}, originDescription);
-  const normalized = convert(value, "");
+  const normalized = guardStackDepth(
+    () => convert(value, ""),
+    (msg) => depthError(`yaml: ${msg}`)
+  );
   if (typeof normalized !== "object" || normalized === null || Array.isArray(normalized)) {
     throw new ConfigError(
       `yaml: document root is ${Array.isArray(normalized) ? "an array" : typeof normalized}, but a config root must be an object (spec F0.3)`,
@@ -1537,7 +1624,8 @@ function convert(v, atPath) {
     return v.toISOString();
   }
   if (v instanceof Map) {
-    const out = {};
+    const entries = [];
+    const seen = /* @__PURE__ */ new Map();
     for (const [k, e] of v) {
       if (k !== null && typeof k === "object") {
         throw new ConfigError(
@@ -1545,19 +1633,27 @@ function convert(v, atPath) {
           atPath
         );
       }
-      out[String(k)] = convert(e, atPath === "" ? String(k) : `${atPath}.${String(k)}`);
+      const key = String(k);
+      if (seen.has(key)) {
+        throw new ConfigError(
+          `yaml: sibling mapping keys ${keyForm(seen.get(key))} and ${keyForm(k)} both give the key "${key}"${atPath === "" ? "" : ` at "${atPath}"`}; rename one of them, because one of the two values would otherwise be lost. Quoting a non-string key helps only where that changes the key text, as 0x10 does and 1 does not (spec F5.3)`,
+          atPath
+        );
+      }
+      seen.set(key, k);
+      entries.push([key, convert(e, atPath === "" ? key : `${atPath}.${key}`)]);
     }
-    return out;
+    return Object.fromEntries(entries);
   }
   if (v instanceof Uint8Array) {
-    return btoa(String.fromCharCode(...v));
+    return bytesToBase64(v);
   }
   if (v !== null && typeof v === "object") {
-    const out = {};
-    for (const [k, e] of Object.entries(v)) {
-      out[k] = convert(e, atPath === "" ? k : `${atPath}.${k}`);
-    }
-    return out;
+    return Object.fromEntries(
+      Object.entries(v).map(
+        ([k, e]) => [k, convert(e, atPath === "" ? k : `${atPath}.${k}`)]
+      )
+    );
   }
   if (typeof v === "number" && !Number.isFinite(v)) {
     throw new ConfigError(
@@ -1565,8 +1661,28 @@ function convert(v, atPath) {
       atPath
     );
   }
+  if (typeof v === "bigint") {
+    return isSafeIntegerBigInt(v) ? Number(v) : v;
+  }
   return v;
 }
+function bytesToBase64(bytes) {
+  const CHUNK = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+}
+function keyForm(k) {
+  if (typeof k === "string") return JSON.stringify(k);
+  return `${String(k)} (${k === null ? "null" : typeof k})`;
+}
+var MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+var MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
+function isSafeIntegerBigInt(v) {
+  return v <= MAX_SAFE && v >= MIN_SAFE;
+}
 export {
   fromYamlValue,
   parseYaml

package/dist/{config-PdhVgeLS.d.cts → config-Dlq6rF3w.d.cts}

@@ -316,7 +316,53 @@ declare class Config {
      * E12 decisions 9, 10.
      */
     resolveWith(source: Config, opts?: ResolveOptions): Config;
-    toObject(): unknown;
+    /**
+     * 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?: {
+        nullPrototype?: boolean;
+    }): unknown;
     /**
      * @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