@o3co/ts.hocon 0.1.2 → 0.1.5

package/dist/zod.cjs

@@ -1,7 +1,9 @@
 "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)
@@ -15,25 +17,945 @@ var __copyProps = (to, from, except, desc) => {
   }
   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/zod.ts
 var zod_exports = {};
 __export(zod_exports, {
   getValidated: () => getValidated,
+  parseFileWithSchema: () => parseFileWithSchema,
+  parseWithSchema: () => parseWithSchema,
   validate: () => validate
 });
 module.exports = __toCommonJS(zod_exports);
+
+// src/coerce.ts
+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 (!/^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)) return void 0;
+  return Number(value);
+}
+
+// src/errors.ts
+var ParseError = class extends Error {
+  constructor(message, line, col, file) {
+    super(message);
+    this.line = line;
+    this.col = col;
+    this.file = file;
+    this.name = "ParseError";
+  }
+};
+var ResolveError = class extends Error {
+  constructor(message, path2, line, col, file) {
+    super(message);
+    this.path = path2;
+    this.line = line;
+    this.col = col;
+    this.file = file;
+    this.name = "ResolveError";
+  }
+};
+var ConfigError = class extends Error {
+  constructor(message, path2) {
+    super(message);
+    this.path = path2;
+    this.name = "ConfigError";
+  }
+};
+
+// src/internal/lexer/lexer.ts
+function tokenize(input) {
+  if (input.charCodeAt(0) === 65279) input = input.slice(1);
+  const tokens = [];
+  let pos = 0;
+  let line = 1;
+  let col = 1;
+  let hadSpace = false;
+  function peek(offset = 0) {
+    return input[pos + offset] ?? "";
+  }
+  function advance() {
+    const ch = input[pos++] ?? "";
+    if (ch === "\n") {
+      line++;
+      col = 1;
+    } else {
+      col++;
+    }
+    return ch;
+  }
+  function push(kind, value, l, c, isQuoted = false) {
+    tokens.push({ kind, value, line: l, col: c, isQuoted, precedingSpace: hadSpace });
+    hadSpace = false;
+  }
+  while (pos < input.length) {
+    const sl = line, sc = col;
+    const ch = peek();
+    if (ch === " " || ch === "	" || ch === "\r") {
+      advance();
+      hadSpace = true;
+      continue;
+    }
+    if (ch === "\n") {
+      advance();
+      if (tokens[tokens.length - 1]?.kind !== "newline") {
+        push("newline", "\n", sl, sc);
+      }
+      continue;
+    }
+    if (ch === "/" && peek(1) === "/") {
+      while (pos < input.length && peek() !== "\n") advance();
+      hadSpace = true;
+      continue;
+    }
+    if (ch === "#") {
+      while (pos < input.length && peek() !== "\n") advance();
+      hadSpace = true;
+      continue;
+    }
+    const single = { "{": "lbrace", "}": "rbrace", "[": "lbracket", "]": "rbracket", ",": "comma", ":": "colon" };
+    if (ch in single) {
+      advance();
+      push(single[ch], ch, sl, sc);
+      continue;
+    }
+    if (ch === "=") {
+      advance();
+      push("equals", "=", sl, sc);
+      continue;
+    }
+    if (ch === "+" && peek(1) === "=") {
+      advance();
+      advance();
+      push("plus_equals", "+=", sl, sc);
+      continue;
+    }
+    if (ch === "$" && peek(1) === "{") {
+      advance();
+      advance();
+      const optional = peek() === "?";
+      if (optional) advance();
+      let path2 = "";
+      while (pos < input.length && peek() !== "}") {
+        if (peek() === "\n") throw new ParseError("unterminated substitution", sl, sc);
+        path2 += advance();
+      }
+      if (peek() !== "}") throw new ParseError("unterminated substitution", sl, sc);
+      advance();
+      push(optional ? "opt_subst" : "subst", path2.trim(), sl, sc);
+      continue;
+    }
+    if (ch === '"' && peek(1) === '"' && peek(2) === '"') {
+      advance();
+      advance();
+      advance();
+      let value = "";
+      while (pos < input.length) {
+        if (peek() === '"') {
+          let quoteCount = 0;
+          while (pos < input.length && peek() === '"') {
+            quoteCount++;
+            advance();
+          }
+          if (quoteCount >= 3) {
+            for (let i = 0; i < quoteCount - 3; i++) value += '"';
+            break;
+          }
+          for (let i = 0; i < quoteCount; i++) value += '"';
+          continue;
+        }
+        value += advance();
+      }
+      if (value.startsWith("\n")) value = value.slice(1);
+      push("triple_string", value, sl, sc, true);
+      continue;
+    }
+    if (ch === '"') {
+      advance();
+      let value = "";
+      while (pos < input.length && peek() !== '"') {
+        if (peek() === "\n") throw new ParseError("unterminated string", sl, sc);
+        if (peek() === "\\") {
+          advance();
+          const esc = advance();
+          switch (esc) {
+            case "n":
+              value += "\n";
+              break;
+            case "t":
+              value += "	";
+              break;
+            case "r":
+              value += "\r";
+              break;
+            case '"':
+              value += '"';
+              break;
+            case "\\":
+              value += "\\";
+              break;
+            case "/":
+              value += "/";
+              break;
+            case "b":
+              value += "\b";
+              break;
+            case "f":
+              value += "\f";
+              break;
+            case "u": {
+              const hex = input.slice(pos, pos + 4);
+              value += String.fromCharCode(parseInt(hex, 16));
+              for (let i = 0; i < 4; i++) advance();
+              break;
+            }
+            default:
+              value += esc;
+          }
+        } else {
+          value += advance();
+        }
+      }
+      if (peek() !== '"') throw new ParseError("unterminated string", sl, sc);
+      advance();
+      push("string", value, sl, sc, true);
+      continue;
+    }
+    if (isUnquotedStart(ch)) {
+      let value = "";
+      while (pos < input.length && isUnquotedContinue(peek(), () => peek(1))) {
+        value += advance();
+      }
+      push("unquoted", value.trimEnd(), sl, sc);
+      continue;
+    }
+    throw new ParseError(`unexpected character: ${JSON.stringify(ch)}`, sl, sc);
+  }
+  tokens.push({ kind: "eof", value: "", line, col, isQuoted: false, precedingSpace: false });
+  return tokens;
+}
+function isUnquotedStart(ch) {
+  return ch !== "" && !'{}[],:=+#\n\r	 "$'.includes(ch);
+}
+function isUnquotedContinue(ch, nextFn) {
+  if (ch === "" || '{}[],:=\n\r	 #"$'.includes(ch) || ch === " ") return false;
+  if (ch === "+" && nextFn() === "=") return false;
+  if (ch === "/" && nextFn() === "/") return false;
+  return true;
+}
+
+// src/internal/parser/parser.ts
+function parseTokens(tokens) {
+  let pos = 0;
+  function peek() {
+    return tokens[pos] ?? { kind: "eof", value: "", line: 0, col: 0, isQuoted: false, precedingSpace: false };
+  }
+  function advance() {
+    const t2 = tokens[pos];
+    if (pos < tokens.length) pos++;
+    return t2 ?? { kind: "eof", value: "", line: 0, col: 0, isQuoted: false, precedingSpace: false };
+  }
+  function skip(...kinds) {
+    while (kinds.includes(peek().kind)) advance();
+  }
+  function currentPos() {
+    const t2 = peek();
+    return { line: t2.line, col: t2.col };
+  }
+  function parseObject(expectClosingBrace) {
+    const p = currentPos();
+    const fields = [];
+    while (true) {
+      skip("newline");
+      const t2 = peek();
+      if (t2.kind === "eof" || t2.kind === "rbrace") break;
+      if (t2.kind === "unquoted" && t2.value === "include") {
+        advance();
+        fields.push(parseInclude());
+        skip("newline");
+        if (peek().kind === "comma") advance();
+        skip("newline");
+        continue;
+      }
+      const keyPos = currentPos();
+      const key = parseKey();
+      skip("newline");
+      let append = false;
+      const sep = peek();
+      if (sep.kind === "equals") advance();
+      else if (sep.kind === "plus_equals") {
+        advance();
+        append = true;
+      } else if (sep.kind === "colon") advance();
+      else if (sep.kind === "lbrace") {
+      } else if (sep.kind !== "newline" && sep.kind !== "eof") {
+        throw new ParseError(`unexpected token after key: ${sep.kind}`, sep.line, sep.col);
+      }
+      skip("newline");
+      const value = parseValue();
+      fields.push({ key, value, append, pos: keyPos });
+      skip("newline");
+      if (peek().kind === "comma") advance();
+      skip("newline");
+    }
+    if (expectClosingBrace) {
+      const t2 = peek();
+      if (t2.kind !== "rbrace") throw new ParseError("expected }", t2.line, t2.col);
+      advance();
+    }
+    return { kind: "object", fields, pos: p };
+  }
+  function parseKey() {
+    const segments = [];
+    let trailingDot = false;
+    while (true) {
+      const t2 = peek();
+      if (t2.kind === "string") {
+        advance();
+        segments.push(t2.value);
+        trailingDot = false;
+      } else if (t2.kind === "unquoted") {
+        advance();
+        const parts = t2.value.split(".");
+        const filtered = parts.filter((s) => s.length > 0);
+        segments.push(...filtered);
+        trailingDot = t2.value.endsWith(".");
+      } else {
+        if (segments.length === 0) throw new ParseError(`expected key, got ${t2.kind}`, t2.line, t2.col);
+        break;
+      }
+      if (trailingDot) continue;
+      const next = peek();
+      if (next.kind === "unquoted" && next.value === "." && !next.precedingSpace) {
+        advance();
+        trailingDot = true;
+        continue;
+      }
+      break;
+    }
+    return segments;
+  }
+  function parseInclude() {
+    const p = currentPos();
+    skip("newline");
+    const t2 = peek();
+    let path2;
+    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();
+    } else {
+      throw new ParseError(`expected include path, got ${t2.kind}`, t2.line, t2.col);
+    }
+    return {
+      key: [],
+      value: { kind: "include", path: path2, pos: p },
+      append: false,
+      pos: p
+    };
+  }
+  function parseValue() {
+    const p = currentPos();
+    const parts = [];
+    while (true) {
+      const t2 = peek();
+      if (t2.kind === "eof" || t2.kind === "newline" || t2.kind === "rbrace" || t2.kind === "rbracket" || t2.kind === "comma") break;
+      const hadSpace = t2.precedingSpace && parts.length > 0;
+      let node;
+      if (t2.kind === "lbrace") {
+        advance();
+        node = parseObject(true);
+      } else if (t2.kind === "lbracket") {
+        advance();
+        node = parseArray();
+      } else if (t2.kind === "subst" || t2.kind === "opt_subst") {
+        advance();
+        node = { kind: "subst", path: t2.value, optional: t2.kind === "opt_subst", pos: { line: t2.line, col: t2.col } };
+      } else if (t2.kind === "string" || t2.kind === "triple_string") {
+        advance();
+        node = { kind: "scalar", value: t2.value, pos: { line: t2.line, col: t2.col } };
+      } else if (t2.kind === "unquoted") {
+        advance();
+        node = { kind: "scalar", value: parseScalarValue(t2.value), pos: { line: t2.line, col: t2.col } };
+      } else if ((t2.kind === "colon" || t2.kind === "equals") && parts.length > 0) {
+        advance();
+        node = { kind: "scalar", value: t2.value, pos: { line: t2.line, col: t2.col } };
+      } else {
+        break;
+      }
+      if (hadSpace) {
+        parts.push({ kind: "scalar", value: " ", pos: { line: t2.line, col: t2.col } });
+      }
+      parts.push(node);
+    }
+    if (parts.length === 0) throw new ParseError("expected value", peek().line, peek().col);
+    if (parts.length === 1) return parts[0];
+    return { kind: "concat", nodes: parts, pos: p };
+  }
+  function parseArray() {
+    const p = currentPos();
+    const items = [];
+    while (true) {
+      skip("newline");
+      if (peek().kind === "rbracket" || peek().kind === "eof") break;
+      items.push(parseValue());
+      skip("newline");
+      if (peek().kind === "comma") advance();
+      skip("newline");
+    }
+    const t2 = peek();
+    if (t2.kind !== "rbracket") throw new ParseError("expected ]", t2.line, t2.col);
+    advance();
+    return { kind: "array", items, pos: p };
+  }
+  function parseScalarValue(raw) {
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+    if (raw === "null") return null;
+    const n = Number(raw);
+    if (!isNaN(n) && raw.trim() !== "") return n;
+    return raw;
+  }
+  skip("newline");
+  const t = peek();
+  if (t.kind === "lbrace") {
+    advance();
+    return parseObject(true);
+  }
+  return parseObject(false);
+}
+
+// src/internal/resolver/resolver.ts
+var nodePath = __toESM(require("path"), 1);
+function isSubst(v) {
+  return v._kind === "subst-placeholder";
+}
+function isConcat(v) {
+  return v._kind === "concat-placeholder";
+}
+function isAppend(v) {
+  return v._kind === "append-placeholder";
+}
+function isResObj(v) {
+  return v._kind === "res-obj";
+}
+function makeResObj() {
+  return { _kind: "res-obj", fields: /* @__PURE__ */ new Map(), priorValues: /* @__PURE__ */ new Map() };
+}
+function resolve2(ast, opts) {
+  const root = buildResObj(ast, opts);
+  const resolving = /* @__PURE__ */ new Set();
+  const resolvedCache = /* @__PURE__ */ new Map();
+  return resolveResObj(root, root, resolving, resolvedCache, opts);
+}
+function buildResObj(ast, opts) {
+  if (ast.kind !== "object") {
+    throw new ResolveError("root AST must be an object", "", ast.pos.line, ast.pos.col);
+  }
+  const obj = makeResObj();
+  for (const field of ast.fields) {
+    applyField(obj, field, opts);
+  }
+  return obj;
+}
+function applyField(obj, field, opts) {
+  if (field.key.length === 0 && field.value.kind === "include") {
+    const included = loadInclude(field.value.path, opts);
+    deepMergeResObjInto(obj, included);
+    return;
+  }
+  const [head, ...tail] = field.key;
+  if (!head) return;
+  if (tail.length > 0) {
+    const syntheticAst = {
+      kind: "object",
+      fields: [{ key: tail, value: field.value, append: field.append, pos: field.pos }],
+      pos: field.pos
+    };
+    applyField(obj, { key: [head], value: syntheticAst, append: false, pos: field.pos }, opts);
+    return;
+  }
+  if (field.append) {
+    const existing2 = obj.fields.get(head) ?? { kind: "array", items: [] };
+    obj.priorValues.set(head, existing2);
+    obj.fields.set(head, {
+      _kind: "append-placeholder",
+      existing: existing2,
+      elem: astToResolverValue(field.value, opts)
+    });
+    return;
+  }
+  const existing = obj.fields.get(head);
+  const newVal = astToResolverValue(field.value, opts);
+  if (existing !== void 0) {
+    obj.priorValues.set(head, existing);
+  }
+  if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
+    deepMergeResObjInto(existing, newVal);
+    return;
+  }
+  obj.fields.set(head, newVal);
+}
+function astToResolverValue(ast, opts) {
+  switch (ast.kind) {
+    case "scalar":
+      return { kind: "scalar", value: ast.value };
+    case "array":
+      return { kind: "array", items: ast.items.map((i) => astToResolverValue(i, opts)) };
+    case "object": {
+      const inner = buildResObj(ast, opts);
+      return inner;
+    }
+    case "subst":
+      return { _kind: "subst-placeholder", path: ast.path, optional: ast.optional, line: ast.pos.line, col: ast.pos.col };
+    case "concat":
+      return { _kind: "concat-placeholder", nodes: ast.nodes.map((n) => astToResolverValue(n, opts)) };
+    case "include":
+      return { kind: "scalar", value: null };
+  }
+}
+function deepMergeResObjInto(dst, src) {
+  for (const [k, srcVal] of src.fields) {
+    const dstVal = dst.fields.get(k);
+    if (dstVal !== void 0 && isResObj(dstVal) && isResObj(srcVal)) {
+      deepMergeResObjInto(dstVal, srcVal);
+    } else {
+      if (dstVal !== void 0) dst.priorValues.set(k, dstVal);
+      dst.fields.set(k, srcVal);
+    }
+  }
+}
+function resolveResObj(obj, root, resolving, resolvedCache, opts) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [key, val] of obj.fields) {
+    const resolved = resolveVal(val, obj, root, resolving, resolvedCache, opts);
+    if (resolved !== void 0) {
+      result.set(key, resolved);
+    } else {
+      const prior = obj.priorValues.get(key);
+      if (prior !== void 0) {
+        const priorResolved = resolveVal(prior, obj, root, resolving, resolvedCache, opts);
+        if (priorResolved !== void 0) result.set(key, priorResolved);
+      }
+    }
+  }
+  return { kind: "object", fields: result };
+}
+function resolveVal(v, scope, root, resolving, resolvedCache, opts) {
+  if (isSubst(v)) return resolveSubst(v, scope, root, resolving, resolvedCache, opts);
+  if (isConcat(v)) return resolveConcat(v.nodes, scope, root, resolving, resolvedCache, opts);
+  if (isAppend(v)) return resolveAppend(v, scope, root, resolving, resolvedCache, opts);
+  if (isResObj(v)) return resolveResObj(v, root, resolving, resolvedCache, opts);
+  const hv = v;
+  if (hv.kind === "array") {
+    return {
+      kind: "array",
+      items: hv.items.map(
+        (item) => resolveVal(item, scope, root, resolving, resolvedCache, opts) ?? { kind: "scalar", value: null }
+      )
+    };
+  }
+  return hv;
+}
+function resolveSubst(s, scope, root, resolving, resolvedCache, opts) {
+  if (resolvedCache.has(s.path)) return resolvedCache.get(s.path);
+  if (resolving.has(s.path)) {
+    const rootSeg = parseSubstPath(s.path)[0] ?? "";
+    const prior = scope.priorValues.get(rootSeg) ?? root.priorValues.get(rootSeg);
+    if (prior !== void 0) {
+      return resolveVal(prior, scope, root, new Set(resolving), resolvedCache, opts);
+    }
+    if (s.optional) return void 0;
+    throw new ResolveError(`circular substitution: ${s.path}`, s.path, s.line, s.col);
+  }
+  resolving.add(s.path);
+  try {
+    const found = lookupPath(root, parseSubstPath(s.path));
+    if (found !== void 0) {
+      if (isSubst(found) || isConcat(found)) {
+        const rootSeg = parseSubstPath(s.path)[0] ?? "";
+        const prior = scope.priorValues.get(rootSeg) ?? root.priorValues.get(rootSeg);
+        if (prior !== void 0) {
+          const result2 = resolveVal(prior, scope, root, resolving, resolvedCache, opts);
+          if (result2 !== void 0) resolvedCache.set(s.path, result2);
+          return result2;
+        }
+      }
+      const result = resolveVal(found, scope, root, resolving, resolvedCache, opts);
+      if (result !== void 0) resolvedCache.set(s.path, result);
+      return result;
+    }
+    const envVal = opts.env[s.path];
+    if (envVal !== void 0) {
+      const result = { kind: "scalar", value: envVal };
+      resolvedCache.set(s.path, result);
+      return result;
+    }
+    if (s.optional) return void 0;
+    throw new ResolveError(`could not resolve substitution: \${${s.path}}`, s.path, s.line, s.col);
+  } finally {
+    resolving.delete(s.path);
+  }
+}
+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 merged = /* @__PURE__ */ new Map();
+    for (const v of resolved) {
+      if (v.kind === "object") {
+        for (const [k, val] of v.fields) {
+          merged.set(k, val);
+        }
+      }
+    }
+    return { kind: "object", fields: merged };
+  }
+  if (resolved.some((v) => v.kind === "array")) {
+    const items = [];
+    for (const v of resolved) {
+      if (v.kind === "array") items.push(...v.items);
+      else items.push(v);
+    }
+    return { kind: "array", items };
+  }
+  const str = resolved.map((v) => v.kind === "scalar" ? String(v.value) : JSON.stringify(v)).join("");
+  return { kind: "scalar", value: str };
+}
+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);
+  const items = existing.kind === "array" ? [...existing.items] : [existing];
+  if (elem !== void 0) items.push(elem);
+  return { kind: "array", items };
+}
+function lookupPath(root, segments) {
+  const [head, ...tail] = segments;
+  if (head === void 0 || head === "") {
+    if (segments.length > 0) {
+      const val2 = root.fields.get("");
+      if (val2 === void 0) return void 0;
+      if (tail.length === 0) return val2;
+      if (isResObj(val2)) return lookupPath(val2, tail);
+      return void 0;
+    }
+    return void 0;
+  }
+  const val = root.fields.get(head);
+  if (val === void 0) return void 0;
+  if (tail.length === 0) return val;
+  if (isResObj(val)) return lookupPath(val, tail);
+  return void 0;
+}
+function parseSubstPath(raw) {
+  const segments = [];
+  let i = 0;
+  while (i < raw.length) {
+    while (i < raw.length && (raw[i] === " " || raw[i] === "	")) i++;
+    if (i >= raw.length) break;
+    if (raw[i] === '"') {
+      i++;
+      let seg = "";
+      while (i < raw.length && raw[i] !== '"') {
+        seg += raw[i];
+        i++;
+      }
+      if (i < raw.length) i++;
+      segments.push(seg);
+      while (i < raw.length && (raw[i] === " " || raw[i] === "	")) i++;
+      if (i < raw.length && raw[i] === ".") i++;
+    } else if (raw[i] === ".") {
+      segments.push("");
+      i++;
+    } else {
+      let seg = "";
+      while (i < raw.length && raw[i] !== ".") {
+        seg += raw[i];
+        i++;
+      }
+      segments.push(seg.trim());
+      if (i < raw.length && raw[i] === ".") i++;
+    }
+  }
+  return segments;
+}
+function loadInclude(includePath, opts) {
+  const { baseDir, readFileSync: readFileSync2, includeStack = [], env } = 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");
+  }
+  for (const candidate of candidates) {
+    let content;
+    try {
+      content = readFileSync2(candidate);
+    } catch {
+      continue;
+    }
+    if (includeStack.includes(candidate)) {
+      throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0);
+    }
+    const ast = parseTokens(tokenize(content));
+    return buildResObj(ast, {
+      env,
+      baseDir: nodePath.dirname(candidate),
+      readFileSync: readFileSync2,
+      includeStack: [...includeStack, candidate]
+    });
+  }
+  return makeResObj();
+}
+
+// src/config.ts
+var Config = class _Config {
+  constructor(root) {
+    this.root = root;
+  }
+  get(path2) {
+    const v = this.lookupNode(path2);
+    if (v === void 0) return void 0;
+    return hoconToJs(v);
+  }
+  getString(path2) {
+    const v = this.requireScalar(path2);
+    if (typeof v !== "string") throw new ConfigError(`expected string at ${path2}, got ${typeof v}`, path2);
+    return v;
+  }
+  getNumber(path2) {
+    const v = this.requireScalar(path2);
+    if (typeof v === "number") return v;
+    if (typeof v === "string") {
+      const coerced = coerceNumber(v);
+      if (coerced !== void 0) return coerced;
+    }
+    throw new ConfigError(`expected number at ${path2}, got ${typeof v}`, path2);
+  }
+  getBoolean(path2) {
+    const v = this.requireScalar(path2);
+    if (typeof v === "boolean") return v;
+    if (typeof v === "string") {
+      const coerced = coerceBoolean(v);
+      if (coerced !== void 0) return coerced;
+    }
+    throw new ConfigError(`expected boolean at ${path2}, got ${typeof v}`, path2);
+  }
+  getConfig(path2) {
+    const v = this.lookupNode(path2);
+    if (v === void 0) throw new ConfigError(`path not found: ${path2}`, path2);
+    if (v.kind !== "object") throw new ConfigError(`expected object at ${path2}`, path2);
+    return new _Config(v);
+  }
+  getList(path2) {
+    const v = this.lookupNode(path2);
+    if (v === void 0) throw new ConfigError(`path not found: ${path2}`, path2);
+    if (v.kind !== "array") throw new ConfigError(`expected array at ${path2}`, path2);
+    return v.items.map(hoconToJs);
+  }
+  has(path2) {
+    return this.lookupNode(path2) !== void 0;
+  }
+  keys() {
+    return [...this.root.fields.keys()];
+  }
+  withFallback(fallback) {
+    const merged = deepMergeHocon(this.root, fallback.root);
+    return new _Config(merged);
+  }
+  toObject() {
+    return hoconToJs(this.root);
+  }
+  lookupNode(path2) {
+    const segments = path2.split(".");
+    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;
+  }
+  requireScalar(path2) {
+    const v = this.lookupNode(path2);
+    if (v === void 0) throw new ConfigError(`path not found: ${path2}`, path2);
+    if (v.kind !== "scalar") throw new ConfigError(`expected scalar at ${path2}, got ${v.kind}`, path2);
+    return v.value;
+  }
+};
+function hoconToJs(v) {
+  switch (v.kind) {
+    case "scalar":
+      return v.value;
+    case "array":
+      return v.items.map(hoconToJs);
+    case "object": {
+      const obj = {};
+      for (const [k, val] of v.fields) obj[k] = hoconToJs(val);
+      return obj;
+    }
+  }
+}
+function deepMergeHocon(receiver, fallback) {
+  const merged = new Map(fallback.fields);
+  for (const [k, v] of receiver.fields) {
+    const fb = merged.get(k);
+    if (fb?.kind === "object" && v.kind === "object") {
+      merged.set(k, deepMergeHocon(v, fb));
+    } else {
+      merged.set(k, v);
+    }
+  }
+  return { kind: "object", fields: merged };
+}
+
+// src/parse.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+function getEnv(opts) {
+  if (opts.env !== void 0) return opts.env;
+  if (typeof process !== "undefined" && process.env) return process.env;
+  return {};
+}
+function defaultReadFileSync(filePath) {
+  return fs.readFileSync(filePath, "utf-8");
+}
+function parse(input, opts = {}) {
+  const tokens = tokenize(input);
+  const ast = parseTokens(tokens);
+  const resolveOpts = {
+    env: getEnv(opts),
+    baseDir: opts.baseDir,
+    readFileSync: opts.readFileSync ?? defaultReadFileSync
+  };
+  const value = resolve2(ast, resolveOpts);
+  if (value.kind !== "object") throw new Error("resolved value is not an object");
+  return new Config(value);
+}
+function parseFile(filePath, opts = {}) {
+  if (typeof process === "undefined" && !opts.readFileSync) {
+    throw new Error("parseFile is not supported in browser environments. Provide opts.readFileSync or use parse() instead.");
+  }
+  const resolvedPath = path.resolve(filePath);
+  const readFileSync2 = opts.readFileSync ?? defaultReadFileSync;
+  const input = readFileSync2(resolvedPath);
+  return parse(input, {
+    ...opts,
+    baseDir: opts.baseDir ?? path.dirname(resolvedPath),
+    readFileSync: readFileSync2
+  });
+}
+
+// src/zod.ts
 function validate(config, schema) {
   const plain = config.toObject();
-  return schema.parse(plain);
+  const coerced = coerceValue(plain, schema);
+  return schema.parse(coerced);
+}
+function getValidated(config, path2, schema) {
+  const val = config.get(path2);
+  const coerced = coerceValue(val, schema);
+  return schema.parse(coerced);
+}
+function getDefType(schema) {
+  const zod = schema._zod;
+  return zod?.def?.type;
 }
