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

package/src/notations.ts

@@ -1,5 +1,3 @@
-import * as Namespace from "./functional/Namespace";
-
 import { CamelCase } from "./CamelCase";
 import { IValidation } from "./IValidation";
 import { PascalCase } from "./PascalCase";
@@ -33,16 +31,14 @@ import { SnakeCase } from "./SnakeCase";
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function camel<T>(input: T): CamelCase<T>;
+export function camel<T>(input: T): CamelCase<T>;
 
 /**
  * @internal
  */
-function camel(): never {
+export function camel(): never {
   return halt("camel");
 }
-const camelPure = /** @__PURE__ */ Object.assign(camel, /** @__PURE__ */ Namespace.notations.camel("camel"));
-export { camelPure as camel };
 
 /**
  * Converts to camel case with type assertion.
@@ -56,7 +52,7 @@ export { camelPure as camel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertCamel<T>(input: T): CamelCase<T>;
+export function assertCamel<T>(input: T): CamelCase<T>;
 
 /**
  * Converts to camel case with type assertion.
@@ -70,20 +66,14 @@ function assertCamel<T>(input: T): CamelCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertCamel<T>(input: unknown): CamelCase<T>;
+export function assertCamel<T>(input: unknown): CamelCase<T>;
 
 /**
  * @internal
  */
-function assertCamel(): never {
+export function assertCamel(): never {
   return halt("assertCamel");
 }
-const assertCamelPure = /** @__PURE__ */ Object.assign(
-  assertCamel,
-  /** @__PURE__ */ Namespace.notations.camel("assertCamel"),
-  /** @__PURE__ */ Namespace.assert("notations.assertCamel")
-);
-export { assertCamelPure as assertCamel };
 
 /**
  * Converts to camel case with type checking.
@@ -97,7 +87,7 @@ export { assertCamelPure as assertCamel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isCamel<T>(input: T): CamelCase<T> | null;
+export function isCamel<T>(input: T): CamelCase<T> | null;
 
 /**
  * Converts to camel case with type checking.
@@ -111,20 +101,14 @@ function isCamel<T>(input: T): CamelCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isCamel<T>(input: unknown): CamelCase<T> | null;
+export function isCamel<T>(input: unknown): CamelCase<T> | null;
 
 /**
  * @internal
  */
-function isCamel(): never {
+export function isCamel(): never {
   return halt("isCamel");
 }
-const isCamelPure = /** @__PURE__ */ Object.assign(
-  isCamel,
-  /** @__PURE__ */ Namespace.notations.camel("isCamel"),
-  /** @__PURE__ */ Namespace.is()
-);
-export { isCamelPure as isCamel };
 
 /**
  * Converts to camel case with type validation.
@@ -140,7 +124,7 @@ export { isCamelPure as isCamel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
+export function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
 
 /**
  * Converts to camel case with type validation.
@@ -156,20 +140,14 @@ function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;
+export function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;
 
 /**
  * @internal
  */
-function validateCamel(): never {
+export function validateCamel(): never {
   return halt("validateCamel");
 }
-const validateCamelPure = /** @__PURE__ */ Object.assign(
-  validateCamel,
-  /** @__PURE__ */ Namespace.notations.camel("validateCamel"),
-  /** @__PURE__ */ Namespace.validate()
-);
-export { validateCamelPure as validateCamel };
 
 /* -----------------------------------------------------------
     PASCAL CASE
@@ -193,19 +171,14 @@ export { validateCamelPure as validateCamel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function pascal<T>(input: T): PascalCase<T>;
+export function pascal<T>(input: T): PascalCase<T>;
 
 /**
  * @internal
  */
-function pascal(): never {
+export function pascal(): never {
   return halt("pascal");
 }
-const pascalPure = /** @__PURE__ */ Object.assign(
-  pascal,
-  /** @__PURE__ */ Namespace.notations.pascal("pascal")
-);
-export { pascalPure as pascal };
 
 /**
  * Converts to pascal case with type assertion.
@@ -219,7 +192,7 @@ export { pascalPure as pascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertPascal<T>(input: T): PascalCase<T>;
+export function assertPascal<T>(input: T): PascalCase<T>;
 
 /**
  * Converts to pascal case with type assertion.
@@ -233,20 +206,14 @@ function assertPascal<T>(input: T): PascalCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertPascal<T>(input: unknown): PascalCase<T>;
+export function assertPascal<T>(input: unknown): PascalCase<T>;
 
 /**
  * @internal
  */
-function assertPascal(): never {
+export function assertPascal(): never {
   return halt("assertPascal");
 }
-const assertPascalPure = /** @__PURE__ */ Object.assign(
-  assertPascal,
-  /** @__PURE__ */ Namespace.notations.pascal("assertPascal"),
-  /** @__PURE__ */ Namespace.assert("notations.assertPascal")
-);
-export { assertPascalPure as assertPascal };
 
 /**
  * Converts to pascal case with type checking.
@@ -260,7 +227,7 @@ export { assertPascalPure as assertPascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isPascal<T>(input: T): PascalCase<T> | null;
+export function isPascal<T>(input: T): PascalCase<T> | null;
 
 /**
  * Converts to pascal case with type checking.
@@ -274,20 +241,14 @@ function isPascal<T>(input: T): PascalCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isPascal<T>(input: unknown): PascalCase<T> | null;
+export function isPascal<T>(input: unknown): PascalCase<T> | null;
 
 /**
  * @internal
  */
-function isPascal(): never {
+export function isPascal(): never {
   return halt("isPascal");
 }
-const isPascalPure = /** @__PURE__ */ Object.assign(
-  isPascal,
-  /** @__PURE__ */ Namespace.notations.pascal("isPascal"),
-  /** @__PURE__ */ Namespace.is()
-);
-export { isPascalPure as isPascal };
 
 /**
  * Converts to pascal case with type validation.
@@ -303,7 +264,7 @@ export { isPascalPure as isPascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
+export function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
 
 /**
  * Converts to pascal case with type validation.
@@ -319,20 +280,14 @@ function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;
+export function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;
 
 /**
  * @internal
  */
-function validatePascal(): never {
+export function validatePascal(): never {
   return halt("validatePascal");
 }
-const validatePascalPure = /** @__PURE__ */Object.assign(
-  validatePascal,
-  /** @__PURE__ */ Namespace.notations.pascal("validatePascal"),
-  /** @__PURE__ */ Namespace.validate()
-);
-export { validatePascalPure as validatePascal };
 
 /* -----------------------------------------------------------
     SNAKE CASE
@@ -356,16 +311,14 @@ export { validatePascalPure as validatePascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function snake<T>(input: T): SnakeCase<T>;
+export function snake<T>(input: T): SnakeCase<T>;
 
 /**
  * @internal
  */
-function snake(): never {
+export function snake(): never {
   return halt("snake");
 }
-const snakePure = /** @__PURE__ */ Object.assign(snake, /** @__PURE__ */ Namespace.notations.snake("snake"));
-export { snakePure as snake };
 
 /**
  * Converts to snake case with type assertion.
@@ -379,7 +332,7 @@ export { snakePure as snake };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertSnake<T>(input: T): SnakeCase<T>;
+export function assertSnake<T>(input: T): SnakeCase<T>;
 
 /**
  * Converts to snake case with type assertion.
@@ -393,20 +346,14 @@ function assertSnake<T>(input: T): SnakeCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertSnake<T>(input: unknown): SnakeCase<T>;
+export function assertSnake<T>(input: unknown): SnakeCase<T>;
 
 /**
  * @internal
  */
-function assertSnake(): never {
+export function assertSnake(): never {
   return halt("assertSnake");
 }
-const assertSnakePure = /** @__PURE__ */ Object.assign(
-  assertSnake,
-  /** @__PURE__ */ Namespace.notations.snake("assertSnake"),
-  /** @__PURE__ */ Namespace.assert("notations.assertSnake"),
-);
-export { assertSnakePure as assertSnake };
 
 /**
  * Converts to snake case with type checking.
@@ -420,7 +367,7 @@ export { assertSnakePure as assertSnake };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isSnake<T>(input: T): SnakeCase<T> | null;
+export function isSnake<T>(input: T): SnakeCase<T> | null;
 
 /**
  * Converts to snake case with type checking.
@@ -434,20 +381,14 @@ function isSnake<T>(input: T): SnakeCase<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function isSnake<T>(input: unknown): SnakeCase<T> | null;
+export function isSnake<T>(input: unknown): SnakeCase<T> | null;
 
 /**
  * @internal
  */
-function isSnake(): never {
+export function isSnake(): never {
   return halt("isSnake");
 }
-const isSnakePure = /** @__PURE__ */ Object.assign(
-  isSnake,
-  /** @__PURE__ */ Namespace.notations.snake("isSnake"),
-  /** @__PURE__ */ Namespace.is()
-);
-export { isSnakePure as isSnake };
 
 /**
  * Converts to snake case with type validation.
@@ -463,7 +404,7 @@ export { isSnakePure as isSnake };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
+export function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
 
 /**
  * Converts to snake case with type validation.
@@ -479,20 +420,15 @@ function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;
+export function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;
 
 /**
  * @internal
  */
-function validateSnake(): never {
+export function validateSnake(): never {
   return halt("validateSnake");
 }
-const validateSnakePure = /** @__PURE__ */ Object.assign(
-  validateSnake,
-  /** @__PURE__ */ Namespace.notations.snake("validateSnake"),
-  /** @__PURE__ */ Namespace.validate()
-);
-export { validateSnakePure as validateSnake };
+
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
 ----------------------------------------------------------- */
@@ -505,7 +441,7 @@ export { validateSnakePure as validateSnake };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createCamel(): never;
+export function createCamel(): never;
 
 /**
  * Creates a reusable {@link camel} function.
@@ -515,19 +451,14 @@ function createCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createCamel<T>(): (input: T) => CamelCase<T>;
+export function createCamel<T>(): (input: T) => CamelCase<T>;
 
 /**
  * @internal
  */
-function createCamel(): never {
+export function createCamel(): never {
   halt("createCamel");
 }
-const createCamelPure = /** @__PURE__ */ Object.assign(
-  createCamel,
-  /** @__PURE__ */ Namespace.notations.camel("createCamel")
-);
-export { createCamelPure as createCamel };
 
 /**
  * Creates a reusable {@link assertCamel} function.
@@ -538,7 +469,7 @@ export { createCamelPure as createCamel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertCamel(): never;
+export function createAssertCamel(): never;
 
 /**
  * Creates a reusable {@link assertCamel} function.
@@ -548,20 +479,14 @@ function createAssertCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertCamel<T>(): (input: T) => CamelCase<T>;
+export function createAssertCamel<T>(): (input: T) => CamelCase<T>;
 
 /**
  * @internal
  */
-function createAssertCamel(): never {
+export function createAssertCamel(): never {
   halt("createAssertCamel");
 }
-const createAssertCamelPure = /** @__PURE__ */ Object.assign(
-  createAssertCamel,
-  /** @__PURE__ */ Namespace.notations.camel("createAssertCamel"),
-  /** @__PURE__ */ Namespace.assert("notations.createAssertCamel"),
-);
-export { createAssertCamelPure as createAssertCamel };
 
 /**
  * Creates a reusable {@link isCamel} function.
@@ -572,7 +497,7 @@ export { createAssertCamelPure as createAssertCamel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsCamel(): never;
+export function createIsCamel(): never;
 
 /**
  * Creates a reusable {@link isCamel} function.
@@ -582,20 +507,14 @@ function createIsCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
+export function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
 
 /**
  * @internal
  */
-function createIsCamel(): never {
+export function createIsCamel(): never {
   halt("createIsCamel");
 }
-const createIsCamelPure = /** @__PURE__ */ Object.assign(
-  createIsCamel,
-  /** @__PURE__ */ Namespace.notations.camel("createIsCamel"),
-  /** @__PURE__ */ Namespace.is()
-);
-export { createIsCamelPure as createIsCamel };
 
 /**
  * Creates a reusable {@link validateCamel} function.
@@ -606,7 +525,7 @@ export { createIsCamelPure as createIsCamel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateCamel(): never;
+export function createValidateCamel(): never;
 
 /**
  * Creates a reusable {@link validateCamel} function.
@@ -616,22 +535,16 @@ function createValidateCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateCamel<T>(): (
+export function createValidateCamel<T>(): (
   input: T,
 ) => IValidation<CamelCase<T>>;
 
 /**
  * @internal
  */
-function createValidateCamel(): never {
+export function createValidateCamel(): never {
   halt("createValidateCamel");
 }
-const createValidateCamelPure = /** @__PURE__ */ Object.assign(
-  createValidateCamel,
-  /** @__PURE__ */ Namespace.notations.camel("createValidateCamel"),
-  /** @__PURE__ */ Namespace.validate()
-);
-export { createValidateCamelPure as createValidateCamel };
 
 /**
  * Creates a reusable {@link pascal} function.
@@ -642,7 +555,7 @@ export { createValidateCamelPure as createValidateCamel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createPascal(): never;
+export function createPascal(): never;
 
 /**
  * Creates a reusable {@link pascal} function.
@@ -652,19 +565,14 @@ function createPascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createPascal<T>(): (input: T) => PascalCase<T>;
+export function createPascal<T>(): (input: T) => PascalCase<T>;
 
 /**
  * @internal
  */
-function createPascal(): never {
+export function createPascal(): never {
   halt("createPascal");
 }
-const createPascalPure = /** @__PURE__ */ Object.assign(
-  createPascal,
-  /** @__PURE__ */ Namespace.notations.pascal("createPascal")
-);
-export { createPascalPure as createPascal };
 
 /**
  * Creates a reusable {@link assertPascal} function.
@@ -675,7 +583,7 @@ export { createPascalPure as createPascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertPascal(): never;
+export function createAssertPascal(): never;
 
 /**
  * Creates a reusable {@link assertPascal} function.
@@ -685,20 +593,14 @@ function createAssertPascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertPascal<T>(): (input: T) => PascalCase<T>;
+export function createAssertPascal<T>(): (input: T) => PascalCase<T>;
 
 /**
  * @internal
  */
-function createAssertPascal(): never {
+export function createAssertPascal(): never {
   halt("createAssertPascal");
 }
-const createAssertPascalPure = /** @__PURE__ */ Object.assign(
-  createAssertPascal,
-  /** @__PURE__ */ Namespace.notations.pascal("createAssertPascal"),
-  /** @__PURE__ */ Namespace.assert("notations.createAssertPascal"),
-);
-export { createAssertPascalPure as createAssertPascal };
 
 /**
  * Creates a reusable {@link isPascal} function.
@@ -709,7 +611,7 @@ export { createAssertPascalPure as createAssertPascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsPascal(): never;
+export function createIsPascal(): never;
 
 /**
  * Creates a reusable {@link isPascal} function.
@@ -719,20 +621,14 @@ function createIsPascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
+export function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
 
 /**
  * @internal
  */
-function createIsPascal(): never {
+export function createIsPascal(): never {
   halt("createIsPascal");
 }
-const createIsPascalPure = /** @__PURE__ */ Object.assign(
-  createIsPascal,
-  /** @__PURE__ */ Namespace.notations.pascal("createIsPascal"),
-  /** @__PURE__ */ Namespace.is()
-);
-export { createIsPascalPure as createIsPascal };
 
 /**
  * Creates a reusable {@link validatePascal} function.
@@ -743,7 +639,7 @@ export { createIsPascalPure as createIsPascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidatePascal(): never;
+export function createValidatePascal(): never;
 
 /**
  * Creates a reusable {@link validatePascal} function.
@@ -753,22 +649,16 @@ function createValidatePascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidatePascal<T>(): (
+export function createValidatePascal<T>(): (
   input: T,
 ) => IValidation<PascalCase<T>>;
 
 /**
  * @internal
  */
-function createValidatePascal(): never {
+export function createValidatePascal(): never {
   halt("createValidatePascal");
 }
-const createValidatePascalPure = /** @__PURE__ */ Object.assign(
-  createValidatePascal,
-  /** @__PURE__ */ Namespace.notations.pascal("createValidatePascal"),
-  /** @__PURE__ */ Namespace.validate(),
-);
-export { createValidatePascalPure as createValidatePascal };
 
 /**
  * Creates a reusable {@link snake} function.
@@ -779,7 +669,7 @@ export { createValidatePascalPure as createValidatePascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createSnake(): never;
+export function createSnake(): never;
 
 /**
  * Creates a reusable {@link snake} function.
@@ -789,19 +679,14 @@ function createSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createSnake<T>(): (input: T) => SnakeCase<T>;
+export function createSnake<T>(): (input: T) => SnakeCase<T>;
 
 /**
  * @internal
  */
-function createSnake(): never {
+export function createSnake(): never {
   halt("createSnake");
 }
-const createSnakePure = /** @__PURE__ */ Object.assign(
-  createSnake,
-  /** @__PURE__ */ Namespace.notations.snake("createSnake")
-);
-export { createSnakePure as createSnake };
 
 /**
  * Creates a reusable {@link assertSnake} function.
@@ -812,7 +697,7 @@ export { createSnakePure as createSnake };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertSnake(): never;
+export function createAssertSnake(): never;
 
 /**
  * Creates a reusable {@link assertSnake} function.
@@ -822,20 +707,14 @@ function createAssertSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertSnake<T>(): (input: T) => SnakeCase<T>;
+export function createAssertSnake<T>(): (input: T) => SnakeCase<T>;
 
 /**
  * @internal
  */
-function createAssertSnake(): never {
+export function createAssertSnake(): never {
   halt("createAssertSnake");
 }
-const createAssertSnakePure = /** @__PURE__ */ Object.assign(
-  createAssertSnake,
-  /** @__PURE__ */ Namespace.notations.snake("createAssertSnake"),
-  /** @__PURE__ */ Namespace.assert("notations.createAssertSnake"),
-);
-export { createAssertSnakePure as createAssertSnake };
 
 /**
  * Creates a reusable {@link isSnake} function.
@@ -846,7 +725,7 @@ export { createAssertSnakePure as createAssertSnake };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsSnake(): never;
+export function createIsSnake(): never;
 
 /**
  * Creates a reusable {@link isSnake} function.
@@ -856,20 +735,14 @@ function createIsSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
+export function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
 
 /**
  * @internal
  */
-function createIsSnake(): never {
+export function createIsSnake(): never {
   halt("createIsSnake");
 }
-const createIsSnakePure = /** @__PURE__ */ Object.assign(
-  createIsSnake,
-  /** @__PURE__ */ Namespace.notations.snake("createIsSnake"),
-  /** @__PURE__ */ Namespace.is()
-);
-export { createIsSnakePure as createIsSnake };
 
 /**
  * Creates a reusable {@link validateSnake} function.
@@ -880,7 +753,7 @@ export { createIsSnakePure as createIsSnake };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateSnake(): never;
+export function createValidateSnake(): never;
 
 /**
  * Creates a reusable {@link validateSnake} function.
@@ -890,22 +763,16 @@ function createValidateSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateSnake<T>(): (
+export function createValidateSnake<T>(): (
   input: T,
 ) => IValidation<SnakeCase<T>>;
 
 /**
  * @internal
  */
-function createValidateSnake(): never {
+export function createValidateSnake(): never {
   halt("createValidateSnake");
 }
-const createValidateSnakePure = /** @__PURE__ */ Object.assign(
-  createValidateSnake,
-  /** @__PURE__ */ Namespace.notations.snake("createValidateSnake"),
-  /** @__PURE__ */ Namespace.validate(),
-);
-export { createValidateSnakePure as createValidateSnake };
 
 /**
  * @internal