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

package/lib/utils/LlmJson2.mjs

@@ -1,172 +1,169 @@
-import { __exports as LlmJson } from '../_virtual/LlmJson.mjs';
-import { __require as requireConverters } from '../converters/index2.mjs';
-import { __require as requireValidators } from '../validators/index2.mjs';
-import { __require as requireCoerceLlmArguments } from './internal/coerceLlmArguments2.mjs';
-import { __require as requireParseLenientJson } from './internal/parseLenientJson2.mjs';
-import { __require as requireStringifyValidationFailure } from './internal/stringifyValidationFailure2.mjs';
+import { __exports as LlmJson$1 } from '../_virtual/LlmJson.mjs';
+import '../converters/index2.mjs';
+import '../validators/index2.mjs';
+import './internal/coerceLlmArguments2.mjs';
+import './internal/parseLenientJson2.mjs';
+import './internal/stringifyValidationFailure2.mjs';
+import { __exports as coerceLlmArguments } from '../_virtual/coerceLlmArguments.mjs';
+import { __exports as parseLenientJson } from '../_virtual/parseLenientJson.mjs';
+import { __exports as stringifyValidationFailure } from '../_virtual/stringifyValidationFailure.mjs';
+import { __exports as converters } from '../_virtual/index2.mjs';
+import { __exports as validators } from '../_virtual/index5.mjs';
 
