@cj-tech-master/excelts 6.1.1 → 6.1.2

package/dist/iife/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
-* @cj-tech-master/excelts v6.1.1
+* @cj-tech-master/excelts v6.1.2
 * TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.
 * (c) 2026 cjnoname
 * Released under the MIT License
@@ -18865,11 +18865,27 @@ var ExcelTS = (function(exports) {
 		}
 		return output.subarray(0, outPos);
 	}
+	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;
 	/**
-	* Compress data using DEFLATE with fixed Huffman codes
+	* 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
+	* properties in the lower bits.
+	*/
+	function hash3(a, b, c) {
+		return (a << 16 | b << 8 | c) * 506832829 >>> 17 & HASH_MASK;
+	}
+	/**
+	* Compress data using DEFLATE with fixed Huffman codes.
 	*
-	* This provides real compression using LZ77 + fixed Huffman codes.
-	* Not as efficient as full DEFLATE but much better than STORE mode.
+	* 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.
 	*
 	* @param data - Data to compress
 	* @returns Compressed data in deflate-raw format
@@ -18880,35 +18896,75 @@ var ExcelTS = (function(exports) {
 		const output = new BitWriter();
 		output.writeBits(1, 1);
 		output.writeBits(1, 2);
-		const hashTable = /* @__PURE__ */ new Map();
+		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 hash = data[pos] << 16 | data[pos + 1] << 8 | data[pos + 2];
-				const matchPos = hashTable.get(hash);
-				if (matchPos !== void 0 && pos - matchPos <= 32768) {
-					const dist = pos - matchPos;
+				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(258, data.length - pos);
-					while (len < maxLen && data[matchPos + len] === data[pos + len]) len++;
-					if (len >= 3) {
+					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];
 				}
-				hashTable.set(hash, pos);
+				prev[pos & MAX_DIST - 1] = head[h];
+				head[h] = pos + 1;
 			}
-			if (bestLen >= 3) {
-				writeLengthCode(output, bestLen);
-				writeDistanceCode(output, bestDist);
-				pos += bestLen;
+			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);
 		return output.finish();
 	}
@@ -19066,7 +19122,10 @@ var ExcelTS = (function(exports) {
 	* maintains state across multiple `write()` calls:
 	*
 	*  - **LZ77 sliding window**: back-references can span across chunks.
-	*  - **Hash table**: match positions persist 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.
 	*  - **Bit writer**: bit position is preserved, so consecutive blocks form
 	*    a single valid DEFLATE bit-stream without alignment issues.
 	*
@@ -19080,10 +19139,15 @@ var ExcelTS = (function(exports) {
 	var SyncDeflater = class {
 		constructor() {
 			this._output = new BitWriter();
-			this._hashTable = /* @__PURE__ */ new Map();
+			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;
 		}
 		/**
 		* Compress a chunk and return the compressed bytes produced so far.
@@ -19096,50 +19160,119 @@ var ExcelTS = (function(exports) {
 			out.writeBits(1, 2);
 			const window = this._window;
 			let wLen = this._windowLen;
-			const hashTable = this._hashTable;
+			const head = this._head;
+			const prevArr = this._prev;
 			const totalIn = this._totalIn;
-			for (let pos = 0; pos < data.length;) {
+			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 = data[pos] << 16 | data[pos + 1] << 8 | data[pos + 2];
-					const matchGlobalPos = hashTable.get(h);
-					if (matchGlobalPos !== void 0) {
-						const dist = totalIn + pos - matchGlobalPos;
-						if (dist > 0 && dist <= WINDOW_SIZE) {
-							const wStart = ((wLen - dist) % WINDOW_SIZE + WINDOW_SIZE) % WINDOW_SIZE;
-							const maxLen = Math.min(258, data.length - pos);
-							let len = 0;
-							while (len < maxLen) {
-								if (window[(wStart + len) % WINDOW_SIZE] !== data[pos + len]) break;
-								len++;
-							}
-							if (len >= 3) {
-								bestLen = len;
-								bestDist = dist;
+					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];
 					}
-					hashTable.set(h, totalIn + pos);
-				}
-				if (bestLen >= 3) {
-					writeLengthCode(out, bestLen);
-					writeDistanceCode(out, bestDist);
-					for (let i = 0; i < bestLen; i++) {
-						window[wLen % WINDOW_SIZE] = data[pos + i];
-						wLen++;
-					}
-					pos += bestLen;
+					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]);
-					window[wLen % WINDOW_SIZE] = data[pos];
-					wLen++;
+					insertWindow(pos, 1);
 					pos++;
 				}
 			}
+			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;
 			return out.flushBytes();
 		}
 		/**
@@ -22783,7 +22916,7 @@ self.onmessage = async function(event) {
 				this._uncompressedSize += data.length;
 			}
 			if (this._deflateWanted) {
-				if (!this._syncDeflater) this._syncDeflater = new SyncDeflater();
+				if (!this._syncDeflater) this._syncDeflater = new SyncDeflater(this.level);
 				if (data.length > 0) {
 					const compressed = this._syncDeflater.write(data);
 					if (compressed.length > 0) {