@simplysm/core-common 13.0.69 → 13.0.71

package/src/utils/bytes.ts

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

package/src/utils/date-format.ts

@@ -1,5 +1,5 @@
 /**
- * 월 설정 시 연도/월/일 정규화 결과
+ * Result of year/month/day normalization when setting month
  */
 export interface DtNormalizedMonth {
   year: number;
@@ -8,27 +8,27 @@ export interface DtNormalizedMonth {
 }
 
 /**
- * 월 설정 시 연도/월/일을 정규화
- * - 월이 1-12 범위를 벗어나면 연도를 조정
- * - 대상 월의 일수보다 현재 일자가 크면 해당 월의 마지막 날로 조정
+ * Normalize year/month/day when setting month
+ * - Adjust year if month is outside 1-12 range
+ * - Adjust to last day of target month if current day is greater than the number of days in the target month
  *
- * @param year 기준 연도
- * @param month 설정할 월 (1-12 범위 외의 값도 허용)
- * @param day 기준 일자
- * @returns 정규화된 연도, 월, 일
+ * @param year Base year
+ * @param month Month to set (values outside 1-12 range allowed)
+ * @param day Base day
+ * @returns Normalized year, month, day
  *
  * @example
  * normalizeMonth(2025, 13, 15) // { year: 2026, month: 1, day: 15 }
  * normalizeMonth(2025, 2, 31)  // { year: 2025, month: 2, day: 28 }
  */
 export function normalizeMonth(year: number, month: number, day: number): DtNormalizedMonth {
-  // 월 오버플로우/언더플로우 정규화
-  // month가 1-12 범위를 벗어나면 연도를 조정
+  // Normalize month overflow/underflow
+  // Adjust year if month is outside 1-12 range
   const normalizedYear = year + Math.floor((month - 1) / 12);
-  // JavaScript % 연산자는 음수에서 음수를 반환하므로 (% 12 + 12) % 12 패턴으로 0-11 범위를 보장 후 1-12로 변환
+  // JavaScript % operator returns negative for negative, so use (% 12 + 12) % 12 pattern to ensure 0-11 range, then convert to 1-12
   const normalizedMonth = ((((month - 1) % 12) + 12) % 12) + 1;
 
-  // 대상 월의 마지막 날 구하기
+  // Get last day of target month
   const lastDay = new Date(normalizedYear, normalizedMonth, 0).getDate();
   const normalizedDay = Math.min(day, lastDay);
 
@@ -36,13 +36,13 @@ export function normalizeMonth(year: number, month: number, day: number): DtNorm
 }
 
 /**
- * 12시간제를 24시간제로 변환
- * - 오전 12시 = 0시, 오후 12시 = 12시
- * - 오전 1-11시 = 1-11시, 오후 1-11시 = 13-23시
+ * Convert 12-hour format to 24-hour format
+ * - 12:00 AM = 0:00, 12:00 PM = 12:00
+ * - 1-11 AM = 1-11, 1-11 PM = 13-23
  *
- * @param rawHour 12시간제 시 (1-12)
- * @param isPM 오후 여부
- * @returns 24시간제 시 (0-23)
+ * @param rawHour 12-hour format hour (1-12)
+ * @param isPM Whether PM
+ * @returns 24-hour format hour (0-23)
  */
 export function convert12To24(rawHour: number, isPM: boolean): number {
   if (rawHour === 12) {
@@ -51,15 +51,15 @@ export function convert12To24(rawHour: number, isPM: boolean): number {
   return isPM ? rawHour + 12 : rawHour;
 }
 
-//#region 정규식 캐싱 (모듈 로드 시 1회만 생성)
+//#region Regex caching (created once at module load)
 
 /**
- * 포맷 패턴 정규식
+ * Format pattern regex
  *
- * 순서 중요:
- * dtFormat() 함수에서 긴 패턴(yyyy, MM, dd 등)을 먼저 처리해야
- * 짧은 패턴(y, M, d 등)이 부분 매칭되는 것을 방지합니다.
- * 예: "yyyy"를 먼저 처리하지 않으면 "yy"가 두 번 매칭될 수 있음
+ * Order is important:
+ * In the dtFormat() function, longer patterns (yyyy, MM, dd, etc.) must be processed first
+ * to prevent shorter patterns (y, M, d, etc.) from being partially matched.
+ * Example: If "yyyy" is not processed first, "yy" may be matched twice
  */
 const patterns = {
   yyyy: /yyyy/g,
@@ -91,49 +91,49 @@ const weekStrings = ["일", "월", "화", "수", "목", "금", "토"];
 //#endregion
 
 /**
- * 포맷 문자열에 따라 날짜/시간을 문자열로 변환한다
+ * Convert date/time to string according to format string
  *
- * @param formatString 포맷 문자열
- * @param args 날짜/시간 구성 요소
+ * @param formatString Format string
+ * @param args Date/time components
  *
  * @remarks
- * C#과 동일한 포맷 문자열을 지원한다:
+ * Supports the same format strings as C#:
  *
- * | 포맷 | 설명 | 예시 |
- * |------|------|------|
- * | yyyy | 4자리 연도 | 2024 |
- * | yy | 2자리 연도 | 24 |
- * | MM | 0으로 패딩된 월 | 01~12 |
- * | M | 월 | 1~12 |
- * | ddd | 요일 (한글) | 일, 월, 화, 수, 목, 금, 토 |
- * | dd | 0으로 패딩된 일 | 01~31 |
- * | d | 일 | 1~31 |
- * | tt | 오전/오후 | 오전, 오후 |
- * | hh | 0으로 패딩된 12시간 | 01~12 |
- * | h | 12시간 | 1~12 |
- * | HH | 0으로 패딩된 24시간 | 00~23 |
- * | H | 24시간 | 0~23 |
- * | mm | 0으로 패딩된 분 | 00~59 |
- * | m | 분 | 0~59 |
- * | ss | 0으로 패딩된 초 | 00~59 |
- * | s | 초 | 0~59 |
- * | fff | 밀리초 (3자리) | 000~999 |
- * | ff | 밀리초 (2자리) | 00~99 |
- * | f | 밀리초 (1자리) | 0~9 |
- * | zzz | 타임존 오프셋 (±HH:mm) | +09:00 |
- * | zz | 타임존 오프셋 (±HH) | +09 |
- * | z | 타임존 오프셋 (±H) | +9 |
+ * | Format | Description | Example |
+ * |--------|-------------|---------|
+ * | yyyy | 4-digit year | 2024 |
+ * | yy | 2-digit year | 24 |
+ * | MM | Zero-padded month | 01~12 |
+ * | M | Month | 1~12 |
+ * | ddd | Day of week | Sun, Mon, Tue, Wed, Thu, Fri, Sat |
+ * | dd | Zero-padded day | 01~31 |
+ * | d | Day | 1~31 |
+ * | tt | AM/PM | AM, PM |
+ * | hh | Zero-padded 12-hour | 01~12 |
+ * | h | 12-hour | 1~12 |
+ * | HH | Zero-padded 24-hour | 00~23 |
+ * | H | 24-hour | 0~23 |
+ * | mm | Zero-padded minute | 00~59 |
+ * | m | Minute | 0~59 |
+ * | ss | Zero-padded second | 00~59 |
+ * | s | Second | 0~59 |
+ * | fff | Milliseconds (3 digits) | 000~999 |
+ * | ff | Milliseconds (2 digits) | 00~99 |
+ * | f | Milliseconds (1 digit) | 0~9 |
+ * | zzz | Timezone offset (±HH:mm) | +09:00 |
+ * | zz | Timezone offset (±HH) | +09 |
+ * | z | Timezone offset (±H) | +9 |
  *
  * @example
  * ```typescript
  * formatDate("yyyy-MM-dd", { year: 2024, month: 3, day: 15 });
  * // "2024-03-15"
  *
- * formatDate("yyyy년 M월 d일 (ddd)", { year: 2024, month: 3, day: 15 });
- * // "2024년 3월 15일 (금)"
+ * formatDate("yyyy-M-d (ddd)", { year: 2024, month: 3, day: 15 });
+ * // "2024-3-15 (Fri)"
  *
  * formatDate("tt h:mm:ss", { hour: 14, minute: 30, second: 45 });
- * // "오후 2:30:45"
+ * // "PM 2:30:45"
  * ```
  */
 export function formatDate(
@@ -165,35 +165,35 @@ export function formatDate(
 
   let result = formatString;
 
-  // 연도
+  // Year
   if (year !== undefined) {
     const yearStr = year.toString();
     result = result.replace(patterns.yyyy, yearStr);
     result = result.replace(patterns.yy, yearStr.substring(2, 4));
   }
 
-  // 월
+  // Month
   if (month !== undefined) {
     const monthStr = month.toString();
     result = result.replace(patterns.MM, monthStr.padStart(2, "0"));
     result = result.replace(patterns.M, monthStr);
   }
 
-  // 요일
+  // Day of week
   if (week !== undefined) {
     result = result.replace(patterns.ddd, weekStrings[week]);
   }
 
-  // 일
+  // Day
   if (day !== undefined) {
     const dayStr = day.toString();
     result = result.replace(patterns.dd, dayStr.padStart(2, "0"));
     result = result.replace(patterns.d, dayStr);
   }
 
-  // 시간
+  // Hour
   if (hour !== undefined) {
-    result = result.replace(patterns.tt, hour < 12 ? "오전" : "오후");
+    result = result.replace(patterns.tt, hour < 12 ? "AM" : "PM");
 
     const hour12 = hour % 12 || 12;
     const hour12Str = hour12.toString();
@@ -205,21 +205,21 @@ export function formatDate(
     result = result.replace(patterns.H, hourStr);
   }
 
-  // 분
+  // Minute
   if (minute !== undefined) {
     const minuteStr = minute.toString();
     result = result.replace(patterns.mm, minuteStr.padStart(2, "0"));
     result = result.replace(patterns.m, minuteStr);
   }
 
-  // 초
+  // Second
   if (second !== undefined) {
     const secondStr = second.toString();
     result = result.replace(patterns.ss, secondStr.padStart(2, "0"));
     result = result.replace(patterns.s, secondStr);
   }
 
-  // 밀리초
+  // Millisecond
   if (millisecond !== undefined) {
     const msStr = millisecond.toString().padStart(3, "0");
     result = result.replace(patterns.fff, msStr);
@@ -227,7 +227,7 @@ export function formatDate(
     result = result.replace(patterns.f, msStr.substring(0, 1));
   }
 
-  // 타임존
+  // Timezone
   if (offsetSign !== undefined && offsetHour !== undefined && offsetMinute !== undefined) {
     result = result.replace(
       patterns.zzz,

package/src/utils/error.ts

@@ -1,10 +1,10 @@
 /**
- * unknown 타입의 에러에서 메시지를 추출하는 유틸리티.
+ * Utility to extract message from unknown type error.
  *
- * Error 인스턴스이면 message 속성을, 아니면 String 변환을 반환한다.
+ * Returns the message property if it's an Error instance, otherwise returns String conversion.
  *
- * @param err - catch 블록의 unknown 에러
- * @returns 에러 메시지 문자열
+ * @param err - Unknown error from catch block
+ * @returns Error message string
  */
 export function errorMessage(err: unknown): string {
   return err instanceof Error ? err.message : String(err);

package/src/utils/json.ts

@@ -1,6 +1,6 @@
 /**
- * JSON 변환 유틸리티
- * 커스텀 타입(DateTime, DateOnly, Time, Uuid 등)을 지원하는 JSON 직렬화/역직렬화
+ * JSON conversion utility
+ * JSON serialization/deserialization supporting custom types (DateTime, DateOnly, Time, Uuid, etc.)
  */
 import { DateTime } from "../types/date-time";
 import { DateOnly } from "../types/date-only";
@@ -19,19 +19,19 @@ interface TypedObject {
 //#region stringify
 
 /**
- * 객체를 JSON 문자열로 직렬화
- * DateTime, DateOnly, Time, Uuid, Set, Map, Error, Uint8Array 등 커스텀 타입 지원
+ * Serialize object to JSON string
+ * Supports custom types like DateTime, DateOnly, Time, Uuid, Set, Map, Error, Uint8Array, etc.
  *
- * @param obj 직렬화할 객체
- * @param options 직렬화 옵션
- * @param options.space JSON 들여쓰기 (숫자: 공백 수, 문자열: 들여쓰기 문자열)
- * @param options.replacer 커스텀 replacer 함수. 기본 타입 변환 전에 호출됨
- * @param options.redactBytes true 시 Uint8Array 내용을 "__hidden__"으로 대체 (로깅용). 이 옵션으로 직렬화한 결과는 jsonParse()로 원본 Uint8Array를 복원할 수 없음
+ * @param obj Object to serialize
+ * @param options Serialization options
+ * @param options.space JSON indentation (number: number of spaces, string: indentation string)
+ * @param options.replacer Custom replacer function. Called before default type conversion
+ * @param options.redactBytes If true, replace Uint8Array contents with "__hidden__" (for logging). Results serialized with this option cannot restore original Uint8Array via jsonParse()
  *
  * @remarks
- * - 순환 참조가 있는 객체는 TypeError를 던짐
- * - 객체의 toJSON 메서드가 있으면 호출하여 결과를 사용함 (Date, DateTime 등 커스텀 타입 제외)
- * - 전역 프로토타입을 수정하지 않아 Worker 환경에서도 안전함
+ * - Objects with circular references throw TypeError
+ * - If object has toJSON method, it is called and the result is used (except for custom types like Date, DateTime)
+ * - Safe in Worker environments as global prototypes are not modified
  */
 export function jsonStringify(
   obj: unknown,
@@ -41,21 +41,21 @@ export function jsonStringify(
     redactBytes?: boolean;
   },
 ): string {
-  // 순환 참조 감지를 위한 WeakSet
+  // WeakSet for circular reference detection
   const seen = new WeakSet<object>();
 
   /**
-   * 재귀적으로 객체를 순회하며 특수 타입을 __type__ 형식으로 변환
+   * Recursively traverse object and convert special types to __type__ format
    *
-   * JSON.stringify의 replacer는 toJSON 호출 후의 값을 받으므로,
-   * Date 등의 타입을 올바르게 처리하려면 미리 변환해야 함.
-   * 이 방식은 전역 프로토타입을 수정하지 않아 Worker 환경에서도 안전함.
+   * JSON.stringify's replacer receives values after toJSON call,
+   * so types like Date must be converted beforehand for proper handling.
+   * This approach is safe in Worker environments as global prototypes are not modified.
    *
-   * @param key 현재 값의 키 (루트는 undefined)
-   * @param value 변환할 값
+   * @param key Key of current value (root is undefined)
+   * @param value Value to convert
    */
   const convertSpecialTypes = (key: string | undefined, value: unknown): unknown => {
-    // 커스텀 replacer 적용
+    // Apply custom replacer
     const currValue = options?.replacer !== undefined ? options.replacer(key, value) : value;
 
     if (currValue instanceof Date) {
@@ -108,9 +108,9 @@ export function jsonStringify(
       return { __type__: "Uint8Array", data: bytesToHex(currValue) };
     }
 
-    // 배열 처리
+    // Array processing
     if (Array.isArray(currValue)) {
-      // 순환 참조 감지
+      // Detect circular reference
       if (seen.has(currValue)) {
         throw new TypeError("Converting circular structure to JSON");
       }
@@ -120,15 +120,15 @@ export function jsonStringify(
       return result;
     }
 
-    // 일반 객체 처리
+    // Generic object processing
     if (currValue !== null && typeof currValue === "object") {
-      // 순환 참조 감지
+      // Detect circular reference
       if (seen.has(currValue)) {
         throw new TypeError("Converting circular structure to JSON");
       }
       seen.add(currValue);
 
-      // toJSON 메서드가 있으면 호출 (Date, DateTime 등 커스텀 타입은 이미 위에서 처리됨)
+      // Call toJSON method if present (custom types like Date, DateTime already handled above)
       if (
         "toJSON" in currValue &&
         typeof (currValue as { toJSON: unknown }).toJSON === "function"
@@ -141,7 +141,7 @@ export function jsonStringify(
       const result: Record<string, unknown> = {};
       for (const [k, v] of Object.entries(currValue)) {
         const converted = convertSpecialTypes(k, v);
-        // undefined는 JSON에서 제외됨
+        // undefined is excluded from JSON
         if (converted !== undefined) {
           result[k] = converted;
         }
@@ -153,8 +153,8 @@ export function jsonStringify(
     return currValue;
   };
 
-  // 전체 객체를 미리 변환 후 JSON.stringify 호출
-  // 이 방식은 Date.prototype.toJSON을 수정하지 않아 동시성 환경에서 안전함
+  // Convert entire object first, then call JSON.stringify
+  // This approach is safe in concurrent environments as Date.prototype.toJSON is not modified
   const converted = convertSpecialTypes(undefined, obj);
   return JSON.stringify(converted, null, options?.space);
 }
@@ -164,23 +164,23 @@ export function jsonStringify(
 //#region parse
 
 /**
- * JSON 문자열을 객체로 역직렬화
- * DateTime, DateOnly, Time, Uuid, Set, Map, Error, Uint8Array 등 커스텀 타입 복원
+ * Deserialize JSON string to object
+ * Restore custom types like DateTime, DateOnly, Time, Uuid, Set, Map, Error, Uint8Array, etc.
  *
  * @remarks
- * `__type__`과 `data` 키를 가진 객체는 타입 복원에 사용된다.
- * 사용자 데이터에 `{ __type__: "Date" | "DateTime" | "DateOnly" | "Time" | "Uuid" | "Set" | "Map" | "Error" | "Uint8Array", data: ... }`
- * 형태가 있으면 의도치 않게 타입 변환될 수 있으므로 주의한다.
+ * Objects with `__type__` and `data` keys are used for type restoration.
+ * Be careful if user data contains objects with `{ __type__: "Date" | "DateTime" | "DateOnly" | "Time" | "Uuid" | "Set" | "Map" | "Error" | "Uint8Array", data: ... }`
+ * format as they may be unintentionally converted to types.
  *
- * @security 개발 모드(`__DEV__`)에서만 에러 메시지에 JSON 문자열 전체가 포함된다.
- * 프로덕션 모드에서는 JSON 길이만 포함된다.
+ * @security In development mode (`__DEV__`), the error message includes the entire JSON string.
+ * In production mode, only JSON length is included.
  */
 export function jsonParse<TResult = unknown>(json: string): TResult {
   try {
     return objNullToUndefined(
       JSON.parse(json, (_key, value: unknown) => {
         if (value != null && typeof value === "object") {
-          // __type__ 기반 타입 복원
+          // Restore types based on __type__ marker
           if ("__type__" in value && "data" in value) {
             const typed = value as TypedObject;
             if (typed.__type__ === "Date" && typeof typed.data === "string") {
@@ -213,7 +213,7 @@ 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로 복원할 수 없습니다",
+                  "Uint8Array serialized with redactBytes option cannot be restored via parse",
                 );
               }
               return bytesFromHex(typed.data);
@@ -226,9 +226,9 @@ export function jsonParse<TResult = unknown>(json: string): TResult {
     ) as TResult;
   } catch (err) {
     if (env.DEV) {
-      throw new SdError(err, "JSON 파싱 에러: \n" + json);
+      throw new SdError(err, "JSON parsing error: \n" + json);
     }
-    throw new SdError(err, `JSON 파싱 에러 (length: ${json.length})`);
+    throw new SdError(err, `JSON parsing error (length: ${json.length})`);
   }
 }