-var hasRequiredLlmJson;
+Object.defineProperty(LlmJson$1, "__esModule", { value: true });
+var LlmJson_2 = LlmJson$1.LlmJson = void 0;
+const converters_1 = converters;
+const validators_1 = validators;
+const coerceLlmArguments_1 = coerceLlmArguments;
+const parseLenientJson_1 = parseLenientJson;
+const stringifyValidationFailure_1 = stringifyValidationFailure;
+/**
+ * JSON utilities for LLM function calling.
+ *
+ * - {@link LlmJson.parse}: Lenient JSON parser for incomplete/malformed JSON
+ * - {@link LlmJson.stringify}: Format validation errors for LLM feedback
+ * - {@link LlmJson.validate}: Create a reusable validator from schema
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+var LlmJson;
+(function (LlmJson) {
+    /**
+     * Coerce LLM arguments to match expected schema types.
+     *
+     * LLMs often return values with incorrect types (e.g., numbers as strings).
+     * This function recursively coerces values based on the schema:
+     *
+     * - `"42"` → `42` (when schema expects number)
+     * - `"true"` → `true` (when schema expects boolean)
+     * - `"null"` → `null` (when schema expects null)
+     * - `"{...}"` → `{...}` (when schema expects object)
+     * - `"[...]"` → `[...]` (when schema expects array)
+     *
+     * Use this when SDK provides already-parsed objects but values may have wrong
+     * types. For raw JSON strings, use {@link parse} instead.
+     *
+     * @param input Parsed arguments object from LLM
+     * @param parameters LLM function parameters schema for type coercion
+     * @returns Coerced arguments with corrected types
+     */
+    function coerce(input, parameters) {
+        return (0, coerceLlmArguments_1.coerceLlmArguments)(input, parameters);
+    }
+    LlmJson.coerce = coerce;
+    /**
+     * Parse lenient JSON with optional schema-based coercion.
+     *
+     * Handles incomplete/malformed JSON commonly produced by LLMs:
+     *
+     * - Unclosed brackets, strings, trailing commas
+     * - JavaScript-style comments (`//` and multi-line)
+     * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)
+     * - Markdown code block extraction, junk prefix skipping
+     *
+     * When `parameters` schema is provided, also coerces double-stringified
+     * values: `"42"` → `42`, `"true"` → `true`, `"{...}"` → `{...}` based on
+     * expected types.
+     *
+     * Type validation is NOT performed - use {@link ILlmFunction.validate}.
+     *
+     * @param input Raw JSON string (potentially incomplete or malformed)
+     * @param parameters Optional LLM parameters schema for type coercion
+     * @returns Parse result with data on success, or partial data with errors
+     */
+    function parse(input, parameters) {
+        const result = (0, parseLenientJson_1.parseLenientJson)(input);
+        // Apply schema-based coercion if parameters provided and parsing succeeded
+        if (parameters !== undefined && result.success) {
+            return {
+                success: true,
+                data: (0, coerceLlmArguments_1.coerceLlmArguments)(result.data, parameters),
+            };
+        }
+        return result;
+    }
+    LlmJson.parse = parse;
+    /**
+     * Format validation failure for LLM auto-correction feedback.
+     *
+     * When LLM generates invalid function call arguments, this produces annotated
+     * JSON with inline `// ❌` error comments at each invalid property. The output
+     * is wrapped in a markdown code block so that LLM can understand and correct
+     * its mistakes in the next turn.
+     *
+     * Below is an example of the output format:
+     *
+     * ```json
+     * {
+     *   "name": "John",
+     *   "age": "twenty", // ❌ [{"path":"$input.age","expected":"number & Type<\"uint32\">"}]
+     *   "email": "not-an-email", // ❌ [{"path":"$input.email","expected":"string & Format<\"email\">"}]
+     *   "hobbies": "reading" // ❌ [{"path":"$input.hobbies","expected":"Array<string>"}]
+     * }
+     * ```
+     *
+     * @param failure Validation failure from {@link ILlmFunction.validate}
+     */
+    function stringify(failure) {
+        return (0, stringifyValidationFailure_1.stringifyValidationFailure)(failure);
+    }
+    LlmJson.stringify = stringify;
+    /**
+     * Create a reusable validator from LLM parameters schema.
+     *
+     * When validation fails, format the failure with {@link stringify} for LLM
+     * auto-correction feedback.
+     *
+     * @param parameters LLM function parameters schema
+     * @param equals If `true`, reject extraneous properties not defined in the
+     *   schema. Otherwise, extra properties are ignored.
+     * @returns Validator function that checks data against the schema
+     */
+    function validate(parameters, equals) {
+        const components = {
+            schemas: {},
+        };
+        const schema = converters_1.LlmSchemaConverter.invert({
+            components,
+            schema: parameters,
+            $defs: parameters.$defs,
+        });
+        return validators_1.OpenApiValidator.create({
+            components,
+            schema,
+            required: true,
+            equals,
+        });
+    }
+    LlmJson.validate = validate;
+    /**
+     * Convert LLM parameters schema to structured output interface.
+     *
+     * Creates an {@link ILlmStructuredOutput} containing everything needed for
+     * handling LLM structured outputs: the parameters schema for prompting, and
+     * functions for parsing, coercing, and validating responses.
+     *
+     * This is useful when you have a parameters schema (e.g., from
+     * `typia.llm.parameters()`) and need the full structured output interface
+     * with all utility functions.
+     *
+     * @template T The expected output type
+     * @param parameters LLM parameters schema
+     * @param equals If `true`, reject extraneous properties not defined in the
+     *   schema during validation. Otherwise, extra properties are ignored.
+     * @returns Structured output interface with parse, coerce, and validate
+     */
+    function structuredOutput(parameters, equals) {
+        const validator = validate(parameters, equals);
+        return {
+            parameters,
+            parse: (str) => parse(str, parameters),
+            coerce: (input) => coerce(input, parameters),
+            validate: (input) => validator(input),
+        };
+    }
+    LlmJson.structuredOutput = structuredOutput;
+})(LlmJson || (LlmJson_2 = LlmJson$1.LlmJson = LlmJson = {}));
 
