typia 7.6.2-dev.20250205 → 7.6.2

package/src/utils/ArrayUtil.ts

@@ -1,41 +1,41 @@
-export namespace ArrayUtil {
-  export const has = <T>(array: T[], pred: (elem: T) => boolean): boolean =>
-    array.some(pred);
-
-  export const add = <T>(
-    array: T[],
-    value: T,
-    pred: (x: T, y: T) => boolean = (x, y) => x === y,
-  ): boolean => {
-    if (array.some((elem) => pred(elem, value))) return false;
-    array.push(value);
-    return true;
-  };
-
-  export const set = <Key, T>(
-    array: T[],
-    value: T,
-    key: (elem: T) => Key,
-  ): void => {
-    if (array.some((elem) => key(elem) === key(value))) return;
-    array.push(value);
-  };
-
-  export const take = <T>(
-    array: T[],
-    pred: (elem: T) => boolean,
-    init: () => T,
-  ): T => {
-    const index: number = array.findIndex(pred);
-    if (index !== -1) return array[index]!;
-
-    const elem: T = init();
-    array.push(elem);
-    return elem;
-  };
-
-  export const repeat = <T>(
-    count: number,
-    closure: (index: number, count: number) => T,
-  ): T[] => new Array(count).fill("").map((_, index) => closure(index, count));
-}
+export namespace ArrayUtil {
+  export const has = <T>(array: T[], pred: (elem: T) => boolean): boolean =>
+    array.some(pred);
+
+  export const add = <T>(
+    array: T[],
+    value: T,
+    pred: (x: T, y: T) => boolean = (x, y) => x === y,
+  ): boolean => {
+    if (array.some((elem) => pred(elem, value))) return false;
+    array.push(value);
+    return true;
+  };
+
+  export const set = <Key, T>(
+    array: T[],
+    value: T,
+    key: (elem: T) => Key,
+  ): void => {
+    if (array.some((elem) => key(elem) === key(value))) return;
+    array.push(value);
+  };
+
+  export const take = <T>(
+    array: T[],
+    pred: (elem: T) => boolean,
+    init: () => T,
+  ): T => {
+    const index: number = array.findIndex(pred);
+    if (index !== -1) return array[index]!;
+
+    const elem: T = init();
+    array.push(elem);
+    return elem;
+  };
+
+  export const repeat = <T>(
+    count: number,
+    closure: (index: number, count: number) => T,
+  ): T[] => new Array(count).fill("").map((_, index) => closure(index, count));
+}

package/src/utils/Escaper.ts

@@ -1,50 +1,50 @@
-export namespace Escaper {
-  export const variable = (str: string): boolean =>
-    reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
-
-  export const reserved = (str: string): boolean => RESERVED.has(str);
-}
-
-const RESERVED: Set<string> = new Set([
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "module",
-  "new",
-  "null",
-  "package",
-  "public",
-  "private",
-  "protected",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-]);
+export namespace Escaper {
+  export const variable = (str: string): boolean =>
+    reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+
+  export const reserved = (str: string): boolean => RESERVED.has(str);
+}
+
+const RESERVED: Set<string> = new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "module",
+  "new",
+  "null",
+  "package",
+  "public",
+  "private",
+  "protected",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+]);

package/src/utils/MapUtil.ts

@@ -1,14 +1,14 @@
-export namespace MapUtil {
-  export const take = <Key, T>(
-    dict: Map<Key, T>,
-    key: Key,
-    generator: () => T,
-  ): T => {
-    const oldbie: T | undefined = dict.get(key);
-    if (oldbie) return oldbie;
-
-    const value: T = generator();
-    dict.set(key, value);
-    return value;
-  };
-}
+export namespace MapUtil {
+  export const take = <Key, T>(
+    dict: Map<Key, T>,
+    key: Key,
+    generator: () => T,
+  ): T => {
+    const oldbie: T | undefined = dict.get(key);
+    if (oldbie) return oldbie;
+
+    const value: T = generator();
+    dict.set(key, value);
+    return value;
+  };
+}

package/src/utils/NamingConvention.ts

