dsh-token-trim 0.1.0 → 0.1.1

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,753 @@
1
+ // Some numerical data is initialized as -1 even when it doesn't need initialization to help the JIT infer types
2
+ // aliases for shorter compressed code (most minifers don't do this)
3
+ var ab = ArrayBuffer, u8 = Uint8Array, u16 = Uint16Array, i16 = Int16Array, u32 = Uint32Array, i32 = Int32Array;
4
+ var slc = function (v, s, e) {
5
+ if (u8.prototype.slice)
6
+ return u8.prototype.slice.call(v, s, e);
7
+ if (s == null || s < 0)
8
+ s = 0;
9
+ if (e == null || e > v.length)
10
+ e = v.length;
11
+ var n = new u8(e - s);
12
+ n.set(v.subarray(s, e));
13
+ return n;
14
+ };
15
+ var fill = function (v, n, s, e) {
16
+ if (u8.prototype.fill)
17
+ return u8.prototype.fill.call(v, n, s, e);
18
+ if (s == null || s < 0)
19
+ s = 0;
20
+ if (e == null || e > v.length)
21
+ e = v.length;
22
+ for (; s < e; ++s)
23
+ v[s] = n;
24
+ return v;
25
+ };
26
+ var cpw = function (v, t, s, e) {
27
+ if (u8.prototype.copyWithin)
28
+ return u8.prototype.copyWithin.call(v, t, s, e);
29
+ if (s == null || s < 0)
30
+ s = 0;
31
+ if (e == null || e > v.length)
32
+ e = v.length;
33
+ while (s < e) {
34
+ v[t++] = v[s++];
35
+ }
36
+ };
37
+ /**
38
+ * Codes for errors generated within this library
39
+ */
40
+ export var ZstdErrorCode = {
41
+ InvalidData: 0,
42
+ WindowSizeTooLarge: 1,
43
+ InvalidBlockType: 2,
44
+ FSEAccuracyTooHigh: 3,
45
+ DistanceTooFarBack: 4,
46
+ UnexpectedEOF: 5
47
+ };
48
+ // error codes
49
+ var ec = [
50
+ 'invalid zstd data',
51
+ 'window size too large (>2046MB)',
52
+ 'invalid block type',
53
+ 'FSE accuracy too high',
54
+ 'match distance too far back',
55
+ 'unexpected EOF'
56
+ ];
57
+ var err = function (ind, msg, nt) {
58
+ var e = new Error(msg || ec[ind]);
59
+ e.code = ind;
60
+ if (Error.captureStackTrace)
61
+ Error.captureStackTrace(e, err);
62
+ if (!nt)
63
+ throw e;
64
+ return e;
65
+ };
66
+ var rb = function (d, b, n) {
67
+ var i = 0, o = 0;
68
+ for (; i < n; ++i)
69
+ o |= d[b++] << (i << 3);
70
+ return o;
71
+ };
72
+ var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };
73
+ // read Zstandard frame header
74
+ var rzfh = function (dat, w) {
75
+ var n3 = dat[0] | (dat[1] << 8) | (dat[2] << 16);
76
+ if (n3 == 0x2FB528 && dat[3] == 253) {
77
+ // Zstandard
78
+ var flg = dat[4];
79
+ // single segment checksum dict flag frame content flag
80
+ var ss = (flg >> 5) & 1, cc = (flg >> 2) & 1, df = flg & 3, fcf = flg >> 6;
81
+ if (flg & 8)
82
+ err(0);
83
+ // byte
84
+ var bt = 6 - ss;
85
+ // dict bytes
86
+ var db = df == 3 ? 4 : df;
87
+ // dictionary id
88
+ var di = rb(dat, bt, db);
89
+ bt += db;
90
+ // frame size bytes
91
+ var fsb = fcf ? (1 << fcf) : ss;
92
+ // frame source size
93
+ var fss = rb(dat, bt, fsb) + ((fcf == 1) && 256);
94
+ // window size
95
+ var ws = fss;
96
+ if (!ss) {
97
+ // window descriptor
98
+ var wb = 1 << (10 + (dat[5] >> 3));
99
+ ws = wb + (wb >> 3) * (dat[5] & 7);
100
+ }
101
+ if (ws > 2145386496)
102
+ err(1);
103
+ var buf = new u8((w == 1 ? (fss || ws) : w ? 0 : ws) + 12);
104
+ buf[0] = 1, buf[4] = 4, buf[8] = 8;
105
+ return {
106
+ b: bt + fsb,
107
+ y: 0,
108
+ l: 0,
109
+ d: di,
110
+ w: (w && w != 1) ? w : buf.subarray(12),
111
+ e: ws,
112
+ o: new i32(buf.buffer, 0, 3),
113
+ u: fss,
114
+ c: cc,
115
+ m: Math.min(131072, ws)
116
+ };
117
+ }
118
+ else if (((n3 >> 4) | (dat[3] << 20)) == 0x184D2A5) {
119
+ // skippable
120
+ return b4(dat, 4) + 8;
121
+ }
122
+ err(0);
123
+ };
124
+ // most significant bit for nonzero
125
+ var msb = function (val) {
126
+ var bits = 0;
127
+ for (; (1 << bits) <= val; ++bits)
128
+ ;
129
+ return bits - 1;
130
+ };
131
+ // read finite state entropy
132
+ var rfse = function (dat, bt, mal) {
133
+ // table pos
134
+ var tpos = (bt << 3) + 4;
135
+ // accuracy log
136
+ var al = (dat[bt] & 15) + 5;
137
+ if (al > mal)
138
+ err(3);
139
+ // size
140
+ var sz = 1 << al;
141
+ // probabilities symbols repeat index high threshold
142
+ var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
143
+ // optimization: single allocation is much faster
144
+ var buf = new ab(512 + (sz << 2));
145
+ var freq = new i16(buf, 0, 256);
146
+ // same view as freq
147
+ var dstate = new u16(buf, 0, 256);
148
+ var nstate = new u16(buf, 512, sz);
149
+ var bb1 = 512 + (sz << 1);
150
+ var syms = new u8(buf, bb1, sz);
151
+ var nbits = new u8(buf, bb1 + sz);
152
+ while (sym < 255 && probs > 0) {
153
+ var bits = msb(probs + 1);
154
+ var cbt = tpos >> 3;
155
+ // mask
156
+ var msk = (1 << (bits + 1)) - 1;
157
+ var val = ((dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16)) >> (tpos & 7)) & msk;
158
+ // mask (1 fewer bit)
159
+ var msk1fb = (1 << bits) - 1;
160
+ // max small value
161
+ var msv = msk - probs - 1;
162
+ // small value
163
+ var sval = val & msk1fb;
164
+ if (sval < msv)
165
+ tpos += bits, val = sval;
166
+ else {
167
+ tpos += bits + 1;
168
+ if (val > msk1fb)
169
+ val -= msv;
170
+ }
171
+ freq[++sym] = --val;
172
+ if (val == -1) {
173
+ probs += val;
174
+ syms[--ht] = sym;
175
+ }
176
+ else
177
+ probs -= val;
178
+ if (!val) {
179
+ do {
180
+ // repeat byte
181
+ var rbt = tpos >> 3;
182
+ re = ((dat[rbt] | (dat[rbt + 1] << 8)) >> (tpos & 7)) & 3;
183
+ tpos += 2;
184
+ sym += re;
185
+ } while (re == 3);
186
+ }
187
+ }
188
+ if (sym > 255 || probs)
189
+ err(0);
190
+ var sympos = 0;
191
+ // sym step (coprime with sz - formula from zstd source)
192
+ var sstep = (sz >> 1) + (sz >> 3) + 3;
193
+ // sym mask
194
+ var smask = sz - 1;
195
+ for (var s = 0; s <= sym; ++s) {
196
+ var sf = freq[s];
197
+ if (sf < 1) {
198
+ dstate[s] = -sf;
199
+ continue;
200
+ }
201
+ // This is split into two loops in zstd to avoid branching, but as JS is higher-level that is unnecessary
202
+ for (i = 0; i < sf; ++i) {
203
+ syms[sympos] = s;
204
+ do {
205
+ sympos = (sympos + sstep) & smask;
206
+ } while (sympos >= ht);
207
+ }
208
+ }
209
+ // After spreading symbols, should be zero again
210
+ if (sympos)
211
+ err(0);
212
+ for (i = 0; i < sz; ++i) {
213
+ // next state
214
+ var ns = dstate[syms[i]]++;
215
+ // num bits
216
+ var nb = nbits[i] = al - msb(ns);
217
+ nstate[i] = (ns << nb) - sz;
218
+ }
219
+ return [(tpos + 7) >> 3, {
220
+ b: al,
221
+ s: syms,
222
+ n: nbits,
223
+ t: nstate
224
+ }];
225
+ };
226
+ // read huffman
227
+ var rhu = function (dat, bt) {
228
+ // index weight count
229
+ var i = 0, wc = -1;
230
+ // buffer header byte
231
+ var buf = new u8(292), hb = dat[bt];
232
+ // huffman weights
233
+ var hw = buf.subarray(0, 256);
234
+ // rank count
235
+ var rc = buf.subarray(256, 268);
236
+ // rank index
237
+ var ri = new u16(buf.buffer, 268);
238
+ // NOTE: at this point bt is 1 less than expected
239
+ if (hb < 128) {
240
+ // end byte, fse decode table
241
+ var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
242
+ bt += hb;
243
+ var epos = ebt << 3;
244
+ // last byte
245
+ var lb = dat[bt];
246
+ if (!lb)
247
+ err(0);
248
+ // state1 state2 state1 bits state2 bits
249
+ var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
250
+ // fse pos
251
+ // pre-increment to account for original deficit of 1
252
+ var fpos = (++bt << 3) - 8 + msb(lb);
253
+ for (;;) {
254
+ fpos -= btr1;
255
+ if (fpos < epos)
256
+ break;
257
+ var cbt = fpos >> 3;
258
+ st1 += ((dat[cbt] | (dat[cbt + 1] << 8)) >> (fpos & 7)) & ((1 << btr1) - 1);
259
+ hw[++wc] = fdt.s[st1];
260
+ fpos -= btr2;
261
+ if (fpos < epos)
262
+ break;
263
+ cbt = fpos >> 3;
264
+ st2 += ((dat[cbt] | (dat[cbt + 1] << 8)) >> (fpos & 7)) & ((1 << btr2) - 1);
265
+ hw[++wc] = fdt.s[st2];
266
+ btr1 = fdt.n[st1];
267
+ st1 = fdt.t[st1];
268
+ btr2 = fdt.n[st2];
269
+ st2 = fdt.t[st2];
270
+ }
271
+ if (++wc > 255)
272
+ err(0);
273
+ }
274
+ else {
275
+ wc = hb - 127;
276
+ for (; i < wc; i += 2) {
277
+ var byte = dat[++bt];
278
+ hw[i] = byte >> 4;
279
+ hw[i + 1] = byte & 15;
280
+ }
281
+ ++bt;
282
+ }
283
+ // weight exponential sum
284
+ var wes = 0;
285
+ for (i = 0; i < wc; ++i) {
286
+ var wt = hw[i];
287
+ // bits must be at most 11, same as weight
288
+ if (wt > 11)
289
+ err(0);
290
+ wes += wt && (1 << (wt - 1));
291
+ }
292
+ // max bits
293
+ var mb = msb(wes) + 1;
294
+ // table size
295
+ var ts = 1 << mb;
296
+ // remaining sum
297
+ var rem = ts - wes;
298
+ // must be power of 2
299
+ if (rem & (rem - 1))
300
+ err(0);
301
+ hw[wc++] = msb(rem) + 1;
302
+ for (i = 0; i < wc; ++i) {
303
+ var wt = hw[i];
304
+ ++rc[hw[i] = wt && (mb + 1 - wt)];
305
+ }
306
+ // huf buf
307
+ var hbuf = new u8(ts << 1);
308
+ // symbols num bits
309
+ var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
310
+ ri[mb] = 0;
311
+ for (i = mb; i > 0; --i) {
312
+ var pv = ri[i];
313
+ fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << (mb - i)));
314
+ }
315
+ if (ri[0] != ts)
316
+ err(0);
317
+ for (i = 0; i < wc; ++i) {
318
+ var bits = hw[i];
319
+ if (bits) {
320
+ var code = ri[bits];
321
+ fill(syms, i, code, ri[bits] = code + (1 << (mb - bits)));
322
+ }
323
+ }
324
+ return [bt, {
325
+ n: nb,
326
+ b: mb,
327
+ s: syms
328
+ }];
329
+ };
330
+ // Tables generated using this:
331
+ // https://gist.github.com/101arrowz/a979452d4355992cbf8f257cbffc9edd
332
+ // default literal length table
333
+ var dllt = /*#__PURE__*/ rfse(/*#__PURE__*/ new u8([
334
+ 81, 16, 99, 140, 49, 198, 24, 99, 12, 33, 196, 24, 99, 102, 102, 134, 70, 146, 4
335
+ ]), 0, 6)[1];
336
+ // default match length table
337
+ var dmlt = /*#__PURE__*/ rfse(/*#__PURE__*/ new u8([
338
+ 33, 20, 196, 24, 99, 140, 33, 132, 16, 66, 8, 33, 132, 16, 66, 8, 33, 68, 68, 68, 68, 68, 68, 68, 68, 36, 9
339
+ ]), 0, 6)[1];
340
+ // default offset code table
341
+ var doct = /*#__PURE__ */ rfse(/*#__PURE__*/ new u8([
342
+ 32, 132, 16, 66, 102, 70, 68, 68, 68, 68, 36, 73, 2
343
+ ]), 0, 5)[1];
344
+ // bits to baseline
345
+ var b2bl = function (b, s) {
346
+ var len = b.length, bl = new i32(len);
347
+ for (var i = 0; i < len; ++i) {
348
+ bl[i] = s;
349
+ s += 1 << b[i];
350
+ }
351
+ return bl;
352
+ };
353
+ // literal length bits
354
+ var llb = /*#__PURE__ */ new u8(( /*#__PURE__ */new i32([
355
+ 0, 0, 0, 0, 16843009, 50528770, 134678020, 202050057, 269422093
356
+ ])).buffer, 0, 36);
357
+ // literal length baseline
358
+ var llbl = /*#__PURE__ */ b2bl(llb, 0);
359
+ // match length bits
360
+ var mlb = /*#__PURE__ */ new u8(( /*#__PURE__ */new i32([
361
+ 0, 0, 0, 0, 0, 0, 0, 0, 16843009, 50528770, 117769220, 185207048, 252579084, 16
362
+ ])).buffer, 0, 53);
363
+ // match length baseline
364
+ var mlbl = /*#__PURE__ */ b2bl(mlb, 3);
365
+ // decode huffman stream
366
+ var dhu = function (dat, out, hu) {
367
+ var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
368
+ if (!lb)
369
+ err(0);
370
+ var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
371
+ for (; pos > eb && i < ss;) {
372
+ var cbt = pos >> 3;
373
+ var val = (dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16)) >> (pos & 7);
374
+ st = ((st << btr) | val) & msk;
375
+ out[++i] = hu.s[st];
376
+ pos -= (btr = hu.n[st]);
377
+ }
378
+ if (pos != eb || i + 1 != ss)
379
+ err(0);
380
+ };
381
+ // decode huffman stream 4x
382
+ // TODO: use workers to parallelize
383
+ var dhu4 = function (dat, out, hu) {
384
+ var bt = 6;
385
+ var ss = out.length, sz1 = (ss + 3) >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
386
+ dhu(dat.subarray(bt, bt += dat[0] | (dat[1] << 8)), out.subarray(0, sz1), hu);
387
+ dhu(dat.subarray(bt, bt += dat[2] | (dat[3] << 8)), out.subarray(sz1, sz2), hu);
388
+ dhu(dat.subarray(bt, bt += dat[4] | (dat[5] << 8)), out.subarray(sz2, sz3), hu);
389
+ dhu(dat.subarray(bt), out.subarray(sz3), hu);
390
+ };
391
+ // read Zstandard block
392
+ var rzb = function (dat, st, out) {
393
+ var _a;
394
+ var bt = st.b;
395
+ // byte 0 block type
396
+ var b0 = dat[bt], btype = (b0 >> 1) & 3;
397
+ st.l = b0 & 1;
398
+ var sz = (b0 >> 3) | (dat[bt + 1] << 5) | (dat[bt + 2] << 13);
399
+ // end byte for block
400
+ var ebt = (bt += 3) + sz;
401
+ if (btype == 1) {
402
+ if (bt >= dat.length)
403
+ return;
404
+ st.b = bt + 1;
405
+ if (out) {
406
+ fill(out, dat[bt], st.y, st.y += sz);
407
+ return out;
408
+ }
409
+ return fill(new u8(sz), dat[bt]);
410
+ }
411
+ if (ebt > dat.length)
412
+ return;
413
+ if (btype == 0) {
414
+ st.b = ebt;
415
+ if (out) {
416
+ out.set(dat.subarray(bt, ebt), st.y);
417
+ st.y += sz;
418
+ return out;
419
+ }
420
+ return slc(dat, bt, ebt);
421
+ }
422
+ if (btype == 2) {
423
+ // byte 3 lit btype size format
424
+ var b3 = dat[bt], lbt = b3 & 3, sf = (b3 >> 2) & 3;
425
+ // lit src size lit cmp sz 4 streams
426
+ var lss = b3 >> 4, lcs = 0, s4 = 0;
427
+ if (lbt < 2) {
428
+ if (sf & 1)
429
+ lss |= (dat[++bt] << 4) | ((sf & 2) && (dat[++bt] << 12));
430
+ else
431
+ lss = b3 >> 3;
432
+ }
433
+ else {
434
+ s4 = sf;
435
+ if (sf < 2)
436
+ lss |= ((dat[++bt] & 63) << 4), lcs = (dat[bt] >> 6) | (dat[++bt] << 2);
437
+ else if (sf == 2)
438
+ lss |= (dat[++bt] << 4) | ((dat[++bt] & 3) << 12), lcs = (dat[bt] >> 2) | (dat[++bt] << 6);
439
+ else
440
+ lss |= (dat[++bt] << 4) | ((dat[++bt] & 63) << 12), lcs = (dat[bt] >> 6) | (dat[++bt] << 2) | (dat[++bt] << 10);
441
+ }
442
+ ++bt;
443
+ // add literals to end - can never overlap with backreferences because unused literals always appended
444
+ var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
445
+ // starting point for literals
446
+ var spl = buf.length - lss;
447
+ if (lbt == 0)
448
+ buf.set(dat.subarray(bt, bt += lss), spl);
449
+ else if (lbt == 1)
450
+ fill(buf, dat[bt++], spl);
451
+ else {
452
+ // huffman table
453
+ var hu = st.h;
454
+ if (lbt == 2) {
455
+ var hud = rhu(dat, bt);
456
+ // subtract description length
457
+ lcs += bt - (bt = hud[0]);
458
+ st.h = hu = hud[1];
459
+ }
460
+ else if (!hu)
461
+ err(0);
462
+ (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
463
+ }
464
+ // num sequences
465
+ var ns = dat[bt++];
466
+ if (ns) {
467
+ if (ns == 255)
468
+ ns = (dat[bt++] | (dat[bt++] << 8)) + 0x7F00;
469
+ else if (ns > 127)
470
+ ns = ((ns - 128) << 8) | dat[bt++];
471
+ // symbol compression modes
472
+ var scm = dat[bt++];
473
+ if (scm & 3)
474
+ err(0);
475
+ var dts = [dmlt, doct, dllt];
476
+ for (var i = 2; i > -1; --i) {
477
+ var md = (scm >> ((i << 1) + 2)) & 3;
478
+ if (md == 1) {
479
+ // rle buf
480
+ var rbuf = new u8([0, 0, dat[bt++]]);
481
+ dts[i] = {
482
+ s: rbuf.subarray(2, 3),
483
+ n: rbuf.subarray(0, 1),
484
+ t: new u16(rbuf.buffer, 0, 1),
485
+ b: 0
486
+ };
487
+ }
488
+ else if (md == 2) {
489
+ // accuracy log 8 for offsets, 9 for others
490
+ _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];
491
+ }
492
+ else if (md == 3) {
493
+ if (!st.t)
494
+ err(0);
495
+ dts[i] = st.t[i];
496
+ }
497
+ }
498
+ var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
499
+ var lb = dat[ebt - 1];
500
+ if (!lb)
501
+ err(0);
502
+ var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
503
+ var lst = ((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << llt.b) - 1);
504
+ cbt = (spos -= oct.b) >> 3;
505
+ var ost = ((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << oct.b) - 1);
506
+ cbt = (spos -= mlt.b) >> 3;
507
+ var mst = ((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << mlt.b) - 1);
508
+ for (++ns; --ns;) {
509
+ var llc = llt.s[lst];
510
+ var lbtr = llt.n[lst];
511
+ var mlc = mlt.s[mst];
512
+ var mbtr = mlt.n[mst];
513
+ var ofc = oct.s[ost];
514
+ var obtr = oct.n[ost];
515
+ cbt = (spos -= ofc) >> 3;
516
+ var ofp = 1 << ofc;
517
+ var off = ofp + (((dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16) | (dat[cbt + 3] << 24)) >>> (spos & 7)) & (ofp - 1));
518
+ cbt = (spos -= mlb[mlc]) >> 3;
519
+ var ml = mlbl[mlc] + (((dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16)) >> (spos & 7)) & ((1 << mlb[mlc]) - 1));
520
+ cbt = (spos -= llb[llc]) >> 3;
521
+ var ll = llbl[llc] + (((dat[cbt] | (dat[cbt + 1] << 8) | (dat[cbt + 2] << 16)) >> (spos & 7)) & ((1 << llb[llc]) - 1));
522
+ cbt = (spos -= lbtr) >> 3;
523
+ lst = llt.t[lst] + (((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << lbtr) - 1));
524
+ cbt = (spos -= mbtr) >> 3;
525
+ mst = mlt.t[mst] + (((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << mbtr) - 1));
526
+ cbt = (spos -= obtr) >> 3;
527
+ ost = oct.t[ost] + (((dat[cbt] | (dat[cbt + 1] << 8)) >> (spos & 7)) & ((1 << obtr) - 1));
528
+ if (off > 3) {
529
+ st.o[2] = st.o[1];
530
+ st.o[1] = st.o[0];
531
+ st.o[0] = off -= 3;
532
+ }
533
+ else {
534
+ var idx = off - (ll != 0);
535
+ if (idx) {
536
+ off = idx == 3 ? st.o[0] - 1 : st.o[idx];
537
+ if (idx > 1)
538
+ st.o[2] = st.o[1];
539
+ st.o[1] = st.o[0];
540
+ st.o[0] = off;
541
+ }
542
+ else
543
+ off = st.o[0];
544
+ }
545
+ for (var i = 0; i < ll; ++i) {
546
+ buf[oubt + i] = buf[spl + i];
547
+ }
548
+ oubt += ll, spl += ll;
549
+ var stin = oubt - off;
550
+ if (stin < 0) {
551
+ var len = -stin;
552
+ var bs = st.e + stin;
553
+ if (len > ml)
554
+ len = ml;
555
+ for (var i = 0; i < len; ++i) {
556
+ buf[oubt + i] = st.w[bs + i];
557
+ }
558
+ oubt += len, ml -= len, stin = 0;
559
+ }
560
+ for (var i = 0; i < ml; ++i) {
561
+ buf[oubt + i] = buf[stin + i];
562
+ }
563
+ oubt += ml;
564
+ }
565
+ if (oubt != spl) {
566
+ while (spl < buf.length) {
567
+ buf[oubt++] = buf[spl++];
568
+ }
569
+ }
570
+ else
571
+ oubt = buf.length;
572
+ if (out)
573
+ st.y += oubt;
574
+ else
575
+ buf = slc(buf, 0, oubt);
576
+ }
577
+ else if (out) {
578
+ st.y += lss;
579
+ if (spl) {
580
+ for (var i = 0; i < lss; ++i) {
581
+ buf[i] = buf[spl + i];
582
+ }
583
+ }
584
+ }
585
+ else if (spl)
586
+ buf = slc(buf, spl);
587
+ st.b = ebt;
588
+ return buf;
589
+ }
590
+ err(2);
591
+ };
592
+ // concat
593
+ var cct = function (bufs, ol) {
594
+ if (bufs.length == 1)
595
+ return bufs[0];
596
+ var buf = new u8(ol);
597
+ for (var i = 0, b = 0; i < bufs.length; ++i) {
598
+ var chk = bufs[i];
599
+ buf.set(chk, b);
600
+ b += chk.length;
601
+ }
602
+ return buf;
603
+ };
604
+ /**
605
+ * Decompresses Zstandard data
606
+ * @param dat The input data
607
+ * @param buf The output buffer. If unspecified, the function will allocate
608
+ * exactly enough memory to fit the decompressed data. If your
609
+ * data has multiple frames and you know the output size, specifying
610
+ * it will yield better performance.
611
+ * @returns The decompressed data
612
+ */
613
+ export function decompress(dat, buf) {
614
+ var bufs = [], nb = +!buf;
615
+ var bt = 0, ol = 0;
616
+ for (; dat.length;) {
617
+ var st = rzfh(dat, nb || buf);
618
+ if (typeof st == 'object') {
619
+ if (nb) {
620
+ buf = null;
621
+ if (st.w.length == st.u) {
622
+ bufs.push(buf = st.w);
623
+ ol += st.u;
624
+ }
625
+ }
626
+ else {
627
+ bufs.push(buf);
628
+ st.e = 0;
629
+ }
630
+ for (; !st.l;) {
631
+ var blk = rzb(dat, st, buf);
632
+ if (!blk)
633
+ err(5);
634
+ if (buf)
635
+ st.e = st.y;
636
+ else {
637
+ bufs.push(blk);
638
+ ol += blk.length;
639
+ cpw(st.w, 0, blk.length);
640
+ st.w.set(blk, st.w.length - blk.length);
641
+ }
642
+ }
643
+ bt = st.b + (st.c * 4);
644
+ }
645
+ else
646
+ bt = st;
647
+ dat = dat.subarray(bt);
648
+ }
649
+ return cct(bufs, ol);
650
+ }
651
+ /**
652
+ * Decompressor for Zstandard streamed data
653
+ */
654
+ var Decompress = /*#__PURE__*/ (function () {
655
+ /**
656
+ * Creates a Zstandard decompressor
657
+ * @param ondata The handler for stream data
658
+ */
659
+ function Decompress(ondata) {
660
+ this.ondata = ondata;
661
+ this.c = [];
662
+ this.l = 0;
663
+ this.z = 0;
664
+ }
665
+ /**
666
+ * Pushes data to be decompressed
667
+ * @param chunk The chunk of data to push
668
+ * @param final Whether or not this is the last chunk in the stream
669
+ */
670
+ Decompress.prototype.push = function (chunk, final) {
671
+ if (typeof this.s == 'number') {
672
+ var sub = Math.min(chunk.length, this.s);
673
+ chunk = chunk.subarray(sub);
674
+ this.s -= sub;
675
+ }
676
+ var sl = chunk.length;
677
+ var ncs = sl + this.l;
678
+ if (!this.s) {
679
+ if (final) {
680
+ if (!ncs) {
681
+ this.ondata(new u8(0), true);
682
+ return;
683
+ }
684
+ // min for frame + one block
685
+ if (ncs < 5)
686
+ err(5);
687
+ }
688
+ else if (ncs < 18) {
689
+ this.c.push(chunk);
690
+ this.l = ncs;
691
+ return;
692
+ }
693
+ if (this.l) {
694
+ this.c.push(chunk);
695
+ chunk = cct(this.c, ncs);
696
+ this.c = [];
697
+ this.l = 0;
698
+ }
699
+ if (typeof (this.s = rzfh(chunk)) == 'number')
700
+ return this.push(chunk, final);
701
+ }
702
+ if (typeof this.s != 'number') {
703
+ if (ncs < (this.z || 3)) {
704
+ if (final)
705
+ err(5);
706
+ this.c.push(chunk);
707
+ this.l = ncs;
708
+ return;
709
+ }
710
+ if (this.l) {
711
+ this.c.push(chunk);
712
+ chunk = cct(this.c, ncs);
713
+ this.c = [];
714
+ this.l = 0;
715
+ }
716
+ if (!this.z && ncs < (this.z = (chunk[this.s.b] & 2) ? 4 : 3 + ((chunk[this.s.b] >> 3) | (chunk[this.s.b + 1] << 5) | (chunk[this.s.b + 2] << 13)))) {
717
+ if (final)
718
+ err(5);
719
+ this.c.push(chunk);
720
+ this.l = ncs;
721
+ return;
722
+ }
723
+ else
724
+ this.z = 0;
725
+ for (;;) {
726
+ var blk = rzb(chunk, this.s);
727
+ if (!blk) {
728
+ if (final)
729
+ err(5);
730
+ var adc = chunk.subarray(this.s.b);
731
+ this.s.b = 0;
732
+ this.c.push(adc), this.l += adc.length;
733
+ return;
734
+ }
735
+ else {
736
+ this.ondata(blk, false);
737
+ cpw(this.s.w, 0, blk.length);
738
+ this.s.w.set(blk, this.s.w.length - blk.length);
739
+ }
740
+ if (this.s.l) {
741
+ var rest = chunk.subarray(this.s.b);
742
+ this.s = this.s.c * 4;
743
+ this.push(rest, final);
744
+ return;
745
+ }
746
+ }
747
+ }
748
+ else if (final)
749
+ err(5);
750
+ };
751
+ return Decompress;
752
+ }());
753
+ export { Decompress };