@ohah/hwpjs 0.1.0-rc.1 → 0.1.0-rc.3

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 N-API for Rust
+Copyright (c) 2021 ohah <bookyoon173@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,87 +1,220 @@
-# `@napi-rs/package-template`
+# @ohah/hwpjs
 
-![https://github.com/napi-rs/package-template/actions](https://github.com/napi-rs/package-template/workflows/CI/badge.svg)
+HWP parser for Node.js, Web, and React Native
 
-> Template project for writing node packages with napi-rs.
+한글과컴퓨터의 한/글 문서 파일(.hwp)을 읽고 파싱하는 라이브러리입니다. Rust로 구현된 핵심 로직을 Node.js, Web, React Native 환경에서 사용할 수 있도록 제공합니다.
 
-# Usage
+## 설치
 
-1. Click **Use this template**.
-2. **Clone** your project.
-3. Run `yarn install` to install dependencies.
-4. Run `yarn napi rename -n [@your-scope/package-name] -b [binary-name]` command under the project folder to rename your package.
+```bash
+npm install @ohah/hwpjs
+# 또는
+yarn add @ohah/hwpjs
+# 또는
+pnpm add @ohah/hwpjs
+# 또는
+bun add @ohah/hwpjs
+```
+
+## 사용법
+
+### CLI (Command Line Interface)
 
-## Install this test package
+명령줄에서 직접 HWP 파일을 변환할 수 있습니다:
 
 ```bash
-yarn add @napi-rs/package-template
+# 전역 설치
+npm install -g @ohah/hwpjs
+
+# JSON 변환
+hwpjs to-json document.hwp -o output.json --pretty
+
+# Markdown 변환
+hwpjs to-markdown document.hwp -o output.md --include-images
+
+# 파일 정보 확인
+hwpjs info document.hwp
+
+# 이미지 추출
+hwpjs extract-images document.hwp -o ./images
+
+# 배치 변환
+hwpjs batch ./documents -o ./output --format json --recursive
 ```
 
-## Ability
+더 자세한 내용은 [CLI 가이드](https://ohah.github.io/hwpjs/guide/cli)를 참고하세요.
 
-### Build
+### Node.js
 
-After `yarn build/npm run build` command, you can see `package-template.[darwin|win32|linux].node` file in project root. This is the native addon built from [lib.rs](./src/lib.rs).
+```typescript
+import { readFileSync } from 'fs';
+import { toJson, toMarkdown, fileHeader } from '@ohah/hwpjs';
 
-### Test
+// HWP 파일 읽기
+const fileBuffer = readFileSync('./document.hwp');
 
-With [ava](https://github.com/avajs/ava), run `yarn test/npm run test` to testing native addon. You can also switch to another testing framework if you want.
+// JSON으로 변환
+const jsonString = toJson(fileBuffer);
+const document = JSON.parse(jsonString);
+console.log(document);
 
-### CI
+// Markdown으로 변환
+const { markdown, images } = toMarkdown(fileBuffer, {
+  image: 'blob', // 또는 'base64'
+  use_html: true,
+  include_version: true,
+  include_page_info: true,
+});
 
-With GitHub Actions, each commit and pull request will be built and tested automatically in [`node@20`, `@node22`] x [`macOS`, `Linux`, `Windows`] matrix. You will never be afraid of the native addon broken in these platforms.
+// FileHeader만 추출
+const headerString = fileHeader(fileBuffer);
+const header = JSON.parse(headerString);
+console.log(header);
+```
 
-### Release
+### Web (Browser)
 
-Release native package is very difficult in old days. Native packages may ask developers who use it to install `build toolchain` like `gcc/llvm`, `node-gyp` or something more.
+```typescript
+import { toJson, toMarkdown } from '@ohah/hwpjs';
 
-With `GitHub actions`, we can easily prebuild a `binary` for major platforms. And with `N-API`, we should never be afraid of **ABI Compatible**.
+// File input에서 HWP 파일 읽기
+const fileInput = document.querySelector('input[type="file"]');
+fileInput.addEventListener('change', async (e) => {
+  const file = e.target.files[0];
+  const arrayBuffer = await file.arrayBuffer();
+  const uint8Array = new Uint8Array(arrayBuffer);
 
-The other problem is how to deliver prebuild `binary` to users. Downloading it in `postinstall` script is a common way that most packages do it right now. The problem with this solution is it introduced many other packages to download binary that has not been used by `runtime codes`. The other problem is some users may not easily download the binary from `GitHub/CDN` if they are behind a private network (But in most cases, they have a private NPM mirror).
+  // JSON으로 변환
+  const jsonString = toJson(uint8Array);
+  const document = JSON.parse(jsonString);
 
-In this package, we choose a better way to solve this problem. We release different `npm packages` for different platforms. And add it to `optionalDependencies` before releasing the `Major` package to npm.
+  // Markdown으로 변환 (base64 이미지 포함)
+  const { markdown } = toMarkdown(uint8Array, {
+    image: 'base64',
+  });
 
-`NPM` will choose which native package should download from `registry` automatically. You can see [npm](./npm) dir for details. And you can also run `yarn add @napi-rs/package-template` to see how it works.
+  // 결과 표시
+  document.getElementById('output').innerHTML = markdown;
+});
+```
 
-## Develop requirements
+### React Native
 
-- Install the latest `Rust`
-- Install `Node.js@10+` which fully supported `Node-API`
-- Install `yarn@1.x`
+```typescript
+import { toJson, toMarkdown } from '@ohah/hwpjs';
+import * as FileSystem from 'expo-file-system';
 
-## Test in local
+// HWP 파일 읽기
+const fileUri = 'file:///path/to/document.hwp';
+const base64 = await FileSystem.readAsStringAsync(fileUri, {
+  encoding: FileSystem.EncodingType.Base64,
+});
+const uint8Array = Uint8Array.from(atob(base64), c => c.charCodeAt(0));
 
-- yarn
-- yarn build
-- yarn test
+// JSON으로 변환
+const jsonString = toJson(uint8Array);
+const document = JSON.parse(jsonString);
 
-And you will see:
+// Markdown으로 변환
+const { markdown, images } = toMarkdown(uint8Array, {
+  image: 'blob',
+});
+```
 
-```bash
-$ ava --verbose
+## API
 
-  ✔ sync function from native code
-  ✔ sleep function from native code (201ms)
-  ─
+### `toJson(data: Buffer | Uint8Array): string`
 
-  2 tests passed
-✨  Done in 1.12s.
+HWP 파일을 JSON 문자열로 변환합니다.
+
+**Parameters:**
+- `data`: HWP 파일의 바이트 배열 (Buffer 또는 Uint8Array)
+
+**Returns:**
+- JSON 문자열 (파싱된 HWP 문서)
+
+**Example:**
+```typescript
+const fileBuffer = readFileSync('./document.hwp');
+const jsonString = toJson(fileBuffer);
+const document = JSON.parse(jsonString);
 ```
 
-## Release package
+### `toMarkdown(data: Buffer | Uint8Array, options?: ToMarkdownOptions): ToMarkdownResult`
+
+HWP 파일을 Markdown 형식으로 변환합니다.
+
+**Parameters:**
+- `data`: HWP 파일의 바이트 배열 (Buffer 또는 Uint8Array)
+- `options`: 변환 옵션 (선택)
+  - `image`: 이미지 형식 (`'base64'` 또는 `'blob'`, 기본값: `'blob'`)
+  - `use_html`: HTML 태그 사용 여부 (기본값: `false`)
+  - `include_version`: 버전 정보 포함 여부 (기본값: `false`)
+  - `include_page_info`: 페이지 정보 포함 여부 (기본값: `false`)
+
+**Returns:**
+- `ToMarkdownResult` 객체:
+  - `markdown`: Markdown 문자열
+  - `images`: 이미지 데이터 배열 (blob 형식인 경우)
+
+**Example:**
+```typescript
+// Base64 이미지 포함
+const { markdown } = toMarkdown(fileBuffer, {
+  image: 'base64',
+  use_html: true,
+});
+
+// Blob 이미지 (별도 배열로 반환)
+const { markdown, images } = toMarkdown(fileBuffer, {
+  image: 'blob',
+});
+// images 배열에서 이미지 데이터 사용
+images.forEach(img => {
+  console.log(`Image ${img.id}: ${img.format}, ${img.data.length} bytes`);
+});
+```
 
-Ensure you have set your **NPM_TOKEN** in the `GitHub` project setting.
+### `fileHeader(data: Buffer | Uint8Array): string`
 
-In `Settings -> Secrets`, add **NPM_TOKEN** into it.
+HWP 파일의 FileHeader만 추출하여 JSON 문자열로 반환합니다.
 
-When you want to release the package:
+**Parameters:**
+- `data`: HWP 파일의 바이트 배열 (Buffer 또는 Uint8Array)
 
-```bash
-npm version [<newversion> | major | minor | patch | premajor | preminor | prepatch | prerelease [--preid=<prerelease-id>] | from-git]
+**Returns:**
+- JSON 문자열 (FileHeader 정보)
 
-git push
+**Example:**
+```typescript
+const fileBuffer = readFileSync('./document.hwp');
+const headerString = fileHeader(fileBuffer);
+const header = JSON.parse(headerString);
+console.log(header.version);
 ```
 
-GitHub actions will do the rest job for you.
+## 예제
+
+더 자세한 예제는 [예제 디렉토리](../../examples)를 참고하세요.
+
+- [Node.js 예제](../../examples/node)
+- [Web 예제](../../examples/web)
+- [React Native 예제](../../examples/react-native)
+
+## 지원 플랫폼
+
+### Node.js
+- Windows (x64, x86, arm64)
+- macOS (x64, arm64)
+- Linux (x64)
+
+### Web
+- WASM (WebAssembly)
+
+### React Native
+- iOS
+- Android
+
+## 라이선스
 
-> WARN: Don't run `npm publish` manually.
+MIT

package/android/src/main/jni/include/ffi.rs.h

@@ -1027,11 +1027,13 @@ private:
 
 ::rust::Box<::craby::hwpjs::bridging::Hwpjs> createHwpjs(::std::size_t id, ::rust::Str data_path) noexcept;
 
-::rust::String fileHeader(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<double> data);
+::rust::Vec<::std::uint8_t> createVecFromSlice(::rust::Slice<::std::uint8_t const> data) noexcept;
 
-::rust::String toJson(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<double> data);
+::rust::String fileHeader(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<::std::uint8_t> data);
 
-::craby::hwpjs::bridging::ToMarkdownResult toMarkdown(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<double> data, ::craby::hwpjs::bridging::ToMarkdownOptions options);
+::rust::String toJson(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<::std::uint8_t> data);
+
+::craby::hwpjs::bridging::ToMarkdownResult toMarkdown(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<::std::uint8_t> data, ::craby::hwpjs::bridging::ToMarkdownOptions options);
 } // namespace bridging
 } // namespace hwpjs
 } // namespace craby

