@mcp-s/skills 1.0.2 → 1.3.1

package/dist/_chunks/libs/node-int64.mjs

@@ -0,0 +1,103 @@
+import { t as __commonJSMin } from "../rolldown-runtime.mjs";
+var require_Int64 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var VAL32 = 4294967296;
+	var _HEX = [];
+	for (var i = 0; i < 256; i++) _HEX[i] = (i > 15 ? "" : "0") + i.toString(16);
+	var Int64 = module.exports = function(a1, a2) {
+		if (a1 instanceof Buffer) {
+			this.buffer = a1;
+			this.offset = a2 || 0;
+		} else if (Object.prototype.toString.call(a1) == "[object Uint8Array]") {
+			this.buffer = new Buffer(a1);
+			this.offset = a2 || 0;
+		} else {
+			this.buffer = this.buffer || new Buffer(8);
+			this.offset = 0;
+			this.setValue.apply(this, arguments);
+		}
+	};
+	Int64.MAX_INT = Math.pow(2, 53);
+	Int64.MIN_INT = -Math.pow(2, 53);
+	Int64.prototype = {
+		constructor: Int64,
+		_2scomp: function() {
+			var b = this.buffer, o = this.offset, carry = 1;
+			for (var i = o + 7; i >= o; i--) {
+				var v = (b[i] ^ 255) + carry;
+				b[i] = v & 255;
+				carry = v >> 8;
+			}
+		},
+		setValue: function(hi, lo) {
+			var negate = false;
+			if (arguments.length == 1) if (typeof hi == "number") {
+				negate = hi < 0;
+				hi = Math.abs(hi);
+				lo = hi % VAL32;
+				hi = hi / VAL32;
+				if (hi > VAL32) throw new RangeError(hi + " is outside Int64 range");
+				hi = hi | 0;
+			} else if (typeof hi == "string") {
+				hi = (hi + "").replace(/^0x/, "");
+				lo = hi.substr(-8);
+				hi = hi.length > 8 ? hi.substr(0, hi.length - 8) : "";
+				hi = parseInt(hi, 16);
+				lo = parseInt(lo, 16);
+			} else throw new Error(hi + " must be a Number or String");
+			var b = this.buffer, o = this.offset;
+			for (var i = 7; i >= 0; i--) {
+				b[o + i] = lo & 255;
+				lo = i == 4 ? hi : lo >>> 8;
+			}
+			if (negate) this._2scomp();
+		},
+		toNumber: function(allowImprecise) {
+			var b = this.buffer, o = this.offset;
+			var negate = b[o] & 128, x = 0, carry = 1;
+			for (var i = 7, m = 1; i >= 0; i--, m *= 256) {
+				var v = b[o + i];
+				if (negate) {
+					v = (v ^ 255) + carry;
+					carry = v >> 8;
+					v = v & 255;
+				}
+				x += v * m;
+			}
+			if (!allowImprecise && x >= Int64.MAX_INT) return negate ? -Infinity : Infinity;
+			return negate ? -x : x;
+		},
+		valueOf: function() {
+			return this.toNumber(false);
+		},
+		toString: function(radix) {
+			return this.valueOf().toString(radix || 10);
+		},
+		toOctetString: function(sep) {
+			var out = new Array(8);
+			var b = this.buffer, o = this.offset;
+			for (var i = 0; i < 8; i++) out[i] = _HEX[b[o + i]];
+			return out.join(sep || "");
+		},
+		toBuffer: function(rawBuffer) {
+			if (rawBuffer && this.offset === 0) return this.buffer;
+			var out = new Buffer(8);
+			this.buffer.copy(out, 0, this.offset, this.offset + 8);
+			return out;
+		},
+		copy: function(targetBuffer, targetOffset) {
+			this.buffer.copy(targetBuffer, targetOffset || 0, this.offset, this.offset + 8);
+		},
+		compare: function(other) {
+			if ((this.buffer[this.offset] & 128) != (other.buffer[other.offset] & 128)) return other.buffer[other.offset] - this.buffer[this.offset];
+			for (var i = 0; i < 8; i++) if (this.buffer[this.offset + i] !== other.buffer[other.offset + i]) return this.buffer[this.offset + i] - other.buffer[other.offset + i];
+			return 0;
+		},
+		equals: function(other) {
+			return this.compare(other) === 0;
+		},
+		inspect: function() {
+			return "[Int64 value:" + this + " octets:" + this.toOctetString(" ") + "]";
+		}
+	};
+}));
+export { require_Int64 as t };