node-pdf2img 0.1.8 → 0.1.9

package/README.md

@@ -1,16 +1,19 @@
 # node-pdf2img
 
-高性能 PDF 转图片工具，基于 PDFium 原生渲染器 + Sharp 图像编码。
+高性能 PDF 转图片工具，支持 PDFium 原生渲染器和 PDF.js 渲染器。
 
 [![npm version](https://badge.fury.io/js/node-pdf2img.svg)](https://badge.fury.io/js/node-pdf2img)
 
 ## 特性
 
-- **高性能**：使用 PDFium 原生渲染，多线程并行处理
+- **双渲染引擎**：PDFium 原生渲染（高性能）+ PDF.js（纯 JavaScript，无需原生依赖）
+- **高性能**：PDFium 多线程并行处理，整体快 1.7x
+- **流式渲染**：URL 输入支持 HTTP Range 请求，大文件无需完整下载
 - **多种格式**：支持 WebP、PNG、JPG 输出
 - **多种输入**：支持本地文件、URL、Buffer
 - **多种输出**：支持本地文件、Buffer、腾讯云 COS
 - **CLI + API**：命令行工具和 Node.js 模块双模式
+- **广泛兼容**：支持 GLIBC 2.17+ (CentOS 7/RHEL 7+)
 
 ## 安装
 
@@ -25,14 +28,20 @@ npm install -g node-pdf2img
 ## 系统要求
 
 - Node.js >= 18.0.0
-- 支持平台：Linux x64/arm64、macOS x64/arm64、Windows x64
+- 支持平台：
+  - Linux x64/arm64 (GLIBC 2.17+，兼容 CentOS 7/RHEL 7+)
+  - macOS x64/arm64
+  - Windows x64
 
 ## CLI 使用
 
 ```bash
-# 基本用法 - 转换所有页面
+# 基本用法 - 转换所有页面（默认使用 PDFium）
 pdf2img document.pdf -o ./output
 
+# 使用 PDF.js 渲染器
+pdf2img document.pdf -o ./output -r pdfjs
+
 # 转换指定页面
 pdf2img document.pdf -p 1,2,3 -o ./output
 
@@ -51,6 +60,9 @@ pdf2img document.pdf -f jpg -q 85 -o ./output
 # 显示 PDF 信息
 pdf2img document.pdf --info
 
+# 显示渲染器版本信息
+pdf2img --version-info
+
 # 上传到腾讯云 COS
 pdf2img document.pdf --cos --cos-prefix images/doc-123
 ```
@@ -64,8 +76,10 @@ pdf2img document.pdf --cos --cos-prefix images/doc-123
 | `-w, --width <width>` | 渲染宽度（像素） | `1920` |
 | `-q, --quality <quality>` | 图片质量（0-100） | `100` |
 | `-f, --format <format>` | 输出格式：webp, png, jpg | `webp` |
+| `-r, --renderer <renderer>` | 渲染器：pdfium, pdfjs | `pdfium` |
 | `--prefix <prefix>` | 文件名前缀 | `page` |
 | `--info` | 仅显示 PDF 信息 | |
+| `--version-info` | 显示渲染器版本信息 | |
 | `-v, --verbose` | 详细输出 | |
 | `--cos` | 上传到腾讯云 COS | |
 | `--cos-prefix <prefix>` | COS key 前缀 | |
@@ -88,7 +102,7 @@ pdf2img document.pdf --cos --cos-prefix images/doc-123
 ### 基本用法
 
 ```javascript
-import { convert, getPageCount, isAvailable } from 'node-pdf2img';
+import { convert, getPageCount, isAvailable, RendererType } from 'node-pdf2img';
 
 // 检查渲染器是否可用
 if (!isAvailable()) {
@@ -96,7 +110,7 @@ if (!isAvailable()) {
     process.exit(1);
 }
 
-// 转换 PDF 为图片（返回 Buffer）
+// 转换 PDF 为图片（返回 Buffer，默认使用 PDFium）
 const result = await convert('./document.pdf');
 console.log(`转换了 ${result.renderedPages} 页`);
 
@@ -106,6 +120,24 @@ for (const page of result.pages) {
 }
 ```
 
+### 使用 PDF.js 渲染器
+
+```javascript
+import { convert, RendererType, isPdfjsAvailable } from 'node-pdf2img';
+
+// 检查 PDF.js 渲染器是否可用
+if (isPdfjsAvailable()) {
+    const result = await convert('./document.pdf', {
+        renderer: RendererType.PDFJS,  // 或直接使用 'pdfjs'
+    });
+    console.log(`使用 PDF.js 转换了 ${result.renderedPages} 页`);
+}
+```
+
+> **渲染器选择建议**：
+> - **PDFium**（默认）：高性能，适合大多数场景，整体快 1.7x
+> - **PDF.js**：纯 JavaScript，无需原生依赖，适合超大文件（>50MB）或无法使用原生模块的环境
+
 ### 保存到文件
 
 ```javascript
@@ -200,8 +232,15 @@ const result = await convert('https://example.com/document.pdf', {
     outputType: 'file',
     outputDir: './output',
 });
+
+// 查看流式渲染统计（仅 URL 输入时存在）
+if (result.streamStats) {
+    console.log(`流式渲染: 缓存命中 ${result.streamStats.cacheHits} 次`);
+}
 ```
 
+> **流式渲染**：对于大于 2MB 的远程 PDF，会自动使用 HTTP Range 请求按需获取数据，避免完整下载。小于 2MB 的文件会直接下载后渲染，减少 Range 请求开销。
+
 ### 上传到腾讯云 COS
 
 ```javascript
@@ -256,6 +295,7 @@ PDF 转图片。
   - `prefix` (string)：文件名前缀，默认 'page'
   - `format` ('webp' | 'png' | 'jpg')：输出格式，默认 'webp'
   - `targetWidth` (number)：渲染宽度，默认 1280
+  - `renderer` ('pdfium' | 'pdfjs')：渲染器，默认 'pdfium'
   - `webp` (object)：WebP 编码选项
     - `quality` (number)：质量 0-100，默认 80
   - `jpeg` (object)：JPEG 编码选项
@@ -276,15 +316,30 @@ PDF 转图片。
 
 **返回：** Promise\<number\>
 
-### `isAvailable()`
+### `isAvailable(renderer?)`
+
+检查渲染器是否可用。
+
+**参数：**
+- `renderer` ('pdfium' | 'pdfjs')：可选，指定检查的渲染器，默认检查 PDFium
+
+**返回：** boolean
+
+### `isPdfjsAvailable()`
 
-检查原生渲染器是否可用。
+检查 PDF.js 渲染器是否可用。
 
 **返回：** boolean
 
 ### `getVersion()`
 
-获取原生渲染器版本信息。
+获取 PDFium 渲染器版本信息。
+
+**返回：** string
+
+### `getPdfjsVersion()`
+
+获取 PDF.js 渲染器版本信息。
 
 **返回：** string
 
@@ -299,8 +354,39 @@ PDF 转图片。
 | 变量 | 说明 | 默认值 |
 |------|------|--------|
 | `PDF2IMG_THREAD_COUNT` | 工作线程数 | CPU 核心数 |
+| `PDF2IMG_RENDERER` | 默认渲染器 (pdfium/pdfjs) | `pdfium` |
 | `PDF2IMG_DEBUG` | 启用调试日志 | `false` |
 
+## 渲染器对比
+
+| 特性 | PDFium | PDF.js |
+|------|--------|--------|
+| 性能 | ⚡ 快 1.7x | 普通 |
+| 依赖 | 原生模块 | 纯 JavaScript |
+| 大文件 (>50MB) | 普通 | ⚡ 更快 |
+| 兼容性 | Linux/macOS/Windows | 所有平台 |
+| 流式渲染 | ✓ | ✓ |
+
+## 架构
+
+模块化设计，职责分离：
+
+```
+src/
+├── core/
+│   ├── converter.js      # 主 API 入口
+│   ├── renderer.js       # PDF 渲染逻辑（流式/下载/本地）
+│   ├── thread-pool.js    # 线程池管理
+│   ├── downloader.js     # 远程文件下载
+│   ├── output-handler.js # 文件保存和 COS 上传
+│   └── config.js         # 配置常量
+├── renderers/
+│   ├── native.js         # PDFium 原生渲染器
+│   └── pdfjs.js          # PDF.js 渲染器（分片加载）
+└── utils/
+    └── logger.js         # 日志工具
+```
+
 ## 许可证
 
 MIT

package/bin/cli.js

@@ -12,8 +12,13 @@
  *   pdf2img document.pdf -p 1,2,3 -o ./output
  *   pdf2img document.pdf --quality 90 --width 1920 -o ./output
  *   pdf2img document.pdf --format png -o ./output  # 输出 PNG 格式
+ *   pdf2img document.pdf --renderer pdfjs -o ./output  # 使用 PDF.js 渲染器
  *   pdf2img document.pdf --cos --cos-prefix images/doc  # 上传到 COS
  *
+ * 渲染器：
+ *   pdfium  - PDFium 原生渲染器（默认，高性能）
+ *   pdfjs   - PDF.js 渲染器（纯 JavaScript，无需原生依赖）
+ *
  * COS 环境变量：
  *   COS_SECRET_ID     - 腾讯云 SecretId
  *   COS_SECRET_KEY    - 腾讯云 SecretKey
@@ -42,10 +47,10 @@ try {
 
 // 处理 --version-info 选项（在解析前检查）
 if (process.argv.includes('--version-info')) {
-    const { isAvailable, getVersion } = await import('../src/index.js');
+    const { isAvailable, getVersion, RendererType } = await import('../src/index.js');
     console.log(`pdf2img v${pkg.version}`);
-    console.log(`原生渲染器: ${getVersion()}`);
-    console.log(`可用: ${isAvailable() ? '是' : '否'}`);
+    console.log(`PDFium 渲染器: ${isAvailable(RendererType.PDFIUM) ? getVersion(RendererType.PDFIUM) : '不可用'}`);
+    console.log(`PDF.js 渲染器: ${isAvailable(RendererType.PDFJS) ? '可用' : '不可用'}`);
     process.exit(0);
 }
 
@@ -59,6 +64,7 @@ program
     .option('-w, --width <width>', '目标渲染宽度（像素）', '1920')
     .option('-q, --quality <quality>', '图片质量（0-100，用于 webp/jpg）', '100')
     .option('-f, --format <format>', '输出格式：webp, png, jpg', 'webp')
+    .option('-r, --renderer <renderer>', '渲染器：pdfium（默认）或 pdfjs', 'pdfium')
     .option('--prefix <prefix>', '输出文件名前缀', 'page')
     .option('--info', '仅显示 PDF 信息（页数）')
     .option('--version-info', '显示原生渲染器版本')
@@ -77,20 +83,31 @@ program
         }
 
         // 动态导入主模块
-        const { convert, getPageCount, isAvailable, getVersion } = await import('../src/index.js');
+        const { convert, getPageCount, isAvailable, getVersion, RendererType } = await import('../src/index.js');
 
         // 显示版本信息
         if (options.versionInfo) {
             console.log(`pdf2img v${pkg.version}`);
-            console.log(`原生渲染器: ${getVersion()}`);
-            console.log(`可用: ${isAvailable() ? '是' : '否'}`);
+            console.log(`PDFium 渲染器: ${isAvailable(RendererType.PDFIUM) ? getVersion(RendererType.PDFIUM) : '不可用'}`);
+            console.log(`PDF.js 渲染器: ${isAvailable(RendererType.PDFJS) ? '可用' : '不可用'}`);
             return;
         }
 
-        // 检查 native renderer
-        if (!isAvailable()) {
-            console.error('错误：原生渲染器不可用。');
-            console.error('请确保 PDFium 库已正确安装。');
+        // 验证渲染器
+        const renderer = options.renderer.toLowerCase();
+        if (renderer !== 'pdfium' && renderer !== 'pdfjs') {
+            console.error(`错误：不支持的渲染器 "${options.renderer}"。支持的渲染器：pdfium, pdfjs`);
+            process.exit(1);
+        }
+
+        // 检查渲染器可用性
+        if (!isAvailable(renderer)) {
+            if (renderer === 'pdfium') {
+                console.error('错误：PDFium 原生渲染器不可用。');
+                console.error('请确保 PDFium 库已正确安装，或使用 --renderer pdfjs 切换到 PDF.js 渲染器。');
+            } else {
+                console.error('错误：PDF.js 渲染器不可用。');
+            }
             process.exit(1);
         }
 
@@ -111,17 +128,15 @@ program
 
         // 仅显示 PDF 信息
         if (options.info) {
-            if (isUrl) {
-                console.error('错误：--info 选项仅支持本地文件');
-                process.exit(1);
-            }
-
             try {
-                const pageCount = getPageCount(input);
-                const stat = fs.statSync(input);
-                console.log(`文件: ${path.basename(input)}`);
-                console.log(`大小: ${(stat.size / 1024 / 1024).toFixed(2)} MB`);
+                const pageCount = await getPageCount(input, { renderer });
+                if (!isUrl) {
+                    const stat = fs.statSync(input);
+                    console.log(`文件: ${path.basename(input)}`);
+                    console.log(`大小: ${(stat.size / 1024 / 1024).toFixed(2)} MB`);
+                }
                 console.log(`页数: ${pageCount}`);
+                console.log(`渲染器: ${renderer}`);
             } catch (err) {
                 console.error(`错误: ${err.message}`);
                 process.exit(1);
@@ -143,6 +158,7 @@ program
             targetWidth: parseInt(options.width, 10),
             quality: parseInt(options.quality, 10),
             format: format,
+            renderer: renderer,
         };
 
         // COS 模式
@@ -195,7 +211,7 @@ program
 
             const duration = Date.now() - startTime;
 
-            spinner.succeed(`${modeText}完成 ${result.renderedPages}/${result.numPages} 页，格式: ${result.format.toUpperCase()}，耗时 ${duration}ms`);
+            spinner.succeed(`${modeText}完成 ${result.renderedPages}/${result.numPages} 页，格式: ${result.format.toUpperCase()}，渲染器: ${result.renderer}，耗时 ${duration}ms`);
 
             // 显示结果
             if (options.cos) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "node-pdf2img",
-    "version": "0.1.8",
-    "description": "High-performance PDF to image converter using PDFium native renderer",
+    "version": "0.1.9",
+    "description": "High-performance PDF to image converter using PDFium native renderer or PDF.js",
     "type": "module",
     "main": "./src/index.js",
     "types": "./src/index.d.ts",
@@ -29,6 +29,7 @@
         "image",
         "converter",
         "pdfium",
+        "pdfjs",
         "webp",
         "native",
         "cli"
@@ -53,9 +54,13 @@
         "dotenv": "^16.0.3",
         "ora": "^8.0.0",
         "p-limit": "^7.2.0",
+        "pdfjs-dist": "^4.0.0",
         "piscina": "^5.1.4",
         "sharp": "^0.33.0",
-        "node-pdf2img-native": "^1.1.9"
+        "node-pdf2img-native": "^1.1.10"
+    },
+    "optionalDependencies": {
+        "canvas": "^2.11.0"
     },
     "devDependencies": {
         "@types/node": "^20.0.0"

package/src/core/config.js

@@ -2,6 +2,15 @@
  * PDF2IMG 配置
  */
 
+// ==================== 渲染器类型 ====================
+export const RendererType = {
+    PDFIUM: 'pdfium',  // PDFium 原生渲染器（默认，高性能）
+    PDFJS: 'pdfjs',    // PDF.js 渲染器（纯 JavaScript，无需原生依赖）
+};
+
+// 默认渲染器
+export const DEFAULT_RENDERER = process.env.PDF2IMG_RENDERER || RendererType.PDFIUM;
+
 // ==================== 渲染配置 ====================
 export const RENDER_CONFIG = {
     // 目标渲染宽度（像素）

package/src/core/converter.js

@@ -7,6 +7,10 @@
  * - 主线程：负责 I/O、任务分发、结果收集
  * - 工作线程池：负责 CPU 密集型任务（PDFium 渲染 + Sharp 编码）
  * 
+ * 渲染器支持：
+ * - pdfium: PDFium 原生渲染器（默认，高性能）
+ * - pdfjs: PDF.js 渲染器（纯 JavaScript，无需原生依赖）
+ * 
  * 性能优化：
  * - 使用 piscina 线程池，充分利用多核 CPU
  * - 异步文件 I/O，不阻塞事件循环
@@ -16,12 +20,13 @@
 
 import fs from 'fs';
 import { createLogger } from '../utils/logger.js';
-import { RENDER_CONFIG, SUPPORTED_FORMATS } from './config.js';
+import { RENDER_CONFIG, SUPPORTED_FORMATS, RendererType, DEFAULT_RENDERER } from './config.js';
 import * as nativeRenderer from '../renderers/native.js';
+import * as pdfjsRenderer from '../renderers/pdfjs.js';
 import { getThreadCount, getThreadPoolStats, destroyThreadPool } from './thread-pool.js';
 import { downloadToTempFile } from './downloader.js';
 import { saveToFiles, uploadToCos, DEFAULT_CONCURRENCY } from './output-handler.js';
-import { InputType, detectInputType, renderPages } from './renderer.js';
+import { InputType, detectInputType, renderPages, getRendererType } from './renderer.js';
 
 const logger = createLogger('Converter');
 
@@ -48,6 +53,7 @@ export { InputType };
  * @param {string} [options.prefix='page'] - 输出文件名前缀
  * @param {string} [options.format='webp'] - 输出格式：'webp'、'png'、'jpg'
  * @param {number} [options.quality] - 图片质量（0-100，用于 webp 和 jpg）
+ * @param {string} [options.renderer='pdfium'] - 渲染器：'pdfium'（默认）或 'pdfjs'
  * @param {Object} [options.webp] - WebP 编码配置
  * @param {number} [options.webp.quality] - WebP 质量（0-100，默认 80）
  * @param {number} [options.webp.method] - WebP 编码方法（0-6，默认 4，0最快6最慢）
@@ -70,6 +76,7 @@ export async function convert(input, options = {}) {
         outputDir,
         prefix = 'page',
         format = RENDER_CONFIG.OUTPUT_FORMAT,
+        renderer = DEFAULT_RENDERER,
         cos: cosConfig,
         cosKeyPrefix = `pdf2img/${Date.now()}`,
         concurrency,
@@ -82,9 +89,13 @@ export async function convert(input, options = {}) {
         throw new Error(`Unsupported format: ${format}. Supported formats: ${SUPPORTED_FORMATS.join(', ')}`);
     }
 
+    // 获取实际使用的渲染器
+    const actualRenderer = getRendererType({ renderer });
+    logger.debug(`Renderer: ${actualRenderer}`);
+
     // 检查渲染器可用性
-    if (!nativeRenderer.isNativeAvailable()) {
-        throw new Error('Native renderer is not available. Please ensure PDFium library is installed.');
+    if (actualRenderer === RendererType.PDFIUM && !nativeRenderer.isNativeAvailable()) {
+        throw new Error('Native renderer is not available. Please ensure PDFium library is installed or use renderer: "pdfjs".');
     }
 
     // 检测输入类型
@@ -101,6 +112,7 @@ export async function convert(input, options = {}) {
         pngCompression: renderOptions.png?.compressionLevel,
         targetWidth: renderOptions.targetWidth,
         detectScan: renderOptions.detectScan,
+        renderer: actualRenderer,
     };
 
     // 使用线程池渲染页面
@@ -186,6 +198,7 @@ export async function convert(input, options = {}) {
         numPages: result.numPages,
         renderedPages: outputResult.filter(p => p.success).length,
         format: normalizedFormat,
+        renderer: result.renderer || actualRenderer,
         pages: outputResult,
         timing: {
             total: Date.now() - startTime,
@@ -204,9 +217,34 @@ export async function convert(input, options = {}) {
  * 获取 PDF 页数（异步版本）
  *
  * @param {string|Buffer} input - PDF 输入（文件路径、URL 或 Buffer）
+ * @param {Object} [options] - 选项
+ * @param {string} [options.renderer] - 渲染器：'pdfium' 或 'pdfjs'
  * @returns {Promise<number>} 页数
  */
-export async function getPageCount(input) {
+export async function getPageCount(input, options = {}) {
+    const rendererType = getRendererType(options);
+    
+    // 使用 PDF.js 渲染器
+    if (rendererType === RendererType.PDFJS) {
+        if (Buffer.isBuffer(input)) {
+            return pdfjsRenderer.getPageCount(input);
+        }
+        if (typeof input === 'string') {
+            if (input.startsWith('http://') || input.startsWith('https://')) {
+                // URL 输入需要下载
+                const tempFile = await downloadToTempFile(input);
+                try {
+                    return pdfjsRenderer.getPageCountFromFile(tempFile);
+                } finally {
+                    try { await fs.promises.unlink(tempFile); } catch {}
+                }
+            }
+            return pdfjsRenderer.getPageCountFromFile(input);
+        }
+        throw new Error('Invalid input: must be a file path, URL, or Buffer');
+    }
+    
+    // 使用 PDFium 渲染器
     if (!nativeRenderer.isNativeAvailable()) {
         throw new Error('Native renderer is not available');
     }
@@ -216,23 +254,15 @@ export async function getPageCount(input) {
     }
     
     if (typeof input === 'string') {
-        // 检查是否是 URL
         if (input.startsWith('http://') || input.startsWith('https://')) {
-            // URL 输入：下载到临时文件后获取页数
             const tempFile = await downloadToTempFile(input);
             try {
                 return nativeRenderer.getPageCountFromFile(tempFile);
             } finally {
-                // 清理临时文件
-                try {
-                    await fs.promises.unlink(tempFile);
-                } catch {
-                    // 忽略清理错误
-                }
+                try { await fs.promises.unlink(tempFile); } catch {}
             }
         }
         
-        // 本地文件路径
         try {
             await fs.promises.access(input, fs.constants.R_OK);
         } catch {
@@ -268,17 +298,37 @@ export function getPageCountSync(input) {
 
 /**
  * 检查渲染器是否可用
+ * 
+ * @param {string} [renderer] - 渲染器类型：'pdfium' 或 'pdfjs'
+ * @returns {boolean} 是否可用
  */
-export function isAvailable() {
-    return nativeRenderer.isNativeAvailable();
+export function isAvailable(renderer) {
+    if (renderer === RendererType.PDFJS) {
+        return pdfjsRenderer.isPdfjsAvailable();
+    }
+    if (renderer === RendererType.PDFIUM) {
+        return nativeRenderer.isNativeAvailable();
+    }
+    // 默认检查 pdfium，如果不可用则检查 pdfjs
+    return nativeRenderer.isNativeAvailable() || pdfjsRenderer.isPdfjsAvailable();
 }
 
 /**
  * 获取版本信息
+ * 
+ * @param {string} [renderer] - 渲染器类型
+ * @returns {string} 版本信息
  */
-export function getVersion() {
-    return nativeRenderer.getVersion();
+export function getVersion(renderer) {
+    if (renderer === RendererType.PDFJS) {
+        return pdfjsRenderer.getPdfjsVersion();
+    }
+    if (nativeRenderer.isNativeAvailable()) {
+        return nativeRenderer.getVersion();
+    }
+    return pdfjsRenderer.getPdfjsVersion();
 }
 
-// 重新导出线程池相关函数
+// 重新导出渲染器类型和线程池相关函数
+export { RendererType };
 export { getThreadPoolStats, destroyThreadPool };

package/src/core/output-handler.js

@@ -162,6 +162,9 @@ export async function uploadToCos(pages, cosConfig, keyPrefix, format = 'webp',
     const cos = new COS({
         SecretId: cosConfig.secretId,
         SecretKey: cosConfig.secretKey,
+        Protocol: cosConfig.protocol || 'https:',
+        ServiceDomain: cosConfig.serviceDomain,
+        Domain: cosConfig.domain,
     });
 
     const ext = getExtension(format);

package/src/core/renderer.js

@@ -2,11 +2,16 @@
  * PDF 渲染模块
  * 
  * 负责 PDF 页面的渲染逻辑，支持本地文件、Buffer 和 URL 输入
+ * 支持两种渲染器：
+ * - pdfium: PDFium 原生渲染器（默认，高性能）
+ * - pdfjs: PDF.js 渲染器（纯 JavaScript，无需原生依赖）
  */
 
 import fs from 'fs';
 import { createLogger } from '../utils/logger.js';
+import { RendererType, DEFAULT_RENDERER } from './config.js';
 import * as nativeRenderer from '../renderers/native.js';
+import * as pdfjsRenderer from '../renderers/pdfjs.js';
 import { getThreadPool, getThreadCount } from './thread-pool.js';
 import { getRemoteFileSize, downloadToTempFile } from './downloader.js';
 
@@ -46,9 +51,30 @@ export function detectInputType(input) {
 }
 
 /**
- * 使用线程池渲染 PDF 页面
+ * 获取当前使用的渲染器类型
  * 
- * 主线程负责协调，工作线程负责 CPU 密集型任务
+ * @param {Object} options - 选项
+ * @returns {string} 渲染器类型
+ */
+export function getRendererType(options = {}) {
+    const renderer = options.renderer || DEFAULT_RENDERER;
+    
+    // 验证渲染器类型
+    if (renderer === RendererType.PDFJS) {
+        return RendererType.PDFJS;
+    }
+    
+    // 默认使用 pdfium，如果不可用则回退到 pdfjs
+    if (!nativeRenderer.isNativeAvailable()) {
+        logger.warn('PDFium 渲染器不可用，回退到 PDF.js');
+        return RendererType.PDFJS;
+    }
+    
+    return RendererType.PDFIUM;
+}
+
+/**
+ * 使用指定渲染器渲染 PDF 页面
  * 
  * @param {string|Buffer} input - 输入
  * @param {string} inputType - 输入类型
@@ -58,16 +84,52 @@ export function detectInputType(input) {
  */
 export async function renderPages(input, inputType, pages, options) {
     const startTime = Date.now();
-
-    // URL 输入：优先使用流式渲染
+    const rendererType = getRendererType(options);
+    
+    logger.debug(`Using renderer: ${rendererType}`);
+    
+    if (rendererType === RendererType.PDFJS) {
+        return renderPagesWithPdfjs(input, inputType, pages, options, startTime);
+    }
+    
+    // 使用 pdfium 渲染器
     if (inputType === InputType.URL) {
         return renderPagesFromUrl(input, pages, options, startTime);
     }
-
-    // 本地文件或 Buffer 输入：使用线程池渲染
+    
     return renderPagesFromLocal(input, inputType, pages, options, startTime);
 }
 
+/**
+ * 使用 PDF.js 渲染器渲染 PDF 页面
+ */
+async function renderPagesWithPdfjs(input, inputType, pages, options, startTime) {
+    let result;
+    
+    if (inputType === InputType.URL) {
+        result = await pdfjsRenderer.renderFromUrl(input, pages, options);
+    } else if (inputType === InputType.BUFFER) {
+        result = await pdfjsRenderer.renderFromBuffer(input, pages, options);
+    } else {
+        result = await pdfjsRenderer.renderFromFile(input, pages, options);
+    }
+    
+    if (!result.success) {
+        throw new Error(result.error || 'PDF.js 渲染失败');
+    }
+    
+    return {
+        success: true,
+        numPages: result.numPages,
+        pages: result.pages,
+        totalTime: Date.now() - startTime,
+        renderTime: result.renderTime || result.pages.reduce((sum, p) => sum + (p.renderTime || 0), 0),
+        encodeTime: result.pages.reduce((sum, p) => sum + (p.encodeTime || 0), 0),
+        renderer: RendererType.PDFJS,
+        streamStats: result.streamStats,
+    };
+}
+
 /**
  * 从 URL 渲染 PDF 页面（流式）
  * 
@@ -97,6 +159,7 @@ async function renderPagesFromUrl(url, pages, options, startTime) {
             renderTime: result.pages.reduce((sum, p) => sum + (p.renderTime || 0), 0),
             encodeTime: result.pages.reduce((sum, p) => sum + (p.encodeTime || 0), 0),
             streamStats: result.streamStats,
+            renderer: RendererType.PDFIUM,
         };
     } catch (err) {
         // 流式渲染失败，回退到下载后渲染
@@ -145,6 +208,7 @@ async function renderPagesWithDownload(url, pages, options, startTime) {
             totalTime: Date.now() - startTime,
             renderTime: results.reduce((sum, p) => sum + (p.renderTime || 0), 0),
             encodeTime: results.reduce((sum, p) => sum + (p.encodeTime || 0), 0),
+            renderer: RendererType.PDFIUM,
         };
     } finally {
         try {
@@ -220,5 +284,6 @@ async function renderPagesFromLocal(input, inputType, pages, options, startTime)
         totalTime: Date.now() - startTime,
         renderTime: results.reduce((sum, p) => sum + (p.renderTime || 0), 0),
         encodeTime: results.reduce((sum, p) => sum + (p.encodeTime || 0), 0),
+        renderer: RendererType.PDFIUM,
     };
 }