hwp-convert 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { resolve as resolvePath, dirname, isAbsolute } from "node:path";
+import HwpxReader from "./lib/hwpxReader.js";
+import HwpxWriter from "./lib/writer.js";
+import { hwpToHwpx, hwpToText, hwpToMarkdown, markdownToHwpx, htmlToHwpx, } from "./lib/hwp/index.js";
+/**
+ * CLI(Node) 전용 fs 기반 이미지 resolver.
+ * md/html 안의 file://·절대/상대 경로 이미지를 읽어 BinData 로 임베드한다.
+ * (data URI 와 원격 URL 은 null → 코어가 처리하거나 스킵)
+ */
+function fsImageResolver(baseDir) {
+    return (src) => {
+        try {
+            if (/^data:/i.test(src) || /^https?:\/\//i.test(src))
+                return null;
+            const p = /^file:\/\//i.test(src)
+                ? fileURLToPath(src)
+                : isAbsolute(src)
+                    ? src
+                    : resolvePath(baseDir, src);
+            const data = new Uint8Array(readFileSync(p));
+            if (data.length === 0)
+                return null;
+            const ext = (p.split(".").pop() || "png").toLowerCase();
+            return { data, extension: ext };
+        }
+        catch {
+            return null;
+        }
+    };
+}
+async function main() {
+    const [command, inputPath, maybeOut] = process.argv.slice(2);
+    if (!command || !inputPath) {
+        console.error("Usage:\n" +
+            "  hwpxjs inspect <file.hwpx>\n" +
+            "  hwpxjs txt <file.hwpx|file.hwp>\n" +
+            "  hwpxjs html <file.hwpx>\n" +
+            "  hwpxjs md <file.hwpx|file.hwp>      # Markdown 추출\n" +
+            "  hwpxjs html:tpl <file.hwpx> <data.json>\n" +
+            "  hwpxjs batch <inFolder> <outFolder>\n" +
+            "  hwpxjs batch:tpl <inFolder> <dataFolder> <outFolder>\n" +
+            "  hwpxjs write:txt <textfile> <out.hwpx>\n" +
+            "  hwpxjs md:hwpx <file.md> <out.hwpx>    # Markdown → HWPX\n" +
+            "  hwpxjs html:hwpx <file.html> <out.hwpx># HTML → HWPX\n" +
+            "  hwpxjs convert:hwp <file.hwp> <out.hwpx>\n" +
+            "  hwpxjs hwp:txt <file.hwp>\n" +
+            "  hwpxjs hwp:md <file.hwp>");
+        process.exit(1);
+    }
+    if (command === "hwp:txt") {
+        const buf = await readFile(inputPath);
+        const ab = toArrayBuffer(buf);
+        const text = await hwpToText(new Uint8Array(ab));
+        console.log(text);
+        return;
+    }
+    if (command === "hwp:md") {
+        const buf = await readFile(inputPath);
+        const ab = toArrayBuffer(buf);
+        const md = await hwpToMarkdown(new Uint8Array(ab));
+        console.log(md);
+        return;
+    }
+    if (command === "md:hwpx") {
+        const outPath = maybeOut;
+        if (!outPath) {
+            console.error("Usage: hwpxjs md:hwpx <input.md> <output.hwpx>");
+            process.exit(1);
+        }
+        const md = await readFile(inputPath, "utf-8");
+        const bytes = await markdownToHwpx(md, {
+            imageResolver: fsImageResolver(dirname(resolvePath(inputPath))),
+        });
+        const { writeFile: wf } = await import("node:fs/promises");
+        await wf(outPath, bytes);
+        console.log(`Wrote ${outPath}`);
+        return;
+    }
+    if (command === "html:hwpx") {
+        const outPath = maybeOut;
+        if (!outPath) {
+            console.error("Usage: hwpxjs html:hwpx <input.html> <output.hwpx>");
+            process.exit(1);
+        }
+        const html = await readFile(inputPath, "utf-8");
+        const bytes = await htmlToHwpx(html, {
+            imageResolver: fsImageResolver(dirname(resolvePath(inputPath))),
+        });
+        const { writeFile: wf } = await import("node:fs/promises");
+        await wf(outPath, bytes);
+        console.log(`Wrote ${outPath}`);
+        return;
+    }
+    if (command === "convert:hwp") {
+        const outPath = maybeOut;
+        if (!outPath) {
+            console.error("Usage: hwpxjs convert:hwp <input.hwp> <output.hwpx>");
+            process.exit(1);
+        }
+        const buf = await readFile(inputPath);
+        const bytes = await hwpToHwpx(new Uint8Array(toArrayBuffer(buf)));
+        const { writeFile: wf } = await import("node:fs/promises");
+        await wf(outPath, bytes);
+        console.log(`Wrote ${outPath}`);
+        return;
+    }
+    if (command === "write:txt") {
+        const textPath = inputPath;
+        const outPath = maybeOut;
+        if (!outPath) {
+            console.error("Usage: hwpxjs write:txt <textfile> <out.hwpx>");
+            process.exit(1);
+        }
+        const { writeFile: wf } = await import("node:fs/promises");
+        const text = await readFile(textPath, "utf-8");
+        const writer = new HwpxWriter();
+        const bytes = await writer.createFromPlainText(text);
+        await wf(outPath, bytes);
+        console.log(`Wrote ${outPath}`);
+        return;
+    }
+    // 자동 감지: .hwp 파일이 들어오면 hwp:txt 로 라우팅
+    if (command === "txt" && /\.hwp$/i.test(inputPath)) {
+        const buf = await readFile(inputPath);
+        const ab = toArrayBuffer(buf);
+        const text = await hwpToText(new Uint8Array(ab));
+        console.log(text);
+        return;
+    }
+    if (command === "md") {
+        if (/\.hwp$/i.test(inputPath)) {
+            const buf = await readFile(inputPath);
+            const md = await hwpToMarkdown(new Uint8Array(toArrayBuffer(buf)));
+            console.log(md);
+            return;
+        }
+        // HWPX 경로
+        const buf = await readFile(inputPath);
+        const reader = new HwpxReader();
+        await reader.loadFromArrayBuffer(toArrayBuffer(buf));
+        const md = await reader.extractMarkdown();
+        console.log(md);
+        return;
+    }
+    const buf = await readFile(inputPath);
+    const ab = toArrayBuffer(buf);
+    const reader = new HwpxReader();
+    await reader.loadFromArrayBuffer(ab);
+    if (command === "inspect") {
+        const info = await reader.getDocumentInfo();
+        console.log(JSON.stringify(info, null, 2));
+        return;
+    }
+    if (command === "txt") {
+        const text = await reader.extractText();
+        console.log(text);
+        return;
+    }
+    if (command === "html") {
+        const html = await reader.extractHtml({ embedImages: true });
+        console.log(html);
+        return;
+    }
+    if (command === "html:tpl") {
+        const dataPath = maybeOut;
+        if (!dataPath) {
+            console.error("Usage: hwpxjs html:tpl <in.hwpx> <data.json>");
+            process.exit(1);
+        }
+        const { readFile: rf } = await import("node:fs/promises");
+        const json = JSON.parse(await rf(dataPath, "utf-8"));
+        const rawText = await reader.extractText({});
+        const replaced = reader
+            .applyTemplateToText(rawText, json);
+        const html = replaced
+            .split(/\n+/)
+            .map((line) => `<p>${line.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</p>`)
+            .join("");
+        console.log(html);
+        return;
+    }
+    if (command === "batch") {
+        const inDir = inputPath;
+        const outDir = maybeOut;
+        if (!outDir) {
+            console.error("Usage: hwpxjs batch <inFolder> <outFolder>");
+            process.exit(1);
+        }
+        const { readdir, readFile: rf, writeFile, mkdir } = await import("node:fs/promises");
+        const { join } = await import("node:path");
+        await mkdir(outDir, { recursive: true });
+        const entries = await readdir(inDir);
+        for (const name of entries) {
+            if (!name.toLowerCase().endsWith(".hwpx"))
+                continue;
+            const inPath = join(inDir, name);
+            const buf2 = await rf(inPath);
+            const reader2 = new HwpxReader();
+            await reader2.loadFromArrayBuffer(toArrayBuffer(buf2));
+            const html = await reader2.extractHtml({ embedImages: true });
+            const outName = name.replace(/\.hwpx$/i, ".html");
+            const outPath = join(outDir, outName);
+            await writeFile(outPath, html, "utf-8");
+            console.log(`Wrote ${outPath}`);
+        }
+        return;
+    }
+    if (command === "batch:tpl") {
+        const inDir = inputPath;
+        const dataDir = maybeOut;
+        const outDir = process.argv[5];
+        if (!dataDir || !outDir) {
+            console.error("Usage: hwpxjs batch:tpl <inFolder> <dataFolder> <outFolder>");
+            process.exit(1);
+        }
+        const { readdir, readFile: rf, writeFile, mkdir } = await import("node:fs/promises");
+        const { join, basename } = await import("node:path");
+        await mkdir(outDir, { recursive: true });
+        const entries = await readdir(inDir);
+        for (const name of entries) {
+            if (!name.toLowerCase().endsWith(".hwpx"))
+                continue;
+            const inPath = join(inDir, name);
+            const buf2 = await rf(inPath);
+            const reader2 = new HwpxReader();
+            await reader2.loadFromArrayBuffer(toArrayBuffer(buf2));
+            const jsonName = basename(name, ".hwpx") + ".json";
+            let json = {};
+            try {
+                json = JSON.parse(await rf(join(dataDir, jsonName), "utf-8"));
+            }
+            catch {
+                try {
+                    json = JSON.parse(await rf(join(dataDir, "default.json"), "utf-8"));
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            const rawText = await reader2.extractText({});
+            const replaced = reader2
+                .applyTemplateToText(rawText, json);
+            const html = replaced
+                .split(/\n+/)
+                .map((line) => `<p>${line.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</p>`)
+                .join("");
+            const outName = name.replace(/\.hwpx$/i, ".html");
+            const outPath = join(outDir, outName);
+            await writeFile(outPath, html, "utf-8");
+            console.log(`Wrote ${outPath}`);
+        }
+        return;
+    }
+    console.error("Unknown command:", command);
+    process.exit(1);
+}
+function toArrayBuffer(buf) {
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+main().catch((err) => {
+    console.error(err?.message || err);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./lib/hwpxReader.js";
+export * from "./lib/types.js";
+export * from "./lib/errors.js";
+export * from "./lib/writer.js";
+export * from "./lib/hwp/index.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./lib/hwpxReader.js";
+export * from "./lib/types.js";
+export * from "./lib/errors.js";
+export * from "./lib/writer.js";
+export * from "./lib/hwp/index.js";

package/dist/lib/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class HwpxNotLoadedError extends Error {
+    constructor();
+}
+export declare class HwpxEncryptedDocumentError extends Error {
+    constructor(message?: string);
+}
+export declare class InvalidHwpxFormatError extends Error {
+    constructor(message?: string);
+}

package/dist/lib/errors.js

@@ -0,0 +1,18 @@
+export class HwpxNotLoadedError extends Error {
+    constructor() {
+        super("HWPX가 로드되지 않았습니다. loadFromArrayBuffer를 먼저 호출하세요.");
+        this.name = "HwpxNotLoadedError";
+    }
+}
+export class HwpxEncryptedDocumentError extends Error {
+    constructor(message = "암호화된 HWPX 문서는 현재 지원하지 않습니다.") {
+        super(message);
+        this.name = "HwpxEncryptedDocumentError";
+    }
+}
+export class InvalidHwpxFormatError extends Error {
+    constructor(message = "유효한 HWPX(mimetype: application/hwp+zip) 문서가 아닙니다.") {
+        super(message);
+        this.name = "InvalidHwpxFormatError";
+    }
+}

package/dist/lib/hwp/binData.d.ts

@@ -0,0 +1,15 @@
+/**
+ * BinData (CFB Storage) 에서 임베디드 이미지/OLE 데이터 추출.
+ *
+ * /BinData/BIN0001.png, BIN0002.jpg, ... 패턴.
+ * DocInfo의 BIN_DATA 레코드와 storageId 로 연결됨.
+ *
+ * 원작: rhwp/src/parser/bin_data.rs (MIT, Edward Kim)
+ */
+import type { HwpCfbReader } from "./cfbReader.js";
+import type { HwpBinDataRef } from "./types.js";
+export declare function loadBinDataContent(cfb: HwpCfbReader, refs: HwpBinDataRef[]): Map<number, {
+    data: Uint8Array;
+    extension: string;
+}>;
+export declare function detectImageMime(extension: string): string;

package/dist/lib/hwp/binData.js

@@ -0,0 +1,64 @@
+/**
+ * BinData (CFB Storage) 에서 임베디드 이미지/OLE 데이터 추출.
+ *
+ * /BinData/BIN0001.png, BIN0002.jpg, ... 패턴.
+ * DocInfo의 BIN_DATA 레코드와 storageId 로 연결됨.
+ *
+ * 원작: rhwp/src/parser/bin_data.rs (MIT, Edward Kim)
+ */
+const CFB_MAGIC = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+export function loadBinDataContent(cfb, refs) {
+    const out = new Map();
+    for (const ref of refs) {
+        if (ref.type === "link")
+            continue;
+        const isStorage = ref.type === "storage";
+        const ext = ref.extension ?? (isStorage ? "OLE" : "dat");
+        // 파일명: BIN{XXXX}.{ext} (4자리 hex, 대문자/소문자 둘 다 시도)
+        const idHex = ref.storageId.toString(16).padStart(4, "0");
+        const candidates = [
+            `/BinData/BIN${idHex.toUpperCase()}.${ext}`,
+            `/BinData/BIN${idHex.toLowerCase()}.${ext}`,
+        ];
+        let bytes = null;
+        for (const path of candidates) {
+            bytes = cfb.readBinData(path);
+            if (bytes)
+                break;
+        }
+        if (!bytes)
+            continue;
+        // OLE Storage 의 경우 선두 4바이트 size prefix 가 붙는 경우가 있어 정리
+        if (isStorage && bytes.byteLength > 12) {
+            const headIsCfb = bytes[0] === CFB_MAGIC[0] &&
+                bytes[1] === CFB_MAGIC[1] &&
+                bytes[2] === CFB_MAGIC[2] &&
+                bytes[3] === CFB_MAGIC[3];
+            const cfbAt4 = bytes[4] === CFB_MAGIC[0] &&
+                bytes[5] === CFB_MAGIC[1] &&
+                bytes[6] === CFB_MAGIC[2] &&
+                bytes[7] === CFB_MAGIC[3];
+            if (!headIsCfb && cfbAt4) {
+                bytes = bytes.subarray(4);
+            }
+        }
+        out.set(ref.storageId, { data: new Uint8Array(bytes), extension: ext });
+    }
+    return out;
+}
+export function detectImageMime(extension) {
+    const ext = extension.toLowerCase();
+    if (ext === "png")
+        return "image/png";
+    if (ext === "jpg" || ext === "jpeg")
+        return "image/jpeg";
+    if (ext === "gif")
+        return "image/gif";
+    if (ext === "bmp")
+        return "image/bmp";
+    if (ext === "webp")
+        return "image/webp";
+    if (ext === "svg")
+        return "image/svg+xml";
+    return "application/octet-stream";
+}

package/dist/lib/hwp/bodyText.d.ts

@@ -0,0 +1,31 @@
+/**
+ * BodyText 섹션 파싱 — 계층 파싱.
+ *
+ * 레코드 트리:
+ *   PARA_HEADER (level=0)
+ *     PARA_TEXT       (level=1)
+ *     PARA_CHAR_SHAPE (level=1)
+ *     PARA_LINE_SEG   (level=1)
+ *     CTRL_HEADER     (level=1)  ← 표/그림/머리말 등
+ *       TABLE         (level=2)
+ *       LIST_HEADER   (level=2)  ← 셀
+ *         PARA_HEADER (level=3)
+ *           PARA_TEXT (level=4)
+ *
+ * 외곽 파라그래프와 셀 안 파라그래프는 분리되어 보존된다.
+ *
+ * 원작: rhwp/src/parser/body_text.rs (MIT, Edward Kim)
+ */
+import { type Record } from "./record.js";
+import type { HwpParagraph, HwpSection } from "./types.js";
+export declare class BodyTextError extends Error {
+    constructor(msg: string);
+}
+export declare function parseBodyTextSection(data: Uint8Array): HwpSection;
+/**
+ * 주어진 레코드 시퀀스에서 baseLevel 인 PARA_HEADER 들을 찾아 문단 목록으로 변환.
+ *
+ * @param records 정렬된 레코드 시퀀스 (서브트리 또는 전체)
+ * @param baseLevel 추출 대상 PARA_HEADER 의 레벨 (보통 외부 컨테이너 레벨 + 1, 섹션 최상위면 0)
+ */
+export declare function parseParagraphList(records: Record[], baseLevel: number): HwpParagraph[];

package/dist/lib/hwp/bodyText.js

@@ -0,0 +1,208 @@
+/**
+ * BodyText 섹션 파싱 — 계층 파싱.
+ *
+ * 레코드 트리:
+ *   PARA_HEADER (level=0)
+ *     PARA_TEXT       (level=1)
+ *     PARA_CHAR_SHAPE (level=1)
+ *     PARA_LINE_SEG   (level=1)
+ *     CTRL_HEADER     (level=1)  ← 표/그림/머리말 등
+ *       TABLE         (level=2)
+ *       LIST_HEADER   (level=2)  ← 셀
+ *         PARA_HEADER (level=3)
+ *           PARA_TEXT (level=4)
+ *
+ * 외곽 파라그래프와 셀 안 파라그래프는 분리되어 보존된다.
+ *
+ * 원작: rhwp/src/parser/body_text.rs (MIT, Edward Kim)
+ */
+import { ByteReader } from "./byteReader.js";
+import { readAllRecords } from "./record.js";
+import { HWPTAG_PARA_HEADER, HWPTAG_PARA_TEXT, HWPTAG_PARA_CHAR_SHAPE, HWPTAG_CTRL_HEADER, } from "./tags.js";
+import { parseCtrlHeader } from "./control.js";
+export class BodyTextError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = "BodyTextError";
+    }
+}
+export function parseBodyTextSection(data) {
+    const records = readAllRecords(data);
+    // 섹션의 최상위 PARA_HEADER 들 (보통 level=0)
+    const topLevel = records.length > 0 ? records[0].level : 0;
+    return { paragraphs: parseParagraphList(records, topLevel) };
+}
+/**
+ * 주어진 레코드 시퀀스에서 baseLevel 인 PARA_HEADER 들을 찾아 문단 목록으로 변환.
+ *
+ * @param records 정렬된 레코드 시퀀스 (서브트리 또는 전체)
+ * @param baseLevel 추출 대상 PARA_HEADER 의 레벨 (보통 외부 컨테이너 레벨 + 1, 섹션 최상위면 0)
+ */
+export function parseParagraphList(records, baseLevel) {
+    const paragraphs = [];
+    for (let i = 0; i < records.length; i++) {
+        const rec = records[i];
+        if (rec.tagId !== HWPTAG_PARA_HEADER)
+            continue;
+        if (rec.level !== baseLevel)
+            continue;
+        // 자기 서브트리 종료점: level <= baseLevel 이 다시 등장하는 위치
+        let end = i + 1;
+        while (end < records.length && records[end].level > baseLevel)
+            end++;
+        const paraRecords = records.slice(i, end);
+        paragraphs.push(buildParagraph(paraRecords));
+        i = end - 1;
+    }
+    return paragraphs;
+}
+function buildParagraph(records) {
+    const header = records[0];
+    const headerInfo = parseParaHeader(header.data);
+    const baseLevel = header.level;
+    let text = "";
+    let charShapeChanges = [];
+    const controls = [];
+    for (let j = 1; j < records.length; j++) {
+        const r = records[j];
+        if (r.level !== baseLevel + 1)
+            continue; // 직접 자식만
+        switch (r.tagId) {
+            case HWPTAG_PARA_TEXT: {
+                text = parseParaText(r.data);
+                break;
+            }
+            case HWPTAG_PARA_CHAR_SHAPE: {
+                charShapeChanges = parseParaCharShape(r.data);
+                break;
+            }
+            case HWPTAG_CTRL_HEADER: {
+                // CTRL_HEADER 의 자식 (level > baseLevel+1) 수집
+                const ctrlChildren = [];
+                for (let k = j + 1; k < records.length; k++) {
+                    if (records[k].level <= baseLevel + 1)
+                        break;
+                    ctrlChildren.push(records[k]);
+                }
+                const ctrl = parseCtrlHeader(r, ctrlChildren, parseParagraphList);
+                controls.push(ctrl);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return {
+        paraShapeId: headerInfo.paraShapeId,
+        styleId: headerInfo.styleId,
+        text,
+        runs: buildRuns(text, charShapeChanges),
+        controls,
+    };
+}
+function parseParaHeader(data) {
+    const r = new ByteReader(data);
+    const nCharsRaw = r.remaining() >= 4 ? r.readU32() : 0;
+    const charCount = nCharsRaw & 0x7fffffff;
+    const controlMask = r.remaining() >= 4 ? r.readU32() : 0;
+    const paraShapeId = r.remaining() >= 2 ? r.readU16() : 0;
+    const styleId = r.remaining() >= 1 ? r.readU8() : 0;
+    return { charCount, controlMask, paraShapeId, styleId };
+}
+/**
+ * PARA_TEXT 디코딩 (텍스트만; 컨트롤 위치는 buildParagraph 의 CTRL_HEADER 처리에서 별도 추적).
+ *
+ * 컨트롤 문자 분류 (HWP 5.0 표 6):
+ *   - 1 word (2바이트): 0, 10 (LF), 13 (para break — 종료), 24~31
+ *   - 8 word (16바이트): 1~8, 11~12, 14~23
+ *   - 9 (탭): 8 word
+ */
+function parseParaText(data) {
+    let text = "";
+    let pos = 0;
+    const end = data.byteLength;
+    while (pos + 1 < end) {
+        const ch = data[pos] | (data[pos + 1] << 8);
+        if (ch === 0) {
+            pos += 2;
+        }
+        else if (ch === 0x09) {
+            text += "\t";
+            pos += 16;
+        }
+        else if (ch === 0x0a) {
+            text += "\n";
+            pos += 2;
+        }
+        else if (ch === 0x0d) {
+            break;
+        }
+        else if (isExtendedCtrl(ch)) {
+            pos += 16;
+        }
+        else if (ch < 0x20) {
+            switch (ch) {
+                case 0x18:
+                    text += " ";
+                    break;
+                case 0x19:
+                    text += " ";
+                    break;
+                case 0x1e:
+                    text += "-";
+                    break;
+                case 0x1f:
+                    text += " ";
+                    break;
+                default:
+                    break;
+            }
+            pos += 2;
+        }
+        else {
+            if (ch >= 0xd800 && ch <= 0xdbff && pos + 3 < end) {
+                const low = data[pos + 2] | (data[pos + 3] << 8);
+                if (low >= 0xdc00 && low <= 0xdfff) {
+                    text += String.fromCharCode(ch, low);
+                    pos += 4;
+                    continue;
+                }
+            }
+            text += String.fromCharCode(ch);
+            pos += 2;
+        }
+    }
+    return text;
+}
+function isExtendedCtrl(ch) {
+    return ((ch >= 1 && ch <= 8) ||
+        ch === 11 ||
+        ch === 12 ||
+        (ch >= 14 && ch <= 23));
+}
+function parseParaCharShape(data) {
+    const r = new ByteReader(data);
+    const out = [];
+    while (r.remaining() >= 8) {
+        const charPos = r.readU32();
+        const charShapeId = r.readU32();
+        out.push({ charPos, charShapeId });
+    }
+    return out;
+}
+function buildRuns(text, changes) {
+    if (text.length === 0)
+        return [];
+    if (changes.length === 0)
+        return [{ charShapeId: 0, text }];
+    const sorted = [...changes].sort((a, b) => a.charPos - b.charPos);
+    const runs = [];
+    for (let i = 0; i < sorted.length; i++) {
+        const start = sorted[i].charPos;
+        const stop = i + 1 < sorted.length ? sorted[i + 1].charPos : text.length;
+        if (stop > start) {
+            runs.push({ charShapeId: sorted[i].charShapeId, text: text.slice(start, stop) });
+        }
+    }
+    return runs;
+}

package/dist/lib/hwp/byteReader.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 바이너리 데이터 읽기 유틸리티 (커서 기반).
+ * HWP 5.0 스트림은 모두 little-endian, 문자열은 UTF-16LE.
+ *
+ * 원작: rhwp/src/parser/byte_reader.rs (MIT, Copyright (c) 2025-2026 Edward Kim)
+ */
+export declare class ByteReader {
+    private view;
+    private offset;
+    private readonly end;
+    constructor(data: Uint8Array, offset?: number, length?: number);
+    /** 현재 위치 (바이트 오프셋, 시작점 기준) */
+    position(): number;
+    /** 남은 바이트 */
+    remaining(): number;
+    isEmpty(): boolean;
+    setPosition(pos: number): void;
+    skip(n: number): void;
+    readU8(): number;
+    readU16(): number;
+    readU32(): number;
+    readI8(): number;
+    readI16(): number;
+    readI32(): number;
+    /** i64 (BigInt). HWP에서는 거의 등장하지 않지만 호환을 위해. */
+    readI64(): bigint;
+    /** 지정 길이 바이트를 복사하지 않고 sub-view 반환 (Uint8Array) */
+    readBytes(len: number): Uint8Array;
+    /** 남은 전부 */
+    readRemaining(): Uint8Array;
+    /**
+     * HWP 문자열: [u16 charCount] + [UTF-16LE bytes * charCount].
+     */
+    readHwpString(): string;
+    /** 지정 글자 수의 UTF-16LE 문자열 */
+    readUtf16(charCount: number): string;
+    /** ColorRef (0x00BBGGRR) — u32 그대로 */
+    readColorRef(): number;
+    private ensure;
+}