Exact comment tracing on interface type.

TypeScript v5.2 supports a new function `getJSDocCommentsAndTags()` that listing up every JsDoc comments and tags at once.

Therefore, evolved `typia` to use `Symbol.getDocumentationComment()` in legavy TypeScript version, and adapted the `getJSDocCommentsAndTags()` function in the latest version.

benchmark/programs/assert-error/class-validator/benchmark-assert-error-class-validator-ArrayRecursive.ts

@@ -1,5 +1,4 @@
 import { ClassValidatorArrayRecursive } from "../../../structures/class-validator/ClassValidatorArrayRecursive";
-
 import { createAssertErrorClassValidatorBenchmarkProgram } from "./createAssertErrorClassValidatorBenchmarkProgram";
 
-createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorArrayRecursive);
+createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorArrayRecursive);

benchmark/programs/assert-error/class-validator/benchmark-assert-error-class-validator-ArrayRecursiveUnionExplicit.ts

@@ -1,5 +1,6 @@
 import { ClassValidatorArrayRecursiveUnionExplicit } from "../../../structures/class-validator/ClassValidatorArrayRecursiveUnionExplicit";
-
 import { createAssertErrorClassValidatorBenchmarkProgram } from "./createAssertErrorClassValidatorBenchmarkProgram";
 
-createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorArrayRecursiveUnionExplicit);
+createAssertErrorClassValidatorBenchmarkProgram(
+    ClassValidatorArrayRecursiveUnionExplicit,
+);

benchmark/programs/assert-error/class-validator/benchmark-assert-error-class-validator-ArrayRecursiveUnionImplicit.ts

@@ -1,5 +1,6 @@
 import { ClassValidatorArrayRecursiveUnionImplicit } from "../../../structures/class-validator/ClassValidatorArrayRecursiveUnionImplicit";
-
 import { createAssertErrorClassValidatorBenchmarkProgram } from "./createAssertErrorClassValidatorBenchmarkProgram";
 
-createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorArrayRecursiveUnionImplicit);
+createAssertErrorClassValidatorBenchmarkProgram(
+    ClassValidatorArrayRecursiveUnionImplicit,
+);

benchmark/programs/assert-error/class-validator/benchmark-assert-error-class-validator-ObjectHierarchical.ts

@@ -1,5 +1,6 @@
 import { ClassValidatorObjectHierarchical } from "../../../structures/class-validator/ClassValidatorObjectHierarchical";
-
 import { createAssertErrorClassValidatorBenchmarkProgram } from "./createAssertErrorClassValidatorBenchmarkProgram";
 
-createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorObjectHierarchical);
+createAssertErrorClassValidatorBenchmarkProgram(
+    ClassValidatorObjectHierarchical,
+);

benchmark/programs/assert-error/class-validator/benchmark-assert-error-class-validator-ObjectRecursive.ts

@@ -1,5 +1,4 @@
 import { ClassValidatorObjectRecursive } from "../../../structures/class-validator/ClassValidatorObjectRecursive";
-
 import { createAssertErrorClassValidatorBenchmarkProgram } from "./createAssertErrorClassValidatorBenchmarkProgram";
 
-createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorObjectRecursive);
+createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorObjectRecursive);

benchmark/programs/assert-error/class-validator/benchmark-assert-error-class-validator-ObjectSimple.ts

@@ -1,5 +1,4 @@
 import { ClassValidatorObjectSimple } from "../../../structures/class-validator/ClassValidatorObjectSimple";
-
 import { createAssertErrorClassValidatorBenchmarkProgram } from "./createAssertErrorClassValidatorBenchmarkProgram";
 
-createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorObjectSimple);
+createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorObjectSimple);

benchmark/programs/assert-error/class-validator/benchmark-assert-error-class-validator-ObjectUnionExplicit.ts

@@ -1,5 +1,6 @@
 import { ClassValidatorObjectUnionExplicit } from "../../../structures/class-validator/ClassValidatorObjectUnionExplicit";
-
 import { createAssertErrorClassValidatorBenchmarkProgram } from "./createAssertErrorClassValidatorBenchmarkProgram";
 
-createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorObjectUnionExplicit);
+createAssertErrorClassValidatorBenchmarkProgram(
+    ClassValidatorObjectUnionExplicit,
+);

benchmark/programs/assert-error/class-validator/benchmark-assert-error-class-validator-ObjectUnionImplicit.ts

