hwp-convert 1.0.0

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

@@ -0,0 +1,26 @@
+/**
+ * DocInfo 스트림 파싱 — 1차 포팅.
+ *
+ * 1차 범위: BIN_DATA, FACE_NAME, CHAR_SHAPE, PARA_SHAPE, STYLE.
+ * BORDER_FILL/NUMBERING/BULLET/TAB_DEF 등은 2차 단계.
+ *
+ * 원작: rhwp/src/parser/doc_info.rs (MIT, Edward Kim)
+ */
+import type { HwpDocInfo } from "./types.js";
+export declare class DocInfoError extends Error {
+    constructor(msg: string);
+}
+export interface DocProperties {
+    sectionCount: number;
+    pageStartNum: number;
+    footnoteStartNum: number;
+    endnoteStartNum: number;
+    pictureStartNum: number;
+    tableStartNum: number;
+    equationStartNum: number;
+}
+export interface DocInfoParseResult {
+    docInfo: HwpDocInfo;
+    docProperties: DocProperties;
+}
+export declare function parseDocInfo(data: Uint8Array): DocInfoParseResult;

package/dist/lib/hwp/docInfo.js

@@ -0,0 +1,396 @@
+/**
+ * DocInfo 스트림 파싱 — 1차 포팅.
+ *
+ * 1차 범위: BIN_DATA, FACE_NAME, CHAR_SHAPE, PARA_SHAPE, STYLE.
+ * BORDER_FILL/NUMBERING/BULLET/TAB_DEF 등은 2차 단계.
+ *
+ * 원작: rhwp/src/parser/doc_info.rs (MIT, Edward Kim)
+ */
+import { ByteReader } from "./byteReader.js";
+import { readAllRecords } from "./record.js";
+import { HWPTAG_DOCUMENT_PROPERTIES, HWPTAG_ID_MAPPINGS, HWPTAG_BIN_DATA, HWPTAG_FACE_NAME, HWPTAG_BORDER_FILL, HWPTAG_CHAR_SHAPE, HWPTAG_TAB_DEF, HWPTAG_NUMBERING, HWPTAG_BULLET, HWPTAG_PARA_SHAPE, HWPTAG_STYLE, } from "./tags.js";
+export class DocInfoError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = "DocInfoError";
+    }
+}
+const DEFAULT_DOC_PROPS = {
+    sectionCount: 1,
+    pageStartNum: 1,
+    footnoteStartNum: 1,
+    endnoteStartNum: 1,
+    pictureStartNum: 1,
+    tableStartNum: 1,
+    equationStartNum: 1,
+};
+export function parseDocInfo(data) {
+    const records = readAllRecords(data);
+    const binData = [];
+    const fontFaces = Array.from({ length: 7 }, () => []);
+    const charShapes = [];
+    const paraShapes = [];
+    const styles = [];
+    const borderFills = [];
+    const numberings = [];
+    const bullets = [];
+    const tabDefs = [];
+    let docProps = { ...DEFAULT_DOC_PROPS };
+    let idMappings = null;
+    let currentLang = 0;
+    const langConsumed = [0, 0, 0, 0, 0, 0, 0];
+    for (const rec of records) {
+        switch (rec.tagId) {
+            case HWPTAG_DOCUMENT_PROPERTIES:
+                docProps = parseDocumentProperties(rec.data);
+                break;
+            case HWPTAG_ID_MAPPINGS:
+                idMappings = parseIdMappings(rec.data);
+                break;
+            case HWPTAG_BIN_DATA:
+                binData.push(parseBinData(rec.data));
+                break;
+            case HWPTAG_FACE_NAME: {
+                const font = parseFaceName(rec.data);
+                if (idMappings) {
+                    while (currentLang < 7 &&
+                        langConsumed[currentLang] >= idMappings.fontCounts[currentLang]) {
+                        currentLang++;
+                    }
+                    if (currentLang < 7) {
+                        fontFaces[currentLang].push(font);
+                        langConsumed[currentLang]++;
+                    }
+                    else {
+                        fontFaces[6].push(font);
+                    }
+                }
+                else {
+                    fontFaces[0].push(font);
+                }
+                break;
+            }
+            case HWPTAG_BORDER_FILL:
+                borderFills.push(parseBorderFill(rec.data));
+                break;
+            case HWPTAG_CHAR_SHAPE:
+                charShapes.push(parseCharShape(rec.data));
+                break;
+            case HWPTAG_TAB_DEF:
+                tabDefs.push(parseTabDef(rec.data));
+                break;
+            case HWPTAG_NUMBERING:
+                numberings.push(parseNumbering(rec.data));
+                break;
+            case HWPTAG_BULLET:
+                bullets.push(parseBullet(rec.data));
+                break;
+            case HWPTAG_PARA_SHAPE:
+                paraShapes.push(parseParaShape(rec.data));
+                break;
+            case HWPTAG_STYLE:
+                styles.push(parseStyle(rec.data));
+                break;
+            default:
+                break;
+        }
+    }
+    return {
+        docInfo: {
+            fontFaces,
+            charShapes,
+            paraShapes,
+            styles,
+            binData,
+            borderFills,
+            numberings,
+            bullets,
+            tabDefs,
+        },
+        docProperties: docProps,
+    };
+}
+function parseBorderFill(data) {
+    const r = new ByteReader(data);
+    const attr = r.remaining() >= 2 ? r.readU16() : 0;
+    // 4면 테두리: 좌/우/상/하 인터리브 — { type u8, width u8, color u32 }
+    const readBorder = () => {
+        if (r.remaining() < 6) {
+            return { lineType: 1, widthIndex: 0, color: 0 };
+        }
+        const lineType = r.readU8();
+        const widthIndex = r.readU8();
+        const color = r.readColorRef();
+        return { lineType, widthIndex, color };
+    };
+    const borders = [
+        readBorder(),
+        readBorder(),
+        readBorder(),
+        readBorder(),
+    ];
+    // 대각선
+    let diagonal = { diagonalType: 0, widthIndex: 0, color: 0 };
+    if (r.remaining() >= 6) {
+        diagonal = {
+            diagonalType: r.readU8(),
+            widthIndex: r.readU8(),
+            color: r.readColorRef(),
+        };
+    }
+    // 채우기: u32 fillType 비트마스크 + 종류별 데이터
+    let fill;
+    if (r.remaining() >= 4) {
+        const fillType = r.readU32();
+        if (fillType === 0) {
+            // 채우기 없음: hwplib 기준 4바이트 추가 skip
+            if (r.remaining() >= 4)
+                r.skip(4);
+        }
+        else if ((fillType & 0x01) !== 0) {
+            // solid
+            if (r.remaining() >= 12) {
+                fill = {
+                    backgroundColor: r.readColorRef(),
+                    patternColor: r.readColorRef(),
+                    patternType: r.readI32(),
+                };
+            }
+            // gradient/image 는 1차 포팅에서 무시 (이후 바이트 무시)
+        }
+    }
+    return { attr, borders, diagonal, fill };
+}
+function parseTabDef(data) {
+    const r = new ByteReader(data);
+    const attr = r.remaining() >= 4 ? r.readU32() : 0;
+    return {
+        attr,
+        autoTabLeft: (attr & 0x01) !== 0,
+        autoTabRight: (attr & 0x02) !== 0,
+    };
+}
+function parseNumbering(data) {
+    const r = new ByteReader(data);
+    const levelFormats = ["", "", "", "", "", "", ""];
+    // 7 레벨 × { attr(u32) + widthAdjust(i16) + textDistance(i16) + charShapeId(u32) + formatLen(u16) + WCHAR[formatLen] }
+    for (let level = 0; level < 7; level++) {
+        if (r.remaining() < 12)
+            break;
+        r.readU32(); // attr
+        r.readI16(); // widthAdjust
+        r.readI16(); // textDistance
+        r.readU32(); // charShapeId
+        if (r.remaining() < 2)
+            break;
+        const formatLen = r.readU16();
+        if (formatLen > 0 && r.remaining() >= formatLen * 2) {
+            try {
+                levelFormats[level] = r.readUtf16(formatLen);
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+    const startNumber = r.remaining() >= 2 ? r.readU16() : 1;
+    return { startNumber, levelFormats };
+}
+function parseBullet(data) {
+    const r = new ByteReader(data);
+    // attr(u32) + widthAdjust(i16) + textDistance(i16) + charShapeId(u32)
+    if (r.remaining() < 12)
+        return { bulletChar: "●" };
+    r.readU32();
+    r.readI16();
+    r.readI16();
+    r.readU32();
+    if (r.remaining() < 2)
+        return { bulletChar: "●" };
+    const bulletCharCode = r.readU16();
+    const bulletChar = bulletCharCode > 0 ? String.fromCharCode(bulletCharCode) : "●";
+    return { bulletChar };
+}
+function parseIdMappings(data) {
+    const r = new ByteReader(data);
+    const safe = (n) => (r.remaining() >= 4 ? r.readU32() : n);
+    return {
+        binDataCount: safe(0),
+        fontCounts: [safe(0), safe(0), safe(0), safe(0), safe(0), safe(0), safe(0)],
+        borderFillCount: safe(0),
+        charShapeCount: safe(0),
+        tabDefCount: safe(0),
+        numberingCount: safe(0),
+        bulletCount: safe(0),
+        paraShapeCount: safe(0),
+        styleCount: safe(0),
+    };
+}
+function parseDocumentProperties(data) {
+    const r = new ByteReader(data);
+    const safe = (n) => (r.remaining() >= 2 ? r.readU16() : n);
+    return {
+        sectionCount: safe(1),
+        pageStartNum: safe(1),
+        footnoteStartNum: safe(1),
+        endnoteStartNum: safe(1),
+        pictureStartNum: safe(1),
+        tableStartNum: safe(1),
+        equationStartNum: safe(1),
+    };
+}
+function parseBinData(data) {
+    const r = new ByteReader(data);
+    const attr = r.readU16();
+    const typeBits = attr & 0x000f;
+    let type;
+    switch (typeBits) {
+        case 0:
+            type = "link";
+            break;
+        case 1:
+            type = "embedding";
+            break;
+        case 2:
+            type = "storage";
+            break;
+        default:
+            type = "link";
+            break;
+    }
+    if (type === "link") {
+        // absPath, relPath — 1차 포팅에서는 무시
+        safeReadHwpString(r);
+        safeReadHwpString(r);
+        return { storageId: 0, type };
+    }
+    const storageId = r.remaining() >= 2 ? r.readU16() : 0;
+    const extension = safeReadHwpString(r);
+    return { storageId, extension, type };
+}
+function parseFaceName(data) {
+    const r = new ByteReader(data);
+    const attr = r.readU8();
+    const name = safeReadHwpString(r) ?? "";
+    let substituteName;
+    if ((attr & 0x80) !== 0) {
+        substituteName = safeReadHwpString(r);
+    }
+    return { name, substituteName };
+}
+function parseCharShape(data) {
+    const r = new ByteReader(data);
+    const fontIds = [];
+    for (let i = 0; i < 7; i++)
+        fontIds.push(r.readU16());
+    // ratios u8x7
+    for (let i = 0; i < 7; i++)
+        r.readU8();
+    // spacings i8x7
+    for (let i = 0; i < 7; i++)
+        r.readI8();
+    // relativeSizes u8x7
+    for (let i = 0; i < 7; i++)
+        r.readU8();
+    // charOffsets i8x7
+    for (let i = 0; i < 7; i++)
+        r.readI8();
+    const baseSize = r.readI32();
+    const attr = r.readU32();
+    // shadow_offset_x, shadow_offset_y (i8 x 2)
+    r.readI8();
+    r.readI8();
+    const textColor = r.readColorRef();
+    const underlineColor = r.readColorRef();
+    const shadeColor = r.readColorRef();
+    const shadowColor = r.readColorRef();
+    return {
+        faceNameIds: {
+            hangul: fontIds[0],
+            latin: fontIds[1],
+            hanja: fontIds[2],
+            japanese: fontIds[3],
+            other: fontIds[4],
+            symbol: fontIds[5],
+            user: fontIds[6],
+        },
+        baseSize,
+        property: attr,
+        textColor,
+        shadeColor,
+        underlineColor,
+        shadowColor,
+        bold: (attr & 0x02) !== 0,
+        italic: (attr & 0x01) !== 0,
+        underline: ((attr >>> 2) & 0x03) !== 0,
+        strikeout: ((attr >>> 18) & 0x07) > 1,
+    };
+}
+function parseParaShape(data) {
+    const r = new ByteReader(data);
+    const attr1 = r.readU32();
+    const leftMargin = r.readI32();
+    const rightMargin = r.readI32();
+    const indent = r.readI32();
+    const prevSpacing = r.readI32();
+    const nextSpacing = r.readI32();
+    const lineSpacing = r.readI32();
+    const alignBits = (attr1 >>> 2) & 0x07;
+    let alignment;
+    switch (alignBits) {
+        case 0:
+            alignment = "justify";
+            break;
+        case 1:
+            alignment = "left";
+            break;
+        case 2:
+            alignment = "right";
+            break;
+        case 3:
+            alignment = "center";
+            break;
+        case 4:
+            alignment = "distribute";
+            break;
+        case 5:
+            alignment = "distributeSpace";
+            break;
+        default:
+            alignment = "unknown";
+    }
+    return {
+        alignment,
+        property: attr1,
+        leftMargin,
+        rightMargin,
+        indent,
+        prevSpacing,
+        nextSpacing,
+        lineSpacing,
+    };
+}
+function parseStyle(data) {
+    const r = new ByteReader(data);
+    const name = safeReadHwpString(r) ?? "";
+    const engName = safeReadHwpString(r);
+    // properties u8, next u8, lang u8 — 일단 skip
+    if (r.remaining() >= 3) {
+        r.readU8();
+        r.readU8();
+        r.readU8();
+    }
+    const paraShapeId = r.remaining() >= 2 ? r.readU16() : 0;
+    const charShapeId = r.remaining() >= 2 ? r.readU16() : 0;
+    return { name, engName, paraShapeId, charShapeId };
+}
+function safeReadHwpString(r) {
+    if (r.remaining() < 2)
+        return undefined;
+    try {
+        return r.readHwpString();
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,42 @@
+/**
+ * HWP FileHeader 스트림 (256바이트, 비압축).
+ *   0..31  : 시그니처 "HWP Document File" + NULL 패딩
+ *   32..35 : 버전 (revision, build, minor, major) — LE
+ *   36..39 : 속성 플래그 (u32 LE)
+ *   40..   : 예약
+ *
+ * 원작: rhwp/src/parser/header.rs (MIT, Copyright (c) 2025-2026 Edward Kim)
+ */
+export declare const HWP_SIGNATURE = "HWP Document File";
+export declare const FILE_HEADER_SIZE = 256;
+export interface HwpVersion {
+    major: number;
+    minor: number;
+    build: number;
+    revision: number;
+}
+export declare function versionToString(v: HwpVersion): string;
+export declare function isVersionSupported(v: HwpVersion): boolean;
+export interface FileHeaderFlags {
+    raw: number;
+    compressed: boolean;
+    encrypted: boolean;
+    distribution: boolean;
+    script: boolean;
+    drm: boolean;
+    xmlTemplate: boolean;
+    documentHistory: boolean;
+    digitalSignature: boolean;
+    publicKeyEncrypted: boolean;
+    modifiedCertificate: boolean;
+    prepareDistribution: boolean;
+}
+export declare function parseFlags(raw: number): FileHeaderFlags;
+export interface FileHeader {
+    version: HwpVersion;
+    flags: FileHeaderFlags;
+}
+export declare class HwpHeaderError extends Error {
+    constructor(msg: string);
+}
+export declare function parseFileHeader(data: Uint8Array): FileHeader;

package/dist/lib/hwp/fileHeader.js

@@ -0,0 +1,66 @@
+/**
+ * HWP FileHeader 스트림 (256바이트, 비압축).
+ *   0..31  : 시그니처 "HWP Document File" + NULL 패딩
+ *   32..35 : 버전 (revision, build, minor, major) — LE
+ *   36..39 : 속성 플래그 (u32 LE)
+ *   40..   : 예약
+ *
+ * 원작: rhwp/src/parser/header.rs (MIT, Copyright (c) 2025-2026 Edward Kim)
+ */
+export const HWP_SIGNATURE = "HWP Document File";
+export const FILE_HEADER_SIZE = 256;
+export function versionToString(v) {
+    return `${v.major}.${v.minor}.${v.build}.${v.revision}`;
+}
+export function isVersionSupported(v) {
+    return v.major === 5 && (v.minor === 0 || v.minor === 1);
+}
+export function parseFlags(raw) {
+    return {
+        raw,
+        compressed: (raw & 0x001) !== 0,
+        encrypted: (raw & 0x002) !== 0,
+        distribution: (raw & 0x004) !== 0,
+        script: (raw & 0x008) !== 0,
+        drm: (raw & 0x010) !== 0,
+        xmlTemplate: (raw & 0x020) !== 0,
+        documentHistory: (raw & 0x040) !== 0,
+        digitalSignature: (raw & 0x080) !== 0,
+        publicKeyEncrypted: (raw & 0x100) !== 0,
+        modifiedCertificate: (raw & 0x200) !== 0,
+        prepareDistribution: (raw & 0x400) !== 0,
+    };
+}
+export class HwpHeaderError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = "HwpHeaderError";
+    }
+}
+const ASCII = new TextDecoder("ascii");
+export function parseFileHeader(data) {
+    if (data.byteLength < FILE_HEADER_SIZE) {
+        throw new HwpHeaderError(`FileHeader 크기 부족: ${data.byteLength} (최소 ${FILE_HEADER_SIZE})`);
+    }
+    // 시그니처 (0..31, NULL 종료)
+    const sigArea = data.subarray(0, 32);
+    let sigEnd = sigArea.indexOf(0);
+    if (sigEnd === -1)
+        sigEnd = 32;
+    const sig = ASCII.decode(sigArea.subarray(0, sigEnd));
+    if (!sig.startsWith(HWP_SIGNATURE)) {
+        throw new HwpHeaderError(`HWP 시그니처가 일치하지 않습니다: "${sig}"`);
+    }
+    // 버전 (revision, build, minor, major)
+    const version = {
+        revision: data[32],
+        build: data[33],
+        minor: data[34],
+        major: data[35],
+    };
+    // 플래그
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const flagsRaw = view.getUint32(36, true);
+    const flags = parseFlags(flagsRaw);
+    return { version, flags };
+}

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

@@ -0,0 +1,17 @@
+/**
+ * HTML → HwpDocument IR.
+ *
+ * `htmlparser2` 로 SAX 파싱 → 트리 구축 → IR 변환.
+ *   - p, div, h1~h6 → paragraph (heading 은 굵게 + 큰 사이즈)
+ *   - strong/b, em/i → 굵게/기울임 run
+ *   - br → 줄바꿈
+ *   - ul/ol/li → "- " / "1. " prefix paragraph
+ *   - table/thead/tbody/tr/th/td → HwpTableControl
+ *   - img → HwpPictureControl (src 가 data: URI 일 때만)
+ *   - blockquote → "> " prefix paragraph
+ *   - code/pre → 모노스페이스
+ *   - a → 텍스트만 (URL 미보존)
+ *   - 기타 (style/script/head 등) → 무시
+ */
+import type { HwpDocument, ConvertOptions } from "./types.js";
+export declare function htmlToHwpDocument(html: string, options?: ConvertOptions): HwpDocument;