1354 lines
49 KiB
JavaScript
1354 lines
49 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: b715dd3a8a120944.5a7f07e15c.js
|
|
* Module id: 42671
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e, t, r) => {
|
|
var i = {
|
|
675: function (e, t) {
|
|
"use strict";
|
|
(t.byteLength = function (e) {
|
|
var t = u(e),
|
|
r = t[0],
|
|
i = t[1];
|
|
return ((r + i) * 3) / 4 - i;
|
|
}),
|
|
(t.toByteArray = function (e) {
|
|
var t,
|
|
r,
|
|
n = u(e),
|
|
a = n[0],
|
|
s = n[1],
|
|
f = new o(((a + s) * 3) / 4 - s),
|
|
c = 0,
|
|
l = s > 0 ? a - 4 : a;
|
|
for (r = 0; r < l; r += 4)
|
|
(t =
|
|
(i[e.charCodeAt(r)] << 18) |
|
|
(i[e.charCodeAt(r + 1)] << 12) |
|
|
(i[e.charCodeAt(r + 2)] << 6) |
|
|
i[e.charCodeAt(r + 3)]),
|
|
(f[c++] = (t >> 16) & 255),
|
|
(f[c++] = (t >> 8) & 255),
|
|
(f[c++] = 255 & t);
|
|
return (
|
|
2 === s &&
|
|
((t =
|
|
(i[e.charCodeAt(r)] << 2) | (i[e.charCodeAt(r + 1)] >> 4)),
|
|
(f[c++] = 255 & t)),
|
|
1 === s &&
|
|
((t =
|
|
(i[e.charCodeAt(r)] << 10) |
|
|
(i[e.charCodeAt(r + 1)] << 4) |
|
|
(i[e.charCodeAt(r + 2)] >> 2)),
|
|
(f[c++] = (t >> 8) & 255),
|
|
(f[c++] = 255 & t)),
|
|
f
|
|
);
|
|
}),
|
|
(t.fromByteArray = function (e) {
|
|
for (
|
|
var t, i = e.length, o = i % 3, n = [], a = 0, s = i - o;
|
|
a < s;
|
|
a += 16383
|
|
)
|
|
n.push(
|
|
(function (e, t, i) {
|
|
for (var o, n = [], a = t; a < i; a += 3)
|
|
(o =
|
|
((e[a] << 16) & 0xff0000) +
|
|
((e[a + 1] << 8) & 65280) +
|
|
(255 & e[a + 2])),
|
|
n.push(
|
|
r[(o >> 18) & 63] +
|
|
r[(o >> 12) & 63] +
|
|
r[(o >> 6) & 63] +
|
|
r[63 & o],
|
|
);
|
|
return n.join("");
|
|
})(e, a, a + 16383 > s ? s : a + 16383),
|
|
);
|
|
return (
|
|
1 === o
|
|
? n.push(r[(t = e[i - 1]) >> 2] + r[(t << 4) & 63] + "==")
|
|
: 2 === o &&
|
|
n.push(
|
|
r[(t = (e[i - 2] << 8) + e[i - 1]) >> 10] +
|
|
r[(t >> 4) & 63] +
|
|
r[(t << 2) & 63] +
|
|
"=",
|
|
),
|
|
n.join("")
|
|
);
|
|
});
|
|
for (
|
|
var r = [],
|
|
i = [],
|
|
o = "u" > typeof Uint8Array ? Uint8Array : Array,
|
|
n =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
|
|
a = 0,
|
|
s = n.length;
|
|
a < s;
|
|
++a
|
|
)
|
|
(r[a] = n[a]), (i[n.charCodeAt(a)] = a);
|
|
function u(e) {
|
|
var t = e.length;
|
|
if (t % 4 > 0)
|
|
throw Error("Invalid string. Length must be a multiple of 4");
|
|
var r = e.indexOf("=");
|
|
-1 === r && (r = t);
|
|
var i = r === t ? 0 : 4 - (r % 4);
|
|
return [r, i];
|
|
}
|
|
(i[45] = 62), (i[95] = 63);
|
|
},
|
|
72: function (e, t, r) {
|
|
"use strict";
|
|
var i = r(675),
|
|
o = r(783),
|
|
n =
|
|
"function" == typeof Symbol && "function" == typeof Symbol.for
|
|
? Symbol.for("nodejs.util.inspect.custom")
|
|
: null;
|
|
function a(e) {
|
|
if (e > 0x7fffffff)
|
|
throw RangeError(
|
|
'The value "' + e + '" is invalid for option "size"',
|
|
);
|
|
var t = new Uint8Array(e);
|
|
return Object.setPrototypeOf(t, s.prototype), t;
|
|
}
|
|
function s(e, t, r) {
|
|
if ("number" == typeof e) {
|
|
if ("string" == typeof t)
|
|
throw TypeError(
|
|
'The "string" argument must be of type string. Received type number',
|
|
);
|
|
return c(e);
|
|
}
|
|
return u(e, t, r);
|
|
}
|
|
function u(e, t, r) {
|
|
if ("string" == typeof e) {
|
|
var i = e,
|
|
o = t;
|
|
if (
|
|
(("string" != typeof o || "" === o) && (o = "utf8"),
|
|
!s.isEncoding(o))
|
|
)
|
|
throw TypeError("Unknown encoding: " + o);
|
|
var n = 0 | p(i, o),
|
|
u = a(n),
|
|
f = u.write(i, o);
|
|
return f !== n && (u = u.slice(0, f)), u;
|
|
}
|
|
if (ArrayBuffer.isView(e)) return l(e);
|
|
if (null == e)
|
|
throw TypeError(
|
|
"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " +
|
|
typeof e,
|
|
);
|
|
if (
|
|
I(e, ArrayBuffer) ||
|
|
(e && I(e.buffer, ArrayBuffer)) ||
|
|
("u" > typeof SharedArrayBuffer &&
|
|
(I(e, SharedArrayBuffer) ||
|
|
(e && I(e.buffer, SharedArrayBuffer))))
|
|
)
|
|
return (function (e, t, r) {
|
|
var i;
|
|
if (t < 0 || e.byteLength < t)
|
|
throw RangeError('"offset" is outside of buffer bounds');
|
|
if (e.byteLength < t + (r || 0))
|
|
throw RangeError('"length" is outside of buffer bounds');
|
|
return (
|
|
Object.setPrototypeOf(
|
|
(i =
|
|
void 0 === t && void 0 === r
|
|
? new Uint8Array(e)
|
|
: void 0 === r
|
|
? new Uint8Array(e, t)
|
|
: new Uint8Array(e, t, r)),
|
|
s.prototype,
|
|
),
|
|
i
|
|
);
|
|
})(e, t, r);
|
|
if ("number" == typeof e)
|
|
throw TypeError(
|
|
'The "value" argument must not be of type number. Received type number',
|
|
);
|
|
var c = e.valueOf && e.valueOf();
|
|
if (null != c && c !== e) return s.from(c, t, r);
|
|
var d = (function (e) {
|
|
if (s.isBuffer(e)) {
|
|
var t = 0 | h(e.length),
|
|
r = a(t);
|
|
return 0 === r.length || e.copy(r, 0, 0, t), r;
|
|
}
|
|
return void 0 !== e.length
|
|
? "number" != typeof e.length ||
|
|
(function (e) {
|
|
return e != e;
|
|
})(e.length)
|
|
? a(0)
|
|
: l(e)
|
|
: "Buffer" === e.type && Array.isArray(e.data)
|
|
? l(e.data)
|
|
: void 0;
|
|
})(e);
|
|
if (d) return d;
|
|
if (
|
|
"u" > typeof Symbol &&
|
|
null != Symbol.toPrimitive &&
|
|
"function" == typeof e[Symbol.toPrimitive]
|
|
)
|
|
return s.from(e[Symbol.toPrimitive]("string"), t, r);
|
|
throw TypeError(
|
|
"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " +
|
|
typeof e,
|
|
);
|
|
}
|
|
function f(e) {
|
|
if ("number" != typeof e)
|
|
throw TypeError('"size" argument must be of type number');
|
|
if (e < 0)
|
|
throw RangeError(
|
|
'The value "' + e + '" is invalid for option "size"',
|
|
);
|
|
}
|
|
function c(e) {
|
|
return f(e), a(e < 0 ? 0 : 0 | h(e));
|
|
}
|
|
function l(e) {
|
|
for (
|
|
var t = e.length < 0 ? 0 : 0 | h(e.length), r = a(t), i = 0;
|
|
i < t;
|
|
i += 1
|
|
)
|
|
r[i] = 255 & e[i];
|
|
return r;
|
|
}
|
|
(t.Buffer = s),
|
|
(t.SlowBuffer = function (e) {
|
|
return +e != e && (e = 0), s.alloc(+e);
|
|
}),
|
|
(t.INSPECT_MAX_BYTES = 50),
|
|
(t.kMaxLength = 0x7fffffff),
|
|
(s.TYPED_ARRAY_SUPPORT = (function () {
|
|
try {
|
|
var e = new Uint8Array(1),
|
|
t = {
|
|
foo: function () {
|
|
return 42;
|
|
},
|
|
};
|
|
return (
|
|
Object.setPrototypeOf(t, Uint8Array.prototype),
|
|
Object.setPrototypeOf(e, t),
|
|
42 === e.foo()
|
|
);
|
|
} catch (e) {
|
|
return !1;
|
|
}
|
|
})()),
|
|
!s.TYPED_ARRAY_SUPPORT &&
|
|
"u" > typeof console &&
|
|
"function" == typeof console.error &&
|
|
console.error(
|
|
"This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.",
|
|
),
|
|
Object.defineProperty(s.prototype, "parent", {
|
|
enumerable: !0,
|
|
get: function () {
|
|
if (s.isBuffer(this)) return this.buffer;
|
|
},
|
|
}),
|
|
Object.defineProperty(s.prototype, "offset", {
|
|
enumerable: !0,
|
|
get: function () {
|
|
if (s.isBuffer(this)) return this.byteOffset;
|
|
},
|
|
}),
|
|
(s.poolSize = 8192),
|
|
(s.from = function (e, t, r) {
|
|
return u(e, t, r);
|
|
}),
|
|
Object.setPrototypeOf(s.prototype, Uint8Array.prototype),
|
|
Object.setPrototypeOf(s, Uint8Array),
|
|
(s.alloc = function (e, t, r) {
|
|
return (f(e), e <= 0)
|
|
? a(e)
|
|
: void 0 !== t
|
|
? "string" == typeof r
|
|
? a(e).fill(t, r)
|
|
: a(e).fill(t)
|
|
: a(e);
|
|
}),
|
|
(s.allocUnsafe = function (e) {
|
|
return c(e);
|
|
}),
|
|
(s.allocUnsafeSlow = function (e) {
|
|
return c(e);
|
|
});
|
|
function h(e) {
|
|
if (e >= 0x7fffffff)
|
|
throw RangeError(
|
|
"Attempt to allocate Buffer larger than maximum size: 0x7fffffff bytes",
|
|
);
|
|
return 0 | e;
|
|
}
|
|
function p(e, t) {
|
|
if (s.isBuffer(e)) return e.length;
|
|
if (ArrayBuffer.isView(e) || I(e, ArrayBuffer)) return e.byteLength;
|
|
if ("string" != typeof e)
|
|
throw TypeError(
|
|
'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' +
|
|
typeof e,
|
|
);
|
|
var r = e.length,
|
|
i = arguments.length > 2 && !0 === arguments[2];
|
|
if (!i && 0 === r) return 0;
|
|
for (var o = !1; ; )
|
|
switch (t) {
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
return r;
|
|
case "utf8":
|
|
case "utf-8":
|
|
return A(e).length;
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return 2 * r;
|
|
case "hex":
|
|
return r >>> 1;
|
|
case "base64":
|
|
return _(e).length;
|
|
default:
|
|
if (o) return i ? -1 : A(e).length;
|
|
(t = ("" + t).toLowerCase()), (o = !0);
|
|
}
|
|
}
|
|
function d(e, t, r) {
|
|
var o,
|
|
n,
|
|
a,
|
|
s = !1;
|
|
if (
|
|
((void 0 === t || t < 0) && (t = 0),
|
|
t > this.length ||
|
|
((void 0 === r || r > this.length) && (r = this.length),
|
|
r <= 0 || (r >>>= 0) <= (t >>>= 0)))
|
|
)
|
|
return "";
|
|
for (e || (e = "utf8"); ; )
|
|
switch (e) {
|
|
case "hex":
|
|
return (function (e, t, r) {
|
|
var i = e.length;
|
|
(!t || t < 0) && (t = 0), (!r || r < 0 || r > i) && (r = i);
|
|
for (var o = "", n = t; n < r; ++n) o += P[e[n]];
|
|
return o;
|
|
})(this, t, r);
|
|
case "utf8":
|
|
case "utf-8":
|
|
return b(this, t, r);
|
|
case "ascii":
|
|
return (function (e, t, r) {
|
|
var i = "";
|
|
r = Math.min(e.length, r);
|
|
for (var o = t; o < r; ++o)
|
|
i += String.fromCharCode(127 & e[o]);
|
|
return i;
|
|
})(this, t, r);
|
|
case "latin1":
|
|
case "binary":
|
|
return (function (e, t, r) {
|
|
var i = "";
|
|
r = Math.min(e.length, r);
|
|
for (var o = t; o < r; ++o) i += String.fromCharCode(e[o]);
|
|
return i;
|
|
})(this, t, r);
|
|
case "base64":
|
|
return (
|
|
(o = this),
|
|
(n = t),
|
|
(a = r),
|
|
0 === n && a === o.length
|
|
? i.fromByteArray(o)
|
|
: i.fromByteArray(o.slice(n, a))
|
|
);
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return (function (e, t, r) {
|
|
for (
|
|
var i = e.slice(t, r), o = "", n = 0;
|
|
n < i.length;
|
|
n += 2
|
|
)
|
|
o += String.fromCharCode(i[n] + 256 * i[n + 1]);
|
|
return o;
|
|
})(this, t, r);
|
|
default:
|
|
if (s) throw TypeError("Unknown encoding: " + e);
|
|
(e = (e + "").toLowerCase()), (s = !0);
|
|
}
|
|
}
|
|
function g(e, t, r) {
|
|
var i = e[t];
|
|
(e[t] = e[r]), (e[r] = i);
|
|
}
|
|
function v(e, t, r, i, o) {
|
|
var n;
|
|
if (0 === e.length) return -1;
|
|
if (
|
|
("string" == typeof r
|
|
? ((i = r), (r = 0))
|
|
: r > 0x7fffffff
|
|
? (r = 0x7fffffff)
|
|
: r < -0x80000000 && (r = -0x80000000),
|
|
(n = r *= 1) != n && (r = o ? 0 : e.length - 1),
|
|
r < 0 && (r = e.length + r),
|
|
r >= e.length)
|
|
)
|
|
if (o) return -1;
|
|
else r = e.length - 1;
|
|
else if (r < 0)
|
|
if (!o) return -1;
|
|
else r = 0;
|
|
if (("string" == typeof t && (t = s.from(t, i)), s.isBuffer(t)))
|
|
return 0 === t.length ? -1 : y(e, t, r, i, o);
|
|
if ("number" == typeof t) {
|
|
if (
|
|
((t &= 255), "function" == typeof Uint8Array.prototype.indexOf)
|
|
)
|
|
if (o) return Uint8Array.prototype.indexOf.call(e, t, r);
|
|
else return Uint8Array.prototype.lastIndexOf.call(e, t, r);
|
|
return y(e, [t], r, i, o);
|
|
}
|
|
throw TypeError("val must be string, number or Buffer");
|
|
}
|
|
function y(e, t, r, i, o) {
|
|
var n,
|
|
a = 1,
|
|
s = e.length,
|
|
u = t.length;
|
|
if (
|
|
void 0 !== i &&
|
|
("ucs2" === (i = String(i).toLowerCase()) ||
|
|
"ucs-2" === i ||
|
|
"utf16le" === i ||
|
|
"utf-16le" === i)
|
|
) {
|
|
if (e.length < 2 || t.length < 2) return -1;
|
|
(a = 2), (s /= 2), (u /= 2), (r /= 2);
|
|
}
|
|
function f(e, t) {
|
|
return 1 === a ? e[t] : e.readUInt16BE(t * a);
|
|
}
|
|
if (o) {
|
|
var c = -1;
|
|
for (n = r; n < s; n++)
|
|
if (f(e, n) === f(t, -1 === c ? 0 : n - c)) {
|
|
if ((-1 === c && (c = n), n - c + 1 === u)) return c * a;
|
|
} else -1 !== c && (n -= n - c), (c = -1);
|
|
} else
|
|
for (r + u > s && (r = s - u), n = r; n >= 0; n--) {
|
|
for (var l = !0, h = 0; h < u; h++)
|
|
if (f(e, n + h) !== f(t, h)) {
|
|
l = !1;
|
|
break;
|
|
}
|
|
if (l) return n;
|
|
}
|
|
return -1;
|
|
}
|
|
(s.isBuffer = function (e) {
|
|
return null != e && !0 === e._isBuffer && e !== s.prototype;
|
|
}),
|
|
(s.compare = function (e, t) {
|
|
if (
|
|
(I(e, Uint8Array) && (e = s.from(e, e.offset, e.byteLength)),
|
|
I(t, Uint8Array) && (t = s.from(t, t.offset, t.byteLength)),
|
|
!s.isBuffer(e) || !s.isBuffer(t))
|
|
)
|
|
throw TypeError(
|
|
'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array',
|
|
);
|
|
if (e === t) return 0;
|
|
for (
|
|
var r = e.length, i = t.length, o = 0, n = Math.min(r, i);
|
|
o < n;
|
|
++o
|
|
)
|
|
if (e[o] !== t[o]) {
|
|
(r = e[o]), (i = t[o]);
|
|
break;
|
|
}
|
|
return r < i ? -1 : +(i < r);
|
|
}),
|
|
(s.isEncoding = function (e) {
|
|
switch (String(e).toLowerCase()) {
|
|
case "hex":
|
|
case "utf8":
|
|
case "utf-8":
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
case "base64":
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
}),
|
|
(s.concat = function (e, t) {
|
|
if (!Array.isArray(e))
|
|
throw TypeError('"list" argument must be an Array of Buffers');
|
|
if (0 === e.length) return s.alloc(0);
|
|
if (void 0 === t)
|
|
for (r = 0, t = 0; r < e.length; ++r) t += e[r].length;
|
|
var r,
|
|
i = s.allocUnsafe(t),
|
|
o = 0;
|
|
for (r = 0; r < e.length; ++r) {
|
|
var n = e[r];
|
|
if ((I(n, Uint8Array) && (n = s.from(n)), !s.isBuffer(n)))
|
|
throw TypeError(
|
|
'"list" argument must be an Array of Buffers',
|
|
);
|
|
n.copy(i, o), (o += n.length);
|
|
}
|
|
return i;
|
|
}),
|
|
(s.byteLength = p),
|
|
(s.prototype._isBuffer = !0),
|
|
(s.prototype.swap16 = function () {
|
|
var e = this.length;
|
|
if (e % 2 != 0)
|
|
throw RangeError("Buffer size must be a multiple of 16-bits");
|
|
for (var t = 0; t < e; t += 2) g(this, t, t + 1);
|
|
return this;
|
|
}),
|
|
(s.prototype.swap32 = function () {
|
|
var e = this.length;
|
|
if (e % 4 != 0)
|
|
throw RangeError("Buffer size must be a multiple of 32-bits");
|
|
for (var t = 0; t < e; t += 4)
|
|
g(this, t, t + 3), g(this, t + 1, t + 2);
|
|
return this;
|
|
}),
|
|
(s.prototype.swap64 = function () {
|
|
var e = this.length;
|
|
if (e % 8 != 0)
|
|
throw RangeError("Buffer size must be a multiple of 64-bits");
|
|
for (var t = 0; t < e; t += 8)
|
|
g(this, t, t + 7),
|
|
g(this, t + 1, t + 6),
|
|
g(this, t + 2, t + 5),
|
|
g(this, t + 3, t + 4);
|
|
return this;
|
|
}),
|
|
(s.prototype.toString = function () {
|
|
var e = this.length;
|
|
return 0 === e
|
|
? ""
|
|
: 0 == arguments.length
|
|
? b(this, 0, e)
|
|
: d.apply(this, arguments);
|
|
}),
|
|
(s.prototype.toLocaleString = s.prototype.toString),
|
|
(s.prototype.equals = function (e) {
|
|
if (!s.isBuffer(e)) throw TypeError("Argument must be a Buffer");
|
|
return this === e || 0 === s.compare(this, e);
|
|
}),
|
|
(s.prototype.inspect = function () {
|
|
var e = "",
|
|
r = t.INSPECT_MAX_BYTES;
|
|
return (
|
|
(e = this.toString("hex", 0, r)
|
|
.replace(/(.{2})/g, "$1 ")
|
|
.trim()),
|
|
this.length > r && (e += " ... "),
|
|
"<Buffer " + e + ">"
|
|
);
|
|
}),
|
|
n && (s.prototype[n] = s.prototype.inspect),
|
|
(s.prototype.compare = function (e, t, r, i, o) {
|
|
if (
|
|
(I(e, Uint8Array) && (e = s.from(e, e.offset, e.byteLength)),
|
|
!s.isBuffer(e))
|
|
)
|
|
throw TypeError(
|
|
'The "target" argument must be one of type Buffer or Uint8Array. Received type ' +
|
|
typeof e,
|
|
);
|
|
if (
|
|
(void 0 === t && (t = 0),
|
|
void 0 === r && (r = e ? e.length : 0),
|
|
void 0 === i && (i = 0),
|
|
void 0 === o && (o = this.length),
|
|
t < 0 || r > e.length || i < 0 || o > this.length)
|
|
)
|
|
throw RangeError("out of range index");
|
|
if (i >= o && t >= r) return 0;
|
|
if (i >= o) return -1;
|
|
if (t >= r) return 1;
|
|
if (((t >>>= 0), (r >>>= 0), (i >>>= 0), (o >>>= 0), this === e))
|
|
return 0;
|
|
for (
|
|
var n = o - i,
|
|
a = r - t,
|
|
u = Math.min(n, a),
|
|
f = this.slice(i, o),
|
|
c = e.slice(t, r),
|
|
l = 0;
|
|
l < u;
|
|
++l
|
|
)
|
|
if (f[l] !== c[l]) {
|
|
(n = f[l]), (a = c[l]);
|
|
break;
|
|
}
|
|
return n < a ? -1 : +(a < n);
|
|
}),
|
|
(s.prototype.includes = function (e, t, r) {
|
|
return -1 !== this.indexOf(e, t, r);
|
|
}),
|
|
(s.prototype.indexOf = function (e, t, r) {
|
|
return v(this, e, t, r, !0);
|
|
}),
|
|
(s.prototype.lastIndexOf = function (e, t, r) {
|
|
return v(this, e, t, r, !1);
|
|
});
|
|
function b(e, t, r) {
|
|
r = Math.min(e.length, r);
|
|
for (var i = [], o = t; o < r; ) {
|
|
var n,
|
|
a,
|
|
s,
|
|
u,
|
|
f = e[o],
|
|
c = null,
|
|
l = f > 239 ? 4 : f > 223 ? 3 : f > 191 ? 2 : 1;
|
|
if (o + l <= r)
|
|
switch (l) {
|
|
case 1:
|
|
f < 128 && (c = f);
|
|
break;
|
|
case 2:
|
|
(192 & (n = e[o + 1])) == 128 &&
|
|
(u = ((31 & f) << 6) | (63 & n)) > 127 &&
|
|
(c = u);
|
|
break;
|
|
case 3:
|
|
(n = e[o + 1]),
|
|
(a = e[o + 2]),
|
|
(192 & n) == 128 &&
|
|
(192 & a) == 128 &&
|
|
(u = ((15 & f) << 12) | ((63 & n) << 6) | (63 & a)) >
|
|
2047 &&
|
|
(u < 55296 || u > 57343) &&
|
|
(c = u);
|
|
break;
|
|
case 4:
|
|
(n = e[o + 1]),
|
|
(a = e[o + 2]),
|
|
(s = e[o + 3]),
|
|
(192 & n) == 128 &&
|
|
(192 & a) == 128 &&
|
|
(192 & s) == 128 &&
|
|
(u =
|
|
((15 & f) << 18) |
|
|
((63 & n) << 12) |
|
|
((63 & a) << 6) |
|
|
(63 & s)) > 65535 &&
|
|
u < 1114112 &&
|
|
(c = u);
|
|
}
|
|
null === c
|
|
? ((c = 65533), (l = 1))
|
|
: c > 65535 &&
|
|
((c -= 65536),
|
|
i.push(((c >>> 10) & 1023) | 55296),
|
|
(c = 56320 | (1023 & c))),
|
|
i.push(c),
|
|
(o += l);
|
|
}
|
|
var h = i,
|
|
p = h.length;
|
|
if (p <= 4096) return String.fromCharCode.apply(String, h);
|
|
for (var d = "", g = 0; g < p; )
|
|
d += String.fromCharCode.apply(String, h.slice(g, (g += 4096)));
|
|
return d;
|
|
}
|
|
function C(e, t, r) {
|
|
if (e % 1 != 0 || e < 0) throw RangeError("offset is not uint");
|
|
if (e + t > r)
|
|
throw RangeError("Trying to access beyond buffer length");
|
|
}
|
|
function m(e, t, r, i, o, n) {
|
|
if (!s.isBuffer(e))
|
|
throw TypeError('"buffer" argument must be a Buffer instance');
|
|
if (t > o || t < n)
|
|
throw RangeError('"value" argument is out of bounds');
|
|
if (r + i > e.length) throw RangeError("Index out of range");
|
|
}
|
|
function k(e, t, r, i, o, n) {
|
|
if (r + i > e.length || r < 0)
|
|
throw RangeError("Index out of range");
|
|
}
|
|
function w(e, t, r, i, n) {
|
|
return (
|
|
(t *= 1),
|
|
(r >>>= 0),
|
|
n || k(e, t, r, 4, 34028234663852886e22, -34028234663852886e22),
|
|
o.write(e, t, r, i, 23, 4),
|
|
r + 4
|
|
);
|
|
}
|
|
function O(e, t, r, i, n) {
|
|
return (
|
|
(t *= 1),
|
|
(r >>>= 0),
|
|
n || k(e, t, r, 8, 17976931348623157e292, -17976931348623157e292),
|
|
o.write(e, t, r, i, 52, 8),
|
|
r + 8
|
|
);
|
|
}
|
|
(s.prototype.write = function (e, t, r, i) {
|
|
if (void 0 === t) (i = "utf8"), (r = this.length), (t = 0);
|
|
else if (void 0 === r && "string" == typeof t)
|
|
(i = t), (r = this.length), (t = 0);
|
|
else if (isFinite(t))
|
|
(t >>>= 0),
|
|
isFinite(r)
|
|
? ((r >>>= 0), void 0 === i && (i = "utf8"))
|
|
: ((i = r), (r = void 0));
|
|
else
|
|
throw Error(
|
|
"Buffer.write(string, encoding, offset[, length]) is no longer supported",
|
|
);
|
|
var o,
|
|
n,
|
|
a,
|
|
s,
|
|
u,
|
|
f,
|
|
c,
|
|
l,
|
|
h = this.length - t;
|
|
if (
|
|
((void 0 === r || r > h) && (r = h),
|
|
(e.length > 0 && (r < 0 || t < 0)) || t > this.length)
|
|
)
|
|
throw RangeError("Attempt to write outside buffer bounds");
|
|
i || (i = "utf8");
|
|
for (var p = !1; ; )
|
|
switch (i) {
|
|
case "hex":
|
|
return (function (e, t, r, i) {
|
|
r = Number(r) || 0;
|
|
var o = e.length - r;
|
|
i ? (i = Number(i)) > o && (i = o) : (i = o);
|
|
var n = t.length;
|
|
i > n / 2 && (i = n / 2);
|
|
for (var a = 0; a < i; ++a) {
|
|
var s,
|
|
u = parseInt(t.substr(2 * a, 2), 16);
|
|
if ((s = u) != s) break;
|
|
e[r + a] = u;
|
|
}
|
|
return a;
|
|
})(this, e, t, r);
|
|
case "utf8":
|
|
case "utf-8":
|
|
return (o = t), (n = r), S(A(e, this.length - o), this, o, n);
|
|
case "ascii":
|
|
return (a = t), (s = r), S(x(e), this, a, s);
|
|
case "latin1":
|
|
case "binary":
|
|
return (function (e, t, r, i) {
|
|
return S(x(t), e, r, i);
|
|
})(this, e, t, r);
|
|
case "base64":
|
|
return (u = t), (f = r), S(_(e), this, u, f);
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return (
|
|
(c = t),
|
|
(l = r),
|
|
S(
|
|
(function (e, t) {
|
|
for (
|
|
var r, i, o = [], n = 0;
|
|
n < e.length && !((t -= 2) < 0);
|
|
++n
|
|
)
|
|
(i = (r = e.charCodeAt(n)) >> 8),
|
|
o.push(r % 256),
|
|
o.push(i);
|
|
return o;
|
|
})(e, this.length - c),
|
|
this,
|
|
c,
|
|
l,
|
|
)
|
|
);
|
|
default:
|
|
if (p) throw TypeError("Unknown encoding: " + i);
|
|
(i = ("" + i).toLowerCase()), (p = !0);
|
|
}
|
|
}),
|
|
(s.prototype.toJSON = function () {
|
|
return {
|
|
type: "Buffer",
|
|
data: Array.prototype.slice.call(this._arr || this, 0),
|
|
};
|
|
}),
|
|
(s.prototype.slice = function (e, t) {
|
|
var r = this.length;
|
|
(e = ~~e),
|
|
(t = void 0 === t ? r : ~~t),
|
|
e < 0 ? (e += r) < 0 && (e = 0) : e > r && (e = r),
|
|
t < 0 ? (t += r) < 0 && (t = 0) : t > r && (t = r),
|
|
t < e && (t = e);
|
|
var i = this.subarray(e, t);
|
|
return Object.setPrototypeOf(i, s.prototype), i;
|
|
}),
|
|
(s.prototype.readUIntLE = function (e, t, r) {
|
|
(e >>>= 0), (t >>>= 0), r || C(e, t, this.length);
|
|
for (var i = this[e], o = 1, n = 0; ++n < t && (o *= 256); )
|
|
i += this[e + n] * o;
|
|
return i;
|
|
}),
|
|
(s.prototype.readUIntBE = function (e, t, r) {
|
|
(e >>>= 0), (t >>>= 0), r || C(e, t, this.length);
|
|
for (var i = this[e + --t], o = 1; t > 0 && (o *= 256); )
|
|
i += this[e + --t] * o;
|
|
return i;
|
|
}),
|
|
(s.prototype.readUInt8 = function (e, t) {
|
|
return (e >>>= 0), t || C(e, 1, this.length), this[e];
|
|
}),
|
|
(s.prototype.readUInt16LE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 2, this.length),
|
|
this[e] | (this[e + 1] << 8)
|
|
);
|
|
}),
|
|
(s.prototype.readUInt16BE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 2, this.length),
|
|
(this[e] << 8) | this[e + 1]
|
|
);
|
|
}),
|
|
(s.prototype.readUInt32LE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 4, this.length),
|
|
(this[e] | (this[e + 1] << 8) | (this[e + 2] << 16)) +
|
|
0x1000000 * this[e + 3]
|
|
);
|
|
}),
|
|
(s.prototype.readUInt32BE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 4, this.length),
|
|
0x1000000 * this[e] +
|
|
((this[e + 1] << 16) | (this[e + 2] << 8) | this[e + 3])
|
|
);
|
|
}),
|
|
(s.prototype.readIntLE = function (e, t, r) {
|
|
(e >>>= 0), (t >>>= 0), r || C(e, t, this.length);
|
|
for (var i = this[e], o = 1, n = 0; ++n < t && (o *= 256); )
|
|
i += this[e + n] * o;
|
|
return i >= (o *= 128) && (i -= Math.pow(2, 8 * t)), i;
|
|
}),
|
|
(s.prototype.readIntBE = function (e, t, r) {
|
|
(e >>>= 0), (t >>>= 0), r || C(e, t, this.length);
|
|
for (var i = t, o = 1, n = this[e + --i]; i > 0 && (o *= 256); )
|
|
n += this[e + --i] * o;
|
|
return n >= (o *= 128) && (n -= Math.pow(2, 8 * t)), n;
|
|
}),
|
|
(s.prototype.readInt8 = function (e, t) {
|
|
return ((e >>>= 0), t || C(e, 1, this.length), 128 & this[e])
|
|
? -((255 - this[e] + 1) * 1)
|
|
: this[e];
|
|
}),
|
|
(s.prototype.readInt16LE = function (e, t) {
|
|
(e >>>= 0), t || C(e, 2, this.length);
|
|
var r = this[e] | (this[e + 1] << 8);
|
|
return 32768 & r ? 0xffff0000 | r : r;
|
|
}),
|
|
(s.prototype.readInt16BE = function (e, t) {
|
|
(e >>>= 0), t || C(e, 2, this.length);
|
|
var r = this[e + 1] | (this[e] << 8);
|
|
return 32768 & r ? 0xffff0000 | r : r;
|
|
}),
|
|
(s.prototype.readInt32LE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 4, this.length),
|
|
this[e] |
|
|
(this[e + 1] << 8) |
|
|
(this[e + 2] << 16) |
|
|
(this[e + 3] << 24)
|
|
);
|
|
}),
|
|
(s.prototype.readInt32BE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 4, this.length),
|
|
(this[e] << 24) |
|
|
(this[e + 1] << 16) |
|
|
(this[e + 2] << 8) |
|
|
this[e + 3]
|
|
);
|
|
}),
|
|
(s.prototype.readFloatLE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 4, this.length),
|
|
o.read(this, e, !0, 23, 4)
|
|
);
|
|
}),
|
|
(s.prototype.readFloatBE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 4, this.length),
|
|
o.read(this, e, !1, 23, 4)
|
|
);
|
|
}),
|
|
(s.prototype.readDoubleLE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 8, this.length),
|
|
o.read(this, e, !0, 52, 8)
|
|
);
|
|
}),
|
|
(s.prototype.readDoubleBE = function (e, t) {
|
|
return (
|
|
(e >>>= 0),
|
|
t || C(e, 8, this.length),
|
|
o.read(this, e, !1, 52, 8)
|
|
);
|
|
}),
|
|
(s.prototype.writeUIntLE = function (e, t, r, i) {
|
|
if (((e *= 1), (t >>>= 0), (r >>>= 0), !i)) {
|
|
var o = Math.pow(2, 8 * r) - 1;
|
|
m(this, e, t, r, o, 0);
|
|
}
|
|
var n = 1,
|
|
a = 0;
|
|
for (this[t] = 255 & e; ++a < r && (n *= 256); )
|
|
this[t + a] = (e / n) & 255;
|
|
return t + r;
|
|
}),
|
|
(s.prototype.writeUIntBE = function (e, t, r, i) {
|
|
if (((e *= 1), (t >>>= 0), (r >>>= 0), !i)) {
|
|
var o = Math.pow(2, 8 * r) - 1;
|
|
m(this, e, t, r, o, 0);
|
|
}
|
|
var n = r - 1,
|
|
a = 1;
|
|
for (this[t + n] = 255 & e; --n >= 0 && (a *= 256); )
|
|
this[t + n] = (e / a) & 255;
|
|
return t + r;
|
|
}),
|
|
(s.prototype.writeUInt8 = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 1, 255, 0),
|
|
(this[t] = 255 & e),
|
|
t + 1
|
|
);
|
|
}),
|
|
(s.prototype.writeUInt16LE = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 2, 65535, 0),
|
|
(this[t] = 255 & e),
|
|
(this[t + 1] = e >>> 8),
|
|
t + 2
|
|
);
|
|
}),
|
|
(s.prototype.writeUInt16BE = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 2, 65535, 0),
|
|
(this[t] = e >>> 8),
|
|
(this[t + 1] = 255 & e),
|
|
t + 2
|
|
);
|
|
}),
|
|
(s.prototype.writeUInt32LE = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 4, 0xffffffff, 0),
|
|
(this[t + 3] = e >>> 24),
|
|
(this[t + 2] = e >>> 16),
|
|
(this[t + 1] = e >>> 8),
|
|
(this[t] = 255 & e),
|
|
t + 4
|
|
);
|
|
}),
|
|
(s.prototype.writeUInt32BE = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 4, 0xffffffff, 0),
|
|
(this[t] = e >>> 24),
|
|
(this[t + 1] = e >>> 16),
|
|
(this[t + 2] = e >>> 8),
|
|
(this[t + 3] = 255 & e),
|
|
t + 4
|
|
);
|
|
}),
|
|
(s.prototype.writeIntLE = function (e, t, r, i) {
|
|
if (((e *= 1), (t >>>= 0), !i)) {
|
|
var o = Math.pow(2, 8 * r - 1);
|
|
m(this, e, t, r, o - 1, -o);
|
|
}
|
|
var n = 0,
|
|
a = 1,
|
|
s = 0;
|
|
for (this[t] = 255 & e; ++n < r && (a *= 256); )
|
|
e < 0 && 0 === s && 0 !== this[t + n - 1] && (s = 1),
|
|
(this[t + n] = (((e / a) | 0) - s) & 255);
|
|
return t + r;
|
|
}),
|
|
(s.prototype.writeIntBE = function (e, t, r, i) {
|
|
if (((e *= 1), (t >>>= 0), !i)) {
|
|
var o = Math.pow(2, 8 * r - 1);
|
|
m(this, e, t, r, o - 1, -o);
|
|
}
|
|
var n = r - 1,
|
|
a = 1,
|
|
s = 0;
|
|
for (this[t + n] = 255 & e; --n >= 0 && (a *= 256); )
|
|
e < 0 && 0 === s && 0 !== this[t + n + 1] && (s = 1),
|
|
(this[t + n] = (((e / a) | 0) - s) & 255);
|
|
return t + r;
|
|
}),
|
|
(s.prototype.writeInt8 = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 1, 127, -128),
|
|
e < 0 && (e = 255 + e + 1),
|
|
(this[t] = 255 & e),
|
|
t + 1
|
|
);
|
|
}),
|
|
(s.prototype.writeInt16LE = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 2, 32767, -32768),
|
|
(this[t] = 255 & e),
|
|
(this[t + 1] = e >>> 8),
|
|
t + 2
|
|
);
|
|
}),
|
|
(s.prototype.writeInt16BE = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 2, 32767, -32768),
|
|
(this[t] = e >>> 8),
|
|
(this[t + 1] = 255 & e),
|
|
t + 2
|
|
);
|
|
}),
|
|
(s.prototype.writeInt32LE = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 4, 0x7fffffff, -0x80000000),
|
|
(this[t] = 255 & e),
|
|
(this[t + 1] = e >>> 8),
|
|
(this[t + 2] = e >>> 16),
|
|
(this[t + 3] = e >>> 24),
|
|
t + 4
|
|
);
|
|
}),
|
|
(s.prototype.writeInt32BE = function (e, t, r) {
|
|
return (
|
|
(e *= 1),
|
|
(t >>>= 0),
|
|
r || m(this, e, t, 4, 0x7fffffff, -0x80000000),
|
|
e < 0 && (e = 0xffffffff + e + 1),
|
|
(this[t] = e >>> 24),
|
|
(this[t + 1] = e >>> 16),
|
|
(this[t + 2] = e >>> 8),
|
|
(this[t + 3] = 255 & e),
|
|
t + 4
|
|
);
|
|
}),
|
|
(s.prototype.writeFloatLE = function (e, t, r) {
|
|
return w(this, e, t, !0, r);
|
|
}),
|
|
(s.prototype.writeFloatBE = function (e, t, r) {
|
|
return w(this, e, t, !1, r);
|
|
}),
|
|
(s.prototype.writeDoubleLE = function (e, t, r) {
|
|
return O(this, e, t, !0, r);
|
|
}),
|
|
(s.prototype.writeDoubleBE = function (e, t, r) {
|
|
return O(this, e, t, !1, r);
|
|
}),
|
|
(s.prototype.copy = function (e, t, r, i) {
|
|
if (!s.isBuffer(e))
|
|
throw TypeError("argument should be a Buffer");
|
|
if (
|
|
(r || (r = 0),
|
|
i || 0 === i || (i = this.length),
|
|
t >= e.length && (t = e.length),
|
|
t || (t = 0),
|
|
i > 0 && i < r && (i = r),
|
|
i === r || 0 === e.length || 0 === this.length)
|
|
)
|
|
return 0;
|
|
if (t < 0) throw RangeError("targetStart out of bounds");
|
|
if (r < 0 || r >= this.length)
|
|
throw RangeError("Index out of range");
|
|
if (i < 0) throw RangeError("sourceEnd out of bounds");
|
|
i > this.length && (i = this.length),
|
|
e.length - t < i - r && (i = e.length - t + r);
|
|
var o = i - r;
|
|
if (
|
|
this === e &&
|
|
"function" == typeof Uint8Array.prototype.copyWithin
|
|
)
|
|
this.copyWithin(t, r, i);
|
|
else if (this === e && r < t && t < i)
|
|
for (var n = o - 1; n >= 0; --n) e[n + t] = this[n + r];
|
|
else Uint8Array.prototype.set.call(e, this.subarray(r, i), t);
|
|
return o;
|
|
}),
|
|
(s.prototype.fill = function (e, t, r, i) {
|
|
if ("string" == typeof e) {
|
|
if (
|
|
("string" == typeof t
|
|
? ((i = t), (t = 0), (r = this.length))
|
|
: "string" == typeof r && ((i = r), (r = this.length)),
|
|
void 0 !== i && "string" != typeof i)
|
|
)
|
|
throw TypeError("encoding must be a string");
|
|
if ("string" == typeof i && !s.isEncoding(i))
|
|
throw TypeError("Unknown encoding: " + i);
|
|
if (1 === e.length) {
|
|
var o,
|
|
n = e.charCodeAt(0);
|
|
(("utf8" === i && n < 128) || "latin1" === i) && (e = n);
|
|
}
|
|
} else
|
|
"number" == typeof e
|
|
? (e &= 255)
|
|
: "boolean" == typeof e && (e = Number(e));
|
|
if (t < 0 || this.length < t || this.length < r)
|
|
throw RangeError("Out of range index");
|
|
if (r <= t) return this;
|
|
if (
|
|
((t >>>= 0),
|
|
(r = void 0 === r ? this.length : r >>> 0),
|
|
e || (e = 0),
|
|
"number" == typeof e)
|
|
)
|
|
for (o = t; o < r; ++o) this[o] = e;
|
|
else {
|
|
var a = s.isBuffer(e) ? e : s.from(e, i),
|
|
u = a.length;
|
|
if (0 === u)
|
|
throw TypeError(
|
|
'The value "' + e + '" is invalid for argument "value"',
|
|
);
|
|
for (o = 0; o < r - t; ++o) this[o + t] = a[o % u];
|
|
}
|
|
return this;
|
|
});
|
|
var E = /[^+/0-9A-Za-z-_]/g;
|
|
function A(e, t) {
|
|
t = t || 1 / 0;
|
|
for (var r, i = e.length, o = null, n = [], a = 0; a < i; ++a) {
|
|
if ((r = e.charCodeAt(a)) > 55295 && r < 57344) {
|
|
if (!o) {
|
|
if (r > 56319 || a + 1 === i) {
|
|
(t -= 3) > -1 && n.push(239, 191, 189);
|
|
continue;
|
|
}
|
|
o = r;
|
|
continue;
|
|
}
|
|
if (r < 56320) {
|
|
(t -= 3) > -1 && n.push(239, 191, 189), (o = r);
|
|
continue;
|
|
}
|
|
r = (((o - 55296) << 10) | (r - 56320)) + 65536;
|
|
} else o && (t -= 3) > -1 && n.push(239, 191, 189);
|
|
if (((o = null), r < 128)) {
|
|
if ((t -= 1) < 0) break;
|
|
n.push(r);
|
|
} else if (r < 2048) {
|
|
if ((t -= 2) < 0) break;
|
|
n.push((r >> 6) | 192, (63 & r) | 128);
|
|
} else if (r < 65536) {
|
|
if ((t -= 3) < 0) break;
|
|
n.push((r >> 12) | 224, ((r >> 6) & 63) | 128, (63 & r) | 128);
|
|
} else if (r < 1114112) {
|
|
if ((t -= 4) < 0) break;
|
|
n.push(
|
|
(r >> 18) | 240,
|
|
((r >> 12) & 63) | 128,
|
|
((r >> 6) & 63) | 128,
|
|
(63 & r) | 128,
|
|
);
|
|
} else throw Error("Invalid code point");
|
|
}
|
|
return n;
|
|
}
|
|
function x(e) {
|
|
for (var t = [], r = 0; r < e.length; ++r)
|
|
t.push(255 & e.charCodeAt(r));
|
|
return t;
|
|
}
|
|
function _(e) {
|
|
return i.toByteArray(
|
|
(function (e) {
|
|
if (
|
|
(e = (e = e.split("=")[0]).trim().replace(E, "")).length < 2
|
|
)
|
|
return "";
|
|
for (; e.length % 4 != 0; ) e += "=";
|
|
return e;
|
|
})(e),
|
|
);
|
|
}
|
|
function S(e, t, r, i) {
|
|
for (
|
|
var o = 0;
|
|
o < i && !(o + r >= t.length) && !(o >= e.length);
|
|
++o
|
|
)
|
|
t[o + r] = e[o];
|
|
return o;
|
|
}
|
|
function I(e, t) {
|
|
return (
|
|
e instanceof t ||
|
|
(null != e &&
|
|
null != e.constructor &&
|
|
null != e.constructor.name &&
|
|
e.constructor.name === t.name)
|
|
);
|
|
}
|
|
var P = (function () {
|
|
for (var e = "0123456789abcdef", t = Array(256), r = 0; r < 16; ++r)
|
|
for (var i = 16 * r, o = 0; o < 16; ++o) t[i + o] = e[r] + e[o];
|
|
return t;
|
|
})();
|
|
},
|
|
783: function (e, t) {
|
|
(t.read = function (e, t, r, i, o) {
|
|
var n,
|
|
a,
|
|
s = 8 * o - i - 1,
|
|
u = (1 << s) - 1,
|
|
f = u >> 1,
|
|
c = -7,
|
|
l = r ? o - 1 : 0,
|
|
h = r ? -1 : 1,
|
|
p = e[t + l];
|
|
for (
|
|
l += h, n = p & ((1 << -c) - 1), p >>= -c, c += s;
|
|
c > 0;
|
|
n = 256 * n + e[t + l], l += h, c -= 8
|
|
);
|
|
for (
|
|
a = n & ((1 << -c) - 1), n >>= -c, c += i;
|
|
c > 0;
|
|
a = 256 * a + e[t + l], l += h, c -= 8
|
|
);
|
|
if (0 === n) n = 1 - f;
|
|
else {
|
|
if (n === u) return a ? NaN : (1 / 0) * (p ? -1 : 1);
|
|
(a += Math.pow(2, i)), (n -= f);
|
|
}
|
|
return (p ? -1 : 1) * a * Math.pow(2, n - i);
|
|
}),
|
|
(t.write = function (e, t, r, i, o, n) {
|
|
var a,
|
|
s,
|
|
u,
|
|
f = 8 * n - o - 1,
|
|
c = (1 << f) - 1,
|
|
l = c >> 1,
|
|
h = 5960464477539062e-23 * (23 === o),
|
|
p = i ? 0 : n - 1,
|
|
d = i ? 1 : -1,
|
|
g = +(t < 0 || (0 === t && 1 / t < 0));
|
|
for (
|
|
isNaN((t = Math.abs(t))) || t === 1 / 0
|
|
? ((s = +!!isNaN(t)), (a = c))
|
|
: ((a = Math.floor(Math.log(t) / Math.LN2)),
|
|
t * (u = Math.pow(2, -a)) < 1 && (a--, (u *= 2)),
|
|
a + l >= 1 ? (t += h / u) : (t += h * Math.pow(2, 1 - l)),
|
|
t * u >= 2 && (a++, (u /= 2)),
|
|
a + l >= c
|
|
? ((s = 0), (a = c))
|
|
: a + l >= 1
|
|
? ((s = (t * u - 1) * Math.pow(2, o)), (a += l))
|
|
: ((s = t * Math.pow(2, l - 1) * Math.pow(2, o)),
|
|
(a = 0)));
|
|
o >= 8;
|
|
e[r + p] = 255 & s, p += d, s /= 256, o -= 8
|
|
);
|
|
for (
|
|
a = (a << o) | s, f += o;
|
|
f > 0;
|
|
e[r + p] = 255 & a, p += d, a /= 256, f -= 8
|
|
);
|
|
e[r + p - d] |= 128 * g;
|
|
});
|
|
},
|
|
},
|
|
o = {};
|
|
function n(e) {
|
|
var t = o[e];
|
|
if (void 0 !== t) return t.exports;
|
|
var r = (o[e] = { exports: {} }),
|
|
a = !0;
|
|
try {
|
|
i[e](r, r.exports, n), (a = !1);
|
|
} finally {
|
|
a && delete o[e];
|
|
}
|
|
return r.exports;
|
|
}
|
|
(n.ab =
|
|
"/ROOT/node_modules/.pnpm/next@16.1.6_@babel+core@7.29.0_@opentelemetry+api@1.9.0_@playwright+test@1.58.1_babel-p_876821d3b4564cd803d7157ee72f8b43/node_modules/next/dist/compiled/buffer/"),
|
|
(t.exports = n(72));
|
|
};
|
|
|
|
export default moduleFactory;
|