-function requireLlmJson () {
-	if (hasRequiredLlmJson) return LlmJson;
-	hasRequiredLlmJson = 1;
-	Object.defineProperty(LlmJson, "__esModule", { value: true });
-	LlmJson.LlmJson = void 0;
-	const converters_1 = requireConverters();
-	const validators_1 = requireValidators();
-	const coerceLlmArguments_1 = requireCoerceLlmArguments();
-	const parseLenientJson_1 = requireParseLenientJson();
-	const stringifyValidationFailure_1 = requireStringifyValidationFailure();
-	/**
-	 * JSON utilities for LLM function calling.
-	 *
-	 * - {@link LlmJson.parse}: Lenient JSON parser for incomplete/malformed JSON
-	 * - {@link LlmJson.stringify}: Format validation errors for LLM feedback
-	 * - {@link LlmJson.validate}: Create a reusable validator from schema
-	 *
-	 * @author Jeongho Nam - https://github.com/samchon
-	 */
-	var LlmJson$1;
-	(function (LlmJson) {
-	    /**
-	     * Coerce LLM arguments to match expected schema types.
-	     *
-	     * LLMs often return values with incorrect types (e.g., numbers as strings).
-	     * This function recursively coerces values based on the schema:
-	     *
-	     * - `"42"` → `42` (when schema expects number)
-	     * - `"true"` → `true` (when schema expects boolean)
-	     * - `"null"` → `null` (when schema expects null)
-	     * - `"{...}"` → `{...}` (when schema expects object)
-	     * - `"[...]"` → `[...]` (when schema expects array)
-	     *
-	     * Use this when SDK provides already-parsed objects but values may have wrong
-	     * types. For raw JSON strings, use {@link parse} instead.
-	     *
-	     * @param input Parsed arguments object from LLM
-	     * @param parameters LLM function parameters schema for type coercion
-	     * @returns Coerced arguments with corrected types
-	     */
-	    function coerce(input, parameters) {
-	        return (0, coerceLlmArguments_1.coerceLlmArguments)(input, parameters);
-	    }
-	    LlmJson.coerce = coerce;
-	    /**
-	     * Parse lenient JSON with optional schema-based coercion.
-	     *
-	     * Handles incomplete/malformed JSON commonly produced by LLMs:
-	     *
-	     * - Unclosed brackets, strings, trailing commas
-	     * - JavaScript-style comments (`//` and multi-line)
-	     * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)
-	     * - Markdown code block extraction, junk prefix skipping
-	     *
-	     * When `parameters` schema is provided, also coerces double-stringified
-	     * values: `"42"` → `42`, `"true"` → `true`, `"{...}"` → `{...}` based on
-	     * expected types.
-	     *
-	     * Type validation is NOT performed - use {@link ILlmFunction.validate}.
-	     *
-	     * @param input Raw JSON string (potentially incomplete or malformed)
-	     * @param parameters Optional LLM parameters schema for type coercion
-	     * @returns Parse result with data on success, or partial data with errors
-	     */
-	    function parse(input, parameters) {
-	        const result = (0, parseLenientJson_1.parseLenientJson)(input);
-	        // Apply schema-based coercion if parameters provided and parsing succeeded
-	        if (parameters !== undefined && result.success) {
-	            return {
-	                success: true,
-	                data: (0, coerceLlmArguments_1.coerceLlmArguments)(result.data, parameters),
-	            };
-	        }
-	        return result;
-	    }
-	    LlmJson.parse = parse;
-	    /**
-	     * Format validation failure for LLM auto-correction feedback.
-	     *
-	     * When LLM generates invalid function call arguments, this produces annotated
-	     * JSON with inline `// ❌` error comments at each invalid property. The output
-	     * is wrapped in a markdown code block so that LLM can understand and correct
-	     * its mistakes in the next turn.
-	     *
-	     * Below is an example of the output format:
-	     *
-	     * ```json
-	     * {
-	     *   "name": "John",
-	     *   "age": "twenty", // ❌ [{"path":"$input.age","expected":"number & Type<\"uint32\">"}]
-	     *   "email": "not-an-email", // ❌ [{"path":"$input.email","expected":"string & Format<\"email\">"}]
-	     *   "hobbies": "reading" // ❌ [{"path":"$input.hobbies","expected":"Array<string>"}]
-	     * }
-	     * ```
-	     *
-	     * @param failure Validation failure from {@link ILlmFunction.validate}
-	     */
-	    function stringify(failure) {
-	        return (0, stringifyValidationFailure_1.stringifyValidationFailure)(failure);
-	    }
-	    LlmJson.stringify = stringify;
-	    /**
-	     * Create a reusable validator from LLM parameters schema.
-	     *
-	     * When validation fails, format the failure with {@link stringify} for LLM
-	     * auto-correction feedback.
-	     *
-	     * @param parameters LLM function parameters schema
-	     * @param equals If `true`, reject extraneous properties not defined in the
-	     *   schema. Otherwise, extra properties are ignored.
-	     * @returns Validator function that checks data against the schema
-	     */
-	    function validate(parameters, equals) {
-	        const components = {
-	            schemas: {},
-	        };
-	        const schema = converters_1.LlmSchemaConverter.invert({
-	            components,
-	            schema: parameters,
-	            $defs: parameters.$defs,
-	        });
-	        return validators_1.OpenApiValidator.create({
-	            components,
-	            schema,
-	            required: true,
-	            equals,
-	        });
-	    }
-	    LlmJson.validate = validate;
-	    /**
-	     * Convert LLM parameters schema to structured output interface.
-	     *
-	     * Creates an {@link ILlmStructuredOutput} containing everything needed for
-	     * handling LLM structured outputs: the parameters schema for prompting, and
-	     * functions for parsing, coercing, and validating responses.
-	     *
-	     * This is useful when you have a parameters schema (e.g., from
-	     * `typia.llm.parameters()`) and need the full structured output interface
-	     * with all utility functions.
-	     *
-	     * @template T The expected output type
-	     * @param parameters LLM parameters schema
-	     * @param equals If `true`, reject extraneous properties not defined in the
-	     *   schema during validation. Otherwise, extra properties are ignored.
-	     * @returns Structured output interface with parse, coerce, and validate
-	     */
-	    function structuredOutput(parameters, equals) {
-	        const validator = validate(parameters, equals);
-	        return {
-	            parameters,
-	            parse: (str) => parse(str, parameters),
-	            coerce: (input) => coerce(input, parameters),
-	            validate: (input) => validator(input),
-	        };
-	    }
-	    LlmJson.structuredOutput = structuredOutput;
-	})(LlmJson$1 || (LlmJson.LlmJson = LlmJson$1 = {}));
-	
-	return LlmJson;
-}
-
-export { requireLlmJson as __require };
+export { LlmJson_2 as LlmJson, LlmJson$1 as default };
 //# sourceMappingURL=LlmJson2.mjs.map

