anytrek-front-public-component 1.13.20 → 1.13.22

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/ImageDisplayVideo-BL2h_eTu.mjs +2918 -0
  2. package/anytrek-front-public-component.mjs +2 -23846
  3. package/anytrek-front-public-component.umd.js +84 -84
  4. package/index-BrI6_G7d.mjs +24 -0
  5. package/index-D8kRViJr.mjs +259 -0
  6. package/index-sg0F8VOH.mjs +20903 -0
  7. package/package.json +1 -1
  8. package/style.css +1 -1
package/ImageDisplayVideo-BL2h_eTu.mjs ADDED
@@ -0,0 +1,2918 @@
1
+ var we = Object.defineProperty;
2
+ var ye = (gt, dt, g) => dt in gt ? we(gt, dt, { enumerable: !0, configurable: !0, writable: !0, value: g }) : gt[dt] = g;
3
+ var Ft = (gt, dt, g) => ye(gt, typeof dt != "symbol" ? dt + "" : dt, g);
4
+ import { ElButton as ke } from "element-plus/es";
5
+ import "element-plus/es/components/base/style/css";
6
+ import "element-plus/es/components/button/style/css";
7
+ import { b as xe, L as ie, _ as Se, u as Ee, a as Ce } from "./index-sg0F8VOH.mjs";
8
+ import { defineComponent as ze, ref as pt, computed as qt, watch as ae, onMounted as Ae, onBeforeUnmount as Ie, openBlock as zt, createElementBlock as At, normalizeStyle as Lt, createElementVNode as ft, toDisplayString as It, unref as se, createCommentVNode as Gt, createVNode as Ot, Transition as oe, withCtx as Kt, withDirectives as Jt, vShow as Qt, withModifiers as Bt, Fragment as le, renderList as ue, normalizeClass as he } from "vue";
9
+ import { g as Te, c as Xt, H as ce, P as Oe } from "./xgplayer-Cpii7T5s.mjs";
10
+ function $t(gt) {
11
+ throw new Error('Could not dynamically require "' + gt + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
12
+ }
13
+ var pe = { exports: {} };
14
+ /*!
15
+
16
+ JSZip v3.10.1 - A JavaScript class for generating and reading zip files
17
+ <http://stuartk.com/jszip>
18
+
19
+ (c) 2009-2016 Stuart Knightley <stuart [at] stuartk.com>
20
+ Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/main/LICENSE.markdown.
21
+
22
+ JSZip uses the library pako released under the MIT license :
23
+ https://github.com/nodeca/pako/blob/main/LICENSE
24
+ */
25
+ (function(gt, dt) {
26
+ (function(g) {
27
+ gt.exports = g();
28
+ })(function() {
29
+ return function g(U, y, h) {
30
+ function l(_, b) {
31
+ if (!y[_]) {
32
+ if (!U[_]) {
33
+ var p = typeof $t == "function" && $t;
34
+ if (!b && p) return p(_, !0);
35
+ if (r) return r(_, !0);
36
+ var v = new Error("Cannot find module '" + _ + "'");
37
+ throw v.code = "MODULE_NOT_FOUND", v;
38
+ }
39
+ var i = y[_] = { exports: {} };
40
+ U[_][0].call(i.exports, function(f) {
41
+ var n = U[_][1][f];
42
+ return l(n || f);
43
+ }, i, i.exports, g, U, y, h);
44
+ }
45
+ return y[_].exports;
46
+ }
47
+ for (var r = typeof $t == "function" && $t, s = 0; s < h.length; s++) l(h[s]);
48
+ return l;
49
+ }({ 1: [function(g, U, y) {
50
+ var h = g("./utils"), l = g("./support"), r = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
51
+ y.encode = function(s) {
52
+ for (var _, b, p, v, i, f, n, u = [], a = 0, d = s.length, w = d, S = h.getTypeOf(s) !== "string"; a < s.length; ) w = d - a, p = S ? (_ = s[a++], b = a < d ? s[a++] : 0, a < d ? s[a++] : 0) : (_ = s.charCodeAt(a++), b = a < d ? s.charCodeAt(a++) : 0, a < d ? s.charCodeAt(a++) : 0), v = _ >> 2, i = (3 & _) << 4 | b >> 4, f = 1 < w ? (15 & b) << 2 | p >> 6 : 64, n = 2 < w ? 63 & p : 64, u.push(r.charAt(v) + r.charAt(i) + r.charAt(f) + r.charAt(n));
53
+ return u.join("");
54
+ }, y.decode = function(s) {
55
+ var _, b, p, v, i, f, n = 0, u = 0, a = "data:";
56
+ if (s.substr(0, a.length) === a) throw new Error("Invalid base64 input, it looks like a data url.");
57
+ var d, w = 3 * (s = s.replace(/[^A-Za-z0-9+/=]/g, "")).length / 4;
58
+ if (s.charAt(s.length - 1) === r.charAt(64) && w--, s.charAt(s.length - 2) === r.charAt(64) && w--, w % 1 != 0) throw new Error("Invalid base64 input, bad content length.");
59
+ for (d = l.uint8array ? new Uint8Array(0 | w) : new Array(0 | w); n < s.length; ) _ = r.indexOf(s.charAt(n++)) << 2 | (v = r.indexOf(s.charAt(n++))) >> 4, b = (15 & v) << 4 | (i = r.indexOf(s.charAt(n++))) >> 2, p = (3 & i) << 6 | (f = r.indexOf(s.charAt(n++))), d[u++] = _, i !== 64 && (d[u++] = b), f !== 64 && (d[u++] = p);
60
+ return d;
61
+ };
62
+ }, { "./support": 30, "./utils": 32 }], 2: [function(g, U, y) {
63
+ var h = g("./external"), l = g("./stream/DataWorker"), r = g("./stream/Crc32Probe"), s = g("./stream/DataLengthProbe");
64
+ function _(b, p, v, i, f) {
65
+ this.compressedSize = b, this.uncompressedSize = p, this.crc32 = v, this.compression = i, this.compressedContent = f;
66
+ }
67
+ _.prototype = { getContentWorker: function() {
68
+ var b = new l(h.Promise.resolve(this.compressedContent)).pipe(this.compression.uncompressWorker()).pipe(new s("data_length")), p = this;
69
+ return b.on("end", function() {
70
+ if (this.streamInfo.data_length !== p.uncompressedSize) throw new Error("Bug : uncompressed data size mismatch");
71
+ }), b;
72
+ }, getCompressedWorker: function() {
73
+ return new l(h.Promise.resolve(this.compressedContent)).withStreamInfo("compressedSize", this.compressedSize).withStreamInfo("uncompressedSize", this.uncompressedSize).withStreamInfo("crc32", this.crc32).withStreamInfo("compression", this.compression);
74
+ } }, _.createWorkerFrom = function(b, p, v) {
75
+ return b.pipe(new r()).pipe(new s("uncompressedSize")).pipe(p.compressWorker(v)).pipe(new s("compressedSize")).withStreamInfo("compression", p);
76
+ }, U.exports = _;
77
+ }, { "./external": 6, "./stream/Crc32Probe": 25, "./stream/DataLengthProbe": 26, "./stream/DataWorker": 27 }], 3: [function(g, U, y) {
78
+ var h = g("./stream/GenericWorker");
79
+ y.STORE = { magic: "\0\0", compressWorker: function() {
80
+ return new h("STORE compression");
81
+ }, uncompressWorker: function() {
82
+ return new h("STORE decompression");
83
+ } }, y.DEFLATE = g("./flate");
84
+ }, { "./flate": 7, "./stream/GenericWorker": 28 }], 4: [function(g, U, y) {
85
+ var h = g("./utils"), l = function() {
86
+ for (var r, s = [], _ = 0; _ < 256; _++) {
87
+ r = _;
88
+ for (var b = 0; b < 8; b++) r = 1 & r ? 3988292384 ^ r >>> 1 : r >>> 1;
89
+ s[_] = r;
90
+ }
91
+ return s;
92
+ }();
93
+ U.exports = function(r, s) {
94
+ return r !== void 0 && r.length ? h.getTypeOf(r) !== "string" ? function(_, b, p, v) {
95
+ var i = l, f = v + p;
96
+ _ ^= -1;
97
+ for (var n = v; n < f; n++) _ = _ >>> 8 ^ i[255 & (_ ^ b[n])];
98
+ return -1 ^ _;
99
+ }(0 | s, r, r.length, 0) : function(_, b, p, v) {
100
+ var i = l, f = v + p;
101
+ _ ^= -1;
102
+ for (var n = v; n < f; n++) _ = _ >>> 8 ^ i[255 & (_ ^ b.charCodeAt(n))];
103
+ return -1 ^ _;
104
+ }(0 | s, r, r.length, 0) : 0;
105
+ };
106
+ }, { "./utils": 32 }], 5: [function(g, U, y) {
107
+ y.base64 = !1, y.binary = !1, y.dir = !1, y.createFolders = !0, y.date = null, y.compression = null, y.compressionOptions = null, y.comment = null, y.unixPermissions = null, y.dosPermissions = null;
108
+ }, {}], 6: [function(g, U, y) {
109
+ var h = null;
110
+ h = typeof Promise < "u" ? Promise : g("lie"), U.exports = { Promise: h };
111
+ }, { lie: 37 }], 7: [function(g, U, y) {
112
+ var h = typeof Uint8Array < "u" && typeof Uint16Array < "u" && typeof Uint32Array < "u", l = g("pako"), r = g("./utils"), s = g("./stream/GenericWorker"), _ = h ? "uint8array" : "array";
113
+ function b(p, v) {
114
+ s.call(this, "FlateWorker/" + p), this._pako = null, this._pakoAction = p, this._pakoOptions = v, this.meta = {};
115
+ }
116
+ y.magic = "\b\0", r.inherits(b, s), b.prototype.processChunk = function(p) {
117
+ this.meta = p.meta, this._pako === null && this._createPako(), this._pako.push(r.transformTo(_, p.data), !1);
118
+ }, b.prototype.flush = function() {
119
+ s.prototype.flush.call(this), this._pako === null && this._createPako(), this._pako.push([], !0);
120
+ }, b.prototype.cleanUp = function() {
121
+ s.prototype.cleanUp.call(this), this._pako = null;
122
+ }, b.prototype._createPako = function() {
123
+ this._pako = new l[this._pakoAction]({ raw: !0, level: this._pakoOptions.level || -1 });
124
+ var p = this;
125
+ this._pako.onData = function(v) {
126
+ p.push({ data: v, meta: p.meta });
127
+ };
128
+ }, y.compressWorker = function(p) {
129
+ return new b("Deflate", p);
130
+ }, y.uncompressWorker = function() {
131
+ return new b("Inflate", {});
132
+ };
133
+ }, { "./stream/GenericWorker": 28, "./utils": 32, pako: 38 }], 8: [function(g, U, y) {
134
+ function h(i, f) {
135
+ var n, u = "";
136
+ for (n = 0; n < f; n++) u += String.fromCharCode(255 & i), i >>>= 8;
137
+ return u;
138
+ }
139
+ function l(i, f, n, u, a, d) {
140
+ var w, S, x = i.file, B = i.compression, T = d !== _.utf8encode, M = r.transformTo("string", d(x.name)), I = r.transformTo("string", _.utf8encode(x.name)), W = x.comment, J = r.transformTo("string", d(W)), m = r.transformTo("string", _.utf8encode(W)), O = I.length !== x.name.length, e = m.length !== W.length, F = "", rt = "", P = "", nt = x.dir, Z = x.date, Q = { crc32: 0, compressedSize: 0, uncompressedSize: 0 };
141
+ f && !n || (Q.crc32 = i.crc32, Q.compressedSize = i.compressedSize, Q.uncompressedSize = i.uncompressedSize);
142
+ var A = 0;
143
+ f && (A |= 8), T || !O && !e || (A |= 2048);
144
+ var C = 0, tt = 0;
145
+ nt && (C |= 16), a === "UNIX" ? (tt = 798, C |= function(K, lt) {
146
+ var _t = K;
147
+ return K || (_t = lt ? 16893 : 33204), (65535 & _t) << 16;
148
+ }(x.unixPermissions, nt)) : (tt = 20, C |= function(K) {
149
+ return 63 & (K || 0);
150
+ }(x.dosPermissions)), w = Z.getUTCHours(), w <<= 6, w |= Z.getUTCMinutes(), w <<= 5, w |= Z.getUTCSeconds() / 2, S = Z.getUTCFullYear() - 1980, S <<= 4, S |= Z.getUTCMonth() + 1, S <<= 5, S |= Z.getUTCDate(), O && (rt = h(1, 1) + h(b(M), 4) + I, F += "up" + h(rt.length, 2) + rt), e && (P = h(1, 1) + h(b(J), 4) + m, F += "uc" + h(P.length, 2) + P);
151
+ var X = "";
152
+ return X += `
153
+ \0`, X += h(A, 2), X += B.magic, X += h(w, 2), X += h(S, 2), X += h(Q.crc32, 4), X += h(Q.compressedSize, 4), X += h(Q.uncompressedSize, 4), X += h(M.length, 2), X += h(F.length, 2), { fileRecord: p.LOCAL_FILE_HEADER + X + M + F, dirRecord: p.CENTRAL_FILE_HEADER + h(tt, 2) + X + h(J.length, 2) + "\0\0\0\0" + h(C, 4) + h(u, 4) + M + F + J };
154
+ }
155
+ var r = g("../utils"), s = g("../stream/GenericWorker"), _ = g("../utf8"), b = g("../crc32"), p = g("../signature");
156
+ function v(i, f, n, u) {
157
+ s.call(this, "ZipFileWorker"), this.bytesWritten = 0, this.zipComment = f, this.zipPlatform = n, this.encodeFileName = u, this.streamFiles = i, this.accumulate = !1, this.contentBuffer = [], this.dirRecords = [], this.currentSourceOffset = 0, this.entriesCount = 0, this.currentFile = null, this._sources = [];
158
+ }
159
+ r.inherits(v, s), v.prototype.push = function(i) {
160
+ var f = i.meta.percent || 0, n = this.entriesCount, u = this._sources.length;
161
+ this.accumulate ? this.contentBuffer.push(i) : (this.bytesWritten += i.data.length, s.prototype.push.call(this, { data: i.data, meta: { currentFile: this.currentFile, percent: n ? (f + 100 * (n - u - 1)) / n : 100 } }));
162
+ }, v.prototype.openedSource = function(i) {
163
+ this.currentSourceOffset = this.bytesWritten, this.currentFile = i.file.name;
164
+ var f = this.streamFiles && !i.file.dir;
165
+ if (f) {
166
+ var n = l(i, f, !1, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);
167
+ this.push({ data: n.fileRecord, meta: { percent: 0 } });
168
+ } else this.accumulate = !0;
169
+ }, v.prototype.closedSource = function(i) {
170
+ this.accumulate = !1;
171
+ var f = this.streamFiles && !i.file.dir, n = l(i, f, !0, this.currentSourceOffset, this.zipPlatform, this.encodeFileName);
172
+ if (this.dirRecords.push(n.dirRecord), f) this.push({ data: function(u) {
173
+ return p.DATA_DESCRIPTOR + h(u.crc32, 4) + h(u.compressedSize, 4) + h(u.uncompressedSize, 4);
174
+ }(i), meta: { percent: 100 } });
175
+ else for (this.push({ data: n.fileRecord, meta: { percent: 0 } }); this.contentBuffer.length; ) this.push(this.contentBuffer.shift());
176
+ this.currentFile = null;
177
+ }, v.prototype.flush = function() {
178
+ for (var i = this.bytesWritten, f = 0; f < this.dirRecords.length; f++) this.push({ data: this.dirRecords[f], meta: { percent: 100 } });
179
+ var n = this.bytesWritten - i, u = function(a, d, w, S, x) {
180
+ var B = r.transformTo("string", x(S));
181
+ return p.CENTRAL_DIRECTORY_END + "\0\0\0\0" + h(a, 2) + h(a, 2) + h(d, 4) + h(w, 4) + h(B.length, 2) + B;
182
+ }(this.dirRecords.length, n, i, this.zipComment, this.encodeFileName);
183
+ this.push({ data: u, meta: { percent: 100 } });
184
+ }, v.prototype.prepareNextSource = function() {
185
+ this.previous = this._sources.shift(), this.openedSource(this.previous.streamInfo), this.isPaused ? this.previous.pause() : this.previous.resume();
186
+ }, v.prototype.registerPrevious = function(i) {
187
+ this._sources.push(i);
188
+ var f = this;
189
+ return i.on("data", function(n) {
190
+ f.processChunk(n);
191
+ }), i.on("end", function() {
192
+ f.closedSource(f.previous.streamInfo), f._sources.length ? f.prepareNextSource() : f.end();
193
+ }), i.on("error", function(n) {
194
+ f.error(n);
195
+ }), this;
196
+ }, v.prototype.resume = function() {
197
+ return !!s.prototype.resume.call(this) && (!this.previous && this._sources.length ? (this.prepareNextSource(), !0) : this.previous || this._sources.length || this.generatedError ? void 0 : (this.end(), !0));
198
+ }, v.prototype.error = function(i) {
199
+ var f = this._sources;
200
+ if (!s.prototype.error.call(this, i)) return !1;
201
+ for (var n = 0; n < f.length; n++) try {
202
+ f[n].error(i);
203
+ } catch {
204
+ }
205
+ return !0;
206
+ }, v.prototype.lock = function() {
207
+ s.prototype.lock.call(this);
208
+ for (var i = this._sources, f = 0; f < i.length; f++) i[f].lock();
209
+ }, U.exports = v;
210
+ }, { "../crc32": 4, "../signature": 23, "../stream/GenericWorker": 28, "../utf8": 31, "../utils": 32 }], 9: [function(g, U, y) {
211
+ var h = g("../compressions"), l = g("./ZipFileWorker");
212
+ y.generateWorker = function(r, s, _) {
213
+ var b = new l(s.streamFiles, _, s.platform, s.encodeFileName), p = 0;
214
+ try {
215
+ r.forEach(function(v, i) {
216
+ p++;
217
+ var f = function(d, w) {
218
+ var S = d || w, x = h[S];
219
+ if (!x) throw new Error(S + " is not a valid compression method !");
220
+ return x;
221
+ }(i.options.compression, s.compression), n = i.options.compressionOptions || s.compressionOptions || {}, u = i.dir, a = i.date;
222
+ i._compressWorker(f, n).withStreamInfo("file", { name: v, dir: u, date: a, comment: i.comment || "", unixPermissions: i.unixPermissions, dosPermissions: i.dosPermissions }).pipe(b);
223
+ }), b.entriesCount = p;
224
+ } catch (v) {
225
+ b.error(v);
226
+ }
227
+ return b;
228
+ };
229
+ }, { "../compressions": 3, "./ZipFileWorker": 8 }], 10: [function(g, U, y) {
230
+ function h() {
231
+ if (!(this instanceof h)) return new h();
232
+ if (arguments.length) throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
233
+ this.files = /* @__PURE__ */ Object.create(null), this.comment = null, this.root = "", this.clone = function() {
234
+ var l = new h();
235
+ for (var r in this) typeof this[r] != "function" && (l[r] = this[r]);
236
+ return l;
237
+ };
238
+ }
239
+ (h.prototype = g("./object")).loadAsync = g("./load"), h.support = g("./support"), h.defaults = g("./defaults"), h.version = "3.10.1", h.loadAsync = function(l, r) {
240
+ return new h().loadAsync(l, r);
241
+ }, h.external = g("./external"), U.exports = h;
242
+ }, { "./defaults": 5, "./external": 6, "./load": 11, "./object": 15, "./support": 30 }], 11: [function(g, U, y) {
243
+ var h = g("./utils"), l = g("./external"), r = g("./utf8"), s = g("./zipEntries"), _ = g("./stream/Crc32Probe"), b = g("./nodejsUtils");
244
+ function p(v) {
245
+ return new l.Promise(function(i, f) {
246
+ var n = v.decompressed.getContentWorker().pipe(new _());
247
+ n.on("error", function(u) {
248
+ f(u);
249
+ }).on("end", function() {
250
+ n.streamInfo.crc32 !== v.decompressed.crc32 ? f(new Error("Corrupted zip : CRC32 mismatch")) : i();
251
+ }).resume();
252
+ });
253
+ }
254
+ U.exports = function(v, i) {
255
+ var f = this;
256
+ return i = h.extend(i || {}, { base64: !1, checkCRC32: !1, optimizedBinaryString: !1, createFolders: !1, decodeFileName: r.utf8decode }), b.isNode && b.isStream(v) ? l.Promise.reject(new Error("JSZip can't accept a stream when loading a zip file.")) : h.prepareContent("the loaded zip file", v, !0, i.optimizedBinaryString, i.base64).then(function(n) {
257
+ var u = new s(i);
258
+ return u.load(n), u;
259
+ }).then(function(n) {
260
+ var u = [l.Promise.resolve(n)], a = n.files;
261
+ if (i.checkCRC32) for (var d = 0; d < a.length; d++) u.push(p(a[d]));
262
+ return l.Promise.all(u);
263
+ }).then(function(n) {
264
+ for (var u = n.shift(), a = u.files, d = 0; d < a.length; d++) {
265
+ var w = a[d], S = w.fileNameStr, x = h.resolve(w.fileNameStr);
266
+ f.file(x, w.decompressed, { binary: !0, optimizedBinaryString: !0, date: w.date, dir: w.dir, comment: w.fileCommentStr.length ? w.fileCommentStr : null, unixPermissions: w.unixPermissions, dosPermissions: w.dosPermissions, createFolders: i.createFolders }), w.dir || (f.file(x).unsafeOriginalName = S);
267
+ }
268
+ return u.zipComment.length && (f.comment = u.zipComment), f;
269
+ });
270
+ };
271
+ }, { "./external": 6, "./nodejsUtils": 14, "./stream/Crc32Probe": 25, "./utf8": 31, "./utils": 32, "./zipEntries": 33 }], 12: [function(g, U, y) {
272
+ var h = g("../utils"), l = g("../stream/GenericWorker");
273
+ function r(s, _) {
274
+ l.call(this, "Nodejs stream input adapter for " + s), this._upstreamEnded = !1, this._bindStream(_);
275
+ }
276
+ h.inherits(r, l), r.prototype._bindStream = function(s) {
277
+ var _ = this;
278
+ (this._stream = s).pause(), s.on("data", function(b) {
279
+ _.push({ data: b, meta: { percent: 0 } });
280
+ }).on("error", function(b) {
281
+ _.isPaused ? this.generatedError = b : _.error(b);
282
+ }).on("end", function() {
283
+ _.isPaused ? _._upstreamEnded = !0 : _.end();
284
+ });
285
+ }, r.prototype.pause = function() {
286
+ return !!l.prototype.pause.call(this) && (this._stream.pause(), !0);
287
+ }, r.prototype.resume = function() {
288
+ return !!l.prototype.resume.call(this) && (this._upstreamEnded ? this.end() : this._stream.resume(), !0);
289
+ }, U.exports = r;
290
+ }, { "../stream/GenericWorker": 28, "../utils": 32 }], 13: [function(g, U, y) {
291
+ var h = g("readable-stream").Readable;
292
+ function l(r, s, _) {
293
+ h.call(this, s), this._helper = r;
294
+ var b = this;
295
+ r.on("data", function(p, v) {
296
+ b.push(p) || b._helper.pause(), _ && _(v);
297
+ }).on("error", function(p) {
298
+ b.emit("error", p);
299
+ }).on("end", function() {
300
+ b.push(null);
301
+ });
302
+ }
303
+ g("../utils").inherits(l, h), l.prototype._read = function() {
304
+ this._helper.resume();
305
+ }, U.exports = l;
306
+ }, { "../utils": 32, "readable-stream": 16 }], 14: [function(g, U, y) {
307
+ U.exports = { isNode: typeof Buffer < "u", newBufferFrom: function(h, l) {
308
+ if (Buffer.from && Buffer.from !== Uint8Array.from) return Buffer.from(h, l);
309
+ if (typeof h == "number") throw new Error('The "data" argument must not be a number');
310
+ return new Buffer(h, l);
311
+ }, allocBuffer: function(h) {
312
+ if (Buffer.alloc) return Buffer.alloc(h);
313
+ var l = new Buffer(h);
314
+ return l.fill(0), l;
315
+ }, isBuffer: function(h) {
316
+ return Buffer.isBuffer(h);
317
+ }, isStream: function(h) {
318
+ return h && typeof h.on == "function" && typeof h.pause == "function" && typeof h.resume == "function";
319
+ } };
320
+ }, {}], 15: [function(g, U, y) {
321
+ function h(x, B, T) {
322
+ var M, I = r.getTypeOf(B), W = r.extend(T || {}, b);
323
+ W.date = W.date || /* @__PURE__ */ new Date(), W.compression !== null && (W.compression = W.compression.toUpperCase()), typeof W.unixPermissions == "string" && (W.unixPermissions = parseInt(W.unixPermissions, 8)), W.unixPermissions && 16384 & W.unixPermissions && (W.dir = !0), W.dosPermissions && 16 & W.dosPermissions && (W.dir = !0), W.dir && (x = a(x)), W.createFolders && (M = u(x)) && d.call(this, M, !0);
324
+ var J = I === "string" && W.binary === !1 && W.base64 === !1;
325
+ T && T.binary !== void 0 || (W.binary = !J), (B instanceof p && B.uncompressedSize === 0 || W.dir || !B || B.length === 0) && (W.base64 = !1, W.binary = !0, B = "", W.compression = "STORE", I = "string");
326
+ var m = null;
327
+ m = B instanceof p || B instanceof s ? B : f.isNode && f.isStream(B) ? new n(x, B) : r.prepareContent(x, B, W.binary, W.optimizedBinaryString, W.base64);
328
+ var O = new v(x, m, W);
329
+ this.files[x] = O;
330
+ }
331
+ var l = g("./utf8"), r = g("./utils"), s = g("./stream/GenericWorker"), _ = g("./stream/StreamHelper"), b = g("./defaults"), p = g("./compressedObject"), v = g("./zipObject"), i = g("./generate"), f = g("./nodejsUtils"), n = g("./nodejs/NodejsStreamInputAdapter"), u = function(x) {
332
+ x.slice(-1) === "/" && (x = x.substring(0, x.length - 1));
333
+ var B = x.lastIndexOf("/");
334
+ return 0 < B ? x.substring(0, B) : "";
335
+ }, a = function(x) {
336
+ return x.slice(-1) !== "/" && (x += "/"), x;
337
+ }, d = function(x, B) {
338
+ return B = B !== void 0 ? B : b.createFolders, x = a(x), this.files[x] || h.call(this, x, null, { dir: !0, createFolders: B }), this.files[x];
339
+ };
340
+ function w(x) {
341
+ return Object.prototype.toString.call(x) === "[object RegExp]";
342
+ }
343
+ var S = { load: function() {
344
+ throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
345
+ }, forEach: function(x) {
346
+ var B, T, M;
347
+ for (B in this.files) M = this.files[B], (T = B.slice(this.root.length, B.length)) && B.slice(0, this.root.length) === this.root && x(T, M);
348
+ }, filter: function(x) {
349
+ var B = [];
350
+ return this.forEach(function(T, M) {
351
+ x(T, M) && B.push(M);
352
+ }), B;
353
+ }, file: function(x, B, T) {
354
+ if (arguments.length !== 1) return x = this.root + x, h.call(this, x, B, T), this;
355
+ if (w(x)) {
356
+ var M = x;
357
+ return this.filter(function(W, J) {
358
+ return !J.dir && M.test(W);
359
+ });
360
+ }
361
+ var I = this.files[this.root + x];
362
+ return I && !I.dir ? I : null;
363
+ }, folder: function(x) {
364
+ if (!x) return this;
365
+ if (w(x)) return this.filter(function(I, W) {
366
+ return W.dir && x.test(I);
367
+ });
368
+ var B = this.root + x, T = d.call(this, B), M = this.clone();
369
+ return M.root = T.name, M;
370
+ }, remove: function(x) {
371
+ x = this.root + x;
372
+ var B = this.files[x];
373
+ if (B || (x.slice(-1) !== "/" && (x += "/"), B = this.files[x]), B && !B.dir) delete this.files[x];
374
+ else for (var T = this.filter(function(I, W) {
375
+ return W.name.slice(0, x.length) === x;
376
+ }), M = 0; M < T.length; M++) delete this.files[T[M].name];
377
+ return this;
378
+ }, generate: function() {
379
+ throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
380
+ }, generateInternalStream: function(x) {
381
+ var B, T = {};
382
+ try {
383
+ if ((T = r.extend(x || {}, { streamFiles: !1, compression: "STORE", compressionOptions: null, type: "", platform: "DOS", comment: null, mimeType: "application/zip", encodeFileName: l.utf8encode })).type = T.type.toLowerCase(), T.compression = T.compression.toUpperCase(), T.type === "binarystring" && (T.type = "string"), !T.type) throw new Error("No output type specified.");
384
+ r.checkSupport(T.type), T.platform !== "darwin" && T.platform !== "freebsd" && T.platform !== "linux" && T.platform !== "sunos" || (T.platform = "UNIX"), T.platform === "win32" && (T.platform = "DOS");
385
+ var M = T.comment || this.comment || "";
386
+ B = i.generateWorker(this, T, M);
387
+ } catch (I) {
388
+ (B = new s("error")).error(I);
389
+ }
390
+ return new _(B, T.type || "string", T.mimeType);
391
+ }, generateAsync: function(x, B) {
392
+ return this.generateInternalStream(x).accumulate(B);
393
+ }, generateNodeStream: function(x, B) {
394
+ return (x = x || {}).type || (x.type = "nodebuffer"), this.generateInternalStream(x).toNodejsStream(B);
395
+ } };
396
+ U.exports = S;
397
+ }, { "./compressedObject": 2, "./defaults": 5, "./generate": 9, "./nodejs/NodejsStreamInputAdapter": 12, "./nodejsUtils": 14, "./stream/GenericWorker": 28, "./stream/StreamHelper": 29, "./utf8": 31, "./utils": 32, "./zipObject": 35 }], 16: [function(g, U, y) {
398
+ U.exports = g("stream");
399
+ }, { stream: void 0 }], 17: [function(g, U, y) {
400
+ var h = g("./DataReader");
401
+ function l(r) {
402
+ h.call(this, r);
403
+ for (var s = 0; s < this.data.length; s++) r[s] = 255 & r[s];
404
+ }
405
+ g("../utils").inherits(l, h), l.prototype.byteAt = function(r) {
406
+ return this.data[this.zero + r];
407
+ }, l.prototype.lastIndexOfSignature = function(r) {
408
+ for (var s = r.charCodeAt(0), _ = r.charCodeAt(1), b = r.charCodeAt(2), p = r.charCodeAt(3), v = this.length - 4; 0 <= v; --v) if (this.data[v] === s && this.data[v + 1] === _ && this.data[v + 2] === b && this.data[v + 3] === p) return v - this.zero;
409
+ return -1;
410
+ }, l.prototype.readAndCheckSignature = function(r) {
411
+ var s = r.charCodeAt(0), _ = r.charCodeAt(1), b = r.charCodeAt(2), p = r.charCodeAt(3), v = this.readData(4);
412
+ return s === v[0] && _ === v[1] && b === v[2] && p === v[3];
413
+ }, l.prototype.readData = function(r) {
414
+ if (this.checkOffset(r), r === 0) return [];
415
+ var s = this.data.slice(this.zero + this.index, this.zero + this.index + r);
416
+ return this.index += r, s;
417
+ }, U.exports = l;
418
+ }, { "../utils": 32, "./DataReader": 18 }], 18: [function(g, U, y) {
419
+ var h = g("../utils");
420
+ function l(r) {
421
+ this.data = r, this.length = r.length, this.index = 0, this.zero = 0;
422
+ }
423
+ l.prototype = { checkOffset: function(r) {
424
+ this.checkIndex(this.index + r);
425
+ }, checkIndex: function(r) {
426
+ if (this.length < this.zero + r || r < 0) throw new Error("End of data reached (data length = " + this.length + ", asked index = " + r + "). Corrupted zip ?");
427
+ }, setIndex: function(r) {
428
+ this.checkIndex(r), this.index = r;
429
+ }, skip: function(r) {
430
+ this.setIndex(this.index + r);
431
+ }, byteAt: function() {
432
+ }, readInt: function(r) {
433
+ var s, _ = 0;
434
+ for (this.checkOffset(r), s = this.index + r - 1; s >= this.index; s--) _ = (_ << 8) + this.byteAt(s);
435
+ return this.index += r, _;
436
+ }, readString: function(r) {
437
+ return h.transformTo("string", this.readData(r));
438
+ }, readData: function() {
439
+ }, lastIndexOfSignature: function() {
440
+ }, readAndCheckSignature: function() {
441
+ }, readDate: function() {
442
+ var r = this.readInt(4);
443
+ return new Date(Date.UTC(1980 + (r >> 25 & 127), (r >> 21 & 15) - 1, r >> 16 & 31, r >> 11 & 31, r >> 5 & 63, (31 & r) << 1));
444
+ } }, U.exports = l;
445
+ }, { "../utils": 32 }], 19: [function(g, U, y) {
446
+ var h = g("./Uint8ArrayReader");
447
+ function l(r) {
448
+ h.call(this, r);
449
+ }
450
+ g("../utils").inherits(l, h), l.prototype.readData = function(r) {
451
+ this.checkOffset(r);
452
+ var s = this.data.slice(this.zero + this.index, this.zero + this.index + r);
453
+ return this.index += r, s;
454
+ }, U.exports = l;
455
+ }, { "../utils": 32, "./Uint8ArrayReader": 21 }], 20: [function(g, U, y) {
456
+ var h = g("./DataReader");
457
+ function l(r) {
458
+ h.call(this, r);
459
+ }
460
+ g("../utils").inherits(l, h), l.prototype.byteAt = function(r) {
461
+ return this.data.charCodeAt(this.zero + r);
462
+ }, l.prototype.lastIndexOfSignature = function(r) {
463
+ return this.data.lastIndexOf(r) - this.zero;
464
+ }, l.prototype.readAndCheckSignature = function(r) {
465
+ return r === this.readData(4);
466
+ }, l.prototype.readData = function(r) {
467
+ this.checkOffset(r);
468
+ var s = this.data.slice(this.zero + this.index, this.zero + this.index + r);
469
+ return this.index += r, s;
470
+ }, U.exports = l;
471
+ }, { "../utils": 32, "./DataReader": 18 }], 21: [function(g, U, y) {
472
+ var h = g("./ArrayReader");
473
+ function l(r) {
474
+ h.call(this, r);
475
+ }
476
+ g("../utils").inherits(l, h), l.prototype.readData = function(r) {
477
+ if (this.checkOffset(r), r === 0) return new Uint8Array(0);
478
+ var s = this.data.subarray(this.zero + this.index, this.zero + this.index + r);
479
+ return this.index += r, s;
480
+ }, U.exports = l;
481
+ }, { "../utils": 32, "./ArrayReader": 17 }], 22: [function(g, U, y) {
482
+ var h = g("../utils"), l = g("../support"), r = g("./ArrayReader"), s = g("./StringReader"), _ = g("./NodeBufferReader"), b = g("./Uint8ArrayReader");
483
+ U.exports = function(p) {
484
+ var v = h.getTypeOf(p);
485
+ return h.checkSupport(v), v !== "string" || l.uint8array ? v === "nodebuffer" ? new _(p) : l.uint8array ? new b(h.transformTo("uint8array", p)) : new r(h.transformTo("array", p)) : new s(p);
486
+ };
487
+ }, { "../support": 30, "../utils": 32, "./ArrayReader": 17, "./NodeBufferReader": 19, "./StringReader": 20, "./Uint8ArrayReader": 21 }], 23: [function(g, U, y) {
488
+ y.LOCAL_FILE_HEADER = "PK", y.CENTRAL_FILE_HEADER = "PK", y.CENTRAL_DIRECTORY_END = "PK", y.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x07", y.ZIP64_CENTRAL_DIRECTORY_END = "PK", y.DATA_DESCRIPTOR = "PK\x07\b";
489
+ }, {}], 24: [function(g, U, y) {
490
+ var h = g("./GenericWorker"), l = g("../utils");
491
+ function r(s) {
492
+ h.call(this, "ConvertWorker to " + s), this.destType = s;
493
+ }
494
+ l.inherits(r, h), r.prototype.processChunk = function(s) {
495
+ this.push({ data: l.transformTo(this.destType, s.data), meta: s.meta });
496
+ }, U.exports = r;
497
+ }, { "../utils": 32, "./GenericWorker": 28 }], 25: [function(g, U, y) {
498
+ var h = g("./GenericWorker"), l = g("../crc32");
499
+ function r() {
500
+ h.call(this, "Crc32Probe"), this.withStreamInfo("crc32", 0);
501
+ }
502
+ g("../utils").inherits(r, h), r.prototype.processChunk = function(s) {
503
+ this.streamInfo.crc32 = l(s.data, this.streamInfo.crc32 || 0), this.push(s);
504
+ }, U.exports = r;
505
+ }, { "../crc32": 4, "../utils": 32, "./GenericWorker": 28 }], 26: [function(g, U, y) {
506
+ var h = g("../utils"), l = g("./GenericWorker");
507
+ function r(s) {
508
+ l.call(this, "DataLengthProbe for " + s), this.propName = s, this.withStreamInfo(s, 0);
509
+ }
510
+ h.inherits(r, l), r.prototype.processChunk = function(s) {
511
+ if (s) {
512
+ var _ = this.streamInfo[this.propName] || 0;
513
+ this.streamInfo[this.propName] = _ + s.data.length;
514
+ }
515
+ l.prototype.processChunk.call(this, s);
516
+ }, U.exports = r;
517
+ }, { "../utils": 32, "./GenericWorker": 28 }], 27: [function(g, U, y) {
518
+ var h = g("../utils"), l = g("./GenericWorker");
519
+ function r(s) {
520
+ l.call(this, "DataWorker");
521
+ var _ = this;
522
+ this.dataIsReady = !1, this.index = 0, this.max = 0, this.data = null, this.type = "", this._tickScheduled = !1, s.then(function(b) {
523
+ _.dataIsReady = !0, _.data = b, _.max = b && b.length || 0, _.type = h.getTypeOf(b), _.isPaused || _._tickAndRepeat();
524
+ }, function(b) {
525
+ _.error(b);
526
+ });
527
+ }
528
+ h.inherits(r, l), r.prototype.cleanUp = function() {
529
+ l.prototype.cleanUp.call(this), this.data = null;
530
+ }, r.prototype.resume = function() {
531
+ return !!l.prototype.resume.call(this) && (!this._tickScheduled && this.dataIsReady && (this._tickScheduled = !0, h.delay(this._tickAndRepeat, [], this)), !0);
532
+ }, r.prototype._tickAndRepeat = function() {
533
+ this._tickScheduled = !1, this.isPaused || this.isFinished || (this._tick(), this.isFinished || (h.delay(this._tickAndRepeat, [], this), this._tickScheduled = !0));
534
+ }, r.prototype._tick = function() {
535
+ if (this.isPaused || this.isFinished) return !1;
536
+ var s = null, _ = Math.min(this.max, this.index + 16384);
537
+ if (this.index >= this.max) return this.end();
538
+ switch (this.type) {
539
+ case "string":
540
+ s = this.data.substring(this.index, _);
541
+ break;
542
+ case "uint8array":
543
+ s = this.data.subarray(this.index, _);
544
+ break;
545
+ case "array":
546
+ case "nodebuffer":
547
+ s = this.data.slice(this.index, _);
548
+ }
549
+ return this.index = _, this.push({ data: s, meta: { percent: this.max ? this.index / this.max * 100 : 0 } });
550
+ }, U.exports = r;
551
+ }, { "../utils": 32, "./GenericWorker": 28 }], 28: [function(g, U, y) {
552
+ function h(l) {
553
+ this.name = l || "default", this.streamInfo = {}, this.generatedError = null, this.extraStreamInfo = {}, this.isPaused = !0, this.isFinished = !1, this.isLocked = !1, this._listeners = { data: [], end: [], error: [] }, this.previous = null;
554
+ }
555
+ h.prototype = { push: function(l) {
556
+ this.emit("data", l);
557
+ }, end: function() {
558
+ if (this.isFinished) return !1;
559
+ this.flush();
560
+ try {
561
+ this.emit("end"), this.cleanUp(), this.isFinished = !0;
562
+ } catch (l) {
563
+ this.emit("error", l);
564
+ }
565
+ return !0;
566
+ }, error: function(l) {
567
+ return !this.isFinished && (this.isPaused ? this.generatedError = l : (this.isFinished = !0, this.emit("error", l), this.previous && this.previous.error(l), this.cleanUp()), !0);
568
+ }, on: function(l, r) {
569
+ return this._listeners[l].push(r), this;
570
+ }, cleanUp: function() {
571
+ this.streamInfo = this.generatedError = this.extraStreamInfo = null, this._listeners = [];
572
+ }, emit: function(l, r) {
573
+ if (this._listeners[l]) for (var s = 0; s < this._listeners[l].length; s++) this._listeners[l][s].call(this, r);
574
+ }, pipe: function(l) {
575
+ return l.registerPrevious(this);
576
+ }, registerPrevious: function(l) {
577
+ if (this.isLocked) throw new Error("The stream '" + this + "' has already been used.");
578
+ this.streamInfo = l.streamInfo, this.mergeStreamInfo(), this.previous = l;
579
+ var r = this;
580
+ return l.on("data", function(s) {
581
+ r.processChunk(s);
582
+ }), l.on("end", function() {
583
+ r.end();
584
+ }), l.on("error", function(s) {
585
+ r.error(s);
586
+ }), this;
587
+ }, pause: function() {
588
+ return !this.isPaused && !this.isFinished && (this.isPaused = !0, this.previous && this.previous.pause(), !0);
589
+ }, resume: function() {
590
+ if (!this.isPaused || this.isFinished) return !1;
591
+ var l = this.isPaused = !1;
592
+ return this.generatedError && (this.error(this.generatedError), l = !0), this.previous && this.previous.resume(), !l;
593
+ }, flush: function() {
594
+ }, processChunk: function(l) {
595
+ this.push(l);
596
+ }, withStreamInfo: function(l, r) {
597
+ return this.extraStreamInfo[l] = r, this.mergeStreamInfo(), this;
598
+ }, mergeStreamInfo: function() {
599
+ for (var l in this.extraStreamInfo) Object.prototype.hasOwnProperty.call(this.extraStreamInfo, l) && (this.streamInfo[l] = this.extraStreamInfo[l]);
600
+ }, lock: function() {
601
+ if (this.isLocked) throw new Error("The stream '" + this + "' has already been used.");
602
+ this.isLocked = !0, this.previous && this.previous.lock();
603
+ }, toString: function() {
604
+ var l = "Worker " + this.name;
605
+ return this.previous ? this.previous + " -> " + l : l;
606
+ } }, U.exports = h;
607
+ }, {}], 29: [function(g, U, y) {
608
+ var h = g("../utils"), l = g("./ConvertWorker"), r = g("./GenericWorker"), s = g("../base64"), _ = g("../support"), b = g("../external"), p = null;
609
+ if (_.nodestream) try {
610
+ p = g("../nodejs/NodejsStreamOutputAdapter");
611
+ } catch {
612
+ }
613
+ function v(f, n) {
614
+ return new b.Promise(function(u, a) {
615
+ var d = [], w = f._internalType, S = f._outputType, x = f._mimeType;
616
+ f.on("data", function(B, T) {
617
+ d.push(B), n && n(T);
618
+ }).on("error", function(B) {
619
+ d = [], a(B);
620
+ }).on("end", function() {
621
+ try {
622
+ var B = function(T, M, I) {
623
+ switch (T) {
624
+ case "blob":
625
+ return h.newBlob(h.transformTo("arraybuffer", M), I);
626
+ case "base64":
627
+ return s.encode(M);
628
+ default:
629
+ return h.transformTo(T, M);
630
+ }
631
+ }(S, function(T, M) {
632
+ var I, W = 0, J = null, m = 0;
633
+ for (I = 0; I < M.length; I++) m += M[I].length;
634
+ switch (T) {
635
+ case "string":
636
+ return M.join("");
637
+ case "array":
638
+ return Array.prototype.concat.apply([], M);
639
+ case "uint8array":
640
+ for (J = new Uint8Array(m), I = 0; I < M.length; I++) J.set(M[I], W), W += M[I].length;
641
+ return J;
642
+ case "nodebuffer":
643
+ return Buffer.concat(M);
644
+ default:
645
+ throw new Error("concat : unsupported type '" + T + "'");
646
+ }
647
+ }(w, d), x);
648
+ u(B);
649
+ } catch (T) {
650
+ a(T);
651
+ }
652
+ d = [];
653
+ }).resume();
654
+ });
655
+ }
656
+ function i(f, n, u) {
657
+ var a = n;
658
+ switch (n) {
659
+ case "blob":
660
+ case "arraybuffer":
661
+ a = "uint8array";
662
+ break;
663
+ case "base64":
664
+ a = "string";
665
+ }
666
+ try {
667
+ this._internalType = a, this._outputType = n, this._mimeType = u, h.checkSupport(a), this._worker = f.pipe(new l(a)), f.lock();
668
+ } catch (d) {
669
+ this._worker = new r("error"), this._worker.error(d);
670
+ }
671
+ }
672
+ i.prototype = { accumulate: function(f) {
673
+ return v(this, f);
674
+ }, on: function(f, n) {
675
+ var u = this;
676
+ return f === "data" ? this._worker.on(f, function(a) {
677
+ n.call(u, a.data, a.meta);
678
+ }) : this._worker.on(f, function() {
679
+ h.delay(n, arguments, u);
680
+ }), this;
681
+ }, resume: function() {
682
+ return h.delay(this._worker.resume, [], this._worker), this;
683
+ }, pause: function() {
684
+ return this._worker.pause(), this;
685
+ }, toNodejsStream: function(f) {
686
+ if (h.checkSupport("nodestream"), this._outputType !== "nodebuffer") throw new Error(this._outputType + " is not supported by this method");
687
+ return new p(this, { objectMode: this._outputType !== "nodebuffer" }, f);
688
+ } }, U.exports = i;
689
+ }, { "../base64": 1, "../external": 6, "../nodejs/NodejsStreamOutputAdapter": 13, "../support": 30, "../utils": 32, "./ConvertWorker": 24, "./GenericWorker": 28 }], 30: [function(g, U, y) {
690
+ if (y.base64 = !0, y.array = !0, y.string = !0, y.arraybuffer = typeof ArrayBuffer < "u" && typeof Uint8Array < "u", y.nodebuffer = typeof Buffer < "u", y.uint8array = typeof Uint8Array < "u", typeof ArrayBuffer > "u") y.blob = !1;
691
+ else {
692
+ var h = new ArrayBuffer(0);
693
+ try {
694
+ y.blob = new Blob([h], { type: "application/zip" }).size === 0;
695
+ } catch {
696
+ try {
697
+ var l = new (self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder)();
698
+ l.append(h), y.blob = l.getBlob("application/zip").size === 0;
699
+ } catch {
700
+ y.blob = !1;
701
+ }
702
+ }
703
+ }
704
+ try {
705
+ y.nodestream = !!g("readable-stream").Readable;
706
+ } catch {
707
+ y.nodestream = !1;
708
+ }
709
+ }, { "readable-stream": 16 }], 31: [function(g, U, y) {
710
+ for (var h = g("./utils"), l = g("./support"), r = g("./nodejsUtils"), s = g("./stream/GenericWorker"), _ = new Array(256), b = 0; b < 256; b++) _[b] = 252 <= b ? 6 : 248 <= b ? 5 : 240 <= b ? 4 : 224 <= b ? 3 : 192 <= b ? 2 : 1;
711
+ _[254] = _[254] = 1;
712
+ function p() {
713
+ s.call(this, "utf-8 decode"), this.leftOver = null;
714
+ }
715
+ function v() {
716
+ s.call(this, "utf-8 encode");
717
+ }
718
+ y.utf8encode = function(i) {
719
+ return l.nodebuffer ? r.newBufferFrom(i, "utf-8") : function(f) {
720
+ var n, u, a, d, w, S = f.length, x = 0;
721
+ for (d = 0; d < S; d++) (64512 & (u = f.charCodeAt(d))) == 55296 && d + 1 < S && (64512 & (a = f.charCodeAt(d + 1))) == 56320 && (u = 65536 + (u - 55296 << 10) + (a - 56320), d++), x += u < 128 ? 1 : u < 2048 ? 2 : u < 65536 ? 3 : 4;
722
+ for (n = l.uint8array ? new Uint8Array(x) : new Array(x), d = w = 0; w < x; d++) (64512 & (u = f.charCodeAt(d))) == 55296 && d + 1 < S && (64512 & (a = f.charCodeAt(d + 1))) == 56320 && (u = 65536 + (u - 55296 << 10) + (a - 56320), d++), u < 128 ? n[w++] = u : (u < 2048 ? n[w++] = 192 | u >>> 6 : (u < 65536 ? n[w++] = 224 | u >>> 12 : (n[w++] = 240 | u >>> 18, n[w++] = 128 | u >>> 12 & 63), n[w++] = 128 | u >>> 6 & 63), n[w++] = 128 | 63 & u);
723
+ return n;
724
+ }(i);
725
+ }, y.utf8decode = function(i) {
726
+ return l.nodebuffer ? h.transformTo("nodebuffer", i).toString("utf-8") : function(f) {
727
+ var n, u, a, d, w = f.length, S = new Array(2 * w);
728
+ for (n = u = 0; n < w; ) if ((a = f[n++]) < 128) S[u++] = a;
729
+ else if (4 < (d = _[a])) S[u++] = 65533, n += d - 1;
730
+ else {
731
+ for (a &= d === 2 ? 31 : d === 3 ? 15 : 7; 1 < d && n < w; ) a = a << 6 | 63 & f[n++], d--;
732
+ 1 < d ? S[u++] = 65533 : a < 65536 ? S[u++] = a : (a -= 65536, S[u++] = 55296 | a >> 10 & 1023, S[u++] = 56320 | 1023 & a);
733
+ }
734
+ return S.length !== u && (S.subarray ? S = S.subarray(0, u) : S.length = u), h.applyFromCharCode(S);
735
+ }(i = h.transformTo(l.uint8array ? "uint8array" : "array", i));
736
+ }, h.inherits(p, s), p.prototype.processChunk = function(i) {
737
+ var f = h.transformTo(l.uint8array ? "uint8array" : "array", i.data);
738
+ if (this.leftOver && this.leftOver.length) {
739
+ if (l.uint8array) {
740
+ var n = f;
741
+ (f = new Uint8Array(n.length + this.leftOver.length)).set(this.leftOver, 0), f.set(n, this.leftOver.length);
742
+ } else f = this.leftOver.concat(f);
743
+ this.leftOver = null;
744
+ }
745
+ var u = function(d, w) {
746
+ var S;
747
+ for ((w = w || d.length) > d.length && (w = d.length), S = w - 1; 0 <= S && (192 & d[S]) == 128; ) S--;
748
+ return S < 0 || S === 0 ? w : S + _[d[S]] > w ? S : w;
749
+ }(f), a = f;
750
+ u !== f.length && (l.uint8array ? (a = f.subarray(0, u), this.leftOver = f.subarray(u, f.length)) : (a = f.slice(0, u), this.leftOver = f.slice(u, f.length))), this.push({ data: y.utf8decode(a), meta: i.meta });
751
+ }, p.prototype.flush = function() {
752
+ this.leftOver && this.leftOver.length && (this.push({ data: y.utf8decode(this.leftOver), meta: {} }), this.leftOver = null);
753
+ }, y.Utf8DecodeWorker = p, h.inherits(v, s), v.prototype.processChunk = function(i) {
754
+ this.push({ data: y.utf8encode(i.data), meta: i.meta });
755
+ }, y.Utf8EncodeWorker = v;
756
+ }, { "./nodejsUtils": 14, "./stream/GenericWorker": 28, "./support": 30, "./utils": 32 }], 32: [function(g, U, y) {
757
+ var h = g("./support"), l = g("./base64"), r = g("./nodejsUtils"), s = g("./external");
758
+ function _(n) {
759
+ return n;
760
+ }
761
+ function b(n, u) {
762
+ for (var a = 0; a < n.length; ++a) u[a] = 255 & n.charCodeAt(a);
763
+ return u;
764
+ }
765
+ g("setimmediate"), y.newBlob = function(n, u) {
766
+ y.checkSupport("blob");
767
+ try {
768
+ return new Blob([n], { type: u });
769
+ } catch {
770
+ try {
771
+ var a = new (self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder)();
772
+ return a.append(n), a.getBlob(u);
773
+ } catch {
774
+ throw new Error("Bug : can't construct the Blob.");
775
+ }
776
+ }
777
+ };
778
+ var p = { stringifyByChunk: function(n, u, a) {
779
+ var d = [], w = 0, S = n.length;
780
+ if (S <= a) return String.fromCharCode.apply(null, n);
781
+ for (; w < S; ) u === "array" || u === "nodebuffer" ? d.push(String.fromCharCode.apply(null, n.slice(w, Math.min(w + a, S)))) : d.push(String.fromCharCode.apply(null, n.subarray(w, Math.min(w + a, S)))), w += a;
782
+ return d.join("");
783
+ }, stringifyByChar: function(n) {
784
+ for (var u = "", a = 0; a < n.length; a++) u += String.fromCharCode(n[a]);
785
+ return u;
786
+ }, applyCanBeUsed: { uint8array: function() {
787
+ try {
788
+ return h.uint8array && String.fromCharCode.apply(null, new Uint8Array(1)).length === 1;
789
+ } catch {
790
+ return !1;
791
+ }
792
+ }(), nodebuffer: function() {
793
+ try {
794
+ return h.nodebuffer && String.fromCharCode.apply(null, r.allocBuffer(1)).length === 1;
795
+ } catch {
796
+ return !1;
797
+ }
798
+ }() } };
799
+ function v(n) {
800
+ var u = 65536, a = y.getTypeOf(n), d = !0;
801
+ if (a === "uint8array" ? d = p.applyCanBeUsed.uint8array : a === "nodebuffer" && (d = p.applyCanBeUsed.nodebuffer), d) for (; 1 < u; ) try {
802
+ return p.stringifyByChunk(n, a, u);
803
+ } catch {
804
+ u = Math.floor(u / 2);
805
+ }
806
+ return p.stringifyByChar(n);
807
+ }
808
+ function i(n, u) {
809
+ for (var a = 0; a < n.length; a++) u[a] = n[a];
810
+ return u;
811
+ }
812
+ y.applyFromCharCode = v;
813
+ var f = {};
814
+ f.string = { string: _, array: function(n) {
815
+ return b(n, new Array(n.length));
816
+ }, arraybuffer: function(n) {
817
+ return f.string.uint8array(n).buffer;
818
+ }, uint8array: function(n) {
819
+ return b(n, new Uint8Array(n.length));
820
+ }, nodebuffer: function(n) {
821
+ return b(n, r.allocBuffer(n.length));
822
+ } }, f.array = { string: v, array: _, arraybuffer: function(n) {
823
+ return new Uint8Array(n).buffer;
824
+ }, uint8array: function(n) {
825
+ return new Uint8Array(n);
826
+ }, nodebuffer: function(n) {
827
+ return r.newBufferFrom(n);
828
+ } }, f.arraybuffer = { string: function(n) {
829
+ return v(new Uint8Array(n));
830
+ }, array: function(n) {
831
+ return i(new Uint8Array(n), new Array(n.byteLength));
832
+ }, arraybuffer: _, uint8array: function(n) {
833
+ return new Uint8Array(n);
834
+ }, nodebuffer: function(n) {
835
+ return r.newBufferFrom(new Uint8Array(n));
836
+ } }, f.uint8array = { string: v, array: function(n) {
837
+ return i(n, new Array(n.length));
838
+ }, arraybuffer: function(n) {
839
+ return n.buffer;
840
+ }, uint8array: _, nodebuffer: function(n) {
841
+ return r.newBufferFrom(n);
842
+ } }, f.nodebuffer = { string: v, array: function(n) {
843
+ return i(n, new Array(n.length));
844
+ }, arraybuffer: function(n) {
845
+ return f.nodebuffer.uint8array(n).buffer;
846
+ }, uint8array: function(n) {
847
+ return i(n, new Uint8Array(n.length));
848
+ }, nodebuffer: _ }, y.transformTo = function(n, u) {
849
+ if (u = u || "", !n) return u;
850
+ y.checkSupport(n);
851
+ var a = y.getTypeOf(u);
852
+ return f[a][n](u);
853
+ }, y.resolve = function(n) {
854
+ for (var u = n.split("/"), a = [], d = 0; d < u.length; d++) {
855
+ var w = u[d];
856
+ w === "." || w === "" && d !== 0 && d !== u.length - 1 || (w === ".." ? a.pop() : a.push(w));
857
+ }
858
+ return a.join("/");
859
+ }, y.getTypeOf = function(n) {
860
+ return typeof n == "string" ? "string" : Object.prototype.toString.call(n) === "[object Array]" ? "array" : h.nodebuffer && r.isBuffer(n) ? "nodebuffer" : h.uint8array && n instanceof Uint8Array ? "uint8array" : h.arraybuffer && n instanceof ArrayBuffer ? "arraybuffer" : void 0;
861
+ }, y.checkSupport = function(n) {
862
+ if (!h[n.toLowerCase()]) throw new Error(n + " is not supported by this platform");
863
+ }, y.MAX_VALUE_16BITS = 65535, y.MAX_VALUE_32BITS = -1, y.pretty = function(n) {
864
+ var u, a, d = "";
865
+ for (a = 0; a < (n || "").length; a++) d += "\\x" + ((u = n.charCodeAt(a)) < 16 ? "0" : "") + u.toString(16).toUpperCase();
866
+ return d;
867
+ }, y.delay = function(n, u, a) {
868
+ setImmediate(function() {
869
+ n.apply(a || null, u || []);
870
+ });
871
+ }, y.inherits = function(n, u) {
872
+ function a() {
873
+ }
874
+ a.prototype = u.prototype, n.prototype = new a();
875
+ }, y.extend = function() {
876
+ var n, u, a = {};
877
+ for (n = 0; n < arguments.length; n++) for (u in arguments[n]) Object.prototype.hasOwnProperty.call(arguments[n], u) && a[u] === void 0 && (a[u] = arguments[n][u]);
878
+ return a;
879
+ }, y.prepareContent = function(n, u, a, d, w) {
880
+ return s.Promise.resolve(u).then(function(S) {
881
+ return h.blob && (S instanceof Blob || ["[object File]", "[object Blob]"].indexOf(Object.prototype.toString.call(S)) !== -1) && typeof FileReader < "u" ? new s.Promise(function(x, B) {
882
+ var T = new FileReader();
883
+ T.onload = function(M) {
884
+ x(M.target.result);
885
+ }, T.onerror = function(M) {
886
+ B(M.target.error);
887
+ }, T.readAsArrayBuffer(S);
888
+ }) : S;
889
+ }).then(function(S) {
890
+ var x = y.getTypeOf(S);
891
+ return x ? (x === "arraybuffer" ? S = y.transformTo("uint8array", S) : x === "string" && (w ? S = l.decode(S) : a && d !== !0 && (S = function(B) {
892
+ return b(B, h.uint8array ? new Uint8Array(B.length) : new Array(B.length));
893
+ }(S))), S) : s.Promise.reject(new Error("Can't read the data of '" + n + "'. Is it in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?"));
894
+ });
895
+ };
896
+ }, { "./base64": 1, "./external": 6, "./nodejsUtils": 14, "./support": 30, setimmediate: 54 }], 33: [function(g, U, y) {
897
+ var h = g("./reader/readerFor"), l = g("./utils"), r = g("./signature"), s = g("./zipEntry"), _ = g("./support");
898
+ function b(p) {
899
+ this.files = [], this.loadOptions = p;
900
+ }
901
+ b.prototype = { checkSignature: function(p) {
902
+ if (!this.reader.readAndCheckSignature(p)) {
903
+ this.reader.index -= 4;
904
+ var v = this.reader.readString(4);
905
+ throw new Error("Corrupted zip or bug: unexpected signature (" + l.pretty(v) + ", expected " + l.pretty(p) + ")");
906
+ }
907
+ }, isSignature: function(p, v) {
908
+ var i = this.reader.index;
909
+ this.reader.setIndex(p);
910
+ var f = this.reader.readString(4) === v;
911
+ return this.reader.setIndex(i), f;
912
+ }, readBlockEndOfCentral: function() {
913
+ this.diskNumber = this.reader.readInt(2), this.diskWithCentralDirStart = this.reader.readInt(2), this.centralDirRecordsOnThisDisk = this.reader.readInt(2), this.centralDirRecords = this.reader.readInt(2), this.centralDirSize = this.reader.readInt(4), this.centralDirOffset = this.reader.readInt(4), this.zipCommentLength = this.reader.readInt(2);
914
+ var p = this.reader.readData(this.zipCommentLength), v = _.uint8array ? "uint8array" : "array", i = l.transformTo(v, p);
915
+ this.zipComment = this.loadOptions.decodeFileName(i);
916
+ }, readBlockZip64EndOfCentral: function() {
917
+ this.zip64EndOfCentralSize = this.reader.readInt(8), this.reader.skip(4), this.diskNumber = this.reader.readInt(4), this.diskWithCentralDirStart = this.reader.readInt(4), this.centralDirRecordsOnThisDisk = this.reader.readInt(8), this.centralDirRecords = this.reader.readInt(8), this.centralDirSize = this.reader.readInt(8), this.centralDirOffset = this.reader.readInt(8), this.zip64ExtensibleData = {};
918
+ for (var p, v, i, f = this.zip64EndOfCentralSize - 44; 0 < f; ) p = this.reader.readInt(2), v = this.reader.readInt(4), i = this.reader.readData(v), this.zip64ExtensibleData[p] = { id: p, length: v, value: i };
919
+ }, readBlockZip64EndOfCentralLocator: function() {
920
+ if (this.diskWithZip64CentralDirStart = this.reader.readInt(4), this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8), this.disksCount = this.reader.readInt(4), 1 < this.disksCount) throw new Error("Multi-volumes zip are not supported");
921
+ }, readLocalFiles: function() {
922
+ var p, v;
923
+ for (p = 0; p < this.files.length; p++) v = this.files[p], this.reader.setIndex(v.localHeaderOffset), this.checkSignature(r.LOCAL_FILE_HEADER), v.readLocalPart(this.reader), v.handleUTF8(), v.processAttributes();
924
+ }, readCentralDir: function() {
925
+ var p;
926
+ for (this.reader.setIndex(this.centralDirOffset); this.reader.readAndCheckSignature(r.CENTRAL_FILE_HEADER); ) (p = new s({ zip64: this.zip64 }, this.loadOptions)).readCentralPart(this.reader), this.files.push(p);
927
+ if (this.centralDirRecords !== this.files.length && this.centralDirRecords !== 0 && this.files.length === 0) throw new Error("Corrupted zip or bug: expected " + this.centralDirRecords + " records in central dir, got " + this.files.length);
928
+ }, readEndOfCentral: function() {
929
+ var p = this.reader.lastIndexOfSignature(r.CENTRAL_DIRECTORY_END);
930
+ if (p < 0) throw this.isSignature(0, r.LOCAL_FILE_HEADER) ? new Error("Corrupted zip: can't find end of central directory") : new Error("Can't find end of central directory : is this a zip file ? If it is, see https://stuk.github.io/jszip/documentation/howto/read_zip.html");
931
+ this.reader.setIndex(p);
932
+ var v = p;
933
+ if (this.checkSignature(r.CENTRAL_DIRECTORY_END), this.readBlockEndOfCentral(), this.diskNumber === l.MAX_VALUE_16BITS || this.diskWithCentralDirStart === l.MAX_VALUE_16BITS || this.centralDirRecordsOnThisDisk === l.MAX_VALUE_16BITS || this.centralDirRecords === l.MAX_VALUE_16BITS || this.centralDirSize === l.MAX_VALUE_32BITS || this.centralDirOffset === l.MAX_VALUE_32BITS) {
934
+ if (this.zip64 = !0, (p = this.reader.lastIndexOfSignature(r.ZIP64_CENTRAL_DIRECTORY_LOCATOR)) < 0) throw new Error("Corrupted zip: can't find the ZIP64 end of central directory locator");
935
+ if (this.reader.setIndex(p), this.checkSignature(r.ZIP64_CENTRAL_DIRECTORY_LOCATOR), this.readBlockZip64EndOfCentralLocator(), !this.isSignature(this.relativeOffsetEndOfZip64CentralDir, r.ZIP64_CENTRAL_DIRECTORY_END) && (this.relativeOffsetEndOfZip64CentralDir = this.reader.lastIndexOfSignature(r.ZIP64_CENTRAL_DIRECTORY_END), this.relativeOffsetEndOfZip64CentralDir < 0)) throw new Error("Corrupted zip: can't find the ZIP64 end of central directory");
936
+ this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir), this.checkSignature(r.ZIP64_CENTRAL_DIRECTORY_END), this.readBlockZip64EndOfCentral();
937
+ }
938
+ var i = this.centralDirOffset + this.centralDirSize;
939
+ this.zip64 && (i += 20, i += 12 + this.zip64EndOfCentralSize);
940
+ var f = v - i;
941
+ if (0 < f) this.isSignature(v, r.CENTRAL_FILE_HEADER) || (this.reader.zero = f);
942
+ else if (f < 0) throw new Error("Corrupted zip: missing " + Math.abs(f) + " bytes.");
943
+ }, prepareReader: function(p) {
944
+ this.reader = h(p);
945
+ }, load: function(p) {
946
+ this.prepareReader(p), this.readEndOfCentral(), this.readCentralDir(), this.readLocalFiles();
947
+ } }, U.exports = b;
948
+ }, { "./reader/readerFor": 22, "./signature": 23, "./support": 30, "./utils": 32, "./zipEntry": 34 }], 34: [function(g, U, y) {
949
+ var h = g("./reader/readerFor"), l = g("./utils"), r = g("./compressedObject"), s = g("./crc32"), _ = g("./utf8"), b = g("./compressions"), p = g("./support");
950
+ function v(i, f) {
951
+ this.options = i, this.loadOptions = f;
952
+ }
953
+ v.prototype = { isEncrypted: function() {
954
+ return (1 & this.bitFlag) == 1;
955
+ }, useUTF8: function() {
956
+ return (2048 & this.bitFlag) == 2048;
957
+ }, readLocalPart: function(i) {
958
+ var f, n;
959
+ if (i.skip(22), this.fileNameLength = i.readInt(2), n = i.readInt(2), this.fileName = i.readData(this.fileNameLength), i.skip(n), this.compressedSize === -1 || this.uncompressedSize === -1) throw new Error("Bug or corrupted zip : didn't get enough information from the central directory (compressedSize === -1 || uncompressedSize === -1)");
960
+ if ((f = function(u) {
961
+ for (var a in b) if (Object.prototype.hasOwnProperty.call(b, a) && b[a].magic === u) return b[a];
962
+ return null;
963
+ }(this.compressionMethod)) === null) throw new Error("Corrupted zip : compression " + l.pretty(this.compressionMethod) + " unknown (inner file : " + l.transformTo("string", this.fileName) + ")");
964
+ this.decompressed = new r(this.compressedSize, this.uncompressedSize, this.crc32, f, i.readData(this.compressedSize));
965
+ }, readCentralPart: function(i) {
966
+ this.versionMadeBy = i.readInt(2), i.skip(2), this.bitFlag = i.readInt(2), this.compressionMethod = i.readString(2), this.date = i.readDate(), this.crc32 = i.readInt(4), this.compressedSize = i.readInt(4), this.uncompressedSize = i.readInt(4);
967
+ var f = i.readInt(2);
968
+ if (this.extraFieldsLength = i.readInt(2), this.fileCommentLength = i.readInt(2), this.diskNumberStart = i.readInt(2), this.internalFileAttributes = i.readInt(2), this.externalFileAttributes = i.readInt(4), this.localHeaderOffset = i.readInt(4), this.isEncrypted()) throw new Error("Encrypted zip are not supported");
969
+ i.skip(f), this.readExtraFields(i), this.parseZIP64ExtraField(i), this.fileComment = i.readData(this.fileCommentLength);
970
+ }, processAttributes: function() {
971
+ this.unixPermissions = null, this.dosPermissions = null;
972
+ var i = this.versionMadeBy >> 8;
973
+ this.dir = !!(16 & this.externalFileAttributes), i == 0 && (this.dosPermissions = 63 & this.externalFileAttributes), i == 3 && (this.unixPermissions = this.externalFileAttributes >> 16 & 65535), this.dir || this.fileNameStr.slice(-1) !== "/" || (this.dir = !0);
974
+ }, parseZIP64ExtraField: function() {
975
+ if (this.extraFields[1]) {
976
+ var i = h(this.extraFields[1].value);
977
+ this.uncompressedSize === l.MAX_VALUE_32BITS && (this.uncompressedSize = i.readInt(8)), this.compressedSize === l.MAX_VALUE_32BITS && (this.compressedSize = i.readInt(8)), this.localHeaderOffset === l.MAX_VALUE_32BITS && (this.localHeaderOffset = i.readInt(8)), this.diskNumberStart === l.MAX_VALUE_32BITS && (this.diskNumberStart = i.readInt(4));
978
+ }
979
+ }, readExtraFields: function(i) {
980
+ var f, n, u, a = i.index + this.extraFieldsLength;
981
+ for (this.extraFields || (this.extraFields = {}); i.index + 4 < a; ) f = i.readInt(2), n = i.readInt(2), u = i.readData(n), this.extraFields[f] = { id: f, length: n, value: u };
982
+ i.setIndex(a);
983
+ }, handleUTF8: function() {
984
+ var i = p.uint8array ? "uint8array" : "array";
985
+ if (this.useUTF8()) this.fileNameStr = _.utf8decode(this.fileName), this.fileCommentStr = _.utf8decode(this.fileComment);
986
+ else {
987
+ var f = this.findExtraFieldUnicodePath();
988
+ if (f !== null) this.fileNameStr = f;
989
+ else {
990
+ var n = l.transformTo(i, this.fileName);
991
+ this.fileNameStr = this.loadOptions.decodeFileName(n);
992
+ }
993
+ var u = this.findExtraFieldUnicodeComment();
994
+ if (u !== null) this.fileCommentStr = u;
995
+ else {
996
+ var a = l.transformTo(i, this.fileComment);
997
+ this.fileCommentStr = this.loadOptions.decodeFileName(a);
998
+ }
999
+ }
1000
+ }, findExtraFieldUnicodePath: function() {
1001
+ var i = this.extraFields[28789];
1002
+ if (i) {
1003
+ var f = h(i.value);
1004
+ return f.readInt(1) !== 1 || s(this.fileName) !== f.readInt(4) ? null : _.utf8decode(f.readData(i.length - 5));
1005
+ }
1006
+ return null;
1007
+ }, findExtraFieldUnicodeComment: function() {
1008
+ var i = this.extraFields[25461];
1009
+ if (i) {
1010
+ var f = h(i.value);
1011
+ return f.readInt(1) !== 1 || s(this.fileComment) !== f.readInt(4) ? null : _.utf8decode(f.readData(i.length - 5));
1012
+ }
1013
+ return null;
1014
+ } }, U.exports = v;
1015
+ }, { "./compressedObject": 2, "./compressions": 3, "./crc32": 4, "./reader/readerFor": 22, "./support": 30, "./utf8": 31, "./utils": 32 }], 35: [function(g, U, y) {
1016
+ function h(f, n, u) {
1017
+ this.name = f, this.dir = u.dir, this.date = u.date, this.comment = u.comment, this.unixPermissions = u.unixPermissions, this.dosPermissions = u.dosPermissions, this._data = n, this._dataBinary = u.binary, this.options = { compression: u.compression, compressionOptions: u.compressionOptions };
1018
+ }
1019
+ var l = g("./stream/StreamHelper"), r = g("./stream/DataWorker"), s = g("./utf8"), _ = g("./compressedObject"), b = g("./stream/GenericWorker");
1020
+ h.prototype = { internalStream: function(f) {
1021
+ var n = null, u = "string";
1022
+ try {
1023
+ if (!f) throw new Error("No output type specified.");
1024
+ var a = (u = f.toLowerCase()) === "string" || u === "text";
1025
+ u !== "binarystring" && u !== "text" || (u = "string"), n = this._decompressWorker();
1026
+ var d = !this._dataBinary;
1027
+ d && !a && (n = n.pipe(new s.Utf8EncodeWorker())), !d && a && (n = n.pipe(new s.Utf8DecodeWorker()));
1028
+ } catch (w) {
1029
+ (n = new b("error")).error(w);
1030
+ }
1031
+ return new l(n, u, "");
1032
+ }, async: function(f, n) {
1033
+ return this.internalStream(f).accumulate(n);
1034
+ }, nodeStream: function(f, n) {
1035
+ return this.internalStream(f || "nodebuffer").toNodejsStream(n);
1036
+ }, _compressWorker: function(f, n) {
1037
+ if (this._data instanceof _ && this._data.compression.magic === f.magic) return this._data.getCompressedWorker();
1038
+ var u = this._decompressWorker();
1039
+ return this._dataBinary || (u = u.pipe(new s.Utf8EncodeWorker())), _.createWorkerFrom(u, f, n);
1040
+ }, _decompressWorker: function() {
1041
+ return this._data instanceof _ ? this._data.getContentWorker() : this._data instanceof b ? this._data : new r(this._data);
1042
+ } };
1043
+ for (var p = ["asText", "asBinary", "asNodeBuffer", "asUint8Array", "asArrayBuffer"], v = function() {
1044
+ throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.");
1045
+ }, i = 0; i < p.length; i++) h.prototype[p[i]] = v;
1046
+ U.exports = h;
1047
+ }, { "./compressedObject": 2, "./stream/DataWorker": 27, "./stream/GenericWorker": 28, "./stream/StreamHelper": 29, "./utf8": 31 }], 36: [function(g, U, y) {
1048
+ (function(h) {
1049
+ var l, r, s = h.MutationObserver || h.WebKitMutationObserver;
1050
+ if (s) {
1051
+ var _ = 0, b = new s(f), p = h.document.createTextNode("");
1052
+ b.observe(p, { characterData: !0 }), l = function() {
1053
+ p.data = _ = ++_ % 2;
1054
+ };
1055
+ } else if (h.setImmediate || h.MessageChannel === void 0) l = "document" in h && "onreadystatechange" in h.document.createElement("script") ? function() {
1056
+ var n = h.document.createElement("script");
1057
+ n.onreadystatechange = function() {
1058
+ f(), n.onreadystatechange = null, n.parentNode.removeChild(n), n = null;
1059
+ }, h.document.documentElement.appendChild(n);
1060
+ } : function() {
1061
+ setTimeout(f, 0);
1062
+ };
1063
+ else {
1064
+ var v = new h.MessageChannel();
1065
+ v.port1.onmessage = f, l = function() {
1066
+ v.port2.postMessage(0);
1067
+ };
1068
+ }
1069
+ var i = [];
1070
+ function f() {
1071
+ var n, u;
1072
+ r = !0;
1073
+ for (var a = i.length; a; ) {
1074
+ for (u = i, i = [], n = -1; ++n < a; ) u[n]();
1075
+ a = i.length;
1076
+ }
1077
+ r = !1;
1078
+ }
1079
+ U.exports = function(n) {
1080
+ i.push(n) !== 1 || r || l();
1081
+ };
1082
+ }).call(this, typeof Xt < "u" ? Xt : typeof self < "u" ? self : typeof window < "u" ? window : {});
1083
+ }, {}], 37: [function(g, U, y) {
1084
+ var h = g("immediate");
1085
+ function l() {
1086
+ }
1087
+ var r = {}, s = ["REJECTED"], _ = ["FULFILLED"], b = ["PENDING"];
1088
+ function p(a) {
1089
+ if (typeof a != "function") throw new TypeError("resolver must be a function");
1090
+ this.state = b, this.queue = [], this.outcome = void 0, a !== l && n(this, a);
1091
+ }
1092
+ function v(a, d, w) {
1093
+ this.promise = a, typeof d == "function" && (this.onFulfilled = d, this.callFulfilled = this.otherCallFulfilled), typeof w == "function" && (this.onRejected = w, this.callRejected = this.otherCallRejected);
1094
+ }
1095
+ function i(a, d, w) {
1096
+ h(function() {
1097
+ var S;
1098
+ try {
1099
+ S = d(w);
1100
+ } catch (x) {
1101
+ return r.reject(a, x);
1102
+ }
1103
+ S === a ? r.reject(a, new TypeError("Cannot resolve promise with itself")) : r.resolve(a, S);
1104
+ });
1105
+ }
1106
+ function f(a) {
1107
+ var d = a && a.then;
1108
+ if (a && (typeof a == "object" || typeof a == "function") && typeof d == "function") return function() {
1109
+ d.apply(a, arguments);
1110
+ };
1111
+ }
1112
+ function n(a, d) {
1113
+ var w = !1;
1114
+ function S(T) {
1115
+ w || (w = !0, r.reject(a, T));
1116
+ }
1117
+ function x(T) {
1118
+ w || (w = !0, r.resolve(a, T));
1119
+ }
1120
+ var B = u(function() {
1121
+ d(x, S);
1122
+ });
1123
+ B.status === "error" && S(B.value);
1124
+ }
1125
+ function u(a, d) {
1126
+ var w = {};
1127
+ try {
1128
+ w.value = a(d), w.status = "success";
1129
+ } catch (S) {
1130
+ w.status = "error", w.value = S;
1131
+ }
1132
+ return w;
1133
+ }
1134
+ (U.exports = p).prototype.finally = function(a) {
1135
+ if (typeof a != "function") return this;
1136
+ var d = this.constructor;
1137
+ return this.then(function(w) {
1138
+ return d.resolve(a()).then(function() {
1139
+ return w;
1140
+ });
1141
+ }, function(w) {
1142
+ return d.resolve(a()).then(function() {
1143
+ throw w;
1144
+ });
1145
+ });
1146
+ }, p.prototype.catch = function(a) {
1147
+ return this.then(null, a);
1148
+ }, p.prototype.then = function(a, d) {
1149
+ if (typeof a != "function" && this.state === _ || typeof d != "function" && this.state === s) return this;
1150
+ var w = new this.constructor(l);
1151
+ return this.state !== b ? i(w, this.state === _ ? a : d, this.outcome) : this.queue.push(new v(w, a, d)), w;
1152
+ }, v.prototype.callFulfilled = function(a) {
1153
+ r.resolve(this.promise, a);
1154
+ }, v.prototype.otherCallFulfilled = function(a) {
1155
+ i(this.promise, this.onFulfilled, a);
1156
+ }, v.prototype.callRejected = function(a) {
1157
+ r.reject(this.promise, a);
1158
+ }, v.prototype.otherCallRejected = function(a) {
1159
+ i(this.promise, this.onRejected, a);
1160
+ }, r.resolve = function(a, d) {
1161
+ var w = u(f, d);
1162
+ if (w.status === "error") return r.reject(a, w.value);
1163
+ var S = w.value;
1164
+ if (S) n(a, S);
1165
+ else {
1166
+ a.state = _, a.outcome = d;
1167
+ for (var x = -1, B = a.queue.length; ++x < B; ) a.queue[x].callFulfilled(d);
1168
+ }
1169
+ return a;
1170
+ }, r.reject = function(a, d) {
1171
+ a.state = s, a.outcome = d;
1172
+ for (var w = -1, S = a.queue.length; ++w < S; ) a.queue[w].callRejected(d);
1173
+ return a;
1174
+ }, p.resolve = function(a) {
1175
+ return a instanceof this ? a : r.resolve(new this(l), a);
1176
+ }, p.reject = function(a) {
1177
+ var d = new this(l);
1178
+ return r.reject(d, a);
1179
+ }, p.all = function(a) {
1180
+ var d = this;
1181
+ if (Object.prototype.toString.call(a) !== "[object Array]") return this.reject(new TypeError("must be an array"));
1182
+ var w = a.length, S = !1;
1183
+ if (!w) return this.resolve([]);
1184
+ for (var x = new Array(w), B = 0, T = -1, M = new this(l); ++T < w; ) I(a[T], T);
1185
+ return M;
1186
+ function I(W, J) {
1187
+ d.resolve(W).then(function(m) {
1188
+ x[J] = m, ++B !== w || S || (S = !0, r.resolve(M, x));
1189
+ }, function(m) {
1190
+ S || (S = !0, r.reject(M, m));
1191
+ });
1192
+ }
1193
+ }, p.race = function(a) {
1194
+ var d = this;
1195
+ if (Object.prototype.toString.call(a) !== "[object Array]") return this.reject(new TypeError("must be an array"));
1196
+ var w = a.length, S = !1;
1197
+ if (!w) return this.resolve([]);
1198
+ for (var x = -1, B = new this(l); ++x < w; ) T = a[x], d.resolve(T).then(function(M) {
1199
+ S || (S = !0, r.resolve(B, M));
1200
+ }, function(M) {
1201
+ S || (S = !0, r.reject(B, M));
1202
+ });
1203
+ var T;
1204
+ return B;
1205
+ };
1206
+ }, { immediate: 36 }], 38: [function(g, U, y) {
1207
+ var h = {};
1208
+ (0, g("./lib/utils/common").assign)(h, g("./lib/deflate"), g("./lib/inflate"), g("./lib/zlib/constants")), U.exports = h;
1209
+ }, { "./lib/deflate": 39, "./lib/inflate": 40, "./lib/utils/common": 41, "./lib/zlib/constants": 44 }], 39: [function(g, U, y) {
1210
+ var h = g("./zlib/deflate"), l = g("./utils/common"), r = g("./utils/strings"), s = g("./zlib/messages"), _ = g("./zlib/zstream"), b = Object.prototype.toString, p = 0, v = -1, i = 0, f = 8;
1211
+ function n(a) {
1212
+ if (!(this instanceof n)) return new n(a);
1213
+ this.options = l.assign({ level: v, method: f, chunkSize: 16384, windowBits: 15, memLevel: 8, strategy: i, to: "" }, a || {});
1214
+ var d = this.options;
1215
+ d.raw && 0 < d.windowBits ? d.windowBits = -d.windowBits : d.gzip && 0 < d.windowBits && d.windowBits < 16 && (d.windowBits += 16), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new _(), this.strm.avail_out = 0;
1216
+ var w = h.deflateInit2(this.strm, d.level, d.method, d.windowBits, d.memLevel, d.strategy);
1217
+ if (w !== p) throw new Error(s[w]);
1218
+ if (d.header && h.deflateSetHeader(this.strm, d.header), d.dictionary) {
1219
+ var S;
1220
+ if (S = typeof d.dictionary == "string" ? r.string2buf(d.dictionary) : b.call(d.dictionary) === "[object ArrayBuffer]" ? new Uint8Array(d.dictionary) : d.dictionary, (w = h.deflateSetDictionary(this.strm, S)) !== p) throw new Error(s[w]);
1221
+ this._dict_set = !0;
1222
+ }
1223
+ }
1224
+ function u(a, d) {
1225
+ var w = new n(d);
1226
+ if (w.push(a, !0), w.err) throw w.msg || s[w.err];
1227
+ return w.result;
1228
+ }
1229
+ n.prototype.push = function(a, d) {
1230
+ var w, S, x = this.strm, B = this.options.chunkSize;
1231
+ if (this.ended) return !1;
1232
+ S = d === ~~d ? d : d === !0 ? 4 : 0, typeof a == "string" ? x.input = r.string2buf(a) : b.call(a) === "[object ArrayBuffer]" ? x.input = new Uint8Array(a) : x.input = a, x.next_in = 0, x.avail_in = x.input.length;
1233
+ do {
1234
+ if (x.avail_out === 0 && (x.output = new l.Buf8(B), x.next_out = 0, x.avail_out = B), (w = h.deflate(x, S)) !== 1 && w !== p) return this.onEnd(w), !(this.ended = !0);
1235
+ x.avail_out !== 0 && (x.avail_in !== 0 || S !== 4 && S !== 2) || (this.options.to === "string" ? this.onData(r.buf2binstring(l.shrinkBuf(x.output, x.next_out))) : this.onData(l.shrinkBuf(x.output, x.next_out)));
1236
+ } while ((0 < x.avail_in || x.avail_out === 0) && w !== 1);
1237
+ return S === 4 ? (w = h.deflateEnd(this.strm), this.onEnd(w), this.ended = !0, w === p) : S !== 2 || (this.onEnd(p), !(x.avail_out = 0));
1238
+ }, n.prototype.onData = function(a) {
1239
+ this.chunks.push(a);
1240
+ }, n.prototype.onEnd = function(a) {
1241
+ a === p && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = l.flattenChunks(this.chunks)), this.chunks = [], this.err = a, this.msg = this.strm.msg;
1242
+ }, y.Deflate = n, y.deflate = u, y.deflateRaw = function(a, d) {
1243
+ return (d = d || {}).raw = !0, u(a, d);
1244
+ }, y.gzip = function(a, d) {
1245
+ return (d = d || {}).gzip = !0, u(a, d);
1246
+ };
1247
+ }, { "./utils/common": 41, "./utils/strings": 42, "./zlib/deflate": 46, "./zlib/messages": 51, "./zlib/zstream": 53 }], 40: [function(g, U, y) {
1248
+ var h = g("./zlib/inflate"), l = g("./utils/common"), r = g("./utils/strings"), s = g("./zlib/constants"), _ = g("./zlib/messages"), b = g("./zlib/zstream"), p = g("./zlib/gzheader"), v = Object.prototype.toString;
1249
+ function i(n) {
1250
+ if (!(this instanceof i)) return new i(n);
1251
+ this.options = l.assign({ chunkSize: 16384, windowBits: 0, to: "" }, n || {});
1252
+ var u = this.options;
1253
+ u.raw && 0 <= u.windowBits && u.windowBits < 16 && (u.windowBits = -u.windowBits, u.windowBits === 0 && (u.windowBits = -15)), !(0 <= u.windowBits && u.windowBits < 16) || n && n.windowBits || (u.windowBits += 32), 15 < u.windowBits && u.windowBits < 48 && !(15 & u.windowBits) && (u.windowBits |= 15), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new b(), this.strm.avail_out = 0;
1254
+ var a = h.inflateInit2(this.strm, u.windowBits);
1255
+ if (a !== s.Z_OK) throw new Error(_[a]);
1256
+ this.header = new p(), h.inflateGetHeader(this.strm, this.header);
1257
+ }
1258
+ function f(n, u) {
1259
+ var a = new i(u);
1260
+ if (a.push(n, !0), a.err) throw a.msg || _[a.err];
1261
+ return a.result;
1262
+ }
1263
+ i.prototype.push = function(n, u) {
1264
+ var a, d, w, S, x, B, T = this.strm, M = this.options.chunkSize, I = this.options.dictionary, W = !1;
1265
+ if (this.ended) return !1;
1266
+ d = u === ~~u ? u : u === !0 ? s.Z_FINISH : s.Z_NO_FLUSH, typeof n == "string" ? T.input = r.binstring2buf(n) : v.call(n) === "[object ArrayBuffer]" ? T.input = new Uint8Array(n) : T.input = n, T.next_in = 0, T.avail_in = T.input.length;
1267
+ do {
1268
+ if (T.avail_out === 0 && (T.output = new l.Buf8(M), T.next_out = 0, T.avail_out = M), (a = h.inflate(T, s.Z_NO_FLUSH)) === s.Z_NEED_DICT && I && (B = typeof I == "string" ? r.string2buf(I) : v.call(I) === "[object ArrayBuffer]" ? new Uint8Array(I) : I, a = h.inflateSetDictionary(this.strm, B)), a === s.Z_BUF_ERROR && W === !0 && (a = s.Z_OK, W = !1), a !== s.Z_STREAM_END && a !== s.Z_OK) return this.onEnd(a), !(this.ended = !0);
1269
+ T.next_out && (T.avail_out !== 0 && a !== s.Z_STREAM_END && (T.avail_in !== 0 || d !== s.Z_FINISH && d !== s.Z_SYNC_FLUSH) || (this.options.to === "string" ? (w = r.utf8border(T.output, T.next_out), S = T.next_out - w, x = r.buf2string(T.output, w), T.next_out = S, T.avail_out = M - S, S && l.arraySet(T.output, T.output, w, S, 0), this.onData(x)) : this.onData(l.shrinkBuf(T.output, T.next_out)))), T.avail_in === 0 && T.avail_out === 0 && (W = !0);
1270
+ } while ((0 < T.avail_in || T.avail_out === 0) && a !== s.Z_STREAM_END);
1271
+ return a === s.Z_STREAM_END && (d = s.Z_FINISH), d === s.Z_FINISH ? (a = h.inflateEnd(this.strm), this.onEnd(a), this.ended = !0, a === s.Z_OK) : d !== s.Z_SYNC_FLUSH || (this.onEnd(s.Z_OK), !(T.avail_out = 0));
1272
+ }, i.prototype.onData = function(n) {
1273
+ this.chunks.push(n);
1274
+ }, i.prototype.onEnd = function(n) {
1275
+ n === s.Z_OK && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = l.flattenChunks(this.chunks)), this.chunks = [], this.err = n, this.msg = this.strm.msg;
1276
+ }, y.Inflate = i, y.inflate = f, y.inflateRaw = function(n, u) {
1277
+ return (u = u || {}).raw = !0, f(n, u);
1278
+ }, y.ungzip = f;
1279
+ }, { "./utils/common": 41, "./utils/strings": 42, "./zlib/constants": 44, "./zlib/gzheader": 47, "./zlib/inflate": 49, "./zlib/messages": 51, "./zlib/zstream": 53 }], 41: [function(g, U, y) {
1280
+ var h = typeof Uint8Array < "u" && typeof Uint16Array < "u" && typeof Int32Array < "u";
1281
+ y.assign = function(s) {
1282
+ for (var _ = Array.prototype.slice.call(arguments, 1); _.length; ) {
1283
+ var b = _.shift();
1284
+ if (b) {
1285
+ if (typeof b != "object") throw new TypeError(b + "must be non-object");
1286
+ for (var p in b) b.hasOwnProperty(p) && (s[p] = b[p]);
1287
+ }
1288
+ }
1289
+ return s;
1290
+ }, y.shrinkBuf = function(s, _) {
1291
+ return s.length === _ ? s : s.subarray ? s.subarray(0, _) : (s.length = _, s);
1292
+ };
1293
+ var l = { arraySet: function(s, _, b, p, v) {
1294
+ if (_.subarray && s.subarray) s.set(_.subarray(b, b + p), v);
1295
+ else for (var i = 0; i < p; i++) s[v + i] = _[b + i];
1296
+ }, flattenChunks: function(s) {
1297
+ var _, b, p, v, i, f;
1298
+ for (_ = p = 0, b = s.length; _ < b; _++) p += s[_].length;
1299
+ for (f = new Uint8Array(p), _ = v = 0, b = s.length; _ < b; _++) i = s[_], f.set(i, v), v += i.length;
1300
+ return f;
1301
+ } }, r = { arraySet: function(s, _, b, p, v) {
1302
+ for (var i = 0; i < p; i++) s[v + i] = _[b + i];
1303
+ }, flattenChunks: function(s) {
1304
+ return [].concat.apply([], s);
1305
+ } };
1306
+ y.setTyped = function(s) {
1307
+ s ? (y.Buf8 = Uint8Array, y.Buf16 = Uint16Array, y.Buf32 = Int32Array, y.assign(y, l)) : (y.Buf8 = Array, y.Buf16 = Array, y.Buf32 = Array, y.assign(y, r));
1308
+ }, y.setTyped(h);
1309
+ }, {}], 42: [function(g, U, y) {
1310
+ var h = g("./common"), l = !0, r = !0;
1311
+ try {
1312
+ String.fromCharCode.apply(null, [0]);
1313
+ } catch {
1314
+ l = !1;
1315
+ }
1316
+ try {
1317
+ String.fromCharCode.apply(null, new Uint8Array(1));
1318
+ } catch {
1319
+ r = !1;
1320
+ }
1321
+ for (var s = new h.Buf8(256), _ = 0; _ < 256; _++) s[_] = 252 <= _ ? 6 : 248 <= _ ? 5 : 240 <= _ ? 4 : 224 <= _ ? 3 : 192 <= _ ? 2 : 1;
1322
+ function b(p, v) {
1323
+ if (v < 65537 && (p.subarray && r || !p.subarray && l)) return String.fromCharCode.apply(null, h.shrinkBuf(p, v));
1324
+ for (var i = "", f = 0; f < v; f++) i += String.fromCharCode(p[f]);
1325
+ return i;
1326
+ }
1327
+ s[254] = s[254] = 1, y.string2buf = function(p) {
1328
+ var v, i, f, n, u, a = p.length, d = 0;
1329
+ for (n = 0; n < a; n++) (64512 & (i = p.charCodeAt(n))) == 55296 && n + 1 < a && (64512 & (f = p.charCodeAt(n + 1))) == 56320 && (i = 65536 + (i - 55296 << 10) + (f - 56320), n++), d += i < 128 ? 1 : i < 2048 ? 2 : i < 65536 ? 3 : 4;
1330
+ for (v = new h.Buf8(d), n = u = 0; u < d; n++) (64512 & (i = p.charCodeAt(n))) == 55296 && n + 1 < a && (64512 & (f = p.charCodeAt(n + 1))) == 56320 && (i = 65536 + (i - 55296 << 10) + (f - 56320), n++), i < 128 ? v[u++] = i : (i < 2048 ? v[u++] = 192 | i >>> 6 : (i < 65536 ? v[u++] = 224 | i >>> 12 : (v[u++] = 240 | i >>> 18, v[u++] = 128 | i >>> 12 & 63), v[u++] = 128 | i >>> 6 & 63), v[u++] = 128 | 63 & i);
1331
+ return v;
1332
+ }, y.buf2binstring = function(p) {
1333
+ return b(p, p.length);
1334
+ }, y.binstring2buf = function(p) {
1335
+ for (var v = new h.Buf8(p.length), i = 0, f = v.length; i < f; i++) v[i] = p.charCodeAt(i);
1336
+ return v;
1337
+ }, y.buf2string = function(p, v) {
1338
+ var i, f, n, u, a = v || p.length, d = new Array(2 * a);
1339
+ for (i = f = 0; i < a; ) if ((n = p[i++]) < 128) d[f++] = n;
1340
+ else if (4 < (u = s[n])) d[f++] = 65533, i += u - 1;
1341
+ else {
1342
+ for (n &= u === 2 ? 31 : u === 3 ? 15 : 7; 1 < u && i < a; ) n = n << 6 | 63 & p[i++], u--;
1343
+ 1 < u ? d[f++] = 65533 : n < 65536 ? d[f++] = n : (n -= 65536, d[f++] = 55296 | n >> 10 & 1023, d[f++] = 56320 | 1023 & n);
1344
+ }
1345
+ return b(d, f);
1346
+ }, y.utf8border = function(p, v) {
1347
+ var i;
1348
+ for ((v = v || p.length) > p.length && (v = p.length), i = v - 1; 0 <= i && (192 & p[i]) == 128; ) i--;
1349
+ return i < 0 || i === 0 ? v : i + s[p[i]] > v ? i : v;
1350
+ };
1351
+ }, { "./common": 41 }], 43: [function(g, U, y) {
1352
+ U.exports = function(h, l, r, s) {
1353
+ for (var _ = 65535 & h | 0, b = h >>> 16 & 65535 | 0, p = 0; r !== 0; ) {
1354
+ for (r -= p = 2e3 < r ? 2e3 : r; b = b + (_ = _ + l[s++] | 0) | 0, --p; ) ;
1355
+ _ %= 65521, b %= 65521;
1356
+ }
1357
+ return _ | b << 16 | 0;
1358
+ };
1359
+ }, {}], 44: [function(g, U, y) {
1360
+ U.exports = { 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_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 };
1361
+ }, {}], 45: [function(g, U, y) {
1362
+ var h = function() {
1363
+ for (var l, r = [], s = 0; s < 256; s++) {
1364
+ l = s;
1365
+ for (var _ = 0; _ < 8; _++) l = 1 & l ? 3988292384 ^ l >>> 1 : l >>> 1;
1366
+ r[s] = l;
1367
+ }
1368
+ return r;
1369
+ }();
1370
+ U.exports = function(l, r, s, _) {
1371
+ var b = h, p = _ + s;
1372
+ l ^= -1;
1373
+ for (var v = _; v < p; v++) l = l >>> 8 ^ b[255 & (l ^ r[v])];
1374
+ return -1 ^ l;
1375
+ };
1376
+ }, {}], 46: [function(g, U, y) {
1377
+ var h, l = g("../utils/common"), r = g("./trees"), s = g("./adler32"), _ = g("./crc32"), b = g("./messages"), p = 0, v = 4, i = 0, f = -2, n = -1, u = 4, a = 2, d = 8, w = 9, S = 286, x = 30, B = 19, T = 2 * S + 1, M = 15, I = 3, W = 258, J = W + I + 1, m = 42, O = 113, e = 1, F = 2, rt = 3, P = 4;
1378
+ function nt(t, R) {
1379
+ return t.msg = b[R], R;
1380
+ }
1381
+ function Z(t) {
1382
+ return (t << 1) - (4 < t ? 9 : 0);
1383
+ }
1384
+ function Q(t) {
1385
+ for (var R = t.length; 0 <= --R; ) t[R] = 0;
1386
+ }
1387
+ function A(t) {
1388
+ var R = t.state, z = R.pending;
1389
+ z > t.avail_out && (z = t.avail_out), z !== 0 && (l.arraySet(t.output, R.pending_buf, R.pending_out, z, t.next_out), t.next_out += z, R.pending_out += z, t.total_out += z, t.avail_out -= z, R.pending -= z, R.pending === 0 && (R.pending_out = 0));
1390
+ }
1391
+ function C(t, R) {
1392
+ r._tr_flush_block(t, 0 <= t.block_start ? t.block_start : -1, t.strstart - t.block_start, R), t.block_start = t.strstart, A(t.strm);
1393
+ }
1394
+ function tt(t, R) {
1395
+ t.pending_buf[t.pending++] = R;
1396
+ }
1397
+ function X(t, R) {
1398
+ t.pending_buf[t.pending++] = R >>> 8 & 255, t.pending_buf[t.pending++] = 255 & R;
1399
+ }
1400
+ function K(t, R) {
1401
+ var z, c, o = t.max_chain_length, k = t.strstart, L = t.prev_length, N = t.nice_match, E = t.strstart > t.w_size - J ? t.strstart - (t.w_size - J) : 0, H = t.window, $ = t.w_mask, G = t.prev, et = t.strstart + W, ot = H[k + L - 1], at = H[k + L];
1402
+ t.prev_length >= t.good_match && (o >>= 2), N > t.lookahead && (N = t.lookahead);
1403
+ do
1404
+ if (H[(z = R) + L] === at && H[z + L - 1] === ot && H[z] === H[k] && H[++z] === H[k + 1]) {
1405
+ k += 2, z++;
1406
+ do
1407
+ ;
1408
+ while (H[++k] === H[++z] && H[++k] === H[++z] && H[++k] === H[++z] && H[++k] === H[++z] && H[++k] === H[++z] && H[++k] === H[++z] && H[++k] === H[++z] && H[++k] === H[++z] && k < et);
1409
+ if (c = W - (et - k), k = et - W, L < c) {
1410
+ if (t.match_start = R, N <= (L = c)) break;
1411
+ ot = H[k + L - 1], at = H[k + L];
1412
+ }
1413
+ }
1414
+ while ((R = G[R & $]) > E && --o != 0);
1415
+ return L <= t.lookahead ? L : t.lookahead;
1416
+ }
1417
+ function lt(t) {
1418
+ var R, z, c, o, k, L, N, E, H, $, G = t.w_size;
1419
+ do {
1420
+ if (o = t.window_size - t.lookahead - t.strstart, t.strstart >= G + (G - J)) {
1421
+ for (l.arraySet(t.window, t.window, G, G, 0), t.match_start -= G, t.strstart -= G, t.block_start -= G, R = z = t.hash_size; c = t.head[--R], t.head[R] = G <= c ? c - G : 0, --z; ) ;
1422
+ for (R = z = G; c = t.prev[--R], t.prev[R] = G <= c ? c - G : 0, --z; ) ;
1423
+ o += G;
1424
+ }
1425
+ if (t.strm.avail_in === 0) break;
1426
+ if (L = t.strm, N = t.window, E = t.strstart + t.lookahead, H = o, $ = void 0, $ = L.avail_in, H < $ && ($ = H), z = $ === 0 ? 0 : (L.avail_in -= $, l.arraySet(N, L.input, L.next_in, $, E), L.state.wrap === 1 ? L.adler = s(L.adler, N, $, E) : L.state.wrap === 2 && (L.adler = _(L.adler, N, $, E)), L.next_in += $, L.total_in += $, $), t.lookahead += z, t.lookahead + t.insert >= I) for (k = t.strstart - t.insert, t.ins_h = t.window[k], t.ins_h = (t.ins_h << t.hash_shift ^ t.window[k + 1]) & t.hash_mask; t.insert && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[k + I - 1]) & t.hash_mask, t.prev[k & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = k, k++, t.insert--, !(t.lookahead + t.insert < I)); ) ;
1427
+ } while (t.lookahead < J && t.strm.avail_in !== 0);
1428
+ }
1429
+ function _t(t, R) {
1430
+ for (var z, c; ; ) {
1431
+ if (t.lookahead < J) {
1432
+ if (lt(t), t.lookahead < J && R === p) return e;
1433
+ if (t.lookahead === 0) break;
1434
+ }
1435
+ if (z = 0, t.lookahead >= I && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + I - 1]) & t.hash_mask, z = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart), z !== 0 && t.strstart - z <= t.w_size - J && (t.match_length = K(t, z)), t.match_length >= I) if (c = r._tr_tally(t, t.strstart - t.match_start, t.match_length - I), t.lookahead -= t.match_length, t.match_length <= t.max_lazy_match && t.lookahead >= I) {
1436
+ for (t.match_length--; t.strstart++, t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + I - 1]) & t.hash_mask, z = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart, --t.match_length != 0; ) ;
1437
+ t.strstart++;
1438
+ } else t.strstart += t.match_length, t.match_length = 0, t.ins_h = t.window[t.strstart], t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + 1]) & t.hash_mask;
1439
+ else c = r._tr_tally(t, 0, t.window[t.strstart]), t.lookahead--, t.strstart++;
1440
+ if (c && (C(t, !1), t.strm.avail_out === 0)) return e;
1441
+ }
1442
+ return t.insert = t.strstart < I - 1 ? t.strstart : I - 1, R === v ? (C(t, !0), t.strm.avail_out === 0 ? rt : P) : t.last_lit && (C(t, !1), t.strm.avail_out === 0) ? e : F;
1443
+ }
1444
+ function st(t, R) {
1445
+ for (var z, c, o; ; ) {
1446
+ if (t.lookahead < J) {
1447
+ if (lt(t), t.lookahead < J && R === p) return e;
1448
+ if (t.lookahead === 0) break;
1449
+ }
1450
+ if (z = 0, t.lookahead >= I && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + I - 1]) & t.hash_mask, z = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart), t.prev_length = t.match_length, t.prev_match = t.match_start, t.match_length = I - 1, z !== 0 && t.prev_length < t.max_lazy_match && t.strstart - z <= t.w_size - J && (t.match_length = K(t, z), t.match_length <= 5 && (t.strategy === 1 || t.match_length === I && 4096 < t.strstart - t.match_start) && (t.match_length = I - 1)), t.prev_length >= I && t.match_length <= t.prev_length) {
1451
+ for (o = t.strstart + t.lookahead - I, c = r._tr_tally(t, t.strstart - 1 - t.prev_match, t.prev_length - I), t.lookahead -= t.prev_length - 1, t.prev_length -= 2; ++t.strstart <= o && (t.ins_h = (t.ins_h << t.hash_shift ^ t.window[t.strstart + I - 1]) & t.hash_mask, z = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h], t.head[t.ins_h] = t.strstart), --t.prev_length != 0; ) ;
1452
+ if (t.match_available = 0, t.match_length = I - 1, t.strstart++, c && (C(t, !1), t.strm.avail_out === 0)) return e;
1453
+ } else if (t.match_available) {
1454
+ if ((c = r._tr_tally(t, 0, t.window[t.strstart - 1])) && C(t, !1), t.strstart++, t.lookahead--, t.strm.avail_out === 0) return e;
1455
+ } else t.match_available = 1, t.strstart++, t.lookahead--;
1456
+ }
1457
+ return t.match_available && (c = r._tr_tally(t, 0, t.window[t.strstart - 1]), t.match_available = 0), t.insert = t.strstart < I - 1 ? t.strstart : I - 1, R === v ? (C(t, !0), t.strm.avail_out === 0 ? rt : P) : t.last_lit && (C(t, !1), t.strm.avail_out === 0) ? e : F;
1458
+ }
1459
+ function it(t, R, z, c, o) {
1460
+ this.good_length = t, this.max_lazy = R, this.nice_length = z, this.max_chain = c, this.func = o;
1461
+ }
1462
+ function mt() {
1463
+ 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 = d, 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 l.Buf16(2 * T), this.dyn_dtree = new l.Buf16(2 * (2 * x + 1)), this.bl_tree = new l.Buf16(2 * (2 * B + 1)), Q(this.dyn_ltree), Q(this.dyn_dtree), Q(this.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this.bl_count = new l.Buf16(M + 1), this.heap = new l.Buf16(2 * S + 1), Q(this.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new l.Buf16(2 * S + 1), Q(this.depth), this.l_buf = 0, this.lit_bufsize = 0, this.last_lit = 0, this.d_buf = 0, this.opt_len = 0, this.static_len = 0, this.matches = 0, this.insert = 0, this.bi_buf = 0, this.bi_valid = 0;
1464
+ }
1465
+ function ut(t) {
1466
+ var R;
1467
+ return t && t.state ? (t.total_in = t.total_out = 0, t.data_type = a, (R = t.state).pending = 0, R.pending_out = 0, R.wrap < 0 && (R.wrap = -R.wrap), R.status = R.wrap ? m : O, t.adler = R.wrap === 2 ? 0 : 1, R.last_flush = p, r._tr_init(R), i) : nt(t, f);
1468
+ }
1469
+ function kt(t) {
1470
+ var R = ut(t);
1471
+ return R === i && function(z) {
1472
+ z.window_size = 2 * z.w_size, Q(z.head), z.max_lazy_match = h[z.level].max_lazy, z.good_match = h[z.level].good_length, z.nice_match = h[z.level].nice_length, z.max_chain_length = h[z.level].max_chain, z.strstart = 0, z.block_start = 0, z.lookahead = 0, z.insert = 0, z.match_length = z.prev_length = I - 1, z.match_available = 0, z.ins_h = 0;
1473
+ }(t.state), R;
1474
+ }
1475
+ function yt(t, R, z, c, o, k) {
1476
+ if (!t) return f;
1477
+ var L = 1;
1478
+ if (R === n && (R = 6), c < 0 ? (L = 0, c = -c) : 15 < c && (L = 2, c -= 16), o < 1 || w < o || z !== d || c < 8 || 15 < c || R < 0 || 9 < R || k < 0 || u < k) return nt(t, f);
1479
+ c === 8 && (c = 9);
1480
+ var N = new mt();
1481
+ return (t.state = N).strm = t, N.wrap = L, N.gzhead = null, N.w_bits = c, N.w_size = 1 << N.w_bits, N.w_mask = N.w_size - 1, N.hash_bits = o + 7, N.hash_size = 1 << N.hash_bits, N.hash_mask = N.hash_size - 1, N.hash_shift = ~~((N.hash_bits + I - 1) / I), N.window = new l.Buf8(2 * N.w_size), N.head = new l.Buf16(N.hash_size), N.prev = new l.Buf16(N.w_size), N.lit_bufsize = 1 << o + 6, N.pending_buf_size = 4 * N.lit_bufsize, N.pending_buf = new l.Buf8(N.pending_buf_size), N.d_buf = 1 * N.lit_bufsize, N.l_buf = 3 * N.lit_bufsize, N.level = R, N.strategy = k, N.method = z, kt(t);
1482
+ }
1483
+ h = [new it(0, 0, 0, 0, function(t, R) {
1484
+ var z = 65535;
1485
+ for (z > t.pending_buf_size - 5 && (z = t.pending_buf_size - 5); ; ) {
1486
+ if (t.lookahead <= 1) {
1487
+ if (lt(t), t.lookahead === 0 && R === p) return e;
1488
+ if (t.lookahead === 0) break;
1489
+ }
1490
+ t.strstart += t.lookahead, t.lookahead = 0;
1491
+ var c = t.block_start + z;
1492
+ if ((t.strstart === 0 || t.strstart >= c) && (t.lookahead = t.strstart - c, t.strstart = c, C(t, !1), t.strm.avail_out === 0) || t.strstart - t.block_start >= t.w_size - J && (C(t, !1), t.strm.avail_out === 0)) return e;
1493
+ }
1494
+ return t.insert = 0, R === v ? (C(t, !0), t.strm.avail_out === 0 ? rt : P) : (t.strstart > t.block_start && (C(t, !1), t.strm.avail_out), e);
1495
+ }), new it(4, 4, 8, 4, _t), new it(4, 5, 16, 8, _t), new it(4, 6, 32, 32, _t), new it(4, 4, 16, 16, st), new it(8, 16, 32, 32, st), new it(8, 16, 128, 128, st), new it(8, 32, 128, 256, st), new it(32, 128, 258, 1024, st), new it(32, 258, 258, 4096, st)], y.deflateInit = function(t, R) {
1496
+ return yt(t, R, d, 15, 8, 0);
1497
+ }, y.deflateInit2 = yt, y.deflateReset = kt, y.deflateResetKeep = ut, y.deflateSetHeader = function(t, R) {
1498
+ return t && t.state ? t.state.wrap !== 2 ? f : (t.state.gzhead = R, i) : f;
1499
+ }, y.deflate = function(t, R) {
1500
+ var z, c, o, k;
1501
+ if (!t || !t.state || 5 < R || R < 0) return t ? nt(t, f) : f;
1502
+ if (c = t.state, !t.output || !t.input && t.avail_in !== 0 || c.status === 666 && R !== v) return nt(t, t.avail_out === 0 ? -5 : f);
1503
+ if (c.strm = t, z = c.last_flush, c.last_flush = R, c.status === m) if (c.wrap === 2) t.adler = 0, tt(c, 31), tt(c, 139), tt(c, 8), c.gzhead ? (tt(c, (c.gzhead.text ? 1 : 0) + (c.gzhead.hcrc ? 2 : 0) + (c.gzhead.extra ? 4 : 0) + (c.gzhead.name ? 8 : 0) + (c.gzhead.comment ? 16 : 0)), tt(c, 255 & c.gzhead.time), tt(c, c.gzhead.time >> 8 & 255), tt(c, c.gzhead.time >> 16 & 255), tt(c, c.gzhead.time >> 24 & 255), tt(c, c.level === 9 ? 2 : 2 <= c.strategy || c.level < 2 ? 4 : 0), tt(c, 255 & c.gzhead.os), c.gzhead.extra && c.gzhead.extra.length && (tt(c, 255 & c.gzhead.extra.length), tt(c, c.gzhead.extra.length >> 8 & 255)), c.gzhead.hcrc && (t.adler = _(t.adler, c.pending_buf, c.pending, 0)), c.gzindex = 0, c.status = 69) : (tt(c, 0), tt(c, 0), tt(c, 0), tt(c, 0), tt(c, 0), tt(c, c.level === 9 ? 2 : 2 <= c.strategy || c.level < 2 ? 4 : 0), tt(c, 3), c.status = O);
1504
+ else {
1505
+ var L = d + (c.w_bits - 8 << 4) << 8;
1506
+ L |= (2 <= c.strategy || c.level < 2 ? 0 : c.level < 6 ? 1 : c.level === 6 ? 2 : 3) << 6, c.strstart !== 0 && (L |= 32), L += 31 - L % 31, c.status = O, X(c, L), c.strstart !== 0 && (X(c, t.adler >>> 16), X(c, 65535 & t.adler)), t.adler = 1;
1507
+ }
1508
+ if (c.status === 69) if (c.gzhead.extra) {
1509
+ for (o = c.pending; c.gzindex < (65535 & c.gzhead.extra.length) && (c.pending !== c.pending_buf_size || (c.gzhead.hcrc && c.pending > o && (t.adler = _(t.adler, c.pending_buf, c.pending - o, o)), A(t), o = c.pending, c.pending !== c.pending_buf_size)); ) tt(c, 255 & c.gzhead.extra[c.gzindex]), c.gzindex++;
1510
+ c.gzhead.hcrc && c.pending > o && (t.adler = _(t.adler, c.pending_buf, c.pending - o, o)), c.gzindex === c.gzhead.extra.length && (c.gzindex = 0, c.status = 73);
1511
+ } else c.status = 73;
1512
+ if (c.status === 73) if (c.gzhead.name) {
1513
+ o = c.pending;
1514
+ do {
1515
+ if (c.pending === c.pending_buf_size && (c.gzhead.hcrc && c.pending > o && (t.adler = _(t.adler, c.pending_buf, c.pending - o, o)), A(t), o = c.pending, c.pending === c.pending_buf_size)) {
1516
+ k = 1;
1517
+ break;
1518
+ }
1519
+ k = c.gzindex < c.gzhead.name.length ? 255 & c.gzhead.name.charCodeAt(c.gzindex++) : 0, tt(c, k);
1520
+ } while (k !== 0);
1521
+ c.gzhead.hcrc && c.pending > o && (t.adler = _(t.adler, c.pending_buf, c.pending - o, o)), k === 0 && (c.gzindex = 0, c.status = 91);
1522
+ } else c.status = 91;
1523
+ if (c.status === 91) if (c.gzhead.comment) {
1524
+ o = c.pending;
1525
+ do {
1526
+ if (c.pending === c.pending_buf_size && (c.gzhead.hcrc && c.pending > o && (t.adler = _(t.adler, c.pending_buf, c.pending - o, o)), A(t), o = c.pending, c.pending === c.pending_buf_size)) {
1527
+ k = 1;
1528
+ break;
1529
+ }
1530
+ k = c.gzindex < c.gzhead.comment.length ? 255 & c.gzhead.comment.charCodeAt(c.gzindex++) : 0, tt(c, k);
1531
+ } while (k !== 0);
1532
+ c.gzhead.hcrc && c.pending > o && (t.adler = _(t.adler, c.pending_buf, c.pending - o, o)), k === 0 && (c.status = 103);
1533
+ } else c.status = 103;
1534
+ if (c.status === 103 && (c.gzhead.hcrc ? (c.pending + 2 > c.pending_buf_size && A(t), c.pending + 2 <= c.pending_buf_size && (tt(c, 255 & t.adler), tt(c, t.adler >> 8 & 255), t.adler = 0, c.status = O)) : c.status = O), c.pending !== 0) {
1535
+ if (A(t), t.avail_out === 0) return c.last_flush = -1, i;
1536
+ } else if (t.avail_in === 0 && Z(R) <= Z(z) && R !== v) return nt(t, -5);
1537
+ if (c.status === 666 && t.avail_in !== 0) return nt(t, -5);
1538
+ if (t.avail_in !== 0 || c.lookahead !== 0 || R !== p && c.status !== 666) {
1539
+ var N = c.strategy === 2 ? function(E, H) {
1540
+ for (var $; ; ) {
1541
+ if (E.lookahead === 0 && (lt(E), E.lookahead === 0)) {
1542
+ if (H === p) return e;
1543
+ break;
1544
+ }
1545
+ if (E.match_length = 0, $ = r._tr_tally(E, 0, E.window[E.strstart]), E.lookahead--, E.strstart++, $ && (C(E, !1), E.strm.avail_out === 0)) return e;
1546
+ }
1547
+ return E.insert = 0, H === v ? (C(E, !0), E.strm.avail_out === 0 ? rt : P) : E.last_lit && (C(E, !1), E.strm.avail_out === 0) ? e : F;
1548
+ }(c, R) : c.strategy === 3 ? function(E, H) {
1549
+ for (var $, G, et, ot, at = E.window; ; ) {
1550
+ if (E.lookahead <= W) {
1551
+ if (lt(E), E.lookahead <= W && H === p) return e;
1552
+ if (E.lookahead === 0) break;
1553
+ }
1554
+ if (E.match_length = 0, E.lookahead >= I && 0 < E.strstart && (G = at[et = E.strstart - 1]) === at[++et] && G === at[++et] && G === at[++et]) {
1555
+ ot = E.strstart + W;
1556
+ do
1557
+ ;
1558
+ while (G === at[++et] && G === at[++et] && G === at[++et] && G === at[++et] && G === at[++et] && G === at[++et] && G === at[++et] && G === at[++et] && et < ot);
1559
+ E.match_length = W - (ot - et), E.match_length > E.lookahead && (E.match_length = E.lookahead);
1560
+ }
1561
+ if (E.match_length >= I ? ($ = r._tr_tally(E, 1, E.match_length - I), E.lookahead -= E.match_length, E.strstart += E.match_length, E.match_length = 0) : ($ = r._tr_tally(E, 0, E.window[E.strstart]), E.lookahead--, E.strstart++), $ && (C(E, !1), E.strm.avail_out === 0)) return e;
1562
+ }
1563
+ return E.insert = 0, H === v ? (C(E, !0), E.strm.avail_out === 0 ? rt : P) : E.last_lit && (C(E, !1), E.strm.avail_out === 0) ? e : F;
1564
+ }(c, R) : h[c.level].func(c, R);
1565
+ if (N !== rt && N !== P || (c.status = 666), N === e || N === rt) return t.avail_out === 0 && (c.last_flush = -1), i;
1566
+ if (N === F && (R === 1 ? r._tr_align(c) : R !== 5 && (r._tr_stored_block(c, 0, 0, !1), R === 3 && (Q(c.head), c.lookahead === 0 && (c.strstart = 0, c.block_start = 0, c.insert = 0))), A(t), t.avail_out === 0)) return c.last_flush = -1, i;
1567
+ }
1568
+ return R !== v ? i : c.wrap <= 0 ? 1 : (c.wrap === 2 ? (tt(c, 255 & t.adler), tt(c, t.adler >> 8 & 255), tt(c, t.adler >> 16 & 255), tt(c, t.adler >> 24 & 255), tt(c, 255 & t.total_in), tt(c, t.total_in >> 8 & 255), tt(c, t.total_in >> 16 & 255), tt(c, t.total_in >> 24 & 255)) : (X(c, t.adler >>> 16), X(c, 65535 & t.adler)), A(t), 0 < c.wrap && (c.wrap = -c.wrap), c.pending !== 0 ? i : 1);
1569
+ }, y.deflateEnd = function(t) {
1570
+ var R;
1571
+ return t && t.state ? (R = t.state.status) !== m && R !== 69 && R !== 73 && R !== 91 && R !== 103 && R !== O && R !== 666 ? nt(t, f) : (t.state = null, R === O ? nt(t, -3) : i) : f;
1572
+ }, y.deflateSetDictionary = function(t, R) {
1573
+ var z, c, o, k, L, N, E, H, $ = R.length;
1574
+ if (!t || !t.state || (k = (z = t.state).wrap) === 2 || k === 1 && z.status !== m || z.lookahead) return f;
1575
+ for (k === 1 && (t.adler = s(t.adler, R, $, 0)), z.wrap = 0, $ >= z.w_size && (k === 0 && (Q(z.head), z.strstart = 0, z.block_start = 0, z.insert = 0), H = new l.Buf8(z.w_size), l.arraySet(H, R, $ - z.w_size, z.w_size, 0), R = H, $ = z.w_size), L = t.avail_in, N = t.next_in, E = t.input, t.avail_in = $, t.next_in = 0, t.input = R, lt(z); z.lookahead >= I; ) {
1576
+ for (c = z.strstart, o = z.lookahead - (I - 1); z.ins_h = (z.ins_h << z.hash_shift ^ z.window[c + I - 1]) & z.hash_mask, z.prev[c & z.w_mask] = z.head[z.ins_h], z.head[z.ins_h] = c, c++, --o; ) ;
1577
+ z.strstart = c, z.lookahead = I - 1, lt(z);
1578
+ }
1579
+ return z.strstart += z.lookahead, z.block_start = z.strstart, z.insert = z.lookahead, z.lookahead = 0, z.match_length = z.prev_length = I - 1, z.match_available = 0, t.next_in = N, t.input = E, t.avail_in = L, z.wrap = k, i;
1580
+ }, y.deflateInfo = "pako deflate (from Nodeca project)";
1581
+ }, { "../utils/common": 41, "./adler32": 43, "./crc32": 45, "./messages": 51, "./trees": 52 }], 47: [function(g, U, y) {
1582
+ U.exports = function() {
1583
+ 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;
1584
+ };
1585
+ }, {}], 48: [function(g, U, y) {
1586
+ U.exports = function(h, l) {
1587
+ var r, s, _, b, p, v, i, f, n, u, a, d, w, S, x, B, T, M, I, W, J, m, O, e, F;
1588
+ r = h.state, s = h.next_in, e = h.input, _ = s + (h.avail_in - 5), b = h.next_out, F = h.output, p = b - (l - h.avail_out), v = b + (h.avail_out - 257), i = r.dmax, f = r.wsize, n = r.whave, u = r.wnext, a = r.window, d = r.hold, w = r.bits, S = r.lencode, x = r.distcode, B = (1 << r.lenbits) - 1, T = (1 << r.distbits) - 1;
1589
+ t: do {
1590
+ w < 15 && (d += e[s++] << w, w += 8, d += e[s++] << w, w += 8), M = S[d & B];
1591
+ e: for (; ; ) {
1592
+ if (d >>>= I = M >>> 24, w -= I, (I = M >>> 16 & 255) === 0) F[b++] = 65535 & M;
1593
+ else {
1594
+ if (!(16 & I)) {
1595
+ if (!(64 & I)) {
1596
+ M = S[(65535 & M) + (d & (1 << I) - 1)];
1597
+ continue e;
1598
+ }
1599
+ if (32 & I) {
1600
+ r.mode = 12;
1601
+ break t;
1602
+ }
1603
+ h.msg = "invalid literal/length code", r.mode = 30;
1604
+ break t;
1605
+ }
1606
+ W = 65535 & M, (I &= 15) && (w < I && (d += e[s++] << w, w += 8), W += d & (1 << I) - 1, d >>>= I, w -= I), w < 15 && (d += e[s++] << w, w += 8, d += e[s++] << w, w += 8), M = x[d & T];
1607
+ r: for (; ; ) {
1608
+ if (d >>>= I = M >>> 24, w -= I, !(16 & (I = M >>> 16 & 255))) {
1609
+ if (!(64 & I)) {
1610
+ M = x[(65535 & M) + (d & (1 << I) - 1)];
1611
+ continue r;
1612
+ }
1613
+ h.msg = "invalid distance code", r.mode = 30;
1614
+ break t;
1615
+ }
1616
+ if (J = 65535 & M, w < (I &= 15) && (d += e[s++] << w, (w += 8) < I && (d += e[s++] << w, w += 8)), i < (J += d & (1 << I) - 1)) {
1617
+ h.msg = "invalid distance too far back", r.mode = 30;
1618
+ break t;
1619
+ }
1620
+ if (d >>>= I, w -= I, (I = b - p) < J) {
1621
+ if (n < (I = J - I) && r.sane) {
1622
+ h.msg = "invalid distance too far back", r.mode = 30;
1623
+ break t;
1624
+ }
1625
+ if (O = a, (m = 0) === u) {
1626
+ if (m += f - I, I < W) {
1627
+ for (W -= I; F[b++] = a[m++], --I; ) ;
1628
+ m = b - J, O = F;
1629
+ }
1630
+ } else if (u < I) {
1631
+ if (m += f + u - I, (I -= u) < W) {
1632
+ for (W -= I; F[b++] = a[m++], --I; ) ;
1633
+ if (m = 0, u < W) {
1634
+ for (W -= I = u; F[b++] = a[m++], --I; ) ;
1635
+ m = b - J, O = F;
1636
+ }
1637
+ }
1638
+ } else if (m += u - I, I < W) {
1639
+ for (W -= I; F[b++] = a[m++], --I; ) ;
1640
+ m = b - J, O = F;
1641
+ }
1642
+ for (; 2 < W; ) F[b++] = O[m++], F[b++] = O[m++], F[b++] = O[m++], W -= 3;
1643
+ W && (F[b++] = O[m++], 1 < W && (F[b++] = O[m++]));
1644
+ } else {
1645
+ for (m = b - J; F[b++] = F[m++], F[b++] = F[m++], F[b++] = F[m++], 2 < (W -= 3); ) ;
1646
+ W && (F[b++] = F[m++], 1 < W && (F[b++] = F[m++]));
1647
+ }
1648
+ break;
1649
+ }
1650
+ }
1651
+ break;
1652
+ }
1653
+ } while (s < _ && b < v);
1654
+ s -= W = w >> 3, d &= (1 << (w -= W << 3)) - 1, h.next_in = s, h.next_out = b, h.avail_in = s < _ ? _ - s + 5 : 5 - (s - _), h.avail_out = b < v ? v - b + 257 : 257 - (b - v), r.hold = d, r.bits = w;
1655
+ };
1656
+ }, {}], 49: [function(g, U, y) {
1657
+ var h = g("../utils/common"), l = g("./adler32"), r = g("./crc32"), s = g("./inffast"), _ = g("./inftrees"), b = 1, p = 2, v = 0, i = -2, f = 1, n = 852, u = 592;
1658
+ function a(m) {
1659
+ return (m >>> 24 & 255) + (m >>> 8 & 65280) + ((65280 & m) << 8) + ((255 & m) << 24);
1660
+ }
1661
+ function d() {
1662
+ 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 h.Buf16(320), this.work = new h.Buf16(288), this.lendyn = null, this.distdyn = null, this.sane = 0, this.back = 0, this.was = 0;
1663
+ }
1664
+ function w(m) {
1665
+ var O;
1666
+ return m && m.state ? (O = m.state, m.total_in = m.total_out = O.total = 0, m.msg = "", O.wrap && (m.adler = 1 & O.wrap), O.mode = f, O.last = 0, O.havedict = 0, O.dmax = 32768, O.head = null, O.hold = 0, O.bits = 0, O.lencode = O.lendyn = new h.Buf32(n), O.distcode = O.distdyn = new h.Buf32(u), O.sane = 1, O.back = -1, v) : i;
1667
+ }
1668
+ function S(m) {
1669
+ var O;
1670
+ return m && m.state ? ((O = m.state).wsize = 0, O.whave = 0, O.wnext = 0, w(m)) : i;
1671
+ }
1672
+ function x(m, O) {
1673
+ var e, F;
1674
+ return m && m.state ? (F = m.state, O < 0 ? (e = 0, O = -O) : (e = 1 + (O >> 4), O < 48 && (O &= 15)), O && (O < 8 || 15 < O) ? i : (F.window !== null && F.wbits !== O && (F.window = null), F.wrap = e, F.wbits = O, S(m))) : i;
1675
+ }
1676
+ function B(m, O) {
1677
+ var e, F;
1678
+ return m ? (F = new d(), (m.state = F).window = null, (e = x(m, O)) !== v && (m.state = null), e) : i;
1679
+ }
1680
+ var T, M, I = !0;
1681
+ function W(m) {
1682
+ if (I) {
1683
+ var O;
1684
+ for (T = new h.Buf32(512), M = new h.Buf32(32), O = 0; O < 144; ) m.lens[O++] = 8;
1685
+ for (; O < 256; ) m.lens[O++] = 9;
1686
+ for (; O < 280; ) m.lens[O++] = 7;
1687
+ for (; O < 288; ) m.lens[O++] = 8;
1688
+ for (_(b, m.lens, 0, 288, T, 0, m.work, { bits: 9 }), O = 0; O < 32; ) m.lens[O++] = 5;
1689
+ _(p, m.lens, 0, 32, M, 0, m.work, { bits: 5 }), I = !1;
1690
+ }
1691
+ m.lencode = T, m.lenbits = 9, m.distcode = M, m.distbits = 5;
1692
+ }
1693
+ function J(m, O, e, F) {
1694
+ var rt, P = m.state;
1695
+ return P.window === null && (P.wsize = 1 << P.wbits, P.wnext = 0, P.whave = 0, P.window = new h.Buf8(P.wsize)), F >= P.wsize ? (h.arraySet(P.window, O, e - P.wsize, P.wsize, 0), P.wnext = 0, P.whave = P.wsize) : (F < (rt = P.wsize - P.wnext) && (rt = F), h.arraySet(P.window, O, e - F, rt, P.wnext), (F -= rt) ? (h.arraySet(P.window, O, e - F, F, 0), P.wnext = F, P.whave = P.wsize) : (P.wnext += rt, P.wnext === P.wsize && (P.wnext = 0), P.whave < P.wsize && (P.whave += rt))), 0;
1696
+ }
1697
+ y.inflateReset = S, y.inflateReset2 = x, y.inflateResetKeep = w, y.inflateInit = function(m) {
1698
+ return B(m, 15);
1699
+ }, y.inflateInit2 = B, y.inflate = function(m, O) {
1700
+ var e, F, rt, P, nt, Z, Q, A, C, tt, X, K, lt, _t, st, it, mt, ut, kt, yt, t, R, z, c, o = 0, k = new h.Buf8(4), L = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
1701
+ if (!m || !m.state || !m.output || !m.input && m.avail_in !== 0) return i;
1702
+ (e = m.state).mode === 12 && (e.mode = 13), nt = m.next_out, rt = m.output, Q = m.avail_out, P = m.next_in, F = m.input, Z = m.avail_in, A = e.hold, C = e.bits, tt = Z, X = Q, R = v;
1703
+ t: for (; ; ) switch (e.mode) {
1704
+ case f:
1705
+ if (e.wrap === 0) {
1706
+ e.mode = 13;
1707
+ break;
1708
+ }
1709
+ for (; C < 16; ) {
1710
+ if (Z === 0) break t;
1711
+ Z--, A += F[P++] << C, C += 8;
1712
+ }
1713
+ if (2 & e.wrap && A === 35615) {
1714
+ k[e.check = 0] = 255 & A, k[1] = A >>> 8 & 255, e.check = r(e.check, k, 2, 0), C = A = 0, e.mode = 2;
1715
+ break;
1716
+ }
1717
+ if (e.flags = 0, e.head && (e.head.done = !1), !(1 & e.wrap) || (((255 & A) << 8) + (A >> 8)) % 31) {
1718
+ m.msg = "incorrect header check", e.mode = 30;
1719
+ break;
1720
+ }
1721
+ if ((15 & A) != 8) {
1722
+ m.msg = "unknown compression method", e.mode = 30;
1723
+ break;
1724
+ }
1725
+ if (C -= 4, t = 8 + (15 & (A >>>= 4)), e.wbits === 0) e.wbits = t;
1726
+ else if (t > e.wbits) {
1727
+ m.msg = "invalid window size", e.mode = 30;
1728
+ break;
1729
+ }
1730
+ e.dmax = 1 << t, m.adler = e.check = 1, e.mode = 512 & A ? 10 : 12, C = A = 0;
1731
+ break;
1732
+ case 2:
1733
+ for (; C < 16; ) {
1734
+ if (Z === 0) break t;
1735
+ Z--, A += F[P++] << C, C += 8;
1736
+ }
1737
+ if (e.flags = A, (255 & e.flags) != 8) {
1738
+ m.msg = "unknown compression method", e.mode = 30;
1739
+ break;
1740
+ }
1741
+ if (57344 & e.flags) {
1742
+ m.msg = "unknown header flags set", e.mode = 30;
1743
+ break;
1744
+ }
1745
+ e.head && (e.head.text = A >> 8 & 1), 512 & e.flags && (k[0] = 255 & A, k[1] = A >>> 8 & 255, e.check = r(e.check, k, 2, 0)), C = A = 0, e.mode = 3;
1746
+ case 3:
1747
+ for (; C < 32; ) {
1748
+ if (Z === 0) break t;
1749
+ Z--, A += F[P++] << C, C += 8;
1750
+ }
1751
+ e.head && (e.head.time = A), 512 & e.flags && (k[0] = 255 & A, k[1] = A >>> 8 & 255, k[2] = A >>> 16 & 255, k[3] = A >>> 24 & 255, e.check = r(e.check, k, 4, 0)), C = A = 0, e.mode = 4;
1752
+ case 4:
1753
+ for (; C < 16; ) {
1754
+ if (Z === 0) break t;
1755
+ Z--, A += F[P++] << C, C += 8;
1756
+ }
1757
+ e.head && (e.head.xflags = 255 & A, e.head.os = A >> 8), 512 & e.flags && (k[0] = 255 & A, k[1] = A >>> 8 & 255, e.check = r(e.check, k, 2, 0)), C = A = 0, e.mode = 5;
1758
+ case 5:
1759
+ if (1024 & e.flags) {
1760
+ for (; C < 16; ) {
1761
+ if (Z === 0) break t;
1762
+ Z--, A += F[P++] << C, C += 8;
1763
+ }
1764
+ e.length = A, e.head && (e.head.extra_len = A), 512 & e.flags && (k[0] = 255 & A, k[1] = A >>> 8 & 255, e.check = r(e.check, k, 2, 0)), C = A = 0;
1765
+ } else e.head && (e.head.extra = null);
1766
+ e.mode = 6;
1767
+ case 6:
1768
+ if (1024 & e.flags && (Z < (K = e.length) && (K = Z), K && (e.head && (t = e.head.extra_len - e.length, e.head.extra || (e.head.extra = new Array(e.head.extra_len)), h.arraySet(e.head.extra, F, P, K, t)), 512 & e.flags && (e.check = r(e.check, F, K, P)), Z -= K, P += K, e.length -= K), e.length)) break t;
1769
+ e.length = 0, e.mode = 7;
1770
+ case 7:
1771
+ if (2048 & e.flags) {
1772
+ if (Z === 0) break t;
1773
+ for (K = 0; t = F[P + K++], e.head && t && e.length < 65536 && (e.head.name += String.fromCharCode(t)), t && K < Z; ) ;
1774
+ if (512 & e.flags && (e.check = r(e.check, F, K, P)), Z -= K, P += K, t) break t;
1775
+ } else e.head && (e.head.name = null);
1776
+ e.length = 0, e.mode = 8;
1777
+ case 8:
1778
+ if (4096 & e.flags) {
1779
+ if (Z === 0) break t;
1780
+ for (K = 0; t = F[P + K++], e.head && t && e.length < 65536 && (e.head.comment += String.fromCharCode(t)), t && K < Z; ) ;
1781
+ if (512 & e.flags && (e.check = r(e.check, F, K, P)), Z -= K, P += K, t) break t;
1782
+ } else e.head && (e.head.comment = null);
1783
+ e.mode = 9;
1784
+ case 9:
1785
+ if (512 & e.flags) {
1786
+ for (; C < 16; ) {
1787
+ if (Z === 0) break t;
1788
+ Z--, A += F[P++] << C, C += 8;
1789
+ }
1790
+ if (A !== (65535 & e.check)) {
1791
+ m.msg = "header crc mismatch", e.mode = 30;
1792
+ break;
1793
+ }
1794
+ C = A = 0;
1795
+ }
1796
+ e.head && (e.head.hcrc = e.flags >> 9 & 1, e.head.done = !0), m.adler = e.check = 0, e.mode = 12;
1797
+ break;
1798
+ case 10:
1799
+ for (; C < 32; ) {
1800
+ if (Z === 0) break t;
1801
+ Z--, A += F[P++] << C, C += 8;
1802
+ }
1803
+ m.adler = e.check = a(A), C = A = 0, e.mode = 11;
1804
+ case 11:
1805
+ if (e.havedict === 0) return m.next_out = nt, m.avail_out = Q, m.next_in = P, m.avail_in = Z, e.hold = A, e.bits = C, 2;
1806
+ m.adler = e.check = 1, e.mode = 12;
1807
+ case 12:
1808
+ if (O === 5 || O === 6) break t;
1809
+ case 13:
1810
+ if (e.last) {
1811
+ A >>>= 7 & C, C -= 7 & C, e.mode = 27;
1812
+ break;
1813
+ }
1814
+ for (; C < 3; ) {
1815
+ if (Z === 0) break t;
1816
+ Z--, A += F[P++] << C, C += 8;
1817
+ }
1818
+ switch (e.last = 1 & A, C -= 1, 3 & (A >>>= 1)) {
1819
+ case 0:
1820
+ e.mode = 14;
1821
+ break;
1822
+ case 1:
1823
+ if (W(e), e.mode = 20, O !== 6) break;
1824
+ A >>>= 2, C -= 2;
1825
+ break t;
1826
+ case 2:
1827
+ e.mode = 17;
1828
+ break;
1829
+ case 3:
1830
+ m.msg = "invalid block type", e.mode = 30;
1831
+ }
1832
+ A >>>= 2, C -= 2;
1833
+ break;
1834
+ case 14:
1835
+ for (A >>>= 7 & C, C -= 7 & C; C < 32; ) {
1836
+ if (Z === 0) break t;
1837
+ Z--, A += F[P++] << C, C += 8;
1838
+ }
1839
+ if ((65535 & A) != (A >>> 16 ^ 65535)) {
1840
+ m.msg = "invalid stored block lengths", e.mode = 30;
1841
+ break;
1842
+ }
1843
+ if (e.length = 65535 & A, C = A = 0, e.mode = 15, O === 6) break t;
1844
+ case 15:
1845
+ e.mode = 16;
1846
+ case 16:
1847
+ if (K = e.length) {
1848
+ if (Z < K && (K = Z), Q < K && (K = Q), K === 0) break t;
1849
+ h.arraySet(rt, F, P, K, nt), Z -= K, P += K, Q -= K, nt += K, e.length -= K;
1850
+ break;
1851
+ }
1852
+ e.mode = 12;
1853
+ break;
1854
+ case 17:
1855
+ for (; C < 14; ) {
1856
+ if (Z === 0) break t;
1857
+ Z--, A += F[P++] << C, C += 8;
1858
+ }
1859
+ if (e.nlen = 257 + (31 & A), A >>>= 5, C -= 5, e.ndist = 1 + (31 & A), A >>>= 5, C -= 5, e.ncode = 4 + (15 & A), A >>>= 4, C -= 4, 286 < e.nlen || 30 < e.ndist) {
1860
+ m.msg = "too many length or distance symbols", e.mode = 30;
1861
+ break;
1862
+ }
1863
+ e.have = 0, e.mode = 18;
1864
+ case 18:
1865
+ for (; e.have < e.ncode; ) {
1866
+ for (; C < 3; ) {
1867
+ if (Z === 0) break t;
1868
+ Z--, A += F[P++] << C, C += 8;
1869
+ }
1870
+ e.lens[L[e.have++]] = 7 & A, A >>>= 3, C -= 3;
1871
+ }
1872
+ for (; e.have < 19; ) e.lens[L[e.have++]] = 0;
1873
+ if (e.lencode = e.lendyn, e.lenbits = 7, z = { bits: e.lenbits }, R = _(0, e.lens, 0, 19, e.lencode, 0, e.work, z), e.lenbits = z.bits, R) {
1874
+ m.msg = "invalid code lengths set", e.mode = 30;
1875
+ break;
1876
+ }
1877
+ e.have = 0, e.mode = 19;
1878
+ case 19:
1879
+ for (; e.have < e.nlen + e.ndist; ) {
1880
+ for (; it = (o = e.lencode[A & (1 << e.lenbits) - 1]) >>> 16 & 255, mt = 65535 & o, !((st = o >>> 24) <= C); ) {
1881
+ if (Z === 0) break t;
1882
+ Z--, A += F[P++] << C, C += 8;
1883
+ }
1884
+ if (mt < 16) A >>>= st, C -= st, e.lens[e.have++] = mt;
1885
+ else {
1886
+ if (mt === 16) {
1887
+ for (c = st + 2; C < c; ) {
1888
+ if (Z === 0) break t;
1889
+ Z--, A += F[P++] << C, C += 8;
1890
+ }
1891
+ if (A >>>= st, C -= st, e.have === 0) {
1892
+ m.msg = "invalid bit length repeat", e.mode = 30;
1893
+ break;
1894
+ }
1895
+ t = e.lens[e.have - 1], K = 3 + (3 & A), A >>>= 2, C -= 2;
1896
+ } else if (mt === 17) {
1897
+ for (c = st + 3; C < c; ) {
1898
+ if (Z === 0) break t;
1899
+ Z--, A += F[P++] << C, C += 8;
1900
+ }
1901
+ C -= st, t = 0, K = 3 + (7 & (A >>>= st)), A >>>= 3, C -= 3;
1902
+ } else {
1903
+ for (c = st + 7; C < c; ) {
1904
+ if (Z === 0) break t;
1905
+ Z--, A += F[P++] << C, C += 8;
1906
+ }
1907
+ C -= st, t = 0, K = 11 + (127 & (A >>>= st)), A >>>= 7, C -= 7;
1908
+ }
1909
+ if (e.have + K > e.nlen + e.ndist) {
1910
+ m.msg = "invalid bit length repeat", e.mode = 30;
1911
+ break;
1912
+ }
1913
+ for (; K--; ) e.lens[e.have++] = t;
1914
+ }
1915
+ }
1916
+ if (e.mode === 30) break;
1917
+ if (e.lens[256] === 0) {
1918
+ m.msg = "invalid code -- missing end-of-block", e.mode = 30;
1919
+ break;
1920
+ }
1921
+ if (e.lenbits = 9, z = { bits: e.lenbits }, R = _(b, e.lens, 0, e.nlen, e.lencode, 0, e.work, z), e.lenbits = z.bits, R) {
1922
+ m.msg = "invalid literal/lengths set", e.mode = 30;
1923
+ break;
1924
+ }
1925
+ if (e.distbits = 6, e.distcode = e.distdyn, z = { bits: e.distbits }, R = _(p, e.lens, e.nlen, e.ndist, e.distcode, 0, e.work, z), e.distbits = z.bits, R) {
1926
+ m.msg = "invalid distances set", e.mode = 30;
1927
+ break;
1928
+ }
1929
+ if (e.mode = 20, O === 6) break t;
1930
+ case 20:
1931
+ e.mode = 21;
1932
+ case 21:
1933
+ if (6 <= Z && 258 <= Q) {
1934
+ m.next_out = nt, m.avail_out = Q, m.next_in = P, m.avail_in = Z, e.hold = A, e.bits = C, s(m, X), nt = m.next_out, rt = m.output, Q = m.avail_out, P = m.next_in, F = m.input, Z = m.avail_in, A = e.hold, C = e.bits, e.mode === 12 && (e.back = -1);
1935
+ break;
1936
+ }
1937
+ for (e.back = 0; it = (o = e.lencode[A & (1 << e.lenbits) - 1]) >>> 16 & 255, mt = 65535 & o, !((st = o >>> 24) <= C); ) {
1938
+ if (Z === 0) break t;
1939
+ Z--, A += F[P++] << C, C += 8;
1940
+ }
1941
+ if (it && !(240 & it)) {
1942
+ for (ut = st, kt = it, yt = mt; it = (o = e.lencode[yt + ((A & (1 << ut + kt) - 1) >> ut)]) >>> 16 & 255, mt = 65535 & o, !(ut + (st = o >>> 24) <= C); ) {
1943
+ if (Z === 0) break t;
1944
+ Z--, A += F[P++] << C, C += 8;
1945
+ }
1946
+ A >>>= ut, C -= ut, e.back += ut;
1947
+ }
1948
+ if (A >>>= st, C -= st, e.back += st, e.length = mt, it === 0) {
1949
+ e.mode = 26;
1950
+ break;
1951
+ }
1952
+ if (32 & it) {
1953
+ e.back = -1, e.mode = 12;
1954
+ break;
1955
+ }
1956
+ if (64 & it) {
1957
+ m.msg = "invalid literal/length code", e.mode = 30;
1958
+ break;
1959
+ }
1960
+ e.extra = 15 & it, e.mode = 22;
1961
+ case 22:
1962
+ if (e.extra) {
1963
+ for (c = e.extra; C < c; ) {
1964
+ if (Z === 0) break t;
1965
+ Z--, A += F[P++] << C, C += 8;
1966
+ }
1967
+ e.length += A & (1 << e.extra) - 1, A >>>= e.extra, C -= e.extra, e.back += e.extra;
1968
+ }
1969
+ e.was = e.length, e.mode = 23;
1970
+ case 23:
1971
+ for (; it = (o = e.distcode[A & (1 << e.distbits) - 1]) >>> 16 & 255, mt = 65535 & o, !((st = o >>> 24) <= C); ) {
1972
+ if (Z === 0) break t;
1973
+ Z--, A += F[P++] << C, C += 8;
1974
+ }
1975
+ if (!(240 & it)) {
1976
+ for (ut = st, kt = it, yt = mt; it = (o = e.distcode[yt + ((A & (1 << ut + kt) - 1) >> ut)]) >>> 16 & 255, mt = 65535 & o, !(ut + (st = o >>> 24) <= C); ) {
1977
+ if (Z === 0) break t;
1978
+ Z--, A += F[P++] << C, C += 8;
1979
+ }
1980
+ A >>>= ut, C -= ut, e.back += ut;
1981
+ }
1982
+ if (A >>>= st, C -= st, e.back += st, 64 & it) {
1983
+ m.msg = "invalid distance code", e.mode = 30;
1984
+ break;
1985
+ }
1986
+ e.offset = mt, e.extra = 15 & it, e.mode = 24;
1987
+ case 24:
1988
+ if (e.extra) {
1989
+ for (c = e.extra; C < c; ) {
1990
+ if (Z === 0) break t;
1991
+ Z--, A += F[P++] << C, C += 8;
1992
+ }
1993
+ e.offset += A & (1 << e.extra) - 1, A >>>= e.extra, C -= e.extra, e.back += e.extra;
1994
+ }
1995
+ if (e.offset > e.dmax) {
1996
+ m.msg = "invalid distance too far back", e.mode = 30;
1997
+ break;
1998
+ }
1999
+ e.mode = 25;
2000
+ case 25:
2001
+ if (Q === 0) break t;
2002
+ if (K = X - Q, e.offset > K) {
2003
+ if ((K = e.offset - K) > e.whave && e.sane) {
2004
+ m.msg = "invalid distance too far back", e.mode = 30;
2005
+ break;
2006
+ }
2007
+ lt = K > e.wnext ? (K -= e.wnext, e.wsize - K) : e.wnext - K, K > e.length && (K = e.length), _t = e.window;
2008
+ } else _t = rt, lt = nt - e.offset, K = e.length;
2009
+ for (Q < K && (K = Q), Q -= K, e.length -= K; rt[nt++] = _t[lt++], --K; ) ;
2010
+ e.length === 0 && (e.mode = 21);
2011
+ break;
2012
+ case 26:
2013
+ if (Q === 0) break t;
2014
+ rt[nt++] = e.length, Q--, e.mode = 21;
2015
+ break;
2016
+ case 27:
2017
+ if (e.wrap) {
2018
+ for (; C < 32; ) {
2019
+ if (Z === 0) break t;
2020
+ Z--, A |= F[P++] << C, C += 8;
2021
+ }
2022
+ if (X -= Q, m.total_out += X, e.total += X, X && (m.adler = e.check = e.flags ? r(e.check, rt, X, nt - X) : l(e.check, rt, X, nt - X)), X = Q, (e.flags ? A : a(A)) !== e.check) {
2023
+ m.msg = "incorrect data check", e.mode = 30;
2024
+ break;
2025
+ }
2026
+ C = A = 0;
2027
+ }
2028
+ e.mode = 28;
2029
+ case 28:
2030
+ if (e.wrap && e.flags) {
2031
+ for (; C < 32; ) {
2032
+ if (Z === 0) break t;
2033
+ Z--, A += F[P++] << C, C += 8;
2034
+ }
2035
+ if (A !== (4294967295 & e.total)) {
2036
+ m.msg = "incorrect length check", e.mode = 30;
2037
+ break;
2038
+ }
2039
+ C = A = 0;
2040
+ }
2041
+ e.mode = 29;
2042
+ case 29:
2043
+ R = 1;
2044
+ break t;
2045
+ case 30:
2046
+ R = -3;
2047
+ break t;
2048
+ case 31:
2049
+ return -4;
2050
+ case 32:
2051
+ default:
2052
+ return i;
2053
+ }
2054
+ return m.next_out = nt, m.avail_out = Q, m.next_in = P, m.avail_in = Z, e.hold = A, e.bits = C, (e.wsize || X !== m.avail_out && e.mode < 30 && (e.mode < 27 || O !== 4)) && J(m, m.output, m.next_out, X - m.avail_out) ? (e.mode = 31, -4) : (tt -= m.avail_in, X -= m.avail_out, m.total_in += tt, m.total_out += X, e.total += X, e.wrap && X && (m.adler = e.check = e.flags ? r(e.check, rt, X, m.next_out - X) : l(e.check, rt, X, m.next_out - X)), m.data_type = e.bits + (e.last ? 64 : 0) + (e.mode === 12 ? 128 : 0) + (e.mode === 20 || e.mode === 15 ? 256 : 0), (tt == 0 && X === 0 || O === 4) && R === v && (R = -5), R);
2055
+ }, y.inflateEnd = function(m) {
2056
+ if (!m || !m.state) return i;
2057
+ var O = m.state;
2058
+ return O.window && (O.window = null), m.state = null, v;
2059
+ }, y.inflateGetHeader = function(m, O) {
2060
+ var e;
2061
+ return m && m.state && 2 & (e = m.state).wrap ? ((e.head = O).done = !1, v) : i;
2062
+ }, y.inflateSetDictionary = function(m, O) {
2063
+ var e, F = O.length;
2064
+ return m && m.state ? (e = m.state).wrap !== 0 && e.mode !== 11 ? i : e.mode === 11 && l(1, O, F, 0) !== e.check ? -3 : J(m, O, F, F) ? (e.mode = 31, -4) : (e.havedict = 1, v) : i;
2065
+ }, y.inflateInfo = "pako inflate (from Nodeca project)";
2066
+ }, { "../utils/common": 41, "./adler32": 43, "./crc32": 45, "./inffast": 48, "./inftrees": 50 }], 50: [function(g, U, y) {
2067
+ var h = g("../utils/common"), l = [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], r = [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], s = [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], _ = [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];
2068
+ U.exports = function(b, p, v, i, f, n, u, a) {
2069
+ var d, w, S, x, B, T, M, I, W, J = a.bits, m = 0, O = 0, e = 0, F = 0, rt = 0, P = 0, nt = 0, Z = 0, Q = 0, A = 0, C = null, tt = 0, X = new h.Buf16(16), K = new h.Buf16(16), lt = null, _t = 0;
2070
+ for (m = 0; m <= 15; m++) X[m] = 0;
2071
+ for (O = 0; O < i; O++) X[p[v + O]]++;
2072
+ for (rt = J, F = 15; 1 <= F && X[F] === 0; F--) ;
2073
+ if (F < rt && (rt = F), F === 0) return f[n++] = 20971520, f[n++] = 20971520, a.bits = 1, 0;
2074
+ for (e = 1; e < F && X[e] === 0; e++) ;
2075
+ for (rt < e && (rt = e), m = Z = 1; m <= 15; m++) if (Z <<= 1, (Z -= X[m]) < 0) return -1;
2076
+ if (0 < Z && (b === 0 || F !== 1)) return -1;
2077
+ for (K[1] = 0, m = 1; m < 15; m++) K[m + 1] = K[m] + X[m];
2078
+ for (O = 0; O < i; O++) p[v + O] !== 0 && (u[K[p[v + O]]++] = O);
2079
+ if (T = b === 0 ? (C = lt = u, 19) : b === 1 ? (C = l, tt -= 257, lt = r, _t -= 257, 256) : (C = s, lt = _, -1), m = e, B = n, nt = O = A = 0, S = -1, x = (Q = 1 << (P = rt)) - 1, b === 1 && 852 < Q || b === 2 && 592 < Q) return 1;
2080
+ for (; ; ) {
2081
+ for (M = m - nt, W = u[O] < T ? (I = 0, u[O]) : u[O] > T ? (I = lt[_t + u[O]], C[tt + u[O]]) : (I = 96, 0), d = 1 << m - nt, e = w = 1 << P; f[B + (A >> nt) + (w -= d)] = M << 24 | I << 16 | W | 0, w !== 0; ) ;
2082
+ for (d = 1 << m - 1; A & d; ) d >>= 1;
2083
+ if (d !== 0 ? (A &= d - 1, A += d) : A = 0, O++, --X[m] == 0) {
2084
+ if (m === F) break;
2085
+ m = p[v + u[O]];
2086
+ }
2087
+ if (rt < m && (A & x) !== S) {
2088
+ for (nt === 0 && (nt = rt), B += e, Z = 1 << (P = m - nt); P + nt < F && !((Z -= X[P + nt]) <= 0); ) P++, Z <<= 1;
2089
+ if (Q += 1 << P, b === 1 && 852 < Q || b === 2 && 592 < Q) return 1;
2090
+ f[S = A & x] = rt << 24 | P << 16 | B - n | 0;
2091
+ }
2092
+ }
2093
+ return A !== 0 && (f[B + A] = m - nt << 24 | 64 << 16 | 0), a.bits = rt, 0;
2094
+ };
2095
+ }, { "../utils/common": 41 }], 51: [function(g, U, y) {
2096
+ U.exports = { 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" };
2097
+ }, {}], 52: [function(g, U, y) {
2098
+ var h = g("../utils/common"), l = 0, r = 1;
2099
+ function s(o) {
2100
+ for (var k = o.length; 0 <= --k; ) o[k] = 0;
2101
+ }
2102
+ var _ = 0, b = 29, p = 256, v = p + 1 + b, i = 30, f = 19, n = 2 * v + 1, u = 15, a = 16, d = 7, w = 256, S = 16, x = 17, B = 18, T = [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], M = [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], I = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7], W = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15], J = new Array(2 * (v + 2));
2103
+ s(J);
2104
+ var m = new Array(2 * i);
2105
+ s(m);
2106
+ var O = new Array(512);
2107
+ s(O);
2108
+ var e = new Array(256);
2109
+ s(e);
2110
+ var F = new Array(b);
2111
+ s(F);
2112
+ var rt, P, nt, Z = new Array(i);
2113
+ function Q(o, k, L, N, E) {
2114
+ this.static_tree = o, this.extra_bits = k, this.extra_base = L, this.elems = N, this.max_length = E, this.has_stree = o && o.length;
2115
+ }
2116
+ function A(o, k) {
2117
+ this.dyn_tree = o, this.max_code = 0, this.stat_desc = k;
2118
+ }
2119
+ function C(o) {
2120
+ return o < 256 ? O[o] : O[256 + (o >>> 7)];
2121
+ }
2122
+ function tt(o, k) {
2123
+ o.pending_buf[o.pending++] = 255 & k, o.pending_buf[o.pending++] = k >>> 8 & 255;
2124
+ }
2125
+ function X(o, k, L) {
2126
+ o.bi_valid > a - L ? (o.bi_buf |= k << o.bi_valid & 65535, tt(o, o.bi_buf), o.bi_buf = k >> a - o.bi_valid, o.bi_valid += L - a) : (o.bi_buf |= k << o.bi_valid & 65535, o.bi_valid += L);
2127
+ }
2128
+ function K(o, k, L) {
2129
+ X(o, L[2 * k], L[2 * k + 1]);
2130
+ }
2131
+ function lt(o, k) {
2132
+ for (var L = 0; L |= 1 & o, o >>>= 1, L <<= 1, 0 < --k; ) ;
2133
+ return L >>> 1;
2134
+ }
2135
+ function _t(o, k, L) {
2136
+ var N, E, H = new Array(u + 1), $ = 0;
2137
+ for (N = 1; N <= u; N++) H[N] = $ = $ + L[N - 1] << 1;
2138
+ for (E = 0; E <= k; E++) {
2139
+ var G = o[2 * E + 1];
2140
+ G !== 0 && (o[2 * E] = lt(H[G]++, G));
2141
+ }
2142
+ }
2143
+ function st(o) {
2144
+ var k;
2145
+ for (k = 0; k < v; k++) o.dyn_ltree[2 * k] = 0;
2146
+ for (k = 0; k < i; k++) o.dyn_dtree[2 * k] = 0;
2147
+ for (k = 0; k < f; k++) o.bl_tree[2 * k] = 0;
2148
+ o.dyn_ltree[2 * w] = 1, o.opt_len = o.static_len = 0, o.last_lit = o.matches = 0;
2149
+ }
2150
+ function it(o) {
2151
+ 8 < o.bi_valid ? tt(o, o.bi_buf) : 0 < o.bi_valid && (o.pending_buf[o.pending++] = o.bi_buf), o.bi_buf = 0, o.bi_valid = 0;
2152
+ }
2153
+ function mt(o, k, L, N) {
2154
+ var E = 2 * k, H = 2 * L;
2155
+ return o[E] < o[H] || o[E] === o[H] && N[k] <= N[L];
2156
+ }
2157
+ function ut(o, k, L) {
2158
+ for (var N = o.heap[L], E = L << 1; E <= o.heap_len && (E < o.heap_len && mt(k, o.heap[E + 1], o.heap[E], o.depth) && E++, !mt(k, N, o.heap[E], o.depth)); ) o.heap[L] = o.heap[E], L = E, E <<= 1;
2159
+ o.heap[L] = N;
2160
+ }
2161
+ function kt(o, k, L) {
2162
+ var N, E, H, $, G = 0;
2163
+ if (o.last_lit !== 0) for (; N = o.pending_buf[o.d_buf + 2 * G] << 8 | o.pending_buf[o.d_buf + 2 * G + 1], E = o.pending_buf[o.l_buf + G], G++, N === 0 ? K(o, E, k) : (K(o, (H = e[E]) + p + 1, k), ($ = T[H]) !== 0 && X(o, E -= F[H], $), K(o, H = C(--N), L), ($ = M[H]) !== 0 && X(o, N -= Z[H], $)), G < o.last_lit; ) ;
2164
+ K(o, w, k);
2165
+ }
2166
+ function yt(o, k) {
2167
+ var L, N, E, H = k.dyn_tree, $ = k.stat_desc.static_tree, G = k.stat_desc.has_stree, et = k.stat_desc.elems, ot = -1;
2168
+ for (o.heap_len = 0, o.heap_max = n, L = 0; L < et; L++) H[2 * L] !== 0 ? (o.heap[++o.heap_len] = ot = L, o.depth[L] = 0) : H[2 * L + 1] = 0;
2169
+ for (; o.heap_len < 2; ) H[2 * (E = o.heap[++o.heap_len] = ot < 2 ? ++ot : 0)] = 1, o.depth[E] = 0, o.opt_len--, G && (o.static_len -= $[2 * E + 1]);
2170
+ for (k.max_code = ot, L = o.heap_len >> 1; 1 <= L; L--) ut(o, H, L);
2171
+ for (E = et; L = o.heap[1], o.heap[1] = o.heap[o.heap_len--], ut(o, H, 1), N = o.heap[1], o.heap[--o.heap_max] = L, o.heap[--o.heap_max] = N, H[2 * E] = H[2 * L] + H[2 * N], o.depth[E] = (o.depth[L] >= o.depth[N] ? o.depth[L] : o.depth[N]) + 1, H[2 * L + 1] = H[2 * N + 1] = E, o.heap[1] = E++, ut(o, H, 1), 2 <= o.heap_len; ) ;
2172
+ o.heap[--o.heap_max] = o.heap[1], function(at, bt) {
2173
+ var Tt, wt, Et, ht, Rt, Pt, xt = bt.dyn_tree, Nt = bt.max_code, Ut = bt.stat_desc.static_tree, Mt = bt.stat_desc.has_stree, Vt = bt.stat_desc.extra_bits, jt = bt.stat_desc.extra_base, Ct = bt.stat_desc.max_length, D = 0;
2174
+ for (ht = 0; ht <= u; ht++) at.bl_count[ht] = 0;
2175
+ for (xt[2 * at.heap[at.heap_max] + 1] = 0, Tt = at.heap_max + 1; Tt < n; Tt++) Ct < (ht = xt[2 * xt[2 * (wt = at.heap[Tt]) + 1] + 1] + 1) && (ht = Ct, D++), xt[2 * wt + 1] = ht, Nt < wt || (at.bl_count[ht]++, Rt = 0, jt <= wt && (Rt = Vt[wt - jt]), Pt = xt[2 * wt], at.opt_len += Pt * (ht + Rt), Mt && (at.static_len += Pt * (Ut[2 * wt + 1] + Rt)));
2176
+ if (D !== 0) {
2177
+ do {
2178
+ for (ht = Ct - 1; at.bl_count[ht] === 0; ) ht--;
2179
+ at.bl_count[ht]--, at.bl_count[ht + 1] += 2, at.bl_count[Ct]--, D -= 2;
2180
+ } while (0 < D);
2181
+ for (ht = Ct; ht !== 0; ht--) for (wt = at.bl_count[ht]; wt !== 0; ) Nt < (Et = at.heap[--Tt]) || (xt[2 * Et + 1] !== ht && (at.opt_len += (ht - xt[2 * Et + 1]) * xt[2 * Et], xt[2 * Et + 1] = ht), wt--);
2182
+ }
2183
+ }(o, k), _t(H, ot, o.bl_count);
2184
+ }
2185
+ function t(o, k, L) {
2186
+ var N, E, H = -1, $ = k[1], G = 0, et = 7, ot = 4;
2187
+ for ($ === 0 && (et = 138, ot = 3), k[2 * (L + 1) + 1] = 65535, N = 0; N <= L; N++) E = $, $ = k[2 * (N + 1) + 1], ++G < et && E === $ || (G < ot ? o.bl_tree[2 * E] += G : E !== 0 ? (E !== H && o.bl_tree[2 * E]++, o.bl_tree[2 * S]++) : G <= 10 ? o.bl_tree[2 * x]++ : o.bl_tree[2 * B]++, H = E, ot = (G = 0) === $ ? (et = 138, 3) : E === $ ? (et = 6, 3) : (et = 7, 4));
2188
+ }
2189
+ function R(o, k, L) {
2190
+ var N, E, H = -1, $ = k[1], G = 0, et = 7, ot = 4;
2191
+ for ($ === 0 && (et = 138, ot = 3), N = 0; N <= L; N++) if (E = $, $ = k[2 * (N + 1) + 1], !(++G < et && E === $)) {
2192
+ if (G < ot) for (; K(o, E, o.bl_tree), --G != 0; ) ;
2193
+ else E !== 0 ? (E !== H && (K(o, E, o.bl_tree), G--), K(o, S, o.bl_tree), X(o, G - 3, 2)) : G <= 10 ? (K(o, x, o.bl_tree), X(o, G - 3, 3)) : (K(o, B, o.bl_tree), X(o, G - 11, 7));
2194
+ H = E, ot = (G = 0) === $ ? (et = 138, 3) : E === $ ? (et = 6, 3) : (et = 7, 4);
2195
+ }
2196
+ }
2197
+ s(Z);
2198
+ var z = !1;
2199
+ function c(o, k, L, N) {
2200
+ X(o, (_ << 1) + (N ? 1 : 0), 3), function(E, H, $, G) {
2201
+ it(E), tt(E, $), tt(E, ~$), h.arraySet(E.pending_buf, E.window, H, $, E.pending), E.pending += $;
2202
+ }(o, k, L);
2203
+ }
2204
+ y._tr_init = function(o) {
2205
+ z || (function() {
2206
+ var k, L, N, E, H, $ = new Array(u + 1);
2207
+ for (E = N = 0; E < b - 1; E++) for (F[E] = N, k = 0; k < 1 << T[E]; k++) e[N++] = E;
2208
+ for (e[N - 1] = E, E = H = 0; E < 16; E++) for (Z[E] = H, k = 0; k < 1 << M[E]; k++) O[H++] = E;
2209
+ for (H >>= 7; E < i; E++) for (Z[E] = H << 7, k = 0; k < 1 << M[E] - 7; k++) O[256 + H++] = E;
2210
+ for (L = 0; L <= u; L++) $[L] = 0;
2211
+ for (k = 0; k <= 143; ) J[2 * k + 1] = 8, k++, $[8]++;
2212
+ for (; k <= 255; ) J[2 * k + 1] = 9, k++, $[9]++;
2213
+ for (; k <= 279; ) J[2 * k + 1] = 7, k++, $[7]++;
2214
+ for (; k <= 287; ) J[2 * k + 1] = 8, k++, $[8]++;
2215
+ for (_t(J, v + 1, $), k = 0; k < i; k++) m[2 * k + 1] = 5, m[2 * k] = lt(k, 5);
2216
+ rt = new Q(J, T, p + 1, v, u), P = new Q(m, M, 0, i, u), nt = new Q(new Array(0), I, 0, f, d);
2217
+ }(), z = !0), o.l_desc = new A(o.dyn_ltree, rt), o.d_desc = new A(o.dyn_dtree, P), o.bl_desc = new A(o.bl_tree, nt), o.bi_buf = 0, o.bi_valid = 0, st(o);
2218
+ }, y._tr_stored_block = c, y._tr_flush_block = function(o, k, L, N) {
2219
+ var E, H, $ = 0;
2220
+ 0 < o.level ? (o.strm.data_type === 2 && (o.strm.data_type = function(G) {
2221
+ var et, ot = 4093624447;
2222
+ for (et = 0; et <= 31; et++, ot >>>= 1) if (1 & ot && G.dyn_ltree[2 * et] !== 0) return l;
2223
+ if (G.dyn_ltree[18] !== 0 || G.dyn_ltree[20] !== 0 || G.dyn_ltree[26] !== 0) return r;
2224
+ for (et = 32; et < p; et++) if (G.dyn_ltree[2 * et] !== 0) return r;
2225
+ return l;
2226
+ }(o)), yt(o, o.l_desc), yt(o, o.d_desc), $ = function(G) {
2227
+ var et;
2228
+ for (t(G, G.dyn_ltree, G.l_desc.max_code), t(G, G.dyn_dtree, G.d_desc.max_code), yt(G, G.bl_desc), et = f - 1; 3 <= et && G.bl_tree[2 * W[et] + 1] === 0; et--) ;
2229
+ return G.opt_len += 3 * (et + 1) + 5 + 5 + 4, et;
2230
+ }(o), E = o.opt_len + 3 + 7 >>> 3, (H = o.static_len + 3 + 7 >>> 3) <= E && (E = H)) : E = H = L + 5, L + 4 <= E && k !== -1 ? c(o, k, L, N) : o.strategy === 4 || H === E ? (X(o, 2 + (N ? 1 : 0), 3), kt(o, J, m)) : (X(o, 4 + (N ? 1 : 0), 3), function(G, et, ot, at) {
2231
+ var bt;
2232
+ for (X(G, et - 257, 5), X(G, ot - 1, 5), X(G, at - 4, 4), bt = 0; bt < at; bt++) X(G, G.bl_tree[2 * W[bt] + 1], 3);
2233
+ R(G, G.dyn_ltree, et - 1), R(G, G.dyn_dtree, ot - 1);
2234
+ }(o, o.l_desc.max_code + 1, o.d_desc.max_code + 1, $ + 1), kt(o, o.dyn_ltree, o.dyn_dtree)), st(o), N && it(o);
2235
+ }, y._tr_tally = function(o, k, L) {
2236
+ return o.pending_buf[o.d_buf + 2 * o.last_lit] = k >>> 8 & 255, o.pending_buf[o.d_buf + 2 * o.last_lit + 1] = 255 & k, o.pending_buf[o.l_buf + o.last_lit] = 255 & L, o.last_lit++, k === 0 ? o.dyn_ltree[2 * L]++ : (o.matches++, k--, o.dyn_ltree[2 * (e[L] + p + 1)]++, o.dyn_dtree[2 * C(k)]++), o.last_lit === o.lit_bufsize - 1;
2237
+ }, y._tr_align = function(o) {
2238
+ X(o, 2, 3), K(o, w, J), function(k) {
2239
+ k.bi_valid === 16 ? (tt(k, k.bi_buf), k.bi_buf = 0, k.bi_valid = 0) : 8 <= k.bi_valid && (k.pending_buf[k.pending++] = 255 & k.bi_buf, k.bi_buf >>= 8, k.bi_valid -= 8);
2240
+ }(o);
2241
+ };
2242
+ }, { "../utils/common": 41 }], 53: [function(g, U, y) {
2243
+ U.exports = function() {
2244
+ 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;
2245
+ };
2246
+ }, {}], 54: [function(g, U, y) {
2247
+ (function(h) {
2248
+ (function(l, r) {
2249
+ if (!l.setImmediate) {
2250
+ var s, _, b, p, v = 1, i = {}, f = !1, n = l.document, u = Object.getPrototypeOf && Object.getPrototypeOf(l);
2251
+ u = u && u.setTimeout ? u : l, s = {}.toString.call(l.process) === "[object process]" ? function(S) {
2252
+ process.nextTick(function() {
2253
+ d(S);
2254
+ });
2255
+ } : function() {
2256
+ if (l.postMessage && !l.importScripts) {
2257
+ var S = !0, x = l.onmessage;
2258
+ return l.onmessage = function() {
2259
+ S = !1;
2260
+ }, l.postMessage("", "*"), l.onmessage = x, S;
2261
+ }
2262
+ }() ? (p = "setImmediate$" + Math.random() + "$", l.addEventListener ? l.addEventListener("message", w, !1) : l.attachEvent("onmessage", w), function(S) {
2263
+ l.postMessage(p + S, "*");
2264
+ }) : l.MessageChannel ? ((b = new MessageChannel()).port1.onmessage = function(S) {
2265
+ d(S.data);
2266
+ }, function(S) {
2267
+ b.port2.postMessage(S);
2268
+ }) : n && "onreadystatechange" in n.createElement("script") ? (_ = n.documentElement, function(S) {
2269
+ var x = n.createElement("script");
2270
+ x.onreadystatechange = function() {
2271
+ d(S), x.onreadystatechange = null, _.removeChild(x), x = null;
2272
+ }, _.appendChild(x);
2273
+ }) : function(S) {
2274
+ setTimeout(d, 0, S);
2275
+ }, u.setImmediate = function(S) {
2276
+ typeof S != "function" && (S = new Function("" + S));
2277
+ for (var x = new Array(arguments.length - 1), B = 0; B < x.length; B++) x[B] = arguments[B + 1];
2278
+ var T = { callback: S, args: x };
2279
+ return i[v] = T, s(v), v++;
2280
+ }, u.clearImmediate = a;
2281
+ }
2282
+ function a(S) {
2283
+ delete i[S];
2284
+ }
2285
+ function d(S) {
2286
+ if (f) setTimeout(d, 0, S);
2287
+ else {
2288
+ var x = i[S];
2289
+ if (x) {
2290
+ f = !0;
2291
+ try {
2292
+ (function(B) {
2293
+ var T = B.callback, M = B.args;
2294
+ switch (M.length) {
2295
+ case 0:
2296
+ T();
2297
+ break;
2298
+ case 1:
2299
+ T(M[0]);
2300
+ break;
2301
+ case 2:
2302
+ T(M[0], M[1]);
2303
+ break;
2304
+ case 3:
2305
+ T(M[0], M[1], M[2]);
2306
+ break;
2307
+ default:
2308
+ T.apply(r, M);
2309
+ }
2310
+ })(x);
2311
+ } finally {
2312
+ a(S), f = !1;
2313
+ }
2314
+ }
2315
+ }
2316
+ }
2317
+ function w(S) {
2318
+ S.source === l && typeof S.data == "string" && S.data.indexOf(p) === 0 && d(+S.data.slice(p.length));
2319
+ }
2320
+ })(typeof self > "u" ? h === void 0 ? this : h : self);
2321
+ }).call(this, typeof Xt < "u" ? Xt : typeof self < "u" ? self : typeof window < "u" ? window : {});
2322
+ }, {}] }, {}, [10])(10);
2323
+ });
2324
+ })(pe);
2325
+ var Be = pe.exports;
2326
+ const Re = /* @__PURE__ */ Te(Be);
2327
+ function fe(gt) {
2328
+ return new Date(gt).getTime();
2329
+ }
2330
+ let te = null;
2331
+ async function De() {
2332
+ return te || (te = (await import("./index-BrI6_G7d.mjs")).fetchFile), te;
2333
+ }
2334
+ class Fe {
2335
+ constructor() {
2336
+ Ft(this, "ffmpeg", null);
2337
+ Ft(this, "rawData", null);
2338
+ Ft(this, "format", "mp4");
2339
+ Ft(this, "progressCallback", null);
2340
+ Ft(this, "controller", new AbortController());
2341
+ }
2342
+ setProgressCallback(dt) {
2343
+ this.progressCallback = dt;
2344
+ }
2345
+ updateProgress(dt) {
2346
+ this.progressCallback && this.progressCallback(dt);
2347
+ }
2348
+ async initFFmpeg() {
2349
+ if (!this.ffmpeg) {
2350
+ const { FFmpeg: dt } = await import("./index-D8kRViJr.mjs");
2351
+ this.ffmpeg = new dt();
2352
+ }
2353
+ await this.ffmpeg.load({
2354
+ coreURL: "https://cdn.jsdelivr.net/npm/@ffmpeg/core@0.12.6/dist/esm/ffmpeg-core.js"
2355
+ });
2356
+ }
2357
+ parseM3u8(dt, g) {
2358
+ const h = dt.replace(/\r\n|\r/g, `
2359
+ `).split(`
2360
+ `).filter((r) => {
2361
+ const s = r.trim();
2362
+ return s.endsWith(".ts") && !s.startsWith("#") && s !== "";
2363
+ }), l = g.substring(0, g.lastIndexOf("/") + 1);
2364
+ return h.map((r) => {
2365
+ const s = r.trim();
2366
+ let _;
2367
+ if (s.startsWith("http"))
2368
+ _ = s;
2369
+ else
2370
+ try {
2371
+ _ = new URL(s, g).href;
2372
+ } catch {
2373
+ _ = l + s;
2374
+ }
2375
+ return _;
2376
+ });
2377
+ }
2378
+ async convertHLSToMP4(dt, g) {
2379
+ g && this.setProgressCallback(g), this.format = "mp4", this.updateProgress(0), await this.initFFmpeg(), this.updateProgress(1);
2380
+ const U = await fetch(dt, {
2381
+ signal: this.controller.signal
2382
+ });
2383
+ if (!U.ok)
2384
+ throw new Error(`Failed to fetch m3u8: ${U.status}`);
2385
+ const y = await U.text(), h = this.parseM3u8(y, dt);
2386
+ if (h.length === 0)
2387
+ throw new Error("No TS segments found in the m3u8 file");
2388
+ let l = 0;
2389
+ const r = h.length, s = await Promise.all(
2390
+ h.map(async (b, p) => {
2391
+ const i = await (await De())(b), f = `segment_${p}.ts`;
2392
+ return await this.ffmpeg.writeFile(f, i), l++, this.updateProgress(`${Math.floor(l / r * 100)}`), f;
2393
+ })
2394
+ );
2395
+ let _ = y;
2396
+ return h.forEach((b, p) => {
2397
+ const v = b.split("/").pop() || "";
2398
+ _ = _.replace(v, s[p]);
2399
+ }), await this.ffmpeg.writeFile("input.m3u8", _), await this.ffmpeg.exec([
2400
+ "-protocol_whitelist",
2401
+ "file,http,https,tcp,tls",
2402
+ "-i",
2403
+ "input.m3u8",
2404
+ "-c",
2405
+ "copy",
2406
+ "-movflags",
2407
+ "+faststart",
2408
+ "output.mp4"
2409
+ ]), this.rawData = await this.ffmpeg.readFile("output.mp4"), this.updateProgress(100), await Promise.all(s.map((b) => this.ffmpeg.deleteFile(b))), await this.ffmpeg.deleteFile("input.m3u8"), await this.ffmpeg.deleteFile("output.mp4"), this.rawData;
2410
+ }
2411
+ getMp4File() {
2412
+ return this.rawData;
2413
+ }
2414
+ getController() {
2415
+ return this.controller;
2416
+ }
2417
+ }
2418
+ const Pe = {
2419
+ key: 0,
2420
+ class: "error-overlay"
2421
+ }, Le = ["src"], Ne = {
2422
+ key: 2,
2423
+ class: "buffering-overlay"
2424
+ }, Ue = { class: "center-play-btn" }, Me = { class: "time-current" }, je = { class: "time-total" }, We = { class: "progress-track-container" }, Ze = { class: "progress-track virtual" }, He = { class: "time-current" }, Ge = { class: "time-total" }, Ke = ["onClick"], Xe = {
2425
+ key: 0,
2426
+ class: "download-progress"
2427
+ }, de = 3, $e = /* @__PURE__ */ ze({
2428
+ __name: "ImageDisplayVideo",
2429
+ props: {
2430
+ videoList: {},
2431
+ dialogWidth: {},
2432
+ dialogHeight: {}
2433
+ },
2434
+ setup(gt, { expose: dt }) {
2435
+ const { t: g } = xe(), U = Ee(), y = gt, h = pt(null), l = pt(null);
2436
+ let r = null;
2437
+ const s = pt(0), _ = pt(0), b = pt(0), p = pt(!1), v = pt(1), i = pt(!1), f = pt(!0), n = pt(!0), u = pt(!1), a = pt(!1), d = pt(!1), w = pt(!1), S = pt(0), x = pt([]), B = pt(0), T = pt(!1), M = pt(0), I = pt(0);
2438
+ let W = null, J = null, m = null, O = !1, e = !1;
2439
+ const F = /* @__PURE__ */ new Set(), rt = pt(0);
2440
+ let P = null;
2441
+ const nt = () => {
2442
+ const D = y.videoList;
2443
+ if (!(D != null && D.length)) {
2444
+ x.value = [], B.value = 0;
2445
+ return;
2446
+ }
2447
+ let j = 0;
2448
+ const Y = [];
2449
+ D.forEach((V, q) => {
2450
+ const ct = V.duration || 0;
2451
+ if (Y.push({
2452
+ videoUrl: V.media,
2453
+ start: j,
2454
+ duration: ct,
2455
+ end: j + ct,
2456
+ gapDuration: 0,
2457
+ isGap: !1
2458
+ }), j += ct, q < D.length - 1) {
2459
+ const vt = (fe(D[q + 1].startTime) - fe(V.endTime)) / 1e3;
2460
+ vt > 0 && (Y.push({
2461
+ videoUrl: "",
2462
+ start: j,
2463
+ duration: vt,
2464
+ end: j + vt,
2465
+ gapDuration: 0,
2466
+ isGap: !0
2467
+ }), j += vt);
2468
+ }
2469
+ }), x.value = Y, B.value = j;
2470
+ }, Z = [1, 2, 4, 8], Q = qt(() => x.value.filter((D) => !D.isGap)), A = qt(() => {
2471
+ var D, j;
2472
+ return ((j = (D = y.videoList) == null ? void 0 : D[_.value]) == null ? void 0 : j.thumb) || "";
2473
+ }), C = qt(() => {
2474
+ if (B.value === 0 || !rt.value) return 0;
2475
+ const D = K(b.value);
2476
+ return Math.max(0, Math.min(100, D / rt.value * 100));
2477
+ }), tt = (D) => {
2478
+ const j = Math.max(0, D || 0), Y = Math.floor(j / 3600), V = Math.floor(j % 3600 / 60), q = Math.floor(j % 60);
2479
+ return Y > 0 ? `${String(Y).padStart(2, "0")}:${String(V).padStart(2, "0")}:${String(q).padStart(2, "0")}` : `${String(V).padStart(2, "0")}:${String(q).padStart(2, "0")}`;
2480
+ }, X = () => {
2481
+ const D = x.value, j = rt.value || 1, Y = D.length;
2482
+ if (!Y || !j) return [];
2483
+ const V = B.value || 1, q = (Y - 1) * de, ct = Math.max(0, j - q), vt = [];
2484
+ let St = 0;
2485
+ for (let Dt = 0; Dt < Y; Dt++) {
2486
+ const Wt = V > 0 ? D[Dt].duration / V * ct : 0;
2487
+ vt.push({ leftPx: St, widthPx: Wt }), St += Wt + de;
2488
+ }
2489
+ return vt;
2490
+ }, K = (D) => {
2491
+ const j = x.value, Y = X();
2492
+ for (let V = 0; V < j.length; V++) {
2493
+ const q = j[V];
2494
+ if (D >= q.start && D < q.end) {
2495
+ const ct = q.duration ? (D - q.start) / q.duration : 0;
2496
+ return Y[V].leftPx + ct * Y[V].widthPx;
2497
+ }
2498
+ }
2499
+ if (Y.length) {
2500
+ const V = Y[Y.length - 1];
2501
+ return V.leftPx + V.widthPx;
2502
+ }
2503
+ return 0;
2504
+ }, lt = (D) => {
2505
+ const j = x.value, Y = X();
2506
+ for (let V = 0; V < Y.length; V++) {
2507
+ const q = Y[V];
2508
+ if (D >= q.leftPx && D <= q.leftPx + q.widthPx) {
2509
+ const ct = q.widthPx ? (D - q.leftPx) / q.widthPx : 0;
2510
+ return j[V].start + ct * j[V].duration;
2511
+ }
2512
+ }
2513
+ if (Y.length) {
2514
+ const V = Y[Y.length - 1];
2515
+ if (D > V.leftPx + V.widthPx) return j[j.length - 1].end;
2516
+ for (let q = 0; q < Y.length; q++)
2517
+ if (D <= Y[q].leftPx) return j[q].start;
2518
+ }
2519
+ return 0;
2520
+ }, _t = (D, j) => {
2521
+ const Y = rt.value || 1, q = X()[j] || { leftPx: 0, widthPx: 0 };
2522
+ return {
2523
+ left: `${q.leftPx / Y * 100}%`,
2524
+ width: `${q.widthPx / Y * 100}%`
2525
+ };
2526
+ }, st = (D) => {
2527
+ const j = Q.value;
2528
+ if (!j.length) return { index: 0, local: 0 };
2529
+ for (let V = 0; V < j.length; V++)
2530
+ if (D >= j[V].start && D <= j[V].end)
2531
+ return { index: V, local: D - j[V].start };
2532
+ for (let V = 0; V < j.length; V++)
2533
+ if (D < j[V].start) return { index: V, local: 0 };
2534
+ const Y = j[j.length - 1];
2535
+ return { index: j.length - 1, local: Y.duration - 0.05 };
2536
+ }, it = () => (r == null ? void 0 : r.media) || null, mt = () => {
2537
+ const D = it();
2538
+ D && (D.addEventListener("timeupdate", L), D.addEventListener("ended", N), D.addEventListener("canplay", E), D.addEventListener("waiting", H), D.addEventListener("playing", $), D.addEventListener("pause", G), D.addEventListener("error", et));
2539
+ }, ut = () => {
2540
+ const D = it();
2541
+ D && (D.removeEventListener("timeupdate", L), D.removeEventListener("ended", N), D.removeEventListener("canplay", E), D.removeEventListener("waiting", H), D.removeEventListener("playing", $), D.removeEventListener("pause", G), D.removeEventListener("error", et));
2542
+ }, kt = (D) => {
2543
+ if (r)
2544
+ try {
2545
+ r.switchURL(D);
2546
+ } catch {
2547
+ i.value = !0;
2548
+ }
2549
+ else {
2550
+ if (!ce.isSupported()) {
2551
+ i.value = !0;
2552
+ return;
2553
+ }
2554
+ r = new Oe({
2555
+ el: h.value,
2556
+ url: D,
2557
+ width: "100%",
2558
+ height: "100%",
2559
+ isLive: !1,
2560
+ autoplay: !1,
2561
+ controls: !1,
2562
+ plugins: [ce],
2563
+ // 隐藏 xgplayer 默认 UI，仅作为播放内核
2564
+ videoFillMode: "fill",
2565
+ fitVideoSize: "auto",
2566
+ cssFullscreen: !1,
2567
+ fullscreen: !1,
2568
+ keyboard: !1,
2569
+ playsinline: !0
2570
+ }), mt(), r.on("loadedmetadata", () => {
2571
+ R();
2572
+ }), r.on("error", () => {
2573
+ i.value = !0;
2574
+ });
2575
+ }
2576
+ }, yt = () => {
2577
+ ut(), r && (r.destroy(), r = null);
2578
+ }, t = () => {
2579
+ const D = it();
2580
+ D && D.playbackRate !== v.value && (D.playbackRate = v.value);
2581
+ }, R = () => {
2582
+ const D = it();
2583
+ if (D) {
2584
+ if (t(), m != null) {
2585
+ const j = Q.value[s.value], Y = j == null ? void 0 : j.duration, V = m;
2586
+ D.currentTime = Y && isFinite(V) ? Math.max(0, Math.min(V, Y - 0.05)) : Math.max(0, V), m = null;
2587
+ }
2588
+ O && (O = !1, D.play().catch(() => {
2589
+ }));
2590
+ }
2591
+ }, z = (D, j, Y) => {
2592
+ const V = Q.value[D];
2593
+ V && (s.value = D, _.value = D, k = !1, m = Math.max(0, j), O = Y, n.value = !0, u.value = !0, kt(V.videoUrl));
2594
+ }, c = () => {
2595
+ const D = it();
2596
+ if (D) {
2597
+ if (b.value >= B.value - 0.05) {
2598
+ b.value = 0, z(0, 0, !0);
2599
+ return;
2600
+ }
2601
+ D.paused ? D.play().then(() => {
2602
+ p.value = !0, n.value = !1, at();
2603
+ }).catch(() => {
2604
+ }) : (D.pause(), p.value = !1, f.value = !0);
2605
+ }
2606
+ };
2607
+ let o = 0, k = !1;
2608
+ const L = () => {
2609
+ var Y;
2610
+ if (d.value) return;
2611
+ const D = it(), j = Q.value[s.value];
2612
+ if (D && j) {
2613
+ const V = j.end, q = j.start + D.currentTime;
2614
+ b.value = Math.max(j.start, Math.min(q, V));
2615
+ const ct = Date.now();
2616
+ ct - o >= 1e3 && (o = ct, console.log("[Progress]", {
2617
+ index: s.value,
2618
+ currentTime: Number(D.currentTime.toFixed(2)),
2619
+ videoDuration: Number((Y = D.duration) == null ? void 0 : Y.toFixed(2)),
2620
+ segStart: Number(j.start.toFixed(2)),
2621
+ segEnd: Number(j.end.toFixed(2)),
2622
+ globalTime: Number(b.value.toFixed(2)),
2623
+ totalDuration: Number(B.value.toFixed(2)),
2624
+ metaDurations: y.videoList.map((St) => St.duration)
2625
+ }));
2626
+ const vt = j.duration;
2627
+ D.currentTime >= vt - 0.1 && !k && (k = !0, N());
2628
+ }
2629
+ }, N = () => {
2630
+ const D = Q.value[s.value];
2631
+ D && (b.value = D.end), s.value < Q.value.length - 1 ? z(s.value + 1, 0, !0) : (p.value = !1, f.value = !0, n.value = !0);
2632
+ }, E = () => {
2633
+ i.value = !1, u.value = !1, R();
2634
+ }, H = () => {
2635
+ u.value = !0;
2636
+ }, $ = () => {
2637
+ u.value = !1, p.value = !0, n.value = !1, at();
2638
+ }, G = () => {
2639
+ u.value = !1, p.value = !1, f.value = !0;
2640
+ }, et = () => {
2641
+ i.value = !0, n.value = !1;
2642
+ }, ot = () => {
2643
+ i.value = !1, Q.value[s.value] && z(s.value, 0, !1);
2644
+ }, at = () => {
2645
+ f.value = !0, W && clearTimeout(W), W = setTimeout(() => {
2646
+ p.value && !a.value && (f.value = !1);
2647
+ }, 1500);
2648
+ }, bt = () => {
2649
+ a.value = !0, p.value && (f.value = !0, W && clearTimeout(W));
2650
+ }, Tt = () => {
2651
+ a.value = !1, p.value && at();
2652
+ }, wt = (D) => {
2653
+ const j = l.value;
2654
+ if (!j) return 0;
2655
+ const Y = j.getBoundingClientRect();
2656
+ return Math.max(0, Math.min(1, (D - Y.left) / Y.width)) * 100;
2657
+ }, Et = (D) => {
2658
+ const j = D / 100 * (rt.value || 1);
2659
+ return lt(j);
2660
+ }, ht = (D) => {
2661
+ const j = Et(D), Y = st(j), V = Q.value[Y.index];
2662
+ if (!V) return;
2663
+ b.value = V.start + Y.local;
2664
+ const q = it();
2665
+ if (q && Y.index === s.value) {
2666
+ q.currentTime = Y.local;
2667
+ return;
2668
+ }
2669
+ z(Y.index, Y.local, p.value);
2670
+ }, Rt = (D) => {
2671
+ if (D.preventDefault(), !l.value) return;
2672
+ d.value = !0, T.value = !0;
2673
+ const j = (V) => {
2674
+ J || (J = setTimeout(() => {
2675
+ var St;
2676
+ J = null;
2677
+ const q = wt(V.clientX), ct = Et(q);
2678
+ I.value = q, M.value = Math.max(0, Math.min(ct, B.value - 0.05));
2679
+ const vt = st(ct);
2680
+ b.value = ((St = Q.value[vt.index]) == null ? void 0 : St.start) + vt.local;
2681
+ }, 30));
2682
+ }, Y = (V) => {
2683
+ d.value = !1, T.value = !1, J && (clearTimeout(J), J = null), document.removeEventListener("mousemove", j), document.removeEventListener("mouseup", Y), ht(wt(V.clientX));
2684
+ };
2685
+ document.addEventListener("mousemove", j), document.addEventListener("mouseup", Y);
2686
+ }, Pt = (D) => {
2687
+ const j = wt(D.clientX);
2688
+ I.value = j, M.value = Math.max(0, Math.min(Et(j), B.value - 0.05)), T.value = !0;
2689
+ }, xt = () => {
2690
+ T.value = !1;
2691
+ }, Nt = () => {
2692
+ I.value = C.value, M.value = Math.max(0, Math.min(b.value, B.value - 0.05)), T.value = !0;
2693
+ }, Ut = () => {
2694
+ P == null || P.abort();
2695
+ }, Mt = (D, j) => {
2696
+ const Y = URL.createObjectURL(D), V = document.createElement("a");
2697
+ V.href = Y, V.download = j, V.click(), URL.revokeObjectURL(Y);
2698
+ }, Vt = async () => {
2699
+ var Y, V;
2700
+ if (w.value) return;
2701
+ P == null || P.abort(), P = new AbortController(), w.value = !0, S.value = 0;
2702
+ const D = [], j = () => {
2703
+ D.forEach((q) => q.getController().abort());
2704
+ };
2705
+ P.signal.addEventListener("abort", j);
2706
+ try {
2707
+ const q = y.videoList, ct = (Y = q == null ? void 0 : q[0]) == null ? void 0 : Y.deviceId, vt = ((V = q == null ? void 0 : q[0]) == null ? void 0 : V.startTime) || (/* @__PURE__ */ new Date()).toISOString(), St = q.length, Dt = new Array(St).fill(0), Wt = async (Zt, Yt) => {
2708
+ const Ht = new Fe();
2709
+ D.push(Ht), Ht.setProgressCallback((_e) => {
2710
+ Dt[Yt] = Number(_e) || 0, S.value = Math.round(
2711
+ Dt.reduce((ve, be) => ve + be, 0) / St
2712
+ );
2713
+ }), await Ht.convertHLSToMP4(Zt.media);
2714
+ const ne = Ht.getMp4File();
2715
+ if (!ne) throw new Error("No video data");
2716
+ return new Blob([ne.buffer], { type: "video/mp4" });
2717
+ }, ee = await Promise.all(q.map(Wt));
2718
+ if (P != null && P.signal.aborted) throw new Error("Download aborted");
2719
+ if (St === 1) {
2720
+ Mt(ee[0], `${ct} (${vt}).mp4`);
2721
+ return;
2722
+ }
2723
+ const re = new Re(), me = re.folder(`${ct} (${vt}).mp4`);
2724
+ q.forEach((Zt, Yt) => {
2725
+ me.file(`${Zt.deviceId} (${Zt.startTime}).mp4`, ee[Yt]);
2726
+ });
2727
+ const ge = await re.generateAsync({ type: "blob" });
2728
+ Mt(ge, `${ct} (${vt}).zip`);
2729
+ } catch (q) {
2730
+ if (P != null && P.signal.aborted) {
2731
+ console.log("[Download] cancelled");
2732
+ return;
2733
+ }
2734
+ console.error("[Download]", q), U.error(g("downloadFailed"));
2735
+ } finally {
2736
+ P == null || P.signal.removeEventListener("abort", j), P = null, w.value = !1;
2737
+ }
2738
+ };
2739
+ dt({ abortDownload: Ut });
2740
+ const jt = () => {
2741
+ var D;
2742
+ (D = y.videoList) == null || D.forEach((j) => {
2743
+ if (!j.thumb || F.has(j.thumb)) return;
2744
+ F.add(j.thumb);
2745
+ const Y = new Image();
2746
+ Y.src = j.thumb;
2747
+ });
2748
+ };
2749
+ ae(() => y.videoList, (D) => {
2750
+ D != null && D.length && (nt(), jt(), s.value = 0, b.value = 0, p.value = !1, f.value = !0, n.value = !0, i.value = !1, r ? z(0, 0, !1) : e = !0);
2751
+ }, { immediate: !0 }), Ae(() => {
2752
+ var D;
2753
+ Ct(), window.addEventListener("resize", Ct), e && ((D = y.videoList) != null && D.length) && (e = !1, z(0, 0, !1));
2754
+ });
2755
+ const Ct = () => {
2756
+ const D = l.value;
2757
+ D && (rt.value = D.getBoundingClientRect().width);
2758
+ };
2759
+ return ae(v, () => {
2760
+ t();
2761
+ }), Ie(() => {
2762
+ Ut(), W && clearTimeout(W), J && clearTimeout(J), window.removeEventListener("resize", Ct), yt();
2763
+ }), (D, j) => {
2764
+ const Y = Se, V = ke;
2765
+ return zt(), At("div", {
2766
+ class: "video-viewport",
2767
+ style: Lt({ width: gt.dialogWidth + "px", height: gt.dialogHeight + "px" }),
2768
+ onMouseenter: bt,
2769
+ onMouseleave: Tt
2770
+ }, [
2771
+ ft("div", {
2772
+ ref_key: "playerContainerRef",
2773
+ ref: h,
2774
+ class: "xgplayer-container"
2775
+ }, null, 512),
2776
+ i.value ? (zt(), At("div", Pe, [
2777
+ ft("p", null, It(se(g)("videoLoadFailed")), 1),
2778
+ ft("button", { onClick: ot }, It(se(g)("retry")), 1)
2779
+ ])) : Gt("", !0),
2780
+ n.value && A.value ? (zt(), At("img", {
2781
+ key: 1,
2782
+ class: "video-cover",
2783
+ src: A.value,
2784
+ alt: ""
2785
+ }, null, 8, Le)) : Gt("", !0),
2786
+ u.value ? (zt(), At("div", Ne, [
2787
+ Ot(ie, {
2788
+ white: !0,
2789
+ loading: !0
2790
+ })
2791
+ ])) : Gt("", !0),
2792
+ ft("div", {
2793
+ class: "center-play-overlay",
2794
+ onClick: c
2795
+ }, [
2796
+ Ot(oe, { name: "fade" }, {
2797
+ default: Kt(() => [
2798
+ Jt(ft("div", Ue, [
2799
+ Ot(Y, {
2800
+ name: p.value ? "stopPlay" : "play",
2801
+ "font-size": "48",
2802
+ color: "#fff"
2803
+ }, null, 8, ["name"])
2804
+ ], 512), [
2805
+ [Qt, f.value]
2806
+ ])
2807
+ ]),
2808
+ _: 1
2809
+ }),
2810
+ Ot(oe, { name: "fade" }, {
2811
+ default: Kt(() => [
2812
+ Jt(ft("div", {
2813
+ class: "center-time",
2814
+ onClick: j[0] || (j[0] = Bt(() => {
2815
+ }, ["stop"]))
2816
+ }, [
2817
+ ft("span", Me, It(tt(b.value)), 1),
2818
+ j[4] || (j[4] = ft("span", { class: "time-sep" }, "/", -1)),
2819
+ ft("span", je, It(tt(B.value)), 1)
2820
+ ], 512), [
2821
+ [Qt, f.value]
2822
+ ])
2823
+ ]),
2824
+ _: 1
2825
+ })
2826
+ ]),
2827
+ ft("div", {
2828
+ class: "bottom-controls",
2829
+ onClick: j[3] || (j[3] = Bt(() => {
2830
+ }, ["stop"]))
2831
+ }, [
2832
+ ft("div", {
2833
+ class: "progress-container",
2834
+ style: Lt({ width: gt.dialogWidth - 500 + "px" })
2835
+ }, [
2836
+ ft("div", We, [
2837
+ ft("div", Ze, [
2838
+ Jt(ft("div", {
2839
+ class: "thumb-time",
2840
+ style: Lt({ left: I.value + "%" })
2841
+ }, [
2842
+ ft("span", He, It(tt(M.value)), 1),
2843
+ j[5] || (j[5] = ft("span", { class: "time-sep" }, "/", -1)),
2844
+ ft("span", Ge, It(tt(B.value)), 1)
2845
+ ], 4), [
2846
+ [Qt, T.value]
2847
+ ])
2848
+ ]),
2849
+ ft("div", {
2850
+ class: "progress-track",
2851
+ ref_key: "trackRef",
2852
+ ref: l,
2853
+ onMousedown: Rt,
2854
+ onMousemove: Pt,
2855
+ onMouseleave: xt
2856
+ }, [
2857
+ (zt(!0), At(le, null, ue(x.value, (q, ct) => (zt(), At("div", {
2858
+ key: ct,
2859
+ class: he(["progress-segment", { gap: q.isGap }]),
2860
+ style: Lt(_t(q, ct))
2861
+ }, null, 6))), 128)),
2862
+ ft("div", {
2863
+ class: "progress-thumb",
2864
+ style: Lt({ left: C.value + "%" }),
2865
+ onMousemove: Bt(Nt, ["stop"]),
2866
+ onMouseleave: j[1] || (j[1] = Bt((q) => T.value = !1, ["stop"]))
2867
+ }, [...j[6] || (j[6] = [
2868
+ ft("div", { class: "thumb-dot" }, null, -1)
2869
+ ])], 36)
2870
+ ], 544)
2871
+ ]),
2872
+ ft("div", {
2873
+ class: "speed-selector",
2874
+ onClick: j[2] || (j[2] = Bt(() => {
2875
+ }, ["stop"]))
2876
+ }, [
2877
+ (zt(), At(le, null, ue(Z, (q) => ft("span", {
2878
+ key: q,
2879
+ class: he(["speed-text", { active: v.value === q }]),
2880
+ onClick: Bt((ct) => v.value = q, ["stop"])
2881
+ }, "X" + It(q), 11, Ke)), 64))
2882
+ ])
2883
+ ], 4)
2884
+ ]),
2885
+ ft("div", {
2886
+ class: "download",
2887
+ onClick: Bt(Vt, ["stop"])
2888
+ }, [
2889
+ Ot(V, {
2890
+ loading: w.value,
2891
+ type: "primary",
2892
+ size: "default"
2893
+ }, {
2894
+ loading: Kt(() => [
2895
+ Ot(ie, {
2896
+ white: !0,
2897
+ loading: w.value
2898
+ }, null, 8, ["loading"])
2899
+ ]),
2900
+ default: Kt(() => [
2901
+ Ot(Y, {
2902
+ name: "cargoCam-iconDownload",
2903
+ "font-size": "24",
2904
+ inert: "",
2905
+ tabindex: "-1"
2906
+ }),
2907
+ w.value ? (zt(), At("span", Xe, It(Math.round(S.value)) + "%", 1)) : Gt("", !0)
2908
+ ]),
2909
+ _: 1
2910
+ }, 8, ["loading"])
2911
+ ])
2912
+ ], 36);
2913
+ };
2914
+ }
2915
+ }), rr = /* @__PURE__ */ Ce($e, [["__scopeId", "data-v-b4327930"]]);
2916
+ export {
2917
+ rr as default
2918
+ };