2889 lines
102 KiB
JavaScript
2889 lines
102 KiB
JavaScript
/*
|
|
* Support for source maps in V8 stack traces
|
|
* https://github.com/evanw/node-source-map-support
|
|
*/
|
|
/*
|
|
The buffer module from node.js, for the browser.
|
|
|
|
@author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
|
license MIT
|
|
*/
|
|
(
|
|
this.define ||
|
|
function (R, U) {
|
|
this.sourceMapSupport = U();
|
|
}
|
|
)('browser-source-map-support', function (R) {
|
|
(function e(C, J, A) {
|
|
function p(f, c) {
|
|
if (!J[f]) {
|
|
if (!C[f]) {
|
|
var l = 'function' == typeof require && require;
|
|
if (!c && l) return l(f, !0);
|
|
if (t) return t(f, !0);
|
|
throw Error("Cannot find module '" + f + "'");
|
|
}
|
|
l = J[f] = { exports: {} };
|
|
C[f][0].call(
|
|
l.exports,
|
|
function (q) {
|
|
var r = C[f][1][q];
|
|
return p(r ? r : q);
|
|
},
|
|
l,
|
|
l.exports,
|
|
e,
|
|
C,
|
|
J,
|
|
A
|
|
);
|
|
}
|
|
return J[f].exports;
|
|
}
|
|
for (
|
|
var t = 'function' == typeof require && require, m = 0;
|
|
m < A.length;
|
|
m++
|
|
)
|
|
p(A[m]);
|
|
return p;
|
|
})(
|
|
{
|
|
1: [
|
|
function (C, J, A) {
|
|
R = C('./source-map-support');
|
|
},
|
|
{ './source-map-support': 21 },
|
|
],
|
|
2: [
|
|
function (C, J, A) {
|
|
(function (e) {
|
|
function p(m) {
|
|
m = m.charCodeAt(0);
|
|
if (43 === m) return 62;
|
|
if (47 === m) return 63;
|
|
if (48 > m) return -1;
|
|
if (58 > m) return m - 48 + 52;
|
|
if (91 > m) return m - 65;
|
|
if (123 > m) return m - 97 + 26;
|
|
}
|
|
var t = 'undefined' !== typeof Uint8Array ? Uint8Array : Array;
|
|
e.toByteArray = function (m) {
|
|
function f(d) {
|
|
q[k++] = d;
|
|
}
|
|
if (0 < m.length % 4)
|
|
throw Error('Invalid string. Length must be a multiple of 4');
|
|
var c = m.length;
|
|
var l =
|
|
'=' === m.charAt(c - 2) ? 2
|
|
: '=' === m.charAt(c - 1) ? 1
|
|
: 0;
|
|
var q = new t((3 * m.length) / 4 - l);
|
|
var r = 0 < l ? m.length - 4 : m.length;
|
|
var k = 0;
|
|
for (c = 0; c < r; c += 4) {
|
|
var u =
|
|
(p(m.charAt(c)) << 18) |
|
|
(p(m.charAt(c + 1)) << 12) |
|
|
(p(m.charAt(c + 2)) << 6) |
|
|
p(m.charAt(c + 3));
|
|
f((u & 16711680) >> 16);
|
|
f((u & 65280) >> 8);
|
|
f(u & 255);
|
|
}
|
|
2 === l ?
|
|
((u = (p(m.charAt(c)) << 2) | (p(m.charAt(c + 1)) >> 4)),
|
|
f(u & 255))
|
|
: 1 === l &&
|
|
((u =
|
|
(p(m.charAt(c)) << 10) |
|
|
(p(m.charAt(c + 1)) << 4) |
|
|
(p(m.charAt(c + 2)) >> 2)),
|
|
f((u >> 8) & 255),
|
|
f(u & 255));
|
|
return q;
|
|
};
|
|
e.fromByteArray = function (m) {
|
|
var f = m.length % 3,
|
|
c = '',
|
|
l;
|
|
var q = 0;
|
|
for (l = m.length - f; q < l; q += 3) {
|
|
var r = (m[q] << 16) + (m[q + 1] << 8) + m[q + 2];
|
|
r =
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(
|
|
(r >> 18) & 63
|
|
) +
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(
|
|
(r >> 12) & 63
|
|
) +
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(
|
|
(r >> 6) & 63
|
|
) +
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(
|
|
r & 63
|
|
);
|
|
c += r;
|
|
}
|
|
switch (f) {
|
|
case 1:
|
|
r = m[m.length - 1];
|
|
c +=
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(
|
|
r >> 2
|
|
);
|
|
c +=
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(
|
|
(r << 4) & 63
|
|
);
|
|
c += '==';
|
|
break;
|
|
case 2:
|
|
(r = (m[m.length - 2] << 8) + m[m.length - 1]),
|
|
(c +=
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(
|
|
r >> 10
|
|
)),
|
|
(c +=
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(
|
|
(r >> 4) & 63
|
|
)),
|
|
(c +=
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(
|
|
(r << 2) & 63
|
|
)),
|
|
(c += '=');
|
|
}
|
|
return c;
|
|
};
|
|
})('undefined' === typeof A ? (this.base64js = {}) : A);
|
|
},
|
|
{},
|
|
],
|
|
3: [function (C, J, A) {}, {}],
|
|
4: [
|
|
function (C, J, A) {
|
|
(function (e) {
|
|
var p = Object.prototype.toString,
|
|
t =
|
|
'function' === typeof e.alloc &&
|
|
'function' === typeof e.allocUnsafe &&
|
|
'function' === typeof e.from;
|
|
J.exports = function (m, f, c) {
|
|
if ('number' === typeof m)
|
|
throw new TypeError('"value" argument must not be a number');
|
|
if ('ArrayBuffer' === p.call(m).slice(8, -1)) {
|
|
f >>>= 0;
|
|
var l = m.byteLength - f;
|
|
if (0 > l) throw new RangeError("'offset' is out of bounds");
|
|
if (void 0 === c) c = l;
|
|
else if (((c >>>= 0), c > l))
|
|
throw new RangeError("'length' is out of bounds");
|
|
return t ?
|
|
e.from(m.slice(f, f + c))
|
|
: new e(new Uint8Array(m.slice(f, f + c)));
|
|
}
|
|
if ('string' === typeof m) {
|
|
c = f;
|
|
if ('string' !== typeof c || '' === c) c = 'utf8';
|
|
if (!e.isEncoding(c))
|
|
throw new TypeError(
|
|
'"encoding" must be a valid string encoding'
|
|
);
|
|
return t ? e.from(m, c) : new e(m, c);
|
|
}
|
|
return t ? e.from(m) : new e(m);
|
|
};
|
|
}).call(this, C('buffer').Buffer);
|
|
},
|
|
{ buffer: 5 },
|
|
],
|
|
5: [
|
|
function (C, J, A) {
|
|
function e(a, b, h) {
|
|
if (!(this instanceof e)) return new e(a, b, h);
|
|
var w = typeof a;
|
|
if ('number' === w) var y = 0 < a ? a >>> 0 : 0;
|
|
else if ('string' === w) {
|
|
if ('base64' === b)
|
|
for (
|
|
a = (a.trim ? a.trim() : a.replace(/^\s+|\s+$/g, '')).replace(
|
|
L,
|
|
''
|
|
);
|
|
0 !== a.length % 4;
|
|
|
|
)
|
|
a += '=';
|
|
y = e.byteLength(a, b);
|
|
} else if ('object' === w && null !== a)
|
|
'Buffer' === a.type && z(a.data) && (a = a.data),
|
|
(y = 0 < +a.length ? Math.floor(+a.length) : 0);
|
|
else
|
|
throw new TypeError(
|
|
'must start with number, buffer, array or string'
|
|
);
|
|
if (this.length > G)
|
|
throw new RangeError(
|
|
'Attempt to allocate Buffer larger than maximum size: 0x' +
|
|
G.toString(16) +
|
|
' bytes'
|
|
);
|
|
if (e.TYPED_ARRAY_SUPPORT) var I = e._augment(new Uint8Array(y));
|
|
else (I = this), (I.length = y), (I._isBuffer = !0);
|
|
if (e.TYPED_ARRAY_SUPPORT && 'number' === typeof a.byteLength)
|
|
I._set(a);
|
|
else {
|
|
var K = a;
|
|
if (
|
|
z(K) ||
|
|
e.isBuffer(K) ||
|
|
(K && 'object' === typeof K && 'number' === typeof K.length)
|
|
)
|
|
if (e.isBuffer(a))
|
|
for (b = 0; b < y; b++) I[b] = a.readUInt8(b);
|
|
else for (b = 0; b < y; b++) I[b] = ((a[b] % 256) + 256) % 256;
|
|
else if ('string' === w) I.write(a, 0, b);
|
|
else if ('number' === w && !e.TYPED_ARRAY_SUPPORT && !h)
|
|
for (b = 0; b < y; b++) I[b] = 0;
|
|
}
|
|
return I;
|
|
}
|
|
function p(a, b, h) {
|
|
var w = '';
|
|
for (h = Math.min(a.length, h); b < h; b++)
|
|
w += String.fromCharCode(a[b]);
|
|
return w;
|
|
}
|
|
function t(a, b, h) {
|
|
if (0 !== a % 1 || 0 > a)
|
|
throw new RangeError('offset is not uint');
|
|
if (a + b > h)
|
|
throw new RangeError('Trying to access beyond buffer length');
|
|
}
|
|
function m(a, b, h, w, y, I) {
|
|
if (!e.isBuffer(a))
|
|
throw new TypeError('buffer must be a Buffer instance');
|
|
if (b > y || b < I) throw new TypeError('value is out of bounds');
|
|
if (h + w > a.length) throw new TypeError('index out of range');
|
|
}
|
|
function f(a, b, h, w) {
|
|
0 > b && (b = 65535 + b + 1);
|
|
for (var y = 0, I = Math.min(a.length - h, 2); y < I; y++)
|
|
a[h + y] =
|
|
(b & (255 << (8 * (w ? y : 1 - y)))) >>> (8 * (w ? y : 1 - y));
|
|
}
|
|
function c(a, b, h, w) {
|
|
0 > b && (b = 4294967295 + b + 1);
|
|
for (var y = 0, I = Math.min(a.length - h, 4); y < I; y++)
|
|
a[h + y] = (b >>> (8 * (w ? y : 3 - y))) & 255;
|
|
}
|
|
function l(a, b, h, w, y, I) {
|
|
if (b > y || b < I) throw new TypeError('value is out of bounds');
|
|
if (h + w > a.length) throw new TypeError('index out of range');
|
|
}
|
|
function q(a, b, h, w, y) {
|
|
y || l(a, b, h, 4, 3.4028234663852886e38, -3.4028234663852886e38);
|
|
v.write(a, b, h, w, 23, 4);
|
|
return h + 4;
|
|
}
|
|
function r(a, b, h, w, y) {
|
|
y || l(a, b, h, 8, 1.7976931348623157e308, -1.7976931348623157e308);
|
|
v.write(a, b, h, w, 52, 8);
|
|
return h + 8;
|
|
}
|
|
function k(a) {
|
|
for (var b = [], h = 0; h < a.length; h++) {
|
|
var w = a.charCodeAt(h);
|
|
if (127 >= w) b.push(w);
|
|
else {
|
|
var y = h;
|
|
55296 <= w && 57343 >= w && h++;
|
|
w = encodeURIComponent(a.slice(y, h + 1))
|
|
.substr(1)
|
|
.split('%');
|
|
for (y = 0; y < w.length; y++) b.push(parseInt(w[y], 16));
|
|
}
|
|
}
|
|
return b;
|
|
}
|
|
function u(a) {
|
|
for (var b = [], h = 0; h < a.length; h++)
|
|
b.push(a.charCodeAt(h) & 255);
|
|
return b;
|
|
}
|
|
function d(a, b, h, w, y) {
|
|
y && (w -= w % y);
|
|
for (y = 0; y < w && !(y + h >= b.length || y >= a.length); y++)
|
|
b[y + h] = a[y];
|
|
return y;
|
|
}
|
|
function g(a) {
|
|
try {
|
|
return decodeURIComponent(a);
|
|
} catch (b) {
|
|
return String.fromCharCode(65533);
|
|
}
|
|
}
|
|
var n = C('base64-js'),
|
|
v = C('ieee754'),
|
|
z = C('is-array');
|
|
A.Buffer = e;
|
|
A.SlowBuffer = e;
|
|
A.INSPECT_MAX_BYTES = 50;
|
|
e.poolSize = 8192;
|
|
var G = 1073741823;
|
|
e.TYPED_ARRAY_SUPPORT = (function () {
|
|
try {
|
|
var a = new ArrayBuffer(0),
|
|
b = new Uint8Array(a);
|
|
b.foo = function () {
|
|
return 42;
|
|
};
|
|
return (
|
|
42 === b.foo() &&
|
|
'function' === typeof b.subarray &&
|
|
0 === new Uint8Array(1).subarray(1, 1).byteLength
|
|
);
|
|
} catch (h) {
|
|
return !1;
|
|
}
|
|
})();
|
|
e.isBuffer = function (a) {
|
|
return !(null == a || !a._isBuffer);
|
|
};
|
|
e.compare = function (a, b) {
|
|
if (!e.isBuffer(a) || !e.isBuffer(b))
|
|
throw new TypeError('Arguments must be Buffers');
|
|
for (
|
|
var h = a.length, w = b.length, y = 0, I = Math.min(h, w);
|
|
y < I && a[y] === b[y];
|
|
y++
|
|
);
|
|
y !== I && ((h = a[y]), (w = b[y]));
|
|
return (
|
|
h < w ? -1
|
|
: w < h ? 1
|
|
: 0
|
|
);
|
|
};
|
|
e.isEncoding = function (a) {
|
|
switch (String(a).toLowerCase()) {
|
|
case 'hex':
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case 'ascii':
|
|
case 'binary':
|
|
case 'base64':
|
|
case 'raw':
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
};
|
|
e.concat = function (a, b) {
|
|
if (!z(a))
|
|
throw new TypeError('Usage: Buffer.concat(list[, length])');
|
|
if (0 === a.length) return new e(0);
|
|
if (1 === a.length) return a[0];
|
|
var h;
|
|
if (void 0 === b)
|
|
for (h = b = 0; h < a.length; h++) b += a[h].length;
|
|
var w = new e(b),
|
|
y = 0;
|
|
for (h = 0; h < a.length; h++) {
|
|
var I = a[h];
|
|
I.copy(w, y);
|
|
y += I.length;
|
|
}
|
|
return w;
|
|
};
|
|
e.byteLength = function (a, b) {
|
|
a += '';
|
|
switch (b || 'utf8') {
|
|
case 'ascii':
|
|
case 'binary':
|
|
case 'raw':
|
|
var h = a.length;
|
|
break;
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
h = 2 * a.length;
|
|
break;
|
|
case 'hex':
|
|
h = a.length >>> 1;
|
|
break;
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
h = k(a).length;
|
|
break;
|
|
case 'base64':
|
|
h = n.toByteArray(a).length;
|
|
break;
|
|
default:
|
|
h = a.length;
|
|
}
|
|
return h;
|
|
};
|
|
e.prototype.length = void 0;
|
|
e.prototype.parent = void 0;
|
|
e.prototype.toString = function (a, b, h) {
|
|
var w = !1;
|
|
b >>>= 0;
|
|
h = void 0 === h || Infinity === h ? this.length : h >>> 0;
|
|
a || (a = 'utf8');
|
|
0 > b && (b = 0);
|
|
h > this.length && (h = this.length);
|
|
if (h <= b) return '';
|
|
for (;;)
|
|
switch (a) {
|
|
case 'hex':
|
|
a = b;
|
|
b = h;
|
|
h = this.length;
|
|
if (!a || 0 > a) a = 0;
|
|
if (!b || 0 > b || b > h) b = h;
|
|
w = '';
|
|
for (h = a; h < b; h++)
|
|
(a = w),
|
|
(w = this[h]),
|
|
(w = 16 > w ? '0' + w.toString(16) : w.toString(16)),
|
|
(w = a + w);
|
|
return w;
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
w = a = '';
|
|
for (h = Math.min(this.length, h); b < h; b++)
|
|
127 >= this[b] ?
|
|
((a += g(w) + String.fromCharCode(this[b])), (w = ''))
|
|
: (w += '%' + this[b].toString(16));
|
|
return a + g(w);
|
|
case 'ascii':
|
|
return p(this, b, h);
|
|
case 'binary':
|
|
return p(this, b, h);
|
|
case 'base64':
|
|
return (
|
|
(b =
|
|
0 === b && h === this.length ?
|
|
n.fromByteArray(this)
|
|
: n.fromByteArray(this.slice(b, h))),
|
|
b
|
|
);
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
b = this.slice(b, h);
|
|
h = '';
|
|
for (a = 0; a < b.length; a += 2)
|
|
h += String.fromCharCode(b[a] + 256 * b[a + 1]);
|
|
return h;
|
|
default:
|
|
if (w) throw new TypeError('Unknown encoding: ' + a);
|
|
a = (a + '').toLowerCase();
|
|
w = !0;
|
|
}
|
|
};
|
|
e.prototype.equals = function (a) {
|
|
if (!e.isBuffer(a))
|
|
throw new TypeError('Argument must be a Buffer');
|
|
return 0 === e.compare(this, a);
|
|
};
|
|
e.prototype.inspect = function () {
|
|
var a = '',
|
|
b = A.INSPECT_MAX_BYTES;
|
|
0 < this.length &&
|
|
((a = this.toString('hex', 0, b).match(/.{2}/g).join(' ')),
|
|
this.length > b && (a += ' ... '));
|
|
return '<Buffer ' + a + '>';
|
|
};
|
|
e.prototype.compare = function (a) {
|
|
if (!e.isBuffer(a))
|
|
throw new TypeError('Argument must be a Buffer');
|
|
return e.compare(this, a);
|
|
};
|
|
e.prototype.get = function (a) {
|
|
console.log(
|
|
'.get() is deprecated. Access using array indexes instead.'
|
|
);
|
|
return this.readUInt8(a);
|
|
};
|
|
e.prototype.set = function (a, b) {
|
|
console.log(
|
|
'.set() is deprecated. Access using array indexes instead.'
|
|
);
|
|
return this.writeUInt8(a, b);
|
|
};
|
|
e.prototype.write = function (a, b, h, w) {
|
|
if (isFinite(b)) isFinite(h) || ((w = h), (h = void 0));
|
|
else {
|
|
var y = w;
|
|
w = b;
|
|
b = h;
|
|
h = y;
|
|
}
|
|
b = Number(b) || 0;
|
|
y = this.length - b;
|
|
h ? ((h = Number(h)), h > y && (h = y)) : (h = y);
|
|
w = String(w || 'utf8').toLowerCase();
|
|
switch (w) {
|
|
case 'hex':
|
|
b = Number(b) || 0;
|
|
w = this.length - b;
|
|
h ? ((h = Number(h)), h > w && (h = w)) : (h = w);
|
|
w = a.length;
|
|
if (0 !== w % 2) throw Error('Invalid hex string');
|
|
h > w / 2 && (h = w / 2);
|
|
for (w = 0; w < h; w++) {
|
|
y = parseInt(a.substr(2 * w, 2), 16);
|
|
if (isNaN(y)) throw Error('Invalid hex string');
|
|
this[b + w] = y;
|
|
}
|
|
a = w;
|
|
break;
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
a = d(k(a), this, b, h);
|
|
break;
|
|
case 'ascii':
|
|
a = d(u(a), this, b, h);
|
|
break;
|
|
case 'binary':
|
|
a = d(u(a), this, b, h);
|
|
break;
|
|
case 'base64':
|
|
a = d(n.toByteArray(a), this, b, h);
|
|
break;
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
y = [];
|
|
for (var I = 0; I < a.length; I++) {
|
|
var K = a.charCodeAt(I);
|
|
w = K >> 8;
|
|
K %= 256;
|
|
y.push(K);
|
|
y.push(w);
|
|
}
|
|
a = d(y, this, b, h, 2);
|
|
break;
|
|
default:
|
|
throw new TypeError('Unknown encoding: ' + w);
|
|
}
|
|
return a;
|
|
};
|
|
e.prototype.toJSON = function () {
|
|
return {
|
|
type: 'Buffer',
|
|
data: Array.prototype.slice.call(this._arr || this, 0),
|
|
};
|
|
};
|
|
e.prototype.slice = function (a, b) {
|
|
var h = this.length;
|
|
a = ~~a;
|
|
b = void 0 === b ? h : ~~b;
|
|
0 > a ? ((a += h), 0 > a && (a = 0)) : a > h && (a = h);
|
|
0 > b ? ((b += h), 0 > b && (b = 0)) : b > h && (b = h);
|
|
b < a && (b = a);
|
|
if (e.TYPED_ARRAY_SUPPORT) return e._augment(this.subarray(a, b));
|
|
h = b - a;
|
|
for (var w = new e(h, void 0, !0), y = 0; y < h; y++)
|
|
w[y] = this[y + a];
|
|
return w;
|
|
};
|
|
e.prototype.readUInt8 = function (a, b) {
|
|
b || t(a, 1, this.length);
|
|
return this[a];
|
|
};
|
|
e.prototype.readUInt16LE = function (a, b) {
|
|
b || t(a, 2, this.length);
|
|
return this[a] | (this[a + 1] << 8);
|
|
};
|
|
e.prototype.readUInt16BE = function (a, b) {
|
|
b || t(a, 2, this.length);
|
|
return (this[a] << 8) | this[a + 1];
|
|
};
|
|
e.prototype.readUInt32LE = function (a, b) {
|
|
b || t(a, 4, this.length);
|
|
return (
|
|
(this[a] | (this[a + 1] << 8) | (this[a + 2] << 16)) +
|
|
16777216 * this[a + 3]
|
|
);
|
|
};
|
|
e.prototype.readUInt32BE = function (a, b) {
|
|
b || t(a, 4, this.length);
|
|
return (
|
|
16777216 * this[a] +
|
|
((this[a + 1] << 16) | (this[a + 2] << 8) | this[a + 3])
|
|
);
|
|
};
|
|
e.prototype.readInt8 = function (a, b) {
|
|
b || t(a, 1, this.length);
|
|
return this[a] & 128 ? -1 * (255 - this[a] + 1) : this[a];
|
|
};
|
|
e.prototype.readInt16LE = function (a, b) {
|
|
b || t(a, 2, this.length);
|
|
var h = this[a] | (this[a + 1] << 8);
|
|
return h & 32768 ? h | 4294901760 : h;
|
|
};
|
|
e.prototype.readInt16BE = function (a, b) {
|
|
b || t(a, 2, this.length);
|
|
var h = this[a + 1] | (this[a] << 8);
|
|
return h & 32768 ? h | 4294901760 : h;
|
|
};
|
|
e.prototype.readInt32LE = function (a, b) {
|
|
b || t(a, 4, this.length);
|
|
return (
|
|
this[a] |
|
|
(this[a + 1] << 8) |
|
|
(this[a + 2] << 16) |
|
|
(this[a + 3] << 24)
|
|
);
|
|
};
|
|
e.prototype.readInt32BE = function (a, b) {
|
|
b || t(a, 4, this.length);
|
|
return (
|
|
(this[a] << 24) |
|
|
(this[a + 1] << 16) |
|
|
(this[a + 2] << 8) |
|
|
this[a + 3]
|
|
);
|
|
};
|
|
e.prototype.readFloatLE = function (a, b) {
|
|
b || t(a, 4, this.length);
|
|
return v.read(this, a, !0, 23, 4);
|
|
};
|
|
e.prototype.readFloatBE = function (a, b) {
|
|
b || t(a, 4, this.length);
|
|
return v.read(this, a, !1, 23, 4);
|
|
};
|
|
e.prototype.readDoubleLE = function (a, b) {
|
|
b || t(a, 8, this.length);
|
|
return v.read(this, a, !0, 52, 8);
|
|
};
|
|
e.prototype.readDoubleBE = function (a, b) {
|
|
b || t(a, 8, this.length);
|
|
return v.read(this, a, !1, 52, 8);
|
|
};
|
|
e.prototype.writeUInt8 = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 1, 255, 0);
|
|
e.TYPED_ARRAY_SUPPORT || (a = Math.floor(a));
|
|
this[b] = a;
|
|
return b + 1;
|
|
};
|
|
e.prototype.writeUInt16LE = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 2, 65535, 0);
|
|
e.TYPED_ARRAY_SUPPORT ?
|
|
((this[b] = a), (this[b + 1] = a >>> 8))
|
|
: f(this, a, b, !0);
|
|
return b + 2;
|
|
};
|
|
e.prototype.writeUInt16BE = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 2, 65535, 0);
|
|
e.TYPED_ARRAY_SUPPORT ?
|
|
((this[b] = a >>> 8), (this[b + 1] = a))
|
|
: f(this, a, b, !1);
|
|
return b + 2;
|
|
};
|
|
e.prototype.writeUInt32LE = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 4, 4294967295, 0);
|
|
e.TYPED_ARRAY_SUPPORT ?
|
|
((this[b + 3] = a >>> 24),
|
|
(this[b + 2] = a >>> 16),
|
|
(this[b + 1] = a >>> 8),
|
|
(this[b] = a))
|
|
: c(this, a, b, !0);
|
|
return b + 4;
|
|
};
|
|
e.prototype.writeUInt32BE = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 4, 4294967295, 0);
|
|
e.TYPED_ARRAY_SUPPORT ?
|
|
((this[b] = a >>> 24),
|
|
(this[b + 1] = a >>> 16),
|
|
(this[b + 2] = a >>> 8),
|
|
(this[b + 3] = a))
|
|
: c(this, a, b, !1);
|
|
return b + 4;
|
|
};
|
|
e.prototype.writeInt8 = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 1, 127, -128);
|
|
e.TYPED_ARRAY_SUPPORT || (a = Math.floor(a));
|
|
0 > a && (a = 255 + a + 1);
|
|
this[b] = a;
|
|
return b + 1;
|
|
};
|
|
e.prototype.writeInt16LE = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 2, 32767, -32768);
|
|
e.TYPED_ARRAY_SUPPORT ?
|
|
((this[b] = a), (this[b + 1] = a >>> 8))
|
|
: f(this, a, b, !0);
|
|
return b + 2;
|
|
};
|
|
e.prototype.writeInt16BE = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 2, 32767, -32768);
|
|
e.TYPED_ARRAY_SUPPORT ?
|
|
((this[b] = a >>> 8), (this[b + 1] = a))
|
|
: f(this, a, b, !1);
|
|
return b + 2;
|
|
};
|
|
e.prototype.writeInt32LE = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 4, 2147483647, -2147483648);
|
|
e.TYPED_ARRAY_SUPPORT ?
|
|
((this[b] = a),
|
|
(this[b + 1] = a >>> 8),
|
|
(this[b + 2] = a >>> 16),
|
|
(this[b + 3] = a >>> 24))
|
|
: c(this, a, b, !0);
|
|
return b + 4;
|
|
};
|
|
e.prototype.writeInt32BE = function (a, b, h) {
|
|
a = +a;
|
|
b >>>= 0;
|
|
h || m(this, a, b, 4, 2147483647, -2147483648);
|
|
0 > a && (a = 4294967295 + a + 1);
|
|
e.TYPED_ARRAY_SUPPORT ?
|
|
((this[b] = a >>> 24),
|
|
(this[b + 1] = a >>> 16),
|
|
(this[b + 2] = a >>> 8),
|
|
(this[b + 3] = a))
|
|
: c(this, a, b, !1);
|
|
return b + 4;
|
|
};
|
|
e.prototype.writeFloatLE = function (a, b, h) {
|
|
return q(this, a, b, !0, h);
|
|
};
|
|
e.prototype.writeFloatBE = function (a, b, h) {
|
|
return q(this, a, b, !1, h);
|
|
};
|
|
e.prototype.writeDoubleLE = function (a, b, h) {
|
|
return r(this, a, b, !0, h);
|
|
};
|
|
e.prototype.writeDoubleBE = function (a, b, h) {
|
|
return r(this, a, b, !1, h);
|
|
};
|
|
e.prototype.copy = function (a, b, h, w) {
|
|
h || (h = 0);
|
|
w || 0 === w || (w = this.length);
|
|
b || (b = 0);
|
|
if (w !== h && 0 !== a.length && 0 !== this.length) {
|
|
if (w < h) throw new TypeError('sourceEnd < sourceStart');
|
|
if (0 > b || b >= a.length)
|
|
throw new TypeError('targetStart out of bounds');
|
|
if (0 > h || h >= this.length)
|
|
throw new TypeError('sourceStart out of bounds');
|
|
if (0 > w || w > this.length)
|
|
throw new TypeError('sourceEnd out of bounds');
|
|
w > this.length && (w = this.length);
|
|
a.length - b < w - h && (w = a.length - b + h);
|
|
w -= h;
|
|
if (1e3 > w || !e.TYPED_ARRAY_SUPPORT)
|
|
for (var y = 0; y < w; y++) a[y + b] = this[y + h];
|
|
else a._set(this.subarray(h, h + w), b);
|
|
}
|
|
};
|
|
e.prototype.fill = function (a, b, h) {
|
|
a || (a = 0);
|
|
b || (b = 0);
|
|
h || (h = this.length);
|
|
if (h < b) throw new TypeError('end < start');
|
|
if (h !== b && 0 !== this.length) {
|
|
if (0 > b || b >= this.length)
|
|
throw new TypeError('start out of bounds');
|
|
if (0 > h || h > this.length)
|
|
throw new TypeError('end out of bounds');
|
|
if ('number' === typeof a) for (; b < h; b++) this[b] = a;
|
|
else {
|
|
a = k(a.toString());
|
|
for (var w = a.length; b < h; b++) this[b] = a[b % w];
|
|
}
|
|
return this;
|
|
}
|
|
};
|
|
e.prototype.toArrayBuffer = function () {
|
|
if ('undefined' !== typeof Uint8Array) {
|
|
if (e.TYPED_ARRAY_SUPPORT) return new e(this).buffer;
|
|
for (
|
|
var a = new Uint8Array(this.length), b = 0, h = a.length;
|
|
b < h;
|
|
b += 1
|
|
)
|
|
a[b] = this[b];
|
|
return a.buffer;
|
|
}
|
|
throw new TypeError(
|
|
'Buffer.toArrayBuffer not supported in this browser'
|
|
);
|
|
};
|
|
var D = e.prototype;
|
|
e._augment = function (a) {
|
|
a.constructor = e;
|
|
a._isBuffer = !0;
|
|
a._get = a.get;
|
|
a._set = a.set;
|
|
a.get = D.get;
|
|
a.set = D.set;
|
|
a.write = D.write;
|
|
a.toString = D.toString;
|
|
a.toLocaleString = D.toString;
|
|
a.toJSON = D.toJSON;
|
|
a.equals = D.equals;
|
|
a.compare = D.compare;
|
|
a.copy = D.copy;
|
|
a.slice = D.slice;
|
|
a.readUInt8 = D.readUInt8;
|
|
a.readUInt16LE = D.readUInt16LE;
|
|
a.readUInt16BE = D.readUInt16BE;
|
|
a.readUInt32LE = D.readUInt32LE;
|
|
a.readUInt32BE = D.readUInt32BE;
|
|
a.readInt8 = D.readInt8;
|
|
a.readInt16LE = D.readInt16LE;
|
|
a.readInt16BE = D.readInt16BE;
|
|
a.readInt32LE = D.readInt32LE;
|
|
a.readInt32BE = D.readInt32BE;
|
|
a.readFloatLE = D.readFloatLE;
|
|
a.readFloatBE = D.readFloatBE;
|
|
a.readDoubleLE = D.readDoubleLE;
|
|
a.readDoubleBE = D.readDoubleBE;
|
|
a.writeUInt8 = D.writeUInt8;
|
|
a.writeUInt16LE = D.writeUInt16LE;
|
|
a.writeUInt16BE = D.writeUInt16BE;
|
|
a.writeUInt32LE = D.writeUInt32LE;
|
|
a.writeUInt32BE = D.writeUInt32BE;
|
|
a.writeInt8 = D.writeInt8;
|
|
a.writeInt16LE = D.writeInt16LE;
|
|
a.writeInt16BE = D.writeInt16BE;
|
|
a.writeInt32LE = D.writeInt32LE;
|
|
a.writeInt32BE = D.writeInt32BE;
|
|
a.writeFloatLE = D.writeFloatLE;
|
|
a.writeFloatBE = D.writeFloatBE;
|
|
a.writeDoubleLE = D.writeDoubleLE;
|
|
a.writeDoubleBE = D.writeDoubleBE;
|
|
a.fill = D.fill;
|
|
a.inspect = D.inspect;
|
|
a.toArrayBuffer = D.toArrayBuffer;
|
|
return a;
|
|
};
|
|
var L = /[^+\/0-9A-z]/g;
|
|
},
|
|
{ 'base64-js': 2, ieee754: 6, 'is-array': 7 },
|
|
],
|
|
6: [
|
|
function (C, J, A) {
|
|
A.read = function (e, p, t, m, f) {
|
|
var c = 8 * f - m - 1;
|
|
var l = (1 << c) - 1,
|
|
q = l >> 1,
|
|
r = -7;
|
|
f = t ? f - 1 : 0;
|
|
var k = t ? -1 : 1,
|
|
u = e[p + f];
|
|
f += k;
|
|
t = u & ((1 << -r) - 1);
|
|
u >>= -r;
|
|
for (r += c; 0 < r; t = 256 * t + e[p + f], f += k, r -= 8);
|
|
c = t & ((1 << -r) - 1);
|
|
t >>= -r;
|
|
for (r += m; 0 < r; c = 256 * c + e[p + f], f += k, r -= 8);
|
|
if (0 === t) t = 1 - q;
|
|
else {
|
|
if (t === l) return c ? NaN : Infinity * (u ? -1 : 1);
|
|
c += Math.pow(2, m);
|
|
t -= q;
|
|
}
|
|
return (u ? -1 : 1) * c * Math.pow(2, t - m);
|
|
};
|
|
A.write = function (e, p, t, m, f, c) {
|
|
var l,
|
|
q = 8 * c - f - 1,
|
|
r = (1 << q) - 1,
|
|
k = r >> 1,
|
|
u = 23 === f ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
|
|
c = m ? 0 : c - 1;
|
|
var d = m ? 1 : -1,
|
|
g = 0 > p || (0 === p && 0 > 1 / p) ? 1 : 0;
|
|
p = Math.abs(p);
|
|
isNaN(p) || Infinity === p ?
|
|
((p = isNaN(p) ? 1 : 0), (m = r))
|
|
: ((m = Math.floor(Math.log(p) / Math.LN2)),
|
|
1 > p * (l = Math.pow(2, -m)) && (m--, (l *= 2)),
|
|
(p = 1 <= m + k ? p + u / l : p + u * Math.pow(2, 1 - k)),
|
|
2 <= p * l && (m++, (l /= 2)),
|
|
m + k >= r ? ((p = 0), (m = r))
|
|
: 1 <= m + k ? ((p = (p * l - 1) * Math.pow(2, f)), (m += k))
|
|
: ((p = p * Math.pow(2, k - 1) * Math.pow(2, f)), (m = 0)));
|
|
for (; 8 <= f; e[t + c] = p & 255, c += d, p /= 256, f -= 8);
|
|
m = (m << f) | p;
|
|
for (q += f; 0 < q; e[t + c] = m & 255, c += d, m /= 256, q -= 8);
|
|
e[t + c - d] |= 128 * g;
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
7: [
|
|
function (C, J, A) {
|
|
var e = Object.prototype.toString;
|
|
J.exports =
|
|
Array.isArray ||
|
|
function (p) {
|
|
return !!p && '[object Array]' == e.call(p);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
8: [
|
|
function (C, J, A) {
|
|
(function (e) {
|
|
function p(c, l) {
|
|
for (var q = 0, r = c.length - 1; 0 <= r; r--) {
|
|
var k = c[r];
|
|
'.' === k ? c.splice(r, 1)
|
|
: '..' === k ? (c.splice(r, 1), q++)
|
|
: q && (c.splice(r, 1), q--);
|
|
}
|
|
if (l) for (; q--; q) c.unshift('..');
|
|
return c;
|
|
}
|
|
function t(c, l) {
|
|
if (c.filter) return c.filter(l);
|
|
for (var q = [], r = 0; r < c.length; r++)
|
|
l(c[r], r, c) && q.push(c[r]);
|
|
return q;
|
|
}
|
|
var m =
|
|
/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
|
A.resolve = function () {
|
|
for (
|
|
var c = '', l = !1, q = arguments.length - 1;
|
|
-1 <= q && !l;
|
|
q--
|
|
) {
|
|
var r = 0 <= q ? arguments[q] : e.cwd();
|
|
if ('string' !== typeof r)
|
|
throw new TypeError(
|
|
'Arguments to path.resolve must be strings'
|
|
);
|
|
r && ((c = r + '/' + c), (l = '/' === r.charAt(0)));
|
|
}
|
|
c = p(
|
|
t(c.split('/'), function (k) {
|
|
return !!k;
|
|
}),
|
|
!l
|
|
).join('/');
|
|
return (l ? '/' : '') + c || '.';
|
|
};
|
|
A.normalize = function (c) {
|
|
var l = A.isAbsolute(c),
|
|
q = '/' === f(c, -1);
|
|
(c = p(
|
|
t(c.split('/'), function (r) {
|
|
return !!r;
|
|
}),
|
|
!l
|
|
).join('/')) ||
|
|
l ||
|
|
(c = '.');
|
|
c && q && (c += '/');
|
|
return (l ? '/' : '') + c;
|
|
};
|
|
A.isAbsolute = function (c) {
|
|
return '/' === c.charAt(0);
|
|
};
|
|
A.join = function () {
|
|
var c = Array.prototype.slice.call(arguments, 0);
|
|
return A.normalize(
|
|
t(c, function (l, q) {
|
|
if ('string' !== typeof l)
|
|
throw new TypeError(
|
|
'Arguments to path.join must be strings'
|
|
);
|
|
return l;
|
|
}).join('/')
|
|
);
|
|
};
|
|
A.relative = function (c, l) {
|
|
function q(n) {
|
|
for (var v = 0; v < n.length && '' === n[v]; v++);
|
|
for (var z = n.length - 1; 0 <= z && '' === n[z]; z--);
|
|
return v > z ? [] : n.slice(v, z - v + 1);
|
|
}
|
|
c = A.resolve(c).substr(1);
|
|
l = A.resolve(l).substr(1);
|
|
for (
|
|
var r = q(c.split('/')),
|
|
k = q(l.split('/')),
|
|
u = Math.min(r.length, k.length),
|
|
d = u,
|
|
g = 0;
|
|
g < u;
|
|
g++
|
|
)
|
|
if (r[g] !== k[g]) {
|
|
d = g;
|
|
break;
|
|
}
|
|
u = [];
|
|
for (g = d; g < r.length; g++) u.push('..');
|
|
u = u.concat(k.slice(d));
|
|
return u.join('/');
|
|
};
|
|
A.sep = '/';
|
|
A.delimiter = ':';
|
|
A.dirname = function (c) {
|
|
var l = m.exec(c).slice(1);
|
|
c = l[0];
|
|
l = l[1];
|
|
if (!c && !l) return '.';
|
|
l && (l = l.substr(0, l.length - 1));
|
|
return c + l;
|
|
};
|
|
A.basename = function (c, l) {
|
|
var q = m.exec(c).slice(1)[2];
|
|
l &&
|
|
q.substr(-1 * l.length) === l &&
|
|
(q = q.substr(0, q.length - l.length));
|
|
return q;
|
|
};
|
|
A.extname = function (c) {
|
|
return m.exec(c).slice(1)[3];
|
|
};
|
|
var f =
|
|
'b' === 'ab'.substr(-1) ?
|
|
function (c, l, q) {
|
|
return c.substr(l, q);
|
|
}
|
|
: function (c, l, q) {
|
|
0 > l && (l = c.length + l);
|
|
return c.substr(l, q);
|
|
};
|
|
}).call(this, C('g5I+bs'));
|
|
},
|
|
{ 'g5I+bs': 9 },
|
|
],
|
|
9: [
|
|
function (C, J, A) {
|
|
function e() {}
|
|
C = J.exports = {};
|
|
C.nextTick = (function () {
|
|
if ('undefined' !== typeof window && window.setImmediate)
|
|
return function (t) {
|
|
return window.setImmediate(t);
|
|
};
|
|
if (
|
|
'undefined' !== typeof window &&
|
|
window.postMessage &&
|
|
window.addEventListener
|
|
) {
|
|
var p = [];
|
|
window.addEventListener(
|
|
'message',
|
|
function (t) {
|
|
var m = t.source;
|
|
(m !== window && null !== m) ||
|
|
'process-tick' !== t.data ||
|
|
(t.stopPropagation(), 0 < p.length && p.shift()());
|
|
},
|
|
!0
|
|
);
|
|
return function (t) {
|
|
p.push(t);
|
|
window.postMessage('process-tick', '*');
|
|
};
|
|
}
|
|
return function (t) {
|
|
setTimeout(t, 0);
|
|
};
|
|
})();
|
|
C.title = 'browser';
|
|
C.browser = !0;
|
|
C.env = {};
|
|
C.argv = [];
|
|
C.on = e;
|
|
C.addListener = e;
|
|
C.once = e;
|
|
C.off = e;
|
|
C.removeListener = e;
|
|
C.removeAllListeners = e;
|
|
C.emit = e;
|
|
C.binding = function (p) {
|
|
throw Error('process.binding is not supported');
|
|
};
|
|
C.cwd = function () {
|
|
return '/';
|
|
};
|
|
C.chdir = function (p) {
|
|
throw Error('process.chdir is not supported');
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
10: [
|
|
function (C, J, A) {
|
|
function e() {
|
|
this._array = [];
|
|
this._set = m ? new Map() : Object.create(null);
|
|
}
|
|
var p = C('./util'),
|
|
t = Object.prototype.hasOwnProperty,
|
|
m = 'undefined' !== typeof Map;
|
|
e.fromArray = function (f, c) {
|
|
for (var l = new e(), q = 0, r = f.length; q < r; q++)
|
|
l.add(f[q], c);
|
|
return l;
|
|
};
|
|
e.prototype.size = function () {
|
|
return m ?
|
|
this._set.size
|
|
: Object.getOwnPropertyNames(this._set).length;
|
|
};
|
|
e.prototype.add = function (f, c) {
|
|
var l = m ? f : p.toSetString(f),
|
|
q = m ? this.has(f) : t.call(this._set, l),
|
|
r = this._array.length;
|
|
(q && !c) || this._array.push(f);
|
|
q || (m ? this._set.set(f, r) : (this._set[l] = r));
|
|
};
|
|
e.prototype.has = function (f) {
|
|
if (m) return this._set.has(f);
|
|
f = p.toSetString(f);
|
|
return t.call(this._set, f);
|
|
};
|
|
e.prototype.indexOf = function (f) {
|
|
if (m) {
|
|
var c = this._set.get(f);
|
|
if (0 <= c) return c;
|
|
} else if (((c = p.toSetString(f)), t.call(this._set, c)))
|
|
return this._set[c];
|
|
throw Error('"' + f + '" is not in the set.');
|
|
};
|
|
e.prototype.at = function (f) {
|
|
if (0 <= f && f < this._array.length) return this._array[f];
|
|
throw Error('No element indexed by ' + f);
|
|
};
|
|
e.prototype.toArray = function () {
|
|
return this._array.slice();
|
|
};
|
|
A.ArraySet = e;
|
|
},
|
|
{ './util': 19 },
|
|
],
|
|
11: [
|
|
function (C, J, A) {
|
|
var e = C('./base64');
|
|
A.encode = function (p) {
|
|
var t = '',
|
|
m = 0 > p ? (-p << 1) + 1 : p << 1;
|
|
do (p = m & 31), (m >>>= 5), 0 < m && (p |= 32), (t += e.encode(p));
|
|
while (0 < m);
|
|
return t;
|
|
};
|
|
A.decode = function (p, t, m) {
|
|
var f = p.length,
|
|
c = 0,
|
|
l = 0;
|
|
do {
|
|
if (t >= f)
|
|
throw Error('Expected more digits in base 64 VLQ value.');
|
|
var q = e.decode(p.charCodeAt(t++));
|
|
if (-1 === q)
|
|
throw Error('Invalid base64 digit: ' + p.charAt(t - 1));
|
|
var r = !!(q & 32);
|
|
q &= 31;
|
|
c += q << l;
|
|
l += 5;
|
|
} while (r);
|
|
p = c >> 1;
|
|
m.value = 1 === (c & 1) ? -p : p;
|
|
m.rest = t;
|
|
};
|
|
},
|
|
{ './base64': 12 },
|
|
],
|
|
12: [
|
|
function (C, J, A) {
|
|
var e =
|
|
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split(
|
|
''
|
|
);
|
|
A.encode = function (p) {
|
|
if (0 <= p && p < e.length) return e[p];
|
|
throw new TypeError('Must be between 0 and 63: ' + p);
|
|
};
|
|
A.decode = function (p) {
|
|
return (
|
|
65 <= p && 90 >= p ? p - 65
|
|
: 97 <= p && 122 >= p ? p - 97 + 26
|
|
: 48 <= p && 57 >= p ? p - 48 + 52
|
|
: 43 == p ? 62
|
|
: 47 == p ? 63
|
|
: -1
|
|
);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
13: [
|
|
function (C, J, A) {
|
|
function e(p, t, m, f, c, l) {
|
|
var q = Math.floor((t - p) / 2) + p,
|
|
r = c(m, f[q], !0);
|
|
return (
|
|
0 === r ? q
|
|
: 0 < r ?
|
|
1 < t - q ? e(q, t, m, f, c, l)
|
|
: l == A.LEAST_UPPER_BOUND ?
|
|
t < f.length ?
|
|
t
|
|
: -1
|
|
: q
|
|
: 1 < q - p ? e(p, q, m, f, c, l)
|
|
: l == A.LEAST_UPPER_BOUND ? q
|
|
: 0 > p ? -1
|
|
: p
|
|
);
|
|
}
|
|
A.GREATEST_LOWER_BOUND = 1;
|
|
A.LEAST_UPPER_BOUND = 2;
|
|
A.search = function (p, t, m, f) {
|
|
if (0 === t.length) return -1;
|
|
p = e(-1, t.length, p, t, m, f || A.GREATEST_LOWER_BOUND);
|
|
if (0 > p) return -1;
|
|
for (; 0 <= p - 1 && 0 === m(t[p], t[p - 1], !0); ) --p;
|
|
return p;
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
14: [
|
|
function (C, J, A) {
|
|
function e() {
|
|
this._array = [];
|
|
this._sorted = !0;
|
|
this._last = { generatedLine: -1, generatedColumn: 0 };
|
|
}
|
|
var p = C('./util');
|
|
e.prototype.unsortedForEach = function (t, m) {
|
|
this._array.forEach(t, m);
|
|
};
|
|
e.prototype.add = function (t) {
|
|
var m = this._last,
|
|
f = m.generatedLine,
|
|
c = t.generatedLine,
|
|
l = m.generatedColumn,
|
|
q = t.generatedColumn;
|
|
(
|
|
c > f ||
|
|
(c == f && q >= l) ||
|
|
0 >= p.compareByGeneratedPositionsInflated(m, t)
|
|
) ?
|
|
(this._last = t)
|
|
: (this._sorted = !1);
|
|
this._array.push(t);
|
|
};
|
|
e.prototype.toArray = function () {
|
|
this._sorted ||
|
|
(this._array.sort(p.compareByGeneratedPositionsInflated),
|
|
(this._sorted = !0));
|
|
return this._array;
|
|
};
|
|
A.MappingList = e;
|
|
},
|
|
{ './util': 19 },
|
|
],
|
|
15: [
|
|
function (C, J, A) {
|
|
function e(t, m, f) {
|
|
var c = t[m];
|
|
t[m] = t[f];
|
|
t[f] = c;
|
|
}
|
|
function p(t, m, f, c) {
|
|
if (f < c) {
|
|
var l = f - 1;
|
|
e(t, Math.round(f + Math.random() * (c - f)), c);
|
|
for (var q = t[c], r = f; r < c; r++)
|
|
0 >= m(t[r], q) && ((l += 1), e(t, l, r));
|
|
e(t, l + 1, r);
|
|
l += 1;
|
|
p(t, m, f, l - 1);
|
|
p(t, m, l + 1, c);
|
|
}
|
|
}
|
|
A.quickSort = function (t, m) {
|
|
p(t, m, 0, t.length - 1);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
16: [
|
|
function (C, J, A) {
|
|
function e(k, u) {
|
|
var d = k;
|
|
'string' === typeof k && (d = f.parseSourceMapInput(k));
|
|
return null != d.sections ? new m(d, u) : new p(d, u);
|
|
}
|
|
function p(k, u) {
|
|
var d = k;
|
|
'string' === typeof k && (d = f.parseSourceMapInput(k));
|
|
var g = f.getArg(d, 'version'),
|
|
n = f.getArg(d, 'sources'),
|
|
v = f.getArg(d, 'names', []),
|
|
z = f.getArg(d, 'sourceRoot', null),
|
|
G = f.getArg(d, 'sourcesContent', null),
|
|
D = f.getArg(d, 'mappings');
|
|
d = f.getArg(d, 'file', null);
|
|
if (g != this._version) throw Error('Unsupported version: ' + g);
|
|
z && (z = f.normalize(z));
|
|
n = n
|
|
.map(String)
|
|
.map(f.normalize)
|
|
.map(function (L) {
|
|
return z && f.isAbsolute(z) && f.isAbsolute(L) ?
|
|
f.relative(z, L)
|
|
: L;
|
|
});
|
|
this._names = l.fromArray(v.map(String), !0);
|
|
this._sources = l.fromArray(n, !0);
|
|
this.sourceRoot = z;
|
|
this.sourcesContent = G;
|
|
this._mappings = D;
|
|
this._sourceMapURL = u;
|
|
this.file = d;
|
|
}
|
|
function t() {
|
|
this.generatedColumn = this.generatedLine = 0;
|
|
this.name =
|
|
this.originalColumn =
|
|
this.originalLine =
|
|
this.source =
|
|
null;
|
|
}
|
|
function m(k, u) {
|
|
var d = k;
|
|
'string' === typeof k && (d = f.parseSourceMapInput(k));
|
|
var g = f.getArg(d, 'version');
|
|
d = f.getArg(d, 'sections');
|
|
if (g != this._version) throw Error('Unsupported version: ' + g);
|
|
this._sources = new l();
|
|
this._names = new l();
|
|
var n = { line: -1, column: 0 };
|
|
this._sections = d.map(function (v) {
|
|
if (v.url)
|
|
throw Error(
|
|
'Support for url field in sections not implemented.'
|
|
);
|
|
var z = f.getArg(v, 'offset'),
|
|
G = f.getArg(z, 'line'),
|
|
D = f.getArg(z, 'column');
|
|
if (G < n.line || (G === n.line && D < n.column))
|
|
throw Error(
|
|
'Section offsets must be ordered and non-overlapping.'
|
|
);
|
|
n = z;
|
|
return {
|
|
generatedOffset: {
|
|
generatedLine: G + 1,
|
|
generatedColumn: D + 1,
|
|
},
|
|
consumer: new e(f.getArg(v, 'map'), u),
|
|
};
|
|
});
|
|
}
|
|
var f = C('./util'),
|
|
c = C('./binary-search'),
|
|
l = C('./array-set').ArraySet,
|
|
q = C('./base64-vlq'),
|
|
r = C('./quick-sort').quickSort;
|
|
e.fromSourceMap = function (k) {
|
|
return p.fromSourceMap(k);
|
|
};
|
|
e.prototype._version = 3;
|
|
e.prototype.__generatedMappings = null;
|
|
Object.defineProperty(e.prototype, '_generatedMappings', {
|
|
configurable: !0,
|
|
enumerable: !0,
|
|
get: function () {
|
|
this.__generatedMappings ||
|
|
this._parseMappings(this._mappings, this.sourceRoot);
|
|
return this.__generatedMappings;
|
|
},
|
|
});
|
|
e.prototype.__originalMappings = null;
|
|
Object.defineProperty(e.prototype, '_originalMappings', {
|
|
configurable: !0,
|
|
enumerable: !0,
|
|
get: function () {
|
|
this.__originalMappings ||
|
|
this._parseMappings(this._mappings, this.sourceRoot);
|
|
return this.__originalMappings;
|
|
},
|
|
});
|
|
e.prototype._charIsMappingSeparator = function (k, u) {
|
|
var d = k.charAt(u);
|
|
return ';' === d || ',' === d;
|
|
};
|
|
e.prototype._parseMappings = function (k, u) {
|
|
throw Error('Subclasses must implement _parseMappings');
|
|
};
|
|
e.GENERATED_ORDER = 1;
|
|
e.ORIGINAL_ORDER = 2;
|
|
e.GREATEST_LOWER_BOUND = 1;
|
|
e.LEAST_UPPER_BOUND = 2;
|
|
e.prototype.eachMapping = function (k, u, d) {
|
|
u = u || null;
|
|
switch (d || e.GENERATED_ORDER) {
|
|
case e.GENERATED_ORDER:
|
|
d = this._generatedMappings;
|
|
break;
|
|
case e.ORIGINAL_ORDER:
|
|
d = this._originalMappings;
|
|
break;
|
|
default:
|
|
throw Error('Unknown order of iteration.');
|
|
}
|
|
var g = this.sourceRoot;
|
|
d.map(function (n) {
|
|
var v = null === n.source ? null : this._sources.at(n.source);
|
|
v = f.computeSourceURL(g, v, this._sourceMapURL);
|
|
return {
|
|
source: v,
|
|
generatedLine: n.generatedLine,
|
|
generatedColumn: n.generatedColumn,
|
|
originalLine: n.originalLine,
|
|
originalColumn: n.originalColumn,
|
|
name: null === n.name ? null : this._names.at(n.name),
|
|
};
|
|
}, this).forEach(k, u);
|
|
};
|
|
e.prototype.allGeneratedPositionsFor = function (k) {
|
|
var u = f.getArg(k, 'line'),
|
|
d = {
|
|
source: f.getArg(k, 'source'),
|
|
originalLine: u,
|
|
originalColumn: f.getArg(k, 'column', 0),
|
|
};
|
|
null != this.sourceRoot &&
|
|
(d.source = f.relative(this.sourceRoot, d.source));
|
|
if (!this._sources.has(d.source)) return [];
|
|
d.source = this._sources.indexOf(d.source);
|
|
var g = [];
|
|
d = this._findMapping(
|
|
d,
|
|
this._originalMappings,
|
|
'originalLine',
|
|
'originalColumn',
|
|
f.compareByOriginalPositions,
|
|
c.LEAST_UPPER_BOUND
|
|
);
|
|
if (0 <= d) {
|
|
var n = this._originalMappings[d];
|
|
if (void 0 === k.column)
|
|
for (u = n.originalLine; n && n.originalLine === u; )
|
|
g.push({
|
|
line: f.getArg(n, 'generatedLine', null),
|
|
column: f.getArg(n, 'generatedColumn', null),
|
|
lastColumn: f.getArg(n, 'lastGeneratedColumn', null),
|
|
}),
|
|
(n = this._originalMappings[++d]);
|
|
else
|
|
for (
|
|
k = n.originalColumn;
|
|
n && n.originalLine === u && n.originalColumn == k;
|
|
|
|
)
|
|
g.push({
|
|
line: f.getArg(n, 'generatedLine', null),
|
|
column: f.getArg(n, 'generatedColumn', null),
|
|
lastColumn: f.getArg(n, 'lastGeneratedColumn', null),
|
|
}),
|
|
(n = this._originalMappings[++d]);
|
|
}
|
|
return g;
|
|
};
|
|
A.SourceMapConsumer = e;
|
|
p.prototype = Object.create(e.prototype);
|
|
p.prototype.consumer = e;
|
|
p.fromSourceMap = function (k, u) {
|
|
var d = Object.create(p.prototype),
|
|
g = (d._names = l.fromArray(k._names.toArray(), !0)),
|
|
n = (d._sources = l.fromArray(k._sources.toArray(), !0));
|
|
d.sourceRoot = k._sourceRoot;
|
|
d.sourcesContent = k._generateSourcesContent(
|
|
d._sources.toArray(),
|
|
d.sourceRoot
|
|
);
|
|
d.file = k._file;
|
|
d._sourceMapURL = u;
|
|
for (
|
|
var v = k._mappings.toArray().slice(),
|
|
z = (d.__generatedMappings = []),
|
|
G = (d.__originalMappings = []),
|
|
D = 0,
|
|
L = v.length;
|
|
D < L;
|
|
D++
|
|
) {
|
|
var a = v[D],
|
|
b = new t();
|
|
b.generatedLine = a.generatedLine;
|
|
b.generatedColumn = a.generatedColumn;
|
|
a.source &&
|
|
((b.source = n.indexOf(a.source)),
|
|
(b.originalLine = a.originalLine),
|
|
(b.originalColumn = a.originalColumn),
|
|
a.name && (b.name = g.indexOf(a.name)),
|
|
G.push(b));
|
|
z.push(b);
|
|
}
|
|
r(d.__originalMappings, f.compareByOriginalPositions);
|
|
return d;
|
|
};
|
|
p.prototype._version = 3;
|
|
Object.defineProperty(p.prototype, 'sources', {
|
|
get: function () {
|
|
return this._sources.toArray().map(function (k) {
|
|
return f.computeSourceURL(
|
|
this.sourceRoot,
|
|
k,
|
|
this._sourceMapURL
|
|
);
|
|
}, this);
|
|
},
|
|
});
|
|
p.prototype._parseMappings = function (k, u) {
|
|
for (
|
|
var d = 1,
|
|
g = 0,
|
|
n = 0,
|
|
v = 0,
|
|
z = 0,
|
|
G = 0,
|
|
D = k.length,
|
|
L = 0,
|
|
a = {},
|
|
b = {},
|
|
h = [],
|
|
w = [],
|
|
y,
|
|
I,
|
|
K,
|
|
N,
|
|
P;
|
|
L < D;
|
|
|
|
)
|
|
if (';' === k.charAt(L)) d++, L++, (g = 0);
|
|
else if (',' === k.charAt(L)) L++;
|
|
else {
|
|
y = new t();
|
|
y.generatedLine = d;
|
|
for (N = L; N < D && !this._charIsMappingSeparator(k, N); N++);
|
|
I = k.slice(L, N);
|
|
if ((K = a[I])) L += I.length;
|
|
else {
|
|
for (K = []; L < N; )
|
|
q.decode(k, L, b), (P = b.value), (L = b.rest), K.push(P);
|
|
if (2 === K.length)
|
|
throw Error('Found a source, but no line and column');
|
|
if (3 === K.length)
|
|
throw Error('Found a source and line, but no column');
|
|
a[I] = K;
|
|
}
|
|
y.generatedColumn = g + K[0];
|
|
g = y.generatedColumn;
|
|
1 < K.length &&
|
|
((y.source = z + K[1]),
|
|
(z += K[1]),
|
|
(y.originalLine = n + K[2]),
|
|
(n = y.originalLine),
|
|
(y.originalLine += 1),
|
|
(y.originalColumn = v + K[3]),
|
|
(v = y.originalColumn),
|
|
4 < K.length && ((y.name = G + K[4]), (G += K[4])));
|
|
w.push(y);
|
|
'number' === typeof y.originalLine && h.push(y);
|
|
}
|
|
r(w, f.compareByGeneratedPositionsDeflated);
|
|
this.__generatedMappings = w;
|
|
r(h, f.compareByOriginalPositions);
|
|
this.__originalMappings = h;
|
|
};
|
|
p.prototype._findMapping = function (k, u, d, g, n, v) {
|
|
if (0 >= k[d])
|
|
throw new TypeError(
|
|
'Line must be greater than or equal to 1, got ' + k[d]
|
|
);
|
|
if (0 > k[g])
|
|
throw new TypeError(
|
|
'Column must be greater than or equal to 0, got ' + k[g]
|
|
);
|
|
return c.search(k, u, n, v);
|
|
};
|
|
p.prototype.computeColumnSpans = function () {
|
|
for (var k = 0; k < this._generatedMappings.length; ++k) {
|
|
var u = this._generatedMappings[k];
|
|
if (k + 1 < this._generatedMappings.length) {
|
|
var d = this._generatedMappings[k + 1];
|
|
if (u.generatedLine === d.generatedLine) {
|
|
u.lastGeneratedColumn = d.generatedColumn - 1;
|
|
continue;
|
|
}
|
|
}
|
|
u.lastGeneratedColumn = Infinity;
|
|
}
|
|
};
|
|
p.prototype.originalPositionFor = function (k) {
|
|
var u = {
|
|
generatedLine: f.getArg(k, 'line'),
|
|
generatedColumn: f.getArg(k, 'column'),
|
|
};
|
|
k = this._findMapping(
|
|
u,
|
|
this._generatedMappings,
|
|
'generatedLine',
|
|
'generatedColumn',
|
|
f.compareByGeneratedPositionsDeflated,
|
|
f.getArg(k, 'bias', e.GREATEST_LOWER_BOUND)
|
|
);
|
|
if (
|
|
0 <= k &&
|
|
((k = this._generatedMappings[k]),
|
|
k.generatedLine === u.generatedLine)
|
|
) {
|
|
u = f.getArg(k, 'source', null);
|
|
null !== u &&
|
|
((u = this._sources.at(u)),
|
|
(u = f.computeSourceURL(
|
|
this.sourceRoot,
|
|
u,
|
|
this._sourceMapURL
|
|
)));
|
|
var d = f.getArg(k, 'name', null);
|
|
null !== d && (d = this._names.at(d));
|
|
return {
|
|
source: u,
|
|
line: f.getArg(k, 'originalLine', null),
|
|
column: f.getArg(k, 'originalColumn', null),
|
|
name: d,
|
|
};
|
|
}
|
|
return { source: null, line: null, column: null, name: null };
|
|
};
|
|
p.prototype.hasContentsOfAllSources = function () {
|
|
return this.sourcesContent ?
|
|
this.sourcesContent.length >= this._sources.size() &&
|
|
!this.sourcesContent.some(function (k) {
|
|
return null == k;
|
|
})
|
|
: !1;
|
|
};
|
|
p.prototype.sourceContentFor = function (k, u) {
|
|
if (!this.sourcesContent) return null;
|
|
var d = k;
|
|
null != this.sourceRoot && (d = f.relative(this.sourceRoot, d));
|
|
if (this._sources.has(d))
|
|
return this.sourcesContent[this._sources.indexOf(d)];
|
|
var g = this.sources,
|
|
n;
|
|
for (n = 0; n < g.length; ++n)
|
|
if (g[n] == k) return this.sourcesContent[n];
|
|
var v;
|
|
if (null != this.sourceRoot && (v = f.urlParse(this.sourceRoot))) {
|
|
g = d.replace(/^file:\/\//, '');
|
|
if ('file' == v.scheme && this._sources.has(g))
|
|
return this.sourcesContent[this._sources.indexOf(g)];
|
|
if ((!v.path || '/' == v.path) && this._sources.has('/' + d))
|
|
return this.sourcesContent[this._sources.indexOf('/' + d)];
|
|
}
|
|
if (u) return null;
|
|
throw Error('"' + d + '" is not in the SourceMap.');
|
|
};
|
|
p.prototype.generatedPositionFor = function (k) {
|
|
var u = f.getArg(k, 'source');
|
|
null != this.sourceRoot && (u = f.relative(this.sourceRoot, u));
|
|
if (!this._sources.has(u))
|
|
return { line: null, column: null, lastColumn: null };
|
|
u = this._sources.indexOf(u);
|
|
u = {
|
|
source: u,
|
|
originalLine: f.getArg(k, 'line'),
|
|
originalColumn: f.getArg(k, 'column'),
|
|
};
|
|
k = this._findMapping(
|
|
u,
|
|
this._originalMappings,
|
|
'originalLine',
|
|
'originalColumn',
|
|
f.compareByOriginalPositions,
|
|
f.getArg(k, 'bias', e.GREATEST_LOWER_BOUND)
|
|
);
|
|
return (
|
|
0 <= k &&
|
|
((k = this._originalMappings[k]), k.source === u.source)
|
|
) ?
|
|
{
|
|
line: f.getArg(k, 'generatedLine', null),
|
|
column: f.getArg(k, 'generatedColumn', null),
|
|
lastColumn: f.getArg(k, 'lastGeneratedColumn', null),
|
|
}
|
|
: { line: null, column: null, lastColumn: null };
|
|
};
|
|
A.BasicSourceMapConsumer = p;
|
|
m.prototype = Object.create(e.prototype);
|
|
m.prototype.constructor = e;
|
|
m.prototype._version = 3;
|
|
Object.defineProperty(m.prototype, 'sources', {
|
|
get: function () {
|
|
for (var k = [], u = 0; u < this._sections.length; u++)
|
|
for (
|
|
var d = 0;
|
|
d < this._sections[u].consumer.sources.length;
|
|
d++
|
|
)
|
|
k.push(this._sections[u].consumer.sources[d]);
|
|
return k;
|
|
},
|
|
});
|
|
m.prototype.originalPositionFor = function (k) {
|
|
var u = {
|
|
generatedLine: f.getArg(k, 'line'),
|
|
generatedColumn: f.getArg(k, 'column'),
|
|
},
|
|
d = c.search(u, this._sections, function (g, n) {
|
|
var v = g.generatedLine - n.generatedOffset.generatedLine;
|
|
return v ? v : (
|
|
g.generatedColumn - n.generatedOffset.generatedColumn
|
|
);
|
|
});
|
|
return (d = this._sections[d]) ?
|
|
d.consumer.originalPositionFor({
|
|
line: u.generatedLine - (d.generatedOffset.generatedLine - 1),
|
|
column:
|
|
u.generatedColumn -
|
|
(d.generatedOffset.generatedLine === u.generatedLine ?
|
|
d.generatedOffset.generatedColumn - 1
|
|
: 0),
|
|
bias: k.bias,
|
|
})
|
|
: { source: null, line: null, column: null, name: null };
|
|
};
|
|
m.prototype.hasContentsOfAllSources = function () {
|
|
return this._sections.every(function (k) {
|
|
return k.consumer.hasContentsOfAllSources();
|
|
});
|
|
};
|
|
m.prototype.sourceContentFor = function (k, u) {
|
|
for (var d = 0; d < this._sections.length; d++) {
|
|
var g = this._sections[d].consumer.sourceContentFor(k, !0);
|
|
if (g) return g;
|
|
}
|
|
if (u) return null;
|
|
throw Error('"' + k + '" is not in the SourceMap.');
|
|
};
|
|
m.prototype.generatedPositionFor = function (k) {
|
|
for (var u = 0; u < this._sections.length; u++) {
|
|
var d = this._sections[u];
|
|
if (-1 !== d.consumer.sources.indexOf(f.getArg(k, 'source'))) {
|
|
var g = d.consumer.generatedPositionFor(k);
|
|
if (g)
|
|
return {
|
|
line: g.line + (d.generatedOffset.generatedLine - 1),
|
|
column:
|
|
g.column +
|
|
(d.generatedOffset.generatedLine === g.line ?
|
|
d.generatedOffset.generatedColumn - 1
|
|
: 0),
|
|
};
|
|
}
|
|
}
|
|
return { line: null, column: null };
|
|
};
|
|
m.prototype._parseMappings = function (k, u) {
|
|
this.__generatedMappings = [];
|
|
this.__originalMappings = [];
|
|
for (var d = 0; d < this._sections.length; d++)
|
|
for (
|
|
var g = this._sections[d],
|
|
n = g.consumer._generatedMappings,
|
|
v = 0;
|
|
v < n.length;
|
|
v++
|
|
) {
|
|
var z = n[v],
|
|
G = g.consumer._sources.at(z.source);
|
|
G = f.computeSourceURL(
|
|
g.consumer.sourceRoot,
|
|
G,
|
|
this._sourceMapURL
|
|
);
|
|
this._sources.add(G);
|
|
G = this._sources.indexOf(G);
|
|
var D = null;
|
|
z.name &&
|
|
((D = g.consumer._names.at(z.name)),
|
|
this._names.add(D),
|
|
(D = this._names.indexOf(D)));
|
|
z = {
|
|
source: G,
|
|
generatedLine:
|
|
z.generatedLine + (g.generatedOffset.generatedLine - 1),
|
|
generatedColumn:
|
|
z.generatedColumn +
|
|
(g.generatedOffset.generatedLine === z.generatedLine ?
|
|
g.generatedOffset.generatedColumn - 1
|
|
: 0),
|
|
originalLine: z.originalLine,
|
|
originalColumn: z.originalColumn,
|
|
name: D,
|
|
};
|
|
this.__generatedMappings.push(z);
|
|
'number' === typeof z.originalLine &&
|
|
this.__originalMappings.push(z);
|
|
}
|
|
r(this.__generatedMappings, f.compareByGeneratedPositionsDeflated);
|
|
r(this.__originalMappings, f.compareByOriginalPositions);
|
|
};
|
|
A.IndexedSourceMapConsumer = m;
|
|
},
|
|
{
|
|
'./array-set': 10,
|
|
'./base64-vlq': 11,
|
|
'./binary-search': 13,
|
|
'./quick-sort': 15,
|
|
'./util': 19,
|
|
},
|
|
],
|
|
17: [
|
|
function (C, J, A) {
|
|
function e(c) {
|
|
c || (c = {});
|
|
this._file = t.getArg(c, 'file', null);
|
|
this._sourceRoot = t.getArg(c, 'sourceRoot', null);
|
|
this._skipValidation = t.getArg(c, 'skipValidation', !1);
|
|
this._sources = new m();
|
|
this._names = new m();
|
|
this._mappings = new f();
|
|
this._sourcesContents = null;
|
|
}
|
|
var p = C('./base64-vlq'),
|
|
t = C('./util'),
|
|
m = C('./array-set').ArraySet,
|
|
f = C('./mapping-list').MappingList;
|
|
e.prototype._version = 3;
|
|
e.fromSourceMap = function (c) {
|
|
var l = c.sourceRoot,
|
|
q = new e({ file: c.file, sourceRoot: l });
|
|
c.eachMapping(function (r) {
|
|
var k = {
|
|
generated: { line: r.generatedLine, column: r.generatedColumn },
|
|
};
|
|
null != r.source &&
|
|
((k.source = r.source),
|
|
null != l && (k.source = t.relative(l, k.source)),
|
|
(k.original = {
|
|
line: r.originalLine,
|
|
column: r.originalColumn,
|
|
}),
|
|
null != r.name && (k.name = r.name));
|
|
q.addMapping(k);
|
|
});
|
|
c.sources.forEach(function (r) {
|
|
var k = r;
|
|
null !== l && (k = t.relative(l, r));
|
|
q._sources.has(k) || q._sources.add(k);
|
|
k = c.sourceContentFor(r);
|
|
null != k && q.setSourceContent(r, k);
|
|
});
|
|
return q;
|
|
};
|
|
e.prototype.addMapping = function (c) {
|
|
var l = t.getArg(c, 'generated'),
|
|
q = t.getArg(c, 'original', null),
|
|
r = t.getArg(c, 'source', null);
|
|
c = t.getArg(c, 'name', null);
|
|
this._skipValidation || this._validateMapping(l, q, r, c);
|
|
null != r &&
|
|
((r = String(r)), this._sources.has(r) || this._sources.add(r));
|
|
null != c &&
|
|
((c = String(c)), this._names.has(c) || this._names.add(c));
|
|
this._mappings.add({
|
|
generatedLine: l.line,
|
|
generatedColumn: l.column,
|
|
originalLine: null != q && q.line,
|
|
originalColumn: null != q && q.column,
|
|
source: r,
|
|
name: c,
|
|
});
|
|
};
|
|
e.prototype.setSourceContent = function (c, l) {
|
|
var q = c;
|
|
null != this._sourceRoot && (q = t.relative(this._sourceRoot, q));
|
|
null != l ?
|
|
(this._sourcesContents ||
|
|
(this._sourcesContents = Object.create(null)),
|
|
(this._sourcesContents[t.toSetString(q)] = l))
|
|
: this._sourcesContents &&
|
|
(delete this._sourcesContents[t.toSetString(q)],
|
|
0 === Object.keys(this._sourcesContents).length &&
|
|
(this._sourcesContents = null));
|
|
};
|
|
e.prototype.applySourceMap = function (c, l, q) {
|
|
var r = l;
|
|
if (null == l) {
|
|
if (null == c.file)
|
|
throw Error(
|
|
'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map\'s "file" property. Both were omitted.'
|
|
);
|
|
r = c.file;
|
|
}
|
|
var k = this._sourceRoot;
|
|
null != k && (r = t.relative(k, r));
|
|
var u = new m(),
|
|
d = new m();
|
|
this._mappings.unsortedForEach(function (g) {
|
|
if (g.source === r && null != g.originalLine) {
|
|
var n = c.originalPositionFor({
|
|
line: g.originalLine,
|
|
column: g.originalColumn,
|
|
});
|
|
null != n.source &&
|
|
((g.source = n.source),
|
|
null != q && (g.source = t.join(q, g.source)),
|
|
null != k && (g.source = t.relative(k, g.source)),
|
|
(g.originalLine = n.line),
|
|
(g.originalColumn = n.column),
|
|
null != n.name && (g.name = n.name));
|
|
}
|
|
n = g.source;
|
|
null == n || u.has(n) || u.add(n);
|
|
g = g.name;
|
|
null == g || d.has(g) || d.add(g);
|
|
}, this);
|
|
this._sources = u;
|
|
this._names = d;
|
|
c.sources.forEach(function (g) {
|
|
var n = c.sourceContentFor(g);
|
|
null != n &&
|
|
(null != q && (g = t.join(q, g)),
|
|
null != k && (g = t.relative(k, g)),
|
|
this.setSourceContent(g, n));
|
|
}, this);
|
|
};
|
|
e.prototype._validateMapping = function (c, l, q, r) {
|
|
if (l && 'number' !== typeof l.line && 'number' !== typeof l.column)
|
|
throw Error(
|
|
'original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.'
|
|
);
|
|
if (
|
|
!(
|
|
(c &&
|
|
'line' in c &&
|
|
'column' in c &&
|
|
0 < c.line &&
|
|
0 <= c.column &&
|
|
!l &&
|
|
!q &&
|
|
!r) ||
|
|
(c &&
|
|
'line' in c &&
|
|
'column' in c &&
|
|
l &&
|
|
'line' in l &&
|
|
'column' in l &&
|
|
0 < c.line &&
|
|
0 <= c.column &&
|
|
0 < l.line &&
|
|
0 <= l.column &&
|
|
q)
|
|
)
|
|
)
|
|
throw Error(
|
|
'Invalid mapping: ' +
|
|
JSON.stringify({
|
|
generated: c,
|
|
source: q,
|
|
original: l,
|
|
name: r,
|
|
})
|
|
);
|
|
};
|
|
e.prototype._serializeMappings = function () {
|
|
for (
|
|
var c = 0,
|
|
l = 1,
|
|
q = 0,
|
|
r = 0,
|
|
k = 0,
|
|
u = 0,
|
|
d = '',
|
|
g,
|
|
n,
|
|
v,
|
|
z = this._mappings.toArray(),
|
|
G = 0,
|
|
D = z.length;
|
|
G < D;
|
|
G++
|
|
) {
|
|
n = z[G];
|
|
g = '';
|
|
if (n.generatedLine !== l)
|
|
for (c = 0; n.generatedLine !== l; ) (g += ';'), l++;
|
|
else if (0 < G) {
|
|
if (!t.compareByGeneratedPositionsInflated(n, z[G - 1]))
|
|
continue;
|
|
g += ',';
|
|
}
|
|
g += p.encode(n.generatedColumn - c);
|
|
c = n.generatedColumn;
|
|
null != n.source &&
|
|
((v = this._sources.indexOf(n.source)),
|
|
(g += p.encode(v - u)),
|
|
(u = v),
|
|
(g += p.encode(n.originalLine - 1 - r)),
|
|
(r = n.originalLine - 1),
|
|
(g += p.encode(n.originalColumn - q)),
|
|
(q = n.originalColumn),
|
|
null != n.name &&
|
|
((n = this._names.indexOf(n.name)),
|
|
(g += p.encode(n - k)),
|
|
(k = n)));
|
|
d += g;
|
|
}
|
|
return d;
|
|
};
|
|
e.prototype._generateSourcesContent = function (c, l) {
|
|
return c.map(function (q) {
|
|
if (!this._sourcesContents) return null;
|
|
null != l && (q = t.relative(l, q));
|
|
q = t.toSetString(q);
|
|
return (
|
|
Object.prototype.hasOwnProperty.call(this._sourcesContents, q)
|
|
) ?
|
|
this._sourcesContents[q]
|
|
: null;
|
|
}, this);
|
|
};
|
|
e.prototype.toJSON = function () {
|
|
var c = {
|
|
version: this._version,
|
|
sources: this._sources.toArray(),
|
|
names: this._names.toArray(),
|
|
mappings: this._serializeMappings(),
|
|
};
|
|
null != this._file && (c.file = this._file);
|
|
null != this._sourceRoot && (c.sourceRoot = this._sourceRoot);
|
|
this._sourcesContents &&
|
|
(c.sourcesContent = this._generateSourcesContent(
|
|
c.sources,
|
|
c.sourceRoot
|
|
));
|
|
return c;
|
|
};
|
|
e.prototype.toString = function () {
|
|
return JSON.stringify(this.toJSON());
|
|
};
|
|
A.SourceMapGenerator = e;
|
|
},
|
|
{
|
|
'./array-set': 10,
|
|
'./base64-vlq': 11,
|
|
'./mapping-list': 14,
|
|
'./util': 19,
|
|
},
|
|
],
|
|
18: [
|
|
function (C, J, A) {
|
|
function e(f, c, l, q, r) {
|
|
this.children = [];
|
|
this.sourceContents = {};
|
|
this.line = null == f ? null : f;
|
|
this.column = null == c ? null : c;
|
|
this.source = null == l ? null : l;
|
|
this.name = null == r ? null : r;
|
|
this.$$$isSourceNode$$$ = !0;
|
|
null != q && this.add(q);
|
|
}
|
|
var p = C('./source-map-generator').SourceMapGenerator,
|
|
t = C('./util'),
|
|
m = /(\r?\n)/;
|
|
e.fromStringWithSourceMap = function (f, c, l) {
|
|
function q(z, G) {
|
|
if (null === z || void 0 === z.source) r.add(G);
|
|
else {
|
|
var D = l ? t.join(l, z.source) : z.source;
|
|
r.add(new e(z.originalLine, z.originalColumn, D, G, z.name));
|
|
}
|
|
}
|
|
var r = new e(),
|
|
k = f.split(m),
|
|
u = 0,
|
|
d = function () {
|
|
var z = u < k.length ? k[u++] : void 0,
|
|
G = (u < k.length ? k[u++] : void 0) || '';
|
|
return z + G;
|
|
},
|
|
g = 1,
|
|
n = 0,
|
|
v = null;
|
|
c.eachMapping(function (z) {
|
|
if (null !== v)
|
|
if (g < z.generatedLine) q(v, d()), g++, (n = 0);
|
|
else {
|
|
var G = k[u] || '',
|
|
D = G.substr(0, z.generatedColumn - n);
|
|
k[u] = G.substr(z.generatedColumn - n);
|
|
n = z.generatedColumn;
|
|
q(v, D);
|
|
v = z;
|
|
return;
|
|
}
|
|
for (; g < z.generatedLine; ) r.add(d()), g++;
|
|
n < z.generatedColumn &&
|
|
((G = k[u] || ''),
|
|
r.add(G.substr(0, z.generatedColumn)),
|
|
(k[u] = G.substr(z.generatedColumn)),
|
|
(n = z.generatedColumn));
|
|
v = z;
|
|
}, this);
|
|
u < k.length && (v && q(v, d()), r.add(k.splice(u).join('')));
|
|
c.sources.forEach(function (z) {
|
|
var G = c.sourceContentFor(z);
|
|
null != G &&
|
|
(null != l && (z = t.join(l, z)), r.setSourceContent(z, G));
|
|
});
|
|
return r;
|
|
};
|
|
e.prototype.add = function (f) {
|
|
if (Array.isArray(f))
|
|
f.forEach(function (c) {
|
|
this.add(c);
|
|
}, this);
|
|
else if (f.$$$isSourceNode$$$ || 'string' === typeof f)
|
|
f && this.children.push(f);
|
|
else
|
|
throw new TypeError(
|
|
'Expected a SourceNode, string, or an array of SourceNodes and strings. Got ' +
|
|
f
|
|
);
|
|
return this;
|
|
};
|
|
e.prototype.prepend = function (f) {
|
|
if (Array.isArray(f))
|
|
for (var c = f.length - 1; 0 <= c; c--) this.prepend(f[c]);
|
|
else if (f.$$$isSourceNode$$$ || 'string' === typeof f)
|
|
this.children.unshift(f);
|
|
else
|
|
throw new TypeError(
|
|
'Expected a SourceNode, string, or an array of SourceNodes and strings. Got ' +
|
|
f
|
|
);
|
|
return this;
|
|
};
|
|
e.prototype.walk = function (f) {
|
|
for (var c, l = 0, q = this.children.length; l < q; l++)
|
|
(c = this.children[l]),
|
|
c.$$$isSourceNode$$$ ?
|
|
c.walk(f)
|
|
: '' !== c &&
|
|
f(c, {
|
|
source: this.source,
|
|
line: this.line,
|
|
column: this.column,
|
|
name: this.name,
|
|
});
|
|
};
|
|
e.prototype.join = function (f) {
|
|
var c,
|
|
l = this.children.length;
|
|
if (0 < l) {
|
|
var q = [];
|
|
for (c = 0; c < l - 1; c++) q.push(this.children[c]), q.push(f);
|
|
q.push(this.children[c]);
|
|
this.children = q;
|
|
}
|
|
return this;
|
|
};
|
|
e.prototype.replaceRight = function (f, c) {
|
|
var l = this.children[this.children.length - 1];
|
|
l.$$$isSourceNode$$$ ? l.replaceRight(f, c)
|
|
: 'string' === typeof l ?
|
|
(this.children[this.children.length - 1] = l.replace(f, c))
|
|
: this.children.push(''.replace(f, c));
|
|
return this;
|
|
};
|
|
e.prototype.setSourceContent = function (f, c) {
|
|
this.sourceContents[t.toSetString(f)] = c;
|
|
};
|
|
e.prototype.walkSourceContents = function (f) {
|
|
for (var c = 0, l = this.children.length; c < l; c++)
|
|
this.children[c].$$$isSourceNode$$$ &&
|
|
this.children[c].walkSourceContents(f);
|
|
var q = Object.keys(this.sourceContents);
|
|
c = 0;
|
|
for (l = q.length; c < l; c++)
|
|
f(t.fromSetString(q[c]), this.sourceContents[q[c]]);
|
|
};
|
|
e.prototype.toString = function () {
|
|
var f = '';
|
|
this.walk(function (c) {
|
|
f += c;
|
|
});
|
|
return f;
|
|
};
|
|
e.prototype.toStringWithSourceMap = function (f) {
|
|
var c = '',
|
|
l = 1,
|
|
q = 0,
|
|
r = new p(f),
|
|
k = !1,
|
|
u = null,
|
|
d = null,
|
|
g = null,
|
|
n = null;
|
|
this.walk(function (v, z) {
|
|
c += v;
|
|
null !== z.source && null !== z.line && null !== z.column ?
|
|
((u === z.source &&
|
|
d === z.line &&
|
|
g === z.column &&
|
|
n === z.name) ||
|
|
r.addMapping({
|
|
source: z.source,
|
|
original: { line: z.line, column: z.column },
|
|
generated: { line: l, column: q },
|
|
name: z.name,
|
|
}),
|
|
(u = z.source),
|
|
(d = z.line),
|
|
(g = z.column),
|
|
(n = z.name),
|
|
(k = !0))
|
|
: k &&
|
|
(r.addMapping({ generated: { line: l, column: q } }),
|
|
(u = null),
|
|
(k = !1));
|
|
for (var G = 0, D = v.length; G < D; G++)
|
|
10 === v.charCodeAt(G) ?
|
|
(l++,
|
|
(q = 0),
|
|
G + 1 === D ?
|
|
((u = null), (k = !1))
|
|
: k &&
|
|
r.addMapping({
|
|
source: z.source,
|
|
original: { line: z.line, column: z.column },
|
|
generated: { line: l, column: q },
|
|
name: z.name,
|
|
}))
|
|
: q++;
|
|
});
|
|
this.walkSourceContents(function (v, z) {
|
|
r.setSourceContent(v, z);
|
|
});
|
|
return { code: c, map: r };
|
|
};
|
|
A.SourceNode = e;
|
|
},
|
|
{ './source-map-generator': 17, './util': 19 },
|
|
],
|
|
19: [
|
|
function (C, J, A) {
|
|
function e(d) {
|
|
return (d = d.match(k)) ?
|
|
{ scheme: d[1], auth: d[2], host: d[3], port: d[4], path: d[5] }
|
|
: null;
|
|
}
|
|
function p(d) {
|
|
var g = '';
|
|
d.scheme && (g += d.scheme + ':');
|
|
g += '//';
|
|
d.auth && (g += d.auth + '@');
|
|
d.host && (g += d.host);
|
|
d.port && (g += ':' + d.port);
|
|
d.path && (g += d.path);
|
|
return g;
|
|
}
|
|
function t(d) {
|
|
var g = d,
|
|
n = e(d);
|
|
if (n) {
|
|
if (!n.path) return d;
|
|
g = n.path;
|
|
}
|
|
d = A.isAbsolute(g);
|
|
g = g.split(/\/+/);
|
|
for (var v, z = 0, G = g.length - 1; 0 <= G; G--)
|
|
(v = g[G]),
|
|
'.' === v ? g.splice(G, 1)
|
|
: '..' === v ? z++
|
|
: 0 < z &&
|
|
('' === v ?
|
|
(g.splice(G + 1, z), (z = 0))
|
|
: (g.splice(G, 2), z--));
|
|
g = g.join('/');
|
|
'' === g && (g = d ? '/' : '.');
|
|
return n ? ((n.path = g), p(n)) : g;
|
|
}
|
|
function m(d, g) {
|
|
'' === d && (d = '.');
|
|
'' === g && (g = '.');
|
|
var n = e(g),
|
|
v = e(d);
|
|
v && (d = v.path || '/');
|
|
if (n && !n.scheme) return v && (n.scheme = v.scheme), p(n);
|
|
if (n || g.match(u)) return g;
|
|
if (v && !v.host && !v.path) return (v.host = g), p(v);
|
|
n = '/' === g.charAt(0) ? g : t(d.replace(/\/+$/, '') + '/' + g);
|
|
return v ? ((v.path = n), p(v)) : n;
|
|
}
|
|
function f(d) {
|
|
return d;
|
|
}
|
|
function c(d) {
|
|
return q(d) ? '$' + d : d;
|
|
}
|
|
function l(d) {
|
|
return q(d) ? d.slice(1) : d;
|
|
}
|
|
function q(d) {
|
|
if (!d) return !1;
|
|
var g = d.length;
|
|
if (
|
|
9 > g ||
|
|
95 !== d.charCodeAt(g - 1) ||
|
|
95 !== d.charCodeAt(g - 2) ||
|
|
111 !== d.charCodeAt(g - 3) ||
|
|
116 !== d.charCodeAt(g - 4) ||
|
|
111 !== d.charCodeAt(g - 5) ||
|
|
114 !== d.charCodeAt(g - 6) ||
|
|
112 !== d.charCodeAt(g - 7) ||
|
|
95 !== d.charCodeAt(g - 8) ||
|
|
95 !== d.charCodeAt(g - 9)
|
|
)
|
|
return !1;
|
|
for (g -= 10; 0 <= g; g--) if (36 !== d.charCodeAt(g)) return !1;
|
|
return !0;
|
|
}
|
|
function r(d, g) {
|
|
return (
|
|
d === g ? 0
|
|
: null === d ? 1
|
|
: null === g ? -1
|
|
: d > g ? 1
|
|
: -1
|
|
);
|
|
}
|
|
A.getArg = function (d, g, n) {
|
|
if (g in d) return d[g];
|
|
if (3 === arguments.length) return n;
|
|
throw Error('"' + g + '" is a required argument.');
|
|
};
|
|
var k =
|
|
/^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/,
|
|
u = /^data:.+,.+$/;
|
|
A.urlParse = e;
|
|
A.urlGenerate = p;
|
|
A.normalize = t;
|
|
A.join = m;
|
|
A.isAbsolute = function (d) {
|
|
return '/' === d.charAt(0) || k.test(d);
|
|
};
|
|
A.relative = function (d, g) {
|
|
'' === d && (d = '.');
|
|
d = d.replace(/\/$/, '');
|
|
for (var n = 0; 0 !== g.indexOf(d + '/'); ) {
|
|
var v = d.lastIndexOf('/');
|
|
if (0 > v) return g;
|
|
d = d.slice(0, v);
|
|
if (d.match(/^([^\/]+:\/)?\/*$/)) return g;
|
|
++n;
|
|
}
|
|
return Array(n + 1).join('../') + g.substr(d.length + 1);
|
|
};
|
|
C = !('__proto__' in Object.create(null));
|
|
A.toSetString = C ? f : c;
|
|
A.fromSetString = C ? f : l;
|
|
A.compareByOriginalPositions = function (d, g, n) {
|
|
var v = r(d.source, g.source);
|
|
if (0 !== v) return v;
|
|
v = d.originalLine - g.originalLine;
|
|
if (0 !== v) return v;
|
|
v = d.originalColumn - g.originalColumn;
|
|
if (0 !== v || n) return v;
|
|
v = d.generatedColumn - g.generatedColumn;
|
|
if (0 !== v) return v;
|
|
v = d.generatedLine - g.generatedLine;
|
|
return 0 !== v ? v : r(d.name, g.name);
|
|
};
|
|
A.compareByGeneratedPositionsDeflated = function (d, g, n) {
|
|
var v = d.generatedLine - g.generatedLine;
|
|
if (0 !== v) return v;
|
|
v = d.generatedColumn - g.generatedColumn;
|
|
if (0 !== v || n) return v;
|
|
v = r(d.source, g.source);
|
|
if (0 !== v) return v;
|
|
v = d.originalLine - g.originalLine;
|
|
if (0 !== v) return v;
|
|
v = d.originalColumn - g.originalColumn;
|
|
return 0 !== v ? v : r(d.name, g.name);
|
|
};
|
|
A.compareByGeneratedPositionsInflated = function (d, g) {
|
|
var n = d.generatedLine - g.generatedLine;
|
|
if (0 !== n) return n;
|
|
n = d.generatedColumn - g.generatedColumn;
|
|
if (0 !== n) return n;
|
|
n = r(d.source, g.source);
|
|
if (0 !== n) return n;
|
|
n = d.originalLine - g.originalLine;
|
|
if (0 !== n) return n;
|
|
n = d.originalColumn - g.originalColumn;
|
|
return 0 !== n ? n : r(d.name, g.name);
|
|
};
|
|
A.parseSourceMapInput = function (d) {
|
|
return JSON.parse(d.replace(/^\)]}'[^\n]*\n/, ''));
|
|
};
|
|
A.computeSourceURL = function (d, g, n) {
|
|
g = g || '';
|
|
d &&
|
|
('/' !== d[d.length - 1] && '/' !== g[0] && (d += '/'),
|
|
(g = d + g));
|
|
if (n) {
|
|
d = e(n);
|
|
if (!d) throw Error('sourceMapURL could not be parsed');
|
|
d.path &&
|
|
((n = d.path.lastIndexOf('/')),
|
|
0 <= n && (d.path = d.path.substring(0, n + 1)));
|
|
g = m(p(d), g);
|
|
}
|
|
return t(g);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
20: [
|
|
function (C, J, A) {
|
|
A.SourceMapGenerator = C(
|
|
'./lib/source-map-generator'
|
|
).SourceMapGenerator;
|
|
A.SourceMapConsumer = C(
|
|
'./lib/source-map-consumer'
|
|
).SourceMapConsumer;
|
|
A.SourceNode = C('./lib/source-node').SourceNode;
|
|
},
|
|
{
|
|
'./lib/source-map-consumer': 16,
|
|
'./lib/source-map-generator': 17,
|
|
'./lib/source-node': 18,
|
|
},
|
|
],
|
|
21: [
|
|
function (C, J, A) {
|
|
(function (e) {
|
|
function p() {
|
|
return (
|
|
'browser' === a ? !0
|
|
: 'node' === a ? !1
|
|
: 'undefined' !== typeof window &&
|
|
'function' === typeof XMLHttpRequest &&
|
|
!(
|
|
window.require &&
|
|
window.module &&
|
|
window.process &&
|
|
'renderer' === window.process.type
|
|
)
|
|
);
|
|
}
|
|
function t(x) {
|
|
return function (B) {
|
|
for (var F = 0; F < x.length; F++) {
|
|
var E = x[F](B);
|
|
if (E) return E;
|
|
}
|
|
return null;
|
|
};
|
|
}
|
|
function m(x, B) {
|
|
if (!x) return B;
|
|
var F = n.dirname(x),
|
|
E = /^\w+:\/\/[^\/]*/.exec(F);
|
|
E = E ? E[0] : '';
|
|
var H = F.slice(E.length);
|
|
return E && /^\/\w:/.test(H) ?
|
|
((E += '/'),
|
|
E + n.resolve(F.slice(E.length), B).replace(/\\/g, '/'))
|
|
: E + n.resolve(F.slice(E.length), B);
|
|
}
|
|
function f(x) {
|
|
var B = h[x.source];
|
|
if (!B) {
|
|
var F = N(x.source);
|
|
F ?
|
|
((B = h[x.source] = { url: F.url, map: new g(F.map) }),
|
|
B.map.sourcesContent &&
|
|
B.map.sources.forEach(function (E, H) {
|
|
var M = B.map.sourcesContent[H];
|
|
if (M) {
|
|
var S = m(B.url, E);
|
|
b[S] = M;
|
|
}
|
|
}))
|
|
: (B = h[x.source] = { url: null, map: null });
|
|
}
|
|
return (
|
|
B &&
|
|
B.map &&
|
|
'function' === typeof B.map.originalPositionFor &&
|
|
((F = B.map.originalPositionFor(x)), null !== F.source)
|
|
) ?
|
|
((F.source = m(B.url, F.source)), F)
|
|
: x;
|
|
}
|
|
function c(x) {
|
|
var B = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(x);
|
|
return (
|
|
B ?
|
|
((x = f({ source: B[2], line: +B[3], column: B[4] - 1 })),
|
|
'eval at ' +
|
|
B[1] +
|
|
' (' +
|
|
x.source +
|
|
':' +
|
|
x.line +
|
|
':' +
|
|
(x.column + 1) +
|
|
')')
|
|
: (B = /^eval at ([^(]+) \((.+)\)$/.exec(x)) ?
|
|
'eval at ' + B[1] + ' (' + c(B[2]) + ')'
|
|
: x
|
|
);
|
|
}
|
|
function l() {
|
|
var x = '';
|
|
if (this.isNative()) x = 'native';
|
|
else {
|
|
var B = this.getScriptNameOrSourceURL();
|
|
!B &&
|
|
this.isEval() &&
|
|
((x = this.getEvalOrigin()), (x += ', '));
|
|
x = B ? x + B : x + '<anonymous>';
|
|
B = this.getLineNumber();
|
|
null != B &&
|
|
((x += ':' + B),
|
|
(B = this.getColumnNumber()) && (x += ':' + B));
|
|
}
|
|
B = '';
|
|
var F = this.getFunctionName(),
|
|
E = !0,
|
|
H = this.isConstructor();
|
|
if (this.isToplevel() || H)
|
|
H ? (B += 'new ' + (F || '<anonymous>'))
|
|
: F ? (B += F)
|
|
: ((B += x), (E = !1));
|
|
else {
|
|
H = this.getTypeName();
|
|
'[object Object]' === H && (H = 'null');
|
|
var M = this.getMethodName();
|
|
F ?
|
|
(H && 0 != F.indexOf(H) && (B += H + '.'),
|
|
(B += F),
|
|
M &&
|
|
F.indexOf('.' + M) != F.length - M.length - 1 &&
|
|
(B += ' [as ' + M + ']'))
|
|
: (B += H + '.' + (M || '<anonymous>'));
|
|
}
|
|
E && (B += ' (' + x + ')');
|
|
return B;
|
|
}
|
|
function q(x) {
|
|
var B = {};
|
|
Object.getOwnPropertyNames(Object.getPrototypeOf(x)).forEach(
|
|
function (F) {
|
|
B[F] =
|
|
/^(?:is|get)/.test(F) ?
|
|
function () {
|
|
return x[F].call(x);
|
|
}
|
|
: x[F];
|
|
}
|
|
);
|
|
B.toString = l;
|
|
return B;
|
|
}
|
|
function r(x, B) {
|
|
void 0 === B && (B = { nextPosition: null, curPosition: null });
|
|
if (x.isNative()) return (B.curPosition = null), x;
|
|
var F = x.getFileName() || x.getScriptNameOrSourceURL();
|
|
if (F) {
|
|
var E = x.getLineNumber(),
|
|
H = x.getColumnNumber() - 1,
|
|
M =
|
|
/^v(10\.1[6-9]|10\.[2-9][0-9]|10\.[0-9]{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/,
|
|
S = M.test;
|
|
var V = 'object' === typeof e && null !== e ? e.version : '';
|
|
M = S.call(M, V) ? 0 : 62;
|
|
1 === E && H > M && !p() && !x.isEval() && (H -= M);
|
|
var O = f({ source: F, line: E, column: H });
|
|
B.curPosition = O;
|
|
x = q(x);
|
|
var T = x.getFunctionName;
|
|
x.getFunctionName = function () {
|
|
return null == B.nextPosition ?
|
|
T()
|
|
: B.nextPosition.name || T();
|
|
};
|
|
x.getFileName = function () {
|
|
return O.source;
|
|
};
|
|
x.getLineNumber = function () {
|
|
return O.line;
|
|
};
|
|
x.getColumnNumber = function () {
|
|
return O.column + 1;
|
|
};
|
|
x.getScriptNameOrSourceURL = function () {
|
|
return O.source;
|
|
};
|
|
return x;
|
|
}
|
|
var Q = x.isEval() && x.getEvalOrigin();
|
|
Q &&
|
|
((Q = c(Q)),
|
|
(x = q(x)),
|
|
(x.getEvalOrigin = function () {
|
|
return Q;
|
|
}));
|
|
return x;
|
|
}
|
|
function k(x, B) {
|
|
L && ((b = {}), (h = {}));
|
|
for (
|
|
var F = (x.name || 'Error') + ': ' + (x.message || ''),
|
|
E = { nextPosition: null, curPosition: null },
|
|
H = [],
|
|
M = B.length - 1;
|
|
0 <= M;
|
|
M--
|
|
)
|
|
H.push('\n at ' + r(B[M], E)),
|
|
(E.nextPosition = E.curPosition);
|
|
E.curPosition = E.nextPosition = null;
|
|
return F + H.reverse().join('');
|
|
}
|
|
function u(x) {
|
|
var B = /\n at [^(]+ \((.*):(\d+):(\d+)\)/.exec(x.stack);
|
|
if (B) {
|
|
x = B[1];
|
|
var F = +B[2];
|
|
B = +B[3];
|
|
var E = b[x];
|
|
if (!E && v && v.existsSync(x))
|
|
try {
|
|
E = v.readFileSync(x, 'utf8');
|
|
} catch (H) {
|
|
E = '';
|
|
}
|
|
if (E && (E = E.split(/(?:\r\n|\r|\n)/)[F - 1]))
|
|
return (
|
|
x + ':' + F + '\n' + E + '\n' + Array(B).join(' ') + '^'
|
|
);
|
|
}
|
|
return null;
|
|
}
|
|
function d() {
|
|
var x = e.emit;
|
|
e.emit = function (B) {
|
|
if ('uncaughtException' === B) {
|
|
var F = arguments[1] && arguments[1].stack,
|
|
E = 0 < this.listeners(B).length;
|
|
if (F && !E) {
|
|
F = arguments[1];
|
|
E = u(F);
|
|
var H =
|
|
'object' === typeof e && null !== e ? e.stderr : void 0;
|
|
H &&
|
|
H._handle &&
|
|
H._handle.setBlocking &&
|
|
H._handle.setBlocking(!0);
|
|
E && (console.error(), console.error(E));
|
|
console.error(F.stack);
|
|
'object' === typeof e &&
|
|
null !== e &&
|
|
'function' === typeof e.exit &&
|
|
e.exit(1);
|
|
return;
|
|
}
|
|
}
|
|
return x.apply(this, arguments);
|
|
};
|
|
}
|
|
var g = C('source-map').SourceMapConsumer,
|
|
n = C('path');
|
|
try {
|
|
var v = C('fs');
|
|
(v.existsSync && v.readFileSync) || (v = null);
|
|
} catch (x) {}
|
|
var z = C('buffer-from'),
|
|
G = !1,
|
|
D = !1,
|
|
L = !1,
|
|
a = 'auto',
|
|
b = {},
|
|
h = {},
|
|
w = /^data:application\/json[^,]+base64,/,
|
|
y = [],
|
|
I = [],
|
|
K = t(y);
|
|
y.push(function (x) {
|
|
x = x.trim();
|
|
/^file:/.test(x) &&
|
|
(x = x.replace(/file:\/\/\/(\w:)?/, function (E, H) {
|
|
return H ? '' : '/';
|
|
}));
|
|
if (x in b) return b[x];
|
|
var B = '';
|
|
try {
|
|
if (v) v.existsSync(x) && (B = v.readFileSync(x, 'utf8'));
|
|
else {
|
|
var F = new XMLHttpRequest();
|
|
F.open('GET', x, !1);
|
|
F.send(null);
|
|
4 === F.readyState &&
|
|
200 === F.status &&
|
|
(B = F.responseText);
|
|
}
|
|
} catch (E) {}
|
|
return (b[x] = B);
|
|
});
|
|
var N = t(I);
|
|
I.push(function (x) {
|
|
a: {
|
|
if (p())
|
|
try {
|
|
var B = new XMLHttpRequest();
|
|
B.open('GET', x, !1);
|
|
B.send(null);
|
|
var F =
|
|
B.getResponseHeader('SourceMap') ||
|
|
B.getResponseHeader('X-SourceMap');
|
|
if (F) {
|
|
var E = F;
|
|
break a;
|
|
}
|
|
} catch (M) {}
|
|
E = K(x);
|
|
B =
|
|
/(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/gm;
|
|
for (var H; (F = B.exec(E)); ) H = F;
|
|
E = H ? H[1] : null;
|
|
}
|
|
if (!E) return null;
|
|
w.test(E) ?
|
|
((H = E.slice(E.indexOf(',') + 1)),
|
|
(H = z(H, 'base64').toString()),
|
|
(E = x))
|
|
: ((E = m(x, E)), (H = K(E)));
|
|
return H ? { url: E, map: H } : null;
|
|
});
|
|
var P = y.slice(0),
|
|
W = I.slice(0);
|
|
A.wrapCallSite = r;
|
|
A.getErrorSource = u;
|
|
A.mapSourcePosition = f;
|
|
A.retrieveSourceMap = N;
|
|
A.install = function (x) {
|
|
x = x || {};
|
|
if (
|
|
x.environment &&
|
|
((a = x.environment),
|
|
-1 === ['node', 'browser', 'auto'].indexOf(a))
|
|
)
|
|
throw Error(
|
|
'environment ' +
|
|
a +
|
|
' was unknown. Available options are {auto, browser, node}'
|
|
);
|
|
x.retrieveFile &&
|
|
(x.overrideRetrieveFile && (y.length = 0),
|
|
y.unshift(x.retrieveFile));
|
|
x.retrieveSourceMap &&
|
|
(x.overrideRetrieveSourceMap && (I.length = 0),
|
|
I.unshift(x.retrieveSourceMap));
|
|
if (x.hookRequire && !p()) {
|
|
var B = J.require('module'),
|
|
F = B.prototype._compile;
|
|
F.__sourceMapSupport ||
|
|
((B.prototype._compile = function (E, H) {
|
|
b[H] = E;
|
|
h[H] = void 0;
|
|
return F.call(this, E, H);
|
|
}),
|
|
(B.prototype._compile.__sourceMapSupport = !0));
|
|
}
|
|
L ||
|
|
(L =
|
|
'emptyCacheBetweenOperations' in x ?
|
|
x.emptyCacheBetweenOperations
|
|
: !1);
|
|
G || ((G = !0), (Error.prepareStackTrace = k));
|
|
if (!D) {
|
|
x =
|
|
'handleUncaughtExceptions' in x ?
|
|
x.handleUncaughtExceptions
|
|
: !0;
|
|
try {
|
|
!1 === J.require('worker_threads').isMainThread && (x = !1);
|
|
} catch (E) {}
|
|
x &&
|
|
'object' === typeof e &&
|
|
null !== e &&
|
|
'function' === typeof e.on &&
|
|
((D = !0), d());
|
|
}
|
|
};
|
|
A.resetRetrieveHandlers = function () {
|
|
y.length = 0;
|
|
I.length = 0;
|
|
y = P.slice(0);
|
|
I = W.slice(0);
|
|
N = t(I);
|
|
K = t(y);
|
|
};
|
|
}).call(this, C('g5I+bs'));
|
|
},
|
|
{ 'buffer-from': 4, fs: 3, 'g5I+bs': 9, path: 8, 'source-map': 20 },
|
|
],
|
|
},
|
|
{},
|
|
[1]
|
|
);
|
|
return R;
|
|
});
|