@urban-toolkit/autk-db 2.0.0

package/dist/pako.esm-Crx1NgSq.js

@@ -0,0 +1,1447 @@
+//#region node_modules/pako/dist/pako.esm.mjs
+var e = 4, t = 0, n = 1, r = 2;
+function i(e) {
+	let t = e.length;
+	for (; --t >= 0;) e[t] = 0;
+}
+var a = 0, o = 1, s = 2, c = 3, l = 258, u = 29, d = 256, f = d + 1 + u, p = 30, m = 19, h = 2 * f + 1, g = 15, _ = 16, v = 7, y = 256, b = 16, x = 17, S = 18, C = 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
+]), w = 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
+]), T = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	2,
+	3,
+	7
+]), E = new Uint8Array([
+	16,
+	17,
+	18,
+	0,
+	8,
+	7,
+	9,
+	6,
+	10,
+	5,
+	11,
+	4,
+	12,
+	3,
+	13,
+	2,
+	14,
+	1,
+	15
+]), D = 512, O = Array((f + 2) * 2);
+i(O);
+var ee = Array(p * 2);
+i(ee);
+var k = Array(D);
+i(k);
+var A = Array(l - c + 1);
+i(A);
+var te = Array(u);
+i(te);
+var ne = Array(p);
+i(ne);
+function re(e, t, n, r, i) {
+	this.static_tree = e, this.extra_bits = t, this.extra_base = n, this.elems = r, this.max_length = i, this.has_stree = e && e.length;
+}
+var ie, ae, oe;
+function se(e, t) {
+	this.dyn_tree = e, this.max_code = 0, this.stat_desc = t;
+}
+var ce = (e) => e < 256 ? k[e] : k[256 + (e >>> 7)], le = (e, t) => {
+	e.pending_buf[e.pending++] = t & 255, e.pending_buf[e.pending++] = t >>> 8 & 255;
+}, j = (e, t, n) => {
+	e.bi_valid > _ - n ? (e.bi_buf |= t << e.bi_valid & 65535, le(e, e.bi_buf), e.bi_buf = t >> _ - e.bi_valid, e.bi_valid += n - _) : (e.bi_buf |= t << e.bi_valid & 65535, e.bi_valid += n);
+}, M = (e, t, n) => {
+	j(e, n[t * 2], n[t * 2 + 1]);
+}, ue = (e, t) => {
+	let n = 0;
+	do
+		n |= e & 1, e >>>= 1, n <<= 1;
+	while (--t > 0);
+	return n >>> 1;
+}, de = (e) => {
+	e.bi_valid === 16 ? (le(e, e.bi_buf), e.bi_buf = 0, e.bi_valid = 0) : e.bi_valid >= 8 && (e.pending_buf[e.pending++] = e.bi_buf & 255, e.bi_buf >>= 8, e.bi_valid -= 8);
+}, fe = (e, t) => {
+	let n = t.dyn_tree, r = t.max_code, i = t.stat_desc.static_tree, a = t.stat_desc.has_stree, o = t.stat_desc.extra_bits, s = t.stat_desc.extra_base, c = t.stat_desc.max_length, l, u, d, f, p, m, _ = 0;
+	for (f = 0; f <= g; f++) e.bl_count[f] = 0;
+	for (n[e.heap[e.heap_max] * 2 + 1] = 0, l = e.heap_max + 1; l < h; l++) u = e.heap[l], f = n[n[u * 2 + 1] * 2 + 1] + 1, f > c && (f = c, _++), n[u * 2 + 1] = f, !(u > r) && (e.bl_count[f]++, p = 0, u >= s && (p = o[u - s]), m = n[u * 2], e.opt_len += m * (f + p), a && (e.static_len += m * (i[u * 2 + 1] + p)));
+	if (_ !== 0) {
+		do {
+			for (f = c - 1; e.bl_count[f] === 0;) f--;
+			e.bl_count[f]--, e.bl_count[f + 1] += 2, e.bl_count[c]--, _ -= 2;
+		} while (_ > 0);
+		for (f = c; f !== 0; f--) for (u = e.bl_count[f]; u !== 0;) d = e.heap[--l], !(d > r) && (n[d * 2 + 1] !== f && (e.opt_len += (f - n[d * 2 + 1]) * n[d * 2], n[d * 2 + 1] = f), u--);
+	}
+}, pe = (e, t, n) => {
+	let r = Array(g + 1), i = 0, a, o;
+	for (a = 1; a <= g; a++) i = i + n[a - 1] << 1, r[a] = i;
+	for (o = 0; o <= t; o++) {
+		let t = e[o * 2 + 1];
+		t !== 0 && (e[o * 2] = ue(r[t]++, t));
+	}
+}, me = () => {
+	let e, t, n, r, i, a = Array(g + 1);
+	for (n = 0, r = 0; r < u - 1; r++) for (te[r] = n, e = 0; e < 1 << C[r]; e++) A[n++] = r;
+	for (A[n - 1] = r, i = 0, r = 0; r < 16; r++) for (ne[r] = i, e = 0; e < 1 << w[r]; e++) k[i++] = r;
+	for (i >>= 7; r < p; r++) for (ne[r] = i << 7, e = 0; e < 1 << w[r] - 7; e++) k[256 + i++] = r;
+	for (t = 0; t <= g; t++) a[t] = 0;
+	for (e = 0; e <= 143;) O[e * 2 + 1] = 8, e++, a[8]++;
+	for (; e <= 255;) O[e * 2 + 1] = 9, e++, a[9]++;
+	for (; e <= 279;) O[e * 2 + 1] = 7, e++, a[7]++;
+	for (; e <= 287;) O[e * 2 + 1] = 8, e++, a[8]++;
+	for (pe(O, f + 1, a), e = 0; e < p; e++) ee[e * 2 + 1] = 5, ee[e * 2] = ue(e, 5);
+	ie = new re(O, C, d + 1, f, g), ae = new re(ee, w, 0, p, g), oe = new re([], T, 0, m, v);
+}, he = (e) => {
+	let t;
+	for (t = 0; t < f; t++) e.dyn_ltree[t * 2] = 0;
+	for (t = 0; t < p; t++) e.dyn_dtree[t * 2] = 0;
+	for (t = 0; t < m; t++) e.bl_tree[t * 2] = 0;
+	e.dyn_ltree[y * 2] = 1, e.opt_len = e.static_len = 0, e.sym_next = e.matches = 0;
+}, ge = (e) => {
+	e.bi_valid > 8 ? le(e, e.bi_buf) : e.bi_valid > 0 && (e.pending_buf[e.pending++] = e.bi_buf), e.bi_buf = 0, e.bi_valid = 0;
+}, _e = (e, t, n, r) => {
+	let i = t * 2, a = n * 2;
+	return e[i] < e[a] || e[i] === e[a] && r[t] <= r[n];
+}, ve = (e, t, n) => {
+	let r = e.heap[n], i = n << 1;
+	for (; i <= e.heap_len && (i < e.heap_len && _e(t, e.heap[i + 1], e.heap[i], e.depth) && i++, !_e(t, r, e.heap[i], e.depth));) e.heap[n] = e.heap[i], n = i, i <<= 1;
+	e.heap[n] = r;
+}, ye = (e, t, n) => {
+	let r, i, a = 0, o, s;
+	if (e.sym_next !== 0) do
+		r = e.pending_buf[e.sym_buf + a++] & 255, r += (e.pending_buf[e.sym_buf + a++] & 255) << 8, i = e.pending_buf[e.sym_buf + a++], r === 0 ? M(e, i, t) : (o = A[i], M(e, o + d + 1, t), s = C[o], s !== 0 && (i -= te[o], j(e, i, s)), r--, o = ce(r), M(e, o, n), s = w[o], s !== 0 && (r -= ne[o], j(e, r, s)));
+	while (a < e.sym_next);
+	M(e, y, t);
+}, be = (e, t) => {
+	let n = t.dyn_tree, r = t.stat_desc.static_tree, i = t.stat_desc.has_stree, a = t.stat_desc.elems, o, s, c = -1, l;
+	for (e.heap_len = 0, e.heap_max = h, o = 0; o < a; o++) n[o * 2] === 0 ? n[o * 2 + 1] = 0 : (e.heap[++e.heap_len] = c = o, e.depth[o] = 0);
+	for (; e.heap_len < 2;) l = e.heap[++e.heap_len] = c < 2 ? ++c : 0, n[l * 2] = 1, e.depth[l] = 0, e.opt_len--, i && (e.static_len -= r[l * 2 + 1]);
+	for (t.max_code = c, o = e.heap_len >> 1; o >= 1; o--) ve(e, n, o);
+	l = a;
+	do
+		o = e.heap[1], e.heap[1] = e.heap[e.heap_len--], ve(e, n, 1), s = e.heap[1], e.heap[--e.heap_max] = o, e.heap[--e.heap_max] = s, n[l * 2] = n[o * 2] + n[s * 2], e.depth[l] = (e.depth[o] >= e.depth[s] ? e.depth[o] : e.depth[s]) + 1, n[o * 2 + 1] = n[s * 2 + 1] = l, e.heap[1] = l++, ve(e, n, 1);
+	while (e.heap_len >= 2);
+	e.heap[--e.heap_max] = e.heap[1], fe(e, t), pe(n, c, e.bl_count);
+}, xe = (e, t, n) => {
+	let r, i = -1, a, o = t[1], s = 0, c = 7, l = 4;
+	for (o === 0 && (c = 138, l = 3), t[(n + 1) * 2 + 1] = 65535, r = 0; r <= n; r++) a = o, o = t[(r + 1) * 2 + 1], !(++s < c && a === o) && (s < l ? e.bl_tree[a * 2] += s : a === 0 ? s <= 10 ? e.bl_tree[x * 2]++ : e.bl_tree[S * 2]++ : (a !== i && e.bl_tree[a * 2]++, e.bl_tree[b * 2]++), s = 0, i = a, o === 0 ? (c = 138, l = 3) : a === o ? (c = 6, l = 3) : (c = 7, l = 4));
+}, Se = (e, t, n) => {
+	let r, i = -1, a, o = t[1], s = 0, c = 7, l = 4;
+	for (o === 0 && (c = 138, l = 3), r = 0; r <= n; r++) if (a = o, o = t[(r + 1) * 2 + 1], !(++s < c && a === o)) {
+		if (s < l) do
+			M(e, a, e.bl_tree);
+		while (--s !== 0);
+		else a === 0 ? s <= 10 ? (M(e, x, e.bl_tree), j(e, s - 3, 3)) : (M(e, S, e.bl_tree), j(e, s - 11, 7)) : (a !== i && (M(e, a, e.bl_tree), s--), M(e, b, e.bl_tree), j(e, s - 3, 2));
+		s = 0, i = a, o === 0 ? (c = 138, l = 3) : a === o ? (c = 6, l = 3) : (c = 7, l = 4);
+	}
+}, Ce = (e) => {
+	let t;
+	for (xe(e, e.dyn_ltree, e.l_desc.max_code), xe(e, e.dyn_dtree, e.d_desc.max_code), be(e, e.bl_desc), t = m - 1; t >= 3 && e.bl_tree[E[t] * 2 + 1] === 0; t--);
+	return e.opt_len += 3 * (t + 1) + 5 + 5 + 4, t;
+}, we = (e, t, n, r) => {
+	let i;
+	for (j(e, t - 257, 5), j(e, n - 1, 5), j(e, r - 4, 4), i = 0; i < r; i++) j(e, e.bl_tree[E[i] * 2 + 1], 3);
+	Se(e, e.dyn_ltree, t - 1), Se(e, e.dyn_dtree, n - 1);
+}, Te = (e) => {
+	let r = 4093624447, i;
+	for (i = 0; i <= 31; i++, r >>>= 1) if (r & 1 && e.dyn_ltree[i * 2] !== 0) return t;
+	if (e.dyn_ltree[18] !== 0 || e.dyn_ltree[20] !== 0 || e.dyn_ltree[26] !== 0) return n;
+	for (i = 32; i < d; i++) if (e.dyn_ltree[i * 2] !== 0) return n;
+	return t;
+}, Ee = !1, De = (e) => {
+	Ee ||= (me(), !0), e.l_desc = new se(e.dyn_ltree, ie), e.d_desc = new se(e.dyn_dtree, ae), e.bl_desc = new se(e.bl_tree, oe), e.bi_buf = 0, e.bi_valid = 0, he(e);
+}, Oe = (e, t, n, r) => {
+	j(e, (a << 1) + +!!r, 3), ge(e), le(e, n), le(e, ~n), n && e.pending_buf.set(e.window.subarray(t, t + n), e.pending), e.pending += n;
+}, ke = {
+	_tr_init: De,
+	_tr_stored_block: Oe,
+	_tr_flush_block: (t, n, i, a) => {
+		let c, l, u = 0;
+		t.level > 0 ? (t.strm.data_type === r && (t.strm.data_type = Te(t)), be(t, t.l_desc), be(t, t.d_desc), u = Ce(t), c = t.opt_len + 3 + 7 >>> 3, l = t.static_len + 3 + 7 >>> 3, l <= c && (c = l)) : c = l = i + 5, i + 4 <= c && n !== -1 ? Oe(t, n, i, a) : t.strategy === e || l === c ? (j(t, (o << 1) + +!!a, 3), ye(t, O, ee)) : (j(t, (s << 1) + +!!a, 3), we(t, t.l_desc.max_code + 1, t.d_desc.max_code + 1, u + 1), ye(t, t.dyn_ltree, t.dyn_dtree)), he(t), a && ge(t);
+	},
+	_tr_tally: (e, t, n) => (e.pending_buf[e.sym_buf + e.sym_next++] = t, e.pending_buf[e.sym_buf + e.sym_next++] = t >> 8, e.pending_buf[e.sym_buf + e.sym_next++] = n, t === 0 ? e.dyn_ltree[n * 2]++ : (e.matches++, t--, e.dyn_ltree[(A[n] + d + 1) * 2]++, e.dyn_dtree[ce(t) * 2]++), e.sym_next === e.sym_end),
+	_tr_align: (e) => {
+		j(e, o << 1, 3), M(e, y, O), de(e);
+	}
+}, Ae = (e, t, n, r) => {
+	let i = e & 65535 | 0, a = e >>> 16 & 65535 | 0, o = 0;
+	for (; n !== 0;) {
+		o = n > 2e3 ? 2e3 : n, n -= o;
+		do
+			i = i + t[r++] | 0, a = a + i | 0;
+		while (--o);
+		i %= 65521, a %= 65521;
+	}
+	return i | a << 16 | 0;
+}, je = new Uint32Array((() => {
+	let e, t = [];
+	for (var n = 0; n < 256; n++) {
+		e = n;
+		for (var r = 0; r < 8; r++) e = e & 1 ? 3988292384 ^ e >>> 1 : e >>> 1;
+		t[n] = e;
+	}
+	return t;
+})()), N = (e, t, n, r) => {
+	let i = je, a = r + n;
+	e ^= -1;
+	for (let n = r; n < a; n++) e = e >>> 8 ^ i[(e ^ t[n]) & 255];
+	return e ^ -1;
+}, Me = {
+	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"
+}, Ne = {
+	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
+}, { _tr_init: Pe, _tr_stored_block: Fe, _tr_flush_block: Ie, _tr_tally: P, _tr_align: Le } = ke, { Z_NO_FLUSH: F, Z_PARTIAL_FLUSH: Re, Z_FULL_FLUSH: ze, Z_FINISH: I, Z_BLOCK: Be, Z_OK: L, Z_STREAM_END: Ve, Z_STREAM_ERROR: R, Z_DATA_ERROR: He, Z_BUF_ERROR: Ue, Z_DEFAULT_COMPRESSION: We, Z_FILTERED: Ge, Z_HUFFMAN_ONLY: Ke, Z_RLE: qe, Z_FIXED: Je, Z_DEFAULT_STRATEGY: Ye, Z_UNKNOWN: Xe, Z_DEFLATED: Ze } = Ne, Qe = 9, $e = 15, et = 8, tt = 286, nt = 30, rt = 19, it = 2 * tt + 1, at = 15, z = 3, B = 258, V = B + z + 1, ot = 32, st = 42, ct = 57, lt = 69, ut = 73, dt = 91, ft = 103, H = 113, pt = 666, U = 1, mt = 2, ht = 3, gt = 4, _t = 3, vt = (e, t) => (e.msg = Me[t], t), yt = (e) => e * 2 - (e > 4 ? 9 : 0), W = (e) => {
+	let t = e.length;
+	for (; --t >= 0;) e[t] = 0;
+}, bt = (e) => {
+	let t, n, r, i = e.w_size;
+	t = e.hash_size, r = t;
+	do
+		n = e.head[--r], e.head[r] = n >= i ? n - i : 0;
+	while (--t);
+	t = i, r = t;
+	do
+		n = e.prev[--r], e.prev[r] = n >= i ? n - i : 0;
+	while (--t);
+}, G = (e, t, n) => (t << e.hash_shift ^ n) & e.hash_mask, K = (e) => {
+	let t = e.state, n = t.pending;
+	n > e.avail_out && (n = e.avail_out), n !== 0 && (e.output.set(t.pending_buf.subarray(t.pending_out, t.pending_out + n), e.next_out), e.next_out += n, t.pending_out += n, e.total_out += n, e.avail_out -= n, t.pending -= n, t.pending === 0 && (t.pending_out = 0));
+}, q = (e, t) => {
+	Ie(e, e.block_start >= 0 ? e.block_start : -1, e.strstart - e.block_start, t), e.block_start = e.strstart, K(e.strm);
+}, J = (e, t) => {
+	e.pending_buf[e.pending++] = t;
+}, xt = (e, t) => {
+	e.pending_buf[e.pending++] = t >>> 8 & 255, e.pending_buf[e.pending++] = t & 255;
+}, St = (e, t, n, r) => {
+	let i = e.avail_in;
+	return i > r && (i = r), i === 0 ? 0 : (e.avail_in -= i, t.set(e.input.subarray(e.next_in, e.next_in + i), n), e.state.wrap === 1 ? e.adler = Ae(e.adler, t, i, n) : e.state.wrap === 2 && (e.adler = N(e.adler, t, i, n)), e.next_in += i, e.total_in += i, i);
+}, Ct = (e, t) => {
+	let n = e.max_chain_length, r = e.strstart, i, a, o = e.prev_length, s = e.nice_match, c = e.strstart > e.w_size - V ? e.strstart - (e.w_size - V) : 0, l = e.window, u = e.w_mask, d = e.prev, f = e.strstart + B, p = l[r + o - 1], m = l[r + o];
+	e.prev_length >= e.good_match && (n >>= 2), s > e.lookahead && (s = e.lookahead);
+	do {
+		if (i = t, l[i + o] !== m || l[i + o - 1] !== p || l[i] !== l[r] || l[++i] !== l[r + 1]) continue;
+		r += 2, i++;
+		do		;
+while (l[++r] === l[++i] && l[++r] === l[++i] && l[++r] === l[++i] && l[++r] === l[++i] && l[++r] === l[++i] && l[++r] === l[++i] && l[++r] === l[++i] && l[++r] === l[++i] && r < f);
+		if (a = B - (f - r), r = f - B, a > o) {
+			if (e.match_start = t, o = a, a >= s) break;
+			p = l[r + o - 1], m = l[r + o];
+		}
+	} while ((t = d[t & u]) > c && --n !== 0);
+	return o <= e.lookahead ? o : e.lookahead;
+}, wt = (e) => {
+	let t = e.w_size, n, r, i;
+	do {
+		if (r = e.window_size - e.lookahead - e.strstart, e.strstart >= t + (t - V) && (e.window.set(e.window.subarray(t, t + t - r), 0), e.match_start -= t, e.strstart -= t, e.block_start -= t, e.insert > e.strstart && (e.insert = e.strstart), bt(e), r += t), e.strm.avail_in === 0) break;
+		if (n = St(e.strm, e.window, e.strstart + e.lookahead, r), e.lookahead += n, e.lookahead + e.insert >= z) for (i = e.strstart - e.insert, e.ins_h = e.window[i], e.ins_h = G(e, e.ins_h, e.window[i + 1]); e.insert && (e.ins_h = G(e, e.ins_h, e.window[i + z - 1]), e.prev[i & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = i, i++, e.insert--, !(e.lookahead + e.insert < z)););
+	} while (e.lookahead < V && e.strm.avail_in !== 0);
+}, Tt = (e, t) => {
+	let n = e.pending_buf_size - 5 > e.w_size ? e.w_size : e.pending_buf_size - 5, r, i, a, o = 0, s = e.strm.avail_in;
+	do {
+		if (r = 65535, a = e.bi_valid + 42 >> 3, e.strm.avail_out < a || (a = e.strm.avail_out - a, i = e.strstart - e.block_start, r > i + e.strm.avail_in && (r = i + e.strm.avail_in), r > a && (r = a), r < n && (r === 0 && t !== I || t === F || r !== i + e.strm.avail_in))) break;
+		o = +(t === I && r === i + e.strm.avail_in), Fe(e, 0, 0, o), e.pending_buf[e.pending - 4] = r, e.pending_buf[e.pending - 3] = r >> 8, e.pending_buf[e.pending - 2] = ~r, e.pending_buf[e.pending - 1] = ~r >> 8, K(e.strm), i && (i > r && (i = r), e.strm.output.set(e.window.subarray(e.block_start, e.block_start + i), e.strm.next_out), e.strm.next_out += i, e.strm.avail_out -= i, e.strm.total_out += i, e.block_start += i, r -= i), r && (St(e.strm, e.strm.output, e.strm.next_out, r), e.strm.next_out += r, e.strm.avail_out -= r, e.strm.total_out += r);
+	} while (o === 0);
+	return s -= e.strm.avail_in, s && (s >= e.w_size ? (e.matches = 2, e.window.set(e.strm.input.subarray(e.strm.next_in - e.w_size, e.strm.next_in), 0), e.strstart = e.w_size, e.insert = e.strstart) : (e.window_size - e.strstart <= s && (e.strstart -= e.w_size, e.window.set(e.window.subarray(e.w_size, e.w_size + e.strstart), 0), e.matches < 2 && e.matches++, e.insert > e.strstart && (e.insert = e.strstart)), e.window.set(e.strm.input.subarray(e.strm.next_in - s, e.strm.next_in), e.strstart), e.strstart += s, e.insert += s > e.w_size - e.insert ? e.w_size - e.insert : s), e.block_start = e.strstart), e.high_water < e.strstart && (e.high_water = e.strstart), o ? gt : t !== F && t !== I && e.strm.avail_in === 0 && e.strstart === e.block_start ? mt : (a = e.window_size - e.strstart, e.strm.avail_in > a && e.block_start >= e.w_size && (e.block_start -= e.w_size, e.strstart -= e.w_size, e.window.set(e.window.subarray(e.w_size, e.w_size + e.strstart), 0), e.matches < 2 && e.matches++, a += e.w_size, e.insert > e.strstart && (e.insert = e.strstart)), a > e.strm.avail_in && (a = e.strm.avail_in), a && (St(e.strm, e.window, e.strstart, a), e.strstart += a, e.insert += a > e.w_size - e.insert ? e.w_size - e.insert : a), e.high_water < e.strstart && (e.high_water = e.strstart), a = e.bi_valid + 42 >> 3, a = e.pending_buf_size - a > 65535 ? 65535 : e.pending_buf_size - a, n = a > e.w_size ? e.w_size : a, i = e.strstart - e.block_start, (i >= n || (i || t === I) && t !== F && e.strm.avail_in === 0 && i <= a) && (r = i > a ? a : i, o = +(t === I && e.strm.avail_in === 0 && r === i), Fe(e, e.block_start, r, o), e.block_start += r, K(e.strm)), o ? ht : U);
+}, Et = (e, t) => {
+	let n, r;
+	for (;;) {
+		if (e.lookahead < V) {
+			if (wt(e), e.lookahead < V && t === F) return U;
+			if (e.lookahead === 0) break;
+		}
+		if (n = 0, e.lookahead >= z && (e.ins_h = G(e, e.ins_h, e.window[e.strstart + z - 1]), n = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart), n !== 0 && e.strstart - n <= e.w_size - V && (e.match_length = Ct(e, n)), e.match_length >= z) if (r = P(e, e.strstart - e.match_start, e.match_length - z), e.lookahead -= e.match_length, e.match_length <= e.max_lazy_match && e.lookahead >= z) {
+			e.match_length--;
+			do
+				e.strstart++, e.ins_h = G(e, e.ins_h, e.window[e.strstart + z - 1]), n = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart;
+			while (--e.match_length !== 0);
+			e.strstart++;
+		} else e.strstart += e.match_length, e.match_length = 0, e.ins_h = e.window[e.strstart], e.ins_h = G(e, e.ins_h, e.window[e.strstart + 1]);
+		else r = P(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++;
+		if (r && (q(e, !1), e.strm.avail_out === 0)) return U;
+	}
+	return e.insert = e.strstart < z - 1 ? e.strstart : z - 1, t === I ? (q(e, !0), e.strm.avail_out === 0 ? ht : gt) : e.sym_next && (q(e, !1), e.strm.avail_out === 0) ? U : mt;
+}, Dt = (e, t) => {
+	let n, r, i;
+	for (;;) {
+		if (e.lookahead < V) {
+			if (wt(e), e.lookahead < V && t === F) return U;
+			if (e.lookahead === 0) break;
+		}
+		if (n = 0, e.lookahead >= z && (e.ins_h = G(e, e.ins_h, e.window[e.strstart + z - 1]), n = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart), e.prev_length = e.match_length, e.prev_match = e.match_start, e.match_length = z - 1, n !== 0 && e.prev_length < e.max_lazy_match && e.strstart - n <= e.w_size - V && (e.match_length = Ct(e, n), e.match_length <= 5 && (e.strategy === Ge || e.match_length === z && e.strstart - e.match_start > 4096) && (e.match_length = z - 1)), e.prev_length >= z && e.match_length <= e.prev_length) {
+			i = e.strstart + e.lookahead - z, r = P(e, e.strstart - 1 - e.prev_match, e.prev_length - z), e.lookahead -= e.prev_length - 1, e.prev_length -= 2;
+			do
+				++e.strstart <= i && (e.ins_h = G(e, e.ins_h, e.window[e.strstart + z - 1]), n = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart);
+			while (--e.prev_length !== 0);
+			if (e.match_available = 0, e.match_length = z - 1, e.strstart++, r && (q(e, !1), e.strm.avail_out === 0)) return U;
+		} else if (e.match_available) {
+			if (r = P(e, 0, e.window[e.strstart - 1]), r && q(e, !1), e.strstart++, e.lookahead--, e.strm.avail_out === 0) return U;
+		} else e.match_available = 1, e.strstart++, e.lookahead--;
+	}
+	return e.match_available &&= (r = P(e, 0, e.window[e.strstart - 1]), 0), e.insert = e.strstart < z - 1 ? e.strstart : z - 1, t === I ? (q(e, !0), e.strm.avail_out === 0 ? ht : gt) : e.sym_next && (q(e, !1), e.strm.avail_out === 0) ? U : mt;
+}, Ot = (e, t) => {
+	let n, r, i, a, o = e.window;
+	for (;;) {
+		if (e.lookahead <= B) {
+			if (wt(e), e.lookahead <= B && t === F) return U;
+			if (e.lookahead === 0) break;
+		}
+		if (e.match_length = 0, e.lookahead >= z && e.strstart > 0 && (i = e.strstart - 1, r = o[i], r === o[++i] && r === o[++i] && r === o[++i])) {
+			a = e.strstart + B;
+			do			;
+while (r === o[++i] && r === o[++i] && r === o[++i] && r === o[++i] && r === o[++i] && r === o[++i] && r === o[++i] && r === o[++i] && i < a);
+			e.match_length = B - (a - i), e.match_length > e.lookahead && (e.match_length = e.lookahead);
+		}
+		if (e.match_length >= z ? (n = P(e, 1, e.match_length - z), e.lookahead -= e.match_length, e.strstart += e.match_length, e.match_length = 0) : (n = P(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++), n && (q(e, !1), e.strm.avail_out === 0)) return U;
+	}
+	return e.insert = 0, t === I ? (q(e, !0), e.strm.avail_out === 0 ? ht : gt) : e.sym_next && (q(e, !1), e.strm.avail_out === 0) ? U : mt;
+}, kt = (e, t) => {
+	let n;
+	for (;;) {
+		if (e.lookahead === 0 && (wt(e), e.lookahead === 0)) {
+			if (t === F) return U;
+			break;
+		}
+		if (e.match_length = 0, n = P(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++, n && (q(e, !1), e.strm.avail_out === 0)) return U;
+	}
+	return e.insert = 0, t === I ? (q(e, !0), e.strm.avail_out === 0 ? ht : gt) : e.sym_next && (q(e, !1), e.strm.avail_out === 0) ? U : mt;
+};
+function Y(e, t, n, r, i) {
+	this.good_length = e, this.max_lazy = t, this.nice_length = n, this.max_chain = r, this.func = i;
+}
+var At = [
+	new Y(0, 0, 0, 0, Tt),
+	new Y(4, 4, 8, 4, Et),
+	new Y(4, 5, 16, 8, Et),
+	new Y(4, 6, 32, 32, Et),
+	new Y(4, 4, 16, 16, Dt),
+	new Y(8, 16, 32, 32, Dt),
+	new Y(8, 16, 128, 128, Dt),
+	new Y(8, 32, 128, 256, Dt),
+	new Y(32, 128, 258, 1024, Dt),
+	new Y(32, 258, 258, 4096, Dt)
+], jt = (e) => {
+	e.window_size = 2 * e.w_size, W(e.head), e.max_lazy_match = At[e.level].max_lazy, e.good_match = At[e.level].good_length, e.nice_match = At[e.level].nice_length, e.max_chain_length = At[e.level].max_chain, e.strstart = 0, e.block_start = 0, e.lookahead = 0, e.insert = 0, e.match_length = e.prev_length = z - 1, e.match_available = 0, e.ins_h = 0;
+};
+function Mt() {
+	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 = Ze, 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(it * 2), this.dyn_dtree = new Uint16Array((2 * nt + 1) * 2), this.bl_tree = new Uint16Array((2 * rt + 1) * 2), W(this.dyn_ltree), W(this.dyn_dtree), W(this.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this.bl_count = new Uint16Array(at + 1), this.heap = new Uint16Array(2 * tt + 1), W(this.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new Uint16Array(2 * tt + 1), W(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;
+}
+var Nt = (e) => {
+	if (!e) return 1;
+	let t = e.state;
+	return +(!t || t.strm !== e || t.status !== st && t.status !== ct && t.status !== lt && t.status !== ut && t.status !== dt && t.status !== ft && t.status !== H && t.status !== pt);
+}, Pt = (e) => {
+	if (Nt(e)) return vt(e, R);
+	e.total_in = e.total_out = 0, e.data_type = Xe;
+	let t = e.state;
+	return t.pending = 0, t.pending_out = 0, t.wrap < 0 && (t.wrap = -t.wrap), t.status = t.wrap === 2 ? ct : t.wrap ? st : H, e.adler = t.wrap === 2 ? 0 : 1, t.last_flush = -2, Pe(t), L;
+}, Ft = (e) => {
+	let t = Pt(e);
+	return t === L && jt(e.state), t;
+}, It = (e, t) => Nt(e) || e.state.wrap !== 2 ? R : (e.state.gzhead = t, L), Lt = (e, t, n, r, i, a) => {
+	if (!e) return R;
+	let o = 1;
+	if (t === We && (t = 6), r < 0 ? (o = 0, r = -r) : r > 15 && (o = 2, r -= 16), i < 1 || i > Qe || n !== Ze || r < 8 || r > 15 || t < 0 || t > 9 || a < 0 || a > Je || r === 8 && o !== 1) return vt(e, R);
+	r === 8 && (r = 9);
+	let s = new Mt();
+	return e.state = s, s.strm = e, s.status = st, s.wrap = o, s.gzhead = null, s.w_bits = r, s.w_size = 1 << s.w_bits, s.w_mask = s.w_size - 1, s.hash_bits = i + 7, s.hash_size = 1 << s.hash_bits, s.hash_mask = s.hash_size - 1, s.hash_shift = ~~((s.hash_bits + z - 1) / z), 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 << i + 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 = t, s.strategy = a, s.method = n, Ft(e);
+}, Rt = {
+	deflateInit: (e, t) => Lt(e, t, Ze, $e, et, Ye),
+	deflateInit2: Lt,
+	deflateReset: Ft,
+	deflateResetKeep: Pt,
+	deflateSetHeader: It,
+	deflate: (e, t) => {
+		if (Nt(e) || t > Be || t < 0) return e ? vt(e, R) : R;
+		let n = e.state;
+		if (!e.output || e.avail_in !== 0 && !e.input || n.status === pt && t !== I) return vt(e, e.avail_out === 0 ? Ue : R);
+		let r = n.last_flush;
+		if (n.last_flush = t, n.pending !== 0) {
+			if (K(e), e.avail_out === 0) return n.last_flush = -1, L;
+		} else if (e.avail_in === 0 && yt(t) <= yt(r) && t !== I) return vt(e, Ue);
+		if (n.status === pt && e.avail_in !== 0) return vt(e, Ue);
+		if (n.status === st && n.wrap === 0 && (n.status = H), n.status === st) {
+			let t = Ze + (n.w_bits - 8 << 4) << 8, r = -1;
+			if (r = n.strategy >= Ke || n.level < 2 ? 0 : n.level < 6 ? 1 : n.level === 6 ? 2 : 3, t |= r << 6, n.strstart !== 0 && (t |= ot), t += 31 - t % 31, xt(n, t), n.strstart !== 0 && (xt(n, e.adler >>> 16), xt(n, e.adler & 65535)), e.adler = 1, n.status = H, K(e), n.pending !== 0) return n.last_flush = -1, L;
+		}
+		if (n.status === ct) {
+			if (e.adler = 0, J(n, 31), J(n, 139), J(n, 8), n.gzhead) J(n, +!!n.gzhead.text + (n.gzhead.hcrc ? 2 : 0) + (n.gzhead.extra ? 4 : 0) + (n.gzhead.name ? 8 : 0) + (n.gzhead.comment ? 16 : 0)), J(n, n.gzhead.time & 255), J(n, n.gzhead.time >> 8 & 255), J(n, n.gzhead.time >> 16 & 255), J(n, n.gzhead.time >> 24 & 255), J(n, n.level === 9 ? 2 : n.strategy >= Ke || n.level < 2 ? 4 : 0), J(n, n.gzhead.os & 255), n.gzhead.extra && n.gzhead.extra.length && (J(n, n.gzhead.extra.length & 255), J(n, n.gzhead.extra.length >> 8 & 255)), n.gzhead.hcrc && (e.adler = N(e.adler, n.pending_buf, n.pending, 0)), n.gzindex = 0, n.status = lt;
+			else if (J(n, 0), J(n, 0), J(n, 0), J(n, 0), J(n, 0), J(n, n.level === 9 ? 2 : n.strategy >= Ke || n.level < 2 ? 4 : 0), J(n, _t), n.status = H, K(e), n.pending !== 0) return n.last_flush = -1, L;
+		}
+		if (n.status === lt) {
+			if (n.gzhead.extra) {
+				let t = n.pending, r = (n.gzhead.extra.length & 65535) - n.gzindex;
+				for (; n.pending + r > n.pending_buf_size;) {
+					let i = n.pending_buf_size - n.pending;
+					if (n.pending_buf.set(n.gzhead.extra.subarray(n.gzindex, n.gzindex + i), n.pending), n.pending = n.pending_buf_size, n.gzhead.hcrc && n.pending > t && (e.adler = N(e.adler, n.pending_buf, n.pending - t, t)), n.gzindex += i, K(e), n.pending !== 0) return n.last_flush = -1, L;
+					t = 0, r -= i;
+				}
+				let i = new Uint8Array(n.gzhead.extra);
+				n.pending_buf.set(i.subarray(n.gzindex, n.gzindex + r), n.pending), n.pending += r, n.gzhead.hcrc && n.pending > t && (e.adler = N(e.adler, n.pending_buf, n.pending - t, t)), n.gzindex = 0;
+			}
+			n.status = ut;
+		}
+		if (n.status === ut) {
+			if (n.gzhead.name) {
+				let t = n.pending, r;
+				do {
+					if (n.pending === n.pending_buf_size) {
+						if (n.gzhead.hcrc && n.pending > t && (e.adler = N(e.adler, n.pending_buf, n.pending - t, t)), K(e), n.pending !== 0) return n.last_flush = -1, L;
+						t = 0;
+					}
+					r = n.gzindex < n.gzhead.name.length ? n.gzhead.name.charCodeAt(n.gzindex++) & 255 : 0, J(n, r);
+				} while (r !== 0);
+				n.gzhead.hcrc && n.pending > t && (e.adler = N(e.adler, n.pending_buf, n.pending - t, t)), n.gzindex = 0;
+			}
+			n.status = dt;
+		}
+		if (n.status === dt) {
+			if (n.gzhead.comment) {
+				let t = n.pending, r;
+				do {
+					if (n.pending === n.pending_buf_size) {
+						if (n.gzhead.hcrc && n.pending > t && (e.adler = N(e.adler, n.pending_buf, n.pending - t, t)), K(e), n.pending !== 0) return n.last_flush = -1, L;
+						t = 0;
+					}
+					r = n.gzindex < n.gzhead.comment.length ? n.gzhead.comment.charCodeAt(n.gzindex++) & 255 : 0, J(n, r);
+				} while (r !== 0);
+				n.gzhead.hcrc && n.pending > t && (e.adler = N(e.adler, n.pending_buf, n.pending - t, t));
+			}
+			n.status = ft;
+		}
+		if (n.status === ft) {
+			if (n.gzhead.hcrc) {
+				if (n.pending + 2 > n.pending_buf_size && (K(e), n.pending !== 0)) return n.last_flush = -1, L;
+				J(n, e.adler & 255), J(n, e.adler >> 8 & 255), e.adler = 0;
+			}
+			if (n.status = H, K(e), n.pending !== 0) return n.last_flush = -1, L;
+		}
+		if (e.avail_in !== 0 || n.lookahead !== 0 || t !== F && n.status !== pt) {
+			let r = n.level === 0 ? Tt(n, t) : n.strategy === Ke ? kt(n, t) : n.strategy === qe ? Ot(n, t) : At[n.level].func(n, t);
+			if ((r === ht || r === gt) && (n.status = pt), r === U || r === ht) return e.avail_out === 0 && (n.last_flush = -1), L;
+			if (r === mt && (t === Re ? Le(n) : t !== Be && (Fe(n, 0, 0, !1), t === ze && (W(n.head), n.lookahead === 0 && (n.strstart = 0, n.block_start = 0, n.insert = 0))), K(e), e.avail_out === 0)) return n.last_flush = -1, L;
+		}
+		return t === I ? n.wrap <= 0 ? Ve : (n.wrap === 2 ? (J(n, e.adler & 255), J(n, e.adler >> 8 & 255), J(n, e.adler >> 16 & 255), J(n, e.adler >> 24 & 255), J(n, e.total_in & 255), J(n, e.total_in >> 8 & 255), J(n, e.total_in >> 16 & 255), J(n, e.total_in >> 24 & 255)) : (xt(n, e.adler >>> 16), xt(n, e.adler & 65535)), K(e), n.wrap > 0 && (n.wrap = -n.wrap), n.pending === 0 ? Ve : L) : L;
+	},
+	deflateEnd: (e) => {
+		if (Nt(e)) return R;
+		let t = e.state.status;
+		return e.state = null, t === H ? vt(e, He) : L;
+	},
+	deflateSetDictionary: (e, t) => {
+		let n = t.length;
+		if (Nt(e)) return R;
+		let r = e.state, i = r.wrap;
+		if (i === 2 || i === 1 && r.status !== st || r.lookahead) return R;
+		if (i === 1 && (e.adler = Ae(e.adler, t, n, 0)), r.wrap = 0, n >= r.w_size) {
+			i === 0 && (W(r.head), r.strstart = 0, r.block_start = 0, r.insert = 0);
+			let e = new Uint8Array(r.w_size);
+			e.set(t.subarray(n - r.w_size, n), 0), t = e, n = r.w_size;
+		}
+		let a = e.avail_in, o = e.next_in, s = e.input;
+		for (e.avail_in = n, e.next_in = 0, e.input = t, wt(r); r.lookahead >= z;) {
+			let e = r.strstart, t = r.lookahead - (z - 1);
+			do
+				r.ins_h = G(r, r.ins_h, r.window[e + z - 1]), r.prev[e & r.w_mask] = r.head[r.ins_h], r.head[r.ins_h] = e, e++;
+			while (--t);
+			r.strstart = e, r.lookahead = z - 1, wt(r);
+		}
+		return r.strstart += r.lookahead, r.block_start = r.strstart, r.insert = r.lookahead, r.lookahead = 0, r.match_length = r.prev_length = z - 1, r.match_available = 0, e.next_in = o, e.input = s, e.avail_in = a, r.wrap = i, L;
+	},
+	deflateInfo: "pako deflate (from Nodeca project)"
+}, zt = (e, t) => Object.prototype.hasOwnProperty.call(e, t), Bt = {
+	assign: function(e) {
+		let t = Array.prototype.slice.call(arguments, 1);
+		for (; t.length;) {
+			let n = t.shift();
+			if (n) {
+				if (typeof n != "object") throw TypeError(n + "must be non-object");
+				for (let t in n) zt(n, t) && (e[t] = n[t]);
+			}
+		}
+		return e;
+	},
+	flattenChunks: (e) => {
+		let t = 0;
+		for (let n = 0, r = e.length; n < r; n++) t += e[n].length;
+		let n = new Uint8Array(t);
+		for (let t = 0, r = 0, i = e.length; t < i; t++) {
+			let i = e[t];
+			n.set(i, r), r += i.length;
+		}
+		return n;
+	}
+}, Vt = !0;
+try {
+	String.fromCharCode.apply(null, new Uint8Array(1));
+} catch {
+	Vt = !1;
+}
+var Ht = new Uint8Array(256);
+for (let e = 0; e < 256; e++) Ht[e] = e >= 252 ? 6 : e >= 248 ? 5 : e >= 240 ? 4 : e >= 224 ? 3 : e >= 192 ? 2 : 1;
+Ht[254] = Ht[254] = 1;
+var Ut = (e) => {
+	if (typeof TextEncoder == "function" && TextEncoder.prototype.encode) return new TextEncoder().encode(e);
+	let t, n, r, i, a, o = e.length, s = 0;
+	for (i = 0; i < o; i++) n = e.charCodeAt(i), (n & 64512) == 55296 && i + 1 < o && (r = e.charCodeAt(i + 1), (r & 64512) == 56320 && (n = 65536 + (n - 55296 << 10) + (r - 56320), i++)), s += n < 128 ? 1 : n < 2048 ? 2 : n < 65536 ? 3 : 4;
+	for (t = new Uint8Array(s), a = 0, i = 0; a < s; i++) n = e.charCodeAt(i), (n & 64512) == 55296 && i + 1 < o && (r = e.charCodeAt(i + 1), (r & 64512) == 56320 && (n = 65536 + (n - 55296 << 10) + (r - 56320), i++)), n < 128 ? t[a++] = n : n < 2048 ? (t[a++] = 192 | n >>> 6, t[a++] = 128 | n & 63) : n < 65536 ? (t[a++] = 224 | n >>> 12, t[a++] = 128 | n >>> 6 & 63, t[a++] = 128 | n & 63) : (t[a++] = 240 | n >>> 18, t[a++] = 128 | n >>> 12 & 63, t[a++] = 128 | n >>> 6 & 63, t[a++] = 128 | n & 63);
+	return t;
+}, Wt = (e, t) => {
+	if (t < 65534 && e.subarray && Vt) return String.fromCharCode.apply(null, e.length === t ? e : e.subarray(0, t));
+	let n = "";
+	for (let r = 0; r < t; r++) n += String.fromCharCode(e[r]);
+	return n;
+}, Gt = {
+	string2buf: Ut,
+	buf2string: (e, t) => {
+		let n = t || e.length;
+		if (typeof TextDecoder == "function" && TextDecoder.prototype.decode) return new TextDecoder().decode(e.subarray(0, t));
+		let r, i, a = Array(n * 2);
+		for (i = 0, r = 0; r < n;) {
+			let t = e[r++];
+			if (t < 128) {
+				a[i++] = t;
+				continue;
+			}
+			let o = Ht[t];
+			if (o > 4) {
+				a[i++] = 65533, r += o - 1;
+				continue;
+			}
+			for (t &= o === 2 ? 31 : o === 3 ? 15 : 7; o > 1 && r < n;) t = t << 6 | e[r++] & 63, o--;
+			if (o > 1) {
+				a[i++] = 65533;
+				continue;
+			}
+			t < 65536 ? a[i++] = t : (t -= 65536, a[i++] = 55296 | t >> 10 & 1023, a[i++] = 56320 | t & 1023);
+		}
+		return Wt(a, i);
+	},
+	utf8border: (e, t) => {
+		t ||= e.length, t > e.length && (t = e.length);
+		let n = t - 1;
+		for (; n >= 0 && (e[n] & 192) == 128;) n--;
+		return n < 0 || n === 0 ? t : n + Ht[e[n]] > t ? n : t;
+	}
+};
+function Kt() {
+	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 qt = Kt, Jt = Object.prototype.toString, { Z_NO_FLUSH: Yt, Z_SYNC_FLUSH: Xt, Z_FULL_FLUSH: Zt, Z_FINISH: Qt, Z_OK: $t, Z_STREAM_END: en, Z_DEFAULT_COMPRESSION: tn, Z_DEFAULT_STRATEGY: nn, Z_DEFLATED: rn } = Ne;
+function an(e) {
+	this.options = Bt.assign({
+		level: tn,
+		method: rn,
+		chunkSize: 16384,
+		windowBits: 15,
+		memLevel: 8,
+		strategy: nn
+	}, e || {});
+	let t = this.options;
+	t.raw && t.windowBits > 0 ? t.windowBits = -t.windowBits : t.gzip && t.windowBits > 0 && t.windowBits < 16 && (t.windowBits += 16), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new qt(), this.strm.avail_out = 0;
+	let n = Rt.deflateInit2(this.strm, t.level, t.method, t.windowBits, t.memLevel, t.strategy);
+	if (n !== $t) throw Error(Me[n]);
+	if (t.header && Rt.deflateSetHeader(this.strm, t.header), t.dictionary) {
+		let e;
+		if (e = typeof t.dictionary == "string" ? Gt.string2buf(t.dictionary) : Jt.call(t.dictionary) === "[object ArrayBuffer]" ? new Uint8Array(t.dictionary) : t.dictionary, n = Rt.deflateSetDictionary(this.strm, e), n !== $t) throw Error(Me[n]);
+		this._dict_set = !0;
+	}
+}
+an.prototype.push = function(e, t) {
+	let n = this.strm, r = this.options.chunkSize, i, a;
+	if (this.ended) return !1;
+	for (a = t === ~~t ? t : t === !0 ? Qt : Yt, typeof e == "string" ? n.input = Gt.string2buf(e) : Jt.call(e) === "[object ArrayBuffer]" ? n.input = new Uint8Array(e) : n.input = e, n.next_in = 0, n.avail_in = n.input.length;;) {
+		if (n.avail_out === 0 && (n.output = new Uint8Array(r), n.next_out = 0, n.avail_out = r), (a === Xt || a === Zt) && n.avail_out <= 6) {
+			this.onData(n.output.subarray(0, n.next_out)), n.avail_out = 0;
+			continue;
+		}
+		if (i = Rt.deflate(n, a), i === en) return n.next_out > 0 && this.onData(n.output.subarray(0, n.next_out)), i = Rt.deflateEnd(this.strm), this.onEnd(i), this.ended = !0, i === $t;
+		if (n.avail_out === 0) {
+			this.onData(n.output);
+			continue;
+		}
+		if (a > 0 && n.next_out > 0) {
+			this.onData(n.output.subarray(0, n.next_out)), n.avail_out = 0;
+			continue;
+		}
+		if (n.avail_in === 0) break;
+	}
+	return !0;
+}, an.prototype.onData = function(e) {
+	this.chunks.push(e);
+}, an.prototype.onEnd = function(e) {
+	e === $t && (this.result = Bt.flattenChunks(this.chunks)), this.chunks = [], this.err = e, this.msg = this.strm.msg;
+};
+function on(e, t) {
+	let n = new an(t);
+	if (n.push(e, !0), n.err) throw n.msg || Me[n.err];
+	return n.result;
+}
+function sn(e, t) {
+	return t ||= {}, t.raw = !0, on(e, t);
+}
+function cn(e, t) {
+	return t ||= {}, t.gzip = !0, on(e, t);
+}
+var ln = {
+	Deflate: an,
+	deflate: on,
+	deflateRaw: sn,
+	gzip: cn,
+	constants: Ne
+}, un = 16209, dn = 16191, fn = function(e, t) {
+	let n, r, i, a, o, s, c, l, u, d, f, p, m, h, g, _, v, y, b, x, S, C, w, T, E = e.state;
+	n = e.next_in, w = e.input, r = n + (e.avail_in - 5), i = e.next_out, T = e.output, a = i - (t - e.avail_out), o = i + (e.avail_out - 257), s = E.dmax, c = E.wsize, l = E.whave, u = E.wnext, d = E.window, f = E.hold, p = E.bits, m = E.lencode, h = E.distcode, g = (1 << E.lenbits) - 1, _ = (1 << E.distbits) - 1;
+	top: do {
+		p < 15 && (f += w[n++] << p, p += 8, f += w[n++] << p, p += 8), v = m[f & g];
+		dolen: for (;;) {
+			if (y = v >>> 24, f >>>= y, p -= y, y = v >>> 16 & 255, y === 0) T[i++] = v & 65535;
+			else if (y & 16) {
+				b = v & 65535, y &= 15, y && (p < y && (f += w[n++] << p, p += 8), b += f & (1 << y) - 1, f >>>= y, p -= y), p < 15 && (f += w[n++] << p, p += 8, f += w[n++] << p, p += 8), v = h[f & _];
+				dodist: for (;;) {
+					if (y = v >>> 24, f >>>= y, p -= y, y = v >>> 16 & 255, y & 16) {
+						if (x = v & 65535, y &= 15, p < y && (f += w[n++] << p, p += 8, p < y && (f += w[n++] << p, p += 8)), x += f & (1 << y) - 1, x > s) {
+							e.msg = "invalid distance too far back", E.mode = un;
+							break top;
+						}
+						if (f >>>= y, p -= y, y = i - a, x > y) {
+							if (y = x - y, y > l && E.sane) {
+								e.msg = "invalid distance too far back", E.mode = un;
+								break top;
+							}
+							if (S = 0, C = d, u === 0) {
+								if (S += c - y, y < b) {
+									b -= y;
+									do
+										T[i++] = d[S++];
+									while (--y);
+									S = i - x, C = T;
+								}
+							} else if (u < y) {
+								if (S += c + u - y, y -= u, y < b) {
+									b -= y;
+									do
+										T[i++] = d[S++];
+									while (--y);
+									if (S = 0, u < b) {
+										y = u, b -= y;
+										do
+											T[i++] = d[S++];
+										while (--y);
+										S = i - x, C = T;
+									}
+								}
+							} else if (S += u - y, y < b) {
+								b -= y;
+								do
+									T[i++] = d[S++];
+								while (--y);
+								S = i - x, C = T;
+							}
+							for (; b > 2;) T[i++] = C[S++], T[i++] = C[S++], T[i++] = C[S++], b -= 3;
+							b && (T[i++] = C[S++], b > 1 && (T[i++] = C[S++]));
+						} else {
+							S = i - x;
+							do
+								T[i++] = T[S++], T[i++] = T[S++], T[i++] = T[S++], b -= 3;
+							while (b > 2);
+							b && (T[i++] = T[S++], b > 1 && (T[i++] = T[S++]));
+						}
+					} else if (y & 64) {
+						e.msg = "invalid distance code", E.mode = un;
+						break top;
+					} else {
+						v = h[(v & 65535) + (f & (1 << y) - 1)];
+						continue dodist;
+					}
+					break;
+				}
+			} else if (!(y & 64)) {
+				v = m[(v & 65535) + (f & (1 << y) - 1)];
+				continue dolen;
+			} else if (y & 32) {
+				E.mode = dn;
+				break top;
+			} else {
+				e.msg = "invalid literal/length code", E.mode = un;
+				break top;
+			}
+			break;
+		}
+	} while (n < r && i < o);
+	b = p >> 3, n -= b, p -= b << 3, f &= (1 << p) - 1, e.next_in = n, e.next_out = i, e.avail_in = n < r ? 5 + (r - n) : 5 - (n - r), e.avail_out = i < o ? 257 + (o - i) : 257 - (i - o), E.hold = f, E.bits = p;
+}, pn = 15, mn = 852, hn = 592, gn = 0, _n = 1, vn = 2, yn = 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
+]), bn = 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
+]), xn = 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
+]), Sn = 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
+]), Cn = (e, t, n, r, i, a, o, s) => {
+	let c = s.bits, l = 0, u = 0, d = 0, f = 0, p = 0, m = 0, h = 0, g = 0, _ = 0, v = 0, y, b, x, S, C, w = null, T, E = new Uint16Array(pn + 1), D = new Uint16Array(pn + 1), O = null, ee, k, A;
+	for (l = 0; l <= pn; l++) E[l] = 0;
+	for (u = 0; u < r; u++) E[t[n + u]]++;
+	for (p = c, f = pn; f >= 1 && E[f] === 0; f--);
+	if (p > f && (p = f), f === 0) return i[a++] = 20971520, i[a++] = 20971520, s.bits = 1, 0;
+	for (d = 1; d < f && E[d] === 0; d++);
+	for (p < d && (p = d), g = 1, l = 1; l <= pn; l++) if (g <<= 1, g -= E[l], g < 0) return -1;
+	if (g > 0 && (e === gn || f !== 1)) return -1;
+	for (D[1] = 0, l = 1; l < pn; l++) D[l + 1] = D[l] + E[l];
+	for (u = 0; u < r; u++) t[n + u] !== 0 && (o[D[t[n + u]]++] = u);
+	if (e === gn ? (w = O = o, T = 20) : e === _n ? (w = yn, O = bn, T = 257) : (w = xn, O = Sn, T = 0), v = 0, u = 0, l = d, C = a, m = p, h = 0, x = -1, _ = 1 << p, S = _ - 1, e === _n && _ > mn || e === vn && _ > hn) return 1;
+	for (;;) {
+		ee = l - h, o[u] + 1 < T ? (k = 0, A = o[u]) : o[u] >= T ? (k = O[o[u] - T], A = w[o[u] - T]) : (k = 96, A = 0), y = 1 << l - h, b = 1 << m, d = b;
+		do
+			b -= y, i[C + (v >> h) + b] = ee << 24 | k << 16 | A | 0;
+		while (b !== 0);
+		for (y = 1 << l - 1; v & y;) y >>= 1;
+		if (y === 0 ? v = 0 : (v &= y - 1, v += y), u++, --E[l] === 0) {
+			if (l === f) break;
+			l = t[n + o[u]];
+		}
+		if (l > p && (v & S) !== x) {
+			for (h === 0 && (h = p), C += d, m = l - h, g = 1 << m; m + h < f && (g -= E[m + h], !(g <= 0));) m++, g <<= 1;
+			if (_ += 1 << m, e === _n && _ > mn || e === vn && _ > hn) return 1;
+			x = v & S, i[x] = p << 24 | m << 16 | C - a | 0;
+		}
+	}
+	return v !== 0 && (i[C + v] = l - h << 24 | 4194304), s.bits = p, 0;
+}, wn = 0, Tn = 1, En = 2, { Z_FINISH: Dn, Z_BLOCK: On, Z_TREES: kn, Z_OK: An, Z_STREAM_END: jn, Z_NEED_DICT: Mn, Z_STREAM_ERROR: X, Z_DATA_ERROR: Nn, Z_MEM_ERROR: Pn, Z_BUF_ERROR: Fn, Z_DEFLATED: In } = Ne, Ln = 16180, Rn = 16181, zn = 16182, Bn = 16183, Vn = 16184, Hn = 16185, Un = 16186, Wn = 16187, Gn = 16188, Kn = 16189, qn = 16190, Z = 16191, Jn = 16192, Yn = 16193, Xn = 16194, Zn = 16195, Qn = 16196, $n = 16197, er = 16198, tr = 16199, nr = 16200, rr = 16201, ir = 16202, ar = 16203, or = 16204, sr = 16205, cr = 16206, lr = 16207, ur = 16208, Q = 16209, dr = 16210, fr = 16211, pr = 852, mr = 592, hr = 15, gr = (e) => (e >>> 24 & 255) + (e >>> 8 & 65280) + ((e & 65280) << 8) + ((e & 255) << 24);
+function _r() {
+	this.strm = null, this.mode = 0, this.last = !1, this.wrap = 0, this.havedict = !1, 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;
+}
+var vr = (e) => {
+	if (!e) return 1;
+	let t = e.state;
+	return +(!t || t.strm !== e || t.mode < Ln || t.mode > fr);
+}, yr = (e) => {
+	if (vr(e)) return X;
+	let t = e.state;
+	return e.total_in = e.total_out = t.total = 0, e.msg = "", t.wrap && (e.adler = t.wrap & 1), t.mode = Ln, t.last = 0, t.havedict = 0, t.flags = -1, t.dmax = 32768, t.head = null, t.hold = 0, t.bits = 0, t.lencode = t.lendyn = new Int32Array(pr), t.distcode = t.distdyn = new Int32Array(mr), t.sane = 1, t.back = -1, An;
+}, br = (e) => {
+	if (vr(e)) return X;
+	let t = e.state;
+	return t.wsize = 0, t.whave = 0, t.wnext = 0, yr(e);
+}, xr = (e, t) => {
+	let n;
+	if (vr(e)) return X;
+	let r = e.state;
+	return t < 0 ? (n = 0, t = -t) : (n = (t >> 4) + 5, t < 48 && (t &= 15)), t && (t < 8 || t > 15) ? X : (r.window !== null && r.wbits !== t && (r.window = null), r.wrap = n, r.wbits = t, br(e));
+}, Sr = (e, t) => {
+	if (!e) return X;
+	let n = new _r();
+	e.state = n, n.strm = e, n.window = null, n.mode = Ln;
+	let r = xr(e, t);
+	return r !== An && (e.state = null), r;
+}, Cr = (e) => Sr(e, hr), wr = !0, Tr, Er, Dr = (e) => {
+	if (wr) {
+		Tr = new Int32Array(512), Er = new Int32Array(32);
+		let t = 0;
+		for (; t < 144;) e.lens[t++] = 8;
+		for (; t < 256;) e.lens[t++] = 9;
+		for (; t < 280;) e.lens[t++] = 7;
+		for (; t < 288;) e.lens[t++] = 8;
+		for (Cn(Tn, e.lens, 0, 288, Tr, 0, e.work, { bits: 9 }), t = 0; t < 32;) e.lens[t++] = 5;
+		Cn(En, e.lens, 0, 32, Er, 0, e.work, { bits: 5 }), wr = !1;
+	}
+	e.lencode = Tr, e.lenbits = 9, e.distcode = Er, e.distbits = 5;
+}, Or = (e, t, n, r) => {
+	let i, a = e.state;
+	return a.window === null && (a.wsize = 1 << a.wbits, a.wnext = 0, a.whave = 0, a.window = new Uint8Array(a.wsize)), r >= a.wsize ? (a.window.set(t.subarray(n - a.wsize, n), 0), a.wnext = 0, a.whave = a.wsize) : (i = a.wsize - a.wnext, i > r && (i = r), a.window.set(t.subarray(n - r, n - r + i), a.wnext), r -= i, r ? (a.window.set(t.subarray(n - r, n), 0), a.wnext = r, a.whave = a.wsize) : (a.wnext += i, a.wnext === a.wsize && (a.wnext = 0), a.whave < a.wsize && (a.whave += i))), 0;
+}, $ = {
+	inflateReset: br,
+	inflateReset2: xr,
+	inflateResetKeep: yr,
+	inflateInit: Cr,
+	inflateInit2: Sr,
+	inflate: (e, t) => {
+		let n, r, i, a, o, s, c, l, u, d, f, p, m, h, g = 0, _, v, y, b, x, S, C, w, T = new Uint8Array(4), E, D, O = new Uint8Array([
+			16,
+			17,
+			18,
+			0,
+			8,
+			7,
+			9,
+			6,
+			10,
+			5,
+			11,
+			4,
+			12,
+			3,
+			13,
+			2,
+			14,
+			1,
+			15
+		]);
+		if (vr(e) || !e.output || !e.input && e.avail_in !== 0) return X;
+		n = e.state, n.mode === Z && (n.mode = Jn), o = e.next_out, i = e.output, c = e.avail_out, a = e.next_in, r = e.input, s = e.avail_in, l = n.hold, u = n.bits, d = s, f = c, w = An;
+		inf_leave: for (;;) switch (n.mode) {
+			case Ln:
+				if (n.wrap === 0) {
+					n.mode = Jn;
+					break;
+				}
+				for (; u < 16;) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				if (n.wrap & 2 && l === 35615) {
+					n.wbits === 0 && (n.wbits = 15), n.check = 0, T[0] = l & 255, T[1] = l >>> 8 & 255, n.check = N(n.check, T, 2, 0), l = 0, u = 0, n.mode = Rn;
+					break;
+				}
+				if (n.head && (n.head.done = !1), !(n.wrap & 1) || (((l & 255) << 8) + (l >> 8)) % 31) {
+					e.msg = "incorrect header check", n.mode = Q;
+					break;
+				}
+				if ((l & 15) !== In) {
+					e.msg = "unknown compression method", n.mode = Q;
+					break;
+				}
+				if (l >>>= 4, u -= 4, C = (l & 15) + 8, n.wbits === 0 && (n.wbits = C), C > 15 || C > n.wbits) {
+					e.msg = "invalid window size", n.mode = Q;
+					break;
+				}
+				n.dmax = 1 << n.wbits, n.flags = 0, e.adler = n.check = 1, n.mode = l & 512 ? Kn : Z, l = 0, u = 0;
+				break;
+			case Rn:
+				for (; u < 16;) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				if (n.flags = l, (n.flags & 255) !== In) {
+					e.msg = "unknown compression method", n.mode = Q;
+					break;
+				}
+				if (n.flags & 57344) {
+					e.msg = "unknown header flags set", n.mode = Q;
+					break;
+				}
+				n.head && (n.head.text = l >> 8 & 1), n.flags & 512 && n.wrap & 4 && (T[0] = l & 255, T[1] = l >>> 8 & 255, n.check = N(n.check, T, 2, 0)), l = 0, u = 0, n.mode = zn;
+			case zn:
+				for (; u < 32;) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				n.head && (n.head.time = l), n.flags & 512 && n.wrap & 4 && (T[0] = l & 255, T[1] = l >>> 8 & 255, T[2] = l >>> 16 & 255, T[3] = l >>> 24 & 255, n.check = N(n.check, T, 4, 0)), l = 0, u = 0, n.mode = Bn;
+			case Bn:
+				for (; u < 16;) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				n.head && (n.head.xflags = l & 255, n.head.os = l >> 8), n.flags & 512 && n.wrap & 4 && (T[0] = l & 255, T[1] = l >>> 8 & 255, n.check = N(n.check, T, 2, 0)), l = 0, u = 0, n.mode = Vn;
+			case Vn:
+				if (n.flags & 1024) {
+					for (; u < 16;) {
+						if (s === 0) break inf_leave;
+						s--, l += r[a++] << u, u += 8;
+					}
+					n.length = l, n.head && (n.head.extra_len = l), n.flags & 512 && n.wrap & 4 && (T[0] = l & 255, T[1] = l >>> 8 & 255, n.check = N(n.check, T, 2, 0)), l = 0, u = 0;
+				} else n.head && (n.head.extra = null);
+				n.mode = Hn;
+			case Hn:
+				if (n.flags & 1024 && (p = n.length, p > s && (p = s), p && (n.head && (C = n.head.extra_len - n.length, n.head.extra || (n.head.extra = new Uint8Array(n.head.extra_len)), n.head.extra.set(r.subarray(a, a + p), C)), n.flags & 512 && n.wrap & 4 && (n.check = N(n.check, r, p, a)), s -= p, a += p, n.length -= p), n.length)) break inf_leave;
+				n.length = 0, n.mode = Un;
+			case Un:
+				if (n.flags & 2048) {
+					if (s === 0) break inf_leave;
+					p = 0;
+					do
+						C = r[a + p++], n.head && C && n.length < 65536 && (n.head.name += String.fromCharCode(C));
+					while (C && p < s);
+					if (n.flags & 512 && n.wrap & 4 && (n.check = N(n.check, r, p, a)), s -= p, a += p, C) break inf_leave;
+				} else n.head && (n.head.name = null);
+				n.length = 0, n.mode = Wn;
+			case Wn:
+				if (n.flags & 4096) {
+					if (s === 0) break inf_leave;
+					p = 0;
+					do
+						C = r[a + p++], n.head && C && n.length < 65536 && (n.head.comment += String.fromCharCode(C));
+					while (C && p < s);
+					if (n.flags & 512 && n.wrap & 4 && (n.check = N(n.check, r, p, a)), s -= p, a += p, C) break inf_leave;
+				} else n.head && (n.head.comment = null);
+				n.mode = Gn;
+			case Gn:
+				if (n.flags & 512) {
+					for (; u < 16;) {
+						if (s === 0) break inf_leave;
+						s--, l += r[a++] << u, u += 8;
+					}
+					if (n.wrap & 4 && l !== (n.check & 65535)) {
+						e.msg = "header crc mismatch", n.mode = Q;
+						break;
+					}
+					l = 0, u = 0;
+				}
+				n.head && (n.head.hcrc = n.flags >> 9 & 1, n.head.done = !0), e.adler = n.check = 0, n.mode = Z;
+				break;
+			case Kn:
+				for (; u < 32;) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				e.adler = n.check = gr(l), l = 0, u = 0, n.mode = qn;
+			case qn:
+				if (n.havedict === 0) return e.next_out = o, e.avail_out = c, e.next_in = a, e.avail_in = s, n.hold = l, n.bits = u, Mn;
+				e.adler = n.check = 1, n.mode = Z;
+			case Z: if (t === On || t === kn) break inf_leave;
+			case Jn:
+				if (n.last) {
+					l >>>= u & 7, u -= u & 7, n.mode = cr;
+					break;
+				}
+				for (; u < 3;) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				switch (n.last = l & 1, l >>>= 1, --u, l & 3) {
+					case 0:
+						n.mode = Yn;
+						break;
+					case 1:
+						if (Dr(n), n.mode = tr, t === kn) {
+							l >>>= 2, u -= 2;
+							break inf_leave;
+						}
+						break;
+					case 2:
+						n.mode = Qn;
+						break;
+					case 3: e.msg = "invalid block type", n.mode = Q;
+				}
+				l >>>= 2, u -= 2;
+				break;
+			case Yn:
+				for (l >>>= u & 7, u -= u & 7; u < 32;) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				if ((l & 65535) != (l >>> 16 ^ 65535)) {
+					e.msg = "invalid stored block lengths", n.mode = Q;
+					break;
+				}
+				if (n.length = l & 65535, l = 0, u = 0, n.mode = Xn, t === kn) break inf_leave;
+			case Xn: n.mode = Zn;
+			case Zn:
+				if (p = n.length, p) {
+					if (p > s && (p = s), p > c && (p = c), p === 0) break inf_leave;
+					i.set(r.subarray(a, a + p), o), s -= p, a += p, c -= p, o += p, n.length -= p;
+					break;
+				}
+				n.mode = Z;
+				break;
+			case Qn:
+				for (; u < 14;) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				if (n.nlen = (l & 31) + 257, l >>>= 5, u -= 5, n.ndist = (l & 31) + 1, l >>>= 5, u -= 5, n.ncode = (l & 15) + 4, l >>>= 4, u -= 4, n.nlen > 286 || n.ndist > 30) {
+					e.msg = "too many length or distance symbols", n.mode = Q;
+					break;
+				}
+				n.have = 0, n.mode = $n;
+			case $n:
+				for (; n.have < n.ncode;) {
+					for (; u < 3;) {
+						if (s === 0) break inf_leave;
+						s--, l += r[a++] << u, u += 8;
+					}
+					n.lens[O[n.have++]] = l & 7, l >>>= 3, u -= 3;
+				}
+				for (; n.have < 19;) n.lens[O[n.have++]] = 0;
+				if (n.lencode = n.lendyn, n.lenbits = 7, E = { bits: n.lenbits }, w = Cn(wn, n.lens, 0, 19, n.lencode, 0, n.work, E), n.lenbits = E.bits, w) {
+					e.msg = "invalid code lengths set", n.mode = Q;
+					break;
+				}
+				n.have = 0, n.mode = er;
+			case er:
+				for (; n.have < n.nlen + n.ndist;) {
+					for (; g = n.lencode[l & (1 << n.lenbits) - 1], _ = g >>> 24, v = g >>> 16 & 255, y = g & 65535, !(_ <= u);) {
+						if (s === 0) break inf_leave;
+						s--, l += r[a++] << u, u += 8;
+					}
+					if (y < 16) l >>>= _, u -= _, n.lens[n.have++] = y;
+					else {
+						if (y === 16) {
+							for (D = _ + 2; u < D;) {
+								if (s === 0) break inf_leave;
+								s--, l += r[a++] << u, u += 8;
+							}
+							if (l >>>= _, u -= _, n.have === 0) {
+								e.msg = "invalid bit length repeat", n.mode = Q;
+								break;
+							}
+							C = n.lens[n.have - 1], p = 3 + (l & 3), l >>>= 2, u -= 2;
+						} else if (y === 17) {
+							for (D = _ + 3; u < D;) {
+								if (s === 0) break inf_leave;
+								s--, l += r[a++] << u, u += 8;
+							}
+							l >>>= _, u -= _, C = 0, p = 3 + (l & 7), l >>>= 3, u -= 3;
+						} else {
+							for (D = _ + 7; u < D;) {
+								if (s === 0) break inf_leave;
+								s--, l += r[a++] << u, u += 8;
+							}
+							l >>>= _, u -= _, C = 0, p = 11 + (l & 127), l >>>= 7, u -= 7;
+						}
+						if (n.have + p > n.nlen + n.ndist) {
+							e.msg = "invalid bit length repeat", n.mode = Q;
+							break;
+						}
+						for (; p--;) n.lens[n.have++] = C;
+					}
+				}
+				if (n.mode === Q) break;
+				if (n.lens[256] === 0) {
+					e.msg = "invalid code -- missing end-of-block", n.mode = Q;
+					break;
+				}
+				if (n.lenbits = 9, E = { bits: n.lenbits }, w = Cn(Tn, n.lens, 0, n.nlen, n.lencode, 0, n.work, E), n.lenbits = E.bits, w) {
+					e.msg = "invalid literal/lengths set", n.mode = Q;
+					break;
+				}
+				if (n.distbits = 6, n.distcode = n.distdyn, E = { bits: n.distbits }, w = Cn(En, n.lens, n.nlen, n.ndist, n.distcode, 0, n.work, E), n.distbits = E.bits, w) {
+					e.msg = "invalid distances set", n.mode = Q;
+					break;
+				}
+				if (n.mode = tr, t === kn) break inf_leave;
+			case tr: n.mode = nr;
+			case nr:
+				if (s >= 6 && c >= 258) {
+					e.next_out = o, e.avail_out = c, e.next_in = a, e.avail_in = s, n.hold = l, n.bits = u, fn(e, f), o = e.next_out, i = e.output, c = e.avail_out, a = e.next_in, r = e.input, s = e.avail_in, l = n.hold, u = n.bits, n.mode === Z && (n.back = -1);
+					break;
+				}
+				for (n.back = 0; g = n.lencode[l & (1 << n.lenbits) - 1], _ = g >>> 24, v = g >>> 16 & 255, y = g & 65535, !(_ <= u);) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				if (v && !(v & 240)) {
+					for (b = _, x = v, S = y; g = n.lencode[S + ((l & (1 << b + x) - 1) >> b)], _ = g >>> 24, v = g >>> 16 & 255, y = g & 65535, !(b + _ <= u);) {
+						if (s === 0) break inf_leave;
+						s--, l += r[a++] << u, u += 8;
+					}
+					l >>>= b, u -= b, n.back += b;
+				}
+				if (l >>>= _, u -= _, n.back += _, n.length = y, v === 0) {
+					n.mode = sr;
+					break;
+				}
+				if (v & 32) {
+					n.back = -1, n.mode = Z;
+					break;
+				}
+				if (v & 64) {
+					e.msg = "invalid literal/length code", n.mode = Q;
+					break;
+				}
+				n.extra = v & 15, n.mode = rr;
+			case rr:
+				if (n.extra) {
+					for (D = n.extra; u < D;) {
+						if (s === 0) break inf_leave;
+						s--, l += r[a++] << u, u += 8;
+					}
+					n.length += l & (1 << n.extra) - 1, l >>>= n.extra, u -= n.extra, n.back += n.extra;
+				}
+				n.was = n.length, n.mode = ir;
+			case ir:
+				for (; g = n.distcode[l & (1 << n.distbits) - 1], _ = g >>> 24, v = g >>> 16 & 255, y = g & 65535, !(_ <= u);) {
+					if (s === 0) break inf_leave;
+					s--, l += r[a++] << u, u += 8;
+				}
+				if (!(v & 240)) {
+					for (b = _, x = v, S = y; g = n.distcode[S + ((l & (1 << b + x) - 1) >> b)], _ = g >>> 24, v = g >>> 16 & 255, y = g & 65535, !(b + _ <= u);) {
+						if (s === 0) break inf_leave;
+						s--, l += r[a++] << u, u += 8;
+					}
+					l >>>= b, u -= b, n.back += b;
+				}
+				if (l >>>= _, u -= _, n.back += _, v & 64) {
+					e.msg = "invalid distance code", n.mode = Q;
+					break;
+				}
+				n.offset = y, n.extra = v & 15, n.mode = ar;
+			case ar:
+				if (n.extra) {
+					for (D = n.extra; u < D;) {
+						if (s === 0) break inf_leave;
+						s--, l += r[a++] << u, u += 8;
+					}
+					n.offset += l & (1 << n.extra) - 1, l >>>= n.extra, u -= n.extra, n.back += n.extra;
+				}
+				if (n.offset > n.dmax) {
+					e.msg = "invalid distance too far back", n.mode = Q;
+					break;
+				}
+				n.mode = or;
+			case or:
+				if (c === 0) break inf_leave;
+				if (p = f - c, n.offset > p) {
+					if (p = n.offset - p, p > n.whave && n.sane) {
+						e.msg = "invalid distance too far back", n.mode = Q;
+						break;
+					}
+					p > n.wnext ? (p -= n.wnext, m = n.wsize - p) : m = n.wnext - p, p > n.length && (p = n.length), h = n.window;
+				} else h = i, m = o - n.offset, p = n.length;
+				p > c && (p = c), c -= p, n.length -= p;
+				do
+					i[o++] = h[m++];
+				while (--p);
+				n.length === 0 && (n.mode = nr);
+				break;
+			case sr:
+				if (c === 0) break inf_leave;
+				i[o++] = n.length, c--, n.mode = nr;
+				break;
+			case cr:
+				if (n.wrap) {
+					for (; u < 32;) {
+						if (s === 0) break inf_leave;
+						s--, l |= r[a++] << u, u += 8;
+					}
+					if (f -= c, e.total_out += f, n.total += f, n.wrap & 4 && f && (e.adler = n.check = n.flags ? N(n.check, i, f, o - f) : Ae(n.check, i, f, o - f)), f = c, n.wrap & 4 && (n.flags ? l : gr(l)) !== n.check) {
+						e.msg = "incorrect data check", n.mode = Q;
+						break;
+					}
+					l = 0, u = 0;
+				}
+				n.mode = lr;
+			case lr:
+				if (n.wrap && n.flags) {
+					for (; u < 32;) {
+						if (s === 0) break inf_leave;
+						s--, l += r[a++] << u, u += 8;
+					}
+					if (n.wrap & 4 && l !== (n.total & 4294967295)) {
+						e.msg = "incorrect length check", n.mode = Q;
+						break;
+					}
+					l = 0, u = 0;
+				}
+				n.mode = ur;
+			case ur:
+				w = jn;
+				break inf_leave;
+			case Q:
+				w = Nn;
+				break inf_leave;
+			case dr: return Pn;
+			case fr:
+			default: return X;
+		}
+		return e.next_out = o, e.avail_out = c, e.next_in = a, e.avail_in = s, n.hold = l, n.bits = u, (n.wsize || f !== e.avail_out && n.mode < Q && (n.mode < cr || t !== Dn)) && Or(e, e.output, e.next_out, f - e.avail_out), d -= e.avail_in, f -= e.avail_out, e.total_in += d, e.total_out += f, n.total += f, n.wrap & 4 && f && (e.adler = n.check = n.flags ? N(n.check, i, f, e.next_out - f) : Ae(n.check, i, f, e.next_out - f)), e.data_type = n.bits + (n.last ? 64 : 0) + (n.mode === Z ? 128 : 0) + (n.mode === tr || n.mode === Xn ? 256 : 0), (d === 0 && f === 0 || t === Dn) && w === An && (w = Fn), w;
+	},
+	inflateEnd: (e) => {
+		if (vr(e)) return X;
+		let t = e.state;
+		return t.window &&= null, e.state = null, An;
+	},
+	inflateGetHeader: (e, t) => {
+		if (vr(e)) return X;
+		let n = e.state;
+		return n.wrap & 2 ? (n.head = t, t.done = !1, An) : X;
+	},
+	inflateSetDictionary: (e, t) => {
+		let n = t.length, r, i, a;
+		return vr(e) || (r = e.state, r.wrap !== 0 && r.mode !== qn) ? X : r.mode === qn && (i = 1, i = Ae(i, t, n, 0), i !== r.check) ? Nn : (a = Or(e, t, n, n), a ? (r.mode = dr, Pn) : (r.havedict = 1, An));
+	},
+	inflateInfo: "pako inflate (from Nodeca project)"
+};
+function kr() {
+	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 = !1;
+}
+var Ar = kr, jr = Object.prototype.toString, { Z_NO_FLUSH: Mr, Z_FINISH: Nr, Z_OK: Pr, Z_STREAM_END: Fr, Z_NEED_DICT: Ir, Z_STREAM_ERROR: Lr, Z_DATA_ERROR: Rr, Z_MEM_ERROR: zr } = Ne;
+function Br(e) {
+	this.options = Bt.assign({
+		chunkSize: 1024 * 64,
+		windowBits: 15,
+		to: ""
+	}, e || {});
+	let t = this.options;
+	t.raw && t.windowBits >= 0 && t.windowBits < 16 && (t.windowBits = -t.windowBits, t.windowBits === 0 && (t.windowBits = -15)), t.windowBits >= 0 && t.windowBits < 16 && !(e && e.windowBits) && (t.windowBits += 32), t.windowBits > 15 && t.windowBits < 48 && (t.windowBits & 15 || (t.windowBits |= 15)), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new qt(), this.strm.avail_out = 0;
+	let n = $.inflateInit2(this.strm, t.windowBits);
+	if (n !== Pr || (this.header = new Ar(), $.inflateGetHeader(this.strm, this.header), t.dictionary && (typeof t.dictionary == "string" ? t.dictionary = Gt.string2buf(t.dictionary) : jr.call(t.dictionary) === "[object ArrayBuffer]" && (t.dictionary = new Uint8Array(t.dictionary)), t.raw && (n = $.inflateSetDictionary(this.strm, t.dictionary), n !== Pr)))) throw Error(Me[n]);
+}
+Br.prototype.push = function(e, t) {
+	let n = this.strm, r = this.options.chunkSize, i = this.options.dictionary, a, o, s;
+	if (this.ended) return !1;
+	for (o = t === ~~t ? t : t === !0 ? Nr : Mr, jr.call(e) === "[object ArrayBuffer]" ? n.input = new Uint8Array(e) : n.input = e, n.next_in = 0, n.avail_in = n.input.length;;) {
+		for (n.avail_out === 0 && (n.output = new Uint8Array(r), n.next_out = 0, n.avail_out = r), a = $.inflate(n, o), a === Ir && i && (a = $.inflateSetDictionary(n, i), a === Pr ? a = $.inflate(n, o) : a === Rr && (a = Ir)); n.avail_in > 0 && a === Fr && n.state.wrap > 0 && e[n.next_in] !== 0;) $.inflateReset(n), a = $.inflate(n, o);
+		switch (a) {
+			case Lr:
+			case Rr:
+			case Ir:
+			case zr: return this.onEnd(a), this.ended = !0, !1;
+		}
+		if (s = n.avail_out, n.next_out && (n.avail_out === 0 || a === Fr)) if (this.options.to === "string") {
+			let e = Gt.utf8border(n.output, n.next_out), t = n.next_out - e, i = Gt.buf2string(n.output, e);
+			n.next_out = t, n.avail_out = r - t, t && n.output.set(n.output.subarray(e, e + t), 0), this.onData(i);
+		} else this.onData(n.output.length === n.next_out ? n.output : n.output.subarray(0, n.next_out));
+		if (!(a === Pr && s === 0)) {
+			if (a === Fr) return a = $.inflateEnd(this.strm), this.onEnd(a), this.ended = !0, !0;
+			if (n.avail_in === 0) break;
+		}
+	}
+	return !0;
+}, Br.prototype.onData = function(e) {
+	this.chunks.push(e);
+}, Br.prototype.onEnd = function(e) {
+	e === Pr && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = Bt.flattenChunks(this.chunks)), this.chunks = [], this.err = e, this.msg = this.strm.msg;
+};
+function Vr(e, t) {
+	let n = new Br(t);
+	if (n.push(e), n.err) throw n.msg || Me[n.err];
+	return n.result;
+}
+function Hr(e, t) {
+	return t ||= {}, t.raw = !0, Vr(e, t);
+}
+var Ur = {
+	Inflate: Br,
+	inflate: Vr,
+	inflateRaw: Hr,
+	ungzip: Vr,
+	constants: Ne
+}, { Deflate: Wr, deflate: Gr, deflateRaw: Kr, gzip: qr } = ln, { Inflate: Jr, inflate: Yr, inflateRaw: Xr, ungzip: Zr } = Ur, Qr = Yr;
+//#endregion
+export { Qr as t };
+
+//# sourceMappingURL=pako.esm-Crx1NgSq.js.map