nconv-cli 1.0.0

package/.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(tree:*)",
+      "Bash(npm install)",
+      "Bash(chmod:*)",
+      "Bash(npm run build:*)",
+      "Bash(npm link:*)",
+      "Bash(notion-convertor:*)"
+    ]
+  }
+}

package/.env.example

@@ -0,0 +1,4 @@
+# Notion Cookies - copy these from your browser's developer tools
+# Go to notion.so, log in, and find these in the Application > Cookies section.
+TOKEN_V2=your_token_v2_here
+FILE_TOKEN=your_file_token_here

package/README.en.md

@@ -0,0 +1,200 @@
+<p align="right">
+  <a href="./README.md">한국어</a>
+</p>
+
+# nconv-cli (Notion Convertor CLI)
+
+> A CLI tool that converts Notion pages into blog-ready Markdown  
+> (with automatic image extraction and path normalization)
+
+nconv-cli converts public Notion pages into Markdown  
+and extracts images into local files, organizing everything  
+in a blog-friendly directory structure.
+
+## Features
+
+- 🚀 Convert public Notion pages into blog-ready Markdown
+- 🖼️ Automatically download images and rewrite them as relative paths
+- 📁 Output organized by post-level directory structure
+- 🎨 Simple and intuitive CLI interface
+
+## Problems with Existing Notion → Markdown Workflows
+
+When moving content written in Notion to a blog,  
+simple copy & paste or the built-in Markdown export often causes issues.
+
+- **Copy & Paste**
+  - Text is converted into Markdown-like syntax
+  - Images remain linked to Notion CDN URLs
+  - Image access frequently breaks with `Access Denied` errors
+
+- **Notion Markdown Export**
+  - Requires manual download and extraction of exported files
+  - Difficult to organize content by individual posts
+
+As a result, publishing to a blog usually involves  
+manually downloading images, renaming files, fixing paths,  
+and reorganizing directory structures.
+
+| Method | Image Handling | Blog Usability |
+|------|---------------|----------------|
+| Copy & Paste | ❌ Dependent on Notion CDN | ❌ Broken images |
+| Notion Export | ⚠️ Manual organization required | ⚠️ Inconvenient |
+| **nconv-cli** | ✅ Local image extraction | ✅ Ready to publish |
+
+## Recommended For
+
+- Developers who write in Notion and publish Markdown posts to  
+  Velog, Tistory, GitHub Pages, Hugo, or similar platforms
+- Anyone who has experienced broken images due to Notion CDN issues
+- Users looking to migrate Notion content into tools like Obsidian
+
+## Environment
+
+- **Node.js**: v20 or higher (npm v10 or higher)
+- **TypeScript**: v5 or higher
+
+## Installation
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Install CLI locally
+npm link
+````
+
+## Configuration
+
+Set your Notion authentication tokens in the `.env` file.
+
+```bash
+# Create .env file
+cp .env.example .env
+```
+
+Edit `.env` and set the following values:
+
+```
+TOKEN_V2=your_token_v2_here
+FILE_TOKEN=your_file_token_here
+```
+
+### How to Find Notion Tokens
+
+1. Log in to [notion.so](https://notion.so)
+2. Open browser developer tools (F12)
+3. Application > Cookies > notion.so
+4. Copy `token_v2` → paste into `.env` as `TOKEN_V2`
+5. Copy `file_token` → paste into `.env` as `FILE_TOKEN`
+
+## Usage
+
+### Basic Usage
+
+```bash
+nconv md <notion-url>
+```
+
+### Examples
+
+```bash
+# Default output (saved to ./output)
+nconv md "https://notion.so/My-Page-abc123"
+
+# Specify output directory
+nconv md "https://notion.so/My-Page-abc123" -o ./blog-posts
+
+# Custom filename
+nconv md "https://notion.so/My-Page-abc123" -f "my-article"
+
+# Verbose logging
+nconv md "https://notion.so/My-Page-abc123" -v
+
+# All options
+nconv md "https://notion.so/My-Page-abc123" -o ./blog -i assets -f "article-1" -v
+```
+
+## Options
+
+| Option              | Short | Description                                 | Default            |
+| ------------------- | ----- | ------------------------------------------- | ------------------ |
+| `--output <dir>`    | `-o`  | Output directory                            | `./output`         |
+| `--image-dir <dir>` | `-i`  | Image directory (relative to output)        | `images`           |
+| `--filename <name>` | `-f`  | Output filename (with or without extension) | Extracted from URL |
+| `--verbose`         | `-v`  | Enable verbose logging                      | `false`            |
+
+## Output Structure
+
+```text
+output/
+├── my-article-folder/
+│   ├── my-article.md
+│   └── images/
+│       ├── abc12345.png
+│       ├── def67890.jpg
+│       └── ...
+```
+
+Image paths inside the Markdown file are converted to relative paths:
+
+```md
+![image](./images/abc12345.png)
+```
+
+## Libraries
+
+### Main Libraries
+
+* **notion-exporter**: Export Notion pages to Markdown
+* **commander**: CLI command definition and parsing
+* **axios**: HTTP client (image downloads)
+* **dotenv**: Environment variable management
+* **chalk**: Terminal output styling
+* **ora**: Terminal spinner for progress display
+* **slugify**: Convert strings to URL-friendly slugs
+* **uuid**: Generate unique IDs
+
+### Open Source Licenses
+
+* **nconv-cli**: [ISC License](LICENSE)
+* This project uses multiple open source libraries,
+  each distributed under its respective license.
+
+## Development
+
+```bash
+# Development mode (watch files)
+npm run dev
+
+# Build
+npm run build
+
+# Local testing
+npm link
+nconv md "https://notion.so/test-page"
+```
+
+## Project Structure
+
+```text
+nconv/
+├── src/
+│   ├── index.ts
+│   ├── config.ts
+│   ├── commands/
+│   │   └── md.ts
+│   ├── core/
+│   │   ├── exporter.ts
+│   │   └── image-processor.ts
+│   └── utils/
+│       ├── file.ts
+│       └── logger.ts
+├── bin/
+│   └── nconv.js
+├── package.json
+├── tsconfig.json
+└── tsup.config.ts

package/README.md

@@ -0,0 +1,196 @@
+<p align="right">
+  <a href="./README.en.md">English</a>
+</p>
+
+# nconv-cli (Notion Convertor CLI)
+
+> Notion 글을 블로그에 바로 올릴 수 있는 마크다운으로 변환하는 CLI  
+> (이미지 자동 추출 및 경로 정리 포함)
+
+Notion 퍼블릭 페이지를 마크다운으로 변환하고  
+이미지 파일을 로컬로 추출해 블로그 친화적인 구조로 정리해주는 CLI 도구입니다.
+
+## 특징
+
+- 🚀 Notion 퍼블릭 페이지를 블로그용 마크다운으로 바로 변환
+- 🖼️ 이미지 파일을 로컬로 자동 다운로드 및 상대경로로 변환
+- 📁 게시글 단위로 정리된 출력 디렉토리 구조
+- 🎨 간단한 CLI 인터페이스
+
+
+
+## 기존 Notion -> Markdown 변환의 문제점
+
+Notion에서 작성한 글을 블로그에 옮길 때,
+단순한 복사/붙여넣기나 기본 Markdown export는 포스팅에 불편함이 있습니다.
+
+* 복사 & 붙여넣기 방식의 문제점
+  * 마크다운 식으로 텍스트는 변환되지만,
+  * 이미지는 Notion CDN URL로 유지되며
+  * Access Denied 로 이미지 접근이 깨지는 경우가 많습니다
+
+* Notion Markdown Export 방식의 문제점
+  * 직접 다운받아서 수동으로 저장 후 압축을 해제해야하며,
+  * 게시글 단위로 정리하기 어렵습니다
+
+결과적으로 블로그에 게시하려면 이미지 개별 다운로드,
+파일명 및 경로 수정, 폴더 구조 재정리가 필요합니다.
+
+| 방식 | 이미지 관리 | 블로그 사용성 |
+|------|------------|---------------|
+| 복사 & 붙여넣기 | ❌ Notion CDN 의존 | ❌ 이미지 깨짐 |
+| Notion Export | ⚠️ 수동 정리 필요 | ⚠️ 번거로움 |
+| **nconv-cli** | ✅ 로컬 자동 추출 | ✅ 즉시 사용 가능 |
+
+## 이런 분들에게 추천합니다
+
+- Notion으로 글을 쓰고, Velog / Tistory / GitHub Pages / Hugo 등의 플랫폼에 마크다운으로 포스팅을 하시는 분
+- Notion 이미지 CDN 문제로 글이 깨져본 경험이 있는 분
+- 노션 문서 체계를 옵시디언 등으로 마이그레이션하기 원하시는 분
+
+
+## 환경
+- **Node.js**: v20 이상 (npm v10 이상)
+- **TypeScript**: v5 이상
+
+## 설치
+
+```bash
+# 의존성 설치
+npm install
+
+# 빌드
+npm run build
+
+# 로컬에 CLI 설치
+npm link
+```
+
+## 설정
+
+`.env` 파일에 Notion 인증 토큰을 설정해야 합니다.
+
+```bash
+# .env 파일 생성
+cp .env.example .env
+```
+
+`.env` 파일을 열고 아래 값들을 설정하세요:
+
+```
+TOKEN_V2=your_token_v2_here
+FILE_TOKEN=your_file_token_here
+```
+
+### Notion env 값 확인하는 방법
+
+1. [notion.so](https://notion.so)에 로그인
+2. 브라우저 개발자 도구 열기 (F12)
+3. Application > Cookies > notion.so
+4. `token_v2` 값 복사 → `.env`의 `TOKEN_V2`에 붙여넣기
+5. `file_token` 값 복사 → `.env`의 `FILE_TOKEN`에 붙여넣기
+
+## 사용법
+
+### 기본 사용법
+
+```bash
+nconv md <notion-url>
+```
+
+### 예시
+
+```bash
+# 기본 사용 (./output 폴더에 저장)
+nconv md "https://notion.so/My-Page-abc123"
+
+# 출력 디렉토리 지정
+nconv md "https://notion.so/My-Page-abc123" -o ./blog-posts
+
+# 커스텀 파일명
+nconv md "https://notion.so/My-Page-abc123" -f "my-article"
+
+# 상세 로그 출력
+nconv md "https://notion.so/My-Page-abc123" -v
+
+# 모든 옵션 사용
+nconv md "https://notion.so/My-Page-abc123" -o ./blog -i assets -f "article-1" -v
+```
+
+## 옵션
+
+| 옵션 | 단축 | 설명 | 기본값 |
+|------|------|------|--------|
+| `--output <dir>` | `-o` | 출력 디렉토리 | `./output` |
+| `--image-dir <dir>` | `-i` | 이미지 폴더명 (output 기준 상대경로) | `images` |
+| `--filename <name>` | `-f` | 출력 파일명 (확장자 제외 또는 포함) | URL에서 자동 추출 |
+| `--verbose` | `-v` | 상세 로그 출력 | `false` |
+
+## 출력 구조
+
+```
+output/
+├── my-article-folder/
+    ├── my-article.md          # 마크다운 파일
+    └── images/
+        ├── abc12345.png       # 다운로드된 이미지들
+        ├── def67890.jpg
+        └── ...
+```
+
+마크다운 파일 내 이미지 경로는 상대경로로 변환됩니다:
+
+```markdown
+![image](./images/abc12345.png)
+```
+
+## 라이브러리
+### 주요 라이브러리
+- **notion-exporter**: Notion 페이지를 마크다운으로 내보내는 라이브러리
+- **commander**: CLI 명령 정의 및 파싱 도구
+- **axios**: HTTP 클라이언트 (이미지 다운로드 등)
+- **dotenv**: 환경 변수 관리
+- **chalk**: 터미널 출력 색상화
+- **ora**: 터미널 스피너 (진행 상황 표시)
+- **slugify**: 문자열을 URL 슬러그로 변환
+- **uuid**: 고유 ID 생성
+
+### 오픈소스 라이선스
+- **nconv-cli**: [ISC License](LICENSE)
+- 본 프로젝트는 위에 명시된 주요 라이브러리 외에도 다수의 오픈소스 라이브러리를 사용하며, 각 라이브러리는 해당 라이선스 정책을 따릅니다.
+
+## 개발
+
+```bash
+# 개발 모드 (파일 변경 감지)
+npm run dev
+
+# 빌드
+npm run build
+
+# 로컬 테스트
+npm link
+nconv md "https://notion.so/test-page"
+```
+
+## 프로젝트 구조
+
+```
+nconv/
+├── src/
+│   ├── index.ts              # CLI 진입점
+│   ├── config.ts             # 설정 관리
+│   ├── commands/
+│   │   └── md.ts             # md 명령어
+│   ├── core/
+│   │   ├── exporter.ts       # Notion 내보내기
+│   │   └── image-processor.ts # 이미지 처리
+│   └── utils/
+│       ├── file.ts           # 파일 유틸리티
+│       └── logger.ts         # 로깅
+├── bin/
+│   └── nconv.js   # 실행 파일
+├── package.json
+├── tsconfig.json
+└── tsup.config.ts
+```

package/bin/nconv.js

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

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config.ts
+import { config as dotenvConfig } from "dotenv";
+import { resolve } from "path";
+dotenvConfig();
+function getNotionConfig() {
+  const tokenV2 = process.env.TOKEN_V2 || "";
+  const fileToken = process.env.FILE_TOKEN || "";
+  if (!tokenV2 || !fileToken) {
+    throw new Error(
+      "Notion \uD1A0\uD070\uC774 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.\n.env \uD30C\uC77C\uC5D0 TOKEN_V2\uC640 FILE_TOKEN\uC744 \uC124\uC815\uD574\uC8FC\uC138\uC694.\n\uC790\uC138\uD55C \uB0B4\uC6A9\uC740 .env.example\uC744 \uCC38\uACE0\uD558\uC138\uC694."
+    );
+  }
+  return { tokenV2, fileToken };
+}
+function createConfig(options) {
+  const notionConfig = getNotionConfig();
+  const outputDir = resolve(process.cwd(), options.output);
+  return {
+    ...notionConfig,
+    ...options,
+    output: outputDir
+  };
+}
+
+// src/core/exporter.ts
+import { NotionExporter } from "notion-exporter";
+import { promises as fs } from "fs";
+import path from "path";
+var NotionMarkdownExporter = class {
+  constructor(config) {
+    this.exporter = new NotionExporter(config.tokenV2, config.fileToken);
+  }
+  /**
+   * Notion URL에서 마크다운과 이미지 파일 가져오기
+   */
+  async exportWithImages(notionUrl, tempDir) {
+    try {
+      await fs.mkdir(tempDir, { recursive: true });
+      await this.exporter.getMdFiles(notionUrl, tempDir);
+      const files = await fs.readdir(tempDir, { withFileTypes: true });
+      const mdFile = files.find((f) => f.isFile() && f.name.endsWith(".md"));
+      if (!mdFile) {
+        throw new Error("Markdown file not found.");
+      }
+      const mdPath = path.join(tempDir, mdFile.name);
+      const markdown = await fs.readFile(mdPath, "utf-8");
+      const imageFiles = files.filter((f) => f.isFile() && !f.name.endsWith(".md")).map((f) => ({
+        filename: f.name,
+        sourcePath: path.join(tempDir, f.name)
+      }));
+      const dirs = files.filter((f) => f.isDirectory());
+      for (const dir of dirs) {
+        const subFiles = await fs.readdir(path.join(tempDir, dir.name), { withFileTypes: true });
+        for (const subFile of subFiles) {
+          if (subFile.isFile() && !subFile.name.endsWith(".md")) {
+            imageFiles.push({
+              filename: path.join(dir.name, subFile.name),
+              sourcePath: path.join(tempDir, dir.name, subFile.name)
+            });
+          }
+        }
+      }
+      return { markdown, imageFiles };
+    } catch (error2) {
+      if (error2 instanceof Error) {
+        throw new Error(`Failed to fetch Notion page: ${error2.message}`);
+      }
+      throw new Error("Failed to fetch Notion page.");
+    }
+  }
+};
+
+// src/utils/file.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import slugify from "slugify";
+import { v4 as uuidv4 } from "uuid";
+function extractTitleFromUrl(notionUrl) {
+  try {
+    const url = new URL(notionUrl);
+    const pathname = url.pathname;
+    const match = pathname.match(/\/([^/]+)-[a-f0-9]{32}$/i);
+    if (match) {
+      const title = match[1].replace(/-/g, " ");
+      return title;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function generateSafeFilename(title, extension = "md") {
+  if (title) {
+    const slug = slugify(title, {
+      lower: true,
+      strict: true,
+      locale: "ko"
+    });
+    if (slug.length > 0) {
+      return extension ? `${slug}.${extension}` : slug;
+    }
+  }
+  const hash = uuidv4().slice(0, 8);
+  return extension ? `notion-export-${hash}.${extension}` : `notion-export-${hash}`;
+}
+async function saveMarkdownFile(outputDir, filename, content) {
+  await fs2.mkdir(outputDir, { recursive: true });
+  const filePath = path2.join(outputDir, filename);
+  await fs2.writeFile(filePath, content, "utf-8");
+  return filePath;
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+function success(message) {
+  console.log(chalk.green("\u2713"), message);
+}
+function error(message) {
+  console.error(chalk.red("\u2717"), message);
+}
+function info(message) {
+  console.log(chalk.blue("\u2139"), message);
+}
+function spinner(text) {
+  return ora(text).start();
+}
+
+// src/commands/md.ts
+import path3 from "path";
+import { promises as fs3 } from "fs";
+import os from "os";
+async function mdCommand(notionUrl, options) {
+  const tempDir = path3.join(os.tmpdir(), `nconv-cli-${Date.now()}`);
+  try {
+    const config = createConfig(options);
+    if (config.verbose) {
+      info("Configuration loaded successfully");
+      console.log(`  Output directory: ${config.output}
+`);
+    }
+    const spinner2 = spinner("Fetching Notion page...");
+    const exporter = new NotionMarkdownExporter({
+      tokenV2: config.tokenV2,
+      fileToken: config.fileToken
+    });
+    let result;
+    try {
+      result = await exporter.exportWithImages(notionUrl, tempDir);
+      spinner2.succeed(`Notion page fetched (${result.imageFiles.length} images)`);
+    } catch (error2) {
+      spinner2.fail("Failed to fetch Notion page");
+      throw error2;
+    }
+    let baseFilename;
+    if (config.filename) {
+      baseFilename = config.filename.replace(/\.md$/, "");
+    } else {
+      const title = extractTitleFromUrl(notionUrl);
+      baseFilename = generateSafeFilename(title, "");
+    }
+    const pageDir = path3.join(config.output, baseFilename);
+    await fs3.mkdir(pageDir, { recursive: true });
+    if (config.verbose) {
+      console.log(`\u{1F4C1} \uCD9C\uB825 \uD3F4\uB354: ${path3.relative(process.cwd(), pageDir)}
+`);
+    }
+    const imageOutputDir = path3.join(pageDir, config.imageDir);
+    await fs3.mkdir(imageOutputDir, { recursive: true });
+    if (config.verbose && result.imageFiles.length > 0) {
+      console.log(`Processing image files...
+`);
+    }
+    let processedMarkdown = result.markdown;
+    for (const imageFile of result.imageFiles) {
+      try {
+        const originalFileName = path3.basename(imageFile.filename);
+        const safeFileName = originalFileName.replace(/\s+/g, "-");
+        const targetPath = path3.join(imageOutputDir, safeFileName);
+        await fs3.copyFile(imageFile.sourcePath, targetPath);
+        if (config.verbose) {
+          console.log(`\u2713 ${safeFileName}`);
+        }
+        const originalPath = imageFile.filename;
+        const relativePath = `./${config.imageDir}/${safeFileName}`;
+        const pathParts = originalPath.split("/");
+        const encodedPath = pathParts.map((part) => encodeURIComponent(part)).join("/");
+        const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        processedMarkdown = processedMarkdown.replace(new RegExp(`\\(${escapeRegex(originalPath)}\\)`, "g"), `(${relativePath})`).replace(new RegExp(`\\(${escapeRegex(encodedPath)}\\)`, "g"), `(${relativePath})`);
+      } catch (error2) {
+        if (config.verbose) {
+          const errorMsg = error2 instanceof Error ? error2.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+          console.error(`\u2717 ${imageFile.filename}: ${errorMsg}`);
+        }
+      }
+    }
+    const filename = `${baseFilename}.md`;
+    const filePath = await saveMarkdownFile(pageDir, filename, processedMarkdown);
+    console.log("");
+    success("Conversion complete!");
+    console.log("");
+    console.log(`\u{1F4C1} Folder: ${path3.relative(process.cwd(), pageDir)}`);
+    console.log(`\u{1F4C4} Markdown: ${filename}`);
+    if (result.imageFiles.length > 0) {
+      console.log(`\u{1F5BC}\uFE0F  Images: ${config.imageDir}/ (${result.imageFiles.length} files)`);
+    }
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      error(error2.message);
+    } else {
+      error("An unknown error occurred.");
+    }
+    process.exit(1);
+  } finally {
+    try {
+      await fs3.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+// src/commands/debug.ts
+import * as fs4 from "fs/promises";
+import * as os2 from "os";
+import * as path4 from "path";
+async function debugCommand(notionUrl, options) {
+  let tempDir;
+  try {
+    const config = createConfig(options);
+    const exporter = new NotionMarkdownExporter({
+      tokenV2: config.tokenV2,
+      fileToken: config.fileToken
+    });
+    tempDir = path4.join(os2.tmpdir(), `notion-debug-${Date.now()}`);
+    console.log("Fetching Notion page...\n");
+    const { markdown, imageFiles } = await exporter.exportWithImages(notionUrl, tempDir);
+    console.log("=== Raw Markdown ===\n");
+    console.log(markdown.slice(0, 3e3));
+    console.log("\n... (truncated) ...\n");
+    console.log(`
+=== Found Images (${imageFiles.length}) ===
+`);
+    imageFiles.forEach((file, i) => {
+      console.log(`${i + 1}. ${file.filename} (\uC6D0\uBCF8 \uACBD\uB85C: ${file.sourcePath})`);
+    });
+  } catch (error2) {
+    console.error("Error:", error2);
+  } finally {
+    if (tempDir) {
+      await fs4.rm(tempDir, { recursive: true, force: true }).catch((err) => {
+        console.warn(`Error cleaning up temporary directory: ${err.message}`);
+      });
+    }
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("nconv").description("CLI tool for converting Notion pages to blog-ready markdown").version("1.0.0");
+program.command("md <url>").description("Convert a Notion page to markdown").option("-o, --output <dir>", "Output directory", "./output").option("-i, --image-dir <dir>", "Image folder name (relative to output)", "images").option("-f, --filename <name>", "\uCD9C\uB825 \uD30C\uC77C\uBA85 (\uD655\uC7A5\uC790 \uC81C\uC678 \uB610\uB294 \uD3EC\uD568)").option("-v, --verbose", "Enable verbose logging", false).action(async (url, options) => {
+  await mdCommand(url, {
+    output: options.output,
+    imageDir: options.imageDir,
+    filename: options.filename,
+    verbose: options.verbose
+  });
+});
+if (process.env.NODE_ENV !== "production") {
+  program.command("debug <url>").description("Debug: Output raw markdown and image URLs").option("-o, --output <dir>", "\uCD9C\uB825 \uB514\uB809\uD1A0\uB9AC", "./output").option("-i, --image-dir <dir>", "Image folder name", "images").option("-v, --verbose", "Enable verbose logging", false).action(async (url, options) => {
+    await debugCommand(url, {
+      output: options.output,
+      imageDir: options.imageDir,
+      filename: "",
+      verbose: options.verbose
+    });
+  });
+}
+program.parse();
+//# sourceMappingURL=index.js.map