Add range limit for numeric types.

build/internal/TestFeature.ts

@@ -8,10 +8,10 @@ export interface TestFeature {
     explicit?: true;
     primitive?: true;
     random?: true;
-    opposite?: {
+    opposite?: Array<{
         name: string;
         method: string;
-    };
+    }>;
 }
 export namespace TestFeature {
     export const DATA: TestFeature[] = [
@@ -69,10 +69,12 @@ export namespace TestFeature {
             spoilable: false,
             primitive: true,
             random: true,
-            opposite: {
-                name: "assert",
-                method: "typia.createAssert",
-            },
+            opposite: [
+                {
+                    name: "assert",
+                    method: "typia.createAssert",
+                },
+            ],
         },
 
         //----
@@ -84,40 +86,48 @@ export namespace TestFeature {
             method: "encode",
             creatable: true,
             spoilable: false,
-            opposite: {
-                name: "message",
-                method: "typia.protobuf.message",
-            },
+            opposite: [
+                {
+                    name: "message",
+                    method: "typia.protobuf.message",
+                },
+            ],
         },
         {
             module: "protobuf",
             method: "isEncode",
             creatable: true,
             spoilable: true,
-            opposite: {
-                name: "message",
-                method: "typia.protobuf.message",
-            },
+            opposite: [
+                {
+                    name: "message",
+                    method: "typia.protobuf.message",
+                },
+            ],
         },
         {
             module: "protobuf",
             method: "assertEncode",
             creatable: true,
             spoilable: true,
-            opposite: {
-                name: "message",
-                method: "typia.protobuf.message",
-            },
+            opposite: [
+                {
+                    name: "message",
+                    method: "typia.protobuf.message",
+                },
+            ],
         },
         {
             module: "protobuf",
             method: "validateEncode",
             creatable: true,
             spoilable: true,
-            opposite: {
-                name: "message",
-                method: "typia.protobuf.message",
-            },
+            opposite: [
+                {
+                    name: "message",
+                    method: "typia.protobuf.message",
+                },
+            ],
         },
 
         //----

build/test.ts

@@ -99,11 +99,13 @@ function script(
               struct.RANDOM ? `${struct.name}.RANDOM` : ""
           })`
         : `(input) => ${symbol}<${struct.name}>(input)`;
-    const body: string = feat.opposite
+    const body: string = feat.opposite?.length
         ? [
               "{",
               `    ${feat.method}: ${call},`,
-              `    ${feat.opposite.name}: ${feat.opposite.method}<${struct.name}>(),`,
+              ...feat.opposite.map(
+                  (o) => `    ${o.name}: ${o.method}<${struct.name}>(),`,
+              ),
               "}",
           ].join("\n")
         : call;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "5.0.0-dev.20230819",
+  "version": "5.0.0-dev.20230820-2",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

packages/typescript-json/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-json",
-  "version": "5.0.0-dev.20230819",
+  "version": "5.0.0-dev.20230820-2",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -68,7 +68,7 @@
   },
   "homepage": "https://typia.io",
   "dependencies": {
-    "typia": "5.0.0-dev.20230819"
+    "typia": "5.0.0-dev.20230820-2"
   },
   "peerDependencies": {
     "typescript": ">= 4.7.4"

src/factories/ExpressionFactory.ts

@@ -1,6 +1,13 @@
 import ts from "typescript";
 
 export namespace ExpressionFactory {
+    export const bigint = (value: number) =>
+        ts.factory.createCallExpression(
+            ts.factory.createIdentifier("BigInt"),
+            undefined,
+            [ts.factory.createNumericLiteral(value)],
+        );
+
     export const isRequired = (input: ts.Expression): ts.Expression =>
         ts.factory.createStrictInequality(
             ts.factory.createIdentifier("undefined"),

src/factories/MetadataTagFactory.ts

@@ -93,8 +93,7 @@ export namespace MetadataTagFactory {
                     text === "uint32" ||
                     text === "int64" ||
                     text === "uint64" ||
-                    text === "float" ||
-                    text === "double")
+                    text === "float")
                 ? { kind: "type", value: text }
                 : null;
         },
@@ -315,6 +314,7 @@ const has_atomic =
             metadata.tuples.some((tuple) =>
                 tuple.elements.some(has_atomic(type)(visited)),
             ) ||
+            metadata.maps.some((map) => has_atomic(type)(visited)(map.value)) ||
             metadata.aliases.some((alias) =>
                 has_atomic(type)(visited)(alias.value),
             ) ||
@@ -337,6 +337,7 @@ const has_native =
             metadata.tuples.some((tuple) =>
                 tuple.elements.some(has_native(type)(visited)),
             ) ||
+            metadata.maps.some((map) => has_native(type)(visited)(map.value)) ||
             metadata.aliases.some((alias) =>
                 has_native(type)(visited)(alias.value),
             ) ||
@@ -355,6 +356,7 @@ const has_array =
             metadata.tuples.some((tuple) =>
                 tuple.elements.some(has_array(visited)),
             ) ||
+            metadata.maps.some((map) => has_array(visited)(map.value)) ||
             metadata.aliases.some((alias) => has_array(visited)(alias.value)) ||
             (metadata.resolved !== null &&
                 has_array(visited)(metadata.resolved.returns))

src/functional/$ProtobufReader.ts

@@ -170,8 +170,7 @@ export class $ProtobufReader {
         if (loaded < N80) return value;
 
         value |= (this.u8n() & N01) << BigInt(63);
-
-        return value;
+        return BigInt.asIntN(64, value);
     }
 
     private u8(): number {