@echecs/pgn 1.0.0 → 2.1.2

package/dist/grammar.js

@@ -1,4 +1,4 @@
-// Generated automatically by nearley, version 2.19.2
+// Generated automatically by nearley, version 2.20.1
 // http://github.com/Hardmath123/nearley
 (function () {
 function id(x) { return x[0]; }
@@ -126,41 +126,70 @@ var grammar = {
     {"name": "DATABASE$ebnf$1", "symbols": ["GAME"]},
     {"name": "DATABASE$ebnf$1", "symbols": ["DATABASE$ebnf$1", "GAME"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "DATABASE", "symbols": ["DATABASE$ebnf$1"], "postprocess": id},
-    {"name": "GAME", "symbols": ["TAGS", "__", "MOVES", "__", "result", "__"], "postprocess": 
-        (d) => ({ meta: d[0], moves: d[2], result: d[4] })
+    {"name": "GAME", "symbols": ["TAGS", "MOVE_SECTION", "__", "result", "__"], "postprocess": 
+        (d) => ({ meta: d[0], moves: d[1], result: d[3] })
         },
-    {"name": "TAGS$ebnf$1", "symbols": ["TAG"]},
-    {"name": "TAGS$ebnf$1", "symbols": ["TAGS$ebnf$1", "TAG"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
-    {"name": "TAGS", "symbols": ["TAGS$ebnf$1"], "postprocess": (d) => d[0].reduce((acc, item) => ({ ...acc, ...item }), {})},
-    {"name": "TAG", "symbols": [{"literal":"["}, "NAME", "__", "VALUE", {"literal":"]"}, "__"], "postprocess": (d) => ({ [d[1]]: d[3] })},
+    {"name": "TAGS$ebnf$1$subexpression$1", "symbols": ["TAG", "__"]},
+    {"name": "TAGS$ebnf$1", "symbols": ["TAGS$ebnf$1$subexpression$1"]},
+    {"name": "TAGS$ebnf$1$subexpression$2", "symbols": ["TAG", "__"]},
+    {"name": "TAGS$ebnf$1", "symbols": ["TAGS$ebnf$1", "TAGS$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "TAGS", "symbols": ["TAGS$ebnf$1"], "postprocess": (d) => d[0].map(d0 => d0[0]).reduce((acc, item) => ({ ...acc, ...item }), {})},
+    {"name": "TAG", "symbols": [{"literal":"["}, "NAME", "__", "VALUE", {"literal":"]"}], "postprocess": (d) => ({ [d[1]]: d[3] })},
     {"name": "NAME", "symbols": ["string"]},
     {"name": "VALUE", "symbols": ["dqstring"], "postprocess": id},
+    {"name": "MOVE_SECTION$ebnf$1", "symbols": []},
+    {"name": "MOVE_SECTION$ebnf$1$subexpression$1", "symbols": ["_", "MOVE"]},
+    {"name": "MOVE_SECTION$ebnf$1", "symbols": ["MOVE_SECTION$ebnf$1", "MOVE_SECTION$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "MOVE_SECTION$ebnf$2$subexpression$1", "symbols": ["_", "HM_WHITE"]},
+    {"name": "MOVE_SECTION$ebnf$2", "symbols": ["MOVE_SECTION$ebnf$2$subexpression$1"], "postprocess": id},
+    {"name": "MOVE_SECTION$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "MOVE_SECTION", "symbols": ["MOVE", "MOVE_SECTION$ebnf$1", "MOVE_SECTION$ebnf$2"], "postprocess": 
+        (d) => {
+            const moves = [d[0]];
+        
+            if (d[1].length > 0) {
+                const d1 = d[1];
+        
+                moves.push(...d1.map(d => d[1]));
+            }
+        
+            if (d[2]) {
+                const d2 = d[2];
+        
+                moves.push(d2[1]);
+            }
+        
+            return moves;
+        }
+            },
+    {"name": "MOVE_SECTION", "symbols": ["HM_WHITE"], "postprocess": d => [d[0]]},
     {"name": "MOVES$ebnf$1", "symbols": []},
-    {"name": "MOVES$ebnf$1", "symbols": ["MOVES$ebnf$1", "MOVE"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
-    {"name": "MOVES$ebnf$2", "symbols": ["HALFMOVE"], "postprocess": id},
+    {"name": "MOVES$ebnf$1$subexpression$1", "symbols": ["_", "MOVE"]},
+    {"name": "MOVES$ebnf$1", "symbols": ["MOVES$ebnf$1", "MOVES$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "MOVES$ebnf$2$subexpression$1", "symbols": ["_", "HM_WHITE"]},
+    {"name": "MOVES$ebnf$2", "symbols": ["MOVES$ebnf$2$subexpression$1"], "postprocess": id},
     {"name": "MOVES$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "MOVES", "symbols": ["MOVES$ebnf$1", "MOVES$ebnf$2"], "postprocess": 
         (d) => {
             const moves = [];
-            const assign = (number, ...move) => {
-                moves[number - 1] = move;
-            };
         
-            d[0].map(dd0 => assign(...dd0));
+            if (d[0]) {
+                d[0].map(d0 => d0[1]).map(d01 => moves.push(d01));
+            }
         
             if (d[1]) {
-                assign(...d[1]);
+                moves.push(d[1][1]);
             }
         
             return moves;
         }
         },
-    {"name": "HALFMOVE$ebnf$1$subexpression$1", "symbols": ["_", "VARIATION"]},
-    {"name": "HALFMOVE$ebnf$1", "symbols": ["HALFMOVE$ebnf$1$subexpression$1"], "postprocess": id},
-    {"name": "HALFMOVE$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
-    {"name": "HALFMOVE", "symbols": ["NUMBER", "_", "SAN", "HALFMOVE$ebnf$1", "_"], "postprocess": 
+    {"name": "HM_WHITE$ebnf$1", "symbols": []},
+    {"name": "HM_WHITE$ebnf$1$subexpression$1", "symbols": ["_", "VARIANT"]},
+    {"name": "HM_WHITE$ebnf$1", "symbols": ["HM_WHITE$ebnf$1", "HM_WHITE$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "HM_WHITE", "symbols": ["NUMBER", "_", "SAN", "HM_WHITE$ebnf$1"], "postprocess": 
         (d) => {
-            const move = [d[0], {...d[2], ...(d[3] && { variation: d[3][1] }), }];
+            const move = [d[0], {...d[2], ...(d[3].length > 0 && { variants: d[3].map(d3 => d3[1]) }), }];
         
             if (move[1].castling) {
                 move[1].to = move[1].castling === 'K' ? 'g1' : 'c1';
@@ -170,155 +199,201 @@ var grammar = {
             return move;
         }
         },
-    {"name": "MOVE$ebnf$1$subexpression$1", "symbols": ["_", "VARIATION"]},
-    {"name": "MOVE$ebnf$1", "symbols": ["MOVE$ebnf$1$subexpression$1"], "postprocess": id},
-    {"name": "MOVE$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
-    {"name": "MOVE", "symbols": ["NUMBER", "_", "SAN", "__", "SAN", "MOVE$ebnf$1", "_"], "postprocess": 
+    {"name": "HM_BLACK$ebnf$1", "symbols": []},
+    {"name": "HM_BLACK$ebnf$1$subexpression$1", "symbols": ["_", "VARIANT"]},
+    {"name": "HM_BLACK$ebnf$1", "symbols": ["HM_BLACK$ebnf$1", "HM_BLACK$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "HM_BLACK", "symbols": ["_", "NUMBER", "continuation", "_", "SAN", "HM_BLACK$ebnf$1"], "postprocess": 
         (d) => {
-            const move = [d[0], d[2], d[4]];
-        
-            if (move[1].castling) {
-                move[1].to = move[1].castling === 'K' ? 'g1' : 'c1';
-                move[1].castling = true;
-            }
+            const move = [d[1], undefined, {...d[4], ...(d[5].length > 0 && { variants: d[5].map(d5 => d5[1]) }) }];
         
             if (move[2].castling) {
                 move[2].to = move[2].castling === 'K' ? 'g8' : 'c8';
                 move[2].castling = true;
             }
         
-            if (d[5]) {
-                const variant = d[5][1];
-                const isWhite = variant[0][0] !== undefined;
-        
-                move[isWhite ? 1 : 2].variation = d[5][1];
-            }
-        
             return move;
         }
         },
-    {"name": "VARIATION", "symbols": [{"literal":"("}, "MOVES", {"literal":")"}], "postprocess": 
-        (d) => [...d[1].values()].filter(Boolean)
-            },
-    {"name": "VARIATION", "symbols": [{"literal":"("}, "MOVES_BLACK", {"literal":")"}], "postprocess": 
-        (d) => [...d[1].values()].filter(Boolean)
-            },
-    {"name": "MOVES_BLACK$ebnf$1", "symbols": ["MOVES"], "postprocess": id},
-    {"name": "MOVES_BLACK$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
-    {"name": "MOVES_BLACK", "symbols": ["HALFMOVE_BLACK", "MOVES_BLACK$ebnf$1"], "postprocess": 
+    {"name": "MOVE$ebnf$1", "symbols": []},
+    {"name": "MOVE$ebnf$1$subexpression$1", "symbols": ["_", "VARIANT"]},
+    {"name": "MOVE$ebnf$1", "symbols": ["MOVE$ebnf$1", "MOVE$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "MOVE", "symbols": ["NUMBER", "_", "SAN", "__", "SAN", "MOVE$ebnf$1"], "postprocess": 
         (d) => {
-            const moves = d[1] || [];
-        
-            const assign = (number, ...move) => {
-                moves[number - 1] = move;
-            };
+            const move = [d[0], d[2], d[4]];
         
-            if (d[0]) {
-                assign(...d[0]);
+            if (move[1].castling) {
+                move[1].to = move[1].castling === 'K' ? 'g1' : 'c1';
+                move[1].castling = true;
             }
         
-            return moves;
-        }
-        },
-    {"name": "HALFMOVE_BLACK$ebnf$1$subexpression$1", "symbols": ["_", "VARIATION"]},
-    {"name": "HALFMOVE_BLACK$ebnf$1", "symbols": ["HALFMOVE_BLACK$ebnf$1$subexpression$1"], "postprocess": id},
-    {"name": "HALFMOVE_BLACK$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
-    {"name": "HALFMOVE_BLACK", "symbols": ["NUMBER", "continuation", "_", "SAN", "HALFMOVE_BLACK$ebnf$1", "_"], "postprocess": 
-        (d) => {
-            const move = [
-                d[0],
-                undefined,
-                {...d[3], ...(d[4] && { variation: d[4][1] }), }
-            ];
-        
             if (move[2].castling) {
                 move[2].to = move[2].castling === 'K' ? 'g8' : 'c8';
                 move[2].castling = true;
             }
         
+            if (d[5]) {
+                const variants = d[5].map(d5 => d5[1]);
+        
+                const white = variants.filter(variant => variant[0][1]);
+                const black = variants.filter(variant => !variant[0][1]);
+        
+                if (white.length > 0) {
+                    move[1].variants = white;
+                }
+        
+                if (black.length > 0) {
+                    move[2].variants = black;
+                }
+            }
+        
             return move;
         }
-        },
-    {"name": "NUMBER$ebnf$1", "symbols": []},
-    {"name": "NUMBER$ebnf$1", "symbols": ["NUMBER$ebnf$1", {"literal":"."}], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+            },
+    {"name": "MOVE", "symbols": ["HM_WHITE", "__", "HM_BLACK"], "postprocess": 
+        d => [d[0][0], d[0][1], d[2][2]]
+            },
+    {"name": "NUMBER$ebnf$1", "symbols": [{"literal":"."}], "postprocess": id},
+    {"name": "NUMBER$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "NUMBER", "symbols": ["unsigned_int", "NUMBER$ebnf$1"], "postprocess": (d) => d[0]},
+    {"name": "VARIANT", "symbols": [{"literal":"("}, "MOVES", "_", {"literal":")"}], "postprocess": 
+        (d) => d[1]
+            },
+    {"name": "VARIANT", "symbols": [{"literal":"("}, "HM_BLACK", "MOVES", "_", {"literal":")"}], "postprocess": 
+        (d) => [d[1], ...d[2]]
+            },
     {"name": "SAN$ebnf$1", "symbols": ["piece"], "postprocess": id},
     {"name": "SAN$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "SAN$ebnf$2", "symbols": ["DISAMBIGUATION"], "postprocess": id},
     {"name": "SAN$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "SAN$ebnf$3", "symbols": ["capture"], "postprocess": id},
     {"name": "SAN$ebnf$3", "symbols": [], "postprocess": function(d) {return null;}},
-    {"name": "SAN$ebnf$4", "symbols": ["promotion"], "postprocess": id},
+    {"name": "SAN$ebnf$4", "symbols": ["PROMOTION"], "postprocess": id},
     {"name": "SAN$ebnf$4", "symbols": [], "postprocess": function(d) {return null;}},
-    {"name": "SAN$ebnf$5", "symbols": []},
-    {"name": "SAN$ebnf$5$subexpression$1", "symbols": ["_", "annotation"]},
-    {"name": "SAN$ebnf$5", "symbols": ["SAN$ebnf$5", "SAN$ebnf$5$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "SAN$ebnf$5$subexpression$1", "symbols": ["_", "SUFFIX"]},
+    {"name": "SAN$ebnf$5", "symbols": ["SAN$ebnf$5$subexpression$1"], "postprocess": id},
+    {"name": "SAN$ebnf$5", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "SAN$ebnf$6", "symbols": []},
     {"name": "SAN$ebnf$6$subexpression$1", "symbols": ["_", "COMMENT"]},
-    {"name": "SAN$ebnf$6", "symbols": ["SAN$ebnf$6$subexpression$1"], "postprocess": id},
-    {"name": "SAN$ebnf$6", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "SAN$ebnf$6", "symbols": ["SAN$ebnf$6", "SAN$ebnf$6$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "SAN", "symbols": ["SAN$ebnf$1", "SAN$ebnf$2", "SAN$ebnf$3", "file", "rank", "SAN$ebnf$4", "SAN$ebnf$5", "SAN$ebnf$6"], "postprocess": 
-        (d) => ({
-            ...(d[6].length > 0 && { annotations: d[6].map(([_, a]) => a) }),
-            ...(d[7] && { comment: d[7][1] }),
-            ...(d[1] && { from: d[1][0] }),
-            piece: d[0] ? d[0][0] : 'P',
-            ...(d[5] && { promotion: d[5] }),
-            to: `${d[3]}${d[4]}`,
-        })
+        (d) => {
+            const comments = d[7].map(d7 => d7[1]).filter(Boolean);
+        
+            return  ({
+               ...(d[6] && d[6][1]),
+               ...(comments.length > 0 && { comment: comments.reduce((acc, item) => `${acc} ${item}`, '') }),
+               ...(d[2] && { capture: true }),
+               ...(d[1] && { from: d[1][0] }),
+               piece: d[0] ? d[0][0] : 'P',
+               ...(d[5] && { promotion: d[5] }),
+               to: `${d[3]}${d[4]}`,
+            });
+        }
             },
     {"name": "SAN$ebnf$7", "symbols": []},
-    {"name": "SAN$ebnf$7$subexpression$1", "symbols": ["_", "annotation"]},
+    {"name": "SAN$ebnf$7$subexpression$1", "symbols": ["_", "SUFFIX"]},
     {"name": "SAN$ebnf$7", "symbols": ["SAN$ebnf$7", "SAN$ebnf$7$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "SAN$ebnf$8", "symbols": []},
     {"name": "SAN$ebnf$8$subexpression$1", "symbols": ["_", "COMMENT"]},
-    {"name": "SAN$ebnf$8", "symbols": ["SAN$ebnf$8$subexpression$1"], "postprocess": id},
-    {"name": "SAN$ebnf$8", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "SAN$ebnf$8", "symbols": ["SAN$ebnf$8", "SAN$ebnf$8$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "SAN", "symbols": ["castling", "SAN$ebnf$7", "SAN$ebnf$8"], "postprocess": 
-        (d) => ({
-            ...(d[1].length > 0 && { annotations: d[1].map(([_, a]) => a) }),
-            ...(d[2] && { comment: d[2][1] }),
-            castling: d[0],
-            piece: 'K'
-        })
+        (d) => {
+            const comments = d[2].map(d2 => d2[1]).filter(Boolean);
+        
+            return ({
+               ...(d[1]),
+               ...(comments.length > 0 && { comment: comments.reduce((acc, item) => `${acc} ${item}`, '') }),
+               castling: d[0],
+               piece: 'K'
+            })
+        }
             },
     {"name": "DISAMBIGUATION", "symbols": ["file"], "postprocess": id},
     {"name": "DISAMBIGUATION", "symbols": ["rank"], "postprocess": id},
+    {"name": "PROMOTION", "symbols": [{"literal":"="}, /[QBNR]/], "postprocess": (d) => d[1]},
+    {"name": "SUFFIX$subexpression$1", "symbols": ["check"]},
+    {"name": "SUFFIX$subexpression$1", "symbols": ["checkmate"]},
+    {"name": "SUFFIX$ebnf$1", "symbols": ["annotation"], "postprocess": id},
+    {"name": "SUFFIX$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "SUFFIX$ebnf$2", "symbols": []},
+    {"name": "SUFFIX$ebnf$2$subexpression$1", "symbols": ["_", "NAG"]},
+    {"name": "SUFFIX$ebnf$2", "symbols": ["SUFFIX$ebnf$2", "SUFFIX$ebnf$2$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "SUFFIX", "symbols": ["SUFFIX$subexpression$1", "SUFFIX$ebnf$1", "SUFFIX$ebnf$2"], "postprocess": 
+        (d) => ({
+            ...(d[0] && { [d[0]]: true }),
+            ...((d[1] || d[2].length > 0) && { annotations: [...(d[1] ? [d[1]] : []), ...d[2].map(d2 => d2[1])] }),
+        })
+            },
+    {"name": "SUFFIX$ebnf$3$subexpression$1", "symbols": ["check"]},
+    {"name": "SUFFIX$ebnf$3$subexpression$1", "symbols": ["checkmate"]},
+    {"name": "SUFFIX$ebnf$3", "symbols": ["SUFFIX$ebnf$3$subexpression$1"], "postprocess": id},
+    {"name": "SUFFIX$ebnf$3", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "SUFFIX$ebnf$4", "symbols": []},
+    {"name": "SUFFIX$ebnf$4$subexpression$1", "symbols": ["_", "NAG"]},
+    {"name": "SUFFIX$ebnf$4", "symbols": ["SUFFIX$ebnf$4", "SUFFIX$ebnf$4$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "SUFFIX", "symbols": ["SUFFIX$ebnf$3", "annotation", "SUFFIX$ebnf$4"], "postprocess": 
+        (d) => ({
+            ...(d[0] && { [d[0]]: true }),
+            ...((d[1] || d[2].length > 0) && { annotations: [...(d[1] ? [d[1]] : []), ...d[2].map(d2 => d2[1])] }),
+        })
+            },
+    {"name": "SUFFIX$ebnf$5$subexpression$1", "symbols": ["check"]},
+    {"name": "SUFFIX$ebnf$5$subexpression$1", "symbols": ["checkmate"]},
+    {"name": "SUFFIX$ebnf$5", "symbols": ["SUFFIX$ebnf$5$subexpression$1"], "postprocess": id},
+    {"name": "SUFFIX$ebnf$5", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "SUFFIX$ebnf$6", "symbols": ["annotation"], "postprocess": id},
+    {"name": "SUFFIX$ebnf$6", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "SUFFIX$ebnf$7$subexpression$1", "symbols": ["_", "NAG"]},
+    {"name": "SUFFIX$ebnf$7", "symbols": ["SUFFIX$ebnf$7$subexpression$1"]},
+    {"name": "SUFFIX$ebnf$7$subexpression$2", "symbols": ["_", "NAG"]},
+    {"name": "SUFFIX$ebnf$7", "symbols": ["SUFFIX$ebnf$7", "SUFFIX$ebnf$7$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "SUFFIX", "symbols": ["SUFFIX$ebnf$5", "SUFFIX$ebnf$6", "SUFFIX$ebnf$7"], "postprocess": 
+        (d) => ({
+            ...(d[0] && { [d[0]]: true }),
+            ...((d[1] || d[2].length > 0) && { annotations: [...(d[1] ? [d[1]] : []), ...d[2].map(d2 => d2[1])] }),
+        })
+            },
+    {"name": "NAG$subexpression$1$string$1", "symbols": [{"literal":"2"}, {"literal":"5"}], "postprocess": function joiner(d) {return d.join('');}},
+    {"name": "NAG$subexpression$1", "symbols": ["NAG$subexpression$1$string$1", /[0-5]/]},
+    {"name": "NAG$subexpression$1", "symbols": [{"literal":"2"}, /[0-4]/, /[0-9]/]},
+    {"name": "NAG$subexpression$1", "symbols": [{"literal":"1"}, /[0-9]/, /[0-9]/]},
+    {"name": "NAG$subexpression$1", "symbols": [/[1-9]/, /[0-9]/]},
+    {"name": "NAG$subexpression$1", "symbols": [/[0-9]/]},
+    {"name": "NAG", "symbols": [{"literal":"$"}, "NAG$subexpression$1"], "postprocess": 
+        (d) => d[1]
+        },
     {"name": "COMMENT", "symbols": ["bstring"]},
+    {"name": "COMMENT$ebnf$1", "symbols": []},
+    {"name": "COMMENT$ebnf$1", "symbols": ["COMMENT$ebnf$1", /[^\n]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "COMMENT", "symbols": [{"literal":";"}, "COMMENT$ebnf$1"]},
     {"name": "annotation$string$1", "symbols": [{"literal":"!"}, {"literal":"!"}], "postprocess": function joiner(d) {return d.join('');}},
     {"name": "annotation", "symbols": ["annotation$string$1"], "postprocess": id},
     {"name": "annotation", "symbols": [{"literal":"!"}], "postprocess": id},
     {"name": "annotation$string$2", "symbols": [{"literal":"!"}, {"literal":"?"}], "postprocess": function joiner(d) {return d.join('');}},
     {"name": "annotation", "symbols": ["annotation$string$2"], "postprocess": id},
-    {"name": "annotation", "symbols": [{"literal":"#"}], "postprocess": () => 'checkmate'},
-    {"name": "annotation$string$3", "symbols": [{"literal":"$"}, {"literal":"1"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$3"], "postprocess": () => '!'},
-    {"name": "annotation$string$4", "symbols": [{"literal":"$"}, {"literal":"2"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$4"], "postprocess": () => '?'},
-    {"name": "annotation$string$5", "symbols": [{"literal":"$"}, {"literal":"3"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$5"], "postprocess": () => '!!'},
-    {"name": "annotation$string$6", "symbols": [{"literal":"$"}, {"literal":"4"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$6"], "postprocess": () => '!?'},
-    {"name": "annotation$string$7", "symbols": [{"literal":"$"}, {"literal":"5"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$7"], "postprocess": () => '?!'},
-    {"name": "annotation$string$8", "symbols": [{"literal":"$"}, {"literal":"6"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$8"], "postprocess": () => '??'},
-    {"name": "annotation", "symbols": [{"literal":"+"}], "postprocess": () => 'check'},
-    {"name": "annotation$string$9", "symbols": [{"literal":"+"}, {"literal":"-"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$9"], "postprocess": id},
-    {"name": "annotation$string$10", "symbols": [{"literal":"-"}, {"literal":"+"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$10"], "postprocess": id},
+    {"name": "annotation$string$3", "symbols": [{"literal":"?"}, {"literal":"!"}], "postprocess": function joiner(d) {return d.join('');}},
+    {"name": "annotation", "symbols": ["annotation$string$3"], "postprocess": id},
+    {"name": "annotation", "symbols": [{"literal":"?"}], "postprocess": id},
+    {"name": "annotation$string$4", "symbols": [{"literal":"?"}, {"literal":"?"}], "postprocess": function joiner(d) {return d.join('');}},
+    {"name": "annotation", "symbols": ["annotation$string$4"], "postprocess": id},
+    {"name": "annotation$string$5", "symbols": [{"literal":"+"}, {"literal":"-"}], "postprocess": function joiner(d) {return d.join('');}},
+    {"name": "annotation", "symbols": ["annotation$string$5"], "postprocess": id},
+    {"name": "annotation$string$6", "symbols": [{"literal":"-"}, {"literal":"+"}], "postprocess": function joiner(d) {return d.join('');}},
+    {"name": "annotation", "symbols": ["annotation$string$6"], "postprocess": id},
     {"name": "annotation", "symbols": [{"literal":"="}], "postprocess": id},
-    {"name": "annotation$string$11", "symbols": [{"literal":"?"}, {"literal":"!"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$11"], "postprocess": id},
+    {"name": "annotation$string$7", "symbols": [{"literal":"?"}, {"literal":"!"}], "postprocess": function joiner(d) {return d.join('');}},
+    {"name": "annotation", "symbols": ["annotation$string$7"], "postprocess": id},
     {"name": "annotation", "symbols": [{"literal":"?"}], "postprocess": id},
-    {"name": "annotation$string$12", "symbols": [{"literal":"?"}, {"literal":"?"}], "postprocess": function joiner(d) {return d.join('');}},
-    {"name": "annotation", "symbols": ["annotation$string$12"], "postprocess": id},
-    {"name": "annotation", "symbols": [{"literal":"N"}], "postprocess": id},
+    {"name": "annotation$string$8", "symbols": [{"literal":"?"}, {"literal":"?"}], "postprocess": function joiner(d) {return d.join('');}},
+    {"name": "annotation", "symbols": ["annotation$string$8"], "postprocess": id},
     {"name": "annotation", "symbols": [{"literal":"±"}], "postprocess": id},
     {"name": "annotation", "symbols": [{"literal":"∓"}], "postprocess": id},
     {"name": "annotation", "symbols": [{"literal":"∞"}], "postprocess": id},
     {"name": "annotation", "symbols": [{"literal":"⨀"}], "postprocess": id},
     {"name": "annotation", "symbols": [{"literal":"⩱"}], "postprocess": id},
     {"name": "annotation", "symbols": [{"literal":"⩲"}], "postprocess": id},
+    {"name": "check", "symbols": [{"literal":"+"}], "postprocess": () => 'check'},
+    {"name": "checkmate", "symbols": [{"literal":"#"}], "postprocess": () => 'checkmate'},
     {"name": "bstring$ebnf$1", "symbols": []},
     {"name": "bstring$ebnf$1", "symbols": ["bstring$ebnf$1", /[^}]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "bstring", "symbols": [{"literal":"{"}, "bstring$ebnf$1", {"literal":"}"}], "postprocess": (d) => d[1].join('')},
@@ -331,7 +406,6 @@ var grammar = {
     {"name": "continuation", "symbols": ["continuation$string$1"]},
     {"name": "file", "symbols": [/[a-h]/]},
     {"name": "piece", "symbols": [/[KQBNR]/]},
-    {"name": "promotion", "symbols": [{"literal":"="}, /[QBNR]/], "postprocess": (d) => d[1]},
     {"name": "rank", "symbols": [/[1-8]/]},
     {"name": "result$string$1", "symbols": [{"literal":"1"}, {"literal":"-"}, {"literal":"0"}], "postprocess": function joiner(d) {return d.join('');}},
     {"name": "result", "symbols": ["result$string$1"], "postprocess": () => 1},

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+type File = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
+type Piece = 'B' | 'K' | 'N' | 'P' | 'Q' | 'R';
+type Rank = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8';
+type Result = '1-0' | '0-1' | '1/2-1/2' | '?';
+type Square = `${File}${Rank}`;
+type HalfMove = [number, undefined, Move];
+type VariantMove = Move | HalfMove;
+type VariantMoves = VariantMove[];
+type Move = {
+    annotations?: string[];
+    capture?: boolean;
+    castling?: boolean;
+    check?: boolean;
+    checkmate?: boolean;
+    comment?: string;
+    from?: File | Rank;
+    piece: Piece;
+    promotion?: Piece;
+    to: Square;
+    variants?: VariantMoves[];
+};
+type Meta = {
+    Result: Result;
+    [key: string]: string;
+};
+type Moves = [number, Move] | [number, Move, Move];
+type PGN = {
+    meta: Meta;
+    moves: Moves;
+    result: Result;
+};
+export default function parse(input: string): PGN[];
+export {};

package/dist/index.js

@@ -0,0 +1,14 @@
+import { Grammar, Parser } from 'nearley';
+import grammar from './grammar';
+function tokenize(input) {
+    const parser = new Parser(Grammar.fromCompiled(grammar));
+    parser.feed(input);
+    if (parser.results.length > 1) {
+        throw new Error(`@echecs/parser: Ambiguous syntax. Found ${parser.results.length} results`);
+    }
+    return parser.results[0];
+}
+export default function parse(input) {
+    const games = input.replace(/[\r\uFEFF]/g, '');
+    return tokenize(games);
+}

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package/package.json

@@ -1,55 +1,47 @@
 {
   "author": "Adrian de la Rosa <adrian@delarosab.me>",
   "dependencies": {
-    "nearley": "^2.19.2"
+    "nearley": "^2.20.1"
   },
+  "description": "FIDE PGN Parser",
   "devDependencies": {
-    "@babel/core": "^7.9.0",
-    "@babel/plugin-proposal-class-properties": "^7.8.3",
-    "@babel/plugin-proposal-export-namespace-from": "^7.8.3",
-    "@babel/preset-env": "^7.9.5",
-    "@rollup/plugin-commonjs": "^11.1.0",
-    "babel-eslint": "^10.1.0",
-    "eslint": "^6.8.0",
-    "eslint-config-prettier": "^6.11.0",
-    "eslint-config-standard": "^14.1.1",
-    "eslint-plugin-import": "^2.20.2",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^4.2.1",
-    "eslint-plugin-sort-keys-fix": "^1.1.1",
-    "eslint-plugin-standard": "^4.0.1",
-    "gitmoji-cli": "^3.2.3",
-    "husky": "^4.2.5",
-    "jest": "^25.4.0",
-    "jest-cli": "^25.4.0",
-    "lint-staged": "^10.1.7",
-    "prettier": "^2.0.5",
-    "rollup": "^2.7.2",
-    "rollup-plugin-babel": "^4.4.0",
-    "rollup-plugin-copy": "^3.3.0",
-    "rollup-plugin-size-snapshot": "^0.11.0",
-    "rollup-plugin-visualizer": "^4.0.4"
+    "@types/jest": "^29.2.5",
+    "@types/nearley": "^2.11.2",
+    "@typescript-eslint/eslint-plugin": "^5.48.0",
+    "@typescript-eslint/parser": "^5.48.0",
+    "eslint": "^8.31.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-config-standard": "^17.0.0",
+    "husky": "^8.0.3",
+    "jest": "^29.3.1",
+    "lint-staged": "^13.1.0",
+    "prettier": "^2.8.2",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.9.4"
   },
+  "keywords": [
+    "chess",
+    "fide",
+    "parser",
+    "pgn"
+  ],
   "license": "MIT",
-  "main": "index.js",
+  "main": "dist/index.js",
   "name": "@echecs/pgn",
   "repository": "mormubis/pgn",
   "scripts": {
-    "build": "rollup -c",
-    "build:ci": "npm run build",
-    "compile": "nearleyc src/grammar.ne -o src/grammar.js",
-    "coverage": "jest --coverage --no-cache --silent",
-    "coverage:ci": "npm run coverage -- --maxWorkers 4",
-    "format": "npm run format:ci -- --write",
-    "format:ci": "prettier --ignore-path .gitignore -l \"**/*.+(js|json|md|yml)\"",
-    "lint": "eslint \"**/*.js\" --fix",
-    "lint:ci": "npm run lint",
-    "prepare": "npm run compile && npm run build:ci",
-    "start": "rollup -c -w",
+    "build": "npm run grammar:compile && npm run compile && cp src/grammar.js dist/grammar.js",
+    "compile": "tsc",
+    "format": "prettier --ignore-path .gitignore \"src/**/*.+(js|json|md|yml)\" --write",
+    "grammar:compile": "nearleyc src/grammar.ne -o src/grammar.js",
+    "grammar:diagram": "nearley-railroad regex.ne -o diagram.html",
+    "grammar:test": "nearley-test -s DATABASE src/grammar.js < ./test.pgn",
+    "lint": "eslint \"src/**/*.ts\" --fix",
+    "prepare": "npm run build",
     "test": "jest",
-    "test:ci": "npm test -- --maxWorkers 4 --no-cache --silent",
-    "test:grammar": "nearley-test -s DATABASE src/grammar.js < ./test.pgn",
-    "test:watch": "jest --watch"
+    "test:coverage": "npm run test -- --coverage",
+    "test:watch": "npm run test -- --watch"
   },
-  "version": "1.0.0"
+  "types": "dist/index.d.ts",
+  "version": "2.1.2"
 }