@o3co/ts.hocon 1.5.2 → 1.6.0

package/dist/zod.cjs

@@ -342,7 +342,7 @@ function stringSegmentsToKey(segments) {
   }).join(".");
 }
 function containsSelfRef(v, fullKey) {
-  if (isSubst(v)) return substFullKey(v) === fullKey;
+  if (isSubst(v)) return !v.knownAbsent && substFullKey(v) === fullKey;
   if (isConcat(v)) return v.nodes.some((n) => containsSelfRef(n, fullKey));
   if (isAppend(v)) {
     return containsSelfRef(v.existing, fullKey) || containsSelfRef(v.elem, fullKey);
@@ -409,15 +409,75 @@ function foldSelfRef(v, fullKey, replacement) {
 }
 function foldOrSkipPrior(prior, fullKey, old) {
   if (!containsSelfRef(prior, fullKey)) return cloneResolverValue(prior);
-  if (old === void 0) return void 0;
+  if (old === void 0) return foldOptionalSelfRefAbsent(prior, fullKey);
   return foldSelfRef(prior, fullKey, old);
 }
+function foldOptionalSelfRefAbsent(v, fullKey) {
+  if (isSubst(v) && substFullKey(v) === fullKey) {
+    if (!v.optional) return void 0;
+    return {
+      _kind: "subst-placeholder",
+      segments: v.segments.map((seg) => ({ text: seg.text, line: seg.line, col: seg.col })),
+      optional: v.optional,
+      knownAbsent: true,
+      listSuffix: v.listSuffix,
+      line: v.line,
+      col: v.col,
+      prefixLen: v.prefixLen
+    };
+  }
+  if (isConcat(v)) {
+    const nodes = [];
+    for (const node of v.nodes) {
+      const folded = foldOptionalSelfRefAbsent(node, fullKey);
+      if (folded === void 0) return void 0;
+      nodes.push(folded);
+    }
+    return { _kind: "concat-placeholder", nodes, line: v.line, col: v.col };
+  }
+  if (isAppend(v)) {
+    const existing = foldOptionalSelfRefAbsent(v.existing, fullKey);
+    const elem = foldOptionalSelfRefAbsent(v.elem, fullKey);
+    if (existing === void 0 || elem === void 0) return void 0;
+    return { _kind: "append-placeholder", existing, elem };
+  }
+  if (isResObj(v)) {
+    const fields = /* @__PURE__ */ new Map();
+    for (const [key, value] of v.fields) {
+      const folded = foldOptionalSelfRefAbsent(value, fullKey);
+      if (folded === void 0) return void 0;
+      fields.set(key, folded);
+    }
+    return { _kind: "res-obj", fields, priorValues: new Map(v.priorValues) };
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    const items = [];
+    for (const item of hv.items) {
+      const folded = foldOptionalSelfRefAbsent(item, fullKey);
+      if (folded === void 0) return void 0;
+      items.push(folded);
+    }
+    return { kind: "array", items };
+  }
+  if (hv.kind === "object") {
+    const fields = /* @__PURE__ */ new Map();
+    for (const [key, value] of hv.fields) {
+      const folded = foldOptionalSelfRefAbsent(value, fullKey);
+      if (folded === void 0) return void 0;
+      fields.set(key, folded);
+    }
+    return { kind: "object", fields };
+  }
+  return cloneResolverValue(v);
+}
 function cloneResolverValue(v) {
   if (isSubst(v)) {
     return {
       _kind: "subst-placeholder",
       segments: v.segments.map((seg) => ({ text: seg.text, line: seg.line, col: seg.col })),
       optional: v.optional,
+      knownAbsent: v.knownAbsent,
       listSuffix: v.listSuffix,
       line: v.line,
       col: v.col,
@@ -482,7 +542,7 @@ function foldNestedSelfRefs(v, pathPrefix) {
   return { _kind: "res-obj", fields: newFields, priorValues: new Map(v.priorValues) };
 }
 function containsSubstByPath(v, target) {
-  if (isSubst(v)) return segmentsTextEqual(v.segments, target);
+  if (isSubst(v)) return !v.knownAbsent && segmentsTextEqual(v.segments, target);
   if (isConcat(v)) return v.nodes.some((n) => containsSubstByPath(n, target));
   if (isAppend(v)) {
     return containsSubstByPath(v.existing, target) || containsSubstByPath(v.elem, target);
@@ -649,6 +709,11 @@ var Lexer = class {
     this.line = 1;
     this.col = 1;
     this.hadSpace = false;
+    // Accumulates literal whitespace chars consumed between tokens. Reset on every
+    // token push. Used so the parser can preserve path-expression whitespace
+    // (xx.hocon#42, E13) — e.g. tab vs space adjacent to dots in key paths.
+    // Comment text is NOT accumulated; only the actual WS chars.
+    this.whitespaceBuffer = "";
     this.tokens = [];
     if (input.charCodeAt(0) === 65279) this.input = input.slice(1);
   }
@@ -664,6 +729,7 @@ var Lexer = class {
         continue;
       }
       if (isHoconWhitespace(ch)) {
+        this.whitespaceBuffer += ch;
         this.advance();
         this.hadSpace = true;
         continue;
@@ -755,7 +821,7 @@ var Lexer = class {
       }
       throw new ParseError(`unexpected character: ${JSON.stringify(ch)}`, sl, sc);
     }
-    this.tokens.push({ kind: "eof", value: "", line: this.line, col: this.col, isQuoted: false, precedingSpace: false });
+    this.tokens.push({ kind: "eof", value: "", line: this.line, col: this.col, isQuoted: false, precedingSpace: false, precedingWhitespace: "" });
     return this.tokens;
   }
   peek(offset = 0) {
@@ -772,12 +838,14 @@ var Lexer = class {
     return ch;
   }
   push(kind, value, l, c, isQuoted = false) {
-    this.tokens.push({ kind, value, line: l, col: c, isQuoted, precedingSpace: this.hadSpace });
+    this.tokens.push({ kind, value, line: l, col: c, isQuoted, precedingSpace: this.hadSpace, precedingWhitespace: this.whitespaceBuffer });
     this.hadSpace = false;
+    this.whitespaceBuffer = "";
   }
   pushSubst(payload, value, l, c) {
-    this.tokens.push({ kind: "subst", value, line: l, col: c, isQuoted: false, precedingSpace: this.hadSpace, subst: payload });
+    this.tokens.push({ kind: "subst", value, line: l, col: c, isQuoted: false, precedingSpace: this.hadSpace, precedingWhitespace: this.whitespaceBuffer, subst: payload });
     this.hadSpace = false;
+    this.whitespaceBuffer = "";
   }
   /**
    * Read body of a quoted string. Opening `"` must already be consumed.
@@ -1023,7 +1091,7 @@ function isUnquotedContinue(ch, nextFn) {
 }
 
 // src/internal/parser/parser.ts
-var EOF_TOKEN = { kind: "eof", value: "", line: 0, col: 0, isQuoted: false, precedingSpace: false, subst: void 0 };
+var EOF_TOKEN = { kind: "eof", value: "", line: 0, col: 0, isQuoted: false, precedingSpace: false, precedingWhitespace: "", subst: void 0 };
 var Parser = class {
   constructor(tokens) {
     this.tokens = tokens;
@@ -1136,13 +1204,17 @@ var Parser = class {
     let trailingDot = false;
     let firstWasQuoted = false;
     let spaceConcat = false;
+    let postDotPrefix = "";
     while (true) {
       const t = this.peek();
       if (t.kind === "string") {
         this.advance();
         if (segments.length === 0) firstWasQuoted = true;
         if (spaceConcat) {
-          segments[segments.length - 1] = `${segments[segments.length - 1]} ${t.value}`;
+          segments[segments.length - 1] = `${segments[segments.length - 1]}${t.precedingWhitespace}${t.value}`;
+        } else if (postDotPrefix !== "") {
+          segments.push(`${postDotPrefix}${t.value}`);
+          postDotPrefix = "";
         } else {
           segments.push(t.value);
         }
@@ -1152,24 +1224,23 @@ var Parser = class {
         const raw = t.value.startsWith(".") && segments.length > 0 && !t.precedingSpace ? t.value.slice(1) : t.value;
         const parts = raw.split(".");
         const filtered = parts.filter((s) => s.length > 0);
-        for (const seg of filtered) {
-          if (seg[0] === "-" && !(seg.length >= 2 && seg[1] >= "0" && seg[1] <= "9")) {
-            const after = seg.length >= 2 ? JSON.stringify(seg[1]) : "EOF";
-            throw new ParseError(
-              `unquoted key segment cannot begin with '-' unless followed by a digit (got '-' then ${after} in ${JSON.stringify(seg)}, HOCON.md L270-276)`,
-              t.line,
-              t.col
-            );
-          }
-        }
-        if (spaceConcat && filtered.length > 0) {
+        if (spaceConcat) {
+          segments[segments.length - 1] = `${segments[segments.length - 1]}${t.precedingWhitespace}`;
           if (raw.startsWith(".")) {
             segments.push(...filtered);
-          } else {
+          } else if (filtered.length > 0) {
             const [head, ...tail] = filtered;
-            segments[segments.length - 1] = `${segments[segments.length - 1]} ${head}`;
+            segments[segments.length - 1] = `${segments[segments.length - 1]}${head}`;
             segments.push(...tail);
           }
+        } else if (postDotPrefix !== "" && raw.startsWith(".")) {
+          segments.push(postDotPrefix);
+          postDotPrefix = "";
+          segments.push(...filtered);
+        } else if (postDotPrefix !== "" && filtered.length > 0) {
+          const [head, ...tail] = filtered;
+          segments.push(`${postDotPrefix}${head}`, ...tail);
+          postDotPrefix = "";
         } else {
           segments.push(...filtered);
         }
@@ -1179,11 +1250,23 @@ var Parser = class {
         break;
       }
       spaceConcat = false;
-      if (trailingDot) continue;
+      if (trailingDot) {
+        const next2 = this.peek();
+        if ((next2.kind === "unquoted" || next2.kind === "string") && next2.precedingWhitespace.length > 0) {
+          postDotPrefix = next2.precedingWhitespace;
+        } else {
+          postDotPrefix = "";
+        }
+        continue;
+      }
       const next = this.peek();
       if (next.kind === "unquoted" && next.value === "." && !next.precedingSpace) {
         this.advance();
         trailingDot = true;
+        const afterDot = this.peek();
+        if ((afterDot.kind === "unquoted" || afterDot.kind === "string") && afterDot.precedingWhitespace.length > 0) {
+          postDotPrefix = afterDot.precedingWhitespace;
+        }
         continue;
       }
       if (next.kind === "unquoted" && next.value.startsWith(".") && !next.precedingSpace) {
@@ -1196,6 +1279,14 @@ var Parser = class {
       }
       break;
     }
+    if (trailingDot) {
+      const here = this.peek();
+      throw new ParseError(
+        `path has a trailing period '.' \u2014 empty key segment not allowed (HOCON.md path rules)`,
+        here.line,
+        here.col
+      );
+    }
     return { segments, firstWasQuoted };
   }
   parseInclude() {
@@ -1368,7 +1459,8 @@ var Parser = class {
         break;
       }
       if (hadSpace) {
-        parts.push({ kind: "scalar", raw: " ", valueType: "string", pos: { line: t.line, col: t.col }, _separator: true });
+        const sep = t.precedingWhitespace.length > 0 ? t.precedingWhitespace : " ";
+        parts.push({ kind: "scalar", raw: sep, valueType: "string", pos: { line: t.line, col: t.col }, _separator: true });
       }
       parts.push(node);
     }
@@ -1830,9 +1922,9 @@ var StructureBuilder = class _StructureBuilder {
     const existing = obj.fields.get(head);
     const newVal = this.astToResolverValue(field.value, childPrefix);
     if (existing !== void 0) {
-      const exFolded = foldNestedSelfRefs(existing, childPrefix);
       const oldPrior = obj.priorValues.get(head);
-      const prior = foldOrSkipPrior(exFolded, fullKey, oldPrior);
+      const priorInput = isResObj(existing) ? foldNestedSelfRefs(existing, childPrefix) : existing;
+      const prior = foldOrSkipPrior(priorInput, fullKey, oldPrior);
       if (prior !== void 0) obj.priorValues.set(head, prior);
     }
     if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
@@ -1884,9 +1976,9 @@ var StructureBuilder = class _StructureBuilder {
     const existing = obj.fields.get(head);
     const newVal = await this.astToResolverValueAsync(field.value, childPrefix);
     if (existing !== void 0) {
-      const exFolded = foldNestedSelfRefs(existing, childPrefix);
       const oldPrior = obj.priorValues.get(head);
-      const prior = foldOrSkipPrior(exFolded, fullKey, oldPrior);
+      const priorInput = isResObj(existing) ? foldNestedSelfRefs(existing, childPrefix) : existing;
+      const prior = foldOrSkipPrior(priorInput, fullKey, oldPrior);
       if (prior !== void 0) obj.priorValues.set(head, prior);
     }
     if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
@@ -1909,7 +2001,7 @@ var StructureBuilder = class _StructureBuilder {
         return inner;
       }
       case "subst":
-        return { _kind: "subst-placeholder", segments: ast.segments, optional: ast.optional, listSuffix: ast.listSuffix, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
+        return { _kind: "subst-placeholder", segments: ast.segments, optional: ast.optional, knownAbsent: false, listSuffix: ast.listSuffix, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
       case "concat":
         return { _kind: "concat-placeholder", nodes: ast.nodes.map((n) => this.astToResolverValue(n, pathPrefix)), line: ast.pos.line, col: ast.pos.col };
       case "include":
@@ -1933,7 +2025,7 @@ var StructureBuilder = class _StructureBuilder {
       case "object":
         return await this.buildAsync(ast, pathPrefix);
       case "subst":
-        return { _kind: "subst-placeholder", segments: ast.segments, optional: ast.optional, listSuffix: ast.listSuffix, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
+        return { _kind: "subst-placeholder", segments: ast.segments, optional: ast.optional, knownAbsent: false, listSuffix: ast.listSuffix, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
       case "concat": {
         const nodes = [];
         for (const n of ast.nodes) {
@@ -2051,6 +2143,8 @@ var SubstitutionResolver = class {
     const result = /* @__PURE__ */ new Map();
     for (const [key, val] of obj.fields) {
       this.resolvingFieldPath.push(key);
+      const fullCacheKey = stringSegmentsToKey(this.resolvingFieldPath);
+      this.cache.delete(fullCacheKey);
       let resolved;
       try {
         resolved = this.resolveVal(val, obj);
@@ -2063,28 +2157,42 @@ var SubstitutionResolver = class {
           if (prior !== void 0) {
             const priorResolved = this.resolveVal(prior, obj);
             if (priorResolved !== void 0 && priorResolved.kind === "object") {
-              result.set(
-                key,
-                deepMergeHoconValues(
-                  priorResolved,
-                  resolved
-                )
+              const finalValue = deepMergeHoconValues(
+                priorResolved,
+                resolved
               );
+              result.set(key, finalValue);
+              this.cache.set(fullCacheKey, finalValue);
+              this.cacheDescendants(fullCacheKey, finalValue);
               continue;
             }
           }
         }
         result.set(key, resolved);
+        this.cache.set(fullCacheKey, resolved);
+        this.cacheDescendants(fullCacheKey, resolved);
       } else {
         const prior = obj.priorValues.get(key);
         if (prior !== void 0) {
           const priorResolved = this.resolveVal(prior, obj);
-          if (priorResolved !== void 0) result.set(key, priorResolved);
+          if (priorResolved !== void 0) {
+            result.set(key, priorResolved);
+            this.cache.set(fullCacheKey, priorResolved);
+            this.cacheDescendants(fullCacheKey, priorResolved);
+          }
         }
       }
     }
     return { kind: "object", fields: result };
   }
+  cacheDescendants(prefix, value) {
+    if (value.kind !== "object") return;
+    for (const [key, child] of value.fields) {
+      const childKey = `${prefix}.${stringSegmentsToKey([key])}`;
+      this.cache.set(childKey, child);
+      this.cacheDescendants(childKey, child);
+    }
+  }
   resolveVal(v, scope) {
     if (isSubst(v)) return this.resolveSubst(v, scope);
     if (isConcat(v)) {
@@ -2110,6 +2218,7 @@ var SubstitutionResolver = class {
     return hv;
   }
   resolveSubst(s, scope) {
+    if (s.knownAbsent) return void 0;
     const key = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
     if (this.cache.has(key)) return this.cache.get(key);
     if (this.resolving.has(key)) {
@@ -2202,6 +2311,28 @@ var SubstitutionResolver = class {
         if (result !== void 0) this.cache.set(key, result);
         return result;
       }
+      if (s.prefixLen > 0 && s.segments.length > s.prefixLen) {
+        const originalSegments = s.segments.slice(s.prefixLen);
+        const fallbackFound = lookupPath(this.root, originalSegments);
+        if (fallbackFound !== void 0) {
+          let result = this.resolveVal(fallbackFound, scope);
+          if (originalSegments.length === 1 && result !== void 0 && result.kind === "object") {
+            const rootSeg = originalSegments[0]?.text ?? "";
+            const prior = this.root.priorValues.get(rootSeg);
+            if (prior !== void 0) {
+              const priorResolved = this.resolveVal(prior, scope);
+              if (priorResolved !== void 0 && priorResolved.kind === "object") {
+                result = deepMergeHoconValues(
+                  priorResolved,
+                  result
+                );
+              }
+            }
+          }
+          if (result !== void 0) this.cache.set(key, result);
+          return result;
+        }
+      }
       if (s.listSuffix && this.opts.useSystemEnvironment !== false) {
         const result = this.resolveEnvList(s);
         if (result !== void 0) {

package/dist/zod.d.cts

@@ -1,5 +1,5 @@
 import { ZodType } from 'zod';
-import { C as Config, a as ParseOptions } from './config-BwjvKeZ5.cjs';
+import { C as Config, a as ParseOptions } from './config-CjSkQ4_l.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, a as ParseOptions } from './config-BwjvKeZ5.js';
+import { C as Config, a as ParseOptions } from './config-CjSkQ4_l.js';
 
 declare function validate<T>(config: Config, schema: ZodType<T>): T;
 declare function getValidated<T>(config: Config, path: string, schema: ZodType<T>): T;