@@ -1,5 +1,6 @@
 import { ClassValidatorObjectUnionImplicit } from "../../../structures/class-validator/ClassValidatorObjectUnionImplicit";
-
 import { createAssertErrorClassValidatorBenchmarkProgram } from "./createAssertErrorClassValidatorBenchmarkProgram";
 
-createAssertErrorClassValidatorBenchmarkProgram(ClassValidatorObjectUnionImplicit);
+createAssertErrorClassValidatorBenchmarkProgram(
+    ClassValidatorObjectUnionImplicit,
+);

benchmark/programs/assert-error/io-ts/benchmark-assert-error-io-ts-ArrayRecursive.ts

@@ -1,5 +1,4 @@
 import { IoTsArrayRecursive } from "../../../structures/io-ts/IoTsArrayRecursive";
-
 import { createAssertErrorIoTsBenchmarkProgram } from "./createAssertErrorIoTsBenchmarkProgram";
 
-createAssertErrorIoTsBenchmarkProgram(IoTsArrayRecursive);
+createAssertErrorIoTsBenchmarkProgram(IoTsArrayRecursive);

benchmark/programs/assert-error/io-ts/benchmark-assert-error-io-ts-ArrayRecursiveUnionExplicit.ts

@@ -1,5 +1,4 @@
 import { IoTsArrayRecursiveUnionExplicit } from "../../../structures/io-ts/IoTsArrayRecursiveUnionExplicit";
-
 import { createAssertErrorIoTsBenchmarkProgram } from "./createAssertErrorIoTsBenchmarkProgram";
 
-createAssertErrorIoTsBenchmarkProgram(IoTsArrayRecursiveUnionExplicit);
+createAssertErrorIoTsBenchmarkProgram(IoTsArrayRecursiveUnionExplicit);

benchmark/programs/assert-error/io-ts/benchmark-assert-error-io-ts-ArrayRecursiveUnionImplicit.ts

@@ -1,5 +1,4 @@
 import { IoTsArrayRecursiveUnionImplicit } from "../../../structures/io-ts/IoTsArrayRecursiveUnionImplicit";
-
 import { createAssertErrorIoTsBenchmarkProgram } from "./createAssertErrorIoTsBenchmarkProgram";
 
-createAssertErrorIoTsBenchmarkProgram(IoTsArrayRecursiveUnionImplicit);
+createAssertErrorIoTsBenchmarkProgram(IoTsArrayRecursiveUnionImplicit);

benchmark/programs/assert-error/io-ts/benchmark-assert-error-io-ts-ObjectHierarchical.ts

@@ -1,5 +1,4 @@
 import { IoTsObjectHierarchical } from "../../../structures/io-ts/IoTsObjectHierarchical";
-
 import { createAssertErrorIoTsBenchmarkProgram } from "./createAssertErrorIoTsBenchmarkProgram";
 
-createAssertErrorIoTsBenchmarkProgram(IoTsObjectHierarchical);
+createAssertErrorIoTsBenchmarkProgram(IoTsObjectHierarchical);

benchmark/programs/assert-error/io-ts/benchmark-assert-error-io-ts-ObjectRecursive.ts

@@ -1,5 +1,4 @@
 import { IoTsObjectRecursive } from "../../../structures/io-ts/IoTsObjectRecursive";
-
 import { createAssertErrorIoTsBenchmarkProgram } from "./createAssertErrorIoTsBenchmarkProgram";
 
-createAssertErrorIoTsBenchmarkProgram(IoTsObjectRecursive);
+createAssertErrorIoTsBenchmarkProgram(IoTsObjectRecursive);

benchmark/programs/assert-error/io-ts/benchmark-assert-error-io-ts-ObjectSimple.ts

@@ -1,5 +1,4 @@
 import { IoTsObjectSimple } from "../../../structures/io-ts/IoTsObjectSimple";
-
 import { createAssertErrorIoTsBenchmarkProgram } from "./createAssertErrorIoTsBenchmarkProgram";
 
-createAssertErrorIoTsBenchmarkProgram(IoTsObjectSimple);
+createAssertErrorIoTsBenchmarkProgram(IoTsObjectSimple);

benchmark/programs/assert-error/io-ts/benchmark-assert-error-io-ts-ObjectUnionExplicit.ts

@@ -1,5 +1,4 @@
 import { IoTsObjectUnionExplicit } from "../../../structures/io-ts/IoTsObjectUnionExplicit";
-
 import { createAssertErrorIoTsBenchmarkProgram } from "./createAssertErrorIoTsBenchmarkProgram";
 
