Add range limit for numeric types.

From v5 updates, supports those atomic types, and their ranges are limited by their own specs. For reference, `int` and `uint` types, they are not being limited.

  - int32 / uint32
  - int64
  - float

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",
+                },
+            ],
         },
 
         //----

package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "5.0.0-dev.20230819",
+  "version": "5.0.0-dev.20230820",
   "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",
   "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"
   },
   "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

@@ -315,6 +315,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 +338,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 +357,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 {