typia 13.0.0 → 13.0.1

package/lib/plain.mjs

@@ -1,3 +1,119 @@
-export { assertClassify, assertClone, assertPrune, classify, clone, createAssertClassify, createAssertClone, createAssertPrune, createClassify, createClone, createIsClone, createIsPrune, createPrune, createValidateClassify, createValidateClone, createValidatePrune, isClone, isPrune, prune, validateClassify, validateClone, validatePrune } from './plain2.mjs';
-export { __exports as default } from './_virtual/plain.mjs';
-//# sourceMappingURL=plain.mjs.map
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/plain.ts
+var plain_exports = /* @__PURE__ */ __exportAll({
+	assertClassify: () => assertClassify,
+	assertClone: () => assertClone,
+	assertPrune: () => assertPrune,
+	classify: () => classify,
+	clone: () => clone,
+	createAssertClassify: () => createAssertClassify,
+	createAssertClone: () => createAssertClone,
+	createAssertPrune: () => createAssertPrune,
+	createClassify: () => createClassify,
+	createClone: () => createClone,
+	createIsClone: () => createIsClone,
+	createIsPrune: () => createIsPrune,
+	createPrune: () => createPrune,
+	createValidateClassify: () => createValidateClassify,
+	createValidateClone: () => createValidateClone,
+	createValidatePrune: () => createValidatePrune,
+	isClone: () => isClone,
+	isPrune: () => isPrune,
+	prune: () => prune,
+	validateClassify: () => validateClassify,
+	validateClone: () => validateClone,
+	validatePrune: () => validatePrune
+});
+/** @internal */
+function clone() {
+	NoTransformConfigurationError("plain.clone");
+}
+/** @internal */
+function assertClone() {
+	NoTransformConfigurationError("plain.assertClone");
+}
+/** @internal */
+function isClone() {
+	NoTransformConfigurationError("plain.isClone");
+}
+/** @internal */
+function validateClone() {
+	NoTransformConfigurationError("plain.validateClone");
+}
+/** @internal */
+function prune() {
+	NoTransformConfigurationError("plain.prune");
+}
+/** @internal */
+function assertPrune() {
+	NoTransformConfigurationError("plain.assertPrune");
+}
+/** @internal */
+function isPrune() {
+	NoTransformConfigurationError("plain.isPrune");
+}
+/** @internal */
+function validatePrune() {
+	NoTransformConfigurationError("plain.validatePrune");
+}
+/** @internal */
+function classify() {
+	NoTransformConfigurationError("plain.classify");
+}
+/** @internal */
+function assertClassify() {
+	NoTransformConfigurationError("plain.assertClassify");
+}
+/** @internal */
+function validateClassify() {
+	NoTransformConfigurationError("plain.validateClassify");
+}
+/** @internal */
+function createClone() {
+	NoTransformConfigurationError("plain.createClone");
+}
+/** @internal */
+function createAssertClone() {
+	NoTransformConfigurationError("plain.createAssertClone");
+}
+/** @internal */
+function createIsClone() {
+	NoTransformConfigurationError("plain.createIsClone");
+}
+/** @internal */
+function createValidateClone() {
+	NoTransformConfigurationError("plain.createValidateClone");
+}
+/** @internal */
+function createPrune() {
+	NoTransformConfigurationError("plain.createPrune");
+}
+/** @internal */
+function createAssertPrune() {
+	NoTransformConfigurationError("plain.createAssertPrune");
+}
+/** @internal */
+function createIsPrune() {
+	NoTransformConfigurationError("plain.createIsPrune");
+}
+/** @internal */
+function createValidatePrune() {
+	NoTransformConfigurationError("plain.createValidatePrune");
+}
+/** @internal */
+function createClassify() {
+	NoTransformConfigurationError("plain.createClassify");
+}
+/** @internal */
+function createAssertClassify() {
+	NoTransformConfigurationError("plain.createAssertClassify");
+}
+/** @internal */
+function createValidateClassify() {
+	NoTransformConfigurationError("plain.createValidateClassify");
+}
+//#endregion
+export { assertClassify, assertClone, assertPrune, classify, clone, createAssertClassify, createAssertClone, createAssertPrune, createClassify, createClone, createIsClone, createIsPrune, createPrune, createValidateClassify, createValidateClone, createValidatePrune, isClone, isPrune, plain_exports, prune, validateClassify, validateClone, validatePrune };
+
+//# sourceMappingURL=plain.mjs.map

