@echecs/pgn 1.0.0 → 2.1.1

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: npm
+    directory: '/'
+    schedule:
+      interval: daily
+      time: '13:00'
+    open-pull-requests-limit: 10
+    commit-message:
+      prefix: 'chore'
+      include: 'scope'

package/.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    name: Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: Setup
+        uses: actions/setup-node@v3
+        with:
+          node-version: node
+      - name: Cache NPM Modules
+        id: cache-node
+        uses: actions/cache@v3
+        with:
+          path: '**/node_modules'
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/package-lock.json') }}
+      - name: Install dependencies
+        if: steps.cache-node.outputs.cache-hit != 'true'
+        run: npm ci
+      - name: Verify
+        run: npm run test
+      - name: Release to NPM
+        uses: JS-DevTools/npm-publish@v1
+        with:
+          access: public
+          token: ${{ secrets.NPM_TOKEN }}

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx lint-staged

package/.husky/pre-push

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npm run format && npm run lint && npm run test

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Adrian de la Rosa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,19 +1,34 @@
 # PGN
 
-PGN is part of the project @echecs (chess). It parses a PGN File following the
-specification provided in:
-[Specification](http://www.saremba.de/chessgml/standards/pgn/pgn-complete.htm)
+**PGN** is part of the **ECHECS** project. **PGN** is a parser of the
+[PGN specification](http://www.saremba.de/chessgml/standards/pgn/pgn-complete.htm).
 
-## Use
+## Installation
+
+```bash
+npm install --save-dev @echecs/pgn
+```
+
+```bash
+yarn add @echecs/pgn
+```
+
+## Usage
 
 We just need to provide with a PGN to the parser. It always return an array
 because PGN files could contain several games.
 
 ```js
-const parser = require('@echecs/pgn');
+import { readFileSync } from 'fs';
+import parse from '@echecs/pgn';
+
+function readFile(path: string): string {
+  const filename = require.resolve(path);
 
-parser(string);
+  return readFileSync(filename, 'utf8');
+}
 
+const pgn = parse(readFile('./games/file.pgn'));
 // [
 //   {
 //     "meta": {

package/dist/grammar.d.ts

@@ -0,0 +1,35 @@
+export const Lexer: undefined;
+export const ParserRules: ({
+    name: string;
+    symbols: (string | RegExp)[];
+    postprocess: (d: any) => any;
+} | {
+    name: string;
+    symbols: (string | {
+        literal: string;
+    })[];
+    postprocess?: undefined;
+} | {
+    name: string;
+    symbols: (string | RegExp)[];
+    postprocess?: undefined;
+} | {
+    name: string;
+    symbols: (string | {
+        literal: string;
+    })[];
+    postprocess: (d: any) => any;
+} | {
+    name: string;
+    symbols: (RegExp | {
+        literal: string;
+    })[];
+    postprocess: (d: any) => any;
+} | {
+    name: string;
+    symbols: (RegExp | {
+        literal: string;
+    })[];
+    postprocess?: undefined;
+})[];
+export const ParserStart: string;

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',
+};