package/lib/utils/LlmJson2.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"LlmJson2.mjs","sources":["LlmJson.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.LlmJson = void 0;\nconst converters_1 = require(\"../converters\");\nconst validators_1 = require(\"../validators\");\nconst coerceLlmArguments_1 = require(\"./internal/coerceLlmArguments\");\nconst parseLenientJson_1 = require(\"./internal/parseLenientJson\");\nconst stringifyValidationFailure_1 = require(\"./internal/stringifyValidationFailure\");\n/**\n * JSON utilities for LLM function calling.\n *\n * - {@link LlmJson.parse}: Lenient JSON parser for incomplete/malformed JSON\n * - {@link LlmJson.stringify}: Format validation errors for LLM feedback\n * - {@link LlmJson.validate}: Create a reusable validator from schema\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nvar LlmJson;\n(function (LlmJson) {\n    /**\n     * Coerce LLM arguments to match expected schema types.\n     *\n     * LLMs often return values with incorrect types (e.g., numbers as strings).\n     * This function recursively coerces values based on the schema:\n     *\n     * - `\"42\"` → `42` (when schema expects number)\n     * - `\"true\"` → `true` (when schema expects boolean)\n     * - `\"null\"` → `null` (when schema expects null)\n     * - `\"{...}\"` → `{...}` (when schema expects object)\n     * - `\"[...]\"` → `[...]` (when schema expects array)\n     *\n     * Use this when SDK provides already-parsed objects but values may have wrong\n     * types. For raw JSON strings, use {@link parse} instead.\n     *\n     * @param input Parsed arguments object from LLM\n     * @param parameters LLM function parameters schema for type coercion\n     * @returns Coerced arguments with corrected types\n     */\n    function coerce(input, parameters) {\n        return (0, coerceLlmArguments_1.coerceLlmArguments)(input, parameters);\n    }\n    LlmJson.coerce = coerce;\n    /**\n     * Parse lenient JSON with optional schema-based coercion.\n     *\n     * Handles incomplete/malformed JSON commonly produced by LLMs:\n     *\n     * - Unclosed brackets, strings, trailing commas\n     * - JavaScript-style comments (`//` and multi-line)\n     * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)\n     * - Markdown code block extraction, junk prefix skipping\n     *\n     * When `parameters` schema is provided, also coerces double-stringified\n     * values: `\"42\"` → `42`, `\"true\"` → `true`, `\"{...}\"` → `{...}` based on\n     * expected types.\n     *\n     * Type validation is NOT performed - use {@link ILlmFunction.validate}.\n     *\n     * @param input Raw JSON string (potentially incomplete or malformed)\n     * @param parameters Optional LLM parameters schema for type coercion\n     * @returns Parse result with data on success, or partial data with errors\n     */\n    function parse(input, parameters) {\n        const result = (0, parseLenientJson_1.parseLenientJson)(input);\n        // Apply schema-based coercion if parameters provided and parsing succeeded\n        if (parameters !== undefined && result.success) {\n            return {\n                success: true,\n                data: (0, coerceLlmArguments_1.coerceLlmArguments)(result.data, parameters),\n            };\n        }\n        return result;\n    }\n    LlmJson.parse = parse;\n    /**\n     * Format validation failure for LLM auto-correction feedback.\n     *\n     * When LLM generates invalid function call arguments, this produces annotated\n     * JSON with inline `// ❌` error comments at each invalid property. The output\n     * is wrapped in a markdown code block so that LLM can understand and correct\n     * its mistakes in the next turn.\n     *\n     * Below is an example of the output format:\n     *\n     * ```json\n     * {\n     *   \"name\": \"John\",\n     *   \"age\": \"twenty\", // ❌ [{\"path\":\"$input.age\",\"expected\":\"number & Type<\\\"uint32\\\">\"}]\n     *   \"email\": \"not-an-email\", // ❌ [{\"path\":\"$input.email\",\"expected\":\"string & Format<\\\"email\\\">\"}]\n     *   \"hobbies\": \"reading\" // ❌ [{\"path\":\"$input.hobbies\",\"expected\":\"Array<string>\"}]\n     * }\n     * ```\n     *\n     * @param failure Validation failure from {@link ILlmFunction.validate}\n     */\n    function stringify(failure) {\n        return (0, stringifyValidationFailure_1.stringifyValidationFailure)(failure);\n    }\n    LlmJson.stringify = stringify;\n    /**\n     * Create a reusable validator from LLM parameters schema.\n     *\n     * When validation fails, format the failure with {@link stringify} for LLM\n     * auto-correction feedback.\n     *\n     * @param parameters LLM function parameters schema\n     * @param equals If `true`, reject extraneous properties not defined in the\n     *   schema. Otherwise, extra properties are ignored.\n     * @returns Validator function that checks data against the schema\n     */\n    function validate(parameters, equals) {\n        const components = {\n            schemas: {},\n        };\n        const schema = converters_1.LlmSchemaConverter.invert({\n            components,\n            schema: parameters,\n            $defs: parameters.$defs,\n        });\n        return validators_1.OpenApiValidator.create({\n            components,\n            schema,\n            required: true,\n            equals,\n        });\n    }\n    LlmJson.validate = validate;\n    /**\n     * Convert LLM parameters schema to structured output interface.\n     *\n     * Creates an {@link ILlmStructuredOutput} containing everything needed for\n     * handling LLM structured outputs: the parameters schema for prompting, and\n     * functions for parsing, coercing, and validating responses.\n     *\n     * This is useful when you have a parameters schema (e.g., from\n     * `typia.llm.parameters()`) and need the full structured output interface\n     * with all utility functions.\n     *\n     * @template T The expected output type\n     * @param parameters LLM parameters schema\n     * @param equals If `true`, reject extraneous properties not defined in the\n     *   schema during validation. Otherwise, extra properties are ignored.\n     * @returns Structured output interface with parse, coerce, and validate\n     */\n    function structuredOutput(parameters, equals) {\n        const validator = validate(parameters, equals);\n        return {\n            parameters,\n            parse: (str) => parse(str, parameters),\n            coerce: (input) => coerce(input, parameters),\n            validate: (input) => validator(input),\n        };\n    }\n    LlmJson.structuredOutput = structuredOutput;\n})(LlmJson || (exports.LlmJson = LlmJson = {}));\n//# sourceMappingURL=LlmJson.js.map"],"names":["LlmJson_1","require$$0","require$$1","require$$2","require$$3","require$$4","LlmJson"],"mappings":"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"}
+{"version":3,"file":"LlmJson2.mjs","sources":["LlmJson.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.LlmJson = void 0;\nconst converters_1 = require(\"../converters\");\nconst validators_1 = require(\"../validators\");\nconst coerceLlmArguments_1 = require(\"./internal/coerceLlmArguments\");\nconst parseLenientJson_1 = require(\"./internal/parseLenientJson\");\nconst stringifyValidationFailure_1 = require(\"./internal/stringifyValidationFailure\");\n/**\n * JSON utilities for LLM function calling.\n *\n * - {@link LlmJson.parse}: Lenient JSON parser for incomplete/malformed JSON\n * - {@link LlmJson.stringify}: Format validation errors for LLM feedback\n * - {@link LlmJson.validate}: Create a reusable validator from schema\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nvar LlmJson;\n(function (LlmJson) {\n    /**\n     * Coerce LLM arguments to match expected schema types.\n     *\n     * LLMs often return values with incorrect types (e.g., numbers as strings).\n     * This function recursively coerces values based on the schema:\n     *\n     * - `\"42\"` → `42` (when schema expects number)\n     * - `\"true\"` → `true` (when schema expects boolean)\n     * - `\"null\"` → `null` (when schema expects null)\n     * - `\"{...}\"` → `{...}` (when schema expects object)\n     * - `\"[...]\"` → `[...]` (when schema expects array)\n     *\n     * Use this when SDK provides already-parsed objects but values may have wrong\n     * types. For raw JSON strings, use {@link parse} instead.\n     *\n     * @param input Parsed arguments object from LLM\n     * @param parameters LLM function parameters schema for type coercion\n     * @returns Coerced arguments with corrected types\n     */\n    function coerce(input, parameters) {\n        return (0, coerceLlmArguments_1.coerceLlmArguments)(input, parameters);\n    }\n    LlmJson.coerce = coerce;\n    /**\n     * Parse lenient JSON with optional schema-based coercion.\n     *\n     * Handles incomplete/malformed JSON commonly produced by LLMs:\n     *\n     * - Unclosed brackets, strings, trailing commas\n     * - JavaScript-style comments (`//` and multi-line)\n     * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)\n     * - Markdown code block extraction, junk prefix skipping\n     *\n     * When `parameters` schema is provided, also coerces double-stringified\n     * values: `\"42\"` → `42`, `\"true\"` → `true`, `\"{...}\"` → `{...}` based on\n     * expected types.\n     *\n     * Type validation is NOT performed - use {@link ILlmFunction.validate}.\n     *\n     * @param input Raw JSON string (potentially incomplete or malformed)\n     * @param parameters Optional LLM parameters schema for type coercion\n     * @returns Parse result with data on success, or partial data with errors\n     */\n    function parse(input, parameters) {\n        const result = (0, parseLenientJson_1.parseLenientJson)(input);\n        // Apply schema-based coercion if parameters provided and parsing succeeded\n        if (parameters !== undefined && result.success) {\n            return {\n                success: true,\n                data: (0, coerceLlmArguments_1.coerceLlmArguments)(result.data, parameters),\n            };\n        }\n        return result;\n    }\n    LlmJson.parse = parse;\n    /**\n     * Format validation failure for LLM auto-correction feedback.\n     *\n     * When LLM generates invalid function call arguments, this produces annotated\n     * JSON with inline `// ❌` error comments at each invalid property. The output\n     * is wrapped in a markdown code block so that LLM can understand and correct\n     * its mistakes in the next turn.\n     *\n     * Below is an example of the output format:\n     *\n     * ```json\n     * {\n     *   \"name\": \"John\",\n     *   \"age\": \"twenty\", // ❌ [{\"path\":\"$input.age\",\"expected\":\"number & Type<\\\"uint32\\\">\"}]\n     *   \"email\": \"not-an-email\", // ❌ [{\"path\":\"$input.email\",\"expected\":\"string & Format<\\\"email\\\">\"}]\n     *   \"hobbies\": \"reading\" // ❌ [{\"path\":\"$input.hobbies\",\"expected\":\"Array<string>\"}]\n     * }\n     * ```\n     *\n     * @param failure Validation failure from {@link ILlmFunction.validate}\n     */\n    function stringify(failure) {\n        return (0, stringifyValidationFailure_1.stringifyValidationFailure)(failure);\n    }\n    LlmJson.stringify = stringify;\n    /**\n     * Create a reusable validator from LLM parameters schema.\n     *\n     * When validation fails, format the failure with {@link stringify} for LLM\n     * auto-correction feedback.\n     *\n     * @param parameters LLM function parameters schema\n     * @param equals If `true`, reject extraneous properties not defined in the\n     *   schema. Otherwise, extra properties are ignored.\n     * @returns Validator function that checks data against the schema\n     */\n    function validate(parameters, equals) {\n        const components = {\n            schemas: {},\n        };\n        const schema = converters_1.LlmSchemaConverter.invert({\n            components,\n            schema: parameters,\n            $defs: parameters.$defs,\n        });\n        return validators_1.OpenApiValidator.create({\n            components,\n            schema,\n            required: true,\n            equals,\n        });\n    }\n    LlmJson.validate = validate;\n    /**\n     * Convert LLM parameters schema to structured output interface.\n     *\n     * Creates an {@link ILlmStructuredOutput} containing everything needed for\n     * handling LLM structured outputs: the parameters schema for prompting, and\n     * functions for parsing, coercing, and validating responses.\n     *\n     * This is useful when you have a parameters schema (e.g., from\n     * `typia.llm.parameters()`) and need the full structured output interface\n     * with all utility functions.\n     *\n     * @template T The expected output type\n     * @param parameters LLM parameters schema\n     * @param equals If `true`, reject extraneous properties not defined in the\n     *   schema during validation. Otherwise, extra properties are ignored.\n     * @returns Structured output interface with parse, coerce, and validate\n     */\n    function structuredOutput(parameters, equals) {\n        const validator = validate(parameters, equals);\n        return {\n            parameters,\n            parse: (str) => parse(str, parameters),\n            coerce: (input) => coerce(input, parameters),\n            validate: (input) => validator(input),\n        };\n    }\n    LlmJson.structuredOutput = structuredOutput;\n})(LlmJson || (exports.LlmJson = LlmJson = {}));\n//# sourceMappingURL=LlmJson.js.map"],"names":["LlmJson_1","require$$0","require$$1","require$$2","require$$3","require$$4"],"mappings":"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"}

