chess.js
Version:
[](https://github.com/jhlywa/chess.js/actions) [](https://www.npmjs.com/package/chess.js) [
1,742 lines (1,619 loc) • 107 kB
JavaScript
'use strict';
// @generated by Peggy 4.2.0.
//
// https://peggyjs.org/
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);
// istanbul ignore next Check is a necessary evil to support older environments
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 += "\n --> " + loc + "\n"
+ filler + " |\n"
+ offset_s.line + " | " + line + "\n"
+ filler + " | " + peg$padEnd("", s.column - 1, ' ')
+ peg$padEnd("", hatLen, "^");
} else {
str += "\n 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", "\n"], 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", "\n"], 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: text, ignoreCase: ignoreCase };
}
function peg$classExpectation(parts, inverted, ignoreCase) {
return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
}
function peg$endExpectation() {
return { type: "end" };
}
function peg$otherExpectation(description) {
return { type: "other", description: 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 /** @type {any} */ ({
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)
);
}
}
/**
* @license
* Copyright (c) 2025, Jeff Hlywa (jhlywa@gmail.com)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
const MASK64 = 0xffffffffffffffffn;
function rotl(x, k) {
return ((x << k) | (x >> (64n - k))) & 0xffffffffffffffffn;
}
function wrappingMul(x, y) {
return (x * y) & MASK64;
}
// xoroshiro128**
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;
};
}
const rand = xoroshiro128(0xa187eb39cdcaed8f31c4b365b102e01en);
const PIECE_KEYS = Array.from({ length: 2 }, () => Array.from({ length: 6 }, () => Array.from({ length: 128 }, () => rand())));
const EP_KEYS = Array.from({ length: 8 }, () => rand());
const CASTLING_KEYS = Array.from({ length: 16 }, () => rand());
const SIDE_KEY = rand();
const WHITE = 'w';
const BLACK = 'b';
const PAWN = 'p';
const KNIGHT = 'n';
const BISHOP = 'b';
const ROOK = 'r';
const QUEEN = 'q';
const KING = 'k';
const DEFAULT_POSITION = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1';
class Move {
color;
from;
to;
piece;
captured;
promotion;
/**
* @deprecated This field is deprecated and will be removed in version 2.0.0.
* Please use move descriptor functions instead: `isCapture`, `isPromotion`,
* `isEnPassant`, `isKingsideCastle`, `isQueensideCastle`, `isCastle`, and
* `isBigPawn`
*/
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;
/*
* HACK: The chess['_method']() calls below invoke private methods in the
* Chess class to generate SAN and FEN. It's a bit of a hack, but makes the
* code cleaner elsewhere.
*/
this.san = chess['_moveToSan'](internal, chess['_moves']({ legal: true }));
this.lan = fromAlgebraic + toAlgebraic;
this.before = chess.fen();
// Generate the FEN for the 'after' key
chess['_makeMove'](internal);
this.after = chess.fen();
chess['_undoMove']();
// Build the text representation of the move flags
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;
}
}
const EMPTY = -1;
const FLAGS = {
NORMAL: 'n',
CAPTURE: 'c',
BIG_PAWN: 'b',
EP_CAPTURE: 'e',
PROMOTION: 'p',
KSIDE_CASTLE: 'k',
QSIDE_CASTLE: 'q',
NULL_MOVE: '-',
};
// prettier-ignore
const SQUARES = [
'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8',
'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7',
'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6',
'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5',
'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4',
'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3',
'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2',
'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1'
];
const BITS = {
NORMAL: 1,
CAPTURE: 2,
BIG_PAWN: 4,
EP_CAPTURE: 8,
PROMOTION: 16,
KSIDE_CASTLE: 32,
QSIDE_CASTLE: 64,
NULL_MOVE: 128,
};
/* eslint-disable @typescript-eslint/naming-convention */
// these are required, according to spec
const SEVEN_TAG_ROSTER = {
Event: '?',
Site: '?',
Date: '????.??.??',
Round: '?',
White: '?',
Black: '?',
Result: '*',
};
/**
* These nulls are placeholders to fix the order of tags (as they appear in PGN spec); null values will be
* eliminated in getHeaders()
*/
const 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,
};
const HEADER_TEMPLATE = {
...SEVEN_TAG_ROSTER,
...SUPLEMENTAL_TAGS,
};
/* eslint-enable @typescript-eslint/naming-convention */
/*
* NOTES ABOUT 0x88 MOVE GENERATION ALGORITHM
* ----------------------------------------------------------------------------
* From https://github.com/jhlywa/chess.js/issues/230
*
* A lot of people are confused when they first see the internal representation
* of chess.js. It uses the 0x88 Move Generation Algorithm which internally
* stores the board as an 8x16 array. This is purely for efficiency but has a
* couple of interesting benefits:
*
* 1. 0x88 offers a very inexpensive "off the board" check. Bitwise AND (&) any
* square with 0x88, if the result is non-zero then the square is off the
* board. For example, assuming a knight square A8 (0 in 0x88 notation),
* there are 8 possible directions in which the knight can move. These
* directions are relative to the 8x16 board and are stored in the
* PIECE_OFFSETS map. One possible move is A8 - 18 (up one square, and two
* squares to the left - which is off the board). 0 - 18 = -18 & 0x88 = 0x88
* (because of two-complement representation of -18). The non-zero result
* means the square is off the board and the move is illegal. Take the
* opposite move (from A8 to C7), 0 + 18 = 18 & 0x88 = 0. A result of zero
* means the square is on the board.
*
* 2. The relative distance (or difference) between two squares on a 8x16 board
* is unique and can be used to inexpensively determine if a piece on a
* square can attack any other arbitrary square. For example, let's see if a
* pawn on E7 can attack E2. The difference between E7 (20) - E2 (100) is
* -80. We add 119 to make the ATTACKS array index non-negative (because the
* worst case difference is A8 - H1 = -119). The ATTACKS array contains a
* bitmask of pieces that can attack from that distance and direction.
* ATTACKS[-80 + 119=39] gives us 24 or 0b11000 in binary. Look at the
* PIECE_MASKS map to determine the mask for a given piece type. In our pawn
* example, we would check to see if 24 & 0x1 is non-zero, which it is
* not. So, naturally, a pawn on E7 can't attack a piece on E2. However, a
* rook can since 24 & 0x8 is non-zero. The only thing left to check is that
* there are no blocking pieces between E7 and E2. That's where the RAYS
* array comes in. It provides an offset (in this case 16) to add to E7 (20)
* to check for blocking pieces. E7 (20) + 16 = E6 (36) + 16 = E5 (52) etc.
*/
// prettier-ignore
// eslint-disable-next-line
const 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
};
const PAWN_OFFSETS = {
b: [16, 32, 17, 15],
w: [-16, -32, -17, -15],
};
const 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],
};
// prettier-ignore
const 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
];
// prettier-ignore
const 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
];
const PIECE_MASKS = { p: 0x1, n: 0x2, b: 0x4, r: 0x8, q: 0x10, k: 0x20 };
const SYMBOLS = 'pnbrqkPNBRQK';
const PROMOTIONS = [KNIGHT, BISHOP, ROOK, QUEEN];
const RANK_1 = 7;
const RANK_2 = 6;
/*
* const RANK_3 = 5
* const RANK_4 = 4
* const RANK_5 = 3
* const RANK_6 = 2
*/
const RANK_7 = 1;
const RANK_8 = 0;
const SIDES = {
[KING]: BITS.KSIDE_CASTLE,
[QUEEN]: BITS.QSIDE_CASTLE,
};
const 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 },
],
};
const SECOND_RANK = { b: RANK_7, w: RANK_2 };
const SAN_NULLMOVE = '--';
// Extracts the zero-based rank of an 0x88 square.
function rank(square) {
return square >> 4;
}
// Extracts the zero-based file of an 0x88 square.
function file(square) {
return square & 0xf;
}
function isDigit(c) {
return '0123456789'.indexOf(c) !== -1;
}
// Converts a 0x88 square to algebraic notation.
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) {
// 1st criterion: 6 space-seperated fields?
const tokens = fen.split(/\s+/);
if (tokens.length !== 6) {
return {
ok: false,
error: 'Invalid FEN: must contain six space-delimited fields',
};
}
// 2nd criterion: move number field is a integer value > 0?
const moveNumber = parseInt(tokens[5], 10);
if (isNaN(moveNumber) || moveNumber <= 0) {
return {
ok: false,
error: 'Invalid FEN: move number must be a positive integer',
};
}
// 3rd criterion: half move counter is an integer >= 0?
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',
};
}
// 4th criterion: 4th field is a valid e.p.-string?
if (!/^(-|[abcdefgh][36])$/.test(tokens[3])) {
return { ok: false, error: 'Invalid FEN: en-passant square is invalid' };
}
// 5th criterion: 3th field is a valid castle-string?
if (/[^kKqQ-]/.test(tokens[2])) {
return { ok: false, error: 'Invalid FEN: castling availability is invalid' };
}
// 6th criterion: 2nd field is "w" (white) or "b" (black)?
if (!/^(w|b)$/.test(tokens[1])) {
return { ok: false, error: 'Invalid FEN: side-to-move is invalid' };
}
// 7th criterion: 1st field contains 8 rows?
const rows = tokens[0].split('/');
if (rows.length !== 8) {
return {
ok: false,
error: "Invalid FEN: piece data does not contain 8 '/'-delimited rows",
};
}
// 8th criterion: every row is valid?
for (let i = 0; i < rows.length; i++) {
// check for right sum of fields AND not two numbers in succession
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)',
};
}
}
// 9th criterion: is en-passant square legal?
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' };
}
// 10th criterion: does chess position contain exact two kings?
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` };
}
}
// 11th criterion: are any pawns on the first or eighth rows?
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 };
}
// this function is used to uniquely identify ambiguous moves
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 a move of the same piece type ends on the same to square, we'll need
* to add a disambiguator to the algebraic notation
*/
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) {
/*
* if there exists a similar moving piece on the same rank and file as
* the move in question, use the square as the disambiguator
*/
return algebraic(from);
}
else if (sameFile > 0) {
/*
*