package/android/src/main/jni/src/ffi.rs.cc

@@ -1102,11 +1102,13 @@ extern "C" {
 
 ::craby::hwpjs::bridging::Hwpjs *craby$hwpjs$bridging$cxxbridge1$190$create_hwpjs(::std::size_t id, ::rust::Str data_path) noexcept;
 
-::rust::repr::PtrLen craby$hwpjs$bridging$cxxbridge1$190$hwpjs_file_header(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<double> *data, ::rust::String *return$) noexcept;
+void craby$hwpjs$bridging$cxxbridge1$190$create_vec_from_slice(::rust::Slice<::std::uint8_t const> data, ::rust::Vec<::std::uint8_t> *return$) noexcept;
 
-::rust::repr::PtrLen craby$hwpjs$bridging$cxxbridge1$190$hwpjs_to_json(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<double> *data, ::rust::String *return$) noexcept;
+::rust::repr::PtrLen craby$hwpjs$bridging$cxxbridge1$190$hwpjs_file_header(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<::std::uint8_t> *data, ::rust::String *return$) noexcept;
 
-::rust::repr::PtrLen craby$hwpjs$bridging$cxxbridge1$190$hwpjs_to_markdown(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<double> *data, ::craby::hwpjs::bridging::ToMarkdownOptions *options, ::craby::hwpjs::bridging::ToMarkdownResult *return$) noexcept;
+::rust::repr::PtrLen craby$hwpjs$bridging$cxxbridge1$190$hwpjs_to_json(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<::std::uint8_t> *data, ::rust::String *return$) noexcept;
+
+::rust::repr::PtrLen craby$hwpjs$bridging$cxxbridge1$190$hwpjs_to_markdown(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<::std::uint8_t> *data, ::craby::hwpjs::bridging::ToMarkdownOptions *options, ::craby::hwpjs::bridging::ToMarkdownResult *return$) noexcept;
 } // extern "C"
 
 ::std::size_t Hwpjs::layout::size() noexcept {
@@ -1121,8 +1123,14 @@ extern "C" {
   return ::rust::Box<::craby::hwpjs::bridging::Hwpjs>::from_raw(craby$hwpjs$bridging$cxxbridge1$190$create_hwpjs(id, data_path));
 }
 
-::rust::String fileHeader(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<double> data) {
-  ::rust::ManuallyDrop<::rust::Vec<double>> data$(::std::move(data));
+::rust::Vec<::std::uint8_t> createVecFromSlice(::rust::Slice<::std::uint8_t const> data) noexcept {
+  ::rust::MaybeUninit<::rust::Vec<::std::uint8_t>> return$;
+  craby$hwpjs$bridging$cxxbridge1$190$create_vec_from_slice(data, &return$.value);
+  return ::std::move(return$.value);
+}
+
+::rust::String fileHeader(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<::std::uint8_t> data) {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> data$(::std::move(data));
   ::rust::MaybeUninit<::rust::String> return$;
   ::rust::repr::PtrLen error$ = craby$hwpjs$bridging$cxxbridge1$190$hwpjs_file_header(it_, &data$.value, &return$.value);
   if (error$.ptr) {
@@ -1131,8 +1139,8 @@ extern "C" {
   return ::std::move(return$.value);
 }
 
-::rust::String toJson(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<double> data) {
-  ::rust::ManuallyDrop<::rust::Vec<double>> data$(::std::move(data));
+::rust::String toJson(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<::std::uint8_t> data) {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> data$(::std::move(data));
   ::rust::MaybeUninit<::rust::String> return$;
   ::rust::repr::PtrLen error$ = craby$hwpjs$bridging$cxxbridge1$190$hwpjs_to_json(it_, &data$.value, &return$.value);
   if (error$.ptr) {
@@ -1141,8 +1149,8 @@ extern "C" {
   return ::std::move(return$.value);
 }
 
-::craby::hwpjs::bridging::ToMarkdownResult toMarkdown(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<double> data, ::craby::hwpjs::bridging::ToMarkdownOptions options) {
-  ::rust::ManuallyDrop<::rust::Vec<double>> data$(::std::move(data));
+::craby::hwpjs::bridging::ToMarkdownResult toMarkdown(::craby::hwpjs::bridging::Hwpjs &it_, ::rust::Vec<::std::uint8_t> data, ::craby::hwpjs::bridging::ToMarkdownOptions options) {
+  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> data$(::std::move(data));
   ::rust::ManuallyDrop<::craby::hwpjs::bridging::ToMarkdownOptions> options$(::std::move(options));
   ::rust::MaybeUninit<::craby::hwpjs::bridging::ToMarkdownResult> return$;
   ::rust::repr::PtrLen error$ = craby$hwpjs$bridging$cxxbridge1$190$hwpjs_to_markdown(it_, &data$.value, &options$.value, &return$.value);

package/bin/hwpjs.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/cli/index.js');

package/cpp/CxxHwpjsModule.cpp

@@ -60,7 +60,7 @@ jsi::Value CxxHwpjsModule::fileHeader(jsi::Runtime &rt,
       throw jsi::JSError(rt, "Expected 1 argument");
     }
 
-    auto arg0 = react::bridging::fromJs<rust::Vec<double>>(rt, args[0], callInvoker);
+    auto arg0 = react::bridging::fromJs<rust::Vec<uint8_t>>(rt, args[0], callInvoker);
     auto ret = craby::hwpjs::bridging::fileHeader(*it_, arg0);
 
     return react::bridging::toJs(rt, ret);
@@ -84,7 +84,7 @@ jsi::Value CxxHwpjsModule::toJson(jsi::Runtime &rt,
       throw jsi::JSError(rt, "Expected 1 argument");
     }
 
-    auto arg0 = react::bridging::fromJs<rust::Vec<double>>(rt, args[0], callInvoker);
+    auto arg0 = react::bridging::fromJs<rust::Vec<uint8_t>>(rt, args[0], callInvoker);
     auto ret = craby::hwpjs::bridging::toJson(*it_, arg0);
 
     return react::bridging::toJs(rt, ret);
@@ -108,7 +108,7 @@ jsi::Value CxxHwpjsModule::toMarkdown(jsi::Runtime &rt,
       throw jsi::JSError(rt, "Expected 2 arguments");
     }
 
-    auto arg0 = react::bridging::fromJs<rust::Vec<double>>(rt, args[0], callInvoker);
+    auto arg0 = react::bridging::fromJs<rust::Vec<uint8_t>>(rt, args[0], callInvoker);
     auto arg1 = react::bridging::fromJs<craby::hwpjs::bridging::ToMarkdownOptions>(rt, args[1], callInvoker);
     auto ret = craby::hwpjs::bridging::toMarkdown(*it_, arg0, arg1);
 

package/cpp/bridging-generated.hpp

@@ -4,12 +4,47 @@
 #include "cxx.h"
 #include "ffi.rs.h"
 #include <react/bridging/Bridging.h>
+#include <variant>
 
 using namespace facebook;
 
+namespace hwpjs {
+
+class RustVecBuffer : public jsi::MutableBuffer {
+public:
+  explicit RustVecBuffer(rust::Vec<uint8_t> vec)
+    : vec_(std::move(vec)) {}
+
+  ~RustVecBuffer() override = default;
+
+  size_t size() const override {
+    return vec_.size();
+  }
+
+  uint8_t* data() override {
+    return const_cast<uint8_t*>(vec_.data());
+  }
+
+private:
+  rust::Vec<uint8_t> vec_;
+};
+
+} // namespace hwpjs
+
 namespace facebook {
 namespace react {
 
+template <>
+struct Bridging<std::monostate> {
+  static std::monostate fromJs(jsi::Runtime& rt, const jsi::Value &value, std::shared_ptr<CallInvoker> callInvoker) {
+    return std::monostate{};
+  }
+
+  static jsi::Value toJs(jsi::Runtime& rt, const std::monostate& value) {
+    return jsi::Value::undefined();
+  }
+};
+
 template <>
 struct Bridging<rust::Str> {
   static rust::Str fromJs(jsi::Runtime& rt, const jsi::Value &value, std::shared_ptr<CallInvoker> callInvoker) {
@@ -34,6 +69,24 @@ struct Bridging<rust::String> {
   }
 };
 
+template <>
+struct Bridging<rust::Vec<uint8_t>> {
+  static rust::Vec<uint8_t> fromJs(jsi::Runtime& rt, const jsi::Value &value, std::shared_ptr<CallInvoker> callInvoker) {
+    auto arrayBuffer = value.asObject(rt).getArrayBuffer(rt);
+    uint8_t* data = arrayBuffer.data(rt);
+    size_t size = arrayBuffer.size(rt);
+    rust::Slice<const uint8_t> slice{data, size};
+    rust::Vec<uint8_t> vec = craby::hwpjs::bridging::createVecFromSlice(slice);
+
+    return vec;
+  }
+
+  static jsi::Value toJs(jsi::Runtime& rt, const rust::Vec<uint8_t>& vec) {
+    auto buffer = std::make_shared<hwpjs::RustVecBuffer>(std::move(vec));
+    return jsi::ArrayBuffer(rt, buffer);
+  }
+};
+
 template <typename T>
 struct Bridging<rust::Vec<T>> {
   static rust::Vec<T> fromJs(jsi::Runtime& rt, const jsi::Value &value, std::shared_ptr<CallInvoker> callInvoker) {

package/dist/cli/commands/batch.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchCommand = batchCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// CLI는 빌드된 NAPI 모듈을 사용합니다
+// @ts-ignore - 런타임에 dist/index.js에서 로드됨 (빌드 후 경로: ../../index)
+const { toJson, toMarkdown } = require('../../index');
+function batchCommand(program) {
+    program
+        .command('batch')
+        .description('Batch convert HWP files in a directory')
+        .argument('<input-dir>', 'Input directory containing HWP files')
+        .option('-o, --output-dir <dir>', 'Output directory (default: ./output)', './output')
+        .option('--format <format>', 'Output format (json or markdown)', 'json')
+        .option('-r, --recursive', 'Process subdirectories recursively')
+        .option('--pretty', 'Pretty print JSON (only for json format)')
+        .option('--include-images', 'Include images as base64 (only for markdown format)')
+        .action((inputDir, options) => {
+        try {
+            const outputDir = options.outputDir || './output';
+            const format = options.format || 'json';
+            // Create output directory
+            if (!require('fs').existsSync(outputDir)) {
+                (0, fs_1.mkdirSync)(outputDir, { recursive: true });
+            }
+            // Find all HWP files
+            const hwpFiles = [];
+            function findHwpFiles(dir, basePath = '') {
+                const entries = (0, fs_1.readdirSync)(dir);
+                for (const entry of entries) {
+                    const fullPath = (0, path_1.join)(dir, entry);
+                    const stat = (0, fs_1.statSync)(fullPath);
+                    if (stat.isDirectory() && options.recursive) {
+                        findHwpFiles(fullPath, (0, path_1.join)(basePath, entry));
+                    }
+                    else if (stat.isFile() && (0, path_1.extname)(entry).toLowerCase() === '.hwp') {
+                        hwpFiles.push(fullPath);
+                    }
+                }
+            }
+            findHwpFiles(inputDir);
+            if (hwpFiles.length === 0) {
+                console.log('No HWP files found in the specified directory');
+                return;
+            }
+            console.log(`Found ${hwpFiles.length} HWP file(s)`);
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            let successCount = 0;
+            let errorCount = 0;
+            // Process each file
+            for (const filePath of hwpFiles) {
+                try {
+                    const fileName = (0, path_1.basename)(filePath, '.hwp');
+                    const data = (0, fs_1.readFileSync)(filePath);
+                    let outputContent;
+                    let outputExt;
+                    if (format === 'json') {
+                        const jsonString = toJson(data);
+                        if (options.pretty) {
+                            const json = JSON.parse(jsonString);
+                            outputContent = JSON.stringify(json, null, 2);
+                        }
+                        else {
+                            outputContent = jsonString;
+                        }
+                        outputExt = 'json';
+                    }
+                    else {
+                        const result = toMarkdown(data, {
+                            image: options.includeImages ? 'base64' : 'blob',
+                        });
+                        outputContent = result.markdown;
+                        outputExt = 'md';
+                    }
+                    const outputPath = (0, path_1.join)(outputDir, `${fileName}.${outputExt}`);
+                    (0, fs_1.writeFileSync)(outputPath, outputContent, 'utf-8');
+                    console.log(`✓ ${filePath} → ${outputPath}`);
+                    successCount++;
+                }
+                catch (error) {
+                    console.error(`✗ ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+                    errorCount++;
+                }
+            }
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log(`✓ Success: ${successCount}`);
+            if (errorCount > 0) {
+                console.log(`✗ Errors: ${errorCount}`);
+            }
+        }
+        catch (error) {
+            console.error('Error:', error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/extract-images.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImagesCommand = extractImagesCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// CLI는 빌드된 NAPI 모듈을 사용합니다
+// @ts-ignore - 런타임에 dist/index.js에서 로드됨 (빌드 후 경로: ../../index)
+const { toMarkdown } = require('../../index');
+function extractImagesCommand(program) {
+    program
+        .command('extract-images')
+        .description('Extract images from HWP file')
+        .argument('<input>', 'Input HWP file path')
+        .option('-o, --output-dir <dir>', 'Output directory for images (default: ./images)', './images')
+        .option('--format <format>', 'Image format filter (jpg, png, bmp, or all)', 'all')
+        .action((input, options) => {
+        try {
+            // Read HWP file
+            const data = (0, fs_1.readFileSync)(input);
+            // Convert to Markdown with blob images
+            const result = toMarkdown(data, {
+                image: 'blob',
+            });
+            if (result.images.length === 0) {
+                console.log('No images found in HWP file');
+                return;
+            }
+            // Create output directory
+            const outputDir = options.outputDir || './images';
+            if (!(0, fs_1.existsSync)(outputDir)) {
+                (0, fs_1.mkdirSync)(outputDir, { recursive: true });
+            }
+            // Filter images by format if specified
+            const formatFilter = options.format?.toLowerCase();
+            const imagesToExtract = formatFilter === 'all'
+                ? result.images
+                : result.images.filter((img) => img.format.toLowerCase() === formatFilter);
+            if (imagesToExtract.length === 0) {
+                console.log(`No images found with format: ${formatFilter}`);
+                return;
+            }
+            // Extract images
+            let extractedCount = 0;
+            for (const image of imagesToExtract) {
+                const extension = image.format || 'jpg';
+                const filename = `${image.id}.${extension}`;
+                const filepath = (0, path_1.join)(outputDir, filename);
+                (0, fs_1.writeFileSync)(filepath, image.data);
+                extractedCount++;
+                console.log(`✓ Extracted: ${filepath} (${image.data.length} bytes)`);
+            }
+            console.log(`\n✓ Extracted ${extractedCount} image(s) to ${outputDir}`);
+        }
+        catch (error) {
+            console.error('Error:', error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+}