hwp2md 1.0.0

package/dist/cli/index.mjs

@@ -0,0 +1,687 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { readFile, writeFile } from "node:fs/promises";
+import * as CFB from "cfb";
+import { inflateRaw } from "pako";
+import "fflate";
+import "fast-xml-parser";
+
+//#region src/utils/compression.ts
+/**
+* Decompress raw deflate data (no zlib header)
+* Equivalent to Python: zlib.decompress(data, -15)
+*
+* HWP files use raw deflate compression without zlib wrapper headers.
+* The windowBits=-15 in Python indicates raw deflate mode.
+*
+* @param data - Compressed data
+* @returns Decompressed data
+*/
+function decompressRaw(data) {
+	try {
+		return inflateRaw(data);
+	} catch (error) {
+		throw new Error(`Failed to decompress data: ${error.message}`);
+	}
+}
+
+//#endregion
+//#region src/parser.ts
+/**
+* HWP 5.0 File Parser
+* Parses OLE Compound File format HWP files
+*/
+/**
+* HWP File Parser
+* Reads and parses HWP 5.0 files using OLE Compound File format
+*/
+var HWPFile = class HWPFile {
+	cfb = null;
+	_fileHeader = null;
+	_isCompressed = false;
+	/**
+	* Create HWPFile from raw data
+	* @param data - Raw HWP file data
+	*/
+	constructor(data) {
+		this.data = data;
+	}
+	/**
+	* Create HWPFile from file path (Node.js only)
+	* @param path - Path to HWP file
+	*/
+	static async fromFile(path) {
+		const data = await (await import("node:fs/promises")).readFile(path);
+		return new HWPFile(new Uint8Array(data));
+	}
+	/**
+	* Create HWPFile from ArrayBuffer
+	* @param data - ArrayBuffer data
+	*/
+	static fromArrayBuffer(data) {
+		return new HWPFile(new Uint8Array(data));
+	}
+	/**
+	* Create HWPFile from Uint8Array
+	* @param data - Uint8Array data
+	*/
+	static fromUint8Array(data) {
+		return new HWPFile(data);
+	}
+	/**
+	* Open and parse HWP file
+	*/
+	open() {
+		const uint8Array = this.data instanceof Uint8Array ? this.data : new Uint8Array(this.data);
+		if (uint8Array.length >= 30) {
+			if (new TextDecoder("utf-8").decode(uint8Array.slice(0, 30)).replace(/\0+$/, "").startsWith("HWP Document File V3")) throw new Error("HWP 3.0 format (HWP 97, 2002, etc.) is not supported. Please use HWP 5.0 or later format. You can convert HWP 3.0 files to HWP 5.0 format using Hancom Office.");
+		}
+		try {
+			if (typeof Buffer !== "undefined") {
+				const buffer = Buffer.from(uint8Array);
+				this.cfb = CFB.read(buffer, { type: "buffer" });
+			} else {
+				const buffer = Array.from(uint8Array);
+				this.cfb = CFB.read(buffer, { type: "array" });
+			}
+		} catch (error) {
+			throw new Error(`Failed to parse HWP file: ${error.message}`);
+		}
+		this._fileHeader = this.parseFileHeader();
+		this._isCompressed = this._fileHeader.isCompressed;
+	}
+	/**
+	* Close HWP file and release resources
+	*/
+	close() {
+		this.cfb = null;
+		this._fileHeader = null;
+	}
+	/**
+	* Get file header information
+	*/
+	get fileHeader() {
+		return this._fileHeader;
+	}
+	/**
+	* Check if file is compressed
+	*/
+	get isCompressed() {
+		return this._isCompressed;
+	}
+	/**
+	* Parse FileHeader stream (256 bytes fixed)
+	*/
+	parseFileHeader() {
+		if (!this.cfb) throw new Error("HWP file not opened");
+		const entry = CFB.find(this.cfb, "FileHeader");
+		if (!entry) throw new Error("FileHeader not found in HWP file");
+		const data = entry.content;
+		if (data.length !== 256) throw new Error(`Invalid FileHeader size: ${data.length} (expected 256)`);
+		const signatureBytes = data.slice(0, 32);
+		const signature = new TextDecoder("utf-8").decode(signatureBytes).replace(/\0+$/, "");
+		if (!signature.startsWith("HWP Document File")) throw new Error(`Invalid HWP signature: ${signature}`);
+		const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+		const versionRaw = view.getUint32(32, true);
+		const major = versionRaw >> 24 & 255;
+		const minor = versionRaw >> 16 & 255;
+		const patch = versionRaw >> 8 & 255;
+		const rev = versionRaw & 255;
+		const properties = view.getUint32(36, true);
+		const isCompressed = Boolean(properties & 1);
+		const isEncrypted = Boolean(properties & 2);
+		return {
+			signature,
+			version: `${major}.${minor}.${patch}.${rev}`,
+			isCompressed,
+			isEncrypted,
+			rawProperties: properties
+		};
+	}
+	/**
+	* Read and decompress stream
+	* @param streamPath - Stream path (e.g., 'DocInfo', 'BodyText/Section0')
+	* @returns Decompressed data or null if stream doesn't exist
+	*/
+	readStream(streamPath) {
+		if (!this.cfb) return null;
+		const entry = CFB.find(this.cfb, streamPath);
+		if (!entry) return null;
+		let data = entry.content;
+		if (this._isCompressed) try {
+			data = decompressRaw(data);
+		} catch (error) {
+			throw new Error(`Failed to decompress ${streamPath}: ${error.message}`);
+		}
+		return data;
+	}
+	/**
+	* List all streams in HWP file
+	* @returns Array of stream paths
+	*/
+	listStreams() {
+		if (!this.cfb) return [];
+		const streams = [];
+		for (const entry of this.cfb.FileIndex) if (entry.type === 2) {
+			const path = entry.name.split("/").filter((p) => p);
+			if (path.length > 0) streams.push(path);
+		}
+		return streams;
+	}
+	/**
+	* Get file information
+	*/
+	getFileInfo() {
+		if (!this._fileHeader) return {};
+		return {
+			signature: this._fileHeader.signature,
+			version: this._fileHeader.version,
+			compressed: this._isCompressed,
+			encrypted: this._fileHeader.isEncrypted,
+			streams: this.listStreams()
+		};
+	}
+	/**
+	* Get number of sections in BodyText
+	*/
+	getSectionCount() {
+		if (!this.cfb) return 0;
+		let count = 0;
+		while (CFB.find(this.cfb, `BodyText/Section${count}`) || CFB.find(this.cfb, `Section${count}`)) count++;
+		return count;
+	}
+	/**
+	* Read section data
+	* @param sectionIndex - Section index (0-based)
+	* @returns Decompressed section data
+	*/
+	readSection(sectionIndex) {
+		let data = this.readStream(`BodyText/Section${sectionIndex}`);
+		if (!data) data = this.readStream(`Section${sectionIndex}`);
+		return data;
+	}
+};
+
+//#endregion
+//#region src/record.ts
+const HWPTAG_BEGIN = 16;
+const HWPTAG_PARA_HEADER = HWPTAG_BEGIN + 50;
+const HWPTAG_PARA_TEXT = HWPTAG_BEGIN + 51;
+const HWPTAG_PARA_CHAR_SHAPE = HWPTAG_BEGIN + 52;
+const HWPTAG_PARA_LINE_SEG = HWPTAG_BEGIN + 53;
+const HWPTAG_PARA_RANGE_TAG = HWPTAG_BEGIN + 54;
+const HWPTAG_CTRL_HEADER = HWPTAG_BEGIN + 55;
+const HWPTAG_LIST_HEADER = HWPTAG_BEGIN + 56;
+const HWPTAG_PAGE_DEF = HWPTAG_BEGIN + 57;
+const HWPTAG_FOOTNOTE_SHAPE = HWPTAG_BEGIN + 58;
+const HWPTAG_PAGE_BORDER_FILL = HWPTAG_BEGIN + 59;
+const HWPTAG_SHAPE_COMPONENT = HWPTAG_BEGIN + 60;
+const HWPTAG_TABLE = HWPTAG_BEGIN + 61;
+const HWPTAG_SHAPE_COMPONENT_LINE = HWPTAG_BEGIN + 62;
+const HWPTAG_CTRL_DATA = HWPTAG_BEGIN + 71;
+/**
+* HWP Record Reader
+* Reads binary records from HWP stream data
+*/
+var RecordReader = class {
+	data;
+	offset = 0;
+	constructor(data) {
+		this.data = data;
+	}
+	/**
+	* Check if there are more records to read
+	*/
+	hasMore() {
+		return this.offset < this.data.length;
+	}
+	/**
+	* Read next record
+	* @returns Next record, or null if no more records
+	*/
+	readRecord() {
+		if (this.offset + 4 > this.data.length) return null;
+		const header = new DataView(this.data.buffer, this.data.byteOffset + this.offset, 4).getUint32(0, true);
+		const tagId = header & 1023;
+		const level = header >> 10 & 1023;
+		let size = header >> 20 & 4095;
+		let dataOffset = this.offset + 4;
+		if (size === 4095) {
+			if (dataOffset + 4 > this.data.length) return null;
+			size = new DataView(this.data.buffer, this.data.byteOffset + dataOffset, 4).getUint32(0, true);
+			dataOffset += 4;
+		}
+		if (dataOffset + size > this.data.length) return null;
+		const recordData = this.data.slice(dataOffset, dataOffset + size);
+		this.offset = dataOffset + size;
+		return {
+			tagId,
+			level,
+			data: recordData,
+			size
+		};
+	}
+	/**
+	* Peek at next record header without consuming it
+	* @returns Header info with tagId, level, size
+	*/
+	peekRecordHeader() {
+		if (this.offset + 4 > this.data.length) return null;
+		const header = new DataView(this.data.buffer, this.data.byteOffset + this.offset, 4).getUint32(0, true);
+		const tagId = header & 1023;
+		const level = header >> 10 & 1023;
+		let size = header >> 20 & 4095;
+		let dataOffset = this.offset + 4;
+		if (size === 4095) {
+			if (dataOffset + 4 > this.data.length) return null;
+			size = new DataView(this.data.buffer, this.data.byteOffset + dataOffset, 4).getUint32(0, true);
+		}
+		return {
+			tagId,
+			level,
+			size
+		};
+	}
+	/**
+	* Read all records (considering hierarchy)
+	* @param parentLevel - Stop when reaching this level or below
+	* @returns All records at current level
+	*/
+	readAllRecords(parentLevel) {
+		const records = [];
+		while (this.hasMore()) {
+			const header = this.peekRecordHeader();
+			if (!header) break;
+			if (parentLevel !== void 0 && header.level <= parentLevel) break;
+			const record = this.readRecord();
+			if (record) records.push(record);
+		}
+		return records;
+	}
+	/**
+	* Get current position
+	*/
+	get position() {
+		return this.offset;
+	}
+	/**
+	* Get remaining bytes
+	*/
+	get remaining() {
+		return this.data.length - this.offset;
+	}
+};
+
+//#endregion
+//#region src/table.ts
+/**
+* HWP Table Parser
+* Parses table records and converts to Markdown
+*/
+/**
+* Parse table properties from TABLE record data
+* @param data - TABLE record data
+* @returns Table properties with rows, cols
+*/
+function parseTableProperties(data) {
+	if (data.length < 8) throw new Error(`Invalid TABLE record size: ${data.length}`);
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	return {
+		properties: view.getUint32(0, true),
+		rows: view.getUint16(4, true),
+		cols: view.getUint16(6, true)
+	};
+}
+/**
+* Parse table from TABLE record and subsequent records
+* @param tableRecordData - TABLE record data
+* @param reader - Record reader for reading cell data
+* @param lineBreakStyle - How to handle line breaks in cells
+* @returns Parsed table
+*/
+function parseTable(tableRecordData, reader, lineBreakStyle = "space") {
+	const props = parseTableProperties(tableRecordData);
+	const rows = props.rows;
+	const cols = props.cols;
+	const cells = [];
+	let cellIndex = 0;
+	while (reader.hasMore() && cellIndex < rows * cols) {
+		const header = reader.peekRecordHeader();
+		if (!header) break;
+		if (header.level < 2) break;
+		if (header.tagId === HWPTAG_LIST_HEADER) {
+			const listRecord = reader.readRecord();
+			if (!listRecord) break;
+			let row, col, colspan, rowspan;
+			if (listRecord.data.length >= 16) {
+				const view = new DataView(listRecord.data.buffer, listRecord.data.byteOffset, listRecord.data.byteLength);
+				col = view.getUint16(8, true);
+				row = view.getUint16(10, true);
+				colspan = view.getUint16(12, true);
+				rowspan = view.getUint16(14, true);
+				if (colspan === 0) colspan = 1;
+				if (rowspan === 0) rowspan = 1;
+			} else {
+				row = Math.floor(cellIndex / cols);
+				col = cellIndex % cols;
+				colspan = 1;
+				rowspan = 1;
+			}
+			const textParts = [];
+			while (reader.hasMore()) {
+				const paraHeader = reader.peekRecordHeader();
+				if (!paraHeader) break;
+				if (paraHeader.tagId === HWPTAG_LIST_HEADER) break;
+				if (paraHeader.level < 2) break;
+				if (paraHeader.tagId === HWPTAG_PARA_HEADER) {
+					const paraRec = reader.readRecord();
+					if (!paraRec) break;
+					if (paraRec.data.length >= 4) {
+						const nchars = new DataView(paraRec.data.buffer, paraRec.data.byteOffset, paraRec.data.byteLength).getUint32(0, true) & 2147483647;
+						if (nchars > 0 && reader.hasMore()) {
+							const nextH = reader.peekRecordHeader();
+							if (nextH && nextH.tagId === HWPTAG_PARA_TEXT) {
+								const textRec = reader.readRecord();
+								if (textRec) {
+									const text = processControlChars(parseParaText(textRec.data, nchars)).text;
+									if (text.trim()) textParts.push(text.trim());
+								}
+							}
+						}
+					}
+				} else reader.readRecord();
+			}
+			let cellText;
+			if (lineBreakStyle === "br") {
+				cellText = textParts.join("<br>");
+				cellText = cellText.replace(/\n/g, "<br>");
+			} else {
+				cellText = textParts.join(" ");
+				cellText = cellText.replace(/\n/g, " ");
+			}
+			const cell = {
+				row,
+				col,
+				rowspan,
+				colspan,
+				text: cellText
+			};
+			cells.push(cell);
+			cellIndex++;
+		} else reader.readRecord();
+	}
+	return {
+		rows,
+		cols,
+		cells
+	};
+}
+/**
+* Convert table to Markdown
+* @param table - Table object
+* @param mergeStrategy - 'repeat' (default) or 'blank'
+* @returns Markdown table
+*/
+function tableToMarkdown(table, mergeStrategy = "repeat") {
+	const { rows, cols, cells } = table;
+	const matrix = Array.from({ length: rows }, () => Array(cols).fill(""));
+	for (const cell of cells) if (mergeStrategy === "repeat") {
+		for (let r = cell.row; r < cell.row + cell.rowspan; r++) for (let c = cell.col; c < cell.col + cell.colspan; c++) if (r < rows && c < cols) matrix[r][c] = cell.text;
+	} else if (cell.row < rows && cell.col < cols) matrix[cell.row][cell.col] = cell.text;
+	const lines = [];
+	if (rows === 0 || cols === 0) return "[Empty Table]";
+	lines.push("| " + Array(cols).fill("").join(" | ") + " |");
+	lines.push("| " + Array(cols).fill("---").join(" | ") + " |");
+	for (const row of matrix) lines.push("| " + row.join(" | ") + " |");
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/paragraph.ts
+/**
+* HWP Paragraph Parser
+* Parses paragraph records and extracts text
+*/
+/**
+* Parse paragraph header
+* @param data - PARA_HEADER record data
+* @returns Paragraph header information
+*/
+function parseParaHeader(data) {
+	if (data.length < 22) throw new Error(`Invalid PARA_HEADER size: ${data.length}`);
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	return {
+		textCount: view.getUint32(0, true) & 2147483647,
+		controlMask: view.getUint32(4, true),
+		paraShapeId: view.getUint16(8, true),
+		styleId: view.getUint8(10),
+		columnType: view.getUint8(11),
+		charShapeCount: view.getUint16(12, true)
+	};
+}
+/**
+* Parse paragraph text with control info table
+*
+* PARA_TEXT structure:
+* [Control info table: 16 bytes per control] + [Actual text]
+*
+* Each control info block (16 bytes):
+* - 2 bytes: control code
+* - 4 bytes: control ID
+* - 8 bytes: control data
+* - 2 bytes: control code (repeated)
+*
+* @param data - PARA_TEXT record data
+* @param nchars - Number of WCHAR characters (control table + text)
+* @returns Decoded text
+*/
+function parseParaText(data, _nchars) {
+	const CHAR_CONTROLS = new Set([
+		0,
+		10,
+		13,
+		30,
+		31
+	]);
+	let offset = 0;
+	while (offset + 2 <= data.length) {
+		const charCode = new DataView(data.buffer, data.byteOffset + offset, 2).getUint16(0, true);
+		if (charCode < 32 && !CHAR_CONTROLS.has(charCode)) {
+			offset += 16;
+			if (offset > data.length) break;
+		} else break;
+	}
+	const textData = data.slice(offset);
+	if (textData.length === 0) return "";
+	try {
+		return new TextDecoder("utf-16le").decode(textData);
+	} catch (error) {
+		return "";
+	}
+}
+/**
+* Process control characters in text
+* @param text - Raw text with control characters
+* @returns Processed text and has_table flag
+*/
+function processControlChars(text) {
+	const result = [];
+	let hasTable = false;
+	for (const char of text) {
+		const code = char.codePointAt(0) ?? 0;
+		if (code < 32) {
+			if (code === 10) result.push("\n");
+			else if (code === 11) hasTable = true;
+			else if (code === 13) result.push("\n");
+		} else result.push(char);
+	}
+	return {
+		text: result.join(""),
+		hasTable
+	};
+}
+/**
+* Paragraph Parser
+* Parses paragraphs from HWP record stream
+*/
+var ParagraphParser = class {
+	constructor(reader, options = {}) {
+		this.reader = reader;
+		this.options = options;
+		if (!this.options.tableLineBreakStyle) this.options.tableLineBreakStyle = "space";
+	}
+	/**
+	* Parse next paragraph
+	* @returns Parsed paragraph, or null if no more paragraphs
+	*/
+	parseParagraph() {
+		if (!this.reader.hasMore()) return null;
+		let record = null;
+		while (this.reader.hasMore()) {
+			record = this.reader.readRecord();
+			if (record && record.tagId === HWPTAG_PARA_HEADER) break;
+			record = null;
+		}
+		if (!record) return null;
+		const header = parseParaHeader(record.data);
+		let text = "";
+		if (header.textCount > 0) {
+			const nextHeader = this.reader.peekRecordHeader();
+			if (nextHeader && nextHeader.tagId === HWPTAG_PARA_TEXT) {
+				record = this.reader.readRecord();
+				if (record) text = processControlChars(parseParaText(record.data, header.textCount)).text;
+			}
+		}
+		const tables = [];
+		while (this.reader.hasMore()) {
+			const nextHeader = this.reader.peekRecordHeader();
+			if (!nextHeader) break;
+			if (nextHeader.tagId === HWPTAG_PARA_HEADER) break;
+			if (nextHeader.level === 0) break;
+			if (nextHeader.tagId === HWPTAG_CTRL_HEADER) {
+				this.reader.readRecord();
+				const tableHeader = this.reader.peekRecordHeader();
+				if (tableHeader && tableHeader.tagId === HWPTAG_TABLE) {
+					const tableRecord = this.reader.readRecord();
+					if (tableRecord) try {
+						const tableMd = tableToMarkdown(parseTable(tableRecord.data, this.reader, this.options.tableLineBreakStyle));
+						tables.push(tableMd);
+					} catch (error) {
+						console.warn("Warning: Failed to parse table:", error);
+						tables.push("[TABLE - Parse Error]");
+					}
+				}
+			} else this.reader.readRecord();
+		}
+		if (tables.length > 0) {
+			text = text.trimEnd();
+			if (text.length > 0 && text.length < 5 && [...text].every((c) => {
+				return (c.codePointAt(0) ?? 0) > 127 || /\s/.test(c);
+			})) text = tables.join("\n\n");
+			else {
+				if (text) text += "\n\n";
+				text += tables.join("\n\n");
+			}
+		}
+		return {
+			text,
+			header
+		};
+	}
+	/**
+	* Parse all paragraphs in section
+	* @returns All paragraphs
+	*/
+	parseAllParagraphs() {
+		const paragraphs = [];
+		while (this.reader.hasMore()) {
+			const para = this.parseParagraph();
+			if (para) paragraphs.push(para);
+			else break;
+		}
+		return paragraphs;
+	}
+};
+
+//#endregion
+//#region src/converter.ts
+/**
+* Convert paragraphs to Markdown
+* @param paragraphs - List of paragraphs
+* @returns Markdown text
+*/
+function paragraphsToMarkdown(paragraphs) {
+	const lines = [];
+	for (const para of paragraphs) {
+		const text = para.text.trim();
+		if (!text) continue;
+		if (text.length < 5 && !text.startsWith("|") && [...text].every((c) => (c.codePointAt(0) ?? 0) > 127)) continue;
+		lines.push(text);
+	}
+	return lines.join("\n\n");
+}
+/**
+* Convert HWP file to Markdown
+* @param hwp - Opened HWP file
+* @param options - Conversion options
+* @returns Markdown content
+*/
+function convertHwpToMarkdown(hwp, options = {}) {
+	const allParagraphs = [];
+	if (!options.tableLineBreakStyle) options.tableLineBreakStyle = "space";
+	const sectionCount = hwp.getSectionCount();
+	for (let i = 0; i < sectionCount; i++) {
+		const sectionData = hwp.readSection(i);
+		if (!sectionData) continue;
+		const paragraphs = new ParagraphParser(new RecordReader(sectionData), options).parseAllParagraphs();
+		allParagraphs.push(...paragraphs);
+	}
+	return paragraphsToMarkdown(allParagraphs);
+}
+
+//#endregion
+//#region src/cli/index.ts
+/**
+* HWP2MD CLI
+* Command-line interface for HWP to Markdown conversion
+*/
+const program = new Command();
+program.name("hwp2md").description("HWP to Markdown converter").version("0.1.0");
+program.command("info <file>").description("Display HWP file information").action(async (file) => {
+	try {
+		const data = await readFile(file);
+		const hwp = new HWPFile(new Uint8Array(data));
+		hwp.open();
+		const header = hwp.fileHeader;
+		console.log(`File: ${file}`);
+		console.log(`Signature: ${header?.signature}`);
+		console.log(`Version: ${header?.version}`);
+		console.log(`Compressed: ${hwp.isCompressed}`);
+		console.log(`Encrypted: ${header?.isEncrypted}`);
+		console.log(`Sections: ${hwp.getSectionCount()}`);
+		hwp.close();
+	} catch (error) {
+		console.error(`Error: ${error.message}`);
+		process.exit(1);
+	}
+});
+program.command("convert <input> [output]").description("Convert HWP file to Markdown").option("--table-line-breaks <style>", "Line break style in table cells: space or br", "space").action(async (input, output, options) => {
+	const outputPath = output ?? input.replace(/\.hwp$/i, ".md");
+	try {
+		console.log(`Converting ${input} to ${outputPath}...`);
+		const data = await readFile(input);
+		const hwp = new HWPFile(new Uint8Array(data));
+		hwp.open();
+		await writeFile(outputPath, convertHwpToMarkdown(hwp, { tableLineBreakStyle: options.tableLineBreaks }), "utf-8");
+		console.log(`Conversion completed: ${outputPath}`);
+		hwp.close();
+	} catch (error) {
+		console.error(`Error: ${error.message}`);
+		process.exit(1);
+	}
+});
+program.parse();
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.mjs.map