@clazic/kordoc 2.5.2 → 2.6.1

package/README.md

@@ -126,6 +126,25 @@ if (result.success) {
 }
 ```
 
+### PDF 변환 (HWP/HWPX → PDF)
+
+```typescript
+import { convertToPdf } from "@clazic/kordoc"
+import { readFileSync, writeFileSync } from "fs"
+
+const buffer = readFileSync("사업계획서.hwp")
+const result = await convertToPdf(buffer)
+
+if (result.success) {
+  writeFileSync("사업계획서.pdf", result.pdf)
+  console.log(`변환 완료: ${result.sourceFormat} → PDF`)
+} else {
+  console.error(`변환 실패: ${result.error}`)
+}
+```
+
+**요구사항**: 시스템에 [LibreOffice](https://www.libreoffice.org/)가 설치되어 있어야 합니다.
+
 ### 문서 비교 (신구대조표)
 
 ```typescript
@@ -272,6 +291,11 @@ kordoc convert 보고서.md -o 최종보고서.hwpx     # 출력 경로 지정
 kordoc convert 보고서.md --image-dir ./이미지   # 이미지 폴더 지정
 kordoc convert 보고서.md --template 기본.hwpx  # HWPX 템플릿 적용
 
+# HWP/HWPX → PDF 변환
+kordoc convert-pdf 사업계획서.hwp               # → 사업계획서.pdf
+kordoc convert-pdf 보고서.hwpx -o 결과.pdf      # 출력 경로 지정
+kordoc convert-pdf 문서.hwp --pages 1-3        # 페이지 범위
+
 # 폴더 감시 모드
 kordoc watch ./수신함 -d ./변환결과              # 폴더 감시 모드
 kordoc watch ./문서 --webhook https://api/hook  # 웹훅 알림
@@ -381,12 +405,13 @@ HWP 5.x를 제외한 모든 포맷 지원. 설치 없이 바로 연결 가능합
 }
 ```
 
-**8개 도구:**
+**9개 도구:**
 
 | 도구 | 설명 |
 |------|------|
 | `parse_document` | HWP/HWPX/PDF/XLSX/DOCX → 마크다운 (메타데이터·이미지 포함, `image_dir` 지원) |
 | `convert_document` | Markdown → HWPX 또는 XLSX 변환 (이미지 폴더·템플릿 지원) |
+| `convert_to_pdf` | HWP/HWPX → PDF 변환 (페이지 범위·타임아웃 지원) |
 | `detect_format` | 매직 바이트로 포맷 감지 |
 | `parse_metadata` | 메타데이터만 빠르게 추출 |
 | `parse_pages` | 특정 페이지 범위만 파싱 |
@@ -406,6 +431,7 @@ HWP 5.x를 제외한 모든 포맷 지원. 설치 없이 바로 연결 가능합
 | `parsePdf(buffer, options?)` | PDF 전용 |
 | `parseXlsx(buffer, options?)` | XLSX 전용 |
 | `parseDocx(buffer, options?)` | DOCX 전용 |
+| `convertToPdf(input, options?)` | HWP/HWPX → PDF 변환 |
 | `detectFormat(buffer)` | `"hwpx" \| "hwp" \| "pdf" \| "xlsx" \| "docx" \| "unknown"` |
 
 ### 고급 함수
@@ -429,6 +455,8 @@ import type {
   FormField, FormResult,
   OcrProvider, WatchOptions,
   MarkdownToXlsxOptions,
+  // PDF 변환 타입
+  ConvertToPdfOptions, ConvertToPdfResult,
 } from "@clazic/kordoc"
 ```
 

