typia 4.3.2-dev.20230821 → 4.3.3-dev.20230825

package/src/transformers/features/miscellaneous/CreateValidateCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateValidateCloneTransformer {
-    export const transform = GenericTransformer.factory("createValidateClone")(
-        (project) => (modulo) => ValidateCloneProgrammer.write(project)(modulo),
-    );
-}
+import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateValidateCloneTransformer {
+    export const transform = GenericTransformer.factory("createValidateClone")(
+        (project) => (modulo) => ValidateCloneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/CreateValidatePruneTransformer.ts

@@ -1,9 +1,9 @@
-import { ValidatePruneProgrammer } from "../../../programmers/ValidatePruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateValidatePruneTransformer {
-    export const transform = GenericTransformer.factory("createValidatePrune")(
-        (project) => (modulo) => ValidatePruneProgrammer.write(project)(modulo),
-    );
-}
+import { ValidatePruneProgrammer } from "../../../programmers/ValidatePruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateValidatePruneTransformer {
+    export const transform = GenericTransformer.factory("createValidatePrune")(
+        (project) => (modulo) => ValidatePruneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/IsCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace IsCloneTransformer {
-    export const transform = GenericTransformer.scalar("isClone")(
-        (project) => (modulo) => IsCloneProgrammer.write(project)(modulo),
-    );
-}
+import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace IsCloneTransformer {
+    export const transform = GenericTransformer.scalar("isClone")(
+        (project) => (modulo) => IsCloneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/IsPruneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace IsPruneTransformer {
-    export const transform = GenericTransformer.scalar("isPrune")(
-        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
-    );
-}
+import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace IsPruneTransformer {
+    export const transform = GenericTransformer.scalar("isPrune")(
+        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/LiteralsTransformer.ts

@@ -1,28 +1,28 @@
-import ts from "typescript";
-
-import { LiteralsProgrammer } from "../../../programmers/LiteralsProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace LiteralsTransformer {
-    export const transform =
-        (project: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
-
-            // GET TYPE INFO
-            const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
-
-            // DO TRANSFORM
-            return LiteralsProgrammer.write(project)(type);
-        };
-}
-
-const NOT_SPECIFIED =
-    "Error on typia.literals(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.literals(): non-specified generic argument.";
+import ts from "typescript";
+
+import { LiteralsProgrammer } from "../../../programmers/LiteralsProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace LiteralsTransformer {
+    export const transform =
+        (project: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+
+            // GET TYPE INFO
+            const node: ts.TypeNode = expression.typeArguments[0];
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+
+            // DO TRANSFORM
+            return LiteralsProgrammer.write(project)(type);
+        };
+}
+
+const NOT_SPECIFIED =
+    "Error on typia.literals(): generic argument is not specified.";
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.literals(): non-specified generic argument.";

package/src/transformers/features/miscellaneous/MetadataTransformer.ts

@@ -1,53 +1,53 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IMetadataApplication } from "../../../metadata/IMetadataApplication";
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProject } from "../../IProject";
-
-export namespace MetadataTransformer {
-    export const transform =
-        ({ checker }: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
-
-            // VALIDATE TUPLE ARGUMENTS
-            const top: ts.Node = expression.typeArguments[0]!;
-            if (!ts.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !ts.isTypeNode(child)))
-                return expression;
-
-            // GET TYPES
-            const types: ts.Type[] = top.elements.map((child) =>
-                checker.getTypeFromTypeNode(child as ts.TypeNode),
-            );
-            if (types.some((t) => t.isTypeParameter()))
-                throw new Error(GENERIC_ARGUMENT);
-
-            // METADATA
-            const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
-                    resolve: true,
-                    constant: true,
-                    absorb: true,
-                })(collection)(type),
-            );
-
-            // CONVERT TO PRIMITIVE TYPE
-            const app: IMetadataApplication = {
-                metadatas: metadatas.map((metadata) => metadata.toJSON()),
-                collection: collection.toJSON(),
-            };
-            return LiteralFactory.generate(app);
-        };
-}
-
-const NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.metadata(): non-specified generic argument(s).";
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IMetadataApplication } from "../../../metadata/IMetadataApplication";
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProject } from "../../IProject";
+
+export namespace MetadataTransformer {
+    export const transform =
+        ({ checker }: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new Error(NO_GENERIC_ARGUMENT);
+
+            // VALIDATE TUPLE ARGUMENTS
+            const top: ts.Node = expression.typeArguments[0]!;
+            if (!ts.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !ts.isTypeNode(child)))
+                return expression;
+
+            // GET TYPES
+            const types: ts.Type[] = top.elements.map((child) =>
+                checker.getTypeFromTypeNode(child as ts.TypeNode),
+            );
+            if (types.some((t) => t.isTypeParameter()))
+                throw new Error(GENERIC_ARGUMENT);
+
+            // METADATA
+            const collection: MetadataCollection = new MetadataCollection();
+            const metadatas: Array<Metadata> = types.map((type) =>
+                MetadataFactory.analyze(checker)({
+                    resolve: true,
+                    constant: true,
+                    absorb: true,
+                })(collection)(type),
+            );
+
+            // CONVERT TO PRIMITIVE TYPE
+            const app: IMetadataApplication = {
+                metadatas: metadatas.map((metadata) => metadata.toJSON()),
+                collection: collection.toJSON(),
+            };
+            return LiteralFactory.generate(app);
+        };
+}
+
+const NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";
+const GENERIC_ARGUMENT =
+    "Error on typia.metadata(): non-specified generic argument(s).";

