@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/mysql2@3.16.1/node_modules/mysql2/lib/packets/packet.js

@@ -0,0 +1,652 @@
+import { __commonJS, __require } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_errors } from "../constants/errors.js";
+import { require_umd } from "../../../../../long@5.3.2/node_modules/long/umd/index.js";
+import { require_string } from "../parsers/string.js";
+import { require_types } from "../constants/types.js";
+
+//#region ../../node_modules/.pnpm/mysql2@3.16.1/node_modules/mysql2/lib/packets/packet.js
+var require_packet = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mysql2@3.16.1/node_modules/mysql2/lib/packets/packet.js": ((exports, module) => {
+	const ErrorCodeToName = require_errors();
+	const NativeBuffer = __require("buffer").Buffer;
+	const Long = require_umd();
+	const StringParser = require_string();
+	const Types = require_types();
+	const INVALID_DATE = /* @__PURE__ */ new Date(NaN);
+	const pad = "000000000000";
+	function leftPad(num, value) {
+		const s = value.toString();
+		if (s.length >= num) return s;
+		return (pad + s).slice(-num);
+	}
+	const minus = "-".charCodeAt(0);
+	const plus = "+".charCodeAt(0);
+	const dot = ".".charCodeAt(0);
+	const exponent = "e".charCodeAt(0);
+	const exponentCapital = "E".charCodeAt(0);
+	var Packet = class Packet {
+		constructor(id, buffer, start, end) {
+			this.sequenceId = id;
+			this.numPackets = 1;
+			this.buffer = buffer;
+			this.start = start;
+			this.offset = start + 4;
+			this.end = end;
+		}
+		reset() {
+			this.offset = this.start + 4;
+		}
+		length() {
+			return this.end - this.start;
+		}
+		slice() {
+			return this.buffer.slice(this.start, this.end);
+		}
+		dump() {
+			console.log([this.buffer.asciiSlice(this.start, this.end)], this.buffer.slice(this.start, this.end), this.length(), this.sequenceId);
+		}
+		haveMoreData() {
+			return this.end > this.offset;
+		}
+		skip(num) {
+			this.offset += num;
+		}
+		readInt8() {
+			return this.buffer[this.offset++];
+		}
+		readInt16() {
+			this.offset += 2;
+			return this.buffer.readUInt16LE(this.offset - 2);
+		}
+		readInt24() {
+			return this.readInt16() + (this.readInt8() << 16);
+		}
+		readInt32() {
+			this.offset += 4;
+			return this.buffer.readUInt32LE(this.offset - 4);
+		}
+		readSInt8() {
+			return this.buffer.readInt8(this.offset++);
+		}
+		readSInt16() {
+			this.offset += 2;
+			return this.buffer.readInt16LE(this.offset - 2);
+		}
+		readSInt32() {
+			this.offset += 4;
+			return this.buffer.readInt32LE(this.offset - 4);
+		}
+		readInt64JSNumber() {
+			return new Long(this.readInt32(), this.readInt32(), true).toNumber();
+		}
+		readSInt64JSNumber() {
+			const word0 = this.readInt32();
+			const word1 = this.readInt32();
+			if (!(word1 & 2147483648)) return word0 + 4294967296 * word1;
+			return new Long(word0, word1, false).toNumber();
+		}
+		readInt64String() {
+			return new Long(this.readInt32(), this.readInt32(), true).toString();
+		}
+		readSInt64String() {
+			return new Long(this.readInt32(), this.readInt32(), false).toString();
+		}
+		readInt64() {
+			let res = new Long(this.readInt32(), this.readInt32(), true);
+			const resNumber = res.toNumber();
+			const resString = res.toString();
+			res = resNumber.toString() === resString ? resNumber : resString;
+			return res;
+		}
+		readSInt64() {
+			let res = new Long(this.readInt32(), this.readInt32(), false);
+			const resNumber = res.toNumber();
+			const resString = res.toString();
+			res = resNumber.toString() === resString ? resNumber : resString;
+			return res;
+		}
+		isEOF() {
+			return this.buffer[this.offset] === 254 && this.length() < 13;
+		}
+		eofStatusFlags() {
+			return this.buffer.readInt16LE(this.offset + 3);
+		}
+		eofWarningCount() {
+			return this.buffer.readInt16LE(this.offset + 1);
+		}
+		readLengthCodedNumber(bigNumberStrings, signed) {
+			const byte1 = this.buffer[this.offset++];
+			if (byte1 < 251) return byte1;
+			return this.readLengthCodedNumberExt(byte1, bigNumberStrings, signed);
+		}
+		readLengthCodedNumberSigned(bigNumberStrings) {
+			return this.readLengthCodedNumber(bigNumberStrings, true);
+		}
+		readLengthCodedNumberExt(tag, bigNumberStrings, signed) {
+			let word0, word1;
+			let res;
+			if (tag === 251) return null;
+			if (tag === 252) return this.readInt8() + (this.readInt8() << 8);
+			if (tag === 253) return this.readInt8() + (this.readInt8() << 8) + (this.readInt8() << 16);
+			if (tag === 254) {
+				word0 = this.readInt32();
+				word1 = this.readInt32();
+				if (word1 === 0) return word0;
+				if (word1 < 2097152) return word1 * 4294967296 + word0;
+				res = new Long(word0, word1, !signed);
+				const resNumber = res.toNumber();
+				const resString = res.toString();
+				res = resNumber.toString() === resString ? resNumber : resString;
+				return bigNumberStrings ? resString : res;
+			}
+			console.trace();
+			throw new Error(`Should not reach here: ${tag}`);
+		}
+		readFloat() {
+			const res = this.buffer.readFloatLE(this.offset);
+			this.offset += 4;
+			return res;
+		}
+		readDouble() {
+			const res = this.buffer.readDoubleLE(this.offset);
+			this.offset += 8;
+			return res;
+		}
+		readBuffer(len) {
+			if (typeof len === "undefined") len = this.end - this.offset;
+			this.offset += len;
+			return this.buffer.slice(this.offset - len, this.offset);
+		}
+		readDateTime(timezone) {
+			if (!timezone || timezone === "Z" || timezone === "local") {
+				const length = this.readInt8();
+				if (length === 251) return null;
+				let y = 0;
+				let m = 0;
+				let d = 0;
+				let H = 0;
+				let M = 0;
+				let S = 0;
+				let ms = 0;
+				if (length > 3) {
+					y = this.readInt16();
+					m = this.readInt8();
+					d = this.readInt8();
+				}
+				if (length > 6) {
+					H = this.readInt8();
+					M = this.readInt8();
+					S = this.readInt8();
+				}
+				if (length > 10) ms = this.readInt32() / 1e3;
+				if (y + m + d + H + M + S + ms === 0) return INVALID_DATE;
+				if (timezone === "Z") return new Date(Date.UTC(y, m - 1, d, H, M, S, ms));
+				return new Date(y, m - 1, d, H, M, S, ms);
+			}
+			let str = this.readDateTimeString(6, "T", null);
+			if (str.length === 10) str += "T00:00:00";
+			return new Date(str + timezone);
+		}
+		readDateTimeString(decimals, timeSep, columnType) {
+			const length = this.readInt8();
+			let y = 0;
+			let m = 0;
+			let d = 0;
+			let H = 0;
+			let M = 0;
+			let S = 0;
+			let ms = 0;
+			let str;
+			if (length > 3) {
+				y = this.readInt16();
+				m = this.readInt8();
+				d = this.readInt8();
+				str = [
+					leftPad(4, y),
+					leftPad(2, m),
+					leftPad(2, d)
+				].join("-");
+			}
+			if (length > 6) {
+				H = this.readInt8();
+				M = this.readInt8();
+				S = this.readInt8();
+				str += `${timeSep || " "}${[
+					leftPad(2, H),
+					leftPad(2, M),
+					leftPad(2, S)
+				].join(":")}`;
+			} else if (columnType === Types.DATETIME) str += " 00:00:00";
+			if (length > 10) {
+				ms = this.readInt32();
+				str += ".";
+				if (decimals) {
+					ms = leftPad(6, ms);
+					if (ms.length > decimals) ms = ms.substring(0, decimals);
+				}
+				str += ms;
+			}
+			return str;
+		}
+		readTimeString(convertTtoMs) {
+			const length = this.readInt8();
+			if (length === 0) return "00:00:00";
+			const sign = this.readInt8() ? -1 : 1;
+			let d = 0;
+			let H = 0;
+			let M = 0;
+			let S = 0;
+			let ms = 0;
+			if (length > 6) {
+				d = this.readInt32();
+				H = this.readInt8();
+				M = this.readInt8();
+				S = this.readInt8();
+			}
+			if (length > 10) ms = this.readInt32();
+			if (convertTtoMs) {
+				H += d * 24;
+				M += H * 60;
+				S += M * 60;
+				ms += S * 1e3;
+				ms *= sign;
+				return ms;
+			}
+			return (sign === -1 ? "-" : "") + [
+				leftPad(2, d * 24 + H),
+				leftPad(2, M),
+				leftPad(2, S)
+			].join(":") + (ms ? `.${ms}`.replace(/0+$/, "") : "");
+		}
+		readLengthCodedString(encoding) {
+			const len = this.readLengthCodedNumber();
+			if (len === null) return null;
+			this.offset += len;
+			return StringParser.decode(this.buffer, encoding, this.offset - len, this.offset);
+		}
+		readLengthCodedBuffer() {
+			const len = this.readLengthCodedNumber();
+			if (len === null) return null;
+			return this.readBuffer(len);
+		}
+		readNullTerminatedString(encoding) {
+			const start = this.offset;
+			let end = this.offset;
+			while (this.buffer[end]) end = end + 1;
+			this.offset = end + 1;
+			return StringParser.decode(this.buffer, encoding, start, end);
+		}
+		readString(len, encoding) {
+			if (typeof len === "string" && typeof encoding === "undefined") {
+				encoding = len;
+				len = void 0;
+			}
+			if (typeof len === "undefined") len = this.end - this.offset;
+			this.offset += len;
+			return StringParser.decode(this.buffer, encoding, this.offset - len, this.offset);
+		}
+		parseInt(len, supportBigNumbers) {
+			if (len === null) return null;
+			if (len >= 14 && !supportBigNumbers) {
+				const s = this.buffer.toString("ascii", this.offset, this.offset + len);
+				this.offset += len;
+				return Number(s);
+			}
+			let result = 0;
+			const start = this.offset;
+			const end = this.offset + len;
+			let sign = 1;
+			if (len === 0) return 0;
+			if (this.buffer[this.offset] === minus) {
+				this.offset++;
+				sign = -1;
+			}
+			let str;
+			const numDigits = end - this.offset;
+			if (supportBigNumbers) {
+				if (numDigits >= 15) {
+					str = this.readString(end - this.offset, "binary");
+					result = parseInt(str, 10);
+					if (result.toString() === str) return sign * result;
+					return sign === -1 ? `-${str}` : str;
+				}
+				if (numDigits > 16) {
+					str = this.readString(end - this.offset);
+					return sign === -1 ? `-${str}` : str;
+				}
+			}
+			if (this.buffer[this.offset] === plus) this.offset++;
+			while (this.offset < end) {
+				result *= 10;
+				result += this.buffer[this.offset] - 48;
+				this.offset++;
+			}
+			const num = result * sign;
+			if (!supportBigNumbers) return num;
+			str = this.buffer.toString("ascii", start, end);
+			if (num.toString() === str) return num;
+			return str;
+		}
+		parseIntNoBigCheck(len) {
+			if (len === null) return null;
+			let result = 0;
+			const end = this.offset + len;
+			let sign = 1;
+			if (len === 0) return 0;
+			if (this.buffer[this.offset] === minus) {
+				this.offset++;
+				sign = -1;
+			}
+			if (this.buffer[this.offset] === plus) this.offset++;
+			while (this.offset < end) {
+				result *= 10;
+				result += this.buffer[this.offset] - 48;
+				this.offset++;
+			}
+			return result * sign;
+		}
+		parseGeometryValue() {
+			const buffer = this.readLengthCodedBuffer();
+			let offset = 4;
+			if (buffer === null || !buffer.length) return null;
+			function parseGeometry() {
+				let x, y, i, j, numPoints, line;
+				let result = null;
+				const byteOrder = buffer.readUInt8(offset);
+				offset += 1;
+				const wkbType = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
+				offset += 4;
+				switch (wkbType) {
+					case 1:
+						x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
+						offset += 8;
+						y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
+						offset += 8;
+						result = {
+							x,
+							y
+						};
+						break;
+					case 2:
+						numPoints = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
+						offset += 4;
+						result = [];
+						for (i = numPoints; i > 0; i--) {
+							x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
+							offset += 8;
+							y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
+							offset += 8;
+							result.push({
+								x,
+								y
+							});
+						}
+						break;
+					case 3:
+						const numRings = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
+						offset += 4;
+						result = [];
+						for (i = numRings; i > 0; i--) {
+							numPoints = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
+							offset += 4;
+							line = [];
+							for (j = numPoints; j > 0; j--) {
+								x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
+								offset += 8;
+								y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset);
+								offset += 8;
+								line.push({
+									x,
+									y
+								});
+							}
+							result.push(line);
+						}
+						break;
+					case 4:
+					case 5:
+					case 6:
+					case 7:
+						const num = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
+						offset += 4;
+						result = [];
+						for (i = num; i > 0; i--) result.push(parseGeometry());
+						break;
+				}
+				return result;
+			}
+			return parseGeometry();
+		}
+		parseVector() {
+			const bufLen = this.readLengthCodedNumber();
+			const vectorEnd = this.offset + bufLen;
+			const result = [];
+			while (this.offset < vectorEnd && this.offset < this.end) result.push(this.readFloat());
+			return result;
+		}
+		parseDate(timezone) {
+			const strLen = this.readLengthCodedNumber();
+			if (strLen === null) return null;
+			if (strLen !== 10) return /* @__PURE__ */ new Date(NaN);
+			const y = this.parseInt(4);
+			this.offset++;
+			const m = this.parseInt(2);
+			this.offset++;
+			const d = this.parseInt(2);
+			if (!timezone || timezone === "local") return new Date(y, m - 1, d);
+			if (timezone === "Z") return new Date(Date.UTC(y, m - 1, d));
+			return /* @__PURE__ */ new Date(`${leftPad(4, y)}-${leftPad(2, m)}-${leftPad(2, d)}T00:00:00${timezone}`);
+		}
+		parseDateTime(timezone) {
+			const str = this.readLengthCodedString("binary");
+			if (str === null) return null;
+			if (!timezone || timezone === "local") return new Date(str);
+			return /* @__PURE__ */ new Date(`${str}${timezone}`);
+		}
+		parseFloat(len) {
+			if (len === null) return null;
+			let result = 0;
+			const end = this.offset + len;
+			let factor = 1;
+			let pastDot = false;
+			let charCode = 0;
+			if (len === 0) return 0;
+			if (this.buffer[this.offset] === minus) {
+				this.offset++;
+				factor = -1;
+			}
+			if (this.buffer[this.offset] === plus) this.offset++;
+			while (this.offset < end) {
+				charCode = this.buffer[this.offset];
+				if (charCode === dot) {
+					pastDot = true;
+					this.offset++;
+				} else if (charCode === exponent || charCode === exponentCapital) {
+					this.offset++;
+					const exponentValue = this.parseInt(end - this.offset);
+					return result / factor * Math.pow(10, exponentValue);
+				} else {
+					result *= 10;
+					result += this.buffer[this.offset] - 48;
+					this.offset++;
+					if (pastDot) factor = factor * 10;
+				}
+			}
+			return result / factor;
+		}
+		parseLengthCodedIntNoBigCheck() {
+			return this.parseIntNoBigCheck(this.readLengthCodedNumber());
+		}
+		parseLengthCodedInt(supportBigNumbers) {
+			return this.parseInt(this.readLengthCodedNumber(), supportBigNumbers);
+		}
+		parseLengthCodedIntString() {
+			return this.readLengthCodedString("binary");
+		}
+		parseLengthCodedFloat() {
+			return this.parseFloat(this.readLengthCodedNumber());
+		}
+		peekByte() {
+			return this.buffer[this.offset];
+		}
+		isAlt() {
+			return this.peekByte() === 254;
+		}
+		isError() {
+			return this.peekByte() === 255;
+		}
+		asError(encoding) {
+			this.reset();
+			this.readInt8();
+			const errorCode = this.readInt16();
+			let sqlState = "";
+			if (this.buffer[this.offset] === 35) {
+				this.skip(1);
+				sqlState = this.readBuffer(5).toString();
+			}
+			const message = this.readString(void 0, encoding);
+			const err = new Error(message);
+			err.code = ErrorCodeToName[errorCode];
+			err.errno = errorCode;
+			err.sqlState = sqlState;
+			err.sqlMessage = message;
+			return err;
+		}
+		writeInt32(n) {
+			this.buffer.writeUInt32LE(n, this.offset);
+			this.offset += 4;
+		}
+		writeInt24(n) {
+			this.writeInt8(n & 255);
+			this.writeInt16(n >> 8);
+		}
+		writeInt16(n) {
+			this.buffer.writeUInt16LE(n, this.offset);
+			this.offset += 2;
+		}
+		writeInt8(n) {
+			this.buffer.writeUInt8(n, this.offset);
+			this.offset++;
+		}
+		writeDouble(n) {
+			this.buffer.writeDoubleLE(n, this.offset);
+			this.offset += 8;
+		}
+		writeBuffer(b) {
+			b.copy(this.buffer, this.offset);
+			this.offset += b.length;
+		}
+		writeNull() {
+			this.buffer[this.offset] = 251;
+			this.offset++;
+		}
+		writeNullTerminatedString(s, encoding) {
+			const buf = StringParser.encode(s, encoding);
+			this.buffer.length && buf.copy(this.buffer, this.offset);
+			this.offset += buf.length;
+			this.writeInt8(0);
+		}
+		writeString(s, encoding) {
+			if (s === null) {
+				this.writeInt8(251);
+				return;
+			}
+			if (s.length === 0) return;
+			const buf = StringParser.encode(s, encoding);
+			this.buffer.length && buf.copy(this.buffer, this.offset);
+			this.offset += buf.length;
+		}
+		writeLengthCodedString(s, encoding) {
+			const buf = StringParser.encode(s, encoding);
+			this.writeLengthCodedNumber(buf.length);
+			this.buffer.length && buf.copy(this.buffer, this.offset);
+			this.offset += buf.length;
+		}
+		writeLengthCodedBuffer(b) {
+			this.writeLengthCodedNumber(b.length);
+			b.copy(this.buffer, this.offset);
+			this.offset += b.length;
+		}
+		writeLengthCodedNumber(n) {
+			if (n < 251) return this.writeInt8(n);
+			if (n < 65535) {
+				this.writeInt8(252);
+				return this.writeInt16(n);
+			}
+			if (n < 16777215) {
+				this.writeInt8(253);
+				return this.writeInt24(n);
+			}
+			if (n === null) return this.writeInt8(251);
+			this.writeInt8(254);
+			this.buffer.writeUInt32LE(n, this.offset);
+			this.offset += 4;
+			this.buffer.writeUInt32LE(n >> 32, this.offset);
+			this.offset += 4;
+			return this.offset;
+		}
+		writeDate(d, timezone) {
+			this.buffer.writeUInt8(11, this.offset);
+			if (!timezone || timezone === "local") {
+				this.buffer.writeUInt16LE(d.getFullYear(), this.offset + 1);
+				this.buffer.writeUInt8(d.getMonth() + 1, this.offset + 3);
+				this.buffer.writeUInt8(d.getDate(), this.offset + 4);
+				this.buffer.writeUInt8(d.getHours(), this.offset + 5);
+				this.buffer.writeUInt8(d.getMinutes(), this.offset + 6);
+				this.buffer.writeUInt8(d.getSeconds(), this.offset + 7);
+				this.buffer.writeUInt32LE(d.getMilliseconds() * 1e3, this.offset + 8);
+			} else {
+				if (timezone !== "Z") {
+					const offset = (timezone[0] === "-" ? -1 : 1) * (parseInt(timezone.substring(1, 3), 10) * 60 + parseInt(timezone.substring(4), 10));
+					if (offset !== 0) d = new Date(d.getTime() + 6e4 * offset);
+				}
+				this.buffer.writeUInt16LE(d.getUTCFullYear(), this.offset + 1);
+				this.buffer.writeUInt8(d.getUTCMonth() + 1, this.offset + 3);
+				this.buffer.writeUInt8(d.getUTCDate(), this.offset + 4);
+				this.buffer.writeUInt8(d.getUTCHours(), this.offset + 5);
+				this.buffer.writeUInt8(d.getUTCMinutes(), this.offset + 6);
+				this.buffer.writeUInt8(d.getUTCSeconds(), this.offset + 7);
+				this.buffer.writeUInt32LE(d.getUTCMilliseconds() * 1e3, this.offset + 8);
+			}
+			this.offset += 12;
+		}
+		writeHeader(sequenceId) {
+			const offset = this.offset;
+			this.offset = 0;
+			this.writeInt24(this.buffer.length - 4);
+			this.writeInt8(sequenceId);
+			this.offset = offset;
+		}
+		clone() {
+			return new Packet(this.sequenceId, this.buffer, this.start, this.end);
+		}
+		type() {
+			if (this.isEOF()) return "EOF";
+			if (this.isError()) return "Error";
+			if (this.buffer[this.offset] === 0) return "maybeOK";
+			return "";
+		}
+		static lengthCodedNumberLength(n) {
+			if (n < 251) return 1;
+			if (n < 65535) return 3;
+			if (n < 16777215) return 5;
+			return 9;
+		}
+		static lengthCodedStringLength(str, encoding) {
+			const slen = StringParser.encode(str, encoding).length;
+			return Packet.lengthCodedNumberLength(slen) + slen;
+		}
+		static MockBuffer() {
+			const noop = function() {};
+			const res = Buffer.alloc(0);
+			for (const op in NativeBuffer.prototype) if (typeof res[op] === "function") res[op] = noop;
+			return res;
+		}
+	};
+	module.exports = Packet;
+}) });
+
+//#endregion
+export default require_packet();
+
+export { require_packet };
+//# sourceMappingURL=packet.js.map