package/dist/{chunk-5CILZHRW.js → chunk-4X5JCZFZ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/utils.ts
-var VERSION = true ? "2.5.1" : "0.0.0-dev";
+var VERSION = true ? "2.6.0" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -105,4 +105,4 @@ export {
   classifyError,
   normalizeKordocError
 };
-//# sourceMappingURL=chunk-5CILZHRW.js.map
+//# sourceMappingURL=chunk-4X5JCZFZ.js.map

package/dist/{chunk-25ZYYLVP.js → chunk-BZPZXI66.js}

@@ -7,7 +7,7 @@ import {
   precheckZipSize,
   sanitizeHref,
   toArrayBuffer
-} from "./chunk-5CILZHRW.js";
+} from "./chunk-4X5JCZFZ.js";
 import {
   parsePageRange
 } from "./chunk-MOL7MDBG.js";
@@ -6686,7 +6686,7 @@ function mergeKoreanLines(text) {
 }
 
 // src/index.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 
 // src/xlsx/parser.ts
 import JSZip3 from "jszip";
@@ -9821,10 +9821,444 @@ async function markdownToXlsx(markdown, options) {
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 }
 
-// src/pipeline/unified-ocr.ts
-import { performance } from "perf_hooks";
+// src/convert/index.ts
+import { readFile } from "fs/promises";
+
+// src/convert/libreoffice.ts
 import libre from "libreoffice-convert";