package/lib/utils/MapUtil.mjs

@@ -1,8 +1,3 @@
-import { getDefaultExportFromCjs } from '../_virtual/_commonjsHelpers.mjs';
-import { __require as requireMapUtil } from './MapUtil2.mjs';
-
-var MapUtilExports = requireMapUtil();
-var MapUtil = /*@__PURE__*/getDefaultExportFromCjs(MapUtilExports);
-
-export { MapUtil as default };
+export { MapUtil } from './MapUtil2.mjs';
+export { __exports as default } from '../_virtual/MapUtil.mjs';
 //# sourceMappingURL=MapUtil.mjs.map

package/lib/utils/MapUtil.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MapUtil.mjs","sources":["MapUtil.js?commonjs-entry"],"sourcesContent":["import { getDefaultExportFromCjs } from \"\u0000commonjsHelpers.js\";\nimport { __require as requireMapUtil } from \"/home/samchon/github/samchon/typia@next/packages/utils/lib/utils/MapUtil.js\";\nvar MapUtilExports = requireMapUtil();\nexport { MapUtilExports as __moduleExports };\nexport default /*@__PURE__*/getDefaultExportFromCjs(MapUtilExports);"],"names":[],"mappings":";;;AAEA,IAAI,cAAc,GAAG,cAAc,EAAE;AAErC,cAAe,aAAa,uBAAuB,CAAC,cAAc,CAAC;;;;"}
+{"version":3,"file":"MapUtil.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/lib/utils/MapUtil2.mjs

@@ -1,27 +1,19 @@
-import { __exports as MapUtil } from '../_virtual/MapUtil.mjs';
+import { __exports as MapUtil$1 } from '../_virtual/MapUtil.mjs';
 
-var hasRequiredMapUtil;
+Object.defineProperty(MapUtil$1, "__esModule", { value: true });
+var MapUtil_2 = MapUtil$1.MapUtil = void 0;
+/** @internal */
+var MapUtil;
+(function (MapUtil) {
+    MapUtil.take = (dict, key, generator) => {
+        const oldbie = dict.get(key);
+        if (oldbie)
+            return oldbie;
+        const value = generator();
+        dict.set(key, value);
+        return value;
+    };
+})(MapUtil || (MapUtil_2 = MapUtil$1.MapUtil = MapUtil = {}));
 
-function requireMapUtil () {
-	if (hasRequiredMapUtil) return MapUtil;
-	hasRequiredMapUtil = 1;
-	Object.defineProperty(MapUtil, "__esModule", { value: true });
-	MapUtil.MapUtil = void 0;
-	/** @internal */
-	var MapUtil$1;
-	(function (MapUtil) {
-	    MapUtil.take = (dict, key, generator) => {
-	        const oldbie = dict.get(key);
-	        if (oldbie)
-	            return oldbie;
-	        const value = generator();
-	        dict.set(key, value);
-	        return value;
-	    };
-	})(MapUtil$1 || (MapUtil.MapUtil = MapUtil$1 = {}));
-	
-	return MapUtil;
-}
-
-export { requireMapUtil as __require };
+export { MapUtil_2 as MapUtil, MapUtil$1 as default };
 //# sourceMappingURL=MapUtil2.mjs.map

package/lib/utils/MapUtil2.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MapUtil2.mjs","sources":["MapUtil.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MapUtil = void 0;\n/** @internal */\nvar MapUtil;\n(function (MapUtil) {\n    MapUtil.take = (dict, key, generator) => {\n        const oldbie = dict.get(key);\n        if (oldbie)\n            return oldbie;\n        const value = generator();\n        dict.set(key, value);\n        return value;\n    };\n})(MapUtil || (exports.MapUtil = MapUtil = {}));\n//# sourceMappingURL=MapUtil.js.map"],"names":["MapUtil_1","MapUtil"],"mappings":";;;;;;;AACA,CAAA,MAAM,CAAC,cAAc,CAACA,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,CAAAA,OAAA,CAAA,OAAe,GAAG,MAAM;AACxB;AACA,CAAA,IAAIC,SAAO;CACX,CAAC,UAAU,OAAO,EAAE;KAChB,OAAO,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,KAAK;SACrC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;AACpC,SAAQ,IAAI,MAAM;AAClB,aAAY,OAAO,MAAM;AACzB,SAAQ,MAAM,KAAK,GAAG,SAAS,EAAE;AACjC,SAAQ,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC;AAC5B,SAAQ,OAAO,KAAK;KACpB,CAAK;CACL,CAAC,EAAEA,SAAO,KAAKD,OAAA,CAAA,OAAe,GAAGC,SAAO,GAAG,EAAE,CAAC,CAAC;AAC/C;;;;;;"}
+{"version":3,"file":"MapUtil2.mjs","sources":["MapUtil.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MapUtil = void 0;\n/** @internal */\nvar MapUtil;\n(function (MapUtil) {\n    MapUtil.take = (dict, key, generator) => {\n        const oldbie = dict.get(key);\n        if (oldbie)\n            return oldbie;\n        const value = generator();\n        dict.set(key, value);\n        return value;\n    };\n})(MapUtil || (exports.MapUtil = MapUtil = {}));\n//# sourceMappingURL=MapUtil.js.map"],"names":["MapUtil_1"],"mappings":";;AACA,MAAM,CAAC,cAAc,CAACA,SAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,IAAA,SAAA,GAAAA,SAAA,CAAA,OAAe,GAAG;AAClB;AACA,IAAI,OAAO;AACX,CAAC,UAAU,OAAO,EAAE;AACpB,IAAI,OAAO,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,KAAK;AAC7C,QAAQ,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;AACpC,QAAQ,IAAI,MAAM;AAClB,YAAY,OAAO,MAAM;AACzB,QAAQ,MAAM,KAAK,GAAG,SAAS,EAAE;AACjC,QAAQ,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC;AAC5B,QAAQ,OAAO,KAAK;AACpB,IAAA,CAAK;AACL,CAAC,EAAE,OAAO,KAAK,SAAA,GAAAA,SAAA,CAAA,OAAe,GAAG,OAAO,GAAG,EAAE,CAAC,CAAC;;;;"}

package/lib/utils/NamingConvention.mjs

@@ -1,8 +1,3 @@
-import { getDefaultExportFromCjs } from '../_virtual/_commonjsHelpers.mjs';
-import { __require as requireNamingConvention } from './NamingConvention2.mjs';
-
-var NamingConventionExports = requireNamingConvention();
-var NamingConvention = /*@__PURE__*/getDefaultExportFromCjs(NamingConventionExports);
-
-export { NamingConvention as default };
+export { NamingConvention } from './NamingConvention2.mjs';
+export { __exports as default } from '../_virtual/NamingConvention.mjs';
 //# sourceMappingURL=NamingConvention.mjs.map

package/lib/utils/NamingConvention.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"NamingConvention.mjs","sources":["NamingConvention.js?commonjs-entry"],"sourcesContent":["import { getDefaultExportFromCjs } from \"\u0000commonjsHelpers.js\";\nimport { __require as requireNamingConvention } from \"/home/samchon/github/samchon/typia@next/packages/utils/lib/utils/NamingConvention.js\";\nvar NamingConventionExports = requireNamingConvention();\nexport { NamingConventionExports as __moduleExports };\nexport default /*@__PURE__*/getDefaultExportFromCjs(NamingConventionExports);"],"names":[],"mappings":";;;AAEA,IAAI,uBAAuB,GAAG,uBAAuB,EAAE;AAEvD,uBAAe,aAAa,uBAAuB,CAAC,uBAAuB,CAAC;;;;"}
+{"version":3,"file":"NamingConvention.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}