-createAssertErrorIoTsBenchmarkProgram(IoTsObjectUnionExplicit);
+createAssertErrorIoTsBenchmarkProgram(IoTsObjectUnionExplicit);

benchmark/programs/assert-error/io-ts/benchmark-assert-error-io-ts-ObjectUnionImplicit.ts

@@ -1,5 +1,4 @@
 import { IoTsObjectUnionImplicit } from "../../../structures/io-ts/IoTsObjectUnionImplicit";
-
 import { createAssertErrorIoTsBenchmarkProgram } from "./createAssertErrorIoTsBenchmarkProgram";
 
-createAssertErrorIoTsBenchmarkProgram(IoTsObjectUnionImplicit);
+createAssertErrorIoTsBenchmarkProgram(IoTsObjectUnionImplicit);

benchmark/programs/assert-error/io-ts/benchmark-assert-error-io-ts-UltimateUnion.ts

@@ -1,5 +1,4 @@
 import { IoTsUltimateUnion } from "../../../structures/io-ts/IoTsUltimateUnion";
-
 import { createAssertErrorIoTsBenchmarkProgram } from "./createAssertErrorIoTsBenchmarkProgram";
 
-createAssertErrorIoTsBenchmarkProgram(IoTsUltimateUnion);
+createAssertErrorIoTsBenchmarkProgram(IoTsUltimateUnion);

benchmark/programs/assert-error/typebox/benchmark-assert-error-typebox-ArrayRecursive.ts

@@ -1,5 +1,4 @@
 import { __TypeboxArrayRecursive } from "../../../structures/typebox/TypeboxArrayRecursive";
-
 import { createAssertErrorTypeboxBenchmarkProgram } from "./createAssertErrorTypeboxBenchmarkProgram";
 
-createAssertErrorTypeboxBenchmarkProgram(__TypeboxArrayRecursive);
+createAssertErrorTypeboxBenchmarkProgram(__TypeboxArrayRecursive);

benchmark/programs/assert-error/typebox/benchmark-assert-error-typebox-ArrayRecursiveUnionExplicit.ts

@@ -1,5 +1,4 @@
 import { __TypeboxArrayRecursiveUnionExplicit } from "../../../structures/typebox/TypeboxArrayRecursiveUnionExplicit";
-
 import { createAssertErrorTypeboxBenchmarkProgram } from "./createAssertErrorTypeboxBenchmarkProgram";
 
-createAssertErrorTypeboxBenchmarkProgram(__TypeboxArrayRecursiveUnionExplicit);
+createAssertErrorTypeboxBenchmarkProgram(__TypeboxArrayRecursiveUnionExplicit);

benchmark/programs/assert-error/typebox/benchmark-assert-error-typebox-ArrayRecursiveUnionImplicit.ts

@@ -1,5 +1,4 @@
 import { __TypeboxArrayRecursiveUnionImplicit } from "../../../structures/typebox/TypeboxArrayRecursiveUnionImplicit";
-
 import { createAssertErrorTypeboxBenchmarkProgram } from "./createAssertErrorTypeboxBenchmarkProgram";
 
-createAssertErrorTypeboxBenchmarkProgram(__TypeboxArrayRecursiveUnionImplicit);
+createAssertErrorTypeboxBenchmarkProgram(__TypeboxArrayRecursiveUnionImplicit);

benchmark/programs/assert-error/typebox/benchmark-assert-error-typebox-ObjectHierarchical.ts

@@ -1,5 +1,4 @@
 import { __TypeboxObjectHierarchical } from "../../../structures/typebox/TypeboxObjectHierarchical";
-
 import { createAssertErrorTypeboxBenchmarkProgram } from "./createAssertErrorTypeboxBenchmarkProgram";
 
-createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectHierarchical);
+createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectHierarchical);

benchmark/programs/assert-error/typebox/benchmark-assert-error-typebox-ObjectRecursive.ts

@@ -1,5 +1,4 @@
 import { __TypeboxObjectRecursive } from "../../../structures/typebox/TypeboxObjectRecursive";
-
 import { createAssertErrorTypeboxBenchmarkProgram } from "./createAssertErrorTypeboxBenchmarkProgram";
 
-createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectRecursive);
+createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectRecursive);

benchmark/programs/assert-error/typebox/benchmark-assert-error-typebox-ObjectSimple.ts

@@ -1,5 +1,4 @@
 import { __TypeboxObjectSimple } from "../../../structures/typebox/TypeboxObjectSimple";
