@simplysm/core-common 13.0.28 → 13.0.29

package/src/extensions/arr-ext.ts

@@ -246,7 +246,10 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
     return result;
   },
 
-  toMapValues<T, K, V>(keySelector: (item: T, index: number) => K, valueSelector: (items: T[]) => V): Map<K, V | T> {
+  toMapValues<T, K, V>(
+    keySelector: (item: T, index: number) => K,
+    valueSelector: (items: T[]) => V,
+  ): Map<K, V | T> {
     const itemsMap = new Map<K, T[]>();
 
     for (let i = 0; i < this.length; i++) {
@@ -304,7 +307,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
     return fn(rootItems);
   },
 
-  distinct<T>(options?: boolean | { matchAddress?: boolean; keyFn?: (item: T) => string | number }): T[] {
+  distinct<T>(
+    options?: boolean | { matchAddress?: boolean; keyFn?: (item: T) => string | number },
+  ): T[] {
     // 옵션 정규화
     const opts = typeof options === "boolean" ? { matchAddress: options } : (options ?? {});
 
@@ -367,7 +372,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
     return result;
   },
 
-  orderBy<T>(selector?: (item: T) => string | number | DateTime | DateOnly | Time | undefined): T[] {
+  orderBy<T>(
+    selector?: (item: T) => string | number | DateTime | DateOnly | Time | undefined,
+  ): T[] {
     return [...this].sort((p, n) => {
       const pp = selector == null ? p : selector(p);
       const pn = selector == null ? n : selector(n);
@@ -375,7 +382,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
     });
   },
 
-  orderByDesc<T>(selector?: (item: T) => string | number | DateTime | DateOnly | Time | undefined): T[] {
+  orderByDesc<T>(
+    selector?: (item: T) => string | number | DateTime | DateOnly | Time | undefined,
+  ): T[] {
     return [...this].sort((p, n) => {
       const pp = selector == null ? p : selector(p);
       const pn = selector == null ? n : selector(n);
@@ -403,7 +412,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
 
     if (keyIndexedTarget) {
       for (const targetItem of uncheckedTarget) {
-        const keyStr = JSON.stringify(options!.keys!.map((k) => (targetItem as Record<string, unknown>)[k]));
+        const keyStr = JSON.stringify(
+          options!.keys!.map((k) => (targetItem as Record<string, unknown>)[k]),
+        );
         const arr = keyIndexedTarget.get(keyStr);
         if (arr) {
           arr.push(targetItem);
@@ -429,7 +440,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
 
       // 전체 일치가 없고 keys 옵션이 있으면 Map에서 O(1) 조회
       if (sameTarget === undefined && keyIndexedTarget) {
-        const sourceKeyStr = JSON.stringify(options!.keys!.map((k) => (sourceItem as Record<string, unknown>)[k]));
+        const sourceKeyStr = JSON.stringify(
+          options!.keys!.map((k) => (sourceItem as Record<string, unknown>)[k]),
+        );
         const candidates = keyIndexedTarget.get(sourceKeyStr);
         if (candidates && candidates.length > 0) {
           // uncheckedTargetSet에서 O(1) 조회로 아직 남아있는 첫 번째 항목 선택
@@ -467,13 +480,16 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
       orgItems instanceof Map
         ? orgItems
         : orgItems.toMap((orgItem) =>
-            typeof keyPropNameOrFn === "function" ? keyPropNameOrFn(orgItem) : orgItem[keyPropNameOrFn],
+            typeof keyPropNameOrFn === "function"
+              ? keyPropNameOrFn(orgItem)
+              : orgItem[keyPropNameOrFn],
           );
     const includeSame = options?.includeSame ?? false;
 
     const diffs: ArrayDiffs2Result<T>[] = [];
     for (const item of this) {
-      const keyValue = typeof keyPropNameOrFn === "function" ? keyPropNameOrFn(item) : item[keyPropNameOrFn];
+      const keyValue =
+        typeof keyPropNameOrFn === "function" ? keyPropNameOrFn(item) : item[keyPropNameOrFn];
       if (keyValue == null) {
         diffs.push({ type: "create", item, orgItem: undefined });
         continue;
@@ -542,7 +558,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
     for (let i = 0; i < this.length; i++) {
       const item = selector !== undefined ? selector(this[i], i) : this[i];
       if (typeof item !== "number") {
-        throw new ArgumentError("sum 은 number 에 대해서만 사용할 수 있습니다.", { type: typeof item });
+        throw new ArgumentError("sum 은 number 에 대해서만 사용할 수 있습니다.", {
+          type: typeof item,
+        });
       }
       result += item;
     }
@@ -555,7 +573,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
     for (let i = 0; i < this.length; i++) {
       const item = selector !== undefined ? selector(this[i], i) : this[i];
       if (typeof item !== "number" && typeof item !== "string") {
-        throw new ArgumentError("min 은 number/string 에 대해서만 사용할 수 있습니다.", { type: typeof item });
+        throw new ArgumentError("min 은 number/string 에 대해서만 사용할 수 있습니다.", {
+          type: typeof item,
+        });
       }
       if (result === undefined || result > item) {
         result = item;
@@ -570,7 +590,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
     for (let i = 0; i < this.length; i++) {
       const item = selector !== undefined ? selector(this[i], i) : this[i];
       if (typeof item !== "number" && typeof item !== "string") {
-        throw new ArgumentError("max 은 number/string 에 대해서만 사용할 수 있습니다.", { type: typeof item });
+        throw new ArgumentError("max 은 number/string 에 대해서만 사용할 수 있습니다.", {
+          type: typeof item,
+        });
       }
       if (result === undefined || result < item) {
         result = item;
@@ -595,7 +617,9 @@ const arrayReadonlyExtensions: ReadonlyArrayExt<any> & ThisType<any[]> = {
 };
 
 const arrayMutableExtensions: MutableArrayExt<any> & ThisType<any[]> = {
-  distinctThis<T>(options?: boolean | { matchAddress?: boolean; keyFn?: (item: T) => string | number }): T[] {
+  distinctThis<T>(
+    options?: boolean | { matchAddress?: boolean; keyFn?: (item: T) => string | number },
+  ): T[] {
     // 옵션 정규화
     const opts = typeof options === "boolean" ? { matchAddress: options } : (options ?? {});
 
@@ -700,7 +724,9 @@ const arrayMutableExtensions: MutableArrayExt<any> & ThisType<any[]> = {
     return this;
   },
 
-  orderByThis<T>(selector?: (item: T) => string | number | DateTime | DateOnly | Time | undefined): T[] {
+  orderByThis<T>(
+    selector?: (item: T) => string | number | DateTime | DateOnly | Time | undefined,
+  ): T[] {
     return this.sort((p, n) => {
       const pp = selector?.(p) ?? p;
       const pn = selector?.(n) ?? n;
@@ -708,7 +734,9 @@ const arrayMutableExtensions: MutableArrayExt<any> & ThisType<any[]> = {
     });
   },
 
-  orderByDescThis<T>(selector?: (item: T) => string | number | DateTime | DateOnly | Time | undefined): T[] {
+  orderByDescThis<T>(
+    selector?: (item: T) => string | number | DateTime | DateOnly | Time | undefined,
+  ): T[] {
     return this.sort((p, n) => {
       const pp = selector?.(p) ?? p;
       const pn = selector?.(n) ?? n;
@@ -774,4 +802,9 @@ declare global {
 
 //#endregion
 
-export type { ArrayDiffsResult, ArrayDiffs2Result, TreeArray, ComparableType } from "./arr-ext.types";
+export type {
+  ArrayDiffsResult,
+  ArrayDiffs2Result,
+  TreeArray,
+  ComparableType,
+} from "./arr-ext.types";

package/src/extensions/arr-ext.types.ts

@@ -108,7 +108,10 @@ export interface ReadonlyArrayExt<TItem> {
     valueSelector: (item: TItem, index: number) => V,
   ): Map<K, Set<V>>;
 
-  toMapValues<K, V>(keySelector: (item: TItem, index: number) => K, valueSelector: (items: TItem[]) => V): Map<K, V>;
+  toMapValues<K, V>(
+    keySelector: (item: TItem, index: number) => K,
+    valueSelector: (items: TItem[]) => V,
+  ): Map<K, V>;
 
   toObject(keySelector: (item: TItem, index: number) => string): Record<string, TItem>;
 
@@ -153,18 +156,27 @@ export interface ReadonlyArrayExt<TItem> {
    * // ]}]
    * ```
    */
-  toTree<K extends keyof TItem, P extends keyof TItem>(keyProp: K, parentKey: P): TreeArray<TItem>[];
+  toTree<K extends keyof TItem, P extends keyof TItem>(
+    keyProp: K,
+    parentKey: P,
+  ): TreeArray<TItem>[];
 
   /**
    * 중복 제거
    * @param options matchAddress: 주소 비교 (true면 Set 사용), keyFn: 커스텀 키 함수 (O(n) 성능)
    * @note 객체 배열에서 keyFn 없이 사용 시 O(n²) 복잡도. 대량 데이터는 keyFn 사용 권장
    */
-  distinct(options?: boolean | { matchAddress?: boolean; keyFn?: (item: TItem) => string | number }): TItem[];
+  distinct(
+    options?: boolean | { matchAddress?: boolean; keyFn?: (item: TItem) => string | number },
+  ): TItem[];
 
-  orderBy(selector?: (item: TItem) => string | number | DateOnly | DateTime | Time | undefined): TItem[];
+  orderBy(
+    selector?: (item: TItem) => string | number | DateOnly | DateTime | Time | undefined,
+  ): TItem[];
 
-  orderByDesc(selector?: (item: TItem) => string | number | DateOnly | DateTime | Time | undefined): TItem[];
+  orderByDesc(
+    selector?: (item: TItem) => string | number | DateOnly | DateTime | Time | undefined,
+  ): TItem[];
 
   /**
    * 두 배열 비교 (INSERT/DELETE/UPDATE)
@@ -221,13 +233,19 @@ export interface MutableArrayExt<TItem> {
    * @note 객체 배열에서 keyFn 없이 사용 시 O(n²) 복잡도. 대량 데이터는 keyFn 사용 권장
    * @mutates
    */
-  distinctThis(options?: boolean | { matchAddress?: boolean; keyFn?: (item: TItem) => string | number }): TItem[];
+  distinctThis(
+    options?: boolean | { matchAddress?: boolean; keyFn?: (item: TItem) => string | number },
+  ): TItem[];
 
   /** 원본 배열 오름차순 정렬 @mutates */
-  orderByThis(selector?: (item: TItem) => string | number | DateOnly | DateTime | Time | undefined): TItem[];
+  orderByThis(
+    selector?: (item: TItem) => string | number | DateOnly | DateTime | Time | undefined,
+  ): TItem[];
 
   /** 원본 배열 내림차순 정렬 @mutates */
-  orderByDescThis(selector?: (item: TItem) => string | number | DateOnly | DateTime | Time | undefined): TItem[];
+  orderByDescThis(
+    selector?: (item: TItem) => string | number | DateOnly | DateTime | Time | undefined,
+  ): TItem[];
 
   /** 원본 배열에 항목 삽입 @mutates */
   insert(index: number, ...items: TItem[]): this;

package/src/features/event-emitter.ts

@@ -20,7 +20,9 @@
  * emitter.emit("data", "hello");
  * emitter.emit("done"); // void 타입은 인자 없이 호출
  */
-export class EventEmitter<TEvents extends { [K in keyof TEvents]: unknown } = Record<string, unknown>> {
+export class EventEmitter<
+  TEvents extends { [K in keyof TEvents]: unknown } = Record<string, unknown>,
+> {
   private readonly _target = new EventTarget();
   // 이벤트 타입별로 리스너 맵 관리 (같은 리스너를 다른 이벤트에 등록 가능)
   // 다형적 리스너 관리를 위해 Function 타입 사용
@@ -77,7 +79,10 @@ export class EventEmitter<TEvents extends { [K in keyof TEvents]: unknown } = Re
    * @param type 이벤트 타입
    * @param args 이벤트 데이터 (void 타입이면 생략)
    */
-  emit<K extends keyof TEvents & string>(type: K, ...args: TEvents[K] extends void ? [] : [data: TEvents[K]]): void {
+  emit<K extends keyof TEvents & string>(
+    type: K,
+    ...args: TEvents[K] extends void ? [] : [data: TEvents[K]]
+  ): void {
     this._target.dispatchEvent(new CustomEvent(type, { detail: args[0] }));
   }
 

package/src/types/date-only.ts

@@ -64,7 +64,11 @@ export class DateOnly {
     // yyyyMMdd 형식 (타임존 영향 없음)
     const matchCompact = /^(\d{4})(\d{2})(\d{2})$/.exec(str);
     if (matchCompact != null) {
-      return new DateOnly(Number(matchCompact[1]), Number(matchCompact[2]), Number(matchCompact[3]));
+      return new DateOnly(
+        Number(matchCompact[1]),
+        Number(matchCompact[2]),
+        Number(matchCompact[3]),
+      );
     }
 
     // ISO 8601 등 기타 형식 (Date.parse 사용, 타임존 변환 적용)
@@ -80,9 +84,12 @@ export class DateOnly {
       return new DateOnly(localTick);
     }
 
-    throw new ArgumentError(`날짜 형식을 파싱할 수 없습니다. 지원 형식: 'yyyy-MM-dd', 'yyyyMMdd', ISO 8601 날짜`, {
-      input: str,
-    });
+    throw new ArgumentError(
+      `날짜 형식을 파싱할 수 없습니다. 지원 형식: 'yyyy-MM-dd', 'yyyyMMdd', ISO 8601 날짜`,
+      {
+        input: str,
+      },
+    );
   }
 
   //#region 주차 계산
@@ -156,10 +163,16 @@ export class DateOnly {
    * // 미국식 (일요일 시작, 첫 주 1일 이상)
    * new DateOnly(2025, 1, 1).getWeekSeqOfYear(0, 1); // { year: 2025, weekSeq: 1 }
    */
-  getWeekSeqOfYear(weekStartDay: number = 1, minDaysInFirstWeek: number = 4): { year: number; weekSeq: number } {
+  getWeekSeqOfYear(
+    weekStartDay: number = 1,
+    minDaysInFirstWeek: number = 4,
+  ): { year: number; weekSeq: number } {
     const base = this.getBaseYearMonthSeqForWeekSeq(weekStartDay, minDaysInFirstWeek);
 
-    const firstWeekStart = new DateOnly(base.year, 1, 1).getWeekSeqStartDate(weekStartDay, minDaysInFirstWeek);
+    const firstWeekStart = new DateOnly(base.year, 1, 1).getWeekSeqStartDate(
+      weekStartDay,
+      minDaysInFirstWeek,
+    );
 
     const diffDays = (this.tick - firstWeekStart.tick) / DateOnly.MS_PER_DAY;
     return {

package/src/types/date-time.ts

@@ -43,7 +43,15 @@ export class DateTime {
     if (arg1 === undefined) {
       this.date = new Date();
     } else if (arg2 !== undefined && arg3 !== undefined) {
-      this.date = new Date(arg1 as number, arg2 - 1, arg3, arg4 ?? 0, arg5 ?? 0, arg6 ?? 0, arg7 ?? 0);
+      this.date = new Date(
+        arg1 as number,
+        arg2 - 1,
+        arg3,
+        arg4 ?? 0,
+        arg5 ?? 0,
+        arg6 ?? 0,
+        arg7 ?? 0,
+      );
     } else if (arg1 instanceof Date) {
       this.date = new Date(arg1.getTime());
     } else {
@@ -72,7 +80,9 @@ export class DateTime {
     }
 
     const match1 =
-      /^([0-9]{4})-([0-9]{2})-([0-9]{2}) (오전|오후) ([0-9]{1,2}):([0-9]{2}):([0-9]{2})(\.([0-9]{1,3}))?$/.exec(str);
+      /^([0-9]{4})-([0-9]{2})-([0-9]{2}) (오전|오후) ([0-9]{1,2}):([0-9]{2}):([0-9]{2})(\.([0-9]{1,3}))?$/.exec(
+        str,
+      );
     if (match1 != null) {
       const rawHour = Number(match1[5]);
       const isPM = match1[4] === "오후";
@@ -100,7 +110,10 @@ export class DateTime {
       );
     }
 
-    const match3 = /^([0-9]{4})-([0-9]{2})-([0-9]{2}) ([0-9]{2}):([0-9]{2}):([0-9]{2})(\.([0-9]{1,3}))?$/.exec(str);
+    const match3 =
+      /^([0-9]{4})-([0-9]{2})-([0-9]{2}) ([0-9]{2}):([0-9]{2}):([0-9]{2})(\.([0-9]{1,3}))?$/.exec(
+        str,
+      );
     if (match3 != null) {
       return new DateTime(
         Number(match3[1]),
@@ -173,7 +186,15 @@ export class DateTime {
 
   /** 지정된 연도로 새 인스턴스 반환 */
   setYear(year: number): DateTime {
-    return new DateTime(year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+    return new DateTime(
+      year,
+      this.month,
+      this.day,
+      this.hour,
+      this.minute,
+      this.second,
+      this.millisecond,
+    );
   }
 
   /**
@@ -202,27 +223,67 @@ export class DateTime {
    *       자동으로 다음/이전 달로 조정됨 (예: 1월에 day=32 → 2월 1일)
    */
   setDay(day: number): DateTime {
-    return new DateTime(this.year, this.month, day, this.hour, this.minute, this.second, this.millisecond);
+    return new DateTime(
+      this.year,
+      this.month,
+      day,
+      this.hour,
+      this.minute,
+      this.second,
+      this.millisecond,
+    );
   }
 
   /** 지정된 시로 새 인스턴스 반환 */
   setHour(hour: number): DateTime {
-    return new DateTime(this.year, this.month, this.day, hour, this.minute, this.second, this.millisecond);
+    return new DateTime(
+      this.year,
+      this.month,
+      this.day,
+      hour,
+      this.minute,
+      this.second,
+      this.millisecond,
+    );
   }
 
   /** 지정된 분으로 새 인스턴스 반환 */
   setMinute(minute: number): DateTime {
-    return new DateTime(this.year, this.month, this.day, this.hour, minute, this.second, this.millisecond);
+    return new DateTime(
+      this.year,
+      this.month,
+      this.day,
+      this.hour,
+      minute,
+      this.second,
+      this.millisecond,
+    );
   }
 
   /** 지정된 초로 새 인스턴스 반환 */
   setSecond(second: number): DateTime {
-    return new DateTime(this.year, this.month, this.day, this.hour, this.minute, second, this.millisecond);
+    return new DateTime(
+      this.year,
+      this.month,
+      this.day,
+      this.hour,
+      this.minute,
+      second,
+      this.millisecond,
+    );
   }
 
   /** 지정된 밀리초로 새 인스턴스 반환 */
   setMillisecond(millisecond: number): DateTime {
-    return new DateTime(this.year, this.month, this.day, this.hour, this.minute, this.second, millisecond);
+    return new DateTime(
+      this.year,
+      this.month,
+      this.day,
+      this.hour,
+      this.minute,
+      this.second,
+      millisecond,
+    );
   }
 
   //#endregion

package/src/types/time.ts

@@ -36,7 +36,8 @@ export class Time {
         Time.MS_PER_DAY;
     } else if (arg2 !== undefined) {
       let tick =
-        ((arg4 ?? 0) + (arg3 ?? 0) * 1000 + arg2 * 60 * 1000 + (arg1 as number) * 60 * 60 * 1000) % Time.MS_PER_DAY;
+        ((arg4 ?? 0) + (arg3 ?? 0) * 1000 + arg2 * 60 * 1000 + (arg1 as number) * 60 * 60 * 1000) %
+        Time.MS_PER_DAY;
       if (tick < 0) tick += Time.MS_PER_DAY;
       this._tick = tick;
     } else if (arg1 instanceof Date) {
@@ -72,7 +73,12 @@ export class Time {
       const rawHour = Number(match1[2]);
       const isPM = match1[1] === "오후";
       const hour = convert12To24(rawHour, isPM);
-      return new Time(hour, Number(match1[3]), Number(match1[4]), Number(match1[6] ? match1[6].padEnd(3, "0") : "0"));
+      return new Time(
+        hour,
+        Number(match1[3]),
+        Number(match1[4]),
+        Number(match1[6] ? match1[6].padEnd(3, "0") : "0"),
+      );
     }
 
     const match2 = /([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})(\.([0-9]{1,3}))?$/.exec(str);
@@ -91,7 +97,12 @@ export class Time {
     if (isoMatch != null) {
       const date = new Date(str);
       if (!Number.isNaN(date.getTime())) {
-        return new Time(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+        return new Time(
+          date.getHours(),
+          date.getMinutes(),
+          date.getSeconds(),
+          date.getMilliseconds(),
+        );
       }
     }
 

package/src/types/uuid.ts

@@ -12,9 +12,12 @@ import { ArgumentError } from "../errors/argument-error";
  */
 export class Uuid {
   // 0x00 ~ 0xFF에 대한 hex 문자열 미리 계산 (256개)
-  private static readonly _hexTable: string[] = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+  private static readonly _hexTable: string[] = Array.from({ length: 256 }, (_, i) =>
+    i.toString(16).padStart(2, "0"),
+  );
 
-  private static readonly _uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  private static readonly _uuidRegex =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
   /** 16바이트 배열을 UUID 문자열로 변환 */
   private static _bytesToUuidStr(bytes: Uint8Array): string {

package/src/utils/bytes.ts

@@ -132,7 +132,9 @@ export function bytesFromBase64(base64: string): Bytes {
 
   // 유효성 검사: 문자
   if (!/^[A-Za-z0-9+/]+$/.test(cleanBase64)) {
-    throw new ArgumentError("유효하지 않은 base64 문자가 포함되어 있습니다", { base64: base64.substring(0, 20) });
+    throw new ArgumentError("유효하지 않은 base64 문자가 포함되어 있습니다", {
+      base64: base64.substring(0, 20),
+    });
   }
 
   // 유효성 검사: 길이 (패딩 제거 후 나머지가 1이면 유효하지 않음)

package/src/utils/date-format.ts

@@ -151,10 +151,12 @@ export function formatDate(
 ): string {
   const { year, month, day, hour, minute, second, millisecond, timezoneOffsetMinutes } = args;
 
-  const absOffsetMinutes = timezoneOffsetMinutes !== undefined ? Math.abs(timezoneOffsetMinutes) : undefined;
+  const absOffsetMinutes =
+    timezoneOffsetMinutes !== undefined ? Math.abs(timezoneOffsetMinutes) : undefined;
   const offsetHour = absOffsetMinutes !== undefined ? Math.floor(absOffsetMinutes / 60) : undefined;
   const offsetMinute = absOffsetMinutes !== undefined ? absOffsetMinutes % 60 : undefined;
-  const offsetSign = timezoneOffsetMinutes !== undefined ? (timezoneOffsetMinutes >= 0 ? "+" : "-") : undefined;
+  const offsetSign =
+    timezoneOffsetMinutes !== undefined ? (timezoneOffsetMinutes >= 0 ? "+" : "-") : undefined;
 
   const week =
     year !== undefined && month !== undefined && day !== undefined

package/src/utils/json.ts

@@ -129,7 +129,10 @@ export function jsonStringify(
       seen.add(currValue);
 
       // toJSON 메서드가 있으면 호출 (Date, DateTime 등 커스텀 타입은 이미 위에서 처리됨)
-      if ("toJSON" in currValue && typeof (currValue as { toJSON: unknown }).toJSON === "function") {
+      if (
+        "toJSON" in currValue &&
+        typeof (currValue as { toJSON: unknown }).toJSON === "function"
+      ) {
         const toJsonResult = (currValue as { toJSON: (key?: string) => unknown }).toJSON(key);
         seen.delete(currValue);
         return convertSpecialTypes(key, toJsonResult);
@@ -209,7 +212,9 @@ export function jsonParse<TResult = unknown>(json: string): TResult {
             }
             if (typed.__type__ === "Uint8Array" && typeof typed.data === "string") {
               if (typed.data === "__hidden__") {
-                throw new SdError("redactBytes 옵션으로 직렬화된 Uint8Array는 parse로 복원할 수 없습니다");
+                throw new SdError(
+                  "redactBytes 옵션으로 직렬화된 Uint8Array는 parse로 복원할 수 없습니다",
+                );
               }
               return bytesFromHex(typed.data);
             }

package/src/utils/num.ts

@@ -86,8 +86,14 @@ export function numIsNullOrEmpty(val: number | undefined): val is 0 | undefined
  * numFormat(1234, { min: 2 }) // "1,234.00"
  */
 export function numFormat(val: number, digit?: { max?: number; min?: number }): string;
-export function numFormat(val: number | undefined, digit?: { max?: number; min?: number }): string | undefined;
-export function numFormat(val: number | undefined, digit?: { max?: number; min?: number }): string | undefined {
+export function numFormat(
+  val: number | undefined,
+  digit?: { max?: number; min?: number },
+): string | undefined;
+export function numFormat(
+  val: number | undefined,
+  digit?: { max?: number; min?: number },
+): string | undefined {
   return val?.toLocaleString(undefined, {
     maximumFractionDigits: digit?.max,
     minimumFractionDigits: digit?.min,

package/src/utils/obj.ts

@@ -204,7 +204,11 @@ export function objEqual(source: unknown, target: unknown, options?: EqualOption
   }
 
   if (typeof source === "object" && typeof target === "object") {
-    return objEqualObject(source as Record<string, unknown>, target as Record<string, unknown>, options);
+    return objEqualObject(
+      source as Record<string, unknown>,
+      target as Record<string, unknown>,
+      options,
+    );
   }
 
   return false;
@@ -229,9 +233,14 @@ function objEqualArray(source: unknown[], target: unknown[], options?: EqualOpti
       });
     } else {
       // 재귀 호출 시 topLevelIncludes/topLevelExcludes 옵션은 최상위 레벨에만 적용되므로 제외
-      const recursiveOptions = { ignoreArrayIndex: options.ignoreArrayIndex, onlyOneDepth: options.onlyOneDepth };
+      const recursiveOptions = {
+        ignoreArrayIndex: options.ignoreArrayIndex,
+        onlyOneDepth: options.onlyOneDepth,
+      };
       return source.every((sourceItem) => {
-        const idx = target.findIndex((t, i) => !matchedIndices.has(i) && objEqual(t, sourceItem, recursiveOptions));
+        const idx = target.findIndex(
+          (t, i) => !matchedIndices.has(i) && objEqual(t, sourceItem, recursiveOptions),
+        );
         if (idx !== -1) {
           matchedIndices.add(idx);
           return true;
@@ -269,7 +278,11 @@ function objEqualArray(source: unknown[], target: unknown[], options?: EqualOpti
  * @note 비문자열 키(객체, 배열 등) 처리 시 O(n²) 복잡도 발생
  * @note 대량 데이터의 경우 onlyOneDepth: true 옵션 사용 권장 (참조 비교로 O(n)으로 개선)
  */
-function objEqualMap(source: Map<unknown, unknown>, target: Map<unknown, unknown>, options?: EqualOptions): boolean {
+function objEqualMap(
+  source: Map<unknown, unknown>,
+  target: Map<unknown, unknown>,
+  options?: EqualOptions,
+): boolean {
   // Map 비교 시 topLevelIncludes/topLevelExcludes 옵션은 무시됨 (object 속성 키에만 적용)
   const sourceKeys = Array.from(source.keys()).filter((key) => source.get(key) != null);
   const targetKeys = Array.from(target.keys()).filter((key) => target.get(key) != null);
@@ -392,7 +405,9 @@ function objEqualSet(source: Set<unknown>, target: Set<unknown>, options?: Equal
     const targetArr = [...target];
     const matchedIndices = new Set<number>();
     for (const sourceItem of source) {
-      const idx = targetArr.findIndex((t, i) => !matchedIndices.has(i) && objEqual(sourceItem, t, options));
+      const idx = targetArr.findIndex(
+        (t, i) => !matchedIndices.has(i) && objEqual(sourceItem, t, options),
+      );
       if (idx === -1) {
         return false;
       }
@@ -447,7 +462,9 @@ export function objMerge<TSource, TMergeTarget>(
   }
 
   if (target === null) {
-    return opt?.useDelTargetNull ? (undefined as TSource & TMergeTarget) : (objClone(source) as TSource & TMergeTarget);
+    return opt?.useDelTargetNull
+      ? (undefined as TSource & TMergeTarget)
+      : (objClone(source) as TSource & TMergeTarget);
   }
 
   if (typeof target !== "object") {
@@ -588,7 +605,10 @@ export function objMerge3<
  * objOmit(user, ["email"]);
  * // { name: "Alice", age: 30 }
  */
-export function objOmit<T extends Record<string, unknown>, K extends keyof T>(item: T, omitKeys: K[]): Omit<T, K> {
+export function objOmit<T extends Record<string, unknown>, K extends keyof T>(
+  item: T,
+  omitKeys: K[],
+): Omit<T, K> {
   const result: Record<string, unknown> = {};
   for (const key of Object.keys(item)) {
     if (!omitKeys.includes(key as K)) {
@@ -609,7 +629,10 @@ export function objOmit<T extends Record<string, unknown>, K extends keyof T>(it
  * objOmitByFilter(data, (key) => key.startsWith("_"));
  * // { name: "Alice", age: 30 }
  */
-export function objOmitByFilter<T extends Record<string, unknown>>(item: T, omitKeyFn: (key: keyof T) => boolean): T {
+export function objOmitByFilter<T extends Record<string, unknown>>(
+  item: T,
+  omitKeyFn: (key: keyof T) => boolean,
+): T {
   const result: Record<string, unknown> = {};
   for (const key of Object.keys(item)) {
     if (!omitKeyFn(key)) {
@@ -629,7 +652,10 @@ export function objOmitByFilter<T extends Record<string, unknown>>(item: T, omit
  * objPick(user, ["name", "age"]);
  * // { name: "Alice", age: 30 }
  */
-export function objPick<T extends Record<string, unknown>, K extends keyof T>(item: T, keys: K[]): Pick<T, K> {
+export function objPick<T extends Record<string, unknown>, K extends keyof T>(
+  item: T,
+  keys: K[],
+): Pick<T, K> {
   const result: Record<string, unknown> = {};
   for (const key of keys) {
     result[key as string] = item[key];
@@ -669,7 +695,11 @@ function getChainSplits(chain: string): (string | number)[] {
  */
 export function objGetChainValue(obj: unknown, chain: string, optional: true): unknown | undefined;
 export function objGetChainValue(obj: unknown, chain: string): unknown;
-export function objGetChainValue(obj: unknown, chain: string, optional?: true): unknown | undefined {
+export function objGetChainValue(
+  obj: unknown,
+  chain: string,
+  optional?: true,
+): unknown | undefined {
   const splits = getChainSplits(chain);
   let result: unknown = obj;
   for (const splitItem of splits) {
@@ -957,7 +987,10 @@ function objMapImpl<TSource extends object, TNewKey extends string, TNewValue>(
 ): Record<string, TNewValue> {
   const result: Record<string, TNewValue> = {};
   for (const key of Object.keys(obj)) {
-    const [newKey, newValue] = fn(key as keyof TSource, (obj as Record<string, TSource[keyof TSource]>)[key]);
+    const [newKey, newValue] = fn(
+      key as keyof TSource,
+      (obj as Record<string, TSource[keyof TSource]>)[key],
+    );
     result[newKey ?? key] = newValue;
   }
   return result;