@@ -1,94 +1,94 @@
-import { StringUtil } from "./StringUtil";
-
-export namespace NamingConvention {
-  const unsnake =
-    (props: {
-      plain: (str: string) => string;
-      snake: (str: string, index: number) => string;
-    }) =>
-    (str: string): string => {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      let prefix: string = "";
-      for (let i: number = 0; i < str.length; i++) {
-        if (str[i] === "_") prefix += "_";
-        else break;
-      }
-      if (prefix.length !== 0) str = str.substring(prefix.length);
-
-      const out = (s: string) => `${prefix}${s}`;
-      if (str.length === 0) return out("");
-
-      const items: string[] = str.split("_").filter((s) => s.length !== 0);
-      return items.length === 0
-        ? out("")
-        : items.length === 1
-          ? out(props.plain(items[0]!))
-          : out(items.map(props.snake).join(""));
-    };
-
-  export function snake(str: string): string {
-    if (str.length === 0) return str;
-
-    // PREFIX
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    let prefix: string = "";
-    for (let i: number = 0; i < str.length; i++) {
-      if (str[i] === "_") prefix += "_";
-      else break;
-    }
-    if (prefix.length !== 0) str = str.substring(prefix.length);
-
-    const out = (s: string) => `${prefix}${s}`;
-
-    // SNAKE CASE
-    const items: string[] = str.split("_");
-    if (items.length > 1)
-      return out(items.map((s) => s.toLowerCase()).join("_"));
-
-    // CAMEL OR PASCAL CASE
-    const indexes: number[] = [];
-    for (let i: number = 0; i < str.length; i++) {
-      const code: number = str.charCodeAt(i);
-      if (65 <= code && code <= 90) indexes.push(i);
-    }
-    for (let i: number = indexes.length - 1; i > 0; --i) {
-      const now: number = indexes[i]!;
-      const prev: number = indexes[i - 1]!;
-      if (now - prev === 1) indexes.splice(i, 1);
-    }
-    if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
-    if (indexes.length === 0) return str.toLowerCase();
-
-    let ret: string = "";
-    for (let i: number = 0; i < indexes.length; i++) {
-      const first: number = i === 0 ? 0 : indexes[i - 1]!;
-      const last: number = indexes[i]!;
-
-      ret += str.substring(first, last).toLowerCase();
-      ret += "_";
-    }
-    ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
-    return out(ret);
-  }
-
-  export function camel(str: string) {
-    return unsnake({
-      plain: (str) =>
-        str.length
-          ? str === str.toUpperCase()
-            ? str.toLocaleLowerCase()
-            : `${str[0]!.toLowerCase()}${str.substring(1)}`
-          : str,
-      snake: (str, i) =>
-        i === 0 ? str.toLowerCase() : StringUtil.capitalize(str.toLowerCase()),
-    })(str);
-  }
-
-  export function pascal(str: string) {
-    return unsnake({
-      plain: (str) =>
-        str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str,
-      snake: StringUtil.capitalize,
-    })(str);
-  }
-}
+import { StringUtil } from "./StringUtil";
+
+export namespace NamingConvention {
+  const unsnake =
+    (props: {
+      plain: (str: string) => string;
+      snake: (str: string, index: number) => string;
+    }) =>
+    (str: string): string => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      let prefix: string = "";
+      for (let i: number = 0; i < str.length; i++) {
+        if (str[i] === "_") prefix += "_";
+        else break;
+      }
+      if (prefix.length !== 0) str = str.substring(prefix.length);
+
+      const out = (s: string) => `${prefix}${s}`;
+      if (str.length === 0) return out("");
+
+      const items: string[] = str.split("_").filter((s) => s.length !== 0);
+      return items.length === 0
+        ? out("")
+        : items.length === 1
+          ? out(props.plain(items[0]!))
+          : out(items.map(props.snake).join(""));
+    };
+
+  export function snake(str: string): string {
+    if (str.length === 0) return str;
+
+    // PREFIX
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    let prefix: string = "";
+    for (let i: number = 0; i < str.length; i++) {
+      if (str[i] === "_") prefix += "_";
+      else break;
+    }
+    if (prefix.length !== 0) str = str.substring(prefix.length);
+
+    const out = (s: string) => `${prefix}${s}`;
+
+    // SNAKE CASE
+    const items: string[] = str.split("_");
+    if (items.length > 1)
+      return out(items.map((s) => s.toLowerCase()).join("_"));
+
+    // CAMEL OR PASCAL CASE
+    const indexes: number[] = [];
+    for (let i: number = 0; i < str.length; i++) {
+      const code: number = str.charCodeAt(i);
+      if (65 <= code && code <= 90) indexes.push(i);
+    }
+    for (let i: number = indexes.length - 1; i > 0; --i) {
+      const now: number = indexes[i]!;
+      const prev: number = indexes[i - 1]!;
+      if (now - prev === 1) indexes.splice(i, 1);
+    }
+    if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
+    if (indexes.length === 0) return str.toLowerCase();
+
+    let ret: string = "";
+    for (let i: number = 0; i < indexes.length; i++) {
+      const first: number = i === 0 ? 0 : indexes[i - 1]!;
+      const last: number = indexes[i]!;
+
+      ret += str.substring(first, last).toLowerCase();
+      ret += "_";
+    }
+    ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
+    return out(ret);
+  }
+
+  export function camel(str: string) {
+    return unsnake({
+      plain: (str) =>
+        str.length
+          ? str === str.toUpperCase()
+            ? str.toLocaleLowerCase()
+            : `${str[0]!.toLowerCase()}${str.substring(1)}`
+          : str,
+      snake: (str, i) =>
+        i === 0 ? str.toLowerCase() : StringUtil.capitalize(str.toLowerCase()),
+    })(str);
+  }
+
+  export function pascal(str: string) {
+    return unsnake({
+      plain: (str) =>
+        str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str,
+      snake: StringUtil.capitalize,
+    })(str);
+  }
+}