+
+// src/convert/error.ts
+var ConvertError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ConvertError";
+  }
+};
+
+// src/convert/installer.ts
+import { homedir } from "os";
+import { join as join2, delimiter } from "path";
+import { mkdir, access, symlink, rm } from "fs/promises";
+import { createWriteStream } from "fs";
+import { spawn } from "child_process";
+var CACHE_DIR = join2(homedir(), ".cache", "kordoc", "libreoffice");
+var VERSION_FILE = join2(CACHE_DIR, "version");
+var PACKAGES = {
+  darwin: {
+    url: "https://download.documentfoundation.org/libreoffice/stable/24.8.4/mac/x86_64/LibreOffice_24.8.4_MacOS_x86-64.dmg",
+    binPath: "LibreOffice.app/Contents/MacOS/soffice",
+    sizeMb: 300
+  },
+  linux: {
+    url: "https://download.documentfoundation.org/libreoffice/stable/24.8.4/deb/x86_64/LibreOffice_24.8.4_Linux_x86-64_deb.tar.gz",
+    binPath: "opt/libreoffice24.8/program/soffice",
+    sizeMb: 200
+  },
+  win32: {
+    url: "https://download.documentfoundation.org/libreoffice/stable/24.8.4/win/x86_64/LibreOffice_24.8.4_Win_x86-64.msi",
+    binPath: "LibreOffice/program/soffice.exe",
+    sizeMb: 350
+  }
+};
+async function findInPath() {
+  try {
+    const { runCommand } = await import("./utils-56QT5C33.js");
+    await runCommand("soffice", ["--version"]);
+    return "soffice";
+  } catch {
+    return null;
+  }
+}
+async function findInCache() {
+  const cachedBin = join2(CACHE_DIR, "bin", "soffice");
+  try {
+    await access(cachedBin);
+    return cachedBin;
+  } catch {
+    return null;
+  }
+}
+async function downloadWithProgress(url, dest, totalBytes, onProgress) {
+  const response = await fetch(url);
+  if (!response.body) throw new Error("\uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: response body \uC5C6\uC74C");
+  const file = createWriteStream(dest);
+  const reader = response.body.getReader();
+  let downloaded = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      file.write(value);
+      downloaded += value.length;
+      onProgress?.(downloaded, totalBytes);
+    }
+  } finally {
+    file.end();
+    reader.releaseLock();
+  }
+}
+async function installForPlatform(pkg, onProgress) {
+  const platform = process.platform;
+  await mkdir(CACHE_DIR, { recursive: true });
+  const downloadPath = join2(CACHE_DIR, `download-${Date.now()}`);
+  await downloadWithProgress(pkg.url, downloadPath, pkg.sizeMb * 1024 * 1024, onProgress);
+  try {
+    if (platform === "darwin") {
+      return await installMacOS(pkg, downloadPath);
+    } else if (platform === "linux") {
+      return await installLinux(pkg, downloadPath);
+    } else if (platform === "win32") {
+      return await installWindows(pkg, downloadPath);
+    }
+  } catch (err) {
+    await rm(downloadPath, { force: true });
+    throw err;
+  }
+  throw new ConvertError("UNSUPPORTED_PLATFORM", `${platform}\uC740 \uC790\uB3D9 \uC124\uCE58\uB97C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4`);
+}
+async function installMacOS(pkg, downloadPath) {
+  const mountPoint = `/Volumes/LibreOffice_${Date.now()}`;
+  await new Promise((resolve2, reject) => {
+    const child = spawn("hdiutil", ["attach", "-nobrowse", "-mountpoint", mountPoint, downloadPath]);
+    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error("dmg \uB9C8\uC6B4\uD2B8 \uC2E4\uD328")));
+  });
+  try {
+    const appSource = join2(mountPoint, "LibreOffice.app");
+    const appDest = join2(CACHE_DIR, "LibreOffice.app");
+    await new Promise((resolve2, reject) => {
+      const child = spawn("cp", ["-R", appSource, appDest]);
+      child.on("close", (code) => code === 0 ? resolve2() : reject(new Error(".app \uBCF5\uC0AC \uC2E4\uD328")));
+    });
+  } finally {
+    await new Promise((resolve2) => {
+      const child = spawn("hdiutil", ["detach", mountPoint]);
+      child.on("close", () => resolve2());
+    });
+  }
+  await rm(downloadPath, { force: true });
+  return await createSymlink(join2(CACHE_DIR, pkg.binPath));
+}
+async function installLinux(pkg, downloadPath) {
+  const extractDir = join2(CACHE_DIR, `extract-${Date.now()}`);
+  await mkdir(extractDir, { recursive: true });
+  await new Promise((resolve2, reject) => {
+    const child = spawn("tar", ["xzf", downloadPath, "-C", extractDir]);
+    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error("\uC555\uCD95 \uD574\uC81C \uC2E4\uD328")));
+  });
+  const debsDir = join2(extractDir, "DEBS");
+  try {
+    await access(debsDir);
+    const entries = await (await import("fs/promises")).readdir(debsDir);
+    for (const entry of entries) {
+      if (entry.endsWith(".deb")) {
+        await new Promise((resolve2, reject) => {
+          const child = spawn("dpkg-deb", ["-x", join2(debsDir, entry), CACHE_DIR]);
+          child.on("close", (code) => code === 0 ? resolve2() : reject(new Error(`${entry} \uCD94\uCD9C \uC2E4\uD328`)));
+        });
+      }
+    }
+  } catch {
+  }
+  await rm(downloadPath, { force: true });
+  await rm(extractDir, { recursive: true, force: true });
+  return await createSymlink(join2(CACHE_DIR, pkg.binPath));
+}
+async function installWindows(pkg, downloadPath) {
+  await new Promise((resolve2, reject) => {
+    const child = spawn("msiexec", ["/a", downloadPath, "/qn", `TARGETDIR=${CACHE_DIR}`]);
+    child.on("close", (code) => code === 0 ? resolve2() : reject(new Error("MSI \uC124\uCE58 \uC2E4\uD328")));
+  });
+  await rm(downloadPath, { force: true });
+  return join2(CACHE_DIR, pkg.binPath);
+}
+async function createSymlink(actualBin) {
+  const binDir = join2(CACHE_DIR, "bin");
+  await mkdir(binDir, { recursive: true });
+  const linkBin = join2(binDir, "soffice");
+  try {
+    await symlink(actualBin, linkBin);
+  } catch {
+  }
+  process.env.PATH = `${binDir}${delimiter}${process.env.PATH}`;
+  return linkBin;
+}
+async function installLibreOffice(onProgress) {
+  const platform = process.platform;
+  const pkg = PACKAGES[platform];
+  if (!pkg) {
+    throw new ConvertError(
+      "UNSUPPORTED_PLATFORM",
+      `${platform}\uC740 \uC790\uB3D9 \uC124\uCE58\uB97C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uC218\uB3D9\uC73C\uB85C LibreOffice\uB97C \uC124\uCE58\uD574 \uC8FC\uC138\uC694.`
+    );
+  }
+  return await installForPlatform(pkg, onProgress);
+}
+async function resolveSoffice(emitter, autoInstall = true) {
+  emitter.validate("soffice_check", "LibreOffice \uAC00\uC6A9\uC131 \uD655\uC778 \uC911...");
+  const inPath = await findInPath();
+  if (inPath) {
+    emitter.validate("soffice_found", "\uC2DC\uC2A4\uD15C PATH\uC5D0\uC11C LibreOffice \uBC1C\uACAC", { sofficePath: inPath });
+    return inPath;
+  }
+  const inCache = await findInCache();
+  if (inCache) {
+    emitter.validate("soffice_found", "\uCE90\uC2DC\uB41C LibreOffice \uBC1C\uACAC", { sofficePath: inCache });
+    return inCache;
+  }
+  if (!autoInstall) {
+    emitter.error(
+      "validate",
+      "SOFFICE_NOT_FOUND",
+      "LibreOffice\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+      "\uC218\uB3D9\uC73C\uB85C \uC124\uCE58\uD558\uAC70\uB098 autoInstallLibreOffice: true \uC635\uC158\uC744 \uC0AC\uC6A9\uD558\uC138\uC694."
+    );
+    throw new ConvertError("SOFFICE_NOT_FOUND", "LibreOffice\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4");
+  }
+  emitter.install("install_start", "LibreOffice \uC790\uB3D9 \uC124\uCE58\uB97C \uC2DC\uC791\uD569\uB2C8\uB2E4...");
+  try {
+    const installed = await installLibreOffice((downloaded, total) => {
+      const percent = Math.round(downloaded / total * 100);
+      emitter.install("download_progress", `\uB2E4\uC6B4\uB85C\uB4DC \uC911... ${percent}%`, {
+        percent,
+        downloadedBytes: downloaded,
+        totalBytes: total
+      });
+    });
+    emitter.install("install_complete", "\uC124\uCE58 \uC644\uB8CC", { installedPath: installed });
+    return installed;
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    emitter.install("install_failed", "\uC124\uCE58 \uC2E4\uD328", { error: errorMsg });
+    throw err;
+  }
+}
+
+// src/convert/libreoffice.ts
 var libreConvert = libre.convert;
