typia 6.0.0-dev.20240122 → 6.0.0

package/src/module.ts

@@ -1,8 +1,12 @@
+import * as Namespace from "./functional/Namespace";
+
 import { AssertionGuard } from "./AssertionGuard";
 import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
 import { Resolved } from "./Resolved";
+import { TypeGuardError } from "./TypeGuardError";
 
+export * as functional from "./functional";
 export * as http from "./http";
 export * as json from "./json";
 export * as misc from "./misc";
@@ -13,8 +17,6 @@ export * as tags from "./tags";
 
 export * from "./schemas/metadata/IJsDocTagInfo";
 export * from "./schemas/json/IJsonApplication";
-export * from "./schemas/json/IJsonComponents";
-export * from "./schemas/json/IJsonSchema";
 export * from "./AssertionGuard";
 export * from "./IRandomGenerator";
 export * from "./IValidation";
@@ -47,12 +49,16 @@ export * from "./SnakeCase";
  *
  * @template T Type of the input value
  * @param input A value to be asserted
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Parametric input value
  * @throws A {@link TypeGuardError} instance with detailed reason
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assert<T>(input: T): T;
+function assert<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * Asserts a value type.
@@ -70,19 +76,28 @@ export function assert<T>(input: T): T;
  *
  * @template T Type of the input value
  * @param input A value to be asserted
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Parametric input value casted as `T`
  * @throws A {@link TypeGuardError} instance with detailed reason
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assert<T>(input: unknown): T;
+function assert<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * @internal
  */