package/lib/plain.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"plain.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"plain.mjs","names":[],"sources":["../src/plain.ts"],"sourcesContent":["/* ===========================================================\n    PLAIN\n      - CLONE\n      - PRUNE\n      - CLASSIFY\n      - FACTORY FUNCTIONS\n=========================================================== */\nimport {\n  Classifiable,\n  ClassifyResult,\n  IValidation,\n  Resolved,\n} from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* -----------------------------------------------------------\n    CLONE\n----------------------------------------------------------- */\n/**\n * Deep clones value of type `T`.\n *\n * Creates a deep copy of the input value. Class instances with methods are\n * cloned as plain objects (methods are not copied).\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertClone} — Throws on type mismatch\n * - {@link isClone} — Returns `null` on type mismatch\n * - {@link validateClone} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to clone\n * @returns Deep cloned value\n */\nexport function clone<T>(input: T): Resolved<T>;\n\n/** @internal */\nexport function clone(): never {\n  NoTransformConfigurationError(\"plain.clone\");\n}\n\n/**\n * Deep clones value with assertion.\n *\n * Creates a deep copy with {@link assert} validation. Throws\n * {@link TypeGuardError} on type mismatch. Class instances with methods are\n * cloned as plain objects.\n *\n * Related functions:\n *\n * - {@link clone} — No validation\n * - {@link isClone} — Returns `null` instead of throwing\n * - {@link validateClone} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to clone\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Deep cloned value\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertClone<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Resolved<T>;\n\n/** @internal */\nexport function assertClone<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Resolved<T>;\n\n/** @internal */\nexport function assertClone(): never {\n  NoTransformConfigurationError(\"plain.assertClone\");\n}\n\n/**\n * Deep clones value with type checking.\n *\n * Creates a deep copy with {@link is} validation. Returns `null` on type\n * mismatch. Class instances with methods are cloned as plain objects.\n *\n * Related functions:\n *\n * - {@link clone} — No validation\n * - {@link assertClone} — Throws instead of returning `null`\n * - {@link validateClone} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to clone\n * @returns Deep cloned value, or `null` if invalid\n */\nexport function isClone<T>(input: T): Resolved<T> | null;\n\n/** @internal */\nexport function isClone<T>(input: unknown): Resolved<T> | null;\n\n/** @internal */\nexport function isClone(): never {\n  NoTransformConfigurationError(\"plain.isClone\");\n}\n\n/**\n * Deep clones value with validation.\n *\n * Creates a deep copy with {@link validate} validation. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with cloned value. Class instances with methods\n * are cloned as plain objects.\n *\n * Related functions:\n *\n * - {@link clone} — No validation\n * - {@link assertClone} — Throws on first error\n * - {@link isClone} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Value to clone\n * @returns Validation result containing cloned value or errors\n */\nexport function validateClone<T>(input: T): IValidation<Resolved<T>>;\n\n/** @internal */\nexport function validateClone<T>(input: unknown): IValidation<Resolved<T>>;\n\n/** @internal */\nexport function validateClone(): never {\n  NoTransformConfigurationError(\"plain.validateClone\");\n}\n\n/* -----------------------------------------------------------\n    PRUNE\n----------------------------------------------------------- */\n/**\n * Removes superfluous properties from object.\n *\n * Deletes all properties not defined in type `T`, including in nested objects.\n * Mutates the input directly—removed properties cannot be recovered.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertPrune} — Throws on type mismatch\n * - {@link isPrune} — Returns `false` on type mismatch\n * - {@link validatePrune} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to prune\n */\nexport function prune<T extends object>(input: T): void;\n\n/** @internal */\nexport function prune(): never {\n  NoTransformConfigurationError(\"plain.prune\");\n}\n\n/**\n * Removes superfluous properties with assertion.\n *\n * Combines {@link assert} with {@link prune}. Throws {@link TypeGuardError} on\n * type mismatch. Mutates the input directly—removed properties cannot be\n * recovered.\n *\n * Related functions:\n *\n * - {@link prune} — No validation\n * - {@link isPrune} — Returns `false` instead of throwing\n * - {@link validatePrune} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to assert and prune\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns The pruned input\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertPrune<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertPrune<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertPrune(): unknown {\n  NoTransformConfigurationError(\"plain.assertPrune\");\n}\n\n/**\n * Removes superfluous properties with type checking.\n *\n * Combines {@link is} with {@link prune}. Returns `false` on type mismatch (no\n * pruning occurs). Returns `true` after successful pruning. Mutates the input\n * directly.\n *\n * Related functions:\n *\n * - {@link prune} — No validation\n * - {@link assertPrune} — Throws instead of returning `false`\n * - {@link validatePrune} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to check and prune\n * @returns `true` if valid and pruned, `false` if type mismatch\n */\nexport function isPrune<T>(input: T): input is T;\n\n/** @internal */\nexport function isPrune<T>(input: unknown): input is T;\n\n/** @internal */\nexport function isPrune(): never {\n  NoTransformConfigurationError(\"plain.isPrune\");\n}\n\n/**\n * Removes superfluous properties with validation.\n *\n * Combines {@link validate} with {@link prune}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch (no pruning occurs),\n * or {@link IValidation.ISuccess} after successful pruning. Mutates the input\n * directly.\n *\n * Related functions:\n *\n * - {@link prune} — No validation\n * - {@link assertPrune} — Throws on first error\n * - {@link isPrune} — Returns `false` instead of error details\n *\n * @template T Type of input value\n * @param input Object to validate and prune\n * @returns Validation result\n */\nexport function validatePrune<T>(input: T): IValidation<T>;\n\n/** @internal */\nexport function validatePrune<T>(input: unknown): IValidation<T>;\n\n/** @internal */\nexport function validatePrune<T>(): IValidation<T> {\n  NoTransformConfigurationError(\"plain.validatePrune\");\n}\n\n/* -----------------------------------------------------------\n    CLASSIFY\n----------------------------------------------------------- */\n/**\n * Reconstructs a class instance from plain data.\n *\n * Builds a real instance of class type `T` from a plain object, driven by\n * typia's compile-time type information — no decorators required (unlike\n * `class-transformer`). Each class is constructed by exactly one strategy, in\n * precedence order: a static factory `T.from(x)`, then `new T(x)` (single\n * argument), then field copy onto the prototype. Nested classes and containers\n * are reconstructed recursively, and methods come from the prototype.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertClassify} — Throws on type mismatch\n * - {@link validateClassify} — Returns detailed validation errors\n *\n * @template T Target class type to reconstruct\n * @param input Plain data to classify\n * @returns A real instance of type `T`\n */\nexport function classify<T>(input: Classifiable<T>): ClassifyResult<T>;\n\n/** @internal */\nexport function classify(): never {\n  NoTransformConfigurationError(\"plain.classify\");\n}\n\n/**\n * Reconstructs a class instance with assertion.\n *\n * Combines {@link assert} with {@link classify}: validates the plain input\n * against type `T`, throwing {@link TypeGuardError} on mismatch, then builds a\n * real instance of `T`.\n *\n * Related functions:\n *\n * - {@link classify} — No validation\n * - {@link validateClassify} — Returns detailed validation errors\n *\n * @template T Target class type to reconstruct\n * @param input Plain data to validate and classify\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns A real instance of type `T`\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertClassify<T>(\n  input: Classifiable<T>,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): ClassifyResult<T>;\n\n/** @internal */\nexport function assertClassify<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): ClassifyResult<T>;\n\n/** @internal */\nexport function assertClassify(): never {\n  NoTransformConfigurationError(\"plain.assertClassify\");\n}\n\n/**\n * Reconstructs a class instance with validation.\n *\n * Combines {@link validate} with {@link classify}: validates the plain input\n * against type `T`, returning {@link IValidation.IFailure} with all errors on\n * mismatch, or {@link IValidation.ISuccess} holding a real instance of `T`.\n *\n * Related functions:\n *\n * - {@link classify} — No validation\n * - {@link assertClassify} — Throws on first error\n *\n * @template T Target class type to reconstruct\n * @param input Plain data to validate and classify\n * @returns Validation result containing the instance or errors\n */\nexport function validateClassify<T>(\n  input: Classifiable<T>,\n): IValidation<ClassifyResult<T>>;\n\n/** @internal */\nexport function validateClassify<T>(\n  input: unknown,\n): IValidation<ClassifyResult<T>>;\n\n/** @internal */\nexport function validateClassify(): never {\n  NoTransformConfigurationError(\"plain.validateClassify\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link clone} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createClone(): never;\n\n/**\n * Creates reusable {@link clone} function.\n *\n * @template T Type of input value\n * @returns Reusable clone function\n */\nexport function createClone<T>(): (input: T) => Resolved<T>;\n\n/** @internal */\nexport function createClone(): never {\n  NoTransformConfigurationError(\"plain.createClone\");\n}\n\n/**\n * Creates reusable {@link assertClone} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertClone(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertClone} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable clone function\n */\nexport function createAssertClone<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => Resolved<T>;\n\n/** @internal */\nexport function createAssertClone(): never {\n  NoTransformConfigurationError(\"plain.createAssertClone\");\n}\n\n/**\n * Creates reusable {@link isClone} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsClone(): never;\n\n/**\n * Creates reusable {@link isClone} function.\n *\n * @template T Type of input value\n * @returns Reusable clone function\n */\nexport function createIsClone<T>(): (input: unknown) => Resolved<T> | null;\n\n/** @internal */\nexport function createIsClone(): never {\n  NoTransformConfigurationError(\"plain.createIsClone\");\n}\n\n/**\n * Creates reusable {@link validateClone} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateClone(): never;\n\n/**\n * Creates reusable {@link validateClone} function.\n *\n * @template T Type of input value\n * @returns Reusable clone function\n */\nexport function createValidateClone<T>(): (\n  input: unknown,\n) => IValidation<Resolved<T>>;\n\n/** @internal */\nexport function createValidateClone(): never {\n  NoTransformConfigurationError(\"plain.createValidateClone\");\n}\n\n/**\n * Creates reusable {@link prune} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createPrune(): never;\n\n/**\n * Creates reusable {@link prune} function.\n *\n * @template T Type of input value\n * @returns Reusable prune function\n */\nexport function createPrune<T extends object>(): (input: T) => void;\n\n/** @internal */\nexport function createPrune(): never {\n  NoTransformConfigurationError(\"plain.createPrune\");\n}\n\n/**\n * Creates reusable {@link assertPrune} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertPrune(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertPrune} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable prune function\n */\nexport function createAssertPrune<T extends object>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => T;\n\n/** @internal */\nexport function createAssertPrune(): never {\n  NoTransformConfigurationError(\"plain.createAssertPrune\");\n}\n\n/**\n * Creates reusable {@link isPrune} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsPrune(): never;\n\n/**\n * Creates reusable {@link isPrune} function.\n *\n * @template T Type of input value\n * @returns Reusable prune function\n */\nexport function createIsPrune<T extends object>(): (\n  input: unknown,\n) => input is T;\n\n/** @internal */\nexport function createIsPrune(): never {\n  NoTransformConfigurationError(\"plain.createIsPrune\");\n}\n\n/**\n * Creates reusable {@link validatePrune} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidatePrune(): never;\n\n/**\n * Creates reusable {@link validatePrune} function.\n *\n * @template T Type of input value\n * @returns Reusable prune function\n */\nexport function createValidatePrune<T extends object>(): (\n  input: unknown,\n) => IValidation<T>;\n\n/** @internal */\nexport function createValidatePrune(): never {\n  NoTransformConfigurationError(\"plain.createValidatePrune\");\n}\n\n/**\n * Creates reusable {@link classify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createClassify(): never;\n\n/**\n * Creates reusable {@link classify} function.\n *\n * @template T Target class type to reconstruct\n * @returns Reusable classify function\n */\nexport function createClassify<T>(): (\n  input: Classifiable<T>,\n) => ClassifyResult<T>;\n\n/** @internal */\nexport function createClassify(): never {\n  NoTransformConfigurationError(\"plain.createClassify\");\n}\n\n/**\n * Creates reusable {@link assertClassify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertClassify(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertClassify} function.\n *\n * @template T Target class type to reconstruct\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable classify function\n */\nexport function createAssertClassify<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => ClassifyResult<T>;\n\n/** @internal */\nexport function createAssertClassify(): never {\n  NoTransformConfigurationError(\"plain.createAssertClassify\");\n}\n\n/**\n * Creates reusable {@link validateClassify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateClassify(): never;\n\n/**\n * Creates reusable {@link validateClassify} function.\n *\n * @template T Target class type to reconstruct\n * @returns Reusable classify function\n */\nexport function createValidateClassify<T>(): (\n  input: unknown,\n) => IValidation<ClassifyResult<T>>;\n\n/** @internal */\nexport function createValidateClassify(): never {\n  NoTransformConfigurationError(\"plain.createValidateClassify\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,QAAe;CAC7B,8BAA8B,aAAa;AAC7C;;AAkCA,SAAgB,cAAqB;CACnC,8BAA8B,mBAAmB;AACnD;;AAwBA,SAAgB,UAAiB;CAC/B,8BAA8B,eAAe;AAC/C;;AA0BA,SAAgB,gBAAuB;CACrC,8BAA8B,qBAAqB;AACrD;;AAuBA,SAAgB,QAAe;CAC7B,8BAA8B,aAAa;AAC7C;;AAkCA,SAAgB,cAAuB;CACrC,8BAA8B,mBAAmB;AACnD;;AAyBA,SAAgB,UAAiB;CAC/B,8BAA8B,eAAe;AAC/C;;AA0BA,SAAgB,gBAAmC;CACjD,8BAA8B,qBAAqB;AACrD;;AA2BA,SAAgB,WAAkB;CAChC,8BAA8B,gBAAgB;AAChD;;AAiCA,SAAgB,iBAAwB;CACtC,8BAA8B,sBAAsB;AACtD;;AA4BA,SAAgB,mBAA0B;CACxC,8BAA8B,wBAAwB;AACxD;;AAqBA,SAAgB,cAAqB;CACnC,8BAA8B,mBAAmB;AACnD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,yBAAyB;AACzD;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,qBAAqB;AACrD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,2BAA2B;AAC3D;;AAkBA,SAAgB,cAAqB;CACnC,8BAA8B,mBAAmB;AACnD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,gBAAuB;CACrC,8BAA8B,qBAAqB;AACrD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,2BAA2B;AAC3D;;AAoBA,SAAgB,iBAAwB;CACtC,8BAA8B,sBAAsB;AACtD;;AAwBA,SAAgB,uBAA8B;CAC5C,8BAA8B,4BAA4B;AAC5D;;AAoBA,SAAgB,yBAAgC;CAC9C,8BAA8B,8BAA8B;AAC9D"}

package/lib/protobuf.mjs

@@ -1,3 +1,94 @@
-export { assertDecode, assertEncode, createAssertDecode, createAssertEncode, createDecode, createEncode, createIsDecode, createIsEncode, createValidateDecode, createValidateEncode, decode, encode, isDecode, isEncode, message, validateDecode, validateEncode } from './protobuf2.mjs';
-export { __exports as default } from './_virtual/protobuf.mjs';
-//# sourceMappingURL=protobuf.mjs.map
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/protobuf.ts
+var protobuf_exports = /* @__PURE__ */ __exportAll({
+	assertDecode: () => assertDecode,
+	assertEncode: () => assertEncode,
+	createAssertDecode: () => createAssertDecode,
+	createAssertEncode: () => createAssertEncode,
+	createDecode: () => createDecode,
+	createEncode: () => createEncode,
+	createIsDecode: () => createIsDecode,
+	createIsEncode: () => createIsEncode,
+	createValidateDecode: () => createValidateDecode,
+	createValidateEncode: () => createValidateEncode,
+	decode: () => decode,
+	encode: () => encode,
+	isDecode: () => isDecode,
+	isEncode: () => isEncode,
+	message: () => message,
+	validateDecode: () => validateDecode,
+	validateEncode: () => validateEncode
+});
+/** @internal */
+function message() {
+	NoTransformConfigurationError("protobuf.message");
+}
+/** @internal */
+function decode() {
+	NoTransformConfigurationError("protobuf.decode");
+}
+/** @internal */
+function assertDecode() {
+	NoTransformConfigurationError("protobuf.assertDecode");
+}
+/** @internal */
+function isDecode() {
+	NoTransformConfigurationError("protobuf.isDecode");
+}
+/** @internal */
+function validateDecode() {
+	NoTransformConfigurationError("protobuf.validateDecode");
+}
+/** @internal */
+function encode() {
+	NoTransformConfigurationError("protobuf.encode");
+}
+/** @internal */
+function assertEncode() {
+	NoTransformConfigurationError("protobuf.assertEncode");
+}
+/** @internal */
+function isEncode() {
+	NoTransformConfigurationError("protobuf.isEncode");
+}
+/** @internal */
+function validateEncode() {
+	NoTransformConfigurationError("protobuf.validateEncode");
+}
+/** @internal */
+function createDecode() {
+	NoTransformConfigurationError("protobuf.createDecode");
+}
+/** @internal */
+function createIsDecode() {
+	NoTransformConfigurationError("protobuf.createIsDecode");
+}
+/** @internal */
+function createAssertDecode() {
+	NoTransformConfigurationError("protobuf.createAssertDecode");
+}
+/** @internal */
+function createValidateDecode() {
+	NoTransformConfigurationError("protobuf.createValidateDecode");
+}
+/** @internal */
+function createEncode() {
+	NoTransformConfigurationError("protobuf.createEncode");
+}
+/** @internal */
+function createIsEncode() {
+	NoTransformConfigurationError("protobuf.createIsEncode");
+}
+/** @internal */
+function createAssertEncode() {
+	NoTransformConfigurationError("protobuf.createAssertEncode");
+}
+/** @internal */
+function createValidateEncode() {
+	NoTransformConfigurationError("protobuf.createValidateEncode");
+}
+//#endregion
+export { assertDecode, assertEncode, createAssertDecode, createAssertEncode, createDecode, createEncode, createIsDecode, createIsEncode, createValidateDecode, createValidateEncode, decode, encode, isDecode, isEncode, message, protobuf_exports, validateDecode, validateEncode };
+
+//# sourceMappingURL=protobuf.mjs.map

package/lib/protobuf.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"protobuf.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"protobuf.mjs","names":[],"sources":["../src/protobuf.ts"],"sourcesContent":["import { IValidation, Resolved } from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* ===========================================================\n    PROTOCOL BUFFER\n      - MESSAGE\n      - DECODE\n      - ENCODE\n      - FACTORY FUNCTIONS\n==============================================================\n    SCHEMA\n----------------------------------------------------------- */\n/**\n * Generates Protocol Buffer message schema.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function message(): never;\n\n/**\n * Generates Protocol Buffer message schema for type `T`.\n *\n * Creates a `.proto` message definition string from a TypeScript type. Use for\n * sharing schemas with other languages/frameworks.\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Target type\n * @returns Protocol Buffer message schema string\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function message<T>(): string;\n\n/** @internal */\nexport function message(): never {\n  NoTransformConfigurationError(\"protobuf.message\");\n}\n\n/* -----------------------------------------------------------\n    DECODE\n----------------------------------------------------------- */\n/**\n * Decodes Protocol Buffer binary.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function decode(input: Uint8Array): never;\n\n/**\n * Decodes Protocol Buffer binary to type `T`.\n *\n * Converts Protocol Buffer binary data to a TypeScript instance. Binary data\n * must have been encoded from a `T`-typed value—invalid data causes undefined\n * behavior or errors.\n *\n * For type safety, ensure data was encoded via:\n *\n * - {@link assertEncode} — Encodes with type assertion\n * - {@link isEncode} — Encodes with type checking\n * - {@link validateEncode} — Encodes with validation\n *\n * Note: Decoder validation ({@link assertDecode}, etc.) only checks custom tags\n * like `number & Minimum<7>`, not structural type safety.\n *\n * @template T Target type\n * @param input Protocol Buffer binary data\n * @returns Decoded value of type `T`\n */\nexport function decode<T>(input: Uint8Array): Resolved<T>;\n\n/** @internal */\nexport function decode(): never {\n  NoTransformConfigurationError(\"protobuf.decode\");\n}\n\n/**\n * Decodes Protocol Buffer binary with assertion.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function assertDecode(\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Decodes Protocol Buffer binary with assertion (partial safety).\n *\n * Combines {@link decode} with {@link assert}. Throws {@link TypeGuardError} on\n * validation failure.\n *\n * Warning: Only validates custom tags (e.g., `number & Minimum<7>`, `string &\n * Format<\"uuid\">`), not structural type correctness. Ensure source data was\n * encoded with type-safe encoders.\n *\n * Related functions:\n *\n * - {@link decode} — No validation\n * - {@link isDecode} — Returns `null` instead of throwing\n * - {@link validateDecode} — Returns detailed validation errors\n *\n * @template T Target type\n * @param input Protocol Buffer binary data\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Decoded value of type `T`\n * @throws {TypeGuardError} When custom tag validation fails\n */\nexport function assertDecode<T>(\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Resolved<T>;\n\n/** @internal */\nexport function assertDecode(): never {\n  NoTransformConfigurationError(\"protobuf.assertDecode\");\n}\n\n/**\n * Decodes Protocol Buffer binary with type checking.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function isDecode(input: Uint8Array): never;\n\n/**\n * Decodes Protocol Buffer binary with type checking (partial safety).\n *\n * Combines {@link decode} with {@link is}. Returns `null` on validation failure.\n *\n * Warning: Only validates custom tags (e.g., `number & Minimum<7>`, `string &\n * Format<\"uuid\">`), not structural type correctness. Ensure source data was\n * encoded with type-safe encoders.\n *\n * Related functions:\n *\n * - {@link decode} — No validation\n * - {@link assertDecode} — Throws instead of returning `null`\n * - {@link validateDecode} — Returns detailed validation errors\n *\n * @template T Target type\n * @param input Protocol Buffer binary data\n * @returns Decoded value of type `T`, or `null` if invalid\n */\nexport function isDecode<T>(input: Uint8Array): Resolved<T> | null;\n\n/** @internal */\nexport function isDecode(): never {\n  NoTransformConfigurationError(\"protobuf.isDecode\");\n}\n\n/**\n * Decodes Protocol Buffer binary with validation.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function validateDecode(input: Uint8Array): never;\n\n/**\n * Decodes Protocol Buffer binary with validation (partial safety).\n *\n * Combines {@link decode} with {@link validate}. Returns\n * {@link IValidation.IFailure} with errors on mismatch, or\n * {@link IValidation.ISuccess} with decoded value.\n *\n * Warning: Only validates custom tags (e.g., `number & Minimum<7>`, `string &\n * Format<\"uuid\">`), not structural type correctness. Ensure source data was\n * encoded with type-safe encoders.\n *\n * Related functions:\n *\n * - {@link decode} — No validation\n * - {@link assertDecode} — Throws on first error\n * - {@link isDecode} — Returns `null` instead of error details\n *\n * @template T Target type\n * @param input Protocol Buffer binary data\n * @returns Validation result containing decoded value or errors\n */\nexport function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;\n\n/** @internal */\nexport function validateDecode(): never {\n  NoTransformConfigurationError(\"protobuf.validateDecode\");\n}\n\n/* -----------------------------------------------------------\n    ENCODE\n----------------------------------------------------------- */\n/**\n * Encodes value to Protocol Buffer binary.\n *\n * Converts a TypeScript value to Protocol Buffer binary format.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertEncode} — Throws on type mismatch\n * - {@link isEncode} — Returns `null` on type mismatch\n * - {@link validateEncode} — Returns detailed validation errors\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n * @param input Value to encode\n * @returns Protocol Buffer binary data\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function encode<T>(input: T): Uint8Array;\n\n/** @internal */\nexport function encode(): never {\n  NoTransformConfigurationError(\"protobuf.encode\");\n}\n\n/**\n * Encodes value to Protocol Buffer binary with assertion.\n *\n * Combines {@link assert} with {@link encode}. Throws {@link TypeGuardError} on\n * type mismatch.\n *\n * Related functions:\n *\n * - {@link encode} — No validation\n * - {@link isEncode} — Returns `null` instead of throwing\n * - {@link validateEncode} — Returns detailed validation errors\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n * @param input Value to encode\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Protocol Buffer binary data\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function assertEncode<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Uint8Array;\n\n/** @internal */\nexport function assertEncode<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Uint8Array;\n\n/** @internal */\nexport function assertEncode(): never {\n  NoTransformConfigurationError(\"protobuf.assertEncode\");\n}\n\n/**\n * Encodes value to Protocol Buffer binary with type checking.\n *\n * Combines {@link is} with {@link encode}. Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link encode} — No validation\n * - {@link assertEncode} — Throws instead of returning `null`\n * - {@link validateEncode} — Returns detailed validation errors\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n * @param input Value to encode\n * @returns Protocol Buffer binary data, or `null` if invalid\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function isEncode<T>(input: T): Uint8Array | null;\n\n/** @internal */\nexport function isEncode<T>(input: unknown): Uint8Array | null;\n\n/** @internal */\nexport function isEncode(): never {\n  NoTransformConfigurationError(\"protobuf.isEncode\");\n}\n\n/**\n * Encodes value to Protocol Buffer binary with validation.\n *\n * Combines {@link validate} with {@link encode}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with binary data.\n *\n * Related functions:\n *\n * - {@link encode} — No validation\n * - {@link assertEncode} — Throws on first error\n * - {@link isEncode} — Returns `null` instead of error details\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n * @param input Value to encode\n * @returns Validation result containing binary data or errors\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function validateEncode<T>(input: T): IValidation<Uint8Array>;\n\n/** @internal */\nexport function validateEncode<T>(input: unknown): IValidation<Uint8Array>;\n\n/** @internal */\nexport function validateEncode(): never {\n  NoTransformConfigurationError(\"protobuf.validateEncode\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link decode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createDecode(): never;\n\n/**\n * Creates reusable {@link decode} function.\n *\n * @template T Target type\n * @returns Reusable decoder function\n */\nexport function createDecode<T>(): (input: Uint8Array) => Resolved<T>;\n\n/** @internal */\nexport function createDecode<T>(): (input: Uint8Array) => Resolved<T> {\n  NoTransformConfigurationError(\"protobuf.createDecode\");\n}\n\n/**\n * Creates reusable {@link isDecode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsDecode(): never;\n\n/**\n * Creates reusable {@link isDecode} function.\n *\n * @template T Target type\n * @returns Reusable decoder function\n */\nexport function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;\n\n/** @internal */\nexport function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null {\n  NoTransformConfigurationError(\"protobuf.createIsDecode\");\n}\n\n/**\n * Creates reusable {@link assertDecode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertDecode(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertDecode} function.\n *\n * @template T Target type\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable decoder function\n */\nexport function createAssertDecode<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: Uint8Array) => Resolved<T>;\n\n/** @internal */\nexport function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {\n  NoTransformConfigurationError(\"protobuf.createAssertDecode\");\n}\n\n/**\n * Creates reusable {@link validateDecode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateDecode(): never;\n\n/**\n * Creates reusable {@link validateDecode} function.\n *\n * @template T Target type\n * @returns Reusable decoder function\n */\nexport function createValidateDecode<T>(): (\n  input: Uint8Array,\n) => IValidation<Resolved<T>>;\n\n/** @internal */\nexport function createValidateDecode<T>(): (\n  input: Uint8Array,\n) => IValidation<Resolved<T>> {\n  NoTransformConfigurationError(\"protobuf.createValidateDecode\");\n}\n\n/**\n * Creates reusable {@link encode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createEncode(): never;\n\n/**\n * Creates reusable {@link encode} function.\n *\n * @template T Type of input value\n * @returns Reusable encoder function\n */\nexport function createEncode<T>(): (input: T) => Uint8Array;\n\n/** @internal */\nexport function createEncode<T>(): (input: T) => Uint8Array {\n  NoTransformConfigurationError(\"protobuf.createEncode\");\n}\n\n/**\n * Creates reusable {@link isEncode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsEncode(): never;\n\n/**\n * Creates reusable {@link isEncode} function.\n *\n * @template T Type of input value\n * @returns Reusable encoder function\n */\nexport function createIsEncode<T>(): (input: T) => Uint8Array | null;\n\n/** @internal */\nexport function createIsEncode<T>(): (input: T) => Uint8Array | null {\n  NoTransformConfigurationError(\"protobuf.createIsEncode\");\n}\n\n/**\n * Creates reusable {@link assertEncode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertEncode(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertEncode} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable encoder function\n */\nexport function createAssertEncode<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => Uint8Array;\n\n/** @internal */\nexport function createAssertEncode<T>(): (input: T) => Uint8Array {\n  NoTransformConfigurationError(\"protobuf.createAssertEncode\");\n}\n\n/**\n * Creates reusable {@link validateEncode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateEncode(): never;\n\n/**\n * Creates reusable {@link validateEncode} function.\n *\n * @template T Type of input value\n * @returns Reusable encoder function\n */\nexport function createValidateEncode<T>(): (\n  input: T,\n) => IValidation<Uint8Array>;\n\n/** @internal */\nexport function createValidateEncode<T>(): (\n  input: T,\n) => IValidation<Uint8Array> {\n  NoTransformConfigurationError(\"protobuf.createValidateEncode\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,UAAiB;CAC/B,8BAA8B,kBAAkB;AAClD;;AAmCA,SAAgB,SAAgB;CAC9B,8BAA8B,iBAAiB;AACjD;;AAyCA,SAAgB,eAAsB;CACpC,8BAA8B,uBAAuB;AACvD;;AA+BA,SAAgB,WAAkB;CAChC,8BAA8B,mBAAmB;AACnD;;AAiCA,SAAgB,iBAAwB;CACtC,8BAA8B,yBAAyB;AACzD;;AA2BA,SAAgB,SAAgB;CAC9B,8BAA8B,iBAAiB;AACjD;;AAqCA,SAAgB,eAAsB;CACpC,8BAA8B,uBAAuB;AACvD;;AA2BA,SAAgB,WAAkB;CAChC,8BAA8B,mBAAmB;AACnD;;AA6BA,SAAgB,iBAAwB;CACtC,8BAA8B,yBAAyB;AACzD;;AAqBA,SAAgB,eAAsD;CACpE,8BAA8B,uBAAuB;AACvD;;AAkBA,SAAgB,iBAA+D;CAC7E,8BAA8B,yBAAyB;AACzD;;AAwBA,SAAgB,qBAA4D;CAC1E,8BAA8B,6BAA6B;AAC7D;;AAoBA,SAAgB,uBAEc;CAC5B,8BAA8B,+BAA+B;AAC/D;;AAkBA,SAAgB,eAA4C;CAC1D,8BAA8B,uBAAuB;AACvD;;AAkBA,SAAgB,iBAAqD;CACnE,8BAA8B,yBAAyB;AACzD;;AAwBA,SAAgB,qBAAkD;CAChE,8BAA8B,6BAA6B;AAC7D;;AAoBA,SAAgB,uBAEa;CAC3B,8BAA8B,+BAA+B;AAC/D"}

package/lib/re-exports.d.ts

@@ -1 +1,2 @@
-export { AssertionGuard, IJsonParseResult, IValidation, IRandomGenerator, OpenApi, IJsonSchemaCollection, IJsonSchemaUnit, ILlmController, ILlmApplication, ILlmFunction, ILlmStructuredOutput, ILlmSchema, IMetadataSchema, IMetadataSchemaCollection, IMetadataSchemaUnit, IMetadataComponents, IMetadataTypeTag, IJsDocTagInfo, Classifiable, ClassifyResult, Primitive, Resolved, CamelCase, KebabCase, PascalCase, SnakeCase, IReadableURLSearchParams, tags, } from "@typia/interface";
+export type { AssertionGuard, IJsonParseResult, IValidation, IRandomGenerator, OpenApi, IJsonSchemaCollection, IJsonSchemaUnit, ILlmController, ILlmApplication, ILlmFunction, ILlmStructuredOutput, ILlmSchema, IMetadataSchema, IMetadataSchemaCollection, IMetadataSchemaUnit, IMetadataComponents, IMetadataTypeTag, IJsDocTagInfo, Classifiable, ClassifyResult, Primitive, Resolved, CamelCase, KebabCase, PascalCase, SnakeCase, IReadableURLSearchParams, } from "@typia/interface";
+export { tags } from "@typia/interface";

package/lib/re-exports.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tags = void 0;
+// `tags` is the only runtime value `@typia/interface` exports. Everything
+// above must stay `export type`: the `.mjs` build transpiles per file
+// (rolldown/oxc, no cross-file type info), so a plain re-export of a type
+// would survive as a runtime import and crash against the CJS-only
+// `@typia/interface`.
 var interface_1 = require("@typia/interface");
-// namespaces
 Object.defineProperty(exports, "tags", { enumerable: true, get: function () { return interface_1.tags; } });
 //# sourceMappingURL=re-exports.js.map

package/lib/re-exports.js.map

@@ -1 +1 @@
-{"version":3,"file":"re-exports.js","sourceRoot":"","sources":["../src/re-exports.ts"],"names":[],"mappings":";;;AAAA,8CAoC0B;AAFxB,aAAa;AACb,iGAAA,IAAI,OAAA"}
+{"version":3,"file":"re-exports.js","sourceRoot":"","sources":["../src/re-exports.ts"],"names":[],"mappings":";;;AAoCA,0EAA0E;AAC1E,sEAAsE;AACtE,0EAA0E;AAC1E,mEAAmE;AACnE,sBAAsB;AACtB,8CAAwC;AAA/B,iGAAA,IAAI,OAAA"}

package/lib/re-exports.mjs

@@ -1,2 +1,2 @@
-export { default } from './re-exports2.mjs';
-//# sourceMappingURL=re-exports.mjs.map
+import { tags } from "@typia/interface";
+export { tags };

package/lib/reflect.mjs

@@ -1,3 +1,29 @@
-export { literals, name, schema, schemas } from './reflect2.mjs';
-export { __exports as default } from './_virtual/reflect.mjs';
-//# sourceMappingURL=reflect.mjs.map
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/reflect.ts
+var reflect_exports = /* @__PURE__ */ __exportAll({
+	literals: () => literals,
+	name: () => name,
+	schema: () => schema,
+	schemas: () => schemas
+});
+/** @internal */
+function schemas() {
+	NoTransformConfigurationError("reflect.schemas");
+}
+/** @internal */
+function schema() {
+	NoTransformConfigurationError("reflect.schema");
+}
+/** @internal */
+function name() {
+	NoTransformConfigurationError("reflect.name");
+}
+/** @internal */
+function literals() {
+	NoTransformConfigurationError("reflect.literals");
+}
+//#endregion
+export { literals, name, reflect_exports, schema, schemas };
+
+//# sourceMappingURL=reflect.mjs.map

package/lib/reflect.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"reflect.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"reflect.mjs","names":[],"sources":["../src/reflect.ts"],"sourcesContent":["import {\n  Atomic,\n  IMetadataSchemaCollection,\n  IMetadataSchemaUnit,\n} from \"@typia/interface\";\n\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/**\n * Generates metadata schemas for multiple types.\n *\n * @danger You must configure the generic argument `Types`\n */\nexport function schemas(): never;\n\n/**\n * Generates metadata schemas for multiple types.\n *\n * Creates {@link IMetadataSchemaCollection} containing metadata for all types in\n * the tuple. Collection types (Array, Tuple, Object) are stored in\n * `components`. Alias types are stored in `aliases`.\n *\n * @template Types Tuple of target types\n * @returns Metadata schema collection\n */\nexport function schemas<Types extends unknown[]>(): IMetadataSchemaCollection;\n\n/** @internal */\nexport function schemas(): never {\n  NoTransformConfigurationError(\"reflect.schemas\");\n}\n\n/**\n * Generates metadata schema for a single type.\n *\n * @danger You must configure the generic argument `Type`\n */\nexport function schema(): never;\n\n/**\n * Generates metadata schema for a single type.\n *\n * Creates {@link IMetadataSchemaUnit} containing metadata for the type.\n *\n * @template Type Target type\n * @returns Metadata schema unit\n */\nexport function schema<Type>(): IMetadataSchemaUnit;\n\n/** @internal */\nexport function schema(): never {\n  NoTransformConfigurationError(\"reflect.schema\");\n}\n\n/**\n * Gets the runtime type name of type `T`.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function name(): never;\n\n/**\n * Gets the runtime type name of type `T`.\n *\n * Returns a string representation of the type name.\n *\n * @template T Target type\n * @template Regular If `true`, returns regular (normalized) name\n * @returns Type name string\n */\nexport function name<T, Regular extends boolean = false>(): string;\n\n/** @internal */\nexport function name(): never {\n  NoTransformConfigurationError(\"reflect.name\");\n}\n\n/**\n * Converts union literal type to array.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function literals(): never;\n\n/**\n * Converts union literal type to array.\n *\n * Extracts all members of a union literal type `T` into an array at runtime.\n *\n * @template T Union literal type (e.g., `\"A\" | \"B\" | 1`)\n * @returns Array containing all union members\n */\nexport function literals<T extends Atomic.Type | null>(): T[];\n\n/** @internal */\nexport function literals(): never {\n  NoTransformConfigurationError(\"reflect.literals\");\n}\n"],"mappings":";;;;;;;;;;AA4BA,SAAgB,UAAiB;CAC/B,8BAA8B,iBAAiB;AACjD;;AAoBA,SAAgB,SAAgB;CAC9B,8BAA8B,gBAAgB;AAChD;;AAqBA,SAAgB,OAAc;CAC5B,8BAA8B,cAAc;AAC9C;;AAoBA,SAAgB,WAAkB;CAChC,8BAA8B,kBAAkB;AAClD"}

