check-board 0.0.1

package/dist/check-board.es.js

@@ -0,0 +1,3664 @@
+import oe, { useCallback as K, useRef as O, useMemo as le, useEffect as ue, useImperativeHandle as he } from "react";
+var G = { exports: {} }, F = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ne;
+function de() {
+  if (ne) return F;
+  ne = 1;
+  var d = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function t(r, n, i) {
+    var s = null;
+    if (i !== void 0 && (s = "" + i), n.key !== void 0 && (s = "" + n.key), "key" in n) {
+      i = {};
+      for (var a in n)
+        a !== "key" && (i[a] = n[a]);
+    } else i = n;
+    return n = i.ref, {
+      $$typeof: d,
+      type: r,
+      key: s,
+      ref: n !== void 0 ? n : null,
+      props: i
+    };
+  }
+  return F.Fragment = e, F.jsx = t, F.jsxs = t, F;
+}
+var V = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ie;
+function fe() {
+  return ie || (ie = 1, process.env.NODE_ENV !== "production" && (function() {
+    function d(l) {
+      if (l == null) return null;
+      if (typeof l == "function")
+        return l.$$typeof === I ? null : l.displayName || l.name || null;
+      if (typeof l == "string") return l;
+      switch (l) {
+        case v:
+          return "Fragment";
+        case p:
+          return "Profiler";
+        case C:
+          return "StrictMode";
+        case x:
+          return "Suspense";
+        case M:
+          return "SuspenseList";
+        case A:
+          return "Activity";
+      }
+      if (typeof l == "object")
+        switch (typeof l.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), l.$$typeof) {
+          case P:
+            return "Portal";
+          case w:
+            return l.displayName || "Context";
+          case m:
+            return (l._context.displayName || "Context") + ".Consumer";
+          case R:
+            var S = l.render;
+            return l = l.displayName, l || (l = S.displayName || S.name || "", l = l !== "" ? "ForwardRef(" + l + ")" : "ForwardRef"), l;
+          case E:
+            return S = l.displayName || null, S !== null ? S : d(l.type) || "Memo";
+          case T:
+            S = l._payload, l = l._init;
+            try {
+              return d(l(S));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function e(l) {
+      return "" + l;
+    }
+    function t(l) {
+      try {
+        e(l);
+        var S = !1;
+      } catch {
+        S = !0;
+      }
+      if (S) {
+        S = console;
+        var k = S.error, D = typeof Symbol == "function" && Symbol.toStringTag && l[Symbol.toStringTag] || l.constructor.name || "Object";
+        return k.call(
+          S,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          D
+        ), e(l);
+      }
+    }
+    function r(l) {
+      if (l === v) return "<>";
+      if (typeof l == "object" && l !== null && l.$$typeof === T)
+        return "<...>";
+      try {
+        var S = d(l);
+        return S ? "<" + S + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function n() {
+      var l = z.A;
+      return l === null ? null : l.getOwner();
+    }
+    function i() {
+      return Error("react-stack-top-frame");
+    }
+    function s(l) {
+      if (q.call(l, "key")) {
+        var S = Object.getOwnPropertyDescriptor(l, "key").get;
+        if (S && S.isReactWarning) return !1;
+      }
+      return l.key !== void 0;
+    }
+    function a(l, S) {
+      function k() {
+        W || (W = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          S
+        ));
+      }
+      k.isReactWarning = !0, Object.defineProperty(l, "key", {
+        get: k,
+        configurable: !0
+      });
+    }
+    function o() {
+      var l = d(this.type);
+      return Q[l] || (Q[l] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), l = this.props.ref, l !== void 0 ? l : null;
+    }
+    function c(l, S, k, D, X, J) {
+      var L = k.ref;
+      return l = {
+        $$typeof: g,
+        type: l,
+        key: S,
+        props: k,
+        _owner: D
+      }, (L !== void 0 ? L : null) !== null ? Object.defineProperty(l, "ref", {
+        enumerable: !1,
+        get: o
+      }) : Object.defineProperty(l, "ref", { enumerable: !1, value: null }), l._store = {}, Object.defineProperty(l._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(l, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(l, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: X
+      }), Object.defineProperty(l, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: J
+      }), Object.freeze && (Object.freeze(l.props), Object.freeze(l)), l;
+    }
+    function u(l, S, k, D, X, J) {
+      var L = S.children;
+      if (L !== void 0)
+        if (D)
+          if (j(L)) {
+            for (D = 0; D < L.length; D++)
+              h(L[D]);
+            Object.freeze && Object.freeze(L);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else h(L);
+      if (q.call(S, "key")) {
+        L = d(l);
+        var _ = Object.keys(S).filter(function(ce) {
+          return ce !== "key";
+        });
+        D = 0 < _.length ? "{key: someKey, " + _.join(": ..., ") + ": ...}" : "{key: someKey}", re[L + D] || (_ = 0 < _.length ? "{" + _.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          D,
+          L,
+          _,
+          L
+        ), re[L + D] = !0);
+      }
+      if (L = null, k !== void 0 && (t(k), L = "" + k), s(S) && (t(S.key), L = "" + S.key), "key" in S) {
+        k = {};
+        for (var Z in S)
+          Z !== "key" && (k[Z] = S[Z]);
+      } else k = S;
+      return L && a(
+        k,
+        typeof l == "function" ? l.displayName || l.name || "Unknown" : l
+      ), c(
+        l,
+        L,
+        k,
+        n(),
+        X,
+        J
+      );
+    }
+    function h(l) {
+      y(l) ? l._store && (l._store.validated = 1) : typeof l == "object" && l !== null && l.$$typeof === T && (l._payload.status === "fulfilled" ? y(l._payload.value) && l._payload.value._store && (l._payload.value._store.validated = 1) : l._store && (l._store.validated = 1));
+    }
+    function y(l) {
+      return typeof l == "object" && l !== null && l.$$typeof === g;
+    }
+    var f = oe, g = Symbol.for("react.transitional.element"), P = Symbol.for("react.portal"), v = Symbol.for("react.fragment"), C = Symbol.for("react.strict_mode"), p = Symbol.for("react.profiler"), m = Symbol.for("react.consumer"), w = Symbol.for("react.context"), R = Symbol.for("react.forward_ref"), x = Symbol.for("react.suspense"), M = Symbol.for("react.suspense_list"), E = Symbol.for("react.memo"), T = Symbol.for("react.lazy"), A = Symbol.for("react.activity"), I = Symbol.for("react.client.reference"), z = f.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, q = Object.prototype.hasOwnProperty, j = Array.isArray, B = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    f = {
+      react_stack_bottom_frame: function(l) {
+        return l();
+      }
+    };
+    var W, Q = {}, U = f.react_stack_bottom_frame.bind(
+      f,
+      i
+    )(), Y = B(r(i)), re = {};
+    V.Fragment = v, V.jsx = function(l, S, k) {
+      var D = 1e4 > z.recentlyCreatedOwnerStacks++;
+      return u(
+        l,
+        S,
+        k,
+        !1,
+        D ? Error("react-stack-top-frame") : U,
+        D ? B(r(l)) : Y
+      );
+    }, V.jsxs = function(l, S, k) {
+      var D = 1e4 > z.recentlyCreatedOwnerStacks++;
+      return u(
+        l,
+        S,
+        k,
+        !0,
+        D ? Error("react-stack-top-frame") : U,
+        D ? B(r(l)) : Y
+      );
+    };
+  })()), V;
+}
+var se;
+function ge() {
+  return se || (se = 1, process.env.NODE_ENV === "production" ? G.exports = de() : G.exports = fe()), G.exports;
+}
+var H = ge();
+class b {
+  static files = "abcdefgh";
+  static P1 = 73856093;
+  static P2 = 19349663;
+  static P3 = 83492791;
+  static P4 = 1640531513;
+  constructor() {
+  }
+  static getHashingNumbers() {
+    const { P1: e, P2: t, P3: r, P4: n } = this;
+    return { P1: e, P2: t, P3: r, P4: n };
+  }
+  static squareToCoords(e, t, r) {
+    if (e) {
+      const n = this.files.indexOf(e.file), i = e.rank - 1;
+      return r ? {
+        x: Math.floor((7 - n) * t),
+        y: Math.floor(i * t)
+      } : {
+        x: Math.floor(n * t),
+        y: Math.floor((7 - i) * t)
+      };
+    }
+  }
+  static coordsToSquare = (e, t, r, n) => {
+    let i = Math.floor(e / r), s = 7 - Math.floor(t / r);
+    if (i < 0 || i > 7 || s < 0 || s > 8) return null;
+    n && (i = 7 - Math.floor(e / r), s = Math.floor(t / r));
+    const a = this.files[i], o = s + 1;
+    return a && o ? { file: a, rank: o, notation: `${a}${o}` } : null;
+  };
+  static notationToSquare(e) {
+    if (e.length !== 2) return null;
+    const t = e.charAt(0), r = parseInt(e.charAt(1));
+    if (/^[a-h]$/.test(t)) {
+      if (r < 1 || r > 8) return null;
+    } else return null;
+    return { file: t, rank: r, notation: e };
+  }
+  static getCanvasCoords = (e) => {
+    const t = e.target.getBoundingClientRect(), r = e.clientX - t.left, n = e.clientY - t.top;
+    return { offsetX: r, offsetY: n };
+  };
+  static async asyncHandler(e) {
+    return new Promise((t) => {
+      e(t);
+    });
+  }
+  static deepFreeze(e) {
+    const t = structuredClone(e);
+    if (t === null || typeof t != "object" || Object.isFrozen(t))
+      return t;
+    if (t instanceof Array)
+      t.forEach((r, n) => {
+        t[n] = this.deepFreeze(r);
+      });
+    else if (t instanceof Map)
+      t.forEach((r, n) => {
+        t.set(this.deepFreeze(n), this.deepFreeze(r));
+      });
+    else if (t instanceof Set) {
+      const r = Array.from(t).map(this.deepFreeze);
+      t.clear(), r.forEach((n) => t.add(n));
+    } else
+      Object.getOwnPropertyNames(t).forEach((r) => {
+        const n = t[r];
+        t[r] = this.deepFreeze(n);
+      });
+    return Object.freeze(t);
+  }
+  static parseFen(e) {
+    if (e = e.trim(), !this.validateFen(e).status) return {};
+    const r = e.split("/"), n = /^[1-8]$/, i = /^[PNBRQK]$/, s = "abcdefgh", a = {};
+    let o = 8;
+    for (const c of r) {
+      let u = 0;
+      for (const h of c) {
+        if (n.test(h)) {
+          u += Number(h);
+          continue;
+        }
+        const y = i.test(h), f = s[u], g = o, P = `${y ? "w" : "b"}${h.toUpperCase()}`, v = `${f}${g}`;
+        a[P] || (a[P] = []), a[P].push(v), u++;
+      }
+      o--;
+    }
+    return a;
+  }
+  static parseBoard(e) {
+    const t = "abcdefgh";
+    let r = "";
+    for (let n = 8; n >= 1; n--) {
+      let i = 0;
+      for (const s of t) {
+        const a = `${s}${n}`, o = e[a];
+        if (o) {
+          i > 0 && (r += i, i = 0);
+          const u = o.type.startsWith("w") ? o.type[1] : o.type[1].toLowerCase();
+          r += u;
+        } else i++;
+      }
+      i > 0 && (r += i), n !== 1 && (r += "/");
+    }
+    return r;
+  }
+  static validateFen(e) {
+    if (e = e.trim(), !/^(?:[pnbrqkPNBRQK1-8]+\/){7}[pnbrqkPNBRQK1-8]+$/.test(e))
+      return { status: !1, error: "Invalid format or characters" };
+    const t = e.split("/");
+    if (t.length !== 8)
+      return { status: !1, error: "Must contain exactly 8 ranks" };
+    const r = /^[1-8]$/, n = /^[pnbrqkPNBRQK]$/;
+    for (const i of t) {
+      let s = 0;
+      for (const a of i)
+        if (r.test(a)) s += Number(a);
+        else if (n.test(a)) s += 1;
+        else return { status: !1, error: `Invalid char '${a}'` };
+      if (s !== 8)
+        return { status: !1, error: `Rank '${i}' does not sum to 8` };
+    }
+    return { status: !0 };
+  }
+  static createBaseCtx(e) {
+    const t = /* @__PURE__ */ new Map();
+    let r = [];
+    const n = [], i = [];
+    function s(f, g, P, v) {
+      const C = e.shadowBlur || 0, p = e.shadowOffsetX || 0, m = e.shadowOffsetY || 0, w = Math.abs(p) + C, R = Math.abs(m) + C;
+      return {
+        x: f - w,
+        y: g - R,
+        w: P + w * 2,
+        h: v + R * 2
+      };
+    }
+    function a(f, g, P, v, C) {
+      if (!Number.isFinite(g) || !Number.isFinite(P) || v <= 0 || C <= 0)
+        return;
+      const p = s(g, P, v, C);
+      n.push({
+        x: p.x,
+        y: p.y,
+        w: p.w,
+        h: p.h,
+        type: f
+      });
+    }
+    function o(f, g, P, v) {
+      !Number.isFinite(f) || !Number.isFinite(g) || P <= 0 || v <= 0 || i.push({
+        x: f,
+        y: g,
+        w: P,
+        h: v
+      });
+    }
+    function c(f, g, P, v = 0.05) {
+      const C = [];
+      for (let p = 0; p <= 1.001; p += v) {
+        const m = (1 - p) * (1 - p) * f.x + 2 * (1 - p) * p * g.x + p * p * P.x, w = (1 - p) * (1 - p) * f.y + 2 * (1 - p) * p * g.y + p * p * P.y;
+        C.push({ x: m, y: w });
+      }
+      return C;
+    }
+    function u(f, g, P, v, C = 0.05) {
+      const p = [];
+      for (let m = 0; m <= 1.001; m += C) {
+        const w = Math.pow(1 - m, 3) * f.x + 3 * Math.pow(1 - m, 2) * m * g.x + 3 * (1 - m) * Math.pow(m, 2) * P.x + Math.pow(m, 3) * v.x, R = Math.pow(1 - m, 3) * f.y + 3 * Math.pow(1 - m, 2) * m * g.y + 3 * (1 - m) * Math.pow(m, 2) * P.y + Math.pow(m, 3) * v.y;
+        p.push({ x: w, y: R });
+      }
+      return p;
+    }
+    function h(f) {
+      const P = f.font.match(/(\d+(?:\.\d+)?)px/);
+      return P ? parseFloat(P[1]) : 16;
+    }
+    const y = new Proxy(e, {
+      get(f, g) {
+        if (t.has(g)) return t.get(g);
+        const P = f[g];
+        if (typeof P != "function")
+          return t.set(g, P), P;
+        const C = ((...p) => {
+          try {
+            switch (g) {
+              case "beginPath":
+                r = [];
+                break;
+              case "moveTo":
+              case "lineTo": {
+                const [m, w] = p;
+                Number.isFinite(m) && Number.isFinite(w) && r.push({ x: m, y: w });
+                break;
+              }
+              case "rect": {
+                const [m, w, R, x] = p;
+                a(g, m, w, R, x), r.push({ x: m, y: w }, { x: m + R, y: w + x });
+                break;
+              }
+              case "arc": {
+                const [m, w, R] = p;
+                Number.isFinite(m) && Number.isFinite(w) && Number.isFinite(R) && (a(g, m - R, w - R, R * 2, R * 2), r.push(
+                  { x: m - R, y: w - R },
+                  { x: m + R, y: w + R }
+                ));
+                break;
+              }
+              case "ellipse": {
+                const [m, w, R, x] = p;
+                Number.isFinite(m) && Number.isFinite(w) && R && x && (a(g, m - R, w - x, R * 2, x * 2), r.push(
+                  { x: m - R, y: w - x },
+                  { x: m + R, y: w + x }
+                ));
+                break;
+              }
+              case "quadraticCurveTo": {
+                const [m, w, R, x] = p, M = r[r.length - 1];
+                if (M && Number.isFinite(m) && Number.isFinite(w)) {
+                  const E = c(M, { x: m, y: w }, { x: R, y: x });
+                  r.push(...E);
+                } else
+                  r.push({ x: R, y: x });
+                break;
+              }
+              case "bezierCurveTo": {
+                const [m, w, R, x, M, E] = p, T = r[r.length - 1];
+                if (T && [m, w, R, x, M, E].every(Number.isFinite)) {
+                  const A = u(
+                    T,
+                    { x: m, y: w },
+                    { x: R, y: x },
+                    { x: M, y: E }
+                  );
+                  r.push(...A);
+                } else
+                  r.push({ x: M, y: E });
+                break;
+              }
+              case "fill":
+              case "stroke": {
+                if (p[0] instanceof Path2D)
+                  a(g, 0, 0, e.canvas.width, e.canvas.height);
+                else if (r.length) {
+                  const w = r.map((I) => I.x), R = r.map((I) => I.y), x = Math.min(...w), M = Math.min(...R), E = Math.max(...w), T = Math.max(...R), A = Math.max((e.lineWidth ?? 1) * 0.95, 1);
+                  a(
+                    g,
+                    x - A,
+                    M - A,
+                    E - x + A * 2,
+                    T - M + A * 2
+                  ), r = [];
+                }
+                break;
+              }
+              case "fillRect":
+              case "strokeRect": {
+                const [m, w, R, x] = p, M = e.lineWidth ?? 2;
+                a(g, m - M, w - M, R + M * 2, x + M * 2);
+                break;
+              }
+              case "fillText":
+              case "strokeText": {
+                const [m, w, R] = p;
+                if (typeof m != "string" || !Number.isFinite(w) || !Number.isFinite(R))
+                  break;
+                const x = h(e), M = e.measureText(m), E = M.actualBoundingBoxAscent || x * 0.8, T = M.actualBoundingBoxDescent || x * 0.2, A = M.width || m.length * x * 0.5, I = x * 0.35, z = x * 0.15, q = x * 0.2;
+                let j = w, B = R - E;
+                switch (e.textAlign) {
+                  case "center":
+                    j = w - A / 2;
+                    break;
+                  case "right":
+                  case "end":
+                    j = w - A;
+                    break;
+                }
+                switch (e.textBaseline) {
+                  case "top":
+                    B = R;
+                    break;
+                  case "middle":
+                    B = R - E * 0.6;
+                    break;
+                  case "bottom":
+                    B = R - E - T;
+                    break;
+                  case "alphabetic":
+                  default:
+                    B = R - E;
+                }
+                const W = j - q, Q = B - I, U = A + q * 2, Y = E + T + I + z;
+                a(g, W, Q, U, Y), o(j, B, A, E + T);
+                break;
+              }
+              case "drawImage": {
+                let m = null, w = 0, R = 0, x = 0, M = 0;
+                if (p.length === 3 ? ([m, w, R] = p, x = m?.width ?? 32, M = m?.height ?? 32) : p.length === 5 ? [m, w, R, x, M] = p : p.length === 9 && ([, , , , , w, R, x, M] = p, m = p[0]), m instanceof HTMLVideoElement) {
+                  console.warn(
+                    "⚠️ [SafeCtx] drawImage with video is blocked for safety reasons."
+                  );
+                  return;
+                }
+                const E = 0;
+                a(
+                  "drawImage",
+                  w - E,
+                  R - E,
+                  x + E * 2,
+                  M + E * 2
+                ), o(w, R, x, M);
+                break;
+              }
+            }
+          } catch (m) {
+            console.warn(`[SafeCtx:${g}]`, m);
+          }
+          return P.apply(f, p);
+        }).bind(f);
+        return t.set(g, C), C;
+      },
+      set(f, g, P) {
+        return f[g] = P, !0;
+      }
+    });
+    return y.__drawRegions = n, y.__currentPath = r, y.__clearRegions = () => {
+      n.length = 0, i.length = 0;
+    }, y.__actualRegions = i, y;
+  }
+  static createSafeCtx(e) {
+    const t = /* @__PURE__ */ new Set([
+      "clearRect",
+      "reset",
+      "resetTransform",
+      "restore",
+      "save",
+      "scale",
+      "rotate",
+      "translate",
+      "transform",
+      "setTransform",
+      "clip",
+      "arcTo"
+    ]), r = /* @__PURE__ */ new Set([
+      "canvas",
+      "filter",
+      "globalAlpha",
+      "globalCompositeOperation"
+    ]), n = /* @__PURE__ */ new Map();
+    return new Proxy(e, {
+      get(s, a, o) {
+        if (n.has(a)) return n.get(a);
+        if (t.has(a)) {
+          const u = () => console.warn(`⚠️ [SafeCtx] Access to ${a}() is restricted.`);
+          return n.set(a, u), u;
+        }
+        const c = s[a];
+        return n.set(a, c), c;
+      },
+      set(s, a, o) {
+        return r.has(a) ? (console.warn(
+          `⚠️ [SafeCtx] Modification to ${String(a)} is restricted.`
+        ), !1) : (s[a] = o, !0);
+      }
+    });
+  }
+}
+class me {
+  staticPiecesCanvas;
+  boardCanvas;
+  overlayCanvas;
+  underlayCanvas;
+  dynamicPiecesCanvas;
+  staticPiecesCtx = null;
+  boardCtx = null;
+  overlayCtx = null;
+  underlayCtx = null;
+  dynamicPiecesCtx = null;
+  clientStaticPiecesCtx = null;
+  clientBoardCtx = null;
+  clientOverlayCtx = null;
+  clientUnderlayCtx = null;
+  clientDynamicPiecesCtx = null;
+  clientCtxMap = {
+    staticPieces: this.clientStaticPiecesCtx,
+    board: this.clientBoardCtx,
+    overlay: this.clientOverlayCtx,
+    underlay: this.clientUnderlayCtx,
+    dynamicPieces: this.clientDynamicPiecesCtx
+  };
+  overlayOffscreen;
+  underlayOffscreen;
+  dynamicPiecesOffscreen;
+  overlayOffscreenCtx = null;
+  underlayOffscreenCtx = null;
+  dynamicPiecesOffscreenCtx = null;
+  size;
+  dpr = 1;
+  constructor(e, t, r, n, i, s) {
+    this.staticPiecesCanvas = t, this.boardCanvas = e, this.overlayCanvas = r, this.underlayCanvas = n, this.dynamicPiecesCanvas = i, this.size = s, this.disableTouchAction(), this.setContext(), this.setQuality();
+  }
+  destroy() {
+    this.clearAllRect(), this.clearCanvas();
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+  }
+  disableTouchAction() {
+    [
+      "board",
+      "staticPieces",
+      "overlay",
+      "underlay",
+      "dynamicPieces"
+    ].forEach((e) => this.setCanvasStyle(e, { touchAction: "none" }));
+  }
+  getContext(e) {
+    return this[`${e}Ctx`] === null && this[`${e}Canvas`].current && this.setContext(), this[`${e}Ctx`];
+  }
+  getClientContext(e) {
+    return this.clientCtxMap[e];
+  }
+  getCanvas(e) {
+    return this[`${e}Canvas`];
+  }
+  keepQuality(e, t) {
+    const r = this[`${e}Canvas`].current;
+    if (!r) return;
+    const n = window.devicePixelRatio || 1;
+    this.dpr = n;
+    const i = t * n, s = t * n;
+    if (r.width === i && r.height === s) return;
+    r.width = i, r.height = s, r.style.width = t + "px", r.style.height = t + "px";
+    const a = this.getContext(e);
+    a && (a.setTransform(1, 0, 0, 1, 0, 0), a.scale(n, n), a.imageSmoothingEnabled = !0, a.imageSmoothingQuality = "high");
+  }
+  getDpr() {
+    return this.dpr;
+  }
+  setCanvasStyle(e, t) {
+    const r = this[`${e}Canvas`].current;
+    if (r)
+      for (const [n, i] of Object.entries(t))
+        i && (r.style[n] = i);
+  }
+  setOffscreen() {
+    if (typeof OffscreenCanvas !== void 0)
+      try {
+        this.overlayOffscreen = new OffscreenCanvas(this.size, this.size), this.underlayOffscreen = new OffscreenCanvas(this.size, this.size), this.dynamicPiecesOffscreen = new OffscreenCanvas(this.size, this.size), this.overlayOffscreenCtx = this.overlayOffscreen.getContext("2d"), this.underlayOffscreenCtx = this.underlayOffscreen.getContext("2d"), this.dynamicPiecesOffscreenCtx = this.dynamicPiecesOffscreen.getContext("2d");
+      } catch {
+        console.warn(
+          "OffscreenCanvas not supported, using normal canvas rendering."
+        );
+      }
+  }
+  setContext() {
+    const e = this.staticPiecesCanvas.current?.getContext("2d"), t = this.boardCanvas.current?.getContext("2d"), r = this.overlayCanvas.current?.getContext("2d"), n = this.underlayCanvas.current?.getContext("2d"), i = this.dynamicPiecesCanvas.current?.getContext("2d");
+    this.staticPiecesCtx = e ? b.createBaseCtx(e) : null, this.boardCtx = t ? b.createBaseCtx(t) : null, this.overlayCtx = r ? b.createBaseCtx(r) : null, this.underlayCtx = n ? b.createBaseCtx(n) : null, this.dynamicPiecesCtx = i ? b.createBaseCtx(i) : null, this.clientStaticPiecesCtx = this.staticPiecesCtx ? b.createSafeCtx(this.staticPiecesCtx) : null, this.clientBoardCtx = this.boardCtx ? b.createSafeCtx(this.boardCtx) : null, this.clientOverlayCtx = this.overlayCtx ? b.createSafeCtx(this.overlayCtx) : null, this.clientUnderlayCtx = this.underlayCtx ? b.createSafeCtx(this.underlayCtx) : null, this.clientDynamicPiecesCtx = this.dynamicPiecesCtx ? b.createSafeCtx(this.dynamicPiecesCtx) : null, this.clientCtxMap = {
+      staticPieces: this.clientStaticPiecesCtx,
+      board: this.clientBoardCtx,
+      overlay: this.clientOverlayCtx,
+      underlay: this.clientUnderlayCtx,
+      dynamicPieces: this.clientDynamicPiecesCtx
+    };
+  }
+  setQuality() {
+    [
+      "board",
+      "staticPieces",
+      "overlay",
+      "underlay",
+      "dynamicPieces"
+    ].forEach((e) => this.keepQuality(e, this.size));
+  }
+  blitOffscreenToMain() {
+    const e = this.overlayCtx, t = this.underlayCtx, r = this.dynamicPiecesCtx;
+    e && this.overlayOffscreen && e.drawImage(this.overlayOffscreen, 0, 0), t && this.underlayOffscreen && t.drawImage(this.underlayOffscreen, 0, 0), r && this.dynamicPiecesOffscreen && r.drawImage(this.dynamicPiecesOffscreen, 0, 0);
+  }
+  resize(e) {
+    this.size = e, this.setQuality();
+  }
+  clearAllRect(e) {
+    if (e) {
+      for (const [t, r] of Object.entries(e)) {
+        if (!r) continue;
+        this[`${t}Ctx`]?.clearRect(0, 0, this.size, this.size);
+      }
+      return;
+    }
+    [
+      this.staticPiecesCtx,
+      this.boardCtx,
+      this.overlayCtx,
+      this.underlayCtx,
+      this.dynamicPiecesCtx
+    ].forEach((t) => t?.clearRect(0, 0, this.size, this.size));
+  }
+  clearCanvas() {
+    [
+      this.boardCanvas,
+      this.overlayCanvas,
+      this.staticPiecesCanvas,
+      this.underlayCanvas,
+      this.dynamicPiecesCanvas
+    ].forEach((t) => {
+      const r = t.current;
+      if (r) {
+        const n = r.getContext("2d");
+        n?.setTransform(1, 0, 0, 1, 0, 0), n?.clearRect(0, 0, r.width, r.height);
+      }
+      t.current = null;
+    }), this.boardCtx = null, this.overlayCtx = null, this.staticPiecesCtx = null, this.underlayCtx = null, this.dynamicPiecesCtx = null;
+  }
+}
+const ye = ({
+  boardRuntime: d,
+  boardRef: e,
+  staticPiecesRef: t,
+  overlayRef: r,
+  underlayRef: n,
+  dynamicPiecesRef: i,
+  size: s
+}) => {
+  const a = K(
+    (h) => {
+      d.current?.boardEvents.OnPointerDown(h);
+    },
+    [d]
+  ), o = K(
+    (h) => {
+      d.current?.boardEvents.onPointerMove(h);
+    },
+    [d]
+  ), c = K(
+    (h) => {
+      d.current?.boardEvents.onPointerUp(h);
+    },
+    [d]
+  ), u = K(
+    (h) => {
+      d.current?.boardEvents.onPointerLeave(h);
+    },
+    [d]
+  );
+  return /* @__PURE__ */ H.jsxs(
+    "div",
+    {
+      style: {
+        position: "relative",
+        width: s,
+        height: s
+      },
+      children: [
+        /* @__PURE__ */ H.jsx(
+          "canvas",
+          {
+            ref: e,
+            width: s,
+            height: s,
+            style: {
+              display: "block",
+              position: "absolute",
+              top: 0,
+              left: 0,
+              pointerEvents: "none",
+              zIndex: 1
+            }
+          }
+        ),
+        /* @__PURE__ */ H.jsx(
+          "canvas",
+          {
+            ref: t,
+            width: s,
+            height: s,
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              background: "transparent",
+              zIndex: 2
+            },
+            onPointerDown: a,
+            onPointerMove: o,
+            onPointerUp: c,
+            onPointerLeave: u
+          }
+        ),
+        /* @__PURE__ */ H.jsx(
+          "canvas",
+          {
+            ref: r,
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              background: "transparent",
+              pointerEvents: "none",
+              zIndex: 1
+            },
+            width: s,
+            height: s
+          }
+        ),
+        /* @__PURE__ */ H.jsx(
+          "canvas",
+          {
+            ref: n,
+            width: s,
+            height: s,
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              background: "transparent",
+              zIndex: 3,
+              pointerEvents: "none"
+            }
+          }
+        ),
+        /* @__PURE__ */ H.jsx(
+          "canvas",
+          {
+            ref: i,
+            width: s,
+            height: s,
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              background: "transparent",
+              zIndex: 4,
+              pointerEvents: "none"
+            }
+          }
+        )
+      ]
+    }
+  );
+}, ae = [
+  "wP",
+  "wB",
+  "wR",
+  "wN",
+  "wQ",
+  "wK",
+  "bP",
+  "bB",
+  "bR",
+  "bN",
+  "bQ",
+  "bK"
+];
+class ve {
+  constructor(e) {
+    this.boardRuntime = e, this.boardRuntime = e;
+  }
+  destroy() {
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+  }
+  OnPointerDown(e) {
+    this.boardRuntime.getIsMoving() || (this.boardRuntime.getEventEmitter().emit("onPointerDown"), this.boardRuntime.helpers.pointerEventsHelper.startPress(e));
+  }
+  onPointerMove(e) {
+    this.boardRuntime.getIsMoving() || (this.boardRuntime.getEventEmitter().emit("onPointerMove"), this.boardRuntime.helpers.pointerEventsHelper.handlePieceHover(e), this.boardRuntime.helpers.pointerEventsHelper.handleGrab(e));
+  }
+  onPointerUp(e) {
+    this.boardRuntime.helpers.pointerEventsHelper.handlePointerUp(e), !this.boardRuntime.getIsMoving() && this.boardRuntime.getEventEmitter().emit("onPointerUp");
+  }
+  onPointerLeave(e) {
+    this.boardRuntime.getIsMoving() || this.boardRuntime.helpers.pointerEventsHelper.handlePointerLeave(e);
+  }
+}
+const pe = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cpath%20fill='%23fff'%20stroke='%23000'%20stroke-linecap='round'%20stroke-width='1.5'%20d='M22.5%209c-2.21%200-4%201.79-4%204%200%20.89.29%201.71.78%202.38C17.33%2016.5%2016%2018.59%2016%2021c0%202.03.94%203.84%202.41%205.03-3%201.06-7.41%205.55-7.41%2013.47h23c0-7.92-4.41-12.41-7.41-13.47%201.47-1.19%202.41-3%202.41-5.03%200-2.41-1.33-4.5-3.28-5.62.49-.67.78-1.49.78-2.38%200-2.21-1.79-4-4-4z'/%3e%3c/svg%3e", Pe = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill='none'%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cg%20fill='%23fff'%20stroke-linecap='butt'%3e%3cpath%20d='M9%2036c3.39-.97%2010.11.43%2013.5-2%203.39%202.43%2010.11%201.03%2013.5%202%200%200%201.65.54%203%202-.68.97-1.65.99-3%20.5-3.39-.97-10.11.46-13.5-1-3.39%201.46-10.11.03-13.5%201-1.35.49-2.32.47-3-.5%201.35-1.94%203-2%203-2z'/%3e%3cpath%20d='M15%2032c2.5%202.5%2012.5%202.5%2015%200%20.5-1.5%200-2%200-2%200-2.5-2.5-4-2.5-4%205.5-1.5%206-11.5-5-15.5-11%204-10.5%2014-5%2015.5%200%200-2.5%201.5-2.5%204%200%200-.5.5%200%202z'/%3e%3cpath%20d='M25%208a2.5%202.5%200%201%201-5%200%202.5%202.5%200%201%201%205%200z'/%3e%3c/g%3e%3cpath%20stroke-linejoin='miter'%20d='M17.5%2026h10M15%2030h15m-7.5-14.5v5M20%2018h5'/%3e%3c/g%3e%3c/svg%3e", we = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill='none'%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cpath%20fill='%23fff'%20d='M22%2010c10.5%201%2016.5%208%2016%2029H15c0-9%2010-6.5%208-21'/%3e%3cpath%20fill='%23fff'%20d='M24%2018c.38%202.91-5.55%207.37-8%209-3%202-2.82%204.34-5%204-1.042-.94%201.41-3.04%200-3-1%200%20.19%201.23-1%202-1%200-4.003%201-4-4%200-2%206-12%206-12s1.89-1.9%202-3.5c-.73-.994-.5-2-.5-3%201-1%203%202.5%203%202.5h2s.78-1.992%202.5-3c1%200%201%203%201%203'/%3e%3cpath%20fill='%23000'%20d='M9.5%2025.5a.5.5%200%201%201-1%200%20.5.5%200%201%201%201%200zm5.433-9.75a.5%201.5%2030%201%201-.866-.5.5%201.5%2030%201%201%20.866.5z'/%3e%3c/g%3e%3c/svg%3e", be = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill='%23fff'%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cpath%20stroke-linecap='butt'%20d='M9%2039h27v-3H9v3zm3-3v-4h21v4H12zm-1-22V9h4v2h5V9h5v2h5V9h4v5'/%3e%3cpath%20d='m34%2014-3%203H14l-3-3'/%3e%3cpath%20stroke-linecap='butt'%20stroke-linejoin='miter'%20d='M31%2017v12.5H14V17'/%3e%3cpath%20d='m31%2029.5%201.5%202.5h-20l1.5-2.5'/%3e%3cpath%20fill='none'%20stroke-linejoin='miter'%20d='M11%2014h23'/%3e%3c/g%3e%3c/svg%3e", Re = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill='%23fff'%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cpath%20d='M8%2012a2%202%200%201%201-4%200%202%202%200%201%201%204%200zm16.5-4.5a2%202%200%201%201-4%200%202%202%200%201%201%204%200zM41%2012a2%202%200%201%201-4%200%202%202%200%201%201%204%200zM16%208.5a2%202%200%201%201-4%200%202%202%200%201%201%204%200zM33%209a2%202%200%201%201-4%200%202%202%200%201%201%204%200z'/%3e%3cpath%20stroke-linecap='butt'%20d='M9%2026c8.5-1.5%2021-1.5%2027%200l2-12-7%2011V11l-5.5%2013.5-3-15-3%2015-5.5-14V25L7%2014l2%2012z'/%3e%3cpath%20stroke-linecap='butt'%20d='M9%2026c0%202%201.5%202%202.5%204%201%201.5%201%201%20.5%203.5-1.5%201-1.5%202.5-1.5%202.5-1.5%201.5.5%202.5.5%202.5%206.5%201%2016.5%201%2023%200%200%200%201.5-1%200-2.5%200%200%20.5-1.5-1-2.5-.5-2.5-.5-2%20.5-3.5%201-2%202.5-2%202.5-4-8.5-1.5-18.5-1.5-27%200z'/%3e%3cpath%20fill='none'%20d='M11.5%2030c3.5-1%2018.5-1%2022%200M12%2033.5c6-1%2015-1%2021%200'/%3e%3c/g%3e%3c/svg%3e", Ce = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill='none'%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cpath%20stroke-linejoin='miter'%20d='M22.5%2011.63V6M20%208h5'/%3e%3cpath%20fill='%23fff'%20stroke-linecap='butt'%20stroke-linejoin='miter'%20d='M22.5%2025s4.5-7.5%203-10.5c0%200-1-2.5-3-2.5s-3%202.5-3%202.5c-1.5%203%203%2010.5%203%2010.5'/%3e%3cpath%20fill='%23fff'%20d='M11.5%2037c5.5%203.5%2015.5%203.5%2021%200v-7s9-4.5%206-10.5c-4-6.5-13.5-3.5-16%204V27v-3.5c-3.5-7.5-13-10.5-16-4-3%206%205%2010%205%2010V37z'/%3e%3cpath%20d='M11.5%2030c5.5-3%2015.5-3%2021%200m-21%203.5c5.5-3%2015.5-3%2021%200m-21%203.5c5.5-3%2015.5-3%2021%200'/%3e%3c/g%3e%3c/svg%3e", xe = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cpath%20stroke='%23000'%20stroke-linecap='round'%20stroke-width='1.5'%20d='M22.5%209a4%204%200%200%200-3.22%206.38%206.48%206.48%200%200%200-.87%2010.65c-3%201.06-7.41%205.55-7.41%2013.47h23c0-7.92-4.41-12.41-7.41-13.47a6.46%206.46%200%200%200-.87-10.65A4.01%204.01%200%200%200%2022.5%209z'/%3e%3c/svg%3e", Se = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill='none'%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cg%20fill='%23000'%20stroke-linecap='butt'%3e%3cpath%20d='M9%2036c3.4-1%2010.1.4%2013.5-2%203.4%202.4%2010.1%201%2013.5%202%200%200%201.6.5%203%202-.7%201-1.6%201-3%20.5-3.4-1-10.1.5-13.5-1-3.4%201.5-10.1%200-13.5%201-1.4.5-2.3.5-3-.5%201.4-2%203-2%203-2z'/%3e%3cpath%20d='M15%2032c2.5%202.5%2012.5%202.5%2015%200%20.5-1.5%200-2%200-2%200-2.5-2.5-4-2.5-4%205.5-1.5%206-11.5-5-15.5-11%204-10.5%2014-5%2015.5%200%200-2.5%201.5-2.5%204%200%200-.5.5%200%202z'/%3e%3cpath%20d='M25%208a2.5%202.5%200%201%201-5%200%202.5%202.5%200%201%201%205%200z'/%3e%3c/g%3e%3cpath%20stroke='%23ececec'%20stroke-linejoin='miter'%20d='M17.5%2026h10M15%2030h15m-7.5-14.5v5M20%2018h5'/%3e%3c/g%3e%3c/svg%3e", Me = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill='none'%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cpath%20fill='%23000'%20d='M22%2010c10.5%201%2016.5%208%2016%2029H15c0-9%2010-6.5%208-21'/%3e%3cpath%20fill='%23000'%20d='M24%2018c.38%202.91-5.55%207.37-8%209-3%202-2.82%204.34-5%204-1.04-.94%201.41-3.04%200-3-1%200%20.19%201.23-1%202-1%200-4%201-4-4%200-2%206-12%206-12s1.89-1.9%202-3.5c-.73-1-.5-2-.5-3%201-1%203%202.5%203%202.5h2s.78-2%202.5-3c1%200%201%203%201%203'/%3e%3cpath%20fill='%23ececec'%20stroke='%23ececec'%20d='M9.5%2025.5a.5.5%200%201%201-1%200%20.5.5%200%201%201%201%200zm5.43-9.75a.5%201.5%2030%201%201-.86-.5.5%201.5%2030%201%201%20.86.5z'/%3e%3cpath%20fill='%23ececec'%20stroke='none'%20d='m24.55%2010.4-.45%201.45.5.15c3.15%201%205.65%202.49%207.9%206.75S35.75%2029.06%2035.25%2039l-.05.5h2.25l.05-.5c.5-10.06-.88-16.85-3.25-21.34-2.37-4.49-5.79-6.64-9.19-7.16l-.51-.1z'/%3e%3c/g%3e%3c/svg%3e", ke = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cpath%20stroke-linecap='butt'%20d='M9%2039h27v-3H9v3zm3.5-7%201.5-2.5h17l1.5%202.5h-20zm-.5%204v-4h21v4H12z'/%3e%3cpath%20stroke-linecap='butt'%20stroke-linejoin='miter'%20d='M14%2029.5v-13h17v13H14z'/%3e%3cpath%20stroke-linecap='butt'%20d='M14%2016.5%2011%2014h23l-3%202.5H14zM11%2014V9h4v2h5V9h5v2h5V9h4v5H11z'/%3e%3cpath%20fill='none'%20stroke='%23ececec'%20stroke-linejoin='miter'%20stroke-width='1'%20d='M12%2035.5h21m-20-4h19m-18-2h17m-17-13h17M11%2014h23'/%3e%3c/g%3e%3c/svg%3e", Ee = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cg%20stroke='none'%3e%3ccircle%20cx='6'%20cy='12'%20r='2.75'/%3e%3ccircle%20cx='14'%20cy='9'%20r='2.75'/%3e%3ccircle%20cx='22.5'%20cy='8'%20r='2.75'/%3e%3ccircle%20cx='31'%20cy='9'%20r='2.75'/%3e%3ccircle%20cx='39'%20cy='12'%20r='2.75'/%3e%3c/g%3e%3cpath%20stroke-linecap='butt'%20d='M9%2026c8.5-1.5%2021-1.5%2027%200l2.5-12.5L31%2025l-.3-14.1-5.2%2013.6-3-14.5-3%2014.5-5.2-13.6L14%2025%206.5%2013.5%209%2026z'/%3e%3cpath%20stroke-linecap='butt'%20d='M9%2026c0%202%201.5%202%202.5%204%201%201.5%201%201%20.5%203.5-1.5%201-1.5%202.5-1.5%202.5-1.5%201.5.5%202.5.5%202.5%206.5%201%2016.5%201%2023%200%200%200%201.5-1%200-2.5%200%200%20.5-1.5-1-2.5-.5-2.5-.5-2%20.5-3.5%201-2%202.5-2%202.5-4-8.5-1.5-18.5-1.5-27%200z'/%3e%3cpath%20fill='none'%20stroke-linecap='butt'%20d='M11%2038.5a35%2035%201%200%200%2023%200'/%3e%3cpath%20fill='none'%20stroke='%23ececec'%20d='M11%2029a35%2035%201%200%201%2023%200m-21.5%202.5h20m-21%203a35%2035%201%200%200%2022%200m-23%203a35%2035%201%200%200%2024%200'/%3e%3c/g%3e%3c/svg%3e", De = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2045%2045'%3e%3cg%20fill='none'%20fill-rule='evenodd'%20stroke='%23000'%20stroke-linecap='round'%20stroke-linejoin='round'%20stroke-width='1.5'%3e%3cpath%20stroke-linejoin='miter'%20d='M22.5%2011.6V6'/%3e%3cpath%20fill='%23000'%20stroke-linecap='butt'%20stroke-linejoin='miter'%20d='M22.5%2025s4.5-7.5%203-10.5c0%200-1-2.5-3-2.5s-3%202.5-3%202.5c-1.5%203%203%2010.5%203%2010.5'/%3e%3cpath%20fill='%23000'%20d='M11.5%2037a22.3%2022.3%200%200%200%2021%200v-7s9-4.5%206-10.5c-4-6.5-13.5-3.5-16%204V27v-3.5c-3.5-7.5-13-10.5-16-4-3%206%205%2010%205%2010V37z'/%3e%3cpath%20stroke-linejoin='miter'%20d='M20%208h5'/%3e%3cpath%20stroke='%23ececec'%20d='M32%2029.5s8.5-4%206-9.7C34.1%2014%2025%2018%2022.5%2024.6v2.1-2.1C20%2018%209.9%2014%207%2019.9c-2.5%205.6%204.8%209%204.8%209'/%3e%3cpath%20stroke='%23ececec'%20d='M11.5%2030c5.5-3%2015.5-3%2021%200m-21%203.5c5.5-3%2015.5-3%2021%200m-21%203.5c5.5-3%2015.5-3%2021%200'/%3e%3c/g%3e%3c/svg%3e";
+class Le {
+  imagesSrc = {
+    wP: pe,
+    wB: Pe,
+    wN: we,
+    wR: be,
+    wQ: Re,
+    wK: Ce,
+    bP: xe,
+    bB: Se,
+    bN: Me,
+    bR: ke,
+    bQ: Ee,
+    bK: De
+  };
+  cache = /* @__PURE__ */ new Map();
+  destroy() {
+    this.clearCache();
+    const e = this.getPieceImages?.image;
+    if (e)
+      for (const t in e) {
+        const r = e[t];
+        r instanceof HTMLImageElement && (r.src = "", r.onload = null, r.onerror = null), e[t] = null;
+      }
+    for (const t of Object.getOwnPropertyNames(this))
+      this[t] = null;
+  }
+  getPieceAt(e, t, r, n, i) {
+    const s = i;
+    if (!s) return;
+    const a = b.coordsToSquare(e, t, r, n);
+    if (!a) return;
+    const o = this.cache.get(a.notation);
+    if (o) return { piece: { ...o.piece }, id: o.id };
+    const c = Object.entries(s).find(([y, f]) => f.square?.notation === a.notation);
+    if (!c) return;
+    const [u, h] = c;
+    return this.cache.set(a.notation, {
+      piece: h,
+      id: u
+    }), { id: u, piece: h };
+  }
+  clearCache() {
+    return this.cache.clear();
+  }
+  updateCache(e, t, r) {
+    this.cache.delete(e), this.cache.set(t, r);
+  }
+  removeCache(e) {
+    this.cache.delete(e);
+  }
+  getPieceImages = {
+    string: {
+      wK: "♔",
+      wQ: "♕",
+      wR: "♖",
+      wB: "♗",
+      wN: "♘",
+      wP: "♙",
+      bK: "♔",
+      bQ: "♕",
+      bR: "♖",
+      bB: "♗",
+      bN: "♘",
+      bP: "♙"
+    },
+    image: (() => {
+      const e = (t) => {
+        const r = new URL(t, import.meta.url).href, n = new Image();
+        return n.src = r, n;
+      };
+      return {
+        wP: e(this.imagesSrc.wP),
+        wB: e(this.imagesSrc.wB),
+        wR: e(this.imagesSrc.wR),
+        wN: e(this.imagesSrc.wN),
+        wQ: e(this.imagesSrc.wQ),
+        wK: e(this.imagesSrc.wK),
+        bP: e(this.imagesSrc.bP),
+        bB: e(this.imagesSrc.bB),
+        bR: e(this.imagesSrc.bR),
+        bN: e(this.imagesSrc.bN),
+        bQ: e(this.imagesSrc.bQ),
+        bK: e(this.imagesSrc.bK)
+      };
+    })()
+  };
+  async preloadImages(e) {
+    const t = Object.values(e).map((r) => new Promise((n) => {
+      r instanceof HTMLImageElement ? r.complete && r.naturalWidth > 0 ? n() : (r.onload = () => n(), r.onerror = () => n()) : n();
+    }));
+    await Promise.all(t);
+  }
+}
+class Ae {
+  constructor(e) {
+    this.boardRuntime = e;
+  }
+  triggerUp = !0;
+  pointerSession = 0;
+  activeSession = null;
+  destroy() {
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+  }
+  detectMove(e) {
+    const { offsetX: t, offsetY: r } = b.getCanvasCoords(e), n = this.boardRuntime.getSelected(), i = this.boardRuntime.getSize() / 8, s = this.boardRuntime.getIsBlackView(), a = n && this.boardRuntime.getInternalRefVal(n.id);
+    this.boardRuntime.renderer.pipelineRender.setNextEvent("onPointerHover", [
+      null
+    ]);
+    const o = b.coordsToSquare(
+      t,
+      r,
+      i,
+      s
+    );
+    if (n && o?.notation === n.square?.notation)
+      return { from: null, to: null, piece: null };
+    if (!n || !o || !a)
+      return { from: null, to: null, piece: null };
+    const c = n.square ? this.boardRuntime.getBoard()[n.square.notation] : null;
+    return c ? { from: n.square, to: o, piece: c } : { from: null, to: null, piece: null };
+  }
+  handlePieceHover(e) {
+    const { offsetX: t, offsetY: r } = b.getCanvasCoords(e), n = this.boardRuntime.getSelected(), i = this.boardRuntime.getSize() / 8;
+    if (n && n?.isDragging || this.boardRuntime.getIsMoving() || e.pressure > 0)
+      return;
+    const s = this.boardRuntime.helpers.pieceHelper.getPieceAt(
+      t,
+      r,
+      i,
+      this.boardRuntime.getIsBlackView(),
+      this.boardRuntime.getInternalRefObj()
+    );
+    if (s && this.boardRuntime.getCanvasLayers().setCanvasStyle("staticPieces", {
+      cursor: "grab"
+    }), n && s?.id === n?.id) {
+      this.boardRuntime.getPieceHover() !== null && this.boardRuntime.renderer.pipelineRender.setNextEvent(
+        "onPointerHover",
+        [null]
+      );
+      return;
+    }
+    if (!s) {
+      this.boardRuntime.getPieceHover() && this.boardRuntime.renderer.pipelineRender.setNextEvent(
+        "onPointerHover",
+        [null]
+      ), this.boardRuntime.getCanvasLayers().setCanvasStyle("staticPieces", {
+        cursor: "default"
+      });
+      return;
+    }
+    this.boardRuntime.renderer.pipelineRender.setNextEvent("onPointerHover", [
+      s.id
+    ]);
+  }
+  handleGrab(e) {
+    const { offsetX: t, offsetY: r } = b.getCanvasCoords(e), n = this.boardRuntime.getSize() / 8, i = this.boardRuntime.getSelected(), s = this.activeSession;
+    if (s === null || s !== this.pointerSession || i === null || i.startX === null || i?.startY === null || e.pressure <= 0 || this.boardRuntime.getIsMoving())
+      return;
+    const a = t - i.startX, o = r - i.startY;
+    if (Math.sqrt(a * a + o * o) > 3 && i.id) {
+      const c = this.boardRuntime.getInternalRefVal(i.id), u = n / 2;
+      if (c && !i.isDragging) {
+        i.isDragging = !0, c.x = t - u, c.y = r - u, this.boardRuntime.renderer.getLayerManager().addDraw("onPointerDragStart"), this.boardRuntime.getPieceHover() && this.boardRuntime.renderer.pipelineRender.setNextEvent(
+          "onPointerHover",
+          [null]
+        ), this.boardRuntime.renderer.pipelineRender.setNextEvent(
+          "onToggleCanvas",
+          ["staticPieces", "dynamicPieces", i.id]
+        );
+        return;
+      }
+      const h = t - u, y = r - u;
+      c.x = Math.max(
+        0,
+        Math.min(h, this.boardRuntime.getSize() - n)
+      ), c.y = Math.max(
+        0,
+        Math.min(y, this.boardRuntime.getSize() - n)
+      ), this.boardRuntime.renderer.getLayerManager().addDraw("onPointerDrag"), this.boardRuntime.renderer.pipelineRender.setNextEvent("onRender", [
+        {
+          board: !1,
+          staticPieces: !0,
+          overlay: !0,
+          underlay: !0,
+          dynamicPieces: !0
+        }
+      ]);
+    }
+  }
+  handlePointerUp(e) {
+    if (++this.pointerSession, this.activeSession = null, this.boardRuntime.getIsMoving()) return;
+    const { offsetX: t, offsetY: r } = b.getCanvasCoords(e), n = this.boardRuntime.getSize(), i = this.boardRuntime.getSelected();
+    if (t < 0 || r < 0 || t >= n || r >= n) {
+      this.handlePointerLeave(e);
+      return;
+    }
+    this.boardRuntime.getCanvasLayers().setCanvasStyle("staticPieces", {
+      cursor: "default"
+    }), this.boardRuntime.renderer.pipelineRender.setNextEvent("onPointerHover", [
+      null,
+      !0
+    ]);
+    const s = i?.isDragging;
+    if (this.triggerUp) {
+      const { from: a, to: o, piece: c } = this.boardRuntime.helpers.pointerEventsHelper.detectMove(e);
+      if (a !== null && a.notation !== o.notation) {
+        this.boardRuntime.helpers.setNextMove({
+          from: a.notation,
+          to: o.notation,
+          piece: c,
+          click: !1,
+          offset: { x: t, y: r }
+        });
+        return;
+      }
+    } else this.triggerUp = !0;
+    s && this.endDrag(t, r, !1, !0), i?.secondClick || s ? this.boardRuntime.helpers.toggleSelected(!1) : this.boardRuntime.helpers.toggleSelected(!0), this.boardRuntime.renderer.pipelineRender.setNextEvent("onRender", [
+      {
+        board: !1,
+        staticPieces: !0,
+        overlay: !0,
+        underlay: !0,
+        dynamicPieces: !0
+      }
+    ]);
+  }
+  handlePointerLeave(e) {
+    const t = this.boardRuntime.getSelected(), r = !(t && t.secondClick);
+    this.endDrag(-1, -1, !1, !0), this.boardRuntime.helpers.toggleSelected(r), this.boardRuntime.getCanvasLayers().setCanvasStyle("staticPieces", {
+      cursor: "default"
+    }), this.boardRuntime.renderer.pipelineRender.setNextEvent("onPointerHover", [
+      null,
+      !0
+    ]), this.boardRuntime.renderer.pipelineRender.setNextEvent("onRender", [
+      {
+        board: !1,
+        staticPieces: !0,
+        overlay: !0,
+        underlay: !0,
+        dynamicPieces: !0
+      }
+    ]);
+  }
+  startPress(e) {
+    const { offsetX: t, offsetY: r } = b.getCanvasCoords(e), n = this.boardRuntime.getSize() / 8, i = this.boardRuntime.getSelected();
+    if (t === null || r === null) return;
+    this.activeSession = this.pointerSession;
+    const s = b.coordsToSquare(
+      t,
+      r,
+      n,
+      this.boardRuntime.getIsBlackView()
+    );
+    if (!s || i?.isDragging) return;
+    const a = this.boardRuntime.helpers.pieceHelper.getPieceAt(
+      t,
+      r,
+      n,
+      this.boardRuntime.getIsBlackView(),
+      this.boardRuntime.getInternalRefObj()
+    );
+    a ? i ? s.notation !== i.square?.notation ? (this.triggerUp = !1, this.moveOnClick(e, i, { x: t, y: r })) : (i.startX = t, i.startY = r, i.secondClick = !0) : this.boardRuntime.renderer.pipelineRender.setNextEvent(
+      "onPointerSelect",
+      [
+        {
+          id: a.id,
+          x: a.piece.x,
+          y: a.piece.y,
+          square: a.piece.square,
+          isDragging: !1,
+          isPending: !1,
+          startX: t,
+          startY: r,
+          secondClick: !1
+        }
+      ]
+    ) : i && (this.triggerUp = !1, this.moveOnClick(e, i, { x: t, y: r }));
+  }
+  moveOnClick(e, t, r) {
+    if (t) {
+      const { from: n, to: i, piece: s } = this.boardRuntime.helpers.pointerEventsHelper.detectMove(e);
+      n !== null && this.boardRuntime.helpers.setNextMove({
+        from: n.notation,
+        to: i.notation,
+        piece: s,
+        click: !0,
+        offset: r
+      });
+    }
+  }
+  toggleLayer(e, t) {
+    const r = this.boardRuntime.getSelected(), n = r && this.boardRuntime.getInternalRefVal(r.id);
+    r && r.isDragging && n && (n.x = r.x, n.y = r.y, n.square = structuredClone(r.square), this.boardRuntime.renderer.pipelineRender.setNextEvent("onToggleCanvas", [
+      e,
+      t,
+      r.id,
+      !0
+    ]));
+  }
+  endDrag(e, t, r, n) {
+    const i = this.boardRuntime.getSelected(), s = this.boardRuntime.getSize() / 8, a = this.boardRuntime.getIsBlackView(), o = i && this.boardRuntime.getInternalRefVal(i.id), c = b.coordsToSquare(e, t, s, a), u = b.squareToCoords(c, s, a);
+    if (!(!i || !i.isDragging || !o)) {
+      if (!r)
+        o.square = structuredClone(i.square), o.x = i.x, o.y = i.y;
+      else if (c && u) {
+        const { x: h, y } = u;
+        o.square = structuredClone(c), o.x = h, o.y = y;
+      }
+      n && this.toggleLayer("dynamicPieces", "staticPieces"), i.isDragging = !1;
+    }
+  }
+}
+class Te {
+  constructor(e) {
+    this.boardRuntime = e, this.pointerEventsHelper = new Ae(this.boardRuntime);
+  }
+  pointerEventsHelper;
+  pieceHelper = new Le();
+  pipelineMove = [];
+  moveToken = 0;
+  isMoving = !1;
+  destroy() {
+    this.pieceHelper.destroy(), this.pointerEventsHelper.destroy();
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+  }
+  createLazyEventContext(e, t, r) {
+    const n = /* @__PURE__ */ new Map(), i = { ...e }, s = r?.cache ?? !0;
+    for (const a of Object.keys(t))
+      i[a] = (...o) => {
+        if (s && n.has(a))
+          return n.get(a);
+        const c = t[a](...o);
+        return s && n.set(a, c), c;
+      };
+    return i.toPlain = () => {
+      const a = { ...e };
+      for (const o of Object.keys(t))
+        a[o] = t[o]();
+      return a;
+    }, i.clearCache = () => n.clear(), i.destroy = () => {
+      n.clear();
+      for (const a of Object.keys(i))
+        delete i[a];
+    }, i;
+  }
+  triggerEvent(e, t, r, n) {
+    let i = null;
+    try {
+      const s = e?.[t];
+      if (!s) return;
+      r.__event = t, n !== void 0 ? i = s(
+        r,
+        n
+      ) : i = s(r);
+    } finally {
+      "destroy" in r && typeof r.destroy == "function" && r.destroy();
+    }
+    return i;
+  }
+  async movePromiseCancel() {
+    return new Promise((e) => {
+      setTimeout(() => {
+        e();
+      }, 8e3);
+    });
+  }
+  async move(e, t, r, n, i) {
+    if (e === t) return !1;
+    const s = this.boardRuntime.getSelected(), a = s?.id, o = this.boardRuntime.getMove();
+    if (o) {
+      const c = await this.pendingDrag(i.x, i.y), u = await Promise.race([
+        o({ from: e, to: t, piece: r }),
+        this.movePromiseCancel().then(() => (this.boardRuntime.getEventEmitter().emit("onMoveAbort", []), { status: !1, result: [] }))
+      ]);
+      if (s) {
+        if (!n && c && u.status) {
+          const h = this.boardRuntime.getInternalRefVal(s.id);
+          h.square = c;
+        }
+        s.isPending && (this.boardRuntime.renderer.pipelineRender.setNextEvent(
+          "onToggleCanvas",
+          ["dynamicPieces", "staticPieces", a, !0]
+        ), s.isPending = !1, await b.asyncHandler(
+          (h) => this.boardRuntime.renderer.pipelineRender.setNextEvent(
+            "onRender",
+            [
+              {
+                board: !1,
+                staticPieces: !0,
+                overlay: !0,
+                underlay: !0,
+                dynamicPieces: !0
+              }
+            ],
+            h
+          )
+        ));
+      }
+      return u.status ? (await this.boardRuntime.updateBoardState(u.result, n), !0) : !1;
+    } else
+      return this.pointerEventsHelper.endDrag(i.x, i.y, !0, !1), this.boardRuntime.renderer.pipelineRender.setNextEvent("onToggleCanvas", [
+        "dynamicPieces",
+        "staticPieces",
+        a,
+        !0
+      ]), await this.boardRuntime.updateBoardState(
+        [{ from: e, to: t, captured: [t] }],
+        n
+      ), !0;
+  }
+  toggleSelected(e) {
+    const t = this.boardRuntime.getSelected();
+    t && (e ? this.boardRuntime.renderer.pipelineRender.setNextEvent(
+      "onPointerSelect",
+      [
+        {
+          ...t,
+          isDragging: !1,
+          startX: null,
+          startY: null,
+          secondClick: !1
+        },
+        !0
+      ]
+    ) : this.boardRuntime.renderer.pipelineRender.setNextEvent(
+      "onPointerSelect",
+      [null, !0]
+    ));
+  }
+  setNextMove(e) {
+    const t = ++this.moveToken;
+    this.pipelineMove.push({ ...e, token: t }), this.isMoving || this.handleMove();
+  }
+  async pendingDrag(e, t) {
+    const r = this.boardRuntime.getSelected();
+    this.boardRuntime.renderer.getLayerManager().removeEvent("onPointerSelect");
+    const n = (h) => this.boardRuntime.renderer.pipelineRender.setNextEvent(
+      "onRender",
+      [
+        {
+          board: !1,
+          staticPieces: !0,
+          overlay: !0,
+          underlay: !0,
+          dynamicPieces: !0
+        }
+      ],
+      h
+    );
+    if (!r || !r.isDragging) {
+      await b.asyncHandler(n);
+      return;
+    }
+    const i = this.boardRuntime.getSize() / 8, s = this.boardRuntime.getIsBlackView(), a = b.coordsToSquare(e, t, i, s), o = this.boardRuntime.renderer.getLayerManager().getLayer("dynamicPieces");
+    if (!a) return;
+    const c = b.squareToCoords(a, i, s);
+    r.isPending = !0;
+    const u = o.getPiece(r.id);
+    return u && (u.x = c ? c.x : e, u.y = c ? c.y : t), r.x = c ? c.x : e, r.y = c ? c.y : t, r.square = a, r.startX = null, r.startY = null, r.isDragging = !1, o.addToRender(r.id), await b.asyncHandler(n), o.removeToRender(r.id), a;
+  }
+  async handleMove() {
+    if (!this.isMoving) {
+      this.isMoving = !0, this.boardRuntime.setIsMoving(!0);
+      try {
+        for (; this.pipelineMove.length; ) {
+          const e = this.boardRuntime.getSelected(), t = this.pipelineMove.shift();
+          if (!t) continue;
+          const { from: r, to: n, piece: i, click: s, offset: a, token: o } = t;
+          if (o !== this.moveToken) continue;
+          let c = !1;
+          const u = e?.x, h = e?.y, y = e && e.square !== null ? { ...e.square } : null;
+          this.boardRuntime.getCanvasLayers().setCanvasStyle("staticPieces", {
+            cursor: "progress"
+          }), c = await this.move(r, n, i, s, a), this.boardRuntime.getCanvasLayers().setCanvasStyle("staticPieces", {
+            cursor: "default"
+          }), c && this.boardRuntime.clearRedo();
+          const f = this.boardRuntime.getBoard()[n], g = f ? this.boardRuntime.getInternalRefVal(f.id) : null, P = f ? b.squareToCoords(
+            f.square,
+            this.boardRuntime.getSize() / 8,
+            this.boardRuntime.getIsBlackView()
+          ) : null;
+          if (s && (c || (f && g ? P && this.boardRuntime.renderer.pipelineRender.setNextEvent(
+            "onPointerSelect",
+            [
+              {
+                id: f.id,
+                x: P.x,
+                y: P.y,
+                square: g.square,
+                isDragging: !1,
+                startX: a.x,
+                startY: a.y,
+                secondClick: !1
+              },
+              !0
+            ]
+          ) : this.boardRuntime.renderer.pipelineRender.setNextEvent(
+            "onPointerSelect",
+            [null, !0]
+          ))), !c) {
+            if (!s) {
+              if (e && u !== void 0 && h !== void 0) {
+                const v = this.boardRuntime.getInternalRefVal(e.id);
+                v.x = u, v.y = h, v.square = structuredClone(y);
+              }
+              this.boardRuntime.renderer.pipelineRender.setNextEvent(
+                "onPointerSelect",
+                [null, !0]
+              );
+            }
+            this.boardRuntime.renderer.pipelineRender.setNextEvent("onRender", [
+              {
+                board: !1,
+                staticPieces: !0,
+                overlay: !0,
+                underlay: !0,
+                dynamicPieces: !0
+              }
+            ]);
+          }
+        }
+      } finally {
+        this.isMoving = !1, this.boardRuntime.setIsMoving(!1), this.pipelineMove.length && queueMicrotask(() => this.handleMove());
+      }
+    }
+  }
+}
+class N {
+  capacity = 4;
+  boundary;
+  objects = [];
+  child = {
+    NE: null,
+    NW: null,
+    SE: null,
+    SW: null
+  };
+  destroyed = !1;
+  constructor(e) {
+    this.boundary = e;
+  }
+  destroy() {
+    this.destroyed || (this.destroyed = !0, this.objects = [], this.child.NE?.destroy(), this.child.NW?.destroy(), this.child.SE?.destroy(), this.child.SW?.destroy(), this.child = { NE: null, NW: null, SE: null, SW: null }, this.boundary = { x: 0, y: 0, w: 0, h: 0 });
+  }
+  insert(e) {
+    if (this.destroyed || !this.intersect(e.box, this.boundary)) return !1;
+    if (this.boundary.w <= 1 || this.boundary.h <= 1)
+      return this.objects.push(e), !0;
+    if (this.objects.length < this.capacity && this.child.NE === null)
+      return this.objects.push(e), !0;
+    this.child.NE === null && this.subdivide();
+    const t = [];
+    for (const r of this.objects) this.insertChild(r) || t.push(r);
+    return this.objects = t, this.insertChild(e) || this.objects.push(e), !0;
+  }
+  intersect(e, t) {
+    if (!this.destroyed)
+      return e.x < t.x + t.w && e.x + e.w > t.x && e.y < t.y + t.h && e.y + e.h > t.y;
+  }
+  contains(e, t) {
+    if (!this.destroyed)
+      return e.x >= t.x && e.x + e.w <= t.x + t.w && e.y >= t.y && e.y + e.h <= t.y + t.h;
+  }
+  insertChild(e) {
+    if (this.destroyed) return !1;
+    let t = null;
+    for (const r of Object.values(this.child))
+      if (!(!r || !r.contains(e.box, r.boundary)))
+        if (!t) t = r;
+        else return !1;
+    return t === null ? !1 : t.insert(e);
+  }
+  subdivide() {
+    if (this.destroyed) return;
+    const e = this.boundary.w / 2, t = this.boundary.h / 2;
+    this.child.NW = new N({
+      x: this.boundary.x,
+      y: this.boundary.y,
+      w: e,
+      h: t
+    }), this.child.NE = new N({
+      x: this.boundary.x + e,
+      y: this.boundary.y,
+      w: e,
+      h: t
+    }), this.child.SW = new N({
+      x: this.boundary.x,
+      y: this.boundary.y + t,
+      w: e,
+      h: t
+    }), this.child.SE = new N({
+      x: this.boundary.x + e,
+      y: this.boundary.y + t,
+      w: e,
+      h: t
+    });
+  }
+  search(e, t = []) {
+    if (this.destroyed || !this.intersect(e, this.boundary)) return t;
+    for (const r of this.objects)
+      this.intersect(r.box, e) && t.push(r);
+    if (!this.child.NE) return t;
+    for (const r of Object.values(this.child))
+      r && this.intersect(e, r.boundary) && r.search(e, t);
+    return t;
+  }
+  searchById(e) {
+    if (this.destroyed) return null;
+    for (const t of this.objects)
+      if (t.id === e) return t;
+    if (!this.child.NE) return null;
+    for (const t of Object.values(this.child)) {
+      if (!t) continue;
+      const r = t.searchById(e);
+      if (r) return r;
+    }
+    return null;
+  }
+  remove(e, t) {
+    if (this.destroyed) return !1;
+    let r = -1;
+    if (t) {
+      const { P1: n, P2: i, P3: s, P4: a } = b.getHashingNumbers(), o = n * t.x ^ i * t.y ^ s * t.w ^ a * t.h;
+      r = this.objects.findIndex((c) => c.id === e && c.hash === o);
+    }
+    if (r === -1 && (r = this.objects.findIndex((n) => n.id === e)), r !== -1)
+      return this.objects.splice(r, 1), !0;
+    if (this.child.NE === null) return !1;
+    for (const n of Object.values(this.child))
+      if (n && (t ? n.remove(e, t) : n.remove(e)))
+        return this.tryMerge(), !0;
+    return !1;
+  }
+  update(e, t) {
+    const r = this.searchById(e);
+    return r ? (this.remove(e), r.box = t, this.insert(r), !0) : !1;
+  }
+  tryMerge() {
+    this.destroyed || !this.child.NE || !Object.values(this.child).every(
+      (t) => t && t.objects.length === 0 && !t.child.NE
+    ) || (this.child = { NE: null, NW: null, SE: null, SW: null });
+  }
+}
+class Be {
+  constructor(e, t) {
+    this.id = e, this.box = t;
+    const { P1: r, P2: n, P3: i, P4: s } = b.getHashingNumbers();
+    this.hash = r * t.x ^ n * t.y ^ i * t.w ^ s * t.h;
+  }
+  hash;
+}
+class $ {
+  name;
+  boardRuntime;
+  pieces = /* @__PURE__ */ new Map();
+  coordsMap = /* @__PURE__ */ new Map();
+  clearMap = /* @__PURE__ */ new Map();
+  renderMap = /* @__PURE__ */ new Set();
+  clearQueue = [];
+  clearQueueHash = /* @__PURE__ */ new Set();
+  eventsMap = {};
+  pendingResolvers = /* @__PURE__ */ new Map();
+  animationGen = 0;
+  animationRef = null;
+  animation = [];
+  ctx = null;
+  delayedPieceClear = /* @__PURE__ */ new Map();
+  destroyed = !1;
+  spatialIndex;
+  constructor(e, t) {
+    this.name = e, this.boardRuntime = t, this.ctx = t.getCanvasLayers().getContext(e);
+    const r = this.boardRuntime.getSize();
+    this.spatialIndex = new N({ x: 0, y: 0, w: r, h: r });
+  }
+  destroy() {
+    this.clearAnimation();
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+    this.destroyed = !0;
+  }
+  update(e) {
+    throw new Error("Method not implemented.");
+  }
+  clearPieces(e) {
+    throw new Error("Method not implemented.");
+  }
+  clear() {
+    const t = this.boardRuntime.getCanvasLayers().getDpr();
+    for (const r of this.clearQueue)
+      this.ctx?.save(), this.ctx?.setTransform(1, 0, 0, 1, 0, 0), this.ctx?.clearRect(r.x * t, r.y * t, r.w * t, r.h * t), this.ctx?.restore();
+    this.resetClearQueue();
+  }
+  async draw() {
+    throw new Error("Method not implemented.");
+  }
+  addPiece(e, t) {
+    this.pieces.set(e, t);
+  }
+  removePiece(e) {
+    this.pieces.delete(e);
+  }
+  addAll(e, t, r, n) {
+    if (!(this.pieces.has(e) || !this.boardRuntime.isActivePiece(e))) {
+      if (t.square?.notation && this.boardRuntime.getBoard()[t.square.notation]) {
+        const i = this.boardRuntime.getBoard()[t.square.notation];
+        i.id, this.removeAll?.(i.id);
+      }
+      this.addCoords(e, r), this.addPiece?.(e, t), this.addClearCoords(e, n), this.addToRender(e);
+    }
+  }
+  removeAll(e) {
+    if (!this.pieces.has(e)) return;
+    const t = this.getClearCoords(e);
+    t && this.addClearQueue(t), this.removePiece?.(e), this.removeToRender(e), this.removeCoords(e), this.removeClearCoords(e);
+  }
+  handleEvent(e, t) {
+    this.eventsMap[e] || (this.eventsMap[e] = []), this.eventsMap[e].push(t);
+  }
+  addCoords(e, t) {
+    this.spatialIndex.update(e, t) || this.spatialIndex.insert(new Be(e, t)), this.coordsMap.set(e, { ...t, id: e });
+  }
+  removeCoords(e) {
+    const t = this.getCoords(e);
+    t && (this.spatialIndex.remove(e, t), this.coordsMap.delete(e));
+  }
+  addClearCoords(e, t) {
+    this.clearMap.set(e, { ...t, id: e });
+  }
+  removeClearCoords(e) {
+    this.clearMap.delete(e);
+  }
+  addToRender(e) {
+    this.renderMap.add(e);
+  }
+  removeToRender(e) {
+    this.renderMap.delete(e);
+  }
+  addClearQueue(e) {
+    const { P1: t, P2: r, P3: n, P4: i } = b.getHashingNumbers(), s = t * e.x ^ r * e.y ^ n * e.w ^ i * e.h;
+    this.clearQueueHash.has(s) || (this.clearQueueHash.add(s), this.clearQueue.push(e));
+  }
+  resetClearQueue() {
+    this.clearQueue = [], this.clearQueueHash.clear();
+  }
+  addEvent(e, t) {
+    this.eventsMap[e] || (this.eventsMap[e] = []), t = Array.isArray(t) ? t : [t], this.eventsMap[e].push(...t);
+  }
+  removeEvent(e) {
+    const t = this.eventsMap[e];
+    if (!t) return;
+    const r = [];
+    for (const i of t)
+      this.addClearQueue(i), r.push(i);
+    delete this.eventsMap[e];
+    const n = this.boardRuntime.renderer.getLayerManager();
+    for (const [i, s] of Object.entries(this.eventsMap))
+      for (const a of s)
+        for (const o of r)
+          if (this.intersects(a, o)) {
+            n.addDraw(i), n.removeEvent(i);
+            break;
+          }
+  }
+  intersects(e, t) {
+    return !(e.x + e.w <= t.x || t.x + t.w <= e.x || e.y + e.h <= t.y || t.y + t.h <= e.y);
+  }
+  pieceIntersects(e, t) {
+    const r = Math.max(e.x, t.x), n = Math.min(e.x + e.w, t.x + t.w), i = Math.max(e.y, t.y), s = Math.min(e.y + e.h, t.y + t.h), a = n - r, o = s - i;
+    return a <= 0 || o <= 0 ? !1 : a >= 2 && o >= 2;
+  }
+  getCtx() {
+    return this.ctx;
+  }
+  hasPiece(e) {
+    return this.pieces.has(e);
+  }
+  getPiece(e) {
+    return this.pieces.get(e);
+  }
+  getCoords(e) {
+    return this.coordsMap.get(e);
+  }
+  getClearCoords(e) {
+    return this.clearMap.get(e);
+  }
+  getToRender() {
+    return Array.from(this.renderMap.keys());
+  }
+  hasToRender(e) {
+    return this.renderMap.has(e);
+  }
+  clearRenderMap() {
+    this.renderMap.clear();
+  }
+  resetLayer() {
+    const e = this.boardRuntime.getSize();
+    this.pieces.clear(), this.coordsMap.clear(), this.renderMap.clear(), this.clearMap.clear(), this.spatialIndex.destroy(), this.spatialIndex = new N({
+      x: 0,
+      y: 0,
+      w: e,
+      h: e
+    }), this.clearQueue.length = 0, this.eventsMap = {};
+  }
+  redrawPieces() {
+    for (const e of this.pieces.keys()) this.addToRender(e);
+  }
+  updateClear() {
+  }
+  postRender() {
+  }
+  setAnimationRef(e) {
+    this.animationRef = e;
+  }
+  clearAnimation() {
+    if (this.animationRef && (cancelAnimationFrame(this.animationRef), this.setAnimationRef(null)), this.incrementAnimationGen(), this.pendingResolvers.size > 0) {
+      for (const [, e] of this.pendingResolvers)
+        try {
+          e();
+        } catch {
+        }
+      this.pendingResolvers.clear();
+    }
+  }
+  setPendingResolvers(e, t) {
+    this.pendingResolvers.set(e, t);
+  }
+  getPendingResolvers() {
+    return this.pendingResolvers;
+  }
+  getAnimationGen() {
+    return this.animationGen;
+  }
+  setResolverGen(e) {
+    this.animationGen = e;
+  }
+  incrementAnimationGen() {
+    this.animationGen++;
+  }
+  getAnimation() {
+    return this.animation;
+  }
+  getAnimationRef() {
+    return this.animationRef;
+  }
+  addAnimation(e) {
+    this.animation.push(e);
+  }
+  updateAnimation() {
+    this.animation = this.animation.filter((e) => e.piece.anim), this.animation.length <= 0 && this.boardRuntime.setIsMoving(!1);
+  }
+  getEvents(e) {
+    return e ? this.eventsMap[e] : this.eventsMap;
+  }
+  drawEvent(e, t) {
+    this.ctx && (e(this.ctx), this.boardRuntime.renderer.getLayerManager().applyDrawResult(this.ctx, this.name, t));
+  }
+  async render(e) {
+    this.updateClear(), this.update?.(e), this.clear(), this.draw(), this.postRender();
+  }
+  async renderAsync() {
+    await this.render(0);
+  }
+}
+class Oe extends $ {
+  constructor(e) {
+    super("board", e);
+  }
+  update(e) {
+  }
+  async draw() {
+    const e = this.ctx;
+    if (!e) return;
+    const t = this.boardRuntime.getSize(), r = this.boardRuntime.getIsBlackView(), n = this.boardRuntime.getLightTile(), i = this.boardRuntime.getDarkTile();
+    e.clearRect(0, 0, t, t);
+    const s = t / 8, a = r ? i : n, o = r ? n : i;
+    for (let c = 0; c < 8; ++c)
+      for (let u = 0; u < 8; ++u) {
+        const h = (c + u) % 2 === 0, y = r ? 7 - c : c, f = r ? 7 - u : u;
+        e.fillStyle = h ? a : o, e.fillRect(
+          f * s,
+          y * s,
+          s,
+          s
+        );
+      }
+  }
+}
+class Ie extends $ {
+  constructor(e) {
+    super("underlay", e);
+  }
+  update(e) {
+  }
+  async draw() {
+  }
+}
+class He extends $ {
+  constructor(e) {
+    super("staticPieces", e);
+  }
+  updateClear() {
+    const e = /* @__PURE__ */ new Set();
+    for (const t of this.clearQueue) {
+      const r = this.spatialIndex.search(t);
+      for (const n of r) {
+        const i = n.id, { P1: s, P2: a, P3: o, P4: c } = b.getHashingNumbers(), u = s * n.box.x ^ a * n.box.y ^ o * n.box.w ^ c * n.box.h;
+        e.has(i) || this.renderMap.has(i) || t.id === i || this.clearQueueHash.has(u) || (this.addClearQueue({ ...n.box, id: i }), this.renderMap.add(i), e.add(i), this.ctx && (this.ctx.strokeStyle = "rgba(251, 0, 0, 1)", this.ctx.lineWidth = 8), this.ctx?.strokeRect(t.x, t.y, t.w, t.h), console.log(t.id, " --- ", n.id, n.box, t));
+      }
+    }
+  }
+  update(e) {
+  }
+  async draw() {
+    const e = this.getToRender(), t = this.boardRuntime.getPieceStyle(), r = this.boardRuntime.getPieceHover(), n = Math.ceil(this.boardRuntime.getSize() / 8), i = this.ctx;
+    if (!(!t || !e || !e.length) && !(typeof t.bB != "string" && !(t.bB instanceof HTMLImageElement)) && i) {
+      for (const s of e) {
+        const a = this.getPiece(s);
+        if (a) {
+          if (i.save(), t && s !== r) {
+            let o = t[a.type];
+            o instanceof HTMLImageElement ? this.DrawHTMLPiece(o, i, a, n) : typeof o == "string" && this.DrawTextPiece(o, i, a, n);
+          }
+          i.restore(), this.boardRuntime.renderer.getLayerManager().applyDrawResult(i, "staticPieces", void 0, s);
+        }
+      }
+      this.clearRenderMap();
+    }
+  }
+  clearPieces(e) {
+    const t = Math.ceil(this.boardRuntime.getSize() / 8), r = /* @__PURE__ */ new Set();
+    for (const n of e)
+      this.hasPiece(n.id) && r.add(n.id);
+    for (const [n, i] of this.pieces)
+      if (!r.has(n) && !this.boardRuntime.renderer.getLayerManager().isDelayedPieceClear(n)) {
+        const s = {
+          x: i.x,
+          y: i.y,
+          w: t,
+          h: t
+        };
+        this.addClearQueue({ ...s, id: n }), this.removeAll?.(n);
+      }
+  }
+  DrawHTMLPiece(e, t, r, n) {
+    const i = b.squareToCoords(
+      r.square,
+      n,
+      this.boardRuntime.getIsBlackView()
+    );
+    i && e && e.complete && e.naturalWidth > 0 && t.drawImage(e, i.x, i.y, n, n);
+  }
+  DrawTextPiece(e, t, r, n) {
+    const i = b.squareToCoords(
+      r.square,
+      n,
+      this.boardRuntime.getIsBlackView()
+    );
+    if (!i) return;
+    const s = e.length > 1 ? e[0] : e;
+    t.fillStyle = r.type[0] === "w" ? "#ffffffff" : "#000000ff", t.font = `${n * 0.7}px monospace`;
+    let a = n * 0.7;
+    t.font = `${a}px monospace`;
+    const o = t.measureText(s).width;
+    o > n * 0.9 && (a *= n * 0.9 / o, t.font = `${a}px monospace`), t.textAlign = "center", t.textBaseline = "middle", t.fillText(s, i.x + n / 2, i.y + n / 2);
+  }
+  DrawPathPiece(e, t, r, n) {
+    t.save(), t.translate(r.x + n / 2, r.y + n / 2);
+    const i = n / 100;
+    t.scale(i, i), t.fillStyle = r.type.startsWith("w") ? "#fff" : "#000", t.fill(e), t.restore();
+  }
+}
+class Ne extends $ {
+  scale = 1.1;
+  toggleCanvas = [];
+  constructor(e) {
+    super("dynamicPieces", e);
+  }
+  updateClear() {
+    const e = ["onPointerDrag"];
+    for (const t of e) this.removeEvent(t);
+  }
+  defaultPieceAnimation(e) {
+    const t = this.getAnimation();
+    for (let r = 0; r < t.length; r++) {
+      const n = t[r], i = Math.hypot(
+        n.to.x - n.from.x,
+        n.to.y - n.from.y
+      ), s = Math.min(
+        400,
+        Math.max(
+          150,
+          this.boardRuntime.getAnimationDuration() + i * 0.08
+        )
+      ), a = (y) => 1 - Math.pow(1 - y, 3), o = Math.max(
+        0,
+        Math.min((e - n.start) / s, 1)
+      ), c = n.piece, u = a(o), h = this.getClearCoords(n.id);
+      h && this.addClearQueue(h), c.x = n.from.x + (n.to.x - n.from.x) * u, c.y = n.from.y + (n.to.y - n.from.y) * u, u < 1 ? (this.addPiece?.(n.id, c), this.addToRender(n.id)) : (c.anim = !1, this.toggleCanvas.push(n.id));
+    }
+  }
+  update(e) {
+    this.boardRuntime.getDefaultAnimation() && this.defaultPieceAnimation(e);
+  }
+  async draw() {
+    const e = this.boardRuntime.getPieceStyle(), t = this.getToRender(), r = this.boardRuntime.getPieceHover(), n = Math.ceil(this.boardRuntime.getSize() / 8), i = this.boardRuntime.getSelected(), s = this.ctx, a = this.boardRuntime.renderer.getLayerManager();
+    if (!(!e || !t || !t.length) && !(typeof e.bB != "string" && !(e.bB instanceof HTMLImageElement)) && s) {
+      for (const o of t) {
+        const c = this.getPiece(o);
+        if (!c || o === r && !c.anim) continue;
+        s.save();
+        const u = e && e[c.type];
+        i?.isPending && i.id === o && (s.globalAlpha = 0.5), u instanceof HTMLImageElement ? this.DrawHTMLPiece(
+          u,
+          s,
+          c,
+          n,
+          !!(i?.isPending && i.id === o)
+        ) : typeof u == "string" && this.DrawTextPiece(
+          u,
+          s,
+          c,
+          n,
+          !!(i?.isPending && i.id === o)
+        ), s.restore(), i?.isDragging && i.id === o ? a.applyDrawResult(s, "dynamicPieces", "onPointerDrag", o) : a.applyDrawResult(s, "dynamicPieces", void 0, o);
+      }
+      for (const o of this.toggleCanvas)
+        a.clearDelayedPiece(o, "staticPieces"), await this.boardRuntime.renderer.getLayerManager().togglePieceLayer("dynamicPieces", "staticPieces", o, !0);
+      this.toggleCanvas.length > 0 && await this.boardRuntime.renderer.render({
+        board: !1,
+        staticPieces: !0,
+        overlay: !0,
+        underlay: !0,
+        dynamicPieces: !0
+      }), this.toggleCanvas.length = 0;
+    }
+  }
+  postRender() {
+    this.animation.length > 0 && this.updateAnimation();
+  }
+  DrawHTMLPiece(e, t, r, n, i) {
+    const s = i ? r.x : r.x - n * (this.scale - 1) / 2, a = i ? r.y : r.y - n * (this.scale - 1) / 2, o = i ? n : n * this.scale;
+    e && e.complete && e.naturalWidth > 0 && t.drawImage(e, s, a, o, o);
+  }
+  DrawTextPiece(e, t, r, n, i) {
+    const s = e.length > 1 ? e[0] : e;
+    t.save(), t.fillStyle = r.type[0] === "w" ? "#ffffffff" : "#000", t.font = i ? `${n * 0.7}px monospace` : `${n * 0.8 * this.scale}px monospace`;
+    let a = i ? n * 0.7 : n * 0.8;
+    t.font = `${a}px monospace`;
+    const o = t.measureText(s).width;
+    o > n * 0.9 && (a *= n * 0.9 / o, t.font = `${a}px monospace`), t.textAlign = "center", t.textBaseline = "middle", t.fillText(s, r.x + n / 2, r.y + n / 2), t.restore();
+  }
+  async renderAsync() {
+    if (this.getAnimation().length === 0) {
+      this.clearAnimation(), await this.render(0);
+      return;
+    }
+    this.incrementAnimationGen();
+    const t = this.getAnimationGen();
+    return new Promise((r) => {
+      const n = () => {
+        this.getPendingResolvers().delete(t);
+        try {
+          r();
+        } catch {
+        }
+      };
+      this.setPendingResolvers(t, n);
+      const i = (a) => {
+        if (t !== this.getAnimationGen()) return;
+        if (this.getAnimation().length === 0) {
+          n(), this.setAnimationRef(null);
+          return;
+        }
+        this.render(a);
+        const c = requestAnimationFrame(i);
+        this.setAnimationRef(c);
+      }, s = requestAnimationFrame(i);
+      this.setAnimationRef(s);
+    });
+  }
+}
+class je extends $ {
+  constructor(e) {
+    super("overlay", e);
+  }
+  update(e) {
+  }
+  async draw() {
+  }
+}
+class _e {
+  constructor(e) {
+    this.boardRuntime = e;
+  }
+  ITERATORS = {
+    onPointerSelect: "defaultOnSelect",
+    onPointerHover: "defaultOnHover",
+    onPointerDragStart: null,
+    onPointerDrag: null,
+    onPointerDrop: null,
+    onAnimationFrame: null,
+    onDrawPiece: null,
+    onDrawBoard: null,
+    onDrawOverlay: null,
+    onDrawUnderlay: null
+  };
+  destroy() {
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+  }
+  defaultOnSelect(e) {
+    const { squareSize: t, x: r, y: n } = e, i = (s) => {
+      const a = "#ffc400ff", o = "rgba(255, 196, 0, 0.75)";
+      s.save(), s.beginPath(), s.arc(
+        r + t / 2,
+        n + t / 2,
+        t * 0.35,
+        0,
+        Math.PI * 2
+      ), s.strokeStyle = a, s.lineWidth = 3, s.fillStyle = o, s.stroke(), s.fill(), s.restore();
+    };
+    this.boardRuntime.renderer.getLayerManager().getLayer("underlay").drawEvent(i, "onPointerSelect"), "clearCache" in e && typeof e.clearCache == "function" && e.clearCache();
+  }
+  defaultOnHover(e) {
+    const { squareSize: t, piece: r, piecesImage: n } = e, i = this.boardRuntime.getHoverConfig();
+    if (!r) return;
+    const s = n?.[r.type];
+    if (i.highlight && this.boardRuntime.getSelected()?.id !== this.boardRuntime.getPieceHover()) {
+      const a = (o) => {
+        o.save(), o.shadowColor = "rgba(255, 204, 0, 0.8)", o.shadowBlur = 10, o.shadowOffsetX = 0, o.shadowOffsetY = 0, o.lineWidth = 3.5, o.strokeStyle = "#ffcc00", o.lineJoin = "round", o.beginPath(), o.strokeRect(
+          r.x + 1,
+          r.y + 1,
+          t - 2,
+          t - 2
+        ), o.restore();
+      };
+      this.boardRuntime.renderer.getLayerManager().getLayer("overlay").drawEvent(a, "onPointerHover");
+    }
+    if (i.scaling && r) {
+      const a = (o) => {
+        o.save(), o.shadowColor = "rgba(0, 0, 0, 0.5)", o.shadowBlur = 10, o.shadowOffsetX = 5, o.shadowOffsetY = 5, s instanceof HTMLImageElement ? this.drawOnHoverHTML(
+          s,
+          o,
+          r,
+          t,
+          i.scaleAmount
+        ) : typeof s == "string" && this.drawOnHoverText(
+          s,
+          o,
+          r,
+          t,
+          i.scaleAmount
+        ), o.restore();
+      };
+      this.boardRuntime.renderer.getLayerManager().getLayer("dynamicPieces").drawEvent(a, "onPointerHover");
+    }
+    "clearCache" in e && typeof e.clearCache == "function" && e.clearCache();
+  }
+  drawOnHoverHTML(e, t, r, n, i) {
+    const s = b.squareToCoords(
+      r.square,
+      n,
+      this.boardRuntime.getIsBlackView()
+    );
+    s && e && e.complete && e.naturalWidth > 0 && t.drawImage(
+      e,
+      s.x - n * (i - 1) / 2,
+      s.y - n * (i - 1) / 2,
+      n * i,
+      n * i
+    );
+  }
+  drawOnHoverText(e, t, r, n, i) {
+    const s = b.squareToCoords(
+      r.square,
+      n,
+      this.boardRuntime.getIsBlackView()
+    );
+    if (!s) return;
+    const a = e.length > 1 ? e[0] : e;
+    t.save(), t.fillStyle = r.type[0] === "w" ? "#ffffffff" : "#000", t.font = `${n * 0.8 * i}px monospace`;
+    let o = n * 0.8;
+    t.font = `${o}px monospace`;
+    const c = t.measureText(a).width;
+    c > n * 0.9 && (o *= n * 0.9 / c, t.font = `${o}px monospace`), t.textAlign = "center", t.textBaseline = "middle", t.fillText(a, s.x + n / 2, s.y + n / 2), t.restore();
+  }
+  drawOnHoverPath() {
+  }
+}
+class ze {
+  constructor(e) {
+    this.boardRuntime = e;
+  }
+  eventsLayerMap = {
+    onPointerSelect: "underlay",
+    onPointerHover: "dynamicPieces",
+    onPointerDragStart: "dynamicPieces",
+    onPointerDrag: "dynamicPieces",
+    onPointerDrop: null,
+    onAnimationFrame: null,
+    onDrawPiece: null,
+    onDrawBoard: null,
+    onDrawOverlay: null,
+    onDrawUnderlay: null
+  };
+  eventsRunMap = {
+    onPointerSelect: this.onPointerSelect.bind(this),
+    onPointerHover: this.onPointerHover.bind(this),
+    onPointerDragStart: this.onPointerDragStart.bind(this),
+    onPointerDrag: this.onPointerDrag.bind(this),
+    onPointerDrop: this.onPointerDrop.bind(this),
+    onAnimationFrame: this.onAnimationFrame.bind(this),
+    onDrawPiece: this.onDrawPiece.bind(this),
+    onDrawBoard: this.onDrawBoard.bind(this),
+    onDrawOverlay: this.onDrawOverlay.bind(this),
+    onDrawUnderlay: this.onDrawUnderlay.bind(this)
+  };
+  getEventLayer(e) {
+    return this.eventsLayerMap[e];
+  }
+  onPointerHover(e) {
+    const t = this.boardRuntime.getSize(), r = this.boardRuntime.getPieceStyle(), n = this.boardRuntime.getInternalRefObj(), i = this.boardRuntime.getPieceHover(), s = this.boardRuntime.getSelected(), a = this.boardRuntime.getEvents(), o = Math.ceil(t / 8), c = this.boardRuntime.getInjection();
+    if (i && !s?.isDragging) {
+      const u = n[i], h = this.boardRuntime.getCanvasLayers().getCanvas("dynamicPieces").current ? this.boardRuntime.getCanvasLayers().getCanvas("dynamicPieces").current : void 0;
+      if (u && !u.anim && (this.boardRuntime.getDefault().onPointerHover && this.boardRuntime.renderer.getLayerManager().getIterator().defaultOnHover({
+        ctx: e,
+        size: t,
+        squareSize: o,
+        x: u.x,
+        y: u.y,
+        canvas: h || void 0,
+        piece: u,
+        square: u.square,
+        piecesImage: r
+      }), a?.onPointerHover)) {
+        let y = this.boardRuntime.getContext(!0, {
+          squareSize: o,
+          x: u.x,
+          y: u.y,
+          size: t,
+          piece: u,
+          square: u.square
+        });
+        y.__event = "onPointerHover", this.boardRuntime.helpers.triggerEvent(
+          a,
+          "onPointerHover",
+          c ? c(y) : y
+        );
+      }
+    }
+  }
+  onPointerSelect(e) {
+    const t = this.boardRuntime.getIsBlackView(), r = Math.ceil(this.boardRuntime.getSize()), n = this.boardRuntime.getPieceStyle(), i = this.boardRuntime.getInternalRefObj(), s = this.boardRuntime.getSelected(), a = this.boardRuntime.getEvents(), o = this.boardRuntime.getInjection(), c = r / 8;
+    if (!s?.id || !e) return;
+    const u = i[s.id] ? b.squareToCoords(s.square, c, t) : null;
+    if (u) {
+      const { x: h, y } = u, f = this.boardRuntime.helpers.pieceHelper.getPieceAt(
+        h,
+        y,
+        c,
+        t,
+        i
+      )?.piece;
+      if (this.boardRuntime.getDefault().onPointerSelect && this.boardRuntime.renderer.getLayerManager().getIterator().defaultOnSelect({
+        ctx: e,
+        x: h,
+        y,
+        size: r,
+        squareSize: c,
+        getPiece: f,
+        getPiecesImage: n,
+        getSquare: s.square
+      }), a?.onPointerSelect) {
+        const g = this.boardRuntime.getContext(!0, {
+          squareSize: c,
+          x: h,
+          y,
+          size: r,
+          piece: f,
+          square: s.square
+        });
+        g.__event = "onPointerSelect", this.boardRuntime.helpers.triggerEvent(
+          a,
+          "onPointerSelect",
+          o ? o(g) : g
+        );
+      }
+    }
+  }
+  onPointerDragStart() {
+    const e = this.boardRuntime.getSelected();
+    !e || !e.isDragging || this.boardRuntime.getCanvasLayers().setCanvasStyle("staticPieces", {
+      cursor: "grabbing"
+    });
+  }
+  onPointerDrag() {
+    const e = this.boardRuntime.getSelected(), t = Math.ceil(this.boardRuntime.getSize() / 8);
+    if (!e || !e.isDragging) return;
+    const r = this.boardRuntime.getInternalRefVal(e.id);
+    if (!r) return;
+    this.boardRuntime.renderer.getLayerManager().getLayer("dynamicPieces").addCoords(e.id, {
+      x: r.x,
+      y: r.y,
+      w: t,
+      h: t
+    });
+  }
+  onPointerDrop() {
+  }
+  onAnimationFrame() {
+  }
+  onDrawPiece() {
+  }
+  onDrawBoard() {
+  }
+  onDrawOverlay() {
+  }
+  onDrawUnderlay() {
+  }
+  run(e) {
+    const t = this.eventsRunMap[e];
+    if (!t) return;
+    const r = this.getEventLayer(e), n = r ? this.boardRuntime.getCanvasLayers().getContext(r) : null;
+    t(n);
+  }
+}
+class qe {
+  layers;
+  iterator;
+  events;
+  interaction = {
+    onPointerSelect: !0,
+    onPointerHover: !0,
+    onPointerDragStart: !0,
+    onPointerDrag: !0,
+    onPointerDrop: !0,
+    onAnimationFrame: !0,
+    onDrawPiece: !0,
+    onDrawBoard: !0,
+    onDrawOverlay: !0,
+    onDrawUnderlay: !0
+  };
+  boardRuntime;
+  drawList = /* @__PURE__ */ new Set();
+  firstDrawList = /* @__PURE__ */ new Set();
+  list = {
+    onPointerSelect: this.drawList,
+    onPointerHover: this.drawList,
+    onPointerDragStart: this.firstDrawList,
+    onPointerDrag: this.firstDrawList,
+    onPointerDrop: this.drawList,
+    onAnimationFrame: this.drawList,
+    onDrawPiece: this.drawList,
+    onDrawBoard: this.drawList,
+    onDrawOverlay: this.drawList,
+    onDrawUnderlay: this.drawList
+  };
+  delayedPieceClear = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this.boardRuntime = e, this.layers = {
+      board: new Oe(e),
+      overlay: new je(e),
+      underlay: new Ie(e),
+      staticPieces: new He(e),
+      dynamicPieces: new Ne(e)
+    }, this.iterator = new _e(e), this.events = new ze(e);
+  }
+  getLayer(e) {
+    return this.layers[e];
+  }
+  getAllLayers() {
+    return Object.keys(this.layers);
+  }
+  getIterator() {
+    return this.iterator;
+  }
+  getPieceLayer(e) {
+    for (const [t, r] of Object.entries(this.layers))
+      if (r.hasPiece(e)) return t;
+    return null;
+  }
+  removeFromAllLayers(e) {
+    for (const t of Object.values(this.layers)) t.removeAll?.(e);
+  }
+  removeEvent(e) {
+    for (const t of Object.values(this.layers)) t.removeEvent(e);
+  }
+  async togglePieceLayer(e, t, r, n) {
+    if (e === t) return;
+    const i = this.getLayer(e), s = this.getLayer(t), a = Math.floor(this.boardRuntime.getSize() / 8), o = this.boardRuntime.isActivePiece(r);
+    if (!i || !s)
+      return;
+    const c = i.getPiece(r), u = i.getCoords(r);
+    if (!c || !u)
+      return;
+    const h = b.squareToCoords(
+      c.square,
+      a,
+      this.boardRuntime.getIsBlackView()
+    );
+    if (!h) return;
+    const y = t === "staticPieces" ? {
+      x: Math.floor(h.x),
+      y: Math.floor(h.y),
+      w: Math.ceil(a),
+      h: Math.ceil(a)
+    } : {
+      x: Math.floor(c.x),
+      y: Math.floor(c.y),
+      w: Math.ceil(a),
+      h: Math.ceil(a)
+    };
+    i.removeAll?.(r), o && s.addAll?.(r, c, y, y), !n && this.boardRuntime.renderer.pipelineRender.setNextEvent("onRender", [
+      {
+        board: !1,
+        staticPieces: !0,
+        overlay: !0,
+        underlay: !0,
+        dynamicPieces: !0
+      }
+    ]);
+  }
+  applyDrawResult(e, t, r, n) {
+    const i = e.__drawRegions, s = e.__actualRegions;
+    for (const a of i) {
+      const o = {
+        x: Math.floor(a.x),
+        y: Math.floor(a.y),
+        w: Math.ceil(a.w),
+        h: Math.ceil(a.h)
+      };
+      n && this.getLayer(t).addClearCoords(n, o), r && this.getLayer(t).addEvent(r, o);
+    }
+    for (const a of s) {
+      const o = {
+        x: Math.floor(a.x),
+        y: Math.floor(a.y),
+        w: Math.ceil(a.w),
+        h: Math.ceil(a.h)
+      };
+      n && this.getLayer(t).addCoords(n, o);
+    }
+    e.__clearRegions();
+  }
+  drawEvent(e) {
+    this.removeEvent(e), this.addDraw(e);
+  }
+  addDraw(e) {
+    this.list[e].add(e);
+  }
+  removeDraw(e) {
+    this.list[e].delete(e);
+  }
+  getEventEnabled() {
+    return this.interaction;
+  }
+  isSelectionEnabled() {
+    return this.interaction.onPointerSelect;
+  }
+  isHoverEnabled() {
+    return this.interaction.onPointerHover;
+  }
+  setHoverEnabled(e) {
+    return this.interaction.onPointerHover = e;
+  }
+  setSelectionEnabled(e) {
+    return this.interaction.onPointerSelect = e;
+  }
+  resetAllLayers() {
+    for (const e of Object.values(this.layers)) e.resetLayer();
+  }
+  renderEvents(e) {
+    const t = e ? this.firstDrawList.values() : this.drawList.values();
+    for (const r of t)
+      this.interaction[r] = !1, this.events.run(r), this.interaction[r] = !0;
+    e ? this.firstDrawList.clear() : this.drawList.clear();
+  }
+  addDelayedPieceClear(e, t) {
+    this.delayedPieceClear.set(e, t);
+  }
+  getDelayedPieceClear(e) {
+    return this.delayedPieceClear.get(e);
+  }
+  deleteDelayedPieceClear(e) {
+    this.delayedPieceClear.delete(e);
+  }
+  resetDelayedPieceClear() {
+    this.delayedPieceClear.clear();
+  }
+  isDelayedPieceClear(e) {
+    return Array.from(this.delayedPieceClear.values()).includes(e);
+  }
+  clearDelayedPiece(e, t) {
+    const r = this.getDelayedPieceClear(e);
+    if (r) {
+      const n = this.getLayer(t), i = n.getCoords(r);
+      i && (n.addClearQueue(i), n.removeAll?.(r), n.clear()), this.deleteDelayedPieceClear(e);
+    }
+  }
+}
+class Fe {
+  constructor(e) {
+    this.boardRuntime = e;
+  }
+  eventsNext = {
+    onPointerSelect: [],
+    onPointerHover: [],
+    onPointerDragStart: [],
+    onPointerDrag: [],
+    onPointerDrop: [],
+    onAnimationFrame: [],
+    onDrawPiece: [],
+    onDrawBoard: [],
+    onDrawOverlay: [],
+    onDrawUnderlay: [],
+    onToggleCanvas: [],
+    onRender: []
+  };
+  eventsToken = {
+    onPointerSelect: 0,
+    onPointerHover: 0,
+    onPointerDragStart: 0,
+    onPointerDrag: 0,
+    onPointerDrop: 0,
+    onAnimationFrame: 0,
+    onDrawPiece: 0,
+    onDrawBoard: 0,
+    onDrawOverlay: 0,
+    onDrawUnderlay: 0,
+    onToggleCanvas: 0,
+    onRender: 0
+  };
+  loading = !1;
+  destroyed = !1;
+  stream = [];
+  destroy() {
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+    this.destroyed = !0;
+  }
+  setNextEvent(e, t, r) {
+    const n = ++this.eventsToken[e];
+    this.eventsNext[e].push({ args: [...t], token: n, resolve: r }), this.stream.push(e), this.loading || this.loadEvents();
+  }
+  getNextEvent(e) {
+    return this.eventsNext[e].shift();
+  }
+  async loadEvents() {
+    if (!(this.loading || this.destroyed)) {
+      this.loading = !0;
+      try {
+        for (; !this.destroyed && this.stream.length > 0; ) {
+          const e = this.stream.shift(), t = this.getNextEvent(e);
+          if (!t) continue;
+          const { args: r, token: n, resolve: i } = t;
+          if (n !== this.eventsToken[e]) {
+            i?.();
+            continue;
+          }
+          const s = this.boardRuntime.renderer.eventsRuntime[e];
+          !s || !r || (await s(...r), i?.());
+        }
+      } finally {
+        if (this.destroyed) return;
+        this.stream.length ? this.loadEvents() : this.loading = !1;
+      }
+    }
+  }
+}
+class Ve {
+  constructor(e) {
+    this.boardRuntime = e, this.layerManager = new qe(e), this.eventsRuntime = {
+      onPointerSelect: this.boardRuntime.setSelected.bind(this.boardRuntime),
+      onPointerHover: this.boardRuntime.setPieceHover.bind(this.boardRuntime),
+      onPointerDragStart: null,
+      onPointerDrag: null,
+      onPointerDrop: null,
+      onAnimationFrame: null,
+      onDrawPiece: null,
+      onDrawBoard: null,
+      onDrawOverlay: null,
+      onDrawUnderlay: null,
+      onToggleCanvas: this.toggleCanvas.bind(this),
+      onRender: this.render.bind(this)
+    }, this.pipelineRender = new Fe(e);
+  }
+  layerManager;
+  eventsRuntime;
+  pipelineRender;
+  destroy() {
+    this.pipelineRender.destroy();
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+  }
+  async render(e) {
+    this.layerManager.renderEvents(!0);
+    for (const [t, r] of Object.entries(e))
+      r && await this.layerManager.getLayer(t).renderAsync();
+    this.layerManager.renderEvents(!1);
+  }
+  getLayerManager() {
+    return this.layerManager;
+  }
+  async toggleCanvas(e, t, r, n) {
+    await this.layerManager.togglePieceLayer(e, t, r, n);
+  }
+}
+class $e {
+  constructor(e) {
+    this.boardRuntime = e;
+  }
+  pipelineRender;
+  eventsRuntime = {};
+  destroy() {
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+  }
+  getLayerManager() {
+    throw new Error("Method not implemented.");
+  }
+  async render(e) {
+    throw new Error("Method not implemented.");
+  }
+}
+class We {
+  events = /* @__PURE__ */ new Map();
+  on(e, t) {
+    const r = this.events.get(e) ?? [];
+    return r.includes(t) ? () => {
+    } : (r.push(t), this.events.set(e, r), () => this.off(e, t));
+  }
+  off(e, t) {
+    const r = this.events.get(e);
+    if (!r) return;
+    const n = r.indexOf(t);
+    n !== -1 && (r.splice(n, 1), r.length || this.events.delete(e));
+  }
+  emit(e, ...t) {
+    const r = this.events.get(e);
+    if (r)
+      for (const n of [...r])
+        n(...t);
+  }
+  once(e, t) {
+    const r = (...i) => {
+      n(), t(...i);
+    }, n = this.on(e, r);
+    return n;
+  }
+}
+class te {
+  constructor(e) {
+    this.args = e, Object.assign(this, e), e.hoverConfig && (this.hoverConfig = e.hoverConfig), this.renderer = e.mode === "2d" ? new Ve(this) : new $e(this), this.setInactivePieces(), b.validateFen(e.board) ? this.setBoard(b.parseFen(e.board)) : this.setBoard(
+      b.parseFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR")
+    );
+  }
+  internalRef = {};
+  selected = null;
+  pieceHover = null;
+  isImagesLoaded = !1;
+  destroyed = !1;
+  animationDuration = 300;
+  piecesToRender = [];
+  isMoving = !1;
+  board;
+  hoverConfig = {
+    highlight: !0,
+    scaling: !1,
+    scaleAmount: 1.05
+  };
+  boardEvents = new ve(this);
+  helpers = new Te(this);
+  renderer;
+  mounted = !1;
+  default = {
+    onPointerSelect: !0,
+    onPointerHover: !0,
+    moveAnimation: !0
+  };
+  activePiecesPool = {
+    wP: /* @__PURE__ */ new Map(),
+    wR: /* @__PURE__ */ new Map(),
+    wN: /* @__PURE__ */ new Map(),
+    wB: /* @__PURE__ */ new Map(),
+    wQ: /* @__PURE__ */ new Map(),
+    wK: /* @__PURE__ */ new Map(),
+    bP: /* @__PURE__ */ new Map(),
+    bR: /* @__PURE__ */ new Map(),
+    bN: /* @__PURE__ */ new Map(),
+    bB: /* @__PURE__ */ new Map(),
+    bQ: /* @__PURE__ */ new Map(),
+    bK: /* @__PURE__ */ new Map()
+  };
+  inactivePiecesPool = {
+    wP: [],
+    wR: [],
+    wN: [],
+    wB: [],
+    wQ: [],
+    wK: [],
+    bP: [],
+    bR: [],
+    bN: [],
+    bB: [],
+    bQ: [],
+    bK: []
+  };
+  piecesBoard = /* @__PURE__ */ new Map();
+  undoStack = [];
+  redoStack = [];
+  eventEmitter = new We();
+  static async create(e) {
+    const t = new te(e);
+    return await t.init(), t;
+  }
+  destroy() {
+    this.mounted && (this.destroyed = !0, this.args.canvasLayers.destroy(), this.helpers.destroy(), this.boardEvents.destroy(), this.args.canvasLayers = null, this.helpers = null, this.boardEvents = null, this.args.pieceStyle && Object.entries(this.args.pieceStyle).map(([e, t]) => {
+      t instanceof HTMLImageElement && (t.src = "", t.onload = null, t.onerror = null), t = null;
+    }));
+  }
+  addPieceBoard(e, t) {
+    this.piecesBoard.set(e, t);
+  }
+  deletePieceBoard(e) {
+    this.piecesBoard.delete(e);
+  }
+  getPieceBoard(e) {
+    return this.piecesBoard.get(e);
+  }
+  getSize() {
+    return this.args.size;
+  }
+  mount() {
+    this.mounted = !0;
+  }
+  getIsBlackView() {
+    return this.args.isBlackView;
+  }
+  getSelected() {
+    return this.selected;
+  }
+  getInternalRefObj() {
+    return this.internalRef;
+  }
+  getPieceHover() {
+    return this.pieceHover;
+  }
+  getBoardCanvas() {
+    return this.args.canvasLayers.getCanvas("board");
+  }
+  getStaticPiecesCanvas() {
+    return this.args.canvasLayers.getCanvas("staticPieces");
+  }
+  getDynamicPiecesCanvas() {
+    return this.args.canvasLayers.getCanvas("dynamicPieces");
+  }
+  getUnderlaycanvas() {
+    return this.args.canvasLayers.getCanvas("underlay");
+  }
+  getOverlaycanvas() {
+    return this.args.canvasLayers.getCanvas("overlay");
+  }
+  getInternalRefVal(e) {
+    return this.internalRef[e];
+  }
+  getLightTile() {
+    return this.args.lightTile || "#9a8b6dff";
+  }
+  getDarkTile() {
+    return this.args.darkTile || "#3E2723";
+  }
+  getPieceStyle() {
+    return this.args.pieceStyle;
+  }
+  getEvents() {
+    return this.args.events;
+  }
+  getInjection() {
+    return this.args.injection;
+  }
+  getBoard() {
+    return this.board;
+  }
+  getMove() {
+    return this.args.onMove;
+  }
+  getCanvasLayers() {
+    return this.args.canvasLayers;
+  }
+  getAnimationDuration() {
+    return this.animationDuration;
+  }
+  getDefault() {
+    return this.args.default ? this.args.default : this.default;
+  }
+  getReadonlyInternalRef() {
+    return b.deepFreeze(this.internalRef);
+  }
+  getReadonlySelectedRef() {
+    return this.selected ? b.deepFreeze(this.selected) : null;
+  }
+  getReadonlyPiece(e, t) {
+    return e ? b.deepFreeze(e) : null;
+  }
+  getReadonlySquare(e) {
+    return e ? b.deepFreeze(e) : null;
+  }
+  getReadonlyAnimation() {
+    const e = [];
+    for (const t of this.renderer.getLayerManager().getAllLayers())
+      e.push(
+        ...this.renderer.getLayerManager().getLayer(t).getAnimation()
+      );
+    return b.deepFreeze(e);
+  }
+  getReadonlyBoard() {
+    return b.deepFreeze(this.getBoard());
+  }
+  getDefaultAnimation() {
+    return this.args.default.moveAnimation;
+  }
+  getContext(e, t) {
+    const { squareSize: r, size: n, x: i, y: s, piece: a, square: o } = t, c = this.helpers.createLazyEventContext(
+      { squareSize: r, size: n, x: i, y: s },
+      {
+        getPiece: () => this.getReadonlyPiece(a || void 0),
+        getPiecesImage: () => this.getPieceStyle(),
+        getSquare: () => this.getReadonlySquare(o || void 0),
+        getPieces: () => this.getReadonlyInternalRef(),
+        getPieceHover: () => this.getPieceHover(),
+        getSelected: () => this.getReadonlySelectedRef(),
+        getIsBlackView: () => this.getIsBlackView(),
+        getLightTile: () => this.getLightTile(),
+        getDarkTile: () => this.getDarkTile(),
+        getAnimation: () => this.getReadonlyAnimation(),
+        getDraw: () => {
+          const u = c.__event, h = (y) => {
+            const { onDraw: f, layer: g } = y, P = this.getCanvasLayers().getClientContext(g);
+            if (!P) return;
+            f(P);
+            const v = P;
+            this.renderer.getLayerManager().applyDrawResult(v, g, u);
+          };
+          return h.batch = (y) => {
+            const f = {};
+            let g = 0;
+            for (const { layer: v, onDraw: C } of y)
+              f[v] || (f[v] = []), f[v].push({ fn: C, index: g++ });
+            const P = Object.values(f).flat().sort((v, C) => v.index - C.index);
+            for (const { fn: v, index: C } of P) {
+              const p = y[C].layer;
+              h.group(p, (m, w) => {
+                w.draw(v);
+              });
+            }
+          }, h.group = (y, f) => {
+            const g = this.getCanvasLayers().getClientContext(y);
+            if (!g) return;
+            f(g, {
+              draw: (C) => C(g)
+            });
+            const v = g;
+            this.renderer.getLayerManager().applyDrawResult(v, y, u);
+          }, h;
+        }
+      },
+      { cache: e }
+    );
+    return c;
+  }
+  getIsMoving() {
+    return this.isMoving;
+  }
+  getHoverConfig() {
+    return (this.hoverConfig.scaleAmount < 0.75 || this.hoverConfig.scaleAmount > 1.15) && (this.hoverConfig.scaleAmount = Math.min(
+      1.15,
+      Math.max(0.75, this.hoverConfig.scaleAmount)
+    )), this.hoverConfig;
+  }
+  getEventEmitter() {
+    return this.eventEmitter;
+  }
+  isActivePiece(e) {
+    return !!this.piecesBoard.get(e)?.square;
+  }
+  setHoverConfig(e) {
+    this.hoverConfig = e;
+  }
+  setIsMoving(e) {
+    this.isMoving = e;
+  }
+  setInactivePieces() {
+    for (let e = 1; e <= 64; e++)
+      for (const t of ae) {
+        const r = `${t}${e}`;
+        this.inactivePiecesPool[t].push(r);
+        const n = {
+          square: null,
+          type: t,
+          id: r
+        };
+        this.piecesBoard.set(r, n);
+      }
+  }
+  getInactivePiece(e) {
+    return this.inactivePiecesPool[e].shift();
+  }
+  addInactivePiece(e, t) {
+    this.inactivePiecesPool[e].unshift(t);
+  }
+  toggleHoverScale(e) {
+    this.hoverConfig.scaleAmount = e;
+  }
+  toggleHoverScaling() {
+    this.hoverConfig.scaling = !this.hoverConfig.scaling;
+  }
+  toggleHoverHighlight() {
+    this.hoverConfig.highlight = !this.hoverConfig.highlight;
+  }
+  async setSize(e) {
+    this.args.size = Math.floor(e / 8) * 8, this.getCanvasLayers().clearAllRect(), this.getCanvasLayers().resize(Math.floor(e / 8) * 8), this.setInternalRefObj({}), this.renderer.getLayerManager().resetAllLayers(), await this.refreshCanvases({
+      board: !0,
+      staticPieces: !0,
+      overlay: !0,
+      underlay: !0,
+      dynamicPieces: !0
+    });
+  }
+  setAnimationDuration(e) {
+    e < 150 || e > 500 || (this.animationDuration = e);
+  }
+  async setBoardByFen(e) {
+    b.validateFen(e).status && (this.setIsMoving(!0), this.setBoard(b.parseFen(e)), this.clearRedo(), this.clearUndo(), await this.refreshCanvases({
+      board: !1,
+      staticPieces: !0,
+      overlay: !0,
+      underlay: !0,
+      dynamicPieces: !0
+    }), this.setIsMoving(!1));
+  }
+  setBoard(e) {
+    for (const t of ae) {
+      const r = [], n = e[t] ? e[t] : [], i = this.activePiecesPool[t], s = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
+      for (let y = 0; y < n.length; y++) {
+        const f = n[y];
+        i.get(f) && (a.add(f), s.add(f));
+      }
+      const o = [], c = Array.from(i.keys());
+      let u = 0;
+      for (let y = 0; y < n.length; y++) {
+        const f = n[y];
+        if (!a.has(f))
+          for (; u < c.length; ) {
+            const g = c[u++];
+            if (g && !s.has(g)) {
+              r.push({ from: g, to: f }), s.add(g), a.add(f);
+              break;
+            }
+          }
+      }
+      for (let y = 0; y < n.length; y++) {
+        const f = n[y];
+        a.has(f) || o.push(f);
+      }
+      const h = /* @__PURE__ */ new Set();
+      for (const y of c)
+        s.has(y) || h.add(y);
+      this.updateBoardPieces(r, h, o, t);
+    }
+    this.createBoard();
+  }
+  createBoard() {
+    const e = {};
+    for (const [t, r] of Object.entries(this.activePiecesPool))
+      for (const n of r.keys()) {
+        const i = r.get(n);
+        if (!i) continue;
+        const s = this.piecesBoard.get(i);
+        s && (e[n] = {
+          id: i,
+          square: s.square,
+          type: t
+        });
+      }
+    this.board = e;
+  }
+  updateBoardPieces(e, t, r, n) {
+    for (const i of e) {
+      const s = this.activePiecesPool[n].get(i.from);
+      if (!s) continue;
+      this.activePiecesPool[n].delete(i.from), this.activePiecesPool[n].set(i.to, s);
+      const a = this.piecesBoard.get(s);
+      a && (a.square = {
+        file: i.to[0],
+        rank: parseInt(i.to[1]),
+        notation: i.to
+      });
+    }
+    for (const i of t.values()) {
+      const s = this.activePiecesPool[n].get(i);
+      if (!s) continue;
+      this.inactivePiecesPool[n].push(s), this.activePiecesPool[n].delete(i);
+      const a = this.piecesBoard.get(s);
+      a && (a.square = null);
+    }
+    for (let i = 0; i < r.length; i++) {
+      const s = this.inactivePiecesPool[n].shift();
+      if (!s) continue;
+      const a = r[i];
+      this.activePiecesPool[n].set(a, s);
+      const o = this.piecesBoard.get(s);
+      o && (o.square = {
+        file: a.charAt(0),
+        rank: parseInt(a.charAt(1)),
+        notation: a
+      });
+    }
+  }
+  async refreshCanvases(e) {
+    await this.resetEvents(!0), this.renderer.getLayerManager().setHoverEnabled(!1), this.helpers.pieceHelper.clearCache(), await this.initInternalRef();
+    const t = (r) => this.renderer.pipelineRender.setNextEvent(
+      "onRender",
+      [e],
+      r
+    );
+    await b.asyncHandler(t), this.renderer.getLayerManager().setHoverEnabled(!0);
+    try {
+      this.args.onUpdate && this.args.onUpdate();
+    } catch (r) {
+      console.log(r);
+    }
+  }
+  async resetEvents(e) {
+    let t = !1;
+    if (this.selected !== null && (this.selected.isDragging && this.helpers.pointerEventsHelper.endDrag(-1, -1, !1, !0), this.renderer.pipelineRender.setNextEvent("onPointerSelect", [
+      null,
+      !0
+    ]), t = !0), this.pieceHover !== null && (this.renderer.pipelineRender.setNextEvent("onPointerHover", [null, !0]), t = !0), !e || !t) return;
+    const r = (n) => this.renderer.pipelineRender.setNextEvent(
+      "onRender",
+      [
+        {
+          board: !1,
+          staticPieces: !0,
+          overlay: !0,
+          underlay: !0,
+          dynamicPieces: !0
+        }
+      ],
+      n
+    );
+    await b.asyncHandler(r);
+  }
+  updateBoard(e) {
+    e.square && (this.board[e.square.notation] = e);
+  }
+  setInternalRefVal(e, t) {
+    this.internalRef[e] = t;
+  }
+  setInternalRefObj(e) {
+    this.internalRef = e;
+  }
+  async setSelected(e, t) {
+    if (e === null && this.selected === null) {
+      this.selected = e;
+      return;
+    } else if (e?.id === this.selected?.id) {
+      this.selected = e;
+      return;
+    } else if (!this.renderer.getLayerManager().isSelectionEnabled()) return;
+    const r = this.renderer.getLayerManager();
+    this.selected = e, r.drawEvent("onPointerSelect"), t || this.renderer.pipelineRender.setNextEvent("onRender", [
+      {
+        board: !1,
+        staticPieces: !0,
+        overlay: !0,
+        underlay: !0,
+        dynamicPieces: !0
+      }
+    ]);
+  }
+  async setPieceHover(e, t) {
+    const r = this.getPieceHover(), n = this.renderer.getLayerManager();
+    r !== e && this.renderer.getLayerManager().isHoverEnabled() && (this.pieceHover = e, n.drawEvent("onPointerHover"), this.hoverConfig.scaling ? e === null && r !== null ? await n.togglePieceLayer(
+      "dynamicPieces",
+      "staticPieces",
+      r,
+      t
+    ) : r === null && e !== null ? await n.togglePieceLayer(
+      "staticPieces",
+      "dynamicPieces",
+      e,
+      t
+    ) : r !== null && e !== null && (await n.togglePieceLayer(
+      "dynamicPieces",
+      "staticPieces",
+      r,
+      t
+    ), await n.togglePieceLayer(
+      "staticPieces",
+      "dynamicPieces",
+      e,
+      t
+    )) : t || this.renderer.pipelineRender.setNextEvent("onRender", [
+      {
+        board: !1,
+        staticPieces: !0,
+        overlay: !0,
+        underlay: !0,
+        dynamicPieces: !0
+      }
+    ]));
+  }
+  async setBlackView(e) {
+    this.getIsBlackView() !== e && (this.args.isBlackView = e, this.setInternalRefObj({}), this.getCanvasLayers().clearAllRect(), this.renderer.getLayerManager().resetAllLayers(), await this.refreshCanvases({
+      board: !0,
+      staticPieces: !0,
+      overlay: !0,
+      underlay: !0,
+      dynamicPieces: !0
+    }));
+  }
+  deleteIntervalRefVal(e) {
+    delete this.internalRef[e];
+  }
+  async loadImages() {
+    this.destroyed || !this.isImagesLoaded && this.args.pieceStyle && (await this.helpers.pieceHelper.preloadImages(this.args.pieceStyle), this.isImagesLoaded = !0);
+  }
+  async init() {
+    return await new Promise(requestAnimationFrame), await this.initPieceImages(), await this.initInternalRef(), new Promise((e) => {
+      this.renderer.pipelineRender.setNextEvent(
+        "onRender",
+        [
+          {
+            board: !0,
+            staticPieces: !0,
+            overlay: !0,
+            underlay: !0,
+            dynamicPieces: !0
+          }
+        ],
+        e
+      );
+    });
+  }
+  async initPieceImages() {
+    (!this.args || !this.args.pieceStyle) && (this.args.pieceStyle = this.helpers.pieceHelper.getPieceImages[this.args.pieceConfig?.type]), await this.loadImages();
+  }
+  async setPieceImages(e) {
+    if (this.destroyed || this.args.pieceConfig.type === e || this.isMoving)
+      return;
+    !this.isImagesLoaded && e === "image" && await this.loadImages(), this.args.pieceConfig.type = e, this.args.pieceStyle = this.helpers.pieceHelper.getPieceImages[e];
+    const t = this.renderer.getLayerManager();
+    this.getCanvasLayers().clearAllRect({
+      board: !1,
+      staticPieces: !0,
+      overlay: !0,
+      underlay: !0,
+      dynamicPieces: !0
+    }), t.getLayer("staticPieces").redrawPieces(), t.getLayer("dynamicPieces").redrawPieces(), await this.refreshCanvases({
+      board: !1,
+      staticPieces: !0,
+      overlay: !0,
+      underlay: !0,
+      dynamicPieces: !0
+    });
+  }
+  async updateBoardState(e, t) {
+    const r = this.renderer.getLayerManager(), n = e, i = [];
+    for (const s of n) {
+      const { from: a, to: o, promotion: c, captured: u } = s;
+      let h = this.board[s.from];
+      const y = {
+        from: o,
+        to: a,
+        captured: [],
+        moved: h.type,
+        promoted: !!c
+      }, f = {
+        file: s.to.charAt(0),
+        rank: parseInt(s.to.charAt(1)),
+        notation: s.to
+      };
+      if (c) {
+        const P = `${h.type[0]}${c.toUpperCase()}`, v = this.inactivePiecesPool[P].shift();
+        if (v) {
+          const C = this.piecesBoard.get(v);
+          if (C) {
+            const p = {
+              square: t ? h.square : f,
+              type: P,
+              x: this.getInternalRefVal(h.id).x,
+              y: this.getInternalRefVal(h.id).y
+            };
+            this.setInternalRefVal(v, p);
+            const m = r.getLayer("staticPieces"), w = m.getCoords(h.id), R = b.squareToCoords(
+              f,
+              this.getSize() / 8,
+              this.getIsBlackView()
+            );
+            h.square = null, C.square = f, this.piecesBoard.set(h.id, h), this.inactivePiecesPool[h.type].push(h.id), this.activePiecesPool[h.type].delete(s.from), this.activePiecesPool[P].set(s.to, C.id), this.piecesBoard.set(v, C), this.deleteIntervalRefVal(h.id), m.removeAll?.(h.id);
+            const x = w || (R ? {
+              x: R.x,
+              y: R.y,
+              w: this.getSize() / 8,
+              h: this.getSize() / 8
+            } : null);
+            x && m.addAll?.(v, p, x, x), h = C;
+          }
+        }
+      }
+      for (const P of u) {
+        const v = this.board[P];
+        if (v) {
+          if (y.captured.push({
+            square: P,
+            type: v.type
+          }), t && this.getDefaultAnimation() ? r.addDelayedPieceClear(h.id, v.id) : r.getLayer("staticPieces").removeAll?.(v.id), v.square) {
+            const C = this.activePiecesPool[v.type].get(
+              v.square.notation
+            );
+            this.helpers.pieceHelper.removeCache(P), this.activePiecesPool[v.type].delete(v.square.notation), C && this.inactivePiecesPool[v.type].push(C);
+            const p = this.piecesBoard.get(v.id);
+            p && (p.square = null);
+          }
+          this.deleteIntervalRefVal(v.id);
+        }
+      }
+      c || (h.square = f, this.activePiecesPool[h.type].set(o, h.id), this.piecesBoard.set(h.id, h)), this.activePiecesPool[h.type].delete(a), this.board[o] = h, delete this.board[a];
+      const g = this.getInternalRefVal(h.id);
+      this.helpers.pieceHelper.updateCache(a, o, {
+        id: h.id,
+        piece: g
+      }), i.push(y);
+    }
+    this.undoStack.push({ undo: i, redo: n }), await this.refreshCanvases({
+      board: !1,
+      staticPieces: !0,
+      overlay: !0,
+      underlay: !0,
+      dynamicPieces: !0
+    });
+  }
+  async undo() {
+    const e = this.undoStack.pop();
+    if (!e) return !1;
+    const t = this.renderer.getLayerManager();
+    for (const r of e.undo) {
+      const { from: n, to: i, moved: s, promoted: a, captured: o } = r;
+      let c = this.board[r.from];
+      const u = {
+        file: r.to.charAt(0),
+        rank: parseInt(r.to.charAt(1)),
+        notation: r.to
+      };
+      if (a) {
+        const y = s, f = this.inactivePiecesPool[y].shift();
+        if (f) {
+          const g = this.piecesBoard.get(f);
+          if (g) {
+            const P = {
+              square: c.square,
+              type: y,
+              x: this.getInternalRefVal(c.id).x,
+              y: this.getInternalRefVal(c.id).y
+            };
+            this.setInternalRefVal(f, P);
+            const v = t.getLayer("staticPieces"), C = v.getCoords(c.id), p = b.squareToCoords(
+              u,
+              this.getSize() / 8,
+              this.getIsBlackView()
+            );
+            c.square = null, g.square = u, this.piecesBoard.set(c.id, c), this.inactivePiecesPool[c.type].push(c.id), this.activePiecesPool[c.type].delete(r.from), this.activePiecesPool[y].set(r.to, g.id), this.piecesBoard.set(f, g), this.deleteIntervalRefVal(c.id), v.removeAll?.(c.id);
+            const m = C || (p ? {
+              x: p.x,
+              y: p.y,
+              w: this.getSize() / 8,
+              h: this.getSize() / 8
+            } : null);
+            m && v.addAll?.(f, P, m, m), c = g;
+          }
+        }
+      }
+      a || (c.square = u, this.activePiecesPool[c.type].set(i, c.id), this.piecesBoard.set(c.id, c)), this.activePiecesPool[c.type].delete(n), this.board[i] = c, delete this.board[n];
+      const h = this.getInternalRefVal(c.id);
+      this.helpers.pieceHelper.updateCache(n, i, {
+        id: c.id,
+        piece: h
+      });
+      for (const y of o) {
+        const { square: f, type: g } = y, P = {
+          file: f.charAt(0),
+          rank: parseInt(f.charAt(1)),
+          notation: f
+        }, v = this.inactivePiecesPool[g].shift();
+        if (!v) continue;
+        const C = this.piecesBoard.get(v);
+        C && (C.square = P, this.activePiecesPool[C.type].set(f, C.id), this.piecesBoard.set(C.id, C), this.board[f] = C);
+      }
+    }
+    return this.redoStack.push([...e.redo]), await this.refreshCanvases({
+      board: !1,
+      staticPieces: !0,
+      overlay: !0,
+      underlay: !0,
+      dynamicPieces: !0
+    }), !0;
+  }
+  async redo() {
+    const e = this.redoStack.pop();
+    return e ? (await this.updateBoardState(e, !0), !0) : !1;
+  }
+  clearRedo() {
+    this.redoStack = [];
+  }
+  clearUndo() {
+    this.undoStack = [];
+  }
+  async initInternalRef() {
+    const e = Math.floor(this.args.size / 8), t = Object.values(this.board), r = this.renderer.getLayerManager();
+    this.renderer.getLayerManager().getLayer("staticPieces").clearPieces?.(t);
+    for (const n of Object.values(this.board)) {
+      const i = this.internalRef[n.id];
+      if (i && i.square?.notation === n.square?.notation)
+        continue;
+      const s = n.square && b.squareToCoords(n.square, e, this.args.isBlackView);
+      if (!s) continue;
+      const a = s.x, o = s.y, c = {
+        x: Math.floor(a),
+        y: Math.floor(o),
+        w: Math.ceil(e),
+        h: Math.ceil(e)
+      }, u = {
+        square: n.square,
+        type: n.type,
+        x: a,
+        y: o
+      };
+      if (this.setInternalRefVal(n.id, u), !i) {
+        r.getLayer("staticPieces").addAll?.(n.id, u, c, c);
+        continue;
+      }
+      if (n.square?.notation !== i.square?.notation)
+        if (!this.getEvents()?.onDrawPiece && this.getDefaultAnimation() && (u.anim = !0, this.setIsMoving(!0)), r.getLayer("dynamicPieces").addAnimation({
+          from: { x: i.x, y: i.y },
+          to: { x: s.x, y: s.y },
+          piece: u,
+          start: performance.now(),
+          id: n.id
+        }), this.getDefaultAnimation())
+          await r.togglePieceLayer(
+            "staticPieces",
+            "dynamicPieces",
+            n.id,
+            !0
+          );
+        else {
+          const h = r.getLayer("staticPieces");
+          h.removeAll?.(n.id), h.addAll?.(n.id, u, c, c);
+        }
+    }
+    this.deleteInternalRef(t);
+  }
+  deleteInternalRef(e) {
+    const t = new Set(e.map((r) => r.id));
+    for (const r in this.internalRef)
+      t.has(r) || delete this.internalRef[r];
+  }
+}
+const ee = /* @__PURE__ */ new WeakMap();
+class Qe {
+  destroyed = !1;
+  fenStream = [];
+  fenStreamDelay = 0;
+  loading = !1;
+  toFlip = !1;
+  toChangeStreamDelay = null;
+  currFlip = !1;
+  pauseFenStream = !1;
+  resizeStream = [];
+  resizing = !1;
+  toResize = !1;
+  debugCountFenStream = 0;
+  isSettingPieceType = !1;
+  toSetPieceType = null;
+  undoing = !1;
+  redoing = !1;
+  isMoving = !1;
+  togglingPause = !1;
+  cachedSize = null;
+  mounted = !1;
+  constructor(e) {
+    ee.set(this, e);
+  }
+  destroy() {
+    ee.delete(this);
+    for (const e of Object.getOwnPropertyNames(this))
+      this[e] = null;
+    this.destroyed = !0;
+  }
+  mount(e) {
+    this.mounted || (this.mounted = !0, e());
+  }
+  getRuntime() {
+    if (this.destroyed) throw new Error("Client destroyed");
+    const e = ee.get(this);
+    if (!e) throw new Error("Runtime not found");
+    return e;
+  }
+  getPieces() {
+    return this.getRuntime()?.getReadonlyInternalRef();
+  }
+  async setBoard(e, t) {
+    t && (this.clearFenStream(), this.pauseFenStream = !1), this.fenStream.push(e), this.loading || (await this.getRuntime()?.resetEvents(!0), this.loadPosition());
+  }
+  clearFenStream() {
+    this.fenStream.splice(0, this.fenStream.length);
+  }
+  loadFenStream(e) {
+    this.destroyed || (this.fenStream.push(...e), !this.loading && !this.pauseFenStream && this.loadPosition());
+  }
+  async loadPosition() {
+    const e = this.getRuntime();
+    if (this.loading || this.destroyed || !e) return;
+    const t = e.getEventEmitter();
+    this.loading = !0;
+    try {
+      for (; !this.pauseFenStream && !this.destroyed && this.fenStream.length; ) {
+        const r = this.fenStream.shift();
+        r && (await this.getRuntime()?.setBoardByFen(r), this.toFlip && (await this.getRuntime()?.setBlackView(
+          !this.getRuntime().getIsBlackView()
+        ), this.toFlip = !1), this.toResize && (await this.sizeStream(), this.toResize = !1), this.toSetPieceType !== null && (await this.setPieceType(this.toSetPieceType, !0), this.toSetPieceType = null), this.fenStreamDelay > 0 && await this.delay(this.fenStreamDelay), this.toChangeStreamDelay !== null && (this.fenStreamDelay = this.toChangeStreamDelay, this.toChangeStreamDelay = null));
+      }
+    } finally {
+      this.destroyed || (this.fenStream.length <= 0 && (this.debugCountFenStream = 0), this.loading = !1, this.fenStream.length && !this.pauseFenStream ? queueMicrotask(() => this.loadPosition()) : this.fenStream.length || t?.emit("onFenStreamLoaded"));
+    }
+  }
+  getIsLoadingFenStream() {
+    return this.fenStream.length > 0;
+  }
+  setFenStreamDelay(e) {
+    this.loading ? this.toChangeStreamDelay = e : this.fenStreamDelay = e;
+  }
+  delay(e) {
+    return new Promise((t) => setTimeout(t, e));
+  }
+  async togglePause() {
+    const e = this.getRuntime();
+    if (!e || this.togglingPause) return this.pauseFenStream;
+    try {
+      return this.togglingPause = !0, this.pauseFenStream = !this.pauseFenStream, !this.pauseFenStream && !this.loading && (await e.resetEvents(!0), this.loadPosition()), !this.pauseFenStream;
+    } finally {
+      this.togglingPause = !1;
+    }
+  }
+  getBoard() {
+    return b.parseBoard(this.getRuntime().getBoard());
+  }
+  async flip() {
+    !this.fenStream.length || this.pauseFenStream ? await this.getRuntime()?.setBlackView(
+      !this.getRuntime().getIsBlackView()
+    ) : this.toFlip = !0, this.cachedSize = null;
+  }
+  updateSize(e) {
+    if (this.resizeStream.push(e), !this.resizing) {
+      if (this.loading) {
+        this.toResize = !0;
+        return;
+      }
+      this.sizeStream();
+    }
+  }
+  async sizeStream() {
+    if (!this.resizing) {
+      this.resizing = !0;
+      try {
+        for (; !this.destroyed && this.resizeStream.length; ) {
+          const e = this.resizeStream.shift();
+          if (e != null)
+            try {
+              await this.getRuntime?.().setSize(e);
+            } catch (t) {
+              console.error("Resize failed:", e, t);
+            }
+        }
+      } finally {
+        if (this.destroyed) return;
+        this.resizing = !1, this.cachedSize = null, this.resizeStream.length && queueMicrotask(() => this.sizeStream());
+      }
+    }
+  }
+  getPieceAt(e) {
+    const t = this.getRuntime();
+    if (!t) return null;
+    const r = t.getInternalRefObj(), n = Object.entries(r).find(
+      ([a, o]) => o.square?.notation === e
+    );
+    if (!n) return null;
+    const [i, s] = n;
+    return { id: i, piece: s };
+  }
+  async undo() {
+    const e = this.getRuntime();
+    if (!e || this.undoing) return !1;
+    this.undoing = !0;
+    try {
+      return await e.undo();
+    } finally {
+      this.undoing = !1;
+    }
+  }
+  async redo() {
+    const e = this.getRuntime();
+    if (!e || this.redoing) return !1;
+    this.redoing = !0;
+    try {
+      return await e.redo();
+    } finally {
+      this.redoing = !1;
+    }
+  }
+  getSquareCoords(e) {
+    const t = this.getRuntime();
+    if (!t) return null;
+    const r = b.notationToSquare(e);
+    if (!r) return null;
+    const n = b.squareToCoords(
+      r,
+      t.getSize() / 8,
+      t.getIsBlackView()
+    );
+    return n || null;
+  }
+  toggleHoverScaling() {
+    const e = this.getRuntime();
+    e && e.toggleHoverScaling();
+  }
+  toggleHoverScale(e) {
+    const t = this.getRuntime();
+    t && t.toggleHoverScale(e);
+  }
+  toggleHoverHighlight() {
+    const e = this.getRuntime();
+    e && e.toggleHoverHighlight();
+  }
+  getSize() {
+    const e = this.getRuntime();
+    if (!e) return null;
+    if (this.cachedSize !== null) return this.cachedSize;
+    const t = e.getSize(), r = { size: t, squareSize: t / 8 };
+    return this.cachedSize = r, r;
+  }
+  async makeMove(e) {
+    const t = this.getRuntime();
+    if (!t || this.isMoving) return !1;
+    this.isMoving = !0;
+    try {
+      return await t.resetEvents(!1), await t.updateBoardState(e, !0), !0;
+    } finally {
+      this.isMoving = !1;
+    }
+  }
+  async setPieceType(e, t) {
+    const r = this.getRuntime();
+    if (this.loading && !t) {
+      this.toSetPieceType = e;
+      return;
+    }
+    if (!(!r || this.isSettingPieceType || r.getIsMoving())) {
+      this.isSettingPieceType = !0;
+      try {
+        await r.setPieceImages(e);
+      } finally {
+        this.isSettingPieceType = !1;
+      }
+    }
+  }
+  getEventEmitter() {
+    const e = this.getRuntime();
+    return e ? e.getEventEmitter() : null;
+  }
+  getPiecesImage() {
+    const e = this.getRuntime();
+    if (!e) return null;
+    const t = e.getPieceStyle();
+    return t || null;
+  }
+}
+function Ue(d, e) {
+  return {
+    loadPosition: (t, r) => {
+      d.current && d.current.setBoard(t, r);
+    },
+    flip: () => {
+      d.current && d.current.flip();
+    },
+    getBoard: () => d.current ? d.current.getBoard() : null,
+    getSquareCoords: (t) => d.current ? d.current.getSquareCoords(t) : null,
+    togglePause: async () => d.current ? await d.current.togglePause() : null,
+    loadFenStream: (t) => {
+      d.current && d.current.loadFenStream(t);
+    },
+    setfenStreamDelay: (t) => {
+      d.current && d.current.setFenStreamDelay(t);
+    },
+    updateSize: (t) => {
+      d.current && d.current.updateSize(t);
+    },
+    getPieceAt: (t) => d.current ? d.current.getPieceAt(t) : null,
+    setPieceType: (t) => {
+      d.current && d.current.setPieceType(t);
+    },
+    undo: async () => d.current ? await d.current.undo() : !1,
+    redo: async () => d.current ? await d.current.redo() : !1,
+    toggleHoverScaling: () => {
+      d.current && d.current.toggleHoverScaling();
+    },
+    toggleHoverScale: (t) => {
+      d.current && d.current.toggleHoverScale(t);
+    },
+    toggleHoverHighlight: () => {
+      d.current && d.current.toggleHoverHighlight();
+    },
+    getSize: () => d.current ? d.current.getSize() : null,
+    makeMove: (t) => d.current ? d.current.makeMove(t) : !1,
+    getEventEmitter: () => d.current ? d.current.getEventEmitter() : null,
+    getPiecesImage: () => d.current ? d.current.getPiecesImage() : null,
+    mount: (t) => {
+      if (!d.current) {
+        e.current = t ?? null;
+        return;
+      }
+      d.current.mount(t), e.current = null;
+    },
+    getIsLoadingFenStream: () => d.current ? d.current.getIsLoadingFenStream() : null,
+    flushPendingMount: () => {
+      !d.current || e.current === null || d.current.mount(e.current);
+    }
+  };
+}
+const Xe = oe.forwardRef(
+  ({ config: d, onMove: e, onUpdate: t }, r) => {
+    const { pieceConfig: n, size: i } = d, s = O(null), a = O(null), o = O(null), c = O(null), u = O(null), h = O(null), y = O(null), f = O(null), g = le(
+      () => Ue(y, f),
+      []
+    ), P = O(0);
+    return ue(() => {
+      let v = null, C = null;
+      const p = ++P.current;
+      if (s.current && a.current && o.current && c.current && u.current) {
+        const m = {
+          ...d,
+          size: Math.floor(i / 8) * 8,
+          onMove: e,
+          onUpdate: t,
+          canvasLayers: new me(
+            s,
+            a,
+            c,
+            o,
+            u,
+            Math.floor(i / 8) * 8
+          ),
+          pieceStyle: n.piecesImage,
+          mode: "2d"
+        };
+        (async () => {
+          const w = await te.create(m);
+          if (P.current !== p) {
+            w.destroy();
+            return;
+          }
+          w.mount(), v = w, h.current = v, C = new Qe(v), y.current = C, g.flushPendingMount?.();
+        })();
+      }
+      return () => {
+        P.current++, v?.destroy(), C?.destroy(), v = null, C = null, h.current = null, y.current = null, f.current = null;
+      };
+    }, []), he(r, () => g), /* @__PURE__ */ H.jsx(
+      ye,
+      {
+        boardRuntime: h,
+        boardRef: s,
+        staticPiecesRef: a,
+        overlayRef: o,
+        underlayRef: c,
+        dynamicPiecesRef: u,
+        size: Math.floor(i / 8) * 8
+      }
+    );
+  }
+), Ke = {
+  onPointerSelect: "onPointerSelect",
+  onPointerHover: "onPointerHover",
+  onPointerDragStart: "onPointerDragStart",
+  onPointerDrag: "onPointerDrag",
+  onPointerDrop: "onPointerDrop",
+  onAnimationFrame: "onAnimationFrame",
+  onDrawPiece: "onDrawPiece",
+  onDrawBoard: "onDrawBoard",
+  onDrawOverlay: "onDrawOverlay",
+  onDrawUnderlay: "onDrawUnderlay"
+};
+export {
+  Xe as Board,
+  Ke as EVENTS,
+  ae as pieceKey
+};
+//# sourceMappingURL=check-board.es.js.map