name

Text2Dia

description

Convert text / code to diagrams and diagrams back to text. Supports Math (tex), Mermaid, PlantUML etc.

icon

sync_alt

instructions

This plugin allows users to easily convert text to diagrams and diagrams back to text. It supports various diagram types including Math (tex), Mermaid, PlantUML, Graphviz, etc.

To convert text to diagrams, select the "Convert to Dia" menu after selecting some text:



To convert diagram back to text, use the "Convert to Text" menu:



The plugin also has tight integration for math. You can also create diagram using an {expression}.


linkText2Dia (v1.0.5)


linkCode

/***
* Source Code: https://github.com/debanjandhar12/my-amplenote-plugins-v2
* Author: debajandhar12
* Build: production
* Character Count: 60850 (0.061 M)
* Target Folder: src-text2dia
***/
(() => {
// node-modules-polyfills:buffer
var exports$3 = {}, _dewExec$2 = !1;
function dew$2() {
if (_dewExec$2) return exports$3;
_dewExec$2 = !0, exports$3.byteLength = byteLength, exports$3.toByteArray = toByteArray, exports$3.fromByteArray = fromByteArray;
for (var lookup = [], revLookup = [], Arr = typeof Uint8Array != "undefined" ? Uint8Array : Array, code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i = 0, len = code.length; i < len; ++i)
lookup[i] = code[i], revLookup[code.charCodeAt(i)] = i;
revLookup[45] = 62, revLookup[95] = 63;
function getLens(b64) {
var len2 = b64.length;
if (len2 % 4 > 0)
throw new Error("Invalid string. Length must be a multiple of 4");
var validLen = b64.indexOf("=");
validLen === -1 && (validLen = len2);
var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
return [validLen, placeHoldersLen];
}
function byteLength(b64) {
var lens = getLens(b64), validLen = lens[0], placeHoldersLen = lens[1];
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
function _byteLength(b64, validLen, placeHoldersLen) {
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
function toByteArray(b64) {
var tmp, lens = getLens(b64), validLen = lens[0], placeHoldersLen = lens[1], arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)), curByte = 0, len2 = placeHoldersLen > 0 ? validLen - 4 : validLen, i2;
for (i2 = 0; i2 < len2; i2 += 4)
tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)], arr[curByte++] = tmp >> 16 & 255, arr[curByte++] = tmp >> 8 & 255, arr[curByte++] = tmp & 255;
return placeHoldersLen === 2 && (tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4, arr[curByte++] = tmp & 255), placeHoldersLen === 1 && (tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2, arr[curByte++] = tmp >> 8 & 255, arr[curByte++] = tmp & 255), 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) {
for (var tmp, output = [], i2 = start; i2 < end; i2 += 3)
tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255), output.push(tripletToBase64(tmp));
return output.join("");
}
function fromByteArray(uint8) {
for (var tmp, len2 = uint8.length, extraBytes = len2 % 3, parts = [], maxChunkLength = 16383, i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength)
parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
return extraBytes === 1 ? (tmp = uint8[len2 - 1], parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==")) : extraBytes === 2 && (tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1], parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=")), parts.join("");
}
return exports$3;
}
var exports$2 = {}, _dewExec$1 = !1;
function dew$1() {
if (_dewExec$1) return exports$2;
_dewExec$1 = !0;
return exports$2.read = function(buffer, offset, isLE, mLen, nBytes) {
var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer[offset + i];
for (i += d, e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8)
;
for (m = e & (1 << -nBits) - 1, e >>= -nBits, nBits += mLen; 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) * (1 / 0);
m = m + Math.pow(2, mLen), e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
}, exports$2.write = function(buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, i = isLE ? 0 : nBytes - 1, d = isLE ? 1 : -1, s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
for (value = Math.abs(value), isNaN(value) || value === 1 / 0 ? (m = isNaN(value) ? 1 : 0, e = eMax) : (e = Math.floor(Math.log(value) / Math.LN2), value * (c = Math.pow(2, -e)) < 1 && (e--, c *= 2), e + eBias >= 1 ? value += rt / c : value += rt * Math.pow(2, 1 - eBias), value * c >= 2 && (e++, c /= 2), e + eBias >= eMax ? (m = 0, e = eMax) : e + eBias >= 1 ? (m = (value * c - 1) * Math.pow(2, mLen), e = e + eBias) : (m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen), e = 0)); mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8)
;
for (e = e << mLen | m, eLen += mLen; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8)
;
buffer[offset + i - d] |= s * 128;
}, exports$2;
}
var exports$1 = {}, _dewExec = !1;
function dew() {
if (_dewExec) return exports$1;
_dewExec = !0;
let base64 = dew$2(), ieee754 = dew$1(), customInspectSymbol = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
exports$1.Buffer = Buffer2, exports$1.SlowBuffer = SlowBuffer, exports$1.INSPECT_MAX_BYTES = 50;
let K_MAX_LENGTH = 2147483647;
exports$1.kMaxLength = K_MAX_LENGTH, Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport(), !Buffer2.TYPED_ARRAY_SUPPORT && typeof console != "undefined" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
function typedArraySupport() {
try {
let arr = new Uint8Array(1), proto = {
foo: function() {
return 42;
}
};
return Object.setPrototypeOf(proto, Uint8Array.prototype), Object.setPrototypeOf(arr, proto), arr.foo() === 42;
} catch {
return !1;
}
}
Object.defineProperty(Buffer2.prototype, "parent", {
enumerable: !0,
get: function() {
if (Buffer2.isBuffer(this))
return this.buffer;
}
}), Object.defineProperty(Buffer2.prototype, "offset", {
enumerable: !0,
get: function() {
if (Buffer2.isBuffer(this))
return this.byteOffset;
}
});
function createBuffer(length) {
if (length > K_MAX_LENGTH)
throw new RangeError('The value "' + length + '" is invalid for option "size"');
let buf = new Uint8Array(length);
return Object.setPrototypeOf(buf, Buffer2.prototype), buf;
}
function Buffer2(arg, encodingOrOffset, length) {
if (typeof arg == "number") {
if (typeof encodingOrOffset == "string")
throw new TypeError('The "string" argument must be of type string. Received type number');
return allocUnsafe(arg);
}
return from(arg, encodingOrOffset, length);
}
Buffer2.poolSize = 8192;
function from(value, encodingOrOffset, length) {
if (typeof value == "string")
return fromString(value, encodingOrOffset);
if (ArrayBuffer.isView(value))
return fromArrayView(value);
if (value == null)
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer) || typeof SharedArrayBuffer != "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer)))
return fromArrayBuffer(value, encodingOrOffset, length);
if (typeof value == "number")
throw new TypeError('The "value" argument must not be of type number. Received type number');
let valueOf = value.valueOf && value.valueOf();
if (valueOf != null && valueOf !== value)
return Buffer2.from(valueOf, encodingOrOffset, length);
let b = fromObject(value);
if (b) return b;
if (typeof Symbol != "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] == "function")
return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
}
Buffer2.from = function(value, encodingOrOffset, length) {
return from(value, encodingOrOffset, length);
}, Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype), Object.setPrototypeOf(Buffer2, Uint8Array);
function assertSize(size) {
if (typeof size != "number")
throw new TypeError('"size" argument must be of type number');
if (size < 0)
throw new RangeError('The value "' + size + '" is invalid for option "size"');
}
function alloc(size, fill, encoding) {
return assertSize(size), size <= 0 ? createBuffer(size) : fill !== void 0 ? typeof encoding == "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill) : createBuffer(size);
}
Buffer2.alloc = function(size, fill, encoding) {
return alloc(size, fill, encoding);
};
function allocUnsafe(size) {
return assertSize(size), createBuffer(size < 0 ? 0 : checked(size) | 0);
}
Buffer2.allocUnsafe = function(size) {
return allocUnsafe(size);
}, Buffer2.allocUnsafeSlow = function(size) {
return allocUnsafe(size);
};
function fromString(string, encoding) {
if ((typeof encoding != "string" || encoding === "") && (encoding = "utf8"), !Buffer2.isEncoding(encoding))
throw new TypeError("Unknown encoding: " + encoding);
let length = byteLength(string, encoding) | 0, buf = createBuffer(length), actual = buf.write(string, encoding);
return actual !== length && (buf = buf.slice(0, actual)), buf;
}
function fromArrayLike(array) {
let length = array.length < 0 ? 0 : checked(array.length) | 0, buf = createBuffer(length);
for (let i = 0; i < length; i += 1)
buf[i] = array[i] & 255;
return buf;
}
function fromArrayView(arrayView) {
if (isInstance(arrayView, Uint8Array)) {
let copy = new Uint8Array(arrayView);
return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
}
return fromArrayLike(arrayView);
}
function fromArrayBuffer(array, byteOffset, length) {
if (byteOffset < 0 || array.byteLength < byteOffset)
throw new RangeError('"offset" is outside of buffer bounds');
if (array.byteLength < byteOffset + (length || 0))
throw new RangeError('"length" is outside of buffer bounds');
let buf;
return byteOffset === void 0 && length === void 0 ? buf = new Uint8Array(array) : length === void 0 ? buf = new Uint8Array(array, byteOffset) : buf = new Uint8Array(array, byteOffset, length), Object.setPrototypeOf(buf, Buffer2.prototype), buf;
}
function fromObject(obj) {
if (Buffer2.isBuffer(obj)) {
let len = checked(obj.length) | 0, buf = createBuffer(len);
return buf.length === 0 || obj.copy(buf, 0, 0, len), buf;
}
if (obj.length !== void 0)
return typeof obj.length != "number" || numberIsNaN(obj.length) ? createBuffer(0) : fromArrayLike(obj);
if (obj.type === "Buffer" && Array.isArray(obj.data))
return fromArrayLike(obj.data);
}
function checked(length) {
if (length >= K_MAX_LENGTH)
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
return length | 0;
}
function SlowBuffer(length) {
return +length != length && (length = 0), Buffer2.alloc(+length);
}
Buffer2.isBuffer = function(b) {
return b != null && b._isBuffer === !0 && b !== Buffer2.prototype;
}, Buffer2.compare = function(a, b) {
if (isInstance(a, Uint8Array) && (a = Buffer2.from(a, a.offset, a.byteLength)), isInstance(b, Uint8Array) && (b = Buffer2.from(b, b.offset, b.byteLength)), !Buffer2.isBuffer(a) || !Buffer2.isBuffer(b))
throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
if (a === b) return 0;
let x = a.length, y = b.length;
for (let i = 0, len = Math.min(x, y); i < len; ++i)
if (a[i] !== b[i]) {
x = a[i], y = b[i];
break;
}
return x < y ? -1 : y < x ? 1 : 0;
}, Buffer2.isEncoding = function(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 !0;
default:
return !1;
}
}, Buffer2.concat = function(list, length) {
if (!Array.isArray(list))
throw new TypeError('"list" argument must be an Array of Buffers');
if (list.length === 0)
return Buffer2.alloc(0);
let i;
if (length === void 0)
for (length = 0, i = 0; i < list.length; ++i)
length += list[i].length;
let buffer = Buffer2.allocUnsafe(length), pos = 0;
for (i = 0; i < list.length; ++i) {
let buf = list[i];
if (isInstance(buf, Uint8Array))
pos + buf.length > buffer.length ? (Buffer2.isBuffer(buf) || (buf = Buffer2.from(buf)), buf.copy(buffer, pos)) : Uint8Array.prototype.set.call(buffer, buf, pos);
else if (Buffer2.isBuffer(buf))
buf.copy(buffer, pos);
else
throw new TypeError('"list" argument must be an Array of Buffers');
pos += buf.length;
}
return buffer;
};
function byteLength(string, encoding) {
if (Buffer2.isBuffer(string))
return string.length;
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer))
return string.byteLength;
if (typeof string != "string")
throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
let len = string.length, mustMatch = arguments.length > 2 && arguments[2] === !0;
if (!mustMatch && len === 0) return 0;
let loweredCase = !1;
for (; ; )
switch (encoding) {
case "ascii":
case "latin1":
case "binary":
return len;
case "utf8":
case "utf-8":
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 mustMatch ? -1 : utf8ToBytes(string).length;
encoding = ("" + encoding).toLowerCase(), loweredCase = !0;
}
}
Buffer2.byteLength = byteLength;
function slowToString(encoding, start, end) {
let loweredCase = !1;
if ((start === void 0 || start < 0) && (start = 0), start > this.length || ((end === void 0 || end > this.length) && (end = this.length), end <= 0) || (end >>>= 0, start >>>= 0, end <= start))
return "";
for (encoding || (encoding = "utf8"); ; )
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 = !0;
}
}
Buffer2.prototype._isBuffer = !0;
function swap(b, n, m) {
let i = b[n];
b[n] = b[m], b[m] = i;
}
Buffer2.prototype.swap16 = function() {
let len = this.length;
if (len % 2 !== 0)
throw new RangeError("Buffer size must be a multiple of 16-bits");
for (let i = 0; i < len; i += 2)
swap(this, i, i + 1);
return this;
}, Buffer2.prototype.swap32 = function() {
let len = this.length;
if (len % 4 !== 0)
throw new RangeError("Buffer size must be a multiple of 32-bits");
for (let i = 0; i < len; i += 4)
swap(this, i, i + 3), swap(this, i + 1, i + 2);
return this;
}, Buffer2.prototype.swap64 = function() {
let len = this.length;
if (len % 8 !== 0)
throw new RangeError("Buffer size must be a multiple of 64-bits");
for (let 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;
}, Buffer2.prototype.toString = function() {
let length = this.length;
return length === 0 ? "" : arguments.length === 0 ? utf8Slice(this, 0, length) : slowToString.apply(this, arguments);
}, Buffer2.prototype.toLocaleString = Buffer2.prototype.toString, Buffer2.prototype.equals = function(b) {
if (!Buffer2.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
return this === b ? !0 : Buffer2.compare(this, b) === 0;
}, Buffer2.prototype.inspect = function() {
let str = "", max = exports$1.INSPECT_MAX_BYTES;
return str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(), this.length > max && (str += " ... "), "<Buffer " + str + ">";
}, customInspectSymbol && (Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect), Buffer2.prototype.compare = function(target, start, end, thisStart, thisEnd) {
if (isInstance(target, Uint8Array) && (target = Buffer2.from(target, target.offset, target.byteLength)), !Buffer2.isBuffer(target))
throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
if (start === void 0 && (start = 0), end === void 0 && (end = target ? target.length : 0), thisStart === void 0 && (thisStart = 0), thisEnd === void 0 && (thisEnd = this.length), 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;
if (start >>>= 0, end >>>= 0, thisStart >>>= 0, thisEnd >>>= 0, this === target) return 0;
let x = thisEnd - thisStart, y = end - start, len = Math.min(x, y), thisCopy = this.slice(thisStart, thisEnd), targetCopy = target.slice(start, end);
for (let i = 0; i < len; ++i)
if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i], y = targetCopy[i];
break;
}
return x < y ? -1 : y < x ? 1 : 0;
};
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
if (buffer.length === 0) return -1;
if (typeof byteOffset == "string" ? (encoding = byteOffset, byteOffset = 0) : byteOffset > 2147483647 ? byteOffset = 2147483647 : byteOffset < -2147483648 && (byteOffset = -2147483648), byteOffset = +byteOffset, numberIsNaN(byteOffset) && (byteOffset = dir ? 0 : buffer.length - 1), byteOffset < 0 && (byteOffset = buffer.length + byteOffset), byteOffset >= buffer.length) {
if (dir) return -1;
byteOffset = buffer.length - 1;
} else if (byteOffset < 0)
if (dir) byteOffset = 0;
else return -1;
if (typeof val == "string" && (val = Buffer2.from(val, encoding)), Buffer2.isBuffer(val))
return val.length === 0 ? -1 : arrayIndexOf(buffer, val, byteOffset, encoding, dir);
if (typeof val == "number")
return val = val & 255, typeof Uint8Array.prototype.indexOf == "function" ? dir ? Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) : Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) : arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
throw new TypeError("val must be string, number or Buffer");
}
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
let indexSize = 1, arrLength = arr.length, valLength = val.length;
if (encoding !== void 0 && (encoding = String(encoding).toLowerCase(), 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 read(buf, i2) {
return indexSize === 1 ? buf[i2] : buf.readUInt16BE(i2 * indexSize);
}
let i;
if (dir) {
let foundIndex = -1;
for (i = byteOffset; i < arrLength; i++)
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1 && (foundIndex = i), i - foundIndex + 1 === valLength) return foundIndex * indexSize;
} else
foundIndex !== -1 && (i -= i - foundIndex), foundIndex = -1;
} else
for (byteOffset + valLength > arrLength && (byteOffset = arrLength - valLength), i = byteOffset; i >= 0; i--) {
let found = !0;
for (let j = 0; j < valLength; j++)
if (read(arr, i + j) !== read(val, j)) {
found = !1;
break;
}
if (found) return i;
}
return -1;
}
Buffer2.prototype.includes = function(val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1;
}, Buffer2.prototype.indexOf = function(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, !0);
}, Buffer2.prototype.lastIndexOf = function(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, !1);
};
function hexWrite(buf, string, offset, length) {
offset = Number(offset) || 0;
let remaining = buf.length - offset;
length ? (length = Number(length), length > remaining && (length = remaining)) : length = remaining;
let strLen = string.length;
length > strLen / 2 && (length = strLen / 2);
let i;
for (i = 0; i < length; ++i) {
let parsed = parseInt(string.substr(i * 2, 2), 16);
if (numberIsNaN(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 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);
}
Buffer2.prototype.write = function(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, isFinite(length) ? (length = length >>> 0, encoding === void 0 && (encoding = "utf8")) : (encoding = length, length = void 0);
else
throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
let remaining = this.length - offset;
if ((length === void 0 || length > remaining) && (length = remaining), string.length > 0 && (length < 0 || offset < 0) || offset > this.length)
throw new RangeError("Attempt to write outside buffer bounds");
encoding || (encoding = "utf8");
let loweredCase = !1;
for (; ; )
switch (encoding) {
case "hex":
return hexWrite(this, string, offset, length);
case "utf8":
case "utf-8":
return utf8Write(this, string, offset, length);
case "ascii":
case "latin1":
case "binary":
return asciiWrite(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 = !0;
}
}, Buffer2.prototype.toJSON = function() {
return {
type: "Buffer",
data: Array.prototype.slice.call(this._arr || this, 0)
};
};
function base64Slice(buf, start, end) {
return start === 0 && end === buf.length ? base64.fromByteArray(buf) : base64.fromByteArray(buf.slice(start, end));
}
function utf8Slice(buf, start, end) {
end = Math.min(buf.length, end);
let res = [], i = start;
for (; i < end; ) {
let firstByte = buf[i], codePoint = null, bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
if (i + bytesPerSequence <= end) {
let secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
firstByte < 128 && (codePoint = firstByte);
break;
case 2:
secondByte = buf[i + 1], (secondByte & 192) === 128 && (tempCodePoint = (firstByte & 31) << 6 | secondByte & 63, tempCodePoint > 127 && (codePoint = tempCodePoint));
break;
case 3:
secondByte = buf[i + 1], thirdByte = buf[i + 2], (secondByte & 192) === 128 && (thirdByte & 192) === 128 && (tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63, tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343) && (codePoint = tempCodePoint));
break;
case 4:
secondByte = buf[i + 1], thirdByte = buf[i + 2], fourthByte = buf[i + 3], (secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128 && (tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63, tempCodePoint > 65535 && tempCodePoint < 1114112 && (codePoint = tempCodePoint));
}
}
codePoint === null ? (codePoint = 65533, bytesPerSequence = 1) : codePoint > 65535 && (codePoint -= 65536, res.push(codePoint >>> 10 & 1023 | 55296), codePoint = 56320 | codePoint & 1023), res.push(codePoint), i += bytesPerSequence;
}
return decodeCodePointsArray(res);
}
let MAX_ARGUMENTS_LENGTH = 4096;
function decodeCodePointsArray(codePoints) {
let len = codePoints.length;
if (len <= MAX_ARGUMENTS_LENGTH)
return String.fromCharCode.apply(String, codePoints);
let res = "", i = 0;
for (; i < len; )
res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
return res;
}
function asciiSlice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i = start; i < end; ++i)
ret += String.fromCharCode(buf[i] & 127);
return ret;
}
function latin1Slice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i = start; i < end; ++i)
ret += String.fromCharCode(buf[i]);
return ret;
}
function hexSlice(buf, start, end) {
let len = buf.length;
(!start || start < 0) && (start = 0), (!end || end < 0 || end > len) && (end = len);
let out = "";
for (let i = start; i < end; ++i)
out += hexSliceLookupTable[buf[i]];
return out;
}
function utf16leSlice(buf, start, end) {
let bytes = buf.slice(start, end), res = "";
for (let i = 0; i < bytes.length - 1; i += 2)
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
return res;
}
Buffer2.prototype.slice = function(start, end) {
let len = this.length;
start = ~~start, end = end === void 0 ? len : ~~end, start < 0 ? (start += len, start < 0 && (start = 0)) : start > len && (start = len), end < 0 ? (end += len, end < 0 && (end = 0)) : end > len && (end = len), end < start && (end = start);
let newBuf = this.subarray(start, end);
return Object.setPrototypeOf(newBuf, Buffer2.prototype), 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");
}
Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function(offset, byteLength2, noAssert) {
offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, noAssert || checkOffset(offset, byteLength2, this.length);
let val = this[offset], mul = 1, i = 0;
for (; ++i < byteLength2 && (mul *= 256); )
val += this[offset + i] * mul;
return val;
}, Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function(offset, byteLength2, noAssert) {
offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, noAssert || checkOffset(offset, byteLength2, this.length);
let val = this[offset + --byteLength2], mul = 1;
for (; byteLength2 > 0 && (mul *= 256); )
val += this[offset + --byteLength2] * mul;
return val;
}, Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 1, this.length), this[offset];
}, Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 2, this.length), this[offset] | this[offset + 1] << 8;
}, Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 2, this.length), this[offset] << 8 | this[offset + 1];
}, Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
}, Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
}, Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function(offset) {
offset = offset >>> 0, validateNumber(offset, "offset");
let first = this[offset], last = this[offset + 7];
(first === void 0 || last === void 0) && boundsError(offset, this.length - 8);
let lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24, hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
return BigInt(lo) + (BigInt(hi) << BigInt(32));
}), Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function(offset) {
offset = offset >>> 0, validateNumber(offset, "offset");
let first = this[offset], last = this[offset + 7];
(first === void 0 || last === void 0) && boundsError(offset, this.length - 8);
let hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset], lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
return (BigInt(hi) << BigInt(32)) + BigInt(lo);
}), Buffer2.prototype.readIntLE = function(offset, byteLength2, noAssert) {
offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, noAssert || checkOffset(offset, byteLength2, this.length);
let val = this[offset], mul = 1, i = 0;
for (; ++i < byteLength2 && (mul *= 256); )
val += this[offset + i] * mul;
return mul *= 128, val >= mul && (val -= Math.pow(2, 8 * byteLength2)), val;
}, Buffer2.prototype.readIntBE = function(offset, byteLength2, noAssert) {
offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, noAssert || checkOffset(offset, byteLength2, this.length);
let i = byteLength2, mul = 1, val = this[offset + --i];
for (; i > 0 && (mul *= 256); )
val += this[offset + --i] * mul;
return mul *= 128, val >= mul && (val -= Math.pow(2, 8 * byteLength2)), val;
}, Buffer2.prototype.readInt8 = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 1, this.length), this[offset] & 128 ? (255 - this[offset] + 1) * -1 : this[offset];
}, Buffer2.prototype.readInt16LE = function(offset, noAssert) {
offset = offset >>> 0, noAssert || checkOffset(offset, 2, this.length);
let val = this[offset] | this[offset + 1] << 8;
return val & 32768 ? val | 4294901760 : val;
}, Buffer2.prototype.readInt16BE = function(offset, noAssert) {
offset = offset >>> 0, noAssert || checkOffset(offset, 2, this.length);
let val = this[offset + 1] | this[offset] << 8;
return val & 32768 ? val | 4294901760 : val;
}, Buffer2.prototype.readInt32LE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
}, Buffer2.prototype.readInt32BE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
}, Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function(offset) {
offset = offset >>> 0, validateNumber(offset, "offset");
let first = this[offset], last = this[offset + 7];
(first === void 0 || last === void 0) && boundsError(offset, this.length - 8);
let val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
}), Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function(offset) {
offset = offset >>> 0, validateNumber(offset, "offset");
let first = this[offset], last = this[offset + 7];
(first === void 0 || last === void 0) && boundsError(offset, this.length - 8);
let val = (first << 24) + // Overflow
this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
}), Buffer2.prototype.readFloatLE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), ieee754.read(this, offset, !0, 23, 4);
}, Buffer2.prototype.readFloatBE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 4, this.length), ieee754.read(this, offset, !1, 23, 4);
}, Buffer2.prototype.readDoubleLE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 8, this.length), ieee754.read(this, offset, !0, 52, 8);
}, Buffer2.prototype.readDoubleBE = function(offset, noAssert) {
return offset = offset >>> 0, noAssert || checkOffset(offset, 8, this.length), ieee754.read(this, offset, !1, 52, 8);
};
function checkInt(buf, value, offset, ext, max, min) {
if (!Buffer2.isBuffer(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");
}
Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function(value, offset, byteLength2, noAssert) {
if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
checkInt(this, value, offset, byteLength2, maxBytes, 0);
}
let mul = 1, i = 0;
for (this[offset] = value & 255; ++i < byteLength2 && (mul *= 256); )
this[offset + i] = value / mul & 255;
return offset + byteLength2;
}, Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function(value, offset, byteLength2, noAssert) {
if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
checkInt(this, value, offset, byteLength2, maxBytes, 0);
}
let i = byteLength2 - 1, mul = 1;
for (this[offset + i] = value & 255; --i >= 0 && (mul *= 256); )
this[offset + i] = value / mul & 255;
return offset + byteLength2;
}, Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 1, 255, 0), this[offset] = value & 255, offset + 1;
}, Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 2, 65535, 0), this[offset] = value & 255, this[offset + 1] = value >>> 8, offset + 2;
}, Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 2, 65535, 0), this[offset] = value >>> 8, this[offset + 1] = value & 255, offset + 2;
}, Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 4, 4294967295, 0), this[offset + 3] = value >>> 24, this[offset + 2] = value >>> 16, this[offset + 1] = value >>> 8, this[offset] = value & 255, offset + 4;
}, Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 4, 4294967295, 0), this[offset] = value >>> 24, this[offset + 1] = value >>> 16, this[offset + 2] = value >>> 8, this[offset + 3] = value & 255, offset + 4;
};
function wrtBigUInt64LE(buf, value, offset, min, max) {
checkIntBI(value, min, max, buf, offset, 7);
let lo = Number(value & BigInt(4294967295));
buf[offset++] = lo, lo = lo >> 8, buf[offset++] = lo, lo = lo >> 8, buf[offset++] = lo, lo = lo >> 8, buf[offset++] = lo;
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
return buf[offset++] = hi, hi = hi >> 8, buf[offset++] = hi, hi = hi >> 8, buf[offset++] = hi, hi = hi >> 8, buf[offset++] = hi, offset;
}
function wrtBigUInt64BE(buf, value, offset, min, max) {
checkIntBI(value, min, max, buf, offset, 7);
let lo = Number(value & BigInt(4294967295));
buf[offset + 7] = lo, lo = lo >> 8, buf[offset + 6] = lo, lo = lo >> 8, buf[offset + 5] = lo, lo = lo >> 8, buf[offset + 4] = lo;
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
return buf[offset + 3] = hi, hi = hi >> 8, buf[offset + 2] = hi, hi = hi >> 8, buf[offset + 1] = hi, hi = hi >> 8, buf[offset] = hi, offset + 8;
}
Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function(value, offset = 0) {
return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
}), Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function(value, offset = 0) {
return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
}), Buffer2.prototype.writeIntLE = function(value, offset, byteLength2, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert) {
let limit = Math.pow(2, 8 * byteLength2 - 1);
checkInt(this, value, offset, byteLength2, limit - 1, -limit);
}
let i = 0, mul = 1, sub = 0;
for (this[offset] = value & 255; ++i < byteLength2 && (mul *= 256); )
value < 0 && sub === 0 && this[offset + i - 1] !== 0 && (sub = 1), this[offset + i] = (value / mul >> 0) - sub & 255;
return offset + byteLength2;
}, Buffer2.prototype.writeIntBE = function(value, offset, byteLength2, noAssert) {
if (value = +value, offset = offset >>> 0, !noAssert) {
let limit = Math.pow(2, 8 * byteLength2 - 1);
checkInt(this, value, offset, byteLength2, limit - 1, -limit);
}
let i = byteLength2 - 1, mul = 1, sub = 0;
for (this[offset + i] = value & 255; --i >= 0 && (mul *= 256); )
value < 0 && sub === 0 && this[offset + i + 1] !== 0 && (sub = 1), this[offset + i] = (value / mul >> 0) - sub & 255;
return offset + byteLength2;
}, Buffer2.prototype.writeInt8 = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 1, 127, -128), value < 0 && (value = 255 + value + 1), this[offset] = value & 255, offset + 1;
}, Buffer2.prototype.writeInt16LE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 2, 32767, -32768), this[offset] = value & 255, this[offset + 1] = value >>> 8, offset + 2;
}, Buffer2.prototype.writeInt16BE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 2, 32767, -32768), this[offset] = value >>> 8, this[offset + 1] = value & 255, offset + 2;
}, Buffer2.prototype.writeInt32LE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 4, 2147483647, -2147483648), this[offset] = value & 255, this[offset + 1] = value >>> 8, this[offset + 2] = value >>> 16, this[offset + 3] = value >>> 24, offset + 4;
}, Buffer2.prototype.writeInt32BE = function(value, offset, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkInt(this, value, offset, 4, 2147483647, -2147483648), value < 0 && (value = 4294967295 + value + 1), this[offset] = value >>> 24, this[offset + 1] = value >>> 16, this[offset + 2] = value >>> 8, this[offset + 3] = value & 255, offset + 4;
}, Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function(value, offset = 0) {
return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
}), Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function(value, offset = 0) {
return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
});
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) {
return value = +value, offset = offset >>> 0, noAssert || checkIEEE754(buf, value, offset, 4), ieee754.write(buf, value, offset, littleEndian, 23, 4), offset + 4;
}
Buffer2.prototype.writeFloatLE = function(value, offset, noAssert) {
return writeFloat(this, value, offset, !0, noAssert);
}, Buffer2.prototype.writeFloatBE = function(value, offset, noAssert) {
return writeFloat(this, value, offset, !1, noAssert);
};
function writeDouble(buf, value, offset, littleEndian, noAssert) {
return value = +value, offset = offset >>> 0, noAssert || checkIEEE754(buf, value, offset, 8), ieee754.write(buf, value, offset, littleEndian, 52, 8), offset + 8;
}
Buffer2.prototype.writeDoubleLE = function(value, offset, noAssert) {
return writeDouble(this, value, offset, !0, noAssert);
}, Buffer2.prototype.writeDoubleBE = function(value, offset, noAssert) {
return writeDouble(this, value, offset, !1, noAssert);
}, Buffer2.prototype.copy = function(target, targetStart, start, end) {
if (!Buffer2.isBuffer(target)) throw new TypeError("argument should be a Buffer");
if (start || (start = 0), !end && end !== 0 && (end = this.length), targetStart >= target.length && (targetStart = target.length), targetStart || (targetStart = 0), end > 0 && end < start && (end = start), end === start || 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("Index out of range");
if (end < 0) throw new RangeError("sourceEnd out of bounds");
end > this.length && (end = this.length), target.length - targetStart < end - start && (end = target.length - targetStart + start);
let len = end - start;
return this === target && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(targetStart, start, end) : Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart), len;
}, Buffer2.prototype.fill = function(val, start, end, encoding) {
if (typeof val == "string") {
if (typeof start == "string" ? (encoding = start, start = 0, end = this.length) : typeof end == "string" && (encoding = end, end = this.length), encoding !== void 0 && typeof encoding != "string")
throw new TypeError("encoding must be a string");
if (typeof encoding == "string" && !Buffer2.isEncoding(encoding))
throw new TypeError("Unknown encoding: " + encoding);
if (val.length === 1) {
let code = val.charCodeAt(0);
(encoding === "utf8" && code < 128 || encoding === "latin1") && (val = code);
}
} else typeof val == "number" ? val = val & 255 : typeof val == "boolean" && (val = Number(val));
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, val || (val = 0);
let i;
if (typeof val == "number")
for (i = start; i < end; ++i)
this[i] = val;
else {
let bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding), len = bytes.length;
if (len === 0)
throw new TypeError('The value "' + val + '" is invalid for argument "value"');
for (i = 0; i < end - start; ++i)
this[i + start] = bytes[i % len];
}
return this;
};
let errors = {};
function E(sym, getMessage, Base) {
errors[sym] = class extends Base {
constructor() {
super(), Object.defineProperty(this, "message", {
value: getMessage.apply(this, arguments),
writable: !0,
configurable: !0
}), this.name = `${this.name} [${sym}]`, this.stack, delete this.name;
}
get code() {
return sym;
}
set code(value) {
Object.defineProperty(this, "code", {
configurable: !0,
enumerable: !0,
value,
writable: !0
});
}
toString() {
return `${this.name} [${sym}]: ${this.message}`;
}
};
}
E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
return name ? `${name} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
}, RangeError), E("ERR_INVALID_ARG_TYPE", function(name, actual) {
return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
}, TypeError), E("ERR_OUT_OF_RANGE", function(str, range, input) {
let msg = `The value of "${str}" is out of range.`, received = input;
return Number.isInteger(input) && Math.abs(input) > 2 ** 32 ? received = addNumericalSeparator(String(input)) : typeof input == "bigint" && (received = String(input), (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) && (received = addNumericalSeparator(received)), received += "n"), msg += ` It must be ${range}. Received ${received}`, msg;
}, RangeError);
function addNumericalSeparator(val) {
let res = "", i = val.length, start = val[0] === "-" ? 1 : 0;
for (; i >= start + 4; i -= 3)
res = `_${val.slice(i - 3, i)}${res}`;
return `${val.slice(0, i)}${res}`;
}
function checkBounds(buf, offset, byteLength2) {
validateNumber(offset, "offset"), (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) && boundsError(offset, buf.length - (byteLength2 + 1));
}
function checkIntBI(value, min, max, buf, offset, byteLength2) {
if (value > max || value < min) {
let n = typeof min == "bigint" ? "n" : "", range;
throw byteLength2 > 3 ? min === 0 || min === BigInt(0) ? range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}` : range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}` : range = `>= ${min}${n} and <= ${max}${n}`, new errors.ERR_OUT_OF_RANGE("value", range, value);
}
checkBounds(buf, offset, byteLength2);
}
function validateNumber(value, name) {
if (typeof value != "number")
throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
}
function boundsError(value, length, type) {
throw Math.floor(value) !== value ? (validateNumber(value, type), new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value)) : length < 0 ? new errors.ERR_BUFFER_OUT_OF_BOUNDS() : new errors.ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
}
let INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
function base64clean(str) {
if (str = str.split("=")[0], str = str.trim().replace(INVALID_BASE64_RE, ""), str.length < 2) return "";
for (; str.length % 4 !== 0; )
str = str + "=";
return str;
}
function utf8ToBytes(string, units) {
units = units || 1 / 0;
let codePoint, length = string.length, leadSurrogate = null, bytes = [];
for (let i = 0; i < length; ++i) {
if (codePoint = string.charCodeAt(i), codePoint > 55295 && codePoint < 57344) {
if (!leadSurrogate) {
if (codePoint > 56319) {
(units -= 3) > -1 && bytes.push(239, 191, 189);
continue;
} else if (i + 1 === length) {
(units -= 3) > -1 && bytes.push(239, 191, 189);
continue;
}
leadSurrogate = codePoint;
continue;
}
if (codePoint < 56320) {
(units -= 3) > -1 && bytes.push(239, 191, 189), leadSurrogate = codePoint;
continue;
}
codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
} else leadSurrogate && (units -= 3) > -1 && bytes.push(239, 191, 189);
if (leadSurrogate = null, 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) {
let byteArray = [];
for (let i = 0; i < str.length; ++i)
byteArray.push(str.charCodeAt(i) & 255);
return byteArray;
}
function utf16leToBytes(str, units) {
let c, hi, lo, byteArray = [];
for (let i = 0; i < str.length && !((units -= 2) < 0); ++i)
c = str.charCodeAt(i), hi = c >> 8, lo = c % 256, byteArray.push(lo), byteArray.push(hi);
return byteArray;
}
function base64ToBytes(str) {
return base64.toByteArray(base64clean(str));
}
function blitBuffer(src, dst, offset, length) {
let i;
for (i = 0; i < length && !(i + offset >= dst.length || i >= src.length); ++i)
dst[i + offset] = src[i];
return i;
}
function isInstance(obj, type) {
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
}
function numberIsNaN(obj) {
return obj !== obj;
}
let hexSliceLookupTable = function() {
let alphabet = "0123456789abcdef", table = new Array(256);
for (let i = 0; i < 16; ++i) {
let i16 = i * 16;
for (let j = 0; j < 16; ++j)
table[i16 + j] = alphabet[i] + alphabet[j];
}
return table;
}();
function defineBigIntMethod(fn) {
return typeof BigInt == "undefined" ? BufferBigIntNotDefined : fn;
}
function BufferBigIntNotDefined() {
throw new Error("BigInt not supported");
}
return exports$1;
}
var exports = dew();
exports.Buffer;
exports.SlowBuffer;
exports.INSPECT_MAX_BYTES;
exports.kMaxLength;
var Buffer = exports.Buffer, INSPECT_MAX_BYTES = exports.INSPECT_MAX_BYTES, kMaxLength = exports.kMaxLength;
 
// src-text2dia/plugin.js
var plugin = {
replaceText: {
"Convert to Dia": async function(app, text) {
text = text.trim();
let { type, text: parsedText } = await plugin._parseUserIntentFromText(app, text);
if (type !== "cancel")
return await plugin._toDiagram(app, type, text, parsedText), null;
}
},
insertText: {
"Create Diagram": async function(app) {
let { type, text } = await plugin._parseUserIntentFromText(app, null);
if (type !== "cancel")
return text = text.trim(), await plugin._toDiagram(app, type, text, text), null;
}
},
imageOption: {
"Convert to Text": {
check: (app, image) => {
try {
if (new URL(image.src).searchParams.get("text") != null)
return !0;
} catch {
}
return !1;
},
run: async (app, image) => (await plugin._toText(app, image), null)
}
},
async _parseUserIntentFromText(app, text) {
if (typeof text == "string" && text.match(/^\$\$(.*?)\$\$$/s))
return { type: "tex-display", text: text.replace(/^\$\$(.*?)\$\$$/s, "$1") };
if (typeof text == "string" && text.match(/^\$(.*?)\$$/s))
return { type: "tex", text: text.replace(/^\$(.*?)\$$/s, "$1") };
let promptInputs = [
{
label: "Diagram Type",
type: "select",
options: [
{ label: "Tex (Inline)", value: "tex" },
{ label: "Tex (Display)", value: "tex-display" },
{ label: "Mermaid", value: "mermaid" },
{ label: "PlantUML", value: "plantuml" },
{ label: "Graphviz", value: "graphviz" },
{ label: "Ditaa", value: "ditaa" },
{ label: "DBML", value: "dbml" }
],
value: "ditaa"
}
], type;
if (text == null) {
let arr = await app.prompt("Options for creating image:", {
inputs: [{ label: "Text / Code", placeholder: `+--+
|A |
+--+`, type: "text" }, ...promptInputs]
});
if (!arr) return { type: "cancel" };
if (text = arr[0], !text || text === "") return { type: "cancel" };
type = arr[1];
} else if (type = await app.prompt("Options for creating image:", {
inputs: promptInputs
}), !type) return { type: "cancel" };
return { type, text };
},
async _toDiagram(app, type, text, parsedText) {
try {
console.log(text);
let response;
if (type == null) return;
if (type === "tex" || type === "tex-display" ? response = await fetch("https://kroki.io/tikz/svg", {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded"
},
body: `\\documentclass{article}
\\usepackage{amsmath}
\\usepackage[dvipsnames]{xcolor}
\\usepackage[active,tightpage]{preview}
\\PreviewEnvironment{equation*}
\\setlength\\PreviewBorder{0.125pt}
 