package/src/transformers/features/miscellaneous/PruneTransformer.ts

@@ -1,9 +1,9 @@
-import { PruneProgrammer } from "../../../programmers/PruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace PruneTransformer {
-    export const transform = GenericTransformer.scalar("prune")(
-        (project) => (modulo) => PruneProgrammer.write(project)(modulo),
-    );
-}
+import { PruneProgrammer } from "../../../programmers/PruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace PruneTransformer {
+    export const transform = GenericTransformer.scalar("prune")(
+        (project) => (modulo) => PruneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/RandomTransformer.ts

@@ -1,42 +1,42 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace RandomTransformer {
-    export const transform =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
-
-            // GET TYPE INFO
-            const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
-
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                RandomProgrammer.write({
-                    ...project,
-                    options: {
-                        ...project.options,
-                        functional: false,
-                        numeric: false,
-                    },
-                })(modulo)()(type, node.getFullText().trim()),
-                undefined,
-                expression.arguments.length
-                    ? [expression.arguments[0]!]
-                    : undefined,
-            );
-        };
-}
-
-const NOT_SPECIFIED =
-    "Error on typia.random(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.random(): non-specified generic argument.";
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace RandomTransformer {
+    export const transform =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+
+            // GET TYPE INFO
+            const node: ts.TypeNode = expression.typeArguments[0];
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                RandomProgrammer.write({
+                    ...project,
+                    options: {
+                        ...project.options,
+                        functional: false,
+                        numeric: false,
+                    },
+                })(modulo)()(type, node.getFullText().trim()),
+                undefined,
+                expression.arguments.length
+                    ? [expression.arguments[0]!]
+                    : undefined,
+            );
+        };
+}
+
+const NOT_SPECIFIED =
+    "Error on typia.random(): generic argument is not specified.";
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.random(): non-specified generic argument.";