-
 import { createAssertErrorTypeboxBenchmarkProgram } from "./createAssertErrorTypeboxBenchmarkProgram";
 
-createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectSimple);
+createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectSimple);

benchmark/programs/assert-error/typebox/benchmark-assert-error-typebox-ObjectUnionExplicit.ts

@@ -1,5 +1,4 @@
 import { __TypeboxObjectUnionExplicit } from "../../../structures/typebox/TypeboxObjectUnionExplicit";
-
 import { createAssertErrorTypeboxBenchmarkProgram } from "./createAssertErrorTypeboxBenchmarkProgram";
 
-createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectUnionExplicit);
+createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectUnionExplicit);

benchmark/programs/assert-error/typebox/benchmark-assert-error-typebox-ObjectUnionImplicit.ts

@@ -1,5 +1,4 @@
 import { __TypeboxObjectUnionImplicit } from "../../../structures/typebox/TypeboxObjectUnionImplicit";
-
 import { createAssertErrorTypeboxBenchmarkProgram } from "./createAssertErrorTypeboxBenchmarkProgram";
 
-createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectUnionImplicit);
+createAssertErrorTypeboxBenchmarkProgram(__TypeboxObjectUnionImplicit);

benchmark/programs/assert-error/typebox/benchmark-assert-error-typebox-UltimateUnion.ts

@@ -1,5 +1,4 @@
 import { __TypeboxUltimateUnion } from "../../../structures/typebox/TypeboxUltimateUnion";
-
 import { createAssertErrorTypeboxBenchmarkProgram } from "./createAssertErrorTypeboxBenchmarkProgram";
 
-createAssertErrorTypeboxBenchmarkProgram(__TypeboxUltimateUnion);
+createAssertErrorTypeboxBenchmarkProgram(__TypeboxUltimateUnion);

benchmark/programs/assert-error/typia/benchmark-assert-error-typia-ArrayRecursive.ts

@@ -3,6 +3,4 @@ import typia from "typia";
 import { ArrayRecursive } from "../../../../test/structures/ArrayRecursive";
 import { createAssertErrorBenchmarkProgram } from "../createAssertErrorBenchmarkProgram";
 
-createAssertErrorBenchmarkProgram(
-    typia.createAssert<ArrayRecursive[]>()
-);
+createAssertErrorBenchmarkProgram(typia.createAssert<ArrayRecursive[]>());

benchmark/programs/assert-error/typia/benchmark-assert-error-typia-ArrayRecursiveUnionExplicit.ts

@@ -4,5 +4,5 @@ import { ArrayRecursiveUnionExplicit } from "../../../../test/structures/ArrayRe
 import { createAssertErrorBenchmarkProgram } from "../createAssertErrorBenchmarkProgram";
 
 createAssertErrorBenchmarkProgram(
-    typia.createAssert<ArrayRecursiveUnionExplicit[]>()
-);
+    typia.createAssert<ArrayRecursiveUnionExplicit[]>(),
+);

benchmark/programs/assert-error/typia/benchmark-assert-error-typia-ArrayRecursiveUnionImplicit.ts

@@ -4,5 +4,5 @@ import { ArrayRecursiveUnionImplicit } from "../../../../test/structures/ArrayRe
 import { createAssertErrorBenchmarkProgram } from "../createAssertErrorBenchmarkProgram";
 
 createAssertErrorBenchmarkProgram(
-    typia.createAssert<ArrayRecursiveUnionImplicit[]>()
-);
+    typia.createAssert<ArrayRecursiveUnionImplicit[]>(),
+);

benchmark/programs/assert-error/typia/benchmark-assert-error-typia-ObjectHierarchical.ts

@@ -3,6 +3,4 @@ import typia from "typia";
 import { ObjectHierarchical } from "../../../../test/structures/ObjectHierarchical";
 import { createAssertErrorBenchmarkProgram } from "../createAssertErrorBenchmarkProgram";
 
-createAssertErrorBenchmarkProgram(
-    typia.createAssert<ObjectHierarchical[]>()
-);
+createAssertErrorBenchmarkProgram(typia.createAssert<ObjectHierarchical[]>());

benchmark/programs/assert-error/typia/benchmark-assert-error-typia-ObjectRecursive.ts

@@ -3,6 +3,4 @@ import typia from "typia";
 import { ObjectRecursive } from "../../../../test/structures/ObjectRecursive";
 import { createAssertErrorBenchmarkProgram } from "../createAssertErrorBenchmarkProgram";
 
