@typia/utils 13.0.0-dev.20260427-3 → 13.0.0-dev.20260430

package/lib/utils/internal/stringifyValidationFailure2.mjs

@@ -1,41 +1,38 @@
-import { __exports as stringifyValidationFailure } from '../../_virtual/stringifyValidationFailure.mjs';
-import { __require as requireNamingConvention } from '../NamingConvention2.mjs';
-import { __require as requireDedent } from '../dedent2.mjs';
+import { __exports as stringifyValidationFailure$1 } from '../../_virtual/stringifyValidationFailure.mjs';
+import '../NamingConvention2.mjs';
+import '../dedent2.mjs';
+import { __exports as dedent } from '../../_virtual/dedent.mjs';
+import { __exports as NamingConvention } from '../../_virtual/NamingConvention.mjs';
 
-var hasRequiredStringifyValidationFailure;
-
-function requireStringifyValidationFailure () {
-	if (hasRequiredStringifyValidationFailure) return stringifyValidationFailure;
-	hasRequiredStringifyValidationFailure = 1;
-	Object.defineProperty(stringifyValidationFailure, "__esModule", { value: true });
-	stringifyValidationFailure.stringifyValidationFailure = stringifyValidationFailure$1;
-	const NamingConvention_1 = requireNamingConvention();
-	const dedent_1 = requireDedent();
-	function stringifyValidationFailure$1(failure) {
-	    const usedErrors = new Set();
-	    // Pre-index errors by path for O(1) lookup
-	    const errorsByPath = new Map();
-	    for (const e of failure.errors) {
-	        const arr = errorsByPath.get(e.path);
-	        if (arr !== undefined)
-	            arr.push(e);
-	        else
-	            errorsByPath.set(e.path, [e]);
-	    }
-	    const jsonOutput = stringify({
-	        value: failure.data,
-	        errorsByPath,
-	        path: "$input",
-	        tab: 0,
-	        inArray: false,
-	        inToJson: false,
-	        usedErrors,
-	    });
-	    // Find errors that couldn't be embedded
-	    const unmappableErrors = failure.errors.filter((e) => !usedErrors.has(e));
-	    // If there are unmappable errors, append them as a separate block
-	    if (unmappableErrors.length > 0)
-	        return (0, dedent_1.dedent) `
+Object.defineProperty(stringifyValidationFailure$1, "__esModule", { value: true });
+var stringifyValidationFailure_2 = stringifyValidationFailure$1.stringifyValidationFailure = stringifyValidationFailure;
+const NamingConvention_1 = NamingConvention;
+const dedent_1 = dedent;
+function stringifyValidationFailure(failure) {
+    const usedErrors = new Set();
+    // Pre-index errors by path for O(1) lookup
+    const errorsByPath = new Map();
+    for (const e of failure.errors) {
+        const arr = errorsByPath.get(e.path);
+        if (arr !== undefined)
+            arr.push(e);
+        else
+            errorsByPath.set(e.path, [e]);
+    }
+    const jsonOutput = stringify({
+        value: failure.data,
+        errorsByPath,
+        path: "$input",
+        tab: 0,
+        inArray: false,
+        inToJson: false,
+        usedErrors,
+    });
+    // Find errors that couldn't be embedded
+    const unmappableErrors = failure.errors.filter((e) => !usedErrors.has(e));
+    // If there are unmappable errors, append them as a separate block
+    if (unmappableErrors.length > 0)
+        return (0, dedent_1.dedent) `
       \`\`\`json
       ${jsonOutput}
       \`\`\`
@@ -45,289 +42,286 @@ function requireStringifyValidationFailure () {
       ${JSON.stringify(unmappableErrors, null, 2)}
       \`\`\`
     `;
-	    return (0, dedent_1.dedent) `
+    return (0, dedent_1.dedent) `
     \`\`\`json
     ${jsonOutput}
     \`\`\`
   `;
-	}
-	function stringify(props) {
-	    var _a;
-	    const { value, errorsByPath, path, tab, inArray, inToJson, usedErrors } = props;
-	    const indent = "  ".repeat(tab);
-	    const errorComment = getErrorComment(path, errorsByPath, usedErrors);
-	    // Handle undefined in arrays
-	    if (inArray && value === undefined) {
-	        return `${indent}undefined${errorComment}`;
-	    }
-	    // Array
-	    if (Array.isArray(value)) {
-	        // Check for missing array element errors (path[])
-	        const missingElementErrors = getMissingArrayElementErrors(path, errorsByPath, usedErrors);
-	        const hasMissingElements = missingElementErrors.length > 0;
-	        if (value.length === 0) {
-	            // Empty array but has missing element errors - show placeholders
-	            if (hasMissingElements) {
-	                const innerIndent = "  ".repeat(tab + 1);
-	                const lines = [];
-	                lines.push(`${indent}[${errorComment}`);
-	                missingElementErrors.forEach((e, idx) => {
-	                    const errComment = ` // ❌ ${JSON.stringify([{ path: e.path, expected: e.expected, description: e.description }])}`;
-	                    const comma = idx < missingElementErrors.length - 1 ? "," : "";
-	                    lines.push(`${innerIndent}undefined${comma}${errComment}`);
-	                });
-	                lines.push(`${indent}]`);
-	                return lines.join("\n");
-	            }
-	            return `${indent}[]${errorComment}`;
-	        }
-	        const lines = [];
-	        lines.push(`${indent}[${errorComment}`);
-	        value.forEach((item, index) => {
-	            const itemPath = `${path}[${index}]`;
-	            const isLastElement = index === value.length - 1;
-	            // If there are missing element errors, this is not truly the last line
-	            const needsComma = !isLastElement || hasMissingElements;
-	            let itemStr = stringify({
-	                value: item,
-	                errorsByPath,
-	                path: itemPath,
-	                tab: tab + 1,
-	                inArray: true,
-	                inToJson: false,
-	                usedErrors,
-	            });
-	            // Add comma before the error comment if not the last element
-	            if (needsComma) {
-	                itemStr = insertCommaBeforeComment(itemStr);
-	            }
-	            lines.push(itemStr);
-	        });
-	        // Add missing element placeholders at the end for each [] error
-	        if (hasMissingElements) {
-	            const innerIndent = "  ".repeat(tab + 1);
-	            missingElementErrors.forEach((e, idx) => {
-	                const errComment = ` // ❌ ${JSON.stringify([{ path: e.path, expected: e.expected, description: e.description }])}`;
-	                const comma = idx < missingElementErrors.length - 1 ? "," : "";
-	                lines.push(`${innerIndent}undefined${comma}${errComment}`);
-	            });
-	        }
-	        lines.push(`${indent}]`);
-	        return lines.join("\n");
-	    }
-	    // Object
-	    if (typeof value === "object" && value !== null) {
-	        // Check for toJSON method
-	        // biome-ignore lint: intended
-	        if (!inToJson && typeof value.toJSON === "function") {
-	            // biome-ignore lint: intended
-	            const jsonValue = value.toJSON();
-	            return stringify({
-	                value: jsonValue,
-	                errorsByPath,
-	                path,
-	                tab,
-	                inArray,
-	                inToJson: true,
-	                usedErrors,
-	            });
-	        }
-	        // Get all entries from the object (including undefined values that have errors)
-	        const allEntries = Object.entries(value);
-	        // Split into defined and undefined entries
-	        const definedEntries = allEntries.filter(([_, val]) => val !== undefined);
-	        const undefinedEntryKeys = new Set(allEntries.filter(([_, val]) => val === undefined).map(([key]) => key));
-	        // Find missing properties that have validation errors (not in object at all)
-	        const missingKeys = getMissingProperties(path, value, errorsByPath);
-	        // Combine: defined entries + undefined entries with errors + missing properties
-	        const undefinedKeysWithErrors = Array.from(undefinedEntryKeys).filter((key) => {
-	            const propPath = NamingConvention_1.NamingConvention.variable(key)
-	                ? `${path}.${key}`
-	                : `${path}[${JSON.stringify(key)}]`;
-	            return hasErrorsAtOrUnder(propPath, errorsByPath);
-	        });
-	        const allKeys = [
-	            ...definedEntries.map(([key]) => key),
-	            ...undefinedKeysWithErrors,
-	            ...missingKeys,
-	        ];
-	        if (allKeys.length === 0) {
-	            return `${indent}{}${errorComment}`;
-	        }
-	        const lines = [];
-	        lines.push(`${indent}{${errorComment}`);
-	        allKeys.forEach((key, index, array) => {
-	            const propPath = NamingConvention_1.NamingConvention.variable(key)
-	                ? `${path}.${key}`
-	                : `${path}[${JSON.stringify(key)}]`;
-	            const propIndent = "  ".repeat(tab + 1);
-	            // Get the value (undefined for missing properties or undefined entries)
-	            const val = missingKeys.includes(key) || undefinedKeysWithErrors.includes(key)
-	                ? undefined
-	                : // biome-ignore lint: intended
-	                    value[key];
-	            // Primitive property value (including undefined for missing properties)
-	            if (val === undefined ||
-	                val === null ||
-	                typeof val === "boolean" ||
-	                typeof val === "number" ||
-	                typeof val === "string") {
-	                const propErrorComment = getErrorComment(propPath, errorsByPath, usedErrors);
-	                const keyStr = JSON.stringify(key);
-	                const valueStr = val === undefined
-	                    ? `${propIndent}${keyStr}: undefined`
-	                    : `${propIndent}${keyStr}: ${JSON.stringify(val)}`;
-	                const withComma = index < array.length - 1 ? `${valueStr},` : valueStr;
-	                const line = withComma + propErrorComment;
-	                lines.push(line);
-	            }
-	            // Complex property value (object or array)
-	            else {
-	                const keyLine = `${propIndent}${JSON.stringify(key)}: `;
-	                let valStr = stringify({
-	                    value: val,
-	                    errorsByPath,
-	                    path: propPath,
-	                    tab: tab + 1,
-	                    inArray: false,
-	                    inToJson: false,
-	                    usedErrors,
-	                });
-	                const valStrWithoutIndent = valStr.trimStart();
-	                // Add comma before the error comment if not the last property
-	                if (index < array.length - 1) {
-	                    valStr = insertCommaBeforeComment(valStrWithoutIndent);
-	                }
-	                else {
-	                    valStr = valStrWithoutIndent;
-	                }
-	                const combined = keyLine + valStr;
-	                lines.push(combined);
-	            }
-	        });
-	        lines.push(`${indent}}`);
-	        return lines.join("\n");
-	    }
-	    // Primitive types (null, boolean, number, string, undefined, etc.)
-	    const valStr = value === undefined
-	        ? "undefined"
-	        : ((_a = JSON.stringify(value)) !== null && _a !== void 0 ? _a : String(value));
-	    return `${indent}${valStr}${errorComment}`;
-	}
-	/** Insert comma before inline error comment on the last line */
-	function insertCommaBeforeComment(str) {
-	    const lines = str.split("\n");
-	    const lastLine = lines[lines.length - 1];
-	    // Use specific error marker to avoid false positives with values containing " //"
-	    const commentIndex = lastLine.lastIndexOf(" // ❌");
-	    if (commentIndex !== -1) {
-	        lines[lines.length - 1] = `${lastLine.slice(0, commentIndex)},${lastLine.slice(commentIndex)}`;
-	    }
-	    else {
-	        lines[lines.length - 1] += ",";
-	    }
-	    return lines.join("\n");
-	}
-	/** Get error comment for a given path */
-	function getErrorComment(path, errorsByPath, usedErrors) {
-	    const pathErrors = errorsByPath.get(path);
-	    if (pathErrors === undefined || pathErrors.length === 0) {
-	        return "";
-	    }
-	    // Mark these errors as used
-	    pathErrors.forEach((e) => usedErrors.add(e));
-	    return ` // ❌ ${JSON.stringify(pathErrors.map((e) => ({
-	        path: e.path,
-	        expected: e.expected,
-	        description: e.description,
-	    })))}`;
-	}
-	/**
-	 * Check if there are missing array element errors (path ending with []) Returns
-	 * an array of error objects, one per missing element
-	 */
-	function getMissingArrayElementErrors(path, errorsByPath, usedErrors) {
-	    var _a;
-	    const wildcardPath = `${path}[]`;
-	    const missingErrors = (_a = errorsByPath.get(wildcardPath)) !== null && _a !== void 0 ? _a : [];
-	    // Mark these errors as used
-	    missingErrors.forEach((e) => usedErrors.add(e));
-	    return missingErrors;
-	}
-	/** Check if any errors exist at or under the given path prefix */
-	function hasErrorsAtOrUnder(pathPrefix, errorsByPath) {
-	    for (const errorPath of errorsByPath.keys()) {
-	        if (errorPath === pathPrefix ||
-	            errorPath.startsWith(pathPrefix + ".") ||
-	            errorPath.startsWith(pathPrefix + "[")) {
-	            return true;
-	        }
-	    }
-	    return false;
-	}
-	/**
-	 * Find missing properties that have validation errors but don't exist in the
-	 * data Returns array of property keys that should be displayed as undefined
-	 */
-	function getMissingProperties(path, value, errorsByPath) {
-	    const missingKeys = new Set();
-	    for (const errorPath of errorsByPath.keys()) {
-	        // Check if error.path is a direct child of current path
-	        const childKey = extractDirectChildKey(path, errorPath);
-	        if (childKey !== null) {
-	            // Check if this property actually exists in the value
-	            if (!(childKey in value)) {
-	                missingKeys.add(childKey);
-	            }
-	        }
-	    }
-	    return Array.from(missingKeys);
-	}
-	/**
-	 * Extract direct child property key if errorPath is a direct child of
-	 * parentPath Returns null if not a direct child
-	 *
-	 * Examples:
-	 *
-	 * - ExtractDirectChildKey("$input", "$input.email") => "email"
-	 * - ExtractDirectChildKey("$input", "$input.user.email") => null (grandchild)
-	 * - ExtractDirectChildKey("$input.user", "$input.user.email") => "email"
-	 * - ExtractDirectChildKey("$input", "$input[0]") => null (array index, not object
-	 *   property)
-	 * - ExtractDirectChildKey("$input", "$input["foo-bar"]") => "foo-bar"
-	 * - ExtractDirectChildKey("$input", "$input["foo"]["bar"]") => null (grandchild)
-	 */
-	function extractDirectChildKey(parentPath, errorPath) {
-	    if (!errorPath.startsWith(parentPath)) {
-	        return null;
-	    }
-	    const suffix = errorPath.slice(parentPath.length);
-	    // Match ".propertyName" pattern (direct child property with dot notation)
-	    // Should not contain additional dots or brackets after the property name
-	    const dotMatch = suffix.match(/^\.([^.[\]]+)$/);
-	    if (dotMatch !== null) {
-	        return dotMatch[1];
-	    }
-	    // Match '["key"]' pattern (direct child property with bracket notation)
-	    // The key is a JSON-encoded string
-	    const bracketMatch = suffix.match(/^\[("[^"\\]*(?:\\.[^"\\]*)*")\]$/);
-	    if (bracketMatch !== null) {
-	        try {
-	            const parsed = JSON.parse(bracketMatch[1]);
-	            // Ensure it's a string key, not a number (array index)
-	            if (typeof parsed === "string") {
-	                return parsed;
-	            }
-	        }
-	        catch (_a) {
-	            // Invalid JSON, ignore
-	        }
-	    }
-	    return null;
-	}
-	
-	return stringifyValidationFailure;
+}
+function stringify(props) {
+    var _a;
+    const { value, errorsByPath, path, tab, inArray, inToJson, usedErrors } = props;
+    const indent = "  ".repeat(tab);
+    const errorComment = getErrorComment(path, errorsByPath, usedErrors);
+    // Handle undefined in arrays
+    if (inArray && value === undefined) {
+        return `${indent}undefined${errorComment}`;
+    }
+    // Array
+    if (Array.isArray(value)) {
+        // Check for missing array element errors (path[])
+        const missingElementErrors = getMissingArrayElementErrors(path, errorsByPath, usedErrors);
+        const hasMissingElements = missingElementErrors.length > 0;
+        if (value.length === 0) {
+            // Empty array but has missing element errors - show placeholders
+            if (hasMissingElements) {
+                const innerIndent = "  ".repeat(tab + 1);
+                const lines = [];
+                lines.push(`${indent}[${errorComment}`);
+                missingElementErrors.forEach((e, idx) => {
+                    const errComment = ` // ❌ ${JSON.stringify([{ path: e.path, expected: e.expected, description: e.description }])}`;
+                    const comma = idx < missingElementErrors.length - 1 ? "," : "";
+                    lines.push(`${innerIndent}undefined${comma}${errComment}`);
+                });
+                lines.push(`${indent}]`);
+                return lines.join("\n");
+            }
+            return `${indent}[]${errorComment}`;
+        }
+        const lines = [];
+        lines.push(`${indent}[${errorComment}`);
+        value.forEach((item, index) => {
+            const itemPath = `${path}[${index}]`;
+            const isLastElement = index === value.length - 1;
+            // If there are missing element errors, this is not truly the last line
+            const needsComma = !isLastElement || hasMissingElements;
+            let itemStr = stringify({
+                value: item,
+                errorsByPath,
+                path: itemPath,
+                tab: tab + 1,
+                inArray: true,
+                inToJson: false,
+                usedErrors,
+            });
+            // Add comma before the error comment if not the last element
+            if (needsComma) {
+                itemStr = insertCommaBeforeComment(itemStr);
+            }
+            lines.push(itemStr);
+        });
+        // Add missing element placeholders at the end for each [] error
+        if (hasMissingElements) {
+            const innerIndent = "  ".repeat(tab + 1);
+            missingElementErrors.forEach((e, idx) => {
+                const errComment = ` // ❌ ${JSON.stringify([{ path: e.path, expected: e.expected, description: e.description }])}`;
+                const comma = idx < missingElementErrors.length - 1 ? "," : "";
+                lines.push(`${innerIndent}undefined${comma}${errComment}`);
+            });
+        }
+        lines.push(`${indent}]`);
+        return lines.join("\n");
+    }
+    // Object
+    if (typeof value === "object" && value !== null) {
+        // Check for toJSON method
+        // biome-ignore lint: intended
+        if (!inToJson && typeof value.toJSON === "function") {
+            // biome-ignore lint: intended
+            const jsonValue = value.toJSON();
+            return stringify({
+                value: jsonValue,
+                errorsByPath,
+                path,
+                tab,
+                inArray,
+                inToJson: true,
+                usedErrors,
+            });
+        }
+        // Get all entries from the object (including undefined values that have errors)
+        const allEntries = Object.entries(value);
+        // Split into defined and undefined entries
+        const definedEntries = allEntries.filter(([_, val]) => val !== undefined);
+        const undefinedEntryKeys = new Set(allEntries.filter(([_, val]) => val === undefined).map(([key]) => key));
+        // Find missing properties that have validation errors (not in object at all)
+        const missingKeys = getMissingProperties(path, value, errorsByPath);
+        // Combine: defined entries + undefined entries with errors + missing properties
+        const undefinedKeysWithErrors = Array.from(undefinedEntryKeys).filter((key) => {
+            const propPath = NamingConvention_1.NamingConvention.variable(key)
+                ? `${path}.${key}`
+                : `${path}[${JSON.stringify(key)}]`;
+            return hasErrorsAtOrUnder(propPath, errorsByPath);
+        });
+        const allKeys = [
+            ...definedEntries.map(([key]) => key),
+            ...undefinedKeysWithErrors,
+            ...missingKeys,
+        ];
+        if (allKeys.length === 0) {
+            return `${indent}{}${errorComment}`;
+        }
+        const lines = [];
+        lines.push(`${indent}{${errorComment}`);
+        allKeys.forEach((key, index, array) => {
+            const propPath = NamingConvention_1.NamingConvention.variable(key)
+                ? `${path}.${key}`
+                : `${path}[${JSON.stringify(key)}]`;
+            const propIndent = "  ".repeat(tab + 1);
+            // Get the value (undefined for missing properties or undefined entries)
+            const val = missingKeys.includes(key) || undefinedKeysWithErrors.includes(key)
+                ? undefined
+                : // biome-ignore lint: intended
+                    value[key];
+            // Primitive property value (including undefined for missing properties)
+            if (val === undefined ||
+                val === null ||
+                typeof val === "boolean" ||
+                typeof val === "number" ||
+                typeof val === "string") {
+                const propErrorComment = getErrorComment(propPath, errorsByPath, usedErrors);
+                const keyStr = JSON.stringify(key);
+                const valueStr = val === undefined
+                    ? `${propIndent}${keyStr}: undefined`
+                    : `${propIndent}${keyStr}: ${JSON.stringify(val)}`;
+                const withComma = index < array.length - 1 ? `${valueStr},` : valueStr;
+                const line = withComma + propErrorComment;
+                lines.push(line);
+            }
+            // Complex property value (object or array)
+            else {
+                const keyLine = `${propIndent}${JSON.stringify(key)}: `;
+                let valStr = stringify({
+                    value: val,
+                    errorsByPath,
+                    path: propPath,
+                    tab: tab + 1,
+                    inArray: false,
+                    inToJson: false,
+                    usedErrors,
+                });
+                const valStrWithoutIndent = valStr.trimStart();
+                // Add comma before the error comment if not the last property
+                if (index < array.length - 1) {
+                    valStr = insertCommaBeforeComment(valStrWithoutIndent);
+                }
+                else {
+                    valStr = valStrWithoutIndent;
+                }
+                const combined = keyLine + valStr;
+                lines.push(combined);
+            }
+        });
+        lines.push(`${indent}}`);
+        return lines.join("\n");
+    }
+    // Primitive types (null, boolean, number, string, undefined, etc.)
+    const valStr = value === undefined
+        ? "undefined"
+        : ((_a = JSON.stringify(value)) !== null && _a !== void 0 ? _a : String(value));
+    return `${indent}${valStr}${errorComment}`;
+}
+/** Insert comma before inline error comment on the last line */
+function insertCommaBeforeComment(str) {
+    const lines = str.split("\n");
+    const lastLine = lines[lines.length - 1];
+    // Use specific error marker to avoid false positives with values containing " //"
+    const commentIndex = lastLine.lastIndexOf(" // ❌");
+    if (commentIndex !== -1) {
+        lines[lines.length - 1] = `${lastLine.slice(0, commentIndex)},${lastLine.slice(commentIndex)}`;
+    }
+    else {
+        lines[lines.length - 1] += ",";
+    }
+    return lines.join("\n");
+}
+/** Get error comment for a given path */
+function getErrorComment(path, errorsByPath, usedErrors) {
+    const pathErrors = errorsByPath.get(path);
+    if (pathErrors === undefined || pathErrors.length === 0) {
+        return "";
+    }
+    // Mark these errors as used
+    pathErrors.forEach((e) => usedErrors.add(e));
+    return ` // ❌ ${JSON.stringify(pathErrors.map((e) => ({
+        path: e.path,
+        expected: e.expected,
+        description: e.description,
+    })))}`;
+}
+/**
+ * Check if there are missing array element errors (path ending with []) Returns
+ * an array of error objects, one per missing element
+ */
+function getMissingArrayElementErrors(path, errorsByPath, usedErrors) {
+    var _a;
+    const wildcardPath = `${path}[]`;
+    const missingErrors = (_a = errorsByPath.get(wildcardPath)) !== null && _a !== void 0 ? _a : [];
+    // Mark these errors as used
+    missingErrors.forEach((e) => usedErrors.add(e));
+    return missingErrors;
+}
+/** Check if any errors exist at or under the given path prefix */
+function hasErrorsAtOrUnder(pathPrefix, errorsByPath) {
+    for (const errorPath of errorsByPath.keys()) {
+        if (errorPath === pathPrefix ||
+            errorPath.startsWith(pathPrefix + ".") ||
+            errorPath.startsWith(pathPrefix + "[")) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Find missing properties that have validation errors but don't exist in the
+ * data Returns array of property keys that should be displayed as undefined
+ */
+function getMissingProperties(path, value, errorsByPath) {
+    const missingKeys = new Set();
+    for (const errorPath of errorsByPath.keys()) {
+        // Check if error.path is a direct child of current path
+        const childKey = extractDirectChildKey(path, errorPath);
+        if (childKey !== null) {
+            // Check if this property actually exists in the value
+            if (!(childKey in value)) {
+                missingKeys.add(childKey);
+            }
+        }
+    }
+    return Array.from(missingKeys);
+}
+/**
+ * Extract direct child property key if errorPath is a direct child of
+ * parentPath Returns null if not a direct child
+ *
+ * Examples:
+ *
+ * - ExtractDirectChildKey("$input", "$input.email") => "email"
+ * - ExtractDirectChildKey("$input", "$input.user.email") => null (grandchild)
+ * - ExtractDirectChildKey("$input.user", "$input.user.email") => "email"
+ * - ExtractDirectChildKey("$input", "$input[0]") => null (array index, not object
+ *   property)
+ * - ExtractDirectChildKey("$input", "$input["foo-bar"]") => "foo-bar"
+ * - ExtractDirectChildKey("$input", "$input["foo"]["bar"]") => null (grandchild)
+ */
+function extractDirectChildKey(parentPath, errorPath) {
+    if (!errorPath.startsWith(parentPath)) {
+        return null;
+    }
+    const suffix = errorPath.slice(parentPath.length);
+    // Match ".propertyName" pattern (direct child property with dot notation)
+    // Should not contain additional dots or brackets after the property name
+    const dotMatch = suffix.match(/^\.([^.[\]]+)$/);
+    if (dotMatch !== null) {
+        return dotMatch[1];
+    }
+    // Match '["key"]' pattern (direct child property with bracket notation)
+    // The key is a JSON-encoded string
+    const bracketMatch = suffix.match(/^\[("[^"\\]*(?:\\.[^"\\]*)*")\]$/);
+    if (bracketMatch !== null) {
+        try {
+            const parsed = JSON.parse(bracketMatch[1]);
+            // Ensure it's a string key, not a number (array index)
+            if (typeof parsed === "string") {
+                return parsed;
+            }
+        }
+        catch (_a) {
+            // Invalid JSON, ignore
+        }
+    }
+    return null;
 }
 
-export { requireStringifyValidationFailure as __require };
+export { stringifyValidationFailure$1 as default, stringifyValidationFailure_2 as stringifyValidationFailure };
 //# sourceMappingURL=stringifyValidationFailure2.mjs.map