@o3co/ts.hocon 0.1.5 → 1.0.0

package/dist/{parse-C1NDMzD5.d.cts → parse-C4VOYuEk.d.cts}

@@ -1,3 +1,6 @@
+type DurationUnit = 'ns' | 'us' | 'ms' | 's' | 'm' | 'h' | 'd';
+type ByteUnit = 'B' | 'KB' | 'KiB' | 'MB' | 'MiB' | 'GB' | 'GiB' | 'TB' | 'TiB';
+
 type HoconValue = {
     kind: 'object';
     fields: Map<string, HoconValue>;
@@ -18,6 +21,8 @@ declare class Config {
     getString(path: string): string;
     getNumber(path: string): number;
     getBoolean(path: string): boolean;
+    getDuration(path: string, unit?: DurationUnit): number;
+    getBytes(path: string, unit?: ByteUnit): number;
     getConfig(path: string): Config;
     getList(path: string): unknown[];
     has(path: string): boolean;
@@ -36,13 +41,11 @@ type ParseOptions = {
 };
 declare function parse(input: string, opts?: ParseOptions): Config;
 /**
- * Async wrapper around `parse()`. Returns a resolved Promise — the parsing
- * itself is synchronous. Use `parseFileAsync()` for async file I/O.
- * Note: `include` directives in string input are resolved synchronously
- * via `readFileSync`; `readFile` is not used by this function.
+ * Truly async version of `parse()`. Include directives are resolved
+ * asynchronously via `readFile` when provided.
  */
 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>;
 
-export { Config as C, type HoconValue as H, type ParseOptions as P, parseAsync as a, parseFile as b, parseFileAsync as c, parse as p };
+export { type ByteUnit as B, Config as C, type DurationUnit as D, type HoconValue as H, type ParseOptions as P, parseAsync as a, parseFile as b, parseFileAsync as c, parse as p };

package/dist/{parse-C1NDMzD5.d.ts → parse-C4VOYuEk.d.ts}

@@ -1,3 +1,6 @@
+type DurationUnit = 'ns' | 'us' | 'ms' | 's' | 'm' | 'h' | 'd';
+type ByteUnit = 'B' | 'KB' | 'KiB' | 'MB' | 'MiB' | 'GB' | 'GiB' | 'TB' | 'TiB';
+
 type HoconValue = {
     kind: 'object';
     fields: Map<string, HoconValue>;
@@ -18,6 +21,8 @@ declare class Config {
     getString(path: string): string;
     getNumber(path: string): number;
     getBoolean(path: string): boolean;
+    getDuration(path: string, unit?: DurationUnit): number;
+    getBytes(path: string, unit?: ByteUnit): number;
     getConfig(path: string): Config;
     getList(path: string): unknown[];
     has(path: string): boolean;
@@ -36,13 +41,11 @@ type ParseOptions = {
 };
 declare function parse(input: string, opts?: ParseOptions): Config;
 /**
- * Async wrapper around `parse()`. Returns a resolved Promise — the parsing
- * itself is synchronous. Use `parseFileAsync()` for async file I/O.
- * Note: `include` directives in string input are resolved synchronously
- * via `readFileSync`; `readFile` is not used by this function.
+ * Truly async version of `parse()`. Include directives are resolved
+ * asynchronously via `readFile` when provided.
  */
 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>;
 
-export { Config as C, type HoconValue as H, type ParseOptions as P, parseAsync as a, parseFile as b, parseFileAsync as c, parse as p };
+export { type ByteUnit as B, Config as C, type DurationUnit as D, type HoconValue as H, type ParseOptions as P, parseAsync as a, parseFile as b, parseFileAsync as c, parse as p };

package/dist/zod.cjs

@@ -50,6 +50,130 @@ function coerceNumber(value) {
   if (!/^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)) return void 0;
   return Number(value);
 }
+var DURATION_UNITS = {
+  ns: 1e-6,
+  nanosecond: 1e-6,
+  nanoseconds: 1e-6,
+  us: 1e-3,
+  microsecond: 1e-3,
+  microseconds: 1e-3,
+  ms: 1,
+  millisecond: 1,
+  milliseconds: 1,
+  s: 1e3,
+  second: 1e3,
+  seconds: 1e3,
+  m: 6e4,
+  minute: 6e4,
+  minutes: 6e4,
+  h: 36e5,
+  hour: 36e5,
+  hours: 36e5,
+  d: 864e5,
+  day: 864e5,
+  days: 864e5
+};
+var OUTPUT_DURATION_UNITS = {
+  ns: 1e-6,
+  us: 1e-3,
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function parseDuration(value, outputUnit = "ms") {
+  const trimmed = value.trim();
+  let i = 0;
+  while (i < trimmed.length) {
+    const ch = trimmed[i];
+    if (ch !== "-" && 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 = trimmed.slice(i).trim().toLowerCase();
+  const mult = DURATION_UNITS[unit];
+  if (mult === void 0) return NaN;
+  const ms = num * mult;
+  const divisor = OUTPUT_DURATION_UNITS[outputUnit];
+  if (divisor === void 0) return NaN;
+  return ms / divisor;
+}
+var BYTE_UNITS = {
+  B: 1,
+  byte: 1,
+  bytes: 1,
+  KB: 1e3,
+  kilobyte: 1e3,
+  kilobytes: 1e3,
+  KiB: 1024,
+  kibibyte: 1024,
+  kibibytes: 1024,
+  MB: 1e6,
+  megabyte: 1e6,
+  megabytes: 1e6,
+  MiB: 1048576,
+  mebibyte: 1048576,
+  mebibytes: 1048576,
+  GB: 1e9,
+  gigabyte: 1e9,
+  gigabytes: 1e9,
+  GiB: 1073741824,
+  gibibyte: 1073741824,
+  gibibytes: 1073741824,
+  TB: 1e12,
+  terabyte: 1e12,
+  terabytes: 1e12,
+  TiB: 1099511627776,
+  tebibyte: 1099511627776,
+  tebibytes: 1099511627776,
+  // lowercase short-form aliases
+  b: 1,
+  kb: 1e3,
+  kib: 1024,
+  mb: 1e6,
+  mib: 1048576,
+  gb: 1e9,
+  gib: 1073741824,
+  tb: 1e12,
+  tib: 1099511627776
+};
+var OUTPUT_BYTE_UNITS = {
+  B: 1,
+  KB: 1e3,
+  KiB: 1024,
+  MB: 1e6,
+  MiB: 1048576,
+  GB: 1e9,
+  GiB: 1073741824,
+  TB: 1e12,
+  TiB: 1099511627776
+};
+function parseBytes(value, outputUnit = "B") {
+  const trimmed = value.trim();
+  let i = 0;
+  while (i < trimmed.length) {
+    const ch = trimmed[i];
+    if (ch !== "-" && 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 = trimmed.slice(i).trim();
+  let mult = BYTE_UNITS[unit];
+  if (mult === void 0) {
+    mult = BYTE_UNITS[unit.toLowerCase()];
+  }
+  if (mult === void 0) return NaN;
+  const bytes = num * mult;
+  const divisor = OUTPUT_BYTE_UNITS[outputUnit];
+  if (divisor === void 0) return NaN;
+  const result = bytes / divisor;
+  return outputUnit === "B" ? Math.round(result) : result;
+}
 
 // src/errors.ts
 var ParseError = class extends Error {
@@ -166,6 +290,7 @@ function tokenize(input) {
       advance();
       advance();
       let value = "";
+      let closed = false;
       while (pos < input.length) {
         if (peek() === '"') {
           let quoteCount = 0;
@@ -175,6 +300,7 @@ function tokenize(input) {
           }
           if (quoteCount >= 3) {
             for (let i = 0; i < quoteCount - 3; i++) value += '"';
+            closed = true;
             break;
           }
           for (let i = 0; i < quoteCount; i++) value += '"';
@@ -182,6 +308,9 @@ function tokenize(input) {
         }
         value += advance();
       }
+      if (!closed) {
+        throw new ParseError("unterminated triple-quoted string", sl, sc);
+      }
       if (value.startsWith("\n")) value = value.slice(1);
       push("triple_string", value, sl, sc, true);
       continue;
@@ -220,13 +349,19 @@ function tokenize(input) {
               value += "\f";
               break;
             case "u": {
+              if (pos + 4 > input.length) {
+                throw new ParseError("Invalid unicode escape: not enough characters", line, col);
+              }
               const hex = input.slice(pos, pos + 4);
+              if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+                throw new ParseError(`Invalid unicode escape: \\u${hex}`, line, col);
+              }
               value += String.fromCharCode(parseInt(hex, 16));
               for (let i = 0; i < 4; i++) advance();
               break;
             }
             default:
-              value += esc;
+              throw new ParseError(`Unknown escape sequence: \\${esc}`, line, col);
           }
         } else {
           value += advance();
@@ -251,10 +386,10 @@ function tokenize(input) {
   return tokens;
 }
 function isUnquotedStart(ch) {
-  return ch !== "" && !'{}[],:=+#\n\r	 "$'.includes(ch);
+  return ch !== "" && !'{}[],:=+#\n\r	 "$?!@*&^\\'.includes(ch);
 }
 function isUnquotedContinue(ch, nextFn) {
-  if (ch === "" || '{}[],:=\n\r	 #"$'.includes(ch) || ch === " ") return false;
+  if (ch === "" || '{}[],:=\n\r	 #"$?!@*&^\\'.includes(ch) || ch === " ") return false;
   if (ch === "+" && nextFn() === "=") return false;
   if (ch === "/" && nextFn() === "/") return false;
   return true;
@@ -356,20 +491,46 @@ function parseTokens(tokens) {
     skip("newline");
     const t2 = peek();
     let path2;
-    if (t2.kind === "string") {
+    let required = false;
+    if (t2.kind === "unquoted" && (t2.value === "required(" || t2.value === "required" || t2.value.startsWith("required("))) {
+      if (t2.value === "required") {
+        const next2 = tokens[pos + 1] ?? { kind: "eof", value: "" };
+        if (next2.kind !== "unquoted" || !next2.value.startsWith("(")) {
+          throw new ParseError("include required must be followed by (", t2.line, t2.col);
+        }
+      }
+      required = true;
+      advance();
+      const innerPrefix = t2.value.startsWith("required(") ? t2.value.slice("required(".length) : "";
+      if (innerPrefix.startsWith("url") || innerPrefix.startsWith("classpath")) {
+        throw new ParseError("include url(...) and classpath(...) are not supported", t2.line, t2.col);
+      }
+      const next = peek();
+      if (next.kind === "unquoted" && (next.value === "url" || next.value.startsWith("url(") || next.value === "classpath" || next.value.startsWith("classpath("))) {
+        throw new ParseError("include url(...) and classpath(...) are not supported", next.line, next.col);
+      }
+      while (peek().kind !== "string" && peek().kind !== "eof") advance();
+      if (peek().kind === "eof") throw new ParseError("expected include path", t2.line, t2.col);
+      path2 = advance().value;
+      while (peek().kind !== "newline" && peek().kind !== "rbrace" && peek().kind !== "eof" && peek().kind !== "comma") advance();
+    } else if (t2.kind === "string") {
       path2 = advance().value;
     } else if (t2.kind === "unquoted" && (t2.value === "file(" || t2.value === "file")) {
       advance();
       while (peek().kind !== "string" && peek().kind !== "eof") advance();
       if (peek().kind === "eof") throw new ParseError("expected include path", t2.line, t2.col);
       path2 = advance().value;
-      while (peek().kind !== "newline" && peek().kind !== "rbrace" && peek().kind !== "eof") advance();
+      while (peek().kind !== "newline" && peek().kind !== "rbrace" && peek().kind !== "eof" && peek().kind !== "comma") advance();
+    } else if (t2.kind === "unquoted" && (t2.value === "url" || t2.value.startsWith("url("))) {
+      throw new ParseError("include url(...) is not supported", t2.line, t2.col);
+    } else if (t2.kind === "unquoted" && (t2.value === "classpath" || t2.value.startsWith("classpath("))) {
+      throw new ParseError("include classpath(...) is not supported", t2.line, t2.col);
     } else {
       throw new ParseError(`expected include path, got ${t2.kind}`, t2.line, t2.col);
     }
     return {
       key: [],
-      value: { kind: "include", path: path2, pos: p },
+      value: { kind: "include", path: path2, required, pos: p },
       append: false,
       pos: p
     };
@@ -404,7 +565,7 @@ function parseTokens(tokens) {
         break;
       }
       if (hadSpace) {
-        parts.push({ kind: "scalar", value: " ", pos: { line: t2.line, col: t2.col } });
+        parts.push({ kind: "scalar", value: " ", pos: { line: t2.line, col: t2.col }, _separator: true });
       }
       parts.push(node);
     }
@@ -440,13 +601,88 @@ function parseTokens(tokens) {
   const t = peek();
   if (t.kind === "lbrace") {
     advance();
-    return parseObject(true);
+    const first = parseObject(true);
+    const allFields = first.kind === "object" ? [...first.fields] : [];
+    while (true) {
+      skip("newline");
+      if (peek().kind === "eof") break;
+      if (peek().kind === "lbrace") {
+        advance();
+        const extra = parseObject(true);
+        if (extra.kind === "object") allFields.push(...extra.fields);
+      } else {
+        const rest = parseObject(false);
+        if (rest.kind === "object") allFields.push(...rest.fields);
+        break;
+      }
+    }
+    skip("newline");
+    const remaining = peek();
+    if (remaining.kind !== "eof") {
+      throw new ParseError(`Unexpected token '${remaining.value}' after closing brace`, remaining.line, remaining.col);
+    }
+    return { kind: "object", fields: allFields, pos: first.pos };
   }
   return parseObject(false);
 }
 
 // src/internal/resolver/resolver.ts
 var nodePath = __toESM(require("path"), 1);
+
+// src/internal/properties/properties.ts
+function parseProperties(input) {
+  const root = /* @__PURE__ */ Object.create(null);
+  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();
+    if (key === "") continue;
+    setNested(root, key.split("."), value);
+  }
+  return root;
+}
+function findSeparator(line) {
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] === "=" || line[i] === ":") return i;
+  }
+  return -1;
+}
+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;
+  current[last] = value;
+}
+function propertiesToHoconValue(input) {
+  const parsed = parseProperties(input);
+  return recordToHoconValue(parsed);
+}
+function recordToHoconValue(obj) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [key, val] of Object.entries(obj)) {
+    if (typeof val === "string") {
+      fields.set(key, { kind: "scalar", value: val });
+    } else if (val !== null && typeof val === "object") {
+      fields.set(key, recordToHoconValue(val));
+    }
+  }
+  return { kind: "object", fields };
+}
+
+// src/internal/resolver/resolver.ts
+var separatorValues = /* @__PURE__ */ new WeakSet();
 function isSubst(v) {
   return v._kind === "subst-placeholder";
 }
@@ -480,7 +716,7 @@ function buildResObj(ast, opts) {
 }
 function applyField(obj, field, opts) {
   if (field.key.length === 0 && field.value.kind === "include") {
-    const included = loadInclude(field.value.path, opts);
+    const included = loadInclude(field.value.path, field.value.required, opts);
     deepMergeResObjInto(obj, included);
     return;
   }
@@ -518,8 +754,11 @@ function applyField(obj, field, opts) {
 }
 function astToResolverValue(ast, opts) {
   switch (ast.kind) {
-    case "scalar":
-      return { kind: "scalar", value: ast.value };
+    case "scalar": {
+      const sv = { kind: "scalar", value: ast.value };
+      if (ast._separator) separatorValues.add(sv);
+      return sv;
+    }
     case "array":
       return { kind: "array", items: ast.items.map((i) => astToResolverValue(i, opts)) };
     case "object": {
@@ -534,6 +773,18 @@ function astToResolverValue(ast, opts) {
       return { kind: "scalar", value: null };
   }
 }
+function hoconValueToResObj(hv) {
+  const obj = makeResObj();
+  if (hv.kind !== "object") return obj;
+  for (const [key, val] of hv.fields) {
+    if (val.kind === "object") {
+      obj.fields.set(key, hoconValueToResObj(val));
+    } else {
+      obj.fields.set(key, val);
+    }
+  }
+  return obj;
+}
 function deepMergeResObjInto(dst, src) {
   for (const [k, srcVal] of src.fields) {
     const dstVal = dst.fields.get(k);
@@ -621,12 +872,18 @@ function resolveConcat(nodes, scope, root, resolving, resolvedCache, opts) {
   const resolved = nodes.map((n) => resolveVal(n, scope, root, resolving, resolvedCache, opts)).filter((v) => v !== void 0);
   if (resolved.length === 0) return { kind: "scalar", value: null };
   if (resolved.length === 1) return resolved[0];
-  if (resolved.every((v) => v.kind === "object")) {
+  const nonSep = resolved.filter((v) => !separatorValues.has(v));
+  if (nonSep.length > 0 && nonSep.every((v) => v.kind === "object")) {
     const merged = /* @__PURE__ */ new Map();
-    for (const v of resolved) {
+    for (const v of nonSep) {
       if (v.kind === "object") {
         for (const [k, val] of v.fields) {
-          merged.set(k, val);
+          const existing = merged.get(k);
+          if (existing?.kind === "object" && val.kind === "object") {
+            merged.set(k, deepMergeHoconValues(existing, val));
+          } else {
+            merged.set(k, val);
+          }
         }
       }
     }
@@ -643,6 +900,18 @@ function resolveConcat(nodes, scope, root, resolving, resolvedCache, opts) {
   const str = resolved.map((v) => v.kind === "scalar" ? String(v.value) : JSON.stringify(v)).join("");
   return { kind: "scalar", value: str };
 }
+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 };
+}
 function resolveAppend(a, scope, root, resolving, resolvedCache, opts) {
   const existing = resolveVal(a.existing, scope, root, resolving, resolvedCache, opts) ?? { kind: "array", items: [] };
   const elem = resolveVal(a.elem, scope, root, resolving, resolvedCache, opts);
@@ -700,35 +969,68 @@ function parseSubstPath(raw) {
   }
   return segments;
 }
-function loadInclude(includePath, opts) {
-  const { baseDir, readFileSync: readFileSync2, includeStack = [], env } = opts;
+function isFileNotFoundError(e) {
+  if (!(e instanceof Error)) return false;
+  const code = e.code;
+  if (code === "ENOENT" || code === "MODULE_NOT_FOUND") return true;
+  const msg = e.message.toLowerCase();
+  return msg.includes("not found") || msg.includes("no such file") || msg.includes("enoent");
+}
+function loadSingleInclude(candidate, opts) {
+  const { readFileSync: readFileSync2, includeStack = [], env } = opts;
+  if (includeStack.includes(candidate)) {
+    throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0);
+  }
+  let content;
+  try {
+    content = readFileSync2(candidate);
+  } catch (e) {
+    if (isFileNotFoundError(e)) return void 0;
+    throw e;
+  }
+  if (candidate.endsWith(".properties")) {
+    return hoconValueToResObj(propertiesToHoconValue(content));
+  }
+  const ast = parseTokens(tokenize(content));
+  return buildResObj(ast, {
+    env,
+    baseDir: nodePath.dirname(candidate),
+    readFileSync: readFileSync2,
+    includeStack: [...includeStack, candidate]
+  });
+}
+function loadInclude(includePath, required, opts) {
+  const { baseDir, includeStack = [] } = opts;
   const absPath = baseDir ? nodePath.resolve(baseDir, includePath) : nodePath.resolve(includePath);
   if (includeStack.includes(absPath)) {
     throw new ResolveError(`circular include: ${absPath}`, absPath, 0, 0);
   }
-  const candidates = [absPath];
-  if (!absPath.endsWith(".conf") && !absPath.endsWith(".json") && !absPath.endsWith(".properties")) {
-    candidates.push(absPath + ".conf", absPath + ".json");
+  if (includeStack.length >= 50) {
+    throw new ResolveError(`include depth limit exceeded (max 50)`, includePath, 0, 0);
   }
-  for (const candidate of candidates) {
-    let content;
-    try {
-      content = readFileSync2(candidate);
-    } catch {
-      continue;
+  const hasExplicitExt = absPath.endsWith(".conf") || absPath.endsWith(".json") || absPath.endsWith(".properties");
+  if (hasExplicitExt) {
+    const result = loadSingleInclude(absPath, opts);
+    if (result !== void 0) return result;
+    if (required) {
+      throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
     }
-    if (includeStack.includes(candidate)) {
-      throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0);
+    return makeResObj();
+  }
+  const merged = makeResObj();
+  let foundAny = false;
+  const probeExts = [".properties", ".json", ".conf"];
+  for (const ext of probeExts) {
+    const obj = loadSingleInclude(`${absPath}${ext}`, opts);
+    if (obj !== void 0) {
+      deepMergeResObjInto(merged, obj);
+      foundAny = true;
     }
-    const ast = parseTokens(tokenize(content));
-    return buildResObj(ast, {
-      env,
-      baseDir: nodePath.dirname(candidate),
-      readFileSync: readFileSync2,
-      includeStack: [...includeStack, candidate]
-    });
   }
-  return makeResObj();
+  if (!foundAny && required) {
+    throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
+  }
+  return merged;
 }
 
 // src/config.ts
@@ -764,6 +1066,20 @@ var Config = class _Config {
     }
     throw new ConfigError(`expected boolean at ${path2}, got ${typeof v}`, path2);
   }
+  getDuration(path2, unit) {
+    const v = this.requireScalar(path2);
+    if (typeof v !== "string") throw new ConfigError(`expected duration string at ${path2}, got ${typeof v}`, path2);
+    const result = parseDuration(v, unit);
+    if (Number.isNaN(result)) throw new ConfigError(`invalid duration at ${path2}: ${JSON.stringify(v)}`, path2);
+    return result;
+  }
+  getBytes(path2, unit) {
+    const v = this.requireScalar(path2);
+    if (typeof v !== "string") throw new ConfigError(`expected byte size string at ${path2}, got ${typeof v}`, path2);
+    const result = parseBytes(v, unit);
+    if (Number.isNaN(result)) throw new ConfigError(`invalid byte size at ${path2}: ${JSON.stringify(v)}`, path2);
+    return result;
+  }
   getConfig(path2) {
     const v = this.lookupNode(path2);
     if (v === void 0) throw new ConfigError(`path not found: ${path2}`, path2);
@@ -790,7 +1106,7 @@ var Config = class _Config {
     return hoconToJs(this.root);
   }
   lookupNode(path2) {
-    const segments = path2.split(".");
+    const segments = splitConfigPath(path2);
     let current = this.root;
     for (const seg of segments) {
       if (current.kind !== "object") return void 0;
@@ -807,6 +1123,45 @@ var Config = class _Config {
     return v.value;
   }
 };
+function splitConfigPath(path2) {
+  const segments = [];
+  let i = 0;
+  while (i < path2.length) {
+    if (path2[i] === '"') {
+      i++;
+      let segment = "";
+      let closed = false;
+      while (i < path2.length) {
+        const ch = path2[i];
+        if (ch === "\\" && i + 1 < path2.length) {
+          const next = path2[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: ${path2}`, path2);
+      segments.push(segment);
+      if (i < path2.length && path2[i] === ".") i++;
+    } else {
+      const dot = path2.indexOf(".", i);
+      if (dot === -1) {
+        segments.push(path2.slice(i));
+        break;
+      }
+      segments.push(path2.slice(i, dot));
+      i = dot + 1;
+    }
+  }
+  return segments;
+}
 function hoconToJs(v) {
   switch (v.kind) {
     case "scalar":
@@ -844,14 +1199,19 @@ function getEnv(opts) {
 function defaultReadFileSync(filePath) {
   return fs.readFileSync(filePath, "utf-8");
 }
-function parse(input, opts = {}) {
+function buildResolveContext(input, opts) {
   const tokens = tokenize(input);
   const ast = parseTokens(tokens);
   const resolveOpts = {
     env: getEnv(opts),
     baseDir: opts.baseDir,
-    readFileSync: opts.readFileSync ?? defaultReadFileSync
+    readFileSync: opts.readFileSync ?? defaultReadFileSync,
+    readFile: opts.readFile
   };
+  return { ast, resolveOpts };
+}
+function parse(input, opts = {}) {
+  const { ast, resolveOpts } = buildResolveContext(input, opts);
   const value = resolve2(ast, resolveOpts);
   if (value.kind !== "object") throw new Error("resolved value is not an object");
   return new Config(value);

package/dist/zod.d.cts

@@ -1,5 +1,5 @@
 import { ZodType } from 'zod';
-import { C as Config, P as ParseOptions } from './parse-C1NDMzD5.cjs';
+import { C as Config, P as ParseOptions } from './parse-C4VOYuEk.cjs';
 
 declare function validate<T>(config: Config, schema: ZodType<T>): T;
 declare function getValidated<T>(config: Config, path: string, schema: ZodType<T>): T;

package/dist/zod.d.ts

@@ -1,5 +1,5 @@
 import { ZodType } from 'zod';
-import { C as Config, P as ParseOptions } from './parse-C1NDMzD5.js';
+import { C as Config, P as ParseOptions } from './parse-C4VOYuEk.js';
 
 declare function validate<T>(config: Config, schema: ZodType<T>): T;
 declare function getValidated<T>(config: Config, path: string, schema: ZodType<T>): T;