@simplysm/excel 13.0.99 → 14.0.1

package/src/excel-worksheet.ts

@@ -14,8 +14,8 @@ import type { ExcelXmlWorkbook } from "./xml/excel-xml-workbook";
 import type { ExcelXmlWorksheet } from "./xml/excel-xml-worksheet";
 
 /**
- * Class representing an Excel worksheet.
- * Provides cell access, row/column copying, data table processing, and image insertion.
+ * Excel 워크시트를 나타내는 클래스.
+ * 셀 접근, 행/열 복사, 데이터 테이블 처리, 이미지 삽입 기능을 제공한다.
  */
 export class ExcelWorksheet {
   private readonly _rowMap = new Map<number, ExcelRow>();
@@ -29,17 +29,17 @@ export class ExcelWorksheet {
 
   //#region Name Methods
 
-  /** Return worksheet name */
+  /** 워크시트 이름 반환 */
   async getName(): Promise<string> {
     const wbXmlData = await this._getWbData();
     const name = wbXmlData.getWorksheetNameById(this._relId);
     if (name == null) {
-      throw new Error(`Cannot find name for worksheet ID ${this._relId}`);
+      throw new Error(`워크시트 ID ${this._relId}의 이름을 찾을 수 없습니다`);
     }
     return name;
   }
 
-  /** Rename worksheet */
+  /** 워크시트 이름 변경 */
   async setName(newName: string): Promise<void> {
     const wbXmlData = await this._getWbData();
     wbXmlData.setWorksheetNameById(this._relId, newName);
@@ -49,17 +49,17 @@ export class ExcelWorksheet {
 
   //#region Cell Access Methods
 
-  /** Return row object (0-based) */
+  /** 행 객체 반환 (0 기반) */
   row(r: number): ExcelRow {
     return this._rowMap.getOrCreate(r, new ExcelRow(this._zipCache, this._targetFileName, r));
   }
 
-  /** Return cell object (0-based row/column) */
+  /** 셀 객체 반환 (0 기반 행/열) */
   cell(r: number, c: number): ExcelCell {
     return this.row(r).cell(c);
   }
 
-  /** Return column object (0-based) */
+  /** 열 객체 반환 (0 기반) */
   col(c: number): ExcelCol {
     return this._colMap.getOrCreate(c, new ExcelCol(this._zipCache, this._targetFileName, c));
   }
@@ -68,7 +68,7 @@ export class ExcelWorksheet {
 
   //#region Copy Methods
 
-  /** Copy style from source row to target row */
+  /** 원본 행에서 대상 행으로 스타일 복사 */
   async copyRowStyle(srcR: number, targetR: number): Promise<void> {
     const range = await this.getRange();
 
@@ -77,7 +77,7 @@ export class ExcelWorksheet {
     }
   }
 
-  /** Copy style from source cell to target cell */
+  /** 원본 셀에서 대상 셀로 스타일 복사 */
   async copyCellStyle(srcAddr: ExcelAddressPoint, targetAddr: ExcelAddressPoint): Promise<void> {
     const wsData = await this._getWsData();
 
@@ -87,55 +87,68 @@ export class ExcelWorksheet {
     }
   }
 
-  /** Copy source row to target row (overwrite) */
+  /** 원본 행을 대상 행으로 복사 (덮어쓰기) */
   async copyRow(srcR: number, targetR: number): Promise<void> {
     const wsData = await this._getWsData();
     wsData.copyRow(srcR, targetR);
   }
 
-  /** Copy source cell to target cell */
+  /** 원본 셀을 대상 셀로 복사 */
   async copyCell(srcAddr: ExcelAddressPoint, targetAddr: ExcelAddressPoint): Promise<void> {
     const wsData = await this._getWsData();
     wsData.copyCell(srcAddr, targetAddr);
   }
 
   /**
-   * Insert-copy the source row at the target position.
-   * Existing rows at and below the target are shifted down by one.
-   * @param srcR Source row index to copy (0-based)
-   * @param targetR Target row index to insert at (0-based)
+   * 원본 행을 대상 위치에 삽입 복사한다.
+   * 대상 위치 이하의 기존 행은 한 칸 아래로 밀린다.
+   * @param srcR 복사할 원본 행 인덱스 (0 기반)
+   * @param targetR 삽입할 대상 행 인덱스 (0 기반)
    */
   async insertCopyRow(srcR: number, targetR: number): Promise<void> {
     const wsData = await this._getWsData();
     const range = wsData.range;
 
-    // Shift merge cells at or below targetR down by 1
+    // targetR 이하의 병합 셀을 1칸 아래로 이동
+    // 삽입 지점을 관통하는 다중행 병합은 자동으로 1행 확장됨
     wsData.shiftMergeCells(targetR, 1);
 
-    // When srcR >= targetR, adjust for the shifted position of srcR
+    // srcR >= targetR인 경우, srcR의 이동된 위치를 보정
     const adjustedSrcR = srcR >= targetR ? srcR + 1 : srcR;
 
-    // Shift existing rows down (from bottom to top to avoid overwriting)
-    // Use skipMerge: true because merge cells are already shifted above
+    // 기존 행을 아래로 이동 (덮어쓰기 방지를 위해 아래에서 위로)
+    // 병합 셀은 위에서 이미 이동했으므로 skipMerge: true 사용
     for (let r = range.e.r; r >= targetR; r--) {
       wsData.copyRow(r, r + 1, { skipMerge: true });
     }
 
-    // Copy source row to target position (includes merge handling)
-    wsData.copyRow(adjustedSrcR, targetR);
+    // 원본 행을 대상 위치에 복사 (병합은 skipMerge로 건너뜀)
+    wsData.copyRow(adjustedSrcR, targetR, { skipMerge: true });
+
+    // 원본 행의 단일행 병합만 대상 행에 복사
+    // (다중행 병합은 shiftMergeCells에서 이미 확장 처리됨)
+    const allMergeCells = wsData.getMergeCells();
+    const sourceMergeCells = allMergeCells.filter(
+      (mc) => mc.s.r === adjustedSrcR && mc.e.r === adjustedSrcR,
+    );
+    for (const mergeCell of sourceMergeCells) {
+      const newStartAddr = { r: targetR, c: mergeCell.s.c };
+      const newEndAddr = { r: targetR, c: mergeCell.e.c };
+      wsData.setMergeCells(newStartAddr, newEndAddr);
+    }
   }
 
   //#endregion
 
   //#region Range Methods
 
-  /** Return data range of the worksheet */
+  /** 워크시트의 데이터 범위 반환 */
   async getRange(): Promise<ExcelAddressRangePoint> {
     const xml = await this._getWsData();
     return xml.range;
   }
 
-  /** Return all cells as a 2D array */
+  /** 모든 셀을 2차원 배열로 반환 */
   async getCells(): Promise<ExcelCell[][]> {
     const xml = await this._getWsData();
     const range = xml.range;
@@ -153,10 +166,10 @@ export class ExcelWorksheet {
   //#region Data Methods
 
   /**
-   * Return worksheet data as a table (record array).
-   * @param opt.headerRowIndex Header row index (default: first row)
-   * @param opt.checkEndColIndex Column index to determine data end. Data ends when this column is empty.
-   * @param opt.usableHeaderNameFn Function to filter usable headers
+   * 워크시트 데이터를 테이블(레코드 배열)로 반환한다.
+   * @param opt.headerRowIndex 헤더 행 인덱스 (기본값: 첫 번째 행)
+   * @param opt.checkEndColIndex 데이터 끝을 판단할 열 인덱스. 이 열이 비어있으면 데이터가 끝난 것으로 판단한다.
+   * @param opt.usableHeaderNameFn 사용 가능한 헤더를 필터링하는 함수
    */
   async getDataTable(opt?: {
     headerRowIndex?: number;
@@ -174,6 +187,11 @@ export class ExcelWorksheet {
       const headerName = await this.cell(startRow, c).getValue();
       if (typeof headerName === "string") {
         if (opt?.usableHeaderNameFn == null || opt.usableHeaderNameFn(headerName)) {
+          if (headerMap.has(headerName)) {
+            throw new Error(
+              `중복된 헤더: "${headerName}" (열 ${headerMap.get(headerName)!}과 열 ${c})`,
+            );
+          }
           headerMap.set(headerName, c);
         }
       }
@@ -200,8 +218,8 @@ export class ExcelWorksheet {
   }
 
   /**
-   * Write 2D array data to the worksheet
-   * @param matrix 2D array data (row-major, index 0 is the first row)
+   * 2차원 배열 데이터를 워크시트에 쓰기
+   * @param matrix 2차원 배열 데이터 (행 우선, 인덱스 0이 첫 번째 행)
    */
   async setDataMatrix(matrix: ExcelValueType[][]): Promise<void> {
     for (let r = 0; r < matrix.length; r++) {
@@ -212,8 +230,8 @@ export class ExcelWorksheet {
   }
 
   /**
-   * Write record array to the worksheet
-   * @param records Record array. Headers are auto-generated in the first row, data follows in subsequent rows.
+   * 레코드 배열을 워크시트에 쓰기
+   * @param records 레코드 배열. 첫 번째 행에 헤더가 자동 생성되고, 이후 행에 데이터가 기록된다.
    */
   async setRecords(records: Record<string, ExcelValueType>[]): Promise<void> {
     const headers = records
@@ -236,7 +254,7 @@ export class ExcelWorksheet {
 
   //#region View Methods
 
-  /** Set worksheet zoom scale (percent) */
+  /** 워크시트 확대/축소 비율 설정 (퍼센트) */
   async setZoom(percent: number): Promise<void> {
     const wbXml = await this._getWbData();
     wbXml.initializeView();
@@ -245,7 +263,7 @@ export class ExcelWorksheet {
     wsXml.setZoom(percent);
   }
 
-  /** Set freeze panes for rows/columns */
+  /** 행/열 틀 고정 설정 */
   async freezeAt(point: { r?: number; c?: number }): Promise<void> {
     const wbXml = await this._getWbData();
     wbXml.initializeView();
@@ -259,11 +277,11 @@ export class ExcelWorksheet {
   //#region Image Methods
 
   /**
-   * Insert an image into the worksheet.
-   * @param opts.bytes Image binary data
-   * @param opts.ext Image extension (png, jpg, etc.)
-   * @param opts.from Image start position (0-based row/column index, rOff/cOff in EMU offset)
-   * @param opts.to Image end position (if omitted, inserted at from position with original size)
+   * 워크시트에 이미지를 삽입한다.
+   * @param opts.bytes 이미지 바이너리 데이터
+   * @param opts.ext 이미지 확장자 (png, jpg 등)
+   * @param opts.from 이미지 시작 위치 (0 기반 행/열 인덱스, rOff/cOff는 EMU 오프셋)
+   * @param opts.to 이미지 끝 위치 (생략 시 from 위치에 원본 크기로 삽입)
    */
   async addImage(opts: {
     bytes: Bytes;
@@ -273,10 +291,10 @@ export class ExcelWorksheet {
   }): Promise<void> {
     const mimeType = mime.getType(opts.ext);
     if (mimeType == null) {
-      throw new Error(`Cannot determine MIME type for extension '${opts.ext}'`);
+      throw new Error(`확장자 '${opts.ext}'에 대한 MIME 타입을 결정할 수 없습니다`);
     }
 
-    // 1. Determine media filename and save
+    // 1. 미디어 파일명 결정 및 저장
     let mediaIndex = 1;
     while ((await this._zipCache.get(`xl/media/image${mediaIndex}.${opts.ext}`)) !== undefined) {
       mediaIndex++;
@@ -284,16 +302,16 @@ export class ExcelWorksheet {
     const mediaPath = `xl/media/image${mediaIndex}.${opts.ext}`;
     this._zipCache.set(mediaPath, opts.bytes);
 
-    // 2. Update [Content_Types].xml
+    // 2. [Content_Types].xml 갱신
     const typeXml = (await this._zipCache.get("[Content_Types].xml")) as ExcelXmlContentType;
     typeXml.add(`/xl/media/image${mediaIndex}.${opts.ext}`, mimeType);
 
-    // 3. Check for existing drawing in worksheet
+    // 3. 워크시트의 기존 drawing 확인
     const wsXml = await this._getWsData();
     const sheetRelsPath = `xl/worksheets/_rels/${this._targetFileName}.rels`;
     let sheetRels = (await this._zipCache.get(sheetRelsPath)) as ExcelXmlRelationship | undefined;
 
-    // Find existing drawing
+    // 기존 drawing 찾기
     let drawingIndex: number | undefined;
     let drawingPath: string | undefined;
     let drawing: ExcelXmlDrawing | undefined;
@@ -306,7 +324,7 @@ export class ExcelWorksheet {
           "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
       );
       if (existingDrawingRel != null) {
-        // Extract index from existing drawing path
+        // 기존 drawing 경로에서 인덱스 추출
         const match = existingDrawingRel.$.Target.match(/drawing(\d+)\.xml$/);
         if (match != null) {
           drawingIndex = parseInt(match[1], 10);
@@ -319,7 +337,7 @@ export class ExcelWorksheet {
       }
     }
 
-    // 4. Create new drawing if none exists
+    // 4. 기존 drawing이 없으면 새로 생성
     if (drawingIndex == null || drawingPath == null || drawing == null) {
       drawingIndex = 1;
       while ((await this._zipCache.get(`xl/drawings/drawing${drawingIndex}.xml`)) !== undefined) {
@@ -328,10 +346,10 @@ export class ExcelWorksheet {
       drawingPath = `xl/drawings/drawing${drawingIndex}.xml`;
       drawing = new ExcelXmlDrawing();
 
-      // Add drawing type to [Content_Types].xml
+      // [Content_Types].xml에 drawing 타입 추가
       typeXml.add("/" + drawingPath, "application/vnd.openxmlformats-officedocument.drawing+xml");
 
-      // Add drawing to worksheet rels
+      // 워크시트 rels에 drawing 추가
       sheetRels = sheetRels ?? new ExcelXmlRelationship();
       const sheetRelNum = sheetRels.addAndGetId(
         `../drawings/drawing${drawingIndex}.xml`,
@@ -340,7 +358,7 @@ export class ExcelWorksheet {
       const drawingRelIdOnWorksheet = `rId${sheetRelNum}`;
       this._zipCache.set(sheetRelsPath, sheetRels);
 
-      // Add drawing to worksheet XML
+      // 워크시트 XML에 drawing 추가
       wsXml.data.worksheet.$["xmlns:r"] =
         wsXml.data.worksheet.$["xmlns:r"] ??
         "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
@@ -349,7 +367,7 @@ export class ExcelWorksheet {
       this._zipCache.set(`xl/worksheets/${this._targetFileName}`, wsXml);
     }
 
-    // 5. Prepare drawing rels (create if not exists)
+    // 5. drawing rels 준비 (없으면 생성)
     drawingRels = drawingRels ?? new ExcelXmlRelationship();
     const mediaFileName = mediaPath.slice(3);
     const drawingTarget = `../${mediaFileName}`;
@@ -359,7 +377,7 @@ export class ExcelWorksheet {
     );
     this._zipCache.set(`xl/drawings/_rels/drawing${drawingIndex}.xml.rels`, drawingRels);
 
-    // 6. Add image to drawing
+    // 6. drawing에 이미지 추가
     const blipRelId = `rId${relNum}`;
     drawing.addPicture({
       from: opts.from,

package/src/excel-wrapper.ts

@@ -13,18 +13,18 @@ import { ExcelWorkbook } from "./excel-workbook";
 import type { ExcelValueType } from "./types";
 
 /**
- * Zod schema-based Excel wrapper
+ * Zod 스키마 기반 Excel 래퍼
  *
- * Infers type information from schema to provide type-safe read/write
+ * 스키마에서 타입 정보를 추론하여 타입 안전한 읽기/쓰기를 제공한다
  */
 export class ExcelWrapper<TSchema extends z.ZodObject<z.ZodRawShape>> {
   /**
-   * @param _schema Zod schema (defines record structure, use `.describe()` to specify Excel header names)
+   * @param _schema Zod 스키마 (레코드 구조를 정의하며, `.describe()`로 Excel 헤더 이름을 지정)
    */
   constructor(private readonly _schema: TSchema) {}
 
   /**
-   * Read Excel file into record array
+   * Excel 파일을 레코드 배열로 읽기
    */
   async read(
     file: Bytes | Blob,
@@ -46,7 +46,7 @@ export class ExcelWrapper<TSchema extends z.ZodObject<z.ZodRawShape>> {
 
     if (rawData.length === 0) {
       throw new Error(
-        `[${wsName}] No data found in Excel file. (Expected headers: ${displayNames.join(", ")})`,
+        `[${wsName}] Excel 파일에서 데이터를 찾을 수 없습니다. (기대하는 헤더: ${displayNames.join(", ")})`,
       );
     }
 
@@ -73,13 +73,13 @@ export class ExcelWrapper<TSchema extends z.ZodObject<z.ZodRawShape>> {
         continue;
       }
 
-      // Validate with Zod schema
+      // Zod 스키마로 유효성 검사
       const parseResult = this._schema.safeParse(record);
       if (!parseResult.success) {
         const errors = parseResult.error.issues
           .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
           .join(", ");
-        throw new Error(`[${wsName}] Data validation failed: ${errors}`);
+        throw new Error(`[${wsName}] 데이터 유효성 검사 실패: ${errors}`);
       }
 
       result.push(parseResult.data);
@@ -89,11 +89,11 @@ export class ExcelWrapper<TSchema extends z.ZodObject<z.ZodRawShape>> {
   }
 
   /**
-   * Record array to Excel workbook
+   * 레코드 배열을 Excel 워크북으로 변환
    *
    * @remarks
-   * The caller is responsible for managing the returned workbook's resources.
-   * Use `await using` or call `close()` after use.
+   * 반환된 워크북의 리소스 관리는 호출자의 책임이다.
+   * `await using`을 사용하거나 사용 후 `close()`를 호출해야 한다.
    *
    * @example
    * ```typescript
@@ -107,53 +107,58 @@ export class ExcelWrapper<TSchema extends z.ZodObject<z.ZodRawShape>> {
     options?: { excludes?: (keyof z.infer<TSchema>)[] },
   ): Promise<ExcelWorkbook> {
     const wb = new ExcelWorkbook();
-    const ws = await wb.addWorksheet(wsName);
+    try {
+      const ws = await wb.addWorksheet(wsName);
 
-    const displayNameMap = this._getDisplayNameMap(options?.excludes as string[] | undefined);
-    const keys = Object.keys(displayNameMap) as (keyof z.infer<TSchema>)[];
-    const headers = keys.map((key) => displayNameMap[key as string]);
+      const displayNameMap = this._getDisplayNameMap(options?.excludes as string[] | undefined);
+      const keys = Object.keys(displayNameMap) as (keyof z.infer<TSchema>)[];
+      const headers = keys.map((key) => displayNameMap[key as string]);
 
-    // Write header row
-    for (let c = 0; c < headers.length; c++) {
-      await ws.cell(0, c).setValue(headers[c]);
-    }
+      // 헤더 행 쓰기
+      for (let c = 0; c < headers.length; c++) {
+        await ws.cell(0, c).setValue(headers[c]);
+      }
 
-    // Write data rows
-    for (let r = 0; r < records.length; r++) {
-      for (let c = 0; c < keys.length; c++) {
-        const key = keys[c];
-        const value = records[r][key] as ExcelValueType;
-        await ws.cell(r + 1, c).setValue(value);
+      // 데이터 행 쓰기
+      for (let r = 0; r < records.length; r++) {
+        for (let c = 0; c < keys.length; c++) {
+          const key = keys[c];
+          const value = records[r][key] as ExcelValueType;
+          await ws.cell(r + 1, c).setValue(value);
+        }
       }
-    }
 
-    // Apply border style
-    for (let r = 0; r < records.length + 1; r++) {
-      for (let c = 0; c < keys.length; c++) {
-        await ws.cell(r, c).setStyle({
-          border: ["left", "right", "top", "bottom"],
-        });
+      // 테두리 스타일 적용
+      for (let r = 0; r < records.length + 1; r++) {
+        for (let c = 0; c < keys.length; c++) {
+          await ws.cell(r, c).setStyle({
+            border: ["left", "right", "top", "bottom"],
+          });
+        }
       }
-    }
 
-    // Highlight required field headers (yellow)
-    const shape = this._schema.shape;
-    for (let c = 0; c < keys.length; c++) {
-      const fieldKey = keys[c] as string;
-      const fieldSchema = shape[fieldKey] as z.ZodType;
-
-      if (this._isRequired(fieldSchema) && !this._isBoolean(fieldSchema)) {
-        await ws.cell(0, c).setStyle({
-          background: "00FFFF00",
-        });
+      // 필수 필드 헤더 강조 (노란색)
+      const shape = this._schema.shape;
+      for (let c = 0; c < keys.length; c++) {
+        const fieldKey = keys[c] as string;
+        const fieldSchema = shape[fieldKey] as z.ZodType;
+
+        if (this._isRequired(fieldSchema) && !this._isBoolean(fieldSchema)) {
+          await ws.cell(0, c).setStyle({
+            background: "00FFFF00",
+          });
+        }
       }
-    }
 
-    // View settings
-    await ws.setZoom(85);
-    await ws.freezeAt({ r: 0 });
+      // 보기 설정
+      await ws.setZoom(85);
+      await ws.freezeAt({ r: 0 });
 
-    return wb;
+      return wb;
+    } catch (e) {
+      await wb.close();
+      throw e;
+    }
   }
 
   //#region Private Methods
@@ -198,7 +203,7 @@ export class ExcelWrapper<TSchema extends z.ZodObject<z.ZodRawShape>> {
       return Boolean(rawValue);
     }
 
-    // DateOnly, DateTime, Time are handled via instanceof
+    // DateOnly, DateTime, Time은 instanceof로 처리
     if (rawValue instanceof DateOnly || rawValue instanceof DateTime || rawValue instanceof Time) {
       return rawValue;
     }
@@ -218,7 +223,7 @@ export class ExcelWrapper<TSchema extends z.ZodObject<z.ZodRawShape>> {
 
   private _getDefaultForSchema(schema: z.ZodType): unknown {
     if (schema instanceof ZodDefault) {
-      // ZodDefault.parse(undefined) returns the default value
+      // ZodDefault.parse(undefined)는 기본값을 반환한다
       return schema.parse(undefined);
     }
 
@@ -226,7 +231,7 @@ export class ExcelWrapper<TSchema extends z.ZodObject<z.ZodRawShape>> {
       return undefined;
     }
 
-    // Default value for required boolean fields is false
+    // 필수 boolean 필드의 기본값은 false
     const innerSchema = this._unwrapSchema(schema);
     if (innerSchema instanceof ZodBoolean) {
       return false;

package/src/index.ts

@@ -1,13 +1,13 @@
-// Types and utilities
+// 타입 및 유틸리티
 export * from "./types";
 export * from "./utils/excel-utils";
 
-// Core classes
+// 핵심 클래스
 export * from "./excel-cell";
 export * from "./excel-row";
 export * from "./excel-col";
 export * from "./excel-worksheet";
 export * from "./excel-workbook";
 
-// Wrapper classes
+// 래퍼 클래스
 export * from "./excel-wrapper";

package/src/types.ts

@@ -134,16 +134,16 @@ export interface ExcelXmlWorksheetData {
 
 export interface ExcelRowData {
   $: {
-    r: string; // address (1~)
+    r: string; // 주소 (1~)
   };
   c?: ExcelCellData[];
 }
 
 export interface ExcelCellData {
   $: {
-    r: string; // address (A~)
-    s?: string; // styleId
-    t?: ExcelCellType; // type: s(sharedString)
+    r: string; // 주소 (A~)
+    s?: string; // 스타일 ID
+    t?: ExcelCellType; // 타입: s(sharedString)
   };
   v?: [string];
   f?: [string];
@@ -324,13 +324,13 @@ export type ExcelValueType = number | string | DateOnly | DateTime | Time | bool
 export type ExcelNumberFormat = "number" | "string" | "DateOnly" | "DateTime" | "Time";
 
 /**
- * Excel cell type
- * - s: shared string (SharedString)
+ * Excel 셀 타입
+ * - s: 공유 문자열 (SharedString)
  * - b: boolean
- * - str: formula result string
- * - n: number
- * - inlineStr: inline string (rich text)
- * - e: error
+ * - str: 수식 결과 문자열
+ * - n: 숫자
+ * - inlineStr: 인라인 문자열 (서식 있는 텍스트)
+ * - e: 에러
  */
 export type ExcelCellType = "s" | "b" | "str" | "n" | "inlineStr" | "e";
 
@@ -366,11 +366,11 @@ export type ExcelHorizontalAlign = "center" | "left" | "right";
 export type ExcelVerticalAlign = "center" | "top" | "bottom";
 
 /**
- * Cell style options
+ * 셀 스타일 옵션
  * @example
  * ```typescript
  * await cell.setStyle({
- *   background: "00FF0000",  // red
+ *   background: "00FF0000",  // 빨강
  *   border: ["left", "right", "top", "bottom"],
  *   horizontalAlign: "center",
  *   verticalAlign: "center",
@@ -379,15 +379,15 @@ export type ExcelVerticalAlign = "center" | "top" | "bottom";
  * ```
  */
 export interface ExcelStyleOptions {
-  /** Background color (ARGB format, e.g. "00FF0000") */
+  /** 배경색 (ARGB 형식, 예: "00FF0000") */
   background?: string;
-  /** Border positions */
+  /** 테두리 위치 */
   border?: ExcelBorderPosition[];
-  /** Horizontal alignment */
+  /** 가로 정렬 */
   horizontalAlign?: ExcelHorizontalAlign;
-  /** Vertical alignment */
+  /** 세로 정렬 */
   verticalAlign?: ExcelVerticalAlign;
-  /** Number format */
+  /** 숫자 형식 */
   numberFormat?: ExcelNumberFormat;
 }