typia 5.0.0-dev.2023084 → 5.0.0

package/src/programmers/helpers/RandomRanger.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 
 export namespace RandomRanger {
     export interface IDefaults {
@@ -13,15 +13,12 @@ export namespace RandomRanger {
         (coalesce: (method: string) => ts.Expression) =>
         (defs: IDefaults) =>
         (acc: length.IAccessors) =>
-        (tags: IMetadataTag[]): ts.Expression | undefined => {
+        (tags: IMetadataTypeTag[]): ts.Expression | undefined => {
             const props = {
-                fixed: getter(tags)(acc.fixed),
                 minimum: getter(tags)(acc.minimum),
                 maximum: getter(tags)(acc.maximum),
             };
-            if (props.fixed !== undefined)
-                return ts.factory.createNumericLiteral(props.fixed);
-            else if (props.minimum === undefined && props.maximum === undefined)
+            if (props.minimum === undefined && props.maximum === undefined)
                 return undefined;
 
             props.minimum ??= defs.minimum;
@@ -40,16 +37,15 @@ export namespace RandomRanger {
         };
     export namespace length {
         export interface IAccessors {
-            minimum: IMetadataTag["kind"];
-            maximum: IMetadataTag["kind"];
-            fixed: IMetadataTag["kind"];
+            minimum: string;
+            maximum: string;
         }
     }
 
     export const number =
         (config: number.IConfig) =>
         (defs: IDefaults) =>
-        (tags: IMetadataTag[]): ts.Expression => {
+        (tags: IMetadataTypeTag[]): ts.Expression => {
             const range = {
                 minimum: {
                     value:
@@ -63,30 +59,14 @@ export namespace RandomRanger {
                         getter(tags)("exclusiveMaximum"),
                     exclusive: getter(tags)("exclusiveMaximum") !== undefined,
                 },
-                step: getter(tags)("step"),
+                stepper: undefined,
                 multiply: getter(tags)("multipleOf"),
             };
-            if (Object.values(range).every((v) => v !== undefined))
-                return config.setter([]);
 
             //----
             // MULTIPLIERS
             //----
-            // STEP
-            if (range.step !== undefined) {
-                const { intercept, minimum, maximum } = stepper(defs.gap)(
-                    range,
-                )(range.step);
-                return ts.factory.createAdd(
-                    config.transform(intercept),
-                    ts.factory.createMultiply(
-                        config.transform(range.step),
-                        config.setter([minimum, maximum]),
-                    ),
-                );
-            }
-            // MULTIPLE-OF
-            else if (range.multiply !== undefined) {
+            if (range.multiply !== undefined) {
                 const { minimum, maximum } = multiplier(defs.gap)(range)(
                     range.multiply,
                 );
@@ -151,30 +131,15 @@ export namespace RandomRanger {
 }
 
 const getter =
-    (tags: IMetadataTag[]) =>
-    (kind: IMetadataTag["kind"]): number | undefined =>
-        tags.find((t) => t.kind === kind)?.value as number | undefined;
-
-const stepper = (gap: number) => (range: IRange) => (s: number) => {
-    const intercept: number = range.minimum.value!;
-    const minimum: number = range.minimum.exclusive ? 1 : 0;
-    if (range.maximum.value === undefined)
-        return {
-            intercept,
-            minimum,
-            maximum: gap,
-        };
-
-    const y: number = Math.floor(range.maximum.value - intercept) / s;
-    return {
-        intercept,
-        minimum,
-        maximum:
-            range.maximum.exclusive && intercept + y * s === range.maximum.value
-                ? y - 1
-                : y,
+    (tags: IMetadataTypeTag[]) =>
+    (kind: string): number | undefined => {
+        const value: bigint | number | undefined = tags.find(
+            (t) =>
+                t.kind === kind &&
+                (typeof t.value === "number" || typeof t.value === "bigint"),
+        )?.value;
+        return value !== undefined ? Number(value) : undefined;
     };
-};
 
 const multiplier = (gap: number) => (range: IRange) => (m: number) => {
     const minimum: number =

package/src/programmers/helpers/StringifyPredicator.ts

@@ -1,12 +1,12 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-export namespace StringifyPredicator {
-    export const require_escape = (value: string): boolean =>
-        value.split("").some((ch) => ESCAPED.some((escaped) => escaped === ch));
-
-    export const undefindable = (meta: Metadata): boolean =>
-        meta.isRequired() === false ||
-        (meta.escaped !== null && meta.escaped.returns.isRequired() === false);
-
-    const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
-}
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+export namespace StringifyPredicator {
+    export const require_escape = (value: string): boolean =>
+        value.split("").some((ch) => ESCAPED.some((escaped) => escaped === ch));
+
+    export const undefindable = (meta: Metadata): boolean =>
+        meta.isRequired() === false ||
+        (meta.escaped !== null && meta.escaped.returns.isRequired() === false);
+
+    const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
+}

package/src/programmers/helpers/UnionExplorer.ts

@@ -3,11 +3,12 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { check_union_array_like } from "../internal/check_union_array_like";
@@ -19,8 +20,6 @@ export namespace UnionExplorer {
             input: ts.Expression,
             target: T,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression;
     }
     export type ObjectCombiner = Decoder<MetadataObject[]>;
@@ -34,18 +33,10 @@ export namespace UnionExplorer {
             input: ts.Expression,
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             // BREAKER
             if (targets.length === 1)
-                return config.objector.decoder()(
-                    input,
-                    targets[0]!,
-                    explore,
-                    tags,
-                    jsDocTags,
-                );
+                return config.objector.decoder()(input, targets[0]!, explore);
 
             const expected: string = `(${targets
                 .map((t) => t.name)
@@ -61,8 +52,6 @@ export namespace UnionExplorer {
                         ...explore,
                         tracable: false,
                     },
-                    tags,
-                    jsDocTags,
                 );
                 return config.objector.full
                     ? config.objector.full(condition)(input, expected, explore)
@@ -88,8 +77,6 @@ export namespace UnionExplorer {
                                   tracable: false,
                                   postfix: IdentifierFactory.postfix(key),
                               },
-                              tags,
-                              jsDocTags,
                           )
                         : (config.objector.required || ((exp) => exp))(
                               ExpressionFactory.isRequired(accessor),
@@ -101,8 +88,6 @@ export namespace UnionExplorer {
                                 input,
                                 spec.object,
                                 explore,
-                                tags,
-                                jsDocTags,
                             ),
                         ),
                         i === array.length - 1
@@ -112,8 +97,6 @@ export namespace UnionExplorer {
                                           input,
                                           remained,
                                           explore,
-                                          tags,
-                                          jsDocTags,
                                       ),
                                   )
                                 : config.objector.failure(
@@ -160,7 +143,7 @@ export namespace UnionExplorer {
             size: null!,
             front: (input) => input,
             array: (input) => input,
-            name: (t) => t.name,
+            name: (t) => t.type.name,
         })(props);
     export namespace tuple {
         export type IProps = check_union_array_like.IProps<
@@ -172,12 +155,12 @@ export namespace UnionExplorer {
     export const array = (props: array.IProps) =>
         check_union_array_like<MetadataArray, MetadataArray, Metadata>({
             transform: (x) => x,
-            element: (x) => x.value,
+            element: (x) => x.type.value,
             size: (input) => IdentifierFactory.access(input)("length"),
             front: (input) =>
                 ts.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
-            name: (t) => t.name,
+            name: (t) => t.type.name,
         })(props);
     export namespace array {
         export type IProps = check_union_array_like.IProps<
@@ -193,12 +176,12 @@ export namespace UnionExplorer {
             Metadata | MetadataTuple
         >({
             transform: (x) => x,
-            element: (x) => (x instanceof MetadataArray ? x.value : x),
+            element: (x) => (x instanceof MetadataArray ? x.type.value : x),
             size: (input) => IdentifierFactory.access(input)("length"),
             front: (input) =>
                 ts.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
-            name: (m) => m.name,
+            name: (m) => m.type.name,
         })(props);
     export namespace array_or_tuple {
         export type IProps = check_union_array_like.IProps<
@@ -211,13 +194,16 @@ export namespace UnionExplorer {
         check_union_array_like<Metadata, MetadataArray, Metadata>({
             transform: (value: Metadata) =>
                 MetadataArray.create({
-                    name: `Set<${value.getName()}>`,
-                    index: null,
-                    recursive: false,
-                    nullables: [],
-                    value,
+                    tags: [],
+                    type: MetadataArrayType.create({
+                        name: `Set<${value.getName()}>`,
+                        index: null,
+                        recursive: false,
+                        nullables: [],
+                        value,
+                    }),
                 }),
-            element: (array) => array.value,
+            element: (array) => array.type.value,
             size: (input) => IdentifierFactory.access(input)("size"),
             front: (input) =>
                 IdentifierFactory.access(
@@ -254,7 +240,10 @@ export namespace UnionExplorer {
             [Metadata, Metadata]
         >({
             element: (array) =>
-                array.value.tuples[0]!.elements as [Metadata, Metadata],
+                array.type.value.tuples[0]!.type.elements as [
+                    Metadata,
+                    Metadata,
+                ],
             size: (input) => IdentifierFactory.access(input)("size"),
             front: (input) =>
                 IdentifierFactory.access(
@@ -278,25 +267,31 @@ export namespace UnionExplorer {
             name: (_m, [k, v]) => `Map<${k.getName()}, ${v.getName()}>`,
             transform: (m: Metadata.Entry) =>
                 MetadataArray.create({
-                    name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
-                    index: null,
-                    recursive: false,
-                    nullables: [],
-                    value: Metadata.create({
-                        ...Metadata.initialize(),
-                        tuples: [
-                            (() => {
-                                const tuple = MetadataTuple.create({
-                                    name: `[${m.key.getName()}, ${m.value.getName()}]`,
-                                    index: null,
-                                    recursive: false,
-                                    nullables: [],
-                                    elements: [m.key, m.value],
-                                });
-                                tuple.of_map = true;
-                                return tuple;
-                            })(),
-                        ],
+                    tags: [],
+                    type: MetadataArrayType.create({
+                        name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
+                        index: null,
+                        recursive: false,
+                        nullables: [],
+                        value: Metadata.create({
+                            ...Metadata.initialize(),
+                            tuples: [
+                                (() => {
+                                    const tuple = MetadataTuple.create({
+                                        tags: [],
+                                        type: MetadataTupleType.create({
+                                            name: `[${m.key.getName()}, ${m.value.getName()}]`,
+                                            index: null,
+                                            recursive: false,
+                                            nullables: [],
+                                            elements: [m.key, m.value],
+                                        }),
+                                    });
+                                    tuple.type.of_map = true;
+                                    return tuple;
+                                })(),
+                            ],
+                        }),
                     }),
                 }),
         })(props);

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { FunctionImporter } from "./FunctionImporeter";
-
-export const disable_function_importer_declare = (
-    importer: FunctionImporter,
-): FunctionImporter => disable(importer) as FunctionImporter;
-
-const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
-    method: importer.method,
-    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[] => [],
-    declareUnions: (): ts.Statement[] => [],
-    increment: (): number => importer.increment(),
-    emplaceUnion: (
-        prefix: string,
-        name: string,
-        factory: () => ts.ArrowFunction,
-    ): string => importer.emplaceUnion(prefix, name, factory),
-    trace: (): void => importer.trace(),
-});
-
-type MethodOnly<T> = {
-    [P in keyof T]: T[P] extends Function
-        ? T[P]
-        : P extends "method"
-        ? T[P]
-        : never;
-};
+import ts from "typescript";
+
+import { FunctionImporter } from "./FunctionImporeter";
+
+export const disable_function_importer_declare = (
+    importer: FunctionImporter,
+): FunctionImporter => disable(importer) as FunctionImporter;
+
+const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
+    method: importer.method,
+    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[] => [],
+    declareUnions: (): ts.Statement[] => [],
+    increment: (): number => importer.increment(),
+    emplaceUnion: (
+        prefix: string,
+        name: string,
+        factory: () => ts.ArrowFunction,
+    ): string => importer.emplaceUnion(prefix, name, factory),
+    trace: (): void => importer.trace(),
+});
+
+type MethodOnly<T> = {
+    [P in keyof T]: T[P] extends Function
+        ? T[P]
+        : P extends "method"
+        ? T[P]
+        : never;
+};

package/src/programmers/internal/application_alias.ts

@@ -49,7 +49,6 @@ export const application_alias =
                         : undefined;
                 })(),
                 description: alias.description ?? undefined,
-                "x-typia-metaTags": alias.tags.length ? alias.tags : undefined,
                 "x-typia-jsDocTags": alias.jsDocTags.length
                     ? alias.jsDocTags
                     : undefined,

package/src/programmers/internal/application_array.ts

@@ -1,5 +1,6 @@
 import { IJsonComponents } from "../../schemas/json/IJsonComponents";
 import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 
 import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
@@ -12,19 +13,41 @@ export const application_array =
     (options: JsonApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
     (array: MetadataArray) =>
-    (attribute: IJsonSchema.IAttribute): IJsonSchema.IArray => {
-        // SCHEMA
-        const schema: IJsonSchema.IArray = {
+    (attribute: IJsonSchema.IAttribute): IJsonSchema.IArray[] => {
+        // BASE SCHEMA
+        const items: IJsonSchema = application_schema(options)(false)(
+            components,
+        )(array.type.value)(attribute);
+        const base: IJsonSchema.IArray = {
             ...attribute,
             type: "array",
-            items: application_schema(options)(false)(components)(array.value)(
-                attribute,
-            ),
+            items: null!,
         };
+        const out = (schema: IJsonSchema.IArray) => {
+            schema.items = items;
+            return schema;
+        };
+        if (array.tags.length === 0) return [out(base)];
+
+        // CONSIDER TYPE TAGS
+        const union: IJsonSchema.IArray[] = array.tags.map(
+            (row) => application_array_tags({ ...base })(row)!,
+        );
+        const map: Map<string, IJsonSchema.IArray> = new Map(
+            union.map((u) => [JSON.stringify(u), u]),
+        );
+        return [...map.values()].map((s) => out(s));
+    };
 
-        // RANGE
-        for (const tag of attribute["x-typia-metaTags"] ?? [])
-            if (tag.kind === "minItems") schema.minItems = tag.value;
-            else if (tag.kind === "maxItems") schema.maxItems = tag.value;
+const application_array_tags =
+    (schema: IJsonSchema.IArray) =>
+    (row: IMetadataTypeTag[]): IJsonSchema.IArray => {
+        for (const tag of row
+            .slice()
+            .sort((a, b) => a.kind.localeCompare(b.kind)))
+            if (tag.kind === "minItems" && typeof tag.value === "number")
+                schema.minItems = tag.value;
+            else if (tag.kind === "maxItems" && typeof tag.value === "number")
+                schema.maxItems = tag.value;
         return schema;
     };

package/src/programmers/internal/application_default_string.ts

@@ -1,37 +1,37 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IJsonSchema } from "../../module";
-import { application_default } from "./application_default";
-
-/**
- * @internal
- */
-export const application_default_string =
-    (meta: Metadata) =>
-    (attribute: IJsonSchema.IAttribute) =>
-    (schema: IJsonSchema.IString) =>
-        application_default(attribute)((str) => {
-            const conditions: boolean[] = [];
-
-            // OTHER ATOMIC TYPES
-            if (
-                meta.atomics.find(
-                    (a) => a.type === "number" || a.type === "bigint",
-                )
-            )
-                conditions.push(Number.isNaN(Number(str)));
-            if (meta.atomics.find((a) => a.type === "boolean"))
-                conditions.push(str !== "true" && str !== "false");
-            for (const constant of meta.constants)
-                for (const value of constant.values)
-                    conditions.push(str !== value.toString());
-
-            // CONSIDER TAGS
-            if (schema.minLength !== undefined)
-                conditions.push(str.length >= schema.minLength);
-            if (schema.maxLength !== undefined)
-                conditions.push(str.length <= schema.maxLength);
-            if (schema.pattern !== undefined)
-                conditions.push(new RegExp(schema.pattern).test(str));
-            return conditions.every((c) => c);
-        })((str) => str);
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IJsonSchema } from "../../module";
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_default_string =
+    (meta: Metadata) =>
+    (attribute: IJsonSchema.IAttribute) =>
+    (schema: IJsonSchema.IString) =>
+        application_default(attribute)((str) => {
+            const conditions: boolean[] = [];
+
+            // OTHER ATOMIC TYPES
+            if (
+                meta.atomics.find(
+                    (a) => a.type === "number" || a.type === "bigint",
+                )
+            )
+                conditions.push(Number.isNaN(Number(str)));
+            if (meta.atomics.find((a) => a.type === "boolean"))
+                conditions.push(str !== "true" && str !== "false");
+            for (const constant of meta.constants)
+                for (const value of constant.values)
+                    conditions.push(str !== value.toString());
+
+            // CONSIDER TAGS
+            if (schema.minLength !== undefined)
+                conditions.push(str.length >= schema.minLength);
+            if (schema.maxLength !== undefined)
+                conditions.push(str.length <= schema.maxLength);
+            if (schema.pattern !== undefined)
+                conditions.push(new RegExp(schema.pattern).test(str));
+            return conditions.every((c) => c);
+        })((str) => str);

package/src/programmers/internal/{application_resolved.ts → application_escaped.ts}

@@ -1,55 +1,55 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
-
-import { IJsonComponents, IJsonSchema } from "../../module";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_schema } from "./application_schema";
-
-export const application_resolved =
-    (options: JsonApplicationProgrammer.IOptions) =>
-    <BlockNever extends boolean>(blockNever: BlockNever) =>
-    (components: IJsonComponents) =>
-    (resolved: MetadataEscaped) =>
-    (attribute: IJsonSchema.IAttribute): IJsonSchema[] => {
-        const output = application_schema(options)(blockNever)(components)(
-            resolved.returns,
-        )(attribute);
-        if (output === null) return [];
-
-        if (is_date(new Set())(resolved.original)) {
-            const string: IJsonSchema.IString | undefined = is_string(output)
-                ? output
-                : is_one_of(output)
-                ? output.oneOf.find(is_string)
-                : undefined;
-            if (
-                string !== undefined &&
-                string.format !== "date" &&
-                string.format !== "date-time"
-            )
-                string.format = "date-time";
-        }
-        return is_one_of(output) ? output.oneOf : [output];
-    };
-
-const is_string = (elem: IJsonSchema): elem is IJsonSchema.IString =>
-    (elem as IJsonSchema.IString).type === "string";
-
-const is_one_of = (elem: IJsonSchema): elem is IJsonSchema.IOneOf =>
-    Array.isArray((elem as IJsonSchema.IOneOf).oneOf);
-
-const is_date =
-    (visited: Set<Metadata>) =>
-    (meta: Metadata): boolean => {
-        if (visited.has(meta)) return false;
-        visited.add(meta);
-
-        return (
-            meta.natives.some((name) => name === "Date") ||
-            meta.arrays.some((array) => is_date(visited)(array.value)) ||
-            meta.tuples.some((tuple) =>
-                tuple.elements.some(is_date(visited)),
-            ) ||
-            meta.aliases.some((alias) => is_date(visited)(alias.value))
-        );
-    };
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
+
+import { IJsonComponents, IJsonSchema } from "../../module";
+import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
+import { application_schema } from "./application_schema";
+
+export const application_escaped =
+    (options: JsonApplicationProgrammer.IOptions) =>
+    <BlockNever extends boolean>(blockNever: BlockNever) =>
+    (components: IJsonComponents) =>
+    (resolved: MetadataEscaped) =>
+    (attribute: IJsonSchema.IAttribute): IJsonSchema[] => {
+        const output = application_schema(options)(blockNever)(components)(
+            resolved.returns,
+        )(attribute);
+        if (output === null) return [];
+
+        if (is_date(new Set())(resolved.original)) {
+            const string: IJsonSchema.IString | undefined = is_string(output)
+                ? output
+                : is_one_of(output)
+                ? output.oneOf.find(is_string)
+                : undefined;
+            if (
+                string !== undefined &&
+                string.format !== "date" &&
+                string.format !== "date-time"
+            )
+                string.format = "date-time";
+        }
+        return is_one_of(output) ? output.oneOf : [output];
+    };
+
+const is_string = (elem: IJsonSchema): elem is IJsonSchema.IString =>
+    (elem as IJsonSchema.IString).type === "string";
+
+const is_one_of = (elem: IJsonSchema): elem is IJsonSchema.IOneOf =>
+    Array.isArray((elem as IJsonSchema.IOneOf).oneOf);
+
+const is_date =
+    (visited: Set<Metadata>) =>
+    (meta: Metadata): boolean => {
+        if (visited.has(meta)) return false;
+        visited.add(meta);
+
+        return (
+            meta.natives.some((name) => name === "Date") ||
+            meta.arrays.some((array) => is_date(visited)(array.type.value)) ||
+            meta.tuples.some((tuple) =>
+                tuple.type.elements.some(is_date(visited)),
+            ) ||
+            meta.aliases.some((alias) => is_date(visited)(alias.value))
+        );
+    };