typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

package/src/factories/internal/metadata/explore_metadata.ts

@@ -1,8 +1,10 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 import { MetadataObject } from "../../../metadata/MetadataObject";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
@@ -10,18 +12,17 @@ import { MetadataFactory } from "../../MetadataFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
 export const explore_metadata =
-    (checker: ts.TypeChecker) =>
+    (project: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.Type | null, parentResolved: boolean): Metadata => {
+    (parentResolved: boolean) =>
+    (type: ts.Type | null): Metadata => {
         // CONSTRUCT METADATA
         const meta: Metadata = Metadata.initialize(parentResolved);
         if (type !== null)
-            iterate_metadata(checker)(options)(collection)(
+            iterate_metadata(project)(options)(collection)(parentResolved)(
                 meta,
-                type,
-                parentResolved,
-            );
+            )(type);
 
         // SORT OBJECTS
         if (meta.objects.length > 1) {

package/src/factories/internal/metadata/iterate_metadata.ts

@@ -1,7 +1,11 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProject } from "../../../transformers/IProject";
+
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
 // import { ArrayUtil } from "../../../utils/ArrayUtil";
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -19,49 +23,41 @@ import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
 import { iterate_metadata_union } from "./iterate_metadata_union";
 
 export const iterate_metadata =
-    (checker: ts.TypeChecker) =>
+    (p: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): void => {
-        if (type.isTypeParameter() === true)
+    (parentResolved: boolean) =>
+    (meta: Metadata) =>
+    (type: ts.Type): void => {
+        if (TsTypeUtil.isTypeParameter(p.tsc)(type) === true)
             throw new Error(
                 `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
             );
 
         // CHECK UNION & toJSON()
         if (
-            iterate_metadata_union(checker)(options)(collection)(
+            iterate_metadata_union(p)(options)(collection)(parentResolved)(
                 meta,
-                type,
-                parentResolved,
-            ) ||
-            iterate_metadata_resolve(checker)(options)(collection)(
+            )(type) ||
+            iterate_metadata_resolve(p)(options)(collection)(parentResolved)(
                 meta,
-                type,
-                parentResolved,
-            )
+            )(type)
         )
             return;
 
         // ITERATE CASES
-        iterate_metadata_coalesce(meta, type) ||
-            iterate_metadata_constant(checker)(options)(meta, type) ||
-            iterate_metadata_template(checker)(options)(collection)(
-                meta,
-                type,
-            ) ||
-            iterate_metadata_atomic(meta, type) ||
-            iterate_metadata_tuple(checker)(options)(collection)(
-                meta,
+        iterate_metadata_coalesce(p.tsc)(meta)(type) ||
+            iterate_metadata_constant(p)(options)(meta)(type) ||
+            iterate_metadata_template(p)(options)(collection)(meta)(type) ||
+            iterate_metadata_atomic(p.tsc)(meta)(type) ||
+            iterate_metadata_tuple(p)(options)(collection)(meta)(
                 type as ts.TupleType,
             ) ||
-            iterate_metadata_array(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_native(checker)(meta, type) ||
-            iterate_metadata_map(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_set(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_object(checker)(options)(collection)(
+            iterate_metadata_array(p)(options)(collection)(meta)(type) ||
+            iterate_metadata_native(p)(meta)(type) ||
+            iterate_metadata_map(p)(options)(collection)(meta)(type) ||
+            iterate_metadata_set(p)(options)(collection)(meta)(type) ||
+            iterate_metadata_object(p)(options)(collection)(parentResolved)(
                 meta,
-                type,
-                parentResolved,
-            );
+            )(type);
     };

package/src/factories/internal/metadata/iterate_metadata_array.ts

@@ -1,7 +1,9 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
@@ -9,20 +11,21 @@ import { MetadataFactory } from "../../MetadataFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_array =
-    (checker: ts.TypeChecker) =>
+    ({ tsc, checker }: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        if (
-            !(checker as any).isArrayType(type) &&
-            !(checker as any).isArrayLikeType(type)
-        )
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        if (!checker.isArrayType(type) && !checker.isArrayLikeType(type))
             return false;
 
-        const value: ts.Type | null = type.getNumberIndexType() || null;
+        const value: ts.Type | null =
+            checker.getIndexTypeOfType(type, tsc.IndexKind.Number) ?? null;
         ArrayUtil.set(
             meta.arrays,
-            explore_metadata(checker)(options)(collection)(value, false),
+            explore_metadata({ tsc, checker })(options)(collection)(false)(
+                value,
+            ),
             (elem) => elem.getName(),
         );
         return true;

package/src/factories/internal/metadata/iterate_metadata_atomic.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
@@ -8,47 +8,47 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 const same = (type: ts.Type | null) => {
     if (type === null) return () => false;
-    return (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    return (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
 };
 
-export const iterate_metadata_atomic = (
-    meta: Metadata,
-    type: ts.Type,
-): boolean => {
-    // PREPARE INTERNAL FUNCTIONS
-    const filter = same(type);
-    const check = (info: IAtomicInfo) => {
-        if (filter(info.atomic) || filter(info.literal)) {
-            ArrayUtil.add(meta.atomics, info.name);
-            return true;
-        }
-        return false;
+export const iterate_metadata_atomic =
+    (tsc: typeof ts) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        // PREPARE INTERNAL FUNCTIONS
+        const filter = same(type);
+        const check = (info: IAtomicInfo) => {
+            if (filter(info.atomic) || filter(info.literal)) {
+                ArrayUtil.add(meta.atomics, info.name);
+                return true;
+            }
+            return false;
+        };
+
+        // CHECK EACH TYPES
+        return ATOMICS(tsc).some((info) => check(info));
     };
 
-    // CHECK EACH TYPES
-    return ATOMICS.some((info) => check(info));
-};
-
-const ATOMICS: IAtomicInfo[] = [
+const ATOMICS = (tsc: typeof ts): IAtomicInfo[] => [
     {
         name: "boolean",
-        atomic: ts.TypeFlags.BooleanLike,
-        literal: ts.TypeFlags.BooleanLiteral,
+        atomic: tsc.TypeFlags.BooleanLike,
+        literal: tsc.TypeFlags.BooleanLiteral,
     },
     {
         name: "number",
-        atomic: ts.TypeFlags.NumberLike,
-        literal: ts.TypeFlags.NumberLiteral,
+        atomic: tsc.TypeFlags.NumberLike,
+        literal: tsc.TypeFlags.NumberLiteral,
     },
     {
         name: "bigint",
-        atomic: ts.TypeFlags.BigInt,
-        literal: ts.TypeFlags.BigIntLiteral,
+        atomic: tsc.TypeFlags.BigInt,
+        literal: tsc.TypeFlags.BigIntLiteral,
     },
     {
         name: "string",
-        atomic: ts.TypeFlags.StringLike,
-        literal: ts.TypeFlags.StringLiteral,
+        atomic: tsc.TypeFlags.StringLike,
+        literal: tsc.TypeFlags.StringLiteral,
     },
 ];
 

package/src/factories/internal/metadata/iterate_metadata_coalesce.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
@@ -6,28 +6,28 @@ import { Writable } from "../../../typings/Writable";
 
 import { TypeFactory } from "../../TypeFactory";
 
-export const iterate_metadata_coalesce = (
-    meta: Metadata,
-    type: ts.Type,
-): boolean => {
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-    if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
-        Writable(meta).any = true;
-        return true;
-    } else if (filter(ts.TypeFlags.Null)) {
-        Writable(meta).nullable = true;
-        return true;
-    } else if (
-        filter(ts.TypeFlags.Undefined) ||
-        filter(ts.TypeFlags.Never) ||
-        filter(ts.TypeFlags.Void) ||
-        filter(ts.TypeFlags.VoidLike)
-    ) {
-        Writable(meta).required = false;
-        return true;
-    } else if (TypeFactory.isFunction(type) === true) {
-        Writable(meta).functional = true;
-        return true;
-    }
-    return false;
-};
+export const iterate_metadata_coalesce =
+    (tsc: typeof ts) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
+        if (filter(tsc.TypeFlags.Unknown) || filter(tsc.TypeFlags.Any)) {
+            Writable(meta).any = true;
+            return true;
+        } else if (filter(tsc.TypeFlags.Null)) {
+            Writable(meta).nullable = true;
+            return true;
+        } else if (
+            filter(tsc.TypeFlags.Undefined) ||
+            filter(tsc.TypeFlags.Never) ||
+            filter(tsc.TypeFlags.Void) ||
+            filter(tsc.TypeFlags.VoidLike)
+        ) {
+            Writable(meta).required = false;
+            return true;
+        } else if (TypeFactory.isFunction(tsc)(type) === true) {
+            Writable(meta).functional = true;
+            return true;
+        }
+        return false;
+    };

package/src/factories/internal/metadata/iterate_metadata_constant.ts

@@ -1,20 +1,24 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 import { MetadataConstant } from "../../../metadata/MetadataConstant";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
 
 import { MetadataFactory } from "../../MetadataFactory";
 
 export const iterate_metadata_constant =
-    (checker: ts.TypeChecker) =>
+    ({ tsc, checker }: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
-    (meta: Metadata, type: ts.Type): boolean => {
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
         if (!options.constant) return false;
 
-        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-        if (type.isLiteral()) {
+        const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
+        if (TsTypeUtil.isLiteral(tsc)(type)) {
             const value: string | number | bigint =
                 typeof type.value === "object"
                     ? BigInt(
@@ -37,7 +41,7 @@ export const iterate_metadata_constant =
                 (a, b) => a === b,
             );
             return true;
-        } else if (filter(ts.TypeFlags.BooleanLiteral)) {
+        } else if (filter(tsc.TypeFlags.BooleanLiteral)) {
             const value: boolean = checker.typeToString(type) === "true";
             const constant: MetadataConstant = ArrayUtil.take(
                 meta.constants,

package/src/factories/internal/metadata/iterate_metadata_map.ts

@@ -1,7 +1,9 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
@@ -10,16 +12,17 @@ import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_map =
-    (checker: ts.TypeChecker) =>
+    (p: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        type = checker.getApparentType(type);
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        type = p.checker.getApparentType(type);
 
-        const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
+        const name = TypeFactory.getFullName(p)(type, type.symbol);
         const generic = type.aliasSymbol
             ? type.aliasTypeArguments
-            : checker.getTypeArguments(type as ts.TypeReference);
+            : p.checker.getTypeArguments(type as ts.TypeReference);
         if (name.substring(0, 4) !== "Map<" || generic?.length !== 2)
             return false;
 
@@ -29,11 +32,8 @@ export const iterate_metadata_map =
         ArrayUtil.set(
             meta.maps,
             {
-                key: explore_metadata(checker)(options)(collection)(key, false),
-                value: explore_metadata(checker)(options)(collection)(
-                    value,
-                    false,
-                ),
+                key: explore_metadata(p)(options)(collection)(false)(key),
+                value: explore_metadata(p)(options)(collection)(false)(value),
             },
             (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
         );

package/src/factories/internal/metadata/iterate_metadata_native.ts

@@ -1,19 +1,19 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { TypeFactory } from "../../TypeFactory";
 
 export const iterate_metadata_native =
-    (checker: ts.TypeChecker) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        const validator = validate(checker)(type);
-        const name: string = TypeFactory.getFullName(checker)(
-            type,
-            type.getSymbol(),
-        );
+    (p: IProject.IModule) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        const validator = validate(p)(type);
+        const name: string = TypeFactory.getFullName(p)(type, type.symbol);
 
         const simple = SIMPLES.get(name);
         if (simple && validator(simple)) {
@@ -39,24 +39,22 @@ export const iterate_metadata_native =
     };
 
 const validate =
-    (checker: ts.TypeChecker) => (type: ts.Type) => (info: IClassInfo) =>
+    (p: IProject.IModule) => (type: ts.Type) => (info: IClassInfo) =>
         (info.methods ?? []).every((method) => {
-            const returnType = TypeFactory.getReturnType(checker)(type)(
-                method.name,
-            );
+            const returnType = TypeFactory.getReturnType(p)(type)(method.name);
             return (
                 returnType !== null &&
-                checker.typeToString(returnType) === method.return
+                p.checker.typeToString(returnType) === method.return
             );
         }) &&
         (info.properties ?? []).every((property) => {
-            const prop = checker.getPropertyOfType(type, property.name);
+            const prop = p.checker.getPropertyOfType(type, property.name);
             const propType = prop?.valueDeclaration
-                ? checker.getTypeAtLocation(prop?.valueDeclaration)
+                ? p.checker.getTypeAtLocation(prop?.valueDeclaration)
                 : undefined;
             return (
                 propType !== undefined &&
-                checker.typeToString(propType) === property.type
+                p.checker.typeToString(propType) === property.type
             );
         });
 

package/src/factories/internal/metadata/iterate_metadata_object.ts

@@ -1,9 +1,12 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 import { MetadataObject } from "../../../metadata/MetadataObject";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -11,27 +14,27 @@ import { emplace_metadata_object } from "./emplace_metadata_object";
 import { iterate_metadata } from "./iterate_metadata";
 
 export const iterate_metadata_object =
-    (checker: ts.TypeChecker) =>
+    ({ tsc, checker }: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
-        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    (parentResolved: boolean) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
         if (
-            !filter(ts.TypeFlags.Object) &&
-            !type.isIntersection() &&
+            !filter(tsc.TypeFlags.Object) &&
+            !TsTypeUtil.isIntersection(tsc)(type) &&
             (type as any).intrinsicName !== "object"
         )
             return false;
-        else if (type.isIntersection()) {
+        else if (TsTypeUtil.isIntersection(tsc)(type)) {
             const fakeCollection = new MetadataCollection();
             const fakeSchema: Metadata = Metadata.initialize();
 
             type.types.forEach((t) =>
-                iterate_metadata(checker)(options)(fakeCollection)(
-                    fakeSchema,
-                    t,
+                iterate_metadata({ tsc, checker })(options)(fakeCollection)(
                     parentResolved,
-                ),
+                )(fakeSchema)(t),
             );
             if (
                 fakeSchema.objects.length === 0 ||
@@ -40,9 +43,9 @@ export const iterate_metadata_object =
                 return true;
         }
 
-        const obj: MetadataObject = emplace_metadata_object(checker)(options)(
-            collection,
-        )(type, meta.nullable);
+        const obj: MetadataObject = emplace_metadata_object({ tsc, checker })(
+            options,
+        )(collection)(type, meta.nullable);
         ArrayUtil.add(meta.objects, obj, (elem) => elem.name === obj.name);
         return true;
     };

package/src/factories/internal/metadata/iterate_metadata_resolve.ts

@@ -1,7 +1,9 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { Writable } from "../../../typings/Writable";
 
 import { MetadataCollection } from "../../MetadataCollection";
@@ -10,16 +12,17 @@ import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_resolve =
-    (checker: ts.TypeChecker) =>
+    (p: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
+    (parentResolved: boolean) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
         if (options.resolve === true && parentResolved === false) {
-            const resolved: ts.Type | null = TypeFactory.resolve(checker)(type);
+            const resolved: ts.Type | null = TypeFactory.resolve(p)(type);
             if (resolved !== null) {
-                Writable(meta).resolved = explore_metadata(checker)(options)(
-                    collection,
-                )(resolved, true);
+                Writable(meta).resolved =
+                    explore_metadata(p)(options)(collection)(true)(resolved);
                 return true;
             }
         }

package/src/factories/internal/metadata/iterate_metadata_set.ts

@@ -1,7 +1,9 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
@@ -10,23 +12,24 @@ import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_set =
-    (checker: ts.TypeChecker) =>
+    (p: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        type = checker.getApparentType(type);
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        type = p.checker.getApparentType(type);
 
-        const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
+        const name = TypeFactory.getFullName(p)(type, type.symbol);
         const generic = type.aliasSymbol
             ? type.aliasTypeArguments
-            : checker.getTypeArguments(type as ts.TypeReference);
+            : p.checker.getTypeArguments(type as ts.TypeReference);
         if (name.substring(0, 4) !== "Set<" || generic?.length !== 1)
             return false;
 
         const key: ts.Type = generic[0]!;
         ArrayUtil.set(
             meta.sets,
-            explore_metadata(checker)(options)(collection)(key, false),
+            explore_metadata(p)(options)(collection)(false)(key),
             (elem) => elem.getName(),
         );
         return true;

package/src/factories/internal/metadata/iterate_metadata_template.ts

@@ -1,19 +1,22 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../../metadata/Metadata";
 
+import { IProject } from "../../../transformers/IProject";
+
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { MetadataHelper } from "./MetadataHelper";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_template =
-    (checker: ts.TypeChecker) =>
+    ({ tsc, checker }: IProject.IModule) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-        if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
+        if (!filter(tsc.TypeFlags.TemplateLiteral)) return false;
 
         const template: ts.TemplateLiteralType = type as ts.TemplateLiteralType;
         const row: Metadata[] = [];
@@ -26,10 +29,9 @@ export const iterate_metadata_template =
             const binded: ts.Type | undefined = template.types[i];
             if (binded)
                 row.push(
-                    explore_metadata(checker)(options)(collection)(
-                        binded,
+                    explore_metadata({ tsc, checker })(options)(collection)(
                         false,
-                    ),
+                    )(binded),
                 );
         });
         meta.templates.push(row);