-createAssertErrorBenchmarkProgram(
-    typia.createAssert<ObjectRecursive[]>()
-);
+createAssertErrorBenchmarkProgram(typia.createAssert<ObjectRecursive[]>());

benchmark/programs/assert-error/typia/benchmark-assert-error-typia-ObjectSimple.ts

@@ -3,6 +3,4 @@ import typia from "typia";
 import { ObjectSimple } from "../../../../test/structures/ObjectSimple";
 import { createAssertErrorBenchmarkProgram } from "../createAssertErrorBenchmarkProgram";
 
-createAssertErrorBenchmarkProgram(
-    typia.createAssert<ObjectSimple[]>()
-);
+createAssertErrorBenchmarkProgram(typia.createAssert<ObjectSimple[]>());

benchmark/programs/assert-error/typia/benchmark-assert-error-typia-ObjectUnionExplicit.ts

@@ -3,6 +3,4 @@ import typia from "typia";
 import { ObjectUnionExplicit } from "../../../../test/structures/ObjectUnionExplicit";
 import { createAssertErrorBenchmarkProgram } from "../createAssertErrorBenchmarkProgram";
 
-createAssertErrorBenchmarkProgram(
-    typia.createAssert<ObjectUnionExplicit[]>()
-);
+createAssertErrorBenchmarkProgram(typia.createAssert<ObjectUnionExplicit[]>());

benchmark/programs/assert-error/typia/benchmark-assert-error-typia-ObjectUnionImplicit.ts

@@ -3,6 +3,4 @@ import typia from "typia";
 import { ObjectUnionImplicit } from "../../../../test/structures/ObjectUnionImplicit";
 import { createAssertErrorBenchmarkProgram } from "../createAssertErrorBenchmarkProgram";
 
-createAssertErrorBenchmarkProgram(
-    typia.createAssert<ObjectUnionImplicit[]>()
-);
+createAssertErrorBenchmarkProgram(typia.createAssert<ObjectUnionImplicit[]>());

benchmark/programs/assert-error/typia/benchmark-assert-error-typia-UltimateUnion.ts

@@ -3,6 +3,4 @@ import typia from "typia";
 import { UltimateUnion } from "../../../../test/structures/UltimateUnion";
 import { createAssertErrorBenchmarkProgram } from "../createAssertErrorBenchmarkProgram";
 
-createAssertErrorBenchmarkProgram(
-    typia.createAssert<UltimateUnion[]>()
-);
+createAssertErrorBenchmarkProgram(typia.createAssert<UltimateUnion[]>());

benchmark/programs/assert-error/zod/benchmark-assert-error-zod-ArrayRecursive.ts

@@ -1,5 +1,4 @@
 import { ZodArrayRecursive } from "../../../structures/zod/ZodArrayRecursive";
-
 import { createAssertErrorZodBenchmarkProgram } from "./createAssertErrorZodBenchmarkProgram";
 
-createAssertErrorZodBenchmarkProgram(ZodArrayRecursive);
+createAssertErrorZodBenchmarkProgram(ZodArrayRecursive);

benchmark/programs/assert-error/zod/benchmark-assert-error-zod-ArrayRecursiveUnionExplicit.ts

@@ -1,5 +1,4 @@
 import { ZodArrayRecursiveUnionExplicit } from "../../../structures/zod/ZodArrayRecursiveUnionExplicit";
-
 import { createAssertErrorZodBenchmarkProgram } from "./createAssertErrorZodBenchmarkProgram";
 
-createAssertErrorZodBenchmarkProgram(ZodArrayRecursiveUnionExplicit);
+createAssertErrorZodBenchmarkProgram(ZodArrayRecursiveUnionExplicit);

benchmark/programs/assert-error/zod/benchmark-assert-error-zod-ArrayRecursiveUnionImplicit.ts

@@ -1,5 +1,4 @@
 import { ZodArrayRecursiveUnionImplicit } from "../../../structures/zod/ZodArrayRecursiveUnionImplicit";
-
 import { createAssertErrorZodBenchmarkProgram } from "./createAssertErrorZodBenchmarkProgram";
 
-createAssertErrorZodBenchmarkProgram(ZodArrayRecursiveUnionImplicit);
+createAssertErrorZodBenchmarkProgram(ZodArrayRecursiveUnionImplicit);

benchmark/programs/assert-error/zod/benchmark-assert-error-zod-ObjectHierarchical.ts

@@ -1,5 +1,4 @@
 import { ZodObjectHierarchical } from "../../../structures/zod/ZodObjectHierarchical";
-
 import { createAssertErrorZodBenchmarkProgram } from "./createAssertErrorZodBenchmarkProgram";
 
-createAssertErrorZodBenchmarkProgram(ZodObjectHierarchical);
+createAssertErrorZodBenchmarkProgram(ZodObjectHierarchical);

benchmark/programs/assert-error/zod/benchmark-assert-error-zod-ObjectRecursive.ts

@@ -1,5 +1,4 @@
 import { ZodObjectRecursive } from "../../../structures/zod/ZodObjectRecursive";
-
 import { createAssertErrorZodBenchmarkProgram } from "./createAssertErrorZodBenchmarkProgram";
 
-createAssertErrorZodBenchmarkProgram(ZodObjectRecursive);
+createAssertErrorZodBenchmarkProgram(ZodObjectRecursive);

benchmark/programs/assert-error/zod/benchmark-assert-error-zod-ObjectSimple.ts

@@ -1,5 +1,4 @@
 import { ZodObjectSimple } from "../../../structures/zod/ZodObjectSimple";
-
 import { createAssertErrorZodBenchmarkProgram } from "./createAssertErrorZodBenchmarkProgram";
 
-createAssertErrorZodBenchmarkProgram(ZodObjectSimple);
+createAssertErrorZodBenchmarkProgram(ZodObjectSimple);

benchmark/programs/assert-error/zod/benchmark-assert-error-zod-ObjectUnionExplicit.ts

@@ -1,5 +1,4 @@
 import { ZodObjectUnionExplicit } from "../../../structures/zod/ZodObjectUnionExplicit";
-
 import { createAssertErrorZodBenchmarkProgram } from "./createAssertErrorZodBenchmarkProgram";
 
-createAssertErrorZodBenchmarkProgram(ZodObjectUnionExplicit);
+createAssertErrorZodBenchmarkProgram(ZodObjectUnionExplicit);

benchmark/programs/assert-error/zod/benchmark-assert-error-zod-ObjectUnionImplicit.ts

@@ -1,5 +1,4 @@
 import { ZodObjectUnionImplicit } from "../../../structures/zod/ZodObjectUnionImplicit";
-
 import { createAssertErrorZodBenchmarkProgram } from "./createAssertErrorZodBenchmarkProgram";
 
-createAssertErrorZodBenchmarkProgram(ZodObjectUnionImplicit);
+createAssertErrorZodBenchmarkProgram(ZodObjectUnionImplicit);

benchmark/programs/assert-error/zod/benchmark-assert-error-zod-UltimateUnion.ts

@@ -1,5 +1,4 @@
 import { ZodUltimateUnion } from "../../../structures/zod/ZodUltimateUnion";
-
 import { createAssertErrorZodBenchmarkProgram } from "./createAssertErrorZodBenchmarkProgram";
 
-createAssertErrorZodBenchmarkProgram(ZodUltimateUnion);
+createAssertErrorZodBenchmarkProgram(ZodUltimateUnion);

benchmark/programs/assert/ajv/benchmark-assert-ajv-ArrayRecursive.ts

@@ -3,6 +3,4 @@ import typia from "typia";
 import { ArrayRecursive } from "../../../../test/structures/ArrayRecursive";
 import { createAssertAjvBenchmarkProgram } from "./createAssertAjvBenchmarkProgram";
 
-createAssertAjvBenchmarkProgram(
-    typia.application<[ArrayRecursive], "ajv">(),
-);
+createAssertAjvBenchmarkProgram(typia.application<[ArrayRecursive], "ajv">());

benchmark/programs/assert/ajv/benchmark-assert-ajv-ArrayRecursiveUnionExplicit.ts

@@ -5,4 +5,4 @@ import { createAssertAjvBenchmarkProgram } from "./createAssertAjvBenchmarkProgr
 
 createAssertAjvBenchmarkProgram(
     typia.application<[ArrayRecursiveUnionExplicit], "ajv">(),
-);
+);

benchmark/programs/assert/ajv/benchmark-assert-ajv-ArrayRecursiveUnionImplicit.ts

@@ -5,4 +5,4 @@ import { createAssertAjvBenchmarkProgram } from "./createAssertAjvBenchmarkProgr
 
 createAssertAjvBenchmarkProgram(
     typia.application<[ArrayRecursiveUnionImplicit], "ajv">(),
-);
+);