kordoc 1.7.1 → 1.7.2

package/README.md

@@ -1,127 +1,132 @@
 # kordoc
 
-**모두 파싱해버리겠다** — The Korean Document Platform.
+**모두 파싱해버리겠다.**
 
-[![npm version](https://img.shields.io/badge/npm-v1.7.0-cb3837.svg)](https://www.npmjs.com/package/kordoc)
+[![npm version](https://img.shields.io/badge/npm-v1.7.1-cb3837.svg)](https://www.npmjs.com/package/kordoc)
 [![license](https://img.shields.io/npm/l/kordoc.svg)](https://github.com/chrisryugj/kordoc/blob/main/LICENSE)
-[![node](https://img.shields.io/node/v/kordoc.svg)](https://nodejs.org)
 
-> *Parse, compare, extract, and generate Korean documents. HWP, HWPX, PDF — all of them.*
+> *대한민국에서 둘째가라면 서러울 문서지옥. 거기서 7년 버틴 공무원이 만들었습니다.*
 
-[한국어](./README-KR.md)
+HWP, HWPX, PDF — 관공서에서 쏟아지는 모든 문서를 파싱하고, 비교하고, 분석하고, 생성합니다.
 
-![kordoc demo](./demo.gif)
+[English](./README-EN.md)
+
+![kordoc 데모](./demo.gif)
 
 ---
 
-## What's New in v1.7.0
+## 💡 kordoc으로 무엇을 할 수 있나요?
 
-- **Image Extraction (HWP/HWPX)** — Binary image extraction from ZIP entries and HWP5 BinData streams. Rendered as `![image](...)` in markdown output.
-- **Partial Parsing (Graceful Degradation)** — Single page failures no longer abort the whole document. Failed pages emit `PARTIAL_PARSE` warnings and parsing continues.
-- **Progress Callbacks** — `onProgress` callback in `ParseOptions`. CLI shows `[3/15 pages]` progress. Batch mode shows `[2/10 files]`.
-- **File Path Input** — `parse("path/to/file.hwp")` string overload. Auto-reads file, detects format, returns result.
-- **PDF Header/Footer Filtering** — `removeHeaderFooter: true` option removes repeated text at page edges. Removed elements recorded in `ParseWarning`.
-- **Security Hardening** — ZIP bomb cumulative-size tracking across all file types, SSRF prevention on webhook URLs, XSS-safe hyperlink rendering (javascript: URLs stripped), null-byte path traversal detection, Levenshtein length guard (O(m×n) DoS prevention), 30s PDF load timeout.
-- **Bug Fixes** — HWPX generator separator logic, XML recursion depth limit (MAX_XML_DEPTH=200), PDF table row merge protection, CLI `--format` validation, variable shadowing in PDF parser.
-- **UX Improvements** — KV table false-positive reduction (time/URL/number patterns excluded), MCP `parse_metadata` uses 50MB limit with header-only format detection, Watch debounce increased to 1000ms with stable-size check.
+단순한 텍스트 추출을 넘어, **공문서 처리를 위한 모든 과정**을 자동화합니다.
 
-<details>
-<summary>v1.6.1 fixes</summary>
+*   **📄 어떤 문서든 마크다운으로**: `HWP`, `HWPX`, `PDF` 파일을 즉시 `Markdown`으로 변환합니다. AI(LLM)가 문서를 읽고 분석하기 가장 좋은 상태로 만들어줍니다.
+*   **📊 복잡한 표(Table) 완벽 재현**: 선이 없는 PDF나 복잡하게 병합된 HWP 표도 구조를 분석하여 정확한 마크다운 테이블로 복원합니다.
+*   **🔍 신구대조표 자동 생성**: 두 문서의 차이점을 분석하여 무엇이 바뀌었는지 한눈에 보여줍니다. (HWP와 HWPX 간의 비교도 가능!)
+*   **📝 마크다운을 다시 HWPX로**: AI가 작성한 내용을 다시 보고서 양식(`HWPX`)으로 되돌려줍니다. 이제 복사-붙여넣기 노가다에서 해방되세요.
+*   **🤖 AI 에이전트 연동 (MCP)**: `Claude`, `Cursor`와 같은 도구에서 직접 `kordoc`을 호출해 문서를 읽고 코딩할 수 있습니다.
+
+---
 
-- **HWP5 Table Cell Offset Fix** — Fixed critical 2-byte offset misalignment in LIST_HEADER parsing. Row address was incorrectly read as colSpan, causing 3-column tables to explode into 6+ columns with misaligned content. Tables now use colAddr/rowAddr-based direct placement for accurate cell positioning.
-- **HWP5 TAB Control Character Fix** — TAB (0x0009) inline control's 14-byte extension data was not skipped, producing garbage characters (`࣐Ā`) after every tab in the output. Fixed by adding the required 14-byte skip.
+## v1.7.1 변경사항
 
-</details>
+- **이미지 추출 (HWP/HWPX)** — ZIP 엔트리와 HWP5 BinData 스트림에서 바이너리 이미지 추출. 마크다운 `![image](...)` 형태로 출력.
+- **부분 파싱 (Graceful Degradation)** — 개별 페이지 실패가 전체 파싱을 중단하지 않음. 실패 페이지는 `PARTIAL_PARSE` 경고 기록 후 계속 진행.
+- **진행률 콜백** — `ParseOptions`에 `onProgress` 콜백 추가. CLI에서 `[3/15 pages]` 형태 표시. 배치 모드는 `[2/10 files]`.
+- **파일 경로 직접 입력** — `parse("path/to/file.hwp")` 문자열 오버로드. 파일 읽기 + 포맷 감지 자동.
+- **PDF 머리글/바닥글 필터링** — `removeHeaderFooter: true` 옵션으로 페이지 상하단 반복 텍스트 제거. 제거 항목은 `ParseWarning` 기록.
+- **보안 강화** — ZIP bomb 누적크기 추적 전체 파일 타입 적용, Webhook SSRF 방지, 하이퍼링크 XSS 방어(javascript: URL 제거), 널바이트 경로 탐색 감지, Levenshtein 길이 가드, PDF 30초 로딩 타임아웃.
+- **버그 수정** — HWPX generator separator 로직, XML 재귀 깊이 제한(MAX_XML_DEPTH=200), PDF 테이블 행 병합 보호, CLI `--format` 검증, PDF 변수 섀도잉.
+- **UX 개선** — KV 테이블 오탐 개선(시간/URL/숫자 패턴 제외), MCP `parse_metadata` 50MB 제한 + 헤더만 포맷 감지, Watch 디바운스 1000ms + 파일 크기 안정성 체크.
 
 <details>
-<summary>v1.6.0 features</summary>
+<summary>v1.6.1 수정사항</summary>
 
-- **Cluster-Based Table Detection (PDF)** — Detects borderless tables by analyzing text alignment patterns. Baseline grouping + X-coordinate clustering identifies 2+ column tables that line-based detection misses. Sort-and-split clustering for order-independent results.
-- **Korean Special Table Detection** — Automatically detects `구분/항목/종류`-style key-value patterns common in Korean government documents and converts them to structured 2-column tables.
-- **Korean Word-Break Recovery** — Improved merging of broken Korean words in PDF table cells. Handles character-level PDF rendering (micro-gaps between Hangul characters) and cell line-break artifacts up to 8 characters.
-- **Empty Table Filtering** — Tables with all-empty cells (from line detection of decorative borders) are now automatically removed.
+- **HWP5 테이블 셀 오프셋 수정** — LIST_HEADER 파싱 시 2바이트 오프셋 밀림으로 rowAddr를 colSpan으로 잘못 읽던 치명적 버그 수정. 3열 테이블이 6열로 뻥튀기되던 문제 해결. colAddr/rowAddr 기반 직접 배치로 병합 테이블 정확도 향상.
+- **HWP5 TAB 제어문자 수정** — TAB(0x0009) 인라인 컨트롤의 14바이트 확장 데이터 스킵 누락으로 `࣐Ā` 쓰레기 문자가 출력되던 버그 수정.
 
 </details>
 
 <details>
-<summary>v1.5.0 features</summary>
+<summary>v1.6.0 기능</summary>
 
-- **Line-Based Table Detection (PDF)** — Ported from OpenDataLoader. Extracts horizontal/vertical lines from PDF graphics commands, builds grid via intersection vertices, maps text to cells by bbox overlap. Proper colspan/rowspan detection. Falls back to heuristic for line-free PDFs.
-- **IRBlock v2** — 6 block types: `heading`, `paragraph`, `table`, `list`, `image`, `separator`. New fields: `bbox`, `style`, `pageNumber`, `level`, `href`, `footnoteText`.
-- **ParseResult v2** — `outline` (document structure) and `warnings` (skipped elements, hidden text) fields.
-- **PDF Enhancements** — XY-Cut reading order, heading detection (font-size ratio), hidden text filtering (prompt injection defense), bounding box on every block.
-- **HWP5 Enhancements** — CHAR_SHAPE parsing, style-based heading detection, warnings for skipped OLE/images.
-- **HWPX Enhancements** — Style parsing from header.xml, hyperlink/footnote extraction.
-- **List Detection** — Numbered paragraphs after tables auto-converted to ordered list blocks.
-- **MCP Server** — Now returns `outline` and `warnings` in parse_document responses.
+- **클러스터 기반 테이블 감지 (PDF)** — 선 없는 PDF에서 텍스트 정렬 패턴으로 테이블 구조 추론. baseline 그룹핑 + X좌표 클러스터링으로 2열 이상 테이블 감지. 선 기반 감지가 실패한 경우의 중간 계층 fallback.
+- **한국어 특수 테이블 감지** — `구분/항목/종류/기준` 등 한국 공문서 key-value 패턴을 자동으로 2열 테이블로 변환.
+- **한국어 어절 끊김 복원** — PDF 셀 내 한글 문자별 렌더링으로 인한 미세 갭 처리 개선. 셀 줄바꿈 병합 임계값 8자로 확장, 1글자 조사 자동 연결.
+- **빈 테이블 필터링** — 장식용 선에서 생긴 빈 테이블 자동 제거.
 
 </details>
 
 <details>
-<summary>v1.4.x features</summary>
-
-- **Document Compare** — Diff two documents at IR level. Cross-format (HWP vs HWPX) supported.
-- **Form Field Recognition** — Extract label-value pairs from government forms automatically.
-- **Structured Parsing** — Access `IRBlock[]` and `DocumentMetadata` directly, not just markdown.
-- **Page Range Parsing** — Parse only pages 1-3: `parse(buffer, { pages: "1-3" })`.
-- **Markdown to HWPX** — Reverse conversion. Generate valid HWPX files from markdown.
-- **OCR Integration** — Pluggable OCR for image-based PDFs (bring your own provider).
-- **Watch Mode** — `kordoc watch ./incoming --webhook https://...` for auto-conversion.
-- **7 MCP Tools** — parse_document, detect_format, parse_metadata, parse_pages, parse_table, compare_documents, parse_form.
-- **Error Codes** — Structured `code` field: `"ENCRYPTED"`, `"ZIP_BOMB"`, `"IMAGE_BASED_PDF"`, etc.
+<summary>v1.5.0 기능</summary>
 
-</details>
+- **선 기반 테이블 감지 (PDF)** — OpenDataLoader 핵심 알고리즘 포팅. PDF 그래픽 명령에서 수평/수직 선을 추출하고, 교차점으로 그리드 구성, bbox overlap으로 텍스트→셀 매핑. colspan/rowspan 자동 감지. 선 없는 PDF는 기존 휴리스틱 fallback.
+- **IRBlock v2** — 6가지 블록 타입: `heading`, `paragraph`, `table`, `list`, `image`, `separator`. 새 필드: `bbox`, `style`, `pageNumber`, `level`, `href`, `footnoteText`.
+- **ParseResult v2** — `outline` (문서 구조), `warnings` (스킵된 요소, 숨김 텍스트) 필드 추가.
+- **PDF 개선** — XY-Cut 읽기 순서, 폰트 크기 기반 헤딩 감지, hidden text 필터링 (프롬프트 인젝션 방어), 모든 블록에 바운딩 박스.
+- **HWP5 개선** — CHAR_SHAPE 파싱, 스타일 기반 헤딩 감지, OLE/이미지 스킵 경고.
+- **HWPX 개선** — header.xml 스타일 파싱, 하이퍼링크/각주 추출.
+- **리스트 감지** — 테이블 뒤 번호 문단을 ordered list 블록으로 자동 변환.
+- **MCP 서버** — parse_document 응답에 `outline`, `warnings` 포함.
 
----
-
-## Why kordoc?
+</details>
 
-South Korea's government runs on **HWP** — a proprietary word processor the rest of the world has never heard of. Every day, 243 local governments and thousands of public institutions produce mountains of `.hwp` files. Extracting text from them has always been a nightmare.
+<details>
+<summary>v1.4.x 기능</summary>
+
+- **문서 비교 (Diff)** — IR 레벨 블록 비교로 신구대조표 생성. HWP↔HWPX 크로스 포맷 지원.
+- **양식 인식** — 공문서 테이블에서 label-value 쌍 자동 추출. 성명, 소속, 전화번호 등.
+- **구조화 파싱** — `IRBlock[]`과 `DocumentMetadata`에 직접 접근. 마크다운 넘어선 데이터 활용.
+- **페이지 범위** — `parse(buffer, { pages: "1-3" })` — 필요한 페이지만 빠르게.
+- **Markdown → HWPX** — 역변환. AI가 생성한 내용을 바로 공문서로.
+- **OCR 연동** — 이미지 기반 PDF도 텍스트 추출 (Tesseract, Claude Vision 등 프로바이더 직접 제공).
+- **Watch 모드** — `kordoc watch ./수신함 -d ./변환결과 --webhook https://...`
+- **MCP 7개 도구** — parse_document, detect_format, parse_metadata, parse_pages, parse_table, compare_documents, parse_form
+- **에러 코드** — `"ENCRYPTED"`, `"ZIP_BOMB"`, `"IMAGE_BASED_PDF"` 등 구조화된 에러 핸들링
 
-**kordoc** was born from that document hell. Built by a Korean civil servant who spent **7 years** buried under HWP files. Battle-tested across 5 real government projects. If a Korean public servant wrote it, kordoc can parse it.
+</details>
 
 ---
 
-## Installation
+## 설치
 
 ```bash
 npm install kordoc
 
-# PDF support (optional)
+# PDF 파싱이 필요하면 (선택)
 npm install pdfjs-dist
 ```
 
-## Quick Start
+## 빠른 시작
 
-### Parse Any Document
+### 문서 파싱
 
 ```typescript
 import { parse } from "kordoc"
 import { readFileSync } from "fs"
 
-const buffer = readFileSync("document.hwpx")
+const buffer = readFileSync("사업계획서.hwpx")
 const result = await parse(buffer.buffer)
 
 if (result.success) {
-  console.log(result.markdown)       // Markdown text
-  console.log(result.blocks)         // IRBlock[] structured data
+  console.log(result.markdown)       // 마크다운 텍스트
+  console.log(result.blocks)         // IRBlock[] 구조화 데이터
   console.log(result.metadata)       // { title, author, createdAt, ... }
 }
 ```
 
-### Compare Two Documents
+### 문서 비교 (신구대조표)
 
 ```typescript
 import { compare } from "kordoc"
 
-const diff = await compare(bufferA, bufferB)
+const diff = await compare(구버전Buffer, 신버전Buffer)
 // diff.stats → { added: 3, removed: 1, modified: 5, unchanged: 42 }
-// diff.diffs → BlockDiff[] with cell-level table diffs
+// diff.diffs → BlockDiff[] (테이블은 셀 단위 diff 포함)
 ```
 
-Cross-format supported: compare HWP against HWPX of the same document.
+HWP vs HWPX 크로스 포맷 비교도 가능합니다.
 
-### Extract Form Fields
+### 양식 필드 추출
 
 ```typescript
 import { parse, extractFormFields } from "kordoc"
@@ -134,28 +139,28 @@ if (result.success) {
 }
 ```
 
-### Generate HWPX from Markdown
+### HWPX 생성 (역변환)
 
 ```typescript
 import { markdownToHwpx } from "kordoc"
 
-const hwpxBuffer = await markdownToHwpx("# Title\n\nParagraph text\n\n| A | B |\n| --- | --- |\n| 1 | 2 |")
-writeFileSync("output.hwpx", Buffer.from(hwpxBuffer))
+const hwpxBuffer = await markdownToHwpx("# 제목\n\n본문 텍스트\n\n| 이름 | 직급 |\n| --- | --- |\n| 홍길동 | 과장 |")
+writeFileSync("출력.hwpx", Buffer.from(hwpxBuffer))
 ```
 
-### Parse Specific Pages
+### 페이지 범위 지정
 
 ```typescript
-const result = await parse(buffer, { pages: "1-3" })     // pages 1-3 only
-const result = await parse(buffer, { pages: [1, 5, 10] }) // specific pages
+const result = await parse(buffer, { pages: "1-3" })      // 1~3 페이지만
+const result = await parse(buffer, { pages: [1, 5, 10] })  // 특정 페이지
 ```
 
-### OCR for Image-Based PDFs
+### OCR (이미지 PDF)
 
 ```typescript
 const result = await parse(buffer, {
   ocr: async (pageImage, pageNumber, mimeType) => {
-    return await myOcrService.recognize(pageImage) // Tesseract, Claude Vision, etc.
+    return await myOcrService.recognize(pageImage)
   }
 })
 ```
@@ -163,16 +168,16 @@ const result = await parse(buffer, {
 ## CLI
 
 ```bash
-npx kordoc document.hwpx                          # stdout
-npx kordoc document.hwp -o output.md              # save to file
-npx kordoc *.pdf -d ./converted/                  # batch convert
-npx kordoc report.hwpx --format json              # JSON with blocks + metadata
-npx kordoc report.hwpx --pages 1-3                # page range
-npx kordoc watch ./incoming -d ./output            # watch mode
-npx kordoc watch ./docs --webhook https://api/hook # webhook notification
+npx kordoc 사업계획서.hwpx                          # 터미널 출력
+npx kordoc 보고서.hwp -o 보고서.md                  # 파일 저장
+npx kordoc *.pdf -d ./변환결과/                     # 일괄 변환
+npx kordoc 검토서.hwpx --format json               # JSON (blocks + metadata 포함)
+npx kordoc 보고서.hwpx --pages 1-3                  # 페이지 범위
+npx kordoc watch ./수신함 -d ./변환결과              # 폴더 감시 모드
+npx kordoc watch ./문서 --webhook https://api/hook  # 웹훅 알림
 ```
 
-## MCP Server (Claude / Cursor / Windsurf)
+## MCP 서버 (Claude / Cursor / Windsurf)
 
 ```json
 {
@@ -185,46 +190,45 @@ npx kordoc watch ./docs --webhook https://api/hook # webhook notification
 }
 ```
 
-**7 Tools:**
+**7개 도구:**
 
-| Tool | Description |
-|------|-------------|
-| `parse_document` | Parse HWP/HWPX/PDF → Markdown with metadata |
-| `detect_format` | Detect file format via magic bytes |
-| `parse_metadata` | Extract metadata only (fast, no full parse) |
-| `parse_pages` | Parse specific page range |
-| `parse_table` | Extract Nth table from document |
-| `compare_documents` | Diff two documents (cross-format) |
-| `parse_form` | Extract form fields as structured JSON |
+| 도구 | 설명 |
+|------|------|
+| `parse_document` | HWP/HWPX/PDF → 마크다운 (메타데이터 포함) |
+| `detect_format` | 매직 바이트로 포맷 감지 |
+| `parse_metadata` | 메타데이터만 빠르게 추출 |
+| `parse_pages` | 특정 페이지 범위만 파싱 |
+| `parse_table` | N번째 테이블만 추출 |
+| `compare_documents` | 두 문서 비교 (크로스 포맷) |
+| `parse_form` | 양식 필드를 JSON으로 추출 |
 
-## API Reference
+## API
 
-### Core
+### 핵심 함수
 
-| Function | Description |
-|----------|-------------|
-| `parse(buffer, options?)` | Auto-detect format, parse to Markdown + IRBlock[] |
-| `parseHwpx(buffer, options?)` | HWPX only |
-| `parseHwp(buffer, options?)` | HWP 5.x only |
-| `parsePdf(buffer, options?)` | PDF only |
-| `detectFormat(buffer)` | Returns `"hwpx" \| "hwp" \| "pdf" \| "unknown"` |
+| 함수 | 설명 |
+|------|------|
+| `parse(buffer, options?)` | 포맷 자동 감지 → Markdown + IRBlock[] |
+| `parseHwpx(buffer, options?)` | HWPX 전용 |
+| `parseHwp(buffer, options?)` | HWP 5.x 전용 |
+| `parsePdf(buffer, options?)` | PDF 전용 |
+| `detectFormat(buffer)` | `"hwpx" \| "hwp" \| "pdf" \| "unknown"` |
 
-### Advanced
+### 고급 함수
 
-| Function | Description |
-|----------|-------------|
-| `compare(bufferA, bufferB, options?)` | Document diff at IR level |
-| `extractFormFields(blocks)` | Form field recognition from IRBlock[] |
-| `markdownToHwpx(markdown)` | Markdown → HWPX reverse conversion |
-| `blocksToMarkdown(blocks)` | IRBlock[] → Markdown string |
+| 함수 | 설명 |
+|------|------|
+| `compare(bufferA, bufferB, options?)` | IR 레벨 문서 비교 |
+| `extractFormFields(blocks)` | IRBlock[]에서 양식 필드 인식 |
+| `markdownToHwpx(markdown)` | Markdown → HWPX 역변환 |
+| `blocksToMarkdown(blocks)` | IRBlock[] → Markdown 문자열 |
 
-### Types
+### 타입
 
 ```typescript
 import type {
   ParseResult, ParseSuccess, ParseFailure, FileType,
-  IRBlock, IRBlockType, IRTable, IRCell, CellContext,
-  BoundingBox, InlineStyle, OutlineItem, ParseWarning, WarningCode,
+  IRBlock, IRTable, IRCell, CellContext,
   DocumentMetadata, ParseOptions, ErrorCode,
   DiffResult, BlockDiff, CellDiff, DiffChangeType,
   FormField, FormResult,
@@ -232,22 +236,23 @@ import type {
 } from "kordoc"
 ```
 
-## Supported Formats
+## 지원 포맷
 
-| Format | Engine | Features |
-|--------|--------|----------|
-| **HWPX** (한컴 2020+) | ZIP + XML DOM | Manifest, nested tables, merged cells, broken ZIP recovery |
-| **HWP 5.x** (한컴 Legacy) | OLE2 + CFB | 21 control chars, zlib decompression, DRM detection, colAddr-based table cell placement |
-| **PDF** | pdfjs-dist | Line-based table detection, XY-Cut reading order, heading detection, hidden text filter, OCR |
+| 포맷 | 엔진 | 특징 |
+|------|------|------|
+| **HWPX** (한컴 2020+) | ZIP + XML DOM | 매니페스트, 중첩 테이블, 병합 셀, 손상 ZIP 복구 |
+| **HWP 5.x** (한컴 레거시) | OLE2 + CFB | 21종 제어문자, zlib 압축 해제, DRM 감지, colAddr 기반 셀 배치 |
+| **PDF** | pdfjs-dist | 라인 그룹핑, 테이블 감지, 이미지 PDF + OCR |
 
-## Security
+## 보안
 
-Production-grade hardening: ZIP bomb protection, XXE/Billion Laughs prevention, decompression bomb guard, path traversal guard, MCP error sanitization, file size limits (500MB). See [SECURITY.md](./SECURITY.md) for details.
+프로덕션급 보안 강화: ZIP bomb 방지, XXE/Billion Laughs 방지, 압축 폭탄 방지, 경로 순회 차단, MCP 에러 정제, 파일 크기 제한(500MB). 자세한 내용은 [SECURITY.md](./SECURITY.md) 참조.
 
-## Credits
+## 만든 사람
 
-Production-tested across 5 Korean government projects: school curriculum plans, facility inspection reports, legal document annexes, municipal newsletters, and public data extraction tools. Thousands of real government documents parsed.
+대한민국 지방공무원. 광진구청에서 7년간 HWP 파일과 싸우다가 이걸 만들었습니다.
+5개 공공 프로젝트에서 수천 건의 실제 관공서 문서를 파싱하며 검증했습니다.
 
-## License
+## 라이선스
 
 [MIT](./LICENSE)

package/dist/{chunk-VOMMXHNQ.js → chunk-NJ3R7LNR.js}

@@ -196,7 +196,7 @@ function tableToMarkdown(table) {
 }
 
 // src/utils.ts
-var VERSION = true ? "1.7.1" : "0.0.0-dev";
+var VERSION = true ? "1.7.2" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -1551,6 +1551,20 @@ function extractLines(fnArray, argsArray) {
   let currentPath = [];
   let pathStartX = 0, pathStartY = 0;
   let curX = 0, curY = 0;
+  function pushRectangle(path, rx, ry, rw, rh) {
+    if (Math.abs(rh) < ORIENTATION_TOL * 2) {
+      path.push({ x1: rx, y1: ry + rh / 2, x2: rx + rw, y2: ry + rh / 2 });
+    } else if (Math.abs(rw) < ORIENTATION_TOL * 2) {
+      path.push({ x1: rx + rw / 2, y1: ry, x2: rx + rw / 2, y2: ry + rh });
+    } else {
+      path.push(
+        { x1: rx, y1: ry, x2: rx + rw, y2: ry },
+        { x1: rx + rw, y1: ry, x2: rx + rw, y2: ry + rh },
+        { x1: rx + rw, y1: ry + rh, x2: rx, y2: ry + rh },
+        { x1: rx, y1: ry + rh, x2: rx, y2: ry }
+      );
+    }
+  }
   function flushPath(isStroke) {
     if (!isStroke) {
       currentPath = [];
@@ -1569,49 +1583,78 @@ function extractLines(fnArray, argsArray) {
         lineWidth = args[0] || 1;
         break;
       case OPS.constructPath: {
-        const subOps = args[0];
-        const coords = args[1];
-        let ci = 0;
-        for (const subOp of subOps) {
-          if (subOp === OPS.moveTo) {
-            curX = coords[ci++];
-            curY = coords[ci++];
-            pathStartX = curX;
-            pathStartY = curY;
-          } else if (subOp === OPS.lineTo) {
-            const x2 = coords[ci++], y2 = coords[ci++];
-            currentPath.push({ x1: curX, y1: curY, x2, y2 });
-            curX = x2;
-            curY = y2;
-          } else if (subOp === OPS.rectangle) {
-            const rx = coords[ci++], ry = coords[ci++];
-            const rw = coords[ci++], rh = coords[ci++];
-            if (Math.abs(rh) < ORIENTATION_TOL * 2) {
-              currentPath.push({ x1: rx, y1: ry + rh / 2, x2: rx + rw, y2: ry + rh / 2 });
-            } else if (Math.abs(rw) < ORIENTATION_TOL * 2) {
-              currentPath.push({ x1: rx + rw / 2, y1: ry, x2: rx + rw / 2, y2: ry + rh });
-            } else {
-              currentPath.push(
-                { x1: rx, y1: ry, x2: rx + rw, y2: ry },
-                // bottom
-                { x1: rx + rw, y1: ry, x2: rx + rw, y2: ry + rh },
-                // right
-                { x1: rx + rw, y1: ry + rh, x2: rx, y2: ry + rh },
-                // top
-                { x1: rx, y1: ry + rh, x2: rx, y2: ry }
-                // left
-              );
+        const arg0 = args[0];
+        if (Array.isArray(arg0)) {
+          const subOps = arg0;
+          const coords = args[1];
+          let ci = 0;
+          for (const subOp of subOps) {
+            if (subOp === OPS.moveTo) {
+              curX = coords[ci++];
+              curY = coords[ci++];
+              pathStartX = curX;
+              pathStartY = curY;
+            } else if (subOp === OPS.lineTo) {
+              const x2 = coords[ci++], y2 = coords[ci++];
+              currentPath.push({ x1: curX, y1: curY, x2, y2 });
+              curX = x2;
+              curY = y2;
+            } else if (subOp === OPS.rectangle) {
+              const rx = coords[ci++], ry = coords[ci++];
+              const rw = coords[ci++], rh = coords[ci++];
+              pushRectangle(currentPath, rx, ry, rw, rh);
+            } else if (subOp === OPS.closePath) {
+              if (curX !== pathStartX || curY !== pathStartY) {
+                currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
+              }
+              curX = pathStartX;
+              curY = pathStartY;
+            } else if (subOp === OPS.curveTo) {
+              ci += 6;
+            } else if (subOp === OPS.curveTo2 || subOp === OPS.curveTo3) {
+              ci += 4;
             }
-          } else if (subOp === OPS.closePath) {
-            if (curX !== pathStartX || curY !== pathStartY) {
-              currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
+          }
+        } else {
+          const afterOp = arg0;
+          const dataArr = args[1];
+          const pathData = dataArr?.[0];
+          if (pathData && typeof pathData === "object") {
+            const len = Object.keys(pathData).length;
+            let di = 0;
+            while (di < len) {
+              const drawOp = pathData[di++];
+              if (drawOp === 0 /* moveTo */) {
+                curX = pathData[di++];
+                curY = pathData[di++];
+                pathStartX = curX;
+                pathStartY = curY;
+              } else if (drawOp === 1 /* lineTo */) {
+                const x2 = pathData[di++], y2 = pathData[di++];
+                currentPath.push({ x1: curX, y1: curY, x2, y2 });
+                curX = x2;
+                curY = y2;
+              } else if (drawOp === 2 /* curveTo */) {
+                di += 6;
+              } else if (drawOp === 3 /* quadraticCurveTo */) {
+                di += 4;
+              } else if (drawOp === 4 /* closePath */) {
+                if (curX !== pathStartX || curY !== pathStartY) {
+                  currentPath.push({ x1: curX, y1: curY, x2: pathStartX, y2: pathStartY });
+                }
+                curX = pathStartX;
+                curY = pathStartY;
+              } else {
+                break;
+              }
             }
-            curX = pathStartX;
-            curY = pathStartY;
-          } else if (subOp === OPS.curveTo) {
-            ci += 6;
-          } else if (subOp === OPS.curveTo2 || subOp === OPS.curveTo3) {
-            ci += 4;
+          }
+          if (afterOp === OPS.stroke || afterOp === OPS.closeStroke) {
+            flushPath(true);
+          } else if (afterOp === OPS.fill || afterOp === OPS.eoFill || afterOp === OPS.fillStroke || afterOp === OPS.eoFillStroke || afterOp === OPS.closeFillStroke || afterOp === OPS.closeEOFillStroke) {
+            flushPath(true);
+          } else if (afterOp === OPS.endPath) {
+            flushPath(false);
           }
         }
         break;
@@ -3328,4 +3371,4 @@ export {
   extractFormFields,
   parse
 };
-//# sourceMappingURL=chunk-VOMMXHNQ.js.map
+//# sourceMappingURL=chunk-NJ3R7LNR.js.map