-
-
Save lucacasonato/358c6b7e8198bfb2cf3d220e49fdcf5f to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
var global$1 = typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}; | |
var lookup = []; | |
var revLookup = []; | |
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array; | |
var inited = false; | |
function init() { | |
inited = true; | |
var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; | |
for (var i = 0, len = code.length; i < len; ++i) { | |
lookup[i] = code[i]; | |
revLookup[code.charCodeAt(i)] = i; | |
} | |
revLookup["-".charCodeAt(0)] = 62; | |
revLookup["_".charCodeAt(0)] = 63; | |
} | |
function toByteArray(b64) { | |
if (!inited) { | |
init(); | |
} | |
var i, j, l, tmp, placeHolders, arr; | |
var len = b64.length; | |
if (len % 4 > 0) { | |
throw new Error("Invalid string. Length must be a multiple of 4"); | |
} | |
placeHolders = b64[len - 2] === "=" ? 2 : b64[len - 1] === "=" ? 1 : 0; | |
arr = new Arr(len * 3 / 4 - placeHolders); | |
l = placeHolders > 0 ? len - 4 : len; | |
var L = 0; | |
for (i = 0, j = 0; i < l; i += 4, j += 3) { | |
tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)]; | |
arr[L++] = tmp >> 16 & 255; | |
arr[L++] = tmp >> 8 & 255; | |
arr[L++] = tmp & 255; | |
} | |
if (placeHolders === 2) { | |
tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4; | |
arr[L++] = tmp & 255; | |
} else if (placeHolders === 1) { | |
tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2; | |
arr[L++] = tmp >> 8 & 255; | |
arr[L++] = tmp & 255; | |
} | |
return arr; | |
} | |
function tripletToBase64(num) { | |
return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63]; | |
} | |
function encodeChunk(uint8, start, end) { | |
var tmp; | |
var output = []; | |
for (var i = start; i < end; i += 3) { | |
tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2]; | |
output.push(tripletToBase64(tmp)); | |
} | |
return output.join(""); | |
} | |
function fromByteArray(uint8) { | |
if (!inited) { | |
init(); | |
} | |
var tmp; | |
var len = uint8.length; | |
var extraBytes = len % 3; | |
var output = ""; | |
var parts = []; | |
var maxChunkLength = 16383; | |
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { | |
parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength)); | |
} | |
if (extraBytes === 1) { | |
tmp = uint8[len - 1]; | |
output += lookup[tmp >> 2]; | |
output += lookup[tmp << 4 & 63]; | |
output += "=="; | |
} else if (extraBytes === 2) { | |
tmp = (uint8[len - 2] << 8) + uint8[len - 1]; | |
output += lookup[tmp >> 10]; | |
output += lookup[tmp >> 4 & 63]; | |
output += lookup[tmp << 2 & 63]; | |
output += "="; | |
} | |
parts.push(output); | |
return parts.join(""); | |
} | |
function read(buffer, offset, isLE, mLen, nBytes) { | |
var e, m; | |
var eLen = nBytes * 8 - mLen - 1; | |
var eMax = (1 << eLen) - 1; | |
var eBias = eMax >> 1; | |
var nBits = -7; | |
var i = isLE ? nBytes - 1 : 0; | |
var d = isLE ? -1 : 1; | |
var s = buffer[offset + i]; | |
i += d; | |
e = s & (1 << -nBits) - 1; | |
s >>= -nBits; | |
nBits += eLen; | |
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) { | |
} | |
m = e & (1 << -nBits) - 1; | |
e >>= -nBits; | |
nBits += mLen; | |
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) { | |
} | |
if (e === 0) { | |
e = 1 - eBias; | |
} else if (e === eMax) { | |
return m ? NaN : (s ? -1 : 1) * Infinity; | |
} else { | |
m = m + Math.pow(2, mLen); | |
e = e - eBias; | |
} | |
return (s ? -1 : 1) * m * Math.pow(2, e - mLen); | |
} | |
function write(buffer, value, offset, isLE, mLen, nBytes) { | |
var e, m, c; | |
var eLen = nBytes * 8 - mLen - 1; | |
var eMax = (1 << eLen) - 1; | |
var eBias = eMax >> 1; | |
var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0; | |
var i = isLE ? 0 : nBytes - 1; | |
var d = isLE ? 1 : -1; | |
var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0; | |
value = Math.abs(value); | |
if (isNaN(value) || value === Infinity) { | |
m = isNaN(value) ? 1 : 0; | |
e = eMax; | |
} else { | |
e = Math.floor(Math.log(value) / Math.LN2); | |
if (value * (c = Math.pow(2, -e)) < 1) { | |
e--; | |
c *= 2; | |
} | |
if (e + eBias >= 1) { | |
value += rt / c; | |
} else { | |
value += rt * Math.pow(2, 1 - eBias); | |
} | |
if (value * c >= 2) { | |
e++; | |
c /= 2; | |
} | |
if (e + eBias >= eMax) { | |
m = 0; | |
e = eMax; | |
} else if (e + eBias >= 1) { | |
m = (value * c - 1) * Math.pow(2, mLen); | |
e = e + eBias; | |
} else { | |
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); | |
e = 0; | |
} | |
} | |
for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) { | |
} | |
e = e << mLen | m; | |
eLen += mLen; | |
for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) { | |
} | |
buffer[offset + i - d] |= s * 128; | |
} | |
var toString = {}.toString; | |
var isArray = Array.isArray || function(arr) { | |
return toString.call(arr) == "[object Array]"; | |
}; | |
/*! | |
* The buffer module from node.js, for the browser. | |
* | |
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org> | |
* @license MIT | |
*/ | |
var INSPECT_MAX_BYTES = 50; | |
Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== void 0 ? global$1.TYPED_ARRAY_SUPPORT : true; | |
function kMaxLength() { | |
return Buffer.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823; | |
} | |
function createBuffer(that, length) { | |
if (kMaxLength() < length) { | |
throw new RangeError("Invalid typed array length"); | |
} | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
that = new Uint8Array(length); | |
that.__proto__ = Buffer.prototype; | |
} else { | |
if (that === null) { | |
that = new Buffer(length); | |
} | |
that.length = length; | |
} | |
return that; | |
} | |
function Buffer(arg, encodingOrOffset, length) { | |
if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { | |
return new Buffer(arg, encodingOrOffset, length); | |
} | |
if (typeof arg === "number") { | |
if (typeof encodingOrOffset === "string") { | |
throw new Error("If encoding is specified then the first argument must be a string"); | |
} | |
return allocUnsafe(this, arg); | |
} | |
return from(this, arg, encodingOrOffset, length); | |
} | |
Buffer.poolSize = 8192; | |
Buffer._augment = function(arr) { | |
arr.__proto__ = Buffer.prototype; | |
return arr; | |
}; | |
function from(that, value, encodingOrOffset, length) { | |
if (typeof value === "number") { | |
throw new TypeError('"value" argument must not be a number'); | |
} | |
if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) { | |
return fromArrayBuffer(that, value, encodingOrOffset, length); | |
} | |
if (typeof value === "string") { | |
return fromString(that, value, encodingOrOffset); | |
} | |
return fromObject(that, value); | |
} | |
Buffer.from = function(value, encodingOrOffset, length) { | |
return from(null, value, encodingOrOffset, length); | |
}; | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
Buffer.prototype.__proto__ = Uint8Array.prototype; | |
Buffer.__proto__ = Uint8Array; | |
} | |
function assertSize(size) { | |
if (typeof size !== "number") { | |
throw new TypeError('"size" argument must be a number'); | |
} else if (size < 0) { | |
throw new RangeError('"size" argument must not be negative'); | |
} | |
} | |
function alloc(that, size, fill2, encoding) { | |
assertSize(size); | |
if (size <= 0) { | |
return createBuffer(that, size); | |
} | |
if (fill2 !== void 0) { | |
return typeof encoding === "string" ? createBuffer(that, size).fill(fill2, encoding) : createBuffer(that, size).fill(fill2); | |
} | |
return createBuffer(that, size); | |
} | |
Buffer.alloc = function(size, fill2, encoding) { | |
return alloc(null, size, fill2, encoding); | |
}; | |
function allocUnsafe(that, size) { | |
assertSize(size); | |
that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); | |
if (!Buffer.TYPED_ARRAY_SUPPORT) { | |
for (var i = 0; i < size; ++i) { | |
that[i] = 0; | |
} | |
} | |
return that; | |
} | |
Buffer.allocUnsafe = function(size) { | |
return allocUnsafe(null, size); | |
}; | |
Buffer.allocUnsafeSlow = function(size) { | |
return allocUnsafe(null, size); | |
}; | |
function fromString(that, string, encoding) { | |
if (typeof encoding !== "string" || encoding === "") { | |
encoding = "utf8"; | |
} | |
if (!Buffer.isEncoding(encoding)) { | |
throw new TypeError('"encoding" must be a valid string encoding'); | |
} | |
var length = byteLength(string, encoding) | 0; | |
that = createBuffer(that, length); | |
var actual = that.write(string, encoding); | |
if (actual !== length) { | |
that = that.slice(0, actual); | |
} | |
return that; | |
} | |
function fromArrayLike(that, array) { | |
var length = array.length < 0 ? 0 : checked(array.length) | 0; | |
that = createBuffer(that, length); | |
for (var i = 0; i < length; i += 1) { | |
that[i] = array[i] & 255; | |
} | |
return that; | |
} | |
function fromArrayBuffer(that, array, byteOffset, length) { | |
array.byteLength; | |
if (byteOffset < 0 || array.byteLength < byteOffset) { | |
throw new RangeError("'offset' is out of bounds"); | |
} | |
if (array.byteLength < byteOffset + (length || 0)) { | |
throw new RangeError("'length' is out of bounds"); | |
} | |
if (byteOffset === void 0 && length === void 0) { | |
array = new Uint8Array(array); | |
} else if (length === void 0) { | |
array = new Uint8Array(array, byteOffset); | |
} else { | |
array = new Uint8Array(array, byteOffset, length); | |
} | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
that = array; | |
that.__proto__ = Buffer.prototype; | |
} else { | |
that = fromArrayLike(that, array); | |
} | |
return that; | |
} | |
function fromObject(that, obj) { | |
if (internalIsBuffer(obj)) { | |
var len = checked(obj.length) | 0; | |
that = createBuffer(that, len); | |
if (that.length === 0) { | |
return that; | |
} | |
obj.copy(that, 0, 0, len); | |
return that; | |
} | |
if (obj) { | |
if (typeof ArrayBuffer !== "undefined" && obj.buffer instanceof ArrayBuffer || "length" in obj) { | |
if (typeof obj.length !== "number" || isnan(obj.length)) { | |
return createBuffer(that, 0); | |
} | |
return fromArrayLike(that, obj); | |
} | |
if (obj.type === "Buffer" && isArray(obj.data)) { | |
return fromArrayLike(that, obj.data); | |
} | |
} | |
throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object."); | |
} | |
function checked(length) { | |
if (length >= kMaxLength()) { | |
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + kMaxLength().toString(16) + " bytes"); | |
} | |
return length | 0; | |
} | |
Buffer.isBuffer = isBuffer; | |
function internalIsBuffer(b) { | |
return !!(b != null && b._isBuffer); | |
} | |
Buffer.compare = function compare(a, b) { | |
if (!internalIsBuffer(a) || !internalIsBuffer(b)) { | |
throw new TypeError("Arguments must be Buffers"); | |
} | |
if (a === b) | |
return 0; | |
var x = a.length; | |
var y = b.length; | |
for (var i = 0, len = Math.min(x, y); i < len; ++i) { | |
if (a[i] !== b[i]) { | |
x = a[i]; | |
y = b[i]; | |
break; | |
} | |
} | |
if (x < y) | |
return -1; | |
if (y < x) | |
return 1; | |
return 0; | |
}; | |
Buffer.isEncoding = function isEncoding(encoding) { | |
switch (String(encoding).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 true; | |
default: | |
return false; | |
} | |
}; | |
Buffer.concat = function concat(list, length) { | |
if (!isArray(list)) { | |
throw new TypeError('"list" argument must be an Array of Buffers'); | |
} | |
if (list.length === 0) { | |
return Buffer.alloc(0); | |
} | |
var i; | |
if (length === void 0) { | |
length = 0; | |
for (i = 0; i < list.length; ++i) { | |
length += list[i].length; | |
} | |
} | |
var buffer = Buffer.allocUnsafe(length); | |
var pos = 0; | |
for (i = 0; i < list.length; ++i) { | |
var buf = list[i]; | |
if (!internalIsBuffer(buf)) { | |
throw new TypeError('"list" argument must be an Array of Buffers'); | |
} | |
buf.copy(buffer, pos); | |
pos += buf.length; | |
} | |
return buffer; | |
}; | |
function byteLength(string, encoding) { | |
if (internalIsBuffer(string)) { | |
return string.length; | |
} | |
if (typeof ArrayBuffer !== "undefined" && typeof ArrayBuffer.isView === "function" && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { | |
return string.byteLength; | |
} | |
if (typeof string !== "string") { | |
string = "" + string; | |
} | |
var len = string.length; | |
if (len === 0) | |
return 0; | |
var loweredCase = false; | |
for (; ; ) { | |
switch (encoding) { | |
case "ascii": | |
case "latin1": | |
case "binary": | |
return len; | |
case "utf8": | |
case "utf-8": | |
case void 0: | |
return utf8ToBytes(string).length; | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return len * 2; | |
case "hex": | |
return len >>> 1; | |
case "base64": | |
return base64ToBytes(string).length; | |
default: | |
if (loweredCase) | |
return utf8ToBytes(string).length; | |
encoding = ("" + encoding).toLowerCase(); | |
loweredCase = true; | |
} | |
} | |
} | |
Buffer.byteLength = byteLength; | |
function slowToString(encoding, start, end) { | |
var loweredCase = false; | |
if (start === void 0 || start < 0) { | |
start = 0; | |
} | |
if (start > this.length) { | |
return ""; | |
} | |
if (end === void 0 || end > this.length) { | |
end = this.length; | |
} | |
if (end <= 0) { | |
return ""; | |
} | |
end >>>= 0; | |
start >>>= 0; | |
if (end <= start) { | |
return ""; | |
} | |
if (!encoding) | |
encoding = "utf8"; | |
while (true) { | |
switch (encoding) { | |
case "hex": | |
return hexSlice(this, start, end); | |
case "utf8": | |
case "utf-8": | |
return utf8Slice(this, start, end); | |
case "ascii": | |
return asciiSlice(this, start, end); | |
case "latin1": | |
case "binary": | |
return latin1Slice(this, start, end); | |
case "base64": | |
return base64Slice(this, start, end); | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return utf16leSlice(this, start, end); | |
default: | |
if (loweredCase) | |
throw new TypeError("Unknown encoding: " + encoding); | |
encoding = (encoding + "").toLowerCase(); | |
loweredCase = true; | |
} | |
} | |
} | |
Buffer.prototype._isBuffer = true; | |
function swap(b, n, m) { | |
var i = b[n]; | |
b[n] = b[m]; | |
b[m] = i; | |
} | |
Buffer.prototype.swap16 = function swap16() { | |
var len = this.length; | |
if (len % 2 !== 0) { | |
throw new RangeError("Buffer size must be a multiple of 16-bits"); | |
} | |
for (var i = 0; i < len; i += 2) { | |
swap(this, i, i + 1); | |
} | |
return this; | |
}; | |
Buffer.prototype.swap32 = function swap32() { | |
var len = this.length; | |
if (len % 4 !== 0) { | |
throw new RangeError("Buffer size must be a multiple of 32-bits"); | |
} | |
for (var i = 0; i < len; i += 4) { | |
swap(this, i, i + 3); | |
swap(this, i + 1, i + 2); | |
} | |
return this; | |
}; | |
Buffer.prototype.swap64 = function swap64() { | |
var len = this.length; | |
if (len % 8 !== 0) { | |
throw new RangeError("Buffer size must be a multiple of 64-bits"); | |
} | |
for (var i = 0; i < len; i += 8) { | |
swap(this, i, i + 7); | |
swap(this, i + 1, i + 6); | |
swap(this, i + 2, i + 5); | |
swap(this, i + 3, i + 4); | |
} | |
return this; | |
}; | |
Buffer.prototype.toString = function toString2() { | |
var length = this.length | 0; | |
if (length === 0) | |
return ""; | |
if (arguments.length === 0) | |
return utf8Slice(this, 0, length); | |
return slowToString.apply(this, arguments); | |
}; | |
Buffer.prototype.equals = function equals(b) { | |
if (!internalIsBuffer(b)) | |
throw new TypeError("Argument must be a Buffer"); | |
if (this === b) | |
return true; | |
return Buffer.compare(this, b) === 0; | |
}; | |
Buffer.prototype.inspect = function inspect() { | |
var str = ""; | |
var max = INSPECT_MAX_BYTES; | |
if (this.length > 0) { | |
str = this.toString("hex", 0, max).match(/.{2}/g).join(" "); | |
if (this.length > max) | |
str += " ... "; | |
} | |
return "<Buffer " + str + ">"; | |
}; | |
Buffer.prototype.compare = function compare2(target, start, end, thisStart, thisEnd) { | |
if (!internalIsBuffer(target)) { | |
throw new TypeError("Argument must be a Buffer"); | |
} | |
if (start === void 0) { | |
start = 0; | |
} | |
if (end === void 0) { | |
end = target ? target.length : 0; | |
} | |
if (thisStart === void 0) { | |
thisStart = 0; | |
} | |
if (thisEnd === void 0) { | |
thisEnd = this.length; | |
} | |
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { | |
throw new RangeError("out of range index"); | |
} | |
if (thisStart >= thisEnd && start >= end) { | |
return 0; | |
} | |
if (thisStart >= thisEnd) { | |
return -1; | |
} | |
if (start >= end) { | |
return 1; | |
} | |
start >>>= 0; | |
end >>>= 0; | |
thisStart >>>= 0; | |
thisEnd >>>= 0; | |
if (this === target) | |
return 0; | |
var x = thisEnd - thisStart; | |
var y = end - start; | |
var len = Math.min(x, y); | |
var thisCopy = this.slice(thisStart, thisEnd); | |
var targetCopy = target.slice(start, end); | |
for (var i = 0; i < len; ++i) { | |
if (thisCopy[i] !== targetCopy[i]) { | |
x = thisCopy[i]; | |
y = targetCopy[i]; | |
break; | |
} | |
} | |
if (x < y) | |
return -1; | |
if (y < x) | |
return 1; | |
return 0; | |
}; | |
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) { | |
if (buffer.length === 0) | |
return -1; | |
if (typeof byteOffset === "string") { | |
encoding = byteOffset; | |
byteOffset = 0; | |
} else if (byteOffset > 2147483647) { | |
byteOffset = 2147483647; | |
} else if (byteOffset < -2147483648) { | |
byteOffset = -2147483648; | |
} | |
byteOffset = +byteOffset; | |
if (isNaN(byteOffset)) { | |
byteOffset = dir ? 0 : buffer.length - 1; | |
} | |
if (byteOffset < 0) | |
byteOffset = buffer.length + byteOffset; | |
if (byteOffset >= buffer.length) { | |
if (dir) | |
return -1; | |
else | |
byteOffset = buffer.length - 1; | |
} else if (byteOffset < 0) { | |
if (dir) | |
byteOffset = 0; | |
else | |
return -1; | |
} | |
if (typeof val === "string") { | |
val = Buffer.from(val, encoding); | |
} | |
if (internalIsBuffer(val)) { | |
if (val.length === 0) { | |
return -1; | |
} | |
return arrayIndexOf(buffer, val, byteOffset, encoding, dir); | |
} else if (typeof val === "number") { | |
val = val & 255; | |
if (Buffer.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === "function") { | |
if (dir) { | |
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset); | |
} else { | |
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset); | |
} | |
} | |
return arrayIndexOf(buffer, [val], byteOffset, encoding, dir); | |
} | |
throw new TypeError("val must be string, number or Buffer"); | |
} | |
function arrayIndexOf(arr, val, byteOffset, encoding, dir) { | |
var indexSize = 1; | |
var arrLength = arr.length; | |
var valLength = val.length; | |
if (encoding !== void 0) { | |
encoding = String(encoding).toLowerCase(); | |
if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") { | |
if (arr.length < 2 || val.length < 2) { | |
return -1; | |
} | |
indexSize = 2; | |
arrLength /= 2; | |
valLength /= 2; | |
byteOffset /= 2; | |
} | |
} | |
function read2(buf, i2) { | |
if (indexSize === 1) { | |
return buf[i2]; | |
} else { | |
return buf.readUInt16BE(i2 * indexSize); | |
} | |
} | |
var i; | |
if (dir) { | |
var foundIndex = -1; | |
for (i = byteOffset; i < arrLength; i++) { | |
if (read2(arr, i) === read2(val, foundIndex === -1 ? 0 : i - foundIndex)) { | |
if (foundIndex === -1) | |
foundIndex = i; | |
if (i - foundIndex + 1 === valLength) | |
return foundIndex * indexSize; | |
} else { | |
if (foundIndex !== -1) | |
i -= i - foundIndex; | |
foundIndex = -1; | |
} | |
} | |
} else { | |
if (byteOffset + valLength > arrLength) | |
byteOffset = arrLength - valLength; | |
for (i = byteOffset; i >= 0; i--) { | |
var found = true; | |
for (var j = 0; j < valLength; j++) { | |
if (read2(arr, i + j) !== read2(val, j)) { | |
found = false; | |
break; | |
} | |
} | |
if (found) | |
return i; | |
} | |
} | |
return -1; | |
} | |
Buffer.prototype.includes = function includes(val, byteOffset, encoding) { | |
return this.indexOf(val, byteOffset, encoding) !== -1; | |
}; | |
Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) { | |
return bidirectionalIndexOf(this, val, byteOffset, encoding, true); | |
}; | |
Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) { | |
return bidirectionalIndexOf(this, val, byteOffset, encoding, false); | |
}; | |
function hexWrite(buf, string, offset, length) { | |
offset = Number(offset) || 0; | |
var remaining = buf.length - offset; | |
if (!length) { | |
length = remaining; | |
} else { | |
length = Number(length); | |
if (length > remaining) { | |
length = remaining; | |
} | |
} | |
var strLen = string.length; | |
if (strLen % 2 !== 0) | |
throw new TypeError("Invalid hex string"); | |
if (length > strLen / 2) { | |
length = strLen / 2; | |
} | |
for (var i = 0; i < length; ++i) { | |
var parsed = parseInt(string.substr(i * 2, 2), 16); | |
if (isNaN(parsed)) | |
return i; | |
buf[offset + i] = parsed; | |
} | |
return i; | |
} | |
function utf8Write(buf, string, offset, length) { | |
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length); | |
} | |
function asciiWrite(buf, string, offset, length) { | |
return blitBuffer(asciiToBytes(string), buf, offset, length); | |
} | |
function latin1Write(buf, string, offset, length) { | |
return asciiWrite(buf, string, offset, length); | |
} | |
function base64Write(buf, string, offset, length) { | |
return blitBuffer(base64ToBytes(string), buf, offset, length); | |
} | |
function ucs2Write(buf, string, offset, length) { | |
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length); | |
} | |
Buffer.prototype.write = function write2(string, offset, length, encoding) { | |
if (offset === void 0) { | |
encoding = "utf8"; | |
length = this.length; | |
offset = 0; | |
} else if (length === void 0 && typeof offset === "string") { | |
encoding = offset; | |
length = this.length; | |
offset = 0; | |
} else if (isFinite(offset)) { | |
offset = offset | 0; | |
if (isFinite(length)) { | |
length = length | 0; | |
if (encoding === void 0) | |
encoding = "utf8"; | |
} else { | |
encoding = length; | |
length = void 0; | |
} | |
} else { | |
throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported"); | |
} | |
var remaining = this.length - offset; | |
if (length === void 0 || length > remaining) | |
length = remaining; | |
if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) { | |
throw new RangeError("Attempt to write outside buffer bounds"); | |
} | |
if (!encoding) | |
encoding = "utf8"; | |
var loweredCase = false; | |
for (; ; ) { | |
switch (encoding) { | |
case "hex": | |
return hexWrite(this, string, offset, length); | |
case "utf8": | |
case "utf-8": | |
return utf8Write(this, string, offset, length); | |
case "ascii": | |
return asciiWrite(this, string, offset, length); | |
case "latin1": | |
case "binary": | |
return latin1Write(this, string, offset, length); | |
case "base64": | |
return base64Write(this, string, offset, length); | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return ucs2Write(this, string, offset, length); | |
default: | |
if (loweredCase) | |
throw new TypeError("Unknown encoding: " + encoding); | |
encoding = ("" + encoding).toLowerCase(); | |
loweredCase = true; | |
} | |
} | |
}; | |
Buffer.prototype.toJSON = function toJSON() { | |
return { | |
type: "Buffer", | |
data: Array.prototype.slice.call(this._arr || this, 0) | |
}; | |
}; | |
function base64Slice(buf, start, end) { | |
if (start === 0 && end === buf.length) { | |
return fromByteArray(buf); | |
} else { | |
return fromByteArray(buf.slice(start, end)); | |
} | |
} | |
function utf8Slice(buf, start, end) { | |
end = Math.min(buf.length, end); | |
var res = []; | |
var i = start; | |
while (i < end) { | |
var firstByte = buf[i]; | |
var codePoint = null; | |
var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1; | |
if (i + bytesPerSequence <= end) { | |
var secondByte, thirdByte, fourthByte, tempCodePoint; | |
switch (bytesPerSequence) { | |
case 1: | |
if (firstByte < 128) { | |
codePoint = firstByte; | |
} | |
break; | |
case 2: | |
secondByte = buf[i + 1]; | |
if ((secondByte & 192) === 128) { | |
tempCodePoint = (firstByte & 31) << 6 | secondByte & 63; | |
if (tempCodePoint > 127) { | |
codePoint = tempCodePoint; | |
} | |
} | |
break; | |
case 3: | |
secondByte = buf[i + 1]; | |
thirdByte = buf[i + 2]; | |
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) { | |
tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63; | |
if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) { | |
codePoint = tempCodePoint; | |
} | |
} | |
break; | |
case 4: | |
secondByte = buf[i + 1]; | |
thirdByte = buf[i + 2]; | |
fourthByte = buf[i + 3]; | |
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) { | |
tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63; | |
if (tempCodePoint > 65535 && tempCodePoint < 1114112) { | |
codePoint = tempCodePoint; | |
} | |
} | |
} | |
} | |
if (codePoint === null) { | |
codePoint = 65533; | |
bytesPerSequence = 1; | |
} else if (codePoint > 65535) { | |
codePoint -= 65536; | |
res.push(codePoint >>> 10 & 1023 | 55296); | |
codePoint = 56320 | codePoint & 1023; | |
} | |
res.push(codePoint); | |
i += bytesPerSequence; | |
} | |
return decodeCodePointsArray(res); | |
} | |
var MAX_ARGUMENTS_LENGTH = 4096; | |
function decodeCodePointsArray(codePoints) { | |
var len = codePoints.length; | |
if (len <= MAX_ARGUMENTS_LENGTH) { | |
return String.fromCharCode.apply(String, codePoints); | |
} | |
var res = ""; | |
var i = 0; | |
while (i < len) { | |
res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)); | |
} | |
return res; | |
} | |
function asciiSlice(buf, start, end) { | |
var ret = ""; | |
end = Math.min(buf.length, end); | |
for (var i = start; i < end; ++i) { | |
ret += String.fromCharCode(buf[i] & 127); | |
} | |
return ret; | |
} | |
function latin1Slice(buf, start, end) { | |
var ret = ""; | |
end = Math.min(buf.length, end); | |
for (var i = start; i < end; ++i) { | |
ret += String.fromCharCode(buf[i]); | |
} | |
return ret; | |
} | |
function hexSlice(buf, start, end) { | |
var len = buf.length; | |
if (!start || start < 0) | |
start = 0; | |
if (!end || end < 0 || end > len) | |
end = len; | |
var out = ""; | |
for (var i = start; i < end; ++i) { | |
out += toHex(buf[i]); | |
} | |
return out; | |
} | |
function utf16leSlice(buf, start, end) { | |
var bytes = buf.slice(start, end); | |
var res = ""; | |
for (var i = 0; i < bytes.length; i += 2) { | |
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); | |
} | |
return res; | |
} | |
Buffer.prototype.slice = function slice(start, end) { | |
var len = this.length; | |
start = ~~start; | |
end = end === void 0 ? len : ~~end; | |
if (start < 0) { | |
start += len; | |
if (start < 0) | |
start = 0; | |
} else if (start > len) { | |
start = len; | |
} | |
if (end < 0) { | |
end += len; | |
if (end < 0) | |
end = 0; | |
} else if (end > len) { | |
end = len; | |
} | |
if (end < start) | |
end = start; | |
var newBuf; | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
newBuf = this.subarray(start, end); | |
newBuf.__proto__ = Buffer.prototype; | |
} else { | |
var sliceLen = end - start; | |
newBuf = new Buffer(sliceLen, void 0); | |
for (var i = 0; i < sliceLen; ++i) { | |
newBuf[i] = this[i + start]; | |
} | |
} | |
return newBuf; | |
}; | |
function checkOffset(offset, ext, length) { | |
if (offset % 1 !== 0 || offset < 0) | |
throw new RangeError("offset is not uint"); | |
if (offset + ext > length) | |
throw new RangeError("Trying to access beyond buffer length"); | |
} | |
Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) { | |
offset = offset | 0; | |
byteLength2 = byteLength2 | 0; | |
if (!noAssert) | |
checkOffset(offset, byteLength2, this.length); | |
var val = this[offset]; | |
var mul = 1; | |
var i = 0; | |
while (++i < byteLength2 && (mul *= 256)) { | |
val += this[offset + i] * mul; | |
} | |
return val; | |
}; | |
Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) { | |
offset = offset | 0; | |
byteLength2 = byteLength2 | 0; | |
if (!noAssert) { | |
checkOffset(offset, byteLength2, this.length); | |
} | |
var val = this[offset + --byteLength2]; | |
var mul = 1; | |
while (byteLength2 > 0 && (mul *= 256)) { | |
val += this[offset + --byteLength2] * mul; | |
} | |
return val; | |
}; | |
Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 1, this.length); | |
return this[offset]; | |
}; | |
Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 2, this.length); | |
return this[offset] | this[offset + 1] << 8; | |
}; | |
Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 2, this.length); | |
return this[offset] << 8 | this[offset + 1]; | |
}; | |
Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 4, this.length); | |
return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216; | |
}; | |
Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 4, this.length); | |
return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]); | |
}; | |
Buffer.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) { | |
offset = offset | 0; | |
byteLength2 = byteLength2 | 0; | |
if (!noAssert) | |
checkOffset(offset, byteLength2, this.length); | |
var val = this[offset]; | |
var mul = 1; | |
var i = 0; | |
while (++i < byteLength2 && (mul *= 256)) { | |
val += this[offset + i] * mul; | |
} | |
mul *= 128; | |
if (val >= mul) | |
val -= Math.pow(2, 8 * byteLength2); | |
return val; | |
}; | |
Buffer.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) { | |
offset = offset | 0; | |
byteLength2 = byteLength2 | 0; | |
if (!noAssert) | |
checkOffset(offset, byteLength2, this.length); | |
var i = byteLength2; | |
var mul = 1; | |
var val = this[offset + --i]; | |
while (i > 0 && (mul *= 256)) { | |
val += this[offset + --i] * mul; | |
} | |
mul *= 128; | |
if (val >= mul) | |
val -= Math.pow(2, 8 * byteLength2); | |
return val; | |
}; | |
Buffer.prototype.readInt8 = function readInt8(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 1, this.length); | |
if (!(this[offset] & 128)) | |
return this[offset]; | |
return (255 - this[offset] + 1) * -1; | |
}; | |
Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 2, this.length); | |
var val = this[offset] | this[offset + 1] << 8; | |
return val & 32768 ? val | 4294901760 : val; | |
}; | |
Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 2, this.length); | |
var val = this[offset + 1] | this[offset] << 8; | |
return val & 32768 ? val | 4294901760 : val; | |
}; | |
Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 4, this.length); | |
return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24; | |
}; | |
Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 4, this.length); | |
return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]; | |
}; | |
Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 4, this.length); | |
return read(this, offset, true, 23, 4); | |
}; | |
Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 4, this.length); | |
return read(this, offset, false, 23, 4); | |
}; | |
Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 8, this.length); | |
return read(this, offset, true, 52, 8); | |
}; | |
Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) { | |
if (!noAssert) | |
checkOffset(offset, 8, this.length); | |
return read(this, offset, false, 52, 8); | |
}; | |
function checkInt(buf, value, offset, ext, max, min) { | |
if (!internalIsBuffer(buf)) | |
throw new TypeError('"buffer" argument must be a Buffer instance'); | |
if (value > max || value < min) | |
throw new RangeError('"value" argument is out of bounds'); | |
if (offset + ext > buf.length) | |
throw new RangeError("Index out of range"); | |
} | |
Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
byteLength2 = byteLength2 | 0; | |
if (!noAssert) { | |
var maxBytes = Math.pow(2, 8 * byteLength2) - 1; | |
checkInt(this, value, offset, byteLength2, maxBytes, 0); | |
} | |
var mul = 1; | |
var i = 0; | |
this[offset] = value & 255; | |
while (++i < byteLength2 && (mul *= 256)) { | |
this[offset + i] = value / mul & 255; | |
} | |
return offset + byteLength2; | |
}; | |
Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
byteLength2 = byteLength2 | 0; | |
if (!noAssert) { | |
var maxBytes = Math.pow(2, 8 * byteLength2) - 1; | |
checkInt(this, value, offset, byteLength2, maxBytes, 0); | |
} | |
var i = byteLength2 - 1; | |
var mul = 1; | |
this[offset + i] = value & 255; | |
while (--i >= 0 && (mul *= 256)) { | |
this[offset + i] = value / mul & 255; | |
} | |
return offset + byteLength2; | |
}; | |
Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 1, 255, 0); | |
if (!Buffer.TYPED_ARRAY_SUPPORT) | |
value = Math.floor(value); | |
this[offset] = value & 255; | |
return offset + 1; | |
}; | |
function objectWriteUInt16(buf, value, offset, littleEndian) { | |
if (value < 0) | |
value = 65535 + value + 1; | |
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { | |
buf[offset + i] = (value & 255 << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8; | |
} | |
} | |
Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 2, 65535, 0); | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = value & 255; | |
this[offset + 1] = value >>> 8; | |
} else { | |
objectWriteUInt16(this, value, offset, true); | |
} | |
return offset + 2; | |
}; | |
Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 2, 65535, 0); | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = value >>> 8; | |
this[offset + 1] = value & 255; | |
} else { | |
objectWriteUInt16(this, value, offset, false); | |
} | |
return offset + 2; | |
}; | |
function objectWriteUInt32(buf, value, offset, littleEndian) { | |
if (value < 0) | |
value = 4294967295 + value + 1; | |
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { | |
buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 255; | |
} | |
} | |
Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 4, 4294967295, 0); | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset + 3] = value >>> 24; | |
this[offset + 2] = value >>> 16; | |
this[offset + 1] = value >>> 8; | |
this[offset] = value & 255; | |
} else { | |
objectWriteUInt32(this, value, offset, true); | |
} | |
return offset + 4; | |
}; | |
Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 4, 4294967295, 0); | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = value >>> 24; | |
this[offset + 1] = value >>> 16; | |
this[offset + 2] = value >>> 8; | |
this[offset + 3] = value & 255; | |
} else { | |
objectWriteUInt32(this, value, offset, false); | |
} | |
return offset + 4; | |
}; | |
Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) { | |
var limit = Math.pow(2, 8 * byteLength2 - 1); | |
checkInt(this, value, offset, byteLength2, limit - 1, -limit); | |
} | |
var i = 0; | |
var mul = 1; | |
var sub = 0; | |
this[offset] = value & 255; | |
while (++i < byteLength2 && (mul *= 256)) { | |
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { | |
sub = 1; | |
} | |
this[offset + i] = (value / mul >> 0) - sub & 255; | |
} | |
return offset + byteLength2; | |
}; | |
Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) { | |
var limit = Math.pow(2, 8 * byteLength2 - 1); | |
checkInt(this, value, offset, byteLength2, limit - 1, -limit); | |
} | |
var i = byteLength2 - 1; | |
var mul = 1; | |
var sub = 0; | |
this[offset + i] = value & 255; | |
while (--i >= 0 && (mul *= 256)) { | |
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { | |
sub = 1; | |
} | |
this[offset + i] = (value / mul >> 0) - sub & 255; | |
} | |
return offset + byteLength2; | |
}; | |
Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 1, 127, -128); | |
if (!Buffer.TYPED_ARRAY_SUPPORT) | |
value = Math.floor(value); | |
if (value < 0) | |
value = 255 + value + 1; | |
this[offset] = value & 255; | |
return offset + 1; | |
}; | |
Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 2, 32767, -32768); | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = value & 255; | |
this[offset + 1] = value >>> 8; | |
} else { | |
objectWriteUInt16(this, value, offset, true); | |
} | |
return offset + 2; | |
}; | |
Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 2, 32767, -32768); | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = value >>> 8; | |
this[offset + 1] = value & 255; | |
} else { | |
objectWriteUInt16(this, value, offset, false); | |
} | |
return offset + 2; | |
}; | |
Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 4, 2147483647, -2147483648); | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = value & 255; | |
this[offset + 1] = value >>> 8; | |
this[offset + 2] = value >>> 16; | |
this[offset + 3] = value >>> 24; | |
} else { | |
objectWriteUInt32(this, value, offset, true); | |
} | |
return offset + 4; | |
}; | |
Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) { | |
value = +value; | |
offset = offset | 0; | |
if (!noAssert) | |
checkInt(this, value, offset, 4, 2147483647, -2147483648); | |
if (value < 0) | |
value = 4294967295 + value + 1; | |
if (Buffer.TYPED_ARRAY_SUPPORT) { | |
this[offset] = value >>> 24; | |
this[offset + 1] = value >>> 16; | |
this[offset + 2] = value >>> 8; | |
this[offset + 3] = value & 255; | |
} else { | |
objectWriteUInt32(this, value, offset, false); | |
} | |
return offset + 4; | |
}; | |
function checkIEEE754(buf, value, offset, ext, max, min) { | |
if (offset + ext > buf.length) | |
throw new RangeError("Index out of range"); | |
if (offset < 0) | |
throw new RangeError("Index out of range"); | |
} | |
function writeFloat(buf, value, offset, littleEndian, noAssert) { | |
if (!noAssert) { | |
checkIEEE754(buf, value, offset, 4); | |
} | |
write(buf, value, offset, littleEndian, 23, 4); | |
return offset + 4; | |
} | |
Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) { | |
return writeFloat(this, value, offset, true, noAssert); | |
}; | |
Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) { | |
return writeFloat(this, value, offset, false, noAssert); | |
}; | |
function writeDouble(buf, value, offset, littleEndian, noAssert) { | |
if (!noAssert) { | |
checkIEEE754(buf, value, offset, 8); | |
} | |
write(buf, value, offset, littleEndian, 52, 8); | |
return offset + 8; | |
} | |
Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) { | |
return writeDouble(this, value, offset, true, noAssert); | |
}; | |
Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) { | |
return writeDouble(this, value, offset, false, noAssert); | |
}; | |
Buffer.prototype.copy = function copy(target, targetStart, start, end) { | |
if (!start) | |
start = 0; | |
if (!end && end !== 0) | |
end = this.length; | |
if (targetStart >= target.length) | |
targetStart = target.length; | |
if (!targetStart) | |
targetStart = 0; | |
if (end > 0 && end < start) | |
end = start; | |
if (end === start) | |
return 0; | |
if (target.length === 0 || this.length === 0) | |
return 0; | |
if (targetStart < 0) { | |
throw new RangeError("targetStart out of bounds"); | |
} | |
if (start < 0 || start >= this.length) | |
throw new RangeError("sourceStart out of bounds"); | |
if (end < 0) | |
throw new RangeError("sourceEnd out of bounds"); | |
if (end > this.length) | |
end = this.length; | |
if (target.length - targetStart < end - start) { | |
end = target.length - targetStart + start; | |
} | |
var len = end - start; | |
var i; | |
if (this === target && start < targetStart && targetStart < end) { | |
for (i = len - 1; i >= 0; --i) { | |
target[i + targetStart] = this[i + start]; | |
} | |
} else if (len < 1e3 || !Buffer.TYPED_ARRAY_SUPPORT) { | |
for (i = 0; i < len; ++i) { | |
target[i + targetStart] = this[i + start]; | |
} | |
} else { | |
Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart); | |
} | |
return len; | |
}; | |
Buffer.prototype.fill = function fill(val, start, end, encoding) { | |
if (typeof val === "string") { | |
if (typeof start === "string") { | |
encoding = start; | |
start = 0; | |
end = this.length; | |
} else if (typeof end === "string") { | |
encoding = end; | |
end = this.length; | |
} | |
if (val.length === 1) { | |
var code = val.charCodeAt(0); | |
if (code < 256) { | |
val = code; | |
} | |
} | |
if (encoding !== void 0 && typeof encoding !== "string") { | |
throw new TypeError("encoding must be a string"); | |
} | |
if (typeof encoding === "string" && !Buffer.isEncoding(encoding)) { | |
throw new TypeError("Unknown encoding: " + encoding); | |
} | |
} else if (typeof val === "number") { | |
val = val & 255; | |
} | |
if (start < 0 || this.length < start || this.length < end) { | |
throw new RangeError("Out of range index"); | |
} | |
if (end <= start) { | |
return this; | |
} | |
start = start >>> 0; | |
end = end === void 0 ? this.length : end >>> 0; | |
if (!val) | |
val = 0; | |
var i; | |
if (typeof val === "number") { | |
for (i = start; i < end; ++i) { | |
this[i] = val; | |
} | |
} else { | |
var bytes = internalIsBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString()); | |
var len = bytes.length; | |
for (i = 0; i < end - start; ++i) { | |
this[i + start] = bytes[i % len]; | |
} | |
} | |
return this; | |
}; | |
var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; | |
function base64clean(str) { | |
str = stringtrim(str).replace(INVALID_BASE64_RE, ""); | |
if (str.length < 2) | |
return ""; | |
while (str.length % 4 !== 0) { | |
str = str + "="; | |
} | |
return str; | |
} | |
function stringtrim(str) { | |
if (str.trim) | |
return str.trim(); | |
return str.replace(/^\s+|\s+$/g, ""); | |
} | |
function toHex(n) { | |
if (n < 16) | |
return "0" + n.toString(16); | |
return n.toString(16); | |
} | |
function utf8ToBytes(string, units) { | |
units = units || Infinity; | |
var codePoint; | |
var length = string.length; | |
var leadSurrogate = null; | |
var bytes = []; | |
for (var i = 0; i < length; ++i) { | |
codePoint = string.charCodeAt(i); | |
if (codePoint > 55295 && codePoint < 57344) { | |
if (!leadSurrogate) { | |
if (codePoint > 56319) { | |
if ((units -= 3) > -1) | |
bytes.push(239, 191, 189); | |
continue; | |
} else if (i + 1 === length) { | |
if ((units -= 3) > -1) | |
bytes.push(239, 191, 189); | |
continue; | |
} | |
leadSurrogate = codePoint; | |
continue; | |
} | |
if (codePoint < 56320) { | |
if ((units -= 3) > -1) | |
bytes.push(239, 191, 189); | |
leadSurrogate = codePoint; | |
continue; | |
} | |
codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536; | |
} else if (leadSurrogate) { | |
if ((units -= 3) > -1) | |
bytes.push(239, 191, 189); | |
} | |
leadSurrogate = null; | |
if (codePoint < 128) { | |
if ((units -= 1) < 0) | |
break; | |
bytes.push(codePoint); | |
} else if (codePoint < 2048) { | |
if ((units -= 2) < 0) | |
break; | |
bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128); | |
} else if (codePoint < 65536) { | |
if ((units -= 3) < 0) | |
break; | |
bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128); | |
} else if (codePoint < 1114112) { | |
if ((units -= 4) < 0) | |
break; | |
bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128); | |
} else { | |
throw new Error("Invalid code point"); | |
} | |
} | |
return bytes; | |
} | |
function asciiToBytes(str) { | |
var byteArray = []; | |
for (var i = 0; i < str.length; ++i) { | |
byteArray.push(str.charCodeAt(i) & 255); | |
} | |
return byteArray; | |
} | |
function utf16leToBytes(str, units) { | |
var c, hi, lo; | |
var byteArray = []; | |
for (var i = 0; i < str.length; ++i) { | |
if ((units -= 2) < 0) | |
break; | |
c = str.charCodeAt(i); | |
hi = c >> 8; | |
lo = c % 256; | |
byteArray.push(lo); | |
byteArray.push(hi); | |
} | |
return byteArray; | |
} | |
function base64ToBytes(str) { | |
return toByteArray(base64clean(str)); | |
} | |
function blitBuffer(src, dst, offset, length) { | |
for (var i = 0; i < length; ++i) { | |
if (i + offset >= dst.length || i >= src.length) | |
break; | |
dst[i + offset] = src[i]; | |
} | |
return i; | |
} | |
function isnan(val) { | |
return val !== val; | |
} | |
function isBuffer(obj) { | |
return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)); | |
} | |
function isFastBuffer(obj) { | |
return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj); | |
} | |
function isSlowBuffer(obj) { | |
return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isFastBuffer(obj.slice(0, 0)); | |
} | |
function getDefaultExportFromCjs(x) { | |
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; | |
} | |
function createCommonjsModule(fn, basedir, module) { | |
return module = { | |
path: basedir, | |
exports: {}, | |
require: function(path, base) { | |
return commonjsRequire(path, base === void 0 || base === null ? module.path : base); | |
} | |
}, fn(module, module.exports), module.exports; | |
} | |
function commonjsRequire() { | |
throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs"); | |
} | |
var browser = createCommonjsModule(function(module, exports) { | |
((exports2) => { | |
var __defProp = Object.defineProperty; | |
var __hasOwnProp = Object.prototype.hasOwnProperty; | |
var __getOwnPropSymbols = Object.getOwnPropertySymbols; | |
var __propIsEnum = Object.prototype.propertyIsEnumerable; | |
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {enumerable: true, configurable: true, writable: true, value}) : obj[key] = value; | |
var __objSpread = (a, b) => { | |
for (var prop in b || (b = {})) | |
if (__hasOwnProp.call(b, prop)) | |
__defNormalProp(a, prop, b[prop]); | |
if (__getOwnPropSymbols) | |
for (var prop of __getOwnPropSymbols(b)) { | |
if (__propIsEnum.call(b, prop)) | |
__defNormalProp(a, prop, b[prop]); | |
} | |
return a; | |
}; | |
var __markAsModule = (target) => __defProp(target, "__esModule", {value: true}); | |
var __export = (target, all) => { | |
for (var name in all) | |
__defProp(target, name, {get: all[name], enumerable: true}); | |
}; | |
var __async = (__this, __arguments, generator) => { | |
return new Promise((resolve, reject) => { | |
var fulfilled = (value) => { | |
try { | |
step(generator.next(value)); | |
} catch (e) { | |
reject(e); | |
} | |
}; | |
var rejected = (value) => { | |
try { | |
step(generator.throw(value)); | |
} catch (e) { | |
reject(e); | |
} | |
}; | |
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); | |
step((generator = generator.apply(__this, __arguments)).next()); | |
}); | |
}; | |
__markAsModule(exports2); | |
__export(exports2, { | |
build: () => build2, | |
buildSync: () => buildSync2, | |
formatMessages: () => formatMessages2, | |
formatMessagesSync: () => formatMessagesSync2, | |
initialize: () => initialize2, | |
serve: () => serve2, | |
transform: () => transform2, | |
transformSync: () => transformSync2, | |
version: () => version2 | |
}); | |
function encodePacket(packet) { | |
let visit = (value) => { | |
if (value === null) { | |
bb.write8(0); | |
} else if (typeof value === "boolean") { | |
bb.write8(1); | |
bb.write8(+value); | |
} else if (typeof value === "number") { | |
bb.write8(2); | |
bb.write32(value | 0); | |
} else if (typeof value === "string") { | |
bb.write8(3); | |
bb.write(encodeUTF8(value)); | |
} else if (value instanceof Uint8Array) { | |
bb.write8(4); | |
bb.write(value); | |
} else if (value instanceof Array) { | |
bb.write8(5); | |
bb.write32(value.length); | |
for (let item of value) { | |
visit(item); | |
} | |
} else { | |
let keys = Object.keys(value); | |
bb.write8(6); | |
bb.write32(keys.length); | |
for (let key of keys) { | |
bb.write(encodeUTF8(key)); | |
visit(value[key]); | |
} | |
} | |
}; | |
let bb = new ByteBuffer(); | |
bb.write32(0); | |
bb.write32(packet.id << 1 | +!packet.isRequest); | |
visit(packet.value); | |
writeUInt32LE2(bb.buf, bb.len - 4, 0); | |
return bb.buf.subarray(0, bb.len); | |
} | |
function decodePacket(bytes) { | |
let visit = () => { | |
switch (bb.read8()) { | |
case 0: | |
return null; | |
case 1: | |
return !!bb.read8(); | |
case 2: | |
return bb.read32(); | |
case 3: | |
return decodeUTF8(bb.read()); | |
case 4: | |
return bb.read(); | |
case 5: { | |
let count = bb.read32(); | |
let value2 = []; | |
for (let i = 0; i < count; i++) { | |
value2.push(visit()); | |
} | |
return value2; | |
} | |
case 6: { | |
let count = bb.read32(); | |
let value2 = {}; | |
for (let i = 0; i < count; i++) { | |
value2[decodeUTF8(bb.read())] = visit(); | |
} | |
return value2; | |
} | |
default: | |
throw new Error("Invalid packet"); | |
} | |
}; | |
let bb = new ByteBuffer(bytes); | |
let id = bb.read32(); | |
let isRequest = (id & 1) === 0; | |
id >>>= 1; | |
let value = visit(); | |
if (bb.ptr !== bytes.length) { | |
throw new Error("Invalid packet"); | |
} | |
return {id, isRequest, value}; | |
} | |
var ByteBuffer = class { | |
constructor(buf = new Uint8Array(1024)) { | |
this.buf = buf; | |
this.len = 0; | |
this.ptr = 0; | |
} | |
_write(delta) { | |
if (this.len + delta > this.buf.length) { | |
let clone = new Uint8Array((this.len + delta) * 2); | |
clone.set(this.buf); | |
this.buf = clone; | |
} | |
this.len += delta; | |
return this.len - delta; | |
} | |
write8(value) { | |
let offset = this._write(1); | |
this.buf[offset] = value; | |
} | |
write32(value) { | |
let offset = this._write(4); | |
writeUInt32LE2(this.buf, value, offset); | |
} | |
write(bytes) { | |
let offset = this._write(4 + bytes.length); | |
writeUInt32LE2(this.buf, bytes.length, offset); | |
this.buf.set(bytes, offset + 4); | |
} | |
_read(delta) { | |
if (this.ptr + delta > this.buf.length) { | |
throw new Error("Invalid packet"); | |
} | |
this.ptr += delta; | |
return this.ptr - delta; | |
} | |
read8() { | |
return this.buf[this._read(1)]; | |
} | |
read32() { | |
return readUInt32LE2(this.buf, this._read(4)); | |
} | |
read() { | |
let length = this.read32(); | |
let bytes = new Uint8Array(length); | |
let ptr = this._read(bytes.length); | |
bytes.set(this.buf.subarray(ptr, ptr + length)); | |
return bytes; | |
} | |
}; | |
var encodeUTF8; | |
var decodeUTF8; | |
if (typeof TextEncoder !== "undefined" && typeof TextDecoder !== "undefined") { | |
let encoder = new TextEncoder(); | |
let decoder = new TextDecoder(); | |
encodeUTF8 = (text) => encoder.encode(text); | |
decodeUTF8 = (bytes) => decoder.decode(bytes); | |
} else if (typeof Buffer !== "undefined") { | |
encodeUTF8 = (text) => { | |
let buffer = Buffer.from(text); | |
if (!(buffer instanceof Uint8Array)) { | |
buffer = new Uint8Array(buffer); | |
} | |
return buffer; | |
}; | |
decodeUTF8 = (bytes) => { | |
let {buffer, byteOffset, byteLength: byteLength2} = bytes; | |
return Buffer.from(buffer, byteOffset, byteLength2).toString(); | |
}; | |
} else { | |
throw new Error("No UTF-8 codec found"); | |
} | |
function readUInt32LE2(buffer, offset) { | |
return buffer[offset++] | buffer[offset++] << 8 | buffer[offset++] << 16 | buffer[offset++] << 24; | |
} | |
function writeUInt32LE2(buffer, value, offset) { | |
buffer[offset++] = value; | |
buffer[offset++] = value >> 8; | |
buffer[offset++] = value >> 16; | |
buffer[offset++] = value >> 24; | |
} | |
function validateTarget(target) { | |
target += ""; | |
if (target.indexOf(",") >= 0) | |
throw new Error(`Invalid target: ${target}`); | |
return target; | |
} | |
var canBeAnything = () => null; | |
var mustBeBoolean = (value) => typeof value === "boolean" ? null : "a boolean"; | |
var mustBeBooleanOrObject = (value) => typeof value === "boolean" || typeof value === "object" && !Array.isArray(value) ? null : "a boolean or an object"; | |
var mustBeString = (value) => typeof value === "string" ? null : "a string"; | |
var mustBeRegExp = (value) => value instanceof RegExp ? null : "a RegExp object"; | |
var mustBeInteger = (value) => typeof value === "number" && value === (value | 0) ? null : "an integer"; | |
var mustBeFunction = (value) => typeof value === "function" ? null : "a function"; | |
var mustBeArray = (value) => Array.isArray(value) ? null : "an array"; | |
var mustBeObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? null : "an object"; | |
var mustBeArrayOrRecord = (value) => typeof value === "object" && value !== null ? null : "an array or an object"; | |
var mustBeObjectOrNull = (value) => typeof value === "object" && !Array.isArray(value) ? null : "an object or null"; | |
var mustBeStringOrBoolean = (value) => typeof value === "string" || typeof value === "boolean" ? null : "a string or a boolean"; | |
var mustBeStringOrObject = (value) => typeof value === "string" || typeof value === "object" && value !== null && !Array.isArray(value) ? null : "a string or an object"; | |
var mustBeStringOrArray = (value) => typeof value === "string" || Array.isArray(value) ? null : "a string or an array"; | |
var mustBeStringOrUint8Array = (value) => typeof value === "string" || value instanceof Uint8Array ? null : "a string or a Uint8Array"; | |
function getFlag(object, keys, key, mustBeFn) { | |
let value = object[key]; | |
keys[key + ""] = true; | |
if (value === void 0) | |
return void 0; | |
let mustBe = mustBeFn(value); | |
if (mustBe !== null) | |
throw new Error(`"${key}" must be ${mustBe}`); | |
return value; | |
} | |
function checkForInvalidFlags(object, keys, where) { | |
for (let key in object) { | |
if (!(key in keys)) { | |
throw new Error(`Invalid option ${where}: "${key}"`); | |
} | |
} | |
} | |
function validateInitializeOptions(options) { | |
let keys = Object.create(null); | |
let wasmURL = getFlag(options, keys, "wasmURL", mustBeString); | |
let worker = getFlag(options, keys, "worker", mustBeBoolean); | |
checkForInvalidFlags(options, keys, "in startService() call"); | |
return { | |
wasmURL, | |
worker | |
}; | |
} | |
function pushLogFlags(flags, options, keys, isTTY, logLevelDefault) { | |
let color = getFlag(options, keys, "color", mustBeBoolean); | |
let logLevel = getFlag(options, keys, "logLevel", mustBeString); | |
let logLimit = getFlag(options, keys, "logLimit", mustBeInteger); | |
if (color) | |
flags.push(`--color=${color}`); | |
else if (isTTY) | |
flags.push(`--color=true`); | |
flags.push(`--log-level=${logLevel || logLevelDefault}`); | |
flags.push(`--log-limit=${logLimit || 0}`); | |
} | |
function pushCommonFlags(flags, options, keys) { | |
let legalComments = getFlag(options, keys, "legalComments", mustBeString); | |
let sourceRoot = getFlag(options, keys, "sourceRoot", mustBeString); | |
let sourcesContent = getFlag(options, keys, "sourcesContent", mustBeBoolean); | |
let target = getFlag(options, keys, "target", mustBeStringOrArray); | |
let format = getFlag(options, keys, "format", mustBeString); | |
let globalName = getFlag(options, keys, "globalName", mustBeString); | |
let minify = getFlag(options, keys, "minify", mustBeBoolean); | |
let minifySyntax = getFlag(options, keys, "minifySyntax", mustBeBoolean); | |
let minifyWhitespace = getFlag(options, keys, "minifyWhitespace", mustBeBoolean); | |
let minifyIdentifiers = getFlag(options, keys, "minifyIdentifiers", mustBeBoolean); | |
let charset = getFlag(options, keys, "charset", mustBeString); | |
let treeShaking = getFlag(options, keys, "treeShaking", mustBeStringOrBoolean); | |
let jsxFactory = getFlag(options, keys, "jsxFactory", mustBeString); | |
let jsxFragment = getFlag(options, keys, "jsxFragment", mustBeString); | |
let define = getFlag(options, keys, "define", mustBeObject); | |
let pure = getFlag(options, keys, "pure", mustBeArray); | |
let keepNames = getFlag(options, keys, "keepNames", mustBeBoolean); | |
if (legalComments) | |
flags.push(`--legal-comments=${legalComments}`); | |
if (sourceRoot !== void 0) | |
flags.push(`--source-root=${sourceRoot}`); | |
if (sourcesContent !== void 0) | |
flags.push(`--sources-content=${sourcesContent}`); | |
if (target) { | |
if (Array.isArray(target)) | |
flags.push(`--target=${Array.from(target).map(validateTarget).join(",")}`); | |
else | |
flags.push(`--target=${validateTarget(target)}`); | |
} | |
if (format) | |
flags.push(`--format=${format}`); | |
if (globalName) | |
flags.push(`--global-name=${globalName}`); | |
if (minify) | |
flags.push("--minify"); | |
if (minifySyntax) | |
flags.push("--minify-syntax"); | |
if (minifyWhitespace) | |
flags.push("--minify-whitespace"); | |
if (minifyIdentifiers) | |
flags.push("--minify-identifiers"); | |
if (charset) | |
flags.push(`--charset=${charset}`); | |
if (treeShaking !== void 0 && treeShaking !== true) | |
flags.push(`--tree-shaking=${treeShaking}`); | |
if (jsxFactory) | |
flags.push(`--jsx-factory=${jsxFactory}`); | |
if (jsxFragment) | |
flags.push(`--jsx-fragment=${jsxFragment}`); | |
if (define) { | |
for (let key in define) { | |
if (key.indexOf("=") >= 0) | |
throw new Error(`Invalid define: ${key}`); | |
flags.push(`--define:${key}=${define[key]}`); | |
} | |
} | |
if (pure) | |
for (let fn of pure) | |
flags.push(`--pure:${fn}`); | |
if (keepNames) | |
flags.push(`--keep-names`); | |
} | |
function flagsForBuildOptions(callName, options, isTTY, logLevelDefault, writeDefault) { | |
var _a; | |
let flags = []; | |
let entries = []; | |
let keys = Object.create(null); | |
let stdinContents = null; | |
let stdinResolveDir = null; | |
let watchMode = null; | |
pushLogFlags(flags, options, keys, isTTY, logLevelDefault); | |
pushCommonFlags(flags, options, keys); | |
let sourcemap = getFlag(options, keys, "sourcemap", mustBeStringOrBoolean); | |
let bundle = getFlag(options, keys, "bundle", mustBeBoolean); | |
let watch = getFlag(options, keys, "watch", mustBeBooleanOrObject); | |
let splitting = getFlag(options, keys, "splitting", mustBeBoolean); | |
let preserveSymlinks = getFlag(options, keys, "preserveSymlinks", mustBeBoolean); | |
let metafile = getFlag(options, keys, "metafile", mustBeBoolean); | |
let outfile = getFlag(options, keys, "outfile", mustBeString); | |
let outdir = getFlag(options, keys, "outdir", mustBeString); | |
let outbase = getFlag(options, keys, "outbase", mustBeString); | |
let platform = getFlag(options, keys, "platform", mustBeString); | |
let tsconfig = getFlag(options, keys, "tsconfig", mustBeString); | |
let resolveExtensions = getFlag(options, keys, "resolveExtensions", mustBeArray); | |
let nodePathsInput = getFlag(options, keys, "nodePaths", mustBeArray); | |
let mainFields = getFlag(options, keys, "mainFields", mustBeArray); | |
let conditions = getFlag(options, keys, "conditions", mustBeArray); | |
let external = getFlag(options, keys, "external", mustBeArray); | |
let loader = getFlag(options, keys, "loader", mustBeObject); | |
let outExtension = getFlag(options, keys, "outExtension", mustBeObject); | |
let publicPath = getFlag(options, keys, "publicPath", mustBeString); | |
let entryNames = getFlag(options, keys, "entryNames", mustBeString); | |
let chunkNames = getFlag(options, keys, "chunkNames", mustBeString); | |
let assetNames = getFlag(options, keys, "assetNames", mustBeString); | |
let inject = getFlag(options, keys, "inject", mustBeArray); | |
let banner = getFlag(options, keys, "banner", mustBeObject); | |
let footer = getFlag(options, keys, "footer", mustBeObject); | |
let entryPoints = getFlag(options, keys, "entryPoints", mustBeArrayOrRecord); | |
let absWorkingDir = getFlag(options, keys, "absWorkingDir", mustBeString); | |
let stdin = getFlag(options, keys, "stdin", mustBeObject); | |
let write3 = (_a = getFlag(options, keys, "write", mustBeBoolean)) != null ? _a : writeDefault; | |
let allowOverwrite = getFlag(options, keys, "allowOverwrite", mustBeBoolean); | |
let incremental = getFlag(options, keys, "incremental", mustBeBoolean) === true; | |
keys.plugins = true; | |
checkForInvalidFlags(options, keys, `in ${callName}() call`); | |
if (sourcemap) | |
flags.push(`--sourcemap${sourcemap === true ? "" : `=${sourcemap}`}`); | |
if (bundle) | |
flags.push("--bundle"); | |
if (allowOverwrite) | |
flags.push("--allow-overwrite"); | |
if (watch) { | |
flags.push("--watch"); | |
if (typeof watch === "boolean") { | |
watchMode = {}; | |
} else { | |
let watchKeys = Object.create(null); | |
let onRebuild = getFlag(watch, watchKeys, "onRebuild", mustBeFunction); | |
checkForInvalidFlags(watch, watchKeys, `on "watch" in ${callName}() call`); | |
watchMode = {onRebuild}; | |
} | |
} | |
if (splitting) | |
flags.push("--splitting"); | |
if (preserveSymlinks) | |
flags.push("--preserve-symlinks"); | |
if (metafile) | |
flags.push(`--metafile`); | |
if (outfile) | |
flags.push(`--outfile=${outfile}`); | |
if (outdir) | |
flags.push(`--outdir=${outdir}`); | |
if (outbase) | |
flags.push(`--outbase=${outbase}`); | |
if (platform) | |
flags.push(`--platform=${platform}`); | |
if (tsconfig) | |
flags.push(`--tsconfig=${tsconfig}`); | |
if (resolveExtensions) { | |
let values = []; | |
for (let value of resolveExtensions) { | |
value += ""; | |
if (value.indexOf(",") >= 0) | |
throw new Error(`Invalid resolve extension: ${value}`); | |
values.push(value); | |
} | |
flags.push(`--resolve-extensions=${values.join(",")}`); | |
} | |
if (publicPath) | |
flags.push(`--public-path=${publicPath}`); | |
if (entryNames) | |
flags.push(`--entry-names=${entryNames}`); | |
if (chunkNames) | |
flags.push(`--chunk-names=${chunkNames}`); | |
if (assetNames) | |
flags.push(`--asset-names=${assetNames}`); | |
if (mainFields) { | |
let values = []; | |
for (let value of mainFields) { | |
value += ""; | |
if (value.indexOf(",") >= 0) | |
throw new Error(`Invalid main field: ${value}`); | |
values.push(value); | |
} | |
flags.push(`--main-fields=${values.join(",")}`); | |
} | |
if (conditions) { | |
let values = []; | |
for (let value of conditions) { | |
value += ""; | |
if (value.indexOf(",") >= 0) | |
throw new Error(`Invalid condition: ${value}`); | |
values.push(value); | |
} | |
flags.push(`--conditions=${values.join(",")}`); | |
} | |
if (external) | |
for (let name of external) | |
flags.push(`--external:${name}`); | |
if (banner) { | |
for (let type in banner) { | |
if (type.indexOf("=") >= 0) | |
throw new Error(`Invalid banner file type: ${type}`); | |
flags.push(`--banner:${type}=${banner[type]}`); | |
} | |
} | |
if (footer) { | |
for (let type in footer) { | |
if (type.indexOf("=") >= 0) | |
throw new Error(`Invalid footer file type: ${type}`); | |
flags.push(`--footer:${type}=${footer[type]}`); | |
} | |
} | |
if (inject) | |
for (let path of inject) | |
flags.push(`--inject:${path}`); | |
if (loader) { | |
for (let ext in loader) { | |
if (ext.indexOf("=") >= 0) | |
throw new Error(`Invalid loader extension: ${ext}`); | |
flags.push(`--loader:${ext}=${loader[ext]}`); | |
} | |
} | |
if (outExtension) { | |
for (let ext in outExtension) { | |
if (ext.indexOf("=") >= 0) | |
throw new Error(`Invalid out extension: ${ext}`); | |
flags.push(`--out-extension:${ext}=${outExtension[ext]}`); | |
} | |
} | |
if (entryPoints) { | |
if (Array.isArray(entryPoints)) { | |
for (let entryPoint of entryPoints) { | |
entries.push(["", entryPoint + ""]); | |
} | |
} else { | |
for (let [key, value] of Object.entries(entryPoints)) { | |
entries.push([key + "", value + ""]); | |
} | |
} | |
} | |
if (stdin) { | |
let stdinKeys = Object.create(null); | |
let contents = getFlag(stdin, stdinKeys, "contents", mustBeString); | |
let resolveDir = getFlag(stdin, stdinKeys, "resolveDir", mustBeString); | |
let sourcefile = getFlag(stdin, stdinKeys, "sourcefile", mustBeString); | |
let loader2 = getFlag(stdin, stdinKeys, "loader", mustBeString); | |
checkForInvalidFlags(stdin, stdinKeys, 'in "stdin" object'); | |
if (sourcefile) | |
flags.push(`--sourcefile=${sourcefile}`); | |
if (loader2) | |
flags.push(`--loader=${loader2}`); | |
if (resolveDir) | |
stdinResolveDir = resolveDir + ""; | |
stdinContents = contents ? contents + "" : ""; | |
} | |
let nodePaths = []; | |
if (nodePathsInput) { | |
for (let value of nodePathsInput) { | |
value += ""; | |
nodePaths.push(value); | |
} | |
} | |
return { | |
entries, | |
flags, | |
write: write3, | |
stdinContents, | |
stdinResolveDir, | |
absWorkingDir, | |
incremental, | |
nodePaths, | |
watch: watchMode | |
}; | |
} | |
function flagsForTransformOptions(callName, options, isTTY, logLevelDefault) { | |
let flags = []; | |
let keys = Object.create(null); | |
pushLogFlags(flags, options, keys, isTTY, logLevelDefault); | |
pushCommonFlags(flags, options, keys); | |
let sourcemap = getFlag(options, keys, "sourcemap", mustBeStringOrBoolean); | |
let tsconfigRaw = getFlag(options, keys, "tsconfigRaw", mustBeStringOrObject); | |
let sourcefile = getFlag(options, keys, "sourcefile", mustBeString); | |
let loader = getFlag(options, keys, "loader", mustBeString); | |
let banner = getFlag(options, keys, "banner", mustBeString); | |
let footer = getFlag(options, keys, "footer", mustBeString); | |
checkForInvalidFlags(options, keys, `in ${callName}() call`); | |
if (sourcemap) | |
flags.push(`--sourcemap=${sourcemap === true ? "external" : sourcemap}`); | |
if (tsconfigRaw) | |
flags.push(`--tsconfig-raw=${typeof tsconfigRaw === "string" ? tsconfigRaw : JSON.stringify(tsconfigRaw)}`); | |
if (sourcefile) | |
flags.push(`--sourcefile=${sourcefile}`); | |
if (loader) | |
flags.push(`--loader=${loader}`); | |
if (banner) | |
flags.push(`--banner=${banner}`); | |
if (footer) | |
flags.push(`--footer=${footer}`); | |
return flags; | |
} | |
function createChannel(streamIn) { | |
let responseCallbacks = new Map(); | |
let pluginCallbacks = new Map(); | |
let watchCallbacks = new Map(); | |
let serveCallbacks = new Map(); | |
let nextServeID = 0; | |
let isClosed = false; | |
let nextRequestID = 0; | |
let nextBuildKey = 0; | |
let stdout = new Uint8Array(16 * 1024); | |
let stdoutUsed = 0; | |
let readFromStdout = (chunk) => { | |
let limit = stdoutUsed + chunk.length; | |
if (limit > stdout.length) { | |
let swap2 = new Uint8Array(limit * 2); | |
swap2.set(stdout); | |
stdout = swap2; | |
} | |
stdout.set(chunk, stdoutUsed); | |
stdoutUsed += chunk.length; | |
let offset = 0; | |
while (offset + 4 <= stdoutUsed) { | |
let length = readUInt32LE2(stdout, offset); | |
if (offset + 4 + length > stdoutUsed) { | |
break; | |
} | |
offset += 4; | |
handleIncomingPacket(stdout.subarray(offset, offset + length)); | |
offset += length; | |
} | |
if (offset > 0) { | |
stdout.copyWithin(0, offset, stdoutUsed); | |
stdoutUsed -= offset; | |
} | |
}; | |
let afterClose = () => { | |
isClosed = true; | |
for (let callback of responseCallbacks.values()) { | |
callback("The service was stopped", null); | |
} | |
responseCallbacks.clear(); | |
for (let callbacks of serveCallbacks.values()) { | |
callbacks.onWait("The service was stopped"); | |
} | |
serveCallbacks.clear(); | |
for (let callback of watchCallbacks.values()) { | |
try { | |
callback(new Error("The service was stopped"), null); | |
} catch (e) { | |
console.error(e); | |
} | |
} | |
watchCallbacks.clear(); | |
}; | |
let sendRequest = (refs, value, callback) => { | |
if (isClosed) | |
return callback("The service is no longer running", null); | |
let id = nextRequestID++; | |
responseCallbacks.set(id, (error, response) => { | |
try { | |
callback(error, response); | |
} finally { | |
if (refs) | |
refs.unref(); | |
} | |
}); | |
if (refs) | |
refs.ref(); | |
streamIn.writeToStdin(encodePacket({id, isRequest: true, value})); | |
}; | |
let sendResponse = (id, value) => { | |
if (isClosed) | |
throw new Error("The service is no longer running"); | |
streamIn.writeToStdin(encodePacket({id, isRequest: false, value})); | |
}; | |
let handleRequest = (id, request) => __async(this, null, function* () { | |
try { | |
switch (request.command) { | |
case "ping": { | |
sendResponse(id, {}); | |
break; | |
} | |
case "start": { | |
let callback = pluginCallbacks.get(request.key); | |
if (!callback) | |
sendResponse(id, {}); | |
else | |
sendResponse(id, yield callback(request)); | |
break; | |
} | |
case "resolve": { | |
let callback = pluginCallbacks.get(request.key); | |
if (!callback) | |
sendResponse(id, {}); | |
else | |
sendResponse(id, yield callback(request)); | |
break; | |
} | |
case "load": { | |
let callback = pluginCallbacks.get(request.key); | |
if (!callback) | |
sendResponse(id, {}); | |
else | |
sendResponse(id, yield callback(request)); | |
break; | |
} | |
case "serve-request": { | |
let callbacks = serveCallbacks.get(request.serveID); | |
if (callbacks && callbacks.onRequest) | |
callbacks.onRequest(request.args); | |
sendResponse(id, {}); | |
break; | |
} | |
case "serve-wait": { | |
let callbacks = serveCallbacks.get(request.serveID); | |
if (callbacks) | |
callbacks.onWait(request.error); | |
sendResponse(id, {}); | |
break; | |
} | |
case "watch-rebuild": { | |
let callback = watchCallbacks.get(request.watchID); | |
try { | |
if (callback) | |
callback(null, request.args); | |
} catch (err) { | |
console.error(err); | |
} | |
sendResponse(id, {}); | |
break; | |
} | |
default: | |
throw new Error(`Invalid command: ` + request.command); | |
} | |
} catch (e) { | |
sendResponse(id, {errors: [extractErrorMessageV8(e, streamIn, null, void 0, "")]}); | |
} | |
}); | |
let isFirstPacket = true; | |
let handleIncomingPacket = (bytes) => { | |
if (isFirstPacket) { | |
isFirstPacket = false; | |
let binaryVersion = String.fromCharCode(...bytes); | |
if (binaryVersion !== "0.11.19") { | |
throw new Error(`Cannot start service: Host version "0.11.19" does not match binary version ${JSON.stringify(binaryVersion)}`); | |
} | |
return; | |
} | |
let packet = decodePacket(bytes); | |
if (packet.isRequest) { | |
handleRequest(packet.id, packet.value); | |
} else { | |
let callback = responseCallbacks.get(packet.id); | |
responseCallbacks.delete(packet.id); | |
if (packet.value.error) | |
callback(packet.value.error, {}); | |
else | |
callback(null, packet.value); | |
} | |
}; | |
let handlePlugins = (initialOptions, plugins, buildKey, stash) => __async(this, null, function* () { | |
let onStartCallbacks = []; | |
let onEndCallbacks = []; | |
let onResolveCallbacks = {}; | |
let onLoadCallbacks = {}; | |
let nextCallbackID = 0; | |
let i = 0; | |
let requestPlugins = []; | |
plugins = [...plugins]; | |
for (let item of plugins) { | |
let keys = {}; | |
if (typeof item !== "object") | |
throw new Error(`Plugin at index ${i} must be an object`); | |
let name = getFlag(item, keys, "name", mustBeString); | |
if (typeof name !== "string" || name === "") | |
throw new Error(`Plugin at index ${i} is missing a name`); | |
try { | |
let setup = getFlag(item, keys, "setup", mustBeFunction); | |
if (typeof setup !== "function") | |
throw new Error(`Plugin is missing a setup function`); | |
checkForInvalidFlags(item, keys, `on plugin ${JSON.stringify(name)}`); | |
let plugin = { | |
name, | |
onResolve: [], | |
onLoad: [] | |
}; | |
i++; | |
let promise = setup({ | |
initialOptions, | |
onStart(callback2) { | |
let registeredText = `This error came from the "onStart" callback registered here`; | |
let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onStart"); | |
onStartCallbacks.push({name, callback: callback2, note: registeredNote}); | |
}, | |
onEnd(callback2) { | |
let registeredText = `This error came from the "onEnd" callback registered here`; | |
let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onEnd"); | |
onEndCallbacks.push({name, callback: callback2, note: registeredNote}); | |
}, | |
onResolve(options, callback2) { | |
let registeredText = `This error came from the "onResolve" callback registered here`; | |
let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onResolve"); | |
let keys2 = {}; | |
let filter = getFlag(options, keys2, "filter", mustBeRegExp); | |
let namespace = getFlag(options, keys2, "namespace", mustBeString); | |
checkForInvalidFlags(options, keys2, `in onResolve() call for plugin ${JSON.stringify(name)}`); | |
if (filter == null) | |
throw new Error(`onResolve() call is missing a filter`); | |
let id = nextCallbackID++; | |
onResolveCallbacks[id] = {name, callback: callback2, note: registeredNote}; | |
plugin.onResolve.push({id, filter: filter.source, namespace: namespace || ""}); | |
}, | |
onLoad(options, callback2) { | |
let registeredText = `This error came from the "onLoad" callback registered here`; | |
let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onLoad"); | |
let keys2 = {}; | |
let filter = getFlag(options, keys2, "filter", mustBeRegExp); | |
let namespace = getFlag(options, keys2, "namespace", mustBeString); | |
checkForInvalidFlags(options, keys2, `in onLoad() call for plugin ${JSON.stringify(name)}`); | |
if (filter == null) | |
throw new Error(`onLoad() call is missing a filter`); | |
let id = nextCallbackID++; | |
onLoadCallbacks[id] = {name, callback: callback2, note: registeredNote}; | |
plugin.onLoad.push({id, filter: filter.source, namespace: namespace || ""}); | |
} | |
}); | |
if (promise) | |
yield promise; | |
requestPlugins.push(plugin); | |
} catch (e) { | |
return {ok: false, error: e, pluginName: name}; | |
} | |
} | |
const callback = (request) => __async(this, null, function* () { | |
switch (request.command) { | |
case "start": { | |
let response = {errors: [], warnings: []}; | |
yield Promise.all(onStartCallbacks.map((_0) => __async(this, [_0], function* ({name, callback: callback2, note}) { | |
try { | |
let result = yield callback2(); | |
if (result != null) { | |
if (typeof result !== "object") | |
throw new Error(`Expected onStart() callback in plugin ${JSON.stringify(name)} to return an object`); | |
let keys = {}; | |
let errors = getFlag(result, keys, "errors", mustBeArray); | |
let warnings = getFlag(result, keys, "warnings", mustBeArray); | |
checkForInvalidFlags(result, keys, `from onStart() callback in plugin ${JSON.stringify(name)}`); | |
if (errors != null) | |
response.errors.push(...sanitizeMessages(errors, "errors", stash, name)); | |
if (warnings != null) | |
response.warnings.push(...sanitizeMessages(warnings, "warnings", stash, name)); | |
} | |
} catch (e) { | |
response.errors.push(extractErrorMessageV8(e, streamIn, stash, note && note(), name)); | |
} | |
}))); | |
return response; | |
} | |
case "resolve": { | |
let response = {}, name = "", callback2, note; | |
for (let id of request.ids) { | |
try { | |
({name, callback: callback2, note} = onResolveCallbacks[id]); | |
let result = yield callback2({ | |
path: request.path, | |
importer: request.importer, | |
namespace: request.namespace, | |
resolveDir: request.resolveDir, | |
kind: request.kind, | |
pluginData: stash.load(request.pluginData) | |
}); | |
if (result != null) { | |
if (typeof result !== "object") | |
throw new Error(`Expected onResolve() callback in plugin ${JSON.stringify(name)} to return an object`); | |
let keys = {}; | |
let pluginName = getFlag(result, keys, "pluginName", mustBeString); | |
let path = getFlag(result, keys, "path", mustBeString); | |
let namespace = getFlag(result, keys, "namespace", mustBeString); | |
let external = getFlag(result, keys, "external", mustBeBoolean); | |
let pluginData = getFlag(result, keys, "pluginData", canBeAnything); | |
let errors = getFlag(result, keys, "errors", mustBeArray); | |
let warnings = getFlag(result, keys, "warnings", mustBeArray); | |
let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray); | |
let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray); | |
checkForInvalidFlags(result, keys, `from onResolve() callback in plugin ${JSON.stringify(name)}`); | |
response.id = id; | |
if (pluginName != null) | |
response.pluginName = pluginName; | |
if (path != null) | |
response.path = path; | |
if (namespace != null) | |
response.namespace = namespace; | |
if (external != null) | |
response.external = external; | |
if (pluginData != null) | |
response.pluginData = stash.store(pluginData); | |
if (errors != null) | |
response.errors = sanitizeMessages(errors, "errors", stash, name); | |
if (warnings != null) | |
response.warnings = sanitizeMessages(warnings, "warnings", stash, name); | |
if (watchFiles != null) | |
response.watchFiles = sanitizeStringArray(watchFiles, "watchFiles"); | |
if (watchDirs != null) | |
response.watchDirs = sanitizeStringArray(watchDirs, "watchDirs"); | |
break; | |
} | |
} catch (e) { | |
return {id, errors: [extractErrorMessageV8(e, streamIn, stash, note && note(), name)]}; | |
} | |
} | |
return response; | |
} | |
case "load": { | |
let response = {}, name = "", callback2, note; | |
for (let id of request.ids) { | |
try { | |
({name, callback: callback2, note} = onLoadCallbacks[id]); | |
let result = yield callback2({ | |
path: request.path, | |
namespace: request.namespace, | |
pluginData: stash.load(request.pluginData) | |
}); | |
if (result != null) { | |
if (typeof result !== "object") | |
throw new Error(`Expected onLoad() callback in plugin ${JSON.stringify(name)} to return an object`); | |
let keys = {}; | |
let pluginName = getFlag(result, keys, "pluginName", mustBeString); | |
let contents = getFlag(result, keys, "contents", mustBeStringOrUint8Array); | |
let resolveDir = getFlag(result, keys, "resolveDir", mustBeString); | |
let pluginData = getFlag(result, keys, "pluginData", canBeAnything); | |
let loader = getFlag(result, keys, "loader", mustBeString); | |
let errors = getFlag(result, keys, "errors", mustBeArray); | |
let warnings = getFlag(result, keys, "warnings", mustBeArray); | |
let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray); | |
let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray); | |
checkForInvalidFlags(result, keys, `from onLoad() callback in plugin ${JSON.stringify(name)}`); | |
response.id = id; | |
if (pluginName != null) | |
response.pluginName = pluginName; | |
if (contents instanceof Uint8Array) | |
response.contents = contents; | |
else if (contents != null) | |
response.contents = encodeUTF8(contents); | |
if (resolveDir != null) | |
response.resolveDir = resolveDir; | |
if (pluginData != null) | |
response.pluginData = stash.store(pluginData); | |
if (loader != null) | |
response.loader = loader; | |
if (errors != null) | |
response.errors = sanitizeMessages(errors, "errors", stash, name); | |
if (warnings != null) | |
response.warnings = sanitizeMessages(warnings, "warnings", stash, name); | |
if (watchFiles != null) | |
response.watchFiles = sanitizeStringArray(watchFiles, "watchFiles"); | |
if (watchDirs != null) | |
response.watchDirs = sanitizeStringArray(watchDirs, "watchDirs"); | |
break; | |
} | |
} catch (e) { | |
return {id, errors: [extractErrorMessageV8(e, streamIn, stash, note && note(), name)]}; | |
} | |
} | |
return response; | |
} | |
default: | |
throw new Error(`Invalid command: ` + request.command); | |
} | |
}); | |
let runOnEndCallbacks = (result, done) => done(); | |
if (onEndCallbacks.length > 0) { | |
runOnEndCallbacks = (result, done) => { | |
(() => __async(this, null, function* () { | |
for (const {name, callback: callback2, note} of onEndCallbacks) { | |
try { | |
yield callback2(result); | |
} catch (e) { | |
result.errors.push(extractErrorMessageV8(e, streamIn, stash, note && note(), name)); | |
} | |
} | |
}))().then(done); | |
}; | |
} | |
let refCount = 0; | |
return { | |
ok: true, | |
requestPlugins, | |
runOnEndCallbacks, | |
pluginRefs: { | |
ref() { | |
if (++refCount === 1) | |
pluginCallbacks.set(buildKey, callback); | |
}, | |
unref() { | |
if (--refCount === 0) | |
pluginCallbacks.delete(buildKey); | |
} | |
} | |
}; | |
}); | |
let buildServeData = (refs, options, request) => { | |
let keys = {}; | |
let port = getFlag(options, keys, "port", mustBeInteger); | |
let host = getFlag(options, keys, "host", mustBeString); | |
let servedir = getFlag(options, keys, "servedir", mustBeString); | |
let onRequest = getFlag(options, keys, "onRequest", mustBeFunction); | |
let serveID = nextServeID++; | |
let onWait; | |
let wait = new Promise((resolve, reject) => { | |
onWait = (error) => { | |
serveCallbacks.delete(serveID); | |
if (error !== null) | |
reject(new Error(error)); | |
else | |
resolve(); | |
}; | |
}); | |
request.serve = {serveID}; | |
checkForInvalidFlags(options, keys, `in serve() call`); | |
if (port !== void 0) | |
request.serve.port = port; | |
if (host !== void 0) | |
request.serve.host = host; | |
if (servedir !== void 0) | |
request.serve.servedir = servedir; | |
serveCallbacks.set(serveID, { | |
onRequest, | |
onWait | |
}); | |
return { | |
wait, | |
stop() { | |
sendRequest(refs, {command: "serve-stop", serveID}, () => { | |
}); | |
} | |
}; | |
}; | |
const buildLogLevelDefault = "warning"; | |
const transformLogLevelDefault = "silent"; | |
let buildOrServe = (args) => { | |
let key = nextBuildKey++; | |
const details = createObjectStash(); | |
let plugins; | |
let {refs, options, isTTY, callback} = args; | |
if (typeof options === "object") { | |
let value = options.plugins; | |
if (value !== void 0) { | |
if (!Array.isArray(value)) | |
throw new Error(`"plugins" must be an array`); | |
plugins = value; | |
} | |
} | |
let handleError = (e, pluginName) => { | |
let flags = []; | |
try { | |
pushLogFlags(flags, options, {}, isTTY, buildLogLevelDefault); | |
} catch (e2) { | |
} | |
const error = extractErrorMessageV8(e, streamIn, details, void 0, pluginName); | |
sendRequest(refs, {command: "error", flags, error}, () => { | |
error.detail = details.load(error.detail); | |
callback(failureErrorWithLog("Build failed", [error], []), null); | |
}); | |
}; | |
if (plugins && plugins.length > 0) { | |
if (streamIn.isSync) | |
return handleError(new Error("Cannot use plugins in synchronous API calls"), ""); | |
handlePlugins(options, plugins, key, details).then((result) => { | |
if (!result.ok) { | |
handleError(result.error, result.pluginName); | |
} else { | |
try { | |
buildOrServeContinue(__objSpread(__objSpread({}, args), { | |
key, | |
details, | |
requestPlugins: result.requestPlugins, | |
runOnEndCallbacks: result.runOnEndCallbacks, | |
pluginRefs: result.pluginRefs | |
})); | |
} catch (e) { | |
handleError(e, ""); | |
} | |
} | |
}, (e) => handleError(e, "")); | |
} else { | |
try { | |
buildOrServeContinue(__objSpread(__objSpread({}, args), { | |
key, | |
details, | |
requestPlugins: null, | |
runOnEndCallbacks: (result, done) => done(), | |
pluginRefs: null | |
})); | |
} catch (e) { | |
handleError(e, ""); | |
} | |
} | |
}; | |
let buildOrServeContinue = ({ | |
callName, | |
refs: callerRefs, | |
serveOptions, | |
options, | |
isTTY, | |
defaultWD, | |
callback, | |
key, | |
details, | |
requestPlugins, | |
runOnEndCallbacks, | |
pluginRefs | |
}) => { | |
const refs = { | |
ref() { | |
if (pluginRefs) | |
pluginRefs.ref(); | |
if (callerRefs) | |
callerRefs.ref(); | |
}, | |
unref() { | |
if (pluginRefs) | |
pluginRefs.unref(); | |
if (callerRefs) | |
callerRefs.unref(); | |
} | |
}; | |
let writeDefault = !streamIn.isBrowser; | |
let { | |
entries, | |
flags, | |
write: write3, | |
stdinContents, | |
stdinResolveDir, | |
absWorkingDir, | |
incremental, | |
nodePaths, | |
watch | |
} = flagsForBuildOptions(callName, options, isTTY, buildLogLevelDefault, writeDefault); | |
let request = { | |
command: "build", | |
key, | |
entries, | |
flags, | |
write: write3, | |
stdinContents, | |
stdinResolveDir, | |
absWorkingDir: absWorkingDir || defaultWD, | |
incremental, | |
nodePaths | |
}; | |
if (requestPlugins) | |
request.plugins = requestPlugins; | |
let serve22 = serveOptions && buildServeData(refs, serveOptions, request); | |
let rebuild; | |
let stop; | |
let copyResponseToResult = (response, result) => { | |
if (response.outputFiles) | |
result.outputFiles = response.outputFiles.map(convertOutputFiles); | |
if (response.metafile) | |
result.metafile = JSON.parse(response.metafile); | |
if (response.writeToStdout !== void 0) | |
console.log(decodeUTF8(response.writeToStdout).replace(/\n$/, "")); | |
}; | |
let buildResponseToResult = (response, callback2) => { | |
let result = { | |
errors: replaceDetailsInMessages(response.errors, details), | |
warnings: replaceDetailsInMessages(response.warnings, details) | |
}; | |
copyResponseToResult(response, result); | |
runOnEndCallbacks(result, () => { | |
if (result.errors.length > 0) { | |
return callback2(failureErrorWithLog("Build failed", result.errors, result.warnings), null); | |
} | |
if (response.rebuildID !== void 0) { | |
if (!rebuild) { | |
let isDisposed = false; | |
rebuild = () => new Promise((resolve, reject) => { | |
if (isDisposed || isClosed) | |
throw new Error("Cannot rebuild"); | |
sendRequest(refs, {command: "rebuild", rebuildID: response.rebuildID}, (error2, response2) => { | |
if (error2) { | |
const message = {pluginName: "", text: error2, location: null, notes: [], detail: void 0}; | |
return callback2(failureErrorWithLog("Build failed", [message], []), null); | |
} | |
buildResponseToResult(response2, (error3, result3) => { | |
if (error3) | |
reject(error3); | |
else | |
resolve(result3); | |
}); | |
}); | |
}); | |
refs.ref(); | |
rebuild.dispose = () => { | |
if (isDisposed) | |
return; | |
isDisposed = true; | |
sendRequest(refs, {command: "rebuild-dispose", rebuildID: response.rebuildID}, () => { | |
}); | |
refs.unref(); | |
}; | |
} | |
result.rebuild = rebuild; | |
} | |
if (response.watchID !== void 0) { | |
if (!stop) { | |
let isStopped = false; | |
refs.ref(); | |
stop = () => { | |
if (isStopped) | |
return; | |
isStopped = true; | |
watchCallbacks.delete(response.watchID); | |
sendRequest(refs, {command: "watch-stop", watchID: response.watchID}, () => { | |
}); | |
refs.unref(); | |
}; | |
if (watch) { | |
watchCallbacks.set(response.watchID, (serviceStopError, watchResponse) => { | |
if (serviceStopError) { | |
if (watch.onRebuild) | |
watch.onRebuild(serviceStopError, null); | |
return; | |
} | |
let result2 = { | |
errors: replaceDetailsInMessages(watchResponse.errors, details), | |
warnings: replaceDetailsInMessages(watchResponse.warnings, details) | |
}; | |
copyResponseToResult(watchResponse, result2); | |
runOnEndCallbacks(result2, () => { | |
if (result2.errors.length > 0) { | |
if (watch.onRebuild) | |
watch.onRebuild(failureErrorWithLog("Build failed", result2.errors, result2.warnings), null); | |
return; | |
} | |
if (watchResponse.rebuildID !== void 0) | |
result2.rebuild = rebuild; | |
result2.stop = stop; | |
if (watch.onRebuild) | |
watch.onRebuild(null, result2); | |
}); | |
}); | |
} | |
} | |
result.stop = stop; | |
} | |
callback2(null, result); | |
}); | |
}; | |
if (write3 && streamIn.isBrowser) | |
throw new Error(`Cannot enable "write" in the browser`); | |
if (incremental && streamIn.isSync) | |
throw new Error(`Cannot use "incremental" with a synchronous build`); | |
sendRequest(refs, request, (error, response) => { | |
if (error) | |
return callback(new Error(error), null); | |
if (serve22) { | |
let serveResponse = response; | |
let isStopped = false; | |
refs.ref(); | |
let result = { | |
port: serveResponse.port, | |
host: serveResponse.host, | |
wait: serve22.wait, | |
stop() { | |
if (isStopped) | |
return; | |
isStopped = true; | |
serve22.stop(); | |
refs.unref(); | |
} | |
}; | |
refs.ref(); | |
serve22.wait.then(refs.unref, refs.unref); | |
return callback(null, result); | |
} | |
return buildResponseToResult(response, callback); | |
}); | |
}; | |
let transform22 = ({callName, refs, input, options, isTTY, fs, callback}) => { | |
const details = createObjectStash(); | |
let start = (inputPath) => { | |
try { | |
if (typeof input !== "string") | |
throw new Error('The input to "transform" must be a string'); | |
let flags = flagsForTransformOptions(callName, options, isTTY, transformLogLevelDefault); | |
let request = { | |
command: "transform", | |
flags, | |
inputFS: inputPath !== null, | |
input: inputPath !== null ? inputPath : input | |
}; | |
sendRequest(refs, request, (error, response) => { | |
if (error) | |
return callback(new Error(error), null); | |
let errors = replaceDetailsInMessages(response.errors, details); | |
let warnings = replaceDetailsInMessages(response.warnings, details); | |
let outstanding = 1; | |
let next = () => --outstanding === 0 && callback(null, {warnings, code: response.code, map: response.map}); | |
if (errors.length > 0) | |
return callback(failureErrorWithLog("Transform failed", errors, warnings), null); | |
if (response.codeFS) { | |
outstanding++; | |
fs.readFile(response.code, (err, contents) => { | |
if (err !== null) { | |
callback(err, null); | |
} else { | |
response.code = contents; | |
next(); | |
} | |
}); | |
} | |
if (response.mapFS) { | |
outstanding++; | |
fs.readFile(response.map, (err, contents) => { | |
if (err !== null) { | |
callback(err, null); | |
} else { | |
response.map = contents; | |
next(); | |
} | |
}); | |
} | |
next(); | |
}); | |
} catch (e) { | |
let flags = []; | |
try { | |
pushLogFlags(flags, options, {}, isTTY, transformLogLevelDefault); | |
} catch (e2) { | |
} | |
const error = extractErrorMessageV8(e, streamIn, details, void 0, ""); | |
sendRequest(refs, {command: "error", flags, error}, () => { | |
error.detail = details.load(error.detail); | |
callback(failureErrorWithLog("Transform failed", [error], []), null); | |
}); | |
} | |
}; | |
if (typeof input === "string" && input.length > 1024 * 1024) { | |
let next = start; | |
start = () => fs.writeFile(input, next); | |
} | |
start(null); | |
}; | |
let formatMessages22 = ({callName, refs, messages, options, callback}) => { | |
let result = sanitizeMessages(messages, "messages", null, ""); | |
if (!options) | |
throw new Error(`Missing second argument in ${callName}() call`); | |
let keys = {}; | |
let kind = getFlag(options, keys, "kind", mustBeString); | |
let color = getFlag(options, keys, "color", mustBeBoolean); | |
let terminalWidth = getFlag(options, keys, "terminalWidth", mustBeInteger); | |
checkForInvalidFlags(options, keys, `in ${callName}() call`); | |
if (kind === void 0) | |
throw new Error(`Missing "kind" in ${callName}() call`); | |
if (kind !== "error" && kind !== "warning") | |
throw new Error(`Expected "kind" to be "error" or "warning" in ${callName}() call`); | |
let request = { | |
command: "format-msgs", | |
messages: result, | |
isWarning: kind === "warning" | |
}; | |
if (color !== void 0) | |
request.color = color; | |
if (terminalWidth !== void 0) | |
request.terminalWidth = terminalWidth; | |
sendRequest(refs, request, (error, response) => { | |
if (error) | |
return callback(new Error(error), null); | |
callback(null, response.messages); | |
}); | |
}; | |
return { | |
readFromStdout, | |
afterClose, | |
service: { | |
buildOrServe, | |
transform: transform22, | |
formatMessages: formatMessages22 | |
} | |
}; | |
} | |
function createObjectStash() { | |
const map = new Map(); | |
let nextID = 0; | |
return { | |
load(id) { | |
return map.get(id); | |
}, | |
store(value) { | |
if (value === void 0) | |
return -1; | |
const id = nextID++; | |
map.set(id, value); | |
return id; | |
} | |
}; | |
} | |
function extractCallerV8(e, streamIn, ident) { | |
let note; | |
let tried = false; | |
return () => { | |
if (tried) | |
return note; | |
tried = true; | |
try { | |
let lines = (e.stack + "").split("\n"); | |
lines.splice(1, 1); | |
let location = parseStackLinesV8(streamIn, lines, ident); | |
if (location) { | |
note = {text: e.message, location}; | |
return note; | |
} | |
} catch (e2) { | |
} | |
}; | |
} | |
function extractErrorMessageV8(e, streamIn, stash, note, pluginName) { | |
let text = "Internal error"; | |
let location = null; | |
try { | |
text = (e && e.message || e) + ""; | |
} catch (e2) { | |
} | |
try { | |
location = parseStackLinesV8(streamIn, (e.stack + "").split("\n"), ""); | |
} catch (e2) { | |
} | |
return {pluginName, text, location, notes: note ? [note] : [], detail: stash ? stash.store(e) : -1}; | |
} | |
function parseStackLinesV8(streamIn, lines, ident) { | |
let at = " at "; | |
if (streamIn.readFileSync && !lines[0].startsWith(at) && lines[1].startsWith(at)) { | |
for (let i = 1; i < lines.length; i++) { | |
let line = lines[i]; | |
if (!line.startsWith(at)) | |
continue; | |
line = line.slice(at.length); | |
while (true) { | |
let match = /^(?:new |async )?\S+ \((.*)\)$/.exec(line); | |
if (match) { | |
line = match[1]; | |
continue; | |
} | |
match = /^eval at \S+ \((.*)\)(?:, \S+:\d+:\d+)?$/.exec(line); | |
if (match) { | |
line = match[1]; | |
continue; | |
} | |
match = /^(\S+):(\d+):(\d+)$/.exec(line); | |
if (match) { | |
let contents; | |
try { | |
contents = streamIn.readFileSync(match[1], "utf8"); | |
} catch (e) { | |
break; | |
} | |
let lineText = contents.split(/\r\n|\r|\n|\u2028|\u2029/)[+match[2] - 1] || ""; | |
let column = +match[3] - 1; | |
let length = lineText.slice(column, column + ident.length) === ident ? ident.length : 0; | |
return { | |
file: match[1], | |
namespace: "file", | |
line: +match[2], | |
column: encodeUTF8(lineText.slice(0, column)).length, | |
length: encodeUTF8(lineText.slice(column, column + length)).length, | |
lineText: lineText + "\n" + lines.slice(1).join("\n"), | |
suggestion: "" | |
}; | |
} | |
break; | |
} | |
} | |
} | |
return null; | |
} | |
function failureErrorWithLog(text, errors, warnings) { | |
let limit = 5; | |
let summary = errors.length < 1 ? "" : ` with ${errors.length} error${errors.length < 2 ? "" : "s"}:` + errors.slice(0, limit + 1).map((e, i) => { | |
if (i === limit) | |
return "\n..."; | |
if (!e.location) | |
return ` | |
error: ${e.text}`; | |
let {file, line, column} = e.location; | |
let pluginText = e.pluginName ? `[plugin: ${e.pluginName}] ` : ""; | |
return ` | |
${file}:${line}:${column}: error: ${pluginText}${e.text}`; | |
}).join(""); | |
let error = new Error(`${text}${summary}`); | |
error.errors = errors; | |
error.warnings = warnings; | |
return error; | |
} | |
function replaceDetailsInMessages(messages, stash) { | |
for (const message of messages) { | |
message.detail = stash.load(message.detail); | |
} | |
return messages; | |
} | |
function sanitizeLocation(location, where) { | |
if (location == null) | |
return null; | |
let keys = {}; | |
let file = getFlag(location, keys, "file", mustBeString); | |
let namespace = getFlag(location, keys, "namespace", mustBeString); | |
let line = getFlag(location, keys, "line", mustBeInteger); | |
let column = getFlag(location, keys, "column", mustBeInteger); | |
let length = getFlag(location, keys, "length", mustBeInteger); | |
let lineText = getFlag(location, keys, "lineText", mustBeString); | |
let suggestion = getFlag(location, keys, "suggestion", mustBeString); | |
checkForInvalidFlags(location, keys, where); | |
return { | |
file: file || "", | |
namespace: namespace || "", | |
line: line || 0, | |
column: column || 0, | |
length: length || 0, | |
lineText: lineText || "", | |
suggestion: suggestion || "" | |
}; | |
} | |
function sanitizeMessages(messages, property, stash, fallbackPluginName) { | |
let messagesClone = []; | |
let index = 0; | |
for (const message of messages) { | |
let keys = {}; | |
let pluginName = getFlag(message, keys, "pluginName", mustBeString); | |
let text = getFlag(message, keys, "text", mustBeString); | |
let location = getFlag(message, keys, "location", mustBeObjectOrNull); | |
let notes = getFlag(message, keys, "notes", mustBeArray); | |
let detail = getFlag(message, keys, "detail", canBeAnything); | |
let where = `in element ${index} of "${property}"`; | |
checkForInvalidFlags(message, keys, where); | |
let notesClone = []; | |
if (notes) { | |
for (const note of notes) { | |
let noteKeys = {}; | |
let noteText = getFlag(note, noteKeys, "text", mustBeString); | |
let noteLocation = getFlag(note, noteKeys, "location", mustBeObjectOrNull); | |
checkForInvalidFlags(note, noteKeys, where); | |
notesClone.push({ | |
text: noteText || "", | |
location: sanitizeLocation(noteLocation, where) | |
}); | |
} | |
} | |
messagesClone.push({ | |
pluginName: pluginName || fallbackPluginName, | |
text: text || "", | |
location: sanitizeLocation(location, where), | |
notes: notesClone, | |
detail: stash ? stash.store(detail) : -1 | |
}); | |
index++; | |
} | |
return messagesClone; | |
} | |
function sanitizeStringArray(values, property) { | |
const result = []; | |
for (const value of values) { | |
if (typeof value !== "string") | |
throw new Error(`${JSON.stringify(property)} must be an array of strings`); | |
result.push(value); | |
} | |
return result; | |
} | |
function convertOutputFiles({path, contents}) { | |
let text = null; | |
return { | |
path, | |
contents, | |
get text() { | |
if (text === null) | |
text = decodeUTF8(contents); | |
return text; | |
} | |
}; | |
} | |
var version2 = "0.11.19"; | |
var build2 = (options) => ensureServiceIsRunning().build(options); | |
var serve2 = () => { | |
throw new Error(`The "serve" API only works in node`); | |
}; | |
var transform2 = (input, options) => ensureServiceIsRunning().transform(input, options); | |
var formatMessages2 = (messages, options) => ensureServiceIsRunning().formatMessages(messages, options); | |
var buildSync2 = () => { | |
throw new Error(`The "buildSync" API only works in node`); | |
}; | |
var transformSync2 = () => { | |
throw new Error(`The "transformSync" API only works in node`); | |
}; | |
var formatMessagesSync2 = () => { | |
throw new Error(`The "formatMessagesSync" API only works in node`); | |
}; | |
var initializePromise; | |
var longLivedService; | |
var ensureServiceIsRunning = () => { | |
if (longLivedService) | |
return longLivedService; | |
if (initializePromise) | |
throw new Error('You need to wait for the promise returned from "initialize" to be resolved before calling this'); | |
throw new Error('You need to call "initialize" before calling this'); | |
}; | |
var initialize2 = (options) => { | |
options = validateInitializeOptions(options || {}); | |
let wasmURL = options.wasmURL; | |
let useWorker = options.worker !== false; | |
if (!wasmURL) | |
throw new Error('Must provide the "wasmURL" option'); | |
wasmURL += ""; | |
if (initializePromise) | |
throw new Error('Cannot call "initialize" more than once'); | |
initializePromise = startRunningService(wasmURL, useWorker); | |
initializePromise.catch(() => { | |
initializePromise = void 0; | |
}); | |
return initializePromise; | |
}; | |
var startRunningService = (wasmURL, useWorker) => __async(void 0, null, function* () { | |
let res = yield fetch(wasmURL); | |
if (!res.ok) | |
throw new Error(`Failed to download ${JSON.stringify(wasmURL)}`); | |
let wasm = yield res.arrayBuffer(); | |
let fn = (postMessage) => { | |
{let global={};for(let o=self;o;o=Object.getPrototypeOf(o))for(let k of Object.getOwnPropertyNames(o))if(!(k in global))Object.defineProperty(global,k,{get:()=>self[k]});// Copyright 2018 The Go Authors. All rights reserved. | |
// Use of this source code is governed by a BSD-style | |
// license that can be found in the LICENSE file. | |
(() => { | |
// Map multiple JavaScript environments to a single common API, | |
// preferring web standards over Node.js API. | |
// | |
// Environments considered: | |
// - Browsers | |
// - Node.js | |
// - Electron | |
// - Parcel | |
// - Webpack | |
if (typeof global !== "undefined") { | |
// global already exists | |
} else if (typeof window !== "undefined") { | |
window.global = window; | |
} else if (typeof self !== "undefined") { | |
self.global = self; | |
} else { | |
throw new Error("cannot export Go (neither global, window nor self is defined)"); | |
} | |
if (!global.require && typeof require !== "undefined") { | |
global.require = require; | |
} | |
if (!global.fs && global.require) { | |
const fs = require("fs"); | |
if (typeof fs === "object" && fs !== null && Object.keys(fs).length !== 0) { | |
global.fs = Object.assign({}, fs, { | |
// Hack around a Unicode bug in node: https://github.com/nodejs/node/issues/24550 | |
write(fd, buf, offset, length, position, callback) { | |
if (offset === 0 && length === buf.length && position === null) { | |
if (fd === process.stdout.fd) { | |
try { | |
process.stdout.write(buf, err => err ? callback(err, 0, null) : callback(null, length, buf)); | |
} catch (err) { | |
callback(err, 0, null); | |
} | |
return; | |
} | |
if (fd === process.stderr.fd) { | |
try { | |
process.stderr.write(buf, err => err ? callback(err, 0, null) : callback(null, length, buf)); | |
} catch (err) { | |
callback(err, 0, null); | |
} | |
return; | |
} | |
} | |
fs.write(fd, buf, offset, length, position, callback); | |
}, | |
}); | |
} | |
} | |
const enosys = () => { | |
const err = new Error("not implemented"); | |
err.code = "ENOSYS"; | |
return err; | |
}; | |
if (!global.fs) { | |
let outputBuf = ""; | |
global.fs = { | |
constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 }, // unused | |
writeSync(fd, buf) { | |
outputBuf += decoder.decode(buf); | |
const nl = outputBuf.lastIndexOf("\n"); | |
if (nl != -1) { | |
console.log(outputBuf.substr(0, nl)); | |
outputBuf = outputBuf.substr(nl + 1); | |
} | |
return buf.length; | |
}, | |
write(fd, buf, offset, length, position, callback) { | |
if (offset !== 0 || length !== buf.length || position !== null) { | |
callback(enosys()); | |
return; | |
} | |
const n = this.writeSync(fd, buf); | |
callback(null, n); | |
}, | |
chmod(path, mode, callback) { callback(enosys()); }, | |
chown(path, uid, gid, callback) { callback(enosys()); }, | |
close(fd, callback) { callback(enosys()); }, | |
fchmod(fd, mode, callback) { callback(enosys()); }, | |
fchown(fd, uid, gid, callback) { callback(enosys()); }, | |
fstat(fd, callback) { callback(enosys()); }, | |
fsync(fd, callback) { callback(null); }, | |
ftruncate(fd, length, callback) { callback(enosys()); }, | |
lchown(path, uid, gid, callback) { callback(enosys()); }, | |
link(path, link, callback) { callback(enosys()); }, | |
lstat(path, callback) { callback(enosys()); }, | |
mkdir(path, perm, callback) { callback(enosys()); }, | |
open(path, flags, mode, callback) { callback(enosys()); }, | |
read(fd, buffer, offset, length, position, callback) { callback(enosys()); }, | |
readdir(path, callback) { callback(enosys()); }, | |
readlink(path, callback) { callback(enosys()); }, | |
rename(from, to, callback) { callback(enosys()); }, | |
rmdir(path, callback) { callback(enosys()); }, | |
stat(path, callback) { callback(enosys()); }, | |
symlink(path, link, callback) { callback(enosys()); }, | |
truncate(path, length, callback) { callback(enosys()); }, | |
unlink(path, callback) { callback(enosys()); }, | |
utimes(path, atime, mtime, callback) { callback(enosys()); }, | |
}; | |
} | |
if (!global.process) { | |
global.process = { | |
getuid() { return -1; }, | |
getgid() { return -1; }, | |
geteuid() { return -1; }, | |
getegid() { return -1; }, | |
getgroups() { throw enosys(); }, | |
pid: -1, | |
ppid: -1, | |
umask() { throw enosys(); }, | |
cwd() { throw enosys(); }, | |
chdir() { throw enosys(); }, | |
} | |
} | |
if (!global.crypto && global.require) { | |
const nodeCrypto = require("crypto"); | |
global.crypto = { | |
getRandomValues(b) { | |
nodeCrypto.randomFillSync(b); | |
}, | |
}; | |
} | |
if (!global.crypto) { | |
throw new Error("global.crypto is not available, polyfill required (getRandomValues only)"); | |
} | |
if (!global.performance) { | |
global.performance = { | |
now() { | |
const [sec, nsec] = process.hrtime(); | |
return sec * 1000 + nsec / 1000000; | |
}, | |
}; | |
} | |
if (!global.TextEncoder && global.require) { | |
global.TextEncoder = require("util").TextEncoder; | |
} | |
if (!global.TextEncoder) { | |
throw new Error("global.TextEncoder is not available, polyfill required"); | |
} | |
if (!global.TextDecoder && global.require) { | |
global.TextDecoder = require("util").TextDecoder; | |
} | |
if (!global.TextDecoder) { | |
throw new Error("global.TextDecoder is not available, polyfill required"); | |
} | |
// End of polyfills for common API. | |
const encoder = new TextEncoder("utf-8"); | |
const decoder = new TextDecoder("utf-8"); | |
global.Go = class { | |
constructor() { | |
this.argv = ["js"]; | |
this.env = {}; | |
this.exit = (code) => { | |
if (code !== 0) { | |
console.warn("exit code:", code); | |
} | |
}; | |
this._exitPromise = new Promise((resolve) => { | |
this._resolveExitPromise = resolve; | |
}); | |
this._pendingEvent = null; | |
this._scheduledTimeouts = new Map(); | |
this._nextCallbackTimeoutID = 1; | |
const setInt64 = (addr, v) => { | |
this.mem.setUint32(addr + 0, v, true); | |
this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true); | |
} | |
const getInt64 = (addr) => { | |
const low = this.mem.getUint32(addr + 0, true); | |
const high = this.mem.getInt32(addr + 4, true); | |
return low + high * 4294967296; | |
} | |
const loadValue = (addr) => { | |
const f = this.mem.getFloat64(addr, true); | |
if (f === 0) { | |
return undefined; | |
} | |
if (!isNaN(f)) { | |
return f; | |
} | |
const id = this.mem.getUint32(addr, true); | |
return this._values[id]; | |
} | |
const storeValue = (addr, v) => { | |
const nanHead = 0x7FF80000; | |
if (typeof v === "number" && v !== 0) { | |
if (isNaN(v)) { | |
this.mem.setUint32(addr + 4, nanHead, true); | |
this.mem.setUint32(addr, 0, true); | |
return; | |
} | |
this.mem.setFloat64(addr, v, true); | |
return; | |
} | |
if (v === undefined) { | |
this.mem.setFloat64(addr, 0, true); | |
return; | |
} | |
let id = this._ids.get(v); | |
if (id === undefined) { | |
id = this._idPool.pop(); | |
if (id === undefined) { | |
id = this._values.length; | |
} | |
this._values[id] = v; | |
this._goRefCounts[id] = 0; | |
this._ids.set(v, id); | |
} | |
this._goRefCounts[id]++; | |
let typeFlag = 0; | |
switch (typeof v) { | |
case "object": | |
if (v !== null) { | |
typeFlag = 1; | |
} | |
break; | |
case "string": | |
typeFlag = 2; | |
break; | |
case "symbol": | |
typeFlag = 3; | |
break; | |
case "function": | |
typeFlag = 4; | |
break; | |
} | |
this.mem.setUint32(addr + 4, nanHead | typeFlag, true); | |
this.mem.setUint32(addr, id, true); | |
} | |
const loadSlice = (addr) => { | |
const array = getInt64(addr + 0); | |
const len = getInt64(addr + 8); | |
return new Uint8Array(this._inst.exports.mem.buffer, array, len); | |
} | |
const loadSliceOfValues = (addr) => { | |
const array = getInt64(addr + 0); | |
const len = getInt64(addr + 8); | |
const a = new Array(len); | |
for (let i = 0; i < len; i++) { | |
a[i] = loadValue(array + i * 8); | |
} | |
return a; | |
} | |
const loadString = (addr) => { | |
const saddr = getInt64(addr + 0); | |
const len = getInt64(addr + 8); | |
return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len)); | |
} | |
const timeOrigin = Date.now() - performance.now(); | |
this.importObject = { | |
go: { | |
// Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters) | |
// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported | |
// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function). | |
// This changes the SP, thus we have to update the SP used by the imported function. | |
// func wasmExit(code int32) | |
"runtime.wasmExit": (sp) => { | |
sp >>>= 0; | |
const code = this.mem.getInt32(sp + 8, true); | |
this.exited = true; | |
delete this._inst; | |
delete this._values; | |
delete this._goRefCounts; | |
delete this._ids; | |
delete this._idPool; | |
this.exit(code); | |
}, | |
// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32) | |
"runtime.wasmWrite": (sp) => { | |
sp >>>= 0; | |
const fd = getInt64(sp + 8); | |
const p = getInt64(sp + 16); | |
const n = this.mem.getInt32(sp + 24, true); | |
fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n)); | |
}, | |
// func resetMemoryDataView() | |
"runtime.resetMemoryDataView": (sp) => { | |
sp >>>= 0; | |
this.mem = new DataView(this._inst.exports.mem.buffer); | |
}, | |
// func nanotime1() int64 | |
"runtime.nanotime1": (sp) => { | |
sp >>>= 0; | |
setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000); | |
}, | |
// func walltime1() (sec int64, nsec int32) | |
"runtime.walltime1": (sp) => { | |
sp >>>= 0; | |
const msec = (new Date).getTime(); | |
setInt64(sp + 8, msec / 1000); | |
this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true); | |
}, | |
// func scheduleTimeoutEvent(delay int64) int32 | |
"runtime.scheduleTimeoutEvent": (sp) => { | |
sp >>>= 0; | |
const id = this._nextCallbackTimeoutID; | |
this._nextCallbackTimeoutID++; | |
this._scheduledTimeouts.set(id, setTimeout( | |
() => { | |
this._resume(); | |
while (this._scheduledTimeouts.has(id)) { | |
// for some reason Go failed to register the timeout event, log and try again | |
// (temporary workaround for https://github.com/golang/go/issues/28975) | |
console.warn("scheduleTimeoutEvent: missed timeout event"); | |
this._resume(); | |
} | |
}, | |
getInt64(sp + 8) + 1, // setTimeout has been seen to fire up to 1 millisecond early | |
)); | |
this.mem.setInt32(sp + 16, id, true); | |
}, | |
// func clearTimeoutEvent(id int32) | |
"runtime.clearTimeoutEvent": (sp) => { | |
sp >>>= 0; | |
const id = this.mem.getInt32(sp + 8, true); | |
clearTimeout(this._scheduledTimeouts.get(id)); | |
this._scheduledTimeouts.delete(id); | |
}, | |
// func getRandomData(r []byte) | |
"runtime.getRandomData": (sp) => { | |
sp >>>= 0; | |
crypto.getRandomValues(loadSlice(sp + 8)); | |
}, | |
// func finalizeRef(v ref) | |
"syscall/js.finalizeRef": (sp) => { | |
sp >>>= 0; | |
const id = this.mem.getUint32(sp + 8, true); | |
this._goRefCounts[id]--; | |
if (this._goRefCounts[id] === 0) { | |
const v = this._values[id]; | |
this._values[id] = null; | |
this._ids.delete(v); | |
this._idPool.push(id); | |
} | |
}, | |
// func stringVal(value string) ref | |
"syscall/js.stringVal": (sp) => { | |
sp >>>= 0; | |
storeValue(sp + 24, loadString(sp + 8)); | |
}, | |
// func valueGet(v ref, p string) ref | |
"syscall/js.valueGet": (sp) => { | |
sp >>>= 0; | |
const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16)); | |
sp = this._inst.exports.getsp() >>> 0; // see comment above | |
storeValue(sp + 32, result); | |
}, | |
// func valueSet(v ref, p string, x ref) | |
"syscall/js.valueSet": (sp) => { | |
sp >>>= 0; | |
Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32)); | |
}, | |
// func valueDelete(v ref, p string) | |
"syscall/js.valueDelete": (sp) => { | |
sp >>>= 0; | |
Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16)); | |
}, | |
// func valueIndex(v ref, i int) ref | |
"syscall/js.valueIndex": (sp) => { | |
sp >>>= 0; | |
storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16))); | |
}, | |
// valueSetIndex(v ref, i int, x ref) | |
"syscall/js.valueSetIndex": (sp) => { | |
sp >>>= 0; | |
Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24)); | |
}, | |
// func valueCall(v ref, m string, args []ref) (ref, bool) | |
"syscall/js.valueCall": (sp) => { | |
sp >>>= 0; | |
try { | |
const v = loadValue(sp + 8); | |
const m = Reflect.get(v, loadString(sp + 16)); | |
const args = loadSliceOfValues(sp + 32); | |
const result = Reflect.apply(m, v, args); | |
sp = this._inst.exports.getsp() >>> 0; // see comment above | |
storeValue(sp + 56, result); | |
this.mem.setUint8(sp + 64, 1); | |
} catch (err) { | |
storeValue(sp + 56, err); | |
this.mem.setUint8(sp + 64, 0); | |
} | |
}, | |
// func valueInvoke(v ref, args []ref) (ref, bool) | |
"syscall/js.valueInvoke": (sp) => { | |
sp >>>= 0; | |
try { | |
const v = loadValue(sp + 8); | |
const args = loadSliceOfValues(sp + 16); | |
const result = Reflect.apply(v, undefined, args); | |
sp = this._inst.exports.getsp() >>> 0; // see comment above | |
storeValue(sp + 40, result); | |
this.mem.setUint8(sp + 48, 1); | |
} catch (err) { | |
storeValue(sp + 40, err); | |
this.mem.setUint8(sp + 48, 0); | |
} | |
}, | |
// func valueNew(v ref, args []ref) (ref, bool) | |
"syscall/js.valueNew": (sp) => { | |
sp >>>= 0; | |
try { | |
const v = loadValue(sp + 8); | |
const args = loadSliceOfValues(sp + 16); | |
const result = Reflect.construct(v, args); | |
sp = this._inst.exports.getsp() >>> 0; // see comment above | |
storeValue(sp + 40, result); | |
this.mem.setUint8(sp + 48, 1); | |
} catch (err) { | |
storeValue(sp + 40, err); | |
this.mem.setUint8(sp + 48, 0); | |
} | |
}, | |
// func valueLength(v ref) int | |
"syscall/js.valueLength": (sp) => { | |
sp >>>= 0; | |
setInt64(sp + 16, parseInt(loadValue(sp + 8).length)); | |
}, | |
// valuePrepareString(v ref) (ref, int) | |
"syscall/js.valuePrepareString": (sp) => { | |
sp >>>= 0; | |
const str = encoder.encode(String(loadValue(sp + 8))); | |
storeValue(sp + 16, str); | |
setInt64(sp + 24, str.length); | |
}, | |
// valueLoadString(v ref, b []byte) | |
"syscall/js.valueLoadString": (sp) => { | |
sp >>>= 0; | |
const str = loadValue(sp + 8); | |
loadSlice(sp + 16).set(str); | |
}, | |
// func valueInstanceOf(v ref, t ref) bool | |
"syscall/js.valueInstanceOf": (sp) => { | |
sp >>>= 0; | |
this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0); | |
}, | |
// func copyBytesToGo(dst []byte, src ref) (int, bool) | |
"syscall/js.copyBytesToGo": (sp) => { | |
sp >>>= 0; | |
const dst = loadSlice(sp + 8); | |
const src = loadValue(sp + 32); | |
if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) { | |
this.mem.setUint8(sp + 48, 0); | |
return; | |
} | |
const toCopy = src.subarray(0, dst.length); | |
dst.set(toCopy); | |
setInt64(sp + 40, toCopy.length); | |
this.mem.setUint8(sp + 48, 1); | |
}, | |
// func copyBytesToJS(dst ref, src []byte) (int, bool) | |
"syscall/js.copyBytesToJS": (sp) => { | |
sp >>>= 0; | |
const dst = loadValue(sp + 8); | |
const src = loadSlice(sp + 16); | |
if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) { | |
this.mem.setUint8(sp + 48, 0); | |
return; | |
} | |
const toCopy = src.subarray(0, dst.length); | |
dst.set(toCopy); | |
setInt64(sp + 40, toCopy.length); | |
this.mem.setUint8(sp + 48, 1); | |
}, | |
"debug": (value) => { | |
console.log(value); | |
}, | |
} | |
}; | |
} | |
async run(instance) { | |
if (!(instance instanceof WebAssembly.Instance)) { | |
throw new Error("Go.run: WebAssembly.Instance expected"); | |
} | |
this._inst = instance; | |
this.mem = new DataView(this._inst.exports.mem.buffer); | |
this._values = [ // JS values that Go currently has references to, indexed by reference id | |
NaN, | |
0, | |
null, | |
true, | |
false, | |
global, | |
this, | |
]; | |
this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id | |
this._ids = new Map([ // mapping from JS values to reference ids | |
[0, 1], | |
[null, 2], | |
[true, 3], | |
[false, 4], | |
[global, 5], | |
[this, 6], | |
]); | |
this._idPool = []; // unused ids that have been garbage collected | |
this.exited = false; // whether the Go program has exited | |
// Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory. | |
let offset = 4096; | |
const strPtr = (str) => { | |
const ptr = offset; | |
const bytes = encoder.encode(str + "\0"); | |
new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes); | |
offset += bytes.length; | |
if (offset % 8 !== 0) { | |
offset += 8 - (offset % 8); | |
} | |
return ptr; | |
}; | |
const argc = this.argv.length; | |
const argvPtrs = []; | |
this.argv.forEach((arg) => { | |
argvPtrs.push(strPtr(arg)); | |
}); | |
argvPtrs.push(0); | |
const keys = Object.keys(this.env).sort(); | |
keys.forEach((key) => { | |
argvPtrs.push(strPtr(`${key}=${this.env[key]}`)); | |
}); | |
argvPtrs.push(0); | |
const argv = offset; | |
argvPtrs.forEach((ptr) => { | |
this.mem.setUint32(offset, ptr, true); | |
this.mem.setUint32(offset + 4, 0, true); | |
offset += 8; | |
}); | |
this._inst.exports.run(argc, argv); | |
if (this.exited) { | |
this._resolveExitPromise(); | |
} | |
await this._exitPromise; | |
} | |
_resume() { | |
if (this.exited) { | |
throw new Error("Go program has already exited"); | |
} | |
this._inst.exports.resume(); | |
if (this.exited) { | |
this._resolveExitPromise(); | |
} | |
} | |
_makeFuncWrapper(id) { | |
const go = this; | |
return function () { | |
const event = { id: id, this: this, args: arguments }; | |
go._pendingEvent = event; | |
go._resume(); | |
return event.result; | |
}; | |
} | |
} | |
if ( | |
typeof module !== "undefined" && | |
global.require && | |
global.require.main === module && | |
global.process && | |
global.process.versions && | |
!global.process.versions.electron | |
) { | |
if (process.argv.length < 3) { | |
console.error("usage: go_js_wasm_exec [wasm binary] [arguments]"); | |
process.exit(1); | |
} | |
const go = new Go(); | |
go.argv = process.argv.slice(2); | |
go.env = Object.assign({ TMPDIR: require("os").tmpdir() }, process.env); | |
go.exit = process.exit; | |
WebAssembly.instantiate(fs.readFileSync(process.argv[2]), go.importObject).then((result) => { | |
process.on("exit", (code) => { // Node.js exits if no event handler is pending | |
if (code === 0 && !go.exited) { | |
// deadlock, make Go print error and stack traces | |
go._pendingEvent = { id: 0 }; | |
go._resume(); | |
} | |
}); | |
return go.run(result.instance); | |
}).catch((err) => { | |
console.error(err); | |
process.exit(1); | |
}); | |
} | |
})(); | |
onmessage = ({data: wasm}) => { | |
let decoder = new TextDecoder(); | |
let fs = global.fs; | |
let stderr = ""; | |
fs.writeSync = (fd, buffer) => { | |
if (fd === 1) { | |
postMessage(buffer); | |
} else if (fd === 2) { | |
stderr += decoder.decode(buffer); | |
let parts = stderr.split("\n"); | |
if (parts.length > 1) | |
console.log(parts.slice(0, -1).join("\n")); | |
stderr = parts[parts.length - 1]; | |
console.warn(stderr); | |
} else { | |
throw new Error("Bad write"); | |
} | |
return buffer.length; | |
}; | |
let stdin = []; | |
let resumeStdin; | |
let stdinPos = 0; | |
onmessage = ({data}) => { | |
if (data.length > 0) { | |
stdin.push(data); | |
if (resumeStdin) | |
resumeStdin(); | |
} | |
}; | |
fs.read = (fd, buffer, offset, length, position, callback) => { | |
if (fd !== 0 || offset !== 0 || length !== buffer.length || position !== null) { | |
throw new Error("Bad read"); | |
} | |
if (stdin.length === 0) { | |
resumeStdin = () => fs.read(fd, buffer, offset, length, position, callback); | |
return; | |
} | |
let first = stdin[0]; | |
let count = Math.max(0, Math.min(length, first.length - stdinPos)); | |
buffer.set(first.subarray(stdinPos, stdinPos + count), offset); | |
stdinPos += count; | |
if (stdinPos === first.length) { | |
stdin.shift(); | |
stdinPos = 0; | |
} | |
callback(null, count); | |
}; | |
let go = new global.Go(); | |
go.argv = ["", `--service=0.11.19`]; | |
WebAssembly.instantiate(wasm, go.importObject).then(({instance}) => go.run(instance)); | |
};} | |
var onmessage; return m => onmessage(m) | |
}; | |
let worker; | |
if (useWorker) { | |
let blob = new Blob([code], {type: "text/javascript"}); | |
worker = new Worker(URL.createObjectURL(blob), { type: "module" }); | |
} else { | |
let onmessage = fn((data) => worker.onmessage({data})); | |
worker = { | |
onmessage: null, | |
postMessage: (data) => onmessage({data}), | |
terminate() { | |
} | |
}; | |
} | |
worker.postMessage(wasm); | |
worker.onmessage = ({data}) => readFromStdout(data); | |
let {readFromStdout, service} = createChannel({ | |
writeToStdin(bytes) { | |
worker.postMessage(bytes); | |
}, | |
isSync: false, | |
isBrowser: true | |
}); | |
longLivedService = { | |
build: (options) => new Promise((resolve, reject) => service.buildOrServe({ | |
callName: "build", | |
refs: null, | |
serveOptions: null, | |
options, | |
isTTY: false, | |
defaultWD: "/", | |
callback: (err, res2) => err ? reject(err) : resolve(res2) | |
})), | |
transform: (input, options) => new Promise((resolve, reject) => service.transform({ | |
callName: "transform", | |
refs: null, | |
input, | |
options: options || {}, | |
isTTY: false, | |
fs: { | |
readFile(_, callback) { | |
callback(new Error("Internal error"), null); | |
}, | |
writeFile(_, callback) { | |
callback(null); | |
} | |
}, | |
callback: (err, res2) => err ? reject(err) : resolve(res2) | |
})), | |
formatMessages: (messages, options) => new Promise((resolve, reject) => service.formatMessages({ | |
callName: "formatMessages", | |
refs: null, | |
messages, | |
options, | |
callback: (err, res2) => err ? reject(err) : resolve(res2) | |
})) | |
}; | |
}); | |
})(exports); | |
}); | |
var __pika_web_default_export_for_treeshaking__ = /* @__PURE__ */ getDefaultExportFromCjs(browser); | |
var build = browser.build; | |
var buildSync = browser.buildSync; | |
export default __pika_web_default_export_for_treeshaking__; | |
var formatMessages = browser.formatMessages; | |
var formatMessagesSync = browser.formatMessagesSync; | |
var initialize = browser.initialize; | |
var serve = browser.serve; | |
var transform = browser.transform; | |
var transformSync = browser.transformSync; | |
var version = browser.version; | |
export {browser as __moduleExports, build, buildSync, formatMessages, formatMessagesSync, initialize, serve, transform, transformSync, version}; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment