@cj-tech-master/excelts 7.6.0 → 8.0.0

package/dist/iife/excelts.iife.js

@@ -1,6 +1,6 @@
 /*!
-* @cj-tech-master/excelts v7.6.0
-* TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.
+* @cj-tech-master/excelts v8.0.0
+* Zero-dependency TypeScript toolkit — Excel (XLSX), PDF, CSV, Markdown, XML, ZIP/TAR, and streaming.
 * (c) 2026 cjnoname
 * Released under the MIT License
 */
@@ -24380,11 +24380,46 @@ var ExcelTS = (function(exports) {
 	}
 	const HASH_SIZE = 32768;
 	const HASH_MASK = HASH_SIZE - 1;
-	const MAX_CHAIN_LEN = 64;
 	const MIN_MATCH = 3;
 	const MAX_MATCH = 258;
 	const MAX_DIST = 32768;
 	/**
+	* Get LZ77 configuration for the given compression level (1-9).
+	* Modelled after zlib's configuration_table.
+	*/
+	function getLZ77Config(level) {
+		if (level <= 1) return {
+			maxChainLen: 4,
+			goodLen: 4,
+			niceLen: 8,
+			lazy: false
+		};
+		if (level <= 3) return {
+			maxChainLen: 8,
+			goodLen: 8,
+			niceLen: 32,
+			lazy: true
+		};
+		if (level <= 5) return {
+			maxChainLen: 32,
+			goodLen: 16,
+			niceLen: 128,
+			lazy: true
+		};
+		if (level <= 7) return {
+			maxChainLen: 64,
+			goodLen: 32,
+			niceLen: 258,
+			lazy: true
+		};
+		return {
+			maxChainLen: 128,
+			goodLen: 64,
+			niceLen: 258,
+			lazy: true
+		};
+	}
+	/**
 	* Hash function for 3-byte sequences.
 	* Uses a multiplicative hash for better distribution than the naive
 	* shift-or approach. The constant 0x1e35a7bd is chosen for good avalanche
@@ -24394,91 +24429,22 @@ var ExcelTS = (function(exports) {
 		return (a << 16 | b << 8 | c) * 506832829 >>> 17 & HASH_MASK;
 	}
 	/**
-	* Compress data using DEFLATE with fixed Huffman codes.
+	* Compress data using DEFLATE with Dynamic Huffman codes (BTYPE=2).
 	*
-	* Uses LZ77 with hash chains and lazy matching for significantly better
-	* compression than a single-entry hash table. The algorithm is modelled
-	* after zlib's "fast" and "slow" deflate strategies.
+	* Uses LZ77 with hash chains and lazy matching for match finding, then builds
+	* optimal Huffman trees from the symbol frequencies for entropy coding.
 	*
 	* @param data - Data to compress
+	* @param level - Compression level (1-9, default 6)
 	* @returns Compressed data in deflate-raw format
 	*/
-	function deflateRawCompressed(data) {
+	function deflateRawCompressed(data, level = 6) {
 		if (data.length === 0) return new Uint8Array([3, 0]);
 		if (data.length < 100) return deflateRawStore(data);
+		const config = getLZ77Config(level);
+		const lz77Symbols = lz77Compress(data, 0, data.length, config, null);
 		const output = new BitWriter();
-		output.writeBits(1, 1);
-		output.writeBits(1, 2);
-		const head = new Int32Array(HASH_SIZE);
-		const prev = new Int32Array(MAX_DIST);
-		let pos = 0;
-		let prevMatchLen = 0;
-		let prevMatchDist = 0;
-		let prevLiteral = 0;
-		let hasPrevMatch = false;
-		while (pos < data.length) {
-			let bestLen = 0;
-			let bestDist = 0;
-			if (pos + 2 < data.length) {
-				const h = hash3(data[pos], data[pos + 1], data[pos + 2]);
-				let chainLen = MAX_CHAIN_LEN;
-				let matchHead = head[h];
-				while (matchHead > 0 && chainLen-- > 0) {
-					const mPos = matchHead - 1;
-					const dist = pos - mPos;
-					if (dist > MAX_DIST || dist <= 0) break;
-					if (bestLen >= MIN_MATCH && data[mPos + bestLen] !== data[pos + bestLen]) {
-						matchHead = prev[mPos & MAX_DIST - 1];
-						continue;
-					}
-					let len = 0;
-					const maxLen = Math.min(MAX_MATCH, data.length - pos);
-					while (len < maxLen && data[mPos + len] === data[pos + len]) len++;
-					if (len > bestLen) {
-						bestLen = len;
-						bestDist = dist;
-						if (len >= MAX_MATCH) break;
-					}
-					matchHead = prev[mPos & MAX_DIST - 1];
-				}
-				prev[pos & MAX_DIST - 1] = head[h];
-				head[h] = pos + 1;
-			}
-			if (hasPrevMatch) if (bestLen > prevMatchLen) {
-				writeLiteralCode(output, prevLiteral);
-				prevMatchLen = bestLen;
-				prevMatchDist = bestDist;
-				prevLiteral = data[pos];
-				pos++;
-			} else {
-				writeLengthCode(output, prevMatchLen);
-				writeDistanceCode(output, prevMatchDist);
-				const matchEnd = pos - 1 + prevMatchLen;
-				for (let i = pos; i < matchEnd && i + 2 < data.length; i++) {
-					const h = hash3(data[i], data[i + 1], data[i + 2]);
-					prev[i & MAX_DIST - 1] = head[h];
-					head[h] = i + 1;
-				}
-				pos = matchEnd;
-				hasPrevMatch = false;
-				prevMatchLen = 0;
-			}
-			else if (bestLen >= MIN_MATCH) {
-				hasPrevMatch = true;
-				prevMatchLen = bestLen;
-				prevMatchDist = bestDist;
-				prevLiteral = data[pos];
-				pos++;
-			} else {
-				writeLiteralCode(output, data[pos]);
-				pos++;
-			}
-		}
-		if (hasPrevMatch) {
-			writeLengthCode(output, prevMatchLen);
-			writeDistanceCode(output, prevMatchDist);
-		}
-		writeLiteralCode(output, 256);
+		emitDynamicBlock(output, lz77Symbols, true);
 		return output.finish();
 	}
 	/**
@@ -24491,6 +24457,12 @@ var ExcelTS = (function(exports) {
 			this.bitBuf = 0;
 			this.bitCount = 0;
 		}
+		/**
+		* Align to the next byte boundary by padding with zero bits.
+		*/
+		alignToByte() {
+			if (this.bitCount > 0) this.writeBits(0, 8 - this.bitCount);
+		}
 		writeBits(value, count) {
 			this.bitBuf |= value << this.bitCount;
 			this.bitCount += count;
@@ -24563,73 +24535,484 @@ var ExcelTS = (function(exports) {
 		output.writeBitsReverse(code, len);
 	}
 	/**
-	* Write a length code (257-285)
-	*/
-	function writeLengthCode(output, length) {
-		let code;
-		let extraBits;
-		let extraValue;
-		if (length <= 10) {
-			code = 257 + length - 3;
-			extraBits = 0;
-			extraValue = 0;
-		} else if (length <= 18) {
-			const base = length - 11;
-			code = 265 + Math.floor(base / 2);
-			extraBits = 1;
-			extraValue = base % 2;
-		} else if (length <= 34) {
-			const base = length - 19;
-			code = 269 + Math.floor(base / 4);
-			extraBits = 2;
-			extraValue = base % 4;
-		} else if (length <= 66) {
-			const base = length - 35;
-			code = 273 + Math.floor(base / 8);
-			extraBits = 3;
-			extraValue = base % 8;
-		} else if (length <= 130) {
-			const base = length - 67;
-			code = 277 + Math.floor(base / 16);
-			extraBits = 4;
-			extraValue = base % 16;
-		} else if (length <= 257) {
-			const base = length - 131;
-			code = 281 + Math.floor(base / 32);
-			extraBits = 5;
-			extraValue = base % 32;
-		} else {
-			code = 285;
-			extraBits = 0;
-			extraValue = 0;
+	* Compute the DEFLATE length code (257..285) and extra bits for a given
+	* match length (3..258).
+	*/
+	function getLengthSymbol(length) {
+		for (let i = 0; i < LENGTH_BASE.length; i++) if (i === LENGTH_BASE.length - 1 || length < LENGTH_BASE[i + 1]) return {
+			code: 257 + i,
+			extra: length - LENGTH_BASE[i],
+			extraBits: LENGTH_EXTRA[i]
+		};
+		return {
+			code: 285,
+			extra: 0,
+			extraBits: 0
+		};
+	}
+	/**
+	* Compute the DEFLATE distance code (0..29) and extra bits for a given
+	* distance (1..32768).
+	*/
+	function getDistSymbol(distance) {
+		for (let i = 0; i < DIST_TABLE.length; i++) {
+			const [maxDist, c, extraBitsCount] = DIST_TABLE[i];
+			if (distance <= maxDist) return {
+				code: c,
+				extra: distance - (i === 0 ? 1 : DIST_TABLE[i - 1][0] + 1),
+				extraBits: extraBitsCount
+			};
 		}
-		writeLiteralCode(output, code);
-		if (extraBits > 0) output.writeBits(extraValue, extraBits);
+		return {
+			code: 29,
+			extra: 0,
+			extraBits: 13
+		};
 	}
 	/**
-	* Write a distance code
+	* Build canonical Huffman code lengths from symbol frequencies.
+	* Uses a bottom-up approach: build a Huffman tree from a priority queue,
+	* then extract depths. Limits maximum code length to maxBits using
+	* the algorithm from zlib's build_tree() / gen_bitlen().
+	*
+	* Returns an array of code lengths indexed by symbol.
 	*/
-	function writeDistanceCode(output, distance) {
+	function buildCodeLengths(freqs, maxBits) {
+		const n = freqs.length;
+		const codeLens = new Uint8Array(n);
+		const activeSymbols = [];
+		for (let i = 0; i < n; i++) if (freqs[i] > 0) activeSymbols.push({
+			sym: i,
+			freq: freqs[i]
+		});
+		if (activeSymbols.length === 0) return codeLens;
+		if (activeSymbols.length === 1) {
+			codeLens[activeSymbols[0].sym] = 1;
+			return codeLens;
+		}
+		activeSymbols.sort((a, b) => a.freq - b.freq || a.sym - b.sym);
+		const nodes = activeSymbols.map((s) => ({
+			freq: s.freq,
+			sym: s.sym,
+			left: null,
+			right: null
+		}));
+		let leafIdx = 0;
+		let intIdx = 0;
+		const intNodes = [];
+		function getMin() {
+			const hasLeaf = leafIdx < nodes.length;
+			const hasInt = intIdx < intNodes.length;
+			if (hasLeaf && hasInt) {
+				if (nodes[leafIdx].freq <= intNodes[intIdx].freq) return nodes[leafIdx++];
+				return intNodes[intIdx++];
+			}
+			if (hasLeaf) return nodes[leafIdx++];
+			return intNodes[intIdx++];
+		}
+		const totalNodes = activeSymbols.length;
+		for (let i = 0; i < totalNodes - 1; i++) {
+			const a = getMin();
+			const b = getMin();
+			const merged = {
+				freq: a.freq + b.freq,
+				sym: -1,
+				left: a,
+				right: b
+			};
+			intNodes.push(merged);
+		}
+		const root = intNodes[intNodes.length - 1];
+		function extractDepths(node, depth) {
+			if (node.sym >= 0) {
+				codeLens[node.sym] = depth;
+				return;
+			}
+			if (node.left) extractDepths(node.left, depth + 1);
+			if (node.right) extractDepths(node.right, depth + 1);
+		}
+		extractDepths(root, 0);
+		const blCount = new Uint16Array(maxBits + 1);
+		for (let i = 0; i < n; i++) if (codeLens[i] > 0) if (codeLens[i] > maxBits) {
+			blCount[maxBits]++;
+			codeLens[i] = maxBits;
+		} else blCount[codeLens[i]]++;
+		let kraft = 0;
+		for (let bits = 1; bits <= maxBits; bits++) kraft += blCount[bits] << maxBits - bits;
+		const target = 1 << maxBits;
+		if (kraft === target) return codeLens;
+		while (kraft > target) {
+			let bits = maxBits - 1;
+			while (bits > 0 && blCount[bits] === 0) bits--;
+			if (bits === 0) break;
+			blCount[bits]--;
+			blCount[maxBits]++;
+			kraft -= (1 << maxBits - bits) - 1;
+		}
+		while (kraft < target) {
+			blCount[maxBits]++;
+			kraft++;
+		}
+		const symbolsByLen = [];
+		for (let i = 0; i < n; i++) if (codeLens[i] > 0) symbolsByLen.push({
+			sym: i,
+			origLen: codeLens[i],
+			freq: freqs[i]
+		});
+		symbolsByLen.sort((a, b) => b.origLen - a.origLen || a.freq - b.freq);
+		codeLens.fill(0);
+		let symIdx = 0;
+		for (let bits = maxBits; bits >= 1; bits--) for (let count = blCount[bits]; count > 0; count--) if (symIdx < symbolsByLen.length) {
+			codeLens[symbolsByLen[symIdx].sym] = bits;
+			symIdx++;
+		}
+		return codeLens;
+	}
+	/**
+	* Build canonical Huffman codes from code lengths (RFC 1951 §3.2.2).
+	* Returns [code, length] pairs indexed by symbol.
+	*/
+	function buildCanonicalCodes(codeLens) {
+		const n = codeLens.length;
+		const codes = new Array(n);
+		const blCount = new Uint16Array(16);
+		for (let i = 0; i < n; i++) if (codeLens[i] > 0) blCount[codeLens[i]]++;
+		const nextCode = new Uint16Array(16);
 		let code = 0;
-		let extraBits = 0;
-		let baseDistance = 1;
-		for (let i = 0; i < DIST_TABLE.length; i++) {
-			const [maxDist, c, extra] = DIST_TABLE[i];
-			if (distance <= maxDist) {
-				code = c;
-				extraBits = extra;
-				break;
+		for (let bits = 1; bits <= 15; bits++) {
+			code = code + blCount[bits - 1] << 1;
+			nextCode[bits] = code;
+		}
+		for (let i = 0; i < n; i++) {
+			const len = codeLens[i];
+			if (len > 0) codes[i] = [nextCode[len]++, len];
+			else codes[i] = [0, 0];
+		}
+		return codes;
+	}
+	/**
+	* Emit a Dynamic Huffman DEFLATE block (BTYPE=2).
+	*
+	* Takes the LZ77 symbol sequence, builds optimal Huffman trees,
+	* encodes the tree descriptions, then encodes the symbols.
+	*/
+	function emitDynamicBlock(out, symbols, isFinal) {
+		const litLenFreqs = new Uint32Array(286);
+		const distFreqs = new Uint32Array(30);
+		litLenFreqs[256] = 1;
+		for (const sym of symbols) if (sym.dist === 0) litLenFreqs[sym.litOrLen]++;
+		else {
+			const ls = getLengthSymbol(sym.litOrLen);
+			litLenFreqs[ls.code]++;
+			const ds = getDistSymbol(sym.dist);
+			distFreqs[ds.code]++;
+		}
+		const litLenLens = buildCodeLengths(litLenFreqs, 15);
+		let distLens = buildCodeLengths(distFreqs, 15);
+		let hasDistCodes = false;
+		for (let i = 0; i < distLens.length; i++) if (distLens[i] > 0) {
+			hasDistCodes = true;
+			break;
+		}
+		if (!hasDistCodes) {
+			distLens = new Uint8Array(30);
+			distLens[0] = 1;
+			distLens[1] = 1;
+		}
+		const litLenCodes = buildCanonicalCodes(litLenLens);
+		const distCodes = buildCanonicalCodes(distLens);
+		let hlit = 286;
+		while (hlit > 257 && litLenLens[hlit - 1] === 0) hlit--;
+		let hdist = 30;
+		while (hdist > 1 && distLens[hdist - 1] === 0) hdist--;
+		const combined = new Uint8Array(hlit + hdist);
+		combined.set(litLenLens.subarray(0, hlit));
+		combined.set(distLens.subarray(0, hdist), hlit);
+		const clSymbols = [];
+		const clFreqs = new Uint32Array(19);
+		for (let i = 0; i < combined.length;) {
+			const val = combined[i];
+			if (val === 0) {
+				let run = 1;
+				while (i + run < combined.length && combined[i + run] === 0) run++;
+				while (run > 0) if (run >= 11) {
+					const repeat = Math.min(run, 138);
+					clSymbols.push({
+						sym: 18,
+						extra: repeat - 11,
+						extraBits: 7
+					});
+					clFreqs[18]++;
+					run -= repeat;
+					i += repeat;
+				} else if (run >= 3) {
+					const repeat = Math.min(run, 10);
+					clSymbols.push({
+						sym: 17,
+						extra: repeat - 3,
+						extraBits: 3
+					});
+					clFreqs[17]++;
+					run -= repeat;
+					i += repeat;
+				} else {
+					clSymbols.push({
+						sym: 0,
+						extra: 0,
+						extraBits: 0
+					});
+					clFreqs[0]++;
+					run--;
+					i++;
+				}
+			} else {
+				clSymbols.push({
+					sym: val,
+					extra: 0,
+					extraBits: 0
+				});
+				clFreqs[val]++;
+				i++;
+				let run = 0;
+				while (i + run < combined.length && combined[i + run] === val) run++;
+				while (run >= 3) {
+					const repeat = Math.min(run, 6);
+					clSymbols.push({
+						sym: 16,
+						extra: repeat - 3,
+						extraBits: 2
+					});
+					clFreqs[16]++;
+					run -= repeat;
+					i += repeat;
+				}
+				while (run > 0) {
+					clSymbols.push({
+						sym: val,
+						extra: 0,
+						extraBits: 0
+					});
+					clFreqs[val]++;
+					run--;
+					i++;
+				}
 			}
-			baseDistance = maxDist + 1;
 		}
-		const extraValue = distance - baseDistance;
-		output.writeBitsReverse(code, 5);
-		if (extraBits > 0) output.writeBits(extraValue, extraBits);
+		const clLens = buildCodeLengths(clFreqs, 7);
+		const clCodes = buildCanonicalCodes(clLens);
+		let hclen = 19;
+		while (hclen > 4 && clLens[CODE_LENGTH_ORDER[hclen - 1]] === 0) hclen--;
+		out.writeBits(isFinal ? 1 : 0, 1);
+		out.writeBits(2, 2);
+		out.writeBits(hlit - 257, 5);
+		out.writeBits(hdist - 1, 5);
+		out.writeBits(hclen - 4, 4);
+		for (let i = 0; i < hclen; i++) out.writeBits(clLens[CODE_LENGTH_ORDER[i]], 3);
+		for (const cls of clSymbols) {
+			const [clCode, clLen] = clCodes[cls.sym];
+			out.writeBitsReverse(clCode, clLen);
+			if (cls.extraBits > 0) out.writeBits(cls.extra, cls.extraBits);
+		}
+		for (const sym of symbols) if (sym.dist === 0) {
+			const [lCode, lLen] = litLenCodes[sym.litOrLen];
+			out.writeBitsReverse(lCode, lLen);
+		} else {
+			const ls = getLengthSymbol(sym.litOrLen);
+			const [lCode, lLen] = litLenCodes[ls.code];
+			out.writeBitsReverse(lCode, lLen);
+			if (ls.extraBits > 0) out.writeBits(ls.extra, ls.extraBits);
+			const ds = getDistSymbol(sym.dist);
+			const [dCode, dLen] = distCodes[ds.code];
+			out.writeBitsReverse(dCode, dLen);
+			if (ds.extraBits > 0) out.writeBits(ds.extra, ds.extraBits);
+		}
+		const [eobCode, eobLen] = litLenCodes[256];
+		out.writeBitsReverse(eobCode, eobLen);
+	}
+	/**
+	* Run LZ77 match-finding on `data[start..end)`.
+	*
+	* When `state` is null, performs one-shot compression with fresh hash tables.
+	* When `state` is provided, maintains sliding window and hash chains across calls.
+	*
+	* Returns an array of LZ77 symbols (literals + length/distance pairs).
+	*/
+	function lz77Compress(data, start, end, config, state) {
+		const symbols = [];
+		const maxChainLen = config.maxChainLen;
+		const goodLen = config.goodLen;
+		const niceLen = config.niceLen;
+		const useLazy = config.lazy;
+		let head;
+		let prevArr;
+		let window;
+		let wLen;
+		let totalIn;
+		let hasPrevMatch;
+		let prevMatchLen;
+		let prevMatchDist;
+		let prevLiteral;
+		if (state) {
+			head = state.head;
+			prevArr = state.prev;
+			window = state.window;
+			wLen = state.windowLen;
+			totalIn = state.totalIn;
+			hasPrevMatch = state.hasPrevMatch;
+			prevMatchLen = state.prevMatchLen;
+			prevMatchDist = state.prevMatchDist;
+			prevLiteral = state.prevLiteral;
+		} else {
+			head = new Int32Array(HASH_SIZE);
+			prevArr = new Int32Array(MAX_DIST);
+			window = null;
+			wLen = 0;
+			totalIn = 0;
+			hasPrevMatch = false;
+			prevMatchLen = 0;
+			prevMatchDist = 0;
+			prevLiteral = 0;
+		}
+		const getByte = state ? (globalPos) => {
+			const localPos = globalPos - totalIn;
+			if (localPos >= start && localPos < end) return data[localPos];
+			return window[globalPos & MAX_DIST - 1];
+		} : (globalPos) => data[globalPos];
+		const insertHash = state ? (localPos) => {
+			if (localPos + 2 >= end) return;
+			const h = hash3(data[localPos], data[localPos + 1], data[localPos + 2]);
+			const gp = totalIn + localPos;
+			prevArr[gp & MAX_DIST - 1] = head[h];
+			head[h] = gp + 1;
+		} : (localPos) => {
+			if (localPos + 2 >= end) return;
+			const h = hash3(data[localPos], data[localPos + 1], data[localPos + 2]);
+			prevArr[localPos & MAX_DIST - 1] = head[h];
+			head[h] = localPos + 1;
+		};
+		const insertWindow = state ? (localPos, count) => {
+			for (let i = 0; i < count; i++) window[wLen + i & MAX_DIST - 1] = data[localPos + i];
+			wLen += count;
+		} : (_localPos, _count) => {};
+		let pos = start;
+		for (; pos < end;) {
+			let bestLen = 0;
+			let bestDist = 0;
+			if (pos + 2 < end) {
+				const h = hash3(data[pos], data[pos + 1], data[pos + 2]);
+				const globalPos = state ? totalIn + pos : pos;
+				let chainRemaining = useLazy && hasPrevMatch && prevMatchLen >= goodLen ? maxChainLen >> 2 : maxChainLen;
+				let matchHead = head[h];
+				while (matchHead > 0 && chainRemaining-- > 0) {
+					const mGlobalPos = matchHead - 1;
+					const dist = globalPos - mGlobalPos;
+					if (dist > MAX_DIST || dist <= 0) break;
+					if (bestLen >= MIN_MATCH) {
+						if (getByte(mGlobalPos + bestLen) !== data[pos + bestLen]) {
+							matchHead = prevArr[mGlobalPos & MAX_DIST - 1];
+							continue;
+						}
+					}
+					const maxLen = Math.min(MAX_MATCH, end - pos);
+					let len = 0;
+					while (len < maxLen) {
+						if (getByte(mGlobalPos + len) !== data[pos + len]) break;
+						len++;
+					}
+					if (len > bestLen) {
+						bestLen = len;
+						bestDist = dist;
+						if (len >= niceLen) break;
+					}
+					matchHead = prevArr[mGlobalPos & MAX_DIST - 1];
+				}
+				if (state) {
+					prevArr[globalPos & MAX_DIST - 1] = head[h];
+					head[h] = globalPos + 1;
+				} else {
+					prevArr[pos & MAX_DIST - 1] = head[h];
+					head[h] = pos + 1;
+				}
+			}
+			if (useLazy && hasPrevMatch) if (bestLen > prevMatchLen) {
+				symbols.push({
+					litOrLen: prevLiteral,
+					dist: 0
+				});
+				prevMatchLen = bestLen;
+				prevMatchDist = bestDist;
+				prevLiteral = data[pos];
+				insertWindow(pos, 1);
+				pos++;
+			} else {
+				symbols.push({
+					litOrLen: prevMatchLen,
+					dist: prevMatchDist
+				});
+				const matchEnd = Math.min(pos - 1 + prevMatchLen, end);
+				for (let i = pos; i < matchEnd; i++) insertHash(i);
+				insertWindow(pos, matchEnd - pos);
+				pos = matchEnd;
+				hasPrevMatch = false;
+				prevMatchLen = 0;
+			}
+			else if (bestLen >= MIN_MATCH) if (useLazy) {
+				hasPrevMatch = true;
+				prevMatchLen = bestLen;
+				prevMatchDist = bestDist;
+				prevLiteral = data[pos];
+				insertWindow(pos, 1);
+				pos++;
+			} else {
+				symbols.push({
+					litOrLen: bestLen,
+					dist: bestDist
+				});
+				const matchEnd = Math.min(pos + bestLen, end);
+				for (let i = pos + 1; i < matchEnd; i++) insertHash(i);
+				insertWindow(pos, matchEnd - pos);
+				pos = matchEnd;
+			}
+			else {
+				if (hasPrevMatch) {
+					symbols.push({
+						litOrLen: prevMatchLen,
+						dist: prevMatchDist
+					});
+					hasPrevMatch = false;
+					prevMatchLen = 0;
+				}
+				symbols.push({
+					litOrLen: data[pos],
+					dist: 0
+				});
+				insertWindow(pos, 1);
+				pos++;
+			}
+		}
+		if (hasPrevMatch) {
+			symbols.push({
+				litOrLen: prevMatchLen,
+				dist: prevMatchDist
+			});
+			const matchEnd = Math.min(pos - 1 + prevMatchLen, end);
+			for (let i = pos; i < matchEnd; i++) insertHash(i);
+			insertWindow(pos, matchEnd - pos);
+			hasPrevMatch = false;
+			prevMatchLen = 0;
+		}
+		if (state) {
+			state.windowLen = wLen;
+			state.totalIn = totalIn + (end - start);
+			state.hasPrevMatch = hasPrevMatch;
+			state.prevMatchLen = prevMatchLen;
+			state.prevMatchDist = prevMatchDist;
+			state.prevLiteral = prevLiteral;
+		}
+		return symbols;
 	}
-	/** Maximum LZ77 sliding window size (32 KB per RFC 1951). */
-	const WINDOW_SIZE = 32768;
 	/**
-	* Stateful synchronous DEFLATE compressor.
+	* Stateful synchronous DEFLATE compressor with Dynamic Huffman encoding.
 	*
 	* Unlike `deflateRawCompressed` (which is a one-shot function), this class
 	* maintains state across multiple `write()` calls:
@@ -24637,30 +25020,39 @@ var ExcelTS = (function(exports) {
 	*  - **LZ77 sliding window**: back-references can span across chunks.
 	*  - **Hash chains**: match positions persist across chunks with typed-array
 	*    hash tables for fast lookup.
-	*  - **Lazy matching**: each match is compared with the next position's match
-	*    to pick the longer one.
+	*  - **Lazy matching**: configurable per compression level.
+	*  - **Dynamic Huffman**: each block builds optimal Huffman trees from
+	*    actual symbol frequencies (BTYPE=2), producing significantly smaller
+	*    output than fixed Huffman (BTYPE=1).
 	*  - **Bit writer**: bit position is preserved, so consecutive blocks form
 	*    a single valid DEFLATE bit-stream without alignment issues.
 	*
-	* Each `write()` emits one non-final fixed-Huffman block (BFINAL=0).
-	* `finish()` emits a final empty block (BFINAL=1) and returns the tail bytes.
+	* Each `write()` emits one non-final Dynamic Huffman block (BFINAL=0).
+	* `finish()` emits a final empty fixed-Huffman block (BFINAL=1).
 	*
 	* This is the pure-JS equivalent of Node.js `zlib.deflateRawSync` with
 	* `Z_SYNC_FLUSH`, used by the streaming ZIP writer (`pushSync`) to achieve
 	* constant-memory streaming in both Node.js and browsers.
+	*
+	* @param level - Compression level (0-9). Level 0 emits STORE blocks.
+	*                Default: 6 (matching zlib default).
 	*/
 	var SyncDeflater = class {
-		constructor() {
+		constructor(level = 6) {
 			this._output = new BitWriter();
-			this._head = new Int32Array(HASH_SIZE);
-			this._prev = new Int32Array(MAX_DIST);
-			this._window = new Uint8Array(WINDOW_SIZE);
-			this._windowLen = 0;
-			this._totalIn = 0;
-			this._hasPrevMatch = false;
-			this._prevMatchLen = 0;
-			this._prevMatchDist = 0;
-			this._prevLiteral = 0;
+			this._state = {
+				head: new Int32Array(HASH_SIZE),
+				prev: new Int32Array(MAX_DIST),
+				window: new Uint8Array(MAX_DIST),
+				windowLen: 0,
+				totalIn: 0,
+				hasPrevMatch: false,
+				prevMatchLen: 0,
+				prevMatchDist: 0,
+				prevLiteral: 0
+			};
+			this._level = Math.max(0, Math.min(9, level));
+			this._config = getLZ77Config(this._level);
 		}
 		/**
 		* Compress a chunk and return the compressed bytes produced so far.
@@ -24669,123 +25061,11 @@ var ExcelTS = (function(exports) {
 		write(data) {
 			if (data.length === 0) return new Uint8Array(0);
 			const out = this._output;
-			out.writeBits(0, 1);
-			out.writeBits(1, 2);
-			const window = this._window;
-			let wLen = this._windowLen;
-			const head = this._head;
-			const prevArr = this._prev;
-			const totalIn = this._totalIn;
-			let hasPrevMatch = this._hasPrevMatch;
-			let prevMatchLen = this._prevMatchLen;
-			let prevMatchDist = this._prevMatchDist;
-			let prevLiteral = this._prevLiteral;
-			/**
-			* Insert a global position into the hash chain and the sliding window.
-			*/
-			const insertHash = (localPos) => {
-				if (localPos + 2 >= data.length) return;
-				const h = hash3(data[localPos], data[localPos + 1], data[localPos + 2]);
-				const globalPos = totalIn + localPos;
-				prevArr[globalPos & MAX_DIST - 1] = head[h];
-				head[h] = globalPos + 1;
-			};
-			const insertWindow = (localPos, count) => {
-				for (let i = 0; i < count; i++) window[wLen + i & WINDOW_SIZE - 1] = data[localPos + i];
-				wLen += count;
-			};
-			let pos = 0;
-			for (; pos < data.length;) {
-				let bestLen = 0;
-				let bestDist = 0;
-				if (pos + 2 < data.length) {
-					const h = hash3(data[pos], data[pos + 1], data[pos + 2]);
-					const globalPos = totalIn + pos;
-					let chainLen = MAX_CHAIN_LEN;
-					let matchHead = head[h];
-					while (matchHead > 0 && chainLen-- > 0) {
-						const mGlobalPos = matchHead - 1;
-						const dist = globalPos - mGlobalPos;
-						if (dist > MAX_DIST || dist <= 0) break;
-						const maxLen = Math.min(MAX_MATCH, data.length - pos);
-						let len = 0;
-						if (bestLen >= MIN_MATCH) {
-							const checkOffset = mGlobalPos + bestLen;
-							let checkByte;
-							const checkLocal = checkOffset - totalIn;
-							if (checkLocal >= 0 && checkLocal < data.length) checkByte = data[checkLocal];
-							else checkByte = window[checkOffset & WINDOW_SIZE - 1];
-							if (checkByte !== data[pos + bestLen]) {
-								matchHead = prevArr[mGlobalPos & MAX_DIST - 1];
-								continue;
-							}
-						}
-						while (len < maxLen) {
-							const matchOffset = mGlobalPos + len;
-							let matchByte;
-							const matchLocal = matchOffset - totalIn;
-							if (matchLocal >= 0 && matchLocal < data.length) matchByte = data[matchLocal];
-							else matchByte = window[matchOffset & WINDOW_SIZE - 1];
-							if (matchByte !== data[pos + len]) break;
-							len++;
-						}
-						if (len > bestLen) {
-							bestLen = len;
-							bestDist = dist;
-							if (len >= MAX_MATCH) break;
-						}
-						matchHead = prevArr[mGlobalPos & MAX_DIST - 1];
-					}
-					prevArr[globalPos & MAX_DIST - 1] = head[h];
-					head[h] = globalPos + 1;
-				}
-				if (hasPrevMatch) if (bestLen > prevMatchLen) {
-					writeLiteralCode(out, prevLiteral);
-					prevMatchLen = bestLen;
-					prevMatchDist = bestDist;
-					prevLiteral = data[pos];
-					insertWindow(pos, 1);
-					pos++;
-				} else {
-					writeLengthCode(out, prevMatchLen);
-					writeDistanceCode(out, prevMatchDist);
-					const matchEnd = pos - 1 + prevMatchLen;
-					const insertEnd = Math.min(matchEnd, data.length);
-					for (let i = pos; i < insertEnd; i++) insertHash(i);
-					insertWindow(pos, insertEnd - pos);
-					pos = insertEnd;
-					hasPrevMatch = false;
-					prevMatchLen = 0;
-				}
-				else if (bestLen >= MIN_MATCH) {
-					hasPrevMatch = true;
-					prevMatchLen = bestLen;
-					prevMatchDist = bestDist;
-					prevLiteral = data[pos];
-					insertWindow(pos, 1);
-					pos++;
-				} else {
-					writeLiteralCode(out, data[pos]);
-					insertWindow(pos, 1);
-					pos++;
-				}
+			if (this._level === 0) {
+				this._writeStore(data);
+				return out.flushBytes();
 			}
-			if (hasPrevMatch) {
-				writeLengthCode(out, prevMatchLen);
-				writeDistanceCode(out, prevMatchDist);
-				const matchEnd = Math.min(pos - 1 + prevMatchLen, data.length);
-				for (let i = pos; i < matchEnd; i++) insertHash(i);
-				insertWindow(pos, matchEnd - pos);
-				hasPrevMatch = false;
-				prevMatchLen = 0;
-			}
-			writeLiteralCode(out, 256);
-			this._windowLen = wLen;
-			this._totalIn = totalIn + data.length;
-			this._hasPrevMatch = hasPrevMatch;
-			this._prevMatchLen = prevMatchLen;
-			this._prevMatchDist = prevMatchDist;
-			this._prevLiteral = prevLiteral;
+			emitDynamicBlock(out, lz77Compress(data, 0, data.length, this._config, this._state), false);
 			return out.flushBytes();
 		}
 		/**
@@ -24799,6 +25079,29 @@ var ExcelTS = (function(exports) {
 			writeLiteralCode(out, 256);
 			return out.finish();
 		}
+		/**
+		* Write STORE (uncompressed) blocks for level=0.
+		* Each block is non-final (BFINAL=0); the final block is emitted by finish().
+		*/
+		_writeStore(data) {
+			const out = this._output;
+			const MAX_BLOCK_SIZE = 65535;
+			let offset = 0;
+			while (offset < data.length) {
+				const remaining = data.length - offset;
+				const blockSize = Math.min(MAX_BLOCK_SIZE, remaining);
+				out.alignToByte();
+				out.writeBits(0, 1);
+				out.writeBits(0, 2);
+				out.alignToByte();
+				out.writeBits(blockSize & 255, 8);
+				out.writeBits(blockSize >> 8 & 255, 8);
+				out.writeBits(~blockSize & 255, 8);
+				out.writeBits(~blockSize >> 8 & 255, 8);
+				for (let i = 0; i < blockSize; i++) out.writeBits(data[offset + i], 8);
+				offset += blockSize;
+			}
+		}
 	};
 	//#endregion
 	//#region src/modules/archive/shared/bytes.ts
@@ -26831,7 +27134,7 @@ self.onmessage = async function(event) {
 			signal: options.signal,
 			allowTransfer: options.allowTransfer
 		});
-		return strategy.jsFallback(data);
+		return strategy.jsFallback(data, options.level);
 	}
 	/**
 	* Decompress data using browser's native DecompressionStream or JS fallback
@@ -26872,7 +27175,7 @@ self.onmessage = async function(event) {
 	*/
 	function zlibSync(data, options = {}) {
 		const level = options.level ?? 6;
-		return wrapZlib(level === 0 ? deflateRawStore(data) : deflateRawCompressed(data), data, level);
+		return wrapZlib(level === 0 ? deflateRawStore(data) : deflateRawCompressed(data, level), data, level);
 	}
 	//#endregion
 	//#region src/modules/archive/compression/streaming-compress.browser.ts
@@ -27063,8 +27366,8 @@ self.onmessage = async function(event) {
 	function createStreamCodec(type, options) {
 		const level = type === "deflate" ? options.level ?? 6 : void 0;
 		if (options.useWorker && hasWorkerSupport()) return createWorkerStreamCodec(type, options.workerPool, level, options.allowTransfer);
-		if (hasDeflateRawWebStreams()) return createNativeWebStreamCodec("deflate-raw", type === "deflate");
-		return new BufferedCodec(type === "deflate" ? deflateRawCompressed : inflateRaw);
+		if (type === "deflate" ? hasDeflateRawCompressionStream() : hasDeflateRawWebStreams()) return createNativeWebStreamCodec("deflate-raw", type === "deflate");
+		return new BufferedCodec(type === "deflate" ? (data) => deflateRawCompressed(data, level) : inflateRaw);
 	}
 	/**
 	* Create a streaming DEFLATE compressor
@@ -27073,6 +27376,15 @@ self.onmessage = async function(event) {
 		return createStreamCodec("deflate", options);
 	}
 	/**
+	* Returns true when the browser supports native `CompressionStream("deflate-raw")`,
+	* signalling that `push()` should prefer the async path over `SyncDeflater`.
+	*
+	* Only checks for compression support — decompression is not needed for writing.
+	*/
+	function hasNativeAsyncDeflate() {
+		return hasDeflateRawCompressionStream();
+	}
+	/**
 	* Initialize ZipCrypto state with a password.
 	*/
 	function zipCryptoInitKeys(password) {
@@ -28629,6 +28941,11 @@ self.onmessage = async function(event) {
 				this._tapCallback(promise, callback);
 				return promise;
 			}
+			if (this._completeError) {
+				const promise = Promise.reject(this._completeError);
+				this._tapCallback(promise, callback);
+				return promise;
+			}
 			if (this._deflateWanted === null) {
 				this._accumulateSampleLen(data);
 				if (!this._shouldDecide(final)) {
@@ -28665,7 +28982,7 @@ self.onmessage = async function(event) {
 		* memory growth when callers push data in a tight synchronous loop.
 		*/
 		push(data, final = false, callback) {
-			if (!this._deflate && this._encryptionMethod === "none") {
+			if (!this._deflate && this._encryptionMethod === "none" && !hasNativeAsyncDeflate()) {
 				try {
 					this._pushSyncPath(data, final);
 					callback?.();
@@ -28675,7 +28992,7 @@ self.onmessage = async function(event) {
 				}
 				return Promise.resolve();
 			}
-			const promise = this._pushChain = this._pushChain.then(() => this._pushUnchained(data, final, callback));
+			const promise = this._pushChain = this._pushChain.then(() => this._pushUnchained(data, final, callback), () => this._pushUnchained(data, final, callback));
 			promise.catch(() => {});
 			return promise;
 		}
@@ -28723,6 +29040,7 @@ self.onmessage = async function(event) {
 				this._syncDeflater = null;
 			}
 			this._emitDataDescriptor();
+			if (this._completeError) throw this._completeError;
 		}
 		/**
 		* Emit local file header with Data Descriptor flag
@@ -34583,6 +34901,9 @@ self.onmessage = async function(event) {
 			this.finalized = false;
 			this._needsDrain = false;
 			this._drainResolvers = [];
+			this._pendingWrites = 0;
+			this._pendingWriteResolvers = [];
+			this._earlyError = null;
 			this.level = options?.level ?? 6;
 			this.modTime = options?.modTime;
 			this.timestamps = options?.timestamps;
@@ -34602,6 +34923,13 @@ self.onmessage = async function(event) {
 			});
 		}
 		_emit(event, ...args) {
+			if (event === "error") {
+				const callbacks = this.events.get(event);
+				if (!callbacks || callbacks.size === 0) {
+					this._earlyError = args[0] instanceof Error ? args[0] : new Error(String(args[0]));
+					return;
+				}
+			}
 			const callbacks = this.events.get(event);
 			if (!callbacks) return;
 			for (const cb of callbacks) cb(...args);
@@ -34612,9 +34940,16 @@ self.onmessage = async function(event) {
 		*/
 		_checkBackpressure(ok) {
 			if (ok instanceof Promise) {
+				this._pendingWrites++;
 				ok.then((result) => {
 					if (result === false) this._needsDrain = true;
-				}, () => {});
+				}, () => {}).finally(() => {
+					this._pendingWrites--;
+					if (this._pendingWrites === 0) {
+						const resolvers = this._pendingWriteResolvers.splice(0);
+						for (const resolve of resolvers) resolve();
+					}
+				});
 				return;
 			}
 			if (ok === false) this._needsDrain = true;
@@ -34623,6 +34958,11 @@ self.onmessage = async function(event) {
 			const callbacks = this.events.get(event) || /* @__PURE__ */ new Set();
 			callbacks.add(callback);
 			this.events.set(event, callbacks);
+			if (event === "error" && this._earlyError) {
+				const err = this._earlyError;
+				this._earlyError = null;
+				callback(err);
+			}
 			return this;
 		}
 		once(event, callback) {
@@ -34649,10 +34989,14 @@ self.onmessage = async function(event) {
 		}
 		/**
 		* Wait for the downstream writable to drain if it signaled backpressure.
-		* Resolves immediately if no backpressure is active.
+		* If any write() calls are still in-flight (returned a Promise that hasn't
+		* settled), waits for all of them first so the backpressure signal isn't missed.
 		*/
-		waitForDrain() {
-			if (!this._needsDrain || !this.pipedStream) return Promise.resolve();
+		async waitForDrain() {
+			if (this._pendingWrites > 0) await new Promise((resolve) => {
+				this._pendingWriteResolvers.push(resolve);
+			});
+			if (!this._needsDrain || !this.pipedStream) return;
 			return new Promise((resolve) => {
 				this._drainResolvers.push(resolve);
 			});
@@ -39531,7 +39875,7 @@ onmessage = async (ev) => {
 	* @param shouldSkipEmpty - true, false, or "greedy"
 	* @returns true if the row should be skipped
 	*/
-	function isEmptyRow(row, shouldSkipEmpty) {
+	function isEmptyRow$1(row, shouldSkipEmpty) {
 		if (!shouldSkipEmpty) return false;
 		if (shouldSkipEmpty === "greedy") {
 			for (const field of row) if (NON_WHITESPACE_REGEX.test(field)) return false;
@@ -39546,7 +39890,7 @@ onmessage = async (ev) => {
 	* @returns true if all fields are empty strings
 	*/
 	function hasAllEmptyValues(row) {
-		return isEmptyRow(row, true);
+		return isEmptyRow$1(row, true);
 	}
 	//#endregion
 	//#region src/modules/csv/errors.ts
@@ -40497,7 +40841,7 @@ onmessage = async (ev) => {
 	*/
 	function shouldSkipRow(row, comment, shouldSkipEmpty, skipRecordsWithEmptyValues) {
 		if (comment && row[0]?.trimStart().startsWith(comment)) return true;
-		if (isEmptyRow(row, shouldSkipEmpty)) return true;
+		if (isEmptyRow$1(row, shouldSkipEmpty)) return true;
 		if (skipRecordsWithEmptyValues && hasAllEmptyValues(row)) return true;
 		return false;
 	}
@@ -41305,7 +41649,7 @@ onmessage = async (ev) => {
 				currentCharOffset += lineCharLength;
 				continue;
 			}
-			if (config.shouldSkipEmpty && isEmptyRow(trimmedRow, config.shouldSkipEmpty)) {
+			if (config.shouldSkipEmpty && isEmptyRow$1(trimmedRow, config.shouldSkipEmpty)) {
 				currentCharOffset += lineCharLength;
 				continue;
 			}
@@ -41369,7 +41713,7 @@ onmessage = async (ev) => {
 				pos = scanResult.endPos;
 				continue;
 			}
-			if (config.shouldSkipEmpty && isEmptyRow(row, config.shouldSkipEmpty)) {
+			if (config.shouldSkipEmpty && isEmptyRow$1(row, config.shouldSkipEmpty)) {
 				pos = scanResult.endPos;
 				continue;
 			}
@@ -42751,6 +43095,545 @@ onmessage = async (ev) => {
 		return new CsvFormatterStream(options);
 	}
 	//#endregion
+	//#region src/modules/markdown/constants.ts
+	/**
+	* Markdown Module Constants
+	*
+	* Shared constants used across the Markdown module.
+	*/
+	/**
+	* Pre-compiled regex for line splitting (matches CR, LF, or CRLF)
+	*/
+	const LINEBREAK_REGEX = /\r\n|\r|\n/;
+	/**
+	* Characters that need escaping in Markdown table cells.
+	* Also matches CRLF/CR/LF so that escaping + newline conversion
+	* can be done in a single `replace()` call.
+	* Note: `\r\n` must come before `\r` to match CRLF as a single unit.
+	*/
+	const ESCAPE_AND_NEWLINE = /\r\n|[|\\\r\n]/g;
+	/**
+	* Regex to unescape Markdown table cell content (`\|` → `|`, `\\` → `\`)
+	*/
+	const UNESCAPE_REGEX = /\\([|\\])/g;
+	/**
+	* Regex to match `<br>`, `<br/>`, or `<br />` tags (case-insensitive).
+	* Used to convert multiline cell representations back to newlines during parsing.
+	*/
+	const BR_TAG_REGEX = /<br\s*\/?>/gi;
+	/**
+	* Regex to match literal newlines (CR, LF, or CRLF) in cell content.
+	* Used when escaping is disabled but newline conversion is still needed.
+	*/
+	const NEWLINE_IN_CELL = /\r\n|\r|\n/g;
+	//#endregion
+	//#region src/modules/markdown/errors.ts
+	/**
+	* Markdown module error types.
+	*/
+	/**
+	* Base class for all Markdown-related errors.
+	*/
+	var MarkdownError = class extends BaseError {
+		constructor(..._args) {
+			super(..._args);
+			this.name = "MarkdownError";
+		}
+	};
+	/**
+	* Error thrown when Markdown parsing fails.
+	*/
+	var MarkdownParseError = class extends MarkdownError {
+		constructor(message, line, options) {
+			super(`Line ${line}: ${message}`, options);
+			this.name = "MarkdownParseError";
+			this.line = line;
+		}
+	};
+	//#endregion
+	//#region src/modules/markdown/parse/index.ts
+	const CH_PIPE = 124;
+	const CH_BACKSLASH = 92;
+	const CH_COLON = 58;
+	const CH_DASH = 45;
+	const CH_SPACE = 32;
+	const CH_TAB = 9;
+	function resolveParseOpts(options) {
+		return {
+			trim: options.trim !== false,
+			unescape: options.unescape !== false,
+			skipEmpty: options.skipEmptyRows !== false,
+			maxRows: options.maxRows,
+			convertBr: options.convertBr === true
+		};
+	}
+	/**
+	* Split a Markdown table row into cell values.
+	* Handles escaped pipes (`\|`) correctly by scanning character by character.
+	*
+	* Optimized: uses start/end index tracking with `slice()` instead of
+	* character-by-character string concatenation to avoid O(n²) worst case.
+	*/
+	function splitRow(line) {
+		const cells = [];
+		const len = line.length;
+		let i = len > 0 && line.charCodeAt(0) === CH_PIPE ? 1 : 0;
+		let end = len;
+		if (len > 1 && line.charCodeAt(len - 1) === CH_PIPE) {
+			let backslashCount = 0;
+			let k = len - 2;
+			while (k >= 0 && line.charCodeAt(k) === CH_BACKSLASH) {
+				backslashCount++;
+				k--;
+			}
+			if (backslashCount % 2 === 0) end = len - 1;
+		}
+		let segStart = i;
+		let current = "";
+		let hasEscape = false;
+		while (i < end) {
+			const ch = line.charCodeAt(i);
+			if (ch === CH_BACKSLASH && i + 1 < end) {
+				hasEscape = true;
+				if (i > segStart) current += line.slice(segStart, i);
+				current += line.slice(i, i + 2);
+				i += 2;
+				segStart = i;
+			} else if (ch === CH_PIPE) {
+				if (hasEscape) {
+					if (i > segStart) current += line.slice(segStart, i);
+					cells.push(current);
+					current = "";
+					hasEscape = false;
+				} else cells.push(line.slice(segStart, i));
+				i++;
+				segStart = i;
+			} else i++;
+		}
+		if (hasEscape) {
+			if (end > segStart) current += line.slice(segStart, end);
+			cells.push(current);
+		} else cells.push(line.slice(segStart, end));
+		return cells;
+	}
+	/**
+	* Determine column alignment from a separator cell.
+	*
+	* - `:---:` → center
+	* - `:---`  → left
+	* - `---:`  → right
+	* - `---`   → none
+	*/
+	function parseAlignment(cell) {
+		const trimmed = cell.trim();
+		const tLen = trimmed.length;
+		if (tLen === 0) return "none";
+		const leftColon = trimmed.charCodeAt(0) === CH_COLON;
+		const rightColon = trimmed.charCodeAt(tLen - 1) === CH_COLON;
+		if (leftColon && rightColon) return "center";
+		if (leftColon) return "left";
+		if (rightColon) return "right";
+		return "none";
+	}
+	/**
+	* Check if a cell string is a valid separator cell.
+	* Hand-rolled check replacing regex for better performance.
+	* Pattern: optional whitespace, optional colon, one or more dashes, optional colon, optional whitespace.
+	*/
+	function isSeparatorCell(cell) {
+		const len = cell.length;
+		let i = 0;
+		while (i < len) {
+			const ch = cell.charCodeAt(i);
+			if (ch !== CH_SPACE && ch !== CH_TAB) break;
+			i++;
+		}
+		if (i < len && cell.charCodeAt(i) === CH_COLON) i++;
+		const dashStart = i;
+		while (i < len && cell.charCodeAt(i) === CH_DASH) i++;
+		if (i === dashStart) return false;
+		if (i < len && cell.charCodeAt(i) === CH_COLON) i++;
+		while (i < len) {
+			const ch = cell.charCodeAt(i);
+			if (ch !== CH_SPACE && ch !== CH_TAB) return false;
+			i++;
+		}
+		return true;
+	}
+	/**
+	* Check if a line is a valid separator row.
+	* A separator row consists entirely of cells matching the pattern `:?-+:?`.
+	*/
+	function isSeparatorRow(cells) {
+		if (cells.length === 0) return false;
+		for (let i = 0; i < cells.length; i++) if (!isSeparatorCell(cells[i])) return false;
+		return true;
+	}
+	/**
+	* Process cell content: trim, optionally unescape, and optionally convert `<br>` to newlines.
+	*/
+	function processCell(value, opts) {
+		let result = opts.trim ? value.trim() : value;
+		if (opts.unescape) result = result.replace(UNESCAPE_REGEX, "$1");
+		if (opts.convertBr) result = result.replace(BR_TAG_REGEX, "\n");
+		return result;
+	}
+	/**
+	* Normalize a row to the expected column count.
+	* - If row has fewer cells, pad with empty strings
+	* - If row has more cells, truncate
+	*/
+	function normalizeRow(cells, columnCount, opts) {
+		const row = new Array(columnCount);
+		for (let i = 0; i < columnCount; i++) row[i] = i < cells.length ? processCell(cells[i], opts) : "";
+		return row;
+	}
+	/**
+	* Check if a row is empty (all cells are empty strings).
+	*/
+	function isEmptyRow(row) {
+		for (let i = 0; i < row.length; i++) if (row[i] !== "") return false;
+		return true;
+	}
+	/**
+	* Check if a line could be part of a table (contains a pipe character).
+	*/
+	function isTableLine(line) {
+		return line.indexOf("|") !== -1;
+	}
+	/**
+	* Check if a line starts with a pipe (after optional leading whitespace).
+	* Used to determine the table's "piped" style for data row validation.
+	*/
+	function startsWithPipe(line) {
+		const len = line.length;
+		let i = 0;
+		while (i < len) {
+			const ch = line.charCodeAt(i);
+			if (ch !== CH_SPACE && ch !== CH_TAB) return ch === CH_PIPE;
+			i++;
+		}
+		return false;
+	}
+	/**
+	* Check if a line could be a separator candidate (contains a dash).
+	*/
+	function hasDash(line) {
+		return line.indexOf("-") !== -1;
+	}
+	/**
+	* Attempt to parse a table starting at line index `startLine`.
+	*
+	* Returns `{ result, endLine }` if a valid table starts here, or `null` otherwise.
+	*/
+	function parseTableAt(lines, startLine, lineCount, opts) {
+		if (startLine >= lineCount - 1) return null;
+		const line = lines[startLine].trim();
+		if (line === "" || !isTableLine(line)) return null;
+		const headerCells = splitRow(line);
+		if (headerCells.length < 1) return null;
+		const separatorLine = lines[startLine + 1].trim();
+		if (separatorLine === "" || !hasDash(separatorLine)) return null;
+		const separatorCells = splitRow(separatorLine);
+		if (!isSeparatorRow(separatorCells)) return null;
+		const columnCount = headerCells.length;
+		const headers = new Array(columnCount);
+		const alignments = new Array(columnCount);
+		for (let c = 0; c < columnCount; c++) {
+			headers[c] = processCell(headerCells[c], opts);
+			alignments[c] = c < separatorCells.length ? parseAlignment(separatorCells[c]) : "none";
+		}
+		const piped = startsWithPipe(line);
+		const rows = [];
+		let j = startLine + 2;
+		for (; j < lineCount; j++) {
+			const dataLine = lines[j].trim();
+			if (dataLine === "" || !isTableLine(dataLine)) break;
+			if (piped && !startsWithPipe(dataLine)) break;
+			if (opts.maxRows !== void 0 && rows.length >= opts.maxRows) {
+				while (j < lineCount) {
+					const remaining = lines[j].trim();
+					if (remaining === "" || !isTableLine(remaining)) break;
+					if (piped && !startsWithPipe(remaining)) break;
+					j++;
+				}
+				break;
+			}
+			const row = normalizeRow(splitRow(dataLine), columnCount, opts);
+			if (opts.skipEmpty && isEmptyRow(row)) continue;
+			rows.push(row);
+		}
+		return {
+			result: {
+				headers,
+				rows,
+				alignments
+			},
+			endLine: j
+		};
+	}
+	/**
+	* Parse a Markdown table string into structured data.
+	*
+	* The parser looks for the GFM table pattern:
+	* 1. A header row (pipe-delimited cells)
+	* 2. A separator row (dashes with optional colons for alignment)
+	* 3. Zero or more data rows
+	*
+	* Non-table content before and after the table is ignored.
+	*
+	* @param input - Markdown string containing a table
+	* @param options - Parse options
+	* @returns Parsed table data with headers, rows, and alignments
+	*
+	* @throws {MarkdownParseError} When no valid table is found in the input
+	*
+	* @example
+	* ```ts
+	* // Basic table
+	* const result = parseMarkdown("| Name | Age |\n| --- | --- |\n| Alice | 30 |");
+	*
+	* // With alignment
+	* const result = parseMarkdown("| Left | Center | Right |\n|:---|:---:|---:|\n|a|b|c|");
+	* // result.alignments = ["left", "center", "right"]
+	*
+	* // From a larger Markdown document
+	* const result = parseMarkdown(markdownDoc); // Finds the first table
+	*
+	* // With options
+	* const result = parseMarkdown(input, { trim: false, maxRows: 100 });
+	* ```
+	*/
+	function parseMarkdown(input, options = {}) {
+		const opts = resolveParseOpts(options);
+		const lines = input.split(LINEBREAK_REGEX);
+		const lineCount = lines.length;
+		for (let i = 0; i < lineCount - 1; i++) {
+			const parsed = parseTableAt(lines, i, lineCount, opts);
+			if (parsed) return parsed.result;
+		}
+		throw new MarkdownParseError("No valid Markdown table found in input", lineCount > 0 ? lineCount : 1);
+	}
+	/**
+	* Parse all Markdown tables from a document.
+	*
+	* @param input - Markdown string containing one or more tables
+	* @param options - Parse options (maxRows applies per table)
+	* @returns Array of parsed tables
+	*
+	* @example
+	* ```ts
+	* const tables = parseMarkdownAll(markdownDoc);
+	* console.log(`Found ${tables.length} tables`);
+	* tables.forEach((t, i) => console.log(`Table ${i}: ${t.headers.join(", ")}`));
+	* ```
+	*/
+	function parseMarkdownAll(input, options = {}) {
+		const opts = resolveParseOpts(options);
+		const lines = input.split(LINEBREAK_REGEX);
+		const lineCount = lines.length;
+		const tables = [];
+		let i = 0;
+		while (i < lineCount - 1) {
+			const parsed = parseTableAt(lines, i, lineCount, opts);
+			if (parsed) {
+				tables.push(parsed.result);
+				i = parsed.endLine;
+			} else i++;
+		}
+		return tables;
+	}
+	//#endregion
+	//#region src/modules/markdown/format/index.ts
+	/**
+	* Calculate the display width of a string in a monospace terminal.
+	* CJK characters, fullwidth forms, and most emoji are 2 columns wide.
+	* This enables proper column alignment in tables containing these characters.
+	*/
+	function displayWidth(str) {
+		let width = 0;
+		for (let i = 0; i < str.length; i++) {
+			const code = str.charCodeAt(i);
+			if (code >= 55296 && code <= 56319 && i + 1 < str.length) {
+				const low = str.charCodeAt(i + 1);
+				if (low >= 56320 && low <= 57343) {
+					width += 2;
+					i++;
+					continue;
+				}
+			}
+			if (code === 8203 || code === 8204 || code === 8205 || code === 65279) continue;
+			if (code >= 768 && code <= 879 || code >= 6832 && code <= 6911 || code >= 7616 && code <= 7679 || code >= 8400 && code <= 8447 || code >= 65056 && code <= 65071) continue;
+			if (code >= 4352 && code <= 4447 || code >= 11904 && code <= 12350 || code >= 12352 && code <= 13247 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 42191 || code >= 43360 && code <= 43391 || code >= 44032 && code <= 55215 || code >= 63744 && code <= 64255 || code >= 65040 && code <= 65049 || code >= 65072 && code <= 65135 || code >= 65281 && code <= 65376 || code >= 65504 && code <= 65510) {
+				width += 2;
+				continue;
+			}
+			width += 1;
+		}
+		return width;
+	}
+	/**
+	* Default value-to-string converter.
+	*/
+	function defaultStringify(value) {
+		if (value === null || value === void 0) return "";
+		if (value instanceof Date) return value.toISOString();
+		if (typeof value === "object") try {
+			return JSON.stringify(value);
+		} catch {
+			return "[object Object]";
+		}
+		return String(value);
+	}
+	/**
+	* Escape pipe characters, backslashes, and convert newlines to `<br>` in a single pass.
+	* `|` → `\|`, `\` → `\\`, `\r\n`/`\r`/`\n` → `<br>`
+	*/
+	function escapeCell(value) {
+		return value.replace(ESCAPE_AND_NEWLINE, (ch) => ch === "|" || ch === "\\" ? "\\" + ch : "<br>");
+	}
+	/**
+	* Convert literal newlines to `<br>` without escaping pipes/backslashes.
+	*/
+	function convertNewlines(value) {
+		if (value.indexOf("\n") !== -1 || value.indexOf("\r") !== -1) return value.replace(NEWLINE_IN_CELL, "<br>");
+		return value;
+	}
+	/**
+	* Build the separator cell for a column based on alignment and width.
+	*
+	* Examples (width=5):
+	* - none:   `-----`
+	* - left:   `:----`
+	* - right:  `----:`
+	* - center: `:---:`
+	*/
+	function buildSeparator(alignment, width) {
+		switch (alignment) {
+			case "left": return ":" + "-".repeat(width - 1);
+			case "right": return "-".repeat(width - 1) + ":";
+			case "center": return ":" + "-".repeat(Math.max(width - 2, 1)) + ":";
+			default: return "-".repeat(width);
+		}
+	}
+	/**
+	* Pad a cell value to the target display width with alignment.
+	* Uses displayWidth() for proper CJK/emoji handling.
+	*/
+	function padCell(value, targetWidth, alignment) {
+		const len = displayWidth(value);
+		if (len >= targetWidth) return value;
+		const diff = targetWidth - len;
+		switch (alignment) {
+			case "right": return " ".repeat(diff) + value;
+			case "center": {
+				const left = Math.floor(diff / 2);
+				const right = diff - left;
+				return " ".repeat(left) + value + " ".repeat(right);
+			}
+			default: return value + " ".repeat(diff);
+		}
+	}
+	/**
+	* Resolve column configuration from options.
+	*/
+	function resolveColumns(headers, options) {
+		const columnCount = headers.length;
+		const defaultAlignment = options.alignment ?? "left";
+		const displayHeaders = new Array(columnCount);
+		const alignments = new Array(columnCount);
+		const minWidths = new Array(columnCount);
+		if (options.columns && options.columns.length > 0) for (let i = 0; i < columnCount; i++) {
+			const col = i < options.columns.length ? options.columns[i] : void 0;
+			if (typeof col === "string") {
+				displayHeaders[i] = col;
+				alignments[i] = defaultAlignment;
+				minWidths[i] = 3;
+			} else if (col) {
+				displayHeaders[i] = col.header;
+				alignments[i] = col.alignment ?? defaultAlignment;
+				minWidths[i] = col.minWidth ?? 3;
+			} else {
+				displayHeaders[i] = headers[i] ?? "";
+				alignments[i] = defaultAlignment;
+				minWidths[i] = 3;
+			}
+		}
+		else for (let i = 0; i < columnCount; i++) {
+			displayHeaders[i] = headers[i] ?? "";
+			alignments[i] = defaultAlignment;
+			minWidths[i] = 3;
+		}
+		return {
+			displayHeaders,
+			alignments,
+			minWidths
+		};
+	}
+	/**
+	* Format data as a Markdown table string.
+	*
+	* @param headers - Column header strings
+	* @param rows - Data rows (each row is an array of cell values)
+	* @param options - Formatting options
+	* @returns Formatted Markdown table string
+	*
+	* @example
+	* ```ts
+	* formatMarkdown(
+	*   ["Name", "Age", "City"],
+	*   [
+	*     ["Alice", 30, "New York"],
+	*     ["Bob", 25, "London"]
+	*   ]
+	* );
+	* ```
+	*/
+	function formatMarkdown(headers, rows, options = {}) {
+		const { padding = true, trailingNewline = true, escapeContent = true, stringify = defaultStringify } = options;
+		const columnCount = headers.length;
+		if (columnCount === 0) return "";
+		const { displayHeaders, alignments, minWidths } = resolveColumns(headers, options);
+		const headerStrings = new Array(columnCount);
+		const widths = new Array(columnCount);
+		for (let i = 0; i < columnCount; i++) {
+			const h = escapeContent ? escapeCell(displayHeaders[i]) : convertNewlines(displayHeaders[i]);
+			headerStrings[i] = h;
+			widths[i] = padding ? Math.max(displayWidth(h), minWidths[i]) : Math.max(minWidths[i], 3);
+		}
+		const rowStrings = new Array(rows.length);
+		for (let r = 0; r < rows.length; r++) {
+			const row = rows[r];
+			const cells = new Array(columnCount);
+			for (let c = 0; c < columnCount; c++) {
+				const raw = c < row.length ? stringify(row[c]) : "";
+				const cell = escapeContent ? escapeCell(raw) : convertNewlines(raw);
+				cells[c] = cell;
+				if (padding) {
+					const cellWidth = displayWidth(cell);
+					if (cellWidth > widths[c]) widths[c] = cellWidth;
+				}
+			}
+			rowStrings[r] = cells;
+		}
+		const totalLines = 2 + rowStrings.length;
+		const lines = new Array(totalLines);
+		const headerParts = new Array(columnCount);
+		for (let c = 0; c < columnCount; c++) headerParts[c] = padding ? " " + padCell(headerStrings[c], widths[c], alignments[c]) + " " : " " + headerStrings[c] + " ";
+		lines[0] = "|" + headerParts.join("|") + "|";
+		const sepParts = new Array(columnCount);
+		for (let c = 0; c < columnCount; c++) sepParts[c] = buildSeparator(alignments[c], widths[c] + 2);
+		lines[1] = "|" + sepParts.join("|") + "|";
+		for (let r = 0; r < rowStrings.length; r++) {
+			const rowParts = new Array(columnCount);
+			for (let c = 0; c < columnCount; c++) rowParts[c] = padding ? " " + padCell(rowStrings[r][c], widths[c], alignments[c]) + " " : " " + rowStrings[r][c] + " ";
+			lines[r + 2] = "|" + rowParts.join("|") + "|";
+		}
+		let result = lines.join("\n");
+		if (trailingNewline) result += "\n";
+		return result;
+	}
+	//#endregion
 	//#region src/modules/excel/workbook.browser.ts
 	/**
 	* Workbook - Cross-platform Excel Workbook (Browser Version)
@@ -42821,6 +43704,33 @@ onmessage = async (ev) => {
 			return value;
 		};
 	}
+	/**
+	* Create a stringify function for Markdown output.
+	* Handles hyperlinks, formulas, rich text, dates, errors, and objects.
+	*/
+	function createMarkdownStringify(dateFormat, dateUTC) {
+		const formatter = dateFormat ? DateFormatter.create(dateFormat, { utc: dateUTC }) : DateFormatter.iso(dateUTC);
+		return function stringify(value) {
+			if (value === null || value === void 0) return "";
+			if (typeof value === "string") return value;
+			if (typeof value === "number" || typeof value === "bigint") return String(value);
+			if (typeof value === "boolean") return value ? "true" : "false";
+			if (value instanceof Date) return formatter.format(value);
+			if (typeof value === "object") {
+				const v = value;
+				if (v.text || v.hyperlink) return v.hyperlink || v.text || "";
+				if (v.formula || v.result) return v.result != null ? String(v.result) : "";
+				if (v.richText && Array.isArray(v.richText)) return v.richText.map((r) => r.text).join("");
+				if (v.error) return v.error;
+				try {
+					return JSON.stringify(value);
+				} catch {
+					return "[object Object]";
+				}
+			}
+			return String(value);
+		};
+	}
 	function isUrl(input) {
 		return typeof input === "string" && /^https?:\/\//i.test(input);
 	}
@@ -43175,6 +44085,153 @@ onmessage = async (ev) => {
 			await pipelinePromise;
 		}
 		/**
+		* Populate a worksheet from a parsed Markdown table result.
+		* Shared by readMarkdown and readMarkdownAll.
+		*/
+		_populateMarkdownWorksheet(worksheet, result, map) {
+			worksheet.addRow(result.headers);
+			worksheet._markdownAlignments = result.alignments;
+			for (const row of result.rows) if (map) worksheet.addRow(row.map((v, i) => map(v, i)));
+			else worksheet.addRow(row);
+		}
+		/**
+		* Read a Markdown table and add as worksheet.
+		*
+		* @example
+		* ```ts
+		* // From a Markdown string
+		* workbook.readMarkdown("| Name | Age |\n| --- | --- |\n| Alice | 30 |");
+		*
+		* // With options
+		* workbook.readMarkdown(markdownString, { sheetName: "Data", map: (v, col) => Number(v) || v });
+		* ```
+		*/
+		readMarkdown(input, options) {
+			const parseResult = parseMarkdown(input, {
+				trim: options?.trim,
+				unescape: options?.unescape,
+				skipEmptyRows: options?.skipEmptyRows,
+				maxRows: options?.maxRows,
+				convertBr: options?.convertBr
+			});
+			const worksheet = this.addWorksheet(options?.sheetName);
+			this._populateMarkdownWorksheet(worksheet, parseResult, options?.map);
+			return worksheet;
+		}
+		/**
+		* Read all Markdown tables from a document, each becoming a separate worksheet.
+		*
+		* @param input - Markdown string containing one or more tables
+		* @param options - Parse options (sheetName is used as prefix: "sheetName", "sheetName_2", ...)
+		* @returns Array of created worksheets (empty if no tables found)
+		*
+		* @example
+		* ```ts
+		* // Parse a document with multiple tables
+		* const sheets = workbook.readMarkdownAll(markdownDoc);
+		* console.log(`Created ${sheets.length} worksheets`);
+		*
+		* // With a naming prefix
+		* const sheets = workbook.readMarkdownAll(markdownDoc, { sheetName: "Table" });
+		* // Creates "Table", "Table_2", "Table_3", ...
+		* ```
+		*/
+		readMarkdownAll(input, options) {
+			const parseResults = parseMarkdownAll(input, {
+				trim: options?.trim,
+				unescape: options?.unescape,
+				skipEmptyRows: options?.skipEmptyRows,
+				maxRows: options?.maxRows,
+				convertBr: options?.convertBr
+			});
+			const baseName = options?.sheetName;
+			const map = options?.map;
+			const worksheets = [];
+			for (let t = 0; t < parseResults.length; t++) {
+				const name = baseName ? t === 0 ? baseName : `${baseName}_${t + 1}` : void 0;
+				const worksheet = this.addWorksheet(name);
+				this._populateMarkdownWorksheet(worksheet, parseResults[t], map);
+				worksheets.push(worksheet);
+			}
+			return worksheets;
+		}
+		/**
+		* Write worksheet as a Markdown table string.
+		*
+		* @example
+		* ```ts
+		* // Write first worksheet
+		* const markdownText = workbook.writeMarkdown();
+		*
+		* // Write specific worksheet with options
+		* const markdownText = workbook.writeMarkdown({ sheetName: "Data", padding: true });
+		* ```
+		*/
+		writeMarkdown(options) {
+			const worksheet = this.getWorksheet(options?.sheetName || options?.sheetId);
+			if (!worksheet) return "";
+			const dateFormat = options?.dateFormat;
+			const dateUTC = options?.dateUTC;
+			const includeEmptyRows = options?.includeEmptyRows !== false;
+			const stringify = options?.stringify ?? createMarkdownStringify(dateFormat, dateUTC);
+			const allRows = [];
+			let lastRow = 1;
+			worksheet.eachRow((row, rowNumber) => {
+				if (includeEmptyRows) while (lastRow++ < rowNumber - 1) allRows.push([]);
+				const values = Array.from(row.values).slice(1);
+				allRows.push(values);
+				lastRow = rowNumber;
+			});
+			if (allRows.length === 0) return "";
+			const headers = allRows[0].map((v) => stringify(v));
+			const dataRows = allRows.slice(1);
+			const storedAlignments = worksheet._markdownAlignments;
+			const columns = options?.columns;
+			let resolvedColumns;
+			if (!columns && storedAlignments) resolvedColumns = headers.map((h, i) => ({
+				header: h,
+				alignment: i < storedAlignments.length ? storedAlignments[i] : void 0
+			}));
+			return formatMarkdown(headers, dataRows, {
+				columns: resolvedColumns ?? columns,
+				alignment: options?.alignment,
+				padding: options?.padding,
+				trailingNewline: options?.trailingNewline,
+				escapeContent: options?.escapeContent,
+				stringify
+			});
+		}
+		/**
+		* Write worksheet to Markdown buffer (Uint8Array).
+		*
+		* @example
+		* ```ts
+		* const buffer = workbook.writeMarkdownBuffer();
+		* ```
+		*/
+		writeMarkdownBuffer(options) {
+			const markdownString = this.writeMarkdown(options);
+			return new TextEncoder().encode(markdownString);
+		}
+		/**
+		* Read Markdown from file (Node.js only - throws in browser)
+		*/
+		async readMarkdownFile(_filename, _options) {
+			throw new ExcelNotSupportedError("readMarkdownFile()", "not available in browser. Use readMarkdown(string) instead.");
+		}
+		/**
+		* Read all Markdown tables from file (Node.js only - throws in browser)
+		*/
+		async readMarkdownAllFile(_filename, _options) {
+			throw new ExcelNotSupportedError("readMarkdownAllFile()", "not available in browser. Use readMarkdownAll(string) instead.");
+		}
+		/**
+		* Write Markdown to file (Node.js only - throws in browser)
+		*/
+		async writeMarkdownFile(_filename, _options) {
+			throw new ExcelNotSupportedError("writeMarkdownFile()", "not available in browser. Use writeMarkdown() and trigger a download instead.");
+		}
+		/**
 		* Create a streaming workbook writer for large files.
 		* This is more memory-efficient than using Workbook for large datasets.
 		*
@@ -48640,6 +49697,8 @@ onmessage = async (ev) => {
 	exports.ImageError = ImageError;
 	exports.InvalidAddressError = InvalidAddressError;
 	exports.InvalidValueTypeError = InvalidValueTypeError;
+	exports.MarkdownError = MarkdownError;
+	exports.MarkdownParseError = MarkdownParseError;
 	exports.MaxItemsExceededError = MaxItemsExceededError;
 	exports.MergeConflictError = MergeConflictError;
 	exports.PageSizes = PageSizes;