typia 5.3.11 → 5.3.12-dev.20240118

package/src/module.ts

@@ -1,4 +1,4 @@
-import { Namespace } from "./functional/Namespace";
+import * as Namespace from "./functional/Namespace";
 
 import { AssertionGuard } from "./AssertionGuard";
 import { IRandomGenerator } from "./IRandomGenerator";
@@ -54,7 +54,7 @@ export * from "./SnakeCase";
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assert<T>(input: T): T;
+function assert<T>(input: T): T;
 
 /**
  * Asserts a value type.
@@ -77,15 +77,16 @@ export function assert<T>(input: T): T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assert<T>(input: unknown): T;
+function assert<T>(input: unknown): T;
 
 /**
  * @internal
  */
-export function assert(): never {
+function assert(): never {
   halt("assert");
 }
-Object.assign(assert, Namespace.assert("assert"));
+const assertPure = /** @__PURE__ */ Object.assign(assert, /** @__PURE__ */ Namespace.assert("assert"));
+export { assertPure as assert };
 
 /**
  * Assertion guard of a value type.
@@ -111,7 +112,7 @@ Object.assign(assert, Namespace.assert("assert"));
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertGuard<T>(input: T): asserts input is T;
+function assertGuard<T>(input: T): asserts input is T;
 
 /**
  * Assertion guard of a value type.
@@ -137,15 +138,16 @@ export function assertGuard<T>(input: T): asserts input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertGuard<T>(input: unknown): asserts input is T;
+function assertGuard<T>(input: unknown): asserts input is T;
 
 /**
  * @internal
  */
-export function assertGuard(): never {
+function assertGuard(): never {
   halt("assertGuard");
 }
-Object.assign(assertGuard, Namespace.assert("assertGuard"));
+const assertGuardPure = /** @__PURE__ */ Object.assign(assertGuard, /** @__PURE__ */ Namespace.assert("assertGuard"));
+export { assertGuardPure as assertGuard };
 
 /**
  * Tests a value type.
@@ -169,7 +171,7 @@ Object.assign(assertGuard, Namespace.assert("assertGuard"));
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function is<T>(input: T): input is T;
+function is<T>(input: T): input is T;
 
 /**
  * Tests a value type.
@@ -193,15 +195,16 @@ export function is<T>(input: T): input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function is<T>(input: unknown): input is T;
+function is<T>(input: unknown): input is T;
 
 /**
  * @internal
  */
-export function is(): never {
+function is(): never {
   halt("is");
 }
-Object.assign(is, Namespace.assert("is"));
+const isPure = /** @__PURE__ */ Object.assign(is, /** @__PURE__ */ Namespace.assert("is"));
+export { isPure as is };
 
 /**
  * Validates a value type.
@@ -226,7 +229,7 @@ Object.assign(is, Namespace.assert("is"));
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validate<T>(input: T): IValidation<T>;
+function validate<T>(input: T): IValidation<T>;
 
 /**
  * Validates a value type.
@@ -251,15 +254,16 @@ export function validate<T>(input: T): IValidation<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validate<T>(input: unknown): IValidation<T>;
+function validate<T>(input: unknown): IValidation<T>;
 
 /**
  * @internal
  */
-export function validate(): never {
+function validate(): never {
   halt("validate");
 }
-Object.assign(validate, Namespace.validate());
+const validatePure = /** @__PURE__ */ Object.assign(validate, /** @__PURE__ */ Namespace.validate());
+export { validatePure as validate };
 
 /* -----------------------------------------------------------
     STRICT VALIDATORS
@@ -287,7 +291,7 @@ Object.assign(validate, Namespace.validate());
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertEquals<T>(input: T): T;
+function assertEquals<T>(input: T): T;
 
 /**
  * Asserts equality between a value and its type.
@@ -312,15 +316,16 @@ export function assertEquals<T>(input: T): T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertEquals<T>(input: unknown): T;
+function assertEquals<T>(input: unknown): T;
 
 /**
  * @internal
  */
-export function assertEquals(): never {
+function assertEquals(): never {
   halt("assertEquals");
 }
-Object.assign(assertEquals, Namespace.assert("assertEquals"));
+const assertEqualsPure = /** @__PURE__ */ Object.assign(assertEquals, /** @__PURE__ */ Namespace.assert("assertEquals"));
+export { assertEqualsPure as assertEquals };
 
 /**
  * Assertion guard of a type with equality.
@@ -349,7 +354,7 @@ Object.assign(assertEquals, Namespace.assert("assertEquals"));
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertGuardEquals<T>(input: T): asserts input is T;
+function assertGuardEquals<T>(input: T): asserts input is T;
 
 /**
  * Assertion guard of a type with equality.
@@ -378,15 +383,16 @@ export function assertGuardEquals<T>(input: T): asserts input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertGuardEquals<T>(input: unknown): asserts input is T;
+function assertGuardEquals<T>(input: unknown): asserts input is T;
 
 /**
  * @internal
  */
-export function assertGuardEquals(): never {
+function assertGuardEquals(): never {
   halt("assertGuardEquals");
 }
-Object.assign(assertGuardEquals, Namespace.assert("assertGuardEquals"));
+const assertGuardEqualsPure = /** @__PURE__ */ Object.assign(assertGuardEquals, /** @__PURE__ */ Namespace.assert("assertGuardEquals"));
+export { assertGuardEqualsPure as assertGuardEquals };
 
 /**
  * Tests equality between a value and its type.
@@ -411,7 +417,7 @@ Object.assign(assertGuardEquals, Namespace.assert("assertGuardEquals"));
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function equals<T>(input: T): input is T;
+function equals<T>(input: T): input is T;
 
 /**
  * Tests equality between a value and its type.
@@ -436,15 +442,16 @@ export function equals<T>(input: T): input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function equals<T>(input: unknown): input is T;
+function equals<T>(input: unknown): input is T;
 
 /**
  * @internal
  */
-export function equals(): never {
+function equals(): never {
   halt("equals");
 }
-Object.assign(equals, Namespace.is());
+const equalsPure = /** @__PURE__ */ Object.assign(equals, /** @__PURE__ */ Namespace.is());
+export { equalsPure as equals };
 
 /**
  * Validates equality between a value and its type.
@@ -470,7 +477,7 @@ Object.assign(equals, Namespace.is());
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateEquals<T>(input: T): IValidation<T>;
+function validateEquals<T>(input: T): IValidation<T>;
 
 /**
  * Validates equality between a value and its type.
@@ -496,15 +503,16 @@ export function validateEquals<T>(input: T): IValidation<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function validateEquals<T>(input: unknown): IValidation<T>;
+function validateEquals<T>(input: unknown): IValidation<T>;
 
 /**
  * @internal
  */
-export function validateEquals(): never {
+function validateEquals(): never {
   halt("validateEquals");
 }
-Object.assign(validateEquals, Namespace.validate());
+const validateEqualsPure = /** @__PURE__ */ Object.assign(validateEquals, /** @__PURE__ */ Namespace.validate());
+export { validateEqualsPure as validateEquals };
 
 /* -----------------------------------------------------------
     RANDOM
@@ -527,7 +535,7 @@ Object.assign(validateEquals, Namespace.validate());
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function random(generator?: Partial<IRandomGenerator>): never;
+function random(generator?: Partial<IRandomGenerator>): never;
 
 /**
  * Generate random data.
@@ -545,15 +553,16 @@ export function random(generator?: Partial<IRandomGenerator>): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;
+function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;
 
 /**
  * @internal
  */
-export function random(): never {
+function random(): never {
   halt("random");
 }
-Object.assign(random, Namespace.random());
+const randomPure = /** @__PURE__ */ Object.assign(random, /** @__PURE__ */ Namespace.random());
+export { randomPure as random };
 
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
@@ -567,7 +576,7 @@ Object.assign(random, Namespace.random());
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssert(): never;
+function createAssert(): never;
 
 /**
  * Creates a reusable {@link assert} function.
@@ -577,15 +586,16 @@ export function createAssert(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssert<T>(): (input: unknown) => T;
+function createAssert<T>(): (input: unknown) => T;
 
 /**
  * @internal
  */
-export function createAssert<T>(): (input: unknown) => T {
+function createAssert<T>(): (input: unknown) => T {
   halt("createAssert");
 }
-Object.assign(createAssert, assert);
+const createAssertPure = /** @__PURE__ */ Object.assign(createAssert, assert);
+export { createAssertPure as createAssert };
 
 /**
  * Creates a reusable {@link assertGuard} function.
@@ -611,7 +621,7 @@ Object.assign(createAssert, assert);
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertGuard(): never;
+function createAssertGuard(): never;
 
 /**
  * Creates a reusable {@link assertGuard} function.
@@ -636,15 +646,16 @@ export function createAssertGuard(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T>;
+function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T>;
 
 /**
  * @internal
  */
-export function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T> {
+function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T> {
   halt("createAssertGuard");
 }
-Object.assign(createAssertGuard, assertGuard);
+const createAssertGuardPure = /** @__PURE__ */ Object.assign(createAssertGuard, assertGuard);
+export { createAssertGuardPure as createAssertGuard };
 
 /**
  * Creates a reusable {@link is} function.
@@ -655,7 +666,7 @@ Object.assign(createAssertGuard, assertGuard);
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIs(): never;
+function createIs(): never;
 
 /**
  * Creates a reusable {@link is} function.
@@ -665,15 +676,16 @@ export function createIs(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIs<T>(): (input: unknown) => input is T;
+function createIs<T>(): (input: unknown) => input is T;
 
 /**
  * @internal
  */
-export function createIs<T>(): (input: unknown) => input is T {
+function createIs<T>(): (input: unknown) => input is T {
   halt("createIs");
 }
-Object.assign(createIs, is);
+const createIsPure = /** @__PURE__ */ Object.assign(createIs, is);
+export { createIsPure as createIs };
 
 /**
  * Creates a reusable {@link validate} function.
@@ -684,7 +696,7 @@ Object.assign(createIs, is);
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidate(): never;
+function createValidate(): never;
 
 /**
  * Creates a reusable {@link validate} function.
@@ -694,15 +706,16 @@ export function createValidate(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidate<T>(): (input: unknown) => IValidation<T>;
+function createValidate<T>(): (input: unknown) => IValidation<T>;
 
 /**
  * @internal
  */
-export function createValidate(): (input: unknown) => IValidation {
+function createValidate(): (input: unknown) => IValidation {
   halt("createValidate");
 }
-Object.assign(createValidate, validate);
+const createValidatePure = /** @__PURE__ */ Object.assign(createValidate, validate);
+export { createValidatePure as createValidate };
 
 /**
  * Creates a reusable {@link assertEquals} function.
@@ -713,7 +726,7 @@ Object.assign(createValidate, validate);
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertEquals(): never;
+function createAssertEquals(): never;
 
 /**
  * Creates a reusable {@link assertEquals} function.
@@ -723,15 +736,16 @@ export function createAssertEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertEquals<T>(): (input: unknown) => T;
+function createAssertEquals<T>(): (input: unknown) => T;
 
 /**
  * @internal
  */
-export function createAssertEquals<T>(): (input: unknown) => T {
+function createAssertEquals<T>(): (input: unknown) => T {
   halt("createAssertEquals");
 }
-Object.assign(createAssertEquals, assertEquals);
+const createAssertEqualsPure = /** @__PURE__ */ Object.assign(createAssertEquals, assertEquals);
+export { createAssertEqualsPure as createAssertEquals };
 
 /**
  * Creates a reusable {@link assertGuardEquals} function.
@@ -757,7 +771,7 @@ Object.assign(createAssertEquals, assertEquals);
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertGuardEquals(): never;
+function createAssertGuardEquals(): never;
 
 /**
  * Creates a reusable {@link assertGuardEquals} function.
@@ -782,19 +796,20 @@ export function createAssertGuardEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertGuardEquals<T>(): (
+function createAssertGuardEquals<T>(): (
   input: unknown,
 ) => AssertionGuard<T>;
 
 /**
  * @internal
  */
-export function createAssertGuardEquals<T>(): (
+function createAssertGuardEquals<T>(): (
   input: unknown,
 ) => AssertionGuard<T> {
   halt("createAssertGuardEquals");
 }
-Object.assign(createAssertGuardEquals, assertGuardEquals);
+const createAssertGuardEqualsPure = /** @__PURE__ */ Object.assign(createAssertGuardEquals, assertGuardEquals);
+export { createAssertGuardEqualsPure as createAssertGuardEquals };
 
 /**
  * Creates a reusable {@link equals} function.
@@ -805,7 +820,7 @@ Object.assign(createAssertGuardEquals, assertGuardEquals);
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createEquals(): never;
+function createEquals(): never;
 
 /**
  * Creates a reusable {@link equals} function.
@@ -815,15 +830,16 @@ export function createEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createEquals<T>(): (input: unknown) => input is T;
+function createEquals<T>(): (input: unknown) => input is T;
 
 /**
  * @internal
  */
-export function createEquals<T>(): (input: unknown) => input is T {
+function createEquals<T>(): (input: unknown) => input is T {
   halt("createEquals");
 }
-Object.assign(createEquals, equals);
+const createEqualsPure = /** @__PURE__ */ Object.assign(createEquals, equals);
+export { createEqualsPure as createEquals };
 
 /**
  * Creates a reusable {@link validateEquals} function.
@@ -834,7 +850,7 @@ Object.assign(createEquals, equals);
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateEquals(): never;
+function createValidateEquals(): never;
 
 /**
  * Creates a reusable {@link validateEquals} function.
@@ -844,15 +860,16 @@ export function createValidateEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateEquals<T>(): (input: unknown) => IValidation<T>;
+function createValidateEquals<T>(): (input: unknown) => IValidation<T>;
 
 /**
  * @internal
  */
-export function createValidateEquals(): (input: unknown) => IValidation {
+function createValidateEquals(): (input: unknown) => IValidation {
   halt("createValidateEquals");
 }
-Object.assign(createValidateEquals, validateEquals);
+const createValidateEqualsPure = /** @__PURE__ */ Object.assign(createValidateEquals, validateEquals);
+export { createValidateEqualsPure as createValidateEquals };
 
 /**
  * Creates a reusable {@link random} function.
@@ -864,7 +881,7 @@ Object.assign(createValidateEquals, validateEquals);
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createRandom(generator?: Partial<IRandomGenerator>): never;
+function createRandom(generator?: Partial<IRandomGenerator>): never;
 
 /**
  * Creates a resuable {@link random} function.
@@ -875,17 +892,18 @@ export function createRandom(generator?: Partial<IRandomGenerator>): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createRandom<T>(
+function createRandom<T>(
   generator?: Partial<IRandomGenerator>,
 ): () => Resolved<T>;
 
 /**
  * @internal
  */
-export function createRandom(): never {
+function createRandom(): never {
   halt("createRandom");
 }
-Object.assign(createRandom, random);
+const createRandomPure = /** @__PURE__ */ Object.assign(createRandom, random);
+export { createRandomPure as createRandom };
 
 /**
  * @internal