package/lib/transform.mjs

@@ -1,2 +1,15 @@
-export { createTtscPlugin, default } from './transform2.mjs';
-//# sourceMappingURL=transform.mjs.map
+import path from "node:path";
+import { createRequire } from "node:module";
+//#region src/transform.ts
+function createTtscPlugin(context) {
+	const requireFrom = createRequire(path.join(context.projectRoot, "package.json"));
+	const root = path.dirname(requireFrom.resolve("typia/package.json"));
+	return {
+		name: "typia",
+		source: path.resolve(root, "native", "cmd", "ttsc-typia")
+	};
+}
+//#endregion
+export { createTtscPlugin, createTtscPlugin as default };
+
+//# sourceMappingURL=transform.mjs.map

package/lib/transform.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"transform.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"transform.mjs","names":[],"sources":["../src/transform.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\nimport path from \"node:path\";\nimport type { ITtscPlugin, ITtscPluginFactoryContext } from \"ttsc\";\n\nexport function createTtscPlugin(\n  context: ITtscPluginFactoryContext,\n): ITtscPlugin {\n  // ttsc loads this descriptor as ESM, where the ambient `require` is\n  // unavailable; anchor a CJS resolver on the consuming project to locate\n  // typia's own package root (not the project root, which has no `native/`).\n  const requireFrom = createRequire(\n    path.join(context.projectRoot, \"package.json\"),\n  );\n  const root: string = path.dirname(requireFrom.resolve(\"typia/package.json\"));\n  return {\n    name: \"typia\",\n    source: path.resolve(root, \"native\", \"cmd\", \"ttsc-typia\"),\n  };\n}\n\nexport default createTtscPlugin;\n"],"mappings":";;;AAIA,SAAgB,iBACd,SACa;CAIb,MAAM,cAAc,cAClB,KAAK,KAAK,QAAQ,aAAa,cAAc,CAC/C;CACA,MAAM,OAAe,KAAK,QAAQ,YAAY,QAAQ,oBAAoB,CAAC;CAC3E,OAAO;EACL,MAAM;EACN,QAAQ,KAAK,QAAQ,MAAM,UAAU,OAAO,YAAY;CAC1D;AACF"}

