@o3co/ts.hocon 1.9.0 → 1.11.0

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

@@ -1,6 +1,3 @@
-type DurationUnit = 'ns' | 'us' | 'ms' | 's' | 'm' | 'h' | 'd';
-type ByteUnit = 'B' | 'KB' | 'KiB' | 'MB' | 'MiB' | 'GB' | 'GiB' | 'TB' | 'TiB';
-
 type ScalarValueType = 'string' | 'number' | 'boolean' | 'null';
 type HoconValue = {
     kind: 'object';
@@ -226,6 +223,9 @@ declare function parseAsync(input: string, opts?: ParseOptions): Promise<Config>
 declare function parseFile(filePath: string, opts?: ParseOptions): Config;
 declare function parseFileAsync(filePath: string, opts?: ParseOptions): Promise<Config>;
 
+type DurationUnit = 'ns' | 'us' | 'ms' | 's' | 'm' | 'h' | 'd';
+type ByteUnit = 'B' | 'KB' | 'KiB' | 'MB' | 'MiB' | 'GB' | 'GiB' | 'TB' | 'TiB';
+
 declare class Config {
     private readonly root;
     /** @internal resolved flag: true when no substitution placeholders remain. */
@@ -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

package/dist/{config-D27s3_aG.d.ts → config-Dlq6rF3w.d.ts}

@@ -1,6 +1,3 @@
-type DurationUnit = 'ns' | 'us' | 'ms' | 's' | 'm' | 'h' | 'd';
-type ByteUnit = 'B' | 'KB' | 'KiB' | 'MB' | 'MiB' | 'GB' | 'GiB' | 'TB' | 'TiB';
-
 type ScalarValueType = 'string' | 'number' | 'boolean' | 'null';
 type HoconValue = {
     kind: 'object';
@@ -226,6 +223,9 @@ declare function parseAsync(input: string, opts?: ParseOptions): Promise<Config>
 declare function parseFile(filePath: string, opts?: ParseOptions): Config;
 declare function parseFileAsync(filePath: string, opts?: ParseOptions): Promise<Config>;
 
+type DurationUnit = 'ns' | 'us' | 'ms' | 's' | 'm' | 'h' | 'd';
+type ByteUnit = 'B' | 'KB' | 'KiB' | 'MB' | 'MiB' | 'GB' | 'GiB' | 'TB' | 'TiB';
+
 declare class Config {
     private readonly root;
     /** @internal resolved flag: true when no substitution placeholders remain. */
@@ -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

package/dist/index.cjs

@@ -700,6 +700,7 @@ function isFileNotFoundError(e) {
 // 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/lexer/lexer.ts
 function isHoconWhitespace(ch) {
@@ -1101,12 +1102,12 @@ function isDecimalDigit(ch) {
 }
 function isUnquotedStart(ch) {
   if (ch === "" || isHoconWhitespace(ch)) return false;
-  if ('{}[],:=+#"$?!@*&^\\'.includes(ch)) return false;
+  if ('{}[],:=+#"$?!@*&^`\\'.includes(ch)) return false;
   return true;
 }
 function isUnquotedContinue(ch, nextFn) {
   if (ch === "" || isHoconWhitespace(ch)) return false;
-  if ('{}[],:=#"$?!@*&^\\'.includes(ch)) return false;
+  if ('{}[],:=#"$?!@*&^`\\'.includes(ch)) return false;
   if (ch === "+" && nextFn() === "=") return false;
   if (ch === "/" && nextFn() === "/") return false;
   return true;
@@ -1255,6 +1256,17 @@ var Parser = class {
         this.advance();
         const raw = t.value.startsWith(".") && segments.length > 0 && !t.precedingSpace ? t.value.slice(1) : t.value;
         const parts = raw.split(".");
+        const leadingDotIsSeparator = spaceConcat || postDotPrefix !== "";
+        for (let i = 0; i < parts.length; i++) {
+          if (parts[i] !== "") continue;
+          if (i === parts.length - 1) continue;
+          if (i === 0 && leadingDotIsSeparator) continue;
+          throw new ParseError(
+            `path has ${i === 0 ? "a leading period '.'" : "two adjacent periods '.'"} \u2014 empty key segment not allowed, use quoted "" (HOCON.md path rules)`,
+            t.line,
+            t.col
+          );
+        }
         const filtered = parts.filter((s) => s.length > 0);
         if (spaceConcat) {
           segments[segments.length - 1] = `${segments[segments.length - 1]}${t.precedingWhitespace}`;
@@ -1531,45 +1543,135 @@ function parseTokens(tokens) {
   return new Parser(tokens).parse();
 }
 
+// src/internal/strip-bom.ts
+function stripBom(input) {
+  return input.charCodeAt(0) === 65279 ? input.slice(1) : input;
+}
+
 // src/internal/properties/properties.ts
 function parseProperties(input) {
-  const root = /* @__PURE__ */ Object.create(null);
   const pairs = [];
-  for (const line of input.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed === "" || trimmed.startsWith("#") || trimmed.startsWith("!")) continue;
-    const sepIdx = findSeparator(trimmed);
-    if (sepIdx === -1) continue;
-    const key = trimmed.slice(0, sepIdx).trim();
-    const value = trimmed.slice(sepIdx + 1).trim();
+  for (const { text, line } of logicalLines(stripBom(input))) {
+    const [rawKey, rawValue] = splitKeyValue(text);
+    const key = unescapeProps(rawKey, line);
     if (key === "") continue;
-    pairs.push([key, value]);
+    pairs.push([key.split("."), unescapeProps(rawValue, line)]);
   }
-  pairs.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-  for (const [key, value] of pairs) {
-    setNested(root, key.split("."), value);
+  return nestPairs(pairs);
+}
+function nestPairs(pairs) {
+  const root = /* @__PURE__ */ Object.create(null);
+  const sorted = [...pairs].sort(([a], [b]) => compareSegments(a, b));
+  for (const [segments, value] of sorted) {
+    setNested(root, segments, value);
   }
   return root;
 }
-function findSeparator(line) {
-  for (let i = 0; i < line.length; i++) {
-    if (line[i] === "=" || line[i] === ":") return i;
+function compareSegments(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  return a.length - b.length;
+}
+function logicalLines(input) {
+  const natural = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const out = [];
+  for (let i = 0; i < natural.length; i++) {
+    let text = trimLeadingSpace(natural[i] ?? "");
+    if (text === "" || text.startsWith("#") || text.startsWith("!")) continue;
+    const start = i + 1;
+    while (endsWithContinuation(text)) {
+      text = text.slice(0, -1);
+      if (i + 1 >= natural.length) break;
+      i++;
+      text += trimLeadingSpace(natural[i] ?? "");
+    }
+    out.push({ text, line: start });
+  }
+  return out;
+}
+function trimLeadingSpace(s) {
+  return s.replace(/^[ \t\f]+/, "");
+}
+function endsWithContinuation(line) {
+  let n = 0;
+  for (let i = line.length - 1; i >= 0 && line[i] === "\\"; i--) n++;
+  return n % 2 === 1;
+}
+function splitKeyValue(line) {
+  let key = "";
+  let i = 0;
+  for (; i < line.length; i++) {
+    const c = line[i];
+    if (c === "\\" && i + 1 < line.length) {
+      key += c + line[i + 1];
+      i++;
+      continue;
+    }
+    if (c === "=" || c === ":" || isPropsSpace(c)) break;
+    key += c;
+  }
+  while (i < line.length && isPropsSpace(line[i])) i++;
+  if (i < line.length && (line[i] === "=" || line[i] === ":")) {
+    i++;
+    while (i < line.length && isPropsSpace(line[i])) i++;
+  }
+  return [key, line.slice(i)];
+}
+function isPropsSpace(c) {
+  return c === " " || c === "	" || c === "\f";
+}
+function unescapeProps(s, line) {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] !== "\\") {
+      out += s[i];
+      continue;
+    }
+    i++;
+    if (i >= s.length) break;
+    const e = s[i];
+    switch (e) {
+      case "t":
+        out += "	";
+        break;
+      case "n":
+        out += "\n";
+        break;
+      case "r":
+        out += "\r";
+        break;
+      case "f":
+        out += "\f";
+        break;
+      case "u": {
+        const hex = s.slice(i + 1, i + 5);
+        if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+          throw new ParseError(`malformed \\u escape in .properties: \\u${hex}`, line, i + 1);
+        }
+        out += String.fromCharCode(parseInt(hex, 16));
+        i += 4;
+        break;
+      }
+      default:
+        out += e;
+    }
   }
-  return -1;
+  return out;
 }
-var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function setNested(obj, segments, value) {
   let current = obj;
   for (let i = 0; i < segments.length - 1; i++) {
     const seg = segments[i];
-    if (seg === void 0 || DANGEROUS_KEYS.has(seg)) return;
     if (!(seg in current) || typeof current[seg] !== "object" || current[seg] === null) {
       current[seg] = /* @__PURE__ */ Object.create(null);
     }
     current = current[seg];
   }
   const last = segments[segments.length - 1];
-  if (last === void 0 || DANGEROUS_KEYS.has(last)) return;
   if (typeof current[last] === "object" && current[last] !== null) return;
   current[last] = value;
 }
@@ -1591,7 +1693,22 @@ function recordToHoconValue(obj) {
 
 // src/internal/resolver/include-loader.ts
 var import_meta = {};
-var _require = (0, import_node_module.createRequire)(import_meta.url);
+var _require;
+function getRequire() {
+  if (_require === void 0) {
+    _require = pickRequire(
+      typeof require === "function" ? require : void 0,
+      import_meta.url
+    );
+  }
+  return _require;
+}
+function pickRequire(candidate, metaUrl) {
+  if (typeof candidate?.resolve === "function") {
+    return candidate;
+  }
+  return (0, import_node_module.createRequire)(metaUrl ?? (0, import_node_url.pathToFileURL)(nodePath.join(process.cwd(), "noop.js")));
+}
 function isPnpPath(p) {
   return p.includes(".yarn/cache") || p.includes(".pnp.cjs") || p.includes(".pnp.loader");
 }
@@ -1647,7 +1764,7 @@ function defaultPackageResolver(identifier, file, includingFile, baseDir, resolv
   const from = resolveFrom ? Array.isArray(resolveFrom) ? resolveFrom : [resolveFrom] : baseDir ? [baseDir] : includingFile ? [nodePath.dirname(includingFile)] : [process.cwd()];
   let resolved;
   try {
-    resolved = _require.resolve(`${identifier}/${file}`, { paths: from });
+    resolved = getRequire().resolve(`${identifier}/${file}`, { paths: from });
   } catch {
     throw new PackageLookupError(
       `include package("${identifier}", "${file}"): module not found (starting from: ${from.join(", ")})`,
@@ -2701,10 +2818,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 ${path2}`, path2);
-    return v.items.map(hoconToJs);
+    return v.items.map((item) => hoconToJs(item));
   }
   has(path2) {
     return this.lookupNode(path2) !== void 0;
@@ -2832,8 +2949,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
@@ -2945,16 +3106,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);
     }
   }
 }
@@ -3188,6 +3358,8 @@ function empty(originDescription) {
   const root = { kind: "object", fields: /* @__PURE__ */ new Map() };
   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)) {
@@ -3216,14 +3388,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
         );
       }

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { C as Config } from './config-D27s3_aG.cjs';
-export { B as ByteUnit, D as DurationUnit, H as HoconValue, P as PackageResolver, a as ParseOptions, R as ReadonlyHoconValue, b as ResolveOptions, S as ScalarValueType, c as asArray, d as asBoolean, e as asNumber, f as asObject, g as asString, h as defaultParseOptions, i as defaultResolveOptions, j as isArray, k as isNull, l as isObject, m as isScalar, p as parse, n as parseAsync, o as parseFile, q as parseFileAsync, r as parseFileWithOptions, s as parseString, t as parseStringWithOptions } from './config-D27s3_aG.cjs';
+import { C as Config } from './config-Dlq6rF3w.cjs';
+export { B as ByteUnit, D as DurationUnit, H as HoconValue, P as PackageResolver, a as ParseOptions, R as ReadonlyHoconValue, b as ResolveOptions, S as ScalarValueType, c as asArray, d as asBoolean, e as asNumber, f as asObject, g as asString, h as defaultParseOptions, i as defaultResolveOptions, j as isArray, k as isNull, l as isObject, m as isScalar, p as parse, n as parseAsync, o as parseFile, q as parseFileAsync, r as parseFileWithOptions, s as parseString, t as parseStringWithOptions } from './config-Dlq6rF3w.cjs';
 
 declare class ParseError extends Error {
     readonly line: number;
@@ -48,7 +48,14 @@ declare class NotResolvedError extends ConfigError {
  *   null            → scalar/null
  *   Array<unknown>  → array (elements recursively coerced)
  *   Record<string,unknown> → object (values recursively coerced)
- *   undefined / function / symbol / bigint (> MAX_SAFE_INTEGER) → ConfigError
+ *   bigint          → scalar/number, digits kept verbatim (out of int64 = error)
+ *   undefined / function / symbol → ConfigError
+ *
+ * A `bigint` is how a caller (or a format adapter) hands over an integer that a
+ * JS `number` cannot hold exactly: its digits are kept verbatim in the value's
+ * raw text, so `getString` returns them intact, while `getNumber` / `toObject`
+ * apply the JS number model as they do for any other value. Integers outside
+ * the int64 range are rejected (spec F0.5).
  *
  * originDescription (optional) provides a source name for error messages.
  * E12 decision 13.

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as Config } from './config-D27s3_aG.js';
-export { B as ByteUnit, D as DurationUnit, H as HoconValue, P as PackageResolver, a as ParseOptions, R as ReadonlyHoconValue, b as ResolveOptions, S as ScalarValueType, c as asArray, d as asBoolean, e as asNumber, f as asObject, g as asString, h as defaultParseOptions, i as defaultResolveOptions, j as isArray, k as isNull, l as isObject, m as isScalar, p as parse, n as parseAsync, o as parseFile, q as parseFileAsync, r as parseFileWithOptions, s as parseString, t as parseStringWithOptions } from './config-D27s3_aG.js';
+import { C as Config } from './config-Dlq6rF3w.js';
+export { B as ByteUnit, D as DurationUnit, H as HoconValue, P as PackageResolver, a as ParseOptions, R as ReadonlyHoconValue, b as ResolveOptions, S as ScalarValueType, c as asArray, d as asBoolean, e as asNumber, f as asObject, g as asString, h as defaultParseOptions, i as defaultResolveOptions, j as isArray, k as isNull, l as isObject, m as isScalar, p as parse, n as parseAsync, o as parseFile, q as parseFileAsync, r as parseFileWithOptions, s as parseString, t as parseStringWithOptions } from './config-Dlq6rF3w.js';
 
 declare class ParseError extends Error {
     readonly line: number;
@@ -48,7 +48,14 @@ declare class NotResolvedError extends ConfigError {
  *   null            → scalar/null
  *   Array<unknown>  → array (elements recursively coerced)
  *   Record<string,unknown> → object (values recursively coerced)
- *   undefined / function / symbol / bigint (> MAX_SAFE_INTEGER) → ConfigError
+ *   bigint          → scalar/number, digits kept verbatim (out of int64 = error)
+ *   undefined / function / symbol → ConfigError
+ *
+ * A `bigint` is how a caller (or a format adapter) hands over an integer that a
+ * JS `number` cannot hold exactly: its digits are kept verbatim in the value's
+ * raw text, so `getString` returns them intact, while `getNumber` / `toObject`
+ * apply the JS number model as they do for any other value. Integers outside
+ * the int64 range are rejected (spec F0.5).
  *
  * originDescription (optional) provides a source name for error messages.
  * E12 decision 13.