\\begin{document}
\\${type === "tex-display" ? "huge" : "large"}
\\begin{equation*}
{${type === "tex-display" ? "\\displaystyle" : ""} \\color{Emerald} ${parsedText}}
\\end{equation*}
\\end{document}`
}) : (type === "mermaid" || type === "plantuml" || type === "graphviz" || type === "ditaa" || type === "dbml") && (response = await fetch(`https://kroki.io/${type}/svg`, {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded"
},
body: parsedText
})), !response)
throw new Error("No response from kroki.io");
if (!response.ok) {
let error = await response.text();
throw new Error(error);
}
let blob = await response.blob(), svgDataURL = await plugin._dataURLFromBlob(blob), pngDataURL = await plugin._svgToPng(svgDataURL), noteHandle = { uuid: app.context.noteUUID }, appendedFileURL = await app.attachNoteMedia(noteHandle, pngDataURL) + "?text=" + window.encodeURIComponent(Buffer.from(text, "utf8").toString("base64"));
return app.context.replaceSelection(`<a> </a>![${text || ""}](${appendedFileURL}) <!-- dummy comment -->`), null;
} catch (e) {
app.alert("Failed _toDiagram - " + e);
}
},
async _toText(app, image) {
try {
let url = new URL(image.src);
if (url.searchParams.get("text") == null) throw new Error("No text information found in image. It is possible that the image was not created by this plugin.");
let text = Buffer.from(window.decodeURIComponent(url.searchParams.get("text")), "base64").toString("utf8");
console.log(text), app.context.replaceSelection(text);
} catch (e) {
app.alert("Failed _toText - " + e);
}
},
async _svgToPng(svgBase64) {
return new Promise(async function(resolve, reject) {
let image = new Image();
image.src = svgBase64, image.onload = function() {
let canvas = document.createElement("canvas");
canvas.width = image.width, canvas.height = image.height, canvas.getContext("2d").drawImage(image, 0, 0);
let output = canvas.toDataURL("image/png");
resolve(output);
};
});
},
async _dataURLFromBlob(blob) {
return new Promise((resolve, reject) => {
let reader = new FileReader();
reader.onload = (event) => {
resolve(event.target.result);
}, reader.onerror = function(event) {
reader.abort(), reject(event.target.error);
}, reader.readAsDataURL(blob);
});
}
}, plugin_default = plugin;
return plugin;
})()
//# sourceMappingURL=plugin.js.map
 


linkChangelog

13/07/2024 - Temporarily fixed issue with replaceSelection
28/09/2024 - Reduced bundle size



Note: The images are generated by the free and open source service kroki.io.

The content above is from a note published by an Amplenote subscriber. As updates to the note are made, they are reflected here in real time.   Learn how to embed notes anywhere keyboard_arrow_right