@uipath/codedapp-tool 1.206.0-preview.303 → 1.207.0-preview.305

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.
@@ -0,0 +1,915 @@
1
+ // ../../node_modules/fflate/esm/index.mjs
2
+ import { createRequire } from "module";
3
+ var require2 = createRequire("/");
4
+ var _a;
5
+ var Worker;
6
+ var isMarkedAsUntransferable;
7
+ try {
8
+ _a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
9
+ } catch (e) {}
10
+ var u8 = Uint8Array;
11
+ var u16 = Uint16Array;
12
+ var i32 = Int32Array;
13
+ var fleb = new u8([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, 0, 0, 0]);
14
+ var fdeb = new u8([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, 0, 0]);
15
+ var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
16
+ var freb = function(eb, start) {
17
+ var b = new u16(31);
18
+ for (var i = 0;i < 31; ++i) {
19
+ b[i] = start += 1 << eb[i - 1];
20
+ }
21
+ var r = new i32(b[30]);
22
+ for (var i = 1;i < 30; ++i) {
23
+ for (var j = b[i];j < b[i + 1]; ++j) {
24
+ r[j] = j - b[i] << 5 | i;
25
+ }
26
+ }
27
+ return { b, r };
28
+ };
29
+ var _a = freb(fleb, 2);
30
+ var fl = _a.b;
31
+ var revfl = _a.r;
32
+ fl[28] = 258, revfl[258] = 28;
33
+ var _b = freb(fdeb, 0);
34
+ var fd = _b.b;
35
+ var revfd = _b.r;
36
+ var rev = new u16(32768);
37
+ for (i = 0;i < 32768; ++i) {
38
+ x = (i & 43690) >> 1 | (i & 21845) << 1;
39
+ x = (x & 52428) >> 2 | (x & 13107) << 2;
40
+ x = (x & 61680) >> 4 | (x & 3855) << 4;
41
+ rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
42
+ }
43
+ var x;
44
+ var i;
45
+ var hMap = function(cd, mb, r) {
46
+ var s = cd.length;
47
+ var i = 0;
48
+ var l = new u16(mb);
49
+ for (;i < s; ++i) {
50
+ if (cd[i])
51
+ ++l[cd[i] - 1];
52
+ }
53
+ var le = new u16(mb);
54
+ for (i = 1;i < mb; ++i) {
55
+ le[i] = le[i - 1] + l[i - 1] << 1;
56
+ }
57
+ var co;
58
+ if (r) {
59
+ co = new u16(1 << mb);
60
+ var rvb = 15 - mb;
61
+ for (i = 0;i < s; ++i) {
62
+ if (cd[i]) {
63
+ var sv = i << 4 | cd[i];
64
+ var r_1 = mb - cd[i];
65
+ var v = le[cd[i] - 1]++ << r_1;
66
+ for (var m = v | (1 << r_1) - 1;v <= m; ++v) {
67
+ co[rev[v] >> rvb] = sv;
68
+ }
69
+ }
70
+ }
71
+ } else {
72
+ co = new u16(s);
73
+ for (i = 0;i < s; ++i) {
74
+ if (cd[i]) {
75
+ co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
76
+ }
77
+ }
78
+ }
79
+ return co;
80
+ };
81
+ var flt = new u8(288);
82
+ for (i = 0;i < 144; ++i)
83
+ flt[i] = 8;
84
+ var i;
85
+ for (i = 144;i < 256; ++i)
86
+ flt[i] = 9;
87
+ var i;
88
+ for (i = 256;i < 280; ++i)
89
+ flt[i] = 7;
90
+ var i;
91
+ for (i = 280;i < 288; ++i)
92
+ flt[i] = 8;
93
+ var i;
94
+ var fdt = new u8(32);
95
+ for (i = 0;i < 32; ++i)
96
+ fdt[i] = 5;
97
+ var i;
98
+ var flm = /* @__PURE__ */ hMap(flt, 9, 0);
99
+ var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
100
+ var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
101
+ var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
102
+ var max = function(a) {
103
+ var m = a[0];
104
+ for (var i = 1;i < a.length; ++i) {
105
+ if (a[i] > m)
106
+ m = a[i];
107
+ }
108
+ return m;
109
+ };
110
+ var bits = function(d, p, m) {
111
+ var o = p / 8 | 0;
112
+ return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
113
+ };
114
+ var bits16 = function(d, p) {
115
+ var o = p / 8 | 0;
116
+ return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
117
+ };
118
+ var shft = function(p) {
119
+ return (p + 7) / 8 | 0;
120
+ };
121
+ var slc = function(v, s, e) {
122
+ if (s == null || s < 0)
123
+ s = 0;
124
+ if (e == null || e > v.length)
125
+ e = v.length;
126
+ return new u8(v.subarray(s, e));
127
+ };
128
+ var ec = [
129
+ "unexpected EOF",
130
+ "invalid block type",
131
+ "invalid length/literal",
132
+ "invalid distance",
133
+ "stream finished",
134
+ "no stream handler",
135
+ ,
136
+ "no callback",
137
+ "invalid UTF-8 data",
138
+ "extra field too long",
139
+ "date not in range 1980-2099",
140
+ "filename too long",
141
+ "stream finishing",
142
+ "invalid zip data"
143
+ ];
144
+ var err = function(ind, msg, nt) {
145
+ var e = new Error(msg || ec[ind]);
146
+ e.code = ind;
147
+ if (Error.captureStackTrace)
148
+ Error.captureStackTrace(e, err);
149
+ if (!nt)
150
+ throw e;
151
+ return e;
152
+ };
153
+ var inflt = function(dat, st, buf, dict) {
154
+ var sl = dat.length, dl = dict ? dict.length : 0;
155
+ if (!sl || st.f && !st.l)
156
+ return buf || new u8(0);
157
+ var noBuf = !buf;
158
+ var resize = noBuf || st.i != 2;
159
+ var noSt = st.i;
160
+ if (noBuf)
161
+ buf = new u8(sl * 3);
162
+ var cbuf = function(l) {
163
+ var bl = buf.length;
164
+ if (l > bl) {
165
+ var nbuf = new u8(Math.max(bl * 2, l));
166
+ nbuf.set(buf);
167
+ buf = nbuf;
168
+ }
169
+ };
170
+ var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, { l: lm, d: dm, m: lbt, n: dbt } = st;
171
+ var tbts = sl * 8;
172
+ do {
173
+ if (!lm) {
174
+ final = bits(dat, pos, 1);
175
+ var type = bits(dat, pos + 1, 3);
176
+ pos += 3;
177
+ if (!type) {
178
+ var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
179
+ if (t > sl) {
180
+ if (noSt)
181
+ err(0);
182
+ break;
183
+ }
184
+ if (resize)
185
+ cbuf(bt + l);
186
+ buf.set(dat.subarray(s, t), bt);
187
+ st.b = bt += l, st.p = pos = t * 8, st.f = final;
188
+ continue;
189
+ } else if (type == 1)
190
+ lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
191
+ else if (type == 2) {
192
+ var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
193
+ var tl = hLit + bits(dat, pos + 5, 31) + 1;
194
+ pos += 14;
195
+ var ldt = new u8(tl);
196
+ var clt = new u8(19);
197
+ for (var i = 0;i < hcLen; ++i) {
198
+ clt[clim[i]] = bits(dat, pos + i * 3, 7);
199
+ }
200
+ pos += hcLen * 3;
201
+ var clb = max(clt), clbmsk = (1 << clb) - 1;
202
+ var clm = hMap(clt, clb, 1);
203
+ for (var i = 0;i < tl; ) {
204
+ var r = clm[bits(dat, pos, clbmsk)];
205
+ pos += r & 15;
206
+ var s = r >> 4;
207
+ if (s < 16) {
208
+ ldt[i++] = s;
209
+ } else {
210
+ var c = 0, n = 0;
211
+ if (s == 16)
212
+ n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
213
+ else if (s == 17)
214
+ n = 3 + bits(dat, pos, 7), pos += 3;
215
+ else if (s == 18)
216
+ n = 11 + bits(dat, pos, 127), pos += 7;
217
+ while (n--)
218
+ ldt[i++] = c;
219
+ }
220
+ }
221
+ var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
222
+ lbt = max(lt);
223
+ dbt = max(dt);
224
+ lm = hMap(lt, lbt, 1);
225
+ dm = hMap(dt, dbt, 1);
226
+ } else
227
+ err(1);
228
+ if (pos > tbts) {
229
+ if (noSt)
230
+ err(0);
231
+ break;
232
+ }
233
+ }
234
+ if (resize)
235
+ cbuf(bt + 131072);
236
+ var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
237
+ var lpos = pos;
238
+ for (;; lpos = pos) {
239
+ var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
240
+ pos += c & 15;
241
+ if (pos > tbts) {
242
+ if (noSt)
243
+ err(0);
244
+ break;
245
+ }
246
+ if (!c)
247
+ err(2);
248
+ if (sym < 256)
249
+ buf[bt++] = sym;
250
+ else if (sym == 256) {
251
+ lpos = pos, lm = null;
252
+ break;
253
+ } else {
254
+ var add = sym - 254;
255
+ if (sym > 264) {
256
+ var i = sym - 257, b = fleb[i];
257
+ add = bits(dat, pos, (1 << b) - 1) + fl[i];
258
+ pos += b;
259
+ }
260
+ var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
261
+ if (!d)
262
+ err(3);
263
+ pos += d & 15;
264
+ var dt = fd[dsym];
265
+ if (dsym > 3) {
266
+ var b = fdeb[dsym];
267
+ dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
268
+ }
269
+ if (pos > tbts) {
270
+ if (noSt)
271
+ err(0);
272
+ break;
273
+ }
274
+ if (resize)
275
+ cbuf(bt + 131072);
276
+ var end = bt + add;
277
+ if (bt < dt) {
278
+ var shift = dl - dt, dend = Math.min(dt, end);
279
+ if (shift + bt < 0)
280
+ err(3);
281
+ for (;bt < dend; ++bt)
282
+ buf[bt] = dict[shift + bt];
283
+ }
284
+ for (;bt < end; ++bt)
285
+ buf[bt] = buf[bt - dt];
286
+ }
287
+ }
288
+ st.l = lm, st.p = lpos, st.b = bt, st.f = final;
289
+ if (lm)
290
+ final = 1, st.m = lbt, st.d = dm, st.n = dbt;
291
+ } while (!final);
292
+ return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
293
+ };
294
+ var wbits = function(d, p, v) {
295
+ v <<= p & 7;
296
+ var o = p / 8 | 0;
297
+ d[o] |= v;
298
+ d[o + 1] |= v >> 8;
299
+ };
300
+ var wbits16 = function(d, p, v) {
301
+ v <<= p & 7;
302
+ var o = p / 8 | 0;
303
+ d[o] |= v;
304
+ d[o + 1] |= v >> 8;
305
+ d[o + 2] |= v >> 16;
306
+ };
307
+ var hTree = function(d, mb) {
308
+ var t = [];
309
+ for (var i = 0;i < d.length; ++i) {
310
+ if (d[i])
311
+ t.push({ s: i, f: d[i] });
312
+ }
313
+ var s = t.length;
314
+ var t2 = t.slice();
315
+ if (!s)
316
+ return { t: et, l: 0 };
317
+ if (s == 1) {
318
+ var v = new u8(t[0].s + 1);
319
+ v[t[0].s] = 1;
320
+ return { t: v, l: 1 };
321
+ }
322
+ t.sort(function(a, b) {
323
+ return a.f - b.f;
324
+ });
325
+ t.push({ s: -1, f: 25001 });
326
+ var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
327
+ t[0] = { s: -1, f: l.f + r.f, l, r };
328
+ while (i1 != s - 1) {
329
+ l = t[t[i0].f < t[i2].f ? i0++ : i2++];
330
+ r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
331
+ t[i1++] = { s: -1, f: l.f + r.f, l, r };
332
+ }
333
+ var maxSym = t2[0].s;
334
+ for (var i = 1;i < s; ++i) {
335
+ if (t2[i].s > maxSym)
336
+ maxSym = t2[i].s;
337
+ }
338
+ var tr = new u16(maxSym + 1);
339
+ var mbt = ln(t[i1 - 1], tr, 0);
340
+ if (mbt > mb) {
341
+ var i = 0, dt = 0;
342
+ var lft = mbt - mb, cst = 1 << lft;
343
+ t2.sort(function(a, b) {
344
+ return tr[b.s] - tr[a.s] || a.f - b.f;
345
+ });
346
+ for (;i < s; ++i) {
347
+ var i2_1 = t2[i].s;
348
+ if (tr[i2_1] > mb) {
349
+ dt += cst - (1 << mbt - tr[i2_1]);
350
+ tr[i2_1] = mb;
351
+ } else
352
+ break;
353
+ }
354
+ dt >>= lft;
355
+ while (dt > 0) {
356
+ var i2_2 = t2[i].s;
357
+ if (tr[i2_2] < mb)
358
+ dt -= 1 << mb - tr[i2_2]++ - 1;
359
+ else
360
+ ++i;
361
+ }
362
+ for (;i >= 0 && dt; --i) {
363
+ var i2_3 = t2[i].s;
364
+ if (tr[i2_3] == mb) {
365
+ --tr[i2_3];
366
+ ++dt;
367
+ }
368
+ }
369
+ mbt = mb;
370
+ }
371
+ return { t: new u8(tr), l: mbt };
372
+ };
373
+ var ln = function(n, l, d) {
374
+ return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
375
+ };
376
+ var lc = function(c) {
377
+ var s = c.length;
378
+ while (s && !c[--s])
379
+ ;
380
+ var cl = new u16(++s);
381
+ var cli = 0, cln = c[0], cls = 1;
382
+ var w = function(v) {
383
+ cl[cli++] = v;
384
+ };
385
+ for (var i = 1;i <= s; ++i) {
386
+ if (c[i] == cln && i != s)
387
+ ++cls;
388
+ else {
389
+ if (!cln && cls > 2) {
390
+ for (;cls > 138; cls -= 138)
391
+ w(32754);
392
+ if (cls > 2) {
393
+ w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
394
+ cls = 0;
395
+ }
396
+ } else if (cls > 3) {
397
+ w(cln), --cls;
398
+ for (;cls > 6; cls -= 6)
399
+ w(8304);
400
+ if (cls > 2)
401
+ w(cls - 3 << 5 | 8208), cls = 0;
402
+ }
403
+ while (cls--)
404
+ w(cln);
405
+ cls = 1;
406
+ cln = c[i];
407
+ }
408
+ }
409
+ return { c: cl.subarray(0, cli), n: s };
410
+ };
411
+ var clen = function(cf, cl) {
412
+ var l = 0;
413
+ for (var i = 0;i < cl.length; ++i)
414
+ l += cf[i] * cl[i];
415
+ return l;
416
+ };
417
+ var wfblk = function(out, pos, dat) {
418
+ var s = dat.length;
419
+ var o = shft(pos + 2);
420
+ out[o] = s & 255;
421
+ out[o + 1] = s >> 8;
422
+ out[o + 2] = out[o] ^ 255;
423
+ out[o + 3] = out[o + 1] ^ 255;
424
+ for (var i = 0;i < s; ++i)
425
+ out[o + i + 4] = dat[i];
426
+ return (o + 4 + s) * 8;
427
+ };
428
+ var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
429
+ wbits(out, p++, final);
430
+ ++lf[256];
431
+ var _a = hTree(lf, 15), { t: dlt, l: mlb } = _a;
432
+ var _b = hTree(df, 15), { t: ddt, l: mdb } = _b;
433
+ var _c = lc(dlt), { c: lclt, n: nlc } = _c;
434
+ var _d = lc(ddt), { c: lcdt, n: ndc } = _d;
435
+ var lcfreq = new u16(19);
436
+ for (var i = 0;i < lclt.length; ++i)
437
+ ++lcfreq[lclt[i] & 31];
438
+ for (var i = 0;i < lcdt.length; ++i)
439
+ ++lcfreq[lcdt[i] & 31];
440
+ var _e = hTree(lcfreq, 7), { t: lct, l: mlcb } = _e;
441
+ var nlcc = 19;
442
+ for (;nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
443
+ ;
444
+ var flen = bl + 5 << 3;
445
+ var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
446
+ var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
447
+ if (bs >= 0 && flen <= ftlen && flen <= dtlen)
448
+ return wfblk(out, p, dat.subarray(bs, bs + bl));
449
+ var lm, ll, dm, dl;
450
+ wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
451
+ if (dtlen < ftlen) {
452
+ lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
453
+ var llm = hMap(lct, mlcb, 0);
454
+ wbits(out, p, nlc - 257);
455
+ wbits(out, p + 5, ndc - 1);
456
+ wbits(out, p + 10, nlcc - 4);
457
+ p += 14;
458
+ for (var i = 0;i < nlcc; ++i)
459
+ wbits(out, p + 3 * i, lct[clim[i]]);
460
+ p += 3 * nlcc;
461
+ var lcts = [lclt, lcdt];
462
+ for (var it = 0;it < 2; ++it) {
463
+ var clct = lcts[it];
464
+ for (var i = 0;i < clct.length; ++i) {
465
+ var len = clct[i] & 31;
466
+ wbits(out, p, llm[len]), p += lct[len];
467
+ if (len > 15)
468
+ wbits(out, p, clct[i] >> 5 & 127), p += clct[i] >> 12;
469
+ }
470
+ }
471
+ } else {
472
+ lm = flm, ll = flt, dm = fdm, dl = fdt;
473
+ }
474
+ for (var i = 0;i < li; ++i) {
475
+ var sym = syms[i];
476
+ if (sym > 255) {
477
+ var len = sym >> 18 & 31;
478
+ wbits16(out, p, lm[len + 257]), p += ll[len + 257];
479
+ if (len > 7)
480
+ wbits(out, p, sym >> 23 & 31), p += fleb[len];
481
+ var dst = sym & 31;
482
+ wbits16(out, p, dm[dst]), p += dl[dst];
483
+ if (dst > 3)
484
+ wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
485
+ } else {
486
+ wbits16(out, p, lm[sym]), p += ll[sym];
487
+ }
488
+ }
489
+ wbits16(out, p, lm[256]);
490
+ return p + ll[256];
491
+ };
492
+ var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
493
+ var et = /* @__PURE__ */ new u8(0);
494
+ var dflt = function(dat, lvl, plvl, pre, post, st) {
495
+ var s = st.z || dat.length;
496
+ var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);
497
+ var w = o.subarray(pre, o.length - post);
498
+ var lst = st.l;
499
+ var pos = (st.r || 0) & 7;
500
+ if (lvl) {
501
+ if (pos)
502
+ w[0] = st.r >> 3;
503
+ var opt = deo[lvl - 1];
504
+ var n = opt >> 13, c = opt & 8191;
505
+ var msk_1 = (1 << plvl) - 1;
506
+ var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
507
+ var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
508
+ var hsh = function(i) {
509
+ return (dat[i] ^ dat[i + 1] << bs1_1 ^ dat[i + 2] << bs2_1) & msk_1;
510
+ };
511
+ var syms = new i32(25000);
512
+ var lf = new u16(288), df = new u16(32);
513
+ var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
514
+ for (;i + 2 < s; ++i) {
515
+ var hv = hsh(i);
516
+ var imod = i & 32767, pimod = head[hv];
517
+ prev[imod] = pimod;
518
+ head[hv] = imod;
519
+ if (wi <= i) {
520
+ var rem = s - i;
521
+ if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {
522
+ pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
523
+ li = lc_1 = eb = 0, bs = i;
524
+ for (var j = 0;j < 286; ++j)
525
+ lf[j] = 0;
526
+ for (var j = 0;j < 30; ++j)
527
+ df[j] = 0;
528
+ }
529
+ var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
530
+ if (rem > 2 && hv == hsh(i - dif)) {
531
+ var maxn = Math.min(n, rem) - 1;
532
+ var maxd = Math.min(32767, i);
533
+ var ml = Math.min(258, rem);
534
+ while (dif <= maxd && --ch_1 && imod != pimod) {
535
+ if (dat[i + l] == dat[i + l - dif]) {
536
+ var nl = 0;
537
+ for (;nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
538
+ ;
539
+ if (nl > l) {
540
+ l = nl, d = dif;
541
+ if (nl > maxn)
542
+ break;
543
+ var mmd = Math.min(dif, nl - 2);
544
+ var md = 0;
545
+ for (var j = 0;j < mmd; ++j) {
546
+ var ti = i - dif + j & 32767;
547
+ var pti = prev[ti];
548
+ var cd = ti - pti & 32767;
549
+ if (cd > md)
550
+ md = cd, pimod = ti;
551
+ }
552
+ }
553
+ }
554
+ imod = pimod, pimod = prev[imod];
555
+ dif += imod - pimod & 32767;
556
+ }
557
+ }
558
+ if (d) {
559
+ syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
560
+ var lin = revfl[l] & 31, din = revfd[d] & 31;
561
+ eb += fleb[lin] + fdeb[din];
562
+ ++lf[257 + lin];
563
+ ++df[din];
564
+ wi = i + l;
565
+ ++lc_1;
566
+ } else {
567
+ syms[li++] = dat[i];
568
+ ++lf[dat[i]];
569
+ }
570
+ }
571
+ }
572
+ for (i = Math.max(i, wi);i < s; ++i) {
573
+ syms[li++] = dat[i];
574
+ ++lf[dat[i]];
575
+ }
576
+ pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
577
+ if (!lst) {
578
+ st.r = pos & 7 | w[pos / 8 | 0] << 3;
579
+ pos -= 7;
580
+ st.h = head, st.p = prev, st.i = i, st.w = wi;
581
+ }
582
+ } else {
583
+ for (var i = st.w || 0;i < s + lst; i += 65535) {
584
+ var e = i + 65535;
585
+ if (e >= s) {
586
+ w[pos / 8 | 0] = lst;
587
+ e = s;
588
+ }
589
+ pos = wfblk(w, pos + 1, dat.subarray(i, e));
590
+ }
591
+ st.i = s;
592
+ }
593
+ return slc(o, 0, pre + shft(pos) + post);
594
+ };
595
+ var crct = /* @__PURE__ */ function() {
596
+ var t = new Int32Array(256);
597
+ for (var i = 0;i < 256; ++i) {
598
+ var c = i, k = 9;
599
+ while (--k)
600
+ c = (c & 1 && -306674912) ^ c >>> 1;
601
+ t[i] = c;
602
+ }
603
+ return t;
604
+ }();
605
+ var crc = function() {
606
+ var c = -1;
607
+ return {
608
+ p: function(d) {
609
+ var cr = c;
610
+ for (var i = 0;i < d.length; ++i)
611
+ cr = crct[cr & 255 ^ d[i]] ^ cr >>> 8;
612
+ c = cr;
613
+ },
614
+ d: function() {
615
+ return ~c;
616
+ }
617
+ };
618
+ };
619
+ var dopt = function(dat, opt, pre, post, st) {
620
+ if (!st) {
621
+ st = { l: 1 };
622
+ if (opt.dictionary) {
623
+ var dict = opt.dictionary.subarray(-32768);
624
+ var newDat = new u8(dict.length + dat.length);
625
+ newDat.set(dict);
626
+ newDat.set(dat, dict.length);
627
+ dat = newDat;
628
+ st.w = dict.length;
629
+ }
630
+ }
631
+ return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
632
+ };
633
+ var mrg = function(a, b) {
634
+ var o = {};
635
+ for (var k in a)
636
+ o[k] = a[k];
637
+ for (var k in b)
638
+ o[k] = b[k];
639
+ return o;
640
+ };
641
+ var b2 = function(d, b) {
642
+ return d[b] | d[b + 1] << 8;
643
+ };
644
+ var b4 = function(d, b) {
645
+ return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
646
+ };
647
+ var b8 = function(d, b) {
648
+ return b4(d, b) + b4(d, b + 4) * 4294967296;
649
+ };
650
+ var wbytes = function(d, b, v) {
651
+ for (;v; ++b)
652
+ d[b] = v, v >>>= 8;
653
+ };
654
+ function deflateSync(data, opts) {
655
+ return dopt(data, opts || {}, 0, 0);
656
+ }
657
+ function inflateSync(data, opts) {
658
+ return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
659
+ }
660
+ var fltn = function(d, p, t, o) {
661
+ for (var k in d) {
662
+ var val = d[k], n = p + k, op = o;
663
+ if (Array.isArray(val))
664
+ op = mrg(o, val[1]), val = val[0];
665
+ if (ArrayBuffer.isView(val))
666
+ t[n] = [val, op];
667
+ else {
668
+ t[n += "/"] = [new u8(0), op];
669
+ fltn(val, n, t, o);
670
+ }
671
+ }
672
+ };
673
+ var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder;
674
+ var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
675
+ var tds = 0;
676
+ try {
677
+ td.decode(et, { stream: true });
678
+ tds = 1;
679
+ } catch (e) {}
680
+ var dutf8 = function(d) {
681
+ for (var r = "", i = 0;; ) {
682
+ var c = d[i++];
683
+ var eb = (c > 127) + (c > 223) + (c > 239);
684
+ if (i + eb > d.length)
685
+ return { s: r, r: slc(d, i - 1) };
686
+ if (!eb)
687
+ r += String.fromCharCode(c);
688
+ else if (eb == 3) {
689
+ c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
690
+ } else if (eb & 1)
691
+ r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
692
+ else
693
+ r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
694
+ }
695
+ };
696
+ function strToU8(str, latin1) {
697
+ if (latin1) {
698
+ var ar_1 = new u8(str.length);
699
+ for (var i = 0;i < str.length; ++i)
700
+ ar_1[i] = str.charCodeAt(i);
701
+ return ar_1;
702
+ }
703
+ if (te)
704
+ return te.encode(str);
705
+ var l = str.length;
706
+ var ar = new u8(str.length + (str.length >> 1));
707
+ var ai = 0;
708
+ var w = function(v) {
709
+ ar[ai++] = v;
710
+ };
711
+ for (var i = 0;i < l; ++i) {
712
+ if (ai + 5 > ar.length) {
713
+ var n = new u8(ai + 8 + (l - i << 1));
714
+ n.set(ar);
715
+ ar = n;
716
+ }
717
+ var c = str.charCodeAt(i);
718
+ if (c < 128 || latin1)
719
+ w(c);
720
+ else if (c < 2048)
721
+ w(192 | c >> 6), w(128 | c & 63);
722
+ else if (c > 55295 && c < 57344)
723
+ c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
724
+ else
725
+ w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
726
+ }
727
+ return slc(ar, 0, ai);
728
+ }
729
+ function strFromU82(dat, latin1) {
730
+ if (latin1) {
731
+ var r = "";
732
+ for (var i = 0;i < dat.length; i += 16384)
733
+ r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
734
+ return r;
735
+ } else if (td) {
736
+ return td.decode(dat);
737
+ } else {
738
+ var _a = dutf8(dat), { s, r } = _a;
739
+ if (r.length)
740
+ err(8);
741
+ return s;
742
+ }
743
+ }
744
+ var slzh = function(d, b) {
745
+ return b + 30 + b2(d, b + 26) + b2(d, b + 28);
746
+ };
747
+ var zh = function(d, b, z) {
748
+ var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU82(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
749
+ var _a = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a[0], su = _a[1], off = _a[2];
750
+ return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
751
+ };
752
+ var z64hs = function(d, b, l, z, sc, su, off) {
753
+ var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
754
+ var nf = nsc + nsu + noff;
755
+ if (z && nf) {
756
+ for (;b + 4 < e; b += 4 + b2(d, b + 2)) {
757
+ if (b2(d, b) == 1) {
758
+ return [
759
+ nsc ? b8(d, b + 4 + 8 * nsu) : sc,
760
+ nsu ? b8(d, b + 4) : su,
761
+ noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
762
+ 1
763
+ ];
764
+ }
765
+ }
766
+ if (z < 2)
767
+ err(13);
768
+ }
769
+ return [sc, su, off, 0];
770
+ };
771
+ var exfl = function(ex) {
772
+ var le = 0;
773
+ if (ex) {
774
+ for (var k in ex) {
775
+ var l = ex[k].length;
776
+ if (l > 65535)
777
+ err(9);
778
+ le += l + 4;
779
+ }
780
+ }
781
+ return le;
782
+ };
783
+ var wzh = function(d, b, f, fn, u, c, ce, co) {
784
+ var fl = fn.length, ex = f.extra, col = co && co.length;
785
+ var exl = exfl(ex);
786
+ wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
787
+ if (ce != null)
788
+ d[b++] = 20, d[b++] = f.os;
789
+ d[b] = 20, b += 2;
790
+ d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
791
+ d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
792
+ var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
793
+ if (y < 0 || y > 119)
794
+ err(10);
795
+ wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
796
+ if (c != -1) {
797
+ wbytes(d, b, f.crc);
798
+ wbytes(d, b + 4, c < 0 ? -c - 2 : c);
799
+ wbytes(d, b + 8, f.size);
800
+ }
801
+ wbytes(d, b + 12, fl);
802
+ wbytes(d, b + 14, exl), b += 16;
803
+ if (ce != null) {
804
+ wbytes(d, b, col);
805
+ wbytes(d, b + 6, f.attrs);
806
+ wbytes(d, b + 10, ce), b += 14;
807
+ }
808
+ d.set(fn, b);
809
+ b += fl;
810
+ if (exl) {
811
+ for (var k in ex) {
812
+ var exf = ex[k], l = exf.length;
813
+ wbytes(d, b, +k);
814
+ wbytes(d, b + 2, l);
815
+ d.set(exf, b + 4), b += 4 + l;
816
+ }
817
+ }
818
+ if (col)
819
+ d.set(co, b), b += col;
820
+ return b;
821
+ };
822
+ var wzf = function(o, b, c, d, e) {
823
+ wbytes(o, b, 101010256);
824
+ wbytes(o, b + 8, c);
825
+ wbytes(o, b + 10, c);
826
+ wbytes(o, b + 12, d);
827
+ wbytes(o, b + 16, e);
828
+ };
829
+ function zipSync2(data, opts) {
830
+ if (!opts)
831
+ opts = {};
832
+ var r = {};
833
+ var files = [];
834
+ fltn(data, "", r, opts);
835
+ var o = 0;
836
+ var tot = 0;
837
+ for (var fn in r) {
838
+ var _a = r[fn], file = _a[0], p = _a[1];
839
+ var compression = p.level == 0 ? 0 : 8;
840
+ var f = strToU8(fn), s = f.length;
841
+ var com = p.comment, m = com && strToU8(com), ms = m && m.length;
842
+ var exl = exfl(p.extra);
843
+ if (s > 65535)
844
+ err(11);
845
+ var d = compression ? deflateSync(file, p) : file, l = d.length;
846
+ var c = crc();
847
+ c.p(file);
848
+ files.push(mrg(p, {
849
+ size: file.length,
850
+ crc: c.d(),
851
+ c: d,
852
+ f,
853
+ m,
854
+ u: s != fn.length || m && com.length != ms,
855
+ o,
856
+ compression
857
+ }));
858
+ o += 30 + s + exl + l;
859
+ tot += 76 + 2 * (s + exl) + (ms || 0) + l;
860
+ }
861
+ var out = new u8(tot + 22), oe = o, cdl = tot - o;
862
+ for (var i = 0;i < files.length; ++i) {
863
+ var f = files[i];
864
+ wzh(out, f.o, f, f.f, f.u, f.c.length);
865
+ var badd = 30 + f.f.length + exfl(f.extra);
866
+ out.set(f.c, f.o + badd);
867
+ wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);
868
+ }
869
+ wzf(out, o, files.length, cdl, oe);
870
+ return out;
871
+ }
872
+ function unzipSync2(data, opts) {
873
+ var files = {};
874
+ var e = data.length - 22;
875
+ for (;b4(data, e) != 101010256; --e) {
876
+ if (!e || data.length - e > 65558)
877
+ err(13);
878
+ }
879
+ var c = b2(data, e + 8);
880
+ if (!c)
881
+ return {};
882
+ var o = b4(data, e + 16);
883
+ var z = b4(data, e - 20) == 117853008;
884
+ if (z) {
885
+ var ze = b4(data, e - 12);
886
+ z = b4(data, ze) == 101075792;
887
+ if (z) {
888
+ c = b4(data, ze + 32);
889
+ o = b4(data, ze + 48);
890
+ }
891
+ }
892
+ var fltr = opts && opts.filter;
893
+ for (var i = 0;i < c; ++i) {
894
+ var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
895
+ o = no;
896
+ if (!fltr || fltr({
897
+ name: fn,
898
+ size: sc,
899
+ originalSize: su,
900
+ compression: c_2
901
+ })) {
902
+ if (!c_2)
903
+ files[fn] = slc(data, b, b + sc);
904
+ else if (c_2 == 8)
905
+ files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
906
+ else
907
+ err(14, "unknown compression type " + c_2);
908
+ }
909
+ }
910
+ return files;
911
+ }
912
+
913
+ export { strFromU82, zipSync2, unzipSync2 };
914
+
915
+ //# debugId=5CB7614DE124DB8B64756E2164756E21