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

package/src/programmers/helpers/RandomJoiner.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
@@ -22,10 +22,11 @@ export namespace RandomJoiner {
     ) => ts.Expression;
 
     export const array =
+        (tsc: typeof ts) =>
         (coalesce: (method: string) => ts.Expression) =>
         (decoder: Decoder) =>
         (item: Metadata, tags: IMetadataTag[], comments: ICommentTag[]) => {
-            const tail = RandomRanger.length(coalesce)({
+            const tail = RandomRanger.length(tsc)(coalesce)({
                 minimum: 0,
                 maximum: 3,
                 gap: 3,
@@ -34,11 +35,11 @@ export namespace RandomJoiner {
                 minimum: "minItems",
                 maximum: "maxItems",
             })(tags);
-            return ts.factory.createCallExpression(
+            return tsc.factory.createCallExpression(
                 coalesce("array"),
                 undefined,
                 [
-                    ts.factory.createArrowFunction(
+                    tsc.factory.createArrowFunction(
                         undefined,
                         undefined,
                         [],
@@ -52,19 +53,21 @@ export namespace RandomJoiner {
         };
 
     export const tuple =
+        (tsc: typeof ts) =>
         (decoder: Decoder) =>
         (items: Metadata[], tags: IMetadataTag[], comments: ICommentTag[]) =>
-            ts.factory.createArrayLiteralExpression(
+            tsc.factory.createArrayLiteralExpression(
                 items.map((i) => decoder(i.rest ?? i, tags, comments)),
                 true,
             );
 
     export const object =
+        (tsc: typeof ts) =>
         (coalesce: (method: string) => ts.Expression) =>
         (decoder: Decoder) =>
         (obj: MetadataObject): ts.ConciseBody => {
             if (obj.properties.length === 0)
-                return ts.factory.createIdentifier("{}");
+                return tsc.factory.createIdentifier("{}");
 
             // LIST UP PROPERTIES
             const regular = obj.properties.filter((p) => p.key.isSoleLiteral());
@@ -74,13 +77,13 @@ export namespace RandomJoiner {
 
             // REGULAR OBJECT
             const literal: ts.ObjectLiteralExpression =
-                ts.factory.createObjectLiteralExpression(
+                tsc.factory.createObjectLiteralExpression(
                     regular.map((p) => {
                         const str: string = p.key.getSoleLiteral()!;
-                        return ts.factory.createPropertyAssignment(
+                        return tsc.factory.createPropertyAssignment(
                             Escaper.variable(str)
                                 ? str
-                                : ts.factory.createStringLiteral(str),
+                                : tsc.factory.createStringLiteral(str),
                             decoder(
                                 p.value,
                                 p.tags,
@@ -93,32 +96,32 @@ export namespace RandomJoiner {
             if (dynamic.length === 0) return literal;
 
             const properties: ts.Statement[] = dynamic.map((p) =>
-                ts.factory.createExpressionStatement(
-                    dynamicProperty(coalesce)(decoder)(p),
+                tsc.factory.createExpressionStatement(
+                    dynamicProperty(tsc)(coalesce)(decoder)(p),
                 ),
             );
-            return ts.factory.createBlock(
+            return tsc.factory.createBlock(
                 [
-                    StatementFactory.constant(
+                    StatementFactory.constant(tsc)(
                         "output",
-                        ts.factory.createAsExpression(
+                        tsc.factory.createAsExpression(
                             literal,
-                            TypeFactory.keyword("any"),
+                            TypeFactory.keyword(tsc)("any"),
                         ),
                     ),
                     ...(obj.recursive
                         ? [
-                              ts.factory.createIfStatement(
-                                  ts.factory.createGreaterThanEquals(
-                                      ts.factory.createNumericLiteral(5),
-                                      ts.factory.createIdentifier("_depth"),
+                              tsc.factory.createIfStatement(
+                                  tsc.factory.createGreaterThanEquals(
+                                      tsc.factory.createNumericLiteral(5),
+                                      tsc.factory.createIdentifier("_depth"),
                                   ),
-                                  ts.factory.createBlock(properties, true),
+                                  tsc.factory.createBlock(properties, true),
                               ),
                           ]
                         : properties),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
+                    tsc.factory.createReturnStatement(
+                        tsc.factory.createIdentifier("output"),
                     ),
                 ],
                 true,
@@ -126,22 +129,23 @@ export namespace RandomJoiner {
         };
 
     const dynamicProperty =
+        (tsc: typeof ts) =>
         (coalesce: (method: string) => ts.Expression) =>
         (decoder: Decoder) =>
         (p: MetadataProperty) =>
-            ts.factory.createCallExpression(coalesce("array"), undefined, [
-                ts.factory.createArrowFunction(
+            tsc.factory.createCallExpression(coalesce("array"), undefined, [
+                tsc.factory.createArrowFunction(
                     undefined,
                     undefined,
                     [],
                     undefined,
                     undefined,
-                    ts.factory.createBinaryExpression(
-                        ts.factory.createElementAccessExpression(
-                            ts.factory.createIdentifier("output"),
+                    tsc.factory.createBinaryExpression(
+                        tsc.factory.createElementAccessExpression(
+                            tsc.factory.createIdentifier("output"),
                             decoder(p.key, [], []),
                         ),
-                        ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+                        tsc.factory.createToken(tsc.SyntaxKind.EqualsToken),
                         decoder(
                             p.value,
                             p.tags,
@@ -149,12 +153,12 @@ export namespace RandomJoiner {
                         ),
                     ),
                 ),
-                ts.factory.createCallExpression(
+                tsc.factory.createCallExpression(
                     coalesce("integer"),
                     undefined,
                     [
-                        ts.factory.createNumericLiteral(0),
-                        ts.factory.createNumericLiteral(3),
+                        tsc.factory.createNumericLiteral(0),
+                        tsc.factory.createNumericLiteral(3),
                     ],
                 ),
             ]);

package/src/programmers/helpers/RandomRanger.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
@@ -10,6 +10,7 @@ export namespace RandomRanger {
     }
 
     export const length =
+        (tsc: typeof ts) =>
         (coalesce: (method: string) => ts.Expression) =>
         (defs: IDefaults) =>
         (acc: length.IAccessors) =>
@@ -20,7 +21,7 @@ export namespace RandomRanger {
                 maximum: getter(tags)(acc.maximum),
             };
             if (props.fixed !== undefined)
-                return ts.factory.createNumericLiteral(props.fixed);
+                return tsc.factory.createNumericLiteral(props.fixed);
             else if (props.minimum === undefined && props.maximum === undefined)
                 return undefined;
 
@@ -29,12 +30,12 @@ export namespace RandomRanger {
             if (props.maximum <= props.minimum)
                 (props.maximum as number) += defs.gap;
 
-            return ts.factory.createCallExpression(
+            return tsc.factory.createCallExpression(
                 coalesce("integer"),
                 undefined,
                 [
-                    ts.factory.createNumericLiteral(props.minimum),
-                    ts.factory.createNumericLiteral(props.maximum),
+                    tsc.factory.createNumericLiteral(props.minimum),
+                    tsc.factory.createNumericLiteral(props.maximum),
                 ],
             );
         };
@@ -47,6 +48,7 @@ export namespace RandomRanger {
     }
 
     export const number =
+        (tsc: typeof ts) =>
         (config: number.IConfig) =>
         (defs: IDefaults) =>
         (tags: IMetadataTag[]): ts.Expression => {
@@ -77,9 +79,9 @@ export namespace RandomRanger {
                 const { intercept, minimum, maximum } = stepper(defs.gap)(
                     range,
                 )(range.step);
-                return ts.factory.createAdd(
+                return tsc.factory.createAdd(
                     config.transform(intercept),
-                    ts.factory.createMultiply(
+                    tsc.factory.createMultiply(
                         config.transform(range.step),
                         config.setter([minimum, maximum]),
                     ),
@@ -90,7 +92,7 @@ export namespace RandomRanger {
                 const { minimum, maximum } = multiplier(defs.gap)(range)(
                     range.multiply,
                 );
-                return ts.factory.createMultiply(
+                return tsc.factory.createMultiply(
                     config.transform(range.multiply),
                     config.setter([minimum, maximum]),
                 );

package/src/programmers/helpers/StringifyJoinder.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { TemplateFactory } from "../../factories/TemplateFactory";
@@ -10,6 +10,7 @@ import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace StringifyJoiner {
     export const object =
+        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (
             _input: ts.Expression,
@@ -17,7 +18,7 @@ export namespace StringifyJoiner {
         ): ts.Expression => {
             // CHECK AND SORT ENTRIES
             if (entries.length === 0)
-                return ts.factory.createStringLiteral("{}");
+                return tsc.factory.createStringLiteral("{}");
 
             // PROPERTIES
             const regular: IExpressionEntry<ts.Expression>[] = entries.filter(
@@ -27,10 +28,10 @@ export namespace StringifyJoiner {
                 (entry) => !entry.key.isSoleLiteral(),
             );
             const expressions: ts.Expression[] = [
-                ...stringify_regular_properties(regular, dynamic),
+                ...stringify_regular_properties(tsc)(regular, dynamic),
                 ...(dynamic.length
                     ? [
-                          stringify_dynamic_properties(
+                          stringify_dynamic_properties(tsc)(
                               dynamic,
                               regular.map((r) => r.key.getSoleLiteral()!),
                           ),
@@ -46,68 +47,72 @@ export namespace StringifyJoiner {
                 (regular.length === 0 && dynamic.length)
                     ? expressions
                     : [
-                          ts.factory.createCallExpression(
+                          tsc.factory.createCallExpression(
                               importer.use("tail"),
                               undefined,
-                              [TemplateFactory.generate(expressions)],
+                              [TemplateFactory.generate(tsc)(expressions)],
                           ),
                       ];
 
             // RETURNS WITH OBJECT BRACKET
-            return TemplateFactory.generate([
-                ts.factory.createStringLiteral(`{`),
+            return TemplateFactory.generate(tsc)([
+                tsc.factory.createStringLiteral(`{`),
                 ...filtered,
-                ts.factory.createStringLiteral(`}`),
+                tsc.factory.createStringLiteral(`}`),
             ]);
         };
 
-    export const array = (
-        input: ts.Expression,
-        arrow: ts.ArrowFunction,
-    ): ts.Expression =>
-        TemplateFactory.generate([
-            ts.factory.createStringLiteral(`[`),
-            ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.access(input)("map"),
-                        undefined,
-                        [arrow],
+    export const array =
+        (tsc: typeof ts) =>
+        (input: ts.Expression, arrow: ts.ArrowFunction): ts.Expression =>
+            TemplateFactory.generate(tsc)([
+                tsc.factory.createStringLiteral(`[`),
+                tsc.factory.createCallExpression(
+                    tsc.factory.createPropertyAccessExpression(
+                        tsc.factory.createCallExpression(
+                            IdentifierFactory.access(tsc)(input)("map"),
+                            undefined,
+                            [arrow],
+                        ),
+                        tsc.factory.createIdentifier("join"),
                     ),
-                    ts.factory.createIdentifier("join"),
+                    undefined,
+                    [tsc.factory.createStringLiteral(`,`)],
                 ),
-                undefined,
-                [ts.factory.createStringLiteral(`,`)],
-            ),
-            ts.factory.createStringLiteral(`]`),
-        ]);
+                tsc.factory.createStringLiteral(`]`),
+            ]);
 
-    export const tuple = (
-        children: ts.Expression[],
-        rest: ts.Expression | null,
-    ): ts.Expression => {
-        if (children.length === 0) return ts.factory.createStringLiteral("[]");
-        if (
-            rest === null &&
-            children.every((child) => ts.isStringLiteral(child))
-        )
-            return ts.factory.createStringLiteral(
-                "[" +
-                    children
-                        .map((child) => (child as ts.StringLiteral).text)
-                        .join(",") +
-                    "]",
-            );
+    export const tuple =
+        (tsc: typeof ts) =>
+        (
+            children: ts.Expression[],
+            rest: ts.Expression | null,
+        ): ts.Expression => {
+            if (children.length === 0)
+                return tsc.factory.createStringLiteral("[]");
+            if (
+                rest === null &&
+                children.every((child) => tsc.isStringLiteral(child))
+            )
+                return tsc.factory.createStringLiteral(
+                    "[" +
+                        children
+                            .map((child) => (child as ts.StringLiteral).text)
+                            .join(",") +
+                        "]",
+                );
 
-        const elements: ts.Expression[] = [ts.factory.createStringLiteral(`[`)];
-        children.forEach((child, i) => {
-            elements.push(child);
-            if (i !== children.length - 1)
-                elements.push(ts.factory.createStringLiteral(`,`));
-        });
-        if (rest !== null) elements.push(rest);
+            const elements: ts.Expression[] = [
+                tsc.factory.createStringLiteral(`[`),
+            ];
+            children.forEach((child, i) => {
+                elements.push(child);
+                if (i !== children.length - 1)
+                    elements.push(tsc.factory.createStringLiteral(`,`));
+            });
+            if (rest !== null) elements.push(rest);
 
-        elements.push(ts.factory.createStringLiteral(`]`));
-        return TemplateFactory.generate(elements);
-    };
+            elements.push(tsc.factory.createStringLiteral(`]`));
+            return TemplateFactory.generate(tsc)(elements);
+        };
 }

package/src/programmers/helpers/UnionExplorer.ts

@@ -1,4 +1,5 @@
-import ts from "typescript";
+import { JSDocTagInfo } from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
@@ -18,7 +19,7 @@ export namespace UnionExplorer {
             target: T,
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
+            jsDocTags: JSDocTagInfo[],
         ): ts.Expression;
     }
     export type ObjectCombiner = Decoder<MetadataObject[]>;
@@ -27,13 +28,14 @@ export namespace UnionExplorer {
         OBJECT
     ----------------------------------------------------------- */
     export const object =
+        (tsc: typeof ts) =>
         (config: FeatureProgrammer.IConfig, level: number = 0) =>
         (
             input: ts.Expression,
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
+            jsDocTags: JSDocTagInfo[],
         ): ts.Expression => {
             // BREAKER
             if (targets.length === 1)
@@ -76,7 +78,7 @@ export namespace UnionExplorer {
                 .map((spec) => {
                     const key: string = spec.property.key.getSoleLiteral()!;
                     const accessor: ts.Expression =
-                        IdentifierFactory.access(input)(key);
+                        IdentifierFactory.access(tsc)(input)(key);
                     const pred: ts.Expression = spec.neighbour
                         ? config.objector.checker(
                               accessor,
@@ -90,11 +92,11 @@ export namespace UnionExplorer {
                               jsDocTags,
                           )
                         : (config.objector.required || ((exp) => exp))(
-                              ExpressionFactory.isRequired(accessor),
+                              ExpressionFactory.isRequired(tsc)(accessor),
                           );
-                    return ts.factory.createIfStatement(
+                    return tsc.factory.createIfStatement(
                         (config.objector.is || ((exp) => exp))(pred),
-                        ts.factory.createReturnStatement(
+                        tsc.factory.createReturnStatement(
                             config.objector.decoder(
                                 input,
                                 spec.object,
@@ -107,19 +109,19 @@ export namespace UnionExplorer {
                 });
 
             // RETURNS WITH CONDITIONS
-            return ts.factory.createCallExpression(
-                ts.factory.createArrowFunction(
+            return tsc.factory.createCallExpression(
+                tsc.factory.createArrowFunction(
                     undefined,
                     undefined,
                     [],
                     undefined,
                     undefined,
-                    ts.factory.createBlock(
+                    tsc.factory.createBlock(
                         [
                             ...conditions,
                             remained.length
-                                ? ts.factory.createReturnStatement(
-                                      object(config, level + 1)(
+                                ? tsc.factory.createReturnStatement(
+                                      object(tsc)(config, level + 1)(
                                           input,
                                           remained,
                                           explore,
@@ -144,24 +146,27 @@ export namespace UnionExplorer {
     /* -----------------------------------------------------------
         ARRAY LIKE
     ----------------------------------------------------------- */
-    export const tuple = (props: check_union_array_like.IProps<Metadata[]>) =>
-        check_union_array_like<Metadata[]>({
-            size: null,
-            front: (input) => input,
-            array: (input) => input,
-            name: (elems) => `[${elems.map((e) => e.getName()).join(", ")}]`,
-        })(props);
+    export const tuple =
+        (tsc: typeof ts) =>
+        (props: check_union_array_like.IProps<Metadata[]>) =>
+            check_union_array_like(tsc)<Metadata[]>({
+                size: null,
+                front: (input) => input,
+                array: (input) => input,
+                name: (elems) =>
+                    `[${elems.map((e) => e.getName()).join(", ")}]`,
+            })(props);
     export namespace tuple {
         export type IProps = check_union_array_like.IProps<
             Metadata | Metadata[]
         >;
     }
 
-    export const array = (props: array.IProps) =>
-        check_union_array_like<Metadata>({
-            size: (input) => IdentifierFactory.access(input)("length"),
+    export const array = (tsc: typeof ts) => (props: array.IProps) =>
+        check_union_array_like(tsc)<Metadata>({
+            size: (input) => IdentifierFactory.access(tsc)(input)("length"),
             front: (input) =>
-                ts.factory.createElementAccessExpression(input, 0),
+                tsc.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
             name: (t) => `Array<${t.getName()}>`,
         })(props);
@@ -169,32 +174,33 @@ export namespace UnionExplorer {
         export type IProps = check_union_array_like.IProps<Metadata>;
     }
 
-    export const array_or_tuple = (props: array_or_tuple.IProps) =>
-        check_union_array_like<Metadata | Metadata[]>({
-            size: (input) => IdentifierFactory.access(input)("length"),
-            front: (input) =>
-                ts.factory.createElementAccessExpression(input, 0),
-            array: (input) => input,
-            name: (t) =>
-                Array.isArray(t)
-                    ? `[${t.map((e) => e.getName()).join(", ")}]`
-                    : `Array<${t.getName()}>`,
-        })(props);
+    export const array_or_tuple =
+        (tsc: typeof ts) => (props: array_or_tuple.IProps) =>
+            check_union_array_like(tsc)<Metadata | Metadata[]>({
+                size: (input) => IdentifierFactory.access(tsc)(input)("length"),
+                front: (input) =>
+                    tsc.factory.createElementAccessExpression(input, 0),
+                array: (input) => input,
+                name: (t) =>
+                    Array.isArray(t)
+                        ? `[${t.map((e) => e.getName()).join(", ")}]`
+                        : `Array<${t.getName()}>`,
+            })(props);
     export namespace array_or_tuple {
         export type IProps = check_union_array_like.IProps<
             Metadata | Metadata[]
         >;
     }
 
-    export const set = (props: set.IProps) =>
-        check_union_array_like<Metadata>({
-            size: (input) => IdentifierFactory.access(input)("size"),
+    export const set = (tsc: typeof ts) => (props: set.IProps) =>
+        check_union_array_like(tsc)<Metadata>({
+            size: (input) => IdentifierFactory.access(tsc)(input)("size"),
             front: (input) =>
-                IdentifierFactory.access(
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.access(
-                            ts.factory.createCallExpression(
-                                IdentifierFactory.access(input)("values"),
+                IdentifierFactory.access(tsc)(
+                    tsc.factory.createCallExpression(
+                        IdentifierFactory.access(tsc)(
+                            tsc.factory.createCallExpression(
+                                IdentifierFactory.access(tsc)(input)("values"),
                                 undefined,
                                 undefined,
                             ),
@@ -204,8 +210,8 @@ export namespace UnionExplorer {
                     ),
                 )("value"),
             array: (input) =>
-                ts.factory.createArrayLiteralExpression(
-                    [ts.factory.createSpreadElement(input)],
+                tsc.factory.createArrayLiteralExpression(
+                    [tsc.factory.createSpreadElement(input)],
                     false,
                 ),
             name: (t) => `Set<${t.getName()}>`,
@@ -214,15 +220,15 @@ export namespace UnionExplorer {
         export type IProps = check_union_array_like.IProps<Metadata>;
     }
 
-    export const map = (props: map.IProps) =>
-        check_union_array_like<[Metadata, Metadata]>({
-            size: (input) => IdentifierFactory.access(input)("size"),
+    export const map = (tsc: typeof ts) => (props: map.IProps) =>
+        check_union_array_like(tsc)<[Metadata, Metadata]>({
+            size: (input) => IdentifierFactory.access(tsc)(input)("size"),
             front: (input) =>
-                IdentifierFactory.access(
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.access(
-                            ts.factory.createCallExpression(
-                                IdentifierFactory.access(input)("entries"),
+                IdentifierFactory.access(tsc)(
+                    tsc.factory.createCallExpression(
+                        IdentifierFactory.access(tsc)(
+                            tsc.factory.createCallExpression(
+                                IdentifierFactory.access(tsc)(input)("entries"),
                                 undefined,
                                 undefined,
                             ),
@@ -232,8 +238,8 @@ export namespace UnionExplorer {
                     ),
                 )("value"),
             array: (input) =>
-                ts.factory.createArrayLiteralExpression(
-                    [ts.factory.createSpreadElement(input)],
+                tsc.factory.createArrayLiteralExpression(
+                    [tsc.factory.createSpreadElement(input)],
                     false,
                 ),
             name: ([k, v]) => `Map<${k.getName()}, ${v.getName()}>`,

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -0,0 +1,21 @@
+import type ts from "typescript/lib/tsclibrary";
+
+import { FunctionImporter } from "./FunctionImporeter";
+
+export const disable_function_importer_declare = (
+    importer: FunctionImporter,
+): FunctionImporter => disable(importer) as FunctionImporter;
+
+const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
+    empty: (): boolean => importer.empty(),
+    use: (name: string): ts.Identifier => importer.use(name),
+    useLocal: (name: string): string => importer.useLocal(name),
+    hasLocal: (name: string): boolean => importer.hasLocal(name),
+    declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
+    increment: (): number => importer.increment(),
+    trace: (): void => importer.trace(),
+});
+
+type MethodOnly<T> = {
+    [P in keyof T]: T[P] extends Function ? T[P] : never;
+};

package/src/programmers/internal/JSON_SCHEMA_PREFIX.ts

@@ -0,0 +1 @@
+export const JSON_SCHEMA_PREFIX = "#/components/schemas";

package/src/programmers/internal/application_array.ts

@@ -13,23 +13,19 @@ export const application_array =
     (components: IJsonComponents) =>
     (tuple?: IJsonSchema.ITuple) =>
     (metadata: Metadata) =>
-    (props: {
-        nullable: boolean;
-        attribute: IJsonSchema.IAttribute;
-    }): IJsonSchema.IArray => {
+    (attribute: IJsonSchema.IAttribute): IJsonSchema.IArray => {
         // SCHEMA
         const output: IJsonSchema.IArray = {
+            ...attribute,
             type: "array",
             items: application_schema(options)(false)(components)(metadata)(
-                props.attribute,
+                attribute,
             ),
-            nullable: props.nullable,
             "x-typia-tuple": tuple,
-            ...props.attribute,
         };
 
         // RANGE
-        for (const tag of props.attribute["x-typia-metaTags"] || [])
+        for (const tag of attribute["x-typia-metaTags"] ?? [])
             if (tag.kind === "minItems") output.minItems = tag.value;
             else if (tag.kind === "maxItems") output.maxItems = tag.value;
         return output;