@ls-stack/utils 3.24.1 → 3.25.0

package/lib/testUtils.cjs

@@ -131,6 +131,239 @@ function deepEqual(foo, bar, maxDepth = 20) {
   return foo !== foo && bar !== bar;
 }
 
+// src/filterObjectOrArrayKeys.ts
+function filterObjectOrArrayKeys(objOrArray, {
+  filterKeys,
+  rejectKeys,
+  rejectEmptyObjectsInArray = true
+}) {
+  const toArray = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
+  const filterPatternsRaw = toArray(filterKeys);
+  const rejectPatternsRaw = toArray(rejectKeys);
+  const hasFilters = filterPatternsRaw.length > 0;
+  const hasRejects = rejectPatternsRaw.length > 0;
+  function parsePattern(pattern) {
+    const tokens = [];
+    let i = 0;
+    const n = pattern.length;
+    const pushKey = (name) => {
+      if (name.length === 0) return;
+      tokens.push({ type: "KEY", name });
+    };
+    while (i < n) {
+      const ch = pattern[i];
+      if (ch === ".") {
+        i += 1;
+        continue;
+      }
+      if (ch === "[") {
+        const end = pattern.indexOf("]", i + 1);
+        const inside = end === -1 ? pattern.slice(i + 1) : pattern.slice(i + 1, end);
+        if (inside === "*") {
+          tokens.push({ type: "INDEX_ANY" });
+        } else if (inside.includes("-")) {
+          const parts = inside.split("-");
+          const startStr = parts[0] ?? "";
+          const endStr = parts[1] ?? "";
+          const start = parseInt(startStr, 10);
+          const endNum = endStr === "*" ? null : parseInt(endStr, 10);
+          tokens.push({
+            type: "INDEX_RANGE",
+            start,
+            end: endNum === null || Number.isFinite(endNum) ? endNum : null
+          });
+        } else if (inside.length > 0) {
+          const idx = parseInt(inside, 10);
+          tokens.push({ type: "INDEX", index: idx });
+        }
+        i = end === -1 ? n : end + 1;
+        continue;
+      }
+      if (ch === "*") {
+        if (pattern[i + 1] === "*") {
+          tokens.push({ type: "WILDCARD_ANY" });
+          i += 2;
+          let j2 = i;
+          while (j2 < n) {
+            const c = pattern[j2];
+            if (c === "." || c === "[") break;
+            j2 += 1;
+          }
+          if (j2 > i) {
+            pushKey(pattern.slice(i, j2));
+            i = j2;
+          }
+          continue;
+        } else {
+          tokens.push({ type: "WILDCARD_ONE" });
+          i += 1;
+          continue;
+        }
+      }
+      let j = i;
+      while (j < n) {
+        const c = pattern[j];
+        if (c === "." || c === "[") break;
+        j += 1;
+      }
+      pushKey(pattern.slice(i, j));
+      i = j;
+    }
+    return tokens;
+  }
+  const filterPatterns = filterPatternsRaw.map(parsePattern);
+  const rejectPatterns = rejectPatternsRaw.map(parsePattern);
+  function matchPath(path, pattern) {
+    function rec(pi, pti) {
+      if (pti >= pattern.length) return pi === path.length;
+      const pt = pattern[pti];
+      if (pt.type === "WILDCARD_ANY") {
+        if (rec(pi, pti + 1)) return true;
+        if (pi < path.length) return rec(pi + 1, pti);
+        return false;
+      }
+      if (pt.type === "WILDCARD_ONE") {
+        let j = pi;
+        let sawKey = false;
+        while (j < path.length) {
+          if (path[j].type === "KEY") sawKey = true;
+          if (sawKey && rec(j, pti + 1)) return true;
+          j += 1;
+        }
+        return false;
+      }
+      if (pi >= path.length) return false;
+      const ct = path[pi];
+      switch (pt.type) {
+        case "KEY":
+          if (ct.type === "KEY" && ct.name === pt.name)
+            return rec(pi + 1, pti + 1);
+          if (ct.type === "INDEX") return rec(pi + 1, pti);
+          return false;
+        case "INDEX":
+          if (ct.type === "INDEX" && ct.index === pt.index)
+            return rec(pi + 1, pti + 1);
+          return false;
+        case "INDEX_ANY":
+          if (ct.type === "INDEX") return rec(pi + 1, pti + 1);
+          return false;
+        case "INDEX_RANGE":
+          if (ct.type === "INDEX") {
+            const okLower = ct.index >= pt.start;
+            const okUpper = pt.end === null ? true : ct.index <= pt.end;
+            if (okLower && okUpper) return rec(pi + 1, pti + 1);
+          }
+          return false;
+      }
+    }
+    return rec(0, 0);
+  }
+  const matchesAnyFilter = (path) => filterPatterns.some((p) => matchPath(path, p));
+  const matchesAnyReject = (path) => rejectPatterns.some((p) => matchPath(path, p));
+  const build = (value, path, allowedByFilter, stack2, isRoot, parentIsArray) => {
+    if (Array.isArray(value)) {
+      if (stack2.has(value)) {
+        throw new TypeError("Circular references are not supported");
+      }
+      stack2.add(value);
+      const out = [];
+      const includeAllChildren = allowedByFilter || !hasFilters;
+      for (let index = 0; index < value.length; index += 1) {
+        const childPath = path.concat({ type: "INDEX", index });
+        if (hasRejects && matchesAnyReject(childPath)) continue;
+        const child = value[index];
+        const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
+        const childAllowed = includeAllChildren || directInclude;
+        if (isPlainObject(child) || Array.isArray(child)) {
+          const builtChild = build(
+            child,
+            childPath,
+            childAllowed,
+            stack2,
+            false,
+            true
+          );
+          if (builtChild !== void 0) {
+            out.push(builtChild);
+          }
+        } else {
+          if (childAllowed) {
+            out.push(child);
+          }
+        }
+      }
+      stack2.delete(value);
+      const filteredOut = rejectEmptyObjectsInArray ? out.filter(
+        (item) => !(isPlainObject(item) && Object.keys(item).length === 0)
+      ) : out;
+      if (filteredOut.length === 0 && !allowedByFilter && !isRoot)
+        return void 0;
+      return filteredOut;
+    }
+    if (isPlainObject(value)) {
+      if (stack2.has(value)) {
+        throw new TypeError("Circular references are not supported");
+      }
+      stack2.add(value);
+      const result = {};
+      const includeAllChildren = allowedByFilter || !hasFilters;
+      for (const key of Object.keys(value)) {
+        const childPath = path.concat({ type: "KEY", name: key });
+        if (hasRejects && matchesAnyReject(childPath)) continue;
+        const val = value[key];
+        const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
+        const childAllowed = includeAllChildren || directInclude;
+        if (isPlainObject(val) || Array.isArray(val)) {
+          const builtChild = build(
+            val,
+            childPath,
+            childAllowed,
+            stack2,
+            false,
+            false
+          );
+          if (builtChild === void 0) {
+            continue;
+          }
+          if (Array.isArray(builtChild) && builtChild.length === 0 && !childAllowed) {
+            continue;
+          }
+          if (isPlainObject(builtChild) && Object.keys(builtChild).length === 0 && !childAllowed) {
+            continue;
+          }
+          result[key] = builtChild;
+        } else {
+          if (childAllowed) {
+            result[key] = val;
+          }
+        }
+      }
+      stack2.delete(value);
+      if (Object.keys(result).length === 0 && !allowedByFilter && !isRoot) {
+        if (parentIsArray && !rejectEmptyObjectsInArray) {
+          return {};
+        }
+        return void 0;
+      }
+      return result;
+    }
+    return allowedByFilter || !hasFilters ? value : void 0;
+  };
+  const startPath = [];
+  const initialAllowed = !hasFilters;
+  const stack = /* @__PURE__ */ new WeakSet();
+  const built = build(
+    objOrArray,
+    startPath,
+    initialAllowed,
+    stack,
+    true,
+    false
+  );
+  if (built === void 0) return Array.isArray(objOrArray) ? [] : {};
+  return built;
+}
+
 // src/mathUtils.ts
 function clampMin(value, min) {
   return value < min ? min : value;
@@ -197,12 +430,12 @@ function yamlStringify(obj, {
   addRootObjSpaces = "beforeAndAfter"
 } = {}) {
   if (isObject(obj) || Array.isArray(obj) || typeof obj === "function") {
-    return `${stringifyValue(obj, "", maxLineLength, !!showUndefined, maxDepth, 0, collapseObjects, addRootObjSpaces)}
+    return `${stringifyValue(obj, "", maxLineLength, !!showUndefined, maxDepth, 0, collapseObjects, addRootObjSpaces, false)}
 `;
   }
   return JSON.stringify(obj) || "undefined";
 }
-function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, depth, collapseObjects, addObjSpaces) {
+function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, depth, collapseObjects, addObjSpaces, isArrayItem) {
   let result = "";
   const childIndent = `${indent}  `;
   if (isPlainObject(value)) {
@@ -221,7 +454,8 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
           return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
         }
       );
-      if (isSimpleObject && entries.length > 0) {
+      const shouldCollapse = isArrayItem ? entries.length > 1 : entries.length > 0;
+      if (isSimpleObject && shouldCollapse) {
         let line = "{ ";
         line += entries.map(([key, val]) => {
           let valueStr;
@@ -268,20 +502,29 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
         maxDepth,
         depth + 1,
         collapseObjects,
-        addObjSpaces
+        addObjSpaces,
+        false
       );
-      const willBeCollapsed = isObject(objVal) && (Object.keys(objVal).length === 0 || collapseObjects && depth + 1 > 0 && Object.entries(objVal).filter(([, val]) => val !== void 0 || showUndefined).every(([, val]) => {
-        if (typeof val === "string") {
-          return !val.includes("'") && !val.includes('"') && !val.includes("\\");
-        }
-        return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
-      }));
-      const prevWasCollapsed = prevValue && isObject(prevValue) && (Object.keys(prevValue).length === 0 || collapseObjects && depth + 1 > 0 && Object.entries(prevValue).filter(([, val]) => val !== void 0 || showUndefined).every(([, val]) => {
-        if (typeof val === "string") {
-          return !val.includes("'") && !val.includes('"') && !val.includes("\\");
-        }
-        return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
-      }));
+      const willBeCollapsed = isObject(objVal) && (Object.keys(objVal).length === 0 || collapseObjects && depth + 1 > 0 && (() => {
+        const filteredEntries = Object.entries(objVal).filter(([, val]) => val !== void 0 || showUndefined);
+        const shouldCollapseThis = isArrayItem ? filteredEntries.length > 1 : filteredEntries.length > 0;
+        return shouldCollapseThis && filteredEntries.every(([, val]) => {
+          if (typeof val === "string") {
+            return !val.includes("'") && !val.includes('"') && !val.includes("\\");
+          }
+          return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
+        });
+      })());
+      const prevWasCollapsed = prevValue && isObject(prevValue) && (Object.keys(prevValue).length === 0 || collapseObjects && depth + 1 > 0 && (() => {
+        const filteredEntries = Object.entries(prevValue).filter(([, val]) => val !== void 0 || showUndefined);
+        const shouldCollapseThis = isArrayItem ? filteredEntries.length > 1 : filteredEntries.length > 0;
+        return shouldCollapseThis && filteredEntries.every(([, val]) => {
+          if (typeof val === "string") {
+            return !val.includes("'") && !val.includes('"') && !val.includes("\\");
+          }
+          return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
+        });
+      })());
       if (!afterSpaceWasAdded && indent === "" && isObject(objVal) && !willBeCollapsed && prevValue && !prevWasCollapsed && (addObjSpaces === "before" || addObjSpaces === "beforeAndAfter")) {
         result += "\n";
       }
@@ -344,7 +587,8 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
           maxDepth,
           depth + 1,
           collapseObjects,
-          addObjSpaces
+          addObjSpaces,
+          true
         );
       }).join(", ");
       line += "]";
@@ -368,7 +612,8 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
             maxDepth,
             depth + 1,
             collapseObjects,
-            addObjSpaces
+            addObjSpaces,
+            true
           );
           arrayString = arrayString.trimStart();
           result += arrayString;
@@ -381,7 +626,8 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
             maxDepth,
             depth + 1,
             collapseObjects,
-            addObjSpaces
+            addObjSpaces,
+            true
           );
         }
         result += "\n";
@@ -435,7 +681,8 @@ ${indent}${line}
       maxDepth,
       depth + 1,
       collapseObjects,
-      addObjSpaces
+      addObjSpaces,
+      false
     );
   }
   return JSON.stringify(value);
@@ -753,126 +1000,6 @@ function waitController() {
     }
   };
 }
-function matchesKeyPattern(fullPath, key, pattern, currentPath) {
-  if (fullPath === pattern) {
-    return true;
-  }
-  if (pattern.startsWith("*.")) {
-    const propName = pattern.slice(2);
-    return currentPath !== "" && key === propName;
-  }
-  if (pattern.startsWith("*") && !pattern.startsWith("*.")) {
-    const propName = pattern.slice(1);
-    return key === propName;
-  }
-  if (!pattern.includes("*")) {
-    return currentPath === "" && key === pattern;
-  }
-  return false;
-}
-function isParentOfPattern(path, pattern) {
-  if (pattern.includes("*")) {
-    const patternParts = pattern.split(".");
-    const pathParts = path.split(".");
-    if (pathParts.length >= patternParts.length) {
-      return false;
-    }
-    for (let i = 0; i < pathParts.length; i++) {
-      const pathPart = pathParts[i];
-      const patternPart = patternParts[i];
-      if (patternPart === "*") {
-        continue;
-      }
-      if (pathPart !== patternPart) {
-        return false;
-      }
-    }
-    return true;
-  } else {
-    return pattern.startsWith(`${path}.`);
-  }
-}
-function applyKeyFiltering(value, { rejectKeys, filterKeys }, currentPath = "", visited = /* @__PURE__ */ new Set()) {
-  if (!isPlainObject(value) && !Array.isArray(value)) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    if (visited.has(value)) {
-      throw new Error(
-        "Circular reference detected in array during key filtering"
-      );
-    }
-    visited.add(value);
-    try {
-      return value.map(
-        (item, index) => applyKeyFiltering(
-          item,
-          { rejectKeys, filterKeys },
-          currentPath ? `${currentPath}[${index}]` : `[${index}]`,
-          visited
-        )
-      );
-    } finally {
-      visited.delete(value);
-    }
-  }
-  if (isPlainObject(value)) {
-    if (visited.has(value)) {
-      throw new Error(
-        "Circular reference detected in object during key filtering"
-      );
-    }
-    visited.add(value);
-    try {
-      const result = {};
-      for (const [key, itemValue] of Object.entries(value)) {
-        const fullPath = currentPath ? `${currentPath}.${key}` : key;
-        if (rejectKeys?.some(
-          (rejectPath) => matchesKeyPattern(fullPath, key, rejectPath, currentPath)
-        )) {
-          continue;
-        }
-        if (filterKeys) {
-          const exactMatch = filterKeys.some(
-            (filterPath) => matchesKeyPattern(fullPath, key, filterPath, currentPath)
-          );
-          const isParent = filterKeys.some(
-            (filterPath) => isParentOfPattern(fullPath, filterPath)
-          );
-          if (!exactMatch && !isParent) {
-            continue;
-          }
-          if (exactMatch) {
-            result[key] = applyKeyFiltering(
-              itemValue,
-              { rejectKeys },
-              fullPath,
-              visited
-            );
-          } else {
-            result[key] = applyKeyFiltering(
-              itemValue,
-              { rejectKeys, filterKeys },
-              fullPath,
-              visited
-            );
-          }
-        } else {
-          result[key] = applyKeyFiltering(
-            itemValue,
-            { rejectKeys, filterKeys },
-            fullPath,
-            visited
-          );
-        }
-      }
-      return result;
-    } finally {
-      visited.delete(value);
-    }
-  }
-  return value;
-}
 function compactSnapshot(value, {
   collapseObjects = true,
   maxLineLength = 100,
@@ -884,10 +1011,12 @@ function compactSnapshot(value, {
 } = {}) {
   let processedValue = value;
   if (rejectKeys || filterKeys) {
-    processedValue = applyKeyFiltering(processedValue, {
-      rejectKeys: Array.isArray(rejectKeys) ? rejectKeys : rejectKeys ? [rejectKeys] : void 0,
-      filterKeys: Array.isArray(filterKeys) ? filterKeys : filterKeys ? [filterKeys] : void 0
-    });
+    if (isPlainObject(processedValue) || Array.isArray(processedValue)) {
+      processedValue = filterObjectOrArrayKeys(processedValue, {
+        rejectKeys,
+        filterKeys
+      });
+    }
   }
   processedValue = showBooleansAs ? replaceBooleansWithEmoji(processedValue, showBooleansAs) : processedValue;
   return `

package/lib/testUtils.d.cts

@@ -41,6 +41,46 @@ declare function waitController(): {
     stopWaiting: () => void;
     stopWaitingAfter: (ms: number) => void;
 };
+/**
+ * Produces a more compact and readable snapshot of a value using yaml.
+ * By default booleans are shown as `✅` and `❌`, use `showBooleansAs` to disable/configure this.
+ *
+ * Filtering patterns in `rejectKeys` and `filterKeys`:
+ * - `'prop'` - Only root-level properties named 'prop'
+ * - `'**prop'` - Any property named exactly 'prop' at any level (root or nested)
+ * - `'*.prop'` - Any nested property named 'prop' at second level (excludes root-level matches)
+ * - `'test.*.prop'` - Any property named 'prop' at second level of 'test'
+ * - `'test.*.test.**prop'` - Any property named 'prop' inside of 'test.*.test'
+ * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
+ * - `'prop.**nested'` - All nested properties inside root `prop` with name `nested`
+ * - `'prop[0]'` - The first item of the `prop` array
+ * - `'prop[*]'` - All items of the `prop` array
+ * - `'prop[0].nested'` - `nested` prop of the first item of the `prop` array
+ * - `'prop[*].nested'` - `nested` prop of all items of the `prop` array
+ * - `'prop[*]**nested'` - all `nested` props of all items of the `prop` array
+ * - `'prop[0-2]'` - The first three items of the `prop` array
+ * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the end
+ * - `'prop[0-2].nested.**prop'` - Combining multiple nested patterns is supported
+ * - Root array:
+ *   - `'[0]'` - The first item of the root array
+ *   - `'[*]'` - All items of the array
+ *   - `'[0].nested'` - `nested` prop of the first item of the array
+ *   - `'[*].nested'` - `nested` prop of all items of the array
+ *   - `'[*]**nested'` - all `nested` props of all items of the array
+ *   - `'[0-2]'` - The first three items of the array
+ *   - `'[4-*]'` - All items of the array from the fourth index to the end
+ *
+ * @param value - The value to snapshot.
+ * @param options - The options for the snapshot.
+ * @param options.collapseObjects - Whether to collapse objects into a single line.
+ * @param options.maxLineLength - The maximum length of a line.
+ * @param options.showUndefined - Whether to show undefined values.
+ * @param options.showBooleansAs - Whether to show booleans as text, by default true is `✅` and false is `❌`
+ * @param options.rejectKeys - The keys to reject.
+ * @param options.filterKeys - The keys to filter.
+ * @param options.ignoreProps - The props to ignore.
+ * @returns The compact snapshot of the value.
+ */
 declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLength, showUndefined, showBooleansAs, rejectKeys, filterKeys, ...options }?: YamlStringifyOptions & {
     showBooleansAs?: boolean | {
         props?: Record<string, {
@@ -54,12 +94,6 @@ declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLengt
     /**
      * Reject (exclude) keys from the snapshot using pattern matching.
      *
-     * **Pattern Syntax:**
-     * - `'prop'` - Only root-level properties named 'prop'
-     * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
-     * - `'*prop'` - Any property named exactly 'prop' at any level (root or nested)
-     * - `'*.prop'` - Any nested property named 'prop' (excludes root-level matches)
-     *
      * **Examples:**
      * ```typescript
      * // Reject root-level 'secret' only
@@ -79,12 +113,6 @@ declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLengt
     /**
      * Filter (include only) keys that match the specified patterns.
      *
-     * **Pattern Syntax:** (same as rejectKeys)
-     * - `'prop'` - Only root-level properties named 'prop'
-     * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
-     * - `'*prop'` - Any property named exactly 'prop' at any level (root or nested)
-     * - `'*.prop'` - Any nested property named 'prop' (excludes root-level matches)
-     *
      * **Examples:**
      * ```typescript
      * // Include only root-level 'user'

package/lib/testUtils.d.ts

@@ -41,6 +41,46 @@ declare function waitController(): {
     stopWaiting: () => void;
     stopWaitingAfter: (ms: number) => void;
 };
+/**
+ * Produces a more compact and readable snapshot of a value using yaml.
+ * By default booleans are shown as `✅` and `❌`, use `showBooleansAs` to disable/configure this.
+ *
+ * Filtering patterns in `rejectKeys` and `filterKeys`:
+ * - `'prop'` - Only root-level properties named 'prop'
+ * - `'**prop'` - Any property named exactly 'prop' at any level (root or nested)
+ * - `'*.prop'` - Any nested property named 'prop' at second level (excludes root-level matches)
+ * - `'test.*.prop'` - Any property named 'prop' at second level of 'test'
+ * - `'test.*.test.**prop'` - Any property named 'prop' inside of 'test.*.test'
+ * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
+ * - `'prop.**nested'` - All nested properties inside root `prop` with name `nested`
+ * - `'prop[0]'` - The first item of the `prop` array
+ * - `'prop[*]'` - All items of the `prop` array
+ * - `'prop[0].nested'` - `nested` prop of the first item of the `prop` array
+ * - `'prop[*].nested'` - `nested` prop of all items of the `prop` array
+ * - `'prop[*]**nested'` - all `nested` props of all items of the `prop` array
+ * - `'prop[0-2]'` - The first three items of the `prop` array
+ * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the end
+ * - `'prop[0-2].nested.**prop'` - Combining multiple nested patterns is supported
+ * - Root array:
+ *   - `'[0]'` - The first item of the root array
+ *   - `'[*]'` - All items of the array
+ *   - `'[0].nested'` - `nested` prop of the first item of the array
+ *   - `'[*].nested'` - `nested` prop of all items of the array
+ *   - `'[*]**nested'` - all `nested` props of all items of the array
+ *   - `'[0-2]'` - The first three items of the array
+ *   - `'[4-*]'` - All items of the array from the fourth index to the end
+ *
+ * @param value - The value to snapshot.
+ * @param options - The options for the snapshot.
+ * @param options.collapseObjects - Whether to collapse objects into a single line.
+ * @param options.maxLineLength - The maximum length of a line.
+ * @param options.showUndefined - Whether to show undefined values.
+ * @param options.showBooleansAs - Whether to show booleans as text, by default true is `✅` and false is `❌`
+ * @param options.rejectKeys - The keys to reject.
+ * @param options.filterKeys - The keys to filter.
+ * @param options.ignoreProps - The props to ignore.
+ * @returns The compact snapshot of the value.
+ */
 declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLength, showUndefined, showBooleansAs, rejectKeys, filterKeys, ...options }?: YamlStringifyOptions & {
     showBooleansAs?: boolean | {
         props?: Record<string, {
@@ -54,12 +94,6 @@ declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLengt
     /**
      * Reject (exclude) keys from the snapshot using pattern matching.
      *
-     * **Pattern Syntax:**
-     * - `'prop'` - Only root-level properties named 'prop'
-     * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
-     * - `'*prop'` - Any property named exactly 'prop' at any level (root or nested)
-     * - `'*.prop'` - Any nested property named 'prop' (excludes root-level matches)
-     *
      * **Examples:**
      * ```typescript
      * // Reject root-level 'secret' only
@@ -79,12 +113,6 @@ declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLengt
     /**
      * Filter (include only) keys that match the specified patterns.
      *
-     * **Pattern Syntax:** (same as rejectKeys)
-     * - `'prop'` - Only root-level properties named 'prop'
-     * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
-     * - `'*prop'` - Any property named exactly 'prop' at any level (root or nested)
-     * - `'*.prop'` - Any nested property named 'prop' (excludes root-level matches)
-     *
      * **Examples:**
      * ```typescript
      * // Include only root-level 'user'