@vue-skuilder/courseware 0.1.34 → 0.1.35

package/dist/chess-BbHATAzk.js

@@ -0,0 +1,2949 @@
+import { r as e } from "./shapes-BQUVJdp5.js";
+import { r as t, t as n } from "./CourseWare-BTFRjgBR.js";
+import { Fragment as r, computed as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, defineComponent as c, onMounted as l, onUnmounted as u, openBlock as d, ref as f, renderList as p, toDisplayString as m, watch as h } from "vue";
+import { Question as g, useQuestionView as _, useViewable as v } from "@vue-skuilder/common-ui";
+import { DataShapeName as y, FieldType as b, Status as x } from "@vue-skuilder/common";
+//#region src/chess/chessground/types.ts
+var S = ["cg-white", "cg-black"], C = [
+	"a",
+	"b",
+	"c",
+	"d",
+	"e",
+	"f",
+	"g",
+	"h"
+], w = [
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8"
+], T = [...w].reverse(), E = Array.prototype.concat(...C.map((e) => w.map((t) => e + t))), pos2key = (e) => E[8 * e[0] + e[1]], key2pos = (e) => [e.charCodeAt(0) - 97, e.charCodeAt(1) - 49], D = E.map(key2pos);
+function memo(e) {
+	let t, ret = () => (t === void 0 && (t = e()), t);
+	return ret.clear = () => {
+		t = void 0;
+	}, ret;
+}
+var timer = () => {
+	let e;
+	return {
+		start() {
+			e = performance.now();
+		},
+		cancel() {
+			e = void 0;
+		},
+		stop() {
+			if (!e) return 0;
+			let t = performance.now() - e;
+			return e = void 0, t;
+		}
+	};
+}, opposite = (e) => e === "cg-white" ? "cg-black" : "cg-white", distanceSq = (e, t) => {
+	let n = e[0] - t[0], r = e[1] - t[1];
+	return n * n + r * r;
+}, samePiece = (e, t) => e.role === t.role && e.color === t.color, posToTranslate = (e) => (t, n) => [(n ? t[0] : 7 - t[0]) * e.width / 8, (n ? 7 - t[1] : t[1]) * e.height / 8], translate = (e, t) => {
+	e.style.transform = `translate(${t[0]}px,${t[1]}px)`;
+}, translateAndScale = (e, t, n = 1) => {
+	e.style.transform = `translate(${t[0]}px,${t[1]}px) scale(${n})`;
+}, setVisible = (e, t) => {
+	e.style.visibility = t ? "visible" : "hidden";
+}, eventPosition = (e) => {
+	if (e.clientX || e.clientX === 0) return [e.clientX, e.clientY];
+	if (e.targetTouches?.[0]) return [e.targetTouches[0].clientX, e.targetTouches[0].clientY];
+}, isRightButton = (e) => e.button === 2, createEl = (e, t) => {
+	let n = document.createElement(e);
+	return t && (n.className = t), n;
+};
+function computeSquareCenter(e, t, n) {
+	let r = key2pos(e);
+	return t || (r[0] = 7 - r[0], r[1] = 7 - r[1]), [n.left + n.width * r[0] / 8 + n.width / 16, n.top + n.height * (7 - r[1]) / 8 + n.height / 16];
+}
+//#endregion
+//#region src/chess/chessground/premove.ts
+var diff = (e, t) => Math.abs(e - t), pawn = (e) => (t, n, r, i) => diff(t, r) < 2 && (e === "cg-white" ? i === n + 1 || n <= 1 && i === n + 2 && t === r : i === n - 1 || n >= 6 && i === n - 2 && t === r), knight = (e, t, n, r) => {
+	let i = diff(e, n), a = diff(t, r);
+	return i === 1 && a === 2 || i === 2 && a === 1;
+}, bishop = (e, t, n, r) => diff(e, n) === diff(t, r), rook = (e, t, n, r) => e === n || t === r, queen = (e, t, n, r) => bishop(e, t, n, r) || rook(e, t, n, r), king = (e, t, n) => (r, i, a, o) => diff(r, a) < 2 && diff(i, o) < 2 || n && i === o && i === (e === "cg-white" ? 0 : 7) && (r === 4 && (a === 2 && t.includes(0) || a === 6 && t.includes(7)) || t.includes(a));
+function rookFilesOf(e, t) {
+	let n = t === "cg-white" ? "1" : "8", r = [];
+	for (let [i, a] of e) i[1] === n && a.color === t && a.role === "rook" && r.push(key2pos(i)[0]);
+	return r;
+}
+function premove(e, t, n) {
+	let r = e.get(t);
+	if (!r) return [];
+	let i = key2pos(t), a = r.role, o = a === "pawn" ? pawn(r.color) : a === "knight" ? knight : a === "bishop" ? bishop : a === "rook" ? rook : a === "queen" ? queen : king(r.color, rookFilesOf(e, r.color), n);
+	return D.filter((e) => (i[0] !== e[0] || i[1] !== e[1]) && o(i[0], i[1], e[0], e[1])).map(pos2key);
+}
+//#endregion
+//#region src/chess/chessground/board.ts
+function callUserFunction(e, ...t) {
+	e && setTimeout(() => e(...t), 1);
+}
+function toggleOrientation(e) {
+	e.orientation = opposite(e.orientation), e.animation.current = e.draggable.current = e.selected = void 0;
+}
+function setPieces(e, t) {
+	for (let [n, r] of t) r ? e.pieces.set(n, r) : e.pieces.delete(n);
+}
+function setCheck(e, t) {
+	if (e.check = void 0, t === !0 && (t = e.turnColor), t) for (let [n, r] of e.pieces) r.role === "king" && r.color === t && (e.check = n);
+}
+function setPremove(e, t, n, r) {
+	unsetPredrop(e), e.premovable.current = [t, n], callUserFunction(e.premovable.events.set, t, n, r);
+}
+function unsetPremove(e) {
+	e.premovable.current && (e.premovable.current = void 0, callUserFunction(e.premovable.events.unset));
+}
+function setPredrop(e, t, n) {
+	unsetPremove(e), e.predroppable.current = {
+		role: t,
+		key: n
+	}, callUserFunction(e.predroppable.events.set, t, n);
+}
+function unsetPredrop(e) {
+	let t = e.predroppable;
+	t.current && (t.current = void 0, callUserFunction(t.events.unset));
+}
+function tryAutoCastle(e, t, n) {
+	if (!e.autoCastle) return !1;
+	let r = e.pieces.get(t);
+	if (!r || r.role !== "king") return !1;
+	let i = key2pos(t), a = key2pos(n);
+	if (i[1] !== 0 && i[1] !== 7 || i[1] !== a[1]) return !1;
+	i[0] === 4 && !e.pieces.has(n) && (a[0] === 6 ? n = pos2key([7, a[1]]) : a[0] === 2 && (n = pos2key([0, a[1]])));
+	let o = e.pieces.get(n);
+	return !o || o.color !== r.color || o.role !== "rook" ? !1 : (e.pieces.delete(t), e.pieces.delete(n), i[0] < a[0] ? (e.pieces.set(pos2key([6, a[1]]), r), e.pieces.set(pos2key([5, a[1]]), o)) : (e.pieces.set(pos2key([2, a[1]]), r), e.pieces.set(pos2key([3, a[1]]), o)), !0);
+}
+function baseMove(e, t, n) {
+	let r = e.pieces.get(t), i = e.pieces.get(n);
+	if (t === n || !r) return !1;
+	let a = i && i.color !== r.color ? i : void 0;
+	return n === e.selected && unselect(e), callUserFunction(e.events.move, t, n, a), tryAutoCastle(e, t, n) || (e.pieces.set(n, r), e.pieces.delete(t)), e.lastMove = [t, n], e.check = void 0, callUserFunction(e.events.change), a || !0;
+}
+function baseNewPiece(e, t, n, r) {
+	if (e.pieces.has(n)) if (r) e.pieces.delete(n);
+	else return !1;
+	return callUserFunction(e.events.dropNewPiece, t, n), e.pieces.set(n, t), e.lastMove = [n], e.check = void 0, callUserFunction(e.events.change), e.movable.dests = void 0, e.turnColor = opposite(e.turnColor), !0;
+}
+function baseUserMove(e, t, n) {
+	let r = baseMove(e, t, n);
+	return r && (e.movable.dests = void 0, e.turnColor = opposite(e.turnColor), e.animation.current = void 0), r;
+}
+function userMove(e, t, n) {
+	if (canMove(e, t, n)) {
+		let r = baseUserMove(e, t, n);
+		if (r) {
+			let i = e.hold.stop();
+			unselect(e);
+			let a = {
+				premove: !1,
+				ctrlKey: e.stats.ctrlKey,
+				holdTime: i
+			};
+			return r !== !0 && (a.captured = r), callUserFunction(e.movable.events.after, t, n, a), !0;
+		}
+	} else if (canPremove(e, t, n)) return setPremove(e, t, n, { ctrlKey: e.stats.ctrlKey }), unselect(e), !0;
+	return unselect(e), !1;
+}
+function dropNewPiece(e, t, n, r) {
+	let i = e.pieces.get(t);
+	i && (canDrop(e, t, n) || r) ? (e.pieces.delete(t), baseNewPiece(e, i, n, r), callUserFunction(e.movable.events.afterNewPiece, i.role, n, {
+		premove: !1,
+		predrop: !1
+	})) : i && canPredrop(e, t, n) ? setPredrop(e, i.role, n) : (unsetPremove(e), unsetPredrop(e)), e.pieces.delete(t), unselect(e);
+}
+function selectSquare(e, t, n) {
+	if (callUserFunction(e.events.select, t), e.selected) {
+		if (e.selected === t && !e.draggable.enabled) {
+			unselect(e), e.hold.cancel();
+			return;
+		} else if ((e.selectable.enabled || n) && e.selected !== t && userMove(e, e.selected, t)) {
+			e.stats.dragged = !1;
+			return;
+		}
+	}
+	(e.selectable.enabled || e.draggable.enabled) && (isMovable(e, t) || isPremovable(e, t)) && (setSelected(e, t), e.hold.start());
+}
+function setSelected(e, t) {
+	e.selected = t, isPremovable(e, t) ? e.premovable.customDests || (e.premovable.dests = premove(e.pieces, t, e.premovable.castle)) : e.premovable.dests = void 0;
+}
+function unselect(e) {
+	e.selected = void 0, e.premovable.dests = void 0, e.hold.cancel();
+}
+function isMovable(e, t) {
+	let n = e.pieces.get(t);
+	return !!n && (e.movable.color === "both" || e.movable.color === n.color && e.turnColor === n.color);
+}
+var canMove = (e, t, n) => t !== n && isMovable(e, t) && (e.movable.free || !!e.movable.dests?.get(t)?.includes(n));
+function canDrop(e, t, n) {
+	let r = e.pieces.get(t);
+	return !!r && (t === n || !e.pieces.has(n)) && (e.movable.color === "both" || e.movable.color === r.color && e.turnColor === r.color);
+}
+function isPremovable(e, t) {
+	let n = e.pieces.get(t);
+	return !!n && e.premovable.enabled && e.movable.color === n.color && e.turnColor !== n.color;
+}
+function canPremove(e, t, n) {
+	let r = e.premovable.customDests?.get(t) ?? premove(e.pieces, t, e.premovable.castle);
+	return t !== n && isPremovable(e, t) && r.includes(n);
+}
+function canPredrop(e, t, n) {
+	let r = e.pieces.get(t), i = e.pieces.get(n);
+	return !!r && (!i || i.color !== e.movable.color) && e.predroppable.enabled && (r.role !== "pawn" || n[1] !== "1" && n[1] !== "8") && e.movable.color === r.color && e.turnColor !== r.color;
+}
+function isDraggable(e, t) {
+	let n = e.pieces.get(t);
+	return !!n && e.draggable.enabled && (e.movable.color === "both" || e.movable.color === n.color && (e.turnColor === n.color || e.premovable.enabled));
+}
+function playPremove(e) {
+	let t = e.premovable.current;
+	if (!t) return !1;
+	let n = t[0], r = t[1], i = !1;
+	if (canMove(e, n, r)) {
+		let t = baseUserMove(e, n, r);
+		if (t) {
+			let a = { premove: !0 };
+			t !== !0 && (a.captured = t), callUserFunction(e.movable.events.after, n, r, a), i = !0;
+		}
+	}
+	return unsetPremove(e), i;
+}
+function playPredrop(e, t) {
+	let n = e.predroppable.current, r = !1;
+	return n ? (t(n) && baseNewPiece(e, {
+		role: n.role,
+		color: e.movable.color
+	}, n.key) && (callUserFunction(e.movable.events.afterNewPiece, n.role, n.key, {
+		premove: !1,
+		predrop: !0
+	}), r = !0), unsetPredrop(e), r) : !1;
+}
+function cancelMove(e) {
+	unsetPremove(e), unsetPredrop(e), unselect(e);
+}
+function stop(e) {
+	e.movable.color = e.movable.dests = e.animation.current = void 0, cancelMove(e);
+}
+function getKeyAtDomPos(e, t, n) {
+	let r = Math.floor(8 * (e[0] - n.left) / n.width);
+	t || (r = 7 - r);
+	let i = 7 - Math.floor(8 * (e[1] - n.top) / n.height);
+	return t || (i = 7 - i), r >= 0 && r < 8 && i >= 0 && i < 8 ? pos2key([r, i]) : void 0;
+}
+function getSnappedKeyAtDomPos(e, t, n, r) {
+	let i = key2pos(e), a = D.filter((e) => queen(i[0], i[1], e[0], e[1]) || knight(i[0], i[1], e[0], e[1])), o = a.map((e) => computeSquareCenter(pos2key(e), n, r)).map((e) => distanceSq(t, e)), [, s] = o.reduce((e, t, n) => e[0] < t ? e : [t, n], [o[0], 0]);
+	return pos2key(a[s]);
+}
+var whitePov = (e) => e.orientation === "cg-white", O = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR", k = {
+	p: "pawn",
+	r: "rook",
+	n: "knight",
+	b: "bishop",
+	q: "queen",
+	k: "king"
+}, A = {
+	pawn: "p",
+	rook: "r",
+	knight: "n",
+	bishop: "b",
+	queen: "q",
+	king: "k"
+};
+function read(e) {
+	e === "start" && (e = O);
+	let t = /* @__PURE__ */ new Map(), n = 7, r = 0;
+	for (let i of e) switch (i) {
+		case " ":
+		case "[": return t;
+		case "/":
+			if (--n, n < 0) return t;
+			r = 0;
+			break;
+		case "~": {
+			let e = t.get(pos2key([r - 1, n]));
+			e && (e.promoted = !0);
+			break;
+		}
+		default: {
+			let e = i.charCodeAt(0);
+			if (e < 57) r += e - 48;
+			else {
+				let e = i.toLowerCase();
+				t.set(pos2key([r, n]), {
+					role: k[e],
+					color: i === e ? "cg-black" : "cg-white"
+				}), ++r;
+			}
+		}
+	}
+	return t;
+}
+function write(e) {
+	return T.map((t) => C.map((n) => {
+		let r = e.get(n + t);
+		if (r) {
+			let e = A[r.role];
+			return r.color === "cg-white" && (e = e.toUpperCase()), r.promoted && (e += "~"), e;
+		} else return "1";
+	}).join("")).join("/").replace(/1{2,}/g, (e) => e.length.toString());
+}
+//#endregion
+//#region src/chess/chessground/config.ts
+function applyAnimation(e, t) {
+	t.animation && (deepMerge(e.animation, t.animation), (e.animation.duration || 0) < 70 && (e.animation.enabled = !1));
+}
+function configure(e, t) {
+	if (t.movable?.dests && (e.movable.dests = void 0), t.drawable?.autoShapes && (e.drawable.autoShapes = []), deepMerge(e, t), t.fen && (e.pieces = read(t.fen), e.drawable.shapes = t.drawable?.shapes || []), "check" in t && setCheck(e, t.check || !1), "lastMove" in t && !t.lastMove ? e.lastMove = void 0 : t.lastMove && (e.lastMove = t.lastMove), e.selected && setSelected(e, e.selected), applyAnimation(e, t), !e.movable.rookCastle && e.movable.dests) {
+		let t = e.movable.color === "cg-white" ? "1" : "8", n = "e" + t, r = e.movable.dests.get(n), i = e.pieces.get(n);
+		if (!r || !i || i.role !== "king") return;
+		e.movable.dests.set(n, r.filter((e) => !(e === "a" + t && r.includes("c" + t)) && !(e === "h" + t && r.includes("g" + t))));
+	}
+}
+function deepMerge(e, t) {
+	for (let n in t) Object.prototype.hasOwnProperty.call(t, n) && (Object.prototype.hasOwnProperty.call(e, n) && isPlainObject(e[n]) && isPlainObject(t[n]) ? deepMerge(e[n], t[n]) : e[n] = t[n]);
+}
+function isPlainObject(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = Object.getPrototypeOf(e);
+	return t === Object.prototype || t === null;
+}
+//#endregion
+//#region src/chess/chessground/anim.ts
+var anim = (e, t) => t.animation.enabled ? animate(e, t) : render$2(e, t);
+function render$2(e, t) {
+	let n = e(t);
+	return t.dom.redraw(), n;
+}
+e(render$2, "render");
+var makePiece = (e, t) => ({
+	key: e,
+	pos: key2pos(e),
+	piece: t
+}), closer = (e, t) => t.sort((t, n) => distanceSq(e.pos, t.pos) - distanceSq(e.pos, n.pos))[0];
+function computePlan(e, t) {
+	let n = /* @__PURE__ */ new Map(), r = [], i = /* @__PURE__ */ new Map(), a = [], o = [], s = /* @__PURE__ */ new Map(), c, l, u;
+	for (let [t, n] of e) s.set(t, makePiece(t, n));
+	for (let e of E) c = t.pieces.get(e), l = s.get(e), c ? l ? samePiece(c, l.piece) || (a.push(l), o.push(makePiece(e, c))) : o.push(makePiece(e, c)) : l && a.push(l);
+	for (let e of o) l = closer(e, a.filter((t) => samePiece(e.piece, t.piece))), l && (u = [l.pos[0] - e.pos[0], l.pos[1] - e.pos[1]], n.set(e.key, u.concat(u)), r.push(l.key));
+	for (let e of a) r.includes(e.key) || i.set(e.key, e.piece);
+	return {
+		anims: n,
+		fadings: i
+	};
+}
+function step(e, t) {
+	let n = e.animation.current;
+	if (n === void 0) {
+		e.dom.destroyed || e.dom.redrawNow();
+		return;
+	}
+	let r = 1 - (t - n.start) * n.frequency;
+	if (r <= 0) e.animation.current = void 0, e.dom.redrawNow();
+	else {
+		let t = easing(r);
+		for (let e of n.plan.anims.values()) e[2] = e[0] * t, e[3] = e[1] * t;
+		e.dom.redrawNow(!0), requestAnimationFrame((t = performance.now()) => step(e, t));
+	}
+}
+function animate(e, t) {
+	let n = new Map(t.pieces), r = e(t), i = computePlan(n, t);
+	if (i.anims.size || i.fadings.size) {
+		let e = t.animation.current && t.animation.current.start;
+		t.animation.current = {
+			start: performance.now(),
+			frequency: 1 / t.animation.duration,
+			plan: i
+		}, e || step(t, performance.now());
+	} else t.dom.redraw();
+	return r;
+}
+var easing = (e) => e < .5 ? 4 * e * e * e : (e - 1) * (2 * e - 2) * (2 * e - 2) + 1, j = [
+	"green",
+	"red",
+	"blue",
+	"yellow"
+];
+function start$2(e, t) {
+	if (t.touches && t.touches.length > 1) return;
+	t.stopPropagation(), t.preventDefault(), t.ctrlKey ? unselect(e) : cancelMove(e);
+	let n = eventPosition(t), r = getKeyAtDomPos(n, whitePov(e), e.dom.bounds());
+	r && (e.drawable.current = {
+		orig: r,
+		pos: n,
+		brush: eventBrush(t),
+		snapToValidMove: e.drawable.defaultSnapToValidMove
+	}, processDraw(e));
+}
+e(start$2, "start");
+function processDraw(e) {
+	requestAnimationFrame(() => {
+		let t = e.drawable.current;
+		if (t) {
+			let n = getKeyAtDomPos(t.pos, whitePov(e), e.dom.bounds());
+			n || (t.snapToValidMove = !1);
+			let r = t.snapToValidMove ? getSnappedKeyAtDomPos(t.orig, t.pos, whitePov(e), e.dom.bounds()) : n;
+			r !== t.mouseSq && (t.mouseSq = r, t.dest = r === t.orig ? void 0 : r, e.dom.redrawNow()), processDraw(e);
+		}
+	});
+}
+function move$1(e, t) {
+	e.drawable.current && (e.drawable.current.pos = eventPosition(t));
+}
+e(move$1, "move");
+function end$1(e) {
+	let t = e.drawable.current;
+	t && (t.mouseSq && addShape(e.drawable, t), cancel$1(e));
+}
+e(end$1, "end");
+function cancel$1(e) {
+	e.drawable.current && (e.drawable.current = void 0, e.dom.redraw());
+}
+e(cancel$1, "cancel");
+function clear(e) {
+	e.drawable.shapes.length && (e.drawable.shapes = [], e.dom.redraw(), onChange(e.drawable));
+}
+function eventBrush(e) {
+	let t = (e.shiftKey || e.ctrlKey) && isRightButton(e), n = e.altKey || e.metaKey || e.getModifierState?.("AltGraph");
+	return j[(t ? 1 : 0) + (n ? 2 : 0)];
+}
+function addShape(e, t) {
+	let sameShape = (e) => e.orig === t.orig && e.dest === t.dest, n = e.shapes.find(sameShape);
+	n && (e.shapes = e.shapes.filter((e) => !sameShape(e))), (!n || n.brush !== t.brush) && e.shapes.push({
+		orig: t.orig,
+		dest: t.dest,
+		brush: t.brush
+	}), onChange(e);
+}
+function onChange(e) {
+	e.onChange && e.onChange(e.shapes);
+}
+//#endregion
+//#region src/chess/chessground/drag.ts
+function start$1(e, t) {
+	if (!(e.trustAllEvents || t.isTrusted) || t.buttons !== void 0 && t.buttons > 1 || t.touches && t.touches.length > 1) return;
+	let n = e.dom.bounds(), r = eventPosition(t), i = getKeyAtDomPos(r, whitePov(e), n);
+	if (!i) return;
+	let a = e.pieces.get(i), o = e.selected;
+	if (!o && e.drawable.enabled && (e.drawable.eraseOnClick || !a || a.color !== e.turnColor) && clear(e), t.cancelable !== !1 && (!t.touches || e.blockTouchScroll || a || o || pieceCloseTo(e, r))) t.preventDefault();
+	else if (t.touches) return;
+	let s = !!e.premovable.current, c = !!e.predroppable.current;
+	e.stats.ctrlKey = t.ctrlKey, e.selected && canMove(e, e.selected, i) ? anim((e) => selectSquare(e, i), e) : selectSquare(e, i);
+	let l = e.selected === i, u = pieceElementByKey(e, i);
+	if (a && u && l && isDraggable(e, i)) {
+		e.draggable.current = {
+			orig: i,
+			piece: a,
+			origPos: r,
+			pos: r,
+			started: e.draggable.autoDistance && e.stats.dragged,
+			element: u,
+			previouslySelected: o,
+			originTarget: t.target,
+			keyHasChanged: !1
+		}, u.cgDragging = !0, u.classList.add("dragging");
+		let s = e.dom.elements.ghost;
+		s && (s.className = `ghost ${a.color} ${a.role}`, translate(s, posToTranslate(n)(key2pos(i), whitePov(e))), setVisible(s, !0)), processDrag(e);
+	} else s && unsetPremove(e), c && unsetPredrop(e);
+	e.dom.redraw();
+}
+e(start$1, "start");
+function pieceCloseTo(e, t) {
+	let n = whitePov(e), r = e.dom.bounds(), i = (r.width / 8) ** 2;
+	for (let a of e.pieces.keys()) if (distanceSq(computeSquareCenter(a, n, r), t) <= i) return !0;
+	return !1;
+}
+function dragNewPiece(e, t, n, r) {
+	e.pieces.set("a0", t), e.dom.redraw();
+	let i = eventPosition(n);
+	e.draggable.current = {
+		orig: "a0",
+		piece: t,
+		origPos: i,
+		pos: i,
+		started: !0,
+		element: () => pieceElementByKey(e, "a0"),
+		originTarget: n.target,
+		newPiece: !0,
+		force: !!r,
+		keyHasChanged: !1
+	}, processDrag(e);
+}
+function processDrag(e) {
+	requestAnimationFrame(() => {
+		let t = e.draggable.current;
+		if (!t) return;
+		e.animation.current?.plan.anims.has(t.orig) && (e.animation.current = void 0);
+		let n = e.pieces.get(t.orig);
+		if (!n || !samePiece(n, t.piece)) cancel(e);
+		else if (!t.started && distanceSq(t.pos, t.origPos) >= e.draggable.distance ** 2 && (t.started = !0), t.started) {
+			if (typeof t.element == "function") {
+				let e = t.element();
+				if (!e) return;
+				e.cgDragging = !0, e.classList.add("dragging"), t.element = e;
+			}
+			let n = e.dom.bounds();
+			translate(t.element, [t.pos[0] - n.left - n.width / 16, t.pos[1] - n.top - n.height / 16]), t.keyHasChanged = t.keyHasChanged || t.orig !== getKeyAtDomPos(t.pos, whitePov(e), n);
+		}
+		processDrag(e);
+	});
+}
+function move(e, t) {
+	e.draggable.current && (!t.touches || t.touches.length < 2) && (e.draggable.current.pos = eventPosition(t));
+}
+function end(e, t) {
+	let n = e.draggable.current;
+	if (!n) return;
+	if (t.type === "touchend" && t.cancelable !== !1 && t.preventDefault(), t.type === "touchend" && n.originTarget !== t.target && !n.newPiece) {
+		e.draggable.current = void 0;
+		return;
+	}
+	unsetPremove(e), unsetPredrop(e);
+	let r = getKeyAtDomPos(eventPosition(t) || n.pos, whitePov(e), e.dom.bounds());
+	r && n.started && n.orig !== r ? n.newPiece ? dropNewPiece(e, n.orig, r, n.force) : (e.stats.ctrlKey = t.ctrlKey, userMove(e, n.orig, r) && (e.stats.dragged = !0)) : n.newPiece ? e.pieces.delete(n.orig) : e.draggable.deleteOnDropOff && !r && (e.pieces.delete(n.orig), callUserFunction(e.events.change)), (n.orig === n.previouslySelected || n.keyHasChanged) && (n.orig === r || !r) ? unselect(e) : e.selectable.enabled || unselect(e), removeDragElements(e), e.draggable.current = void 0, e.dom.redraw();
+}
+function cancel(e) {
+	let t = e.draggable.current;
+	t && (t.newPiece && e.pieces.delete(t.orig), e.draggable.current = void 0, unselect(e), removeDragElements(e), e.dom.redraw());
+}
+function removeDragElements(e) {
+	let t = e.dom.elements;
+	t.ghost && setVisible(t.ghost, !1);
+}
+function pieceElementByKey(e, t) {
+	let n = e.dom.elements.board.firstChild;
+	for (; n;) {
+		if (n.cgKey === t && n.tagName === "PIECE") return n;
+		n = n.nextSibling;
+	}
+}
+//#endregion
+//#region src/chess/chessground/explosion.ts
+function explosion(e, t) {
+	e.exploding = {
+		stage: 1,
+		keys: t
+	}, e.dom.redraw(), setTimeout(() => {
+		setStage(e, 2), setTimeout(() => setStage(e, void 0), 120);
+	}, 120);
+}
+function setStage(e, t) {
+	e.exploding && (t ? e.exploding.stage = t : e.exploding = void 0, e.dom.redraw());
+}
+//#endregion
+//#region src/chess/chessground/api.ts
+function start(t, n) {
+	function toggleOrientation$1() {
+		toggleOrientation(t), n();
+	}
+	return e(toggleOrientation$1, "toggleOrientation"), {
+		set(e) {
+			e.orientation && e.orientation !== t.orientation && toggleOrientation$1(), applyAnimation(t, e), (e.fen ? anim : render$2)((t) => configure(t, e), t);
+		},
+		state: t,
+		getFen: () => write(t.pieces),
+		toggleOrientation: toggleOrientation$1,
+		setPieces(e) {
+			anim((t) => setPieces(t, e), t);
+		},
+		selectSquare(e, n) {
+			e ? anim((t) => selectSquare(t, e, n), t) : t.selected && (unselect(t), t.dom.redraw());
+		},
+		move(e, n) {
+			anim((t) => baseMove(t, e, n), t);
+		},
+		newPiece(e, n) {
+			anim((t) => baseNewPiece(t, e, n), t);
+		},
+		playPremove() {
+			if (t.premovable.current) {
+				if (anim(playPremove, t)) return !0;
+				t.dom.redraw();
+			}
+			return !1;
+		},
+		playPredrop(e) {
+			if (t.predroppable.current) {
+				let n = playPredrop(t, e);
+				return t.dom.redraw(), n;
+			}
+			return !1;
+		},
+		cancelPremove() {
+			render$2(unsetPremove, t);
+		},
+		cancelPredrop() {
+			render$2(unsetPredrop, t);
+		},
+		cancelMove() {
+			render$2((e) => {
+				cancelMove(e), cancel(e);
+			}, t);
+		},
+		stop() {
+			render$2((e) => {
+				stop(e), cancel(e);
+			}, t);
+		},
+		explode(e) {
+			explosion(t, e);
+		},
+		setAutoShapes(e) {
+			render$2((t) => t.drawable.autoShapes = e, t);
+		},
+		setShapes(e) {
+			render$2((t) => t.drawable.shapes = e, t);
+		},
+		getKeyAtDomPos(e) {
+			return getKeyAtDomPos(e, whitePov(t), t.dom.bounds());
+		},
+		redrawAll: n,
+		dragNewPiece(e, n, r) {
+			dragNewPiece(t, e, n, r);
+		},
+		destroy() {
+			stop(t), t.dom.unbind?.(), t.dom.destroyed = !0;
+		}
+	};
+}
+//#endregion
+//#region src/chess/chessground/state.ts
+function defaults() {
+	return {
+		pieces: read(O),
+		orientation: "cg-white",
+		turnColor: "cg-white",
+		coordinates: !0,
+		coordinatesOnSquares: !1,
+		ranksPosition: "right",
+		autoCastle: !0,
+		viewOnly: !1,
+		disableContextMenu: !1,
+		addPieceZIndex: !1,
+		blockTouchScroll: !1,
+		pieceKey: !1,
+		trustAllEvents: !1,
+		highlight: {
+			lastMove: !0,
+			check: !0
+		},
+		animation: {
+			enabled: !0,
+			duration: 200
+		},
+		movable: {
+			free: !0,
+			color: "both",
+			showDests: !0,
+			events: {},
+			rookCastle: !0
+		},
+		premovable: {
+			enabled: !0,
+			showDests: !0,
+			castle: !0,
+			events: {}
+		},
+		predroppable: {
+			enabled: !1,
+			events: {}
+		},
+		draggable: {
+			enabled: !0,
+			distance: 3,
+			autoDistance: !0,
+			showGhost: !0,
+			deleteOnDropOff: !1
+		},
+		dropmode: { active: !1 },
+		selectable: { enabled: !0 },
+		stats: { dragged: !("ontouchstart" in window) },
+		events: {},
+		drawable: {
+			enabled: !0,
+			visible: !0,
+			defaultSnapToValidMove: !0,
+			eraseOnClick: !0,
+			shapes: [],
+			autoShapes: [],
+			brushes: {
+				green: {
+					key: "g",
+					color: "#15781B",
+					opacity: 1,
+					lineWidth: 10
+				},
+				red: {
+					key: "r",
+					color: "#882020",
+					opacity: 1,
+					lineWidth: 10
+				},
+				blue: {
+					key: "b",
+					color: "#003088",
+					opacity: 1,
+					lineWidth: 10
+				},
+				yellow: {
+					key: "y",
+					color: "#e68f00",
+					opacity: 1,
+					lineWidth: 10
+				},
+				paleBlue: {
+					key: "pb",
+					color: "#003088",
+					opacity: .4,
+					lineWidth: 15
+				},
+				paleGreen: {
+					key: "pg",
+					color: "#15781B",
+					opacity: .4,
+					lineWidth: 15
+				},
+				paleRed: {
+					key: "pr",
+					color: "#882020",
+					opacity: .4,
+					lineWidth: 15
+				},
+				paleGrey: {
+					key: "pgr",
+					color: "#4a4a4a",
+					opacity: .35,
+					lineWidth: 15
+				},
+				purple: {
+					key: "purple",
+					color: "#68217a",
+					opacity: .65,
+					lineWidth: 10
+				},
+				pink: {
+					key: "pink",
+					color: "#ee2080",
+					opacity: .5,
+					lineWidth: 10
+				},
+				white: {
+					key: "white",
+					color: "white",
+					opacity: 1,
+					lineWidth: 10
+				}
+			},
+			prevSvgHash: ""
+		},
+		hold: timer()
+	};
+}
+//#endregion
+//#region src/chess/chessground/svg.ts
+var M = {
+	hilitePrimary: {
+		key: "hilitePrimary",
+		color: "#3291ff",
+		opacity: 1,
+		lineWidth: 1
+	},
+	hiliteWhite: {
+		key: "hiliteWhite",
+		color: "#ffffff",
+		opacity: 1,
+		lineWidth: 1
+	}
+};
+function createDefs() {
+	let e = createElement("defs"), t = setAttributes(createElement("filter"), { id: "cg-filter-blur" });
+	return t.appendChild(setAttributes(createElement("feGaussianBlur"), { stdDeviation: "0.019" })), e.appendChild(t), e;
+}
+function renderSvg(e, t, n) {
+	let r = e.drawable, i = r.current, a = i && i.mouseSq ? i : void 0, o = /* @__PURE__ */ new Map(), s = e.dom.bounds(), c = r.autoShapes.filter((e) => !e.piece);
+	for (let t of r.shapes.concat(c).concat(a ? [a] : [])) {
+		if (!t.dest) continue;
+		let n = o.get(t.dest) ?? /* @__PURE__ */ new Set(), r = pos2user(orient(key2pos(t.orig), e.orientation), s), i = pos2user(orient(key2pos(t.dest), e.orientation), s);
+		n.add(moveAngle(r, i)), o.set(t.dest, n);
+	}
+	let l = r.shapes.concat(c).map((e) => ({
+		shape: e,
+		current: !1,
+		hash: shapeHash(e, isShort(e.dest, o), !1, s)
+	}));
+	a && l.push({
+		shape: a,
+		current: !0,
+		hash: shapeHash(a, isShort(a.dest, o), !0, s)
+	});
+	let u = l.map((e) => e.hash).join(";");
+	u !== e.drawable.prevSvgHash && (e.drawable.prevSvgHash = u, syncDefs(r, l, t.querySelector("defs")), syncShapes$1(l, t.querySelector("g"), n.querySelector("g"), (t) => renderShape$1(e, t, r.brushes, o, s)));
+}
+function syncDefs(e, t, n) {
+	let r = /* @__PURE__ */ new Map(), i;
+	for (let n of t.filter((e) => e.shape.dest && e.shape.brush)) i = makeCustomBrush(e.brushes[n.shape.brush], n.shape.modifiers), n.shape.modifiers?.hilite && r.set(hilite(i).key, hilite(i)), r.set(i.key, i);
+	let a = /* @__PURE__ */ new Set(), o = n.firstElementChild;
+	for (; o;) a.add(o.getAttribute("cgKey")), o = o.nextElementSibling;
+	for (let [e, t] of r.entries()) a.has(e) || n.appendChild(renderMarker(t));
+}
+function syncShapes$1(e, t, n, r) {
+	let i = /* @__PURE__ */ new Map();
+	for (let t of e) i.set(t.hash, !1);
+	for (let e of [t, n]) {
+		let t = [], n = e.firstElementChild, r;
+		for (; n;) r = n.getAttribute("cgHash"), i.has(r) ? i.set(r, !0) : t.push(n), n = n.nextElementSibling;
+		for (let n of t) e.removeChild(n);
+	}
+	for (let a of e.filter((e) => !i.get(e.hash))) for (let e of r(a)) e.isCustom ? n.appendChild(e.el) : t.appendChild(e.el);
+}
+e(syncShapes$1, "syncShapes");
+function shapeHash({ orig: e, dest: t, brush: n, piece: r, modifiers: i, customSvg: a, label: o }, s, c, l) {
+	return [
+		l.width,
+		l.height,
+		c,
+		e,
+		t,
+		n,
+		s && "-",
+		r && pieceHash(r),
+		i && modifiersHash(i),
+		a && `custom-${textHash(a.html)},${a.center?.[0] ?? "o"}`,
+		o && `label-${textHash(o.text)}`
+	].filter((e) => e).join(",");
+}
+function pieceHash(e) {
+	return [
+		e.color,
+		e.role,
+		e.scale
+	].filter((e) => e).join(",");
+}
+function modifiersHash(e) {
+	return [e.lineWidth, e.hilite && "*"].filter((e) => e).join(",");
+}
+function textHash(e) {
+	let t = 0;
+	for (let n = 0; n < e.length; n++) t = (t << 5) - t + e.charCodeAt(n) >>> 0;
+	return t.toString();
+}
+function renderShape$1(e, { shape: t, current: n, hash: r }, i, a, o) {
+	let s = pos2user(orient(key2pos(t.orig), e.orientation), o), c = t.dest ? pos2user(orient(key2pos(t.dest), e.orientation), o) : s, l = t.brush && makeCustomBrush(i[t.brush], t.modifiers), u = a.get(t.dest), d = [];
+	if (l) {
+		let e = setAttributes(createElement("g"), { cgHash: r });
+		d.push({ el: e }), s[0] !== c[0] || s[1] !== c[1] ? e.appendChild(renderArrow(t, l, s, c, n, isShort(t.dest, a))) : e.appendChild(renderCircle(i[t.brush], s, n, o));
+	}
+	if (t.label) {
+		let e = t.label;
+		e.fill || t.brush && i[t.brush] && (e.fill = i[t.brush].color);
+		let n = t.brush ? void 0 : "tr";
+		d.push({
+			el: renderLabel(e, r, s, c, u, n),
+			isCustom: !0
+		});
+	}
+	if (t.customSvg) {
+		let e = t.customSvg.center ?? "orig", [n, i] = e === "label" ? labelCoords(s, c, u).map((e) => e - .5) : e === "dest" ? c : s, a = setAttributes(createElement("g"), {
+			transform: `translate(${n},${i})`,
+			cgHash: r
+		});
+		a.innerHTML = `<svg width="1" height="1" viewBox="0 0 100 100">${t.customSvg.html}</svg>`, d.push({
+			el: a,
+			isCustom: !0
+		});
+	}
+	return d;
+}
+e(renderShape$1, "renderShape");
+function renderCircle(e, t, n, r) {
+	let i = circleWidth(), a = (r.width + r.height) / (4 * Math.max(r.width, r.height));
+	return setAttributes(createElement("circle"), {
+		stroke: e.color,
+		"stroke-width": i[n ? 0 : 1],
+		fill: "none",
+		opacity: opacity(e, n),
+		cx: t[0],
+		cy: t[1],
+		r: a - i[1] / 2
+	});
+}
+function hilite(e) {
+	return [
+		"#ffffff",
+		"#fff",
+		"white"
+	].includes(e.color) ? M.hilitePrimary : M.hiliteWhite;
+}
+function renderArrow(e, t, n, r, i, a) {
+	function renderLine(o) {
+		let s = arrowMargin(a && !i), c = r[0] - n[0], l = r[1] - n[1], u = Math.atan2(l, c), d = Math.cos(u) * s, f = Math.sin(u) * s;
+		return setAttributes(createElement("line"), {
+			stroke: o ? hilite(t).color : t.color,
+			"stroke-width": lineWidth(t, i) + (o ? .04 : 0),
+			"stroke-linecap": "round",
+			"marker-end": `url(#arrowhead-${o ? hilite(t).key : t.key})`,
+			opacity: e.modifiers?.hilite ? 1 : opacity(t, i),
+			x1: n[0],
+			y1: n[1],
+			x2: r[0] - d,
+			y2: r[1] - f
+		});
+	}
+	if (!e.modifiers?.hilite) return renderLine(!1);
+	let o = createElement("g"), s = setAttributes(createElement("g"), { filter: "url(#cg-filter-blur)" });
+	return s.appendChild(filterBox(n, r)), s.appendChild(renderLine(!0)), o.appendChild(s), o.appendChild(renderLine(!1)), o;
+}
+function renderMarker(e) {
+	let t = setAttributes(createElement("marker"), {
+		id: "arrowhead-" + e.key,
+		orient: "auto",
+		overflow: "visible",
+		markerWidth: 4,
+		markerHeight: 4,
+		refX: e.key.startsWith("hilite") ? 1.86 : 2.05,
+		refY: 2
+	});
+	return t.appendChild(setAttributes(createElement("path"), {
+		d: "M0,0 V4 L3,2 Z",
+		fill: e.color
+	})), t.setAttribute("cgKey", e.key), t;
+}
+function renderLabel(e, t, n, r, i, a) {
+	let o = .4, s = o * .75 ** e.text.length, c = labelCoords(n, r, i), l = a === "tr" ? .4 : 0, u = setAttributes(createElement("g"), {
+		transform: `translate(${c[0] + l},${c[1] - l})`,
+		cgHash: t
+	});
+	u.appendChild(setAttributes(createElement("circle"), {
+		r: o / 2,
+		"fill-opacity": a ? 1 : .8,
+		"stroke-opacity": a ? 1 : .7,
+		"stroke-width": .03,
+		fill: e.fill ?? "#666",
+		stroke: "white"
+	}));
+	let d = setAttributes(createElement("text"), {
+		"font-size": s,
+		"font-family": "Noto Sans",
+		"text-anchor": "middle",
+		fill: "white",
+		y: .13 * .75 ** e.text.length
+	});
+	return d.innerHTML = e.text, u.appendChild(d), u;
+}
+function orient(e, t) {
+	return t === "cg-white" ? e : [7 - e[0], 7 - e[1]];
+}
+function isShort(e, t) {
+	return !0 === (e && t.has(e) && t.get(e).size > 1);
+}
+function createElement(e) {
+	return document.createElementNS("http://www.w3.org/2000/svg", e);
+}
+function setAttributes(e, t) {
+	for (let n in t) Object.prototype.hasOwnProperty.call(t, n) && e.setAttribute(n, t[n]);
+	return e;
+}
+function makeCustomBrush(e, t) {
+	return t ? {
+		color: e.color,
+		opacity: Math.round(e.opacity * 10) / 10,
+		lineWidth: Math.round(t.lineWidth || e.lineWidth),
+		key: [e.key, t.lineWidth].filter((e) => e).join("")
+	} : e;
+}
+function circleWidth() {
+	return [3 / 64, 4 / 64];
+}
+function lineWidth(e, t) {
+	return (e.lineWidth || 10) * (t ? .85 : 1) / 64;
+}
+function opacity(e, t) {
+	return (e.opacity || 1) * (t ? .9 : 1);
+}
+function arrowMargin(e) {
+	return (e ? 20 : 10) / 64;
+}
+function pos2user(e, t) {
+	let n = Math.min(1, t.width / t.height), r = Math.min(1, t.height / t.width);
+	return [(e[0] - 3.5) * n, (3.5 - e[1]) * r];
+}
+function filterBox(e, t) {
+	let n = {
+		from: [Math.floor(Math.min(e[0], t[0])), Math.floor(Math.min(e[1], t[1]))],
+		to: [Math.ceil(Math.max(e[0], t[0])), Math.ceil(Math.max(e[1], t[1]))]
+	};
+	return setAttributes(createElement("rect"), {
+		x: n.from[0],
+		y: n.from[1],
+		width: n.to[0] - n.from[0],
+		height: n.to[1] - n.from[1],
+		fill: "none",
+		stroke: "none"
+	});
+}
+function moveAngle(e, t, n = !0) {
+	let r = Math.atan2(t[1] - e[1], t[0] - e[0]) + Math.PI;
+	return n ? (Math.round(r * 8 / Math.PI) + 16) % 16 : r;
+}
+function dist(e, t) {
+	return Math.sqrt([e[0] - t[0], e[1] - t[1]].reduce((e, t) => e + t * t, 0));
+}
+function labelCoords(e, t, n) {
+	let r = dist(e, t), i = moveAngle(e, t, !1);
+	if (n && (r -= 33 / 64, n.size > 1)) {
+		r -= 10 / 64;
+		let i = moveAngle(e, t);
+		(n.has((i + 1) % 16) || n.has((i + 15) % 16)) && i & 1 && (r -= .4);
+	}
+	return [e[0] - Math.cos(i) * r, e[1] - Math.sin(i) * r].map((e) => e + .5);
+}
+//#endregion
+//#region src/chess/chessground/wrap.ts
+function renderWrap(e, t) {
+	e.innerHTML = "", e.classList.add("cg-wrap");
+	for (let n of S) e.classList.toggle("orientation-" + n, t.orientation === n);
+	e.classList.toggle("manipulable", !t.viewOnly);
+	let n = createEl("cg-container");
+	e.appendChild(n);
+	let r = createEl("cg-board");
+	n.appendChild(r);
+	let i, a, o;
+	if (t.drawable.visible && (i = setAttributes(createElement("svg"), {
+		class: "cg-shapes",
+		viewBox: "-4 -4 8 8",
+		preserveAspectRatio: "xMidYMid slice"
+	}), i.appendChild(createDefs()), i.appendChild(createElement("g")), a = setAttributes(createElement("svg"), {
+		class: "cg-custom-svgs",
+		viewBox: "-3.5 -3.5 8 8",
+		preserveAspectRatio: "xMidYMid slice"
+	}), a.appendChild(createElement("g")), o = createEl("cg-auto-pieces"), n.appendChild(i), n.appendChild(a), n.appendChild(o)), t.coordinates) {
+		let e = t.orientation === "cg-black" ? " black" : "", r = t.ranksPosition === "left" ? " left" : "";
+		if (t.coordinatesOnSquares) {
+			let i = t.orientation === "cg-white" ? (e) => e + 1 : (e) => 8 - e;
+			C.forEach((t, a) => n.appendChild(renderCoords(w.map((e) => t + e), "squares rank" + i(a) + e + r)));
+		} else n.appendChild(renderCoords(w, "ranks" + e + r)), n.appendChild(renderCoords(C, "files" + e));
+	}
+	let s;
+	return t.draggable.enabled && t.draggable.showGhost && (s = createEl("piece", "ghost"), setVisible(s, !1), n.appendChild(s)), {
+		board: r,
+		container: n,
+		wrap: e,
+		ghost: s,
+		svg: i,
+		customSvg: a,
+		autoPieces: o
+	};
+}
+function renderCoords(e, t) {
+	let n = createEl("coords", t), r;
+	for (let t of e) r = createEl("coord"), r.textContent = t, n.appendChild(r);
+	return n;
+}
+//#endregion
+//#region src/chess/chessground/drop.ts
+function drop(e, t) {
+	if (!e.dropmode.active) return;
+	unsetPremove(e), unsetPredrop(e);
+	let n = e.dropmode.piece;
+	if (n) {
+		e.pieces.set("a0", n);
+		let r = eventPosition(t), i = r && getKeyAtDomPos(r, whitePov(e), e.dom.bounds());
+		i && dropNewPiece(e, "a0", i);
+	}
+	e.dom.redraw();
+}
+//#endregion
+//#region src/chess/chessground/events.ts
+function bindBoard(e) {
+	let t = e.dom.elements.board;
+	if ((e.disableContextMenu || e.drawable.enabled) && t.addEventListener("contextmenu", (e) => e.preventDefault()), e.viewOnly) return;
+	let n = startDragOrDraw(e);
+	t.addEventListener("touchstart", n, { passive: !1 }), t.addEventListener("mousedown", n, { passive: !1 });
+}
+function bindDocument(e, t) {
+	let n = [];
+	if ("ResizeObserver" in window || n.push(unbindable(document.body, "chessground.resize", t)), !e.viewOnly) {
+		let t = dragOrDraw(e, move, move$1), r = dragOrDraw(e, end, end$1);
+		for (let e of ["touchmove", "mousemove"]) n.push(unbindable(document, e, t));
+		for (let e of ["touchend", "mouseup"]) n.push(unbindable(document, e, r));
+		let onScroll = () => e.dom.bounds.clear();
+		n.push(unbindable(document, "scroll", onScroll, {
+			capture: !0,
+			passive: !0
+		})), n.push(unbindable(window, "resize", onScroll, { passive: !0 }));
+	}
+	return () => n.forEach((e) => e());
+}
+function unbindable(e, t, n, r) {
+	return e.addEventListener(t, n, r), () => e.removeEventListener(t, n, r);
+}
+var startDragOrDraw = (e) => (t) => {
+	e.draggable.current ? cancel(e) : e.drawable.current ? cancel$1(e) : t.shiftKey || isRightButton(t) ? e.drawable.enabled && start$2(e, t) : e.viewOnly || (e.dropmode.active ? drop(e, t) : start$1(e, t));
+}, dragOrDraw = (e, t, n) => (r) => {
+	e.drawable.current ? e.drawable.enabled && n(e, r) : e.viewOnly || t(e, r);
+};
+//#endregion
+//#region src/chess/chessground/render.ts
+function render$1(e) {
+	let t = whitePov(e), n = posToTranslate(e.dom.bounds()), r = e.dom.elements.board, i = e.pieces, a = e.animation.current, o = a ? a.plan.anims : /* @__PURE__ */ new Map(), s = a ? a.plan.fadings : /* @__PURE__ */ new Map(), c = e.draggable.current, l = computeSquareClasses(e), u = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), m, h, g, _, v, y, b, x, S, C;
+	for (h = r.firstChild; h;) {
+		if (m = h.cgKey, isPieceNode(h)) if (g = i.get(m), v = o.get(m), y = s.get(m), _ = h.cgPiece, h.cgDragging && (!c || c.orig !== m) && (h.classList.remove("dragging"), translate(h, n(key2pos(m), t)), h.cgDragging = !1), !y && h.cgFading && (h.cgFading = !1, h.classList.remove("fading")), g) {
+			if (v && h.cgAnimating && _ === pieceNameOf(g)) {
+				let e = key2pos(m);
+				e[0] += v[2], e[1] += v[3], h.classList.add("anim"), translate(h, n(e, t));
+			} else h.cgAnimating && (h.cgAnimating = !1, h.classList.remove("anim"), translate(h, n(key2pos(m), t)), e.addPieceZIndex && (h.style.zIndex = posZIndex(key2pos(m), t)));
+			_ === pieceNameOf(g) && (!y || !h.cgFading) ? u.add(m) : y && _ === pieceNameOf(y) ? (h.classList.add("fading"), h.cgFading = !0) : appendValue(f, _, h);
+		} else appendValue(f, _, h);
+		else if (isSquareNode(h)) {
+			let e = h.className;
+			l.get(m) === e ? d.add(m) : appendValue(p, e, h);
+		}
+		h = h.nextSibling;
+	}
+	for (let [e, i] of l) if (!d.has(e)) {
+		S = p.get(i), C = S && S.pop();
+		let a = n(key2pos(e), t);
+		if (C) C.cgKey = e, translate(C, a);
+		else {
+			let t = createEl("square", i);
+			t.cgKey = e, translate(t, a), r.insertBefore(t, r.firstChild);
+		}
+	}
+	for (let [a, s] of i) if (v = o.get(a), !u.has(a)) if (b = f.get(pieceNameOf(s)), x = b && b.pop(), x) {
+		x.cgKey = a, x.cgFading && (x.classList.remove("fading"), x.cgFading = !1);
+		let r = key2pos(a);
+		e.addPieceZIndex && (x.style.zIndex = posZIndex(r, t)), v && (x.cgAnimating = !0, x.classList.add("anim"), r[0] += v[2], r[1] += v[3]), translate(x, n(r, t));
+	} else {
+		let i = pieceNameOf(s), o = createEl("piece", i), c = key2pos(a);
+		o.cgPiece = i, o.cgKey = a, v && (o.cgAnimating = !0, c[0] += v[2], c[1] += v[3]), translate(o, n(c, t)), e.addPieceZIndex && (o.style.zIndex = posZIndex(c, t)), r.appendChild(o);
+	}
+	for (let t of f.values()) removeNodes(e, t);
+	for (let t of p.values()) removeNodes(e, t);
+}
+e(render$1, "render");
+function renderResized$1(e) {
+	let t = whitePov(e), n = posToTranslate(e.dom.bounds()), r = e.dom.elements.board.firstChild;
+	for (; r;) (isPieceNode(r) && !r.cgAnimating || isSquareNode(r)) && translate(r, n(key2pos(r.cgKey), t)), r = r.nextSibling;
+}
+e(renderResized$1, "renderResized");
+function updateBounds(e) {
+	let t = e.dom.elements.wrap.getBoundingClientRect(), n = e.dom.elements.container, r = t.height / t.width, i = Math.floor(t.width * window.devicePixelRatio / 8) * 8 / window.devicePixelRatio, a = i * r;
+	n.style.width = i + "px", n.style.height = a + "px", e.dom.bounds.clear(), e.addDimensionsCssVarsTo?.style.setProperty("---cg-width", i + "px"), e.addDimensionsCssVarsTo?.style.setProperty("---cg-height", a + "px");
+}
+var isPieceNode = (e) => e.tagName === "PIECE", isSquareNode = (e) => e.tagName === "SQUARE";
+function removeNodes(e, t) {
+	for (let n of t) e.dom.elements.board.removeChild(n);
+}
+function posZIndex(e, t) {
+	let n = e[1];
+	return `${t ? 10 - n : 3 + n}`;
+}
+var pieceNameOf = (e) => `${e.color} ${e.role}`;
+function computeSquareClasses(e) {
+	let t = /* @__PURE__ */ new Map();
+	if (e.lastMove && e.highlight.lastMove) for (let n of e.lastMove) addSquare(t, n, "last-move");
+	if (e.check && e.highlight.check && addSquare(t, e.check, "check"), e.selected && (addSquare(t, e.selected, "selected"), e.movable.showDests)) {
+		let n = e.movable.dests?.get(e.selected);
+		if (n) for (let r of n) addSquare(t, r, "move-dest" + (e.pieces.has(r) ? " oc" : ""));
+		let r = e.premovable.customDests?.get(e.selected) ?? e.premovable.dests;
+		if (r) for (let n of r) addSquare(t, n, "premove-dest" + (e.pieces.has(n) ? " oc" : ""));
+	}
+	let n = e.premovable.current;
+	if (n) for (let e of n) addSquare(t, e, "current-premove");
+	else e.predroppable.current && addSquare(t, e.predroppable.current.key, "current-premove");
+	let r = e.exploding;
+	if (r) for (let e of r.keys) addSquare(t, e, "exploding" + r.stage);
+	return e.highlight.custom && e.highlight.custom.forEach((e, n) => {
+		addSquare(t, n, e);
+	}), t;
+}
+function addSquare(e, t, n) {
+	let r = e.get(t);
+	r ? e.set(t, `${r} ${n}`) : e.set(t, n);
+}
+function appendValue(e, t, n) {
+	let r = e.get(t);
+	r ? r.push(n) : e.set(t, [n]);
+}
+//#endregion
+//#region src/chess/chessground/sync.ts
+function syncShapes(e, t, n) {
+	let r = /* @__PURE__ */ new Map(), i = [];
+	for (let t of e) r.set(t.hash, !1);
+	let a = t.firstElementChild, o;
+	for (; a;) o = a.getAttribute("cgHash"), r.has(o) ? r.set(o, !0) : i.push(a), a = a.nextElementSibling;
+	for (let e of i) t.removeChild(e);
+	for (let i of e) r.get(i.hash) || t.appendChild(n(i));
+}
+//#endregion
+//#region src/chess/chessground/autoPieces.ts
+function render(e, t) {
+	syncShapes(e.drawable.autoShapes.filter((e) => e.piece).map((e) => ({
+		shape: e,
+		hash: hash(e),
+		current: !1
+	})), t, (t) => renderShape(e, t, e.dom.bounds()));
+}
+function renderResized(e) {
+	let t = whitePov(e), n = posToTranslate(e.dom.bounds()), r = e.dom.elements.autoPieces?.firstChild;
+	for (; r;) translateAndScale(r, n(key2pos(r.cgKey), t), r.cgScale), r = r.nextSibling;
+}
+function renderShape(e, { shape: t, hash: n }, r) {
+	let i = t.orig, a = t.piece?.role, o = t.piece?.color, s = t.piece?.scale, c = createEl("piece", `${a} ${o}`);
+	return c.setAttribute("cgHash", n), c.cgKey = i, c.cgScale = s, translateAndScale(c, posToTranslate(r)(key2pos(i), whitePov(e)), s), c;
+}
+var hash = (e) => [
+	e.orig,
+	e.piece?.role,
+	e.piece?.color,
+	e.piece?.scale
+].join(",");
+//#endregion
+//#region src/chess/chessground/chessground.ts
+function Chessground(e, t) {
+	let n = defaults();
+	configure(n, t || {});
+	function redrawAll() {
+		let t = "dom" in n ? n.dom.unbind : void 0, r = renderWrap(e, n), i = memo(() => r.board.getBoundingClientRect()), redrawNow = (e) => {
+			render$1(a), r.autoPieces && render(a, r.autoPieces), !e && r.svg && renderSvg(a, r.svg, r.customSvg);
+		}, onResize = () => {
+			updateBounds(a), renderResized$1(a), r.autoPieces && renderResized(a);
+		}, a = n;
+		return a.dom = {
+			elements: r,
+			bounds: i,
+			redraw: debounceRedraw(redrawNow),
+			redrawNow,
+			unbind: t
+		}, a.drawable.prevSvgHash = "", updateBounds(a), redrawNow(!1), bindBoard(a), t || (a.dom.unbind = bindDocument(a, onResize)), a.events.insert?.(r), a;
+	}
+	return start(redrawAll(), redrawAll);
+}
+function debounceRedraw(e) {
+	let t = !1;
+	return () => {
+		t || (t = !0, requestAnimationFrame(() => {
+			e(), t = !1;
+		}));
+	};
+}
+var N = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", Move = class {
+	color;
+	from;
+	to;
+	piece;
+	captured;
+	promotion;
+	flags;
+	san;
+	lan;
+	before;
+	after;
+	constructor(e, t) {
+		let { color: n, piece: r, from: i, to: a, flags: o, captured: s, promotion: c } = t, l = algebraic(i), u = algebraic(a);
+		this.color = n, this.piece = r, this.from = l, this.to = u, this.san = e._moveToSan(t, e._moves({ legal: !0 })), this.lan = l + u, this.before = e.fen(), e._makeMove(t), this.after = e.fen(), e._undoMove(), this.flags = "";
+		for (let e in L) L[e] & o && (this.flags += F[e]);
+		s && (this.captured = s), c && (this.promotion = c, this.lan += c);
+	}
+	isCapture() {
+		return this.flags.indexOf(F.CAPTURE) > -1;
+	}
+	isPromotion() {
+		return this.flags.indexOf(F.PROMOTION) > -1;
+	}
+	isEnPassant() {
+		return this.flags.indexOf(F.EP_CAPTURE) > -1;
+	}
+	isKingsideCastle() {
+		return this.flags.indexOf(F.KSIDE_CASTLE) > -1;
+	}
+	isQueensideCastle() {
+		return this.flags.indexOf(F.QSIDE_CASTLE) > -1;
+	}
+	isBigPawn() {
+		return this.flags.indexOf(F.BIG_PAWN) > -1;
+	}
+}, P = -1, F = {
+	NORMAL: "n",
+	CAPTURE: "c",
+	BIG_PAWN: "b",
+	EP_CAPTURE: "e",
+	PROMOTION: "p",
+	KSIDE_CASTLE: "k",
+	QSIDE_CASTLE: "q"
+}, I = /* @__PURE__ */ "a8.b8.c8.d8.e8.f8.g8.h8.a7.b7.c7.d7.e7.f7.g7.h7.a6.b6.c6.d6.e6.f6.g6.h6.a5.b5.c5.d5.e5.f5.g5.h5.a4.b4.c4.d4.e4.f4.g4.h4.a3.b3.c3.d3.e3.f3.g3.h3.a2.b2.c2.d2.e2.f2.g2.h2.a1.b1.c1.d1.e1.f1.g1.h1".split("."), L = {
+	NORMAL: 1,
+	CAPTURE: 2,
+	BIG_PAWN: 4,
+	EP_CAPTURE: 8,
+	PROMOTION: 16,
+	KSIDE_CASTLE: 32,
+	QSIDE_CASTLE: 64
+}, R = {
+	a8: 0,
+	b8: 1,
+	c8: 2,
+	d8: 3,
+	e8: 4,
+	f8: 5,
+	g8: 6,
+	h8: 7,
+	a7: 16,
+	b7: 17,
+	c7: 18,
+	d7: 19,
+	e7: 20,
+	f7: 21,
+	g7: 22,
+	h7: 23,
+	a6: 32,
+	b6: 33,
+	c6: 34,
+	d6: 35,
+	e6: 36,
+	f6: 37,
+	g6: 38,
+	h6: 39,
+	a5: 48,
+	b5: 49,
+	c5: 50,
+	d5: 51,
+	e5: 52,
+	f5: 53,
+	g5: 54,
+	h5: 55,
+	a4: 64,
+	b4: 65,
+	c4: 66,
+	d4: 67,
+	e4: 68,
+	f4: 69,
+	g4: 70,
+	h4: 71,
+	a3: 80,
+	b3: 81,
+	c3: 82,
+	d3: 83,
+	e3: 84,
+	f3: 85,
+	g3: 86,
+	h3: 87,
+	a2: 96,
+	b2: 97,
+	c2: 98,
+	d2: 99,
+	e2: 100,
+	f2: 101,
+	g2: 102,
+	h2: 103,
+	a1: 112,
+	b1: 113,
+	c1: 114,
+	d1: 115,
+	e1: 116,
+	f1: 117,
+	g1: 118,
+	h1: 119
+}, z = {
+	b: [
+		16,
+		32,
+		17,
+		15
+	],
+	w: [
+		-16,
+		-32,
+		-17,
+		-15
+	]
+}, B = {
+	n: [
+		-18,
+		-33,
+		-31,
+		-14,
+		18,
+		33,
+		31,
+		14
+	],
+	b: [
+		-17,
+		-15,
+		17,
+		15
+	],
+	r: [
+		-16,
+		1,
+		16,
+		-1
+	],
+	q: [
+		-17,
+		-16,
+		-15,
+		1,
+		17,
+		16,
+		15,
+		-1
+	],
+	k: [
+		-17,
+		-16,
+		-15,
+		1,
+		17,
+		16,
+		15,
+		-1
+	]
+}, V = [
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	24,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	24,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	24,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	24,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	24,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	2,
+	24,
+	2,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	2,
+	53,
+	56,
+	53,
+	2,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	56,
+	0,
+	56,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	2,
+	53,
+	56,
+	53,
+	2,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	2,
+	24,
+	2,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	24,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	24,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	24,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	24,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	24,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	20
+], H = [
+	17,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	16,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	15,
+	0,
+	0,
+	17,
+	0,
+	0,
+	0,
+	0,
+	0,
+	16,
+	0,
+	0,
+	0,
+	0,
+	0,
+	15,
+	0,
+	0,
+	0,
+	0,
+	17,
+	0,
+	0,
+	0,
+	0,
+	16,
+	0,
+	0,
+	0,
+	0,
+	15,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	17,
+	0,
+	0,
+	0,
+	16,
+	0,
+	0,
+	0,
+	15,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	17,
+	0,
+	0,
+	16,
+	0,
+	0,
+	15,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	17,
+	0,
+	16,
+	0,
+	15,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	17,
+	16,
+	15,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	-1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	-15,
+	-16,
+	-17,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	-15,
+	0,
+	-16,
+	0,
+	-17,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	-15,
+	0,
+	0,
+	-16,
+	0,
+	0,
+	-17,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	-15,
+	0,
+	0,
+	0,
+	-16,
+	0,
+	0,
+	0,
+	-17,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	-15,
+	0,
+	0,
+	0,
+	0,
+	-16,
+	0,
+	0,
+	0,
+	0,
+	-17,
+	0,
+	0,
+	0,
+	0,
+	-15,
+	0,
+	0,
+	0,
+	0,
+	0,
+	-16,
+	0,
+	0,
+	0,
+	0,
+	0,
+	-17,
+	0,
+	0,
+	-15,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	-16,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	-17
+], U = {
+	p: 1,
+	n: 2,
+	b: 4,
+	r: 8,
+	q: 16,
+	k: 32
+}, W = "pnbrqkPNBRQK", G = [
+	"n",
+	"b",
+	"r",
+	"q"
+], K = 7, q = 6, J = 1, Y = 0, X = {
+	k: L.KSIDE_CASTLE,
+	q: L.QSIDE_CASTLE
+}, Z = {
+	w: [{
+		square: R.a1,
+		flag: L.QSIDE_CASTLE
+	}, {
+		square: R.h1,
+		flag: L.KSIDE_CASTLE
+	}],
+	b: [{
+		square: R.a8,
+		flag: L.QSIDE_CASTLE
+	}, {
+		square: R.h8,
+		flag: L.KSIDE_CASTLE
+	}]
+}, Q = {
+	b: J,
+	w: q
+}, ee = [
+	"1-0",
+	"0-1",
+	"1/2-1/2",
+	"*"
+];
+function rank(e) {
+	return e >> 4;
+}
+function file(e) {
+	return e & 15;
+}
+function isDigit(e) {
+	return "0123456789".indexOf(e) !== -1;
+}
+function algebraic(e) {
+	let t = file(e), n = rank(e);
+	return "abcdefgh".substring(t, t + 1) + "87654321".substring(n, n + 1);
+}
+function swapColor$1(e) {
+	return e === "w" ? "b" : "w";
+}
+e(swapColor$1, "swapColor");
+function validateFen(e) {
+	let t = e.split(/\s+/);
+	if (t.length !== 6) return {
+		ok: !1,
+		error: "Invalid FEN: must contain six space-delimited fields"
+	};
+	let n = parseInt(t[5], 10);
+	if (isNaN(n) || n <= 0) return {
+		ok: !1,
+		error: "Invalid FEN: move number must be a positive integer"
+	};
+	let r = parseInt(t[4], 10);
+	if (isNaN(r) || r < 0) return {
+		ok: !1,
+		error: "Invalid FEN: half move counter number must be a non-negative integer"
+	};
+	if (!/^(-|[abcdefgh][36])$/.test(t[3])) return {
+		ok: !1,
+		error: "Invalid FEN: en-passant square is invalid"
+	};
+	if (/[^kKqQ-]/.test(t[2])) return {
+		ok: !1,
+		error: "Invalid FEN: castling availability is invalid"
+	};
+	if (!/^(w|b)$/.test(t[1])) return {
+		ok: !1,
+		error: "Invalid FEN: side-to-move is invalid"
+	};
+	let i = t[0].split("/");
+	if (i.length !== 8) return {
+		ok: !1,
+		error: "Invalid FEN: piece data does not contain 8 '/'-delimited rows"
+	};
+	for (let e = 0; e < i.length; e++) {
+		let t = 0, n = !1;
+		for (let r = 0; r < i[e].length; r++) if (isDigit(i[e][r])) {
+			if (n) return {
+				ok: !1,
+				error: "Invalid FEN: piece data is invalid (consecutive number)"
+			};
+			t += parseInt(i[e][r], 10), n = !0;
+		} else {
+			if (!/^[prnbqkPRNBQK]$/.test(i[e][r])) return {
+				ok: !1,
+				error: "Invalid FEN: piece data is invalid (invalid piece)"
+			};
+			t += 1, n = !1;
+		}
+		if (t !== 8) return {
+			ok: !1,
+			error: "Invalid FEN: piece data is invalid (too many squares in rank)"
+		};
+	}
+	if (t[3][1] == "3" && t[1] == "w" || t[3][1] == "6" && t[1] == "b") return {
+		ok: !1,
+		error: "Invalid FEN: illegal en-passant square"
+	};
+	for (let { color: e, regex: n } of [{
+		color: "white",
+		regex: /K/g
+	}, {
+		color: "black",
+		regex: /k/g
+	}]) {
+		if (!n.test(t[0])) return {
+			ok: !1,
+			error: `Invalid FEN: missing ${e} king`
+		};
+		if ((t[0].match(n) || []).length > 1) return {
+			ok: !1,
+			error: `Invalid FEN: too many ${e} kings`
+		};
+	}
+	return Array.from(i[0] + i[7]).some((e) => e.toUpperCase() === "P") ? {
+		ok: !1,
+		error: "Invalid FEN: some pawns are on the edge rows"
+	} : { ok: !0 };
+}
+function getDisambiguator(e, t) {
+	let n = e.from, r = e.to, i = e.piece, a = 0, o = 0, s = 0;
+	for (let e = 0, c = t.length; e < c; e++) {
+		let c = t[e].from, l = t[e].to;
+		i === t[e].piece && n !== c && r === l && (a++, rank(n) === rank(c) && o++, file(n) === file(c) && s++);
+	}
+	return a > 0 ? o > 0 && s > 0 ? algebraic(n) : s > 0 ? algebraic(n).charAt(1) : algebraic(n).charAt(0) : "";
+}
+function addMove(e, t, n, r, i, a = void 0, o = L.NORMAL) {
+	let s = rank(r);
+	if (i === "p" && (s === K || s === Y)) for (let s = 0; s < G.length; s++) {
+		let c = G[s];
+		e.push({
+			color: t,
+			from: n,
+			to: r,
+			piece: i,
+			captured: a,
+			promotion: c,
+			flags: o | L.PROMOTION
+		});
+	}
+	else e.push({
+		color: t,
+		from: n,
+		to: r,
+		piece: i,
+		captured: a,
+		flags: o
+	});
+}
+function inferPieceType(e) {
+	let t = e.charAt(0);
+	return t >= "a" && t <= "h" ? e.match(/[a-h]\d.*[a-h]\d/) ? void 0 : "p" : (t = t.toLowerCase(), t === "o" ? "k" : t);
+}
+function strippedSan(e) {
+	return e.replace(/=/, "").replace(/[+#]?[?!]*$/, "");
+}
+function trimFen(e) {
+	return e.split(" ").slice(0, 4).join(" ");
+}
+var Chess = class {
+	_board = Array(128);
+	_turn = "w";
+	_header = {};
+	_kings = {
+		w: P,
+		b: P
+	};
+	_epSquare = -1;
+	_halfMoves = 0;
+	_moveNumber = 0;
+	_history = [];
+	_comments = {};
+	_castling = {
+		w: 0,
+		b: 0
+	};
+	_positionCount = {};
+	constructor(e = N, { skipValidation: t = !1 } = {}) {
+		this.load(e, { skipValidation: t });
+	}
+	clear({ preserveHeaders: e = !1 } = {}) {
+		this._board = Array(128), this._kings = {
+			w: P,
+			b: P
+		}, this._turn = "w", this._castling = {
+			w: 0,
+			b: 0
+		}, this._epSquare = P, this._halfMoves = 0, this._moveNumber = 1, this._history = [], this._comments = {}, this._header = e ? this._header : {}, this._positionCount = {}, delete this._header.SetUp, delete this._header.FEN;
+	}
+	load(e, { skipValidation: t = !1, preserveHeaders: n = !1 } = {}) {
+		let r = e.split(/\s+/);
+		if (r.length >= 2 && r.length < 6 && (e = r.concat([
+			"-",
+			"-",
+			"0",
+			"1"
+		].slice(-(6 - r.length))).join(" ")), r = e.split(/\s+/), !t) {
+			let { ok: t, error: n } = validateFen(e);
+			if (!t) throw Error(n);
+		}
+		let i = r[0], a = 0;
+		this.clear({ preserveHeaders: n });
+		for (let e = 0; e < i.length; e++) {
+			let t = i.charAt(e);
+			if (t === "/") a += 8;
+			else if (isDigit(t)) a += parseInt(t, 10);
+			else {
+				let e = t < "a" ? "w" : "b";
+				this._put({
+					type: t.toLowerCase(),
+					color: e
+				}, algebraic(a)), a++;
+			}
+		}
+		this._turn = r[1], r[2].indexOf("K") > -1 && (this._castling.w |= L.KSIDE_CASTLE), r[2].indexOf("Q") > -1 && (this._castling.w |= L.QSIDE_CASTLE), r[2].indexOf("k") > -1 && (this._castling.b |= L.KSIDE_CASTLE), r[2].indexOf("q") > -1 && (this._castling.b |= L.QSIDE_CASTLE), this._epSquare = r[3] === "-" ? P : R[r[3]], this._halfMoves = parseInt(r[4], 10), this._moveNumber = parseInt(r[5], 10), this._updateSetup(e), this._incPositionCount(e);
+	}
+	fen() {
+		let e = 0, t = "";
+		for (let n = R.a8; n <= R.h1; n++) {
+			if (this._board[n]) {
+				e > 0 && (t += e, e = 0);
+				let { color: r, type: i } = this._board[n];
+				t += r === "w" ? i.toUpperCase() : i.toLowerCase();
+			} else e++;
+			n + 1 & 136 && (e > 0 && (t += e), n !== R.h1 && (t += "/"), e = 0, n += 8);
+		}
+		let n = "";
+		this._castling.w & L.KSIDE_CASTLE && (n += "K"), this._castling.w & L.QSIDE_CASTLE && (n += "Q"), this._castling.b & L.KSIDE_CASTLE && (n += "k"), this._castling.b & L.QSIDE_CASTLE && (n += "q"), n ||= "-";
+		let r = "-";
+		if (this._epSquare !== P) {
+			let e = this._epSquare + (this._turn === "w" ? 16 : -16), t = [e + 1, e - 1];
+			for (let e of t) {
+				if (e & 136) continue;
+				let t = this._turn;
+				if (this._board[e]?.color === t && this._board[e]?.type === "p") {
+					this._makeMove({
+						color: t,
+						from: e,
+						to: this._epSquare,
+						piece: "p",
+						captured: "p",
+						flags: L.EP_CAPTURE
+					});
+					let n = !this._isKingAttacked(t);
+					if (this._undoMove(), n) {
+						r = algebraic(this._epSquare);
+						break;
+					}
+				}
+			}
+		}
+		return [
+			t,
+			this._turn,
+			n,
+			r,
+			this._halfMoves,
+			this._moveNumber
+		].join(" ");
+	}
+	_updateSetup(e) {
+		this._history.length > 0 || (e === "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1" ? (delete this._header.SetUp, delete this._header.FEN) : (this._header.SetUp = "1", this._header.FEN = e));
+	}
+	reset() {
+		this.load(N);
+	}
+	get(e) {
+		return this._board[R[e]];
+	}
+	put({ type: e, color: t }, n) {
+		return this._put({
+			type: e,
+			color: t
+		}, n) ? (this._updateCastlingRights(), this._updateEnPassantSquare(), this._updateSetup(this.fen()), !0) : !1;
+	}
+	_put({ type: e, color: t }, n) {
+		if (W.indexOf(e.toLowerCase()) === -1 || !(n in R)) return !1;
+		let r = R[n];
+		if (e == "k" && !(this._kings[t] == P || this._kings[t] == r)) return !1;
+		let i = this._board[r];
+		return i && i.type === "k" && (this._kings[i.color] = P), this._board[r] = {
+			type: e,
+			color: t
+		}, e === "k" && (this._kings[t] = r), !0;
+	}
+	remove(e) {
+		let t = this.get(e);
+		return delete this._board[R[e]], t && t.type === "k" && (this._kings[t.color] = P), this._updateCastlingRights(), this._updateEnPassantSquare(), this._updateSetup(this.fen()), t;
+	}
+	_updateCastlingRights() {
+		let e = this._board[R.e1]?.type === "k" && this._board[R.e1]?.color === "w", t = this._board[R.e8]?.type === "k" && this._board[R.e8]?.color === "b";
+		(!e || this._board[R.a1]?.type !== "r" || this._board[R.a1]?.color !== "w") && (this._castling.w &= ~L.QSIDE_CASTLE), (!e || this._board[R.h1]?.type !== "r" || this._board[R.h1]?.color !== "w") && (this._castling.w &= ~L.KSIDE_CASTLE), (!t || this._board[R.a8]?.type !== "r" || this._board[R.a8]?.color !== "b") && (this._castling.b &= ~L.QSIDE_CASTLE), (!t || this._board[R.h8]?.type !== "r" || this._board[R.h8]?.color !== "b") && (this._castling.b &= ~L.KSIDE_CASTLE);
+	}
+	_updateEnPassantSquare() {
+		if (this._epSquare === P) return;
+		let e = this._epSquare + (this._turn === "w" ? -16 : 16), t = this._epSquare + (this._turn === "w" ? 16 : -16), n = [t + 1, t - 1];
+		if (this._board[e] !== null || this._board[this._epSquare] !== null || this._board[t]?.color !== swapColor$1(this._turn) || this._board[t]?.type !== "p") {
+			this._epSquare = P;
+			return;
+		}
+		let canCapture = (e) => !(e & 136) && this._board[e]?.color === this._turn && this._board[e]?.type === "p";
+		n.some(canCapture) || (this._epSquare = P);
+	}
+	_attacked(e, t, n) {
+		let r = [];
+		for (let i = R.a8; i <= R.h1; i++) {
+			if (i & 136) {
+				i += 7;
+				continue;
+			}
+			if (this._board[i] === void 0 || this._board[i].color !== e) continue;
+			let a = this._board[i], o = i - t;
+			if (o === 0) continue;
+			let s = o + 119;
+			if (V[s] & U[a.type]) {
+				if (a.type === "p") {
+					if (o > 0 && a.color === "w" || o <= 0 && a.color === "b") if (n) r.push(algebraic(i));
+					else return !0;
+					continue;
+				}
+				if (a.type === "n" || a.type === "k") if (n) {
+					r.push(algebraic(i));
+					continue;
+				} else return !0;
+				let e = H[s], c = i + e, l = !1;
+				for (; c !== t;) {
+					if (this._board[c] != null) {
+						l = !0;
+						break;
+					}
+					c += e;
+				}
+				if (!l) if (n) {
+					r.push(algebraic(i));
+					continue;
+				} else return !0;
+			}
+		}
+		return n ? r : !1;
+	}
+	attackers(e, t) {
+		return t ? this._attacked(t, R[e], !0) : this._attacked(this._turn, R[e], !0);
+	}
+	_isKingAttacked(e) {
+		let t = this._kings[e];
+		return t === -1 ? !1 : this._attacked(swapColor$1(e), t);
+	}
+	isAttacked(e, t) {
+		return this._attacked(t, R[e]);
+	}
+	isCheck() {
+		return this._isKingAttacked(this._turn);
+	}
+	inCheck() {
+		return this.isCheck();
+	}
+	isCheckmate() {
+		return this.isCheck() && this._moves().length === 0;
+	}
+	isStalemate() {
+		return !this.isCheck() && this._moves().length === 0;
+	}
+	isInsufficientMaterial() {
+		let e = {
+			b: 0,
+			n: 0,
+			r: 0,
+			q: 0,
+			k: 0,
+			p: 0
+		}, t = [], n = 0, r = 0;
+		for (let i = R.a8; i <= R.h1; i++) {
+			if (r = (r + 1) % 2, i & 136) {
+				i += 7;
+				continue;
+			}
+			let a = this._board[i];
+			a && (e[a.type] = a.type in e ? e[a.type] + 1 : 1, a.type === "b" && t.push(r), n++);
+		}
+		if (n === 2 || n === 3 && (e.b === 1 || e.n === 1)) return !0;
+		if (n === e.b + 2) {
+			let e = 0, n = t.length;
+			for (let r = 0; r < n; r++) e += t[r];
+			if (e === 0 || e === n) return !0;
+		}
+		return !1;
+	}
+	isThreefoldRepetition() {
+		return this._getPositionCount(this.fen()) >= 3;
+	}
+	isDrawByFiftyMoves() {
+		return this._halfMoves >= 100;
+	}
+	isDraw() {
+		return this.isDrawByFiftyMoves() || this.isStalemate() || this.isInsufficientMaterial() || this.isThreefoldRepetition();
+	}
+	isGameOver() {
+		return this.isCheckmate() || this.isStalemate() || this.isDraw();
+	}
+	moves({ verbose: e = !1, square: t = void 0, piece: n = void 0 } = {}) {
+		let r = this._moves({
+			square: t,
+			piece: n
+		});
+		return e ? r.map((e) => new Move(this, e)) : r.map((e) => this._moveToSan(e, r));
+	}
+	_moves({ legal: e = !0, piece: t = void 0, square: n = void 0 } = {}) {
+		let r = n ? n.toLowerCase() : void 0, i = t?.toLowerCase(), a = [], o = this._turn, s = swapColor$1(o), c = R.a8, l = R.h1, u = !1;
+		if (r) if (r in R) c = l = R[r], u = !0;
+		else return [];
+		for (let e = c; e <= l; e++) {
+			if (e & 136) {
+				e += 7;
+				continue;
+			}
+			if (!this._board[e] || this._board[e].color === s) continue;
+			let { type: t } = this._board[e], n;
+			if (t === "p") {
+				if (i && i !== t) continue;
+				n = e + z[o][0], this._board[n] || (addMove(a, o, e, n, "p"), n = e + z[o][1], Q[o] === rank(e) && !this._board[n] && addMove(a, o, e, n, "p", void 0, L.BIG_PAWN));
+				for (let t = 2; t < 4; t++) n = e + z[o][t], !(n & 136) && (this._board[n]?.color === s ? addMove(a, o, e, n, "p", this._board[n].type, L.CAPTURE) : n === this._epSquare && addMove(a, o, e, n, "p", "p", L.EP_CAPTURE));
+			} else {
+				if (i && i !== t) continue;
+				for (let r = 0, i = B[t].length; r < i; r++) {
+					let i = B[t][r];
+					for (n = e; n += i, !(n & 136);) {
+						if (!this._board[n]) addMove(a, o, e, n, t);
+						else {
+							if (this._board[n].color === o) break;
+							addMove(a, o, e, n, t, this._board[n].type, L.CAPTURE);
+							break;
+						}
+						if (t === "n" || t === "k") break;
+					}
+				}
+			}
+		}
+		if ((i === void 0 || i === "k") && (!u || l === this._kings[o])) {
+			if (this._castling[o] & L.KSIDE_CASTLE) {
+				let e = this._kings[o], t = e + 2;
+				!this._board[e + 1] && !this._board[t] && !this._attacked(s, this._kings[o]) && !this._attacked(s, e + 1) && !this._attacked(s, t) && addMove(a, o, this._kings[o], t, "k", void 0, L.KSIDE_CASTLE);
+			}
+			if (this._castling[o] & L.QSIDE_CASTLE) {
+				let e = this._kings[o], t = e - 2;
+				!this._board[e - 1] && !this._board[e - 2] && !this._board[e - 3] && !this._attacked(s, this._kings[o]) && !this._attacked(s, e - 1) && !this._attacked(s, t) && addMove(a, o, this._kings[o], t, "k", void 0, L.QSIDE_CASTLE);
+			}
+		}
+		if (!e || this._kings[o] === -1) return a;
+		let d = [];
+		for (let e = 0, t = a.length; e < t; e++) this._makeMove(a[e]), this._isKingAttacked(o) || d.push(a[e]), this._undoMove();
+		return d;
+	}
+	move(e, { strict: t = !1 } = {}) {
+		let n = null;
+		if (typeof e == "string") n = this._moveFromSan(e, t);
+		else if (typeof e == "object") {
+			let t = this._moves();
+			for (let r = 0, i = t.length; r < i; r++) if (e.from === algebraic(t[r].from) && e.to === algebraic(t[r].to) && (!("promotion" in t[r]) || e.promotion === t[r].promotion)) {
+				n = t[r];
+				break;
+			}
+		}
+		if (!n) throw typeof e == "string" ? Error(`Invalid move: ${e}`) : Error(`Invalid move: ${JSON.stringify(e)}`);
+		let r = new Move(this, n);
+		return this._makeMove(n), this._incPositionCount(r.after), r;
+	}
+	_push(e) {
+		this._history.push({
+			move: e,
+			kings: {
+				b: this._kings.b,
+				w: this._kings.w
+			},
+			turn: this._turn,
+			castling: {
+				b: this._castling.b,
+				w: this._castling.w
+			},
+			epSquare: this._epSquare,
+			halfMoves: this._halfMoves,
+			moveNumber: this._moveNumber
+		});
+	}
+	_makeMove(e) {
+		let t = this._turn, n = swapColor$1(t);
+		if (this._push(e), this._board[e.to] = this._board[e.from], delete this._board[e.from], e.flags & L.EP_CAPTURE && (this._turn === "b" ? delete this._board[e.to - 16] : delete this._board[e.to + 16]), e.promotion && (this._board[e.to] = {
+			type: e.promotion,
+			color: t
+		}), this._board[e.to].type === "k") {
+			if (this._kings[t] = e.to, e.flags & L.KSIDE_CASTLE) {
+				let t = e.to - 1, n = e.to + 1;
+				this._board[t] = this._board[n], delete this._board[n];
+			} else if (e.flags & L.QSIDE_CASTLE) {
+				let t = e.to + 1, n = e.to - 2;
+				this._board[t] = this._board[n], delete this._board[n];
+			}
+			this._castling[t] = 0;
+		}
+		if (this._castling[t]) {
+			for (let n = 0, r = Z[t].length; n < r; n++) if (e.from === Z[t][n].square && this._castling[t] & Z[t][n].flag) {
+				this._castling[t] ^= Z[t][n].flag;
+				break;
+			}
+		}
+		if (this._castling[n]) {
+			for (let t = 0, r = Z[n].length; t < r; t++) if (e.to === Z[n][t].square && this._castling[n] & Z[n][t].flag) {
+				this._castling[n] ^= Z[n][t].flag;
+				break;
+			}
+		}
+		e.flags & L.BIG_PAWN ? t === "b" ? this._epSquare = e.to - 16 : this._epSquare = e.to + 16 : this._epSquare = P, e.piece === "p" || e.flags & (L.CAPTURE | L.EP_CAPTURE) ? this._halfMoves = 0 : this._halfMoves++, t === "b" && this._moveNumber++, this._turn = n;
+	}
+	undo() {
+		let e = this._undoMove();
+		if (e) {
+			let t = new Move(this, e);
+			return this._decPositionCount(t.after), t;
+		}
+		return null;
+	}
+	_undoMove() {
+		let e = this._history.pop();
+		if (e === void 0) return null;
+		let t = e.move;
+		this._kings = e.kings, this._turn = e.turn, this._castling = e.castling, this._epSquare = e.epSquare, this._halfMoves = e.halfMoves, this._moveNumber = e.moveNumber;
+		let n = this._turn, r = swapColor$1(n);
+		if (this._board[t.from] = this._board[t.to], this._board[t.from].type = t.piece, delete this._board[t.to], t.captured) if (t.flags & L.EP_CAPTURE) {
+			let e;
+			e = n === "b" ? t.to - 16 : t.to + 16, this._board[e] = {
+				type: "p",
+				color: r
+			};
+		} else this._board[t.to] = {
+			type: t.captured,
+			color: r
+		};
+		if (t.flags & (L.KSIDE_CASTLE | L.QSIDE_CASTLE)) {
+			let e, n;
+			t.flags & L.KSIDE_CASTLE ? (e = t.to + 1, n = t.to - 1) : (e = t.to - 2, n = t.to + 1), this._board[e] = this._board[n], delete this._board[n];
+		}
+		return t;
+	}
+	pgn({ newline: e = "\n", maxWidth: t = 0 } = {}) {
+		let n = [], r = !1;
+		for (let t in this._header) n.push("[" + t + " \"" + this._header[t] + "\"]" + e), r = !0;
+		r && this._history.length && n.push(e);
+		let appendComment = (e) => {
+			let t = this._comments[this.fen()];
+			if (t !== void 0) {
+				let n = e.length > 0 ? " " : "";
+				e = `${e}${n}{${t}}`;
+			}
+			return e;
+		}, i = [];
+		for (; this._history.length > 0;) i.push(this._undoMove());
+		let a = [], o = "";
+		for (i.length === 0 && a.push(appendComment("")); i.length > 0;) {
+			o = appendComment(o);
+			let e = i.pop();
+			if (!e) break;
+			if (!this._history.length && e.color === "b") {
+				let e = `${this._moveNumber}. ...`;
+				o = o ? `${o} ${e}` : e;
+			} else e.color === "w" && (o.length && a.push(o), o = this._moveNumber + ".");
+			o = o + " " + this._moveToSan(e, this._moves({ legal: !0 })), this._makeMove(e);
+		}
+		if (o.length && a.push(appendComment(o)), this._header.Result !== void 0 && a.push(this._header.Result), t === 0) return n.join("") + a.join(" ");
+		let strip = function() {
+			return n.length > 0 && n[n.length - 1] === " " ? (n.pop(), !0) : !1;
+		}, wrapComment = function(r, i) {
+			for (let a of i.split(" ")) if (a) {
+				if (r + a.length > t) {
+					for (; strip();) r--;
+					n.push(e), r = 0;
+				}
+				n.push(a), r += a.length, n.push(" "), r++;
+			}
+			return strip() && r--, r;
+		}, s = 0;
+		for (let r = 0; r < a.length; r++) {
+			if (s + a[r].length > t && a[r].includes("{")) {
+				s = wrapComment(s, a[r]);
+				continue;
+			}
+			s + a[r].length > t && r !== 0 ? (n[n.length - 1] === " " && n.pop(), n.push(e), s = 0) : r !== 0 && (n.push(" "), s++), n.push(a[r]), s += a[r].length;
+		}
+		return n.join("");
+	}
+	header(...e) {
+		for (let t = 0; t < e.length; t += 2) typeof e[t] == "string" && typeof e[t + 1] == "string" && (this._header[e[t]] = e[t + 1]);
+		return this._header;
+	}
+	setHeader(e, t) {
+		return this._header[e] = t, this._header;
+	}
+	removeHeader(e) {
+		return e in this._header ? (delete this._header[e], !0) : !1;
+	}
+	getHeaders() {
+		return this._header;
+	}
+	loadPgn(e, { strict: t = !1, newlineChar: n = "\r?\n" } = {}) {
+		function mask(e) {
+			return e.replace(/\\/g, "\\");
+		}
+		function parsePgnHeader(e) {
+			let t = {}, r = e.split(new RegExp(mask(n))), i = "", a = "";
+			for (let e = 0; e < r.length; e++) {
+				let n = /^\s*\[\s*([A-Za-z]+)\s*"(.*)"\s*\]\s*$/;
+				i = r[e].replace(n, "$1"), a = r[e].replace(n, "$2"), i.trim().length > 0 && (t[i] = a);
+			}
+			return t;
+		}
+		e = e.trim();
+		let r = RegExp("^(\\[((?:" + mask(n) + ")|.)*\\])((?:\\s*" + mask(n) + "){2}|(?:\\s*" + mask(n) + ")*$)").exec(e), i = r && r.length >= 2 ? r[1] : "";
+		this.reset();
+		let a = parsePgnHeader(i), o = "";
+		for (let e in a) e.toLowerCase() === "fen" && (o = a[e]), this.header(e, a[e]);
+		if (!t) o && this.load(o, { preserveHeaders: !0 });
+		else if (a.SetUp === "1") {
+			if (!("FEN" in a)) throw Error("Invalid PGN: FEN tag must be supplied with SetUp tag");
+			this.load(a.FEN, { preserveHeaders: !0 });
+		}
+		function toHex(e) {
+			return Array.from(e).map(function(e) {
+				return e.charCodeAt(0) < 128 ? e.charCodeAt(0).toString(16) : encodeURIComponent(e).replace(/%/g, "").toLowerCase();
+			}).join("");
+		}
+		function fromHex(e) {
+			return e.length == 0 ? "" : decodeURIComponent("%" + (e.match(/.{1,2}/g) || []).join("%"));
+		}
+		let encodeComment = function(e) {
+			return e = e.replace(new RegExp(mask(n), "g"), " "), `{${toHex(e.slice(1, e.length - 1))}}`;
+		}, decodeComment = function(e) {
+			if (e.startsWith("{") && e.endsWith("}")) return fromHex(e.slice(1, e.length - 1));
+		}, s = e.replace(i, "").replace(RegExp(`({[^}]*})+?|;([^${mask(n)}]*)`, "g"), function(e, t, n) {
+			return t === void 0 ? " " + encodeComment(`{${n.slice(1)}}`) : encodeComment(t);
+		}).replace(new RegExp(mask(n), "g"), " "), c = /(\([^()]+\))+?/g;
+		for (; c.test(s);) s = s.replace(c, "");
+		s = s.replace(/\d+\.(\.\.)?/g, ""), s = s.replace(/\.\.\./g, ""), s = s.replace(/\$\d+/g, "");
+		let l = s.trim().split(/* @__PURE__ */ new RegExp(/\s+/));
+		l = l.filter((e) => e !== "");
+		let u = "";
+		for (let e = 0; e < l.length; e++) {
+			let n = decodeComment(l[e]);
+			if (n !== void 0) {
+				this._comments[this.fen()] = n;
+				continue;
+			}
+			let r = this._moveFromSan(l[e], t);
+			if (r == null) if (ee.indexOf(l[e]) > -1) u = l[e];
+			else throw Error(`Invalid move in PGN: ${l[e]}`);
+			else u = "", this._makeMove(r), this._incPositionCount(this.fen());
+		}
+		u && Object.keys(this._header).length && !this._header.Result && this.header("Result", u);
+	}
+	_moveToSan(e, t) {
+		let n = "";
+		if (e.flags & L.KSIDE_CASTLE) n = "O-O";
+		else if (e.flags & L.QSIDE_CASTLE) n = "O-O-O";
+		else {
+			if (e.piece !== "p") {
+				let r = getDisambiguator(e, t);
+				n += e.piece.toUpperCase() + r;
+			}
+			e.flags & (L.CAPTURE | L.EP_CAPTURE) && (e.piece === "p" && (n += algebraic(e.from)[0]), n += "x"), n += algebraic(e.to), e.promotion && (n += "=" + e.promotion.toUpperCase());
+		}
+		return this._makeMove(e), this.isCheck() && (this.isCheckmate() ? n += "#" : n += "+"), this._undoMove(), n;
+	}
+	_moveFromSan(e, t = !1) {
+		let n = strippedSan(e), r = inferPieceType(n), i = this._moves({
+			legal: !0,
+			piece: r
+		});
+		for (let e = 0, t = i.length; e < t; e++) if (n === strippedSan(this._moveToSan(i[e], i))) return i[e];
+		if (t) return null;
+		let a, o, s, c, l, u = !1;
+		if (o = n.match(/([pnbrqkPNBRQK])?([a-h][1-8])x?-?([a-h][1-8])([qrbnQRBN])?/), o ? (a = o[1], s = o[2], c = o[3], l = o[4], s.length == 1 && (u = !0)) : (o = n.match(/([pnbrqkPNBRQK])?([a-h]?[1-8]?)x?-?([a-h][1-8])([qrbnQRBN])?/), o && (a = o[1], s = o[2], c = o[3], l = o[4], s.length == 1 && (u = !0))), r = inferPieceType(n), i = this._moves({
+			legal: !0,
+			piece: a || r
+		}), !c) return null;
+		for (let e = 0, t = i.length; e < t; e++) if (!s) {
+			if (n === strippedSan(this._moveToSan(i[e], i)).replace("x", "")) return i[e];
+		} else if ((!a || a.toLowerCase() == i[e].piece) && R[s] == i[e].from && R[c] == i[e].to && (!l || l.toLowerCase() == i[e].promotion)) return i[e];
+		else if (u) {
+			let t = algebraic(i[e].from);
+			if ((!a || a.toLowerCase() == i[e].piece) && R[c] == i[e].to && (s == t[0] || s == t[1]) && (!l || l.toLowerCase() == i[e].promotion)) return i[e];
+		}
+		return null;
+	}
+	ascii() {
+		let e = "   +------------------------+\n";
+		for (let t = R.a8; t <= R.h1; t++) {
+			if (file(t) === 0 && (e += " " + "87654321"[rank(t)] + " |"), this._board[t]) {
+				let n = this._board[t].type, r = this._board[t].color === "w" ? n.toUpperCase() : n.toLowerCase();
+				e += " " + r + " ";
+			} else e += " . ";
+			t + 1 & 136 && (e += "|\n", t += 8);
+		}
+		return e += "   +------------------------+\n", e += "     a  b  c  d  e  f  g  h", e;
+	}
+	perft(e) {
+		let t = this._moves({ legal: !1 }), n = 0, r = this._turn;
+		for (let i = 0, a = t.length; i < a; i++) this._makeMove(t[i]), this._isKingAttacked(r) || (e - 1 > 0 ? n += this.perft(e - 1) : n++), this._undoMove();
+		return n;
+	}
+	turn() {
+		return this._turn;
+	}
+	board() {
+		let e = [], t = [];
+		for (let n = R.a8; n <= R.h1; n++) this._board[n] == null ? t.push(null) : t.push({
+			square: algebraic(n),
+			type: this._board[n].type,
+			color: this._board[n].color
+		}), n + 1 & 136 && (e.push(t), t = [], n += 8);
+		return e;
+	}
+	squareColor(e) {
+		if (e in R) {
+			let t = R[e];
+			return (rank(t) + file(t)) % 2 == 0 ? "light" : "dark";
+		}
+		return null;
+	}
+	history({ verbose: e = !1 } = {}) {
+		let t = [], n = [];
+		for (; this._history.length > 0;) t.push(this._undoMove());
+		for (;;) {
+			let r = t.pop();
+			if (!r) break;
+			e ? n.push(new Move(this, r)) : n.push(this._moveToSan(r, this._moves())), this._makeMove(r);
+		}
+		return n;
+	}
+	_getPositionCount(e) {
+		let t = trimFen(e);
+		return this._positionCount[t] || 0;
+	}
+	_incPositionCount(e) {
+		let t = trimFen(e);
+		this._positionCount[t] === void 0 && (this._positionCount[t] = 0), this._positionCount[t] += 1;
+	}
+	_decPositionCount(e) {
+		let t = trimFen(e);
+		this._positionCount[t] === 1 ? delete this._positionCount[t] : --this._positionCount[t];
+	}
+	_pruneComments() {
+		let e = [], t = {}, copyComment = (e) => {
+			e in this._comments && (t[e] = this._comments[e]);
+		};
+		for (; this._history.length > 0;) e.push(this._undoMove());
+		for (copyComment(this.fen());;) {
+			let t = e.pop();
+			if (!t) break;
+			this._makeMove(t), copyComment(this.fen());
+		}
+		this._comments = t;
+	}
+	getComment() {
+		return this._comments[this.fen()];
+	}
+	setComment(e) {
+		this._comments[this.fen()] = e.replace("{", "[").replace("}", "]");
+	}
+	deleteComment() {
+		return this.removeComment();
+	}
+	removeComment() {
+		let e = this._comments[this.fen()];
+		return delete this._comments[this.fen()], e;
+	}
+	getComments() {
+		return this._pruneComments(), Object.keys(this._comments).map((e) => ({
+			fen: e,
+			comment: this._comments[e]
+		}));
+	}
+	deleteComments() {
+		return this.removeComments();
+	}
+	removeComments() {
+		return this._pruneComments(), Object.keys(this._comments).map((e) => {
+			let t = this._comments[e];
+			return delete this._comments[e], {
+				fen: e,
+				comment: t
+			};
+		});
+	}
+	setCastlingRights(e, t) {
+		for (let n of ["k", "q"]) t[n] !== void 0 && (t[n] ? this._castling[e] |= X[n] : this._castling[e] &= ~X[n]);
+		this._updateCastlingRights();
+		let n = this.getCastlingRights(e);
+		return (t.k === void 0 || t.k === n.k) && (t.q === void 0 || t.q === n.q);
+	}
+	getCastlingRights(e) {
+		return {
+			k: (this._castling[e] & X.k) !== 0,
+			q: (this._castling[e] & X.q) !== 0
+		};
+	}
+	moveNumber() {
+		return this._moveNumber;
+	}
+};
+//#endregion
+//#region src/chess/composables/useChessgroundBounds.ts
+function useChessgroundBounds(e, t) {
+	let n = null, r = h(() => t.value, (t) => {
+		!t || !e.value || (requestAnimationFrame(() => t.redrawAll()), n = new ResizeObserver(() => t.redrawAll()), n.observe(e.value), r());
+	}, { immediate: !0 });
+	u(() => {
+		n?.disconnect(), n = null;
+	});
+}
+//#endregion
+//#region src/chess/questions/puzzle/puzzle.vue?vue&type=script&lang.ts
+var parseUciMove = (e) => {
+	if (e.length < 4 || e.length > 5) throw Error(`Invalid UCI move format: ${e}`);
+	return {
+		from: e.substring(0, 2),
+		to: e.substring(2, 4),
+		promotion: e.length === 5 ? e[4] : void 0
+	};
+}, toDests = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	return I.forEach((n) => {
+		let r = e.moves({
+			square: n,
+			verbose: !0
+		});
+		r.length && t.set(n, r.map((e) => e.to));
+	}), t;
+}, swapColor = (e) => e === "cg-white" ? "cg-black" : "cg-white", toColor = (e) => e.turn() === "w" ? "cg-white" : "cg-black", te = c({
+	name: "PuzzleView",
+	props: {
+		data: {
+			type: Array,
+			required: !0
+		},
+		modifyDifficulty: {
+			type: Number,
+			required: !1,
+			default: 0
+		}
+	},
+	setup(e, { emit: t }) {
+		let n = v(e, t, "PuzzleView"), r = _(n), a = f(null), o = f(), s = f(), c = f("cg-white"), d = f(!1), p = f(null);
+		useChessgroundBounds(a, s);
+		let m = [
+			{
+				value: "q",
+				name: "Queen",
+				whiteSymbol: "♕",
+				blackSymbol: "♛"
+			},
+			{
+				value: "r",
+				name: "Rook",
+				whiteSymbol: "♖",
+				blackSymbol: "♜"
+			},
+			{
+				value: "b",
+				name: "Bishop",
+				whiteSymbol: "♗",
+				blackSymbol: "♝"
+			},
+			{
+				value: "n",
+				name: "Knight",
+				whiteSymbol: "♘",
+				blackSymbol: "♞"
+			}
+		], h = i(() => {
+			let e = [
+				"a",
+				"b",
+				"c",
+				"d",
+				"e",
+				"f",
+				"g",
+				"h"
+			];
+			return c.value === "cg-white" ? e : e.reverse();
+		}), isPromotionPiece = (e) => e ? [
+			"q",
+			"r",
+			"b",
+			"n"
+		].includes(e) : !1, isUnfinishedPromotion = (e, t, n) => isPromotionPiece(n) ? !1 : o.value?.get(e)?.type === "p" && (t[1] === "8" || t[1] === "1"), updateChessground = () => {
+			!o.value || !s.value || s.value.set({
+				fen: o.value.fen(),
+				turnColor: toColor(o.value),
+				movable: {
+					color: toColor(o.value),
+					dests: toDests(o.value)
+				}
+			});
+		}, handlePromotion = (e) => {
+			if (e !== "q" && e !== "r" && e !== "b" && e !== "n") {
+				n.logger.error(`Invalid promotion piece: ${e}`);
+				return;
+			}
+			p.value && (n.logger.log(`promoting to ${e}`), d.value = !1, checkMove(p.value.from, p.value.to, e));
+		}, checkMove = (e, t, n) => {
+			if (!r.question.value?.moves.length) throw Error("No moves");
+			if (isUnfinishedPromotion(e, t, n)) {
+				p.value = {
+					from: e,
+					to: t
+				}, d.value = !0;
+				return;
+			}
+			r.question.value.moves[0] === (isPromotionPiece(n) ? `${e}${t}${n}` : `${e}${t}`) ? (o.value?.move({
+				from: e,
+				to: t,
+				promotion: isPromotionPiece(n) ? n : void 0
+			}), updateChessground(), r.question.value.moves.shift(), r.question.value.moves.length === 0 ? r.submitAnswer("") : window.setTimeout(() => {
+				if (!r.question.value) return;
+				let e = parseUciMove(r.question.value.moves.shift());
+				o.value?.move(e), updateChessground();
+			}, 300)) : (o.value?.move({
+				from: e,
+				to: t,
+				promotion: n
+			}), o.value?.isCheckmate() ? r.submitAnswer($.CHECKMATE) : o.value?.undo(), r.submitAnswer(e + t + n), updateChessground());
+		};
+		return l(() => {
+			if (!a.value) return;
+			r.question.value = new $(e.data), o.value = new Chess(r.question.value.fen), c.value = swapColor(toColor(o.value)), s.value = Chessground(a.value, {
+				movable: {
+					free: !1,
+					showDests: !0,
+					dests: toDests(o.value),
+					events: { after: checkMove }
+				},
+				draggable: { showGhost: !0 },
+				fen: o.value.fen(),
+				orientation: c.value,
+				coordinates: !1,
+				animation: {
+					duration: 300,
+					enabled: !0
+				}
+			});
+			let t = r.question.value.moves.shift();
+			s.value.move(t.substring(0, 2), t.substring(2)), o.value.move({
+				from: t.substring(0, 2),
+				to: t.substring(2)
+			}), updateChessground();
+		}), u(() => {
+			s.value?.destroy(), o.value = void 0;
+		}), {
+			boardElement: a,
+			playerColor: c,
+			files: h,
+			showPromotionDialog: d,
+			promotionPieces: m,
+			handlePromotion,
+			...n,
+			...r
+		};
+	}
+}), ne = { "data-viewable": "PuzzleView" }, re = { class: "text-h5" }, ie = { class: "puzzle-board-wrapper" }, ae = { class: "puzzle-ranks-labels" }, oe = { class: "puzzle-board-and-files" }, se = {
+	id: "cg",
+	ref: "boardElement"
+}, ce = { class: "puzzle-files-labels" }, le = {
+	key: 0,
+	class: "puzzle-promotion-dialog"
+}, ue = ["onClick"];
+function _sfc_render(e, t, n, i, c, l) {
+	return d(), o("div", ne, [
+		s("p", re, " Make the best move for " + m(e.playerColor === "cg-white" ? "White ♖♘♗♕♔♗♘♖" : "Black ♜♞♝♚♛♝♞♜") + ": ", 1),
+		s("div", ie, [s("div", ae, [(d(), o(r, null, p(8, (t) => s("div", { key: t }, m(e.playerColor === "cg-white" ? 9 - t : t), 1)), 64))]), s("div", oe, [s("div", se, null, 512), s("div", ce, [(d(!0), o(r, null, p(e.files, (e) => (d(), o("div", { key: e }, m(e), 1))), 128))])])]),
+		e.showPromotionDialog ? (d(), o("div", le, [(d(!0), o(r, null, p(e.promotionPieces, (t) => (d(), o("button", {
+			key: t.value,
+			onClick: (n) => e.handlePromotion(t.value)
+		}, m(e.playerColor === "cg-white" ? t.whiteSymbol : t.blackSymbol) + " " + m(t.name), 9, ue))), 128))])) : a("", !0)
+	]);
+}
+var de = /* @__PURE__ */ t(te, [["render", _sfc_render]]), $ = class ChessPuzzle extends g {
+	static dataShapes = [{
+		name: y.CHESS_puzzle,
+		fields: [{
+			name: "puzzleData",
+			type: b.CHESS_PUZZLE,
+			validator: {
+				instructions: "insert a valid fen string",
+				test: function(e) {
+					return console.log(`running puzzle validator on ${e}`), e ? e.split(",").length == 10 ? {
+						status: x.ok,
+						msg: ""
+					} : {
+						status: x.error,
+						msg: "puzzleData must have 8 comma-separated fields"
+					} : {
+						status: x.error,
+						msg: "no defined input"
+					};
+				}
+			},
+			tagger: () => ["test"]
+		}]
+	}];
+	static views = [de];
+	static acceptsUserData = !0;
+	static CHECKMATE = "CHECKMATE";
+	fen;
+	id;
+	moves;
+	rating;
+	themes;
+	constructor(e) {
+		super(e);
+		let [t, n, r, i, , , , a] = e[0].puzzleData.split(",");
+		this.id = t, this.fen = n, this.moves = r.split(" "), this.rating = parseInt(i, 10), this.themes = a.split(" ");
+	}
+	checkMove = (e, t) => (alert("checkMove"), console.log("checkMove", e, t), console.log("this.moves[0]", this.moves[0]), this.moves[0] === t);
+	evaluate(e, t) {
+		return {
+			isCorrect: this.isCorrect(e),
+			performance: this.displayedSkill(e, t)
+		};
+	}
+	displayedSkill(e, t) {
+		return this.isCorrect(e) ? t < 5e3 ? 1 : 1 - Math.min(1, (t - 5e3) / 1e4) : 0;
+	}
+	dataShapes() {
+		return ChessPuzzle.dataShapes;
+	}
+	views() {
+		return ChessPuzzle.views;
+	}
+	isCorrect(e) {
+		let t = this.moves.length === 0;
+		return e === ChessPuzzle.CHECKMATE || t;
+	}
+}, fe = new n("chess", [$]);
+//#endregion
+export { fe as t };
+
+//# sourceMappingURL=chess-BbHATAzk.js.map