+async function convertBuffer(buffer, targetExt, timeoutMs = 6e4) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      reject(
+        new ConvertError("TIMEOUT", `\uBCC0\uD658 \uD0C0\uC784\uC544\uC6C3 (${timeoutMs}ms \uCD08\uACFC)`)
+      );
+    }, timeoutMs);
+    libreConvert(buffer, targetExt, void 0, (err, done) => {
+      clearTimeout(timer);
+      if (err || !done) {
+        reject(
+          new ConvertError(
+            "CONVERT_FAILED",
+            err?.message ?? "LibreOffice \uBCC0\uD658 \uC2E4\uD328"
+          )
+        );
+        return;
+      }
+      resolve2(done);
+    });
+  });
+}
+
+// src/convert/events.ts
+var ConvertEventEmitter = class {
+  listener = null;
+  /** 이벤트 리스너 등록 */
+  setListener(listener) {
+    this.listener = listener;
+  }
+  /** 이벤트 발송 */
+  emit(event) {
+    try {
+      this.listener?.(event);
+    } catch {
+    }
+  }
+  /** 타입 안전한 헬퍼: detect 이벤트 */
+  detect(stage, message, meta) {
+    this.emit({ type: "detect", stage, message, ...meta });
+  }
+  /** 타입 안전한 헬퍼: validate 이벤트 */
+  validate(stage, message, meta) {
+    this.emit({ type: "validate", stage, message, ...meta });
+  }
+  /** 타입 안전한 헬퍼: install 이벤트 */
+  install(stage, message, meta) {
+    this.emit({ type: "install", stage, message, ...meta });
+  }
+  /** 타입 안전한 헬퍼: convert 진행 이벤트 */
+  progress(percent, message) {
+    this.emit({ type: "convert", stage: "convert_progress", message, percent });
+  }
+  /** 타입 안전한 헬퍼: convert 시작 */
+  convertStart(message) {
+    this.emit({ type: "convert", stage: "convert_start", message, percent: 0 });
+  }
+  /** 타입 안전한 헬퍼: convert 완료 */
+  convertDone(message) {
+    this.emit({ type: "convert", stage: "convert_done", message, percent: 100 });
+  }
+  /** 타입 안전한 헬퍼: 완료 이벤트 */
+  complete(result) {
+    this.emit({ type: "complete", stage: "success", message: "\uBCC0\uD658 \uC644\uB8CC", result });
+  }
+  /** 타입 안전한 헬퍼: 에러 이벤트 */
+  error(stage, code, message, suggestion) {
+    this.emit({ type: "error", stage, code, message, recoverable: true, suggestion });
+  }
+};
+
+// src/convert/index.ts
+var isConverting = false;
+var queue = [];
+async function acquireConvertLock() {
+  if (!isConverting) {
+    isConverting = true;
+    return () => {
+      isConverting = false;
+      const next = queue.shift();
+      next?.();
+    };
+  }
+  return new Promise((resolve2) => {
+    queue.push(() => {
+      isConverting = true;
+      resolve2(() => {
+        isConverting = false;
+        const next = queue.shift();
+        next?.();
+      });
+    });
+  });
+}
+async function convertToPdf(input, options) {
+  const emitter = new ConvertEventEmitter();
+  if (options?.onEvent) {
+    emitter.setListener(options.onEvent);
+  }
+  if (options?.onProgress) {
+    const legacyProgress = options.onProgress;
+    emitter.setListener((event) => {
+      if (event.type === "convert" && event.stage === "convert_progress") {
+        legacyProgress(event.percent, event.message);
+      }
+    });
+  }
+  try {
+    emitter.detect("reading", "\uC785\uB825 \uD30C\uC77C \uC77D\uB294 \uC911...");
+    let buffer;
+    try {
+      if (typeof input === "string") {
+        buffer = await readFile(input);
+      } else if (Buffer.isBuffer(input)) {
+        buffer = input;
+      } else {
+        buffer = Buffer.from(input);
+      }
+    } catch (err) {
+      emitter.error(
+        "detect",
+        "PARSE_ERROR",
+        `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return {
+        success: false,
+        code: "PARSE_ERROR",
+        error: `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`,
+        stage: "detect"
+      };
+    }
+    const MAX_FILE_SIZE = 500 * 1024 * 1024;
+    if (buffer.length > MAX_FILE_SIZE) {
+      emitter.error(
+        "detect",
+        "FILE_TOO_LARGE",
+        `\uD30C\uC77C \uD06C\uAE30 \uCD08\uACFC: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 500MB)`
+      );
+      return {
+        success: false,
+        code: "FILE_TOO_LARGE",
+        error: `\uD30C\uC77C \uD06C\uAE30 \uCD08\uACFC: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 500MB)`,
+        stage: "detect"
+      };
+    }
+    const format = detectFormat(toArrayBuffer(buffer));
+    emitter.detect("format_detected", `\uD3EC\uB9F7 \uAC10\uC9C0 \uC644\uB8CC: ${format}`, { format });
+    if (format !== "hwp" && format !== "hwpx") {
+      emitter.error("detect", "UNSUPPORTED_FORMAT", `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD3EC\uB9F7\uC785\uB2C8\uB2E4: ${format}`);
+      return {
+        success: false,
+        code: "UNSUPPORTED_FORMAT",
+        error: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD3EC\uB9F7\uC785\uB2C8\uB2E4: ${format}`,
+        stage: "detect"
+      };
+    }
+    emitter.validate("soffice_check", "LibreOffice \uAC00\uC6A9\uC131 \uD655\uC778 \uC911...");
+    let sofficePath;
+    try {
+      sofficePath = await resolveSoffice(emitter, options?.autoInstallLibreOffice ?? true);
+    } catch (err) {
+      if (err instanceof ConvertError) {
+        return {
+          success: false,
+          code: err.code,
+          error: err.message,
+          stage: "validate"
+        };
+      }
+      throw err;
+    }
+    const releaseLock = await acquireConvertLock();
+    try {
+      emitter.convertStart("\uBCC0\uD658 \uC2DC\uC791...");
+      emitter.progress(10, "\uBCC0\uD658 \uC911...");
+      const pdf = await convertBuffer(buffer, ".pdf", options?.timeoutMs);
+      emitter.progress(100, "\uBCC0\uD658 \uC644\uB8CC");
+      emitter.convertDone("\uBCC0\uD658 \uC644\uB8CC");
+      const result = {
+        success: true,
+        pdf: new Uint8Array(pdf),
+        sourceFormat: format
+      };
+      emitter.complete({
+        sourceFormat: format,
+        pdfSize: pdf.length
+      });
+      return result;
+    } catch (err) {
+      if (err instanceof ConvertError) {
+        emitter.error("convert", err.code, err.message);
+        return {
+          success: false,
+          code: err.code,
+          error: err.message,
+          stage: "convert"
+        };
+      }
+      const errorMsg = err instanceof Error ? err.message : "\uBCC0\uD658 \uC2E4\uD328";
+      emitter.error("convert", classifyError(err), errorMsg);
+      return {
+        success: false,
+        code: classifyError(err),
+        error: errorMsg,
+        stage: "convert"
+      };
+    } finally {
+      releaseLock();
+    }
+  } catch (unexpectedErr) {
+    const errorMsg = unexpectedErr instanceof Error ? unexpectedErr.message : "\uC608\uC0C1\uCE58 \uBABB\uD55C \uC624\uB958";
+    emitter.error("convert", "PARSE_ERROR", errorMsg);
+    return {
+      success: false,
+      code: "PARSE_ERROR",
+      error: errorMsg,
+      stage: "convert"
+    };
+  }
+}
+
+// src/pipeline/unified-ocr.ts
+import { performance } from "perf_hooks";
 var OCR_PROMPT = [
   "\uC774 PDF \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0\uC5D0\uC11C \uD14D\uC2A4\uD2B8\uC640 \uD45C\uB97C \uCD94\uCD9C\uD558\uC5EC Markdown\uC73C\uB85C \uBCC0\uD658\uD558\uACE0, OCR \uC624\uC778\uC2DD \uC624\uB958\uB97C \uC989\uC2DC \uAD50\uC815\uD558\uC5EC \uCD5C\uC885 \uACB0\uACFC\uBB3C\uC744 \uCD9C\uB825\uD558\uC138\uC694.",
   "",
@@ -9864,7 +10298,7 @@ async function parse2(input, options) {
   let buffer;
   if (typeof input === "string") {
     try {
-      const buf = await readFile(input);
+      const buf = await readFile2(input);
       buffer = toArrayBuffer(buf);
     } catch (err) {
       const msg = err instanceof Error && "code" in err && err.code === "ENOENT" ? `\uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${input}` : `\uD30C\uC77C \uC77D\uAE30 \uC2E4\uD328: ${input}`;
@@ -10199,6 +10633,7 @@ export {
   extractFormFields,
   markdownToHwpx,
   markdownToXlsx,
+  convertToPdf,
   parse2 as parse
 };
 /*! Bundled license information:
@@ -10206,4 +10641,4 @@ export {
 cfb/cfb.js:
   (*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com *)
 */
-//# sourceMappingURL=chunk-25ZYYLVP.js.map
+//# sourceMappingURL=chunk-BZPZXI66.js.map