-export function assert(): never {
+function assert(): never {
   halt("assert");
 }
+const assertPure = /** @__PURE__ */ Object.assign<typeof assert, {}>(
+  assert,
+  /** @__PURE__ */ Namespace.assert("assert"),
+);
+export { assertPure as assert };
 
 /**
  * Assertion guard of a value type.
@@ -104,11 +119,15 @@ export function assert(): never {
  *
  * @template T Type of the input value
  * @param input A value to be asserted
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @throws A {@link TypeGuardError} instance with detailed reason
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertGuard<T>(input: T): asserts input is T;
+function assertGuard<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): asserts input is T;
 
 /**
  * Assertion guard of a value type.
@@ -130,18 +149,27 @@ export function assertGuard<T>(input: T): asserts input is T;
  *
  * @template T Type of the input value
  * @param input A value to be asserted
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @throws A {@link TypeGuardError} instance with detailed reason
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertGuard<T>(input: unknown): asserts input is T;
+function assertGuard<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): asserts input is T;
 
 /**
  * @internal
  */
-export function assertGuard(): never {
+function assertGuard(): never {
   halt("assertGuard");
 }
+const assertGuardPure = /** @__PURE__ */ Object.assign<typeof assertGuard, {}>(
+  assertGuard,
+  /** @__PURE__ */ Namespace.assert("assertGuard"),
+);
+export { assertGuardPure as assertGuard };
 
 /**
  * Tests a value type.
@@ -161,11 +189,12 @@ export function assertGuard(): never {
  *
  * @template T Type of the input value
  * @param input A value to be tested
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Whether the parametric value is following the type `T` or not
  *
  * @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.
@@ -189,14 +218,19 @@ 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");
 }
+const isPure = /** @__PURE__ */ Object.assign<typeof is, {}>(
+  is,
+  /** @__PURE__ */ Namespace.assert("is"),
+);
+export { isPure as is };
 
 /**
  * Validates a value type.
@@ -221,7 +255,7 @@ export function is(): never {
  *
  * @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.
@@ -246,14 +280,19 @@ 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");
 }
+const validatePure = /** @__PURE__ */ Object.assign<typeof validate, {}>(
+  validate,
+  /** @__PURE__ */ Namespace.validate(),
+);
+export { validatePure as validate };
 
 /* -----------------------------------------------------------
     STRICT VALIDATORS
@@ -276,12 +315,16 @@ export function validate(): never {
  *
  * @template T Type of the input value
  * @param input A value to be asserted
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Parametric input value
  * @throws A {@link TypeGuardError} instance with detailed reason
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertEquals<T>(input: T): T;
+function assertEquals<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * Asserts equality between a value and its type.
@@ -301,19 +344,28 @@ export function assertEquals<T>(input: T): T;
  *
  * @template T Type of the input value
  * @param input A value to be asserted
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Parametric input value casted as `T`
  * @throws A {@link TypeGuardError} instance with detailed reason
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertEquals<T>(input: unknown): T;
+function assertEquals<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * @internal
  */
-export function assertEquals(): never {
+function assertEquals(): never {
   halt("assertEquals");
 }
+const assertEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof assertEquals,
+  {}
+>(assertEquals, /** @__PURE__ */ Namespace.assert("assertEquals"));
+export { assertEqualsPure as assertEquals };
 
 /**
  * Assertion guard of a type with equality.
@@ -337,12 +389,16 @@ export function assertEquals(): never {
  *
  * @template T Type of the input value
  * @param input A value to be asserted
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Parametric input value casted as `T`
  * @throws A {@link TypeGuardError} instance with detailed reason
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertGuardEquals<T>(input: T): asserts input is T;
+function assertGuardEquals<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): asserts input is T;
 
 /**
  * Assertion guard of a type with equality.
@@ -366,19 +422,28 @@ export function assertGuardEquals<T>(input: T): asserts input is T;
  *
  * @template T Type of the input value
  * @param input A value to be asserted
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Parametric input value casted as `T`
  * @throws A {@link TypeGuardError} instance with detailed reason
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertGuardEquals<T>(input: unknown): asserts input is T;
+function assertGuardEquals<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): asserts input is T;
 
 /**
  * @internal
  */
-export function assertGuardEquals(): never {
+function assertGuardEquals(): never {
   halt("assertGuardEquals");
 }
+const assertGuardEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof assertGuardEquals,
+  {}
+>(assertGuardEquals, /** @__PURE__ */ Namespace.assert("assertGuardEquals"));
+export { assertGuardEqualsPure as assertGuardEquals };
 
 /**
  * Tests equality between a value and its type.
@@ -403,7 +468,7 @@ export function assertGuardEquals(): never {
  *
  * @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.
@@ -428,14 +493,19 @@ 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");
 }
+const equalsPure = /** @__PURE__ */ Object.assign<typeof equals, {}>(
+  equals,
+  /** @__PURE__ */ Namespace.is(),
+);
+export { equalsPure as equals };
 
 /**
  * Validates equality between a value and its type.
@@ -461,7 +531,7 @@ export function equals(): never {
  *
  * @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.
@@ -487,14 +557,19 @@ 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");
 }
+const validateEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof validateEquals,
+  {}
+>(validateEquals, /** @__PURE__ */ Namespace.validate());
+export { validateEqualsPure as validateEquals };
 
 /* -----------------------------------------------------------
     RANDOM
@@ -517,7 +592,7 @@ export function validateEquals(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function random(generator?: Partial<IRandomGenerator>): never;
+function random(generator?: Partial<IRandomGenerator>): never;
 
 /**
  * Generate random data.
@@ -535,14 +610,19 @@ 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");
 }
+const randomPure = /** @__PURE__ */ Object.assign<typeof random, {}>(
+  random,
+  /** @__PURE__ */ Namespace.random(),
+);
+export { randomPure as random };
 
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
@@ -551,29 +631,40 @@ export function random(): never {
  * Creates a reusable {@link assert} function.
  *
  * @danger You must configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssert(): never;
+function createAssert(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assert} function.
  *
  * @template T Type of the input value
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns A reusable `assert` function
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssert<T>(): (input: unknown) => T;
+function createAssert<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => T;
 
 /**
  * @internal
  */
-export function createAssert<T>(): (input: unknown) => T {
+function createAssert<T>(): (input: unknown) => T {
   halt("createAssert");
 }
+const createAssertPure = /** @__PURE__ */ Object.assign<
+  typeof createAssert,
+  {}
+>(createAssert, assertPure);
+export { createAssertPure as createAssert };
 
 /**
  * Creates a reusable {@link assertGuard} function.
@@ -594,12 +685,15 @@ export function createAssert<T>(): (input: unknown) => T {
  * > *explicit type annotation.*
  *
  * @danger You must configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertGuard(): never;
+function createAssertGuard(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertGuard} function.
@@ -620,18 +714,26 @@ export function createAssertGuard(): never;
  * > *explicit type annotation.*
  *
  * @returns Nothing until you configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T>;
+function createAssertGuard<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => AssertionGuard<T>;
 
 /**
  * @internal
  */
-export function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T> {
+function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T> {
   halt("createAssertGuard");
 }
+const createAssertGuardPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertGuard,
+  {}
+>(createAssertGuard, assertGuardPure);
+export { createAssertGuardPure as createAssertGuard };
 
 /**
  * Creates a reusable {@link is} function.
@@ -642,7 +744,7 @@ export function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T> {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIs(): never;
+function createIs(): never;
 
 /**
  * Creates a reusable {@link is} function.
@@ -652,14 +754,19 @@ 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");
 }
+const createIsPure = /** @__PURE__ */ Object.assign<typeof createIs, {}>(
+  createIs,
+  isPure,
+);
+export { createIsPure as createIs };
 
 /**
  * Creates a reusable {@link validate} function.
@@ -670,7 +777,7 @@ export function createIs<T>(): (input: unknown) => input is T {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidate(): never;
+function createValidate(): never;
 
 /**
  * Creates a reusable {@link validate} function.
@@ -680,42 +787,58 @@ 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");
 }
+const createValidatePure = /** @__PURE__ */ Object.assign<
+  typeof createValidate,
+  {}
+>(createValidate, validatePure);
+export { createValidatePure as createValidate };
 
 /**
  * Creates a reusable {@link assertEquals} function.
  *
  * @danger You must configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertEquals(): never;
+function createAssertEquals(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertEquals} function.
  *
  * @template T Type of the input value
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns A reusable `assertEquals` function
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertEquals<T>(): (input: unknown) => T;
+function createAssertEquals<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => T;
 
 /**
  * @internal
  */
-export function createAssertEquals<T>(): (input: unknown) => T {
+function createAssertEquals<T>(): (input: unknown) => T {
   halt("createAssertEquals");
 }
+const createAssertEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertEquals,
+  {}
+>(createAssertEquals, assertEqualsPure);
+export { createAssertEqualsPure as createAssertEquals };
 
 /**
  * Creates a reusable {@link assertGuardEquals} function.
@@ -736,12 +859,15 @@ export function createAssertEquals<T>(): (input: unknown) => T {
  * > *explicit type annotation.*
  *
  * @danger You must configure the generic argument `T`
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertGuardEquals(): never;
+function createAssertGuardEquals(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertGuardEquals} function.
@@ -761,23 +887,27 @@ export function createAssertGuardEquals(): never;
  * > *Assertions require every name in the call target to be declared with an*
  * > *explicit type annotation.*
  *
+ * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertGuardEquals<T>(): (
-  input: unknown,
-) => AssertionGuard<T>;
+function createAssertGuardEquals<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => AssertionGuard<T>;
 
 /**
  * @internal
  */
-export function createAssertGuardEquals<T>(): (
-  input: unknown,
-) => AssertionGuard<T> {
+function createAssertGuardEquals<T>(): (input: unknown) => AssertionGuard<T> {
   halt("createAssertGuardEquals");
 }
+const createAssertGuardEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertGuardEquals,
+  {}
+>(createAssertGuardEquals, assertGuardEqualsPure);
+export { createAssertGuardEqualsPure as createAssertGuardEquals };
 
 /**
  * Creates a reusable {@link equals} function.
@@ -788,7 +918,7 @@ export function createAssertGuardEquals<T>(): (
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createEquals(): never;
+function createEquals(): never;
 
 /**
  * Creates a reusable {@link equals} function.
@@ -798,14 +928,19 @@ 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");
 }
+const createEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof createEquals,
+  {}
+>(createEquals, equalsPure);
+export { createEqualsPure as createEquals };
 
 /**
  * Creates a reusable {@link validateEquals} function.
@@ -816,7 +951,7 @@ export function createEquals<T>(): (input: unknown) => input is T {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateEquals(): never;
+function createValidateEquals(): never;
 
 /**
  * Creates a reusable {@link validateEquals} function.
@@ -826,14 +961,19 @@ 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");
 }
+const createValidateEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof createValidateEquals,
+  {}
+>(createValidateEquals, validateEqualsPure);
+export { createValidateEqualsPure as createValidateEquals };
 
 /**
  * Creates a reusable {@link random} function.
@@ -845,7 +985,7 @@ export function createValidateEquals(): (input: unknown) => IValidation {
  *
  * @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.
@@ -856,16 +996,21 @@ 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");
 }
+const createRandomPure = /** @__PURE__ */ Object.assign<
+  typeof createRandom,
+  {}
+>(createRandom, randomPure);
+export { createRandomPure as createRandom };
 
 /**
  * @internal