package/src/utils/PatternUtil.ts

@@ -1,29 +1,29 @@
-export namespace PatternUtil {
-  export const fix = (str: string): string => {
-    const first: number = str.indexOf(STRING);
-    const last: number = str.lastIndexOf(STRING);
-    return [
-      first === -1 || none("(")(str.slice(0, first)) ? "^" : "",
-      str,
-      last === -1 || none(")")(str.slice(last + STRING.length)) ? "$" : "",
-    ].join("");
-  };
-
-  export const escape = (str: string): string => {
-    return str.replace(/[|\\/{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
-  };
-
-  export const NUMBER =
-    "[+-]?" + // optional sign
-    "\\d+(?:\\.\\d+)?" + // integer or decimal
-    "(?:[eE][+-]?\\d+)?"; // optional exponent
-  export const BOOLEAN = "true|false";
-  export const STRING = "(.*)";
-}
-
-const none =
-  (parenthesis: string) =>
-  (str: string): boolean => {
-    for (const ch of str) if (ch !== parenthesis) return true;
-    return false;
-  };
+export namespace PatternUtil {
+  export const fix = (str: string): string => {
+    const first: number = str.indexOf(STRING);
+    const last: number = str.lastIndexOf(STRING);
+    return [
+      first === -1 || none("(")(str.slice(0, first)) ? "^" : "",
+      str,
+      last === -1 || none(")")(str.slice(last + STRING.length)) ? "$" : "",
+    ].join("");
+  };
+
+  export const escape = (str: string): string => {
+    return str.replace(/[|\\/{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+  };
+
+  export const NUMBER =
+    "[+-]?" + // optional sign
+    "\\d+(?:\\.\\d+)?" + // integer or decimal
+    "(?:[eE][+-]?\\d+)?"; // optional exponent
+  export const BOOLEAN = "true|false";
+  export const STRING = "(.*)";
+}
+
+const none =
+  (parenthesis: string) =>
+  (str: string): boolean => {
+    for (const ch of str) if (ch !== parenthesis) return true;
+    return false;
+  };

package/src/utils/ProtobufNameEncoder.ts

@@ -1,32 +1,32 @@
-export namespace ProtobufNameEncoder {
-  export const encode = (str: string): string => {
-    for (const [before, after] of REPLACERS)
-      str = str.split(before).join(after);
-    return str;
-  };
-
-  export const decode = (str: string): string => {
-    for (const [before, after] of REPLACERS)
-      if (after !== "") str = str.split(after).join(before);
-    return str;
-  };
-}
-
-const REPLACERS: [string, string][] = [
-  ["$", "_dollar_"],
-  ["&", "_and_"],
-  ["|", "_or_"],
-  ["{", "_blt_"],
-  ["}", "_bgt_"],
-  ["<", "_lt_"],
-  [">", "_gt_"],
-  ["(", "_lp_"],
-  [")", "_rp_"],
-  ["[", "_alt_"],
-  ["]", "_agt_"],
-  [",", "_comma_"],
-  ["`", "_backquote_"],
-  ["'", "_singlequote_"],
-  ['"', "_doublequote_"],
-  [" ", "_space_"],
-];
+export namespace ProtobufNameEncoder {
+  export const encode = (str: string): string => {
+    for (const [before, after] of REPLACERS)
+      str = str.split(before).join(after);
+    return str;
+  };
+
+  export const decode = (str: string): string => {
+    for (const [before, after] of REPLACERS)
+      if (after !== "") str = str.split(after).join(before);
+    return str;
+  };
+}
+
+const REPLACERS: [string, string][] = [
+  ["$", "_dollar_"],
+  ["&", "_and_"],
+  ["|", "_or_"],
+  ["{", "_blt_"],
+  ["}", "_bgt_"],
+  ["<", "_lt_"],
+  [">", "_gt_"],
+  ["(", "_lp_"],
+  [")", "_rp_"],
+  ["[", "_alt_"],
+  ["]", "_agt_"],
+  [",", "_comma_"],
+  ["`", "_backquote_"],
+  ["'", "_singlequote_"],
+  ['"', "_doublequote_"],
+  [" ", "_space_"],
+];

package/src/utils/Singleton.ts

@@ -1,16 +1,16 @@
-export class Singleton<T, Args extends any[] = []> {
-  private readonly closure_: (...args: Args) => T;
-  private value_: T | object;
-
-  public constructor(closure: (...args: Args) => T) {
-    this.closure_ = closure;
-    this.value_ = NOT_MOUNTED_YET;
-  }
-
-  public get(...args: Args): T {
-    if (this.value_ === NOT_MOUNTED_YET) this.value_ = this.closure_(...args);
-    return this.value_ as T;
-  }
-}
-
-const NOT_MOUNTED_YET = {};
+export class Singleton<T, Args extends any[] = []> {
+  private readonly closure_: (...args: Args) => T;
+  private value_: T | object;
+
+  public constructor(closure: (...args: Args) => T) {
+    this.closure_ = closure;
+    this.value_ = NOT_MOUNTED_YET;
+  }
+
+  public get(...args: Args): T {
+    if (this.value_ === NOT_MOUNTED_YET) this.value_ = this.closure_(...args);
+    return this.value_ as T;
+  }
+}
+
+const NOT_MOUNTED_YET = {};

package/src/utils/StringUtil.ts

@@ -1,16 +1,16 @@
-export namespace StringUtil {
-  export const capitalize = (str: string) =>
-    str.length ? str[0]!.toUpperCase() + str.slice(1).toLowerCase() : str;
-
-  export const escapeDuplicate = (props: {
-    keep: string[];
-    input: string;
-    escape?: (str: string) => string;
-  }): string =>
-    props.keep.includes(props.input)
-      ? escapeDuplicate({
-          keep: props.keep,
-          input: (props.escape ?? ((str) => `_${str}`))(props.input),
-        })
-      : props.input;
-}
+export namespace StringUtil {
+  export const capitalize = (str: string) =>
+    str.length ? str[0]!.toUpperCase() + str.slice(1).toLowerCase() : str;
+
+  export const escapeDuplicate = (props: {
+    keep: string[];
+    input: string;
+    escape?: (str: string) => string;
+  }): string =>
+    props.keep.includes(props.input)
+      ? escapeDuplicate({
+          keep: props.keep,
+          input: (props.escape ?? ((str) => `_${str}`))(props.input),
+        })
+      : props.input;
+}