typia 5.3.12-dev.20240118 → 6.0.0-dev.20240119

package/src/module.ts

@@ -1,5 +1,3 @@
-import * as Namespace from "./functional/Namespace";
-
 import { AssertionGuard } from "./AssertionGuard";
 import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
@@ -54,7 +52,7 @@ export * from "./SnakeCase";
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assert<T>(input: T): T;
+export function assert<T>(input: T): T;
 
 /**
  * Asserts a value type.
@@ -77,16 +75,14 @@ function assert<T>(input: T): T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assert<T>(input: unknown): T;
+export function assert<T>(input: unknown): T;
 
 /**
  * @internal
  */
-function assert(): never {
+export function assert(): never {
   halt("assert");
 }
-const assertPure = /** @__PURE__ */ Object.assign(assert, /** @__PURE__ */ Namespace.assert("assert"));
-export { assertPure as assert };
 
 /**
  * Assertion guard of a value type.
@@ -112,7 +108,7 @@ export { assertPure as assert };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertGuard<T>(input: T): asserts input is T;
+export function assertGuard<T>(input: T): asserts input is T;
 
 /**
  * Assertion guard of a value type.
@@ -138,16 +134,14 @@ function assertGuard<T>(input: T): asserts input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertGuard<T>(input: unknown): asserts input is T;
+export function assertGuard<T>(input: unknown): asserts input is T;
 
 /**
  * @internal
  */
-function assertGuard(): never {
+export function assertGuard(): never {
   halt("assertGuard");
 }
-const assertGuardPure = /** @__PURE__ */ Object.assign(assertGuard, /** @__PURE__ */ Namespace.assert("assertGuard"));
-export { assertGuardPure as assertGuard };
 
 /**
  * Tests a value type.
@@ -171,7 +165,7 @@ export { assertGuardPure as assertGuard };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function is<T>(input: T): input is T;
+export function is<T>(input: T): input is T;
 
 /**
  * Tests a value type.
@@ -195,16 +189,14 @@ function is<T>(input: T): input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function is<T>(input: unknown): input is T;
+export function is<T>(input: unknown): input is T;
 
 /**
  * @internal
  */
-function is(): never {
+export function is(): never {
   halt("is");
 }
-const isPure = /** @__PURE__ */ Object.assign(is, /** @__PURE__ */ Namespace.assert("is"));
-export { isPure as is };
 
 /**
  * Validates a value type.
@@ -229,7 +221,7 @@ export { isPure as is };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validate<T>(input: T): IValidation<T>;
+export function validate<T>(input: T): IValidation<T>;
 
 /**
  * Validates a value type.
@@ -254,16 +246,14 @@ function validate<T>(input: T): IValidation<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validate<T>(input: unknown): IValidation<T>;
+export function validate<T>(input: unknown): IValidation<T>;
 
 /**
  * @internal
  */
-function validate(): never {
+export function validate(): never {
   halt("validate");
 }
-const validatePure = /** @__PURE__ */ Object.assign(validate, /** @__PURE__ */ Namespace.validate());
-export { validatePure as validate };
 
 /* -----------------------------------------------------------
     STRICT VALIDATORS
@@ -291,7 +281,7 @@ export { validatePure as validate };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertEquals<T>(input: T): T;
+export function assertEquals<T>(input: T): T;
 
 /**
  * Asserts equality between a value and its type.
@@ -316,16 +306,14 @@ function assertEquals<T>(input: T): T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertEquals<T>(input: unknown): T;
+export function assertEquals<T>(input: unknown): T;
 
 /**
  * @internal
  */
-function assertEquals(): never {
+export function assertEquals(): never {
   halt("assertEquals");
 }
-const assertEqualsPure = /** @__PURE__ */ Object.assign(assertEquals, /** @__PURE__ */ Namespace.assert("assertEquals"));
-export { assertEqualsPure as assertEquals };
 
 /**
  * Assertion guard of a type with equality.
@@ -354,7 +342,7 @@ export { assertEqualsPure as assertEquals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertGuardEquals<T>(input: T): asserts input is T;
+export function assertGuardEquals<T>(input: T): asserts input is T;
 
 /**
  * Assertion guard of a type with equality.
@@ -383,16 +371,14 @@ function assertGuardEquals<T>(input: T): asserts input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertGuardEquals<T>(input: unknown): asserts input is T;
+export function assertGuardEquals<T>(input: unknown): asserts input is T;
 
 /**
  * @internal
  */
-function assertGuardEquals(): never {
+export function assertGuardEquals(): never {
   halt("assertGuardEquals");
 }
-const assertGuardEqualsPure = /** @__PURE__ */ Object.assign(assertGuardEquals, /** @__PURE__ */ Namespace.assert("assertGuardEquals"));
-export { assertGuardEqualsPure as assertGuardEquals };
 
 /**
  * Tests equality between a value and its type.
@@ -417,7 +403,7 @@ export { assertGuardEqualsPure as assertGuardEquals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function equals<T>(input: T): input is T;
+export function equals<T>(input: T): input is T;
 
 /**
  * Tests equality between a value and its type.
@@ -442,16 +428,14 @@ function equals<T>(input: T): input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function equals<T>(input: unknown): input is T;
+export function equals<T>(input: unknown): input is T;
 
 /**
  * @internal
  */
-function equals(): never {
+export function equals(): never {
   halt("equals");
 }
-const equalsPure = /** @__PURE__ */ Object.assign(equals, /** @__PURE__ */ Namespace.is());
-export { equalsPure as equals };
 
 /**
  * Validates equality between a value and its type.
@@ -477,7 +461,7 @@ export { equalsPure as equals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateEquals<T>(input: T): IValidation<T>;
+export function validateEquals<T>(input: T): IValidation<T>;
 
 /**
  * Validates equality between a value and its type.
@@ -503,16 +487,14 @@ function validateEquals<T>(input: T): IValidation<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateEquals<T>(input: unknown): IValidation<T>;
+export function validateEquals<T>(input: unknown): IValidation<T>;
 
 /**
  * @internal
  */
-function validateEquals(): never {
+export function validateEquals(): never {
   halt("validateEquals");
 }
-const validateEqualsPure = /** @__PURE__ */ Object.assign(validateEquals, /** @__PURE__ */ Namespace.validate());
-export { validateEqualsPure as validateEquals };
 
 /* -----------------------------------------------------------
     RANDOM
@@ -535,7 +517,7 @@ export { validateEqualsPure as validateEquals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function random(generator?: Partial<IRandomGenerator>): never;
+export function random(generator?: Partial<IRandomGenerator>): never;
 
 /**
  * Generate random data.
@@ -553,16 +535,14 @@ function random(generator?: Partial<IRandomGenerator>): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;
+export function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;
 
 /**
  * @internal
  */
-function random(): never {
+export function random(): never {
   halt("random");
 }
-const randomPure = /** @__PURE__ */ Object.assign(random, /** @__PURE__ */ Namespace.random());
-export { randomPure as random };
 
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
@@ -576,7 +556,7 @@ export { randomPure as random };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssert(): never;
+export function createAssert(): never;
 
 /**
  * Creates a reusable {@link assert} function.
@@ -586,16 +566,14 @@ function createAssert(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssert<T>(): (input: unknown) => T;
+export function createAssert<T>(): (input: unknown) => T;
 
 /**
  * @internal
  */
-function createAssert<T>(): (input: unknown) => T {
+export function createAssert<T>(): (input: unknown) => T {
   halt("createAssert");
 }
-const createAssertPure = /** @__PURE__ */ Object.assign(createAssert, assert);
-export { createAssertPure as createAssert };
 
 /**
  * Creates a reusable {@link assertGuard} function.
@@ -621,7 +599,7 @@ export { createAssertPure as createAssert };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertGuard(): never;
+export function createAssertGuard(): never;
 
 /**
  * Creates a reusable {@link assertGuard} function.
@@ -646,16 +624,14 @@ function createAssertGuard(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T>;
+export function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T>;
 
 /**
  * @internal
  */
-function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T> {
+export function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T> {
   halt("createAssertGuard");
 }
-const createAssertGuardPure = /** @__PURE__ */ Object.assign(createAssertGuard, assertGuard);
-export { createAssertGuardPure as createAssertGuard };
 
 /**
  * Creates a reusable {@link is} function.
@@ -666,7 +642,7 @@ export { createAssertGuardPure as createAssertGuard };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIs(): never;
+export function createIs(): never;
 
 /**
  * Creates a reusable {@link is} function.
@@ -676,16 +652,14 @@ function createIs(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIs<T>(): (input: unknown) => input is T;
+export function createIs<T>(): (input: unknown) => input is T;
 
 /**
  * @internal
  */
-function createIs<T>(): (input: unknown) => input is T {
+export function createIs<T>(): (input: unknown) => input is T {
   halt("createIs");
 }
-const createIsPure = /** @__PURE__ */ Object.assign(createIs, is);
-export { createIsPure as createIs };
 
 /**
  * Creates a reusable {@link validate} function.
@@ -696,7 +670,7 @@ export { createIsPure as createIs };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidate(): never;
+export function createValidate(): never;
 
 /**
  * Creates a reusable {@link validate} function.
@@ -706,16 +680,14 @@ function createValidate(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidate<T>(): (input: unknown) => IValidation<T>;
+export function createValidate<T>(): (input: unknown) => IValidation<T>;
 
 /**
  * @internal
  */
-function createValidate(): (input: unknown) => IValidation {
+export function createValidate(): (input: unknown) => IValidation {
   halt("createValidate");
 }
-const createValidatePure = /** @__PURE__ */ Object.assign(createValidate, validate);
-export { createValidatePure as createValidate };
 
 /**
  * Creates a reusable {@link assertEquals} function.
@@ -726,7 +698,7 @@ export { createValidatePure as createValidate };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertEquals(): never;
+export function createAssertEquals(): never;
 
 /**
  * Creates a reusable {@link assertEquals} function.
@@ -736,16 +708,14 @@ function createAssertEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertEquals<T>(): (input: unknown) => T;
+export function createAssertEquals<T>(): (input: unknown) => T;
 
 /**
  * @internal
  */
-function createAssertEquals<T>(): (input: unknown) => T {
+export function createAssertEquals<T>(): (input: unknown) => T {
   halt("createAssertEquals");
 }
-const createAssertEqualsPure = /** @__PURE__ */ Object.assign(createAssertEquals, assertEquals);
-export { createAssertEqualsPure as createAssertEquals };
 
 /**
  * Creates a reusable {@link assertGuardEquals} function.
@@ -771,7 +741,7 @@ export { createAssertEqualsPure as createAssertEquals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertGuardEquals(): never;
+export function createAssertGuardEquals(): never;
 
 /**
  * Creates a reusable {@link assertGuardEquals} function.
@@ -796,20 +766,18 @@ function createAssertGuardEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertGuardEquals<T>(): (
+export function createAssertGuardEquals<T>(): (
   input: unknown,
 ) => AssertionGuard<T>;
 
 /**
  * @internal
  */
-function createAssertGuardEquals<T>(): (
+export function createAssertGuardEquals<T>(): (
   input: unknown,
 ) => AssertionGuard<T> {
   halt("createAssertGuardEquals");
 }
-const createAssertGuardEqualsPure = /** @__PURE__ */ Object.assign(createAssertGuardEquals, assertGuardEquals);
-export { createAssertGuardEqualsPure as createAssertGuardEquals };
 
 /**
  * Creates a reusable {@link equals} function.
@@ -820,7 +788,7 @@ export { createAssertGuardEqualsPure as createAssertGuardEquals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createEquals(): never;
+export function createEquals(): never;
 
 /**
  * Creates a reusable {@link equals} function.
@@ -830,16 +798,14 @@ function createEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createEquals<T>(): (input: unknown) => input is T;
+export function createEquals<T>(): (input: unknown) => input is T;
 
 /**
  * @internal
  */
-function createEquals<T>(): (input: unknown) => input is T {
+export function createEquals<T>(): (input: unknown) => input is T {
   halt("createEquals");
 }
-const createEqualsPure = /** @__PURE__ */ Object.assign(createEquals, equals);
-export { createEqualsPure as createEquals };
 
 /**
  * Creates a reusable {@link validateEquals} function.
@@ -850,7 +816,7 @@ export { createEqualsPure as createEquals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateEquals(): never;
+export function createValidateEquals(): never;
 
 /**
  * Creates a reusable {@link validateEquals} function.
@@ -860,16 +826,14 @@ function createValidateEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateEquals<T>(): (input: unknown) => IValidation<T>;
+export function createValidateEquals<T>(): (input: unknown) => IValidation<T>;
 
 /**
  * @internal
  */
-function createValidateEquals(): (input: unknown) => IValidation {
+export function createValidateEquals(): (input: unknown) => IValidation {
   halt("createValidateEquals");
 }
-const createValidateEqualsPure = /** @__PURE__ */ Object.assign(createValidateEquals, validateEquals);
-export { createValidateEqualsPure as createValidateEquals };
 
 /**
  * Creates a reusable {@link random} function.
@@ -881,7 +845,7 @@ export { createValidateEqualsPure as createValidateEquals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createRandom(generator?: Partial<IRandomGenerator>): never;
+export function createRandom(generator?: Partial<IRandomGenerator>): never;
 
 /**
  * Creates a resuable {@link random} function.
@@ -892,18 +856,16 @@ function createRandom(generator?: Partial<IRandomGenerator>): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createRandom<T>(
+export function createRandom<T>(
   generator?: Partial<IRandomGenerator>,
 ): () => Resolved<T>;
 
 /**
  * @internal
  */
-function createRandom(): never {
+export function createRandom(): never {
   halt("createRandom");
 }
-const createRandomPure = /** @__PURE__ */ Object.assign(createRandom, random);
-export { createRandomPure as createRandom };
 
 /**
  * @internal