package/src/transformers/features/miscellaneous/ValidateCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidateCloneTransformer {
-    export const transform = GenericTransformer.scalar("validatClone")(
-        (project) => (modulo) => ValidateCloneProgrammer.write(project)(modulo),
-    );
-}
+import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidateCloneTransformer {
+    export const transform = GenericTransformer.scalar("validatClone")(
+        (project) => (modulo) => ValidateCloneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/ValidatePruneTransformer.ts

@@ -1,9 +1,9 @@
-import { ValidatePruneProgrammer } from "../../../programmers/ValidatePruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidatePruneTransformer {
-    export const transform = GenericTransformer.scalar("validatPrune")(
-        (project) => (modulo) => ValidatePruneProgrammer.write(project)(modulo),
-    );
-}
+import { ValidatePruneProgrammer } from "../../../programmers/ValidatePruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidatePruneTransformer {
+    export const transform = GenericTransformer.scalar("validatPrune")(
+        (project) => (modulo) => ValidatePruneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/parsers/AssertParseTransformer.ts

@@ -1,9 +1,9 @@
-import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace AssertParseTransformer {
-    export const transform = GenericTransformer.scalar("assertParse")(
-        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
-    );
-}
+import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace AssertParseTransformer {
+    export const transform = GenericTransformer.scalar("assertParse")(
+        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/parsers/CreateAssertParseTransformer.ts

@@ -1,9 +1,9 @@
-import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateAssertParseTransformer {
-    export const transform = GenericTransformer.factory("createAssertParse")(
-        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
-    );
-}
+import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateAssertParseTransformer {
+    export const transform = GenericTransformer.factory("createAssertParse")(
+        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/parsers/CreateIsParseTransformer.ts

@@ -1,9 +1,9 @@
-import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateIsParseTransformer {
-    export const transform = GenericTransformer.factory("createIsParse")(
-        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
-    );
-}
+import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateIsParseTransformer {
+    export const transform = GenericTransformer.factory("createIsParse")(
+        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/parsers/CreateValidateParseTransformer.ts

@@ -1,9 +1,9 @@
-import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateValidateParseTransformer {
-    export const transform = GenericTransformer.factory("createValidateParse")(
-        (project) => (modulo) => ValidateParseProgrammer.write(project)(modulo),
-    );
-}
+import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateValidateParseTransformer {
+    export const transform = GenericTransformer.factory("createValidateParse")(
+        (project) => (modulo) => ValidateParseProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/parsers/IsParseTransformer.ts

@@ -1,9 +1,9 @@
-import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace IsParseTransformer {
-    export const transform = GenericTransformer.scalar("isParse")(
-        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
-    );
-}
+import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace IsParseTransformer {
+    export const transform = GenericTransformer.scalar("isParse")(
+        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/parsers/ValidateParseTransformer.ts

@@ -1,9 +1,9 @@
-import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidateParseTransformer {
-    export const transform = GenericTransformer.scalar("validatParse")(
-        (project) => (modulo) => ValidateParseProgrammer.write(project)(modulo),
-    );
-}
+import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidateParseTransformer {
+    export const transform = GenericTransformer.scalar("validatParse")(
+        (project) => (modulo) => ValidateParseProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/stringifiers/AssertStringifyTransformer.ts

@@ -1,10 +1,10 @@
-import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace AssertStringifyTransformer {
-    export const transform = GenericTransformer.scalar("assertStringify")(
-        (project) => (modulo) =>
-            AssertStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace AssertStringifyTransformer {
+    export const transform = GenericTransformer.scalar("assertStringify")(
+        (project) => (modulo) =>
+            AssertStringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/stringifiers/CreateAssertStringifyTransformer.ts

@@ -1,12 +1,12 @@
-import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateAssertStringifyTransformer {
-    export const transform = GenericTransformer.factory(
-        "createAssertStringify",
-    )(
-        (project) => (modulo) =>
-            AssertStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateAssertStringifyTransformer {
+    export const transform = GenericTransformer.factory(
+        "createAssertStringify",
+    )(
+        (project) => (modulo) =>
+            AssertStringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/stringifiers/CreateIsStringifyTransformer.ts

@@ -1,9 +1,9 @@
-import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateIsStringifyTransformer {
-    export const transform = GenericTransformer.factory("createIsStringify")(
-        (project) => (modulo) => IsStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateIsStringifyTransformer {
+    export const transform = GenericTransformer.factory("createIsStringify")(
+        (project) => (modulo) => IsStringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/stringifiers/CreateStringifyTransformer.ts

@@ -1,9 +1,9 @@
-import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateStringifyTransformer {
-    export const transform = GenericTransformer.factory("createStringify")(
-        (project) => (modulo) => StringifyProgrammer.write(project)(modulo),
-    );
-}
+import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateStringifyTransformer {
+    export const transform = GenericTransformer.factory("createStringify")(
+        (project) => (modulo) => StringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/stringifiers/CreateValidateStringifyProgrammer.ts

@@ -1,12 +1,12 @@
-import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateValidateStringifyTransformer {
-    export const transform = GenericTransformer.factory(
-        "createValidateStringify",
-    )(
-        (project) => (modulo) =>
-            ValidateStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateValidateStringifyTransformer {
+    export const transform = GenericTransformer.factory(
+        "createValidateStringify",
+    )(
+        (project) => (modulo) =>
+            ValidateStringifyProgrammer.write(project)(modulo),
+    );
+}