-function getValidated(config, path, schema) {
-  const val = config.get(path);
-  return schema.parse(val);
+function getInnerSchema(schema) {
+  const def = schema._zod?.def;
+  return def?.innerType ?? def?.schema;
+}
+function getObjectShape(schema) {
+  const shape = schema._zod?.def?.shape;
+  return typeof shape === "object" && shape !== null ? shape : void 0;
+}
+function getArrayElement(schema) {
+  return schema._zod?.def?.element;
+}
+function parseWithSchema(input, schema, opts) {
+  const config = parse(input, opts);
+  return validate(config, schema);
+}
+function parseFileWithSchema(filePath, schema, opts) {
+  const config = parseFile(filePath, opts);
+  return validate(config, schema);
+}
+function coerceValue(value, schema) {
+  if (value === null || value === void 0) return value;
+  const defType = getDefType(schema);
+  if (!defType) return value;
+  switch (defType) {
+    case "boolean":
+      if (typeof value === "string") {
+        const coerced = coerceBoolean(value);
+        return coerced !== void 0 ? coerced : value;
+      }
+      return value;
+    case "number":
+      if (typeof value === "string") {
+        const coerced = coerceNumber(value);
+        return coerced !== void 0 ? coerced : value;
+      }
+      return value;
+    case "object": {
+      if (typeof value !== "object" || Array.isArray(value)) return value;
+      const shape = getObjectShape(schema);
+      if (!shape) return value;
+      const obj = value;
+      const result = { ...obj };
+      for (const key of Object.keys(shape)) {
+        if (key in obj) {
+          result[key] = coerceValue(obj[key], shape[key]);
+        }
+      }
+      return result;
+    }
+    case "array": {
+      if (!Array.isArray(value)) return value;
+      const elementSchema = getArrayElement(schema);
+      if (!elementSchema) return value;
+      return value.map((item) => coerceValue(item, elementSchema));
+    }
+    case "optional":
+    case "nullable":
+    case "default":
+    case "catch":
+    case "readonly": {
+      const inner = getInnerSchema(schema);
+      return inner ? coerceValue(value, inner) : value;
+    }
+    default:
+      return value;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getValidated,
+  parseFileWithSchema,
+  parseWithSchema,
   validate
 });