@ankhorage/zora 21.1.4 → 22.0.1

package/web-dist/chunks/Accordion-784f23tq.js

@@ -0,0 +1,3813 @@
+'use client';
+import {
+  require_cjs
+} from "./Accordion-7hn324r1.js";
+import {
+  withZoraThemeScope
+} from "./Accordion-k3bc4kad.js";
+import {
+  useZoraTheme2
+} from "./Accordion-7zfskq1s.js";
+import {
+  __toESM
+} from "./Accordion-9qvmwkxe.js";
+
+// src/features/chess/adapters/inbound/ChessBoard.tsx
+var import_react_native = __toESM(require_cjs(), 1);
+
+// node_modules/chess.js/dist/esm/chess.js
+function rootNode(comment) {
+  return comment !== null ? { comment, variations: [] } : { variations: [] };
+}
+function node(move, suffix, nag, comment, variations) {
+  const node = { move, variations };
+  if (suffix) {
+    node.suffix = suffix;
+  }
+  if (nag) {
+    node.nag = nag;
+  }
+  if (comment !== null) {
+    node.comment = comment;
+  }
+  return node;
+}
+function lineToTree(...nodes) {
+  const [root, ...rest] = nodes;
+  let parent = root;
+  for (const child of rest) {
+    if (child !== null) {
+      parent.variations = [child, ...child.variations];
+      child.variations = [];
+      parent = child;
+    }
+  }
+  return root;
+}
+function pgn(headers, game) {
+  if (game.marker && game.marker.comment) {
+    let node = game.root;
+    while (true) {
+      const next = node.variations[0];
+      if (!next) {
+        node.comment = game.marker.comment;
+        break;
+      }
+      node = next;
+    }
+  }
+  return {
+    headers,
+    root: game.root,
+    result: (game.marker && game.marker.result) ?? undefined
+  };
+}
+function peg$subclass(child, parent) {
+  function C() {
+    this.constructor = child;
+  }
+  C.prototype = parent.prototype;
+  child.prototype = new C;
+}
+function peg$SyntaxError(message, expected, found, location) {
+  var self = Error.call(this, message);
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(self, peg$SyntaxError.prototype);
+  }
+  self.expected = expected;
+  self.found = found;
+  self.location = location;
+  self.name = "SyntaxError";
+  return self;
+}
+peg$subclass(peg$SyntaxError, Error);
+function peg$padEnd(str, targetLength, padString) {
+  padString = padString || " ";
+  if (str.length > targetLength) {
+    return str;
+  }
+  targetLength -= str.length;
+  padString += padString.repeat(targetLength);
+  return str + padString.slice(0, targetLength);
+}
+peg$SyntaxError.prototype.format = function(sources) {
+  var str = "Error: " + this.message;
+  if (this.location) {
+    var src = null;
+    var k;
+    for (k = 0;k < sources.length; k++) {
+      if (sources[k].source === this.location.source) {
+        src = sources[k].text.split(/\r\n|\n|\r/g);
+        break;
+      }
+    }
+    var s = this.location.start;
+    var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s;
+    var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
+    if (src) {
+      var e = this.location.end;
+      var filler = peg$padEnd("", offset_s.line.toString().length, " ");
+      var line = src[s.line - 1];
+      var last = s.line === e.line ? e.column : line.length + 1;
+      var hatLen = last - s.column || 1;
+      str += `
+ --> ` + loc + `
+` + filler + ` |
+` + offset_s.line + " | " + line + `
+` + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^");
+    } else {
+      str += `
+ at ` + loc;
+    }
+  }
+  return str;
+};
+peg$SyntaxError.buildMessage = function(expected, found) {
+  var DESCRIBE_EXPECTATION_FNS = {
+    literal: function(expectation) {
+      return '"' + literalEscape(expectation.text) + '"';
+    },
+    class: function(expectation) {
+      var escapedParts = expectation.parts.map(function(part) {
+        return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part);
+      });
+      return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]";
+    },
+    any: function() {
+      return "any character";
+    },
+    end: function() {
+      return "end of input";
+    },
+    other: function(expectation) {
+      return expectation.description;
+    }
+  };
+  function hex(ch) {
+    return ch.charCodeAt(0).toString(16).toUpperCase();
+  }
+  function literalEscape(s) {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) {
+      return "\\x0" + hex(ch);
+    }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) {
+      return "\\x" + hex(ch);
+    });
+  }
+  function classEscape(s) {
+    return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) {
+      return "\\x0" + hex(ch);
+    }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) {
+      return "\\x" + hex(ch);
+    });
+  }
+  function describeExpectation(expectation) {
+    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+  }
+  function describeExpected(expected) {
+    var descriptions = expected.map(describeExpectation);
+    var i, j;
+    descriptions.sort();
+    if (descriptions.length > 0) {
+      for (i = 1, j = 1;i < descriptions.length; i++) {
+        if (descriptions[i - 1] !== descriptions[i]) {
+          descriptions[j] = descriptions[i];
+          j++;
+        }
+      }
+      descriptions.length = j;
+    }
+    switch (descriptions.length) {
+      case 1:
+        return descriptions[0];
+      case 2:
+        return descriptions[0] + " or " + descriptions[1];
+      default:
+        return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
+    }
+  }
+  function describeFound(found) {
+    return found ? '"' + literalEscape(found) + '"' : "end of input";
+  }
+  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+};
+function peg$parse(input, options) {
+  options = options !== undefined ? options : {};
+  var peg$FAILED = {};
+  var peg$source = options.grammarSource;
+  var peg$startRuleFunctions = { pgn: peg$parsepgn };
+  var peg$startRuleFunction = peg$parsepgn;
+  var peg$c0 = "[";
+  var peg$c1 = '"';
+  var peg$c2 = "]";
+  var peg$c3 = ".";
+  var peg$c4 = "O-O-O";
+  var peg$c5 = "O-O";
+  var peg$c6 = "0-0-0";
+  var peg$c7 = "0-0";
+  var peg$c8 = "$";
+  var peg$c9 = "{";
+  var peg$c10 = "}";
+  var peg$c11 = ";";
+  var peg$c12 = "(";
+  var peg$c13 = ")";
+  var peg$c14 = "1-0";
+  var peg$c15 = "0-1";
+  var peg$c16 = "1/2-1/2";
+  var peg$c17 = "*";
+  var peg$r0 = /^[a-zA-Z]/;
+  var peg$r1 = /^[^"]/;
+  var peg$r2 = /^[0-9]/;
+  var peg$r3 = /^[.]/;
+  var peg$r4 = /^[a-zA-Z1-8\-=]/;
+  var peg$r5 = /^[+#]/;
+  var peg$r6 = /^[!?]/;
+  var peg$r7 = /^[^}]/;
+  var peg$r8 = /^[^\r\n]/;
+  var peg$r9 = /^[ \t\r\n]/;
+  var peg$e0 = peg$otherExpectation("tag pair");
+  var peg$e1 = peg$literalExpectation("[", false);
+  var peg$e2 = peg$literalExpectation('"', false);
+  var peg$e3 = peg$literalExpectation("]", false);
+  var peg$e4 = peg$otherExpectation("tag name");
+  var peg$e5 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false);
+  var peg$e6 = peg$otherExpectation("tag value");
+  var peg$e7 = peg$classExpectation(['"'], true, false);
+  var peg$e8 = peg$otherExpectation("move number");
+  var peg$e9 = peg$classExpectation([["0", "9"]], false, false);
+  var peg$e10 = peg$literalExpectation(".", false);
+  var peg$e11 = peg$classExpectation(["."], false, false);
+  var peg$e12 = peg$otherExpectation("standard algebraic notation");
+  var peg$e13 = peg$literalExpectation("O-O-O", false);
+  var peg$e14 = peg$literalExpectation("O-O", false);
+  var peg$e15 = peg$literalExpectation("0-0-0", false);
+  var peg$e16 = peg$literalExpectation("0-0", false);
+  var peg$e17 = peg$classExpectation([["a", "z"], ["A", "Z"], ["1", "8"], "-", "="], false, false);
+  var peg$e18 = peg$classExpectation(["+", "#"], false, false);
+  var peg$e19 = peg$otherExpectation("suffix annotation");
+  var peg$e20 = peg$classExpectation(["!", "?"], false, false);
+  var peg$e21 = peg$otherExpectation("NAG");
+  var peg$e22 = peg$literalExpectation("$", false);
+  var peg$e23 = peg$otherExpectation("brace comment");
+  var peg$e24 = peg$literalExpectation("{", false);
+  var peg$e25 = peg$classExpectation(["}"], true, false);
+  var peg$e26 = peg$literalExpectation("}", false);
+  var peg$e27 = peg$otherExpectation("rest of line comment");
+  var peg$e28 = peg$literalExpectation(";", false);
+  var peg$e29 = peg$classExpectation(["\r", `
+`], true, false);
+  var peg$e30 = peg$otherExpectation("variation");
+  var peg$e31 = peg$literalExpectation("(", false);
+  var peg$e32 = peg$literalExpectation(")", false);
+  var peg$e33 = peg$otherExpectation("game termination marker");
+  var peg$e34 = peg$literalExpectation("1-0", false);
+  var peg$e35 = peg$literalExpectation("0-1", false);
+  var peg$e36 = peg$literalExpectation("1/2-1/2", false);
+  var peg$e37 = peg$literalExpectation("*", false);
+  var peg$e38 = peg$otherExpectation("whitespace");
+  var peg$e39 = peg$classExpectation([" ", "\t", "\r", `
+`], false, false);
+  var peg$f0 = function(headers, game) {
+    return pgn(headers, game);
+  };
+  var peg$f1 = function(tagPairs) {
+    return Object.fromEntries(tagPairs);
+  };
+  var peg$f2 = function(tagName, tagValue) {
+    return [tagName, tagValue];
+  };
+  var peg$f3 = function(root, marker) {
+    return { root, marker };
+  };
+  var peg$f4 = function(comment, moves) {
+    return lineToTree(rootNode(comment), ...moves.flat());
+  };
+  var peg$f5 = function(san, suffix, nag, comment, variations) {
+    return node(san, suffix, nag, comment, variations);
+  };
+  var peg$f6 = function(nag) {
+    return nag;
+  };
+  var peg$f7 = function(comment) {
+    return comment.replace(/[\r\n]+/g, " ");
+  };
+  var peg$f8 = function(comment) {
+    return comment.trim();
+  };
+  var peg$f9 = function(line) {
+    return line;
+  };
+  var peg$f10 = function(result, comment) {
+    return { result, comment };
+  };
+  var peg$currPos = options.peg$currPos | 0;
+  var peg$posDetailsCache = [{ line: 1, column: 1 }];
+  var peg$maxFailPos = peg$currPos;
+  var peg$maxFailExpected = options.peg$maxFailExpected || [];
+  var peg$silentFails = options.peg$silentFails | 0;
+  var peg$result;
+  if (options.startRule) {
+    if (!(options.startRule in peg$startRuleFunctions)) {
+      throw new Error(`Can't start parsing from rule "` + options.startRule + '".');
+    }
+    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+  }
+  function peg$literalExpectation(text, ignoreCase) {
+    return { type: "literal", text, ignoreCase };
+  }
+  function peg$classExpectation(parts, inverted, ignoreCase) {
+    return { type: "class", parts, inverted, ignoreCase };
+  }
+  function peg$endExpectation() {
+    return { type: "end" };
+  }
+  function peg$otherExpectation(description) {
+    return { type: "other", description };
+  }
+  function peg$computePosDetails(pos) {
+    var details = peg$posDetailsCache[pos];
+    var p;
+    if (details) {
+      return details;
+    } else {
+      if (pos >= peg$posDetailsCache.length) {
+        p = peg$posDetailsCache.length - 1;
+      } else {
+        p = pos;
+        while (!peg$posDetailsCache[--p]) {}
+      }
+      details = peg$posDetailsCache[p];
+      details = {
+        line: details.line,
+        column: details.column
+      };
+      while (p < pos) {
+        if (input.charCodeAt(p) === 10) {
+          details.line++;
+          details.column = 1;
+        } else {
+          details.column++;
+        }
+        p++;
+      }
+      peg$posDetailsCache[pos] = details;
+      return details;
+    }
+  }
+  function peg$computeLocation(startPos, endPos, offset) {
+    var startPosDetails = peg$computePosDetails(startPos);
+    var endPosDetails = peg$computePosDetails(endPos);
+    var res = {
+      source: peg$source,
+      start: {
+        offset: startPos,
+        line: startPosDetails.line,
+        column: startPosDetails.column
+      },
+      end: {
+        offset: endPos,
+        line: endPosDetails.line,
+        column: endPosDetails.column
+      }
+    };
+    return res;
+  }
+  function peg$fail(expected) {
+    if (peg$currPos < peg$maxFailPos) {
+      return;
+    }
+    if (peg$currPos > peg$maxFailPos) {
+      peg$maxFailPos = peg$currPos;
+      peg$maxFailExpected = [];
+    }
+    peg$maxFailExpected.push(expected);
+  }
+  function peg$buildStructuredError(expected, found, location) {
+    return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
+  }
+  function peg$parsepgn() {
+    var s0, s1, s2;
+    s0 = peg$currPos;
+    s1 = peg$parsetagPairSection();
+    s2 = peg$parsemoveTextSection();
+    s0 = peg$f0(s1, s2);
+    return s0;
+  }
+  function peg$parsetagPairSection() {
+    var s0, s1, s2;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = peg$parsetagPair();
+    while (s2 !== peg$FAILED) {
+      s1.push(s2);
+      s2 = peg$parsetagPair();
+    }
+    s2 = peg$parse_();
+    s0 = peg$f1(s1);
+    return s0;
+  }
+  function peg$parsetagPair() {
+    var s0, s2, s4, s6, s7, s8, s10;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    peg$parse_();
+    if (input.charCodeAt(peg$currPos) === 91) {
+      s2 = peg$c0;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e1);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      peg$parse_();
+      s4 = peg$parsetagName();
+      if (s4 !== peg$FAILED) {
+        peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 34) {
+          s6 = peg$c1;
+          peg$currPos++;
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e2);
+          }
+        }
+        if (s6 !== peg$FAILED) {
+          s7 = peg$parsetagValue();
+          if (input.charCodeAt(peg$currPos) === 34) {
+            s8 = peg$c1;
+            peg$currPos++;
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e2);
+            }
+          }
+          if (s8 !== peg$FAILED) {
+            peg$parse_();
+            if (input.charCodeAt(peg$currPos) === 93) {
+              s10 = peg$c2;
+              peg$currPos++;
+            } else {
+              s10 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e3);
+              }
+            }
+            if (s10 !== peg$FAILED) {
+              s0 = peg$f2(s4, s7);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e0);
+      }
+    }
+    return s0;
+  }
+  function peg$parsetagName() {
+    var s0, s1, s2;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = input.charAt(peg$currPos);
+    if (peg$r0.test(s2)) {
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e5);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      while (s2 !== peg$FAILED) {
+        s1.push(s2);
+        s2 = input.charAt(peg$currPos);
+        if (peg$r0.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e5);
+          }
+        }
+      }
+    } else {
+      s1 = peg$FAILED;
+    }
+    if (s1 !== peg$FAILED) {
+      s0 = input.substring(s0, peg$currPos);
+    } else {
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e4);
+      }
+    }
+    return s0;
+  }
+  function peg$parsetagValue() {
+    var s0, s1, s2;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = input.charAt(peg$currPos);
+    if (peg$r1.test(s2)) {
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e7);
+      }
+    }
+    while (s2 !== peg$FAILED) {
+      s1.push(s2);
+      s2 = input.charAt(peg$currPos);
+      if (peg$r1.test(s2)) {
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e7);
+        }
+      }
+    }
+    s0 = input.substring(s0, peg$currPos);
+    peg$silentFails--;
+    s1 = peg$FAILED;
+    if (peg$silentFails === 0) {
+      peg$fail(peg$e6);
+    }
+    return s0;
+  }
+  function peg$parsemoveTextSection() {
+    var s0, s1, s3;
+    s0 = peg$currPos;
+    s1 = peg$parseline();
+    peg$parse_();
+    s3 = peg$parsegameTerminationMarker();
+    if (s3 === peg$FAILED) {
+      s3 = null;
+    }
+    peg$parse_();
+    s0 = peg$f3(s1, s3);
+    return s0;
+  }
+  function peg$parseline() {
+    var s0, s1, s2, s3;
+    s0 = peg$currPos;
+    s1 = peg$parsecomment();
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    s2 = [];
+    s3 = peg$parsemove();
+    while (s3 !== peg$FAILED) {
+      s2.push(s3);
+      s3 = peg$parsemove();
+    }
+    s0 = peg$f4(s1, s2);
+    return s0;
+  }
+  function peg$parsemove() {
+    var s0, s4, s5, s6, s7, s8, s9, s10;
+    s0 = peg$currPos;
+    peg$parse_();
+    peg$parsemoveNumber();
+    peg$parse_();
+    s4 = peg$parsesan();
+    if (s4 !== peg$FAILED) {
+      s5 = peg$parsesuffixAnnotation();
+      if (s5 === peg$FAILED) {
+        s5 = null;
+      }
+      s6 = [];
+      s7 = peg$parsenag();
+      while (s7 !== peg$FAILED) {
+        s6.push(s7);
+        s7 = peg$parsenag();
+      }
+      s7 = peg$parse_();
+      s8 = peg$parsecomment();
+      if (s8 === peg$FAILED) {
+        s8 = null;
+      }
+      s9 = [];
+      s10 = peg$parsevariation();
+      while (s10 !== peg$FAILED) {
+        s9.push(s10);
+        s10 = peg$parsevariation();
+      }
+      s0 = peg$f5(s4, s5, s6, s8, s9);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parsemoveNumber() {
+    var s0, s1, s2, s3, s4, s5;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = input.charAt(peg$currPos);
+    if (peg$r2.test(s2)) {
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e9);
+      }
+    }
+    while (s2 !== peg$FAILED) {
+      s1.push(s2);
+      s2 = input.charAt(peg$currPos);
+      if (peg$r2.test(s2)) {
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e9);
+        }
+      }
+    }
+    if (input.charCodeAt(peg$currPos) === 46) {
+      s2 = peg$c3;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e10);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$parse_();
+      s4 = [];
+      s5 = input.charAt(peg$currPos);
+      if (peg$r3.test(s5)) {
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e11);
+        }
+      }
+      while (s5 !== peg$FAILED) {
+        s4.push(s5);
+        s5 = input.charAt(peg$currPos);
+        if (peg$r3.test(s5)) {
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e11);
+          }
+        }
+      }
+      s1 = [s1, s2, s3, s4];
+      s0 = s1;
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e8);
+      }
+    }
+    return s0;
+  }
+  function peg$parsesan() {
+    var s0, s1, s2, s3, s4, s5;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    if (input.substr(peg$currPos, 5) === peg$c4) {
+      s2 = peg$c4;
+      peg$currPos += 5;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e13);
+      }
+    }
+    if (s2 === peg$FAILED) {
+      if (input.substr(peg$currPos, 3) === peg$c5) {
+        s2 = peg$c5;
+        peg$currPos += 3;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e14);
+        }
+      }
+      if (s2 === peg$FAILED) {
+        if (input.substr(peg$currPos, 5) === peg$c6) {
+          s2 = peg$c6;
+          peg$currPos += 5;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e15);
+          }
+        }
+        if (s2 === peg$FAILED) {
+          if (input.substr(peg$currPos, 3) === peg$c7) {
+            s2 = peg$c7;
+            peg$currPos += 3;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e16);
+            }
+          }
+          if (s2 === peg$FAILED) {
+            s2 = peg$currPos;
+            s3 = input.charAt(peg$currPos);
+            if (peg$r0.test(s3)) {
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e5);
+              }
+            }
+            if (s3 !== peg$FAILED) {
+              s4 = [];
+              s5 = input.charAt(peg$currPos);
+              if (peg$r4.test(s5)) {
+                peg$currPos++;
+              } else {
+                s5 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                  peg$fail(peg$e17);
+                }
+              }
+              if (s5 !== peg$FAILED) {
+                while (s5 !== peg$FAILED) {
+                  s4.push(s5);
+                  s5 = input.charAt(peg$currPos);
+                  if (peg$r4.test(s5)) {
+                    peg$currPos++;
+                  } else {
+                    s5 = peg$FAILED;
+                    if (peg$silentFails === 0) {
+                      peg$fail(peg$e17);
+                    }
+                  }
+                }
+              } else {
+                s4 = peg$FAILED;
+              }
+              if (s4 !== peg$FAILED) {
+                s3 = [s3, s4];
+                s2 = s3;
+              } else {
+                peg$currPos = s2;
+                s2 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s2;
+              s2 = peg$FAILED;
+            }
+          }
+        }
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = input.charAt(peg$currPos);
+      if (peg$r5.test(s3)) {
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e18);
+        }
+      }
+      if (s3 === peg$FAILED) {
+        s3 = null;
+      }
+      s2 = [s2, s3];
+      s1 = s2;
+    } else {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    }
+    if (s1 !== peg$FAILED) {
+      s0 = input.substring(s0, peg$currPos);
+    } else {
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e12);
+      }
+    }
+    return s0;
+  }
+  function peg$parsesuffixAnnotation() {
+    var s0, s1, s2;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = input.charAt(peg$currPos);
+    if (peg$r6.test(s2)) {
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e20);
+      }
+    }
+    while (s2 !== peg$FAILED) {
+      s1.push(s2);
+      if (s1.length >= 2) {
+        s2 = peg$FAILED;
+      } else {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r6.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e20);
+          }
+        }
+      }
+    }
+    if (s1.length < 1) {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    } else {
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e19);
+      }
+    }
+    return s0;
+  }
+  function peg$parsenag() {
+    var s0, s2, s3, s4, s5;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    peg$parse_();
+    if (input.charCodeAt(peg$currPos) === 36) {
+      s2 = peg$c8;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e22);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      s4 = [];
+      s5 = input.charAt(peg$currPos);
+      if (peg$r2.test(s5)) {
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e9);
+        }
+      }
+      if (s5 !== peg$FAILED) {
+        while (s5 !== peg$FAILED) {
+          s4.push(s5);
+          s5 = input.charAt(peg$currPos);
+          if (peg$r2.test(s5)) {
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e9);
+            }
+          }
+        }
+      } else {
+        s4 = peg$FAILED;
+      }
+      if (s4 !== peg$FAILED) {
+        s3 = input.substring(s3, peg$currPos);
+      } else {
+        s3 = s4;
+      }
+      if (s3 !== peg$FAILED) {
+        s0 = peg$f6(s3);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e21);
+      }
+    }
+    return s0;
+  }
+  function peg$parsecomment() {
+    var s0;
+    s0 = peg$parsebraceComment();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parserestOfLineComment();
+    }
+    return s0;
+  }
+  function peg$parsebraceComment() {
+    var s0, s1, s2, s3, s4;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 123) {
+      s1 = peg$c9;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e24);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = [];
+      s4 = input.charAt(peg$currPos);
+      if (peg$r7.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e25);
+        }
+      }
+      while (s4 !== peg$FAILED) {
+        s3.push(s4);
+        s4 = input.charAt(peg$currPos);
+        if (peg$r7.test(s4)) {
+          peg$currPos++;
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e25);
+          }
+        }
+      }
+      s2 = input.substring(s2, peg$currPos);
+      if (input.charCodeAt(peg$currPos) === 125) {
+        s3 = peg$c10;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e26);
+        }
+      }
+      if (s3 !== peg$FAILED) {
+        s0 = peg$f7(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e23);
+      }
+    }
+    return s0;
+  }
+  function peg$parserestOfLineComment() {
+    var s0, s1, s2, s3, s4;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 59) {
+      s1 = peg$c11;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e28);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$currPos;
+      s3 = [];
+      s4 = input.charAt(peg$currPos);
+      if (peg$r8.test(s4)) {
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e29);
+        }
+      }
+      while (s4 !== peg$FAILED) {
+        s3.push(s4);
+        s4 = input.charAt(peg$currPos);
+        if (peg$r8.test(s4)) {
+          peg$currPos++;
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e29);
+          }
+        }
+      }
+      s2 = input.substring(s2, peg$currPos);
+      s0 = peg$f8(s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e27);
+      }
+    }
+    return s0;
+  }
+  function peg$parsevariation() {
+    var s0, s2, s3, s5;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    peg$parse_();
+    if (input.charCodeAt(peg$currPos) === 40) {
+      s2 = peg$c12;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e31);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$parseline();
+      if (s3 !== peg$FAILED) {
+        peg$parse_();
+        if (input.charCodeAt(peg$currPos) === 41) {
+          s5 = peg$c13;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e32);
+          }
+        }
+        if (s5 !== peg$FAILED) {
+          s0 = peg$f9(s3);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e30);
+      }
+    }
+    return s0;
+  }
+  function peg$parsegameTerminationMarker() {
+    var s0, s1, s3;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 3) === peg$c14) {
+      s1 = peg$c14;
+      peg$currPos += 3;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e34);
+      }
+    }
+    if (s1 === peg$FAILED) {
+      if (input.substr(peg$currPos, 3) === peg$c15) {
+        s1 = peg$c15;
+        peg$currPos += 3;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e35);
+        }
+      }
+      if (s1 === peg$FAILED) {
+        if (input.substr(peg$currPos, 7) === peg$c16) {
+          s1 = peg$c16;
+          peg$currPos += 7;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e36);
+          }
+        }
+        if (s1 === peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 42) {
+            s1 = peg$c17;
+            peg$currPos++;
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e37);
+            }
+          }
+        }
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$parse_();
+      s3 = peg$parsecomment();
+      if (s3 === peg$FAILED) {
+        s3 = null;
+      }
+      s0 = peg$f10(s1, s3);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e33);
+      }
+    }
+    return s0;
+  }
+  function peg$parse_() {
+    var s0, s1;
+    peg$silentFails++;
+    s0 = [];
+    s1 = input.charAt(peg$currPos);
+    if (peg$r9.test(s1)) {
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e39);
+      }
+    }
+    while (s1 !== peg$FAILED) {
+      s0.push(s1);
+      s1 = input.charAt(peg$currPos);
+      if (peg$r9.test(s1)) {
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e39);
+        }
+      }
+    }
+    peg$silentFails--;
+    s1 = peg$FAILED;
+    if (peg$silentFails === 0) {
+      peg$fail(peg$e38);
+    }
+    return s0;
+  }
+  peg$result = peg$startRuleFunction();
+  if (options.peg$library) {
+    return {
+      peg$result,
+      peg$currPos,
+      peg$FAILED,
+      peg$maxFailExpected,
+      peg$maxFailPos
+    };
+  }
+  if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+    return peg$result;
+  } else {
+    if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+      peg$fail(peg$endExpectation());
+    }
+    throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
+  }
+}
+var MASK64 = 0xffffffffffffffffn;
+function rotl(x, k) {
+  return (x << k | x >> 64n - k) & 0xffffffffffffffffn;
+}
+function wrappingMul(x, y) {
+  return x * y & MASK64;
+}
+function xoroshiro128(state) {
+  return function() {
+    let s0 = BigInt(state & MASK64);
+    let s1 = BigInt(state >> 64n & MASK64);
+    const result = wrappingMul(rotl(wrappingMul(s0, 5n), 7n), 9n);
+    s1 ^= s0;
+    s0 = (rotl(s0, 24n) ^ s1 ^ s1 << 16n) & MASK64;
+    s1 = rotl(s1, 37n);
+    state = s1 << 64n | s0;
+    return result;
+  };
+}
+var rand = xoroshiro128(0xa187eb39cdcaed8f31c4b365b102e01en);
+var PIECE_KEYS = Array.from({ length: 2 }, () => Array.from({ length: 6 }, () => Array.from({ length: 128 }, () => rand())));
+var EP_KEYS = Array.from({ length: 8 }, () => rand());
+var CASTLING_KEYS = Array.from({ length: 16 }, () => rand());
+var SIDE_KEY = rand();
+var WHITE = "w";
+var BLACK = "b";
+var PAWN = "p";
+var KNIGHT = "n";
+var BISHOP = "b";
+var ROOK = "r";
+var QUEEN = "q";
+var KING = "k";
+var DEFAULT_POSITION = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+
+class Move {
+  color;
+  from;
+  to;
+  piece;
+  captured;
+  promotion;
+  flags;
+  san;
+  lan;
+  before;
+  after;
+  constructor(chess, internal) {
+    const { color, piece, from, to, flags, captured, promotion } = internal;
+    const fromAlgebraic = algebraic(from);
+    const toAlgebraic = algebraic(to);
+    this.color = color;
+    this.piece = piece;
+    this.from = fromAlgebraic;
+    this.to = toAlgebraic;
+    this.san = chess["_moveToSan"](internal, chess["_moves"]({ legal: true }));
+    this.lan = fromAlgebraic + toAlgebraic;
+    this.before = chess.fen();
+    chess["_makeMove"](internal);
+    this.after = chess.fen();
+    chess["_undoMove"]();
+    this.flags = "";
+    for (const flag in BITS) {
+      if (BITS[flag] & flags) {
+        this.flags += FLAGS[flag];
+      }
+    }
+    if (captured) {
+      this.captured = captured;
+    }
+    if (promotion) {
+      this.promotion = promotion;
+      this.lan += promotion;
+    }
+  }
+  isCapture() {
+    return this.flags.indexOf(FLAGS["CAPTURE"]) > -1;
+  }
+  isPromotion() {
+    return this.flags.indexOf(FLAGS["PROMOTION"]) > -1;
+  }
+  isEnPassant() {
+    return this.flags.indexOf(FLAGS["EP_CAPTURE"]) > -1;
+  }
+  isKingsideCastle() {
+    return this.flags.indexOf(FLAGS["KSIDE_CASTLE"]) > -1;
+  }
+  isQueensideCastle() {
+    return this.flags.indexOf(FLAGS["QSIDE_CASTLE"]) > -1;
+  }
+  isBigPawn() {
+    return this.flags.indexOf(FLAGS["BIG_PAWN"]) > -1;
+  }
+}
+var EMPTY = -1;
+var FLAGS = {
+  NORMAL: "n",
+  CAPTURE: "c",
+  BIG_PAWN: "b",
+  EP_CAPTURE: "e",
+  PROMOTION: "p",
+  KSIDE_CASTLE: "k",
+  QSIDE_CASTLE: "q",
+  NULL_MOVE: "-"
+};
+var BITS = {
+  NORMAL: 1,
+  CAPTURE: 2,
+  BIG_PAWN: 4,
+  EP_CAPTURE: 8,
+  PROMOTION: 16,
+  KSIDE_CASTLE: 32,
+  QSIDE_CASTLE: 64,
+  NULL_MOVE: 128
+};
+var SEVEN_TAG_ROSTER = {
+  Event: "?",
+  Site: "?",
+  Date: "????.??.??",
+  Round: "?",
+  White: "?",
+  Black: "?",
+  Result: "*"
+};
+var SUPLEMENTAL_TAGS = {
+  WhiteTitle: null,
+  BlackTitle: null,
+  WhiteElo: null,
+  BlackElo: null,
+  WhiteUSCF: null,
+  BlackUSCF: null,
+  WhiteNA: null,
+  BlackNA: null,
+  WhiteType: null,
+  BlackType: null,
+  EventDate: null,
+  EventSponsor: null,
+  Section: null,
+  Stage: null,
+  Board: null,
+  Opening: null,
+  Variation: null,
+  SubVariation: null,
+  ECO: null,
+  NIC: null,
+  Time: null,
+  UTCTime: null,
+  UTCDate: null,
+  TimeControl: null,
+  SetUp: null,
+  FEN: null,
+  Termination: null,
+  Annotator: null,
+  Mode: null,
+  PlyCount: null
+};
+var HEADER_TEMPLATE = {
+  ...SEVEN_TAG_ROSTER,
+  ...SUPLEMENTAL_TAGS
+};
+var Ox88 = {
+  a8: 0,
+  b8: 1,
+  c8: 2,
+  d8: 3,
+  e8: 4,
+  f8: 5,
+  g8: 6,
+  h8: 7,
+  a7: 16,
+  b7: 17,
+  c7: 18,
+  d7: 19,
+  e7: 20,
+  f7: 21,
+  g7: 22,
+  h7: 23,
+  a6: 32,
+  b6: 33,
+  c6: 34,
+  d6: 35,
+  e6: 36,
+  f6: 37,
+  g6: 38,
+  h6: 39,
+  a5: 48,
+  b5: 49,
+  c5: 50,
+  d5: 51,
+  e5: 52,
+  f5: 53,
+  g5: 54,
+  h5: 55,
+  a4: 64,
+  b4: 65,
+  c4: 66,
+  d4: 67,
+  e4: 68,
+  f4: 69,
+  g4: 70,
+  h4: 71,
+  a3: 80,
+  b3: 81,
+  c3: 82,
+  d3: 83,
+  e3: 84,
+  f3: 85,
+  g3: 86,
+  h3: 87,
+  a2: 96,
+  b2: 97,
+  c2: 98,
+  d2: 99,
+  e2: 100,
+  f2: 101,
+  g2: 102,
+  h2: 103,
+  a1: 112,
+  b1: 113,
+  c1: 114,
+  d1: 115,
+  e1: 116,
+  f1: 117,
+  g1: 118,
+  h1: 119
+};
+var PAWN_OFFSETS = {
+  b: [16, 32, 17, 15],
+  w: [-16, -32, -17, -15]
+};
+var PIECE_OFFSETS = {
+  n: [-18, -33, -31, -14, 18, 33, 31, 14],
+  b: [-17, -15, 17, 15],
+  r: [-16, 1, 16, -1],
+  q: [-17, -16, -15, 1, 17, 16, 15, -1],
+  k: [-17, -16, -15, 1, 17, 16, 15, -1]
+};
+var ATTACKS = [
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  24,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  24,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  24,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  24,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  24,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  2,
+  24,
+  2,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  2,
+  53,
+  56,
+  53,
+  2,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  56,
+  0,
+  56,
+  24,
+  24,
+  24,
+  24,
+  24,
+  24,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  2,
+  53,
+  56,
+  53,
+  2,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  2,
+  24,
+  2,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  24,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  24,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  24,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  24,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20,
+  0,
+  0,
+  20,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  24,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  20
+];
+var RAYS = [
+  17,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  16,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  15,
+  0,
+  0,
+  17,
+  0,
+  0,
+  0,
+  0,
+  0,
+  16,
+  0,
+  0,
+  0,
+  0,
+  0,
+  15,
+  0,
+  0,
+  0,
+  0,
+  17,
+  0,
+  0,
+  0,
+  0,
+  16,
+  0,
+  0,
+  0,
+  0,
+  15,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  17,
+  0,
+  0,
+  0,
+  16,
+  0,
+  0,
+  0,
+  15,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  17,
+  0,
+  0,
+  16,
+  0,
+  0,
+  15,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  17,
+  0,
+  16,
+  0,
+  15,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  17,
+  16,
+  15,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  -1,
+  -1,
+  -1,
+  -1,
+  -1,
+  -1,
+  -1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -15,
+  -16,
+  -17,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -15,
+  0,
+  -16,
+  0,
+  -17,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -15,
+  0,
+  0,
+  -16,
+  0,
+  0,
+  -17,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -15,
+  0,
+  0,
+  0,
+  -16,
+  0,
+  0,
+  0,
+  -17,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -15,
+  0,
+  0,
+  0,
+  0,
+  -16,
+  0,
+  0,
+  0,
+  0,
+  -17,
+  0,
+  0,
+  0,
+  0,
+  -15,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -16,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -17,
+  0,
+  0,
+  -15,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -16,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -17
+];
+var PIECE_MASKS = { p: 1, n: 2, b: 4, r: 8, q: 16, k: 32 };
+var SYMBOLS = "pnbrqkPNBRQK";
+var PROMOTIONS = [KNIGHT, BISHOP, ROOK, QUEEN];
+var RANK_1 = 7;
+var RANK_2 = 6;
+var RANK_7 = 1;
+var RANK_8 = 0;
+var SIDES = {
+  [KING]: BITS.KSIDE_CASTLE,
+  [QUEEN]: BITS.QSIDE_CASTLE
+};
+var ROOKS = {
+  w: [
+    { square: Ox88.a1, flag: BITS.QSIDE_CASTLE },
+    { square: Ox88.h1, flag: BITS.KSIDE_CASTLE }
+  ],
+  b: [
+    { square: Ox88.a8, flag: BITS.QSIDE_CASTLE },
+    { square: Ox88.h8, flag: BITS.KSIDE_CASTLE }
+  ]
+};
+var SECOND_RANK = { b: RANK_7, w: RANK_2 };
+var SAN_NULLMOVE = "--";
+function rank(square) {
+  return square >> 4;
+}
+function file(square) {
+  return square & 15;
+}
+function isDigit(c) {
+  return "0123456789".indexOf(c) !== -1;
+}
+function algebraic(square) {
+  const f = file(square);
+  const r = rank(square);
+  return "abcdefgh".substring(f, f + 1) + "87654321".substring(r, r + 1);
+}
+function swapColor(color) {
+  return color === WHITE ? BLACK : WHITE;
+}
+function validateFen(fen) {
+  const tokens = fen.split(/\s+/);
+  if (tokens.length !== 6) {
+    return {
+      ok: false,
+      error: "Invalid FEN: must contain six space-delimited fields"
+    };
+  }
+  const moveNumber = parseInt(tokens[5], 10);
+  if (isNaN(moveNumber) || moveNumber <= 0) {
+    return {
+      ok: false,
+      error: "Invalid FEN: move number must be a positive integer"
+    };
+  }
+  const halfMoves = parseInt(tokens[4], 10);
+  if (isNaN(halfMoves) || halfMoves < 0) {
+    return {
+      ok: false,
+      error: "Invalid FEN: half move counter number must be a non-negative integer"
+    };
+  }
+  if (!/^(-|[abcdefgh][36])$/.test(tokens[3])) {
+    return { ok: false, error: "Invalid FEN: en-passant square is invalid" };
+  }
+  if (/[^kKqQ-]/.test(tokens[2])) {
+    return { ok: false, error: "Invalid FEN: castling availability is invalid" };
+  }
+  if (!/^(w|b)$/.test(tokens[1])) {
+    return { ok: false, error: "Invalid FEN: side-to-move is invalid" };
+  }
+  const rows = tokens[0].split("/");
+  if (rows.length !== 8) {
+    return {
+      ok: false,
+      error: "Invalid FEN: piece data does not contain 8 '/'-delimited rows"
+    };
+  }
+  for (let i = 0;i < rows.length; i++) {
+    let sumFields = 0;
+    let previousWasNumber = false;
+    for (let k = 0;k < rows[i].length; k++) {
+      if (isDigit(rows[i][k])) {
+        if (previousWasNumber) {
+          return {
+            ok: false,
+            error: "Invalid FEN: piece data is invalid (consecutive number)"
+          };
+        }
+        sumFields += parseInt(rows[i][k], 10);
+        previousWasNumber = true;
+      } else {
+        if (!/^[prnbqkPRNBQK]$/.test(rows[i][k])) {
+          return {
+            ok: false,
+            error: "Invalid FEN: piece data is invalid (invalid piece)"
+          };
+        }
+        sumFields += 1;
+        previousWasNumber = false;
+      }
+    }
+    if (sumFields !== 8) {
+      return {
+        ok: false,
+        error: "Invalid FEN: piece data is invalid (too many squares in rank)"
+      };
+    }
+  }
+  if (tokens[3][1] == "3" && tokens[1] == "w" || tokens[3][1] == "6" && tokens[1] == "b") {
+    return { ok: false, error: "Invalid FEN: illegal en-passant square" };
+  }
+  const kings = [
+    { color: "white", regex: /K/g },
+    { color: "black", regex: /k/g }
+  ];
+  for (const { color, regex } of kings) {
+    if (!regex.test(tokens[0])) {
+      return { ok: false, error: `Invalid FEN: missing ${color} king` };
+    }
+    if ((tokens[0].match(regex) || []).length > 1) {
+      return { ok: false, error: `Invalid FEN: too many ${color} kings` };
+    }
+  }
+  if (Array.from(rows[0] + rows[7]).some((char) => char.toUpperCase() === "P")) {
+    return {
+      ok: false,
+      error: "Invalid FEN: some pawns are on the edge rows"
+    };
+  }
+  return { ok: true };
+}
+function getDisambiguator(move, moves) {
+  const from = move.from;
+  const to = move.to;
+  const piece = move.piece;
+  let ambiguities = 0;
+  let sameRank = 0;
+  let sameFile = 0;
+  for (let i = 0, len = moves.length;i < len; i++) {
+    const ambigFrom = moves[i].from;
+    const ambigTo = moves[i].to;
+    const ambigPiece = moves[i].piece;
+    if (piece === ambigPiece && from !== ambigFrom && to === ambigTo) {
+      ambiguities++;
+      if (rank(from) === rank(ambigFrom)) {
+        sameRank++;
+      }
+      if (file(from) === file(ambigFrom)) {
+        sameFile++;
+      }
+    }
+  }
+  if (ambiguities > 0) {
+    if (sameRank > 0 && sameFile > 0) {
+      return algebraic(from);
+    } else if (sameFile > 0) {
+      return algebraic(from).charAt(1);
+    } else {
+      return algebraic(from).charAt(0);
+    }
+  }
+  return "";
+}
+function addMove(moves, color, from, to, piece, captured = undefined, flags = BITS.NORMAL) {
+  const r = rank(to);
+  if (piece === PAWN && (r === RANK_1 || r === RANK_8)) {
+    for (let i = 0;i < PROMOTIONS.length; i++) {
+      const promotion = PROMOTIONS[i];
+      moves.push({
+        color,
+        from,
+        to,
+        piece,
+        captured,
+        promotion,
+        flags: flags | BITS.PROMOTION
+      });
+    }
+  } else {
+    moves.push({
+      color,
+      from,
+      to,
+      piece,
+      captured,
+      flags
+    });
+  }
+}
+function inferPieceType(san) {
+  let pieceType = san.charAt(0);
+  if (pieceType >= "a" && pieceType <= "h") {
+    const matches = san.match(/[a-h]\d.*[a-h]\d/);
+    if (matches) {
+      return;
+    }
+    return PAWN;
+  }
+  pieceType = pieceType.toLowerCase();
+  if (pieceType === "o") {
+    return KING;
+  }
+  return pieceType;
+}
+function strippedSan(move) {
+  return move.replace(/=/, "").replace(/[+#]?[?!]*$/, "");
+}
+
+class Chess {
+  _board = new Array(128);
+  _turn = WHITE;
+  _header = {};
+  _kings = { w: EMPTY, b: EMPTY };
+  _epSquare = -1;
+  _halfMoves = 0;
+  _moveNumber = 0;
+  _history = [];
+  _comments = {};
+  _castling = { w: 0, b: 0 };
+  _hash = 0n;
+  _positionCount = new Map;
+  constructor(fen = DEFAULT_POSITION, { skipValidation = false } = {}) {
+    this.load(fen, { skipValidation });
+  }
+  clear({ preserveHeaders = false } = {}) {
+    this._board = new Array(128);
+    this._kings = { w: EMPTY, b: EMPTY };
+    this._turn = WHITE;
+    this._castling = { w: 0, b: 0 };
+    this._epSquare = EMPTY;
+    this._halfMoves = 0;
+    this._moveNumber = 1;
+    this._history = [];
+    this._comments = {};
+    this._header = preserveHeaders ? this._header : { ...HEADER_TEMPLATE };
+    this._hash = this._computeHash();
+    this._positionCount = new Map;
+    this._header["SetUp"] = null;
+    this._header["FEN"] = null;
+  }
+  load(fen, { skipValidation = false, preserveHeaders = false } = {}) {
+    let tokens = fen.split(/\s+/);
+    if (tokens.length >= 2 && tokens.length < 6) {
+      const adjustments = ["-", "-", "0", "1"];
+      fen = tokens.concat(adjustments.slice(-(6 - tokens.length))).join(" ");
+    }
+    tokens = fen.split(/\s+/);
+    if (!skipValidation) {
+      const { ok, error } = validateFen(fen);
+      if (!ok) {
+        throw new Error(error);
+      }
+    }
+    const position = tokens[0];
+    let square = 0;
+    this.clear({ preserveHeaders });
+    for (let i = 0;i < position.length; i++) {
+      const piece = position.charAt(i);
+      if (piece === "/") {
+        square += 8;
+      } else if (isDigit(piece)) {
+        square += parseInt(piece, 10);
+      } else {
+        const color = piece < "a" ? WHITE : BLACK;
+        this._put({ type: piece.toLowerCase(), color }, algebraic(square));
+        square++;
+      }
+    }
+    this._turn = tokens[1];
+    if (tokens[2].indexOf("K") > -1) {
+      this._castling.w |= BITS.KSIDE_CASTLE;
+    }
+    if (tokens[2].indexOf("Q") > -1) {
+      this._castling.w |= BITS.QSIDE_CASTLE;
+    }
+    if (tokens[2].indexOf("k") > -1) {
+      this._castling.b |= BITS.KSIDE_CASTLE;
+    }
+    if (tokens[2].indexOf("q") > -1) {
+      this._castling.b |= BITS.QSIDE_CASTLE;
+    }
+    this._epSquare = tokens[3] === "-" ? EMPTY : Ox88[tokens[3]];
+    this._halfMoves = parseInt(tokens[4], 10);
+    this._moveNumber = parseInt(tokens[5], 10);
+    this._hash = this._computeHash();
+    this._updateSetup(fen);
+    this._incPositionCount();
+  }
+  fen({ forceEnpassantSquare = false } = {}) {
+    let empty = 0;
+    let fen = "";
+    for (let i = Ox88.a8;i <= Ox88.h1; i++) {
+      if (this._board[i]) {
+        if (empty > 0) {
+          fen += empty;
+          empty = 0;
+        }
+        const { color, type: piece } = this._board[i];
+        fen += color === WHITE ? piece.toUpperCase() : piece.toLowerCase();
+      } else {
+        empty++;
+      }
+      if (i + 1 & 136) {
+        if (empty > 0) {
+          fen += empty;
+        }
+        if (i !== Ox88.h1) {
+          fen += "/";
+        }
+        empty = 0;
+        i += 8;
+      }
+    }
+    let castling = "";
+    if (this._castling[WHITE] & BITS.KSIDE_CASTLE) {
+      castling += "K";
+    }
+    if (this._castling[WHITE] & BITS.QSIDE_CASTLE) {
+      castling += "Q";
+    }
+    if (this._castling[BLACK] & BITS.KSIDE_CASTLE) {
+      castling += "k";
+    }
+    if (this._castling[BLACK] & BITS.QSIDE_CASTLE) {
+      castling += "q";
+    }
+    castling = castling || "-";
+    let epSquare = "-";
+    if (this._epSquare !== EMPTY) {
+      if (forceEnpassantSquare) {
+        epSquare = algebraic(this._epSquare);
+      } else {
+        const bigPawnSquare = this._epSquare + (this._turn === WHITE ? 16 : -16);
+        const squares = [bigPawnSquare + 1, bigPawnSquare - 1];
+        for (const square of squares) {
+          if (square & 136) {
+            continue;
+          }
+          const color = this._turn;
+          if (this._board[square]?.color === color && this._board[square]?.type === PAWN) {
+            this._makeMove({
+              color,
+              from: square,
+              to: this._epSquare,
+              piece: PAWN,
+              captured: PAWN,
+              flags: BITS.EP_CAPTURE
+            });
+            const isLegal = !this._isKingAttacked(color);
+            this._undoMove();
+            if (isLegal) {
+              epSquare = algebraic(this._epSquare);
+              break;
+            }
+          }
+        }
+      }
+    }
+    return [
+      fen,
+      this._turn,
+      castling,
+      epSquare,
+      this._halfMoves,
+      this._moveNumber
+    ].join(" ");
+  }
+  _pieceKey(i) {
+    if (!this._board[i]) {
+      return 0n;
+    }
+    const { color, type } = this._board[i];
+    const colorIndex = {
+      w: 0,
+      b: 1
+    }[color];
+    const typeIndex = {
+      p: 0,
+      n: 1,
+      b: 2,
+      r: 3,
+      q: 4,
+      k: 5
+    }[type];
+    return PIECE_KEYS[colorIndex][typeIndex][i];
+  }
+  _epKey() {
+    return this._epSquare === EMPTY ? 0n : EP_KEYS[this._epSquare & 7];
+  }
+  _castlingKey() {
+    const index = this._castling.w >> 5 | this._castling.b >> 3;
+    return CASTLING_KEYS[index];
+  }
+  _computeHash() {
+    let hash = 0n;
+    for (let i = Ox88.a8;i <= Ox88.h1; i++) {
+      if (i & 136) {
+        i += 7;
+        continue;
+      }
+      if (this._board[i]) {
+        hash ^= this._pieceKey(i);
+      }
+    }
+    hash ^= this._epKey();
+    hash ^= this._castlingKey();
+    if (this._turn === "b") {
+      hash ^= SIDE_KEY;
+    }
+    return hash;
+  }
+  _updateSetup(fen) {
+    if (this._history.length > 0)
+      return;
+    if (fen !== DEFAULT_POSITION) {
+      this._header["SetUp"] = "1";
+      this._header["FEN"] = fen;
+    } else {
+      this._header["SetUp"] = null;
+      this._header["FEN"] = null;
+    }
+  }
+  reset() {
+    this.load(DEFAULT_POSITION);
+  }
+  get(square) {
+    return this._board[Ox88[square]];
+  }
+  findPiece(piece) {
+    const squares = [];
+    for (let i = Ox88.a8;i <= Ox88.h1; i++) {
+      if (i & 136) {
+        i += 7;
+        continue;
+      }
+      if (!this._board[i] || this._board[i]?.color !== piece.color) {
+        continue;
+      }
+      if (this._board[i].color === piece.color && this._board[i].type === piece.type) {
+        squares.push(algebraic(i));
+      }
+    }
+    return squares;
+  }
+  put({ type, color }, square) {
+    if (this._put({ type, color }, square)) {
+      this._updateCastlingRights();
+      this._updateEnPassantSquare();
+      this._updateSetup(this.fen());
+      return true;
+    }
+    return false;
+  }
+  _set(sq, piece) {
+    this._hash ^= this._pieceKey(sq);
+    this._board[sq] = piece;
+    this._hash ^= this._pieceKey(sq);
+  }
+  _put({ type, color }, square) {
+    if (SYMBOLS.indexOf(type.toLowerCase()) === -1) {
+      return false;
+    }
+    if (!(square in Ox88)) {
+      return false;
+    }
+    const sq = Ox88[square];
+    if (type == KING && !(this._kings[color] == EMPTY || this._kings[color] == sq)) {
+      return false;
+    }
+    const currentPieceOnSquare = this._board[sq];
+    if (currentPieceOnSquare && currentPieceOnSquare.type === KING) {
+      this._kings[currentPieceOnSquare.color] = EMPTY;
+    }
+    this._set(sq, { type, color });
+    if (type === KING) {
+      this._kings[color] = sq;
+    }
+    return true;
+  }
+  _clear(sq) {
+    this._hash ^= this._pieceKey(sq);
+    delete this._board[sq];
+  }
+  remove(square) {
+    const piece = this.get(square);
+    this._clear(Ox88[square]);
+    if (piece && piece.type === KING) {
+      this._kings[piece.color] = EMPTY;
+    }
+    this._updateCastlingRights();
+    this._updateEnPassantSquare();
+    this._updateSetup(this.fen());
+    return piece;
+  }
+  _updateCastlingRights() {
+    this._hash ^= this._castlingKey();
+    const whiteKingInPlace = this._board[Ox88.e1]?.type === KING && this._board[Ox88.e1]?.color === WHITE;
+    const blackKingInPlace = this._board[Ox88.e8]?.type === KING && this._board[Ox88.e8]?.color === BLACK;
+    if (!whiteKingInPlace || this._board[Ox88.a1]?.type !== ROOK || this._board[Ox88.a1]?.color !== WHITE) {
+      this._castling.w &= -65;
+    }
+    if (!whiteKingInPlace || this._board[Ox88.h1]?.type !== ROOK || this._board[Ox88.h1]?.color !== WHITE) {
+      this._castling.w &= -33;
+    }
+    if (!blackKingInPlace || this._board[Ox88.a8]?.type !== ROOK || this._board[Ox88.a8]?.color !== BLACK) {
+      this._castling.b &= -65;
+    }
+    if (!blackKingInPlace || this._board[Ox88.h8]?.type !== ROOK || this._board[Ox88.h8]?.color !== BLACK) {
+      this._castling.b &= -33;
+    }
+    this._hash ^= this._castlingKey();
+  }
+  _updateEnPassantSquare() {
+    if (this._epSquare === EMPTY) {
+      return;
+    }
+    const startSquare = this._epSquare + (this._turn === WHITE ? -16 : 16);
+    const currentSquare = this._epSquare + (this._turn === WHITE ? 16 : -16);
+    const attackers = [currentSquare + 1, currentSquare - 1];
+    if (this._board[startSquare] !== null || this._board[this._epSquare] !== null || this._board[currentSquare]?.color !== swapColor(this._turn) || this._board[currentSquare]?.type !== PAWN) {
+      this._hash ^= this._epKey();
+      this._epSquare = EMPTY;
+      return;
+    }
+    const canCapture = (square) => !(square & 136) && this._board[square]?.color === this._turn && this._board[square]?.type === PAWN;
+    if (!attackers.some(canCapture)) {
+      this._hash ^= this._epKey();
+      this._epSquare = EMPTY;
+    }
+  }
+  _attacked(color, square, verbose) {
+    const attackers = [];
+    for (let i = Ox88.a8;i <= Ox88.h1; i++) {
+      if (i & 136) {
+        i += 7;
+        continue;
+      }
+      if (this._board[i] === undefined || this._board[i].color !== color) {
+        continue;
+      }
+      const piece = this._board[i];
+      const difference = i - square;
+      if (difference === 0) {
+        continue;
+      }
+      const index = difference + 119;
+      if (ATTACKS[index] & PIECE_MASKS[piece.type]) {
+        if (piece.type === PAWN) {
+          if (difference > 0 && piece.color === WHITE || difference <= 0 && piece.color === BLACK) {
+            if (!verbose) {
+              return true;
+            } else {
+              attackers.push(algebraic(i));
+            }
+          }
+          continue;
+        }
+        if (piece.type === "n" || piece.type === "k") {
+          if (!verbose) {
+            return true;
+          } else {
+            attackers.push(algebraic(i));
+            continue;
+          }
+        }
+        const offset = RAYS[index];
+        let j = i + offset;
+        let blocked = false;
+        while (j !== square) {
+          if (this._board[j] != null) {
+            blocked = true;
+            break;
+          }
+          j += offset;
+        }
+        if (!blocked) {
+          if (!verbose) {
+            return true;
+          } else {
+            attackers.push(algebraic(i));
+            continue;
+          }
+        }
+      }
+    }
+    if (verbose) {
+      return attackers;
+    } else {
+      return false;
+    }
+  }
+  attackers(square, attackedBy) {
+    if (!attackedBy) {
+      return this._attacked(this._turn, Ox88[square], true);
+    } else {
+      return this._attacked(attackedBy, Ox88[square], true);
+    }
+  }
+  _isKingAttacked(color) {
+    const square = this._kings[color];
+    return square === -1 ? false : this._attacked(swapColor(color), square);
+  }
+  hash() {
+    return this._hash.toString(16);
+  }
+  isAttacked(square, attackedBy) {
+    return this._attacked(attackedBy, Ox88[square]);
+  }
+  isCheck() {
+    return this._isKingAttacked(this._turn);
+  }
+  inCheck() {
+    return this.isCheck();
+  }
+  isCheckmate() {
+    return this.isCheck() && this._moves().length === 0;
+  }
+  isStalemate() {
+    return !this.isCheck() && this._moves().length === 0;
+  }
+  isInsufficientMaterial() {
+    const pieces = {
+      b: 0,
+      n: 0,
+      r: 0,
+      q: 0,
+      k: 0,
+      p: 0
+    };
+    const bishops = [];
+    let numPieces = 0;
+    let squareColor = 0;
+    for (let i = Ox88.a8;i <= Ox88.h1; i++) {
+      squareColor = (squareColor + 1) % 2;
+      if (i & 136) {
+        i += 7;
+        continue;
+      }
+      const piece = this._board[i];
+      if (piece) {
+        pieces[piece.type] = piece.type in pieces ? pieces[piece.type] + 1 : 1;
+        if (piece.type === BISHOP) {
+          bishops.push(squareColor);
+        }
+        numPieces++;
+      }
+    }
+    if (numPieces === 2) {
+      return true;
+    } else if (numPieces === 3 && (pieces[BISHOP] === 1 || pieces[KNIGHT] === 1)) {
+      return true;
+    } else if (numPieces === pieces[BISHOP] + 2) {
+      let sum = 0;
+      const len = bishops.length;
+      for (let i = 0;i < len; i++) {
+        sum += bishops[i];
+      }
+      if (sum === 0 || sum === len) {
+        return true;
+      }
+    }
+    return false;
+  }
+  isThreefoldRepetition() {
+    return this._getPositionCount(this._hash) >= 3;
+  }
+  isDrawByFiftyMoves() {
+    return this._halfMoves >= 100;
+  }
+  isDraw() {
+    return this.isDrawByFiftyMoves() || this.isStalemate() || this.isInsufficientMaterial() || this.isThreefoldRepetition();
+  }
+  isGameOver() {
+    return this.isCheckmate() || this.isDraw();
+  }
+  moves({ verbose = false, square = undefined, piece = undefined } = {}) {
+    const moves = this._moves({ square, piece });
+    if (verbose) {
+      return moves.map((move) => new Move(this, move));
+    } else {
+      return moves.map((move) => this._moveToSan(move, moves));
+    }
+  }
+  _moves({ legal = true, piece = undefined, square = undefined } = {}) {
+    const forSquare = square ? square.toLowerCase() : undefined;
+    const forPiece = piece?.toLowerCase();
+    const moves = [];
+    const us = this._turn;
+    const them = swapColor(us);
+    let firstSquare = Ox88.a8;
+    let lastSquare = Ox88.h1;
+    let singleSquare = false;
+    if (forSquare) {
+      if (!(forSquare in Ox88)) {
+        return [];
+      } else {
+        firstSquare = lastSquare = Ox88[forSquare];
+        singleSquare = true;
+      }
+    }
+    for (let from = firstSquare;from <= lastSquare; from++) {
+      if (from & 136) {
+        from += 7;
+        continue;
+      }
+      if (!this._board[from] || this._board[from].color === them) {
+        continue;
+      }
+      const { type } = this._board[from];
+      let to;
+      if (type === PAWN) {
+        if (forPiece && forPiece !== type)
+          continue;
+        to = from + PAWN_OFFSETS[us][0];
+        if (!this._board[to]) {
+          addMove(moves, us, from, to, PAWN);
+          to = from + PAWN_OFFSETS[us][1];
+          if (SECOND_RANK[us] === rank(from) && !this._board[to]) {
+            addMove(moves, us, from, to, PAWN, undefined, BITS.BIG_PAWN);
+          }
+        }
+        for (let j = 2;j < 4; j++) {
+          to = from + PAWN_OFFSETS[us][j];
+          if (to & 136)
+            continue;
+          if (this._board[to]?.color === them) {
+            addMove(moves, us, from, to, PAWN, this._board[to].type, BITS.CAPTURE);
+          } else if (to === this._epSquare) {
+            addMove(moves, us, from, to, PAWN, PAWN, BITS.EP_CAPTURE);
+          }
+        }
+      } else {
+        if (forPiece && forPiece !== type)
+          continue;
+        for (let j = 0, len = PIECE_OFFSETS[type].length;j < len; j++) {
+          const offset = PIECE_OFFSETS[type][j];
+          to = from;
+          while (true) {
+            to += offset;
+            if (to & 136)
+              break;
+            if (!this._board[to]) {
+              addMove(moves, us, from, to, type);
+            } else {
+              if (this._board[to].color === us)
+                break;
+              addMove(moves, us, from, to, type, this._board[to].type, BITS.CAPTURE);
+              break;
+            }
+            if (type === KNIGHT || type === KING)
+              break;
+          }
+        }
+      }
+    }
+    if (forPiece === undefined || forPiece === KING) {
+      if (!singleSquare || lastSquare === this._kings[us]) {
+        if (this._castling[us] & BITS.KSIDE_CASTLE) {
+          const castlingFrom = this._kings[us];
+          const castlingTo = castlingFrom + 2;
+          if (!this._board[castlingFrom + 1] && !this._board[castlingTo] && !this._attacked(them, this._kings[us]) && !this._attacked(them, castlingFrom + 1) && !this._attacked(them, castlingTo)) {
+            addMove(moves, us, this._kings[us], castlingTo, KING, undefined, BITS.KSIDE_CASTLE);
+          }
+        }
+        if (this._castling[us] & BITS.QSIDE_CASTLE) {
+          const castlingFrom = this._kings[us];
+          const castlingTo = castlingFrom - 2;
+          if (!this._board[castlingFrom - 1] && !this._board[castlingFrom - 2] && !this._board[castlingFrom - 3] && !this._attacked(them, this._kings[us]) && !this._attacked(them, castlingFrom - 1) && !this._attacked(them, castlingTo)) {
+            addMove(moves, us, this._kings[us], castlingTo, KING, undefined, BITS.QSIDE_CASTLE);
+          }
+        }
+      }
+    }
+    if (!legal || this._kings[us] === -1) {
+      return moves;
+    }
+    const legalMoves = [];
+    for (let i = 0, len = moves.length;i < len; i++) {
+      this._makeMove(moves[i]);
+      if (!this._isKingAttacked(us)) {
+        legalMoves.push(moves[i]);
+      }
+      this._undoMove();
+    }
+    return legalMoves;
+  }
+  move(move, { strict = false } = {}) {
+    let moveObj = null;
+    if (typeof move === "string") {
+      moveObj = this._moveFromSan(move, strict);
+    } else if (move === null) {
+      moveObj = this._moveFromSan(SAN_NULLMOVE, strict);
+    } else if (typeof move === "object") {
+      const moves = this._moves();
+      for (let i = 0, len = moves.length;i < len; i++) {
+        if (move.from === algebraic(moves[i].from) && move.to === algebraic(moves[i].to) && (!("promotion" in moves[i]) || move.promotion === moves[i].promotion)) {
+          moveObj = moves[i];
+          break;
+        }
+      }
+    }
+    if (!moveObj) {
+      if (typeof move === "string") {
+        throw new Error(`Invalid move: ${move}`);
+      } else {
+        throw new Error(`Invalid move: ${JSON.stringify(move)}`);
+      }
+    }
+    if (this.isCheck() && moveObj.flags & BITS.NULL_MOVE) {
+      throw new Error("Null move not allowed when in check");
+    }
+    const prettyMove = new Move(this, moveObj);
+    this._makeMove(moveObj);
+    this._incPositionCount();
+    return prettyMove;
+  }
+  _push(move) {
+    this._history.push({
+      move,
+      kings: { b: this._kings.b, w: this._kings.w },
+      turn: this._turn,
+      castling: { b: this._castling.b, w: this._castling.w },
+      epSquare: this._epSquare,
+      halfMoves: this._halfMoves,
+      moveNumber: this._moveNumber
+    });
+  }
+  _movePiece(from, to) {
+    this._hash ^= this._pieceKey(from);
+    this._board[to] = this._board[from];
+    delete this._board[from];
+    this._hash ^= this._pieceKey(to);
+  }
+  _makeMove(move) {
+    const us = this._turn;
+    const them = swapColor(us);
+    this._push(move);
+    if (move.flags & BITS.NULL_MOVE) {
+      if (us === BLACK) {
+        this._moveNumber++;
+      }
+      this._halfMoves++;
+      this._turn = them;
+      this._epSquare = EMPTY;
+      return;
+    }
+    this._hash ^= this._epKey();
+    this._hash ^= this._castlingKey();
+    if (move.captured) {
+      this._hash ^= this._pieceKey(move.to);
+    }
+    this._movePiece(move.from, move.to);
+    if (move.flags & BITS.EP_CAPTURE) {
+      if (this._turn === BLACK) {
+        this._clear(move.to - 16);
+      } else {
+        this._clear(move.to + 16);
+      }
+    }
+    if (move.promotion) {
+      this._clear(move.to);
+      this._set(move.to, { type: move.promotion, color: us });
+    }
+    if (this._board[move.to].type === KING) {
+      this._kings[us] = move.to;
+      if (move.flags & BITS.KSIDE_CASTLE) {
+        const castlingTo = move.to - 1;
+        const castlingFrom = move.to + 1;
+        this._movePiece(castlingFrom, castlingTo);
+      } else if (move.flags & BITS.QSIDE_CASTLE) {
+        const castlingTo = move.to + 1;
+        const castlingFrom = move.to - 2;
+        this._movePiece(castlingFrom, castlingTo);
+      }
+      this._castling[us] = 0;
+    }
+    if (this._castling[us]) {
+      for (let i = 0, len = ROOKS[us].length;i < len; i++) {
+        if (move.from === ROOKS[us][i].square && this._castling[us] & ROOKS[us][i].flag) {
+          this._castling[us] ^= ROOKS[us][i].flag;
+          break;
+        }
+      }
+    }
+    if (this._castling[them]) {
+      for (let i = 0, len = ROOKS[them].length;i < len; i++) {
+        if (move.to === ROOKS[them][i].square && this._castling[them] & ROOKS[them][i].flag) {
+          this._castling[them] ^= ROOKS[them][i].flag;
+          break;
+        }
+      }
+    }
+    this._hash ^= this._castlingKey();
+    if (move.flags & BITS.BIG_PAWN) {
+      let epSquare;
+      if (us === BLACK) {
+        epSquare = move.to - 16;
+      } else {
+        epSquare = move.to + 16;
+      }
+      if (!(move.to - 1 & 136) && this._board[move.to - 1]?.type === PAWN && this._board[move.to - 1]?.color === them || !(move.to + 1 & 136) && this._board[move.to + 1]?.type === PAWN && this._board[move.to + 1]?.color === them) {
+        this._epSquare = epSquare;
+        this._hash ^= this._epKey();
+      } else {
+        this._epSquare = EMPTY;
+      }
+    } else {
+      this._epSquare = EMPTY;
+    }
+    if (move.piece === PAWN) {
+      this._halfMoves = 0;
+    } else if (move.flags & (BITS.CAPTURE | BITS.EP_CAPTURE)) {
+      this._halfMoves = 0;
+    } else {
+      this._halfMoves++;
+    }
+    if (us === BLACK) {
+      this._moveNumber++;
+    }
+    this._turn = them;
+    this._hash ^= SIDE_KEY;
+  }
+  undo() {
+    const hash = this._hash;
+    const move = this._undoMove();
+    if (move) {
+      const prettyMove = new Move(this, move);
+      this._decPositionCount(hash);
+      return prettyMove;
+    }
+    return null;
+  }
+  _undoMove() {
+    const old = this._history.pop();
+    if (old === undefined) {
+      return null;
+    }
+    this._hash ^= this._epKey();
+    this._hash ^= this._castlingKey();
+    const move = old.move;
+    this._kings = old.kings;
+    this._turn = old.turn;
+    this._castling = old.castling;
+    this._epSquare = old.epSquare;
+    this._halfMoves = old.halfMoves;
+    this._moveNumber = old.moveNumber;
+    this._hash ^= this._epKey();
+    this._hash ^= this._castlingKey();
+    this._hash ^= SIDE_KEY;
+    const us = this._turn;
+    const them = swapColor(us);
+    if (move.flags & BITS.NULL_MOVE) {
+      return move;
+    }
+    this._movePiece(move.to, move.from);
+    if (move.piece) {
+      this._clear(move.from);
+      this._set(move.from, { type: move.piece, color: us });
+    }
+    if (move.captured) {
+      if (move.flags & BITS.EP_CAPTURE) {
+        let index;
+        if (us === BLACK) {
+          index = move.to - 16;
+        } else {
+          index = move.to + 16;
+        }
+        this._set(index, { type: PAWN, color: them });
+      } else {
+        this._set(move.to, { type: move.captured, color: them });
+      }
+    }
+    if (move.flags & (BITS.KSIDE_CASTLE | BITS.QSIDE_CASTLE)) {
+      let castlingTo, castlingFrom;
+      if (move.flags & BITS.KSIDE_CASTLE) {
+        castlingTo = move.to + 1;
+        castlingFrom = move.to - 1;
+      } else {
+        castlingTo = move.to - 2;
+        castlingFrom = move.to + 1;
+      }
+      this._movePiece(castlingFrom, castlingTo);
+    }
+    return move;
+  }
+  pgn({ newline = `
+`, maxWidth = 0 } = {}) {
+    const result = [];
+    let headerExists = false;
+    for (const i in this._header) {
+      const headerTag = this._header[i];
+      if (headerTag)
+        result.push(`[${i} "${this._header[i]}"]` + newline);
+      headerExists = true;
+    }
+    if (headerExists && this._history.length) {
+      result.push(newline);
+    }
+    const appendComment = (moveString) => {
+      const comment = this._comments[this.fen()];
+      if (typeof comment !== "undefined") {
+        const delimiter = moveString.length > 0 ? " " : "";
+        moveString = `${moveString}${delimiter}{${comment}}`;
+      }
+      return moveString;
+    };
+    const reversedHistory = [];
+    while (this._history.length > 0) {
+      reversedHistory.push(this._undoMove());
+    }
+    const moves = [];
+    let moveString = "";
+    if (reversedHistory.length === 0) {
+      moves.push(appendComment(""));
+    }
+    while (reversedHistory.length > 0) {
+      moveString = appendComment(moveString);
+      const move = reversedHistory.pop();
+      if (!move) {
+        break;
+      }
+      if (!this._history.length && move.color === "b") {
+        const prefix = `${this._moveNumber}. ...`;
+        moveString = moveString ? `${moveString} ${prefix}` : prefix;
+      } else if (move.color === "w") {
+        if (moveString.length) {
+          moves.push(moveString);
+        }
+        moveString = this._moveNumber + ".";
+      }
+      moveString = moveString + " " + this._moveToSan(move, this._moves({ legal: true }));
+      this._makeMove(move);
+    }
+    if (moveString.length) {
+      moves.push(appendComment(moveString));
+    }
+    moves.push(this._header.Result || "*");
+    if (maxWidth === 0) {
+      return result.join("") + moves.join(" ");
+    }
+    const strip = function() {
+      if (result.length > 0 && result[result.length - 1] === " ") {
+        result.pop();
+        return true;
+      }
+      return false;
+    };
+    const wrapComment = function(width, move) {
+      for (const token of move.split(" ")) {
+        if (!token) {
+          continue;
+        }
+        if (width + token.length > maxWidth) {
+          while (strip()) {
+            width--;
+          }
+          result.push(newline);
+          width = 0;
+        }
+        result.push(token);
+        width += token.length;
+        result.push(" ");
+        width++;
+      }
+      if (strip()) {
+        width--;
+      }
+      return width;
+    };
+    let currentWidth = 0;
+    for (let i = 0;i < moves.length; i++) {
+      if (currentWidth + moves[i].length > maxWidth) {
+        if (moves[i].includes("{")) {
+          currentWidth = wrapComment(currentWidth, moves[i]);
+          continue;
+        }
+      }
+      if (currentWidth + moves[i].length > maxWidth && i !== 0) {
+        if (result[result.length - 1] === " ") {
+          result.pop();
+        }
+        result.push(newline);
+        currentWidth = 0;
+      } else if (i !== 0) {
+        result.push(" ");
+        currentWidth++;
+      }
+      result.push(moves[i]);
+      currentWidth += moves[i].length;
+    }
+    return result.join("");
+  }
+  header(...args) {
+    for (let i = 0;i < args.length; i += 2) {
+      if (typeof args[i] === "string" && typeof args[i + 1] === "string") {
+        this._header[args[i]] = args[i + 1];
+      }
+    }
+    return this._header;
+  }
+  setHeader(key, value) {
+    this._header[key] = value ?? SEVEN_TAG_ROSTER[key] ?? null;
+    return this.getHeaders();
+  }
+  removeHeader(key) {
+    if (key in this._header) {
+      this._header[key] = SEVEN_TAG_ROSTER[key] || null;
+      return true;
+    }
+    return false;
+  }
+  getHeaders() {
+    const nonNullHeaders = {};
+    for (const [key, value] of Object.entries(this._header)) {
+      if (value !== null) {
+        nonNullHeaders[key] = value;
+      }
+    }
+    return nonNullHeaders;
+  }
+  loadPgn(pgn, { strict = false, newlineChar = `\r?
+` } = {}) {
+    if (newlineChar !== `\r?
+`) {
+      pgn = pgn.replace(new RegExp(newlineChar, "g"), `
+`);
+    }
+    const parsedPgn = peg$parse(pgn);
+    this.reset();
+    const headers = parsedPgn.headers;
+    let fen = "";
+    for (const key in headers) {
+      if (key.toLowerCase() === "fen") {
+        fen = headers[key];
+      }
+      this.header(key, headers[key]);
+    }
+    if (!strict) {
+      if (fen) {
+        this.load(fen, { preserveHeaders: true });
+      }
+    } else {
+      if (headers["SetUp"] === "1") {
+        if (!("FEN" in headers)) {
+          throw new Error("Invalid PGN: FEN tag must be supplied with SetUp tag");
+        }
+        this.load(headers["FEN"], { preserveHeaders: true });
+      }
+    }
+    let node = parsedPgn.root;
+    while (node) {
+      if (node.move) {
+        const move = this._moveFromSan(node.move, strict);
+        if (move == null) {
+          throw new Error(`Invalid move in PGN: ${node.move}`);
+        } else {
+          this._makeMove(move);
+          this._incPositionCount();
+        }
+      }
+      if (node.comment !== undefined) {
+        this._comments[this.fen()] = node.comment;
+      }
+      node = node.variations[0];
+    }
+    const result = parsedPgn.result;
+    if (result && Object.keys(this._header).length && this._header["Result"] !== result) {
+      this.setHeader("Result", result);
+    }
+  }
+  _moveToSan(move, moves) {
+    let output = "";
+    if (move.flags & BITS.KSIDE_CASTLE) {
+      output = "O-O";
+    } else if (move.flags & BITS.QSIDE_CASTLE) {
+      output = "O-O-O";
+    } else if (move.flags & BITS.NULL_MOVE) {
+      return SAN_NULLMOVE;
+    } else {
+      if (move.piece !== PAWN) {
+        const disambiguator = getDisambiguator(move, moves);
+        output += move.piece.toUpperCase() + disambiguator;
+      }
+      if (move.flags & (BITS.CAPTURE | BITS.EP_CAPTURE)) {
+        if (move.piece === PAWN) {
+          output += algebraic(move.from)[0];
+        }
+        output += "x";
+      }
+      output += algebraic(move.to);
+      if (move.promotion) {
+        output += "=" + move.promotion.toUpperCase();
+      }
+    }
+    this._makeMove(move);
+    if (this.isCheck()) {
+      if (this.isCheckmate()) {
+        output += "#";
+      } else {
+        output += "+";
+      }
+    }
+    this._undoMove();
+    return output;
+  }
+  _moveFromSan(move, strict = false) {
+    let cleanMove = strippedSan(move);
+    if (!strict) {
+      if (cleanMove === "0-0") {
+        cleanMove = "O-O";
+      } else if (cleanMove === "0-0-0") {
+        cleanMove = "O-O-O";
+      }
+    }
+    if (cleanMove == SAN_NULLMOVE) {
+      const res = {
+        color: this._turn,
+        from: 0,
+        to: 0,
+        piece: "k",
+        flags: BITS.NULL_MOVE
+      };
+      return res;
+    }
+    let pieceType = inferPieceType(cleanMove);
+    let moves = this._moves({ legal: true, piece: pieceType });
+    for (let i = 0, len = moves.length;i < len; i++) {
+      if (cleanMove === strippedSan(this._moveToSan(moves[i], moves))) {
+        return moves[i];
+      }
+    }
+    if (strict) {
+      return null;
+    }
+    let piece = undefined;
+    let matches = undefined;
+    let from = undefined;
+    let to = undefined;
+    let promotion = undefined;
+    let overlyDisambiguated = false;
+    matches = cleanMove.match(/([pnbrqkPNBRQK])?([a-h][1-8])x?-?([a-h][1-8])([qrbnQRBN])?/);
+    if (matches) {
+      piece = matches[1];
+      from = matches[2];
+      to = matches[3];
+      promotion = matches[4];
+      if (from.length == 1) {
+        overlyDisambiguated = true;
+      }
+    } else {
+      matches = cleanMove.match(/([pnbrqkPNBRQK])?([a-h]?[1-8]?)x?-?([a-h][1-8])([qrbnQRBN])?/);
+      if (matches) {
+        piece = matches[1];
+        from = matches[2];
+        to = matches[3];
+        promotion = matches[4];
+        if (from.length == 1) {
+          overlyDisambiguated = true;
+        }
+      }
+    }
+    pieceType = inferPieceType(cleanMove);
+    moves = this._moves({
+      legal: true,
+      piece: piece ? piece : pieceType
+    });
+    if (!to) {
+      return null;
+    }
+    for (let i = 0, len = moves.length;i < len; i++) {
+      if (!from) {
+        if (cleanMove === strippedSan(this._moveToSan(moves[i], moves)).replace("x", "")) {
+          return moves[i];
+        }
+      } else if ((!piece || piece.toLowerCase() == moves[i].piece) && Ox88[from] == moves[i].from && Ox88[to] == moves[i].to && (!promotion || promotion.toLowerCase() == moves[i].promotion)) {
+        return moves[i];
+      } else if (overlyDisambiguated) {
+        const square = algebraic(moves[i].from);
+        if ((!piece || piece.toLowerCase() == moves[i].piece) && Ox88[to] == moves[i].to && (from == square[0] || from == square[1]) && (!promotion || promotion.toLowerCase() == moves[i].promotion)) {
+          return moves[i];
+        }
+      }
+    }
+    return null;
+  }
+  ascii() {
+    let s = `   +------------------------+
+`;
+    for (let i = Ox88.a8;i <= Ox88.h1; i++) {
+      if (file(i) === 0) {
+        s += " " + "87654321"[rank(i)] + " |";
+      }
+      if (this._board[i]) {
+        const piece = this._board[i].type;
+        const color = this._board[i].color;
+        const symbol = color === WHITE ? piece.toUpperCase() : piece.toLowerCase();
+        s += " " + symbol + " ";
+      } else {
+        s += " . ";
+      }
+      if (i + 1 & 136) {
+        s += `|
+`;
+        i += 8;
+      }
+    }
+    s += `   +------------------------+
+`;
+    s += "     a  b  c  d  e  f  g  h";
+    return s;
+  }
+  perft(depth) {
+    const moves = this._moves({ legal: false });
+    let nodes = 0;
+    const color = this._turn;
+    for (let i = 0, len = moves.length;i < len; i++) {
+      this._makeMove(moves[i]);
+      if (!this._isKingAttacked(color)) {
+        if (depth - 1 > 0) {
+          nodes += this.perft(depth - 1);
+        } else {
+          nodes++;
+        }
+      }
+      this._undoMove();
+    }
+    return nodes;
+  }
+  setTurn(color) {
+    if (this._turn == color) {
+      return false;
+    }
+    this.move("--");
+    return true;
+  }
+  turn() {
+    return this._turn;
+  }
+  board() {
+    const output = [];
+    let row = [];
+    for (let i = Ox88.a8;i <= Ox88.h1; i++) {
+      if (this._board[i] == null) {
+        row.push(null);
+      } else {
+        row.push({
+          square: algebraic(i),
+          type: this._board[i].type,
+          color: this._board[i].color
+        });
+      }
+      if (i + 1 & 136) {
+        output.push(row);
+        row = [];
+        i += 8;
+      }
+    }
+    return output;
+  }
+  squareColor(square) {
+    if (square in Ox88) {
+      const sq = Ox88[square];
+      return (rank(sq) + file(sq)) % 2 === 0 ? "light" : "dark";
+    }
+    return null;
+  }
+  history({ verbose = false } = {}) {
+    const reversedHistory = [];
+    const moveHistory = [];
+    while (this._history.length > 0) {
+      reversedHistory.push(this._undoMove());
+    }
+    while (true) {
+      const move = reversedHistory.pop();
+      if (!move) {
+        break;
+      }
+      if (verbose) {
+        moveHistory.push(new Move(this, move));
+      } else {
+        moveHistory.push(this._moveToSan(move, this._moves()));
+      }
+      this._makeMove(move);
+    }
+    return moveHistory;
+  }
+  _getPositionCount(hash) {
+    return this._positionCount.get(hash) ?? 0;
+  }
+  _incPositionCount() {
+    this._positionCount.set(this._hash, (this._positionCount.get(this._hash) ?? 0) + 1);
+  }
+  _decPositionCount(hash) {
+    const currentCount = this._positionCount.get(hash) ?? 0;
+    if (currentCount === 1) {
+      this._positionCount.delete(hash);
+    } else {
+      this._positionCount.set(hash, currentCount - 1);
+    }
+  }
+  _pruneComments() {
+    const reversedHistory = [];
+    const currentComments = {};
+    const copyComment = (fen) => {
+      if (fen in this._comments) {
+        currentComments[fen] = this._comments[fen];
+      }
+    };
+    while (this._history.length > 0) {
+      reversedHistory.push(this._undoMove());
+    }
+    copyComment(this.fen());
+    while (true) {
+      const move = reversedHistory.pop();
+      if (!move) {
+        break;
+      }
+      this._makeMove(move);
+      copyComment(this.fen());
+    }
+    this._comments = currentComments;
+  }
+  getComment() {
+    return this._comments[this.fen()];
+  }
+  setComment(comment) {
+    this._comments[this.fen()] = comment.replace("{", "[").replace("}", "]");
+  }
+  deleteComment() {
+    return this.removeComment();
+  }
+  removeComment() {
+    const comment = this._comments[this.fen()];
+    delete this._comments[this.fen()];
+    return comment;
+  }
+  getComments() {
+    this._pruneComments();
+    return Object.keys(this._comments).map((fen) => {
+      return { fen, comment: this._comments[fen] };
+    });
+  }
+  deleteComments() {
+    return this.removeComments();
+  }
+  removeComments() {
+    this._pruneComments();
+    return Object.keys(this._comments).map((fen) => {
+      const comment = this._comments[fen];
+      delete this._comments[fen];
+      return { fen, comment };
+    });
+  }
+  setCastlingRights(color, rights) {
+    for (const side of [KING, QUEEN]) {
+      if (rights[side] !== undefined) {
+        if (rights[side]) {
+          this._castling[color] |= SIDES[side];
+        } else {
+          this._castling[color] &= ~SIDES[side];
+        }
+      }
+    }
+    this._updateCastlingRights();
+    const result = this.getCastlingRights(color);
+    return (rights[KING] === undefined || rights[KING] === result[KING]) && (rights[QUEEN] === undefined || rights[QUEEN] === result[QUEEN]);
+  }
+  getCastlingRights(color) {
+    return {
+      [KING]: (this._castling[color] & SIDES[KING]) !== 0,
+      [QUEEN]: (this._castling[color] & SIDES[QUEEN]) !== 0
+    };
+  }
+  moveNumber() {
+    return this._moveNumber;
+  }
+}
+
+// src/features/chess/utils/chessEngine.ts
+function createChess(fen) {
+  try {
+    return new Chess(fen);
+  } catch {
+    return null;
+  }
+}
+function toPieceCode(piece) {
+  return piece.color === "w" ? piece.type.toUpperCase() : piece.type.toLowerCase();
+}
+function toPromotionPiece(piece) {
+  return piece === "q" || piece === "r" || piece === "b" || piece === "n" ? piece : undefined;
+}
+function toMoveResult(move, fen) {
+  return {
+    fen,
+    from: move.from,
+    lan: move.lan,
+    promotion: toPromotionPiece(move.promotion),
+    san: move.san,
+    to: move.to
+  };
+}
+function readChessPieces(fen) {
+  const chess = createChess(fen);
+  const pieces = new Map;
+  if (!chess)
+    return pieces;
+  for (const rank of chess.board()) {
+    for (const piece of rank) {
+      if (!piece)
+        continue;
+      pieces.set(piece.square, {
+        color: piece.color === "w" ? "white" : "black",
+        piece: toPieceCode(piece),
+        square: piece.square
+      });
+    }
+  }
+  return pieces;
+}
+function getLegalTargets(fen, from) {
+  const chess = createChess(fen);
+  return chess ? chess.moves({ square: from, verbose: true }).map((move) => move.to) : [];
+}
+function tryMove(fen, attempt) {
+  const chess = createChess(fen);
+  if (!chess)
+    return null;
+  try {
+    const move = chess.move({
+      from: attempt.from,
+      promotion: attempt.promotion,
+      to: attempt.to
+    });
+    return toMoveResult(move, chess.fen());
+  } catch {
+    return null;
+  }
+}
+
+// src/features/chess/utils/createBoardSquares.ts
+var files = ["a", "b", "c", "d", "e", "f", "g", "h"];
+var ranks = ["1", "2", "3", "4", "5", "6", "7", "8"];
+function createBoardSquares(orientation) {
+  const displayedRanks = orientation === "white" ? [...ranks].reverse() : [...ranks];
+  const displayedFiles = orientation === "white" ? [...files] : [...files].reverse();
+  return displayedRanks.flatMap((rank) => displayedFiles.map((file) => `${file}${rank}`));
+}
+
+// src/features/chess/utils/createChessBoardColorScheme.ts
+function createChessBoardColorScheme(theme, overrides) {
+  return {
+    border: theme.semantics.neutral.divider,
+    coordinateText: theme.semantics.content.muted,
+    darkPiece: theme.semantics.content.default,
+    darkSquare: theme.semantics.neutral.surfaceHover,
+    darkSquareText: theme.semantics.content.muted,
+    lastMoveFrom: theme.semantics.warning.softBg,
+    lastMoveTo: theme.semantics.warning.softBg,
+    legalTarget: theme.semantics.success.softBg,
+    lightPiece: theme.semantics.content.default,
+    lightSquare: theme.semantics.neutral.surface,
+    lightSquareText: theme.semantics.content.muted,
+    selectedSquare: theme.semantics.action.primary.softBg,
+    ...overrides
+  };
+}
+
+// src/features/chess/utils/isLightSquare.ts
+var files2 = "abcdefgh";
+function isLightSquare(square) {
+  return (files2.indexOf(square[0] ?? "") + Number(square[1]) - 1) % 2 === 1;
+}
+
+// src/features/chess/adapters/inbound/ChessBoard.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var symbols = new Map([
+  ["white:p", "♙"],
+  ["white:n", "♘"],
+  ["white:b", "♗"],
+  ["white:r", "♖"],
+  ["white:q", "♕"],
+  ["white:k", "♔"],
+  ["black:p", "♟"],
+  ["black:n", "♞"],
+  ["black:b", "♝"],
+  ["black:r", "♜"],
+  ["black:q", "♛"],
+  ["black:k", "♚"]
+]);
+var ChessBoard2 = withZoraThemeScope(ChessBoardInner);
+function ChessBoardInner({
+  fen,
+  pieces,
+  orientation = "white",
+  selectedSquare = null,
+  legalTargets,
+  lastMove = null,
+  disabled = false,
+  showCoordinates = false,
+  validateMoves = true,
+  colorScheme,
+  onSquarePress,
+  onMoveAttempt,
+  onLegalMove,
+  onInvalidMove,
+  renderPiece,
+  interactionPolicy,
+  testID
+}) {
+  const { theme } = useZoraTheme2();
+  const colors = createChessBoardColorScheme(theme, colorScheme);
+  const squares = createBoardSquares(orientation);
+  const piecesBySquare = pieces === undefined ? fen === undefined ? new Map : new Map(readChessPieces(fen)) : new Map(pieces.map((piece) => [piece.square, piece]));
+  const resolvedLegalTargets = legalTargets ?? (fen !== undefined && selectedSquare !== null ? getLegalTargets(fen, selectedSquare) : []);
+  const legalTargetSet = new Set(resolvedLegalTargets);
+  const pressSquare = (square) => {
+    if (disabled || interactionPolicy === "passive")
+      return;
+    onSquarePress?.(square);
+    if (selectedSquare === null || selectedSquare === square)
+      return;
+    const attempt = { from: selectedSquare, to: square };
+    onMoveAttempt?.(attempt);
+    if (!validateMoves || fen === undefined)
+      return;
+    const result = tryMove(fen, attempt);
+    if (result)
+      onLegalMove?.(result);
+    else
+      onInvalidMove?.(attempt);
+  };
+  return /* @__PURE__ */ jsx(import_react_native.View, {
+    accessibilityLabel: "Chess board",
+    style: [styles.board, { borderColor: colors.border, opacity: disabled ? 0.56 : 1 }],
+    testID,
+    children: squares.map((square) => {
+      const piece = piecesBySquare.get(square);
+      const light = isLightSquare(square);
+      const isTarget = legalTargetSet.has(square);
+      const backgroundColor = selectedSquare === square ? colors.selectedSquare : isTarget ? colors.legalTarget : lastMove?.from === square ? colors.lastMoveFrom : lastMove?.to === square ? colors.lastMoveTo : light ? colors.lightSquare : colors.darkSquare;
+      const pieceContent = piece === undefined ? null : renderPiece ? renderPiece({
+        color: piece.color === "white" ? colors.lightPiece : colors.darkPiece,
+        piece: piece.piece,
+        square
+      }) : symbols.get(`${piece.color}:${piece.piece.toLowerCase()}`) ?? piece.piece;
+      return /* @__PURE__ */ jsxs(import_react_native.Pressable, {
+        accessibilityLabel: square,
+        accessibilityRole: "button",
+        disabled: disabled || interactionPolicy === "passive",
+        onPress: () => pressSquare(square),
+        style: [styles.square, { backgroundColor }],
+        testID: testID ? `${testID}-square-${square}` : undefined,
+        children: [
+          showCoordinates ? /* @__PURE__ */ jsx(import_react_native.Text, {
+            style: [
+              styles.coordinate,
+              { color: light ? colors.lightSquareText : colors.darkSquareText }
+            ],
+            children: square
+          }) : null,
+          piece === undefined ? null : /* @__PURE__ */ jsx(import_react_native.View, {
+            pointerEvents: "none",
+            style: styles.pieceContainer,
+            children: renderPiece ? pieceContent : /* @__PURE__ */ jsx(import_react_native.Text, {
+              style: [
+                styles.piece,
+                { color: piece.color === "white" ? colors.lightPiece : colors.darkPiece }
+              ],
+              children: pieceContent
+            })
+          })
+        ]
+      }, square);
+    })
+  });
+}
+var styles = import_react_native.StyleSheet.create({
+  board: {
+    aspectRatio: 1,
+    borderRadius: 12,
+    borderWidth: import_react_native.StyleSheet.hairlineWidth,
+    flexDirection: "row",
+    flexWrap: "wrap",
+    overflow: "hidden",
+    width: "100%"
+  },
+  coordinate: {
+    fontSize: 9,
+    fontWeight: "600",
+    left: 3,
+    opacity: 0.72,
+    position: "absolute",
+    top: 2,
+    zIndex: 2
+  },
+  piece: { fontSize: 32, fontWeight: "600", lineHeight: 38 },
+  pieceContainer: {
+    alignItems: "center",
+    bottom: 0,
+    justifyContent: "center",
+    left: 0,
+    position: "absolute",
+    right: 0,
+    top: 0
+  },
+  square: {
+    alignItems: "center",
+    aspectRatio: 1,
+    width: "12.5%",
+    justifyContent: "center",
+    position: "relative"
+  }
+});
+
+// src/features/chess/adapters/inbound/OpeningBook.tsx
+var import_react_native2 = __toESM(require_cjs(), 1);
+
+// src/features/chess/utils/createOpeningBookColorScheme.ts
+function createOpeningBookColorScheme(theme, overrides) {
+  return {
+    border: theme.semantics.neutral.divider,
+    metricSurface: theme.semantics.neutral.surface,
+    primaryText: theme.semantics.content.default,
+    secondaryText: theme.semantics.content.muted,
+    selectedSurface: theme.semantics.action.primary.softBg,
+    surface: theme.semantics.neutral.surface,
+    surfaceHover: theme.semantics.neutral.surfaceHover,
+    titleText: theme.semantics.content.default,
+    ...overrides
+  };
+}
+
+// src/features/chess/adapters/inbound/OpeningBook.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var OpeningBook2 = withZoraThemeScope(OpeningBookInner);
+function rate(label, value) {
+  if (value === undefined || !Number.isFinite(value))
+    return;
+  return `${label} ${Math.round(value <= 1 ? value * 100 : value)}%`;
+}
+function moveKey(move) {
+  return move.uci ?? move.fen ?? move.san;
+}
+function OpeningBookInner({
+  moves = [],
+  title = "Opening book",
+  loading = false,
+  errorText,
+  emptyText = "No book moves for this position.",
+  selectedMove = null,
+  colorScheme,
+  onMovePress,
+  interactionPolicy,
+  testID
+}) {
+  const { theme } = useZoraTheme2();
+  const colors = createOpeningBookColorScheme(theme, colorScheme);
+  const stateText = loading ? "Loading opening moves…" : errorText ?? emptyText;
+  const showState = loading || errorText !== undefined || moves.length === 0;
+  return /* @__PURE__ */ jsxs2(import_react_native2.View, {
+    accessibilityLabel: title,
+    style: [
+      styles2.root,
+      {
+        borderColor: colors.border,
+        backgroundColor: colors.surface
+      }
+    ],
+    testID,
+    children: [
+      /* @__PURE__ */ jsx2(import_react_native2.Text, {
+        style: [styles2.title, { color: colors.titleText }],
+        children: title
+      }),
+      !showState ? /* @__PURE__ */ jsx2(import_react_native2.View, {
+        style: styles2.moves,
+        children: moves.map((move) => {
+          const selected = selectedMove !== null && (selectedMove === move.san || selectedMove === move.uci || selectedMove === move.fen);
+          const details = [
+            move.eco,
+            move.name,
+            move.games === undefined ? undefined : `${move.games} games`
+          ].filter((part) => typeof part === "string" && part.length > 0);
+          const stats = [
+            rate("W", move.whiteWinRate),
+            rate("D", move.drawRate),
+            rate("B", move.blackWinRate)
+          ].filter((part) => part !== undefined);
+          return /* @__PURE__ */ jsxs2(import_react_native2.Pressable, {
+            accessibilityRole: "button",
+            disabled: onMovePress === undefined || interactionPolicy === "passive",
+            onPress: () => {
+              if (interactionPolicy === "passive")
+                return;
+              onMovePress?.(move);
+            },
+            style: [
+              styles2.move,
+              {
+                backgroundColor: selected ? colors.selectedSurface : colors.surfaceHover,
+                borderColor: colors.border
+              }
+            ],
+            testID: testID ? `${testID}-move-${move.san}` : undefined,
+            children: [
+              /* @__PURE__ */ jsxs2(import_react_native2.View, {
+                style: styles2.moveMain,
+                children: [
+                  /* @__PURE__ */ jsx2(import_react_native2.Text, {
+                    style: [styles2.san, { color: colors.primaryText }],
+                    children: move.san
+                  }),
+                  /* @__PURE__ */ jsx2(import_react_native2.Text, {
+                    style: [styles2.meta, { color: colors.secondaryText }],
+                    children: details.length > 0 ? details.join(" · ") : "Book move"
+                  })
+                ]
+              }),
+              stats.length > 0 ? /* @__PURE__ */ jsx2(import_react_native2.View, {
+                style: [styles2.metric, { backgroundColor: colors.metricSurface }],
+                children: /* @__PURE__ */ jsx2(import_react_native2.Text, {
+                  style: [styles2.metricText, { color: colors.secondaryText }],
+                  children: stats.join(" ")
+                })
+              }) : null
+            ]
+          }, moveKey(move));
+        })
+      }) : /* @__PURE__ */ jsx2(import_react_native2.Text, {
+        style: [styles2.stateText, { color: colors.secondaryText }],
+        children: stateText
+      })
+    ]
+  });
+}
+var styles2 = import_react_native2.StyleSheet.create({
+  root: { borderRadius: 12, borderWidth: import_react_native2.StyleSheet.hairlineWidth, gap: 10, padding: 12 },
+  title: { fontSize: 15, fontWeight: "700", lineHeight: 20 },
+  stateText: { fontSize: 13, lineHeight: 18 },
+  moves: { gap: 8 },
+  move: {
+    alignItems: "center",
+    borderRadius: 10,
+    borderWidth: import_react_native2.StyleSheet.hairlineWidth,
+    flexDirection: "row",
+    gap: 10,
+    justifyContent: "space-between",
+    paddingHorizontal: 10,
+    paddingVertical: 8
+  },
+  moveMain: { flex: 1, gap: 2 },
+  san: { fontSize: 16, fontWeight: "700", lineHeight: 20 },
+  meta: { fontSize: 12, lineHeight: 16 },
+  metric: { borderRadius: 999, paddingHorizontal: 8, paddingVertical: 4 },
+  metricText: { fontSize: 11, fontWeight: "600" }
+});
+export { ChessBoard2, OpeningBook2 };