package/lib/transformers/NoTransformConfigurationError.mjs

@@ -1,3 +1,19 @@
-export { NoTransformConfigurationError } from './NoTransformConfigurationError2.mjs';
-export { __exports as default } from '../_virtual/NoTransformConfigurationError.mjs';
-//# sourceMappingURL=NoTransformConfigurationError.mjs.map
+//#region src/transformers/NoTransformConfigurationError.ts
+/** @internal */
+function NoTransformConfigurationError(name) {
+	throw new Error([
+		`Error on typia.${name}(): no transform has been configured.`,
+		"",
+		"Read and follow https://typia.io/docs/setup please.",
+		"",
+		[
+			"If you've already completed the setup, it means there's",
+			"a bug in your code. Run `tsc` command so that check what",
+			"is wrong with your code."
+		].join(" ")
+	].join("\n"));
+}
+//#endregion
+export { NoTransformConfigurationError };
+
+//# sourceMappingURL=NoTransformConfigurationError.mjs.map

package/lib/transformers/NoTransformConfigurationError.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"NoTransformConfigurationError.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"NoTransformConfigurationError.mjs","names":[],"sources":["../../src/transformers/NoTransformConfigurationError.ts"],"sourcesContent":["/** @internal */\nexport function NoTransformConfigurationError(name: string): never {\n  throw new Error(\n    [\n      `Error on typia.${name}(): no transform has been configured.`,\n      \"\",\n      \"Read and follow https://typia.io/docs/setup please.\",\n      \"\",\n      [\n        \"If you've already completed the setup, it means there's\",\n        \"a bug in your code. Run `tsc` command so that check what\",\n        \"is wrong with your code.\",\n      ].join(\" \"),\n    ].join(\"\\n\"),\n  );\n}\n"],"mappings":";;AACA,SAAgB,8BAA8B,MAAqB;CACjE,MAAM,IAAI,MACR;EACE,kBAAkB,KAAK;EACvB;EACA;EACA;EACA;GACE;GACA;GACA;EACF,CAAC,CAAC,KAAK,GAAG;CACZ,CAAC,CAAC,KAAK,IAAI,CACb;AACF"}

package/native/core/factories/LiteralFactory.go

@@ -1,6 +1,8 @@
 package factories
 
 import (
+  "bytes"
+  "encoding/json"
   "math/big"
   "reflect"
   "sort"
@@ -26,6 +28,41 @@ type LiteralFactory_OrderedObject struct {
   Values map[string]any
 }
 
+// MarshalJSON keeps encoding/json consumers aligned with the printer: the
+// ordered object serializes as the plain JSON object it represents (in Keys
+// order, skipping absent and nil-like entries), never as its raw struct
+// fields. Downstream tools marshal schema metadata containing these objects
+// (e.g. nestia's SDK transform), and the raw {Keys, Values} shape corrupted
+// their output.
+func (obj LiteralFactory_OrderedObject) MarshalJSON() ([]byte, error) {
+  buffer := bytes.Buffer{}
+  buffer.WriteByte('{')
+  first := true
+  for _, key := range obj.Keys {
+    value, ok := obj.Values[key]
+    if ok == false || literalFactory_isNilLike(value) {
+      continue
+    }
+    encodedKey, err := json.Marshal(key)
+    if err != nil {
+      return nil, err
+    }
+    encodedValue, err := json.Marshal(value)
+    if err != nil {
+      return nil, err
+    }
+    if first == false {
+      buffer.WriteByte(',')
+    }
+    first = false
+    buffer.Write(encodedKey)
+    buffer.WriteByte(':')
+    buffer.Write(encodedValue)
+  }
+  buffer.WriteByte('}')
+  return buffer.Bytes(), nil
+}
+
 var literalFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (literalFactoryNamespace) Write(input any, emit ...*shimprinter.EmitContext) *shimast.Node {

package/native/core/factories/literal_factory_ordered_object_marshals_json_test.go

@@ -0,0 +1,40 @@
+package factories
+
+import (
+  "encoding/json"
+  "testing"
+)
+
+// TestLiteralFactoryOrderedObjectMarshalsJSON locks the encoding/json
+// representation of LiteralFactory_OrderedObject. Downstream consumers
+// marshal schema metadata containing these objects (nestia's SDK transform
+// builds swagger documents from it); without a MarshalJSON override the raw
+// {Keys, Values} struct fields leaked into generated documents as
+// `properties.Keys = [...]`, producing invalid OpenAPI schemas.
+//
+// The JSON form must be the plain object the printer would emit: entries in
+// Keys order, entries absent from Values skipped, nil-like values skipped,
+// and nested ordered objects (value or pointer) serialized the same way.
+func TestLiteralFactoryOrderedObjectMarshalsJSON(t *testing.T) {
+  input := LiteralFactory_OrderedObject{
+    Keys: []string{"second", "first", "absent", "nil", "nested"},
+    Values: map[string]any{
+      "second": 2,
+      "first":  1,
+      "nil":    nil,
+      "nested": &LiteralFactory_OrderedObject{
+        Keys:   []string{"z", "a"},
+        Values: map[string]any{"z": "Z", "a": "A"},
+      },
+      "unlisted": true,
+    },
+  }
+  data, err := json.Marshal(input)
+  if err != nil {
+    t.Fatalf("marshal failed: %v", err)
+  }
+  expected := `{"second":2,"first":1,"nested":{"z":"Z","a":"A"}}`
+  if string(data) != expected {
+    t.Fatalf("unexpected JSON:\nexpected %s\nactual   %s", expected, string(data))
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.0.0",
+  "version": "13.0.1",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -50,27 +50,20 @@
     "inquirer": "^8.2.5",
     "randexp": "^0.5.3",
     "tinyglobby": "^0.2.12",
-    "@typia/interface": "^13.0.0",
-    "@typia/utils": "^13.0.0"
+    "@typia/utils": "^13.0.1",
+    "@typia/interface": "^13.0.1"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^29.0.0",
-    "@rollup/plugin-esm-shim": "^0.1.8",
-    "@rollup/plugin-node-resolve": "^16.0.3",
     "@types/inquirer": "^8.2.5",
     "@types/node": "^25.3.0",
     "chalk": "^4.0.0",
     "rimraf": "^6.1.2",
-    "rollup": "^4.56.0",
-    "rollup-plugin-node-externals": "^8.1.2",
+    "rolldown": "^1.1.5",
     "suppress-warnings": "^1.0.2",
     "ttsc": "^0.17.3",
     "typescript": "^7.0.2"
   },
-  "sideEffects": [
-    "./lib/_virtual/*.mjs",
-    "./lib/internal/*2.mjs"
-  ],
+  "sideEffects": false,
   "files": [
     "README.md",
     "package.json",
@@ -117,7 +110,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf lib && ttsc && rollup -c && cp ../../README.md README.md",
+    "build": "rimraf lib && ttsc && rolldown -c && cp ../../README.md README.md",
     "dev": "ttsc --watch"
   },
   "types": "lib/index.d.ts",

package/src/executable/TypiaGenerateWizard.ts

@@ -627,7 +627,11 @@ export namespace TypiaGenerateWizard {
   }
 
   function resolveTypiaPackageRoot(): string {
-    const current: string = path.resolve(__dirname);
+    // The CLI entrypoint (`lib/executable/typia.js`) lives in the same
+    // directory as this module, so its `process.argv[1]` path anchors the
+    // walk-up identically in both the CJS and ESM builds — `__dirname` does
+    // not exist in the transcoded `.mjs`.
+    const current: string = path.dirname(path.resolve(process.argv[1] ?? ""));
     for (const directory of [
       path.resolve(current, "..", ".."),
       path.resolve(current, ".."),

package/src/executable/generate/ttsc.ts

@@ -1,7 +1,6 @@
-const { spawnSync } =
-  require("node:child_process") as typeof import("node:child_process");
-const fs = require("node:fs") as typeof import("node:fs");
-const path = require("node:path") as typeof import("node:path");
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
 
 const packageRoot = path.resolve(
   path.dirname(path.resolve(process.argv[1] ?? "")),

package/src/executable/typia.ts

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+import path from "node:path";
+
 const USAGE = `Wrong command has been detected. Use like below:
 
   npx typia generate [options] [files...]
@@ -32,12 +35,13 @@ const loadTtsc = (): void => {
 };
 
 const loadPackage = (request: string, desc: string): void => {
+  // The ambient CJS `require` does not exist in the transcoded `.mjs`;
+  // anchor explicit resolvers on the consuming project (cwd) first, then on
+  // this executable's own location, mirroring the original lookup order.
   const resolvers: Array<() => string> = [
     () =>
-      require.resolve(request, {
-        paths: [process.cwd()],
-      }),
-    () => require.resolve(request),
+      createRequire(path.join(process.cwd(), "package.json")).resolve(request),
+    () => createRequire(path.resolve(process.argv[1] ?? "")).resolve(request),
   ];
   for (const resolve of resolvers) {
     try {