@btc-vision/transaction 1.7.24 → 1.7.26

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.
@@ -1,4590 +0,0 @@
1
- import { f as It, g as ct, h as Tt, i as Ot, j as Lt, k as Mt, l as Ut } from "./vendors.js";
2
- var Nr = {}, ir = {};
3
- ir.byteLength = Ct;
4
- ir.toByteArray = Dt;
5
- ir.fromByteArray = xt;
6
- var xe = [], Ne = [], Nt = typeof Uint8Array < "u" ? Uint8Array : Array, ar = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
7
- for (var Je = 0, Pt = ar.length; Je < Pt; ++Je)
8
- xe[Je] = ar[Je], Ne[ar.charCodeAt(Je)] = Je;
9
- Ne[45] = 62;
10
- Ne[95] = 63;
11
- function ht(c) {
12
- var v = c.length;
13
- if (v % 4 > 0)
14
- throw new Error("Invalid string. Length must be a multiple of 4");
15
- var P = c.indexOf("=");
16
- P === -1 && (P = v);
17
- var D = P === v ? 0 : 4 - P % 4;
18
- return [P, D];
19
- }
20
- function Ct(c) {
21
- var v = ht(c), P = v[0], D = v[1];
22
- return (P + D) * 3 / 4 - D;
23
- }
24
- function jt(c, v, P) {
25
- return (v + P) * 3 / 4 - P;
26
- }
27
- function Dt(c) {
28
- var v, P = ht(c), D = P[0], Y = P[1], h = new Nt(jt(c, D, Y)), y = 0, O = Y > 0 ? D - 4 : D, p;
29
- for (p = 0; p < O; p += 4)
30
- v = Ne[c.charCodeAt(p)] << 18 | Ne[c.charCodeAt(p + 1)] << 12 | Ne[c.charCodeAt(p + 2)] << 6 | Ne[c.charCodeAt(p + 3)], h[y++] = v >> 16 & 255, h[y++] = v >> 8 & 255, h[y++] = v & 255;
31
- return Y === 2 && (v = Ne[c.charCodeAt(p)] << 2 | Ne[c.charCodeAt(p + 1)] >> 4, h[y++] = v & 255), Y === 1 && (v = Ne[c.charCodeAt(p)] << 10 | Ne[c.charCodeAt(p + 1)] << 4 | Ne[c.charCodeAt(p + 2)] >> 2, h[y++] = v >> 8 & 255, h[y++] = v & 255), h;
32
- }
33
- function kt(c) {
34
- return xe[c >> 18 & 63] + xe[c >> 12 & 63] + xe[c >> 6 & 63] + xe[c & 63];
35
- }
36
- function Ft(c, v, P) {
37
- for (var D, Y = [], h = v; h < P; h += 3)
38
- D = (c[h] << 16 & 16711680) + (c[h + 1] << 8 & 65280) + (c[h + 2] & 255), Y.push(kt(D));
39
- return Y.join("");
40
- }
41
- function xt(c) {
42
- for (var v, P = c.length, D = P % 3, Y = [], h = 16383, y = 0, O = P - D; y < O; y += h)
43
- Y.push(Ft(c, y, y + h > O ? O : y + h));
44
- return D === 1 ? (v = c[P - 1], Y.push(
45
- xe[v >> 2] + xe[v << 4 & 63] + "=="
46
- )) : D === 2 && (v = (c[P - 2] << 8) + c[P - 1], Y.push(
47
- xe[v >> 10] + xe[v >> 4 & 63] + xe[v << 2 & 63] + "="
48
- )), Y.join("");
49
- }
50
- var Pr = {};
51
- Pr.read = function(c, v, P, D, Y) {
52
- var h, y, O = Y * 8 - D - 1, p = (1 << O) - 1, N = p >> 1, l = -7, k = P ? Y - 1 : 0, j = P ? -1 : 1, J = c[v + k];
53
- for (k += j, h = J & (1 << -l) - 1, J >>= -l, l += O; l > 0; h = h * 256 + c[v + k], k += j, l -= 8)
54
- ;
55
- for (y = h & (1 << -l) - 1, h >>= -l, l += D; l > 0; y = y * 256 + c[v + k], k += j, l -= 8)
56
- ;
57
- if (h === 0)
58
- h = 1 - N;
59
- else {
60
- if (h === p)
61
- return y ? NaN : (J ? -1 : 1) * (1 / 0);
62
- y = y + Math.pow(2, D), h = h - N;
63
- }
64
- return (J ? -1 : 1) * y * Math.pow(2, h - D);
65
- };
66
- Pr.write = function(c, v, P, D, Y, h) {
67
- var y, O, p, N = h * 8 - Y - 1, l = (1 << N) - 1, k = l >> 1, j = Y === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, J = D ? 0 : h - 1, V = D ? 1 : -1, X = v < 0 || v === 0 && 1 / v < 0 ? 1 : 0;
68
- for (v = Math.abs(v), isNaN(v) || v === 1 / 0 ? (O = isNaN(v) ? 1 : 0, y = l) : (y = Math.floor(Math.log(v) / Math.LN2), v * (p = Math.pow(2, -y)) < 1 && (y--, p *= 2), y + k >= 1 ? v += j / p : v += j * Math.pow(2, 1 - k), v * p >= 2 && (y++, p /= 2), y + k >= l ? (O = 0, y = l) : y + k >= 1 ? (O = (v * p - 1) * Math.pow(2, Y), y = y + k) : (O = v * Math.pow(2, k - 1) * Math.pow(2, Y), y = 0)); Y >= 8; c[P + J] = O & 255, J += V, O /= 256, Y -= 8)
69
- ;
70
- for (y = y << Y | O, N += Y; N > 0; c[P + J] = y & 255, J += V, y /= 256, N -= 8)
71
- ;
72
- c[P + J - V] |= X * 128;
73
- };
74
- (function(c) {
75
- const v = ir, P = Pr, D = typeof Symbol == "function" && typeof Symbol.for == "function" ? /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom") : null;
76
- c.Buffer = l, c.SlowBuffer = m, c.INSPECT_MAX_BYTES = 50;
77
- const Y = 2147483647;
78
- c.kMaxLength = Y;
79
- const { Uint8Array: h, ArrayBuffer: y, SharedArrayBuffer: O } = globalThis;
80
- l.TYPED_ARRAY_SUPPORT = p(), !l.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error(
81
- "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
82
- );
83
- function p() {
84
- try {
85
- const i = new h(1), e = { foo: function() {
86
- return 42;
87
- } };
88
- return Object.setPrototypeOf(e, h.prototype), Object.setPrototypeOf(i, e), i.foo() === 42;
89
- } catch {
90
- return !1;
91
- }
92
- }
93
- Object.defineProperty(l.prototype, "parent", {
94
- enumerable: !0,
95
- get: function() {
96
- if (l.isBuffer(this))
97
- return this.buffer;
98
- }
99
- }), Object.defineProperty(l.prototype, "offset", {
100
- enumerable: !0,
101
- get: function() {
102
- if (l.isBuffer(this))
103
- return this.byteOffset;
104
- }
105
- });
106
- function N(i) {
107
- if (i > Y)
108
- throw new RangeError('The value "' + i + '" is invalid for option "size"');
109
- const e = new h(i);
110
- return Object.setPrototypeOf(e, l.prototype), e;
111
- }
112
- function l(i, e, t) {
113
- if (typeof i == "number") {
114
- if (typeof e == "string")
115
- throw new TypeError(
116
- 'The "string" argument must be of type string. Received type number'
117
- );
118
- return V(i);
119
- }
120
- return k(i, e, t);
121
- }
122
- l.poolSize = 8192;
123
- function k(i, e, t) {
124
- if (typeof i == "string")
125
- return X(i, e);
126
- if (y.isView(i))
127
- return w(i);
128
- if (i == null)
129
- throw new TypeError(
130
- "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof i
131
- );
132
- if (Oe(i, y) || i && Oe(i.buffer, y) || typeof O < "u" && (Oe(i, O) || i && Oe(i.buffer, O)))
133
- return B(i, e, t);
134
- if (typeof i == "number")
135
- throw new TypeError(
136
- 'The "value" argument must not be of type number. Received type number'
137
- );
138
- const a = i.valueOf && i.valueOf();
139
- if (a != null && a !== i)
140
- return l.from(a, e, t);
141
- const g = R(i);
142
- if (g) return g;
143
- if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof i[Symbol.toPrimitive] == "function")
144
- return l.from(i[Symbol.toPrimitive]("string"), e, t);
145
- throw new TypeError(
146
- "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof i
147
- );
148
- }
149
- l.from = function(i, e, t) {
150
- return k(i, e, t);
151
- }, Object.setPrototypeOf(l.prototype, h.prototype), Object.setPrototypeOf(l, h);
152
- function j(i) {
153
- if (typeof i != "number")
154
- throw new TypeError('"size" argument must be of type number');
155
- if (i < 0)
156
- throw new RangeError('The value "' + i + '" is invalid for option "size"');
157
- }
158
- function J(i, e, t) {
159
- return j(i), i <= 0 ? N(i) : e !== void 0 ? typeof t == "string" ? N(i).fill(e, t) : N(i).fill(e) : N(i);
160
- }
161
- l.alloc = function(i, e, t) {
162
- return J(i, e, t);
163
- };
164
- function V(i) {
165
- return j(i), N(i < 0 ? 0 : d(i) | 0);
166
- }
167
- l.allocUnsafe = function(i) {
168
- return V(i);
169
- }, l.allocUnsafeSlow = function(i) {
170
- return V(i);
171
- };
172
- function X(i, e) {
173
- if ((typeof e != "string" || e === "") && (e = "utf8"), !l.isEncoding(e))
174
- throw new TypeError("Unknown encoding: " + e);
175
- const t = A(i, e) | 0;
176
- let a = N(t);
177
- const g = a.write(i, e);
178
- return g !== t && (a = a.slice(0, g)), a;
179
- }
180
- function K(i) {
181
- const e = i.length < 0 ? 0 : d(i.length) | 0, t = N(e);
182
- for (let a = 0; a < e; a += 1)
183
- t[a] = i[a] & 255;
184
- return t;
185
- }
186
- function w(i) {
187
- if (Oe(i, h)) {
188
- const e = new h(i);
189
- return B(e.buffer, e.byteOffset, e.byteLength);
190
- }
191
- return K(i);
192
- }
193
- function B(i, e, t) {
194
- if (e < 0 || i.byteLength < e)
195
- throw new RangeError('"offset" is outside of buffer bounds');
196
- if (i.byteLength < e + (t || 0))
197
- throw new RangeError('"length" is outside of buffer bounds');
198
- let a;
199
- return e === void 0 && t === void 0 ? a = new h(i) : t === void 0 ? a = new h(i, e) : a = new h(i, e, t), Object.setPrototypeOf(a, l.prototype), a;
200
- }
201
- function R(i) {
202
- if (l.isBuffer(i)) {
203
- const e = d(i.length) | 0, t = N(e);
204
- return t.length === 0 || i.copy(t, 0, 0, e), t;
205
- }
206
- if (i.length !== void 0)
207
- return typeof i.length != "number" || Ue(i.length) ? N(0) : K(i);
208
- if (i.type === "Buffer" && Array.isArray(i.data))
209
- return K(i.data);
210
- }
211
- function d(i) {
212
- if (i >= Y)
213
- throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + Y.toString(16) + " bytes");
214
- return i | 0;
215
- }
216
- function m(i) {
217
- return +i != i && (i = 0), l.alloc(+i);
218
- }
219
- l.isBuffer = function(e) {
220
- return e != null && e._isBuffer === !0 && e !== l.prototype;
221
- }, l.compare = function(e, t) {
222
- if (Oe(e, h) && (e = l.from(e, e.offset, e.byteLength)), Oe(t, h) && (t = l.from(t, t.offset, t.byteLength)), !l.isBuffer(e) || !l.isBuffer(t))
223
- throw new TypeError(
224
- 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
225
- );
226
- if (e === t) return 0;
227
- let a = e.length, g = t.length;
228
- for (let T = 0, x = Math.min(a, g); T < x; ++T)
229
- if (e[T] !== t[T]) {
230
- a = e[T], g = t[T];
231
- break;
232
- }
233
- return a < g ? -1 : g < a ? 1 : 0;
234
- }, l.isEncoding = function(e) {
235
- switch (String(e).toLowerCase()) {
236
- case "hex":
237
- case "utf8":
238
- case "utf-8":
239
- case "ascii":
240
- case "latin1":
241
- case "binary":
242
- case "base64":
243
- case "ucs2":
244
- case "ucs-2":
245
- case "utf16le":
246
- case "utf-16le":
247
- return !0;
248
- default:
249
- return !1;
250
- }
251
- }, l.concat = function(e, t) {
252
- if (!Array.isArray(e))
253
- throw new TypeError('"list" argument must be an Array of Buffers');
254
- if (e.length === 0)
255
- return l.alloc(0);
256
- let a;
257
- if (t === void 0)
258
- for (t = 0, a = 0; a < e.length; ++a)
259
- t += e[a].length;
260
- const g = l.allocUnsafe(t);
261
- let T = 0;
262
- for (a = 0; a < e.length; ++a) {
263
- let x = e[a];
264
- if (Oe(x, h))
265
- T + x.length > g.length ? (l.isBuffer(x) || (x = l.from(x)), x.copy(g, T)) : h.prototype.set.call(
266
- g,
267
- x,
268
- T
269
- );
270
- else if (l.isBuffer(x))
271
- x.copy(g, T);
272
- else
273
- throw new TypeError('"list" argument must be an Array of Buffers');
274
- T += x.length;
275
- }
276
- return g;
277
- };
278
- function A(i, e) {
279
- if (l.isBuffer(i))
280
- return i.length;
281
- if (y.isView(i) || Oe(i, y))
282
- return i.byteLength;
283
- if (typeof i != "string")
284
- throw new TypeError(
285
- 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof i
286
- );
287
- const t = i.length, a = arguments.length > 2 && arguments[2] === !0;
288
- if (!a && t === 0) return 0;
289
- let g = !1;
290
- for (; ; )
291
- switch (e) {
292
- case "ascii":
293
- case "latin1":
294
- case "binary":
295
- return t;
296
- case "utf8":
297
- case "utf-8":
298
- return je(i).length;
299
- case "ucs2":
300
- case "ucs-2":
301
- case "utf16le":
302
- case "utf-16le":
303
- return t * 2;
304
- case "hex":
305
- return t >>> 1;
306
- case "base64":
307
- return _e(i).length;
308
- default:
309
- if (g)
310
- return a ? -1 : je(i).length;
311
- e = ("" + e).toLowerCase(), g = !0;
312
- }
313
- }
314
- l.byteLength = A;
315
- function M(i, e, t) {
316
- let a = !1;
317
- if ((e === void 0 || e < 0) && (e = 0), e > this.length || ((t === void 0 || t > this.length) && (t = this.length), t <= 0) || (t >>>= 0, e >>>= 0, t <= e))
318
- return "";
319
- for (i || (i = "utf8"); ; )
320
- switch (i) {
321
- case "hex":
322
- return I(this, e, t);
323
- case "utf8":
324
- case "utf-8":
325
- return Re(this, e, t);
326
- case "ascii":
327
- return Te(this, e, t);
328
- case "latin1":
329
- case "binary":
330
- return Le(this, e, t);
331
- case "base64":
332
- return Be(this, e, t);
333
- case "ucs2":
334
- case "ucs-2":
335
- case "utf16le":
336
- case "utf-16le":
337
- return F(this, e, t);
338
- default:
339
- if (a) throw new TypeError("Unknown encoding: " + i);
340
- i = (i + "").toLowerCase(), a = !0;
341
- }
342
- }
343
- l.prototype._isBuffer = !0;
344
- function U(i, e, t) {
345
- const a = i[e];
346
- i[e] = i[t], i[t] = a;
347
- }
348
- l.prototype.swap16 = function() {
349
- const e = this.length;
350
- if (e % 2 !== 0)
351
- throw new RangeError("Buffer size must be a multiple of 16-bits");
352
- for (let t = 0; t < e; t += 2)
353
- U(this, t, t + 1);
354
- return this;
355
- }, l.prototype.swap32 = function() {
356
- const e = this.length;
357
- if (e % 4 !== 0)
358
- throw new RangeError("Buffer size must be a multiple of 32-bits");
359
- for (let t = 0; t < e; t += 4)
360
- U(this, t, t + 3), U(this, t + 1, t + 2);
361
- return this;
362
- }, l.prototype.swap64 = function() {
363
- const e = this.length;
364
- if (e % 8 !== 0)
365
- throw new RangeError("Buffer size must be a multiple of 64-bits");
366
- for (let t = 0; t < e; t += 8)
367
- U(this, t, t + 7), U(this, t + 1, t + 6), U(this, t + 2, t + 5), U(this, t + 3, t + 4);
368
- return this;
369
- }, l.prototype.toString = function() {
370
- const e = this.length;
371
- return e === 0 ? "" : arguments.length === 0 ? Re(this, 0, e) : M.apply(this, arguments);
372
- }, l.prototype.toLocaleString = l.prototype.toString, l.prototype.equals = function(e) {
373
- if (!l.isBuffer(e)) throw new TypeError("Argument must be a Buffer");
374
- return this === e ? !0 : l.compare(this, e) === 0;
375
- }, l.prototype.inspect = function() {
376
- let e = "";
377
- const t = c.INSPECT_MAX_BYTES;
378
- return e = this.toString("hex", 0, t).replace(/(.{2})/g, "$1 ").trim(), this.length > t && (e += " ... "), "<Buffer " + e + ">";
379
- }, D && (l.prototype[D] = l.prototype.inspect), l.prototype.compare = function(e, t, a, g, T) {
380
- if (Oe(e, h) && (e = l.from(e, e.offset, e.byteLength)), !l.isBuffer(e))
381
- throw new TypeError(
382
- 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof e
383
- );
384
- if (t === void 0 && (t = 0), a === void 0 && (a = e ? e.length : 0), g === void 0 && (g = 0), T === void 0 && (T = this.length), t < 0 || a > e.length || g < 0 || T > this.length)
385
- throw new RangeError("out of range index");
386
- if (g >= T && t >= a)
387
- return 0;
388
- if (g >= T)
389
- return -1;
390
- if (t >= a)
391
- return 1;
392
- if (t >>>= 0, a >>>= 0, g >>>= 0, T >>>= 0, this === e) return 0;
393
- let x = T - g, ie = a - t;
394
- const pe = Math.min(x, ie), de = this.slice(g, T), ge = e.slice(t, a);
395
- for (let le = 0; le < pe; ++le)
396
- if (de[le] !== ge[le]) {
397
- x = de[le], ie = ge[le];
398
- break;
399
- }
400
- return x < ie ? -1 : ie < x ? 1 : 0;
401
- };
402
- function z(i, e, t, a, g) {
403
- if (i.length === 0) return -1;
404
- if (typeof t == "string" ? (a = t, t = 0) : t > 2147483647 ? t = 2147483647 : t < -2147483648 && (t = -2147483648), t = +t, Ue(t) && (t = g ? 0 : i.length - 1), t < 0 && (t = i.length + t), t >= i.length) {
405
- if (g) return -1;
406
- t = i.length - 1;
407
- } else if (t < 0)
408
- if (g) t = 0;
409
- else return -1;
410
- if (typeof e == "string" && (e = l.from(e, a)), l.isBuffer(e))
411
- return e.length === 0 ? -1 : Q(i, e, t, a, g);
412
- if (typeof e == "number")
413
- return e = e & 255, typeof h.prototype.indexOf == "function" ? g ? h.prototype.indexOf.call(i, e, t) : h.prototype.lastIndexOf.call(i, e, t) : Q(i, [e], t, a, g);
414
- throw new TypeError("val must be string, number or Buffer");
415
- }
416
- function Q(i, e, t, a, g) {
417
- let T = 1, x = i.length, ie = e.length;
418
- if (a !== void 0 && (a = String(a).toLowerCase(), a === "ucs2" || a === "ucs-2" || a === "utf16le" || a === "utf-16le")) {
419
- if (i.length < 2 || e.length < 2)
420
- return -1;
421
- T = 2, x /= 2, ie /= 2, t /= 2;
422
- }
423
- function pe(ge, le) {
424
- return T === 1 ? ge[le] : ge.readUInt16BE(le * T);
425
- }
426
- let de;
427
- if (g) {
428
- let ge = -1;
429
- for (de = t; de < x; de++)
430
- if (pe(i, de) === pe(e, ge === -1 ? 0 : de - ge)) {
431
- if (ge === -1 && (ge = de), de - ge + 1 === ie) return ge * T;
432
- } else
433
- ge !== -1 && (de -= de - ge), ge = -1;
434
- } else
435
- for (t + ie > x && (t = x - ie), de = t; de >= 0; de--) {
436
- let ge = !0;
437
- for (let le = 0; le < ie; le++)
438
- if (pe(i, de + le) !== pe(e, le)) {
439
- ge = !1;
440
- break;
441
- }
442
- if (ge) return de;
443
- }
444
- return -1;
445
- }
446
- l.prototype.includes = function(e, t, a) {
447
- return this.indexOf(e, t, a) !== -1;
448
- }, l.prototype.indexOf = function(e, t, a) {
449
- return z(this, e, t, a, !0);
450
- }, l.prototype.lastIndexOf = function(e, t, a) {
451
- return z(this, e, t, a, !1);
452
- };
453
- function ne(i, e, t, a) {
454
- t = Number(t) || 0;
455
- const g = i.length - t;
456
- a ? (a = Number(a), a > g && (a = g)) : a = g;
457
- const T = e.length;
458
- a > T / 2 && (a = T / 2);
459
- let x;
460
- for (x = 0; x < a; ++x) {
461
- const ie = parseInt(e.substr(x * 2, 2), 16);
462
- if (Ue(ie)) return x;
463
- i[t + x] = ie;
464
- }
465
- return x;
466
- }
467
- function S(i, e, t, a) {
468
- return Pe(je(e, i.length - t), i, t, a);
469
- }
470
- function se(i, e, t, a) {
471
- return Pe(Ke(e), i, t, a);
472
- }
473
- function he(i, e, t, a) {
474
- return Pe(_e(e), i, t, a);
475
- }
476
- function ye(i, e, t, a) {
477
- return Pe(me(e, i.length - t), i, t, a);
478
- }
479
- l.prototype.write = function(e, t, a, g) {
480
- if (t === void 0)
481
- g = "utf8", a = this.length, t = 0;
482
- else if (a === void 0 && typeof t == "string")
483
- g = t, a = this.length, t = 0;
484
- else if (isFinite(t))
485
- t = t >>> 0, isFinite(a) ? (a = a >>> 0, g === void 0 && (g = "utf8")) : (g = a, a = void 0);
486
- else
487
- throw new Error(
488
- "Buffer.write(string, encoding, offset[, length]) is no longer supported"
489
- );
490
- const T = this.length - t;
491
- if ((a === void 0 || a > T) && (a = T), e.length > 0 && (a < 0 || t < 0) || t > this.length)
492
- throw new RangeError("Attempt to write outside buffer bounds");
493
- g || (g = "utf8");
494
- let x = !1;
495
- for (; ; )
496
- switch (g) {
497
- case "hex":
498
- return ne(this, e, t, a);
499
- case "utf8":
500
- case "utf-8":
501
- return S(this, e, t, a);
502
- case "ascii":
503
- case "latin1":
504
- case "binary":
505
- return se(this, e, t, a);
506
- case "base64":
507
- return he(this, e, t, a);
508
- case "ucs2":
509
- case "ucs-2":
510
- case "utf16le":
511
- case "utf-16le":
512
- return ye(this, e, t, a);
513
- default:
514
- if (x) throw new TypeError("Unknown encoding: " + g);
515
- g = ("" + g).toLowerCase(), x = !0;
516
- }
517
- }, l.prototype.toJSON = function() {
518
- return {
519
- type: "Buffer",
520
- data: Array.prototype.slice.call(this._arr || this, 0)
521
- };
522
- };
523
- function Be(i, e, t) {
524
- return e === 0 && t === i.length ? v.fromByteArray(i) : v.fromByteArray(i.slice(e, t));
525
- }
526
- function Re(i, e, t) {
527
- t = Math.min(i.length, t);
528
- const a = [];
529
- let g = e;
530
- for (; g < t; ) {
531
- const T = i[g];
532
- let x = null, ie = T > 239 ? 4 : T > 223 ? 3 : T > 191 ? 2 : 1;
533
- if (g + ie <= t) {
534
- let pe, de, ge, le;
535
- switch (ie) {
536
- case 1:
537
- T < 128 && (x = T);
538
- break;
539
- case 2:
540
- pe = i[g + 1], (pe & 192) === 128 && (le = (T & 31) << 6 | pe & 63, le > 127 && (x = le));
541
- break;
542
- case 3:
543
- pe = i[g + 1], de = i[g + 2], (pe & 192) === 128 && (de & 192) === 128 && (le = (T & 15) << 12 | (pe & 63) << 6 | de & 63, le > 2047 && (le < 55296 || le > 57343) && (x = le));
544
- break;
545
- case 4:
546
- pe = i[g + 1], de = i[g + 2], ge = i[g + 3], (pe & 192) === 128 && (de & 192) === 128 && (ge & 192) === 128 && (le = (T & 15) << 18 | (pe & 63) << 12 | (de & 63) << 6 | ge & 63, le > 65535 && le < 1114112 && (x = le));
547
- }
548
- }
549
- x === null ? (x = 65533, ie = 1) : x > 65535 && (x -= 65536, a.push(x >>> 10 & 1023 | 55296), x = 56320 | x & 1023), a.push(x), g += ie;
550
- }
551
- return Se(a);
552
- }
553
- const Ae = 4096;
554
- function Se(i) {
555
- const e = i.length;
556
- if (e <= Ae)
557
- return String.fromCharCode.apply(String, i);
558
- let t = "", a = 0;
559
- for (; a < e; )
560
- t += String.fromCharCode.apply(
561
- String,
562
- i.slice(a, a += Ae)
563
- );
564
- return t;
565
- }
566
- function Te(i, e, t) {
567
- let a = "";
568
- t = Math.min(i.length, t);
569
- for (let g = e; g < t; ++g)
570
- a += String.fromCharCode(i[g] & 127);
571
- return a;
572
- }
573
- function Le(i, e, t) {
574
- let a = "";
575
- t = Math.min(i.length, t);
576
- for (let g = e; g < t; ++g)
577
- a += String.fromCharCode(i[g]);
578
- return a;
579
- }
580
- function I(i, e, t) {
581
- const a = i.length;
582
- (!e || e < 0) && (e = 0), (!t || t < 0 || t > a) && (t = a);
583
- let g = "";
584
- for (let T = e; T < t; ++T)
585
- g += Ce[i[T]];
586
- return g;
587
- }
588
- function F(i, e, t) {
589
- const a = i.slice(e, t);
590
- let g = "";
591
- for (let T = 0; T < a.length - 1; T += 2)
592
- g += String.fromCharCode(a[T] + a[T + 1] * 256);
593
- return g;
594
- }
595
- l.prototype.slice = function(e, t) {
596
- const a = this.length;
597
- e = ~~e, t = t === void 0 ? a : ~~t, e < 0 ? (e += a, e < 0 && (e = 0)) : e > a && (e = a), t < 0 ? (t += a, t < 0 && (t = 0)) : t > a && (t = a), t < e && (t = e);
598
- const g = this.subarray(e, t);
599
- return Object.setPrototypeOf(g, l.prototype), g;
600
- };
601
- function q(i, e, t) {
602
- if (i % 1 !== 0 || i < 0) throw new RangeError("offset is not uint");
603
- if (i + e > t) throw new RangeError("Trying to access beyond buffer length");
604
- }
605
- l.prototype.readUintLE = l.prototype.readUIntLE = function(e, t, a) {
606
- e = e >>> 0, t = t >>> 0, a || q(e, t, this.length);
607
- let g = this[e], T = 1, x = 0;
608
- for (; ++x < t && (T *= 256); )
609
- g += this[e + x] * T;
610
- return g;
611
- }, l.prototype.readUintBE = l.prototype.readUIntBE = function(e, t, a) {
612
- e = e >>> 0, t = t >>> 0, a || q(e, t, this.length);
613
- let g = this[e + --t], T = 1;
614
- for (; t > 0 && (T *= 256); )
615
- g += this[e + --t] * T;
616
- return g;
617
- }, l.prototype.readUint8 = l.prototype.readUInt8 = function(e, t) {
618
- return e = e >>> 0, t || q(e, 1, this.length), this[e];
619
- }, l.prototype.readUint16LE = l.prototype.readUInt16LE = function(e, t) {
620
- return e = e >>> 0, t || q(e, 2, this.length), this[e] | this[e + 1] << 8;
621
- }, l.prototype.readUint16BE = l.prototype.readUInt16BE = function(e, t) {
622
- return e = e >>> 0, t || q(e, 2, this.length), this[e] << 8 | this[e + 1];
623
- }, l.prototype.readUint32LE = l.prototype.readUInt32LE = function(e, t) {
624
- return e = e >>> 0, t || q(e, 4, this.length), (this[e] | this[e + 1] << 8 | this[e + 2] << 16) + this[e + 3] * 16777216;
625
- }, l.prototype.readUint32BE = l.prototype.readUInt32BE = function(e, t) {
626
- return e = e >>> 0, t || q(e, 4, this.length), this[e] * 16777216 + (this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3]);
627
- }, l.prototype.readBigUInt64LE = Ie(function(e) {
628
- e = e >>> 0, te(e, "offset");
629
- const t = this[e], a = this[e + 7];
630
- (t === void 0 || a === void 0) && ae(e, this.length - 8);
631
- const g = t + this[++e] * 2 ** 8 + this[++e] * 2 ** 16 + this[++e] * 2 ** 24, T = this[++e] + this[++e] * 2 ** 8 + this[++e] * 2 ** 16 + a * 2 ** 24;
632
- return BigInt(g) + (BigInt(T) << BigInt(32));
633
- }), l.prototype.readBigUInt64BE = Ie(function(e) {
634
- e = e >>> 0, te(e, "offset");
635
- const t = this[e], a = this[e + 7];
636
- (t === void 0 || a === void 0) && ae(e, this.length - 8);
637
- const g = t * 2 ** 24 + this[++e] * 2 ** 16 + this[++e] * 2 ** 8 + this[++e], T = this[++e] * 2 ** 24 + this[++e] * 2 ** 16 + this[++e] * 2 ** 8 + a;
638
- return (BigInt(g) << BigInt(32)) + BigInt(T);
639
- }), l.prototype.readIntLE = function(e, t, a) {
640
- e = e >>> 0, t = t >>> 0, a || q(e, t, this.length);
641
- let g = this[e], T = 1, x = 0;
642
- for (; ++x < t && (T *= 256); )
643
- g += this[e + x] * T;
644
- return T *= 128, g >= T && (g -= Math.pow(2, 8 * t)), g;
645
- }, l.prototype.readIntBE = function(e, t, a) {
646
- e = e >>> 0, t = t >>> 0, a || q(e, t, this.length);
647
- let g = t, T = 1, x = this[e + --g];
648
- for (; g > 0 && (T *= 256); )
649
- x += this[e + --g] * T;
650
- return T *= 128, x >= T && (x -= Math.pow(2, 8 * t)), x;
651
- }, l.prototype.readInt8 = function(e, t) {
652
- return e = e >>> 0, t || q(e, 1, this.length), this[e] & 128 ? (255 - this[e] + 1) * -1 : this[e];
653
- }, l.prototype.readInt16LE = function(e, t) {
654
- e = e >>> 0, t || q(e, 2, this.length);
655
- const a = this[e] | this[e + 1] << 8;
656
- return a & 32768 ? a | 4294901760 : a;
657
- }, l.prototype.readInt16BE = function(e, t) {
658
- e = e >>> 0, t || q(e, 2, this.length);
659
- const a = this[e + 1] | this[e] << 8;
660
- return a & 32768 ? a | 4294901760 : a;
661
- }, l.prototype.readInt32LE = function(e, t) {
662
- return e = e >>> 0, t || q(e, 4, this.length), this[e] | this[e + 1] << 8 | this[e + 2] << 16 | this[e + 3] << 24;
663
- }, l.prototype.readInt32BE = function(e, t) {
664
- return e = e >>> 0, t || q(e, 4, this.length), this[e] << 24 | this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3];
665
- }, l.prototype.readBigInt64LE = Ie(function(e) {
666
- e = e >>> 0, te(e, "offset");
667
- const t = this[e], a = this[e + 7];
668
- (t === void 0 || a === void 0) && ae(e, this.length - 8);
669
- const g = this[e + 4] + this[e + 5] * 2 ** 8 + this[e + 6] * 2 ** 16 + (a << 24);
670
- return (BigInt(g) << BigInt(32)) + BigInt(t + this[++e] * 2 ** 8 + this[++e] * 2 ** 16 + this[++e] * 2 ** 24);
671
- }), l.prototype.readBigInt64BE = Ie(function(e) {
672
- e = e >>> 0, te(e, "offset");
673
- const t = this[e], a = this[e + 7];
674
- (t === void 0 || a === void 0) && ae(e, this.length - 8);
675
- const g = (t << 24) + // Overflow
676
- this[++e] * 2 ** 16 + this[++e] * 2 ** 8 + this[++e];
677
- return (BigInt(g) << BigInt(32)) + BigInt(this[++e] * 2 ** 24 + this[++e] * 2 ** 16 + this[++e] * 2 ** 8 + a);
678
- }), l.prototype.readFloatLE = function(e, t) {
679
- return e = e >>> 0, t || q(e, 4, this.length), P.read(this, e, !0, 23, 4);
680
- }, l.prototype.readFloatBE = function(e, t) {
681
- return e = e >>> 0, t || q(e, 4, this.length), P.read(this, e, !1, 23, 4);
682
- }, l.prototype.readDoubleLE = function(e, t) {
683
- return e = e >>> 0, t || q(e, 8, this.length), P.read(this, e, !0, 52, 8);
684
- }, l.prototype.readDoubleBE = function(e, t) {
685
- return e = e >>> 0, t || q(e, 8, this.length), P.read(this, e, !1, 52, 8);
686
- };
687
- function re(i, e, t, a, g, T) {
688
- if (!l.isBuffer(i)) throw new TypeError('"buffer" argument must be a Buffer instance');
689
- if (e > g || e < T) throw new RangeError('"value" argument is out of bounds');
690
- if (t + a > i.length) throw new RangeError("Index out of range");
691
- }
692
- l.prototype.writeUintLE = l.prototype.writeUIntLE = function(e, t, a, g) {
693
- if (e = +e, t = t >>> 0, a = a >>> 0, !g) {
694
- const ie = Math.pow(2, 8 * a) - 1;
695
- re(this, e, t, a, ie, 0);
696
- }
697
- let T = 1, x = 0;
698
- for (this[t] = e & 255; ++x < a && (T *= 256); )
699
- this[t + x] = e / T & 255;
700
- return t + a;
701
- }, l.prototype.writeUintBE = l.prototype.writeUIntBE = function(e, t, a, g) {
702
- if (e = +e, t = t >>> 0, a = a >>> 0, !g) {
703
- const ie = Math.pow(2, 8 * a) - 1;
704
- re(this, e, t, a, ie, 0);
705
- }
706
- let T = a - 1, x = 1;
707
- for (this[t + T] = e & 255; --T >= 0 && (x *= 256); )
708
- this[t + T] = e / x & 255;
709
- return t + a;
710
- }, l.prototype.writeUint8 = l.prototype.writeUInt8 = function(e, t, a) {
711
- return e = +e, t = t >>> 0, a || re(this, e, t, 1, 255, 0), this[t] = e & 255, t + 1;
712
- }, l.prototype.writeUint16LE = l.prototype.writeUInt16LE = function(e, t, a) {
713
- return e = +e, t = t >>> 0, a || re(this, e, t, 2, 65535, 0), this[t] = e & 255, this[t + 1] = e >>> 8, t + 2;
714
- }, l.prototype.writeUint16BE = l.prototype.writeUInt16BE = function(e, t, a) {
715
- return e = +e, t = t >>> 0, a || re(this, e, t, 2, 65535, 0), this[t] = e >>> 8, this[t + 1] = e & 255, t + 2;
716
- }, l.prototype.writeUint32LE = l.prototype.writeUInt32LE = function(e, t, a) {
717
- return e = +e, t = t >>> 0, a || re(this, e, t, 4, 4294967295, 0), this[t + 3] = e >>> 24, this[t + 2] = e >>> 16, this[t + 1] = e >>> 8, this[t] = e & 255, t + 4;
718
- }, l.prototype.writeUint32BE = l.prototype.writeUInt32BE = function(e, t, a) {
719
- return e = +e, t = t >>> 0, a || re(this, e, t, 4, 4294967295, 0), this[t] = e >>> 24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = e & 255, t + 4;
720
- };
721
- function b(i, e, t, a, g) {
722
- fe(e, a, g, i, t, 7);
723
- let T = Number(e & BigInt(4294967295));
724
- i[t++] = T, T = T >> 8, i[t++] = T, T = T >> 8, i[t++] = T, T = T >> 8, i[t++] = T;
725
- let x = Number(e >> BigInt(32) & BigInt(4294967295));
726
- return i[t++] = x, x = x >> 8, i[t++] = x, x = x >> 8, i[t++] = x, x = x >> 8, i[t++] = x, t;
727
- }
728
- function _(i, e, t, a, g) {
729
- fe(e, a, g, i, t, 7);
730
- let T = Number(e & BigInt(4294967295));
731
- i[t + 7] = T, T = T >> 8, i[t + 6] = T, T = T >> 8, i[t + 5] = T, T = T >> 8, i[t + 4] = T;
732
- let x = Number(e >> BigInt(32) & BigInt(4294967295));
733
- return i[t + 3] = x, x = x >> 8, i[t + 2] = x, x = x >> 8, i[t + 1] = x, x = x >> 8, i[t] = x, t + 8;
734
- }
735
- l.prototype.writeBigUInt64LE = Ie(function(e, t = 0) {
736
- return b(this, e, t, BigInt(0), BigInt("0xffffffffffffffff"));
737
- }), l.prototype.writeBigUInt64BE = Ie(function(e, t = 0) {
738
- return _(this, e, t, BigInt(0), BigInt("0xffffffffffffffff"));
739
- }), l.prototype.writeIntLE = function(e, t, a, g) {
740
- if (e = +e, t = t >>> 0, !g) {
741
- const pe = Math.pow(2, 8 * a - 1);
742
- re(this, e, t, a, pe - 1, -pe);
743
- }
744
- let T = 0, x = 1, ie = 0;
745
- for (this[t] = e & 255; ++T < a && (x *= 256); )
746
- e < 0 && ie === 0 && this[t + T - 1] !== 0 && (ie = 1), this[t + T] = (e / x >> 0) - ie & 255;
747
- return t + a;
748
- }, l.prototype.writeIntBE = function(e, t, a, g) {
749
- if (e = +e, t = t >>> 0, !g) {
750
- const pe = Math.pow(2, 8 * a - 1);
751
- re(this, e, t, a, pe - 1, -pe);
752
- }
753
- let T = a - 1, x = 1, ie = 0;
754
- for (this[t + T] = e & 255; --T >= 0 && (x *= 256); )
755
- e < 0 && ie === 0 && this[t + T + 1] !== 0 && (ie = 1), this[t + T] = (e / x >> 0) - ie & 255;
756
- return t + a;
757
- }, l.prototype.writeInt8 = function(e, t, a) {
758
- return e = +e, t = t >>> 0, a || re(this, e, t, 1, 127, -128), e < 0 && (e = 255 + e + 1), this[t] = e & 255, t + 1;
759
- }, l.prototype.writeInt16LE = function(e, t, a) {
760
- return e = +e, t = t >>> 0, a || re(this, e, t, 2, 32767, -32768), this[t] = e & 255, this[t + 1] = e >>> 8, t + 2;
761
- }, l.prototype.writeInt16BE = function(e, t, a) {
762
- return e = +e, t = t >>> 0, a || re(this, e, t, 2, 32767, -32768), this[t] = e >>> 8, this[t + 1] = e & 255, t + 2;
763
- }, l.prototype.writeInt32LE = function(e, t, a) {
764
- return e = +e, t = t >>> 0, a || re(this, e, t, 4, 2147483647, -2147483648), this[t] = e & 255, this[t + 1] = e >>> 8, this[t + 2] = e >>> 16, this[t + 3] = e >>> 24, t + 4;
765
- }, l.prototype.writeInt32BE = function(e, t, a) {
766
- return e = +e, t = t >>> 0, a || re(this, e, t, 4, 2147483647, -2147483648), e < 0 && (e = 4294967295 + e + 1), this[t] = e >>> 24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = e & 255, t + 4;
767
- }, l.prototype.writeBigInt64LE = Ie(function(e, t = 0) {
768
- return b(this, e, t, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
769
- }), l.prototype.writeBigInt64BE = Ie(function(e, t = 0) {
770
- return _(this, e, t, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
771
- });
772
- function C(i, e, t, a, g, T) {
773
- if (t + a > i.length) throw new RangeError("Index out of range");
774
- if (t < 0) throw new RangeError("Index out of range");
775
- }
776
- function Z(i, e, t, a, g) {
777
- return e = +e, t = t >>> 0, g || C(i, e, t, 4), P.write(i, e, t, a, 23, 4), t + 4;
778
- }
779
- l.prototype.writeFloatLE = function(e, t, a) {
780
- return Z(this, e, t, !0, a);
781
- }, l.prototype.writeFloatBE = function(e, t, a) {
782
- return Z(this, e, t, !1, a);
783
- };
784
- function ee(i, e, t, a, g) {
785
- return e = +e, t = t >>> 0, g || C(i, e, t, 8), P.write(i, e, t, a, 52, 8), t + 8;
786
- }
787
- l.prototype.writeDoubleLE = function(e, t, a) {
788
- return ee(this, e, t, !0, a);
789
- }, l.prototype.writeDoubleBE = function(e, t, a) {
790
- return ee(this, e, t, !1, a);
791
- }, l.prototype.copy = function(e, t, a, g) {
792
- if (!l.isBuffer(e)) throw new TypeError("argument should be a Buffer");
793
- if (a || (a = 0), !g && g !== 0 && (g = this.length), t >= e.length && (t = e.length), t || (t = 0), g > 0 && g < a && (g = a), g === a || e.length === 0 || this.length === 0) return 0;
794
- if (t < 0)
795
- throw new RangeError("targetStart out of bounds");
796
- if (a < 0 || a >= this.length) throw new RangeError("Index out of range");
797
- if (g < 0) throw new RangeError("sourceEnd out of bounds");
798
- g > this.length && (g = this.length), e.length - t < g - a && (g = e.length - t + a);
799
- const T = g - a;
800
- return this === e && typeof h.prototype.copyWithin == "function" ? this.copyWithin(t, a, g) : h.prototype.set.call(
801
- e,
802
- this.subarray(a, g),
803
- t
804
- ), T;
805
- }, l.prototype.fill = function(e, t, a, g) {
806
- if (typeof e == "string") {
807
- if (typeof t == "string" ? (g = t, t = 0, a = this.length) : typeof a == "string" && (g = a, a = this.length), g !== void 0 && typeof g != "string")
808
- throw new TypeError("encoding must be a string");
809
- if (typeof g == "string" && !l.isEncoding(g))
810
- throw new TypeError("Unknown encoding: " + g);
811
- if (e.length === 1) {
812
- const x = e.charCodeAt(0);
813
- (g === "utf8" && x < 128 || g === "latin1") && (e = x);
814
- }
815
- } else typeof e == "number" ? e = e & 255 : typeof e == "boolean" && (e = Number(e));
816
- if (t < 0 || this.length < t || this.length < a)
817
- throw new RangeError("Out of range index");
818
- if (a <= t)
819
- return this;
820
- t = t >>> 0, a = a === void 0 ? this.length : a >>> 0, e || (e = 0);
821
- let T;
822
- if (typeof e == "number")
823
- for (T = t; T < a; ++T)
824
- this[T] = e;
825
- else {
826
- const x = l.isBuffer(e) ? e : l.from(e, g), ie = x.length;
827
- if (ie === 0)
828
- throw new TypeError('The value "' + e + '" is invalid for argument "value"');
829
- for (T = 0; T < a - t; ++T)
830
- this[T + t] = x[T % ie];
831
- }
832
- return this;
833
- };
834
- const u = {};
835
- function s(i, e, t) {
836
- u[i] = class extends t {
837
- constructor() {
838
- super(), Object.defineProperty(this, "message", {
839
- value: e.apply(this, arguments),
840
- writable: !0,
841
- configurable: !0
842
- }), this.name = `${this.name} [${i}]`, this.stack, delete this.name;
843
- }
844
- get code() {
845
- return i;
846
- }
847
- set code(g) {
848
- Object.defineProperty(this, "code", {
849
- configurable: !0,
850
- enumerable: !0,
851
- value: g,
852
- writable: !0
853
- });
854
- }
855
- toString() {
856
- return `${this.name} [${i}]: ${this.message}`;
857
- }
858
- };
859
- }
860
- s(
861
- "ERR_BUFFER_OUT_OF_BOUNDS",
862
- function(i) {
863
- return i ? `${i} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
864
- },
865
- RangeError
866
- ), s(
867
- "ERR_INVALID_ARG_TYPE",
868
- function(i, e) {
869
- return `The "${i}" argument must be of type number. Received type ${typeof e}`;
870
- },
871
- TypeError
872
- ), s(
873
- "ERR_OUT_OF_RANGE",
874
- function(i, e, t) {
875
- let a = `The value of "${i}" is out of range.`, g = t;
876
- return Number.isInteger(t) && Math.abs(t) > 2 ** 32 ? g = H(String(t)) : typeof t == "bigint" && (g = String(t), (t > BigInt(2) ** BigInt(32) || t < -(BigInt(2) ** BigInt(32))) && (g = H(g)), g += "n"), a += ` It must be ${e}. Received ${g}`, a;
877
- },
878
- RangeError
879
- );
880
- function H(i) {
881
- let e = "", t = i.length;
882
- const a = i[0] === "-" ? 1 : 0;
883
- for (; t >= a + 4; t -= 3)
884
- e = `_${i.slice(t - 3, t)}${e}`;
885
- return `${i.slice(0, t)}${e}`;
886
- }
887
- function $(i, e, t) {
888
- te(e, "offset"), (i[e] === void 0 || i[e + t] === void 0) && ae(e, i.length - (t + 1));
889
- }
890
- function fe(i, e, t, a, g, T) {
891
- if (i > t || i < e) {
892
- const x = typeof e == "bigint" ? "n" : "";
893
- let ie;
894
- throw e === 0 || e === BigInt(0) ? ie = `>= 0${x} and < 2${x} ** ${(T + 1) * 8}${x}` : ie = `>= -(2${x} ** ${(T + 1) * 8 - 1}${x}) and < 2 ** ${(T + 1) * 8 - 1}${x}`, new u.ERR_OUT_OF_RANGE("value", ie, i);
895
- }
896
- $(a, g, T);
897
- }
898
- function te(i, e) {
899
- if (typeof i != "number")
900
- throw new u.ERR_INVALID_ARG_TYPE(e, "number", i);
901
- }
902
- function ae(i, e, t) {
903
- throw Math.floor(i) !== i ? (te(i, t), new u.ERR_OUT_OF_RANGE("offset", "an integer", i)) : e < 0 ? new u.ERR_BUFFER_OUT_OF_BOUNDS() : new u.ERR_OUT_OF_RANGE(
904
- "offset",
905
- `>= 0 and <= ${e}`,
906
- i
907
- );
908
- }
909
- const Me = /[^+/0-9A-Za-z-_]/g;
910
- function G(i) {
911
- if (i = i.split("=")[0], i = i.trim().replace(Me, ""), i.length < 2) return "";
912
- for (; i.length % 4 !== 0; )
913
- i = i + "=";
914
- return i;
915
- }
916
- function je(i, e) {
917
- e = e || 1 / 0;
918
- let t;
919
- const a = i.length;
920
- let g = null;
921
- const T = [];
922
- for (let x = 0; x < a; ++x) {
923
- if (t = i.charCodeAt(x), t > 55295 && t < 57344) {
924
- if (!g) {
925
- if (t > 56319) {
926
- (e -= 3) > -1 && T.push(239, 191, 189);
927
- continue;
928
- } else if (x + 1 === a) {
929
- (e -= 3) > -1 && T.push(239, 191, 189);
930
- continue;
931
- }
932
- g = t;
933
- continue;
934
- }
935
- if (t < 56320) {
936
- (e -= 3) > -1 && T.push(239, 191, 189), g = t;
937
- continue;
938
- }
939
- t = (g - 55296 << 10 | t - 56320) + 65536;
940
- } else g && (e -= 3) > -1 && T.push(239, 191, 189);
941
- if (g = null, t < 128) {
942
- if ((e -= 1) < 0) break;
943
- T.push(t);
944
- } else if (t < 2048) {
945
- if ((e -= 2) < 0) break;
946
- T.push(
947
- t >> 6 | 192,
948
- t & 63 | 128
949
- );
950
- } else if (t < 65536) {
951
- if ((e -= 3) < 0) break;
952
- T.push(
953
- t >> 12 | 224,
954
- t >> 6 & 63 | 128,
955
- t & 63 | 128
956
- );
957
- } else if (t < 1114112) {
958
- if ((e -= 4) < 0) break;
959
- T.push(
960
- t >> 18 | 240,
961
- t >> 12 & 63 | 128,
962
- t >> 6 & 63 | 128,
963
- t & 63 | 128
964
- );
965
- } else
966
- throw new Error("Invalid code point");
967
- }
968
- return T;
969
- }
970
- function Ke(i) {
971
- const e = [];
972
- for (let t = 0; t < i.length; ++t)
973
- e.push(i.charCodeAt(t) & 255);
974
- return e;
975
- }
976
- function me(i, e) {
977
- let t, a, g;
978
- const T = [];
979
- for (let x = 0; x < i.length && !((e -= 2) < 0); ++x)
980
- t = i.charCodeAt(x), a = t >> 8, g = t % 256, T.push(g), T.push(a);
981
- return T;
982
- }
983
- function _e(i) {
984
- return v.toByteArray(G(i));
985
- }
986
- function Pe(i, e, t, a) {
987
- let g;
988
- for (g = 0; g < a && !(g + t >= e.length || g >= i.length); ++g)
989
- e[g + t] = i[g];
990
- return g;
991
- }
992
- function Oe(i, e) {
993
- return i instanceof e || i != null && i.constructor != null && i.constructor.name != null && i.constructor.name === e.name;
994
- }
995
- function Ue(i) {
996
- return i !== i;
997
- }
998
- const Ce = (function() {
999
- const i = "0123456789abcdef", e = new Array(256);
1000
- for (let t = 0; t < 16; ++t) {
1001
- const a = t * 16;
1002
- for (let g = 0; g < 16; ++g)
1003
- e[a + g] = i[t] + i[g];
1004
- }
1005
- return e;
1006
- })();
1007
- function Ie(i) {
1008
- return typeof BigInt > "u" ? Ge : i;
1009
- }
1010
- function Ge() {
1011
- throw new Error("BigInt not supported");
1012
- }
1013
- })(Nr);
1014
- const qt = Nr.Buffer, un = Nr.Buffer;
1015
- function Wt(c) {
1016
- return c && c.__esModule && Object.prototype.hasOwnProperty.call(c, "default") ? c.default : c;
1017
- }
1018
- var pt = { exports: {} }, ve = pt.exports = {}, ke, Fe;
1019
- function Mr() {
1020
- throw new Error("setTimeout has not been defined");
1021
- }
1022
- function Ur() {
1023
- throw new Error("clearTimeout has not been defined");
1024
- }
1025
- (function() {
1026
- try {
1027
- typeof setTimeout == "function" ? ke = setTimeout : ke = Mr;
1028
- } catch {
1029
- ke = Mr;
1030
- }
1031
- try {
1032
- typeof clearTimeout == "function" ? Fe = clearTimeout : Fe = Ur;
1033
- } catch {
1034
- Fe = Ur;
1035
- }
1036
- })();
1037
- function dt(c) {
1038
- if (ke === setTimeout)
1039
- return setTimeout(c, 0);
1040
- if ((ke === Mr || !ke) && setTimeout)
1041
- return ke = setTimeout, setTimeout(c, 0);
1042
- try {
1043
- return ke(c, 0);
1044
- } catch {
1045
- try {
1046
- return ke.call(null, c, 0);
1047
- } catch {
1048
- return ke.call(this, c, 0);
1049
- }
1050
- }
1051
- }
1052
- function Gt(c) {
1053
- if (Fe === clearTimeout)
1054
- return clearTimeout(c);
1055
- if ((Fe === Ur || !Fe) && clearTimeout)
1056
- return Fe = clearTimeout, clearTimeout(c);
1057
- try {
1058
- return Fe(c);
1059
- } catch {
1060
- try {
1061
- return Fe.call(null, c);
1062
- } catch {
1063
- return Fe.call(this, c);
1064
- }
1065
- }
1066
- }
1067
- var qe = [], Xe = !1, Ve, nr = -1;
1068
- function Ht() {
1069
- !Xe || !Ve || (Xe = !1, Ve.length ? qe = Ve.concat(qe) : nr = -1, qe.length && yt());
1070
- }
1071
- function yt() {
1072
- if (!Xe) {
1073
- var c = dt(Ht);
1074
- Xe = !0;
1075
- for (var v = qe.length; v; ) {
1076
- for (Ve = qe, qe = []; ++nr < v; )
1077
- Ve && Ve[nr].run();
1078
- nr = -1, v = qe.length;
1079
- }
1080
- Ve = null, Xe = !1, Gt(c);
1081
- }
1082
- }
1083
- ve.nextTick = function(c) {
1084
- var v = new Array(arguments.length - 1);
1085
- if (arguments.length > 1)
1086
- for (var P = 1; P < arguments.length; P++)
1087
- v[P - 1] = arguments[P];
1088
- qe.push(new gt(c, v)), qe.length === 1 && !Xe && dt(yt);
1089
- };
1090
- function gt(c, v) {
1091
- this.fun = c, this.array = v;
1092
- }
1093
- gt.prototype.run = function() {
1094
- this.fun.apply(null, this.array);
1095
- };
1096
- ve.title = "browser";
1097
- ve.browser = !0;
1098
- ve.env = {};
1099
- ve.argv = [];
1100
- ve.version = "";
1101
- ve.versions = {};
1102
- function We() {
1103
- }
1104
- ve.on = We;
1105
- ve.addListener = We;
1106
- ve.once = We;
1107
- ve.off = We;
1108
- ve.removeListener = We;
1109
- ve.removeAllListeners = We;
1110
- ve.emit = We;
1111
- ve.prependListener = We;
1112
- ve.prependOnceListener = We;
1113
- ve.listeners = function(c) {
1114
- return [];
1115
- };
1116
- ve.binding = function(c) {
1117
- throw new Error("process.binding is not supported");
1118
- };
1119
- ve.cwd = function() {
1120
- return "/";
1121
- };
1122
- ve.chdir = function(c) {
1123
- throw new Error("process.chdir is not supported");
1124
- };
1125
- ve.umask = function() {
1126
- return 0;
1127
- };
1128
- var Vt = pt.exports;
1129
- const ue = /* @__PURE__ */ Wt(Vt);
1130
- var $e = { exports: {} }, fr = {}, Dr;
1131
- function or() {
1132
- return Dr || (Dr = 1, (function(c) {
1133
- Object.defineProperties(c, { __esModule: { value: !0 }, [Symbol.toStringTag]: { value: "Module" } });
1134
- var v = {}, P = {};
1135
- P.byteLength = l, P.toByteArray = j, P.fromByteArray = X;
1136
- for (var D = [], Y = [], h = typeof Uint8Array < "u" ? Uint8Array : Array, y = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", O = 0, p = y.length; O < p; ++O)
1137
- D[O] = y[O], Y[y.charCodeAt(O)] = O;
1138
- Y[45] = 62, Y[95] = 63;
1139
- function N(B) {
1140
- var R = B.length;
1141
- if (R % 4 > 0)
1142
- throw new Error("Invalid string. Length must be a multiple of 4");
1143
- var d = B.indexOf("=");
1144
- d === -1 && (d = R);
1145
- var m = d === R ? 0 : 4 - d % 4;
1146
- return [d, m];
1147
- }
1148
- function l(B) {
1149
- var R = N(B), d = R[0], m = R[1];
1150
- return (d + m) * 3 / 4 - m;
1151
- }
1152
- function k(B, R, d) {
1153
- return (R + d) * 3 / 4 - d;
1154
- }
1155
- function j(B) {
1156
- var R, d = N(B), m = d[0], A = d[1], M = new h(k(B, m, A)), U = 0, z = A > 0 ? m - 4 : m, Q;
1157
- for (Q = 0; Q < z; Q += 4)
1158
- R = Y[B.charCodeAt(Q)] << 18 | Y[B.charCodeAt(Q + 1)] << 12 | Y[B.charCodeAt(Q + 2)] << 6 | Y[B.charCodeAt(Q + 3)], M[U++] = R >> 16 & 255, M[U++] = R >> 8 & 255, M[U++] = R & 255;
1159
- return A === 2 && (R = Y[B.charCodeAt(Q)] << 2 | Y[B.charCodeAt(Q + 1)] >> 4, M[U++] = R & 255), A === 1 && (R = Y[B.charCodeAt(Q)] << 10 | Y[B.charCodeAt(Q + 1)] << 4 | Y[B.charCodeAt(Q + 2)] >> 2, M[U++] = R >> 8 & 255, M[U++] = R & 255), M;
1160
- }
1161
- function J(B) {
1162
- return D[B >> 18 & 63] + D[B >> 12 & 63] + D[B >> 6 & 63] + D[B & 63];
1163
- }
1164
- function V(B, R, d) {
1165
- for (var m, A = [], M = R; M < d; M += 3)
1166
- m = (B[M] << 16 & 16711680) + (B[M + 1] << 8 & 65280) + (B[M + 2] & 255), A.push(J(m));
1167
- return A.join("");
1168
- }
1169
- function X(B) {
1170
- for (var R, d = B.length, m = d % 3, A = [], M = 16383, U = 0, z = d - m; U < z; U += M)
1171
- A.push(V(B, U, U + M > z ? z : U + M));
1172
- return m === 1 ? (R = B[d - 1], A.push(
1173
- D[R >> 2] + D[R << 4 & 63] + "=="
1174
- )) : m === 2 && (R = (B[d - 2] << 8) + B[d - 1], A.push(
1175
- D[R >> 10] + D[R >> 4 & 63] + D[R << 2 & 63] + "="
1176
- )), A.join("");
1177
- }
1178
- var K = {};
1179
- K.read = function(B, R, d, m, A) {
1180
- var M, U, z = A * 8 - m - 1, Q = (1 << z) - 1, ne = Q >> 1, S = -7, se = d ? A - 1 : 0, he = d ? -1 : 1, ye = B[R + se];
1181
- for (se += he, M = ye & (1 << -S) - 1, ye >>= -S, S += z; S > 0; M = M * 256 + B[R + se], se += he, S -= 8)
1182
- ;
1183
- for (U = M & (1 << -S) - 1, M >>= -S, S += m; S > 0; U = U * 256 + B[R + se], se += he, S -= 8)
1184
- ;
1185
- if (M === 0)
1186
- M = 1 - ne;
1187
- else {
1188
- if (M === Q)
1189
- return U ? NaN : (ye ? -1 : 1) * (1 / 0);
1190
- U = U + Math.pow(2, m), M = M - ne;
1191
- }
1192
- return (ye ? -1 : 1) * U * Math.pow(2, M - m);
1193
- }, K.write = function(B, R, d, m, A, M) {
1194
- var U, z, Q, ne = M * 8 - A - 1, S = (1 << ne) - 1, se = S >> 1, he = A === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, ye = m ? 0 : M - 1, Be = m ? 1 : -1, Re = R < 0 || R === 0 && 1 / R < 0 ? 1 : 0;
1195
- for (R = Math.abs(R), isNaN(R) || R === 1 / 0 ? (z = isNaN(R) ? 1 : 0, U = S) : (U = Math.floor(Math.log(R) / Math.LN2), R * (Q = Math.pow(2, -U)) < 1 && (U--, Q *= 2), U + se >= 1 ? R += he / Q : R += he * Math.pow(2, 1 - se), R * Q >= 2 && (U++, Q /= 2), U + se >= S ? (z = 0, U = S) : U + se >= 1 ? (z = (R * Q - 1) * Math.pow(2, A), U = U + se) : (z = R * Math.pow(2, se - 1) * Math.pow(2, A), U = 0)); A >= 8; B[d + ye] = z & 255, ye += Be, z /= 256, A -= 8)
1196
- ;
1197
- for (U = U << A | z, ne += A; ne > 0; B[d + ye] = U & 255, ye += Be, U /= 256, ne -= 8)
1198
- ;
1199
- B[d + ye - Be] |= Re * 128;
1200
- };
1201
- (function(B) {
1202
- const R = P, d = K, m = typeof Symbol == "function" && typeof Symbol.for == "function" ? /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom") : null;
1203
- B.Buffer = S, B.SlowBuffer = F, B.INSPECT_MAX_BYTES = 50;
1204
- const A = 2147483647;
1205
- B.kMaxLength = A;
1206
- const { Uint8Array: M, ArrayBuffer: U, SharedArrayBuffer: z } = globalThis;
1207
- S.TYPED_ARRAY_SUPPORT = Q(), !S.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error(
1208
- "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
1209
- );
1210
- function Q() {
1211
- try {
1212
- const o = new M(1), r = { foo: function() {
1213
- return 42;
1214
- } };
1215
- return Object.setPrototypeOf(r, M.prototype), Object.setPrototypeOf(o, r), o.foo() === 42;
1216
- } catch {
1217
- return !1;
1218
- }
1219
- }
1220
- Object.defineProperty(S.prototype, "parent", {
1221
- enumerable: !0,
1222
- get: function() {
1223
- if (S.isBuffer(this))
1224
- return this.buffer;
1225
- }
1226
- }), Object.defineProperty(S.prototype, "offset", {
1227
- enumerable: !0,
1228
- get: function() {
1229
- if (S.isBuffer(this))
1230
- return this.byteOffset;
1231
- }
1232
- });
1233
- function ne(o) {
1234
- if (o > A)
1235
- throw new RangeError('The value "' + o + '" is invalid for option "size"');
1236
- const r = new M(o);
1237
- return Object.setPrototypeOf(r, S.prototype), r;
1238
- }
1239
- function S(o, r, n) {
1240
- if (typeof o == "number") {
1241
- if (typeof r == "string")
1242
- throw new TypeError(
1243
- 'The "string" argument must be of type string. Received type number'
1244
- );
1245
- return Be(o);
1246
- }
1247
- return se(o, r, n);
1248
- }
1249
- S.poolSize = 8192;
1250
- function se(o, r, n) {
1251
- if (typeof o == "string")
1252
- return Re(o, r);
1253
- if (U.isView(o))
1254
- return Se(o);
1255
- if (o == null)
1256
- throw new TypeError(
1257
- "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof o
1258
- );
1259
- if (De(o, U) || o && De(o.buffer, U) || typeof z < "u" && (De(o, z) || o && De(o.buffer, z)))
1260
- return Te(o, r, n);
1261
- if (typeof o == "number")
1262
- throw new TypeError(
1263
- 'The "value" argument must not be of type number. Received type number'
1264
- );
1265
- const f = o.valueOf && o.valueOf();
1266
- if (f != null && f !== o)
1267
- return S.from(f, r, n);
1268
- const E = Le(o);
1269
- if (E) return E;
1270
- if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof o[Symbol.toPrimitive] == "function")
1271
- return S.from(o[Symbol.toPrimitive]("string"), r, n);
1272
- throw new TypeError(
1273
- "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof o
1274
- );
1275
- }
1276
- S.from = function(o, r, n) {
1277
- return se(o, r, n);
1278
- }, Object.setPrototypeOf(S.prototype, M.prototype), Object.setPrototypeOf(S, M);
1279
- function he(o) {
1280
- if (typeof o != "number")
1281
- throw new TypeError('"size" argument must be of type number');
1282
- if (o < 0)
1283
- throw new RangeError('The value "' + o + '" is invalid for option "size"');
1284
- }
1285
- function ye(o, r, n) {
1286
- return he(o), o <= 0 ? ne(o) : r !== void 0 ? typeof n == "string" ? ne(o).fill(r, n) : ne(o).fill(r) : ne(o);
1287
- }
1288
- S.alloc = function(o, r, n) {
1289
- return ye(o, r, n);
1290
- };
1291
- function Be(o) {
1292
- return he(o), ne(o < 0 ? 0 : I(o) | 0);
1293
- }
1294
- S.allocUnsafe = function(o) {
1295
- return Be(o);
1296
- }, S.allocUnsafeSlow = function(o) {
1297
- return Be(o);
1298
- };
1299
- function Re(o, r) {
1300
- if ((typeof r != "string" || r === "") && (r = "utf8"), !S.isEncoding(r))
1301
- throw new TypeError("Unknown encoding: " + r);
1302
- const n = q(o, r) | 0;
1303
- let f = ne(n);
1304
- const E = f.write(o, r);
1305
- return E !== n && (f = f.slice(0, E)), f;
1306
- }
1307
- function Ae(o) {
1308
- const r = o.length < 0 ? 0 : I(o.length) | 0, n = ne(r);
1309
- for (let f = 0; f < r; f += 1)
1310
- n[f] = o[f] & 255;
1311
- return n;
1312
- }
1313
- function Se(o) {
1314
- if (De(o, M)) {
1315
- const r = new M(o);
1316
- return Te(r.buffer, r.byteOffset, r.byteLength);
1317
- }
1318
- return Ae(o);
1319
- }
1320
- function Te(o, r, n) {
1321
- if (r < 0 || o.byteLength < r)
1322
- throw new RangeError('"offset" is outside of buffer bounds');
1323
- if (o.byteLength < r + (n || 0))
1324
- throw new RangeError('"length" is outside of buffer bounds');
1325
- let f;
1326
- return r === void 0 && n === void 0 ? f = new M(o) : n === void 0 ? f = new M(o, r) : f = new M(o, r, n), Object.setPrototypeOf(f, S.prototype), f;
1327
- }
1328
- function Le(o) {
1329
- if (S.isBuffer(o)) {
1330
- const r = I(o.length) | 0, n = ne(r);
1331
- return n.length === 0 || o.copy(n, 0, 0, r), n;
1332
- }
1333
- if (o.length !== void 0)
1334
- return typeof o.length != "number" || ur(o.length) ? ne(0) : Ae(o);
1335
- if (o.type === "Buffer" && Array.isArray(o.data))
1336
- return Ae(o.data);
1337
- }
1338
- function I(o) {
1339
- if (o >= A)
1340
- throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + A.toString(16) + " bytes");
1341
- return o | 0;
1342
- }
1343
- function F(o) {
1344
- return +o != o && (o = 0), S.alloc(+o);
1345
- }
1346
- S.isBuffer = function(r) {
1347
- return r != null && r._isBuffer === !0 && r !== S.prototype;
1348
- }, S.compare = function(r, n) {
1349
- if (De(r, M) && (r = S.from(r, r.offset, r.byteLength)), De(n, M) && (n = S.from(n, n.offset, n.byteLength)), !S.isBuffer(r) || !S.isBuffer(n))
1350
- throw new TypeError(
1351
- 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
1352
- );
1353
- if (r === n) return 0;
1354
- let f = r.length, E = n.length;
1355
- for (let L = 0, W = Math.min(f, E); L < W; ++L)
1356
- if (r[L] !== n[L]) {
1357
- f = r[L], E = n[L];
1358
- break;
1359
- }
1360
- return f < E ? -1 : E < f ? 1 : 0;
1361
- }, S.isEncoding = function(r) {
1362
- switch (String(r).toLowerCase()) {
1363
- case "hex":
1364
- case "utf8":
1365
- case "utf-8":
1366
- case "ascii":
1367
- case "latin1":
1368
- case "binary":
1369
- case "base64":
1370
- case "ucs2":
1371
- case "ucs-2":
1372
- case "utf16le":
1373
- case "utf-16le":
1374
- return !0;
1375
- default:
1376
- return !1;
1377
- }
1378
- }, S.concat = function(r, n) {
1379
- if (!Array.isArray(r))
1380
- throw new TypeError('"list" argument must be an Array of Buffers');
1381
- if (r.length === 0)
1382
- return S.alloc(0);
1383
- let f;
1384
- if (n === void 0)
1385
- for (n = 0, f = 0; f < r.length; ++f)
1386
- n += r[f].length;
1387
- const E = S.allocUnsafe(n);
1388
- let L = 0;
1389
- for (f = 0; f < r.length; ++f) {
1390
- let W = r[f];
1391
- if (De(W, M))
1392
- L + W.length > E.length ? (S.isBuffer(W) || (W = S.from(W)), W.copy(E, L)) : M.prototype.set.call(
1393
- E,
1394
- W,
1395
- L
1396
- );
1397
- else if (S.isBuffer(W))
1398
- W.copy(E, L);
1399
- else
1400
- throw new TypeError('"list" argument must be an Array of Buffers');
1401
- L += W.length;
1402
- }
1403
- return E;
1404
- };
1405
- function q(o, r) {
1406
- if (S.isBuffer(o))
1407
- return o.length;
1408
- if (U.isView(o) || De(o, U))
1409
- return o.byteLength;
1410
- if (typeof o != "string")
1411
- throw new TypeError(
1412
- 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof o
1413
- );
1414
- const n = o.length, f = arguments.length > 2 && arguments[2] === !0;
1415
- if (!f && n === 0) return 0;
1416
- let E = !1;
1417
- for (; ; )
1418
- switch (r) {
1419
- case "ascii":
1420
- case "latin1":
1421
- case "binary":
1422
- return n;
1423
- case "utf8":
1424
- case "utf-8":
1425
- return pe(o).length;
1426
- case "ucs2":
1427
- case "ucs-2":
1428
- case "utf16le":
1429
- case "utf-16le":
1430
- return n * 2;
1431
- case "hex":
1432
- return n >>> 1;
1433
- case "base64":
1434
- return le(o).length;
1435
- default:
1436
- if (E)
1437
- return f ? -1 : pe(o).length;
1438
- r = ("" + r).toLowerCase(), E = !0;
1439
- }
1440
- }
1441
- S.byteLength = q;
1442
- function re(o, r, n) {
1443
- let f = !1;
1444
- if ((r === void 0 || r < 0) && (r = 0), r > this.length || ((n === void 0 || n > this.length) && (n = this.length), n <= 0) || (n >>>= 0, r >>>= 0, n <= r))
1445
- return "";
1446
- for (o || (o = "utf8"); ; )
1447
- switch (o) {
1448
- case "hex":
1449
- return je(this, r, n);
1450
- case "utf8":
1451
- case "utf-8":
1452
- return fe(this, r, n);
1453
- case "ascii":
1454
- return Me(this, r, n);
1455
- case "latin1":
1456
- case "binary":
1457
- return G(this, r, n);
1458
- case "base64":
1459
- return $(this, r, n);
1460
- case "ucs2":
1461
- case "ucs-2":
1462
- case "utf16le":
1463
- case "utf-16le":
1464
- return Ke(this, r, n);
1465
- default:
1466
- if (f) throw new TypeError("Unknown encoding: " + o);
1467
- o = (o + "").toLowerCase(), f = !0;
1468
- }
1469
- }
1470
- S.prototype._isBuffer = !0;
1471
- function b(o, r, n) {
1472
- const f = o[r];
1473
- o[r] = o[n], o[n] = f;
1474
- }
1475
- S.prototype.swap16 = function() {
1476
- const r = this.length;
1477
- if (r % 2 !== 0)
1478
- throw new RangeError("Buffer size must be a multiple of 16-bits");
1479
- for (let n = 0; n < r; n += 2)
1480
- b(this, n, n + 1);
1481
- return this;
1482
- }, S.prototype.swap32 = function() {
1483
- const r = this.length;
1484
- if (r % 4 !== 0)
1485
- throw new RangeError("Buffer size must be a multiple of 32-bits");
1486
- for (let n = 0; n < r; n += 4)
1487
- b(this, n, n + 3), b(this, n + 1, n + 2);
1488
- return this;
1489
- }, S.prototype.swap64 = function() {
1490
- const r = this.length;
1491
- if (r % 8 !== 0)
1492
- throw new RangeError("Buffer size must be a multiple of 64-bits");
1493
- for (let n = 0; n < r; n += 8)
1494
- b(this, n, n + 7), b(this, n + 1, n + 6), b(this, n + 2, n + 5), b(this, n + 3, n + 4);
1495
- return this;
1496
- }, S.prototype.toString = function() {
1497
- const r = this.length;
1498
- return r === 0 ? "" : arguments.length === 0 ? fe(this, 0, r) : re.apply(this, arguments);
1499
- }, S.prototype.toLocaleString = S.prototype.toString, S.prototype.equals = function(r) {
1500
- if (!S.isBuffer(r)) throw new TypeError("Argument must be a Buffer");
1501
- return this === r ? !0 : S.compare(this, r) === 0;
1502
- }, S.prototype.inspect = function() {
1503
- let r = "";
1504
- const n = B.INSPECT_MAX_BYTES;
1505
- return r = this.toString("hex", 0, n).replace(/(.{2})/g, "$1 ").trim(), this.length > n && (r += " ... "), "<Buffer " + r + ">";
1506
- }, m && (S.prototype[m] = S.prototype.inspect), S.prototype.compare = function(r, n, f, E, L) {
1507
- if (De(r, M) && (r = S.from(r, r.offset, r.byteLength)), !S.isBuffer(r))
1508
- throw new TypeError(
1509
- 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof r
1510
- );
1511
- if (n === void 0 && (n = 0), f === void 0 && (f = r ? r.length : 0), E === void 0 && (E = 0), L === void 0 && (L = this.length), n < 0 || f > r.length || E < 0 || L > this.length)
1512
- throw new RangeError("out of range index");
1513
- if (E >= L && n >= f)
1514
- return 0;
1515
- if (E >= L)
1516
- return -1;
1517
- if (n >= f)
1518
- return 1;
1519
- if (n >>>= 0, f >>>= 0, E >>>= 0, L >>>= 0, this === r) return 0;
1520
- let W = L - E, oe = f - n;
1521
- const Ee = Math.min(W, oe), we = this.slice(E, L), be = r.slice(n, f);
1522
- for (let ce = 0; ce < Ee; ++ce)
1523
- if (we[ce] !== be[ce]) {
1524
- W = we[ce], oe = be[ce];
1525
- break;
1526
- }
1527
- return W < oe ? -1 : oe < W ? 1 : 0;
1528
- };
1529
- function _(o, r, n, f, E) {
1530
- if (o.length === 0) return -1;
1531
- if (typeof n == "string" ? (f = n, n = 0) : n > 2147483647 ? n = 2147483647 : n < -2147483648 && (n = -2147483648), n = +n, ur(n) && (n = E ? 0 : o.length - 1), n < 0 && (n = o.length + n), n >= o.length) {
1532
- if (E) return -1;
1533
- n = o.length - 1;
1534
- } else if (n < 0)
1535
- if (E) n = 0;
1536
- else return -1;
1537
- if (typeof r == "string" && (r = S.from(r, f)), S.isBuffer(r))
1538
- return r.length === 0 ? -1 : C(o, r, n, f, E);
1539
- if (typeof r == "number")
1540
- return r = r & 255, typeof M.prototype.indexOf == "function" ? E ? M.prototype.indexOf.call(o, r, n) : M.prototype.lastIndexOf.call(o, r, n) : C(o, [r], n, f, E);
1541
- throw new TypeError("val must be string, number or Buffer");
1542
- }
1543
- function C(o, r, n, f, E) {
1544
- let L = 1, W = o.length, oe = r.length;
1545
- if (f !== void 0 && (f = String(f).toLowerCase(), f === "ucs2" || f === "ucs-2" || f === "utf16le" || f === "utf-16le")) {
1546
- if (o.length < 2 || r.length < 2)
1547
- return -1;
1548
- L = 2, W /= 2, oe /= 2, n /= 2;
1549
- }
1550
- function Ee(be, ce) {
1551
- return L === 1 ? be[ce] : be.readUInt16BE(ce * L);
1552
- }
1553
- let we;
1554
- if (E) {
1555
- let be = -1;
1556
- for (we = n; we < W; we++)
1557
- if (Ee(o, we) === Ee(r, be === -1 ? 0 : we - be)) {
1558
- if (be === -1 && (be = we), we - be + 1 === oe) return be * L;
1559
- } else
1560
- be !== -1 && (we -= we - be), be = -1;
1561
- } else
1562
- for (n + oe > W && (n = W - oe), we = n; we >= 0; we--) {
1563
- let be = !0;
1564
- for (let ce = 0; ce < oe; ce++)
1565
- if (Ee(o, we + ce) !== Ee(r, ce)) {
1566
- be = !1;
1567
- break;
1568
- }
1569
- if (be) return we;
1570
- }
1571
- return -1;
1572
- }
1573
- S.prototype.includes = function(r, n, f) {
1574
- return this.indexOf(r, n, f) !== -1;
1575
- }, S.prototype.indexOf = function(r, n, f) {
1576
- return _(this, r, n, f, !0);
1577
- }, S.prototype.lastIndexOf = function(r, n, f) {
1578
- return _(this, r, n, f, !1);
1579
- };
1580
- function Z(o, r, n, f) {
1581
- n = Number(n) || 0;
1582
- const E = o.length - n;
1583
- f ? (f = Number(f), f > E && (f = E)) : f = E;
1584
- const L = r.length;
1585
- f > L / 2 && (f = L / 2);
1586
- let W;
1587
- for (W = 0; W < f; ++W) {
1588
- const oe = parseInt(r.substr(W * 2, 2), 16);
1589
- if (ur(oe)) return W;
1590
- o[n + W] = oe;
1591
- }
1592
- return W;
1593
- }
1594
- function ee(o, r, n, f) {
1595
- return Qe(pe(r, o.length - n), o, n, f);
1596
- }
1597
- function u(o, r, n, f) {
1598
- return Qe(de(r), o, n, f);
1599
- }
1600
- function s(o, r, n, f) {
1601
- return Qe(le(r), o, n, f);
1602
- }
1603
- function H(o, r, n, f) {
1604
- return Qe(ge(r, o.length - n), o, n, f);
1605
- }
1606
- S.prototype.write = function(r, n, f, E) {
1607
- if (n === void 0)
1608
- E = "utf8", f = this.length, n = 0;
1609
- else if (f === void 0 && typeof n == "string")
1610
- E = n, f = this.length, n = 0;
1611
- else if (isFinite(n))
1612
- n = n >>> 0, isFinite(f) ? (f = f >>> 0, E === void 0 && (E = "utf8")) : (E = f, f = void 0);
1613
- else
1614
- throw new Error(
1615
- "Buffer.write(string, encoding, offset[, length]) is no longer supported"
1616
- );
1617
- const L = this.length - n;
1618
- if ((f === void 0 || f > L) && (f = L), r.length > 0 && (f < 0 || n < 0) || n > this.length)
1619
- throw new RangeError("Attempt to write outside buffer bounds");
1620
- E || (E = "utf8");
1621
- let W = !1;
1622
- for (; ; )
1623
- switch (E) {
1624
- case "hex":
1625
- return Z(this, r, n, f);
1626
- case "utf8":
1627
- case "utf-8":
1628
- return ee(this, r, n, f);
1629
- case "ascii":
1630
- case "latin1":
1631
- case "binary":
1632
- return u(this, r, n, f);
1633
- case "base64":
1634
- return s(this, r, n, f);
1635
- case "ucs2":
1636
- case "ucs-2":
1637
- case "utf16le":
1638
- case "utf-16le":
1639
- return H(this, r, n, f);
1640
- default:
1641
- if (W) throw new TypeError("Unknown encoding: " + E);
1642
- E = ("" + E).toLowerCase(), W = !0;
1643
- }
1644
- }, S.prototype.toJSON = function() {
1645
- return {
1646
- type: "Buffer",
1647
- data: Array.prototype.slice.call(this._arr || this, 0)
1648
- };
1649
- };
1650
- function $(o, r, n) {
1651
- return r === 0 && n === o.length ? R.fromByteArray(o) : R.fromByteArray(o.slice(r, n));
1652
- }
1653
- function fe(o, r, n) {
1654
- n = Math.min(o.length, n);
1655
- const f = [];
1656
- let E = r;
1657
- for (; E < n; ) {
1658
- const L = o[E];
1659
- let W = null, oe = L > 239 ? 4 : L > 223 ? 3 : L > 191 ? 2 : 1;
1660
- if (E + oe <= n) {
1661
- let Ee, we, be, ce;
1662
- switch (oe) {
1663
- case 1:
1664
- L < 128 && (W = L);
1665
- break;
1666
- case 2:
1667
- Ee = o[E + 1], (Ee & 192) === 128 && (ce = (L & 31) << 6 | Ee & 63, ce > 127 && (W = ce));
1668
- break;
1669
- case 3:
1670
- Ee = o[E + 1], we = o[E + 2], (Ee & 192) === 128 && (we & 192) === 128 && (ce = (L & 15) << 12 | (Ee & 63) << 6 | we & 63, ce > 2047 && (ce < 55296 || ce > 57343) && (W = ce));
1671
- break;
1672
- case 4:
1673
- Ee = o[E + 1], we = o[E + 2], be = o[E + 3], (Ee & 192) === 128 && (we & 192) === 128 && (be & 192) === 128 && (ce = (L & 15) << 18 | (Ee & 63) << 12 | (we & 63) << 6 | be & 63, ce > 65535 && ce < 1114112 && (W = ce));
1674
- }
1675
- }
1676
- W === null ? (W = 65533, oe = 1) : W > 65535 && (W -= 65536, f.push(W >>> 10 & 1023 | 55296), W = 56320 | W & 1023), f.push(W), E += oe;
1677
- }
1678
- return ae(f);
1679
- }
1680
- const te = 4096;
1681
- function ae(o) {
1682
- const r = o.length;
1683
- if (r <= te)
1684
- return String.fromCharCode.apply(String, o);
1685
- let n = "", f = 0;
1686
- for (; f < r; )
1687
- n += String.fromCharCode.apply(
1688
- String,
1689
- o.slice(f, f += te)
1690
- );
1691
- return n;
1692
- }
1693
- function Me(o, r, n) {
1694
- let f = "";
1695
- n = Math.min(o.length, n);
1696
- for (let E = r; E < n; ++E)
1697
- f += String.fromCharCode(o[E] & 127);
1698
- return f;
1699
- }
1700
- function G(o, r, n) {
1701
- let f = "";
1702
- n = Math.min(o.length, n);
1703
- for (let E = r; E < n; ++E)
1704
- f += String.fromCharCode(o[E]);
1705
- return f;
1706
- }
1707
- function je(o, r, n) {
1708
- const f = o.length;
1709
- (!r || r < 0) && (r = 0), (!n || n < 0 || n > f) && (n = f);
1710
- let E = "";
1711
- for (let L = r; L < n; ++L)
1712
- E += Rt[o[L]];
1713
- return E;
1714
- }
1715
- function Ke(o, r, n) {
1716
- const f = o.slice(r, n);
1717
- let E = "";
1718
- for (let L = 0; L < f.length - 1; L += 2)
1719
- E += String.fromCharCode(f[L] + f[L + 1] * 256);
1720
- return E;
1721
- }
1722
- S.prototype.slice = function(r, n) {
1723
- const f = this.length;
1724
- r = ~~r, n = n === void 0 ? f : ~~n, r < 0 ? (r += f, r < 0 && (r = 0)) : r > f && (r = f), n < 0 ? (n += f, n < 0 && (n = 0)) : n > f && (n = f), n < r && (n = r);
1725
- const E = this.subarray(r, n);
1726
- return Object.setPrototypeOf(E, S.prototype), E;
1727
- };
1728
- function me(o, r, n) {
1729
- if (o % 1 !== 0 || o < 0) throw new RangeError("offset is not uint");
1730
- if (o + r > n) throw new RangeError("Trying to access beyond buffer length");
1731
- }
1732
- S.prototype.readUintLE = S.prototype.readUIntLE = function(r, n, f) {
1733
- r = r >>> 0, n = n >>> 0, f || me(r, n, this.length);
1734
- let E = this[r], L = 1, W = 0;
1735
- for (; ++W < n && (L *= 256); )
1736
- E += this[r + W] * L;
1737
- return E;
1738
- }, S.prototype.readUintBE = S.prototype.readUIntBE = function(r, n, f) {
1739
- r = r >>> 0, n = n >>> 0, f || me(r, n, this.length);
1740
- let E = this[r + --n], L = 1;
1741
- for (; n > 0 && (L *= 256); )
1742
- E += this[r + --n] * L;
1743
- return E;
1744
- }, S.prototype.readUint8 = S.prototype.readUInt8 = function(r, n) {
1745
- return r = r >>> 0, n || me(r, 1, this.length), this[r];
1746
- }, S.prototype.readUint16LE = S.prototype.readUInt16LE = function(r, n) {
1747
- return r = r >>> 0, n || me(r, 2, this.length), this[r] | this[r + 1] << 8;
1748
- }, S.prototype.readUint16BE = S.prototype.readUInt16BE = function(r, n) {
1749
- return r = r >>> 0, n || me(r, 2, this.length), this[r] << 8 | this[r + 1];
1750
- }, S.prototype.readUint32LE = S.prototype.readUInt32LE = function(r, n) {
1751
- return r = r >>> 0, n || me(r, 4, this.length), (this[r] | this[r + 1] << 8 | this[r + 2] << 16) + this[r + 3] * 16777216;
1752
- }, S.prototype.readUint32BE = S.prototype.readUInt32BE = function(r, n) {
1753
- return r = r >>> 0, n || me(r, 4, this.length), this[r] * 16777216 + (this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3]);
1754
- }, S.prototype.readBigUInt64LE = He(function(r) {
1755
- r = r >>> 0, g(r, "offset");
1756
- const n = this[r], f = this[r + 7];
1757
- (n === void 0 || f === void 0) && T(r, this.length - 8);
1758
- const E = n + this[++r] * 2 ** 8 + this[++r] * 2 ** 16 + this[++r] * 2 ** 24, L = this[++r] + this[++r] * 2 ** 8 + this[++r] * 2 ** 16 + f * 2 ** 24;
1759
- return BigInt(E) + (BigInt(L) << BigInt(32));
1760
- }), S.prototype.readBigUInt64BE = He(function(r) {
1761
- r = r >>> 0, g(r, "offset");
1762
- const n = this[r], f = this[r + 7];
1763
- (n === void 0 || f === void 0) && T(r, this.length - 8);
1764
- const E = n * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + this[++r], L = this[++r] * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + f;
1765
- return (BigInt(E) << BigInt(32)) + BigInt(L);
1766
- }), S.prototype.readIntLE = function(r, n, f) {
1767
- r = r >>> 0, n = n >>> 0, f || me(r, n, this.length);
1768
- let E = this[r], L = 1, W = 0;
1769
- for (; ++W < n && (L *= 256); )
1770
- E += this[r + W] * L;
1771
- return L *= 128, E >= L && (E -= Math.pow(2, 8 * n)), E;
1772
- }, S.prototype.readIntBE = function(r, n, f) {
1773
- r = r >>> 0, n = n >>> 0, f || me(r, n, this.length);
1774
- let E = n, L = 1, W = this[r + --E];
1775
- for (; E > 0 && (L *= 256); )
1776
- W += this[r + --E] * L;
1777
- return L *= 128, W >= L && (W -= Math.pow(2, 8 * n)), W;
1778
- }, S.prototype.readInt8 = function(r, n) {
1779
- return r = r >>> 0, n || me(r, 1, this.length), this[r] & 128 ? (255 - this[r] + 1) * -1 : this[r];
1780
- }, S.prototype.readInt16LE = function(r, n) {
1781
- r = r >>> 0, n || me(r, 2, this.length);
1782
- const f = this[r] | this[r + 1] << 8;
1783
- return f & 32768 ? f | 4294901760 : f;
1784
- }, S.prototype.readInt16BE = function(r, n) {
1785
- r = r >>> 0, n || me(r, 2, this.length);
1786
- const f = this[r + 1] | this[r] << 8;
1787
- return f & 32768 ? f | 4294901760 : f;
1788
- }, S.prototype.readInt32LE = function(r, n) {
1789
- return r = r >>> 0, n || me(r, 4, this.length), this[r] | this[r + 1] << 8 | this[r + 2] << 16 | this[r + 3] << 24;
1790
- }, S.prototype.readInt32BE = function(r, n) {
1791
- return r = r >>> 0, n || me(r, 4, this.length), this[r] << 24 | this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3];
1792
- }, S.prototype.readBigInt64LE = He(function(r) {
1793
- r = r >>> 0, g(r, "offset");
1794
- const n = this[r], f = this[r + 7];
1795
- (n === void 0 || f === void 0) && T(r, this.length - 8);
1796
- const E = this[r + 4] + this[r + 5] * 2 ** 8 + this[r + 6] * 2 ** 16 + (f << 24);
1797
- return (BigInt(E) << BigInt(32)) + BigInt(n + this[++r] * 2 ** 8 + this[++r] * 2 ** 16 + this[++r] * 2 ** 24);
1798
- }), S.prototype.readBigInt64BE = He(function(r) {
1799
- r = r >>> 0, g(r, "offset");
1800
- const n = this[r], f = this[r + 7];
1801
- (n === void 0 || f === void 0) && T(r, this.length - 8);
1802
- const E = (n << 24) + // Overflow
1803
- this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + this[++r];
1804
- return (BigInt(E) << BigInt(32)) + BigInt(this[++r] * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + f);
1805
- }), S.prototype.readFloatLE = function(r, n) {
1806
- return r = r >>> 0, n || me(r, 4, this.length), d.read(this, r, !0, 23, 4);
1807
- }, S.prototype.readFloatBE = function(r, n) {
1808
- return r = r >>> 0, n || me(r, 4, this.length), d.read(this, r, !1, 23, 4);
1809
- }, S.prototype.readDoubleLE = function(r, n) {
1810
- return r = r >>> 0, n || me(r, 8, this.length), d.read(this, r, !0, 52, 8);
1811
- }, S.prototype.readDoubleBE = function(r, n) {
1812
- return r = r >>> 0, n || me(r, 8, this.length), d.read(this, r, !1, 52, 8);
1813
- };
1814
- function _e(o, r, n, f, E, L) {
1815
- if (!S.isBuffer(o)) throw new TypeError('"buffer" argument must be a Buffer instance');
1816
- if (r > E || r < L) throw new RangeError('"value" argument is out of bounds');
1817
- if (n + f > o.length) throw new RangeError("Index out of range");
1818
- }
1819
- S.prototype.writeUintLE = S.prototype.writeUIntLE = function(r, n, f, E) {
1820
- if (r = +r, n = n >>> 0, f = f >>> 0, !E) {
1821
- const oe = Math.pow(2, 8 * f) - 1;
1822
- _e(this, r, n, f, oe, 0);
1823
- }
1824
- let L = 1, W = 0;
1825
- for (this[n] = r & 255; ++W < f && (L *= 256); )
1826
- this[n + W] = r / L & 255;
1827
- return n + f;
1828
- }, S.prototype.writeUintBE = S.prototype.writeUIntBE = function(r, n, f, E) {
1829
- if (r = +r, n = n >>> 0, f = f >>> 0, !E) {
1830
- const oe = Math.pow(2, 8 * f) - 1;
1831
- _e(this, r, n, f, oe, 0);
1832
- }
1833
- let L = f - 1, W = 1;
1834
- for (this[n + L] = r & 255; --L >= 0 && (W *= 256); )
1835
- this[n + L] = r / W & 255;
1836
- return n + f;
1837
- }, S.prototype.writeUint8 = S.prototype.writeUInt8 = function(r, n, f) {
1838
- return r = +r, n = n >>> 0, f || _e(this, r, n, 1, 255, 0), this[n] = r & 255, n + 1;
1839
- }, S.prototype.writeUint16LE = S.prototype.writeUInt16LE = function(r, n, f) {
1840
- return r = +r, n = n >>> 0, f || _e(this, r, n, 2, 65535, 0), this[n] = r & 255, this[n + 1] = r >>> 8, n + 2;
1841
- }, S.prototype.writeUint16BE = S.prototype.writeUInt16BE = function(r, n, f) {
1842
- return r = +r, n = n >>> 0, f || _e(this, r, n, 2, 65535, 0), this[n] = r >>> 8, this[n + 1] = r & 255, n + 2;
1843
- }, S.prototype.writeUint32LE = S.prototype.writeUInt32LE = function(r, n, f) {
1844
- return r = +r, n = n >>> 0, f || _e(this, r, n, 4, 4294967295, 0), this[n + 3] = r >>> 24, this[n + 2] = r >>> 16, this[n + 1] = r >>> 8, this[n] = r & 255, n + 4;
1845
- }, S.prototype.writeUint32BE = S.prototype.writeUInt32BE = function(r, n, f) {
1846
- return r = +r, n = n >>> 0, f || _e(this, r, n, 4, 4294967295, 0), this[n] = r >>> 24, this[n + 1] = r >>> 16, this[n + 2] = r >>> 8, this[n + 3] = r & 255, n + 4;
1847
- };
1848
- function Pe(o, r, n, f, E) {
1849
- a(r, f, E, o, n, 7);
1850
- let L = Number(r & BigInt(4294967295));
1851
- o[n++] = L, L = L >> 8, o[n++] = L, L = L >> 8, o[n++] = L, L = L >> 8, o[n++] = L;
1852
- let W = Number(r >> BigInt(32) & BigInt(4294967295));
1853
- return o[n++] = W, W = W >> 8, o[n++] = W, W = W >> 8, o[n++] = W, W = W >> 8, o[n++] = W, n;
1854
- }
1855
- function Oe(o, r, n, f, E) {
1856
- a(r, f, E, o, n, 7);
1857
- let L = Number(r & BigInt(4294967295));
1858
- o[n + 7] = L, L = L >> 8, o[n + 6] = L, L = L >> 8, o[n + 5] = L, L = L >> 8, o[n + 4] = L;
1859
- let W = Number(r >> BigInt(32) & BigInt(4294967295));
1860
- return o[n + 3] = W, W = W >> 8, o[n + 2] = W, W = W >> 8, o[n + 1] = W, W = W >> 8, o[n] = W, n + 8;
1861
- }
1862
- S.prototype.writeBigUInt64LE = He(function(r, n = 0) {
1863
- return Pe(this, r, n, BigInt(0), BigInt("0xffffffffffffffff"));
1864
- }), S.prototype.writeBigUInt64BE = He(function(r, n = 0) {
1865
- return Oe(this, r, n, BigInt(0), BigInt("0xffffffffffffffff"));
1866
- }), S.prototype.writeIntLE = function(r, n, f, E) {
1867
- if (r = +r, n = n >>> 0, !E) {
1868
- const Ee = Math.pow(2, 8 * f - 1);
1869
- _e(this, r, n, f, Ee - 1, -Ee);
1870
- }
1871
- let L = 0, W = 1, oe = 0;
1872
- for (this[n] = r & 255; ++L < f && (W *= 256); )
1873
- r < 0 && oe === 0 && this[n + L - 1] !== 0 && (oe = 1), this[n + L] = (r / W >> 0) - oe & 255;
1874
- return n + f;
1875
- }, S.prototype.writeIntBE = function(r, n, f, E) {
1876
- if (r = +r, n = n >>> 0, !E) {
1877
- const Ee = Math.pow(2, 8 * f - 1);
1878
- _e(this, r, n, f, Ee - 1, -Ee);
1879
- }
1880
- let L = f - 1, W = 1, oe = 0;
1881
- for (this[n + L] = r & 255; --L >= 0 && (W *= 256); )
1882
- r < 0 && oe === 0 && this[n + L + 1] !== 0 && (oe = 1), this[n + L] = (r / W >> 0) - oe & 255;
1883
- return n + f;
1884
- }, S.prototype.writeInt8 = function(r, n, f) {
1885
- return r = +r, n = n >>> 0, f || _e(this, r, n, 1, 127, -128), r < 0 && (r = 255 + r + 1), this[n] = r & 255, n + 1;
1886
- }, S.prototype.writeInt16LE = function(r, n, f) {
1887
- return r = +r, n = n >>> 0, f || _e(this, r, n, 2, 32767, -32768), this[n] = r & 255, this[n + 1] = r >>> 8, n + 2;
1888
- }, S.prototype.writeInt16BE = function(r, n, f) {
1889
- return r = +r, n = n >>> 0, f || _e(this, r, n, 2, 32767, -32768), this[n] = r >>> 8, this[n + 1] = r & 255, n + 2;
1890
- }, S.prototype.writeInt32LE = function(r, n, f) {
1891
- return r = +r, n = n >>> 0, f || _e(this, r, n, 4, 2147483647, -2147483648), this[n] = r & 255, this[n + 1] = r >>> 8, this[n + 2] = r >>> 16, this[n + 3] = r >>> 24, n + 4;
1892
- }, S.prototype.writeInt32BE = function(r, n, f) {
1893
- return r = +r, n = n >>> 0, f || _e(this, r, n, 4, 2147483647, -2147483648), r < 0 && (r = 4294967295 + r + 1), this[n] = r >>> 24, this[n + 1] = r >>> 16, this[n + 2] = r >>> 8, this[n + 3] = r & 255, n + 4;
1894
- }, S.prototype.writeBigInt64LE = He(function(r, n = 0) {
1895
- return Pe(this, r, n, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
1896
- }), S.prototype.writeBigInt64BE = He(function(r, n = 0) {
1897
- return Oe(this, r, n, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
1898
- });
1899
- function Ue(o, r, n, f, E, L) {
1900
- if (n + f > o.length) throw new RangeError("Index out of range");
1901
- if (n < 0) throw new RangeError("Index out of range");
1902
- }
1903
- function Ce(o, r, n, f, E) {
1904
- return r = +r, n = n >>> 0, E || Ue(o, r, n, 4), d.write(o, r, n, f, 23, 4), n + 4;
1905
- }
1906
- S.prototype.writeFloatLE = function(r, n, f) {
1907
- return Ce(this, r, n, !0, f);
1908
- }, S.prototype.writeFloatBE = function(r, n, f) {
1909
- return Ce(this, r, n, !1, f);
1910
- };
1911
- function Ie(o, r, n, f, E) {
1912
- return r = +r, n = n >>> 0, E || Ue(o, r, n, 8), d.write(o, r, n, f, 52, 8), n + 8;
1913
- }
1914
- S.prototype.writeDoubleLE = function(r, n, f) {
1915
- return Ie(this, r, n, !0, f);
1916
- }, S.prototype.writeDoubleBE = function(r, n, f) {
1917
- return Ie(this, r, n, !1, f);
1918
- }, S.prototype.copy = function(r, n, f, E) {
1919
- if (!S.isBuffer(r)) throw new TypeError("argument should be a Buffer");
1920
- if (f || (f = 0), !E && E !== 0 && (E = this.length), n >= r.length && (n = r.length), n || (n = 0), E > 0 && E < f && (E = f), E === f || r.length === 0 || this.length === 0) return 0;
1921
- if (n < 0)
1922
- throw new RangeError("targetStart out of bounds");
1923
- if (f < 0 || f >= this.length) throw new RangeError("Index out of range");
1924
- if (E < 0) throw new RangeError("sourceEnd out of bounds");
1925
- E > this.length && (E = this.length), r.length - n < E - f && (E = r.length - n + f);
1926
- const L = E - f;
1927
- return this === r && typeof M.prototype.copyWithin == "function" ? this.copyWithin(n, f, E) : M.prototype.set.call(
1928
- r,
1929
- this.subarray(f, E),
1930
- n
1931
- ), L;
1932
- }, S.prototype.fill = function(r, n, f, E) {
1933
- if (typeof r == "string") {
1934
- if (typeof n == "string" ? (E = n, n = 0, f = this.length) : typeof f == "string" && (E = f, f = this.length), E !== void 0 && typeof E != "string")
1935
- throw new TypeError("encoding must be a string");
1936
- if (typeof E == "string" && !S.isEncoding(E))
1937
- throw new TypeError("Unknown encoding: " + E);
1938
- if (r.length === 1) {
1939
- const W = r.charCodeAt(0);
1940
- (E === "utf8" && W < 128 || E === "latin1") && (r = W);
1941
- }
1942
- } else typeof r == "number" ? r = r & 255 : typeof r == "boolean" && (r = Number(r));
1943
- if (n < 0 || this.length < n || this.length < f)
1944
- throw new RangeError("Out of range index");
1945
- if (f <= n)
1946
- return this;
1947
- n = n >>> 0, f = f === void 0 ? this.length : f >>> 0, r || (r = 0);
1948
- let L;
1949
- if (typeof r == "number")
1950
- for (L = n; L < f; ++L)
1951
- this[L] = r;
1952
- else {
1953
- const W = S.isBuffer(r) ? r : S.from(r, E), oe = W.length;
1954
- if (oe === 0)
1955
- throw new TypeError('The value "' + r + '" is invalid for argument "value"');
1956
- for (L = 0; L < f - n; ++L)
1957
- this[L + n] = W[L % oe];
1958
- }
1959
- return this;
1960
- };
1961
- const Ge = {};
1962
- function i(o, r, n) {
1963
- Ge[o] = class extends n {
1964
- constructor() {
1965
- super(), Object.defineProperty(this, "message", {
1966
- value: r.apply(this, arguments),
1967
- writable: !0,
1968
- configurable: !0
1969
- }), this.name = `${this.name} [${o}]`, this.stack, delete this.name;
1970
- }
1971
- get code() {
1972
- return o;
1973
- }
1974
- set code(E) {
1975
- Object.defineProperty(this, "code", {
1976
- configurable: !0,
1977
- enumerable: !0,
1978
- value: E,
1979
- writable: !0
1980
- });
1981
- }
1982
- toString() {
1983
- return `${this.name} [${o}]: ${this.message}`;
1984
- }
1985
- };
1986
- }
1987
- i(
1988
- "ERR_BUFFER_OUT_OF_BOUNDS",
1989
- function(o) {
1990
- return o ? `${o} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
1991
- },
1992
- RangeError
1993
- ), i(
1994
- "ERR_INVALID_ARG_TYPE",
1995
- function(o, r) {
1996
- return `The "${o}" argument must be of type number. Received type ${typeof r}`;
1997
- },
1998
- TypeError
1999
- ), i(
2000
- "ERR_OUT_OF_RANGE",
2001
- function(o, r, n) {
2002
- let f = `The value of "${o}" is out of range.`, E = n;
2003
- return Number.isInteger(n) && Math.abs(n) > 2 ** 32 ? E = e(String(n)) : typeof n == "bigint" && (E = String(n), (n > BigInt(2) ** BigInt(32) || n < -(BigInt(2) ** BigInt(32))) && (E = e(E)), E += "n"), f += ` It must be ${r}. Received ${E}`, f;
2004
- },
2005
- RangeError
2006
- );
2007
- function e(o) {
2008
- let r = "", n = o.length;
2009
- const f = o[0] === "-" ? 1 : 0;
2010
- for (; n >= f + 4; n -= 3)
2011
- r = `_${o.slice(n - 3, n)}${r}`;
2012
- return `${o.slice(0, n)}${r}`;
2013
- }
2014
- function t(o, r, n) {
2015
- g(r, "offset"), (o[r] === void 0 || o[r + n] === void 0) && T(r, o.length - (n + 1));
2016
- }
2017
- function a(o, r, n, f, E, L) {
2018
- if (o > n || o < r) {
2019
- const W = typeof r == "bigint" ? "n" : "";
2020
- let oe;
2021
- throw r === 0 || r === BigInt(0) ? oe = `>= 0${W} and < 2${W} ** ${(L + 1) * 8}${W}` : oe = `>= -(2${W} ** ${(L + 1) * 8 - 1}${W}) and < 2 ** ${(L + 1) * 8 - 1}${W}`, new Ge.ERR_OUT_OF_RANGE("value", oe, o);
2022
- }
2023
- t(f, E, L);
2024
- }
2025
- function g(o, r) {
2026
- if (typeof o != "number")
2027
- throw new Ge.ERR_INVALID_ARG_TYPE(r, "number", o);
2028
- }
2029
- function T(o, r, n) {
2030
- throw Math.floor(o) !== o ? (g(o, n), new Ge.ERR_OUT_OF_RANGE("offset", "an integer", o)) : r < 0 ? new Ge.ERR_BUFFER_OUT_OF_BOUNDS() : new Ge.ERR_OUT_OF_RANGE(
2031
- "offset",
2032
- `>= 0 and <= ${r}`,
2033
- o
2034
- );
2035
- }
2036
- const x = /[^+/0-9A-Za-z-_]/g;
2037
- function ie(o) {
2038
- if (o = o.split("=")[0], o = o.trim().replace(x, ""), o.length < 2) return "";
2039
- for (; o.length % 4 !== 0; )
2040
- o = o + "=";
2041
- return o;
2042
- }
2043
- function pe(o, r) {
2044
- r = r || 1 / 0;
2045
- let n;
2046
- const f = o.length;
2047
- let E = null;
2048
- const L = [];
2049
- for (let W = 0; W < f; ++W) {
2050
- if (n = o.charCodeAt(W), n > 55295 && n < 57344) {
2051
- if (!E) {
2052
- if (n > 56319) {
2053
- (r -= 3) > -1 && L.push(239, 191, 189);
2054
- continue;
2055
- } else if (W + 1 === f) {
2056
- (r -= 3) > -1 && L.push(239, 191, 189);
2057
- continue;
2058
- }
2059
- E = n;
2060
- continue;
2061
- }
2062
- if (n < 56320) {
2063
- (r -= 3) > -1 && L.push(239, 191, 189), E = n;
2064
- continue;
2065
- }
2066
- n = (E - 55296 << 10 | n - 56320) + 65536;
2067
- } else E && (r -= 3) > -1 && L.push(239, 191, 189);
2068
- if (E = null, n < 128) {
2069
- if ((r -= 1) < 0) break;
2070
- L.push(n);
2071
- } else if (n < 2048) {
2072
- if ((r -= 2) < 0) break;
2073
- L.push(
2074
- n >> 6 | 192,
2075
- n & 63 | 128
2076
- );
2077
- } else if (n < 65536) {
2078
- if ((r -= 3) < 0) break;
2079
- L.push(
2080
- n >> 12 | 224,
2081
- n >> 6 & 63 | 128,
2082
- n & 63 | 128
2083
- );
2084
- } else if (n < 1114112) {
2085
- if ((r -= 4) < 0) break;
2086
- L.push(
2087
- n >> 18 | 240,
2088
- n >> 12 & 63 | 128,
2089
- n >> 6 & 63 | 128,
2090
- n & 63 | 128
2091
- );
2092
- } else
2093
- throw new Error("Invalid code point");
2094
- }
2095
- return L;
2096
- }
2097
- function de(o) {
2098
- const r = [];
2099
- for (let n = 0; n < o.length; ++n)
2100
- r.push(o.charCodeAt(n) & 255);
2101
- return r;
2102
- }
2103
- function ge(o, r) {
2104
- let n, f, E;
2105
- const L = [];
2106
- for (let W = 0; W < o.length && !((r -= 2) < 0); ++W)
2107
- n = o.charCodeAt(W), f = n >> 8, E = n % 256, L.push(E), L.push(f);
2108
- return L;
2109
- }
2110
- function le(o) {
2111
- return R.toByteArray(ie(o));
2112
- }
2113
- function Qe(o, r, n, f) {
2114
- let E;
2115
- for (E = 0; E < f && !(E + n >= r.length || E >= o.length); ++E)
2116
- r[E + n] = o[E];
2117
- return E;
2118
- }
2119
- function De(o, r) {
2120
- return o instanceof r || o != null && o.constructor != null && o.constructor.name != null && o.constructor.name === r.name;
2121
- }
2122
- function ur(o) {
2123
- return o !== o;
2124
- }
2125
- const Rt = (function() {
2126
- const o = "0123456789abcdef", r = new Array(256);
2127
- for (let n = 0; n < 16; ++n) {
2128
- const f = n * 16;
2129
- for (let E = 0; E < 16; ++E)
2130
- r[f + E] = o[n] + o[E];
2131
- }
2132
- return r;
2133
- })();
2134
- function He(o) {
2135
- return typeof BigInt > "u" ? At : o;
2136
- }
2137
- function At() {
2138
- throw new Error("BigInt not supported");
2139
- }
2140
- })(v);
2141
- const w = v.Buffer;
2142
- c.Blob = v.Blob, c.BlobOptions = v.BlobOptions, c.Buffer = v.Buffer, c.File = v.File, c.FileOptions = v.FileOptions, c.INSPECT_MAX_BYTES = v.INSPECT_MAX_BYTES, c.SlowBuffer = v.SlowBuffer, c.TranscodeEncoding = v.TranscodeEncoding, c.atob = v.atob, c.btoa = v.btoa, c.constants = v.constants, c.default = w, c.isAscii = v.isAscii, c.isUtf8 = v.isUtf8, c.kMaxLength = v.kMaxLength, c.kStringMaxLength = v.kStringMaxLength, c.resolveObjectURL = v.resolveObjectURL, c.transcode = v.transcode;
2143
- })(fr)), fr;
2144
- }
2145
- var kr;
2146
- function wt() {
2147
- return kr || (kr = 1, (function(c, v) {
2148
- var P = or(), D = P.Buffer;
2149
- function Y(y, O) {
2150
- for (var p in y)
2151
- O[p] = y[p];
2152
- }
2153
- D.from && D.alloc && D.allocUnsafe && D.allocUnsafeSlow ? c.exports = P : (Y(P, v), v.Buffer = h);
2154
- function h(y, O, p) {
2155
- return D(y, O, p);
2156
- }
2157
- h.prototype = Object.create(D.prototype), Y(D, h), h.from = function(y, O, p) {
2158
- if (typeof y == "number")
2159
- throw new TypeError("Argument must not be a number");
2160
- return D(y, O, p);
2161
- }, h.alloc = function(y, O, p) {
2162
- if (typeof y != "number")
2163
- throw new TypeError("Argument must be a number");
2164
- var N = D(y);
2165
- return O !== void 0 ? typeof p == "string" ? N.fill(O, p) : N.fill(O) : N.fill(0), N;
2166
- }, h.allocUnsafe = function(y) {
2167
- if (typeof y != "number")
2168
- throw new TypeError("Argument must be a number");
2169
- return D(y);
2170
- }, h.allocUnsafeSlow = function(y) {
2171
- if (typeof y != "number")
2172
- throw new TypeError("Argument must be a number");
2173
- return P.SlowBuffer(y);
2174
- };
2175
- })($e, $e.exports)), $e.exports;
2176
- }
2177
- var sr, Fr;
2178
- function Yt() {
2179
- if (Fr) return sr;
2180
- Fr = 1;
2181
- var c = {}.toString;
2182
- return sr = Array.isArray || function(v) {
2183
- return c.call(v) == "[object Array]";
2184
- }, sr;
2185
- }
2186
- var lr, xr;
2187
- function zt() {
2188
- if (xr) return lr;
2189
- xr = 1;
2190
- var c = /* @__PURE__ */ Tt(), v = /* @__PURE__ */ It(), P = v("TypedArray.prototype.buffer", !0), D = /* @__PURE__ */ ct();
2191
- return lr = P || function(h) {
2192
- if (!D(h))
2193
- throw new c("Not a Typed Array");
2194
- return h.buffer;
2195
- }, lr;
2196
- }
2197
- var cr, qr;
2198
- function fn() {
2199
- if (qr) return cr;
2200
- qr = 1;
2201
- var c = wt().Buffer, v = Yt(), P = /* @__PURE__ */ zt(), D = ArrayBuffer.isView || function(p) {
2202
- try {
2203
- return P(p), !0;
2204
- } catch {
2205
- return !1;
2206
- }
2207
- }, Y = typeof Uint8Array < "u", h = typeof ArrayBuffer < "u" && typeof Uint8Array < "u", y = h && (c.prototype instanceof Uint8Array || c.TYPED_ARRAY_SUPPORT);
2208
- return cr = function(p, N) {
2209
- if (c.isBuffer(p))
2210
- return p.constructor && !("isBuffer" in p) ? c.from(p) : p;
2211
- if (typeof p == "string")
2212
- return c.from(p, N);
2213
- if (h && D(p)) {
2214
- if (p.byteLength === 0)
2215
- return c.alloc(0);
2216
- if (y) {
2217
- var l = c.from(p.buffer, p.byteOffset, p.byteLength);
2218
- if (l.byteLength === p.byteLength)
2219
- return l;
2220
- }
2221
- var k = p instanceof Uint8Array ? p : new Uint8Array(p.buffer, p.byteOffset, p.byteLength), j = c.from(k);
2222
- if (j.length === p.byteLength)
2223
- return j;
2224
- }
2225
- if (Y && p instanceof Uint8Array)
2226
- return c.from(p);
2227
- var J = v(p);
2228
- if (J)
2229
- for (var V = 0; V < p.length; V += 1) {
2230
- var X = p[V];
2231
- if (typeof X != "number" || X < 0 || X > 255 || ~~X !== X)
2232
- throw new RangeError("Array items must be numbers in the range 0-255.");
2233
- }
2234
- if (J || c.isBuffer(p) && p.constructor && typeof p.constructor.isBuffer == "function" && p.constructor.isBuffer(p))
2235
- return c.from(p);
2236
- throw new TypeError('The "data" argument must be a string, an Array, a Buffer, a Uint8Array, or a DataView.');
2237
- }, cr;
2238
- }
2239
- var er = { exports: {} }, hr = {}, pr = {}, Wr;
2240
- function Kt() {
2241
- return Wr || (Wr = 1, (function(c) {
2242
- var v = /* @__PURE__ */ Lt(), P = Ot(), D = /* @__PURE__ */ Mt(), Y = /* @__PURE__ */ ct();
2243
- function h(G) {
2244
- return G.call.bind(G);
2245
- }
2246
- var y = typeof BigInt < "u", O = typeof Symbol < "u", p = h(Object.prototype.toString), N = h(Number.prototype.valueOf), l = h(String.prototype.valueOf), k = h(Boolean.prototype.valueOf);
2247
- if (y)
2248
- var j = h(BigInt.prototype.valueOf);
2249
- if (O)
2250
- var J = h(Symbol.prototype.valueOf);
2251
- function V(G, je) {
2252
- if (typeof G != "object")
2253
- return !1;
2254
- try {
2255
- return je(G), !0;
2256
- } catch {
2257
- return !1;
2258
- }
2259
- }
2260
- c.isArgumentsObject = v, c.isGeneratorFunction = P, c.isTypedArray = Y;
2261
- function X(G) {
2262
- return typeof Promise < "u" && G instanceof Promise || G !== null && typeof G == "object" && typeof G.then == "function" && typeof G.catch == "function";
2263
- }
2264
- c.isPromise = X;
2265
- function K(G) {
2266
- return typeof ArrayBuffer < "u" && ArrayBuffer.isView ? ArrayBuffer.isView(G) : Y(G) || F(G);
2267
- }
2268
- c.isArrayBufferView = K;
2269
- function w(G) {
2270
- return D(G) === "Uint8Array";
2271
- }
2272
- c.isUint8Array = w;
2273
- function B(G) {
2274
- return D(G) === "Uint8ClampedArray";
2275
- }
2276
- c.isUint8ClampedArray = B;
2277
- function R(G) {
2278
- return D(G) === "Uint16Array";
2279
- }
2280
- c.isUint16Array = R;
2281
- function d(G) {
2282
- return D(G) === "Uint32Array";
2283
- }
2284
- c.isUint32Array = d;
2285
- function m(G) {
2286
- return D(G) === "Int8Array";
2287
- }
2288
- c.isInt8Array = m;
2289
- function A(G) {
2290
- return D(G) === "Int16Array";
2291
- }
2292
- c.isInt16Array = A;
2293
- function M(G) {
2294
- return D(G) === "Int32Array";
2295
- }
2296
- c.isInt32Array = M;
2297
- function U(G) {
2298
- return D(G) === "Float32Array";
2299
- }
2300
- c.isFloat32Array = U;
2301
- function z(G) {
2302
- return D(G) === "Float64Array";
2303
- }
2304
- c.isFloat64Array = z;
2305
- function Q(G) {
2306
- return D(G) === "BigInt64Array";
2307
- }
2308
- c.isBigInt64Array = Q;
2309
- function ne(G) {
2310
- return D(G) === "BigUint64Array";
2311
- }
2312
- c.isBigUint64Array = ne;
2313
- function S(G) {
2314
- return p(G) === "[object Map]";
2315
- }
2316
- S.working = typeof Map < "u" && S(/* @__PURE__ */ new Map());
2317
- function se(G) {
2318
- return typeof Map > "u" ? !1 : S.working ? S(G) : G instanceof Map;
2319
- }
2320
- c.isMap = se;
2321
- function he(G) {
2322
- return p(G) === "[object Set]";
2323
- }
2324
- he.working = typeof Set < "u" && he(/* @__PURE__ */ new Set());
2325
- function ye(G) {
2326
- return typeof Set > "u" ? !1 : he.working ? he(G) : G instanceof Set;
2327
- }
2328
- c.isSet = ye;
2329
- function Be(G) {
2330
- return p(G) === "[object WeakMap]";
2331
- }
2332
- Be.working = typeof WeakMap < "u" && Be(/* @__PURE__ */ new WeakMap());
2333
- function Re(G) {
2334
- return typeof WeakMap > "u" ? !1 : Be.working ? Be(G) : G instanceof WeakMap;
2335
- }
2336
- c.isWeakMap = Re;
2337
- function Ae(G) {
2338
- return p(G) === "[object WeakSet]";
2339
- }
2340
- Ae.working = typeof WeakSet < "u" && Ae(/* @__PURE__ */ new WeakSet());
2341
- function Se(G) {
2342
- return Ae(G);
2343
- }
2344
- c.isWeakSet = Se;
2345
- function Te(G) {
2346
- return p(G) === "[object ArrayBuffer]";
2347
- }
2348
- Te.working = typeof ArrayBuffer < "u" && Te(new ArrayBuffer());
2349
- function Le(G) {
2350
- return typeof ArrayBuffer > "u" ? !1 : Te.working ? Te(G) : G instanceof ArrayBuffer;
2351
- }
2352
- c.isArrayBuffer = Le;
2353
- function I(G) {
2354
- return p(G) === "[object DataView]";
2355
- }
2356
- I.working = typeof ArrayBuffer < "u" && typeof DataView < "u" && I(new DataView(new ArrayBuffer(1), 0, 1));
2357
- function F(G) {
2358
- return typeof DataView > "u" ? !1 : I.working ? I(G) : G instanceof DataView;
2359
- }
2360
- c.isDataView = F;
2361
- var q = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : void 0;
2362
- function re(G) {
2363
- return p(G) === "[object SharedArrayBuffer]";
2364
- }
2365
- function b(G) {
2366
- return typeof q > "u" ? !1 : (typeof re.working > "u" && (re.working = re(new q())), re.working ? re(G) : G instanceof q);
2367
- }
2368
- c.isSharedArrayBuffer = b;
2369
- function _(G) {
2370
- return p(G) === "[object AsyncFunction]";
2371
- }
2372
- c.isAsyncFunction = _;
2373
- function C(G) {
2374
- return p(G) === "[object Map Iterator]";
2375
- }
2376
- c.isMapIterator = C;
2377
- function Z(G) {
2378
- return p(G) === "[object Set Iterator]";
2379
- }
2380
- c.isSetIterator = Z;
2381
- function ee(G) {
2382
- return p(G) === "[object Generator]";
2383
- }
2384
- c.isGeneratorObject = ee;
2385
- function u(G) {
2386
- return p(G) === "[object WebAssembly.Module]";
2387
- }
2388
- c.isWebAssemblyCompiledModule = u;
2389
- function s(G) {
2390
- return V(G, N);
2391
- }
2392
- c.isNumberObject = s;
2393
- function H(G) {
2394
- return V(G, l);
2395
- }
2396
- c.isStringObject = H;
2397
- function $(G) {
2398
- return V(G, k);
2399
- }
2400
- c.isBooleanObject = $;
2401
- function fe(G) {
2402
- return y && V(G, j);
2403
- }
2404
- c.isBigIntObject = fe;
2405
- function te(G) {
2406
- return O && V(G, J);
2407
- }
2408
- c.isSymbolObject = te;
2409
- function ae(G) {
2410
- return s(G) || H(G) || $(G) || fe(G) || te(G);
2411
- }
2412
- c.isBoxedPrimitive = ae;
2413
- function Me(G) {
2414
- return typeof Uint8Array < "u" && (Le(G) || b(G));
2415
- }
2416
- c.isAnyArrayBuffer = Me, ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(G) {
2417
- Object.defineProperty(c, G, {
2418
- enumerable: !1,
2419
- value: function() {
2420
- throw new Error(G + " is not supported in userland");
2421
- }
2422
- });
2423
- });
2424
- })(pr)), pr;
2425
- }
2426
- var dr, Gr;
2427
- function Jt() {
2428
- return Gr || (Gr = 1, dr = function(v) {
2429
- return v instanceof qt;
2430
- }), dr;
2431
- }
2432
- var Hr;
2433
- function Cr() {
2434
- return Hr || (Hr = 1, (function(c) {
2435
- var v = Object.getOwnPropertyDescriptors || function(F) {
2436
- for (var q = Object.keys(F), re = {}, b = 0; b < q.length; b++)
2437
- re[q[b]] = Object.getOwnPropertyDescriptor(F, q[b]);
2438
- return re;
2439
- }, P = /%[sdj%]/g;
2440
- c.format = function(I) {
2441
- if (!m(I)) {
2442
- for (var F = [], q = 0; q < arguments.length; q++)
2443
- F.push(y(arguments[q]));
2444
- return F.join(" ");
2445
- }
2446
- for (var q = 1, re = arguments, b = re.length, _ = String(I).replace(P, function(Z) {
2447
- if (Z === "%%") return "%";
2448
- if (q >= b) return Z;
2449
- switch (Z) {
2450
- case "%s":
2451
- return String(re[q++]);
2452
- case "%d":
2453
- return Number(re[q++]);
2454
- case "%j":
2455
- try {
2456
- return JSON.stringify(re[q++]);
2457
- } catch {
2458
- return "[Circular]";
2459
- }
2460
- default:
2461
- return Z;
2462
- }
2463
- }), C = re[q]; q < b; C = re[++q])
2464
- B(C) || !z(C) ? _ += " " + C : _ += " " + y(C);
2465
- return _;
2466
- }, c.deprecate = function(I, F) {
2467
- if (typeof ue < "u" && ue.noDeprecation === !0)
2468
- return I;
2469
- if (typeof ue > "u")
2470
- return function() {
2471
- return c.deprecate(I, F).apply(this, arguments);
2472
- };
2473
- var q = !1;
2474
- function re() {
2475
- if (!q) {
2476
- if (ue.throwDeprecation)
2477
- throw new Error(F);
2478
- ue.traceDeprecation ? console.trace(F) : console.error(F), q = !0;
2479
- }
2480
- return I.apply(this, arguments);
2481
- }
2482
- return re;
2483
- };
2484
- var D = {}, Y = /^$/;
2485
- if (ue.env.NODE_DEBUG) {
2486
- var h = ue.env.NODE_DEBUG;
2487
- h = h.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase(), Y = new RegExp("^" + h + "$", "i");
2488
- }
2489
- c.debuglog = function(I) {
2490
- if (I = I.toUpperCase(), !D[I])
2491
- if (Y.test(I)) {
2492
- var F = ue.pid;
2493
- D[I] = function() {
2494
- var q = c.format.apply(c, arguments);
2495
- console.error("%s %d: %s", I, F, q);
2496
- };
2497
- } else
2498
- D[I] = function() {
2499
- };
2500
- return D[I];
2501
- };
2502
- function y(I, F) {
2503
- var q = {
2504
- seen: [],
2505
- stylize: p
2506
- };
2507
- return arguments.length >= 3 && (q.depth = arguments[2]), arguments.length >= 4 && (q.colors = arguments[3]), w(F) ? q.showHidden = F : F && c._extend(q, F), M(q.showHidden) && (q.showHidden = !1), M(q.depth) && (q.depth = 2), M(q.colors) && (q.colors = !1), M(q.customInspect) && (q.customInspect = !0), q.colors && (q.stylize = O), l(q, I, q.depth);
2508
- }
2509
- c.inspect = y, y.colors = {
2510
- bold: [1, 22],
2511
- italic: [3, 23],
2512
- underline: [4, 24],
2513
- inverse: [7, 27],
2514
- white: [37, 39],
2515
- grey: [90, 39],
2516
- black: [30, 39],
2517
- blue: [34, 39],
2518
- cyan: [36, 39],
2519
- green: [32, 39],
2520
- magenta: [35, 39],
2521
- red: [31, 39],
2522
- yellow: [33, 39]
2523
- }, y.styles = {
2524
- special: "cyan",
2525
- number: "yellow",
2526
- boolean: "yellow",
2527
- undefined: "grey",
2528
- null: "bold",
2529
- string: "green",
2530
- date: "magenta",
2531
- // "name": intentionally not styling
2532
- regexp: "red"
2533
- };
2534
- function O(I, F) {
2535
- var q = y.styles[F];
2536
- return q ? "\x1B[" + y.colors[q][0] + "m" + I + "\x1B[" + y.colors[q][1] + "m" : I;
2537
- }
2538
- function p(I, F) {
2539
- return I;
2540
- }
2541
- function N(I) {
2542
- var F = {};
2543
- return I.forEach(function(q, re) {
2544
- F[q] = !0;
2545
- }), F;
2546
- }
2547
- function l(I, F, q) {
2548
- if (I.customInspect && F && S(F.inspect) && // Filter out the util module, it's inspect function is special
2549
- F.inspect !== c.inspect && // Also filter out any prototype objects using the circular check.
2550
- !(F.constructor && F.constructor.prototype === F)) {
2551
- var re = F.inspect(q, I);
2552
- return m(re) || (re = l(I, re, q)), re;
2553
- }
2554
- var b = k(I, F);
2555
- if (b)
2556
- return b;
2557
- var _ = Object.keys(F), C = N(_);
2558
- if (I.showHidden && (_ = Object.getOwnPropertyNames(F)), ne(F) && (_.indexOf("message") >= 0 || _.indexOf("description") >= 0))
2559
- return j(F);
2560
- if (_.length === 0) {
2561
- if (S(F)) {
2562
- var Z = F.name ? ": " + F.name : "";
2563
- return I.stylize("[Function" + Z + "]", "special");
2564
- }
2565
- if (U(F))
2566
- return I.stylize(RegExp.prototype.toString.call(F), "regexp");
2567
- if (Q(F))
2568
- return I.stylize(Date.prototype.toString.call(F), "date");
2569
- if (ne(F))
2570
- return j(F);
2571
- }
2572
- var ee = "", u = !1, s = ["{", "}"];
2573
- if (K(F) && (u = !0, s = ["[", "]"]), S(F)) {
2574
- var H = F.name ? ": " + F.name : "";
2575
- ee = " [Function" + H + "]";
2576
- }
2577
- if (U(F) && (ee = " " + RegExp.prototype.toString.call(F)), Q(F) && (ee = " " + Date.prototype.toUTCString.call(F)), ne(F) && (ee = " " + j(F)), _.length === 0 && (!u || F.length == 0))
2578
- return s[0] + ee + s[1];
2579
- if (q < 0)
2580
- return U(F) ? I.stylize(RegExp.prototype.toString.call(F), "regexp") : I.stylize("[Object]", "special");
2581
- I.seen.push(F);
2582
- var $;
2583
- return u ? $ = J(I, F, q, C, _) : $ = _.map(function(fe) {
2584
- return V(I, F, q, C, fe, u);
2585
- }), I.seen.pop(), X($, ee, s);
2586
- }
2587
- function k(I, F) {
2588
- if (M(F))
2589
- return I.stylize("undefined", "undefined");
2590
- if (m(F)) {
2591
- var q = "'" + JSON.stringify(F).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
2592
- return I.stylize(q, "string");
2593
- }
2594
- if (d(F))
2595
- return I.stylize("" + F, "number");
2596
- if (w(F))
2597
- return I.stylize("" + F, "boolean");
2598
- if (B(F))
2599
- return I.stylize("null", "null");
2600
- }
2601
- function j(I) {
2602
- return "[" + Error.prototype.toString.call(I) + "]";
2603
- }
2604
- function J(I, F, q, re, b) {
2605
- for (var _ = [], C = 0, Z = F.length; C < Z; ++C)
2606
- Ae(F, String(C)) ? _.push(V(
2607
- I,
2608
- F,
2609
- q,
2610
- re,
2611
- String(C),
2612
- !0
2613
- )) : _.push("");
2614
- return b.forEach(function(ee) {
2615
- ee.match(/^\d+$/) || _.push(V(
2616
- I,
2617
- F,
2618
- q,
2619
- re,
2620
- ee,
2621
- !0
2622
- ));
2623
- }), _;
2624
- }
2625
- function V(I, F, q, re, b, _) {
2626
- var C, Z, ee;
2627
- if (ee = Object.getOwnPropertyDescriptor(F, b) || { value: F[b] }, ee.get ? ee.set ? Z = I.stylize("[Getter/Setter]", "special") : Z = I.stylize("[Getter]", "special") : ee.set && (Z = I.stylize("[Setter]", "special")), Ae(re, b) || (C = "[" + b + "]"), Z || (I.seen.indexOf(ee.value) < 0 ? (B(q) ? Z = l(I, ee.value, null) : Z = l(I, ee.value, q - 1), Z.indexOf(`
2628
- `) > -1 && (_ ? Z = Z.split(`
2629
- `).map(function(u) {
2630
- return " " + u;
2631
- }).join(`
2632
- `).slice(2) : Z = `
2633
- ` + Z.split(`
2634
- `).map(function(u) {
2635
- return " " + u;
2636
- }).join(`
2637
- `))) : Z = I.stylize("[Circular]", "special")), M(C)) {
2638
- if (_ && b.match(/^\d+$/))
2639
- return Z;
2640
- C = JSON.stringify("" + b), C.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (C = C.slice(1, -1), C = I.stylize(C, "name")) : (C = C.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), C = I.stylize(C, "string"));
2641
- }
2642
- return C + ": " + Z;
2643
- }
2644
- function X(I, F, q) {
2645
- var re = I.reduce(function(b, _) {
2646
- return _.indexOf(`
2647
- `) >= 0, b + _.replace(/\u001b\[\d\d?m/g, "").length + 1;
2648
- }, 0);
2649
- return re > 60 ? q[0] + (F === "" ? "" : F + `
2650
- `) + " " + I.join(`,
2651
- `) + " " + q[1] : q[0] + F + " " + I.join(", ") + " " + q[1];
2652
- }
2653
- c.types = Kt();
2654
- function K(I) {
2655
- return Array.isArray(I);
2656
- }
2657
- c.isArray = K;
2658
- function w(I) {
2659
- return typeof I == "boolean";
2660
- }
2661
- c.isBoolean = w;
2662
- function B(I) {
2663
- return I === null;
2664
- }
2665
- c.isNull = B;
2666
- function R(I) {
2667
- return I == null;
2668
- }
2669
- c.isNullOrUndefined = R;
2670
- function d(I) {
2671
- return typeof I == "number";
2672
- }
2673
- c.isNumber = d;
2674
- function m(I) {
2675
- return typeof I == "string";
2676
- }
2677
- c.isString = m;
2678
- function A(I) {
2679
- return typeof I == "symbol";
2680
- }
2681
- c.isSymbol = A;
2682
- function M(I) {
2683
- return I === void 0;
2684
- }
2685
- c.isUndefined = M;
2686
- function U(I) {
2687
- return z(I) && he(I) === "[object RegExp]";
2688
- }
2689
- c.isRegExp = U, c.types.isRegExp = U;
2690
- function z(I) {
2691
- return typeof I == "object" && I !== null;
2692
- }
2693
- c.isObject = z;
2694
- function Q(I) {
2695
- return z(I) && he(I) === "[object Date]";
2696
- }
2697
- c.isDate = Q, c.types.isDate = Q;
2698
- function ne(I) {
2699
- return z(I) && (he(I) === "[object Error]" || I instanceof Error);
2700
- }
2701
- c.isError = ne, c.types.isNativeError = ne;
2702
- function S(I) {
2703
- return typeof I == "function";
2704
- }
2705
- c.isFunction = S;
2706
- function se(I) {
2707
- return I === null || typeof I == "boolean" || typeof I == "number" || typeof I == "string" || typeof I == "symbol" || // ES6 symbol
2708
- typeof I > "u";
2709
- }
2710
- c.isPrimitive = se, c.isBuffer = Jt();
2711
- function he(I) {
2712
- return Object.prototype.toString.call(I);
2713
- }
2714
- function ye(I) {
2715
- return I < 10 ? "0" + I.toString(10) : I.toString(10);
2716
- }
2717
- var Be = [
2718
- "Jan",
2719
- "Feb",
2720
- "Mar",
2721
- "Apr",
2722
- "May",
2723
- "Jun",
2724
- "Jul",
2725
- "Aug",
2726
- "Sep",
2727
- "Oct",
2728
- "Nov",
2729
- "Dec"
2730
- ];
2731
- function Re() {
2732
- var I = /* @__PURE__ */ new Date(), F = [
2733
- ye(I.getHours()),
2734
- ye(I.getMinutes()),
2735
- ye(I.getSeconds())
2736
- ].join(":");
2737
- return [I.getDate(), Be[I.getMonth()], F].join(" ");
2738
- }
2739
- c.log = function() {
2740
- console.log("%s - %s", Re(), c.format.apply(c, arguments));
2741
- }, c.inherits = Ye(), c._extend = function(I, F) {
2742
- if (!F || !z(F)) return I;
2743
- for (var q = Object.keys(F), re = q.length; re--; )
2744
- I[q[re]] = F[q[re]];
2745
- return I;
2746
- };
2747
- function Ae(I, F) {
2748
- return Object.prototype.hasOwnProperty.call(I, F);
2749
- }
2750
- var Se = typeof Symbol < "u" ? /* @__PURE__ */ Symbol("util.promisify.custom") : void 0;
2751
- c.promisify = function(F) {
2752
- if (typeof F != "function")
2753
- throw new TypeError('The "original" argument must be of type Function');
2754
- if (Se && F[Se]) {
2755
- var q = F[Se];
2756
- if (typeof q != "function")
2757
- throw new TypeError('The "util.promisify.custom" argument must be of type Function');
2758
- return Object.defineProperty(q, Se, {
2759
- value: q,
2760
- enumerable: !1,
2761
- writable: !1,
2762
- configurable: !0
2763
- }), q;
2764
- }
2765
- function q() {
2766
- for (var re, b, _ = new Promise(function(ee, u) {
2767
- re = ee, b = u;
2768
- }), C = [], Z = 0; Z < arguments.length; Z++)
2769
- C.push(arguments[Z]);
2770
- C.push(function(ee, u) {
2771
- ee ? b(ee) : re(u);
2772
- });
2773
- try {
2774
- F.apply(this, C);
2775
- } catch (ee) {
2776
- b(ee);
2777
- }
2778
- return _;
2779
- }
2780
- return Object.setPrototypeOf(q, Object.getPrototypeOf(F)), Se && Object.defineProperty(q, Se, {
2781
- value: q,
2782
- enumerable: !1,
2783
- writable: !1,
2784
- configurable: !0
2785
- }), Object.defineProperties(
2786
- q,
2787
- v(F)
2788
- );
2789
- }, c.promisify.custom = Se;
2790
- function Te(I, F) {
2791
- if (!I) {
2792
- var q = new Error("Promise was rejected with a falsy value");
2793
- q.reason = I, I = q;
2794
- }
2795
- return F(I);
2796
- }
2797
- function Le(I) {
2798
- if (typeof I != "function")
2799
- throw new TypeError('The "original" argument must be of type Function');
2800
- function F() {
2801
- for (var q = [], re = 0; re < arguments.length; re++)
2802
- q.push(arguments[re]);
2803
- var b = q.pop();
2804
- if (typeof b != "function")
2805
- throw new TypeError("The last argument must be of type Function");
2806
- var _ = this, C = function() {
2807
- return b.apply(_, arguments);
2808
- };
2809
- I.apply(this, q).then(
2810
- function(Z) {
2811
- ue.nextTick(C.bind(null, null, Z));
2812
- },
2813
- function(Z) {
2814
- ue.nextTick(Te.bind(null, Z, C));
2815
- }
2816
- );
2817
- }
2818
- return Object.setPrototypeOf(F, Object.getPrototypeOf(I)), Object.defineProperties(
2819
- F,
2820
- v(I)
2821
- ), F;
2822
- }
2823
- c.callbackify = Le;
2824
- })(hr)), hr;
2825
- }
2826
- var rr = { exports: {} }, Vr;
2827
- function Xt() {
2828
- return Vr || (Vr = 1, typeof Object.create == "function" ? rr.exports = function(v, P) {
2829
- P && (v.super_ = P, v.prototype = Object.create(P.prototype, {
2830
- constructor: {
2831
- value: v,
2832
- enumerable: !1,
2833
- writable: !0,
2834
- configurable: !0
2835
- }
2836
- }));
2837
- } : rr.exports = function(v, P) {
2838
- if (P) {
2839
- v.super_ = P;
2840
- var D = function() {
2841
- };
2842
- D.prototype = P.prototype, v.prototype = new D(), v.prototype.constructor = v;
2843
- }
2844
- }), rr.exports;
2845
- }
2846
- var Yr;
2847
- function Ye() {
2848
- if (Yr) return er.exports;
2849
- Yr = 1;
2850
- try {
2851
- var c = Cr();
2852
- if (typeof c.inherits != "function") throw "";
2853
- er.exports = c.inherits;
2854
- } catch {
2855
- er.exports = Xt();
2856
- }
2857
- return er.exports;
2858
- }
2859
- var tr = { exports: {} }, zr;
2860
- function mt() {
2861
- if (zr) return tr.exports;
2862
- zr = 1;
2863
- var c = typeof Reflect == "object" ? Reflect : null, v = c && typeof c.apply == "function" ? c.apply : function(m, A, M) {
2864
- return Function.prototype.apply.call(m, A, M);
2865
- }, P;
2866
- c && typeof c.ownKeys == "function" ? P = c.ownKeys : Object.getOwnPropertySymbols ? P = function(m) {
2867
- return Object.getOwnPropertyNames(m).concat(Object.getOwnPropertySymbols(m));
2868
- } : P = function(m) {
2869
- return Object.getOwnPropertyNames(m);
2870
- };
2871
- function D(d) {
2872
- console && console.warn && console.warn(d);
2873
- }
2874
- var Y = Number.isNaN || function(m) {
2875
- return m !== m;
2876
- };
2877
- function h() {
2878
- h.init.call(this);
2879
- }
2880
- tr.exports = h, tr.exports.once = w, h.EventEmitter = h, h.prototype._events = void 0, h.prototype._eventsCount = 0, h.prototype._maxListeners = void 0;
2881
- var y = 10;
2882
- function O(d) {
2883
- if (typeof d != "function")
2884
- throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof d);
2885
- }
2886
- Object.defineProperty(h, "defaultMaxListeners", {
2887
- enumerable: !0,
2888
- get: function() {
2889
- return y;
2890
- },
2891
- set: function(d) {
2892
- if (typeof d != "number" || d < 0 || Y(d))
2893
- throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + d + ".");
2894
- y = d;
2895
- }
2896
- }), h.init = function() {
2897
- (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
2898
- }, h.prototype.setMaxListeners = function(m) {
2899
- if (typeof m != "number" || m < 0 || Y(m))
2900
- throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + m + ".");
2901
- return this._maxListeners = m, this;
2902
- };
2903
- function p(d) {
2904
- return d._maxListeners === void 0 ? h.defaultMaxListeners : d._maxListeners;
2905
- }
2906
- h.prototype.getMaxListeners = function() {
2907
- return p(this);
2908
- }, h.prototype.emit = function(m) {
2909
- for (var A = [], M = 1; M < arguments.length; M++) A.push(arguments[M]);
2910
- var U = m === "error", z = this._events;
2911
- if (z !== void 0)
2912
- U = U && z.error === void 0;
2913
- else if (!U)
2914
- return !1;
2915
- if (U) {
2916
- var Q;
2917
- if (A.length > 0 && (Q = A[0]), Q instanceof Error)
2918
- throw Q;
2919
- var ne = new Error("Unhandled error." + (Q ? " (" + Q.message + ")" : ""));
2920
- throw ne.context = Q, ne;
2921
- }
2922
- var S = z[m];
2923
- if (S === void 0)
2924
- return !1;
2925
- if (typeof S == "function")
2926
- v(S, this, A);
2927
- else
2928
- for (var se = S.length, he = V(S, se), M = 0; M < se; ++M)
2929
- v(he[M], this, A);
2930
- return !0;
2931
- };
2932
- function N(d, m, A, M) {
2933
- var U, z, Q;
2934
- if (O(A), z = d._events, z === void 0 ? (z = d._events = /* @__PURE__ */ Object.create(null), d._eventsCount = 0) : (z.newListener !== void 0 && (d.emit(
2935
- "newListener",
2936
- m,
2937
- A.listener ? A.listener : A
2938
- ), z = d._events), Q = z[m]), Q === void 0)
2939
- Q = z[m] = A, ++d._eventsCount;
2940
- else if (typeof Q == "function" ? Q = z[m] = M ? [A, Q] : [Q, A] : M ? Q.unshift(A) : Q.push(A), U = p(d), U > 0 && Q.length > U && !Q.warned) {
2941
- Q.warned = !0;
2942
- var ne = new Error("Possible EventEmitter memory leak detected. " + Q.length + " " + String(m) + " listeners added. Use emitter.setMaxListeners() to increase limit");
2943
- ne.name = "MaxListenersExceededWarning", ne.emitter = d, ne.type = m, ne.count = Q.length, D(ne);
2944
- }
2945
- return d;
2946
- }
2947
- h.prototype.addListener = function(m, A) {
2948
- return N(this, m, A, !1);
2949
- }, h.prototype.on = h.prototype.addListener, h.prototype.prependListener = function(m, A) {
2950
- return N(this, m, A, !0);
2951
- };
2952
- function l() {
2953
- if (!this.fired)
2954
- return this.target.removeListener(this.type, this.wrapFn), this.fired = !0, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
2955
- }
2956
- function k(d, m, A) {
2957
- var M = { fired: !1, wrapFn: void 0, target: d, type: m, listener: A }, U = l.bind(M);
2958
- return U.listener = A, M.wrapFn = U, U;
2959
- }
2960
- h.prototype.once = function(m, A) {
2961
- return O(A), this.on(m, k(this, m, A)), this;
2962
- }, h.prototype.prependOnceListener = function(m, A) {
2963
- return O(A), this.prependListener(m, k(this, m, A)), this;
2964
- }, h.prototype.removeListener = function(m, A) {
2965
- var M, U, z, Q, ne;
2966
- if (O(A), U = this._events, U === void 0)
2967
- return this;
2968
- if (M = U[m], M === void 0)
2969
- return this;
2970
- if (M === A || M.listener === A)
2971
- --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete U[m], U.removeListener && this.emit("removeListener", m, M.listener || A));
2972
- else if (typeof M != "function") {
2973
- for (z = -1, Q = M.length - 1; Q >= 0; Q--)
2974
- if (M[Q] === A || M[Q].listener === A) {
2975
- ne = M[Q].listener, z = Q;
2976
- break;
2977
- }
2978
- if (z < 0)
2979
- return this;
2980
- z === 0 ? M.shift() : X(M, z), M.length === 1 && (U[m] = M[0]), U.removeListener !== void 0 && this.emit("removeListener", m, ne || A);
2981
- }
2982
- return this;
2983
- }, h.prototype.off = h.prototype.removeListener, h.prototype.removeAllListeners = function(m) {
2984
- var A, M, U;
2985
- if (M = this._events, M === void 0)
2986
- return this;
2987
- if (M.removeListener === void 0)
2988
- return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : M[m] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete M[m]), this;
2989
- if (arguments.length === 0) {
2990
- var z = Object.keys(M), Q;
2991
- for (U = 0; U < z.length; ++U)
2992
- Q = z[U], Q !== "removeListener" && this.removeAllListeners(Q);
2993
- return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
2994
- }
2995
- if (A = M[m], typeof A == "function")
2996
- this.removeListener(m, A);
2997
- else if (A !== void 0)
2998
- for (U = A.length - 1; U >= 0; U--)
2999
- this.removeListener(m, A[U]);
3000
- return this;
3001
- };
3002
- function j(d, m, A) {
3003
- var M = d._events;
3004
- if (M === void 0)
3005
- return [];
3006
- var U = M[m];
3007
- return U === void 0 ? [] : typeof U == "function" ? A ? [U.listener || U] : [U] : A ? K(U) : V(U, U.length);
3008
- }
3009
- h.prototype.listeners = function(m) {
3010
- return j(this, m, !0);
3011
- }, h.prototype.rawListeners = function(m) {
3012
- return j(this, m, !1);
3013
- }, h.listenerCount = function(d, m) {
3014
- return typeof d.listenerCount == "function" ? d.listenerCount(m) : J.call(d, m);
3015
- }, h.prototype.listenerCount = J;
3016
- function J(d) {
3017
- var m = this._events;
3018
- if (m !== void 0) {
3019
- var A = m[d];
3020
- if (typeof A == "function")
3021
- return 1;
3022
- if (A !== void 0)
3023
- return A.length;
3024
- }
3025
- return 0;
3026
- }
3027
- h.prototype.eventNames = function() {
3028
- return this._eventsCount > 0 ? P(this._events) : [];
3029
- };
3030
- function V(d, m) {
3031
- for (var A = new Array(m), M = 0; M < m; ++M)
3032
- A[M] = d[M];
3033
- return A;
3034
- }
3035
- function X(d, m) {
3036
- for (; m + 1 < d.length; m++)
3037
- d[m] = d[m + 1];
3038
- d.pop();
3039
- }
3040
- function K(d) {
3041
- for (var m = new Array(d.length), A = 0; A < m.length; ++A)
3042
- m[A] = d[A].listener || d[A];
3043
- return m;
3044
- }
3045
- function w(d, m) {
3046
- return new Promise(function(A, M) {
3047
- function U(Q) {
3048
- d.removeListener(m, z), M(Q);
3049
- }
3050
- function z() {
3051
- typeof d.removeListener == "function" && d.removeListener("error", U), A([].slice.call(arguments));
3052
- }
3053
- R(d, m, z, { once: !0 }), m !== "error" && B(d, U, { once: !0 });
3054
- });
3055
- }
3056
- function B(d, m, A) {
3057
- typeof d.on == "function" && R(d, "error", m, A);
3058
- }
3059
- function R(d, m, A, M) {
3060
- if (typeof d.on == "function")
3061
- M.once ? d.once(m, A) : d.on(m, A);
3062
- else if (typeof d.addEventListener == "function")
3063
- d.addEventListener(m, function U(z) {
3064
- M.once && d.removeEventListener(m, U), A(z);
3065
- });
3066
- else
3067
- throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof d);
3068
- }
3069
- return tr.exports;
3070
- }
3071
- var yr, Kr;
3072
- function Et() {
3073
- return Kr || (Kr = 1, yr = tn()), yr;
3074
- }
3075
- var gr, Jr;
3076
- function Zt() {
3077
- if (Jr) return gr;
3078
- Jr = 1;
3079
- function c(V, X) {
3080
- var K = Object.keys(V);
3081
- if (Object.getOwnPropertySymbols) {
3082
- var w = Object.getOwnPropertySymbols(V);
3083
- X && (w = w.filter(function(B) {
3084
- return Object.getOwnPropertyDescriptor(V, B).enumerable;
3085
- })), K.push.apply(K, w);
3086
- }
3087
- return K;
3088
- }
3089
- function v(V) {
3090
- for (var X = 1; X < arguments.length; X++) {
3091
- var K = arguments[X] != null ? arguments[X] : {};
3092
- X % 2 ? c(Object(K), !0).forEach(function(w) {
3093
- P(V, w, K[w]);
3094
- }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(V, Object.getOwnPropertyDescriptors(K)) : c(Object(K)).forEach(function(w) {
3095
- Object.defineProperty(V, w, Object.getOwnPropertyDescriptor(K, w));
3096
- });
3097
- }
3098
- return V;
3099
- }
3100
- function P(V, X, K) {
3101
- return X = y(X), X in V ? Object.defineProperty(V, X, { value: K, enumerable: !0, configurable: !0, writable: !0 }) : V[X] = K, V;
3102
- }
3103
- function D(V, X) {
3104
- if (!(V instanceof X))
3105
- throw new TypeError("Cannot call a class as a function");
3106
- }
3107
- function Y(V, X) {
3108
- for (var K = 0; K < X.length; K++) {
3109
- var w = X[K];
3110
- w.enumerable = w.enumerable || !1, w.configurable = !0, "value" in w && (w.writable = !0), Object.defineProperty(V, y(w.key), w);
3111
- }
3112
- }
3113
- function h(V, X, K) {
3114
- return X && Y(V.prototype, X), Object.defineProperty(V, "prototype", { writable: !1 }), V;
3115
- }
3116
- function y(V) {
3117
- var X = O(V, "string");
3118
- return typeof X == "symbol" ? X : String(X);
3119
- }
3120
- function O(V, X) {
3121
- if (typeof V != "object" || V === null) return V;
3122
- var K = V[Symbol.toPrimitive];
3123
- if (K !== void 0) {
3124
- var w = K.call(V, X);
3125
- if (typeof w != "object") return w;
3126
- throw new TypeError("@@toPrimitive must return a primitive value.");
3127
- }
3128
- return String(V);
3129
- }
3130
- var p = or(), N = p.Buffer, l = Cr(), k = l.inspect, j = k && k.custom || "inspect";
3131
- function J(V, X, K) {
3132
- N.prototype.copy.call(V, X, K);
3133
- }
3134
- return gr = /* @__PURE__ */ (function() {
3135
- function V() {
3136
- D(this, V), this.head = null, this.tail = null, this.length = 0;
3137
- }
3138
- return h(V, [{
3139
- key: "push",
3140
- value: function(K) {
3141
- var w = {
3142
- data: K,
3143
- next: null
3144
- };
3145
- this.length > 0 ? this.tail.next = w : this.head = w, this.tail = w, ++this.length;
3146
- }
3147
- }, {
3148
- key: "unshift",
3149
- value: function(K) {
3150
- var w = {
3151
- data: K,
3152
- next: this.head
3153
- };
3154
- this.length === 0 && (this.tail = w), this.head = w, ++this.length;
3155
- }
3156
- }, {
3157
- key: "shift",
3158
- value: function() {
3159
- if (this.length !== 0) {
3160
- var K = this.head.data;
3161
- return this.length === 1 ? this.head = this.tail = null : this.head = this.head.next, --this.length, K;
3162
- }
3163
- }
3164
- }, {
3165
- key: "clear",
3166
- value: function() {
3167
- this.head = this.tail = null, this.length = 0;
3168
- }
3169
- }, {
3170
- key: "join",
3171
- value: function(K) {
3172
- if (this.length === 0) return "";
3173
- for (var w = this.head, B = "" + w.data; w = w.next; ) B += K + w.data;
3174
- return B;
3175
- }
3176
- }, {
3177
- key: "concat",
3178
- value: function(K) {
3179
- if (this.length === 0) return N.alloc(0);
3180
- for (var w = N.allocUnsafe(K >>> 0), B = this.head, R = 0; B; )
3181
- J(B.data, w, R), R += B.data.length, B = B.next;
3182
- return w;
3183
- }
3184
- // Consumes a specified amount of bytes or characters from the buffered data.
3185
- }, {
3186
- key: "consume",
3187
- value: function(K, w) {
3188
- var B;
3189
- return K < this.head.data.length ? (B = this.head.data.slice(0, K), this.head.data = this.head.data.slice(K)) : K === this.head.data.length ? B = this.shift() : B = w ? this._getString(K) : this._getBuffer(K), B;
3190
- }
3191
- }, {
3192
- key: "first",
3193
- value: function() {
3194
- return this.head.data;
3195
- }
3196
- // Consumes a specified amount of characters from the buffered data.
3197
- }, {
3198
- key: "_getString",
3199
- value: function(K) {
3200
- var w = this.head, B = 1, R = w.data;
3201
- for (K -= R.length; w = w.next; ) {
3202
- var d = w.data, m = K > d.length ? d.length : K;
3203
- if (m === d.length ? R += d : R += d.slice(0, K), K -= m, K === 0) {
3204
- m === d.length ? (++B, w.next ? this.head = w.next : this.head = this.tail = null) : (this.head = w, w.data = d.slice(m));
3205
- break;
3206
- }
3207
- ++B;
3208
- }
3209
- return this.length -= B, R;
3210
- }
3211
- // Consumes a specified amount of bytes from the buffered data.
3212
- }, {
3213
- key: "_getBuffer",
3214
- value: function(K) {
3215
- var w = N.allocUnsafe(K), B = this.head, R = 1;
3216
- for (B.data.copy(w), K -= B.data.length; B = B.next; ) {
3217
- var d = B.data, m = K > d.length ? d.length : K;
3218
- if (d.copy(w, w.length - K, 0, m), K -= m, K === 0) {
3219
- m === d.length ? (++R, B.next ? this.head = B.next : this.head = this.tail = null) : (this.head = B, B.data = d.slice(m));
3220
- break;
3221
- }
3222
- ++R;
3223
- }
3224
- return this.length -= R, w;
3225
- }
3226
- // Make sure the linked list only shows the minimal necessary information.
3227
- }, {
3228
- key: j,
3229
- value: function(K, w) {
3230
- return k(this, v(v({}, w), {}, {
3231
- // Only inspect one level.
3232
- depth: 0,
3233
- // It should not recurse.
3234
- customInspect: !1
3235
- }));
3236
- }
3237
- }]), V;
3238
- })(), gr;
3239
- }
3240
- var wr, Xr;
3241
- function bt() {
3242
- if (Xr) return wr;
3243
- Xr = 1;
3244
- function c(y, O) {
3245
- var p = this, N = this._readableState && this._readableState.destroyed, l = this._writableState && this._writableState.destroyed;
3246
- return N || l ? (O ? O(y) : y && (this._writableState ? this._writableState.errorEmitted || (this._writableState.errorEmitted = !0, ue.nextTick(Y, this, y)) : ue.nextTick(Y, this, y)), this) : (this._readableState && (this._readableState.destroyed = !0), this._writableState && (this._writableState.destroyed = !0), this._destroy(y || null, function(k) {
3247
- !O && k ? p._writableState ? p._writableState.errorEmitted ? ue.nextTick(P, p) : (p._writableState.errorEmitted = !0, ue.nextTick(v, p, k)) : ue.nextTick(v, p, k) : O ? (ue.nextTick(P, p), O(k)) : ue.nextTick(P, p);
3248
- }), this);
3249
- }
3250
- function v(y, O) {
3251
- Y(y, O), P(y);
3252
- }
3253
- function P(y) {
3254
- y._writableState && !y._writableState.emitClose || y._readableState && !y._readableState.emitClose || y.emit("close");
3255
- }
3256
- function D() {
3257
- this._readableState && (this._readableState.destroyed = !1, this._readableState.reading = !1, this._readableState.ended = !1, this._readableState.endEmitted = !1), this._writableState && (this._writableState.destroyed = !1, this._writableState.ended = !1, this._writableState.ending = !1, this._writableState.finalCalled = !1, this._writableState.prefinished = !1, this._writableState.finished = !1, this._writableState.errorEmitted = !1);
3258
- }
3259
- function Y(y, O) {
3260
- y.emit("error", O);
3261
- }
3262
- function h(y, O) {
3263
- var p = y._readableState, N = y._writableState;
3264
- p && p.autoDestroy || N && N.autoDestroy ? y.destroy(O) : y.emit("error", O);
3265
- }
3266
- return wr = {
3267
- destroy: c,
3268
- undestroy: D,
3269
- errorOrDestroy: h
3270
- }, wr;
3271
- }
3272
- var mr = {}, Zr;
3273
- function ze() {
3274
- if (Zr) return mr;
3275
- Zr = 1;
3276
- const c = {};
3277
- function v(y, O, p) {
3278
- p || (p = Error);
3279
- function N(k, j, J) {
3280
- return typeof O == "string" ? O : O(k, j, J);
3281
- }
3282
- class l extends p {
3283
- constructor(j, J, V) {
3284
- super(N(j, J, V));
3285
- }
3286
- }
3287
- l.prototype.name = p.name, l.prototype.code = y, c[y] = l;
3288
- }
3289
- function P(y, O) {
3290
- if (Array.isArray(y)) {
3291
- const p = y.length;
3292
- return y = y.map((N) => String(N)), p > 2 ? `one of ${O} ${y.slice(0, p - 1).join(", ")}, or ` + y[p - 1] : p === 2 ? `one of ${O} ${y[0]} or ${y[1]}` : `of ${O} ${y[0]}`;
3293
- } else
3294
- return `of ${O} ${String(y)}`;
3295
- }
3296
- function D(y, O, p) {
3297
- return y.substr(0, O.length) === O;
3298
- }
3299
- function Y(y, O, p) {
3300
- return (p === void 0 || p > y.length) && (p = y.length), y.substring(p - O.length, p) === O;
3301
- }
3302
- function h(y, O, p) {
3303
- return typeof p != "number" && (p = 0), p + O.length > y.length ? !1 : y.indexOf(O, p) !== -1;
3304
- }
3305
- return v("ERR_INVALID_OPT_VALUE", function(y, O) {
3306
- return 'The value "' + O + '" is invalid for option "' + y + '"';
3307
- }, TypeError), v("ERR_INVALID_ARG_TYPE", function(y, O, p) {
3308
- let N;
3309
- typeof O == "string" && D(O, "not ") ? (N = "must not be", O = O.replace(/^not /, "")) : N = "must be";
3310
- let l;
3311
- if (Y(y, " argument"))
3312
- l = `The ${y} ${N} ${P(O, "type")}`;
3313
- else {
3314
- const k = h(y, ".") ? "property" : "argument";
3315
- l = `The "${y}" ${k} ${N} ${P(O, "type")}`;
3316
- }
3317
- return l += `. Received type ${typeof p}`, l;
3318
- }, TypeError), v("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF"), v("ERR_METHOD_NOT_IMPLEMENTED", function(y) {
3319
- return "The " + y + " method is not implemented";
3320
- }), v("ERR_STREAM_PREMATURE_CLOSE", "Premature close"), v("ERR_STREAM_DESTROYED", function(y) {
3321
- return "Cannot call " + y + " after a stream was destroyed";
3322
- }), v("ERR_MULTIPLE_CALLBACK", "Callback called multiple times"), v("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable"), v("ERR_STREAM_WRITE_AFTER_END", "write after end"), v("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError), v("ERR_UNKNOWN_ENCODING", function(y) {
3323
- return "Unknown encoding: " + y;
3324
- }, TypeError), v("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event"), mr.codes = c, mr;
3325
- }
3326
- var Er, Qr;
3327
- function _t() {
3328
- if (Qr) return Er;
3329
- Qr = 1;
3330
- var c = ze().codes.ERR_INVALID_OPT_VALUE;
3331
- function v(D, Y, h) {
3332
- return D.highWaterMark != null ? D.highWaterMark : Y ? D[h] : null;
3333
- }
3334
- function P(D, Y, h, y) {
3335
- var O = v(Y, y, h);
3336
- if (O != null) {
3337
- if (!(isFinite(O) && Math.floor(O) === O) || O < 0) {
3338
- var p = y ? h : "highWaterMark";
3339
- throw new c(p, O);
3340
- }
3341
- return Math.floor(O);
3342
- }
3343
- return D.objectMode ? 16 : 16 * 1024;
3344
- }
3345
- return Er = {
3346
- getHighWaterMark: P
3347
- }, Er;
3348
- }
3349
- var br, $r;
3350
- function vt() {
3351
- if ($r) return br;
3352
- $r = 1, br = U;
3353
- function c(b) {
3354
- var _ = this;
3355
- this.next = null, this.entry = null, this.finish = function() {
3356
- re(_, b);
3357
- };
3358
- }
3359
- var v;
3360
- U.WritableState = A;
3361
- var P = {
3362
- deprecate: Ut()
3363
- }, D = Et(), Y = or().Buffer, h = (typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
3364
- };
3365
- function y(b) {
3366
- return Y.from(b);
3367
- }
3368
- function O(b) {
3369
- return Y.isBuffer(b) || b instanceof h;
3370
- }
3371
- var p = bt(), N = _t(), l = N.getHighWaterMark, k = ze().codes, j = k.ERR_INVALID_ARG_TYPE, J = k.ERR_METHOD_NOT_IMPLEMENTED, V = k.ERR_MULTIPLE_CALLBACK, X = k.ERR_STREAM_CANNOT_PIPE, K = k.ERR_STREAM_DESTROYED, w = k.ERR_STREAM_NULL_VALUES, B = k.ERR_STREAM_WRITE_AFTER_END, R = k.ERR_UNKNOWN_ENCODING, d = p.errorOrDestroy;
3372
- Ye()(U, D);
3373
- function m() {
3374
- }
3375
- function A(b, _, C) {
3376
- v = v || Ze(), b = b || {}, typeof C != "boolean" && (C = _ instanceof v), this.objectMode = !!b.objectMode, C && (this.objectMode = this.objectMode || !!b.writableObjectMode), this.highWaterMark = l(this, b, "writableHighWaterMark", C), this.finalCalled = !1, this.needDrain = !1, this.ending = !1, this.ended = !1, this.finished = !1, this.destroyed = !1;
3377
- var Z = b.decodeStrings === !1;
3378
- this.decodeStrings = !Z, this.defaultEncoding = b.defaultEncoding || "utf8", this.length = 0, this.writing = !1, this.corked = 0, this.sync = !0, this.bufferProcessing = !1, this.onwrite = function(ee) {
3379
- Be(_, ee);
3380
- }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = !1, this.errorEmitted = !1, this.emitClose = b.emitClose !== !1, this.autoDestroy = !!b.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new c(this);
3381
- }
3382
- A.prototype.getBuffer = function() {
3383
- for (var _ = this.bufferedRequest, C = []; _; )
3384
- C.push(_), _ = _.next;
3385
- return C;
3386
- }, (function() {
3387
- try {
3388
- Object.defineProperty(A.prototype, "buffer", {
3389
- get: P.deprecate(function() {
3390
- return this.getBuffer();
3391
- }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
3392
- });
3393
- } catch {
3394
- }
3395
- })();
3396
- var M;
3397
- typeof Symbol == "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] == "function" ? (M = Function.prototype[Symbol.hasInstance], Object.defineProperty(U, Symbol.hasInstance, {
3398
- value: function(_) {
3399
- return M.call(this, _) ? !0 : this !== U ? !1 : _ && _._writableState instanceof A;
3400
- }
3401
- })) : M = function(_) {
3402
- return _ instanceof this;
3403
- };
3404
- function U(b) {
3405
- v = v || Ze();
3406
- var _ = this instanceof v;
3407
- if (!_ && !M.call(U, this)) return new U(b);
3408
- this._writableState = new A(b, this, _), this.writable = !0, b && (typeof b.write == "function" && (this._write = b.write), typeof b.writev == "function" && (this._writev = b.writev), typeof b.destroy == "function" && (this._destroy = b.destroy), typeof b.final == "function" && (this._final = b.final)), D.call(this);
3409
- }
3410
- U.prototype.pipe = function() {
3411
- d(this, new X());
3412
- };
3413
- function z(b, _) {
3414
- var C = new B();
3415
- d(b, C), ue.nextTick(_, C);
3416
- }
3417
- function Q(b, _, C, Z) {
3418
- var ee;
3419
- return C === null ? ee = new w() : typeof C != "string" && !_.objectMode && (ee = new j("chunk", ["string", "Buffer"], C)), ee ? (d(b, ee), ue.nextTick(Z, ee), !1) : !0;
3420
- }
3421
- U.prototype.write = function(b, _, C) {
3422
- var Z = this._writableState, ee = !1, u = !Z.objectMode && O(b);
3423
- return u && !Y.isBuffer(b) && (b = y(b)), typeof _ == "function" && (C = _, _ = null), u ? _ = "buffer" : _ || (_ = Z.defaultEncoding), typeof C != "function" && (C = m), Z.ending ? z(this, C) : (u || Q(this, Z, b, C)) && (Z.pendingcb++, ee = S(this, Z, u, b, _, C)), ee;
3424
- }, U.prototype.cork = function() {
3425
- this._writableState.corked++;
3426
- }, U.prototype.uncork = function() {
3427
- var b = this._writableState;
3428
- b.corked && (b.corked--, !b.writing && !b.corked && !b.bufferProcessing && b.bufferedRequest && Se(this, b));
3429
- }, U.prototype.setDefaultEncoding = function(_) {
3430
- if (typeof _ == "string" && (_ = _.toLowerCase()), !(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((_ + "").toLowerCase()) > -1)) throw new R(_);
3431
- return this._writableState.defaultEncoding = _, this;
3432
- }, Object.defineProperty(U.prototype, "writableBuffer", {
3433
- // making it explicit this property is not enumerable
3434
- // because otherwise some prototype manipulation in
3435
- // userland will fail
3436
- enumerable: !1,
3437
- get: function() {
3438
- return this._writableState && this._writableState.getBuffer();
3439
- }
3440
- });
3441
- function ne(b, _, C) {
3442
- return !b.objectMode && b.decodeStrings !== !1 && typeof _ == "string" && (_ = Y.from(_, C)), _;
3443
- }
3444
- Object.defineProperty(U.prototype, "writableHighWaterMark", {
3445
- // making it explicit this property is not enumerable
3446
- // because otherwise some prototype manipulation in
3447
- // userland will fail
3448
- enumerable: !1,
3449
- get: function() {
3450
- return this._writableState.highWaterMark;
3451
- }
3452
- });
3453
- function S(b, _, C, Z, ee, u) {
3454
- if (!C) {
3455
- var s = ne(_, Z, ee);
3456
- Z !== s && (C = !0, ee = "buffer", Z = s);
3457
- }
3458
- var H = _.objectMode ? 1 : Z.length;
3459
- _.length += H;
3460
- var $ = _.length < _.highWaterMark;
3461
- if ($ || (_.needDrain = !0), _.writing || _.corked) {
3462
- var fe = _.lastBufferedRequest;
3463
- _.lastBufferedRequest = {
3464
- chunk: Z,
3465
- encoding: ee,
3466
- isBuf: C,
3467
- callback: u,
3468
- next: null
3469
- }, fe ? fe.next = _.lastBufferedRequest : _.bufferedRequest = _.lastBufferedRequest, _.bufferedRequestCount += 1;
3470
- } else
3471
- se(b, _, !1, H, Z, ee, u);
3472
- return $;
3473
- }
3474
- function se(b, _, C, Z, ee, u, s) {
3475
- _.writelen = Z, _.writecb = s, _.writing = !0, _.sync = !0, _.destroyed ? _.onwrite(new K("write")) : C ? b._writev(ee, _.onwrite) : b._write(ee, u, _.onwrite), _.sync = !1;
3476
- }
3477
- function he(b, _, C, Z, ee) {
3478
- --_.pendingcb, C ? (ue.nextTick(ee, Z), ue.nextTick(F, b, _), b._writableState.errorEmitted = !0, d(b, Z)) : (ee(Z), b._writableState.errorEmitted = !0, d(b, Z), F(b, _));
3479
- }
3480
- function ye(b) {
3481
- b.writing = !1, b.writecb = null, b.length -= b.writelen, b.writelen = 0;
3482
- }
3483
- function Be(b, _) {
3484
- var C = b._writableState, Z = C.sync, ee = C.writecb;
3485
- if (typeof ee != "function") throw new V();
3486
- if (ye(C), _) he(b, C, Z, _, ee);
3487
- else {
3488
- var u = Te(C) || b.destroyed;
3489
- !u && !C.corked && !C.bufferProcessing && C.bufferedRequest && Se(b, C), Z ? ue.nextTick(Re, b, C, u, ee) : Re(b, C, u, ee);
3490
- }
3491
- }
3492
- function Re(b, _, C, Z) {
3493
- C || Ae(b, _), _.pendingcb--, Z(), F(b, _);
3494
- }
3495
- function Ae(b, _) {
3496
- _.length === 0 && _.needDrain && (_.needDrain = !1, b.emit("drain"));
3497
- }
3498
- function Se(b, _) {
3499
- _.bufferProcessing = !0;
3500
- var C = _.bufferedRequest;
3501
- if (b._writev && C && C.next) {
3502
- var Z = _.bufferedRequestCount, ee = new Array(Z), u = _.corkedRequestsFree;
3503
- u.entry = C;
3504
- for (var s = 0, H = !0; C; )
3505
- ee[s] = C, C.isBuf || (H = !1), C = C.next, s += 1;
3506
- ee.allBuffers = H, se(b, _, !0, _.length, ee, "", u.finish), _.pendingcb++, _.lastBufferedRequest = null, u.next ? (_.corkedRequestsFree = u.next, u.next = null) : _.corkedRequestsFree = new c(_), _.bufferedRequestCount = 0;
3507
- } else {
3508
- for (; C; ) {
3509
- var $ = C.chunk, fe = C.encoding, te = C.callback, ae = _.objectMode ? 1 : $.length;
3510
- if (se(b, _, !1, ae, $, fe, te), C = C.next, _.bufferedRequestCount--, _.writing)
3511
- break;
3512
- }
3513
- C === null && (_.lastBufferedRequest = null);
3514
- }
3515
- _.bufferedRequest = C, _.bufferProcessing = !1;
3516
- }
3517
- U.prototype._write = function(b, _, C) {
3518
- C(new J("_write()"));
3519
- }, U.prototype._writev = null, U.prototype.end = function(b, _, C) {
3520
- var Z = this._writableState;
3521
- return typeof b == "function" ? (C = b, b = null, _ = null) : typeof _ == "function" && (C = _, _ = null), b != null && this.write(b, _), Z.corked && (Z.corked = 1, this.uncork()), Z.ending || q(this, Z, C), this;
3522
- }, Object.defineProperty(U.prototype, "writableLength", {
3523
- // making it explicit this property is not enumerable
3524
- // because otherwise some prototype manipulation in
3525
- // userland will fail
3526
- enumerable: !1,
3527
- get: function() {
3528
- return this._writableState.length;
3529
- }
3530
- });
3531
- function Te(b) {
3532
- return b.ending && b.length === 0 && b.bufferedRequest === null && !b.finished && !b.writing;
3533
- }
3534
- function Le(b, _) {
3535
- b._final(function(C) {
3536
- _.pendingcb--, C && d(b, C), _.prefinished = !0, b.emit("prefinish"), F(b, _);
3537
- });
3538
- }
3539
- function I(b, _) {
3540
- !_.prefinished && !_.finalCalled && (typeof b._final == "function" && !_.destroyed ? (_.pendingcb++, _.finalCalled = !0, ue.nextTick(Le, b, _)) : (_.prefinished = !0, b.emit("prefinish")));
3541
- }
3542
- function F(b, _) {
3543
- var C = Te(_);
3544
- if (C && (I(b, _), _.pendingcb === 0 && (_.finished = !0, b.emit("finish"), _.autoDestroy))) {
3545
- var Z = b._readableState;
3546
- (!Z || Z.autoDestroy && Z.endEmitted) && b.destroy();
3547
- }
3548
- return C;
3549
- }
3550
- function q(b, _, C) {
3551
- _.ending = !0, F(b, _), C && (_.finished ? ue.nextTick(C) : b.once("finish", C)), _.ended = !0, b.writable = !1;
3552
- }
3553
- function re(b, _, C) {
3554
- var Z = b.entry;
3555
- for (b.entry = null; Z; ) {
3556
- var ee = Z.callback;
3557
- _.pendingcb--, ee(C), Z = Z.next;
3558
- }
3559
- _.corkedRequestsFree.next = b;
3560
- }
3561
- return Object.defineProperty(U.prototype, "destroyed", {
3562
- // making it explicit this property is not enumerable
3563
- // because otherwise some prototype manipulation in
3564
- // userland will fail
3565
- enumerable: !1,
3566
- get: function() {
3567
- return this._writableState === void 0 ? !1 : this._writableState.destroyed;
3568
- },
3569
- set: function(_) {
3570
- this._writableState && (this._writableState.destroyed = _);
3571
- }
3572
- }), U.prototype.destroy = p.destroy, U.prototype._undestroy = p.undestroy, U.prototype._destroy = function(b, _) {
3573
- _(b);
3574
- }, br;
3575
- }
3576
- var _r, et;
3577
- function Ze() {
3578
- if (et) return _r;
3579
- et = 1;
3580
- var c = Object.keys || function(N) {
3581
- var l = [];
3582
- for (var k in N) l.push(k);
3583
- return l;
3584
- };
3585
- _r = y;
3586
- var v = Bt(), P = vt();
3587
- Ye()(y, v);
3588
- for (var D = c(P.prototype), Y = 0; Y < D.length; Y++) {
3589
- var h = D[Y];
3590
- y.prototype[h] || (y.prototype[h] = P.prototype[h]);
3591
- }
3592
- function y(N) {
3593
- if (!(this instanceof y)) return new y(N);
3594
- v.call(this, N), P.call(this, N), this.allowHalfOpen = !0, N && (N.readable === !1 && (this.readable = !1), N.writable === !1 && (this.writable = !1), N.allowHalfOpen === !1 && (this.allowHalfOpen = !1, this.once("end", O)));
3595
- }
3596
- Object.defineProperty(y.prototype, "writableHighWaterMark", {
3597
- // making it explicit this property is not enumerable
3598
- // because otherwise some prototype manipulation in
3599
- // userland will fail
3600
- enumerable: !1,
3601
- get: function() {
3602
- return this._writableState.highWaterMark;
3603
- }
3604
- }), Object.defineProperty(y.prototype, "writableBuffer", {
3605
- // making it explicit this property is not enumerable
3606
- // because otherwise some prototype manipulation in
3607
- // userland will fail
3608
- enumerable: !1,
3609
- get: function() {
3610
- return this._writableState && this._writableState.getBuffer();
3611
- }
3612
- }), Object.defineProperty(y.prototype, "writableLength", {
3613
- // making it explicit this property is not enumerable
3614
- // because otherwise some prototype manipulation in
3615
- // userland will fail
3616
- enumerable: !1,
3617
- get: function() {
3618
- return this._writableState.length;
3619
- }
3620
- });
3621
- function O() {
3622
- this._writableState.ended || ue.nextTick(p, this);
3623
- }
3624
- function p(N) {
3625
- N.end();
3626
- }
3627
- return Object.defineProperty(y.prototype, "destroyed", {
3628
- // making it explicit this property is not enumerable
3629
- // because otherwise some prototype manipulation in
3630
- // userland will fail
3631
- enumerable: !1,
3632
- get: function() {
3633
- return this._readableState === void 0 || this._writableState === void 0 ? !1 : this._readableState.destroyed && this._writableState.destroyed;
3634
- },
3635
- set: function(l) {
3636
- this._readableState === void 0 || this._writableState === void 0 || (this._readableState.destroyed = l, this._writableState.destroyed = l);
3637
- }
3638
- }), _r;
3639
- }
3640
- var vr = {}, rt;
3641
- function tt() {
3642
- if (rt) return vr;
3643
- rt = 1;
3644
- var c = wt().Buffer, v = c.isEncoding || function(w) {
3645
- switch (w = "" + w, w && w.toLowerCase()) {
3646
- case "hex":
3647
- case "utf8":
3648
- case "utf-8":
3649
- case "ascii":
3650
- case "binary":
3651
- case "base64":
3652
- case "ucs2":
3653
- case "ucs-2":
3654
- case "utf16le":
3655
- case "utf-16le":
3656
- case "raw":
3657
- return !0;
3658
- default:
3659
- return !1;
3660
- }
3661
- };
3662
- function P(w) {
3663
- if (!w) return "utf8";
3664
- for (var B; ; )
3665
- switch (w) {
3666
- case "utf8":
3667
- case "utf-8":
3668
- return "utf8";
3669
- case "ucs2":
3670
- case "ucs-2":
3671
- case "utf16le":
3672
- case "utf-16le":
3673
- return "utf16le";
3674
- case "latin1":
3675
- case "binary":
3676
- return "latin1";
3677
- case "base64":
3678
- case "ascii":
3679
- case "hex":
3680
- return w;
3681
- default:
3682
- if (B) return;
3683
- w = ("" + w).toLowerCase(), B = !0;
3684
- }
3685
- }
3686
- function D(w) {
3687
- var B = P(w);
3688
- if (typeof B != "string" && (c.isEncoding === v || !v(w))) throw new Error("Unknown encoding: " + w);
3689
- return B || w;
3690
- }
3691
- vr.StringDecoder = Y;
3692
- function Y(w) {
3693
- this.encoding = D(w);
3694
- var B;
3695
- switch (this.encoding) {
3696
- case "utf16le":
3697
- this.text = k, this.end = j, B = 4;
3698
- break;
3699
- case "utf8":
3700
- this.fillLast = p, B = 4;
3701
- break;
3702
- case "base64":
3703
- this.text = J, this.end = V, B = 3;
3704
- break;
3705
- default:
3706
- this.write = X, this.end = K;
3707
- return;
3708
- }
3709
- this.lastNeed = 0, this.lastTotal = 0, this.lastChar = c.allocUnsafe(B);
3710
- }
3711
- Y.prototype.write = function(w) {
3712
- if (w.length === 0) return "";
3713
- var B, R;
3714
- if (this.lastNeed) {
3715
- if (B = this.fillLast(w), B === void 0) return "";
3716
- R = this.lastNeed, this.lastNeed = 0;
3717
- } else
3718
- R = 0;
3719
- return R < w.length ? B ? B + this.text(w, R) : this.text(w, R) : B || "";
3720
- }, Y.prototype.end = l, Y.prototype.text = N, Y.prototype.fillLast = function(w) {
3721
- if (this.lastNeed <= w.length)
3722
- return w.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
3723
- w.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, w.length), this.lastNeed -= w.length;
3724
- };
3725
- function h(w) {
3726
- return w <= 127 ? 0 : w >> 5 === 6 ? 2 : w >> 4 === 14 ? 3 : w >> 3 === 30 ? 4 : w >> 6 === 2 ? -1 : -2;
3727
- }
3728
- function y(w, B, R) {
3729
- var d = B.length - 1;
3730
- if (d < R) return 0;
3731
- var m = h(B[d]);
3732
- return m >= 0 ? (m > 0 && (w.lastNeed = m - 1), m) : --d < R || m === -2 ? 0 : (m = h(B[d]), m >= 0 ? (m > 0 && (w.lastNeed = m - 2), m) : --d < R || m === -2 ? 0 : (m = h(B[d]), m >= 0 ? (m > 0 && (m === 2 ? m = 0 : w.lastNeed = m - 3), m) : 0));
3733
- }
3734
- function O(w, B, R) {
3735
- if ((B[0] & 192) !== 128)
3736
- return w.lastNeed = 0, "�";
3737
- if (w.lastNeed > 1 && B.length > 1) {
3738
- if ((B[1] & 192) !== 128)
3739
- return w.lastNeed = 1, "�";
3740
- if (w.lastNeed > 2 && B.length > 2 && (B[2] & 192) !== 128)
3741
- return w.lastNeed = 2, "�";
3742
- }
3743
- }
3744
- function p(w) {
3745
- var B = this.lastTotal - this.lastNeed, R = O(this, w);
3746
- if (R !== void 0) return R;
3747
- if (this.lastNeed <= w.length)
3748
- return w.copy(this.lastChar, B, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
3749
- w.copy(this.lastChar, B, 0, w.length), this.lastNeed -= w.length;
3750
- }
3751
- function N(w, B) {
3752
- var R = y(this, w, B);
3753
- if (!this.lastNeed) return w.toString("utf8", B);
3754
- this.lastTotal = R;
3755
- var d = w.length - (R - this.lastNeed);
3756
- return w.copy(this.lastChar, 0, d), w.toString("utf8", B, d);
3757
- }
3758
- function l(w) {
3759
- var B = w && w.length ? this.write(w) : "";
3760
- return this.lastNeed ? B + "�" : B;
3761
- }
3762
- function k(w, B) {
3763
- if ((w.length - B) % 2 === 0) {
3764
- var R = w.toString("utf16le", B);
3765
- if (R) {
3766
- var d = R.charCodeAt(R.length - 1);
3767
- if (d >= 55296 && d <= 56319)
3768
- return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = w[w.length - 2], this.lastChar[1] = w[w.length - 1], R.slice(0, -1);
3769
- }
3770
- return R;
3771
- }
3772
- return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = w[w.length - 1], w.toString("utf16le", B, w.length - 1);
3773
- }
3774
- function j(w) {
3775
- var B = w && w.length ? this.write(w) : "";
3776
- if (this.lastNeed) {
3777
- var R = this.lastTotal - this.lastNeed;
3778
- return B + this.lastChar.toString("utf16le", 0, R);
3779
- }
3780
- return B;
3781
- }
3782
- function J(w, B) {
3783
- var R = (w.length - B) % 3;
3784
- return R === 0 ? w.toString("base64", B) : (this.lastNeed = 3 - R, this.lastTotal = 3, R === 1 ? this.lastChar[0] = w[w.length - 1] : (this.lastChar[0] = w[w.length - 2], this.lastChar[1] = w[w.length - 1]), w.toString("base64", B, w.length - R));
3785
- }
3786
- function V(w) {
3787
- var B = w && w.length ? this.write(w) : "";
3788
- return this.lastNeed ? B + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : B;
3789
- }
3790
- function X(w) {
3791
- return w.toString(this.encoding);
3792
- }
3793
- function K(w) {
3794
- return w && w.length ? this.write(w) : "";
3795
- }
3796
- return vr;
3797
- }
3798
- var Br, nt;
3799
- function jr() {
3800
- if (nt) return Br;
3801
- nt = 1;
3802
- var c = ze().codes.ERR_STREAM_PREMATURE_CLOSE;
3803
- function v(h) {
3804
- var y = !1;
3805
- return function() {
3806
- if (!y) {
3807
- y = !0;
3808
- for (var O = arguments.length, p = new Array(O), N = 0; N < O; N++)
3809
- p[N] = arguments[N];
3810
- h.apply(this, p);
3811
- }
3812
- };
3813
- }
3814
- function P() {
3815
- }
3816
- function D(h) {
3817
- return h.setHeader && typeof h.abort == "function";
3818
- }
3819
- function Y(h, y, O) {
3820
- if (typeof y == "function") return Y(h, null, y);
3821
- y || (y = {}), O = v(O || P);
3822
- var p = y.readable || y.readable !== !1 && h.readable, N = y.writable || y.writable !== !1 && h.writable, l = function() {
3823
- h.writable || j();
3824
- }, k = h._writableState && h._writableState.finished, j = function() {
3825
- N = !1, k = !0, p || O.call(h);
3826
- }, J = h._readableState && h._readableState.endEmitted, V = function() {
3827
- p = !1, J = !0, N || O.call(h);
3828
- }, X = function(R) {
3829
- O.call(h, R);
3830
- }, K = function() {
3831
- var R;
3832
- if (p && !J)
3833
- return (!h._readableState || !h._readableState.ended) && (R = new c()), O.call(h, R);
3834
- if (N && !k)
3835
- return (!h._writableState || !h._writableState.ended) && (R = new c()), O.call(h, R);
3836
- }, w = function() {
3837
- h.req.on("finish", j);
3838
- };
3839
- return D(h) ? (h.on("complete", j), h.on("abort", K), h.req ? w() : h.on("request", w)) : N && !h._writableState && (h.on("end", l), h.on("close", l)), h.on("end", V), h.on("finish", j), y.error !== !1 && h.on("error", X), h.on("close", K), function() {
3840
- h.removeListener("complete", j), h.removeListener("abort", K), h.removeListener("request", w), h.req && h.req.removeListener("finish", j), h.removeListener("end", l), h.removeListener("close", l), h.removeListener("finish", j), h.removeListener("end", V), h.removeListener("error", X), h.removeListener("close", K);
3841
- };
3842
- }
3843
- return Br = Y, Br;
3844
- }
3845
- var Sr, it;
3846
- function Qt() {
3847
- if (it) return Sr;
3848
- it = 1;
3849
- var c;
3850
- function v(R, d, m) {
3851
- return d = P(d), d in R ? Object.defineProperty(R, d, { value: m, enumerable: !0, configurable: !0, writable: !0 }) : R[d] = m, R;
3852
- }
3853
- function P(R) {
3854
- var d = D(R, "string");
3855
- return typeof d == "symbol" ? d : String(d);
3856
- }
3857
- function D(R, d) {
3858
- if (typeof R != "object" || R === null) return R;
3859
- var m = R[Symbol.toPrimitive];
3860
- if (m !== void 0) {
3861
- var A = m.call(R, d);
3862
- if (typeof A != "object") return A;
3863
- throw new TypeError("@@toPrimitive must return a primitive value.");
3864
- }
3865
- return (d === "string" ? String : Number)(R);
3866
- }
3867
- var Y = jr(), h = /* @__PURE__ */ Symbol("lastResolve"), y = /* @__PURE__ */ Symbol("lastReject"), O = /* @__PURE__ */ Symbol("error"), p = /* @__PURE__ */ Symbol("ended"), N = /* @__PURE__ */ Symbol("lastPromise"), l = /* @__PURE__ */ Symbol("handlePromise"), k = /* @__PURE__ */ Symbol("stream");
3868
- function j(R, d) {
3869
- return {
3870
- value: R,
3871
- done: d
3872
- };
3873
- }
3874
- function J(R) {
3875
- var d = R[h];
3876
- if (d !== null) {
3877
- var m = R[k].read();
3878
- m !== null && (R[N] = null, R[h] = null, R[y] = null, d(j(m, !1)));
3879
- }
3880
- }
3881
- function V(R) {
3882
- ue.nextTick(J, R);
3883
- }
3884
- function X(R, d) {
3885
- return function(m, A) {
3886
- R.then(function() {
3887
- if (d[p]) {
3888
- m(j(void 0, !0));
3889
- return;
3890
- }
3891
- d[l](m, A);
3892
- }, A);
3893
- };
3894
- }
3895
- var K = Object.getPrototypeOf(function() {
3896
- }), w = Object.setPrototypeOf((c = {
3897
- get stream() {
3898
- return this[k];
3899
- },
3900
- next: function() {
3901
- var d = this, m = this[O];
3902
- if (m !== null)
3903
- return Promise.reject(m);
3904
- if (this[p])
3905
- return Promise.resolve(j(void 0, !0));
3906
- if (this[k].destroyed)
3907
- return new Promise(function(z, Q) {
3908
- ue.nextTick(function() {
3909
- d[O] ? Q(d[O]) : z(j(void 0, !0));
3910
- });
3911
- });
3912
- var A = this[N], M;
3913
- if (A)
3914
- M = new Promise(X(A, this));
3915
- else {
3916
- var U = this[k].read();
3917
- if (U !== null)
3918
- return Promise.resolve(j(U, !1));
3919
- M = new Promise(this[l]);
3920
- }
3921
- return this[N] = M, M;
3922
- }
3923
- }, v(c, Symbol.asyncIterator, function() {
3924
- return this;
3925
- }), v(c, "return", function() {
3926
- var d = this;
3927
- return new Promise(function(m, A) {
3928
- d[k].destroy(null, function(M) {
3929
- if (M) {
3930
- A(M);
3931
- return;
3932
- }
3933
- m(j(void 0, !0));
3934
- });
3935
- });
3936
- }), c), K), B = function(d) {
3937
- var m, A = Object.create(w, (m = {}, v(m, k, {
3938
- value: d,
3939
- writable: !0
3940
- }), v(m, h, {
3941
- value: null,
3942
- writable: !0
3943
- }), v(m, y, {
3944
- value: null,
3945
- writable: !0
3946
- }), v(m, O, {
3947
- value: null,
3948
- writable: !0
3949
- }), v(m, p, {
3950
- value: d._readableState.endEmitted,
3951
- writable: !0
3952
- }), v(m, l, {
3953
- value: function(U, z) {
3954
- var Q = A[k].read();
3955
- Q ? (A[N] = null, A[h] = null, A[y] = null, U(j(Q, !1))) : (A[h] = U, A[y] = z);
3956
- },
3957
- writable: !0
3958
- }), m));
3959
- return A[N] = null, Y(d, function(M) {
3960
- if (M && M.code !== "ERR_STREAM_PREMATURE_CLOSE") {
3961
- var U = A[y];
3962
- U !== null && (A[N] = null, A[h] = null, A[y] = null, U(M)), A[O] = M;
3963
- return;
3964
- }
3965
- var z = A[h];
3966
- z !== null && (A[N] = null, A[h] = null, A[y] = null, z(j(void 0, !0))), A[p] = !0;
3967
- }), d.on("readable", V.bind(null, A)), A;
3968
- };
3969
- return Sr = B, Sr;
3970
- }
3971
- var Rr, ot;
3972
- function $t() {
3973
- if (ot) return Rr;
3974
- ot = 1;
3975
- function c(N, l, k, j, J, V, X) {
3976
- try {
3977
- var K = N[V](X), w = K.value;
3978
- } catch (B) {
3979
- k(B);
3980
- return;
3981
- }
3982
- K.done ? l(w) : Promise.resolve(w).then(j, J);
3983
- }
3984
- function v(N) {
3985
- return function() {
3986
- var l = this, k = arguments;
3987
- return new Promise(function(j, J) {
3988
- var V = N.apply(l, k);
3989
- function X(w) {
3990
- c(V, j, J, X, K, "next", w);
3991
- }
3992
- function K(w) {
3993
- c(V, j, J, X, K, "throw", w);
3994
- }
3995
- X(void 0);
3996
- });
3997
- };
3998
- }
3999
- function P(N, l) {
4000
- var k = Object.keys(N);
4001
- if (Object.getOwnPropertySymbols) {
4002
- var j = Object.getOwnPropertySymbols(N);
4003
- l && (j = j.filter(function(J) {
4004
- return Object.getOwnPropertyDescriptor(N, J).enumerable;
4005
- })), k.push.apply(k, j);
4006
- }
4007
- return k;
4008
- }
4009
- function D(N) {
4010
- for (var l = 1; l < arguments.length; l++) {
4011
- var k = arguments[l] != null ? arguments[l] : {};
4012
- l % 2 ? P(Object(k), !0).forEach(function(j) {
4013
- Y(N, j, k[j]);
4014
- }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(N, Object.getOwnPropertyDescriptors(k)) : P(Object(k)).forEach(function(j) {
4015
- Object.defineProperty(N, j, Object.getOwnPropertyDescriptor(k, j));
4016
- });
4017
- }
4018
- return N;
4019
- }
4020
- function Y(N, l, k) {
4021
- return l = h(l), l in N ? Object.defineProperty(N, l, { value: k, enumerable: !0, configurable: !0, writable: !0 }) : N[l] = k, N;
4022
- }
4023
- function h(N) {
4024
- var l = y(N, "string");
4025
- return typeof l == "symbol" ? l : String(l);
4026
- }
4027
- function y(N, l) {
4028
- if (typeof N != "object" || N === null) return N;
4029
- var k = N[Symbol.toPrimitive];
4030
- if (k !== void 0) {
4031
- var j = k.call(N, l);
4032
- if (typeof j != "object") return j;
4033
- throw new TypeError("@@toPrimitive must return a primitive value.");
4034
- }
4035
- return (l === "string" ? String : Number)(N);
4036
- }
4037
- var O = ze().codes.ERR_INVALID_ARG_TYPE;
4038
- function p(N, l, k) {
4039
- var j;
4040
- if (l && typeof l.next == "function")
4041
- j = l;
4042
- else if (l && l[Symbol.asyncIterator]) j = l[Symbol.asyncIterator]();
4043
- else if (l && l[Symbol.iterator]) j = l[Symbol.iterator]();
4044
- else throw new O("iterable", ["Iterable"], l);
4045
- var J = new N(D({
4046
- objectMode: !0
4047
- }, k)), V = !1;
4048
- J._read = function() {
4049
- V || (V = !0, X());
4050
- };
4051
- function X() {
4052
- return K.apply(this, arguments);
4053
- }
4054
- function K() {
4055
- return K = v(function* () {
4056
- try {
4057
- var w = yield j.next(), B = w.value, R = w.done;
4058
- R ? J.push(null) : J.push(yield B) ? X() : V = !1;
4059
- } catch (d) {
4060
- J.destroy(d);
4061
- }
4062
- }), K.apply(this, arguments);
4063
- }
4064
- return J;
4065
- }
4066
- return Rr = p, Rr;
4067
- }
4068
- var Ar, ut;
4069
- function Bt() {
4070
- if (ut) return Ar;
4071
- ut = 1, Ar = z;
4072
- var c;
4073
- z.ReadableState = U, mt().EventEmitter;
4074
- var v = function(s, H) {
4075
- return s.listeners(H).length;
4076
- }, P = Et(), D = or().Buffer, Y = (typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
4077
- };
4078
- function h(u) {
4079
- return D.from(u);
4080
- }
4081
- function y(u) {
4082
- return D.isBuffer(u) || u instanceof Y;
4083
- }
4084
- var O = Cr(), p;
4085
- O && O.debuglog ? p = O.debuglog("stream") : p = function() {
4086
- };
4087
- var N = Zt(), l = bt(), k = _t(), j = k.getHighWaterMark, J = ze().codes, V = J.ERR_INVALID_ARG_TYPE, X = J.ERR_STREAM_PUSH_AFTER_EOF, K = J.ERR_METHOD_NOT_IMPLEMENTED, w = J.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, B, R, d;
4088
- Ye()(z, P);
4089
- var m = l.errorOrDestroy, A = ["error", "close", "destroy", "pause", "resume"];
4090
- function M(u, s, H) {
4091
- if (typeof u.prependListener == "function") return u.prependListener(s, H);
4092
- !u._events || !u._events[s] ? u.on(s, H) : Array.isArray(u._events[s]) ? u._events[s].unshift(H) : u._events[s] = [H, u._events[s]];
4093
- }
4094
- function U(u, s, H) {
4095
- c = c || Ze(), u = u || {}, typeof H != "boolean" && (H = s instanceof c), this.objectMode = !!u.objectMode, H && (this.objectMode = this.objectMode || !!u.readableObjectMode), this.highWaterMark = j(this, u, "readableHighWaterMark", H), this.buffer = new N(), this.length = 0, this.pipes = null, this.pipesCount = 0, this.flowing = null, this.ended = !1, this.endEmitted = !1, this.reading = !1, this.sync = !0, this.needReadable = !1, this.emittedReadable = !1, this.readableListening = !1, this.resumeScheduled = !1, this.paused = !0, this.emitClose = u.emitClose !== !1, this.autoDestroy = !!u.autoDestroy, this.destroyed = !1, this.defaultEncoding = u.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = !1, this.decoder = null, this.encoding = null, u.encoding && (B || (B = tt().StringDecoder), this.decoder = new B(u.encoding), this.encoding = u.encoding);
4096
- }
4097
- function z(u) {
4098
- if (c = c || Ze(), !(this instanceof z)) return new z(u);
4099
- var s = this instanceof c;
4100
- this._readableState = new U(u, this, s), this.readable = !0, u && (typeof u.read == "function" && (this._read = u.read), typeof u.destroy == "function" && (this._destroy = u.destroy)), P.call(this);
4101
- }
4102
- Object.defineProperty(z.prototype, "destroyed", {
4103
- // making it explicit this property is not enumerable
4104
- // because otherwise some prototype manipulation in
4105
- // userland will fail
4106
- enumerable: !1,
4107
- get: function() {
4108
- return this._readableState === void 0 ? !1 : this._readableState.destroyed;
4109
- },
4110
- set: function(s) {
4111
- this._readableState && (this._readableState.destroyed = s);
4112
- }
4113
- }), z.prototype.destroy = l.destroy, z.prototype._undestroy = l.undestroy, z.prototype._destroy = function(u, s) {
4114
- s(u);
4115
- }, z.prototype.push = function(u, s) {
4116
- var H = this._readableState, $;
4117
- return H.objectMode ? $ = !0 : typeof u == "string" && (s = s || H.defaultEncoding, s !== H.encoding && (u = D.from(u, s), s = ""), $ = !0), Q(this, u, s, !1, $);
4118
- }, z.prototype.unshift = function(u) {
4119
- return Q(this, u, null, !0, !1);
4120
- };
4121
- function Q(u, s, H, $, fe) {
4122
- p("readableAddChunk", s);
4123
- var te = u._readableState;
4124
- if (s === null)
4125
- te.reading = !1, Be(u, te);
4126
- else {
4127
- var ae;
4128
- if (fe || (ae = S(te, s)), ae)
4129
- m(u, ae);
4130
- else if (te.objectMode || s && s.length > 0)
4131
- if (typeof s != "string" && !te.objectMode && Object.getPrototypeOf(s) !== D.prototype && (s = h(s)), $)
4132
- te.endEmitted ? m(u, new w()) : ne(u, te, s, !0);
4133
- else if (te.ended)
4134
- m(u, new X());
4135
- else {
4136
- if (te.destroyed)
4137
- return !1;
4138
- te.reading = !1, te.decoder && !H ? (s = te.decoder.write(s), te.objectMode || s.length !== 0 ? ne(u, te, s, !1) : Se(u, te)) : ne(u, te, s, !1);
4139
- }
4140
- else $ || (te.reading = !1, Se(u, te));
4141
- }
4142
- return !te.ended && (te.length < te.highWaterMark || te.length === 0);
4143
- }
4144
- function ne(u, s, H, $) {
4145
- s.flowing && s.length === 0 && !s.sync ? (s.awaitDrain = 0, u.emit("data", H)) : (s.length += s.objectMode ? 1 : H.length, $ ? s.buffer.unshift(H) : s.buffer.push(H), s.needReadable && Re(u)), Se(u, s);
4146
- }
4147
- function S(u, s) {
4148
- var H;
4149
- return !y(s) && typeof s != "string" && s !== void 0 && !u.objectMode && (H = new V("chunk", ["string", "Buffer", "Uint8Array"], s)), H;
4150
- }
4151
- z.prototype.isPaused = function() {
4152
- return this._readableState.flowing === !1;
4153
- }, z.prototype.setEncoding = function(u) {
4154
- B || (B = tt().StringDecoder);
4155
- var s = new B(u);
4156
- this._readableState.decoder = s, this._readableState.encoding = this._readableState.decoder.encoding;
4157
- for (var H = this._readableState.buffer.head, $ = ""; H !== null; )
4158
- $ += s.write(H.data), H = H.next;
4159
- return this._readableState.buffer.clear(), $ !== "" && this._readableState.buffer.push($), this._readableState.length = $.length, this;
4160
- };
4161
- var se = 1073741824;
4162
- function he(u) {
4163
- return u >= se ? u = se : (u--, u |= u >>> 1, u |= u >>> 2, u |= u >>> 4, u |= u >>> 8, u |= u >>> 16, u++), u;
4164
- }
4165
- function ye(u, s) {
4166
- return u <= 0 || s.length === 0 && s.ended ? 0 : s.objectMode ? 1 : u !== u ? s.flowing && s.length ? s.buffer.head.data.length : s.length : (u > s.highWaterMark && (s.highWaterMark = he(u)), u <= s.length ? u : s.ended ? s.length : (s.needReadable = !0, 0));
4167
- }
4168
- z.prototype.read = function(u) {
4169
- p("read", u), u = parseInt(u, 10);
4170
- var s = this._readableState, H = u;
4171
- if (u !== 0 && (s.emittedReadable = !1), u === 0 && s.needReadable && ((s.highWaterMark !== 0 ? s.length >= s.highWaterMark : s.length > 0) || s.ended))
4172
- return p("read: emitReadable", s.length, s.ended), s.length === 0 && s.ended ? C(this) : Re(this), null;
4173
- if (u = ye(u, s), u === 0 && s.ended)
4174
- return s.length === 0 && C(this), null;
4175
- var $ = s.needReadable;
4176
- p("need readable", $), (s.length === 0 || s.length - u < s.highWaterMark) && ($ = !0, p("length less than watermark", $)), s.ended || s.reading ? ($ = !1, p("reading or ended", $)) : $ && (p("do read"), s.reading = !0, s.sync = !0, s.length === 0 && (s.needReadable = !0), this._read(s.highWaterMark), s.sync = !1, s.reading || (u = ye(H, s)));
4177
- var fe;
4178
- return u > 0 ? fe = _(u, s) : fe = null, fe === null ? (s.needReadable = s.length <= s.highWaterMark, u = 0) : (s.length -= u, s.awaitDrain = 0), s.length === 0 && (s.ended || (s.needReadable = !0), H !== u && s.ended && C(this)), fe !== null && this.emit("data", fe), fe;
4179
- };
4180
- function Be(u, s) {
4181
- if (p("onEofChunk"), !s.ended) {
4182
- if (s.decoder) {
4183
- var H = s.decoder.end();
4184
- H && H.length && (s.buffer.push(H), s.length += s.objectMode ? 1 : H.length);
4185
- }
4186
- s.ended = !0, s.sync ? Re(u) : (s.needReadable = !1, s.emittedReadable || (s.emittedReadable = !0, Ae(u)));
4187
- }
4188
- }
4189
- function Re(u) {
4190
- var s = u._readableState;
4191
- p("emitReadable", s.needReadable, s.emittedReadable), s.needReadable = !1, s.emittedReadable || (p("emitReadable", s.flowing), s.emittedReadable = !0, ue.nextTick(Ae, u));
4192
- }
4193
- function Ae(u) {
4194
- var s = u._readableState;
4195
- p("emitReadable_", s.destroyed, s.length, s.ended), !s.destroyed && (s.length || s.ended) && (u.emit("readable"), s.emittedReadable = !1), s.needReadable = !s.flowing && !s.ended && s.length <= s.highWaterMark, b(u);
4196
- }
4197
- function Se(u, s) {
4198
- s.readingMore || (s.readingMore = !0, ue.nextTick(Te, u, s));
4199
- }
4200
- function Te(u, s) {
4201
- for (; !s.reading && !s.ended && (s.length < s.highWaterMark || s.flowing && s.length === 0); ) {
4202
- var H = s.length;
4203
- if (p("maybeReadMore read 0"), u.read(0), H === s.length)
4204
- break;
4205
- }
4206
- s.readingMore = !1;
4207
- }
4208
- z.prototype._read = function(u) {
4209
- m(this, new K("_read()"));
4210
- }, z.prototype.pipe = function(u, s) {
4211
- var H = this, $ = this._readableState;
4212
- switch ($.pipesCount) {
4213
- case 0:
4214
- $.pipes = u;
4215
- break;
4216
- case 1:
4217
- $.pipes = [$.pipes, u];
4218
- break;
4219
- default:
4220
- $.pipes.push(u);
4221
- break;
4222
- }
4223
- $.pipesCount += 1, p("pipe count=%d opts=%j", $.pipesCount, s);
4224
- var fe = (!s || s.end !== !1) && u !== ue.stdout && u !== ue.stderr, te = fe ? Me : Ue;
4225
- $.endEmitted ? ue.nextTick(te) : H.once("end", te), u.on("unpipe", ae);
4226
- function ae(Ce, Ie) {
4227
- p("onunpipe"), Ce === H && Ie && Ie.hasUnpiped === !1 && (Ie.hasUnpiped = !0, Ke());
4228
- }
4229
- function Me() {
4230
- p("onend"), u.end();
4231
- }
4232
- var G = Le(H);
4233
- u.on("drain", G);
4234
- var je = !1;
4235
- function Ke() {
4236
- p("cleanup"), u.removeListener("close", Pe), u.removeListener("finish", Oe), u.removeListener("drain", G), u.removeListener("error", _e), u.removeListener("unpipe", ae), H.removeListener("end", Me), H.removeListener("end", Ue), H.removeListener("data", me), je = !0, $.awaitDrain && (!u._writableState || u._writableState.needDrain) && G();
4237
- }
4238
- H.on("data", me);
4239
- function me(Ce) {
4240
- p("ondata");
4241
- var Ie = u.write(Ce);
4242
- p("dest.write", Ie), Ie === !1 && (($.pipesCount === 1 && $.pipes === u || $.pipesCount > 1 && ee($.pipes, u) !== -1) && !je && (p("false write response, pause", $.awaitDrain), $.awaitDrain++), H.pause());
4243
- }
4244
- function _e(Ce) {
4245
- p("onerror", Ce), Ue(), u.removeListener("error", _e), v(u, "error") === 0 && m(u, Ce);
4246
- }
4247
- M(u, "error", _e);
4248
- function Pe() {
4249
- u.removeListener("finish", Oe), Ue();
4250
- }
4251
- u.once("close", Pe);
4252
- function Oe() {
4253
- p("onfinish"), u.removeListener("close", Pe), Ue();
4254
- }
4255
- u.once("finish", Oe);
4256
- function Ue() {
4257
- p("unpipe"), H.unpipe(u);
4258
- }
4259
- return u.emit("pipe", H), $.flowing || (p("pipe resume"), H.resume()), u;
4260
- };
4261
- function Le(u) {
4262
- return function() {
4263
- var H = u._readableState;
4264
- p("pipeOnDrain", H.awaitDrain), H.awaitDrain && H.awaitDrain--, H.awaitDrain === 0 && v(u, "data") && (H.flowing = !0, b(u));
4265
- };
4266
- }
4267
- z.prototype.unpipe = function(u) {
4268
- var s = this._readableState, H = {
4269
- hasUnpiped: !1
4270
- };
4271
- if (s.pipesCount === 0) return this;
4272
- if (s.pipesCount === 1)
4273
- return u && u !== s.pipes ? this : (u || (u = s.pipes), s.pipes = null, s.pipesCount = 0, s.flowing = !1, u && u.emit("unpipe", this, H), this);
4274
- if (!u) {
4275
- var $ = s.pipes, fe = s.pipesCount;
4276
- s.pipes = null, s.pipesCount = 0, s.flowing = !1;
4277
- for (var te = 0; te < fe; te++) $[te].emit("unpipe", this, {
4278
- hasUnpiped: !1
4279
- });
4280
- return this;
4281
- }
4282
- var ae = ee(s.pipes, u);
4283
- return ae === -1 ? this : (s.pipes.splice(ae, 1), s.pipesCount -= 1, s.pipesCount === 1 && (s.pipes = s.pipes[0]), u.emit("unpipe", this, H), this);
4284
- }, z.prototype.on = function(u, s) {
4285
- var H = P.prototype.on.call(this, u, s), $ = this._readableState;
4286
- return u === "data" ? ($.readableListening = this.listenerCount("readable") > 0, $.flowing !== !1 && this.resume()) : u === "readable" && !$.endEmitted && !$.readableListening && ($.readableListening = $.needReadable = !0, $.flowing = !1, $.emittedReadable = !1, p("on readable", $.length, $.reading), $.length ? Re(this) : $.reading || ue.nextTick(F, this)), H;
4287
- }, z.prototype.addListener = z.prototype.on, z.prototype.removeListener = function(u, s) {
4288
- var H = P.prototype.removeListener.call(this, u, s);
4289
- return u === "readable" && ue.nextTick(I, this), H;
4290
- }, z.prototype.removeAllListeners = function(u) {
4291
- var s = P.prototype.removeAllListeners.apply(this, arguments);
4292
- return (u === "readable" || u === void 0) && ue.nextTick(I, this), s;
4293
- };
4294
- function I(u) {
4295
- var s = u._readableState;
4296
- s.readableListening = u.listenerCount("readable") > 0, s.resumeScheduled && !s.paused ? s.flowing = !0 : u.listenerCount("data") > 0 && u.resume();
4297
- }
4298
- function F(u) {
4299
- p("readable nexttick read 0"), u.read(0);
4300
- }
4301
- z.prototype.resume = function() {
4302
- var u = this._readableState;
4303
- return u.flowing || (p("resume"), u.flowing = !u.readableListening, q(this, u)), u.paused = !1, this;
4304
- };
4305
- function q(u, s) {
4306
- s.resumeScheduled || (s.resumeScheduled = !0, ue.nextTick(re, u, s));
4307
- }
4308
- function re(u, s) {
4309
- p("resume", s.reading), s.reading || u.read(0), s.resumeScheduled = !1, u.emit("resume"), b(u), s.flowing && !s.reading && u.read(0);
4310
- }
4311
- z.prototype.pause = function() {
4312
- return p("call pause flowing=%j", this._readableState.flowing), this._readableState.flowing !== !1 && (p("pause"), this._readableState.flowing = !1, this.emit("pause")), this._readableState.paused = !0, this;
4313
- };
4314
- function b(u) {
4315
- var s = u._readableState;
4316
- for (p("flow", s.flowing); s.flowing && u.read() !== null; ) ;
4317
- }
4318
- z.prototype.wrap = function(u) {
4319
- var s = this, H = this._readableState, $ = !1;
4320
- u.on("end", function() {
4321
- if (p("wrapped end"), H.decoder && !H.ended) {
4322
- var ae = H.decoder.end();
4323
- ae && ae.length && s.push(ae);
4324
- }
4325
- s.push(null);
4326
- }), u.on("data", function(ae) {
4327
- if (p("wrapped data"), H.decoder && (ae = H.decoder.write(ae)), !(H.objectMode && ae == null) && !(!H.objectMode && (!ae || !ae.length))) {
4328
- var Me = s.push(ae);
4329
- Me || ($ = !0, u.pause());
4330
- }
4331
- });
4332
- for (var fe in u)
4333
- this[fe] === void 0 && typeof u[fe] == "function" && (this[fe] = /* @__PURE__ */ (function(Me) {
4334
- return function() {
4335
- return u[Me].apply(u, arguments);
4336
- };
4337
- })(fe));
4338
- for (var te = 0; te < A.length; te++)
4339
- u.on(A[te], this.emit.bind(this, A[te]));
4340
- return this._read = function(ae) {
4341
- p("wrapped _read", ae), $ && ($ = !1, u.resume());
4342
- }, this;
4343
- }, typeof Symbol == "function" && (z.prototype[Symbol.asyncIterator] = function() {
4344
- return R === void 0 && (R = Qt()), R(this);
4345
- }), Object.defineProperty(z.prototype, "readableHighWaterMark", {
4346
- // making it explicit this property is not enumerable
4347
- // because otherwise some prototype manipulation in
4348
- // userland will fail
4349
- enumerable: !1,
4350
- get: function() {
4351
- return this._readableState.highWaterMark;
4352
- }
4353
- }), Object.defineProperty(z.prototype, "readableBuffer", {
4354
- // making it explicit this property is not enumerable
4355
- // because otherwise some prototype manipulation in
4356
- // userland will fail
4357
- enumerable: !1,
4358
- get: function() {
4359
- return this._readableState && this._readableState.buffer;
4360
- }
4361
- }), Object.defineProperty(z.prototype, "readableFlowing", {
4362
- // making it explicit this property is not enumerable
4363
- // because otherwise some prototype manipulation in
4364
- // userland will fail
4365
- enumerable: !1,
4366
- get: function() {
4367
- return this._readableState.flowing;
4368
- },
4369
- set: function(s) {
4370
- this._readableState && (this._readableState.flowing = s);
4371
- }
4372
- }), z._fromList = _, Object.defineProperty(z.prototype, "readableLength", {
4373
- // making it explicit this property is not enumerable
4374
- // because otherwise some prototype manipulation in
4375
- // userland will fail
4376
- enumerable: !1,
4377
- get: function() {
4378
- return this._readableState.length;
4379
- }
4380
- });
4381
- function _(u, s) {
4382
- if (s.length === 0) return null;
4383
- var H;
4384
- return s.objectMode ? H = s.buffer.shift() : !u || u >= s.length ? (s.decoder ? H = s.buffer.join("") : s.buffer.length === 1 ? H = s.buffer.first() : H = s.buffer.concat(s.length), s.buffer.clear()) : H = s.buffer.consume(u, s.decoder), H;
4385
- }
4386
- function C(u) {
4387
- var s = u._readableState;
4388
- p("endReadable", s.endEmitted), s.endEmitted || (s.ended = !0, ue.nextTick(Z, s, u));
4389
- }
4390
- function Z(u, s) {
4391
- if (p("endReadableNT", u.endEmitted, u.length), !u.endEmitted && u.length === 0 && (u.endEmitted = !0, s.readable = !1, s.emit("end"), u.autoDestroy)) {
4392
- var H = s._writableState;
4393
- (!H || H.autoDestroy && H.finished) && s.destroy();
4394
- }
4395
- }
4396
- typeof Symbol == "function" && (z.from = function(u, s) {
4397
- return d === void 0 && (d = $t()), d(z, u, s);
4398
- });
4399
- function ee(u, s) {
4400
- for (var H = 0, $ = u.length; H < $; H++)
4401
- if (u[H] === s) return H;
4402
- return -1;
4403
- }
4404
- return Ar;
4405
- }
4406
- var Ir, at;
4407
- function St() {
4408
- if (at) return Ir;
4409
- at = 1, Ir = O;
4410
- var c = ze().codes, v = c.ERR_METHOD_NOT_IMPLEMENTED, P = c.ERR_MULTIPLE_CALLBACK, D = c.ERR_TRANSFORM_ALREADY_TRANSFORMING, Y = c.ERR_TRANSFORM_WITH_LENGTH_0, h = Ze();
4411
- Ye()(O, h);
4412
- function y(l, k) {
4413
- var j = this._transformState;
4414
- j.transforming = !1;
4415
- var J = j.writecb;
4416
- if (J === null)
4417
- return this.emit("error", new P());
4418
- j.writechunk = null, j.writecb = null, k != null && this.push(k), J(l);
4419
- var V = this._readableState;
4420
- V.reading = !1, (V.needReadable || V.length < V.highWaterMark) && this._read(V.highWaterMark);
4421
- }
4422
- function O(l) {
4423
- if (!(this instanceof O)) return new O(l);
4424
- h.call(this, l), this._transformState = {
4425
- afterTransform: y.bind(this),
4426
- needTransform: !1,
4427
- transforming: !1,
4428
- writecb: null,
4429
- writechunk: null,
4430
- writeencoding: null
4431
- }, this._readableState.needReadable = !0, this._readableState.sync = !1, l && (typeof l.transform == "function" && (this._transform = l.transform), typeof l.flush == "function" && (this._flush = l.flush)), this.on("prefinish", p);
4432
- }
4433
- function p() {
4434
- var l = this;
4435
- typeof this._flush == "function" && !this._readableState.destroyed ? this._flush(function(k, j) {
4436
- N(l, k, j);
4437
- }) : N(this, null, null);
4438
- }
4439
- O.prototype.push = function(l, k) {
4440
- return this._transformState.needTransform = !1, h.prototype.push.call(this, l, k);
4441
- }, O.prototype._transform = function(l, k, j) {
4442
- j(new v("_transform()"));
4443
- }, O.prototype._write = function(l, k, j) {
4444
- var J = this._transformState;
4445
- if (J.writecb = j, J.writechunk = l, J.writeencoding = k, !J.transforming) {
4446
- var V = this._readableState;
4447
- (J.needTransform || V.needReadable || V.length < V.highWaterMark) && this._read(V.highWaterMark);
4448
- }
4449
- }, O.prototype._read = function(l) {
4450
- var k = this._transformState;
4451
- k.writechunk !== null && !k.transforming ? (k.transforming = !0, this._transform(k.writechunk, k.writeencoding, k.afterTransform)) : k.needTransform = !0;
4452
- }, O.prototype._destroy = function(l, k) {
4453
- h.prototype._destroy.call(this, l, function(j) {
4454
- k(j);
4455
- });
4456
- };
4457
- function N(l, k, j) {
4458
- if (k) return l.emit("error", k);
4459
- if (j != null && l.push(j), l._writableState.length) throw new Y();
4460
- if (l._transformState.transforming) throw new D();
4461
- return l.push(null);
4462
- }
4463
- return Ir;
4464
- }
4465
- var Tr, ft;
4466
- function en() {
4467
- if (ft) return Tr;
4468
- ft = 1, Tr = v;
4469
- var c = St();
4470
- Ye()(v, c);
4471
- function v(P) {
4472
- if (!(this instanceof v)) return new v(P);
4473
- c.call(this, P);
4474
- }
4475
- return v.prototype._transform = function(P, D, Y) {
4476
- Y(null, P);
4477
- }, Tr;
4478
- }
4479
- var Or, st;
4480
- function rn() {
4481
- if (st) return Or;
4482
- st = 1;
4483
- var c;
4484
- function v(j) {
4485
- var J = !1;
4486
- return function() {
4487
- J || (J = !0, j.apply(void 0, arguments));
4488
- };
4489
- }
4490
- var P = ze().codes, D = P.ERR_MISSING_ARGS, Y = P.ERR_STREAM_DESTROYED;
4491
- function h(j) {
4492
- if (j) throw j;
4493
- }
4494
- function y(j) {
4495
- return j.setHeader && typeof j.abort == "function";
4496
- }
4497
- function O(j, J, V, X) {
4498
- X = v(X);
4499
- var K = !1;
4500
- j.on("close", function() {
4501
- K = !0;
4502
- }), c === void 0 && (c = jr()), c(j, {
4503
- readable: J,
4504
- writable: V
4505
- }, function(B) {
4506
- if (B) return X(B);
4507
- K = !0, X();
4508
- });
4509
- var w = !1;
4510
- return function(B) {
4511
- if (!K && !w) {
4512
- if (w = !0, y(j)) return j.abort();
4513
- if (typeof j.destroy == "function") return j.destroy();
4514
- X(B || new Y("pipe"));
4515
- }
4516
- };
4517
- }
4518
- function p(j) {
4519
- j();
4520
- }
4521
- function N(j, J) {
4522
- return j.pipe(J);
4523
- }
4524
- function l(j) {
4525
- return !j.length || typeof j[j.length - 1] != "function" ? h : j.pop();
4526
- }
4527
- function k() {
4528
- for (var j = arguments.length, J = new Array(j), V = 0; V < j; V++)
4529
- J[V] = arguments[V];
4530
- var X = l(J);
4531
- if (Array.isArray(J[0]) && (J = J[0]), J.length < 2)
4532
- throw new D("streams");
4533
- var K, w = J.map(function(B, R) {
4534
- var d = R < J.length - 1, m = R > 0;
4535
- return O(B, d, m, function(A) {
4536
- K || (K = A), A && w.forEach(p), !d && (w.forEach(p), X(K));
4537
- });
4538
- });
4539
- return J.reduce(N);
4540
- }
4541
- return Or = k, Or;
4542
- }
4543
- var Lr, lt;
4544
- function tn() {
4545
- if (lt) return Lr;
4546
- lt = 1, Lr = P;
4547
- var c = mt().EventEmitter, v = Ye();
4548
- v(P, c), P.Readable = Bt(), P.Writable = vt(), P.Duplex = Ze(), P.Transform = St(), P.PassThrough = en(), P.finished = jr(), P.pipeline = rn(), P.Stream = P;
4549
- function P() {
4550
- c.call(this);
4551
- }
4552
- return P.prototype.pipe = function(D, Y) {
4553
- var h = this;
4554
- function y(J) {
4555
- D.writable && D.write(J) === !1 && h.pause && h.pause();
4556
- }
4557
- h.on("data", y);
4558
- function O() {
4559
- h.readable && h.resume && h.resume();
4560
- }
4561
- D.on("drain", O), !D._isStdio && (!Y || Y.end !== !1) && (h.on("end", N), h.on("close", l));
4562
- var p = !1;
4563
- function N() {
4564
- p || (p = !0, D.end());
4565
- }
4566
- function l() {
4567
- p || (p = !0, typeof D.destroy == "function" && D.destroy());
4568
- }
4569
- function k(J) {
4570
- if (j(), c.listenerCount(this, "error") === 0)
4571
- throw J;
4572
- }
4573
- h.on("error", k), D.on("error", k);
4574
- function j() {
4575
- h.removeListener("data", y), D.removeListener("drain", O), h.removeListener("end", N), h.removeListener("close", l), h.removeListener("error", k), D.removeListener("error", k), h.removeListener("end", j), h.removeListener("close", j), D.removeListener("close", j);
4576
- }
4577
- return h.on("end", j), h.on("close", j), D.on("close", j), D.emit("pipe", h), D;
4578
- }, Lr;
4579
- }
4580
- export {
4581
- qt as B,
4582
- un as a,
4583
- fn as b,
4584
- or as c,
4585
- Ye as d,
4586
- Cr as e,
4587
- tn as f,
4588
- ue as p,
4589
- wt as r
4590
- };