hwp2md 1.0.0

package/dist/converter-D6LrZNSL.mjs

@@ -0,0 +1,4804 @@
+import * as CFB from "cfb";
+import { unzipSync } from "fflate";
+import { XMLParser } from "fast-xml-parser";
+
+//#region ../../node_modules/.pnpm/pako@2.1.0/node_modules/pako/dist/pako.esm.mjs
+/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+const Z_FIXED$1 = 4;
+const Z_BINARY = 0;
+const Z_TEXT = 1;
+const Z_UNKNOWN$1 = 2;
+function zero$1(buf) {
+	let len = buf.length;
+	while (--len >= 0) buf[len] = 0;
+}
+const STORED_BLOCK = 0;
+const STATIC_TREES = 1;
+const DYN_TREES = 2;
+const MIN_MATCH$1 = 3;
+const MAX_MATCH$1 = 258;
+const LENGTH_CODES$1 = 29;
+const LITERALS$1 = 256;
+const L_CODES$1 = LITERALS$1 + 1 + LENGTH_CODES$1;
+const D_CODES$1 = 30;
+const BL_CODES$1 = 19;
+const HEAP_SIZE$1 = 2 * L_CODES$1 + 1;
+const MAX_BITS$1 = 15;
+const Buf_size = 16;
+const MAX_BL_BITS = 7;
+const END_BLOCK = 256;
+const REP_3_6 = 16;
+const REPZ_3_10 = 17;
+const REPZ_11_138 = 18;
+const extra_lbits = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	0
+]);
+const extra_dbits = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	6,
+	7,
+	7,
+	8,
+	8,
+	9,
+	9,
+	10,
+	10,
+	11,
+	11,
+	12,
+	12,
+	13,
+	13
+]);
+const extra_blbits = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	2,
+	3,
+	7
+]);
+const bl_order = new Uint8Array([
+	16,
+	17,
+	18,
+	0,
+	8,
+	7,
+	9,
+	6,
+	10,
+	5,
+	11,
+	4,
+	12,
+	3,
+	13,
+	2,
+	14,
+	1,
+	15
+]);
+const DIST_CODE_LEN = 512;
+const static_ltree = new Array((L_CODES$1 + 2) * 2);
+zero$1(static_ltree);
+const static_dtree = new Array(D_CODES$1 * 2);
+zero$1(static_dtree);
+const _dist_code = new Array(DIST_CODE_LEN);
+zero$1(_dist_code);
+const _length_code = new Array(MAX_MATCH$1 - MIN_MATCH$1 + 1);
+zero$1(_length_code);
+const base_length = new Array(LENGTH_CODES$1);
+zero$1(base_length);
+const base_dist = new Array(D_CODES$1);
+zero$1(base_dist);
+function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
+	this.static_tree = static_tree;
+	this.extra_bits = extra_bits;
+	this.extra_base = extra_base;
+	this.elems = elems;
+	this.max_length = max_length;
+	this.has_stree = static_tree && static_tree.length;
+}
+let static_l_desc;
+let static_d_desc;
+let static_bl_desc;
+function TreeDesc(dyn_tree, stat_desc) {
+	this.dyn_tree = dyn_tree;
+	this.max_code = 0;
+	this.stat_desc = stat_desc;
+}
+const d_code = (dist) => {
+	return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
+};
+const put_short = (s, w) => {
+	s.pending_buf[s.pending++] = w & 255;
+	s.pending_buf[s.pending++] = w >>> 8 & 255;
+};
+const send_bits = (s, value, length) => {
+	if (s.bi_valid > Buf_size - length) {
+		s.bi_buf |= value << s.bi_valid & 65535;
+		put_short(s, s.bi_buf);
+		s.bi_buf = value >> Buf_size - s.bi_valid;
+		s.bi_valid += length - Buf_size;
+	} else {
+		s.bi_buf |= value << s.bi_valid & 65535;
+		s.bi_valid += length;
+	}
+};
+const send_code = (s, c, tree) => {
+	send_bits(s, tree[c * 2], tree[c * 2 + 1]);
+};
+const bi_reverse = (code, len) => {
+	let res = 0;
+	do {
+		res |= code & 1;
+		code >>>= 1;
+		res <<= 1;
+	} while (--len > 0);
+	return res >>> 1;
+};
+const bi_flush = (s) => {
+	if (s.bi_valid === 16) {
+		put_short(s, s.bi_buf);
+		s.bi_buf = 0;
+		s.bi_valid = 0;
+	} else if (s.bi_valid >= 8) {
+		s.pending_buf[s.pending++] = s.bi_buf & 255;
+		s.bi_buf >>= 8;
+		s.bi_valid -= 8;
+	}
+};
+const gen_bitlen = (s, desc) => {
+	const tree = desc.dyn_tree;
+	const max_code = desc.max_code;
+	const stree = desc.stat_desc.static_tree;
+	const has_stree = desc.stat_desc.has_stree;
+	const extra = desc.stat_desc.extra_bits;
+	const base = desc.stat_desc.extra_base;
+	const max_length = desc.stat_desc.max_length;
+	let h;
+	let n, m;
+	let bits;
+	let xbits;
+	let f;
+	let overflow = 0;
+	for (bits = 0; bits <= MAX_BITS$1; bits++) s.bl_count[bits] = 0;
+	tree[s.heap[s.heap_max] * 2 + 1] = 0;
+	for (h = s.heap_max + 1; h < HEAP_SIZE$1; h++) {
+		n = s.heap[h];
+		bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
+		if (bits > max_length) {
+			bits = max_length;
+			overflow++;
+		}
+		tree[n * 2 + 1] = bits;
+		if (n > max_code) continue;
+		s.bl_count[bits]++;
+		xbits = 0;
+		if (n >= base) xbits = extra[n - base];
+		f = tree[n * 2];
+		s.opt_len += f * (bits + xbits);
+		if (has_stree) s.static_len += f * (stree[n * 2 + 1] + xbits);
+	}
+	if (overflow === 0) return;
+	do {
+		bits = max_length - 1;
+		while (s.bl_count[bits] === 0) bits--;
+		s.bl_count[bits]--;
+		s.bl_count[bits + 1] += 2;
+		s.bl_count[max_length]--;
+		overflow -= 2;
+	} while (overflow > 0);
+	for (bits = max_length; bits !== 0; bits--) {
+		n = s.bl_count[bits];
+		while (n !== 0) {
+			m = s.heap[--h];
+			if (m > max_code) continue;
+			if (tree[m * 2 + 1] !== bits) {
+				s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
+				tree[m * 2 + 1] = bits;
+			}
+			n--;
+		}
+	}
+};
+const gen_codes = (tree, max_code, bl_count) => {
+	const next_code = new Array(MAX_BITS$1 + 1);
+	let code = 0;
+	let bits;
+	let n;
+	for (bits = 1; bits <= MAX_BITS$1; bits++) {
+		code = code + bl_count[bits - 1] << 1;
+		next_code[bits] = code;
+	}
+	for (n = 0; n <= max_code; n++) {
+		let len = tree[n * 2 + 1];
+		if (len === 0) continue;
+		tree[n * 2] = bi_reverse(next_code[len]++, len);
+	}
+};
+const tr_static_init = () => {
+	let n;
+	let bits;
+	let length;
+	let code;
+	let dist;
+	const bl_count = new Array(MAX_BITS$1 + 1);
+	length = 0;
+	for (code = 0; code < LENGTH_CODES$1 - 1; code++) {
+		base_length[code] = length;
+		for (n = 0; n < 1 << extra_lbits[code]; n++) _length_code[length++] = code;
+	}
+	_length_code[length - 1] = code;
+	dist = 0;
+	for (code = 0; code < 16; code++) {
+		base_dist[code] = dist;
+		for (n = 0; n < 1 << extra_dbits[code]; n++) _dist_code[dist++] = code;
+	}
+	dist >>= 7;
+	for (; code < D_CODES$1; code++) {
+		base_dist[code] = dist << 7;
+		for (n = 0; n < 1 << extra_dbits[code] - 7; n++) _dist_code[256 + dist++] = code;
+	}
+	for (bits = 0; bits <= MAX_BITS$1; bits++) bl_count[bits] = 0;
+	n = 0;
+	while (n <= 143) {
+		static_ltree[n * 2 + 1] = 8;
+		n++;
+		bl_count[8]++;
+	}
+	while (n <= 255) {
+		static_ltree[n * 2 + 1] = 9;
+		n++;
+		bl_count[9]++;
+	}
+	while (n <= 279) {
+		static_ltree[n * 2 + 1] = 7;
+		n++;
+		bl_count[7]++;
+	}
+	while (n <= 287) {
+		static_ltree[n * 2 + 1] = 8;
+		n++;
+		bl_count[8]++;
+	}
+	gen_codes(static_ltree, L_CODES$1 + 1, bl_count);
+	for (n = 0; n < D_CODES$1; n++) {
+		static_dtree[n * 2 + 1] = 5;
+		static_dtree[n * 2] = bi_reverse(n, 5);
+	}
+	static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS$1 + 1, L_CODES$1, MAX_BITS$1);
+	static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES$1, MAX_BITS$1);
+	static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES$1, MAX_BL_BITS);
+};
+const init_block = (s) => {
+	let n;
+	for (n = 0; n < L_CODES$1; n++) s.dyn_ltree[n * 2] = 0;
+	for (n = 0; n < D_CODES$1; n++) s.dyn_dtree[n * 2] = 0;
+	for (n = 0; n < BL_CODES$1; n++) s.bl_tree[n * 2] = 0;
+	s.dyn_ltree[END_BLOCK * 2] = 1;
+	s.opt_len = s.static_len = 0;
+	s.sym_next = s.matches = 0;
+};
+const bi_windup = (s) => {
+	if (s.bi_valid > 8) put_short(s, s.bi_buf);
+	else if (s.bi_valid > 0) s.pending_buf[s.pending++] = s.bi_buf;
+	s.bi_buf = 0;
+	s.bi_valid = 0;
+};
+const smaller = (tree, n, m, depth) => {
+	const _n2 = n * 2;
+	const _m2 = m * 2;
+	return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n] <= depth[m];
+};
+const pqdownheap = (s, tree, k) => {
+	const v = s.heap[k];
+	let j = k << 1;
+	while (j <= s.heap_len) {
+		if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) j++;
+		if (smaller(tree, v, s.heap[j], s.depth)) break;
+		s.heap[k] = s.heap[j];
+		k = j;
+		j <<= 1;
+	}
+	s.heap[k] = v;
+};
+const compress_block = (s, ltree, dtree) => {
+	let dist;
+	let lc;
+	let sx = 0;
+	let code;
+	let extra;
+	if (s.sym_next !== 0) do {
+		dist = s.pending_buf[s.sym_buf + sx++] & 255;
+		dist += (s.pending_buf[s.sym_buf + sx++] & 255) << 8;
+		lc = s.pending_buf[s.sym_buf + sx++];
+		if (dist === 0) send_code(s, lc, ltree);
+		else {
+			code = _length_code[lc];
+			send_code(s, code + LITERALS$1 + 1, ltree);
+			extra = extra_lbits[code];
+			if (extra !== 0) {
+				lc -= base_length[code];
+				send_bits(s, lc, extra);
+			}
+			dist--;
+			code = d_code(dist);
+			send_code(s, code, dtree);
+			extra = extra_dbits[code];
+			if (extra !== 0) {
+				dist -= base_dist[code];
+				send_bits(s, dist, extra);
+			}
+		}
+	} while (sx < s.sym_next);
+	send_code(s, END_BLOCK, ltree);
+};
+const build_tree = (s, desc) => {
+	const tree = desc.dyn_tree;
+	const stree = desc.stat_desc.static_tree;
+	const has_stree = desc.stat_desc.has_stree;
+	const elems = desc.stat_desc.elems;
+	let n, m;
+	let max_code = -1;
+	let node;
+	s.heap_len = 0;
+	s.heap_max = HEAP_SIZE$1;
+	for (n = 0; n < elems; n++) if (tree[n * 2] !== 0) {
+		s.heap[++s.heap_len] = max_code = n;
+		s.depth[n] = 0;
+	} else tree[n * 2 + 1] = 0;
+	while (s.heap_len < 2) {
+		node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
+		tree[node * 2] = 1;
+		s.depth[node] = 0;
+		s.opt_len--;
+		if (has_stree) s.static_len -= stree[node * 2 + 1];
+	}
+	desc.max_code = max_code;
+	for (n = s.heap_len >> 1; n >= 1; n--) pqdownheap(s, tree, n);
+	node = elems;
+	do {
+		/*** pqremove ***/
+		n = s.heap[1];
+		s.heap[1] = s.heap[s.heap_len--];
+		pqdownheap(s, tree, 1);
+		m = s.heap[1];
+		s.heap[--s.heap_max] = n;
+		s.heap[--s.heap_max] = m;
+		tree[node * 2] = tree[n * 2] + tree[m * 2];
+		s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
+		tree[n * 2 + 1] = tree[m * 2 + 1] = node;
+		s.heap[1] = node++;
+		pqdownheap(s, tree, 1);
+	} while (s.heap_len >= 2);
+	s.heap[--s.heap_max] = s.heap[1];
+	gen_bitlen(s, desc);
+	gen_codes(tree, max_code, s.bl_count);
+};
+const scan_tree = (s, tree, max_code) => {
+	let n;
+	let prevlen = -1;
+	let curlen;
+	let nextlen = tree[1];
+	let count = 0;
+	let max_count = 7;
+	let min_count = 4;
+	if (nextlen === 0) {
+		max_count = 138;
+		min_count = 3;
+	}
+	tree[(max_code + 1) * 2 + 1] = 65535;
+	for (n = 0; n <= max_code; n++) {
+		curlen = nextlen;
+		nextlen = tree[(n + 1) * 2 + 1];
+		if (++count < max_count && curlen === nextlen) continue;
+		else if (count < min_count) s.bl_tree[curlen * 2] += count;
+		else if (curlen !== 0) {
+			if (curlen !== prevlen) s.bl_tree[curlen * 2]++;
+			s.bl_tree[REP_3_6 * 2]++;
+		} else if (count <= 10) s.bl_tree[REPZ_3_10 * 2]++;
+		else s.bl_tree[REPZ_11_138 * 2]++;
+		count = 0;
+		prevlen = curlen;
+		if (nextlen === 0) {
+			max_count = 138;
+			min_count = 3;
+		} else if (curlen === nextlen) {
+			max_count = 6;
+			min_count = 3;
+		} else {
+			max_count = 7;
+			min_count = 4;
+		}
+	}
+};
+const send_tree = (s, tree, max_code) => {
+	let n;
+	let prevlen = -1;
+	let curlen;
+	let nextlen = tree[1];
+	let count = 0;
+	let max_count = 7;
+	let min_count = 4;
+	if (nextlen === 0) {
+		max_count = 138;
+		min_count = 3;
+	}
+	for (n = 0; n <= max_code; n++) {
+		curlen = nextlen;
+		nextlen = tree[(n + 1) * 2 + 1];
+		if (++count < max_count && curlen === nextlen) continue;
+		else if (count < min_count) do
+			send_code(s, curlen, s.bl_tree);
+		while (--count !== 0);
+		else if (curlen !== 0) {
+			if (curlen !== prevlen) {
+				send_code(s, curlen, s.bl_tree);
+				count--;
+			}
+			send_code(s, REP_3_6, s.bl_tree);
+			send_bits(s, count - 3, 2);
+		} else if (count <= 10) {
+			send_code(s, REPZ_3_10, s.bl_tree);
+			send_bits(s, count - 3, 3);
+		} else {
+			send_code(s, REPZ_11_138, s.bl_tree);
+			send_bits(s, count - 11, 7);
+		}
+		count = 0;
+		prevlen = curlen;
+		if (nextlen === 0) {
+			max_count = 138;
+			min_count = 3;
+		} else if (curlen === nextlen) {
+			max_count = 6;
+			min_count = 3;
+		} else {
+			max_count = 7;
+			min_count = 4;
+		}
+	}
+};
+const build_bl_tree = (s) => {
+	let max_blindex;
+	scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
+	scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
+	build_tree(s, s.bl_desc);
+	for (max_blindex = BL_CODES$1 - 1; max_blindex >= 3; max_blindex--) if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) break;
+	s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
+	return max_blindex;
+};
+const send_all_trees = (s, lcodes, dcodes, blcodes) => {
+	let rank$1;
+	send_bits(s, lcodes - 257, 5);
+	send_bits(s, dcodes - 1, 5);
+	send_bits(s, blcodes - 4, 4);
+	for (rank$1 = 0; rank$1 < blcodes; rank$1++) send_bits(s, s.bl_tree[bl_order[rank$1] * 2 + 1], 3);
+	send_tree(s, s.dyn_ltree, lcodes - 1);
+	send_tree(s, s.dyn_dtree, dcodes - 1);
+};
+const detect_data_type = (s) => {
+	let block_mask = 4093624447;
+	let n;
+	for (n = 0; n <= 31; n++, block_mask >>>= 1) if (block_mask & 1 && s.dyn_ltree[n * 2] !== 0) return Z_BINARY;
+	if (s.dyn_ltree[18] !== 0 || s.dyn_ltree[20] !== 0 || s.dyn_ltree[26] !== 0) return Z_TEXT;
+	for (n = 32; n < LITERALS$1; n++) if (s.dyn_ltree[n * 2] !== 0) return Z_TEXT;
+	return Z_BINARY;
+};
+let static_init_done = false;
+const _tr_init$1 = (s) => {
+	if (!static_init_done) {
+		tr_static_init();
+		static_init_done = true;
+	}
+	s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
+	s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
+	s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
+	s.bi_buf = 0;
+	s.bi_valid = 0;
+	init_block(s);
+};
+const _tr_stored_block$1 = (s, buf, stored_len, last) => {
+	send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);
+	bi_windup(s);
+	put_short(s, stored_len);
+	put_short(s, ~stored_len);
+	if (stored_len) s.pending_buf.set(s.window.subarray(buf, buf + stored_len), s.pending);
+	s.pending += stored_len;
+};
+const _tr_align$1 = (s) => {
+	send_bits(s, STATIC_TREES << 1, 3);
+	send_code(s, END_BLOCK, static_ltree);
+	bi_flush(s);
+};
+const _tr_flush_block$1 = (s, buf, stored_len, last) => {
+	let opt_lenb, static_lenb;
+	let max_blindex = 0;
+	if (s.level > 0) {
+		if (s.strm.data_type === Z_UNKNOWN$1) s.strm.data_type = detect_data_type(s);
+		build_tree(s, s.l_desc);
+		build_tree(s, s.d_desc);
+		max_blindex = build_bl_tree(s);
+		opt_lenb = s.opt_len + 3 + 7 >>> 3;
+		static_lenb = s.static_len + 3 + 7 >>> 3;
+		if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+	} else opt_lenb = static_lenb = stored_len + 5;
+	if (stored_len + 4 <= opt_lenb && buf !== -1) _tr_stored_block$1(s, buf, stored_len, last);
+	else if (s.strategy === Z_FIXED$1 || static_lenb === opt_lenb) {
+		send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
+		compress_block(s, static_ltree, static_dtree);
+	} else {
+		send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
+		send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
+		compress_block(s, s.dyn_ltree, s.dyn_dtree);
+	}
+	init_block(s);
+	if (last) bi_windup(s);
+};
+const _tr_tally$1 = (s, dist, lc) => {
+	s.pending_buf[s.sym_buf + s.sym_next++] = dist;
+	s.pending_buf[s.sym_buf + s.sym_next++] = dist >> 8;
+	s.pending_buf[s.sym_buf + s.sym_next++] = lc;
+	if (dist === 0) s.dyn_ltree[lc * 2]++;
+	else {
+		s.matches++;
+		dist--;
+		s.dyn_ltree[(_length_code[lc] + LITERALS$1 + 1) * 2]++;
+		s.dyn_dtree[d_code(dist) * 2]++;
+	}
+	return s.sym_next === s.sym_end;
+};
+var trees = {
+	_tr_init: _tr_init$1,
+	_tr_stored_block: _tr_stored_block$1,
+	_tr_flush_block: _tr_flush_block$1,
+	_tr_tally: _tr_tally$1,
+	_tr_align: _tr_align$1
+};
+const adler32 = (adler, buf, len, pos) => {
+	let s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0;
+	while (len !== 0) {
+		n = len > 2e3 ? 2e3 : len;
+		len -= n;
+		do {
+			s1 = s1 + buf[pos++] | 0;
+			s2 = s2 + s1 | 0;
+		} while (--n);
+		s1 %= 65521;
+		s2 %= 65521;
+	}
+	return s1 | s2 << 16 | 0;
+};
+var adler32_1 = adler32;
+const makeTable = () => {
+	let c, table = [];
+	for (var n = 0; n < 256; n++) {
+		c = n;
+		for (var k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+		table[n] = c;
+	}
+	return table;
+};
+const crcTable = new Uint32Array(makeTable());
+const crc32 = (crc, buf, len, pos) => {
+	const t = crcTable;
+	const end = pos + len;
+	crc ^= -1;
+	for (let i = pos; i < end; i++) crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255];
+	return crc ^ -1;
+};
+var crc32_1 = crc32;
+var messages = {
+	2: "need dictionary",
+	1: "stream end",
+	0: "",
+	"-1": "file error",
+	"-2": "stream error",
+	"-3": "data error",
+	"-4": "insufficient memory",
+	"-5": "buffer error",
+	"-6": "incompatible version"
+};
+var constants$2 = {
+	Z_NO_FLUSH: 0,
+	Z_PARTIAL_FLUSH: 1,
+	Z_SYNC_FLUSH: 2,
+	Z_FULL_FLUSH: 3,
+	Z_FINISH: 4,
+	Z_BLOCK: 5,
+	Z_TREES: 6,
+	Z_OK: 0,
+	Z_STREAM_END: 1,
+	Z_NEED_DICT: 2,
+	Z_ERRNO: -1,
+	Z_STREAM_ERROR: -2,
+	Z_DATA_ERROR: -3,
+	Z_MEM_ERROR: -4,
+	Z_BUF_ERROR: -5,
+	Z_NO_COMPRESSION: 0,
+	Z_BEST_SPEED: 1,
+	Z_BEST_COMPRESSION: 9,
+	Z_DEFAULT_COMPRESSION: -1,
+	Z_FILTERED: 1,
+	Z_HUFFMAN_ONLY: 2,
+	Z_RLE: 3,
+	Z_FIXED: 4,
+	Z_DEFAULT_STRATEGY: 0,
+	Z_BINARY: 0,
+	Z_TEXT: 1,
+	Z_UNKNOWN: 2,
+	Z_DEFLATED: 8
+};
+const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = trees;
+const { Z_NO_FLUSH: Z_NO_FLUSH$2, Z_PARTIAL_FLUSH, Z_FULL_FLUSH: Z_FULL_FLUSH$1, Z_FINISH: Z_FINISH$3, Z_BLOCK: Z_BLOCK$1, Z_OK: Z_OK$3, Z_STREAM_END: Z_STREAM_END$3, Z_STREAM_ERROR: Z_STREAM_ERROR$2, Z_DATA_ERROR: Z_DATA_ERROR$2, Z_BUF_ERROR: Z_BUF_ERROR$1, Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION$1, Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED, Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY$1, Z_UNKNOWN, Z_DEFLATED: Z_DEFLATED$2 } = constants$2;
+const MAX_MEM_LEVEL = 9;
+const MAX_WBITS$1 = 15;
+const DEF_MEM_LEVEL = 8;
+const L_CODES = 286;
+const D_CODES = 30;
+const BL_CODES = 19;
+const HEAP_SIZE = 2 * L_CODES + 1;
+const MAX_BITS = 15;
+const MIN_MATCH = 3;
+const MAX_MATCH = 258;
+const MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;
+const PRESET_DICT = 32;
+const INIT_STATE = 42;
+const GZIP_STATE = 57;
+const EXTRA_STATE = 69;
+const NAME_STATE = 73;
+const COMMENT_STATE = 91;
+const HCRC_STATE = 103;
+const BUSY_STATE = 113;
+const FINISH_STATE = 666;
+const BS_NEED_MORE = 1;
+const BS_BLOCK_DONE = 2;
+const BS_FINISH_STARTED = 3;
+const BS_FINISH_DONE = 4;
+const OS_CODE = 3;
+const err = (strm, errorCode) => {
+	strm.msg = messages[errorCode];
+	return errorCode;
+};
+const rank = (f) => {
+	return f * 2 - (f > 4 ? 9 : 0);
+};
+const zero = (buf) => {
+	let len = buf.length;
+	while (--len >= 0) buf[len] = 0;
+};
+const slide_hash = (s) => {
+	let n, m;
+	let p;
+	let wsize = s.w_size;
+	n = s.hash_size;
+	p = n;
+	do {
+		m = s.head[--p];
+		s.head[p] = m >= wsize ? m - wsize : 0;
+	} while (--n);
+	n = wsize;
+	p = n;
+	do {
+		m = s.prev[--p];
+		s.prev[p] = m >= wsize ? m - wsize : 0;
+	} while (--n);
+};
+let HASH_ZLIB = (s, prev, data) => (prev << s.hash_shift ^ data) & s.hash_mask;
+let HASH = HASH_ZLIB;
+const flush_pending = (strm) => {
+	const s = strm.state;
+	let len = s.pending;
+	if (len > strm.avail_out) len = strm.avail_out;
+	if (len === 0) return;
+	strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);
+	strm.next_out += len;
+	s.pending_out += len;
+	strm.total_out += len;
+	strm.avail_out -= len;
+	s.pending -= len;
+	if (s.pending === 0) s.pending_out = 0;
+};
+const flush_block_only = (s, last) => {
+	_tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);
+	s.block_start = s.strstart;
+	flush_pending(s.strm);
+};
+const put_byte = (s, b) => {
+	s.pending_buf[s.pending++] = b;
+};
+const putShortMSB = (s, b) => {
+	s.pending_buf[s.pending++] = b >>> 8 & 255;
+	s.pending_buf[s.pending++] = b & 255;
+};
+const read_buf = (strm, buf, start, size) => {
+	let len = strm.avail_in;
+	if (len > size) len = size;
+	if (len === 0) return 0;
+	strm.avail_in -= len;
+	buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);
+	if (strm.state.wrap === 1) strm.adler = adler32_1(strm.adler, buf, len, start);
+	else if (strm.state.wrap === 2) strm.adler = crc32_1(strm.adler, buf, len, start);
+	strm.next_in += len;
+	strm.total_in += len;
+	return len;
+};
+const longest_match = (s, cur_match) => {
+	let chain_length = s.max_chain_length;
+	let scan = s.strstart;
+	let match;
+	let len;
+	let best_len = s.prev_length;
+	let nice_match = s.nice_match;
+	const limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;
+	const _win = s.window;
+	const wmask = s.w_mask;
+	const prev = s.prev;
+	const strend = s.strstart + MAX_MATCH;
+	let scan_end1 = _win[scan + best_len - 1];
+	let scan_end = _win[scan + best_len];
+	if (s.prev_length >= s.good_match) chain_length >>= 2;
+	if (nice_match > s.lookahead) nice_match = s.lookahead;
+	do {
+		match = cur_match;
+		if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) continue;
+		scan += 2;
+		match++;
+		do		;
+while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend);
+		len = MAX_MATCH - (strend - scan);
+		scan = strend - MAX_MATCH;
+		if (len > best_len) {
+			s.match_start = cur_match;
+			best_len = len;
+			if (len >= nice_match) break;
+			scan_end1 = _win[scan + best_len - 1];
+			scan_end = _win[scan + best_len];
+		}
+	} while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);
+	if (best_len <= s.lookahead) return best_len;
+	return s.lookahead;
+};
+const fill_window = (s) => {
+	const _w_size = s.w_size;
+	let n, more, str;
+	do {
+		more = s.window_size - s.lookahead - s.strstart;
+		if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
+			s.window.set(s.window.subarray(_w_size, _w_size + _w_size - more), 0);
+			s.match_start -= _w_size;
+			s.strstart -= _w_size;
+			s.block_start -= _w_size;
+			if (s.insert > s.strstart) s.insert = s.strstart;
+			slide_hash(s);
+			more += _w_size;
+		}
+		if (s.strm.avail_in === 0) break;
+		n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
+		s.lookahead += n;
+		if (s.lookahead + s.insert >= MIN_MATCH) {
+			str = s.strstart - s.insert;
+			s.ins_h = s.window[str];
+			s.ins_h = HASH(s, s.ins_h, s.window[str + 1]);
+			while (s.insert) {
+				s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
+				s.prev[str & s.w_mask] = s.head[s.ins_h];
+				s.head[s.ins_h] = str;
+				str++;
+				s.insert--;
+				if (s.lookahead + s.insert < MIN_MATCH) break;
+			}
+		}
+	} while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
+};
+const deflate_stored = (s, flush) => {
+	let min_block = s.pending_buf_size - 5 > s.w_size ? s.w_size : s.pending_buf_size - 5;
+	let len, left, have, last = 0;
+	let used = s.strm.avail_in;
+	do {
+		len = 65535;
+		have = s.bi_valid + 42 >> 3;
+		if (s.strm.avail_out < have) break;
+		have = s.strm.avail_out - have;
+		left = s.strstart - s.block_start;
+		if (len > left + s.strm.avail_in) len = left + s.strm.avail_in;
+		if (len > have) len = have;
+		if (len < min_block && (len === 0 && flush !== Z_FINISH$3 || flush === Z_NO_FLUSH$2 || len !== left + s.strm.avail_in)) break;
+		last = flush === Z_FINISH$3 && len === left + s.strm.avail_in ? 1 : 0;
+		_tr_stored_block(s, 0, 0, last);
+		s.pending_buf[s.pending - 4] = len;
+		s.pending_buf[s.pending - 3] = len >> 8;
+		s.pending_buf[s.pending - 2] = ~len;
+		s.pending_buf[s.pending - 1] = ~len >> 8;
+		flush_pending(s.strm);
+		if (left) {
+			if (left > len) left = len;
+			s.strm.output.set(s.window.subarray(s.block_start, s.block_start + left), s.strm.next_out);
+			s.strm.next_out += left;
+			s.strm.avail_out -= left;
+			s.strm.total_out += left;
+			s.block_start += left;
+			len -= left;
+		}
+		if (len) {
+			read_buf(s.strm, s.strm.output, s.strm.next_out, len);
+			s.strm.next_out += len;
+			s.strm.avail_out -= len;
+			s.strm.total_out += len;
+		}
+	} while (last === 0);
+	used -= s.strm.avail_in;
+	if (used) {
+		if (used >= s.w_size) {
+			s.matches = 2;
+			s.window.set(s.strm.input.subarray(s.strm.next_in - s.w_size, s.strm.next_in), 0);
+			s.strstart = s.w_size;
+			s.insert = s.strstart;
+		} else {
+			if (s.window_size - s.strstart <= used) {
+				s.strstart -= s.w_size;
+				s.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0);
+				if (s.matches < 2) s.matches++;
+				if (s.insert > s.strstart) s.insert = s.strstart;
+			}
+			s.window.set(s.strm.input.subarray(s.strm.next_in - used, s.strm.next_in), s.strstart);
+			s.strstart += used;
+			s.insert += used > s.w_size - s.insert ? s.w_size - s.insert : used;
+		}
+		s.block_start = s.strstart;
+	}
+	if (s.high_water < s.strstart) s.high_water = s.strstart;
+	if (last) return BS_FINISH_DONE;
+	if (flush !== Z_NO_FLUSH$2 && flush !== Z_FINISH$3 && s.strm.avail_in === 0 && s.strstart === s.block_start) return BS_BLOCK_DONE;
+	have = s.window_size - s.strstart;
+	if (s.strm.avail_in > have && s.block_start >= s.w_size) {
+		s.block_start -= s.w_size;
+		s.strstart -= s.w_size;
+		s.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0);
+		if (s.matches < 2) s.matches++;
+		have += s.w_size;
+		if (s.insert > s.strstart) s.insert = s.strstart;
+	}
+	if (have > s.strm.avail_in) have = s.strm.avail_in;
+	if (have) {
+		read_buf(s.strm, s.window, s.strstart, have);
+		s.strstart += have;
+		s.insert += have > s.w_size - s.insert ? s.w_size - s.insert : have;
+	}
+	if (s.high_water < s.strstart) s.high_water = s.strstart;
+	have = s.bi_valid + 42 >> 3;
+	have = s.pending_buf_size - have > 65535 ? 65535 : s.pending_buf_size - have;
+	min_block = have > s.w_size ? s.w_size : have;
+	left = s.strstart - s.block_start;
+	if (left >= min_block || (left || flush === Z_FINISH$3) && flush !== Z_NO_FLUSH$2 && s.strm.avail_in === 0 && left <= have) {
+		len = left > have ? have : left;
+		last = flush === Z_FINISH$3 && s.strm.avail_in === 0 && len === left ? 1 : 0;
+		_tr_stored_block(s, s.block_start, len, last);
+		s.block_start += len;
+		flush_pending(s.strm);
+	}
+	return last ? BS_FINISH_STARTED : BS_NEED_MORE;
+};
+const deflate_fast = (s, flush) => {
+	let hash_head;
+	let bflush;
+	for (;;) {
+		if (s.lookahead < MIN_LOOKAHEAD) {
+			fill_window(s);
+			if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH$2) return BS_NEED_MORE;
+			if (s.lookahead === 0) break;
+		}
+		hash_head = 0;
+		if (s.lookahead >= MIN_MATCH) {
+			/*** INSERT_STRING(s, s.strstart, hash_head); ***/
+			s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
+			hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
+			s.head[s.ins_h] = s.strstart;
+		}
+		if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) s.match_length = longest_match(s, hash_head);
+		if (s.match_length >= MIN_MATCH) {
+			/*** _tr_tally_dist(s, s.strstart - s.match_start,
+			s.match_length - MIN_MATCH, bflush); ***/
+			bflush = _tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
+			s.lookahead -= s.match_length;
+			if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) {
+				s.match_length--;
+				do {
+					s.strstart++;
+					/*** INSERT_STRING(s, s.strstart, hash_head); ***/
+					s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
+					hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
+					s.head[s.ins_h] = s.strstart;
+				} while (--s.match_length !== 0);
+				s.strstart++;
+			} else {
+				s.strstart += s.match_length;
+				s.match_length = 0;
+				s.ins_h = s.window[s.strstart];
+				s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]);
+			}
+		} else {
+			/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
+			bflush = _tr_tally(s, 0, s.window[s.strstart]);
+			s.lookahead--;
+			s.strstart++;
+		}
+		if (bflush) {
+			/*** FLUSH_BLOCK(s, 0); ***/
+			flush_block_only(s, false);
+			if (s.strm.avail_out === 0) return BS_NEED_MORE;
+		}
+	}
+	s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
+	if (flush === Z_FINISH$3) {
+		/*** FLUSH_BLOCK(s, 1); ***/
+		flush_block_only(s, true);
+		if (s.strm.avail_out === 0) return BS_FINISH_STARTED;
+		return BS_FINISH_DONE;
+	}
+	if (s.sym_next) {
+		/*** FLUSH_BLOCK(s, 0); ***/
+		flush_block_only(s, false);
+		if (s.strm.avail_out === 0) return BS_NEED_MORE;
+	}
+	return BS_BLOCK_DONE;
+};
+const deflate_slow = (s, flush) => {
+	let hash_head;
+	let bflush;
+	let max_insert;
+	for (;;) {
+		if (s.lookahead < MIN_LOOKAHEAD) {
+			fill_window(s);
+			if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH$2) return BS_NEED_MORE;
+			if (s.lookahead === 0) break;
+		}
+		hash_head = 0;
+		if (s.lookahead >= MIN_MATCH) {
+			/*** INSERT_STRING(s, s.strstart, hash_head); ***/
+			s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
+			hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
+			s.head[s.ins_h] = s.strstart;
+		}
+		s.prev_length = s.match_length;
+		s.prev_match = s.match_start;
+		s.match_length = MIN_MATCH - 1;
+		if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {
+			s.match_length = longest_match(s, hash_head);
+			if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096)) s.match_length = MIN_MATCH - 1;
+		}
+		if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
+			max_insert = s.strstart + s.lookahead - MIN_MATCH;
+			/***_tr_tally_dist(s, s.strstart - 1 - s.prev_match,
+			s.prev_length - MIN_MATCH, bflush);***/
+			bflush = _tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
+			s.lookahead -= s.prev_length - 1;
+			s.prev_length -= 2;
+			do
+				if (++s.strstart <= max_insert) {
+					/*** INSERT_STRING(s, s.strstart, hash_head); ***/
+					s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
+					hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
+					s.head[s.ins_h] = s.strstart;
+				}
+			while (--s.prev_length !== 0);
+			s.match_available = 0;
+			s.match_length = MIN_MATCH - 1;
+			s.strstart++;
+			if (bflush) {
+				/*** FLUSH_BLOCK(s, 0); ***/
+				flush_block_only(s, false);
+				if (s.strm.avail_out === 0) return BS_NEED_MORE;
+			}
+		} else if (s.match_available) {
+			/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
+			bflush = _tr_tally(s, 0, s.window[s.strstart - 1]);
+			if (bflush)
+ /*** FLUSH_BLOCK_ONLY(s, 0) ***/
+			flush_block_only(s, false);
+			s.strstart++;
+			s.lookahead--;
+			if (s.strm.avail_out === 0) return BS_NEED_MORE;
+		} else {
+			s.match_available = 1;
+			s.strstart++;
+			s.lookahead--;
+		}
+	}
+	if (s.match_available) {
+		/*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/
+		bflush = _tr_tally(s, 0, s.window[s.strstart - 1]);
+		s.match_available = 0;
+	}
+	s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
+	if (flush === Z_FINISH$3) {
+		/*** FLUSH_BLOCK(s, 1); ***/
+		flush_block_only(s, true);
+		if (s.strm.avail_out === 0) return BS_FINISH_STARTED;
+		return BS_FINISH_DONE;
+	}
+	if (s.sym_next) {
+		/*** FLUSH_BLOCK(s, 0); ***/
+		flush_block_only(s, false);
+		if (s.strm.avail_out === 0) return BS_NEED_MORE;
+	}
+	return BS_BLOCK_DONE;
+};
+const deflate_rle = (s, flush) => {
+	let bflush;
+	let prev;
+	let scan, strend;
+	const _win = s.window;
+	for (;;) {
+		if (s.lookahead <= MAX_MATCH) {
+			fill_window(s);
+			if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH$2) return BS_NEED_MORE;
+			if (s.lookahead === 0) break;
+		}
+		s.match_length = 0;
+		if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
+			scan = s.strstart - 1;
+			prev = _win[scan];
+			if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
+				strend = s.strstart + MAX_MATCH;
+				do				;
+while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend);
+				s.match_length = MAX_MATCH - (strend - scan);
+				if (s.match_length > s.lookahead) s.match_length = s.lookahead;
+			}
+		}
+		if (s.match_length >= MIN_MATCH) {
+			/*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/
+			bflush = _tr_tally(s, 1, s.match_length - MIN_MATCH);
+			s.lookahead -= s.match_length;
+			s.strstart += s.match_length;
+			s.match_length = 0;
+		} else {
+			/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
+			bflush = _tr_tally(s, 0, s.window[s.strstart]);
+			s.lookahead--;
+			s.strstart++;
+		}
+		if (bflush) {
+			/*** FLUSH_BLOCK(s, 0); ***/
+			flush_block_only(s, false);
+			if (s.strm.avail_out === 0) return BS_NEED_MORE;
+		}
+	}
+	s.insert = 0;
+	if (flush === Z_FINISH$3) {
+		/*** FLUSH_BLOCK(s, 1); ***/
+		flush_block_only(s, true);
+		if (s.strm.avail_out === 0) return BS_FINISH_STARTED;
+		return BS_FINISH_DONE;
+	}
+	if (s.sym_next) {
+		/*** FLUSH_BLOCK(s, 0); ***/
+		flush_block_only(s, false);
+		if (s.strm.avail_out === 0) return BS_NEED_MORE;
+	}
+	return BS_BLOCK_DONE;
+};
+const deflate_huff = (s, flush) => {
+	let bflush;
+	for (;;) {
+		if (s.lookahead === 0) {
+			fill_window(s);
+			if (s.lookahead === 0) {
+				if (flush === Z_NO_FLUSH$2) return BS_NEED_MORE;
+				break;
+			}
+		}
+		s.match_length = 0;
+		/*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/
+		bflush = _tr_tally(s, 0, s.window[s.strstart]);
+		s.lookahead--;
+		s.strstart++;
+		if (bflush) {
+			/*** FLUSH_BLOCK(s, 0); ***/
+			flush_block_only(s, false);
+			if (s.strm.avail_out === 0) return BS_NEED_MORE;
+		}
+	}
+	s.insert = 0;
+	if (flush === Z_FINISH$3) {
+		/*** FLUSH_BLOCK(s, 1); ***/
+		flush_block_only(s, true);
+		if (s.strm.avail_out === 0) return BS_FINISH_STARTED;
+		return BS_FINISH_DONE;
+	}
+	if (s.sym_next) {
+		/*** FLUSH_BLOCK(s, 0); ***/
+		flush_block_only(s, false);
+		if (s.strm.avail_out === 0) return BS_NEED_MORE;
+	}
+	return BS_BLOCK_DONE;
+};
+function Config(good_length, max_lazy, nice_length, max_chain, func) {
+	this.good_length = good_length;
+	this.max_lazy = max_lazy;
+	this.nice_length = nice_length;
+	this.max_chain = max_chain;
+	this.func = func;
+}
+const configuration_table = [
+	new Config(0, 0, 0, 0, deflate_stored),
+	new Config(4, 4, 8, 4, deflate_fast),
+	new Config(4, 5, 16, 8, deflate_fast),
+	new Config(4, 6, 32, 32, deflate_fast),
+	new Config(4, 4, 16, 16, deflate_slow),
+	new Config(8, 16, 32, 32, deflate_slow),
+	new Config(8, 16, 128, 128, deflate_slow),
+	new Config(8, 32, 128, 256, deflate_slow),
+	new Config(32, 128, 258, 1024, deflate_slow),
+	new Config(32, 258, 258, 4096, deflate_slow)
+];
+const lm_init = (s) => {
+	s.window_size = 2 * s.w_size;
+	/*** CLEAR_HASH(s); ***/
+	zero(s.head);
+	s.max_lazy_match = configuration_table[s.level].max_lazy;
+	s.good_match = configuration_table[s.level].good_length;
+	s.nice_match = configuration_table[s.level].nice_length;
+	s.max_chain_length = configuration_table[s.level].max_chain;
+	s.strstart = 0;
+	s.block_start = 0;
+	s.lookahead = 0;
+	s.insert = 0;
+	s.match_length = s.prev_length = MIN_MATCH - 1;
+	s.match_available = 0;
+	s.ins_h = 0;
+};
+function DeflateState() {
+	this.strm = null;
+	this.status = 0;
+	this.pending_buf = null;
+	this.pending_buf_size = 0;
+	this.pending_out = 0;
+	this.pending = 0;
+	this.wrap = 0;
+	this.gzhead = null;
+	this.gzindex = 0;
+	this.method = Z_DEFLATED$2;
+	this.last_flush = -1;
+	this.w_size = 0;
+	this.w_bits = 0;
+	this.w_mask = 0;
+	this.window = null;
+	this.window_size = 0;
+	this.prev = null;
+	this.head = null;
+	this.ins_h = 0;
+	this.hash_size = 0;
+	this.hash_bits = 0;
+	this.hash_mask = 0;
+	this.hash_shift = 0;
+	this.block_start = 0;
+	this.match_length = 0;
+	this.prev_match = 0;
+	this.match_available = 0;
+	this.strstart = 0;
+	this.match_start = 0;
+	this.lookahead = 0;
+	this.prev_length = 0;
+	this.max_chain_length = 0;
+	this.max_lazy_match = 0;
+	this.level = 0;
+	this.strategy = 0;
+	this.good_match = 0;
+	this.nice_match = 0;
+	this.dyn_ltree = new Uint16Array(HEAP_SIZE * 2);
+	this.dyn_dtree = new Uint16Array((2 * D_CODES + 1) * 2);
+	this.bl_tree = new Uint16Array((2 * BL_CODES + 1) * 2);
+	zero(this.dyn_ltree);
+	zero(this.dyn_dtree);
+	zero(this.bl_tree);
+	this.l_desc = null;
+	this.d_desc = null;
+	this.bl_desc = null;
+	this.bl_count = new Uint16Array(MAX_BITS + 1);
+	this.heap = new Uint16Array(2 * L_CODES + 1);
+	zero(this.heap);
+	this.heap_len = 0;
+	this.heap_max = 0;
+	this.depth = new Uint16Array(2 * L_CODES + 1);
+	zero(this.depth);
+	this.sym_buf = 0;
+	this.lit_bufsize = 0;
+	this.sym_next = 0;
+	this.sym_end = 0;
+	this.opt_len = 0;
+	this.static_len = 0;
+	this.matches = 0;
+	this.insert = 0;
+	this.bi_buf = 0;
+	this.bi_valid = 0;
+}
+const deflateStateCheck = (strm) => {
+	if (!strm) return 1;
+	const s = strm.state;
+	if (!s || s.strm !== strm || s.status !== INIT_STATE && s.status !== GZIP_STATE && s.status !== EXTRA_STATE && s.status !== NAME_STATE && s.status !== COMMENT_STATE && s.status !== HCRC_STATE && s.status !== BUSY_STATE && s.status !== FINISH_STATE) return 1;
+	return 0;
+};
+const deflateResetKeep = (strm) => {
+	if (deflateStateCheck(strm)) return err(strm, Z_STREAM_ERROR$2);
+	strm.total_in = strm.total_out = 0;
+	strm.data_type = Z_UNKNOWN;
+	const s = strm.state;
+	s.pending = 0;
+	s.pending_out = 0;
+	if (s.wrap < 0) s.wrap = -s.wrap;
+	s.status = s.wrap === 2 ? GZIP_STATE : s.wrap ? INIT_STATE : BUSY_STATE;
+	strm.adler = s.wrap === 2 ? 0 : 1;
+	s.last_flush = -2;
+	_tr_init(s);
+	return Z_OK$3;
+};
+const deflateReset = (strm) => {
+	const ret = deflateResetKeep(strm);
+	if (ret === Z_OK$3) lm_init(strm.state);
+	return ret;
+};
+const deflateSetHeader = (strm, head) => {
+	if (deflateStateCheck(strm) || strm.state.wrap !== 2) return Z_STREAM_ERROR$2;
+	strm.state.gzhead = head;
+	return Z_OK$3;
+};
+const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
+	if (!strm) return Z_STREAM_ERROR$2;
+	let wrap = 1;
+	if (level === Z_DEFAULT_COMPRESSION$1) level = 6;
+	if (windowBits < 0) {
+		wrap = 0;
+		windowBits = -windowBits;
+	} else if (windowBits > 15) {
+		wrap = 2;
+		windowBits -= 16;
+	}
+	if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED$2 || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED || windowBits === 8 && wrap !== 1) return err(strm, Z_STREAM_ERROR$2);
+	if (windowBits === 8) windowBits = 9;
+	const s = new DeflateState();
+	strm.state = s;
+	s.strm = strm;
+	s.status = INIT_STATE;
+	s.wrap = wrap;
+	s.gzhead = null;
+	s.w_bits = windowBits;
+	s.w_size = 1 << s.w_bits;
+	s.w_mask = s.w_size - 1;
+	s.hash_bits = memLevel + 7;
+	s.hash_size = 1 << s.hash_bits;
+	s.hash_mask = s.hash_size - 1;
+	s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
+	s.window = new Uint8Array(s.w_size * 2);
+	s.head = new Uint16Array(s.hash_size);
+	s.prev = new Uint16Array(s.w_size);
+	s.lit_bufsize = 1 << memLevel + 6;
+	s.pending_buf_size = s.lit_bufsize * 4;
+	s.pending_buf = new Uint8Array(s.pending_buf_size);
+	s.sym_buf = s.lit_bufsize;
+	s.sym_end = (s.lit_bufsize - 1) * 3;
+	s.level = level;
+	s.strategy = strategy;
+	s.method = method;
+	return deflateReset(strm);
+};
+const deflateInit = (strm, level) => {
+	return deflateInit2(strm, level, Z_DEFLATED$2, MAX_WBITS$1, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY$1);
+};
+const deflate$2 = (strm, flush) => {
+	if (deflateStateCheck(strm) || flush > Z_BLOCK$1 || flush < 0) return strm ? err(strm, Z_STREAM_ERROR$2) : Z_STREAM_ERROR$2;
+	const s = strm.state;
+	if (!strm.output || strm.avail_in !== 0 && !strm.input || s.status === FINISH_STATE && flush !== Z_FINISH$3) return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR$1 : Z_STREAM_ERROR$2);
+	const old_flush = s.last_flush;
+	s.last_flush = flush;
+	if (s.pending !== 0) {
+		flush_pending(strm);
+		if (strm.avail_out === 0) {
+			s.last_flush = -1;
+			return Z_OK$3;
+		}
+	} else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH$3) return err(strm, Z_BUF_ERROR$1);
+	if (s.status === FINISH_STATE && strm.avail_in !== 0) return err(strm, Z_BUF_ERROR$1);
+	if (s.status === INIT_STATE && s.wrap === 0) s.status = BUSY_STATE;
+	if (s.status === INIT_STATE) {
+		let header = Z_DEFLATED$2 + (s.w_bits - 8 << 4) << 8;
+		let level_flags = -1;
+		if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) level_flags = 0;
+		else if (s.level < 6) level_flags = 1;
+		else if (s.level === 6) level_flags = 2;
+		else level_flags = 3;
+		header |= level_flags << 6;
+		if (s.strstart !== 0) header |= PRESET_DICT;
+		header += 31 - header % 31;
+		putShortMSB(s, header);
+		if (s.strstart !== 0) {
+			putShortMSB(s, strm.adler >>> 16);
+			putShortMSB(s, strm.adler & 65535);
+		}
+		strm.adler = 1;
+		s.status = BUSY_STATE;
+		flush_pending(strm);
+		if (s.pending !== 0) {
+			s.last_flush = -1;
+			return Z_OK$3;
+		}
+	}
+	if (s.status === GZIP_STATE) {
+		strm.adler = 0;
+		put_byte(s, 31);
+		put_byte(s, 139);
+		put_byte(s, 8);
+		if (!s.gzhead) {
+			put_byte(s, 0);
+			put_byte(s, 0);
+			put_byte(s, 0);
+			put_byte(s, 0);
+			put_byte(s, 0);
+			put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
+			put_byte(s, OS_CODE);
+			s.status = BUSY_STATE;
+			flush_pending(strm);
+			if (s.pending !== 0) {
+				s.last_flush = -1;
+				return Z_OK$3;
+			}
+		} else {
+			put_byte(s, (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16));
+			put_byte(s, s.gzhead.time & 255);
+			put_byte(s, s.gzhead.time >> 8 & 255);
+			put_byte(s, s.gzhead.time >> 16 & 255);
+			put_byte(s, s.gzhead.time >> 24 & 255);
+			put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
+			put_byte(s, s.gzhead.os & 255);
+			if (s.gzhead.extra && s.gzhead.extra.length) {
+				put_byte(s, s.gzhead.extra.length & 255);
+				put_byte(s, s.gzhead.extra.length >> 8 & 255);
+			}
+			if (s.gzhead.hcrc) strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending, 0);
+			s.gzindex = 0;
+			s.status = EXTRA_STATE;
+		}
+	}
+	if (s.status === EXTRA_STATE) {
+		if (s.gzhead.extra) {
+			let beg = s.pending;
+			let left = (s.gzhead.extra.length & 65535) - s.gzindex;
+			while (s.pending + left > s.pending_buf_size) {
+				let copy = s.pending_buf_size - s.pending;
+				s.pending_buf.set(s.gzhead.extra.subarray(s.gzindex, s.gzindex + copy), s.pending);
+				s.pending = s.pending_buf_size;
+				if (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
+				s.gzindex += copy;
+				flush_pending(strm);
+				if (s.pending !== 0) {
+					s.last_flush = -1;
+					return Z_OK$3;
+				}
+				beg = 0;
+				left -= copy;
+			}
+			let gzhead_extra = new Uint8Array(s.gzhead.extra);
+			s.pending_buf.set(gzhead_extra.subarray(s.gzindex, s.gzindex + left), s.pending);
+			s.pending += left;
+			if (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
+			s.gzindex = 0;
+		}
+		s.status = NAME_STATE;
+	}
+	if (s.status === NAME_STATE) {
+		if (s.gzhead.name) {
+			let beg = s.pending;
+			let val;
+			do {
+				if (s.pending === s.pending_buf_size) {
+					if (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
+					flush_pending(strm);
+					if (s.pending !== 0) {
+						s.last_flush = -1;
+						return Z_OK$3;
+					}
+					beg = 0;
+				}
+				if (s.gzindex < s.gzhead.name.length) val = s.gzhead.name.charCodeAt(s.gzindex++) & 255;
+				else val = 0;
+				put_byte(s, val);
+			} while (val !== 0);
+			if (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
+			s.gzindex = 0;
+		}
+		s.status = COMMENT_STATE;
+	}
+	if (s.status === COMMENT_STATE) {
+		if (s.gzhead.comment) {
+			let beg = s.pending;
+			let val;
+			do {
+				if (s.pending === s.pending_buf_size) {
+					if (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
+					flush_pending(strm);
+					if (s.pending !== 0) {
+						s.last_flush = -1;
+						return Z_OK$3;
+					}
+					beg = 0;
+				}
+				if (s.gzindex < s.gzhead.comment.length) val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255;
+				else val = 0;
+				put_byte(s, val);
+			} while (val !== 0);
+			if (s.gzhead.hcrc && s.pending > beg) strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
+		}
+		s.status = HCRC_STATE;
+	}
+	if (s.status === HCRC_STATE) {
+		if (s.gzhead.hcrc) {
+			if (s.pending + 2 > s.pending_buf_size) {
+				flush_pending(strm);
+				if (s.pending !== 0) {
+					s.last_flush = -1;
+					return Z_OK$3;
+				}
+			}
+			put_byte(s, strm.adler & 255);
+			put_byte(s, strm.adler >> 8 & 255);
+			strm.adler = 0;
+		}
+		s.status = BUSY_STATE;
+		flush_pending(strm);
+		if (s.pending !== 0) {
+			s.last_flush = -1;
+			return Z_OK$3;
+		}
+	}
+	if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH$2 && s.status !== FINISH_STATE) {
+		let bstate = s.level === 0 ? deflate_stored(s, flush) : s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s.strategy === Z_RLE ? deflate_rle(s, flush) : configuration_table[s.level].func(s, flush);
+		if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) s.status = FINISH_STATE;
+		if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
+			if (strm.avail_out === 0) s.last_flush = -1;
+			return Z_OK$3;
+		}
+		if (bstate === BS_BLOCK_DONE) {
+			if (flush === Z_PARTIAL_FLUSH) _tr_align(s);
+			else if (flush !== Z_BLOCK$1) {
+				_tr_stored_block(s, 0, 0, false);
+				if (flush === Z_FULL_FLUSH$1) {
+					/*** CLEAR_HASH(s); ***/ zero(s.head);
+					if (s.lookahead === 0) {
+						s.strstart = 0;
+						s.block_start = 0;
+						s.insert = 0;
+					}
+				}
+			}
+			flush_pending(strm);
+			if (strm.avail_out === 0) {
+				s.last_flush = -1;
+				return Z_OK$3;
+			}
+		}
+	}
+	if (flush !== Z_FINISH$3) return Z_OK$3;
+	if (s.wrap <= 0) return Z_STREAM_END$3;
+	if (s.wrap === 2) {
+		put_byte(s, strm.adler & 255);
+		put_byte(s, strm.adler >> 8 & 255);
+		put_byte(s, strm.adler >> 16 & 255);
+		put_byte(s, strm.adler >> 24 & 255);
+		put_byte(s, strm.total_in & 255);
+		put_byte(s, strm.total_in >> 8 & 255);
+		put_byte(s, strm.total_in >> 16 & 255);
+		put_byte(s, strm.total_in >> 24 & 255);
+	} else {
+		putShortMSB(s, strm.adler >>> 16);
+		putShortMSB(s, strm.adler & 65535);
+	}
+	flush_pending(strm);
+	if (s.wrap > 0) s.wrap = -s.wrap;
+	return s.pending !== 0 ? Z_OK$3 : Z_STREAM_END$3;
+};
+const deflateEnd = (strm) => {
+	if (deflateStateCheck(strm)) return Z_STREAM_ERROR$2;
+	const status = strm.state.status;
+	strm.state = null;
+	return status === BUSY_STATE ? err(strm, Z_DATA_ERROR$2) : Z_OK$3;
+};
+const deflateSetDictionary = (strm, dictionary) => {
+	let dictLength = dictionary.length;
+	if (deflateStateCheck(strm)) return Z_STREAM_ERROR$2;
+	const s = strm.state;
+	const wrap = s.wrap;
+	if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) return Z_STREAM_ERROR$2;
+	if (wrap === 1) strm.adler = adler32_1(strm.adler, dictionary, dictLength, 0);
+	s.wrap = 0;
+	if (dictLength >= s.w_size) {
+		if (wrap === 0) {
+			/*** CLEAR_HASH(s); ***/
+			zero(s.head);
+			s.strstart = 0;
+			s.block_start = 0;
+			s.insert = 0;
+		}
+		let tmpDict = new Uint8Array(s.w_size);
+		tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0);
+		dictionary = tmpDict;
+		dictLength = s.w_size;
+	}
+	const avail = strm.avail_in;
+	const next = strm.next_in;
+	const input = strm.input;
+	strm.avail_in = dictLength;
+	strm.next_in = 0;
+	strm.input = dictionary;
+	fill_window(s);
+	while (s.lookahead >= MIN_MATCH) {
+		let str = s.strstart;
+		let n = s.lookahead - (MIN_MATCH - 1);
+		do {
+			s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
+			s.prev[str & s.w_mask] = s.head[s.ins_h];
+			s.head[s.ins_h] = str;
+			str++;
+		} while (--n);
+		s.strstart = str;
+		s.lookahead = MIN_MATCH - 1;
+		fill_window(s);
+	}
+	s.strstart += s.lookahead;
+	s.block_start = s.strstart;
+	s.insert = s.lookahead;
+	s.lookahead = 0;
+	s.match_length = s.prev_length = MIN_MATCH - 1;
+	s.match_available = 0;
+	strm.next_in = next;
+	strm.input = input;
+	strm.avail_in = avail;
+	s.wrap = wrap;
+	return Z_OK$3;
+};
+var deflate_1$2 = {
+	deflateInit,
+	deflateInit2,
+	deflateReset,
+	deflateResetKeep,
+	deflateSetHeader,
+	deflate: deflate$2,
+	deflateEnd,
+	deflateSetDictionary,
+	deflateInfo: "pako deflate (from Nodeca project)"
+};
+const _has = (obj, key) => {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+};
+var assign = function(obj) {
+	const sources = Array.prototype.slice.call(arguments, 1);
+	while (sources.length) {
+		const source = sources.shift();
+		if (!source) continue;
+		if (typeof source !== "object") throw new TypeError(source + "must be non-object");
+		for (const p in source) if (_has(source, p)) obj[p] = source[p];
+	}
+	return obj;
+};
+var flattenChunks = (chunks) => {
+	let len = 0;
+	for (let i = 0, l = chunks.length; i < l; i++) len += chunks[i].length;
+	const result = new Uint8Array(len);
+	for (let i = 0, pos = 0, l = chunks.length; i < l; i++) {
+		let chunk = chunks[i];
+		result.set(chunk, pos);
+		pos += chunk.length;
+	}
+	return result;
+};
+var common = {
+	assign,
+	flattenChunks
+};
+let STR_APPLY_UIA_OK = true;
+try {
+	String.fromCharCode.apply(null, new Uint8Array(1));
+} catch (__) {
+	STR_APPLY_UIA_OK = false;
+}
+const _utf8len = new Uint8Array(256);
+for (let q = 0; q < 256; q++) _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;
+_utf8len[254] = _utf8len[254] = 1;
+var string2buf = (str) => {
+	if (typeof TextEncoder === "function" && TextEncoder.prototype.encode) return new TextEncoder().encode(str);
+	let buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
+	for (m_pos = 0; m_pos < str_len; m_pos++) {
+		c = str.charCodeAt(m_pos);
+		if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
+			c2 = str.charCodeAt(m_pos + 1);
+			if ((c2 & 64512) === 56320) {
+				c = 65536 + (c - 55296 << 10) + (c2 - 56320);
+				m_pos++;
+			}
+		}
+		buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4;
+	}
+	buf = new Uint8Array(buf_len);
+	for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
+		c = str.charCodeAt(m_pos);
+		if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
+			c2 = str.charCodeAt(m_pos + 1);
+			if ((c2 & 64512) === 56320) {
+				c = 65536 + (c - 55296 << 10) + (c2 - 56320);
+				m_pos++;
+			}
+		}
+		if (c < 128) buf[i++] = c;
+		else if (c < 2048) {
+			buf[i++] = 192 | c >>> 6;
+			buf[i++] = 128 | c & 63;
+		} else if (c < 65536) {
+			buf[i++] = 224 | c >>> 12;
+			buf[i++] = 128 | c >>> 6 & 63;
+			buf[i++] = 128 | c & 63;
+		} else {
+			buf[i++] = 240 | c >>> 18;
+			buf[i++] = 128 | c >>> 12 & 63;
+			buf[i++] = 128 | c >>> 6 & 63;
+			buf[i++] = 128 | c & 63;
+		}
+	}
+	return buf;
+};
+const buf2binstring = (buf, len) => {
+	if (len < 65534) {
+		if (buf.subarray && STR_APPLY_UIA_OK) return String.fromCharCode.apply(null, buf.length === len ? buf : buf.subarray(0, len));
+	}
+	let result = "";
+	for (let i = 0; i < len; i++) result += String.fromCharCode(buf[i]);
+	return result;
+};
+var buf2string = (buf, max) => {
+	const len = max || buf.length;
+	if (typeof TextDecoder === "function" && TextDecoder.prototype.decode) return new TextDecoder().decode(buf.subarray(0, max));
+	let i, out;
+	const utf16buf = new Array(len * 2);
+	for (out = 0, i = 0; i < len;) {
+		let c = buf[i++];
+		if (c < 128) {
+			utf16buf[out++] = c;
+			continue;
+		}
+		let c_len = _utf8len[c];
+		if (c_len > 4) {
+			utf16buf[out++] = 65533;
+			i += c_len - 1;
+			continue;
+		}
+		c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7;
+		while (c_len > 1 && i < len) {
+			c = c << 6 | buf[i++] & 63;
+			c_len--;
+		}
+		if (c_len > 1) {
+			utf16buf[out++] = 65533;
+			continue;
+		}
+		if (c < 65536) utf16buf[out++] = c;
+		else {
+			c -= 65536;
+			utf16buf[out++] = 55296 | c >> 10 & 1023;
+			utf16buf[out++] = 56320 | c & 1023;
+		}
+	}
+	return buf2binstring(utf16buf, out);
+};
+var utf8border = (buf, max) => {
+	max = max || buf.length;
+	if (max > buf.length) max = buf.length;
+	let pos = max - 1;
+	while (pos >= 0 && (buf[pos] & 192) === 128) pos--;
+	if (pos < 0) return max;
+	if (pos === 0) return max;
+	return pos + _utf8len[buf[pos]] > max ? pos : max;
+};
+var strings = {
+	string2buf,
+	buf2string,
+	utf8border
+};
+function ZStream() {
+	this.input = null;
+	this.next_in = 0;
+	this.avail_in = 0;
+	this.total_in = 0;
+	this.output = null;
+	this.next_out = 0;
+	this.avail_out = 0;
+	this.total_out = 0;
+	this.msg = "";
+	this.state = null;
+	this.data_type = 2;
+	this.adler = 0;
+}
+var zstream = ZStream;
+const toString$1 = Object.prototype.toString;
+const { Z_NO_FLUSH: Z_NO_FLUSH$1, Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH: Z_FINISH$2, Z_OK: Z_OK$2, Z_STREAM_END: Z_STREAM_END$2, Z_DEFAULT_COMPRESSION, Z_DEFAULT_STRATEGY, Z_DEFLATED: Z_DEFLATED$1 } = constants$2;
+/**
+* class Deflate
+*
+* Generic JS-style wrapper for zlib calls. If you don't need
+* streaming behaviour - use more simple functions: [[deflate]],
+* [[deflateRaw]] and [[gzip]].
+**/
+/**
+* Deflate.result -> Uint8Array
+*
+* Compressed result, generated by default [[Deflate#onData]]
+* and [[Deflate#onEnd]] handlers. Filled after you push last chunk
+* (call [[Deflate#push]] with `Z_FINISH` / `true` param).
+**/
+/**
+* Deflate.err -> Number
+*
+* Error code after deflate finished. 0 (Z_OK) on success.
+* You will not need it in real life, because deflate errors
+* are possible only on wrong options or bad `onData` / `onEnd`
+* custom handlers.
+**/
+/**
+* Deflate.msg -> String
+*
+* Error message, if [[Deflate.err]] != 0
+**/
+/**
+* new Deflate(options)
+* - options (Object): zlib deflate options.
+*
+* Creates new deflator instance with specified params. Throws exception
+* on bad params. Supported options:
+*
+* - `level`
+* - `windowBits`
+* - `memLevel`
+* - `strategy`
+* - `dictionary`
+*
+* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+* for more information on these.
+*
+* Additional options, for internal needs:
+*
+* - `chunkSize` - size of generated data chunks (16K by default)
+* - `raw` (Boolean) - do raw deflate
+* - `gzip` (Boolean) - create gzip wrapper
+* - `header` (Object) - custom header for gzip
+*   - `text` (Boolean) - true if compressed data believed to be text
+*   - `time` (Number) - modification time, unix timestamp
+*   - `os` (Number) - operation system code
+*   - `extra` (Array) - array of bytes with extra data (max 65536)
+*   - `name` (String) - file name (binary string)
+*   - `comment` (String) - comment (binary string)
+*   - `hcrc` (Boolean) - true if header crc should be added
+*
+* ##### Example:
+*
+* ```javascript
+* const pako = require('pako')
+*   , chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])
+*   , chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);
+*
+* const deflate = new pako.Deflate({ level: 3});
+*
+* deflate.push(chunk1, false);
+* deflate.push(chunk2, true);  // true -> last chunk
+*
+* if (deflate.err) { throw new Error(deflate.err); }
+*
+* console.log(deflate.result);
+* ```
+**/
+function Deflate$1(options) {
+	this.options = common.assign({
+		level: Z_DEFAULT_COMPRESSION,
+		method: Z_DEFLATED$1,
+		chunkSize: 16384,
+		windowBits: 15,
+		memLevel: 8,
+		strategy: Z_DEFAULT_STRATEGY
+	}, options || {});
+	let opt = this.options;
+	if (opt.raw && opt.windowBits > 0) opt.windowBits = -opt.windowBits;
+	else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) opt.windowBits += 16;
+	this.err = 0;
+	this.msg = "";
+	this.ended = false;
+	this.chunks = [];
+	this.strm = new zstream();
+	this.strm.avail_out = 0;
+	let status = deflate_1$2.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);
+	if (status !== Z_OK$2) throw new Error(messages[status]);
+	if (opt.header) deflate_1$2.deflateSetHeader(this.strm, opt.header);
+	if (opt.dictionary) {
+		let dict;
+		if (typeof opt.dictionary === "string") dict = strings.string2buf(opt.dictionary);
+		else if (toString$1.call(opt.dictionary) === "[object ArrayBuffer]") dict = new Uint8Array(opt.dictionary);
+		else dict = opt.dictionary;
+		status = deflate_1$2.deflateSetDictionary(this.strm, dict);
+		if (status !== Z_OK$2) throw new Error(messages[status]);
+		this._dict_set = true;
+	}
+}
+/**
+* Deflate#push(data[, flush_mode]) -> Boolean
+* - data (Uint8Array|ArrayBuffer|String): input data. Strings will be
+*   converted to utf8 byte sequence.
+* - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
+*   See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.
+*
+* Sends input data to deflate pipe, generating [[Deflate#onData]] calls with
+* new compressed chunks. Returns `true` on success. The last data block must
+* have `flush_mode` Z_FINISH (or `true`). That will flush internal pending
+* buffers and call [[Deflate#onEnd]].
+*
+* On fail call [[Deflate#onEnd]] with error code and return false.
+*
+* ##### Example
+*
+* ```javascript
+* push(chunk, false); // push one of data chunks
+* ...
+* push(chunk, true);  // push last chunk
+* ```
+**/
+Deflate$1.prototype.push = function(data, flush_mode) {
+	const strm = this.strm;
+	const chunkSize = this.options.chunkSize;
+	let status, _flush_mode;
+	if (this.ended) return false;
+	if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;
+	else _flush_mode = flush_mode === true ? Z_FINISH$2 : Z_NO_FLUSH$1;
+	if (typeof data === "string") strm.input = strings.string2buf(data);
+	else if (toString$1.call(data) === "[object ArrayBuffer]") strm.input = new Uint8Array(data);
+	else strm.input = data;
+	strm.next_in = 0;
+	strm.avail_in = strm.input.length;
+	for (;;) {
+		if (strm.avail_out === 0) {
+			strm.output = new Uint8Array(chunkSize);
+			strm.next_out = 0;
+			strm.avail_out = chunkSize;
+		}
+		if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH) && strm.avail_out <= 6) {
+			this.onData(strm.output.subarray(0, strm.next_out));
+			strm.avail_out = 0;
+			continue;
+		}
+		status = deflate_1$2.deflate(strm, _flush_mode);
+		if (status === Z_STREAM_END$2) {
+			if (strm.next_out > 0) this.onData(strm.output.subarray(0, strm.next_out));
+			status = deflate_1$2.deflateEnd(this.strm);
+			this.onEnd(status);
+			this.ended = true;
+			return status === Z_OK$2;
+		}
+		if (strm.avail_out === 0) {
+			this.onData(strm.output);
+			continue;
+		}
+		if (_flush_mode > 0 && strm.next_out > 0) {
+			this.onData(strm.output.subarray(0, strm.next_out));
+			strm.avail_out = 0;
+			continue;
+		}
+		if (strm.avail_in === 0) break;
+	}
+	return true;
+};
+/**
+* Deflate#onData(chunk) -> Void
+* - chunk (Uint8Array): output data.
+*
+* By default, stores data blocks in `chunks[]` property and glue
+* those in `onEnd`. Override this handler, if you need another behaviour.
+**/
+Deflate$1.prototype.onData = function(chunk) {
+	this.chunks.push(chunk);
+};
+/**
+* Deflate#onEnd(status) -> Void
+* - status (Number): deflate status. 0 (Z_OK) on success,
+*   other if not.
+*
+* Called once after you tell deflate that the input stream is
+* complete (Z_FINISH). By default - join collected chunks,
+* free memory and fill `results` / `err` properties.
+**/
+Deflate$1.prototype.onEnd = function(status) {
+	if (status === Z_OK$2) this.result = common.flattenChunks(this.chunks);
+	this.chunks = [];
+	this.err = status;
+	this.msg = this.strm.msg;
+};
+/**
+* deflate(data[, options]) -> Uint8Array
+* - data (Uint8Array|ArrayBuffer|String): input data to compress.
+* - options (Object): zlib deflate options.
+*
+* Compress `data` with deflate algorithm and `options`.
+*
+* Supported options are:
+*
+* - level
+* - windowBits
+* - memLevel
+* - strategy
+* - dictionary
+*
+* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+* for more information on these.
+*
+* Sugar (options):
+*
+* - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
+*   negative windowBits implicitly.
+*
+* ##### Example:
+*
+* ```javascript
+* const pako = require('pako')
+* const data = new Uint8Array([1,2,3,4,5,6,7,8,9]);
+*
+* console.log(pako.deflate(data));
+* ```
+**/
+function deflate$1(input, options) {
+	const deflator = new Deflate$1(options);
+	deflator.push(input, true);
+	if (deflator.err) throw deflator.msg || messages[deflator.err];
+	return deflator.result;
+}
+/**
+* deflateRaw(data[, options]) -> Uint8Array
+* - data (Uint8Array|ArrayBuffer|String): input data to compress.
+* - options (Object): zlib deflate options.
+*
+* The same as [[deflate]], but creates raw data, without wrapper
+* (header and adler32 crc).
+**/
+function deflateRaw$1(input, options) {
+	options = options || {};
+	options.raw = true;
+	return deflate$1(input, options);
+}
+/**
+* gzip(data[, options]) -> Uint8Array
+* - data (Uint8Array|ArrayBuffer|String): input data to compress.
+* - options (Object): zlib deflate options.
+*
+* The same as [[deflate]], but create gzip wrapper instead of
+* deflate one.
+**/
+function gzip$1(input, options) {
+	options = options || {};
+	options.gzip = true;
+	return deflate$1(input, options);
+}
+var deflate_1$1 = {
+	Deflate: Deflate$1,
+	deflate: deflate$1,
+	deflateRaw: deflateRaw$1,
+	gzip: gzip$1,
+	constants: constants$2
+};
+const BAD$1 = 16209;
+const TYPE$1 = 16191;
+var inffast = function inflate_fast(strm, start) {
+	let _in;
+	let last;
+	let _out;
+	let beg;
+	let end;
+	let dmax;
+	let wsize;
+	let whave;
+	let wnext;
+	let s_window;
+	let hold;
+	let bits;
+	let lcode;
+	let dcode;
+	let lmask;
+	let dmask;
+	let here;
+	let op;
+	let len;
+	let dist;
+	let from;
+	let from_source;
+	let input, output;
+	const state = strm.state;
+	_in = strm.next_in;
+	input = strm.input;
+	last = _in + (strm.avail_in - 5);
+	_out = strm.next_out;
+	output = strm.output;
+	beg = _out - (start - strm.avail_out);
+	end = _out + (strm.avail_out - 257);
+	dmax = state.dmax;
+	wsize = state.wsize;
+	whave = state.whave;
+	wnext = state.wnext;
+	s_window = state.window;
+	hold = state.hold;
+	bits = state.bits;
+	lcode = state.lencode;
+	dcode = state.distcode;
+	lmask = (1 << state.lenbits) - 1;
+	dmask = (1 << state.distbits) - 1;
+	top: do {
+		if (bits < 15) {
+			hold += input[_in++] << bits;
+			bits += 8;
+			hold += input[_in++] << bits;
+			bits += 8;
+		}
+		here = lcode[hold & lmask];
+		dolen: for (;;) {
+			op = here >>> 24;
+			hold >>>= op;
+			bits -= op;
+			op = here >>> 16 & 255;
+			if (op === 0) output[_out++] = here & 65535;
+			else if (op & 16) {
+				len = here & 65535;
+				op &= 15;
+				if (op) {
+					if (bits < op) {
+						hold += input[_in++] << bits;
+						bits += 8;
+					}
+					len += hold & (1 << op) - 1;
+					hold >>>= op;
+					bits -= op;
+				}
+				if (bits < 15) {
+					hold += input[_in++] << bits;
+					bits += 8;
+					hold += input[_in++] << bits;
+					bits += 8;
+				}
+				here = dcode[hold & dmask];
+				dodist: for (;;) {
+					op = here >>> 24;
+					hold >>>= op;
+					bits -= op;
+					op = here >>> 16 & 255;
+					if (op & 16) {
+						dist = here & 65535;
+						op &= 15;
+						if (bits < op) {
+							hold += input[_in++] << bits;
+							bits += 8;
+							if (bits < op) {
+								hold += input[_in++] << bits;
+								bits += 8;
+							}
+						}
+						dist += hold & (1 << op) - 1;
+						if (dist > dmax) {
+							strm.msg = "invalid distance too far back";
+							state.mode = BAD$1;
+							break top;
+						}
+						hold >>>= op;
+						bits -= op;
+						op = _out - beg;
+						if (dist > op) {
+							op = dist - op;
+							if (op > whave) {
+								if (state.sane) {
+									strm.msg = "invalid distance too far back";
+									state.mode = BAD$1;
+									break top;
+								}
+							}
+							from = 0;
+							from_source = s_window;
+							if (wnext === 0) {
+								from += wsize - op;
+								if (op < len) {
+									len -= op;
+									do
+										output[_out++] = s_window[from++];
+									while (--op);
+									from = _out - dist;
+									from_source = output;
+								}
+							} else if (wnext < op) {
+								from += wsize + wnext - op;
+								op -= wnext;
+								if (op < len) {
+									len -= op;
+									do
+										output[_out++] = s_window[from++];
+									while (--op);
+									from = 0;
+									if (wnext < len) {
+										op = wnext;
+										len -= op;
+										do
+											output[_out++] = s_window[from++];
+										while (--op);
+										from = _out - dist;
+										from_source = output;
+									}
+								}
+							} else {
+								from += wnext - op;
+								if (op < len) {
+									len -= op;
+									do
+										output[_out++] = s_window[from++];
+									while (--op);
+									from = _out - dist;
+									from_source = output;
+								}
+							}
+							while (len > 2) {
+								output[_out++] = from_source[from++];
+								output[_out++] = from_source[from++];
+								output[_out++] = from_source[from++];
+								len -= 3;
+							}
+							if (len) {
+								output[_out++] = from_source[from++];
+								if (len > 1) output[_out++] = from_source[from++];
+							}
+						} else {
+							from = _out - dist;
+							do {
+								output[_out++] = output[from++];
+								output[_out++] = output[from++];
+								output[_out++] = output[from++];
+								len -= 3;
+							} while (len > 2);
+							if (len) {
+								output[_out++] = output[from++];
+								if (len > 1) output[_out++] = output[from++];
+							}
+						}
+					} else if ((op & 64) === 0) {
+						here = dcode[(here & 65535) + (hold & (1 << op) - 1)];
+						continue dodist;
+					} else {
+						strm.msg = "invalid distance code";
+						state.mode = BAD$1;
+						break top;
+					}
+					break;
+				}
+			} else if ((op & 64) === 0) {
+				here = lcode[(here & 65535) + (hold & (1 << op) - 1)];
+				continue dolen;
+			} else if (op & 32) {
+				state.mode = TYPE$1;
+				break top;
+			} else {
+				strm.msg = "invalid literal/length code";
+				state.mode = BAD$1;
+				break top;
+			}
+			break;
+		}
+	} while (_in < last && _out < end);
+	len = bits >> 3;
+	_in -= len;
+	bits -= len << 3;
+	hold &= (1 << bits) - 1;
+	strm.next_in = _in;
+	strm.next_out = _out;
+	strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last);
+	strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end);
+	state.hold = hold;
+	state.bits = bits;
+};
+const MAXBITS = 15;
+const ENOUGH_LENS$1 = 852;
+const ENOUGH_DISTS$1 = 592;
+const CODES$1 = 0;
+const LENS$1 = 1;
+const DISTS$1 = 2;
+const lbase = new Uint16Array([
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	13,
+	15,
+	17,
+	19,
+	23,
+	27,
+	31,
+	35,
+	43,
+	51,
+	59,
+	67,
+	83,
+	99,
+	115,
+	131,
+	163,
+	195,
+	227,
+	258,
+	0,
+	0
+]);
+const lext = new Uint8Array([
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	17,
+	17,
+	17,
+	17,
+	18,
+	18,
+	18,
+	18,
+	19,
+	19,
+	19,
+	19,
+	20,
+	20,
+	20,
+	20,
+	21,
+	21,
+	21,
+	21,
+	16,
+	72,
+	78
+]);
+const dbase = new Uint16Array([
+	1,
+	2,
+	3,
+	4,
+	5,
+	7,
+	9,
+	13,
+	17,
+	25,
+	33,
+	49,
+	65,
+	97,
+	129,
+	193,
+	257,
+	385,
+	513,
+	769,
+	1025,
+	1537,
+	2049,
+	3073,
+	4097,
+	6145,
+	8193,
+	12289,
+	16385,
+	24577,
+	0,
+	0
+]);
+const dext = new Uint8Array([
+	16,
+	16,
+	16,
+	16,
+	17,
+	17,
+	18,
+	18,
+	19,
+	19,
+	20,
+	20,
+	21,
+	21,
+	22,
+	22,
+	23,
+	23,
+	24,
+	24,
+	25,
+	25,
+	26,
+	26,
+	27,
+	27,
+	28,
+	28,
+	29,
+	29,
+	64,
+	64
+]);
+const inflate_table = (type, lens, lens_index, codes, table, table_index, work, opts) => {
+	const bits = opts.bits;
+	let len = 0;
+	let sym = 0;
+	let min = 0, max = 0;
+	let root = 0;
+	let curr = 0;
+	let drop = 0;
+	let left = 0;
+	let used = 0;
+	let huff = 0;
+	let incr;
+	let fill;
+	let low;
+	let mask;
+	let next;
+	let base = null;
+	let match;
+	const count = new Uint16Array(MAXBITS + 1);
+	const offs = new Uint16Array(MAXBITS + 1);
+	let extra = null;
+	let here_bits, here_op, here_val;
+	for (len = 0; len <= MAXBITS; len++) count[len] = 0;
+	for (sym = 0; sym < codes; sym++) count[lens[lens_index + sym]]++;
+	root = bits;
+	for (max = MAXBITS; max >= 1; max--) if (count[max] !== 0) break;
+	if (root > max) root = max;
+	if (max === 0) {
+		table[table_index++] = 20971520;
+		table[table_index++] = 20971520;
+		opts.bits = 1;
+		return 0;
+	}
+	for (min = 1; min < max; min++) if (count[min] !== 0) break;
+	if (root < min) root = min;
+	left = 1;
+	for (len = 1; len <= MAXBITS; len++) {
+		left <<= 1;
+		left -= count[len];
+		if (left < 0) return -1;
+	}
+	if (left > 0 && (type === CODES$1 || max !== 1)) return -1;
+	offs[1] = 0;
+	for (len = 1; len < MAXBITS; len++) offs[len + 1] = offs[len] + count[len];
+	for (sym = 0; sym < codes; sym++) if (lens[lens_index + sym] !== 0) work[offs[lens[lens_index + sym]]++] = sym;
+	if (type === CODES$1) {
+		base = extra = work;
+		match = 20;
+	} else if (type === LENS$1) {
+		base = lbase;
+		extra = lext;
+		match = 257;
+	} else {
+		base = dbase;
+		extra = dext;
+		match = 0;
+	}
+	huff = 0;
+	sym = 0;
+	len = min;
+	next = table_index;
+	curr = root;
+	drop = 0;
+	low = -1;
+	used = 1 << root;
+	mask = used - 1;
+	if (type === LENS$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) return 1;
+	for (;;) {
+		here_bits = len - drop;
+		if (work[sym] + 1 < match) {
+			here_op = 0;
+			here_val = work[sym];
+		} else if (work[sym] >= match) {
+			here_op = extra[work[sym] - match];
+			here_val = base[work[sym] - match];
+		} else {
+			here_op = 96;
+			here_val = 0;
+		}
+		incr = 1 << len - drop;
+		fill = 1 << curr;
+		min = fill;
+		do {
+			fill -= incr;
+			table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
+		} while (fill !== 0);
+		incr = 1 << len - 1;
+		while (huff & incr) incr >>= 1;
+		if (incr !== 0) {
+			huff &= incr - 1;
+			huff += incr;
+		} else huff = 0;
+		sym++;
+		if (--count[len] === 0) {
+			if (len === max) break;
+			len = lens[lens_index + work[sym]];
+		}
+		if (len > root && (huff & mask) !== low) {
+			if (drop === 0) drop = root;
+			next += min;
+			curr = len - drop;
+			left = 1 << curr;
+			while (curr + drop < max) {
+				left -= count[curr + drop];
+				if (left <= 0) break;
+				curr++;
+				left <<= 1;
+			}
+			used += 1 << curr;
+			if (type === LENS$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) return 1;
+			low = huff & mask;
+			table[low] = root << 24 | curr << 16 | next - table_index | 0;
+		}
+	}
+	if (huff !== 0) table[next + huff] = len - drop << 24 | 4194304;
+	opts.bits = root;
+	return 0;
+};
+var inftrees = inflate_table;
+const CODES = 0;
+const LENS = 1;
+const DISTS = 2;
+const { Z_FINISH: Z_FINISH$1, Z_BLOCK, Z_TREES, Z_OK: Z_OK$1, Z_STREAM_END: Z_STREAM_END$1, Z_NEED_DICT: Z_NEED_DICT$1, Z_STREAM_ERROR: Z_STREAM_ERROR$1, Z_DATA_ERROR: Z_DATA_ERROR$1, Z_MEM_ERROR: Z_MEM_ERROR$1, Z_BUF_ERROR, Z_DEFLATED } = constants$2;
+const HEAD = 16180;
+const FLAGS = 16181;
+const TIME = 16182;
+const OS = 16183;
+const EXLEN = 16184;
+const EXTRA = 16185;
+const NAME = 16186;
+const COMMENT = 16187;
+const HCRC = 16188;
+const DICTID = 16189;
+const DICT = 16190;
+const TYPE = 16191;
+const TYPEDO = 16192;
+const STORED = 16193;
+const COPY_ = 16194;
+const COPY = 16195;
+const TABLE = 16196;
+const LENLENS = 16197;
+const CODELENS = 16198;
+const LEN_ = 16199;
+const LEN = 16200;
+const LENEXT = 16201;
+const DIST = 16202;
+const DISTEXT = 16203;
+const MATCH = 16204;
+const LIT = 16205;
+const CHECK = 16206;
+const LENGTH = 16207;
+const DONE = 16208;
+const BAD = 16209;
+const MEM = 16210;
+const SYNC = 16211;
+const ENOUGH_LENS = 852;
+const ENOUGH_DISTS = 592;
+const DEF_WBITS = 15;
+const zswap32 = (q) => {
+	return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24);
+};
+function InflateState() {
+	this.strm = null;
+	this.mode = 0;
+	this.last = false;
+	this.wrap = 0;
+	this.havedict = false;
+	this.flags = 0;
+	this.dmax = 0;
+	this.check = 0;
+	this.total = 0;
+	this.head = null;
+	this.wbits = 0;
+	this.wsize = 0;
+	this.whave = 0;
+	this.wnext = 0;
+	this.window = null;
+	this.hold = 0;
+	this.bits = 0;
+	this.length = 0;
+	this.offset = 0;
+	this.extra = 0;
+	this.lencode = null;
+	this.distcode = null;
+	this.lenbits = 0;
+	this.distbits = 0;
+	this.ncode = 0;
+	this.nlen = 0;
+	this.ndist = 0;
+	this.have = 0;
+	this.next = null;
+	this.lens = new Uint16Array(320);
+	this.work = new Uint16Array(288);
+	this.lendyn = null;
+	this.distdyn = null;
+	this.sane = 0;
+	this.back = 0;
+	this.was = 0;
+}
+const inflateStateCheck = (strm) => {
+	if (!strm) return 1;
+	const state = strm.state;
+	if (!state || state.strm !== strm || state.mode < HEAD || state.mode > SYNC) return 1;
+	return 0;
+};
+const inflateResetKeep = (strm) => {
+	if (inflateStateCheck(strm)) return Z_STREAM_ERROR$1;
+	const state = strm.state;
+	strm.total_in = strm.total_out = state.total = 0;
+	strm.msg = "";
+	if (state.wrap) strm.adler = state.wrap & 1;
+	state.mode = HEAD;
+	state.last = 0;
+	state.havedict = 0;
+	state.flags = -1;
+	state.dmax = 32768;
+	state.head = null;
+	state.hold = 0;
+	state.bits = 0;
+	state.lencode = state.lendyn = new Int32Array(ENOUGH_LENS);
+	state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS);
+	state.sane = 1;
+	state.back = -1;
+	return Z_OK$1;
+};
+const inflateReset = (strm) => {
+	if (inflateStateCheck(strm)) return Z_STREAM_ERROR$1;
+	const state = strm.state;
+	state.wsize = 0;
+	state.whave = 0;
+	state.wnext = 0;
+	return inflateResetKeep(strm);
+};
+const inflateReset2 = (strm, windowBits) => {
+	let wrap;
+	if (inflateStateCheck(strm)) return Z_STREAM_ERROR$1;
+	const state = strm.state;
+	if (windowBits < 0) {
+		wrap = 0;
+		windowBits = -windowBits;
+	} else {
+		wrap = (windowBits >> 4) + 5;
+		if (windowBits < 48) windowBits &= 15;
+	}
+	if (windowBits && (windowBits < 8 || windowBits > 15)) return Z_STREAM_ERROR$1;
+	if (state.window !== null && state.wbits !== windowBits) state.window = null;
+	state.wrap = wrap;
+	state.wbits = windowBits;
+	return inflateReset(strm);
+};
+const inflateInit2 = (strm, windowBits) => {
+	if (!strm) return Z_STREAM_ERROR$1;
+	const state = new InflateState();
+	strm.state = state;
+	state.strm = strm;
+	state.window = null;
+	state.mode = HEAD;
+	const ret = inflateReset2(strm, windowBits);
+	if (ret !== Z_OK$1) strm.state = null;
+	return ret;
+};
+const inflateInit = (strm) => {
+	return inflateInit2(strm, DEF_WBITS);
+};
+let virgin = true;
+let lenfix, distfix;
+const fixedtables = (state) => {
+	if (virgin) {
+		lenfix = new Int32Array(512);
+		distfix = new Int32Array(32);
+		let sym = 0;
+		while (sym < 144) state.lens[sym++] = 8;
+		while (sym < 256) state.lens[sym++] = 9;
+		while (sym < 280) state.lens[sym++] = 7;
+		while (sym < 288) state.lens[sym++] = 8;
+		inftrees(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
+		sym = 0;
+		while (sym < 32) state.lens[sym++] = 5;
+		inftrees(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
+		virgin = false;
+	}
+	state.lencode = lenfix;
+	state.lenbits = 9;
+	state.distcode = distfix;
+	state.distbits = 5;
+};
+const updatewindow = (strm, src, end, copy) => {
+	let dist;
+	const state = strm.state;
+	if (state.window === null) {
+		state.wsize = 1 << state.wbits;
+		state.wnext = 0;
+		state.whave = 0;
+		state.window = new Uint8Array(state.wsize);
+	}
+	if (copy >= state.wsize) {
+		state.window.set(src.subarray(end - state.wsize, end), 0);
+		state.wnext = 0;
+		state.whave = state.wsize;
+	} else {
+		dist = state.wsize - state.wnext;
+		if (dist > copy) dist = copy;
+		state.window.set(src.subarray(end - copy, end - copy + dist), state.wnext);
+		copy -= dist;
+		if (copy) {
+			state.window.set(src.subarray(end - copy, end), 0);
+			state.wnext = copy;
+			state.whave = state.wsize;
+		} else {
+			state.wnext += dist;
+			if (state.wnext === state.wsize) state.wnext = 0;
+			if (state.whave < state.wsize) state.whave += dist;
+		}
+	}
+	return 0;
+};
+const inflate$2 = (strm, flush) => {
+	let state;
+	let input, output;
+	let next;
+	let put;
+	let have, left;
+	let hold;
+	let bits;
+	let _in, _out;
+	let copy;
+	let from;
+	let from_source;
+	let here = 0;
+	let here_bits, here_op, here_val;
+	let last_bits, last_op, last_val;
+	let len;
+	let ret;
+	const hbuf = new Uint8Array(4);
+	let opts;
+	let n;
+	const order = new Uint8Array([
+		16,
+		17,
+		18,
+		0,
+		8,
+		7,
+		9,
+		6,
+		10,
+		5,
+		11,
+		4,
+		12,
+		3,
+		13,
+		2,
+		14,
+		1,
+		15
+	]);
+	if (inflateStateCheck(strm) || !strm.output || !strm.input && strm.avail_in !== 0) return Z_STREAM_ERROR$1;
+	state = strm.state;
+	if (state.mode === TYPE) state.mode = TYPEDO;
+	put = strm.next_out;
+	output = strm.output;
+	left = strm.avail_out;
+	next = strm.next_in;
+	input = strm.input;
+	have = strm.avail_in;
+	hold = state.hold;
+	bits = state.bits;
+	_in = have;
+	_out = left;
+	ret = Z_OK$1;
+	inf_leave: for (;;) switch (state.mode) {
+		case HEAD:
+			if (state.wrap === 0) {
+				state.mode = TYPEDO;
+				break;
+			}
+			while (bits < 16) {
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			if (state.wrap & 2 && hold === 35615) {
+				if (state.wbits === 0) state.wbits = 15;
+				state.check = 0;
+				hbuf[0] = hold & 255;
+				hbuf[1] = hold >>> 8 & 255;
+				state.check = crc32_1(state.check, hbuf, 2, 0);
+				hold = 0;
+				bits = 0;
+				state.mode = FLAGS;
+				break;
+			}
+			if (state.head) state.head.done = false;
+			if (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) {
+				strm.msg = "incorrect header check";
+				state.mode = BAD;
+				break;
+			}
+			if ((hold & 15) !== Z_DEFLATED) {
+				strm.msg = "unknown compression method";
+				state.mode = BAD;
+				break;
+			}
+			hold >>>= 4;
+			bits -= 4;
+			len = (hold & 15) + 8;
+			if (state.wbits === 0) state.wbits = len;
+			if (len > 15 || len > state.wbits) {
+				strm.msg = "invalid window size";
+				state.mode = BAD;
+				break;
+			}
+			state.dmax = 1 << state.wbits;
+			state.flags = 0;
+			strm.adler = state.check = 1;
+			state.mode = hold & 512 ? DICTID : TYPE;
+			hold = 0;
+			bits = 0;
+			break;
+		case FLAGS:
+			while (bits < 16) {
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			state.flags = hold;
+			if ((state.flags & 255) !== Z_DEFLATED) {
+				strm.msg = "unknown compression method";
+				state.mode = BAD;
+				break;
+			}
+			if (state.flags & 57344) {
+				strm.msg = "unknown header flags set";
+				state.mode = BAD;
+				break;
+			}
+			if (state.head) state.head.text = hold >> 8 & 1;
+			if (state.flags & 512 && state.wrap & 4) {
+				hbuf[0] = hold & 255;
+				hbuf[1] = hold >>> 8 & 255;
+				state.check = crc32_1(state.check, hbuf, 2, 0);
+			}
+			hold = 0;
+			bits = 0;
+			state.mode = TIME;
+		case TIME:
+			while (bits < 32) {
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			if (state.head) state.head.time = hold;
+			if (state.flags & 512 && state.wrap & 4) {
+				hbuf[0] = hold & 255;
+				hbuf[1] = hold >>> 8 & 255;
+				hbuf[2] = hold >>> 16 & 255;
+				hbuf[3] = hold >>> 24 & 255;
+				state.check = crc32_1(state.check, hbuf, 4, 0);
+			}
+			hold = 0;
+			bits = 0;
+			state.mode = OS;
+		case OS:
+			while (bits < 16) {
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			if (state.head) {
+				state.head.xflags = hold & 255;
+				state.head.os = hold >> 8;
+			}
+			if (state.flags & 512 && state.wrap & 4) {
+				hbuf[0] = hold & 255;
+				hbuf[1] = hold >>> 8 & 255;
+				state.check = crc32_1(state.check, hbuf, 2, 0);
+			}
+			hold = 0;
+			bits = 0;
+			state.mode = EXLEN;
+		case EXLEN:
+			if (state.flags & 1024) {
+				while (bits < 16) {
+					if (have === 0) break inf_leave;
+					have--;
+					hold += input[next++] << bits;
+					bits += 8;
+				}
+				state.length = hold;
+				if (state.head) state.head.extra_len = hold;
+				if (state.flags & 512 && state.wrap & 4) {
+					hbuf[0] = hold & 255;
+					hbuf[1] = hold >>> 8 & 255;
+					state.check = crc32_1(state.check, hbuf, 2, 0);
+				}
+				hold = 0;
+				bits = 0;
+			} else if (state.head) state.head.extra = null;
+			state.mode = EXTRA;
+		case EXTRA:
+			if (state.flags & 1024) {
+				copy = state.length;
+				if (copy > have) copy = have;
+				if (copy) {
+					if (state.head) {
+						len = state.head.extra_len - state.length;
+						if (!state.head.extra) state.head.extra = new Uint8Array(state.head.extra_len);
+						state.head.extra.set(input.subarray(next, next + copy), len);
+					}
+					if (state.flags & 512 && state.wrap & 4) state.check = crc32_1(state.check, input, copy, next);
+					have -= copy;
+					next += copy;
+					state.length -= copy;
+				}
+				if (state.length) break inf_leave;
+			}
+			state.length = 0;
+			state.mode = NAME;
+		case NAME:
+			if (state.flags & 2048) {
+				if (have === 0) break inf_leave;
+				copy = 0;
+				do {
+					len = input[next + copy++];
+					if (state.head && len && state.length < 65536) state.head.name += String.fromCharCode(len);
+				} while (len && copy < have);
+				if (state.flags & 512 && state.wrap & 4) state.check = crc32_1(state.check, input, copy, next);
+				have -= copy;
+				next += copy;
+				if (len) break inf_leave;
+			} else if (state.head) state.head.name = null;
+			state.length = 0;
+			state.mode = COMMENT;
+		case COMMENT:
+			if (state.flags & 4096) {
+				if (have === 0) break inf_leave;
+				copy = 0;
+				do {
+					len = input[next + copy++];
+					if (state.head && len && state.length < 65536) state.head.comment += String.fromCharCode(len);
+				} while (len && copy < have);
+				if (state.flags & 512 && state.wrap & 4) state.check = crc32_1(state.check, input, copy, next);
+				have -= copy;
+				next += copy;
+				if (len) break inf_leave;
+			} else if (state.head) state.head.comment = null;
+			state.mode = HCRC;
+		case HCRC:
+			if (state.flags & 512) {
+				while (bits < 16) {
+					if (have === 0) break inf_leave;
+					have--;
+					hold += input[next++] << bits;
+					bits += 8;
+				}
+				if (state.wrap & 4 && hold !== (state.check & 65535)) {
+					strm.msg = "header crc mismatch";
+					state.mode = BAD;
+					break;
+				}
+				hold = 0;
+				bits = 0;
+			}
+			if (state.head) {
+				state.head.hcrc = state.flags >> 9 & 1;
+				state.head.done = true;
+			}
+			strm.adler = state.check = 0;
+			state.mode = TYPE;
+			break;
+		case DICTID:
+			while (bits < 32) {
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			strm.adler = state.check = zswap32(hold);
+			hold = 0;
+			bits = 0;
+			state.mode = DICT;
+		case DICT:
+			if (state.havedict === 0) {
+				strm.next_out = put;
+				strm.avail_out = left;
+				strm.next_in = next;
+				strm.avail_in = have;
+				state.hold = hold;
+				state.bits = bits;
+				return Z_NEED_DICT$1;
+			}
+			strm.adler = state.check = 1;
+			state.mode = TYPE;
+		case TYPE: if (flush === Z_BLOCK || flush === Z_TREES) break inf_leave;
+		case TYPEDO:
+			if (state.last) {
+				hold >>>= bits & 7;
+				bits -= bits & 7;
+				state.mode = CHECK;
+				break;
+			}
+			while (bits < 3) {
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			state.last = hold & 1;
+			hold >>>= 1;
+			bits -= 1;
+			switch (hold & 3) {
+				case 0:
+					state.mode = STORED;
+					break;
+				case 1:
+					fixedtables(state);
+					state.mode = LEN_;
+					if (flush === Z_TREES) {
+						hold >>>= 2;
+						bits -= 2;
+						break inf_leave;
+					}
+					break;
+				case 2:
+					state.mode = TABLE;
+					break;
+				case 3:
+					strm.msg = "invalid block type";
+					state.mode = BAD;
+			}
+			hold >>>= 2;
+			bits -= 2;
+			break;
+		case STORED:
+			hold >>>= bits & 7;
+			bits -= bits & 7;
+			while (bits < 32) {
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			if ((hold & 65535) !== (hold >>> 16 ^ 65535)) {
+				strm.msg = "invalid stored block lengths";
+				state.mode = BAD;
+				break;
+			}
+			state.length = hold & 65535;
+			hold = 0;
+			bits = 0;
+			state.mode = COPY_;
+			if (flush === Z_TREES) break inf_leave;
+		case COPY_: state.mode = COPY;
+		case COPY:
+			copy = state.length;
+			if (copy) {
+				if (copy > have) copy = have;
+				if (copy > left) copy = left;
+				if (copy === 0) break inf_leave;
+				output.set(input.subarray(next, next + copy), put);
+				have -= copy;
+				next += copy;
+				left -= copy;
+				put += copy;
+				state.length -= copy;
+				break;
+			}
+			state.mode = TYPE;
+			break;
+		case TABLE:
+			while (bits < 14) {
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			state.nlen = (hold & 31) + 257;
+			hold >>>= 5;
+			bits -= 5;
+			state.ndist = (hold & 31) + 1;
+			hold >>>= 5;
+			bits -= 5;
+			state.ncode = (hold & 15) + 4;
+			hold >>>= 4;
+			bits -= 4;
+			if (state.nlen > 286 || state.ndist > 30) {
+				strm.msg = "too many length or distance symbols";
+				state.mode = BAD;
+				break;
+			}
+			state.have = 0;
+			state.mode = LENLENS;
+		case LENLENS:
+			while (state.have < state.ncode) {
+				while (bits < 3) {
+					if (have === 0) break inf_leave;
+					have--;
+					hold += input[next++] << bits;
+					bits += 8;
+				}
+				state.lens[order[state.have++]] = hold & 7;
+				hold >>>= 3;
+				bits -= 3;
+			}
+			while (state.have < 19) state.lens[order[state.have++]] = 0;
+			state.lencode = state.lendyn;
+			state.lenbits = 7;
+			opts = { bits: state.lenbits };
+			ret = inftrees(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
+			state.lenbits = opts.bits;
+			if (ret) {
+				strm.msg = "invalid code lengths set";
+				state.mode = BAD;
+				break;
+			}
+			state.have = 0;
+			state.mode = CODELENS;
+		case CODELENS:
+			while (state.have < state.nlen + state.ndist) {
+				for (;;) {
+					here = state.lencode[hold & (1 << state.lenbits) - 1];
+					here_bits = here >>> 24;
+					here_op = here >>> 16 & 255;
+					here_val = here & 65535;
+					if (here_bits <= bits) break;
+					if (have === 0) break inf_leave;
+					have--;
+					hold += input[next++] << bits;
+					bits += 8;
+				}
+				if (here_val < 16) {
+					hold >>>= here_bits;
+					bits -= here_bits;
+					state.lens[state.have++] = here_val;
+				} else {
+					if (here_val === 16) {
+						n = here_bits + 2;
+						while (bits < n) {
+							if (have === 0) break inf_leave;
+							have--;
+							hold += input[next++] << bits;
+							bits += 8;
+						}
+						hold >>>= here_bits;
+						bits -= here_bits;
+						if (state.have === 0) {
+							strm.msg = "invalid bit length repeat";
+							state.mode = BAD;
+							break;
+						}
+						len = state.lens[state.have - 1];
+						copy = 3 + (hold & 3);
+						hold >>>= 2;
+						bits -= 2;
+					} else if (here_val === 17) {
+						n = here_bits + 3;
+						while (bits < n) {
+							if (have === 0) break inf_leave;
+							have--;
+							hold += input[next++] << bits;
+							bits += 8;
+						}
+						hold >>>= here_bits;
+						bits -= here_bits;
+						len = 0;
+						copy = 3 + (hold & 7);
+						hold >>>= 3;
+						bits -= 3;
+					} else {
+						n = here_bits + 7;
+						while (bits < n) {
+							if (have === 0) break inf_leave;
+							have--;
+							hold += input[next++] << bits;
+							bits += 8;
+						}
+						hold >>>= here_bits;
+						bits -= here_bits;
+						len = 0;
+						copy = 11 + (hold & 127);
+						hold >>>= 7;
+						bits -= 7;
+					}
+					if (state.have + copy > state.nlen + state.ndist) {
+						strm.msg = "invalid bit length repeat";
+						state.mode = BAD;
+						break;
+					}
+					while (copy--) state.lens[state.have++] = len;
+				}
+			}
+			if (state.mode === BAD) break;
+			if (state.lens[256] === 0) {
+				strm.msg = "invalid code -- missing end-of-block";
+				state.mode = BAD;
+				break;
+			}
+			state.lenbits = 9;
+			opts = { bits: state.lenbits };
+			ret = inftrees(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
+			state.lenbits = opts.bits;
+			if (ret) {
+				strm.msg = "invalid literal/lengths set";
+				state.mode = BAD;
+				break;
+			}
+			state.distbits = 6;
+			state.distcode = state.distdyn;
+			opts = { bits: state.distbits };
+			ret = inftrees(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
+			state.distbits = opts.bits;
+			if (ret) {
+				strm.msg = "invalid distances set";
+				state.mode = BAD;
+				break;
+			}
+			state.mode = LEN_;
+			if (flush === Z_TREES) break inf_leave;
+		case LEN_: state.mode = LEN;
+		case LEN:
+			if (have >= 6 && left >= 258) {
+				strm.next_out = put;
+				strm.avail_out = left;
+				strm.next_in = next;
+				strm.avail_in = have;
+				state.hold = hold;
+				state.bits = bits;
+				inffast(strm, _out);
+				put = strm.next_out;
+				output = strm.output;
+				left = strm.avail_out;
+				next = strm.next_in;
+				input = strm.input;
+				have = strm.avail_in;
+				hold = state.hold;
+				bits = state.bits;
+				if (state.mode === TYPE) state.back = -1;
+				break;
+			}
+			state.back = 0;
+			for (;;) {
+				here = state.lencode[hold & (1 << state.lenbits) - 1];
+				here_bits = here >>> 24;
+				here_op = here >>> 16 & 255;
+				here_val = here & 65535;
+				if (here_bits <= bits) break;
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			if (here_op && (here_op & 240) === 0) {
+				last_bits = here_bits;
+				last_op = here_op;
+				last_val = here_val;
+				for (;;) {
+					here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
+					here_bits = here >>> 24;
+					here_op = here >>> 16 & 255;
+					here_val = here & 65535;
+					if (last_bits + here_bits <= bits) break;
+					if (have === 0) break inf_leave;
+					have--;
+					hold += input[next++] << bits;
+					bits += 8;
+				}
+				hold >>>= last_bits;
+				bits -= last_bits;
+				state.back += last_bits;
+			}
+			hold >>>= here_bits;
+			bits -= here_bits;
+			state.back += here_bits;
+			state.length = here_val;
+			if (here_op === 0) {
+				state.mode = LIT;
+				break;
+			}
+			if (here_op & 32) {
+				state.back = -1;
+				state.mode = TYPE;
+				break;
+			}
+			if (here_op & 64) {
+				strm.msg = "invalid literal/length code";
+				state.mode = BAD;
+				break;
+			}
+			state.extra = here_op & 15;
+			state.mode = LENEXT;
+		case LENEXT:
+			if (state.extra) {
+				n = state.extra;
+				while (bits < n) {
+					if (have === 0) break inf_leave;
+					have--;
+					hold += input[next++] << bits;
+					bits += 8;
+				}
+				state.length += hold & (1 << state.extra) - 1;
+				hold >>>= state.extra;
+				bits -= state.extra;
+				state.back += state.extra;
+			}
+			state.was = state.length;
+			state.mode = DIST;
+		case DIST:
+			for (;;) {
+				here = state.distcode[hold & (1 << state.distbits) - 1];
+				here_bits = here >>> 24;
+				here_op = here >>> 16 & 255;
+				here_val = here & 65535;
+				if (here_bits <= bits) break;
+				if (have === 0) break inf_leave;
+				have--;
+				hold += input[next++] << bits;
+				bits += 8;
+			}
+			if ((here_op & 240) === 0) {
+				last_bits = here_bits;
+				last_op = here_op;
+				last_val = here_val;
+				for (;;) {
+					here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
+					here_bits = here >>> 24;
+					here_op = here >>> 16 & 255;
+					here_val = here & 65535;
+					if (last_bits + here_bits <= bits) break;
+					if (have === 0) break inf_leave;
+					have--;
+					hold += input[next++] << bits;
+					bits += 8;
+				}
+				hold >>>= last_bits;
+				bits -= last_bits;
+				state.back += last_bits;
+			}
+			hold >>>= here_bits;
+			bits -= here_bits;
+			state.back += here_bits;
+			if (here_op & 64) {
+				strm.msg = "invalid distance code";
+				state.mode = BAD;
+				break;
+			}
+			state.offset = here_val;
+			state.extra = here_op & 15;
+			state.mode = DISTEXT;
+		case DISTEXT:
+			if (state.extra) {
+				n = state.extra;
+				while (bits < n) {
+					if (have === 0) break inf_leave;
+					have--;
+					hold += input[next++] << bits;
+					bits += 8;
+				}
+				state.offset += hold & (1 << state.extra) - 1;
+				hold >>>= state.extra;
+				bits -= state.extra;
+				state.back += state.extra;
+			}
+			if (state.offset > state.dmax) {
+				strm.msg = "invalid distance too far back";
+				state.mode = BAD;
+				break;
+			}
+			state.mode = MATCH;
+		case MATCH:
+			if (left === 0) break inf_leave;
+			copy = _out - left;
+			if (state.offset > copy) {
+				copy = state.offset - copy;
+				if (copy > state.whave) {
+					if (state.sane) {
+						strm.msg = "invalid distance too far back";
+						state.mode = BAD;
+						break;
+					}
+				}
+				if (copy > state.wnext) {
+					copy -= state.wnext;
+					from = state.wsize - copy;
+				} else from = state.wnext - copy;
+				if (copy > state.length) copy = state.length;
+				from_source = state.window;
+			} else {
+				from_source = output;
+				from = put - state.offset;
+				copy = state.length;
+			}
+			if (copy > left) copy = left;
+			left -= copy;
+			state.length -= copy;
+			do
+				output[put++] = from_source[from++];
+			while (--copy);
+			if (state.length === 0) state.mode = LEN;
+			break;
+		case LIT:
+			if (left === 0) break inf_leave;
+			output[put++] = state.length;
+			left--;
+			state.mode = LEN;
+			break;
+		case CHECK:
+			if (state.wrap) {
+				while (bits < 32) {
+					if (have === 0) break inf_leave;
+					have--;
+					hold |= input[next++] << bits;
+					bits += 8;
+				}
+				_out -= left;
+				strm.total_out += _out;
+				state.total += _out;
+				if (state.wrap & 4 && _out) strm.adler = state.check = state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out);
+				_out = left;
+				if (state.wrap & 4 && (state.flags ? hold : zswap32(hold)) !== state.check) {
+					strm.msg = "incorrect data check";
+					state.mode = BAD;
+					break;
+				}
+				hold = 0;
+				bits = 0;
+			}
+			state.mode = LENGTH;
+		case LENGTH:
+			if (state.wrap && state.flags) {
+				while (bits < 32) {
+					if (have === 0) break inf_leave;
+					have--;
+					hold += input[next++] << bits;
+					bits += 8;
+				}
+				if (state.wrap & 4 && hold !== (state.total & 4294967295)) {
+					strm.msg = "incorrect length check";
+					state.mode = BAD;
+					break;
+				}
+				hold = 0;
+				bits = 0;
+			}
+			state.mode = DONE;
+		case DONE:
+			ret = Z_STREAM_END$1;
+			break inf_leave;
+		case BAD:
+			ret = Z_DATA_ERROR$1;
+			break inf_leave;
+		case MEM: return Z_MEM_ERROR$1;
+		case SYNC:
+		default: return Z_STREAM_ERROR$1;
+	}
+	strm.next_out = put;
+	strm.avail_out = left;
+	strm.next_in = next;
+	strm.avail_in = have;
+	state.hold = hold;
+	state.bits = bits;
+	if (state.wsize || _out !== strm.avail_out && state.mode < BAD && (state.mode < CHECK || flush !== Z_FINISH$1)) {
+		if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out));
+	}
+	_in -= strm.avail_in;
+	_out -= strm.avail_out;
+	strm.total_in += _in;
+	strm.total_out += _out;
+	state.total += _out;
+	if (state.wrap & 4 && _out) strm.adler = state.check = state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out);
+	strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
+	if ((_in === 0 && _out === 0 || flush === Z_FINISH$1) && ret === Z_OK$1) ret = Z_BUF_ERROR;
+	return ret;
+};
+const inflateEnd = (strm) => {
+	if (inflateStateCheck(strm)) return Z_STREAM_ERROR$1;
+	let state = strm.state;
+	if (state.window) state.window = null;
+	strm.state = null;
+	return Z_OK$1;
+};
+const inflateGetHeader = (strm, head) => {
+	if (inflateStateCheck(strm)) return Z_STREAM_ERROR$1;
+	const state = strm.state;
+	if ((state.wrap & 2) === 0) return Z_STREAM_ERROR$1;
+	state.head = head;
+	head.done = false;
+	return Z_OK$1;
+};
+const inflateSetDictionary = (strm, dictionary) => {
+	const dictLength = dictionary.length;
+	let state;
+	let dictid;
+	let ret;
+	if (inflateStateCheck(strm)) return Z_STREAM_ERROR$1;
+	state = strm.state;
+	if (state.wrap !== 0 && state.mode !== DICT) return Z_STREAM_ERROR$1;
+	if (state.mode === DICT) {
+		dictid = 1;
+		dictid = adler32_1(dictid, dictionary, dictLength, 0);
+		if (dictid !== state.check) return Z_DATA_ERROR$1;
+	}
+	ret = updatewindow(strm, dictionary, dictLength, dictLength);
+	if (ret) {
+		state.mode = MEM;
+		return Z_MEM_ERROR$1;
+	}
+	state.havedict = 1;
+	return Z_OK$1;
+};
+var inflate_1$2 = {
+	inflateReset,
+	inflateReset2,
+	inflateResetKeep,
+	inflateInit,
+	inflateInit2,
+	inflate: inflate$2,
+	inflateEnd,
+	inflateGetHeader,
+	inflateSetDictionary,
+	inflateInfo: "pako inflate (from Nodeca project)"
+};
+function GZheader() {
+	this.text = 0;
+	this.time = 0;
+	this.xflags = 0;
+	this.os = 0;
+	this.extra = null;
+	this.extra_len = 0;
+	this.name = "";
+	this.comment = "";
+	this.hcrc = 0;
+	this.done = false;
+}
+var gzheader = GZheader;
+const toString = Object.prototype.toString;
+const { Z_NO_FLUSH, Z_FINISH, Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR } = constants$2;
+/**
+* class Inflate
+*
+* Generic JS-style wrapper for zlib calls. If you don't need
+* streaming behaviour - use more simple functions: [[inflate]]
+* and [[inflateRaw]].
+**/
+/**
+* Inflate.result -> Uint8Array|String
+*
+* Uncompressed result, generated by default [[Inflate#onData]]
+* and [[Inflate#onEnd]] handlers. Filled after you push last chunk
+* (call [[Inflate#push]] with `Z_FINISH` / `true` param).
+**/
+/**
+* Inflate.err -> Number
+*
+* Error code after inflate finished. 0 (Z_OK) on success.
+* Should be checked if broken data possible.
+**/
+/**
+* Inflate.msg -> String
+*
+* Error message, if [[Inflate.err]] != 0
+**/
+/**
+* new Inflate(options)
+* - options (Object): zlib inflate options.
+*
+* Creates new inflator instance with specified params. Throws exception
+* on bad params. Supported options:
+*
+* - `windowBits`
+* - `dictionary`
+*
+* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+* for more information on these.
+*
+* Additional options, for internal needs:
+*
+* - `chunkSize` - size of generated data chunks (16K by default)
+* - `raw` (Boolean) - do raw inflate
+* - `to` (String) - if equal to 'string', then result will be converted
+*   from utf8 to utf16 (javascript) string. When string output requested,
+*   chunk length can differ from `chunkSize`, depending on content.
+*
+* By default, when no options set, autodetect deflate/gzip data format via
+* wrapper header.
+*
+* ##### Example:
+*
+* ```javascript
+* const pako = require('pako')
+* const chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])
+* const chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);
+*
+* const inflate = new pako.Inflate({ level: 3});
+*
+* inflate.push(chunk1, false);
+* inflate.push(chunk2, true);  // true -> last chunk
+*
+* if (inflate.err) { throw new Error(inflate.err); }
+*
+* console.log(inflate.result);
+* ```
+**/
+function Inflate$1(options) {
+	this.options = common.assign({
+		chunkSize: 1024 * 64,
+		windowBits: 15,
+		to: ""
+	}, options || {});
+	const opt = this.options;
+	if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) {
+		opt.windowBits = -opt.windowBits;
+		if (opt.windowBits === 0) opt.windowBits = -15;
+	}
+	if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) opt.windowBits += 32;
+	if (opt.windowBits > 15 && opt.windowBits < 48) {
+		if ((opt.windowBits & 15) === 0) opt.windowBits |= 15;
+	}
+	this.err = 0;
+	this.msg = "";
+	this.ended = false;
+	this.chunks = [];
+	this.strm = new zstream();
+	this.strm.avail_out = 0;
+	let status = inflate_1$2.inflateInit2(this.strm, opt.windowBits);
+	if (status !== Z_OK) throw new Error(messages[status]);
+	this.header = new gzheader();
+	inflate_1$2.inflateGetHeader(this.strm, this.header);
+	if (opt.dictionary) {
+		if (typeof opt.dictionary === "string") opt.dictionary = strings.string2buf(opt.dictionary);
+		else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") opt.dictionary = new Uint8Array(opt.dictionary);
+		if (opt.raw) {
+			status = inflate_1$2.inflateSetDictionary(this.strm, opt.dictionary);
+			if (status !== Z_OK) throw new Error(messages[status]);
+		}
+	}
+}
+/**
+* Inflate#push(data[, flush_mode]) -> Boolean
+* - data (Uint8Array|ArrayBuffer): input data
+* - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE
+*   flush modes. See constants. Skipped or `false` means Z_NO_FLUSH,
+*   `true` means Z_FINISH.
+*
+* Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
+* new output chunks. Returns `true` on success. If end of stream detected,
+* [[Inflate#onEnd]] will be called.
+*
+* `flush_mode` is not needed for normal operation, because end of stream
+* detected automatically. You may try to use it for advanced things, but
+* this functionality was not tested.
+*
+* On fail call [[Inflate#onEnd]] with error code and return false.
+*
+* ##### Example
+*
+* ```javascript
+* push(chunk, false); // push one of data chunks
+* ...
+* push(chunk, true);  // push last chunk
+* ```
+**/
+Inflate$1.prototype.push = function(data, flush_mode) {
+	const strm = this.strm;
+	const chunkSize = this.options.chunkSize;
+	const dictionary = this.options.dictionary;
+	let status, _flush_mode, last_avail_out;
+	if (this.ended) return false;
+	if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;
+	else _flush_mode = flush_mode === true ? Z_FINISH : Z_NO_FLUSH;
+	if (toString.call(data) === "[object ArrayBuffer]") strm.input = new Uint8Array(data);
+	else strm.input = data;
+	strm.next_in = 0;
+	strm.avail_in = strm.input.length;
+	for (;;) {
+		if (strm.avail_out === 0) {
+			strm.output = new Uint8Array(chunkSize);
+			strm.next_out = 0;
+			strm.avail_out = chunkSize;
+		}
+		status = inflate_1$2.inflate(strm, _flush_mode);
+		if (status === Z_NEED_DICT && dictionary) {
+			status = inflate_1$2.inflateSetDictionary(strm, dictionary);
+			if (status === Z_OK) status = inflate_1$2.inflate(strm, _flush_mode);
+			else if (status === Z_DATA_ERROR) status = Z_NEED_DICT;
+		}
+		while (strm.avail_in > 0 && status === Z_STREAM_END && strm.state.wrap > 0 && data[strm.next_in] !== 0) {
+			inflate_1$2.inflateReset(strm);
+			status = inflate_1$2.inflate(strm, _flush_mode);
+		}
+		switch (status) {
+			case Z_STREAM_ERROR:
+			case Z_DATA_ERROR:
+			case Z_NEED_DICT:
+			case Z_MEM_ERROR:
+				this.onEnd(status);
+				this.ended = true;
+				return false;
+		}
+		last_avail_out = strm.avail_out;
+		if (strm.next_out) {
+			if (strm.avail_out === 0 || status === Z_STREAM_END) if (this.options.to === "string") {
+				let next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
+				let tail = strm.next_out - next_out_utf8;
+				let utf8str = strings.buf2string(strm.output, next_out_utf8);
+				strm.next_out = tail;
+				strm.avail_out = chunkSize - tail;
+				if (tail) strm.output.set(strm.output.subarray(next_out_utf8, next_out_utf8 + tail), 0);
+				this.onData(utf8str);
+			} else this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out));
+		}
+		if (status === Z_OK && last_avail_out === 0) continue;
+		if (status === Z_STREAM_END) {
+			status = inflate_1$2.inflateEnd(this.strm);
+			this.onEnd(status);
+			this.ended = true;
+			return true;
+		}
+		if (strm.avail_in === 0) break;
+	}
+	return true;
+};
+/**
+* Inflate#onData(chunk) -> Void
+* - chunk (Uint8Array|String): output data. When string output requested,
+*   each chunk will be string.
+*
+* By default, stores data blocks in `chunks[]` property and glue
+* those in `onEnd`. Override this handler, if you need another behaviour.
+**/
+Inflate$1.prototype.onData = function(chunk) {
+	this.chunks.push(chunk);
+};
+/**
+* Inflate#onEnd(status) -> Void
+* - status (Number): inflate status. 0 (Z_OK) on success,
+*   other if not.
+*
+* Called either after you tell inflate that the input stream is
+* complete (Z_FINISH). By default - join collected chunks,
+* free memory and fill `results` / `err` properties.
+**/
+Inflate$1.prototype.onEnd = function(status) {
+	if (status === Z_OK) if (this.options.to === "string") this.result = this.chunks.join("");
+	else this.result = common.flattenChunks(this.chunks);
+	this.chunks = [];
+	this.err = status;
+	this.msg = this.strm.msg;
+};
+/**
+* inflate(data[, options]) -> Uint8Array|String
+* - data (Uint8Array|ArrayBuffer): input data to decompress.
+* - options (Object): zlib inflate options.
+*
+* Decompress `data` with inflate/ungzip and `options`. Autodetect
+* format via wrapper header by default. That's why we don't provide
+* separate `ungzip` method.
+*
+* Supported options are:
+*
+* - windowBits
+*
+* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+* for more information.
+*
+* Sugar (options):
+*
+* - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
+*   negative windowBits implicitly.
+* - `to` (String) - if equal to 'string', then result will be converted
+*   from utf8 to utf16 (javascript) string. When string output requested,
+*   chunk length can differ from `chunkSize`, depending on content.
+*
+*
+* ##### Example:
+*
+* ```javascript
+* const pako = require('pako');
+* const input = pako.deflate(new Uint8Array([1,2,3,4,5,6,7,8,9]));
+* let output;
+*
+* try {
+*   output = pako.inflate(input);
+* } catch (err) {
+*   console.log(err);
+* }
+* ```
+**/
+function inflate$1(input, options) {
+	const inflator = new Inflate$1(options);
+	inflator.push(input);
+	if (inflator.err) throw inflator.msg || messages[inflator.err];
+	return inflator.result;
+}
+/**
+* inflateRaw(data[, options]) -> Uint8Array|String
+* - data (Uint8Array|ArrayBuffer): input data to decompress.
+* - options (Object): zlib inflate options.
+*
+* The same as [[inflate]], but creates raw data, without wrapper
+* (header and adler32 crc).
+**/
+function inflateRaw$1(input, options) {
+	options = options || {};
+	options.raw = true;
+	return inflate$1(input, options);
+}
+var inflate_1$1 = {
+	Inflate: Inflate$1,
+	inflate: inflate$1,
+	inflateRaw: inflateRaw$1,
+	ungzip: inflate$1,
+	constants: constants$2
+};
+const { Deflate, deflate, deflateRaw, gzip } = deflate_1$1;
+const { Inflate, inflate, inflateRaw, ungzip } = inflate_1$1;
+var inflateRaw_1 = inflateRaw;
+
+//#endregion
+//#region src/utils/compression.ts
+/**
+* Decompress raw deflate data (no zlib header)
+* Equivalent to Python: zlib.decompress(data, -15)
+*
+* HWP files use raw deflate compression without zlib wrapper headers.
+* The windowBits=-15 in Python indicates raw deflate mode.
+*
+* @param data - Compressed data
+* @returns Decompressed data
+*/
+function decompressRaw(data) {
+	try {
+		return inflateRaw_1(data);
+	} catch (error) {
+		throw new Error(`Failed to decompress data: ${error.message}`);
+	}
+}
+
+//#endregion
+//#region src/parser.ts
+/**
+* HWP 5.0 File Parser
+* Parses OLE Compound File format HWP files
+*/
+/**
+* HWP File Parser
+* Reads and parses HWP 5.0 files using OLE Compound File format
+*/
+var HWPFile = class HWPFile {
+	cfb = null;
+	_fileHeader = null;
+	_isCompressed = false;
+	/**
+	* Create HWPFile from raw data
+	* @param data - Raw HWP file data
+	*/
+	constructor(data) {
+		this.data = data;
+	}
+	/**
+	* Create HWPFile from file path (Node.js only)
+	* @param path - Path to HWP file
+	*/
+	static async fromFile(path) {
+		const data = await (await import("node:fs/promises")).readFile(path);
+		return new HWPFile(new Uint8Array(data));
+	}
+	/**
+	* Create HWPFile from ArrayBuffer
+	* @param data - ArrayBuffer data
+	*/
+	static fromArrayBuffer(data) {
+		return new HWPFile(new Uint8Array(data));
+	}
+	/**
+	* Create HWPFile from Uint8Array
+	* @param data - Uint8Array data
+	*/
+	static fromUint8Array(data) {
+		return new HWPFile(data);
+	}
+	/**
+	* Open and parse HWP file
+	*/
+	open() {
+		const uint8Array = this.data instanceof Uint8Array ? this.data : new Uint8Array(this.data);
+		if (uint8Array.length >= 30) {
+			if (new TextDecoder("utf-8").decode(uint8Array.slice(0, 30)).replace(/\0+$/, "").startsWith("HWP Document File V3")) throw new Error("HWP 3.0 format (HWP 97, 2002, etc.) is not supported. Please use HWP 5.0 or later format. You can convert HWP 3.0 files to HWP 5.0 format using Hancom Office.");
+		}
+		try {
+			if (typeof Buffer !== "undefined") {
+				const buffer = Buffer.from(uint8Array);
+				this.cfb = CFB.read(buffer, { type: "buffer" });
+			} else {
+				const buffer = Array.from(uint8Array);
+				this.cfb = CFB.read(buffer, { type: "array" });
+			}
+		} catch (error) {
+			throw new Error(`Failed to parse HWP file: ${error.message}`);
+		}
+		this._fileHeader = this.parseFileHeader();
+		this._isCompressed = this._fileHeader.isCompressed;
+	}
+	/**
+	* Close HWP file and release resources
+	*/
+	close() {
+		this.cfb = null;
+		this._fileHeader = null;
+	}
+	/**
+	* Get file header information
+	*/
+	get fileHeader() {
+		return this._fileHeader;
+	}
+	/**
+	* Check if file is compressed
+	*/
+	get isCompressed() {
+		return this._isCompressed;
+	}
+	/**
+	* Parse FileHeader stream (256 bytes fixed)
+	*/
+	parseFileHeader() {
+		if (!this.cfb) throw new Error("HWP file not opened");
+		const entry = CFB.find(this.cfb, "FileHeader");
+		if (!entry) throw new Error("FileHeader not found in HWP file");
+		const data = entry.content;
+		if (data.length !== 256) throw new Error(`Invalid FileHeader size: ${data.length} (expected 256)`);
+		const signatureBytes = data.slice(0, 32);
+		const signature = new TextDecoder("utf-8").decode(signatureBytes).replace(/\0+$/, "");
+		if (!signature.startsWith("HWP Document File")) throw new Error(`Invalid HWP signature: ${signature}`);
+		const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+		const versionRaw = view.getUint32(32, true);
+		const major = versionRaw >> 24 & 255;
+		const minor = versionRaw >> 16 & 255;
+		const patch = versionRaw >> 8 & 255;
+		const rev = versionRaw & 255;
+		const properties = view.getUint32(36, true);
+		const isCompressed = Boolean(properties & 1);
+		const isEncrypted = Boolean(properties & 2);
+		return {
+			signature,
+			version: `${major}.${minor}.${patch}.${rev}`,
+			isCompressed,
+			isEncrypted,
+			rawProperties: properties
+		};
+	}
+	/**
+	* Read and decompress stream
+	* @param streamPath - Stream path (e.g., 'DocInfo', 'BodyText/Section0')
+	* @returns Decompressed data or null if stream doesn't exist
+	*/
+	readStream(streamPath) {
+		if (!this.cfb) return null;
+		const entry = CFB.find(this.cfb, streamPath);
+		if (!entry) return null;
+		let data = entry.content;
+		if (this._isCompressed) try {
+			data = decompressRaw(data);
+		} catch (error) {
+			throw new Error(`Failed to decompress ${streamPath}: ${error.message}`);
+		}
+		return data;
+	}
+	/**
+	* List all streams in HWP file
+	* @returns Array of stream paths
+	*/
+	listStreams() {
+		if (!this.cfb) return [];
+		const streams = [];
+		for (const entry of this.cfb.FileIndex) if (entry.type === 2) {
+			const path = entry.name.split("/").filter((p) => p);
+			if (path.length > 0) streams.push(path);
+		}
+		return streams;
+	}
+	/**
+	* Get file information
+	*/
+	getFileInfo() {
+		if (!this._fileHeader) return {};
+		return {
+			signature: this._fileHeader.signature,
+			version: this._fileHeader.version,
+			compressed: this._isCompressed,
+			encrypted: this._fileHeader.isEncrypted,
+			streams: this.listStreams()
+		};
+	}
+	/**
+	* Get number of sections in BodyText
+	*/
+	getSectionCount() {
+		if (!this.cfb) return 0;
+		let count = 0;
+		while (CFB.find(this.cfb, `BodyText/Section${count}`) || CFB.find(this.cfb, `Section${count}`)) count++;
+		return count;
+	}
+	/**
+	* Read section data
+	* @param sectionIndex - Section index (0-based)
+	* @returns Decompressed section data
+	*/
+	readSection(sectionIndex) {
+		let data = this.readStream(`BodyText/Section${sectionIndex}`);
+		if (!data) data = this.readStream(`Section${sectionIndex}`);
+		return data;
+	}
+};
+
+//#endregion
+//#region src/record.ts
+const HWPTAG_BEGIN = 16;
+const HWPTAG_PARA_HEADER = HWPTAG_BEGIN + 50;
+const HWPTAG_PARA_TEXT = HWPTAG_BEGIN + 51;
+const HWPTAG_PARA_CHAR_SHAPE = HWPTAG_BEGIN + 52;
+const HWPTAG_PARA_LINE_SEG = HWPTAG_BEGIN + 53;
+const HWPTAG_PARA_RANGE_TAG = HWPTAG_BEGIN + 54;
+const HWPTAG_CTRL_HEADER = HWPTAG_BEGIN + 55;
+const HWPTAG_LIST_HEADER = HWPTAG_BEGIN + 56;
+const HWPTAG_PAGE_DEF = HWPTAG_BEGIN + 57;
+const HWPTAG_FOOTNOTE_SHAPE = HWPTAG_BEGIN + 58;
+const HWPTAG_PAGE_BORDER_FILL = HWPTAG_BEGIN + 59;
+const HWPTAG_SHAPE_COMPONENT = HWPTAG_BEGIN + 60;
+const HWPTAG_TABLE = HWPTAG_BEGIN + 61;
+const HWPTAG_SHAPE_COMPONENT_LINE = HWPTAG_BEGIN + 62;
+const HWPTAG_CTRL_DATA = HWPTAG_BEGIN + 71;
+/**
+* HWP Record Reader
+* Reads binary records from HWP stream data
+*/
+var RecordReader = class {
+	data;
+	offset = 0;
+	constructor(data) {
+		this.data = data;
+	}
+	/**
+	* Check if there are more records to read
+	*/
+	hasMore() {
+		return this.offset < this.data.length;
+	}
+	/**
+	* Read next record
+	* @returns Next record, or null if no more records
+	*/
+	readRecord() {
+		if (this.offset + 4 > this.data.length) return null;
+		const header = new DataView(this.data.buffer, this.data.byteOffset + this.offset, 4).getUint32(0, true);
+		const tagId = header & 1023;
+		const level = header >> 10 & 1023;
+		let size = header >> 20 & 4095;
+		let dataOffset = this.offset + 4;
+		if (size === 4095) {
+			if (dataOffset + 4 > this.data.length) return null;
+			size = new DataView(this.data.buffer, this.data.byteOffset + dataOffset, 4).getUint32(0, true);
+			dataOffset += 4;
+		}
+		if (dataOffset + size > this.data.length) return null;
+		const recordData = this.data.slice(dataOffset, dataOffset + size);
+		this.offset = dataOffset + size;
+		return {
+			tagId,
+			level,
+			data: recordData,
+			size
+		};
+	}
+	/**
+	* Peek at next record header without consuming it
+	* @returns Header info with tagId, level, size
+	*/
+	peekRecordHeader() {
+		if (this.offset + 4 > this.data.length) return null;
+		const header = new DataView(this.data.buffer, this.data.byteOffset + this.offset, 4).getUint32(0, true);
+		const tagId = header & 1023;
+		const level = header >> 10 & 1023;
+		let size = header >> 20 & 4095;
+		let dataOffset = this.offset + 4;
+		if (size === 4095) {
+			if (dataOffset + 4 > this.data.length) return null;
+			size = new DataView(this.data.buffer, this.data.byteOffset + dataOffset, 4).getUint32(0, true);
+		}
+		return {
+			tagId,
+			level,
+			size
+		};
+	}
+	/**
+	* Read all records (considering hierarchy)
+	* @param parentLevel - Stop when reaching this level or below
+	* @returns All records at current level
+	*/
+	readAllRecords(parentLevel) {
+		const records = [];
+		while (this.hasMore()) {
+			const header = this.peekRecordHeader();
+			if (!header) break;
+			if (parentLevel !== void 0 && header.level <= parentLevel) break;
+			const record = this.readRecord();
+			if (record) records.push(record);
+		}
+		return records;
+	}
+	/**
+	* Get current position
+	*/
+	get position() {
+		return this.offset;
+	}
+	/**
+	* Get remaining bytes
+	*/
+	get remaining() {
+		return this.data.length - this.offset;
+	}
+};
+
+//#endregion
+//#region src/table.ts
+/**
+* HWP Table Parser
+* Parses table records and converts to Markdown
+*/
+/**
+* Parse table properties from TABLE record data
+* @param data - TABLE record data
+* @returns Table properties with rows, cols
+*/
+function parseTableProperties(data) {
+	if (data.length < 8) throw new Error(`Invalid TABLE record size: ${data.length}`);
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	return {
+		properties: view.getUint32(0, true),
+		rows: view.getUint16(4, true),
+		cols: view.getUint16(6, true)
+	};
+}
+/**
+* Parse table from TABLE record and subsequent records
+* @param tableRecordData - TABLE record data
+* @param reader - Record reader for reading cell data
+* @param lineBreakStyle - How to handle line breaks in cells
+* @returns Parsed table
+*/
+function parseTable(tableRecordData, reader, lineBreakStyle = "space") {
+	const props = parseTableProperties(tableRecordData);
+	const rows = props.rows;
+	const cols = props.cols;
+	const cells = [];
+	let cellIndex = 0;
+	while (reader.hasMore() && cellIndex < rows * cols) {
+		const header = reader.peekRecordHeader();
+		if (!header) break;
+		if (header.level < 2) break;
+		if (header.tagId === HWPTAG_LIST_HEADER) {
+			const listRecord = reader.readRecord();
+			if (!listRecord) break;
+			let row, col, colspan, rowspan;
+			if (listRecord.data.length >= 16) {
+				const view = new DataView(listRecord.data.buffer, listRecord.data.byteOffset, listRecord.data.byteLength);
+				col = view.getUint16(8, true);
+				row = view.getUint16(10, true);
+				colspan = view.getUint16(12, true);
+				rowspan = view.getUint16(14, true);
+				if (colspan === 0) colspan = 1;
+				if (rowspan === 0) rowspan = 1;
+			} else {
+				row = Math.floor(cellIndex / cols);
+				col = cellIndex % cols;
+				colspan = 1;
+				rowspan = 1;
+			}
+			const textParts = [];
+			while (reader.hasMore()) {
+				const paraHeader = reader.peekRecordHeader();
+				if (!paraHeader) break;
+				if (paraHeader.tagId === HWPTAG_LIST_HEADER) break;
+				if (paraHeader.level < 2) break;
+				if (paraHeader.tagId === HWPTAG_PARA_HEADER) {
+					const paraRec = reader.readRecord();
+					if (!paraRec) break;
+					if (paraRec.data.length >= 4) {
+						const nchars = new DataView(paraRec.data.buffer, paraRec.data.byteOffset, paraRec.data.byteLength).getUint32(0, true) & 2147483647;
+						if (nchars > 0 && reader.hasMore()) {
+							const nextH = reader.peekRecordHeader();
+							if (nextH && nextH.tagId === HWPTAG_PARA_TEXT) {
+								const textRec = reader.readRecord();
+								if (textRec) {
+									const text = processControlChars(parseParaText(textRec.data, nchars)).text;
+									if (text.trim()) textParts.push(text.trim());
+								}
+							}
+						}
+					}
+				} else reader.readRecord();
+			}
+			let cellText;
+			if (lineBreakStyle === "br") {
+				cellText = textParts.join("<br>");
+				cellText = cellText.replace(/\n/g, "<br>");
+			} else {
+				cellText = textParts.join(" ");
+				cellText = cellText.replace(/\n/g, " ");
+			}
+			const cell = {
+				row,
+				col,
+				rowspan,
+				colspan,
+				text: cellText
+			};
+			cells.push(cell);
+			cellIndex++;
+		} else reader.readRecord();
+	}
+	return {
+		rows,
+		cols,
+		cells
+	};
+}
+/**
+* Convert table to Markdown
+* @param table - Table object
+* @param mergeStrategy - 'repeat' (default) or 'blank'
+* @returns Markdown table
+*/
+function tableToMarkdown(table, mergeStrategy = "repeat") {
+	const { rows, cols, cells } = table;
+	const matrix = Array.from({ length: rows }, () => Array(cols).fill(""));
+	for (const cell of cells) if (mergeStrategy === "repeat") {
+		for (let r = cell.row; r < cell.row + cell.rowspan; r++) for (let c = cell.col; c < cell.col + cell.colspan; c++) if (r < rows && c < cols) matrix[r][c] = cell.text;
+	} else if (cell.row < rows && cell.col < cols) matrix[cell.row][cell.col] = cell.text;
+	const lines = [];
+	if (rows === 0 || cols === 0) return "[Empty Table]";
+	lines.push("| " + Array(cols).fill("").join(" | ") + " |");
+	lines.push("| " + Array(cols).fill("---").join(" | ") + " |");
+	for (const row of matrix) lines.push("| " + row.join(" | ") + " |");
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/paragraph.ts
+/**
+* HWP Paragraph Parser
+* Parses paragraph records and extracts text
+*/
+/**
+* Parse paragraph header
+* @param data - PARA_HEADER record data
+* @returns Paragraph header information
+*/
+function parseParaHeader(data) {
+	if (data.length < 22) throw new Error(`Invalid PARA_HEADER size: ${data.length}`);
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	return {
+		textCount: view.getUint32(0, true) & 2147483647,
+		controlMask: view.getUint32(4, true),
+		paraShapeId: view.getUint16(8, true),
+		styleId: view.getUint8(10),
+		columnType: view.getUint8(11),
+		charShapeCount: view.getUint16(12, true)
+	};
+}
+/**
+* Parse paragraph text with control info table
+*
+* PARA_TEXT structure:
+* [Control info table: 16 bytes per control] + [Actual text]
+*
+* Each control info block (16 bytes):
+* - 2 bytes: control code
+* - 4 bytes: control ID
+* - 8 bytes: control data
+* - 2 bytes: control code (repeated)
+*
+* @param data - PARA_TEXT record data
+* @param nchars - Number of WCHAR characters (control table + text)
+* @returns Decoded text
+*/
+function parseParaText(data, _nchars) {
+	const CHAR_CONTROLS = new Set([
+		0,
+		10,
+		13,
+		30,
+		31
+	]);
+	let offset = 0;
+	while (offset + 2 <= data.length) {
+		const charCode = new DataView(data.buffer, data.byteOffset + offset, 2).getUint16(0, true);
+		if (charCode < 32 && !CHAR_CONTROLS.has(charCode)) {
+			offset += 16;
+			if (offset > data.length) break;
+		} else break;
+	}
+	const textData = data.slice(offset);
+	if (textData.length === 0) return "";
+	try {
+		return new TextDecoder("utf-16le").decode(textData);
+	} catch (error) {
+		return "";
+	}
+}
+/**
+* Process control characters in text
+* @param text - Raw text with control characters
+* @returns Processed text and has_table flag
+*/
+function processControlChars(text) {
+	const result = [];
+	let hasTable = false;
+	for (const char of text) {
+		const code = char.codePointAt(0) ?? 0;
+		if (code < 32) {
+			if (code === 10) result.push("\n");
+			else if (code === 11) hasTable = true;
+			else if (code === 13) result.push("\n");
+		} else result.push(char);
+	}
+	return {
+		text: result.join(""),
+		hasTable
+	};
+}
+/**
+* Paragraph Parser
+* Parses paragraphs from HWP record stream
+*/
+var ParagraphParser = class {
+	constructor(reader, options = {}) {
+		this.reader = reader;
+		this.options = options;
+		if (!this.options.tableLineBreakStyle) this.options.tableLineBreakStyle = "space";
+	}
+	/**
+	* Parse next paragraph
+	* @returns Parsed paragraph, or null if no more paragraphs
+	*/
+	parseParagraph() {
+		if (!this.reader.hasMore()) return null;
+		let record = null;
+		while (this.reader.hasMore()) {
+			record = this.reader.readRecord();
+			if (record && record.tagId === HWPTAG_PARA_HEADER) break;
+			record = null;
+		}
+		if (!record) return null;
+		const header = parseParaHeader(record.data);
+		let text = "";
+		if (header.textCount > 0) {
+			const nextHeader = this.reader.peekRecordHeader();
+			if (nextHeader && nextHeader.tagId === HWPTAG_PARA_TEXT) {
+				record = this.reader.readRecord();
+				if (record) text = processControlChars(parseParaText(record.data, header.textCount)).text;
+			}
+		}
+		const tables = [];
+		while (this.reader.hasMore()) {
+			const nextHeader = this.reader.peekRecordHeader();
+			if (!nextHeader) break;
+			if (nextHeader.tagId === HWPTAG_PARA_HEADER) break;
+			if (nextHeader.level === 0) break;
+			if (nextHeader.tagId === HWPTAG_CTRL_HEADER) {
+				this.reader.readRecord();
+				const tableHeader = this.reader.peekRecordHeader();
+				if (tableHeader && tableHeader.tagId === HWPTAG_TABLE) {
+					const tableRecord = this.reader.readRecord();
+					if (tableRecord) try {
+						const tableMd = tableToMarkdown(parseTable(tableRecord.data, this.reader, this.options.tableLineBreakStyle));
+						tables.push(tableMd);
+					} catch (error) {
+						console.warn("Warning: Failed to parse table:", error);
+						tables.push("[TABLE - Parse Error]");
+					}
+				}
+			} else this.reader.readRecord();
+		}
+		if (tables.length > 0) {
+			text = text.trimEnd();
+			if (text.length > 0 && text.length < 5 && [...text].every((c) => {
+				return (c.codePointAt(0) ?? 0) > 127 || /\s/.test(c);
+			})) text = tables.join("\n\n");
+			else {
+				if (text) text += "\n\n";
+				text += tables.join("\n\n");
+			}
+		}
+		return {
+			text,
+			header
+		};
+	}
+	/**
+	* Parse all paragraphs in section
+	* @returns All paragraphs
+	*/
+	parseAllParagraphs() {
+		const paragraphs = [];
+		while (this.reader.hasMore()) {
+			const para = this.parseParagraph();
+			if (para) paragraphs.push(para);
+			else break;
+		}
+		return paragraphs;
+	}
+};
+
+//#endregion
+//#region src/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 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 = 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
+export { HWPFile as a, paragraphsToMarkdown as i, convertHwpToMarkdown as n, convertHwpxToMarkdown as r, convert as t };
+//# sourceMappingURL=converter-D6LrZNSL.mjs.map