hwp2md 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1200 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let cfb = require("cfb");
+cfb = __toESM(cfb);
+let pako = require("pako");
+let fflate = require("fflate");
+let fast_xml_parser = require("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 (0, pako.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_DOCUMENT_PROPERTIES = 16;
+const HWPTAG_ID_MAPPINGS = 17;
+const HWPTAG_BIN_DATA = 18;
+const HWPTAG_FACE_NAME = 19;
+const HWPTAG_BORDER_FILL = 20;
+const HWPTAG_CHAR_SHAPE = 21;
+const HWPTAG_TAB_DEF = 22;
+const HWPTAG_NUMBERING = 23;
+const HWPTAG_BULLET = 24;
+const HWPTAG_PARA_SHAPE = 25;
+const HWPTAG_STYLE = 26;
+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 cell properties
+* @param data - Cell property data
+* @returns Cell properties
+*/
+function parseCellProperties(data) {
+	if (data.length < 8) return {
+		col: 0,
+		row: 0,
+		colspan: 1,
+		rowspan: 1
+	};
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	return {
+		col: view.getUint16(0, true),
+		row: view.getUint16(2, true),
+		colspan: view.getUint16(4, true),
+		rowspan: 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/hwpx_parser.ts
+/**
+* HWPX (ZIP+XML) File Parser
+* Parses HWPX files (ZIP archives containing XML) into Paragraphs and Tables
+*/
+const HWPX_MIMETYPE = "application/hwp+zip";
+/** Options for the XML parser */
+const xmlParserOptions = {
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	removeNSPrefix: false,
+	isArray: (name) => {
+		return [
+			"hp:p",
+			"hp:run",
+			"hp:t",
+			"hp:tr",
+			"hp:tc",
+			"hp:tbl",
+			"opf:item",
+			"opf:itemref"
+		].includes(name);
+	},
+	textNodeName: "#text"
+};
+/**
+* HWPX file parser
+*/
+var HWPXFile = class HWPXFile {
+	data;
+	entries = null;
+	sectionPaths = [];
+	version = "";
+	xmlParser;
+	constructor(data) {
+		this.data = data;
+		this.xmlParser = new fast_xml_parser.XMLParser(xmlParserOptions);
+	}
+	static async fromFile(path) {
+		const { readFileSync } = await import("node:fs");
+		const data = readFileSync(path);
+		return new HWPXFile(new Uint8Array(data));
+	}
+	static fromArrayBuffer(data) {
+		return new HWPXFile(new Uint8Array(data));
+	}
+	static fromUint8Array(data) {
+		return new HWPXFile(data);
+	}
+	open() {
+		if (this.data.length < 4 || this.data[0] !== 80 || this.data[1] !== 75 || this.data[2] !== 3 || this.data[3] !== 4) throw new Error("Not a valid HWPX file (not a ZIP archive)");
+		try {
+			this.entries = (0, fflate.unzipSync)(this.data);
+		} catch (e) {
+			throw new Error(`Failed to parse HWPX file: ${e instanceof Error ? e.message : e}`);
+		}
+		const mimetypeEntry = this.entries["mimetype"];
+		if (!mimetypeEntry) throw new Error("Not a valid HWPX file: missing 'mimetype' entry");
+		const mimetype = new TextDecoder().decode(mimetypeEntry).trim();
+		if (mimetype !== HWPX_MIMETYPE) throw new Error(`Invalid HWPX mimetype: '${mimetype}' (expected '${HWPX_MIMETYPE}')`);
+		this.parseVersion();
+		this.discoverSections();
+	}
+	close() {
+		this.entries = null;
+		this.sectionPaths = [];
+	}
+	parseVersion() {
+		const versionEntry = this.entries?.["version.xml"];
+		if (!versionEntry) {
+			this.version = "unknown";
+			return;
+		}
+		try {
+			const xml = new TextDecoder().decode(versionEntry);
+			const parsed = this.xmlParser.parse(xml);
+			const root = parsed["hv:HCFVersion"] ?? parsed["HCFVersion"] ?? parsed;
+			const major = root["@_major"] ?? "";
+			const minor = root["@_minor"] ?? "";
+			const micro = root["@_micro"] ?? "";
+			if (major) this.version = `${major}.${minor}.${micro}`;
+			else this.version = root["@_Version"] ?? "unknown";
+		} catch {
+			this.version = "unknown";
+		}
+	}
+	discoverSections() {
+		this.sectionPaths = [];
+		const hpfEntry = this.entries?.["Contents/content.hpf"];
+		if (!hpfEntry) {
+			for (const name of Object.keys(this.entries ?? {})) if (name.startsWith("Contents/section") && name.endsWith(".xml")) this.sectionPaths.push(name);
+			this.sectionPaths.sort();
+			return;
+		}
+		try {
+			const xml = new TextDecoder().decode(hpfEntry);
+			const parsed = this.xmlParser.parse(xml);
+			const pkg = parsed["opf:package"] ?? parsed["package"] ?? {};
+			const manifest = pkg["opf:manifest"] ?? pkg["manifest"] ?? {};
+			const spine = pkg["opf:spine"] ?? pkg["spine"] ?? {};
+			const idToHref = {};
+			const items = manifest["opf:item"] ?? manifest["item"] ?? [];
+			const itemList = Array.isArray(items) ? items : [items];
+			for (const item of itemList) {
+				const id = item["@_id"] ?? "";
+				const href = item["@_href"] ?? "";
+				if (href) idToHref[id] = href;
+			}
+			const itemrefs = spine["opf:itemref"] ?? spine["itemref"] ?? [];
+			const refList = Array.isArray(itemrefs) ? itemrefs : [itemrefs];
+			for (const ref of refList) {
+				const idref = ref["@_idref"] ?? "";
+				if (idref in idToHref && idref.toLowerCase().includes("section")) {
+					let href = idToHref[idref];
+					if (!href.startsWith("Contents/")) href = "Contents/" + href;
+					this.sectionPaths.push(href);
+				}
+			}
+			if (this.sectionPaths.length === 0) {
+				for (const [, href] of Object.entries(idToHref).sort()) if (href.toLowerCase().includes("section")) {
+					const fullHref = href.startsWith("Contents/") ? href : "Contents/" + href;
+					this.sectionPaths.push(fullHref);
+				}
+			}
+		} catch {
+			for (const name of Object.keys(this.entries ?? {})) if (name.startsWith("Contents/section") && name.endsWith(".xml")) this.sectionPaths.push(name);
+			this.sectionPaths.sort();
+		}
+	}
+	get fileInfo() {
+		this.ensureOpen();
+		return {
+			format: "HWPX",
+			version: this.version,
+			sectionCount: this.sectionPaths.length,
+			contents: Object.keys(this.entries ?? {})
+		};
+	}
+	getSectionCount() {
+		this.ensureOpen();
+		return this.sectionPaths.length;
+	}
+	getSectionXml(index) {
+		this.ensureOpen();
+		if (index < 0 || index >= this.sectionPaths.length) throw new RangeError(`Section index ${index} out of range (0-${this.sectionPaths.length - 1})`);
+		const path = this.sectionPaths[index];
+		const entry = this.entries?.[path];
+		if (!entry) throw new Error(`Section file not found: ${path}`);
+		const xml = new TextDecoder().decode(entry);
+		return this.xmlParser.parse(xml);
+	}
+	listContents() {
+		this.ensureOpen();
+		return Object.keys(this.entries ?? {});
+	}
+	ensureOpen() {
+		if (!this.entries) throw new Error("HWPX file is not open. Call open() first.");
+	}
+};
+function ensureArray(val) {
+	if (val === void 0 || val === null) return [];
+	return Array.isArray(val) ? val : [val];
+}
+/**
+* Extract text from a paragraph object (hp:p)
+*/
+function extractParagraphText(pObj) {
+	const parts = [];
+	for (const run of ensureArray(pObj["hp:run"])) for (const [key, value] of Object.entries(run)) if (key === "hp:t") for (const t of ensureArray(value)) {
+		const text = typeof t === "string" ? t : t?.["#text"];
+		if (text !== void 0 && text !== null) parts.push(String(text));
+	}
+	else if (key === "hp:lineBreak") parts.push("\n");
+	else if (key === "hp:tab") parts.push("	");
+	return parts.join("");
+}
+/**
+* Extract text from a table cell (hp:tc)
+*/
+function extractCellText(tcObj, lineBreakStyle = "space") {
+	const textParts = [];
+	const subList = tcObj["hp:subList"];
+	if (subList) for (const p of ensureArray(subList["hp:p"])) {
+		const paraText = extractParagraphText(p);
+		if (paraText.trim()) textParts.push(paraText.trim());
+	}
+	if (lineBreakStyle === "br") return textParts.join("<br>").replace(/\n/g, "<br>");
+	return textParts.join(" ").replace(/\n/g, " ");
+}
+/**
+* Parse a table XML object (hp:tbl) into a Table
+*/
+function parseHwpxTable(tblObj, lineBreakStyle = "space") {
+	const rows = Number(tblObj["@_rowCnt"] ?? 0);
+	const cols = Number(tblObj["@_colCnt"] ?? 0);
+	const cells = [];
+	for (const tr of ensureArray(tblObj["hp:tr"])) for (const tc of ensureArray(tr["hp:tc"])) {
+		const addr = tc["hp:cellAddr"];
+		const col = Number(addr?.["@_colAddr"] ?? 0);
+		const row = Number(addr?.["@_rowAddr"] ?? 0);
+		const span = tc["hp:cellSpan"];
+		let colspan = Number(span?.["@_colSpan"] ?? 1);
+		let rowspan = Number(span?.["@_rowSpan"] ?? 1);
+		if (colspan < 1) colspan = 1;
+		if (rowspan < 1) rowspan = 1;
+		const text = extractCellText(tc, lineBreakStyle);
+		cells.push({
+			row,
+			col,
+			rowspan,
+			colspan,
+			text
+		});
+	}
+	return {
+		rows,
+		cols,
+		cells
+	};
+}
+/**
+* Parse a section XML object into paragraphs
+*/
+function parseHwpxSection(sectionObj, options = {}) {
+	const lineBreakStyle = options.tableLineBreakStyle ?? "space";
+	const paragraphs = [];
+	let sec = sectionObj;
+	if (sec["hs:sec"]) sec = sec["hs:sec"];
+	for (const p of ensureArray(sec["hp:p"])) {
+		let text = extractParagraphText(p);
+		const tableMds = [];
+		for (const run of ensureArray(p["hp:run"])) for (const tbl of ensureArray(run["hp:tbl"])) try {
+			const table = parseHwpxTable(tbl, lineBreakStyle);
+			tableMds.push(tableToMarkdown(table));
+		} catch {
+			tableMds.push("[TABLE - Parse Error]");
+		}
+		for (const tbl of ensureArray(p["hp:tbl"])) try {
+			const table = parseHwpxTable(tbl, lineBreakStyle);
+			tableMds.push(tableToMarkdown(table));
+		} catch {
+			tableMds.push("[TABLE - Parse Error]");
+		}
+		if (tableMds.length > 0) {
+			text = text.trimEnd();
+			if (text) text += "\n\n";
+			text += tableMds.join("\n\n");
+		}
+		if (text.trim()) paragraphs.push({
+			text,
+			header: {
+				textCount: 0,
+				controlMask: 0,
+				paraShapeId: 0,
+				styleId: 0,
+				columnType: 0,
+				charShapeCount: 0
+			}
+		});
+	}
+	for (const tbl of ensureArray(sec["hp:tbl"])) try {
+		const md = tableToMarkdown(parseHwpxTable(tbl, lineBreakStyle));
+		if (md.trim()) paragraphs.push({
+			text: md,
+			header: {
+				textCount: 0,
+				controlMask: 0,
+				paraShapeId: 0,
+				styleId: 0,
+				columnType: 0,
+				charShapeCount: 0
+			}
+		});
+	} catch {}
+	return paragraphs;
+}
+/**
+* Check if binary data is a HWPX file (ZIP magic bytes)
+*/
+function isHwpxData(data) {
+	const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+	return bytes.length >= 4 && bytes[0] === 80 && bytes[1] === 75 && bytes[2] === 3 && bytes[3] === 4;
+}
+/**
+* Check if a file path has HWPX extension
+*/
+function isHwpxPath(path) {
+	return path.toLowerCase().endsWith(".hwpx");
+}
+
+//#endregion
+//#region src/converter.ts
+/**
+* HWP/HWPX to Markdown Converter
+* Orchestrates conversion from HWP/HWPX to Markdown
+*/
+/**
+* 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);
+}
+/**
+* Convert HWPX file to Markdown
+* @param hwpx - Opened HWPX file
+* @param options - Conversion options
+* @returns Markdown content
+*/
+function convertHwpxToMarkdown(hwpx, options = {}) {
+	const allParagraphs = [];
+	const sectionCount = hwpx.getSectionCount();
+	for (let i = 0; i < sectionCount; i++) {
+		const paragraphs = parseHwpxSection(hwpx.getSectionXml(i), options);
+		allParagraphs.push(...paragraphs);
+	}
+	return paragraphsToMarkdown(allParagraphs);
+}
+/**
+* High-level API: Convert HWP/HWPX file to Markdown
+* Auto-detects format based on file extension or magic bytes.
+* @param input - File path (Node.js), ArrayBuffer, or Uint8Array
+* @param options - Conversion options
+* @returns Markdown content
+*/
+async function convert(input, options) {
+	if (typeof input === "string" && isHwpxPath(input)) {
+		const hwpx = await HWPXFile.fromFile(input);
+		try {
+			hwpx.open();
+			return convertHwpxToMarkdown(hwpx, options);
+		} finally {
+			hwpx.close();
+		}
+	}
+	if ((input instanceof Uint8Array || input instanceof ArrayBuffer) && isHwpxData(input instanceof ArrayBuffer ? new Uint8Array(input) : input)) {
+		const hwpx = input instanceof Uint8Array ? HWPXFile.fromUint8Array(input) : HWPXFile.fromArrayBuffer(input);
+		try {
+			hwpx.open();
+			return convertHwpxToMarkdown(hwpx, options);
+		} finally {
+			hwpx.close();
+		}
+	}
+	let hwp;
+	if (typeof input === "string") hwp = await HWPFile.fromFile(input);
+	else if (input instanceof Uint8Array) hwp = HWPFile.fromUint8Array(input);
+	else hwp = HWPFile.fromArrayBuffer(input);
+	try {
+		hwp.open();
+		return convertHwpToMarkdown(hwp, options);
+	} finally {
+		hwp.close();
+	}
+}
+
+//#endregion
+//#region src/utils/binary.ts
+/**
+* Binary Reader Utility
+* Replaces Python's struct.unpack functionality
+* All multi-byte values are little-endian
+*/
+var BinaryReader = class BinaryReader {
+	view;
+	offset = 0;
+	constructor(data) {
+		const buffer = data instanceof Uint8Array ? data.buffer : data;
+		const byteOffset = data instanceof Uint8Array ? data.byteOffset : 0;
+		const byteLength = data instanceof Uint8Array ? data.byteLength : data.byteLength;
+		this.view = new DataView(buffer, byteOffset, byteLength);
+	}
+	/**
+	* Read unsigned 8-bit integer (BYTE)
+	*/
+	readUint8() {
+		const value = this.view.getUint8(this.offset);
+		this.offset += 1;
+		return value;
+	}
+	/**
+	* Read unsigned 16-bit integer (WORD) - little-endian
+	*/
+	readUint16LE() {
+		const value = this.view.getUint16(this.offset, true);
+		this.offset += 2;
+		return value;
+	}
+	/**
+	* Read unsigned 32-bit integer (DWORD) - little-endian
+	*/
+	readUint32LE() {
+		const value = this.view.getUint32(this.offset, true);
+		this.offset += 4;
+		return value;
+	}
+	/**
+	* Read signed 32-bit integer - little-endian
+	*/
+	readInt32LE() {
+		const value = this.view.getInt32(this.offset, true);
+		this.offset += 4;
+		return value;
+	}
+	/**
+	* Read bytes without advancing offset (peek)
+	*/
+	peekBytes(length) {
+		return new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, length);
+	}
+	/**
+	* Read bytes and advance offset
+	*/
+	readBytes(length) {
+		const bytes = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, length);
+		this.offset += length;
+		return bytes;
+	}
+	/**
+	* Skip bytes
+	*/
+	skip(length) {
+		this.offset += length;
+	}
+	/**
+	* Set absolute position
+	*/
+	seek(offset) {
+		this.offset = offset;
+	}
+	/**
+	* Get current position
+	*/
+	get position() {
+		return this.offset;
+	}
+	/**
+	* Get remaining bytes
+	*/
+	get remaining() {
+		return this.view.byteLength - this.offset;
+	}
+	/**
+	* Check if more data is available
+	*/
+	hasMore(minBytes = 1) {
+		return this.remaining >= minBytes;
+	}
+	/**
+	* Get total length
+	*/
+	get length() {
+		return this.view.byteLength;
+	}
+	/**
+	* Create a new BinaryReader for a subset of data
+	*/
+	slice(start, end) {
+		const actualEnd = end ?? this.view.byteLength;
+		return new BinaryReader(new Uint8Array(this.view.buffer, this.view.byteOffset + start, actualEnd - start));
+	}
+};
+
+//#endregion
+exports.BinaryReader = BinaryReader;
+exports.HWPFile = HWPFile;
+exports.HWPTAG_BEGIN = HWPTAG_BEGIN;
+exports.HWPTAG_BIN_DATA = HWPTAG_BIN_DATA;
+exports.HWPTAG_BORDER_FILL = HWPTAG_BORDER_FILL;
+exports.HWPTAG_BULLET = HWPTAG_BULLET;
+exports.HWPTAG_CHAR_SHAPE = HWPTAG_CHAR_SHAPE;
+exports.HWPTAG_CTRL_DATA = HWPTAG_CTRL_DATA;
+exports.HWPTAG_CTRL_HEADER = HWPTAG_CTRL_HEADER;
+exports.HWPTAG_DOCUMENT_PROPERTIES = HWPTAG_DOCUMENT_PROPERTIES;
+exports.HWPTAG_FACE_NAME = HWPTAG_FACE_NAME;
+exports.HWPTAG_FOOTNOTE_SHAPE = HWPTAG_FOOTNOTE_SHAPE;
+exports.HWPTAG_ID_MAPPINGS = HWPTAG_ID_MAPPINGS;
+exports.HWPTAG_LIST_HEADER = HWPTAG_LIST_HEADER;
+exports.HWPTAG_NUMBERING = HWPTAG_NUMBERING;
+exports.HWPTAG_PAGE_BORDER_FILL = HWPTAG_PAGE_BORDER_FILL;
+exports.HWPTAG_PAGE_DEF = HWPTAG_PAGE_DEF;
+exports.HWPTAG_PARA_CHAR_SHAPE = HWPTAG_PARA_CHAR_SHAPE;
+exports.HWPTAG_PARA_HEADER = HWPTAG_PARA_HEADER;
+exports.HWPTAG_PARA_LINE_SEG = HWPTAG_PARA_LINE_SEG;
+exports.HWPTAG_PARA_RANGE_TAG = HWPTAG_PARA_RANGE_TAG;
+exports.HWPTAG_PARA_SHAPE = HWPTAG_PARA_SHAPE;
+exports.HWPTAG_PARA_TEXT = HWPTAG_PARA_TEXT;
+exports.HWPTAG_SHAPE_COMPONENT = HWPTAG_SHAPE_COMPONENT;
+exports.HWPTAG_SHAPE_COMPONENT_LINE = HWPTAG_SHAPE_COMPONENT_LINE;
+exports.HWPTAG_STYLE = HWPTAG_STYLE;
+exports.HWPTAG_TABLE = HWPTAG_TABLE;
+exports.HWPTAG_TAB_DEF = HWPTAG_TAB_DEF;
+exports.HWPXFile = HWPXFile;
+exports.ParagraphParser = ParagraphParser;
+exports.RecordReader = RecordReader;
+exports.convert = convert;
+exports.convertHwpToMarkdown = convertHwpToMarkdown;
+exports.convertHwpxToMarkdown = convertHwpxToMarkdown;
+exports.decompressRaw = decompressRaw;
+exports.isHwpxData = isHwpxData;
+exports.isHwpxPath = isHwpxPath;
+exports.paragraphsToMarkdown = paragraphsToMarkdown;
+exports.parseCellProperties = parseCellProperties;
+exports.parseHwpxSection = parseHwpxSection;
+exports.parseHwpxTable = parseHwpxTable;
+exports.parseParaHeader = parseParaHeader;
+exports.parseParaText = parseParaText;
+exports.parseTable = parseTable;
+exports.parseTableProperties = parseTableProperties;
+exports.processControlChars = processControlChars;
+exports.tableToMarkdown = tableToMarkdown;
+//# sourceMappingURL=index.cjs.map