@simplysm/core-common 13.0.100 → 14.0.4

package/src/types/lazy-gc-map.ts

@@ -1,20 +1,20 @@
 import consola from "consola";
 
 /**
- * Map with automatic expiration feature
- * Updates access time in LRU manner, auto-deletes if not accessed for specified time
+ * 자동 만료 기능이 있는 Map
+ * LRU 방식으로 접근 시간을 갱신하고, 지정된 시간 동안 접근하지 않으면 자동 삭제
  *
- * @note Must call dispose() or use 'using' statement after use.
- *       Otherwise GC timer continues running and causes memory leak.
+ * @note 사용 후 반드시 dispose()를 호출하거나 'using' 문을 사용해야 함.
+ *       그렇지 않으면 GC 타이머가 계속 실행되어 메모리 누수 발생.
  *
  * @example
- * // using statement (recommended)
+ * // using 문 (권장)
  * using map = new LazyGcMap({ gcInterval: 10000, expireTime: 60000 });
  *
- * // Or explicit dispose() call
+ * // 또는 명시적 dispose() 호출
  * const map = new LazyGcMap({ gcInterval: 10000, expireTime: 60000 });
  * try {
- *   // ... usage
+ *   // ... 사용
  * } finally {
  *   map.dispose();
  * }
@@ -22,21 +22,21 @@ import consola from "consola";
 export class LazyGcMap<TKey, TValue> {
   private static readonly _logger = consola.withTag("LazyGcMap");
 
-  // Store actual data and last access time together
+  // 실제 데이터와 마지막 접근 시간을 함께 저장
   private readonly _map = new Map<TKey, { value: TValue; lastAccess: number }>();
 
-  // GC timer
+  // GC 타이머
   private _gcTimer?: ReturnType<typeof setInterval>;
-  // Flag to prevent duplicate GC runs
+  // 중복 GC 실행 방지 플래그
   private _isGcRunning = false;
-  // Whether dispose() has been called
+  // dispose()가 호출되었는지 여부
   private _isDestroyed = false;
 
   /**
-   * @param _options Configuration options
-   * @param _options.gcInterval GC interval in milliseconds. Default: 1/10 of expireTime (minimum 1000ms)
-   * @param _options.expireTime Expiration time in milliseconds. Deleted after this time since last access. Example: 60000 (60 seconds)
-   * @param _options.onExpire Callback called on expiration. Can be async function, errors are logged and continue execution
+   * @param _options 설정 옵션
+   * @param _options.gcInterval GC 간격 (밀리초). 기본값: expireTime의 1/10 (최소 1000ms)
+   * @param _options.expireTime 만료 시간 (밀리초). 마지막 접근 이후 이 시간이 지나면 삭제됨. 예: 60000 (60초)
+   * @param _options.onExpire 만료 시 호출되는 콜백. 비동기 함수 가능, 에러 발생 시 로그 출력 후 계속 실행
    */
   constructor(
     private readonly _options: {
@@ -46,48 +46,48 @@ export class LazyGcMap<TKey, TValue> {
     },
   ) {}
 
-  /** Number of stored items */
+  /** 저장된 항목 수 */
   get size(): number {
     return this._map.size;
   }
 
-  /** Check if key exists (does not update access time) */
+  /** key 존재 여부 확인 (접근 시간 갱신하지 않음) */
   has(key: TKey): boolean {
     if (this._isDestroyed) return false;
     return this._map.has(key);
   }
 
-  /** Get value (updates access time) */
+  /** 값 조회 (접근 시간 갱신) */
   get(key: TKey): TValue | undefined {
     if (this._isDestroyed) return undefined;
     const item = this._map.get(key);
     if (item == null) return undefined;
 
-    // Update access time on retrieval (LRU)
+    // 조회 시 접근 시간 갱신 (LRU)
     item.lastAccess = Date.now();
     return item.value;
   }
 
-  /** Store value (sets access time and starts GC timer) */
+  /** 값 저장 (접근 시간 설정 및 GC 타이머 시작) */
   set(key: TKey, value: TValue): void {
     if (this._isDestroyed) return;
     this._map.set(key, { value, lastAccess: Date.now() });
-    // Start GC timer when data is added
+    // 데이터 추가 시 GC 타이머 시작
     this._startGc();
   }
 
-  /** Delete item (stops GC timer if empty) */
+  /** 항목 삭제 (비어있으면 GC 타이머 중지) */
   delete(key: TKey): boolean {
     if (this._isDestroyed) return false;
     const result = this._map.delete(key);
-    // Stop timer if empty
+    // 비어있으면 타이머 중지
     if (this._map.size === 0) {
       this._stopGc();
     }
     return result;
   }
 
-  /** Clean up instance (stop GC timer and delete data) */
+  /** 인스턴스 정리 (GC 타이머 중지 및 데이터 삭제) */
   dispose(): void {
     if (this._isDestroyed) return;
     this._isDestroyed = true;
@@ -95,13 +95,13 @@ export class LazyGcMap<TKey, TValue> {
     this._stopGc();
   }
 
-  /** Support for 'using' statement */
+  /** 'using' 문 지원 */
   [Symbol.dispose](): void {
     this.dispose();
   }
 
   /**
-   * Delete all items (instance can still be used)
+   * 모든 항목 삭제 (인스턴스는 계속 사용 가능)
    */
   clear(): void {
     if (this._isDestroyed) return;
@@ -110,14 +110,14 @@ export class LazyGcMap<TKey, TValue> {
   }
 
   /**
-   * Return value for key, or create and store via factory if not found
-   * @param key Key to look up
-   * @param factory Function to create value if key not found
-   * @returns Existing or newly created value
+   * key에 대한 값을 반환하거나, 없으면 팩토리로 생성하여 저장 후 반환
+   * @param key 조회할 key
+   * @param factory key가 없을 때 값을 생성하는 함수
+   * @returns 기존 값 또는 새로 생성된 값
    */
   getOrCreate(key: TKey, factory: () => TValue): TValue {
     if (this._isDestroyed) {
-      throw new Error("LazyGcMap has already been disposed.");
+      throw new Error("LazyGcMap이 이미 dispose되었습니다.");
     }
     const item = this._map.get(key);
     if (item == null) {
@@ -130,7 +130,7 @@ export class LazyGcMap<TKey, TValue> {
     return item.value;
   }
 
-  /** Iterate over values only (Iterator) */
+  /** 값만 순회 (Iterator) */
   *values(): IterableIterator<TValue> {
     if (this._isDestroyed) return;
     for (const item of this._map.values()) {
@@ -138,13 +138,13 @@ export class LazyGcMap<TKey, TValue> {
     }
   }
 
-  /** Iterate over keys only (Iterator) */
+  /** key만 순회 (Iterator) */
   *keys(): IterableIterator<TKey> {
     if (this._isDestroyed) return;
     yield* this._map.keys();
   }
 
-  /** Iterate over entries (Iterator) */
+  /** 엔트리 순회 (Iterator) */
   *entries(): IterableIterator<[TKey, TValue]> {
     if (this._isDestroyed) return;
     for (const [key, item] of this._map.entries()) {
@@ -165,14 +165,14 @@ export class LazyGcMap<TKey, TValue> {
   }
 
   private async _runGc(): Promise<void> {
-    // Skip if already running (prevent duplicate runs when onExpire callback takes time)
+    // 이미 실행 중이면 건너뜀 (onExpire 콜백이 오래 걸릴 때 중복 실행 방지)
     if (this._isGcRunning) return;
     this._isGcRunning = true;
 
     try {
       const now = Date.now();
 
-      // 1. Collect expired items (before deletion)
+      // 1. 만료된 항목 수집 (삭제 전)
       const expiredEntries: { key: TKey; item: { value: TValue; lastAccess: number } }[] = [];
       for (const [key, item] of this._map) {
         if (now - item.lastAccess > this._options.expireTime) {
@@ -180,33 +180,33 @@ export class LazyGcMap<TKey, TValue> {
         }
       }
 
-      // 2. Run callback then delete each item
+      // 2. 각 항목에 대해 콜백 실행 후 삭제
       for (const { key, item } of expiredEntries) {
-        // Check current state before callback (skip if already replaced or deleted)
+        // 콜백 전 현재 상태 확인 (이미 교체되었거나 삭제된 경우 건너뜀)
         const currentItem = this._map.get(key);
         if (currentItem !== item) {
           continue;
         }
 
-        // Run expiration callback
+        // 만료 콜백 실행
         if (this._options.onExpire != null) {
           try {
             await this._options.onExpire(key, item.value);
           } catch (err) {
-            LazyGcMap._logger.error("onExpire callback error", err);
+            LazyGcMap._logger.error("onExpire 콜백 오류", err);
           }
         }
 
-        // Check if item was re-registered after callback
-        // Scenario: onExpire callback calls set() with same key,
-        // we should not delete newly registered item. If item reference is same, not re-registered, so delete.
+        // 콜백 후 항목이 다시 등록되었는지 확인
+        // 시나리오: onExpire 콜백이 같은 key로 set()을 호출하면,
+        // 새로 등록된 항목을 삭제하면 안 됨. 항목 참조가 같으면 재등록되지 않은 것이므로 삭제.
         const afterItem = this._map.get(key);
         if (afterItem === item) {
           this._map.delete(key);
         }
       }
 
-      // Stop GC if empty after cleanup
+      // 정리 후 비어있으면 GC 중지
       if (this._map.size === 0) {
         this._stopGc();
       }

package/src/types/time.ts

@@ -2,10 +2,10 @@ import { ArgumentError } from "../errors/argument-error";
 import { convert12To24, format } from "../utils/date-format";
 
 /**
- * Time class (without date: HH:mm:ss.fff, immutable)
+ * 시간 클래스 (날짜 제외: HH:mm:ss.fff, 불변)
  *
- * An immutable class that stores only time without date information.
- * Values exceeding 24 hours or negative values are automatically normalized.
+ * 날짜 정보 없이 시간만 저장하는 불변 클래스.
+ * 24시간을 초과하거나 음수인 값은 자동으로 정규화됨.
  *
  * @example
  * const now = new Time();
@@ -17,13 +17,13 @@ export class Time {
 
   private readonly _tick: number;
 
-  /** Create with current time */
+  /** 현재 시간으로 생성 */
   constructor();
-  /** Create with hour, minute, second, millisecond */
+  /** 시, 분, 초, 밀리초로 생성 */
   constructor(hour: number, minute: number, second?: number, millisecond?: number);
-  /** Create from tick (millisecond) */
+  /** tick (밀리초)으로 생성 */
   constructor(tick: number);
-  /** Create by extracting time part only from Date object */
+  /** Date 객체에서 시간 부분만 추출하여 생성 */
   constructor(date: Date);
   constructor(arg1?: number | Date, arg2?: number, arg3?: number, arg4?: number) {
     if (arg1 === undefined) {
@@ -55,11 +55,11 @@ export class Time {
   }
 
   /**
-   * Parse a string to create Time instance
+   * 문자열을 파싱하여 Time 인스턴스 생성
    *
-   * @param str Time string
-   * @returns Parsed Time instance
-   * @throws ArgumentError If unsupported format
+   * @param str 시간 문자열
+   * @returns 파싱된 Time 인스턴스
+   * @throws ArgumentError 지원하지 않는 형식인 경우
    *
    * @example
    * Time.parse("10:30:00")           // HH:mm:ss
@@ -91,8 +91,8 @@ export class Time {
       );
     }
 
-    // ISO 8601 format (e.g., 2025-01-15T10:30:00.123Z, 2025-01-15T10:30:00+09:00)
-    // Use Date object to handle timezone conversion
+    // ISO 8601 형식 (예: 2025-01-15T10:30:00.123Z, 2025-01-15T10:30:00+09:00)
+    // 타임존 변환 처리를 위해 Date 객체 사용
     const isoMatch = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.exec(str);
     if (isoMatch != null) {
       const date = new Date(str);
@@ -107,12 +107,12 @@ export class Time {
     }
 
     throw new ArgumentError(
-      `Failed to parse time format. Supported formats: 'HH:mm:ss', 'HH:mm:ss.fff', 'AM/PM HH:mm:ss', ISO 8601`,
+      `시간 형식 파싱 실패. 지원 형식: 'HH:mm:ss', 'HH:mm:ss.fff', 'AM/PM HH:mm:ss', ISO 8601`,
       { input: str },
     );
   }
 
-  //#region Getters (read-only)
+  //#region Getters (읽기 전용)
 
   get hour(): number {
     return Math.floor(this._tick / (60 * 60 * 1000));
@@ -134,61 +134,61 @@ export class Time {
     return this._tick;
   }
 
-  /** Whether time is set correctly */
+  /** 시간이 올바르게 설정되었는지 여부 */
   get isValid(): boolean {
     return !Number.isNaN(this._tick);
   }
 
   //#endregion
 
-  //#region Immutable transformation methods (returns new instance)
+  //#region 불변 변환 메서드 (새 인스턴스 반환)
 
-  /** Return new instance with specified hour */
+  /** 지정된 시로 새 인스턴스 반환 */
   setHour(hour: number): Time {
     return new Time(hour, this.minute, this.second, this.millisecond);
   }
 
-  /** Return new instance with specified minute */
+  /** 지정된 분으로 새 인스턴스 반환 */
   setMinute(minute: number): Time {
     return new Time(this.hour, minute, this.second, this.millisecond);
   }
 
-  /** Return new instance with specified second */
+  /** 지정된 초로 새 인스턴스 반환 */
   setSecond(second: number): Time {
     return new Time(this.hour, this.minute, second, this.millisecond);
   }
 
-  /** Return new instance with specified millisecond */
+  /** 지정된 밀리초로 새 인스턴스 반환 */
   setMillisecond(millisecond: number): Time {
     return new Time(this.hour, this.minute, this.second, millisecond);
   }
 
   //#endregion
 
-  //#region Arithmetic methods (returns new instance)
+  //#region 산술 메서드 (새 인스턴스 반환)
 
-  /** Return new instance with specified hours added (24-hour wraparound) */
+  /** 지정된 시간을 더한 새 인스턴스 반환 (24시간 순환) */
   addHours(hours: number): Time {
     let newTick = (this._tick + hours * 60 * 60 * 1000) % Time.MS_PER_DAY;
     if (newTick < 0) newTick += Time.MS_PER_DAY;
     return new Time(newTick);
   }
 
-  /** Return new instance with specified minutes added (24-hour wraparound) */
+  /** 지정된 분을 더한 새 인스턴스 반환 (24시간 순환) */
   addMinutes(minutes: number): Time {
     let newTick = (this._tick + minutes * 60 * 1000) % Time.MS_PER_DAY;
     if (newTick < 0) newTick += Time.MS_PER_DAY;
     return new Time(newTick);
   }
 
-  /** Return new instance with specified seconds added (24-hour wraparound) */
+  /** 지정된 초를 더한 새 인스턴스 반환 (24시간 순환) */
   addSeconds(seconds: number): Time {
     let newTick = (this._tick + seconds * 1000) % Time.MS_PER_DAY;
     if (newTick < 0) newTick += Time.MS_PER_DAY;
     return new Time(newTick);
   }
 
-  /** Return new instance with specified milliseconds added (24-hour wraparound) */
+  /** 지정된 밀리초를 더한 새 인스턴스 반환 (24시간 순환) */
   addMilliseconds(milliseconds: number): Time {
     let newTick = (this._tick + milliseconds) % Time.MS_PER_DAY;
     if (newTick < 0) newTick += Time.MS_PER_DAY;
@@ -200,9 +200,9 @@ export class Time {
   //#region Formatting
 
   /**
-   * Convert to string with specified format
-   * @param format Format string
-   * @see dtFormat for supported format strings
+   * 지정된 형식으로 문자열 변환
+   * @param format 형식 문자열
+   * @see dtFormat 지원되는 형식 문자열 참조
    */
   toFormatString(formatStr: string): string {
     return format(formatStr, {

package/src/types/uuid.ts

@@ -2,16 +2,16 @@ import type { Bytes } from "../common.types";
 import { ArgumentError } from "../errors/argument-error";
 
 /**
- * UUID v4 class
+ * UUID v4 클래스
  *
- * Generates cryptographically secure UUIDs based on crypto.getRandomValues. (Chrome 79+, Node.js compatible)
+ * crypto.getRandomValues 기반으로 암호학적으로 안전한 UUID를 생성. (Chrome 79+, Node.js 호환)
  *
  * @example
  * const id = Uuid.generate();
  * const fromStr = new Uuid("550e8400-e29b-41d4-a716-446655440000");
  */
 export class Uuid {
-  // Pre-calculate hex strings for 0x00 ~ 0xFF (256 entries)
+  // 0x00 ~ 0xFF에 대한 hex 문자열 사전 계산 (256개 항목)
   private static readonly _hexTable: string[] = Array.from({ length: 256 }, (_, i) =>
     i.toString(16).padStart(2, "0"),
   );
@@ -19,7 +19,7 @@ export class Uuid {
   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;
 
-  /** Convert 16-byte array to UUID string */
+  /** 16바이트 배열을 UUID 문자열로 변환 */
   private static _bytesToUuidStr(bytes: Uint8Array): string {
     const h = Uuid._hexTable;
     return (
@@ -46,12 +46,12 @@ export class Uuid {
     );
   }
 
-  /** Create new UUID v4 instance */
+  /** 새 UUID v4 인스턴스 생성 */
   static generate(): Uuid {
     const bytes = new Uint8Array(16);
     crypto.getRandomValues(bytes);
 
-    // Set UUID v4 bits
+    // UUID v4 비트 설정
     bytes[6] = (bytes[6] & 0x0f) | 0x40;
     bytes[8] = (bytes[8] & 0x3f) | 0x80;
 
@@ -59,13 +59,13 @@ export class Uuid {
   }
 
   /**
-   * Create UUID from 16-byte Uint8Array
-   * @param bytes 16-byte array
-   * @throws {ArgumentError} If byte size is not 16
+   * 16바이트 Uint8Array로 UUID 생성
+   * @param bytes 16바이트 배열
+   * @throws {ArgumentError} 바이트 크기가 16이 아닌 경우
    */
   static fromBytes(bytes: Bytes): Uuid {
     if (bytes.length !== 16) {
-      throw new ArgumentError("UUID byte size must be 16.", { length: bytes.length });
+      throw new ArgumentError("UUID 바이트 크기는 16이어야 합니다.", { length: bytes.length });
     }
 
     return new Uuid(Uuid._bytesToUuidStr(bytes));
@@ -74,22 +74,22 @@ export class Uuid {
   private readonly _uuid: string;
 
   /**
-   * @param uuid UUID string (format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
-   * @throws {ArgumentError} If format is invalid
+   * @param uuid UUID 문자열 (형식: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+   * @throws {ArgumentError} 형식이 유효하지 않은 경우
    */
   constructor(uuid: string) {
     if (!Uuid._uuidRegex.test(uuid)) {
-      throw new ArgumentError("Invalid UUID format.", { uuid });
+      throw new ArgumentError("유효하지 않은 UUID 형식입니다.", { uuid });
     }
     this._uuid = uuid;
   }
 
-  /** Convert UUID to string */
+  /** UUID를 문자열로 변환 */
   toString(): string {
     return this._uuid;
   }
 
-  /** Convert UUID to 16-byte Uint8Array */
+  /** UUID를 16바이트 Uint8Array로 변환 */
   toBytes(): Bytes {
     const u = this._uuid;
     // UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12)

package/src/utils/bytes.ts

@@ -2,32 +2,32 @@ import type { Bytes } from "../common.types";
 import { ArgumentError } from "../errors/argument-error";
 
 /**
- * Uint8Array utility functions (complex operations only)
+ * Uint8Array 유틸리티 함수 (복잡한 연산만)
  *
- * Features:
- * - concat: Concatenate multiple Uint8Arrays
- * - toHex: Convert Uint8Array to hex string
- * - fromHex: Convert hex string to Uint8Array
- * - toBase64: Convert Uint8Array to base64 string
- * - fromBase64: Convert base64 string to Uint8Array
+ * 기능:
+ * - concat: 여러 Uint8Array 결합
+ * - toHex: Uint8Array를 hex 문자열로 변환
+ * - fromHex: hex 문자열을 Uint8Array로 변환
+ * - toBase64: Uint8Array를 base64 문자열로 변환
+ * - fromBase64: base64 문자열을 Uint8Array로 변환
  */
 
-/** Lookup table for hex conversion (performance optimization) */
+/** hex 변환용 조회 테이블 (성능 최적화) */
 const hexTable: string[] = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 
-/** Base64 encoding table */
+/** Base64 인코딩 테이블 */
 const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-/** Base64 decoding lookup table (O(1) lookup, covers all byte values) */
+/** Base64 디코딩 조회 테이블 (O(1) 조회, 모든 바이트 값 포함) */
 const BASE64_LOOKUP: number[] = Array.from({ length: 256 }, (_, i) => {
   const idx = BASE64_CHARS.indexOf(String.fromCharCode(i));
   return idx === -1 ? 0 : idx;
 });
 
 /**
- * Concatenate multiple Uint8Arrays
- * @param arrays Uint8Array array to concatenate
- * @returns New concatenated Uint8Array
+ * 여러 Uint8Array 결합
+ * @param arrays 결합할 Uint8Array 배열
+ * @returns 결합된 새 Uint8Array
  * @example
  * const a = new Uint8Array([1, 2]);
  * const b = new Uint8Array([3, 4]);
@@ -46,9 +46,9 @@ export function concat(arrays: Bytes[]): Bytes {
 }
 
 /**
- * Convert to hex string
- * @param bytes Uint8Array to convert
- * @returns Lowercase hex string
+ * hex 문자열로 변환
+ * @param bytes 변환할 Uint8Array
+ * @returns 소문자 hex 문자열
  * @example
  * toHex(new Uint8Array([255, 0, 127]));
  * // "ff007f"
@@ -63,20 +63,20 @@ export function toHex(bytes: Bytes): string {
 }
 
 /**
- * Convert from hex string to Uint8Array
- * @param hex Hex string to convert (lowercase and uppercase allowed)
- * @returns Converted Uint8Array
- * @throws {ArgumentError} If odd length or invalid hex characters are present
+ * hex 문자열을 Uint8Array로 변환
+ * @param hex 변환할 hex 문자열 (대소문자 허용)
+ * @returns 변환된 Uint8Array
+ * @throws {ArgumentError} 홀수 길이이거나 유효하지 않은 hex 문자가 포함된 경우
  * @example
  * fromHex("ff007f");
  * // Uint8Array([255, 0, 127])
  */
 export function fromHex(hex: string): Bytes {
   if (hex.length % 2 !== 0) {
-    throw new ArgumentError("Hex string must have even length", { hex });
+    throw new ArgumentError("hex 문자열은 짝수 길이여야 합니다", { hex });
   }
   if (hex.length > 0 && !/^[0-9a-fA-F]+$/.test(hex)) {
-    throw new ArgumentError("Invalid hex character included", { hex });
+    throw new ArgumentError("유효하지 않은 hex 문자가 포함되어 있습니다", { hex });
   }
   const bytes = new Uint8Array(hex.length / 2);
   for (let i = 0; i < bytes.length; i++) {
@@ -86,9 +86,9 @@ export function fromHex(hex: string): Bytes {
 }
 
 /**
- * Convert Bytes to base64 string
- * @param bytes Uint8Array to convert
- * @returns Base64 encoded string
+ * Bytes를 base64 문자열로 변환
+ * @param bytes 변환할 Uint8Array
+ * @returns Base64 인코딩된 문자열
  * @example
  * toBase64(new Uint8Array([72, 101, 108, 108, 111]));
  * // "SGVsbG8="
@@ -113,33 +113,33 @@ export function toBase64(bytes: Bytes): string {
 }
 
 /**
- * Convert base64 string to Bytes
- * @param base64 Base64 string to convert
- * @returns Decoded Uint8Array
- * @throws {ArgumentError} If invalid base64 character is present
+ * base64 문자열을 Bytes로 변환
+ * @param base64 변환할 base64 문자열
+ * @returns 디코딩된 Uint8Array
+ * @throws {ArgumentError} 유효하지 않은 base64 문자가 포함된 경우
  * @example
  * fromBase64("SGVsbG8=");
  * // Uint8Array([72, 101, 108, 108, 111])
  */
 export function fromBase64(base64: string): Bytes {
-  // Remove whitespace and normalize padding
+  // 공백 제거 및 패딩 정규화
   const cleanBase64 = base64.replace(/\s/g, "").replace(/=+$/, "");
 
-  // Handle empty string
+  // 빈 문자열 처리
   if (cleanBase64.length === 0) {
     return new Uint8Array(0);
   }
 
-  // Validation: characters
+  // 유효성 검사: 문자
   if (!/^[A-Za-z0-9+/]+$/.test(cleanBase64)) {
-    throw new ArgumentError("Invalid base64 character included", {
+    throw new ArgumentError("유효하지 않은 base64 문자가 포함되어 있습니다", {
       base64: base64.substring(0, 20),
     });
   }
 
-  // Validation: length (remainder of 1 after padding removal is invalid)
+  // 유효성 검사: 길이 (패딩 제거 후 나머지가 1이면 유효하지 않음)
   if (cleanBase64.length % 4 === 1) {
-    throw new ArgumentError("Invalid base64 length", { length: cleanBase64.length });
+    throw new ArgumentError("유효하지 않은 base64 길이입니다", { length: cleanBase64.length });
   }
 
   const len = cleanBase64.length;