pgn-viewer-parser 1.0.0

package/README.md

@@ -0,0 +1,340 @@
+# PGN Viewer Parser
+
+A production-ready TypeScript library for parsing and viewing chess PGN (Portable Game Notation) files. Designed for Next.js/React applications with full support for variations, comments, NAGs, and annotations.
+
+## Features
+
+✅ **Complete PGN Parsing** - Supports all official PGN features including variations, comments, NAGs, and annotations  
+✅ **Tree Data Structure** - Represents games as a navigable tree with mainline and variations  
+✅ **Pure TypeScript** - No chess.js dependency for parsing (optional for board state)  
+✅ **React Components** - Optional viewer components with keyboard navigation  
+✅ **Next.js Compatible** - Works with App Router (Server/Client components)  
+✅ **Tree-Shakable** - Import only what you need  
+✅ **Fully Typed** - Complete TypeScript type definitions  
+✅ **Comprehensive Tests** - Extensive test coverage with Vitest
+
+## Installation
+
+```bash
+npm install pgn-viewer-parser
+```
+
+For React components:
+```bash
+npm install pgn-viewer-parser react react-dom
+```
+
+## Quick Start
+
+### Basic Parsing
+
+```typescript
+import { parsePGN, GameCursor } from 'pgn-viewer-parser';
+
+const pgnText = `
+[Event "Live Chess"]
+[White "Magnus Carlsen"]
+[Black "Hikaru Nakamura"]
+
+1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 1-0
+`;
+
+// Parse the PGN
+const game = parsePGN(pgnText);
+
+// Access headers
+console.log(game.headers.Event); // "Live Chess"
+console.log(game.headers.White); // "Magnus Carlsen"
+
+// Navigate through moves
+const cursor = new GameCursor(game.root);
+cursor.next(); // e4
+cursor.next(); // e5
+console.log(cursor.current.san); // "e5"
+```
+
+### React Viewer
+
+```tsx
+'use client';
+
+import { parsePGN, GameCursor } from 'pgn-viewer-parser';
+import { PGNViewer, PGNControls } from 'pgn-viewer-parser/viewer';
+
+export default function ChessGame() {
+  const game = parsePGN(pgnText);
+  const cursor = new GameCursor(game.root);
+
+  return (
+    <div>
+      <PGNViewer root={game.root} cursor={cursor} />
+      <PGNControls cursor={cursor} />
+    </div>
+  );
+}
+```
+
+## API Reference
+
+### Parsing
+
+#### `parsePGN(pgnText: string): PGNGame`
+
+Parses PGN text and returns a game object.
+
+```typescript
+const game = parsePGN(pgnText);
+```
+
+### Data Structures
+
+#### `PGNGame`
+
+```typescript
+interface PGNGame {
+  headers: Record<string, string>;  // PGN headers
+  root: MoveNode;                   // Root of the game tree
+}
+```
+
+#### `MoveNode`
+
+```typescript
+interface MoveNode {
+  id: string;              // Unique identifier
+  ply: number;             // Half-move number (0-indexed)
+  moveNumber: number;      // Full move number
+  color: 'w' | 'b';        // Side to move
+  san: string;             // Move in SAN notation
+  nags: number[];          // Numeric Annotation Glyphs
+  commentBefore?: string;  // Comment before move
+  commentAfter?: string;   // Comment after move
+  clock?: number;          // Clock time (seconds)
+  emt?: number;            // Elapsed move time (seconds)
+  eval?: number;           // Position evaluation
+  depth?: number;          // Search depth
+  parent?: MoveNode;       // Parent node
+  next?: MoveNode;         // Next move in mainline
+  variations: MoveNode[];  // Alternative variations
+}
+```
+
+### Navigation
+
+#### `GameCursor`
+
+```typescript
+class GameCursor {
+  current: MoveNode;       // Current position
+  root: MoveNode;          // Game root
+
+  next(): MoveNode | null;              // Move forward
+  prev(): MoveNode | null;              // Move backward
+  goTo(nodeId: string): void;           // Jump to node
+  enterVariation(index: number): MoveNode | null;  // Enter variation
+  exitVariation(): MoveNode | null;     // Exit variation
+  toStart(): void;                      // Go to start
+  toEnd(): void;                        // Go to end
+  isAtStart(): boolean;                 // Check if at start
+  isAtEnd(): boolean;                   // Check if at end
+  getMainlinePath(): MoveNode[];        // Get path to current
+}
+```
+
+### React Components
+
+#### `<PGNViewer />`
+
+Displays moves with variations and comments.
+
+```tsx
+<PGNViewer
+  root={game.root}
+  cursor={cursor}
+  onMoveClick={(node) => console.log(node.san)}
+  className="custom-class"
+/>
+```
+
+**Props:**
+- `root: MoveNode` - Root of the game tree
+- `cursor?: GameCursor` - Optional cursor for external control
+- `onMoveClick?: (node: MoveNode) => void` - Callback when move is clicked
+- `className?: string` - Custom CSS class
+
+#### `<PGNControls />`
+
+Navigation controls with keyboard support.
+
+```tsx
+<PGNControls
+  cursor={cursor}
+  onPositionChange={(cursor) => forceUpdate()}
+  enableKeyboard={true}
+/>
+```
+
+**Props:**
+- `cursor: GameCursor` - The cursor to control
+- `onPositionChange?: (cursor: GameCursor) => void` - Callback on position change
+- `enableKeyboard?: boolean` - Enable keyboard controls (default: true)
+- `className?: string` - Custom CSS class
+
+**Keyboard Shortcuts:**
+- `←` Previous move
+- `→` Next move
+- `↑` Exit variation
+- `↓` Enter first variation
+- `Ctrl+←` First move
+- `Ctrl+→` Last move
+
+## Advanced Features
+
+### Parsing Variations
+
+```typescript
+const pgn = `
+1. e4 e5 (1... c5 2. Nf3) 2. Nf3
+`;
+
+const game = parsePGN(pgn);
+const e4 = game.root.next;
+const e5 = e4.next;
+
+// Access variation
+const c5 = e5.variations[0];
+console.log(c5.san); // "c5"
+```
+
+### Parsing Annotations
+
+```typescript
+const pgn = `
+1. e4 e5 {[%clk 0:04:32][%eval +0.35][%depth 18]}
+`;
+
+const game = parsePGN(pgn);
+const e5 = game.root.next.next;
+
+console.log(e5.clock);  // 272 (seconds)
+console.log(e5.eval);   // 0.35
+console.log(e5.depth);  // 18
+```
+
+### NAG Symbols
+
+```typescript
+import { nagToSymbol } from 'pgn-viewer-parser';
+
+console.log(nagToSymbol(1));  // "!"  (good move)
+console.log(nagToSymbol(2));  // "?"  (poor move)
+console.log(nagToSymbol(3));  // "!!" (brilliant move)
+```
+
+## Next.js Integration
+
+### App Router (Recommended)
+
+```tsx
+// app/game/page.tsx
+'use client';
+
+import { parsePGN, GameCursor } from 'pgn-viewer-parser';
+import { PGNViewer, PGNControls } from 'pgn-viewer-parser/viewer';
+
+export default function GamePage() {
+  // Your component code
+}
+```
+
+### Server Component
+
+```tsx
+// app/game/page.tsx
+import { parsePGN } from 'pgn-viewer-parser';
+
+export default function GamePage() {
+  const game = parsePGN(pgnText);
+  
+  return (
+    <div>
+      <h1>{game.headers.Event}</h1>
+      {/* Render game info */}
+    </div>
+  );
+}
+```
+
+## Comparison with chess.js
+
+| Feature | pgn-viewer-parser | chess.js |
+|---------|------------------|----------|
+| PGN Parsing | ✅ Full support | ⚠️ Mainline only |
+| Variations | ✅ Tree structure | ❌ Not supported |
+| Comments | ✅ Before/after | ⚠️ Limited |
+| NAGs | ✅ Full support | ❌ Not supported |
+| Annotations | ✅ Clock/eval/depth | ❌ Not supported |
+| Board State | ⚠️ Optional | ✅ Built-in |
+| Move Validation | ⚠️ Optional | ✅ Built-in |
+| React Components | ✅ Included | ❌ Not included |
+
+**Use pgn-viewer-parser when:**
+- You need to parse PGN with variations
+- You want to display games with a tree structure
+- You need annotations and comments
+- You're building a PGN viewer/analyzer
+
+**Use chess.js when:**
+- You need move validation
+- You're building a playable chess board
+- You don't need variation support
+
+**Use both together:**
+```typescript
+import { parsePGN } from 'pgn-viewer-parser';
+import { Chess } from 'chess.js';
+
+const game = parsePGN(pgnText);
+const chess = new Chess();
+
+// Apply moves to chess.js for board state
+let node = game.root.next;
+while (node) {
+  chess.move(node.san);
+  node = node.next;
+}
+```
+
+## Examples
+
+See the `examples/` directory for complete examples:
+- `basic-parsing.ts` - Basic parsing and navigation
+- `react-viewer.tsx` - React component usage
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Build library
+npm run build
+
+# Type check
+npm run type-check
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please open an issue or PR.
+
+## Support
+
+For issues and questions, please open an issue on GitHub.

package/dist/cursor/game-cursor.js

@@ -0,0 +1,110 @@
+class u {
+  constructor(t) {
+    this._root = t, this._current = t;
+  }
+  /**
+   * Gets the current node.
+   */
+  get current() {
+    return this._current;
+  }
+  /**
+   * Gets the root node.
+   */
+  get root() {
+    return this._root;
+  }
+  /**
+   * Moves to the next node in the current line.
+   * Returns the new current node, or null if at the end.
+   */
+  next() {
+    return this._current.next ? (this._current = this._current.next, this._current) : null;
+  }
+  /**
+   * Moves to the previous node.
+   * Returns the new current node, or null if at the start.
+   */
+  prev() {
+    return this._current.parent ? (this._current = this._current.parent, this._current) : null;
+  }
+  /**
+   * Jumps to a specific node by ID.
+   */
+  goTo(t) {
+    const r = this.findNodeById(this._root, t);
+    if (r)
+      this._current = r;
+    else
+      throw new Error(`Node with ID ${t} not found`);
+  }
+  /**
+   * Enters a variation at the given index.
+   * Returns the first node of the variation, or null if invalid index.
+   */
+  enterVariation(t) {
+    return t >= 0 && t < this._current.variations.length ? (this._current = this._current.variations[t], this._current) : null;
+  }
+  /**
+   * Exits the current variation and returns to the parent line.
+   * Returns the parent node, or null if already in the mainline.
+   */
+  exitVariation() {
+    return this._current.parent ? (this._current = this._current.parent, this._current) : null;
+  }
+  /**
+   * Goes to the start of the game (root node).
+   */
+  toStart() {
+    this._current = this._root;
+  }
+  /**
+   * Goes to the end of the current line.
+   */
+  toEnd() {
+    for (; this._current.next; )
+      this._current = this._current.next;
+  }
+  /**
+   * Checks if the cursor is at the start.
+   */
+  isAtStart() {
+    return this._current === this._root;
+  }
+  /**
+   * Checks if the cursor is at the end of the current line.
+   */
+  isAtEnd() {
+    return this._current.next === void 0;
+  }
+  /**
+   * Gets the mainline path from root to current position.
+   */
+  getMainlinePath() {
+    const t = [];
+    let r = this._current;
+    for (; r; )
+      t.unshift(r), r = r.parent;
+    return t;
+  }
+  /**
+   * Recursively finds a node by ID.
+   */
+  findNodeById(t, r) {
+    if (t.id === r)
+      return t;
+    if (t.next) {
+      const n = this.findNodeById(t.next, r);
+      if (n) return n;
+    }
+    for (const n of t.variations) {
+      const e = this.findNodeById(n, r);
+      if (e) return e;
+    }
+    return null;
+  }
+}
+export {
+  u as GameCursor
+};
+//# sourceMappingURL=game-cursor.js.map

package/dist/cursor/game-cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"game-cursor.js","sources":["../../src/cursor/game-cursor.ts"],"sourcesContent":["import { MoveNode } from '../model/move-node.js';\n\n/**\n * Cursor for navigating through a chess game tree.\n */\nexport class GameCursor {\n    private _current: MoveNode;\n    private _root: MoveNode;\n\n    constructor(root: MoveNode) {\n        this._root = root;\n        this._current = root;\n    }\n\n    /**\n     * Gets the current node.\n     */\n    get current(): MoveNode {\n        return this._current;\n    }\n\n    /**\n     * Gets the root node.\n     */\n    get root(): MoveNode {\n        return this._root;\n    }\n\n    /**\n     * Moves to the next node in the current line.\n     * Returns the new current node, or null if at the end.\n     */\n    next(): MoveNode | null {\n        if (this._current.next) {\n            this._current = this._current.next;\n            return this._current;\n        }\n        return null;\n    }\n\n    /**\n     * Moves to the previous node.\n     * Returns the new current node, or null if at the start.\n     */\n    prev(): MoveNode | null {\n        if (this._current.parent) {\n            this._current = this._current.parent;\n            return this._current;\n        }\n        return null;\n    }\n\n    /**\n     * Jumps to a specific node by ID.\n     */\n    goTo(nodeId: string): void {\n        const node = this.findNodeById(this._root, nodeId);\n        if (node) {\n            this._current = node;\n        } else {\n            throw new Error(`Node with ID ${nodeId} not found`);\n        }\n    }\n\n    /**\n     * Enters a variation at the given index.\n     * Returns the first node of the variation, or null if invalid index.\n     */\n    enterVariation(index: number): MoveNode | null {\n        if (index >= 0 && index < this._current.variations.length) {\n            this._current = this._current.variations[index];\n            return this._current;\n        }\n        return null;\n    }\n\n    /**\n     * Exits the current variation and returns to the parent line.\n     * Returns the parent node, or null if already in the mainline.\n     */\n    exitVariation(): MoveNode | null {\n        if (this._current.parent) {\n            this._current = this._current.parent;\n            return this._current;\n        }\n        return null;\n    }\n\n    /**\n     * Goes to the start of the game (root node).\n     */\n    toStart(): void {\n        this._current = this._root;\n    }\n\n    /**\n     * Goes to the end of the current line.\n     */\n    toEnd(): void {\n        while (this._current.next) {\n            this._current = this._current.next;\n        }\n    }\n\n    /**\n     * Checks if the cursor is at the start.\n     */\n    isAtStart(): boolean {\n        return this._current === this._root;\n    }\n\n    /**\n     * Checks if the cursor is at the end of the current line.\n     */\n    isAtEnd(): boolean {\n        return this._current.next === undefined;\n    }\n\n    /**\n     * Gets the mainline path from root to current position.\n     */\n    getMainlinePath(): MoveNode[] {\n        const path: MoveNode[] = [];\n        let node: MoveNode | undefined = this._current;\n\n        while (node) {\n            path.unshift(node);\n            node = node.parent;\n        }\n\n        return path;\n    }\n\n    /**\n     * Recursively finds a node by ID.\n     */\n    private findNodeById(node: MoveNode, id: string): MoveNode | null {\n        if (node.id === id) {\n            return node;\n        }\n\n        // Search in mainline\n        if (node.next) {\n            const found = this.findNodeById(node.next, id);\n            if (found) return found;\n        }\n\n        // Search in variations\n        for (const variation of node.variations) {\n            const found = this.findNodeById(variation, id);\n            if (found) return found;\n        }\n\n        return null;\n    }\n}\n"],"names":["GameCursor","root","nodeId","node","index","path","id","found","variation"],"mappings":"AAKO,MAAMA,EAAW;AAAA,EAIpB,YAAYC,GAAgB;AACxB,SAAK,QAAQA,GACb,KAAK,WAAWA;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,UAAoB;AACpB,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,OAAiB;AACjB,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAwB;AACpB,WAAI,KAAK,SAAS,QACd,KAAK,WAAW,KAAK,SAAS,MACvB,KAAK,YAET;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAwB;AACpB,WAAI,KAAK,SAAS,UACd,KAAK,WAAW,KAAK,SAAS,QACvB,KAAK,YAET;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAKA,KAAKC,GAAsB;AACvB,UAAMC,IAAO,KAAK,aAAa,KAAK,OAAOD,CAAM;AACjD,QAAIC;AACA,WAAK,WAAWA;AAAA;AAEhB,YAAM,IAAI,MAAM,gBAAgBD,CAAM,YAAY;AAAA,EAE1D;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,eAAeE,GAAgC;AAC3C,WAAIA,KAAS,KAAKA,IAAQ,KAAK,SAAS,WAAW,UAC/C,KAAK,WAAW,KAAK,SAAS,WAAWA,CAAK,GACvC,KAAK,YAET;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,gBAAiC;AAC7B,WAAI,KAAK,SAAS,UACd,KAAK,WAAW,KAAK,SAAS,QACvB,KAAK,YAET;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAKA,UAAgB;AACZ,SAAK,WAAW,KAAK;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACV,WAAO,KAAK,SAAS;AACjB,WAAK,WAAW,KAAK,SAAS;AAAA,EAEtC;AAAA;AAAA;AAAA;AAAA,EAKA,YAAqB;AACjB,WAAO,KAAK,aAAa,KAAK;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA,EAKA,UAAmB;AACf,WAAO,KAAK,SAAS,SAAS;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA,EAKA,kBAA8B;AAC1B,UAAMC,IAAmB,CAAA;AACzB,QAAIF,IAA6B,KAAK;AAEtC,WAAOA;AACH,MAAAE,EAAK,QAAQF,CAAI,GACjBA,IAAOA,EAAK;AAGhB,WAAOE;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAKQ,aAAaF,GAAgBG,GAA6B;AAC9D,QAAIH,EAAK,OAAOG;AACZ,aAAOH;AAIX,QAAIA,EAAK,MAAM;AACX,YAAMI,IAAQ,KAAK,aAAaJ,EAAK,MAAMG,CAAE;AAC7C,UAAIC,EAAO,QAAOA;AAAA,IACtB;AAGA,eAAWC,KAAaL,EAAK,YAAY;AACrC,YAAMI,IAAQ,KAAK,aAAaC,GAAWF,CAAE;AAC7C,UAAIC,EAAO,QAAOA;AAAA,IACtB;AAEA,WAAO;AAAA,EACX;AACJ;"}

package/dist/index.js

@@ -0,0 +1,27 @@
+import { createMoveNode as r, createRootNode as a } from "./model/move-node.js";
+import { createPGNGame as p } from "./model/pgn-game.js";
+import { PGNParser as n, parsePGN as s } from "./parser/pgn-parser.js";
+import { PGNTokenizer as x, TokenType as G } from "./parser/tokenizer.js";
+import { parseHeader as T, parseHeaders as i } from "./parser/header-parser.js";
+import { GameCursor as d } from "./cursor/game-cursor.js";
+import { NAG_SYMBOLS as S, nagToSymbol as c, nagsToSymbols as l } from "./utils/nag-symbols.js";
+import { parseAnnotations as b, parseEvalAnnotation as g, parseTimeAnnotation as k } from "./utils/annotation-parser.js";
+export {
+  d as GameCursor,
+  S as NAG_SYMBOLS,
+  n as PGNParser,
+  x as PGNTokenizer,
+  G as TokenType,
+  r as createMoveNode,
+  p as createPGNGame,
+  a as createRootNode,
+  c as nagToSymbol,
+  l as nagsToSymbols,
+  b as parseAnnotations,
+  g as parseEvalAnnotation,
+  T as parseHeader,
+  i as parseHeaders,
+  s as parsePGN,
+  k as parseTimeAnnotation
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/dist/model/move-node.js

@@ -0,0 +1,23 @@
+function e(o) {
+  return {
+    ...o,
+    nags: o.nags || [],
+    variations: []
+  };
+}
+function n() {
+  return {
+    id: "root",
+    ply: 0,
+    moveNumber: 0,
+    color: "w",
+    san: "",
+    nags: [],
+    variations: []
+  };
+}
+export {
+  e as createMoveNode,
+  n as createRootNode
+};
+//# sourceMappingURL=move-node.js.map

package/dist/model/move-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-node.js","sources":["../../src/model/move-node.ts"],"sourcesContent":["/**\n * Represents a single move node in the game tree.\n * Each node can have a mainline continuation (next) and alternative variations.\n */\nexport interface MoveNode {\n    /** Unique identifier for this node */\n    id: string;\n\n    /** Ply number (half-moves from start, 0-indexed) */\n    ply: number;\n\n    /** Move number in chess notation (1, 2, 3, etc.) */\n    moveNumber: number;\n\n    /** Color to move: 'w' for white, 'b' for black */\n    color: 'w' | 'b';\n\n    /** Standard Algebraic Notation of the move (e.g., \"e4\", \"Nf3\", \"O-O\") */\n    san: string;\n\n    /** Numeric Annotation Glyphs (e.g., $1 = \"!\", $2 = \"?\") */\n    nags: number[];\n\n    /** Comment appearing before this move */\n    commentBefore?: string;\n\n    /** Comment appearing after this move */\n    commentAfter?: string;\n\n    /** Clock time remaining in seconds */\n    clock?: number;\n\n    /** Elapsed move time in seconds */\n    emt?: number;\n\n    /** Position evaluation in centipawns (positive = white advantage) */\n    eval?: number;\n\n    /** Search depth for the evaluation */\n    depth?: number;\n\n    /** Parent node (undefined for root) */\n    parent?: MoveNode;\n\n    /** Next move in the mainline */\n    next?: MoveNode;\n\n    /** Alternative variations from this position */\n    variations: MoveNode[];\n}\n\n/**\n * Creates a new MoveNode with the given properties.\n */\nexport function createMoveNode(props: {\n    id: string;\n    ply: number;\n    moveNumber: number;\n    color: 'w' | 'b';\n    san: string;\n    nags?: number[];\n    commentBefore?: string;\n    commentAfter?: string;\n    clock?: number;\n    emt?: number;\n    eval?: number;\n    depth?: number;\n    parent?: MoveNode;\n}): MoveNode {\n    return {\n        ...props,\n        nags: props.nags || [],\n        variations: [],\n    };\n}\n\n/**\n * Creates a root node (starting position with no move).\n */\nexport function createRootNode(): MoveNode {\n    return {\n        id: 'root',\n        ply: 0,\n        moveNumber: 0,\n        color: 'w',\n        san: '',\n        nags: [],\n        variations: [],\n    };\n}\n"],"names":["createMoveNode","props","createRootNode"],"mappings":"AAsDO,SAASA,EAAeC,GAclB;AACT,SAAO;AAAA,IACH,GAAGA;AAAA,IACH,MAAMA,EAAM,QAAQ,CAAA;AAAA,IACpB,YAAY,CAAA;AAAA,EAAC;AAErB;AAKO,SAASC,IAA2B;AACvC,SAAO;AAAA,IACH,IAAI;AAAA,IACJ,KAAK;AAAA,IACL,YAAY;AAAA,IACZ,OAAO;AAAA,IACP,KAAK;AAAA,IACL,MAAM,CAAA;AAAA,IACN,YAAY,CAAA;AAAA,EAAC;AAErB;"}

package/dist/model/pgn-game.js

@@ -0,0 +1,18 @@
+function e(o = {}, r) {
+  return {
+    headers: o,
+    root: r || {
+      id: "root",
+      ply: 0,
+      moveNumber: 0,
+      color: "w",
+      san: "",
+      nags: [],
+      variations: []
+    }
+  };
+}
+export {
+  e as createPGNGame
+};
+//# sourceMappingURL=pgn-game.js.map

package/dist/model/pgn-game.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgn-game.js","sources":["../../src/model/pgn-game.ts"],"sourcesContent":["import { MoveNode } from './move-node.js';\n\n/**\n * Represents a complete chess game parsed from PGN.\n */\nexport interface PGNGame {\n    /** PGN headers (Event, Site, Date, White, Black, Result, etc.) */\n    headers: Record<string, string>;\n\n    /** Root node of the game tree (starting position) */\n    root: MoveNode;\n}\n\n/**\n * Creates a new PGNGame with the given headers and root node.\n */\nexport function createPGNGame(\n    headers: Record<string, string> = {},\n    root?: MoveNode\n): PGNGame {\n    return {\n        headers,\n        root: root || {\n            id: 'root',\n            ply: 0,\n            moveNumber: 0,\n            color: 'w',\n            san: '',\n            nags: [],\n            variations: [],\n        },\n    };\n}\n"],"names":["createPGNGame","headers","root"],"mappings":"AAgBO,SAASA,EACZC,IAAkC,CAAA,GAClCC,GACO;AACP,SAAO;AAAA,IACH,SAAAD;AAAA,IACA,MAAMC,KAAQ;AAAA,MACV,IAAI;AAAA,MACJ,KAAK;AAAA,MACL,YAAY;AAAA,MACZ,OAAO;AAAA,MACP,KAAK;AAAA,MACL,MAAM,CAAA;AAAA,MACN,YAAY,CAAA;AAAA,IAAC;AAAA,EACjB;AAER;"}

package/dist/parser/header-parser.js

@@ -0,0 +1,24 @@
+function s(n) {
+  const e = {};
+  for (const r of n) {
+    const t = r.match(/\[(\w+)\s+"(.*)"\]/);
+    if (t) {
+      const [, c, o] = t;
+      e[c] = o;
+    }
+  }
+  return e;
+}
+function a(n) {
+  const e = n.match(/\[(\w+)\s+"(.*)"\]/);
+  if (e) {
+    const [, r, t] = e;
+    return { key: r, value: t };
+  }
+  return null;
+}
+export {
+  a as parseHeader,
+  s as parseHeaders
+};
+//# sourceMappingURL=header-parser.js.map

package/dist/parser/header-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-parser.js","sources":["../../src/parser/header-parser.ts"],"sourcesContent":["/**\n * Parses PGN headers from header tokens.\n * Format: [Key \"Value\"]\n */\nexport function parseHeaders(headerTokens: string[]): Record<string, string> {\n    const headers: Record<string, string> = {};\n\n    for (const token of headerTokens) {\n        const match = token.match(/\\[(\\w+)\\s+\"(.*)\"\\]/);\n        if (match) {\n            const [, key, value] = match;\n            headers[key] = value;\n        }\n    }\n\n    return headers;\n}\n\n/**\n * Parses a single header string.\n */\nexport function parseHeader(header: string): { key: string; value: string } | null {\n    const match = header.match(/\\[(\\w+)\\s+\"(.*)\"\\]/);\n    if (match) {\n        const [, key, value] = match;\n        return { key, value };\n    }\n    return null;\n}\n"],"names":["parseHeaders","headerTokens","headers","token","match","key","value","parseHeader","header"],"mappings":"AAIO,SAASA,EAAaC,GAAgD;AACzE,QAAMC,IAAkC,CAAA;AAExC,aAAWC,KAASF,GAAc;AAC9B,UAAMG,IAAQD,EAAM,MAAM,oBAAoB;AAC9C,QAAIC,GAAO;AACP,YAAM,CAAA,EAAGC,GAAKC,CAAK,IAAIF;AACvB,MAAAF,EAAQG,CAAG,IAAIC;AAAA,IACnB;AAAA,EACJ;AAEA,SAAOJ;AACX;AAKO,SAASK,EAAYC,GAAuD;AAC/E,QAAMJ,IAAQI,EAAO,MAAM,oBAAoB;AAC/C,MAAIJ,GAAO;AACP,UAAM,CAAA,EAAGC,GAAKC,CAAK,IAAIF;AACvB,WAAO,EAAE,KAAAC,GAAK,OAAAC,EAAA;AAAA,EAClB;AACA,SAAO;AACX;"}

package/dist/parser/pgn-parser.js

@@ -0,0 +1,118 @@
+import { PGNTokenizer as E, TokenType as e } from "./tokenizer.js";
+import { parseHeader as k } from "./header-parser.js";
+import { parseAnnotations as T } from "../utils/annotation-parser.js";
+import { createRootNode as y } from "../model/move-node.js";
+import { createPGNGame as A } from "../model/pgn-game.js";
+class M {
+  constructor() {
+    this.tokens = [], this.position = 0, this.nodeIdCounter = 0;
+  }
+  /**
+   * Parses PGN text and returns a PGNGame object.
+   */
+  parse(o) {
+    const s = new E(o);
+    this.tokens = s.tokenize(), this.position = 0, this.nodeIdCounter = 0;
+    const t = this.parseHeaders(), r = y();
+    return this.parseMoveSequence(r, 0), A(t, r);
+  }
+  /**
+   * Parses all headers at the beginning of the PGN.
+   */
+  parseHeaders() {
+    const o = {};
+    for (; this.current().type === e.HEADER; ) {
+      const s = this.consume(e.HEADER), t = k(s.value);
+      t && (o[t.key] = t.value);
+    }
+    return o;
+  }
+  /**
+   * Parses a sequence of moves and variations, building the tree structure.
+   * Returns the FIRST node created in this sequence (for variations).
+   */
+  parseMoveSequence(o, s) {
+    let t = o, r = s, c, h;
+    for (; !this.isAtEnd(); ) {
+      const a = this.current();
+      if (a.type === e.VARIATION_END)
+        return h;
+      if (a.type === e.COMMENT) {
+        const i = this.consume(e.COMMENT).value;
+        c = c ? `${c} ${i}` : i;
+        continue;
+      }
+      if (a.type === e.MOVE_NUMBER) {
+        this.advance();
+        continue;
+      }
+      if (a.type === e.RESULT) {
+        this.advance();
+        break;
+      }
+      if (a.type === e.VARIATION_START) {
+        this.consume(e.VARIATION_START);
+        const i = t.parent || o, d = t.ply, u = this.parseMoveSequence(i, d);
+        u && u !== i && t.variations.push(u), this.consume(e.VARIATION_END);
+        continue;
+      }
+      if (a.type === e.MOVE) {
+        const i = this.consume(e.MOVE), d = r % 2 === 0 ? "w" : "b", u = Math.floor(r / 2) + 1, f = [];
+        for (; this.current().type === e.NAG; ) {
+          const l = this.consume(e.NAG), n = parseInt(l.value.slice(1));
+          f.push(n);
+        }
+        let N;
+        const p = {};
+        if (this.current().type === e.COMMENT) {
+          const l = this.consume(e.COMMENT), n = T(l.value);
+          n.clock !== void 0 && (p.clock = n.clock), n.emt !== void 0 && (p.emt = n.emt), n.eval !== void 0 && (p.eval = n.eval), n.depth !== void 0 && (p.depth = n.depth), n.cleanComment && (N = n.cleanComment);
+        }
+        const m = {
+          id: this.generateNodeId(),
+          ply: r,
+          moveNumber: u,
+          color: d,
+          san: i.value,
+          nags: f,
+          commentBefore: c,
+          commentAfter: N,
+          ...p,
+          parent: t,
+          variations: []
+        };
+        t.next === void 0 && (t.next = m), h || (h = m), t = m, r++, c = void 0;
+      } else
+        this.advance();
+    }
+    return h;
+  }
+  current() {
+    return this.tokens[this.position] || { type: e.EOF, value: "", line: 0, column: 0 };
+  }
+  advance() {
+    return this.tokens[this.position++];
+  }
+  consume(o) {
+    const s = this.current();
+    if (s.type !== o)
+      throw new Error(
+        `Expected token type ${o}, got ${s.type} at line ${s.line}`
+      );
+    return this.advance();
+  }
+  isAtEnd() {
+    return this.current().type === e.EOF;
+  }
+  generateNodeId() {
+    return `node_${this.nodeIdCounter++}`;
+  }
+}
+function V(v) {
+  return new M().parse(v);
+}
+export {
+  M as PGNParser,
+  V as parsePGN
+};
+//# sourceMappingURL=pgn-parser.js.map

package/dist/parser/pgn-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgn-parser.js","sources":["../../src/parser/pgn-parser.ts"],"sourcesContent":["import { Token, TokenType, PGNTokenizer } from './tokenizer.js';\nimport { parseHeader } from './header-parser.js';\nimport { parseAnnotations } from '../utils/annotation-parser.js';\nimport { MoveNode, createRootNode } from '../model/move-node.js';\nimport { PGNGame, createPGNGame } from '../model/pgn-game.js';\n\n/**\n * Main PGN parser that converts PGN text into a game tree structure.\n */\nexport class PGNParser {\n    private tokens: Token[] = [];\n    private position: number = 0;\n    private nodeIdCounter: number = 0;\n\n    /**\n     * Parses PGN text and returns a PGNGame object.\n     */\n    parse(pgnText: string): PGNGame {\n        const tokenizer = new PGNTokenizer(pgnText);\n        this.tokens = tokenizer.tokenize();\n        this.position = 0;\n        this.nodeIdCounter = 0;\n\n        // Parse headers\n        const headers = this.parseHeaders();\n\n        // Create root node\n        const root = createRootNode();\n\n        // Parse moves starting from root\n        this.parseMoveSequence(root, 0);\n\n        return createPGNGame(headers, root);\n    }\n\n    /**\n     * Parses all headers at the beginning of the PGN.\n     */\n    private parseHeaders(): Record<string, string> {\n        const headers: Record<string, string> = {};\n\n        while (this.current().type === TokenType.HEADER) {\n            const headerToken = this.consume(TokenType.HEADER);\n            const parsed = parseHeader(headerToken.value);\n            if (parsed) {\n                headers[parsed.key] = parsed.value;\n            }\n        }\n\n        return headers;\n    }\n\n    /**\n     * Parses a sequence of moves and variations, building the tree structure.\n     * Returns the FIRST node created in this sequence (for variations).\n     */\n    private parseMoveSequence(\n        parentNode: MoveNode,\n        startPly: number\n    ): MoveNode | undefined {\n        let currentNode = parentNode;\n        let ply = startPly;\n        let pendingComment: string | undefined;\n        let firstNode: MoveNode | undefined; // Track the first node we create\n\n        while (!this.isAtEnd()) {\n            const token = this.current();\n\n            // End of variation\n            if (token.type === TokenType.VARIATION_END) {\n                return firstNode; // Return first node, not current\n            }\n\n            // Comment before move\n            if (token.type === TokenType.COMMENT) {\n                const comment = this.consume(TokenType.COMMENT).value;\n                pendingComment = pendingComment\n                    ? `${pendingComment} ${comment}`\n                    : comment;\n                continue;\n            }\n\n            // Skip move numbers\n            if (token.type === TokenType.MOVE_NUMBER) {\n                this.advance();\n                continue;\n            }\n\n            // Result marker (end of game)\n            if (token.type === TokenType.RESULT) {\n                this.advance();\n                break;\n            }\n\n            // Variation start\n            if (token.type === TokenType.VARIATION_START) {\n                this.consume(TokenType.VARIATION_START);\n\n                // Variations are stored on the move they replace (currentNode)\n                // but they branch from the parent's position\n                // For example: \"1. e4 e5 (1... c5)\" - variation stored on e5, but branches from e4's position\n                const variationParent = currentNode.parent || parentNode;\n                const variationPly = currentNode.ply; // Same ply as the move being replaced\n\n                // Parse the variation\n                const variationStart = this.parseMoveSequence(variationParent, variationPly);\n\n                if (variationStart && variationStart !== variationParent) {\n                    currentNode.variations.push(variationStart);\n                }\n\n                this.consume(TokenType.VARIATION_END);\n                continue;\n            }\n\n            // Move\n            if (token.type === TokenType.MOVE) {\n                const moveToken = this.consume(TokenType.MOVE);\n                const color = ply % 2 === 0 ? 'w' : 'b';\n                const moveNumber = Math.floor(ply / 2) + 1;\n\n                // Collect NAGs\n                const nags: number[] = [];\n                while (this.current().type === TokenType.NAG) {\n                    const nagToken = this.consume(TokenType.NAG);\n                    const nagValue = parseInt(nagToken.value.slice(1)); // Remove '$'\n                    nags.push(nagValue);\n                }\n\n                // Collect comment after move\n                let commentAfter: string | undefined;\n                const annotations: {\n                    clock?: number;\n                    emt?: number;\n                    eval?: number;\n                    depth?: number;\n                } = {};\n\n                if (this.current().type === TokenType.COMMENT) {\n                    const commentToken = this.consume(TokenType.COMMENT);\n                    const parsed = parseAnnotations(commentToken.value);\n\n                    if (parsed.clock !== undefined) annotations.clock = parsed.clock;\n                    if (parsed.emt !== undefined) annotations.emt = parsed.emt;\n                    if (parsed.eval !== undefined) annotations.eval = parsed.eval;\n                    if (parsed.depth !== undefined) annotations.depth = parsed.depth;\n\n                    if (parsed.cleanComment) {\n                        commentAfter = parsed.cleanComment;\n                    }\n                }\n\n                // Create new move node\n                const newNode: MoveNode = {\n                    id: this.generateNodeId(),\n                    ply,\n                    moveNumber,\n                    color,\n                    san: moveToken.value,\n                    nags,\n                    commentBefore: pendingComment,\n                    commentAfter,\n                    ...annotations,\n                    parent: currentNode,\n                    variations: [],\n                };\n\n                // Link to parent\n                if (currentNode.next === undefined) {\n                    currentNode.next = newNode;\n                }\n\n                // Track first node created\n                if (!firstNode) {\n                    firstNode = newNode;\n                }\n\n                currentNode = newNode;\n                ply++;\n                pendingComment = undefined;\n            } else {\n                // Unknown token, skip\n                this.advance();\n            }\n        }\n\n        return firstNode; // Return first node for variations\n    }\n\n    private current(): Token {\n        return this.tokens[this.position] || { type: TokenType.EOF, value: '', line: 0, column: 0 };\n    }\n\n    private advance(): Token {\n        return this.tokens[this.position++];\n    }\n\n    private consume(expectedType: TokenType): Token {\n        const token = this.current();\n        if (token.type !== expectedType) {\n            throw new Error(\n                `Expected token type ${expectedType}, got ${token.type} at line ${token.line}`\n            );\n        }\n        return this.advance();\n    }\n\n    private isAtEnd(): boolean {\n        return this.current().type === TokenType.EOF;\n    }\n\n    private generateNodeId(): string {\n        return `node_${this.nodeIdCounter++}`;\n    }\n}\n\n/**\n * Convenience function to parse PGN text.\n */\nexport function parsePGN(pgnText: string): PGNGame {\n    const parser = new PGNParser();\n    return parser.parse(pgnText);\n}\n"],"names":["PGNParser","pgnText","tokenizer","PGNTokenizer","headers","root","createRootNode","createPGNGame","TokenType","headerToken","parsed","parseHeader","parentNode","startPly","currentNode","ply","pendingComment","firstNode","token","comment","variationParent","variationPly","variationStart","moveToken","color","moveNumber","nags","nagToken","nagValue","commentAfter","annotations","commentToken","parseAnnotations","newNode","expectedType","parsePGN"],"mappings":"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"}

package/dist/parser/tokenizer.js

@@ -0,0 +1,121 @@
+var n = /* @__PURE__ */ ((i) => (i.HEADER = "HEADER", i.MOVE_NUMBER = "MOVE_NUMBER", i.MOVE = "MOVE", i.NAG = "NAG", i.COMMENT = "COMMENT", i.VARIATION_START = "VARIATION_START", i.VARIATION_END = "VARIATION_END", i.RESULT = "RESULT", i.EOF = "EOF", i))(n || {});
+class r {
+  constructor(t) {
+    this.position = 0, this.line = 1, this.column = 1, this.input = t;
+  }
+  /**
+   * Returns all tokens from the input.
+   */
+  tokenize() {
+    const t = [];
+    let e;
+    for (; (e = this.nextToken()).type !== "EOF"; )
+      t.push(e);
+    return t.push(e), t;
+  }
+  /**
+   * Gets the next token from the input.
+   */
+  nextToken() {
+    if (this.skipWhitespace(), this.position >= this.input.length)
+      return this.createToken("EOF", "");
+    const t = this.input[this.position];
+    return t === "[" ? this.readHeader() : t === "{" ? this.readBraceComment() : t === ";" ? this.readLineComment() : t === "(" ? this.createToken("VARIATION_START", this.advance()) : t === ")" ? this.createToken("VARIATION_END", this.advance()) : t === "$" ? this.readNAG() : this.isResultStart() ? this.readResult() : this.isDigit(t) ? this.readMoveNumber() : this.isMoveStart(t) ? this.readMove() : (this.advance(), this.nextToken());
+  }
+  readHeader() {
+    this.advance();
+    let t = "[", e = !1;
+    for (; this.position < this.input.length; ) {
+      const s = this.current();
+      if (s === '"' && (e = !e), s === "]" && !e) {
+        t += this.advance();
+        break;
+      }
+      t += this.advance();
+    }
+    return this.createToken("HEADER", t);
+  }
+  readBraceComment() {
+    this.advance();
+    let t = "";
+    for (; this.position < this.input.length && this.current() !== "}"; )
+      t += this.advance();
+    return this.current() === "}" && this.advance(), this.createToken("COMMENT", t.trim());
+  }
+  readLineComment() {
+    this.advance();
+    let t = "";
+    for (; this.position < this.input.length && this.current() !== `
+`; )
+      t += this.advance();
+    return this.createToken("COMMENT", t.trim());
+  }
+  readNAG() {
+    this.advance();
+    let t = "$";
+    for (; this.position < this.input.length && this.isDigit(this.current()); )
+      t += this.advance();
+    return this.createToken("NAG", t);
+  }
+  readResult() {
+    let t = "";
+    if (this.current() === "*")
+      t = this.advance();
+    else
+      for (; this.position < this.input.length && /[01\-\/]/.test(this.current()); )
+        t += this.advance();
+    return this.createToken("RESULT", t);
+  }
+  readMoveNumber() {
+    let t = "";
+    for (; this.position < this.input.length && this.isDigit(this.current()); )
+      t += this.advance();
+    for (; this.current() === "."; )
+      t += this.advance();
+    return this.createToken("MOVE_NUMBER", t);
+  }
+  readMove() {
+    let t = "";
+    for (; this.position < this.input.length && this.isMoveChar(this.current()); )
+      t += this.advance();
+    return this.createToken("MOVE", t);
+  }
+  isMoveStart(t) {
+    return /[NBRQK]/.test(t) || /[a-h]/.test(t) || t === "O";
+  }
+  isMoveChar(t) {
+    return /[a-h1-8NBRQKO\-+=x#]/.test(t) || t === "+" || t === "#" || t === "!";
+  }
+  isResultStart() {
+    const t = this.input.slice(this.position);
+    return t.startsWith("1-0") || t.startsWith("0-1") || t.startsWith("1/2-1/2") || t.startsWith("*");
+  }
+  isDigit(t) {
+    return /[0-9]/.test(t);
+  }
+  skipWhitespace() {
+    for (; this.position < this.input.length && /\s/.test(this.current()); )
+      this.advance();
+  }
+  current() {
+    return this.input[this.position];
+  }
+  advance() {
+    const t = this.input[this.position];
+    return this.position++, t === `
+` ? (this.line++, this.column = 1) : this.column++, t;
+  }
+  createToken(t, e) {
+    return {
+      type: t,
+      value: e,
+      line: this.line,
+      column: this.column
+    };
+  }
+}
+export {
+  r as PGNTokenizer,
+  n as TokenType
+};
+//# sourceMappingURL=tokenizer.js.map

package/dist/parser/tokenizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.js","sources":["../../src/parser/tokenizer.ts"],"sourcesContent":["/**\n * Token types for PGN lexical analysis\n */\nexport enum TokenType {\n    HEADER = 'HEADER',\n    MOVE_NUMBER = 'MOVE_NUMBER',\n    MOVE = 'MOVE',\n    NAG = 'NAG',\n    COMMENT = 'COMMENT',\n    VARIATION_START = 'VARIATION_START',\n    VARIATION_END = 'VARIATION_END',\n    RESULT = 'RESULT',\n    EOF = 'EOF',\n}\n\n/**\n * Represents a single token from PGN text\n */\nexport interface Token {\n    type: TokenType;\n    value: string;\n    line: number;\n    column: number;\n}\n\n/**\n * Tokenizes PGN text into a stream of tokens.\n */\nexport class PGNTokenizer {\n    private input: string;\n    private position: number = 0;\n    private line: number = 1;\n    private column: number = 1;\n\n    constructor(input: string) {\n        this.input = input;\n    }\n\n    /**\n     * Returns all tokens from the input.\n     */\n    tokenize(): Token[] {\n        const tokens: Token[] = [];\n        let token: Token;\n\n        while ((token = this.nextToken()).type !== TokenType.EOF) {\n            tokens.push(token);\n        }\n\n        tokens.push(token); // Add EOF token\n        return tokens;\n    }\n\n    /**\n     * Gets the next token from the input.\n     */\n    private nextToken(): Token {\n        this.skipWhitespace();\n\n        if (this.position >= this.input.length) {\n            return this.createToken(TokenType.EOF, '');\n        }\n\n        const char = this.input[this.position];\n\n        // Header: [Key \"Value\"]\n        if (char === '[') {\n            return this.readHeader();\n        }\n\n        // Comment: {text} or ; line comment\n        if (char === '{') {\n            return this.readBraceComment();\n        }\n\n        if (char === ';') {\n            return this.readLineComment();\n        }\n\n        // Variation markers\n        if (char === '(') {\n            return this.createToken(TokenType.VARIATION_START, this.advance());\n        }\n\n        if (char === ')') {\n            return this.createToken(TokenType.VARIATION_END, this.advance());\n        }\n\n        // NAG: $1, $2, etc.\n        if (char === '$') {\n            return this.readNAG();\n        }\n\n        // Result: 1-0, 0-1, 1/2-1/2, *\n        if (this.isResultStart()) {\n            return this.readResult();\n        }\n\n        // Move number: 1. or 1...\n        if (this.isDigit(char)) {\n            return this.readMoveNumber();\n        }\n\n        // Move in SAN notation\n        if (this.isMoveStart(char)) {\n            return this.readMove();\n        }\n\n        // Unknown character, skip it\n        this.advance();\n        return this.nextToken();\n    }\n\n    private readHeader(): Token {\n        this.advance(); // skip '['\n\n        let value = '[';\n        let inQuotes = false;\n\n        while (this.position < this.input.length) {\n            const char = this.current();\n\n            if (char === '\"') {\n                inQuotes = !inQuotes;\n            }\n\n            if (char === ']' && !inQuotes) {\n                value += this.advance();\n                break;\n            }\n\n            value += this.advance();\n        }\n\n        return this.createToken(TokenType.HEADER, value);\n    }\n\n    private readBraceComment(): Token {\n        this.advance(); // skip '{'\n        let value = '';\n\n        while (this.position < this.input.length && this.current() !== '}') {\n            value += this.advance();\n        }\n\n        if (this.current() === '}') {\n            this.advance(); // skip '}'\n        }\n\n        return this.createToken(TokenType.COMMENT, value.trim());\n    }\n\n    private readLineComment(): Token {\n        this.advance(); // skip ';'\n        let value = '';\n\n        while (this.position < this.input.length && this.current() !== '\\n') {\n            value += this.advance();\n        }\n\n        return this.createToken(TokenType.COMMENT, value.trim());\n    }\n\n    private readNAG(): Token {\n        this.advance(); // skip '$'\n        let value = '$';\n\n        while (this.position < this.input.length && this.isDigit(this.current())) {\n            value += this.advance();\n        }\n\n        return this.createToken(TokenType.NAG, value);\n    }\n\n    private readResult(): Token {\n        let value = '';\n\n        // Match: 1-0, 0-1, 1/2-1/2, or *\n        if (this.current() === '*') {\n            value = this.advance();\n        } else {\n            while (\n                this.position < this.input.length &&\n                /[01\\-\\/]/.test(this.current())\n            ) {\n                value += this.advance();\n            }\n        }\n\n        return this.createToken(TokenType.RESULT, value);\n    }\n\n    private readMoveNumber(): Token {\n        let value = '';\n\n        while (this.position < this.input.length && this.isDigit(this.current())) {\n            value += this.advance();\n        }\n\n        // Skip dots: 1. or 1...\n        while (this.current() === '.') {\n            value += this.advance();\n        }\n\n        return this.createToken(TokenType.MOVE_NUMBER, value);\n    }\n\n    private readMove(): Token {\n        let value = '';\n\n        // Read SAN move: e4, Nf3, O-O, exd5, etc.\n        while (\n            this.position < this.input.length &&\n            this.isMoveChar(this.current())\n        ) {\n            value += this.advance();\n        }\n\n        return this.createToken(TokenType.MOVE, value);\n    }\n\n    private isMoveStart(char: string): boolean {\n        return /[NBRQK]/.test(char) || /[a-h]/.test(char) || char === 'O';\n    }\n\n    private isMoveChar(char: string): boolean {\n        return (\n            /[a-h1-8NBRQKO\\-+=x#]/.test(char) ||\n            char === '+' ||\n            char === '#' ||\n            char === '!'\n        );\n    }\n\n    private isResultStart(): boolean {\n        const remaining = this.input.slice(this.position);\n        return (\n            remaining.startsWith('1-0') ||\n            remaining.startsWith('0-1') ||\n            remaining.startsWith('1/2-1/2') ||\n            remaining.startsWith('*')\n        );\n    }\n\n    private isDigit(char: string): boolean {\n        return /[0-9]/.test(char);\n    }\n\n    private skipWhitespace(): void {\n        while (\n            this.position < this.input.length &&\n            /\\s/.test(this.current())\n        ) {\n            this.advance();\n        }\n    }\n\n    private current(): string {\n        return this.input[this.position];\n    }\n\n    private advance(): string {\n        const char = this.input[this.position];\n        this.position++;\n\n        if (char === '\\n') {\n            this.line++;\n            this.column = 1;\n        } else {\n            this.column++;\n        }\n\n        return char;\n    }\n\n    private createToken(type: TokenType, value: string): Token {\n        return {\n            type,\n            value,\n            line: this.line,\n            column: this.column,\n        };\n    }\n}\n"],"names":["TokenType","PGNTokenizer","input","tokens","token","char","value","inQuotes","remaining","type"],"mappings":"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"}

package/dist/style.css

@@ -0,0 +1 @@
+.pgn-viewer{font-family:Segoe UI,Tahoma,Geneva,Verdana,sans-serif;font-size:14px;line-height:1.8;padding:16px;background-color:#f9f9f9;border:1px solid #ddd;border-radius:4px;max-width:100%;overflow-x:auto}.pgn-move-number{color:#666;margin-right:4px;font-weight:600}.pgn-move{display:inline-block;padding:2px 6px;margin:0 2px;border-radius:3px;transition:background-color .2s}.pgn-move:hover{background-color:#e0e0e0}.pgn-move-current{background-color:#4a90e2;color:#fff;font-weight:600}.pgn-move-current:hover{background-color:#357abd}.pgn-nag{color:#d9534f;margin-left:2px;font-weight:700}.pgn-comment{color:#5a5a5a;font-style:italic;margin:0 4px}.pgn-annotation{color:#888;font-size:12px;margin-left:4px}.pgn-variation{margin-top:4px;margin-bottom:4px;color:#555}.pgn-controls{display:flex;gap:8px;padding:12px;background-color:#f0f0f0;border-radius:4px;justify-content:center}.pgn-control-button{background-color:#4a90e2;color:#fff;border:none;border-radius:4px;padding:8px 16px;font-size:16px;cursor:pointer;transition:background-color .2s;min-width:44px}.pgn-control-button:hover:not(:disabled){background-color:#357abd}.pgn-control-button:disabled{background-color:#ccc;cursor:not-allowed;opacity:.6}.pgn-control-button:active:not(:disabled){transform:scale(.95)}

package/dist/utils/annotation-parser.js

@@ -0,0 +1,40 @@
+function o(e) {
+  const t = {}, s = e.match(/\[%clk\s+(\d+):(\d+):(\d+)\]/);
+  if (s) {
+    const [, n, c, r] = s;
+    t.clock = parseInt(n) * 3600 + parseInt(c) * 60 + parseInt(r);
+  }
+  const a = e.match(/\[%emt\s+(\d+):(\d+):(\d+)\]/);
+  if (a) {
+    const [, n, c, r] = a;
+    t.emt = parseInt(n) * 3600 + parseInt(c) * 60 + parseInt(r);
+  }
+  return t;
+}
+function d(e) {
+  const t = {}, s = e.match(/\[%eval\s+([\+\-]?\d+\.?\d*|#[\+\-]?\d+)\]/);
+  if (s) {
+    const n = s[1];
+    if (n.startsWith("#")) {
+      const c = parseInt(n.slice(1));
+      t.eval = c > 0 ? 1e4 : -1e4;
+    } else
+      t.eval = parseFloat(n);
+  }
+  const a = e.match(/\[%depth\s+(\d+)\]/);
+  return a && (t.depth = parseInt(a[1])), t;
+}
+function l(e) {
+  const t = o(e), s = d(e), a = e.replace(/\[%clk\s+\d+:\d+:\d+\]/g, "").replace(/\[%emt\s+\d+:\d+:\d+\]/g, "").replace(/\[%eval\s+[\+\-]?\d+\.?\d*\]/g, "").replace(/\[%eval\s+#[\+\-]?\d+\]/g, "").replace(/\[%depth\s+\d+\]/g, "").trim();
+  return {
+    ...t,
+    ...s,
+    cleanComment: a
+  };
+}
+export {
+  l as parseAnnotations,
+  d as parseEvalAnnotation,
+  o as parseTimeAnnotation
+};
+//# sourceMappingURL=annotation-parser.js.map

package/dist/utils/annotation-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation-parser.js","sources":["../../src/utils/annotation-parser.ts"],"sourcesContent":["/**\n * Parses time annotations from comments.\n * Supports: [%clk 0:04:32], [%emt 0:00:03]\n */\nexport function parseTimeAnnotation(comment: string): {\n    clock?: number;\n    emt?: number;\n} {\n    const result: { clock?: number; emt?: number } = {};\n\n    // Parse clock: [%clk 0:04:32]\n    const clockMatch = comment.match(/\\[%clk\\s+(\\d+):(\\d+):(\\d+)\\]/);\n    if (clockMatch) {\n        const [, hours, minutes, seconds] = clockMatch;\n        result.clock =\n            parseInt(hours) * 3600 + parseInt(minutes) * 60 + parseInt(seconds);\n    }\n\n    // Parse EMT: [%emt 0:00:03]\n    const emtMatch = comment.match(/\\[%emt\\s+(\\d+):(\\d+):(\\d+)\\]/);\n    if (emtMatch) {\n        const [, hours, minutes, seconds] = emtMatch;\n        result.emt =\n            parseInt(hours) * 3600 + parseInt(minutes) * 60 + parseInt(seconds);\n    }\n\n    return result;\n}\n\n/**\n * Parses evaluation annotation from comments.\n * Supports: [%eval +0.35], [%eval -1.2], [%eval #3]\n */\nexport function parseEvalAnnotation(comment: string): {\n    eval?: number;\n    depth?: number;\n} {\n    const result: { eval?: number; depth?: number } = {};\n\n    // Parse eval: [%eval +0.35] or [%eval #3]\n    const evalMatch = comment.match(/\\[%eval\\s+([\\+\\-]?\\d+\\.?\\d*|#[\\+\\-]?\\d+)\\]/);\n    if (evalMatch) {\n        const evalStr = evalMatch[1];\n        if (evalStr.startsWith('#')) {\n            // Mate score: convert to large number\n            const mateIn = parseInt(evalStr.slice(1));\n            result.eval = mateIn > 0 ? 10000 : -10000;\n        } else {\n            result.eval = parseFloat(evalStr);\n        }\n    }\n\n    // Parse depth: [%depth 18]\n    const depthMatch = comment.match(/\\[%depth\\s+(\\d+)\\]/);\n    if (depthMatch) {\n        result.depth = parseInt(depthMatch[1]);\n    }\n\n    return result;\n}\n\n/**\n * Parses all annotations from a comment string.\n */\nexport function parseAnnotations(comment: string): {\n    clock?: number;\n    emt?: number;\n    eval?: number;\n    depth?: number;\n    cleanComment: string;\n} {\n    const timeData = parseTimeAnnotation(comment);\n    const evalData = parseEvalAnnotation(comment);\n\n    // Remove annotations from comment\n    const cleanComment = comment\n        .replace(/\\[%clk\\s+\\d+:\\d+:\\d+\\]/g, '')\n        .replace(/\\[%emt\\s+\\d+:\\d+:\\d+\\]/g, '')\n        .replace(/\\[%eval\\s+[\\+\\-]?\\d+\\.?\\d*\\]/g, '')\n        .replace(/\\[%eval\\s+#[\\+\\-]?\\d+\\]/g, '')\n        .replace(/\\[%depth\\s+\\d+\\]/g, '')\n        .trim();\n\n    return {\n        ...timeData,\n        ...evalData,\n        cleanComment,\n    };\n}\n"],"names":["parseTimeAnnotation","comment","result","clockMatch","hours","minutes","seconds","emtMatch","parseEvalAnnotation","evalMatch","evalStr","mateIn","depthMatch","parseAnnotations","timeData","evalData","cleanComment"],"mappings":"AAIO,SAASA,EAAoBC,GAGlC;AACE,QAAMC,IAA2C,CAAA,GAG3CC,IAAaF,EAAQ,MAAM,8BAA8B;AAC/D,MAAIE,GAAY;AACZ,UAAM,GAAGC,GAAOC,GAASC,CAAO,IAAIH;AACpC,IAAAD,EAAO,QACH,SAASE,CAAK,IAAI,OAAO,SAASC,CAAO,IAAI,KAAK,SAASC,CAAO;AAAA,EAC1E;AAGA,QAAMC,IAAWN,EAAQ,MAAM,8BAA8B;AAC7D,MAAIM,GAAU;AACV,UAAM,GAAGH,GAAOC,GAASC,CAAO,IAAIC;AACpC,IAAAL,EAAO,MACH,SAASE,CAAK,IAAI,OAAO,SAASC,CAAO,IAAI,KAAK,SAASC,CAAO;AAAA,EAC1E;AAEA,SAAOJ;AACX;AAMO,SAASM,EAAoBP,GAGlC;AACE,QAAMC,IAA4C,CAAA,GAG5CO,IAAYR,EAAQ,MAAM,4CAA4C;AAC5E,MAAIQ,GAAW;AACX,UAAMC,IAAUD,EAAU,CAAC;AAC3B,QAAIC,EAAQ,WAAW,GAAG,GAAG;AAEzB,YAAMC,IAAS,SAASD,EAAQ,MAAM,CAAC,CAAC;AACxC,MAAAR,EAAO,OAAOS,IAAS,IAAI,MAAQ;AAAA,IACvC;AACI,MAAAT,EAAO,OAAO,WAAWQ,CAAO;AAAA,EAExC;AAGA,QAAME,IAAaX,EAAQ,MAAM,oBAAoB;AACrD,SAAIW,MACAV,EAAO,QAAQ,SAASU,EAAW,CAAC,CAAC,IAGlCV;AACX;AAKO,SAASW,EAAiBZ,GAM/B;AACE,QAAMa,IAAWd,EAAoBC,CAAO,GACtCc,IAAWP,EAAoBP,CAAO,GAGtCe,IAAef,EAChB,QAAQ,2BAA2B,EAAE,EACrC,QAAQ,2BAA2B,EAAE,EACrC,QAAQ,iCAAiC,EAAE,EAC3C,QAAQ,4BAA4B,EAAE,EACtC,QAAQ,qBAAqB,EAAE,EAC/B,KAAA;AAEL,SAAO;AAAA,IACH,GAAGa;AAAA,IACH,GAAGC;AAAA,IACH,cAAAC;AAAA,EAAA;AAER;"}

package/dist/utils/nag-symbols.js

@@ -0,0 +1,56 @@
+const o = {
+  1: "!",
+  // Good move
+  2: "?",
+  // Poor move
+  3: "!!",
+  // Very good move
+  4: "??",
+  // Very poor move
+  5: "!?",
+  // Interesting move
+  6: "?!",
+  // Questionable move
+  7: "□",
+  // Forced move
+  10: "=",
+  // Equal position
+  13: "∞",
+  // Unclear position
+  14: "⩲",
+  // White has slight advantage
+  15: "⩱",
+  // Black has slight advantage
+  16: "±",
+  // White has moderate advantage
+  17: "∓",
+  // Black has moderate advantage
+  18: "+−",
+  // White has decisive advantage
+  19: "−+",
+  // Black has decisive advantage
+  22: "⨀",
+  // Zugzwang
+  32: "⟳",
+  // Development advantage
+  36: "↑",
+  // Initiative
+  40: "→",
+  // Attack
+  132: "⇆",
+  // Counterplay
+  138: "⊕"
+  // Time pressure
+};
+function t(n) {
+  return o[n] || `$${n}`;
+}
+function r(n) {
+  return n.map(t);
+}
+export {
+  o as NAG_SYMBOLS,
+  t as nagToSymbol,
+  r as nagsToSymbols
+};
+//# sourceMappingURL=nag-symbols.js.map

package/dist/utils/nag-symbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nag-symbols.js","sources":["../../src/utils/nag-symbols.ts"],"sourcesContent":["/**\n * Maps NAG (Numeric Annotation Glyph) codes to their symbolic representations.\n */\nexport const NAG_SYMBOLS: Record<number, string> = {\n    1: '!',    // Good move\n    2: '?',    // Poor move\n    3: '!!',   // Very good move\n    4: '??',   // Very poor move\n    5: '!?',   // Interesting move\n    6: '?!',   // Questionable move\n    7: '□',    // Forced move\n    10: '=',   // Equal position\n    13: '∞',   // Unclear position\n    14: '⩲',   // White has slight advantage\n    15: '⩱',   // Black has slight advantage\n    16: '±',   // White has moderate advantage\n    17: '∓',   // Black has moderate advantage\n    18: '+−',  // White has decisive advantage\n    19: '−+',  // Black has decisive advantage\n    22: '⨀',   // Zugzwang\n    32: '⟳',   // Development advantage\n    36: '↑',   // Initiative\n    40: '→',   // Attack\n    132: '⇆',  // Counterplay\n    138: '⊕',  // Time pressure\n};\n\n/**\n * Converts a NAG code to its symbolic representation.\n */\nexport function nagToSymbol(nag: number): string {\n    return NAG_SYMBOLS[nag] || `$${nag}`;\n}\n\n/**\n * Converts an array of NAG codes to their symbolic representations.\n */\nexport function nagsToSymbols(nags: number[]): string[] {\n    return nags.map(nagToSymbol);\n}\n"],"names":["NAG_SYMBOLS","nagToSymbol","nag","nagsToSymbols","nags"],"mappings":"AAGO,MAAMA,IAAsC;AAAA,EAC/C,GAAG;AAAA;AAAA,EACH,GAAG;AAAA;AAAA,EACH,GAAG;AAAA;AAAA,EACH,GAAG;AAAA;AAAA,EACH,GAAG;AAAA;AAAA,EACH,GAAG;AAAA;AAAA,EACH,GAAG;AAAA;AAAA,EACH,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,IAAI;AAAA;AAAA,EACJ,KAAK;AAAA;AAAA,EACL,KAAK;AAAA;AACT;AAKO,SAASC,EAAYC,GAAqB;AAC7C,SAAOF,EAAYE,CAAG,KAAK,IAAIA,CAAG;AACtC;AAKO,SAASC,EAAcC,GAA0B;AACpD,SAAOA,EAAK,IAAIH,CAAW;AAC/B;"}

package/dist/viewer/PGNControls.js

@@ -0,0 +1,71 @@
+import { jsxs as y, jsx as d } from "react/jsx-runtime";
+import { useCallback as f, useEffect as A } from "react";
+/* empty css           */
+function x({
+  cursor: l,
+  onPositionChange: t,
+  enableKeyboard: w = !0,
+  className: b = ""
+}) {
+  const r = f(() => {
+    l.toStart(), t == null || t(l);
+  }, [l, t]), p = f(() => {
+    l.prev(), t == null || t(l);
+  }, [l, t]), v = f(() => {
+    l.next(), t == null || t(l);
+  }, [l, t]), m = f(() => {
+    l.toEnd(), t == null || t(l);
+  }, [l, t]);
+  return A(() => {
+    if (!w) return;
+    const k = (e) => {
+      e.ctrlKey || e.metaKey ? e.key === "ArrowLeft" ? (e.preventDefault(), r()) : e.key === "ArrowRight" && (e.preventDefault(), m()) : e.key === "ArrowLeft" ? (e.preventDefault(), p()) : e.key === "ArrowRight" ? (e.preventDefault(), v()) : e.key === "ArrowUp" ? (e.preventDefault(), l.exitVariation(), t == null || t(l)) : e.key === "ArrowDown" && (e.preventDefault(), l.enterVariation(0), t == null || t(l));
+    };
+    return window.addEventListener("keydown", k), () => window.removeEventListener("keydown", k);
+  }, [w, r, p, v, m, l, t]), /* @__PURE__ */ y("div", { className: `pgn-controls ${b}`, children: [
+    /* @__PURE__ */ d(
+      "button",
+      {
+        className: "pgn-control-button",
+        onClick: r,
+        disabled: l.isAtStart(),
+        title: "First move (Ctrl+←)",
+        children: "⏮"
+      }
+    ),
+    /* @__PURE__ */ d(
+      "button",
+      {
+        className: "pgn-control-button",
+        onClick: p,
+        disabled: l.isAtStart(),
+        title: "Previous move (←)",
+        children: "◀"
+      }
+    ),
+    /* @__PURE__ */ d(
+      "button",
+      {
+        className: "pgn-control-button",
+        onClick: v,
+        disabled: l.isAtEnd(),
+        title: "Next move (→)",
+        children: "▶"
+      }
+    ),
+    /* @__PURE__ */ d(
+      "button",
+      {
+        className: "pgn-control-button",
+        onClick: m,
+        disabled: l.isAtEnd(),
+        title: "Last move (Ctrl+→)",
+        children: "⏭"
+      }
+    )
+  ] });
+}
+export {
+  x as PGNControls
+};
+//# sourceMappingURL=PGNControls.js.map

package/dist/viewer/PGNControls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PGNControls.js","sources":["../../src/viewer/PGNControls.tsx"],"sourcesContent":["'use client';\n\nimport { useEffect, useCallback } from 'react';\nimport { GameCursor } from '../cursor/game-cursor.js';\nimport './styles.css';\n\nexport interface PGNControlsProps {\n    /** The game cursor to control */\n    cursor: GameCursor;\n    /** Callback when position changes */\n    onPositionChange?: (cursor: GameCursor) => void;\n    /** Enable keyboard controls (default: true) */\n    enableKeyboard?: boolean;\n    /** Custom class name */\n    className?: string;\n}\n\n/**\n * Navigation controls for a chess game.\n */\nexport function PGNControls({\n    cursor,\n    onPositionChange,\n    enableKeyboard = true,\n    className = '',\n}: PGNControlsProps) {\n    const handleFirst = useCallback(() => {\n        cursor.toStart();\n        onPositionChange?.(cursor);\n    }, [cursor, onPositionChange]);\n\n    const handlePrev = useCallback(() => {\n        cursor.prev();\n        onPositionChange?.(cursor);\n    }, [cursor, onPositionChange]);\n\n    const handleNext = useCallback(() => {\n        cursor.next();\n        onPositionChange?.(cursor);\n    }, [cursor, onPositionChange]);\n\n    const handleLast = useCallback(() => {\n        cursor.toEnd();\n        onPositionChange?.(cursor);\n    }, [cursor, onPositionChange]);\n\n    // Keyboard controls\n    useEffect(() => {\n        if (!enableKeyboard) return;\n\n        const handleKeyDown = (e: KeyboardEvent) => {\n            if (e.ctrlKey || e.metaKey) {\n                if (e.key === 'ArrowLeft') {\n                    e.preventDefault();\n                    handleFirst();\n                } else if (e.key === 'ArrowRight') {\n                    e.preventDefault();\n                    handleLast();\n                }\n            } else {\n                if (e.key === 'ArrowLeft') {\n                    e.preventDefault();\n                    handlePrev();\n                } else if (e.key === 'ArrowRight') {\n                    e.preventDefault();\n                    handleNext();\n                } else if (e.key === 'ArrowUp') {\n                    e.preventDefault();\n                    cursor.exitVariation();\n                    onPositionChange?.(cursor);\n                } else if (e.key === 'ArrowDown') {\n                    e.preventDefault();\n                    cursor.enterVariation(0);\n                    onPositionChange?.(cursor);\n                }\n            }\n        };\n\n        window.addEventListener('keydown', handleKeyDown);\n        return () => window.removeEventListener('keydown', handleKeyDown);\n    }, [enableKeyboard, handleFirst, handlePrev, handleNext, handleLast, cursor, onPositionChange]);\n\n    return (\n        <div className={`pgn-controls ${className}`}>\n            <button\n                className=\"pgn-control-button\"\n                onClick={handleFirst}\n                disabled={cursor.isAtStart()}\n                title=\"First move (Ctrl+←)\"\n            >\n                ⏮\n            </button>\n            <button\n                className=\"pgn-control-button\"\n                onClick={handlePrev}\n                disabled={cursor.isAtStart()}\n                title=\"Previous move (←)\"\n            >\n                ◀\n            </button>\n            <button\n                className=\"pgn-control-button\"\n                onClick={handleNext}\n                disabled={cursor.isAtEnd()}\n                title=\"Next move (→)\"\n            >\n                ▶\n            </button>\n            <button\n                className=\"pgn-control-button\"\n                onClick={handleLast}\n                disabled={cursor.isAtEnd()}\n                title=\"Last move (Ctrl+→)\"\n            >\n                ⏭\n            </button>\n        </div>\n    );\n}\n"],"names":["PGNControls","cursor","onPositionChange","enableKeyboard","className","handleFirst","useCallback","handlePrev","handleNext","handleLast","useEffect","handleKeyDown","jsxs","jsx"],"mappings":";;;AAoBO,SAASA,EAAY;AAAA,EACxB,QAAAC;AAAA,EACA,kBAAAC;AAAA,EACA,gBAAAC,IAAiB;AAAA,EACjB,WAAAC,IAAY;AAChB,GAAqB;AACjB,QAAMC,IAAcC,EAAY,MAAM;AAClC,IAAAL,EAAO,QAAA,GACPC,KAAA,QAAAA,EAAmBD;AAAA,EACvB,GAAG,CAACA,GAAQC,CAAgB,CAAC,GAEvBK,IAAaD,EAAY,MAAM;AACjC,IAAAL,EAAO,KAAA,GACPC,KAAA,QAAAA,EAAmBD;AAAA,EACvB,GAAG,CAACA,GAAQC,CAAgB,CAAC,GAEvBM,IAAaF,EAAY,MAAM;AACjC,IAAAL,EAAO,KAAA,GACPC,KAAA,QAAAA,EAAmBD;AAAA,EACvB,GAAG,CAACA,GAAQC,CAAgB,CAAC,GAEvBO,IAAaH,EAAY,MAAM;AACjC,IAAAL,EAAO,MAAA,GACPC,KAAA,QAAAA,EAAmBD;AAAA,EACvB,GAAG,CAACA,GAAQC,CAAgB,CAAC;AAG7B,SAAAQ,EAAU,MAAM;AACZ,QAAI,CAACP,EAAgB;AAErB,UAAMQ,IAAgB,CAAC,MAAqB;AACxC,MAAI,EAAE,WAAW,EAAE,UACX,EAAE,QAAQ,eACV,EAAE,eAAA,GACFN,EAAA,KACO,EAAE,QAAQ,iBACjB,EAAE,eAAA,GACFI,EAAA,KAGA,EAAE,QAAQ,eACV,EAAE,eAAA,GACFF,EAAA,KACO,EAAE,QAAQ,gBACjB,EAAE,eAAA,GACFC,EAAA,KACO,EAAE,QAAQ,aACjB,EAAE,eAAA,GACFP,EAAO,cAAA,GACPC,KAAA,QAAAA,EAAmBD,MACZ,EAAE,QAAQ,gBACjB,EAAE,eAAA,GACFA,EAAO,eAAe,CAAC,GACvBC,KAAA,QAAAA,EAAmBD;AAAA,IAG/B;AAEA,kBAAO,iBAAiB,WAAWU,CAAa,GACzC,MAAM,OAAO,oBAAoB,WAAWA,CAAa;AAAA,EACpE,GAAG,CAACR,GAAgBE,GAAaE,GAAYC,GAAYC,GAAYR,GAAQC,CAAgB,CAAC,GAG1F,gBAAAU,EAAC,OAAA,EAAI,WAAW,gBAAgBR,CAAS,IACrC,UAAA;AAAA,IAAA,gBAAAS;AAAA,MAAC;AAAA,MAAA;AAAA,QACG,WAAU;AAAA,QACV,SAASR;AAAA,QACT,UAAUJ,EAAO,UAAA;AAAA,QACjB,OAAM;AAAA,QACT,UAAA;AAAA,MAAA;AAAA,IAAA;AAAA,IAGD,gBAAAY;AAAA,MAAC;AAAA,MAAA;AAAA,QACG,WAAU;AAAA,QACV,SAASN;AAAA,QACT,UAAUN,EAAO,UAAA;AAAA,QACjB,OAAM;AAAA,QACT,UAAA;AAAA,MAAA;AAAA,IAAA;AAAA,IAGD,gBAAAY;AAAA,MAAC;AAAA,MAAA;AAAA,QACG,WAAU;AAAA,QACV,SAASL;AAAA,QACT,UAAUP,EAAO,QAAA;AAAA,QACjB,OAAM;AAAA,QACT,UAAA;AAAA,MAAA;AAAA,IAAA;AAAA,IAGD,gBAAAY;AAAA,MAAC;AAAA,MAAA;AAAA,QACG,WAAU;AAAA,QACV,SAASJ;AAAA,QACT,UAAUR,EAAO,QAAA;AAAA,QACjB,OAAM;AAAA,QACT,UAAA;AAAA,MAAA;AAAA,IAAA;AAAA,EAED,GACJ;AAER;"}

package/dist/viewer/PGNViewer.js

@@ -0,0 +1,94 @@
+import { jsx as o, jsxs as l, Fragment as v } from "react/jsx-runtime";
+import { useState as f, useEffect as $, useCallback as N } from "react";
+import { GameCursor as x } from "../cursor/game-cursor.js";
+import { nagToSymbol as b } from "../utils/nag-symbols.js";
+/* empty css           */
+function k({
+  root: s,
+  cursor: a,
+  onMoveClick: t,
+  className: i = ""
+}) {
+  const [e] = f(() => new x(s)), n = a || e, [p, c] = f(n.current.id);
+  $(() => {
+    c(n.current.id);
+  }, [n.current.id]);
+  const m = N(
+    (r) => {
+      n.goTo(r.id), c(r.id), t == null || t(r);
+    },
+    [n, t]
+  );
+  return /* @__PURE__ */ o("div", { className: `pgn-viewer ${i}`, children: h(s, p, m, 0) });
+}
+function h(s, a, t, i) {
+  const e = [];
+  let n = s.next;
+  for (; n; ) {
+    const p = n.id === a, c = n.color === "w";
+    n.commentBefore && e.push(
+      /* @__PURE__ */ o("span", { className: "pgn-comment", children: `{${n.commentBefore}}` }, `comment-before-${n.id}`)
+    ), c && e.push(
+      /* @__PURE__ */ l("span", { className: "pgn-move-number", children: [
+        n.moveNumber,
+        "."
+      ] }, `move-num-${n.id}`)
+    );
+    const m = n.nags.map(b).join("");
+    e.push(
+      /* @__PURE__ */ l(
+        "span",
+        {
+          className: `pgn-move ${p ? "pgn-move-current" : ""}`,
+          onClick: () => t(n),
+          style: { cursor: "pointer" },
+          children: [
+            n.san,
+            m && /* @__PURE__ */ o("span", { className: "pgn-nag", children: m })
+          ]
+        },
+        n.id
+      )
+    ), n.commentAfter && e.push(
+      /* @__PURE__ */ o("span", { className: "pgn-comment", children: `{${n.commentAfter}}` }, `comment-after-${n.id}`)
+    );
+    const r = [];
+    if (n.clock !== void 0) {
+      const u = Math.floor(n.clock / 3600), d = Math.floor(n.clock % 3600 / 60), g = n.clock % 60;
+      r.push(`clk ${u}:${d.toString().padStart(2, "0")}:${g.toString().padStart(2, "0")}`);
+    }
+    n.eval !== void 0 && r.push(`eval ${n.eval > 0 ? "+" : ""}${n.eval.toFixed(2)}`), r.length > 0 && e.push(
+      /* @__PURE__ */ l("span", { className: "pgn-annotation", children: [
+        "[",
+        r.join(", "),
+        "]"
+      ] }, `annotations-${n.id}`)
+    ), n.variations.length > 0 && n.variations.forEach((u, d) => {
+      e.push(
+        /* @__PURE__ */ l(
+          "div",
+          {
+            className: "pgn-variation",
+            style: { marginLeft: `${(i + 1) * 20}px` },
+            children: [
+              "(",
+              h(
+                { ...n, next: u },
+                a,
+                t,
+                i + 1
+              ),
+              ")"
+            ]
+          },
+          `variation-${n.id}-${d}`
+        )
+      );
+    }), n = n.next;
+  }
+  return /* @__PURE__ */ o(v, { children: e });
+}
+export {
+  k as PGNViewer
+};
+//# sourceMappingURL=PGNViewer.js.map

package/dist/viewer/PGNViewer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PGNViewer.js","sources":["../../src/viewer/PGNViewer.tsx"],"sourcesContent":["'use client';\n\nimport React, { useState, useEffect, useCallback } from 'react';\nimport { MoveNode } from '../model/move-node.js';\nimport { GameCursor } from '../cursor/game-cursor.js';\nimport { nagToSymbol } from '../utils/nag-symbols.js';\nimport './styles.css';\n\nexport interface PGNViewerProps {\n    /** The root node of the game tree */\n    root: MoveNode;\n    /** Optional cursor for external control */\n    cursor?: GameCursor;\n    /** Callback when a move is clicked */\n    onMoveClick?: (node: MoveNode) => void;\n    /** Custom class name */\n    className?: string;\n}\n\n/**\n * Displays a chess game in PGN notation with support for variations.\n */\nexport function PGNViewer({\n    root,\n    cursor: externalCursor,\n    onMoveClick,\n    className = '',\n}: PGNViewerProps) {\n    const [internalCursor] = useState(() => new GameCursor(root));\n    const cursor = externalCursor || internalCursor;\n    const [currentNodeId, setCurrentNodeId] = useState(cursor.current.id);\n\n    // Update when cursor changes\n    useEffect(() => {\n        setCurrentNodeId(cursor.current.id);\n    }, [cursor.current.id]);\n\n    const handleMoveClick = useCallback(\n        (node: MoveNode) => {\n            cursor.goTo(node.id);\n            setCurrentNodeId(node.id);\n            onMoveClick?.(node);\n        },\n        [cursor, onMoveClick]\n    );\n\n    return (\n        <div className={`pgn-viewer ${className}`}>\n            {renderMoveTree(root, currentNodeId, handleMoveClick, 0)}\n        </div>\n    );\n}\n\n/**\n * Recursively renders the move tree with proper indentation for variations.\n */\nfunction renderMoveTree(\n    node: MoveNode,\n    currentNodeId: string,\n    onMoveClick: (node: MoveNode) => void,\n    depth: number\n): React.ReactNode {\n    const elements: React.ReactNode[] = [];\n    let currentNode: MoveNode | undefined = node.next;\n    let moveIndex = 0;\n\n    while (currentNode) {\n        const isCurrentMove = currentNode.id === currentNodeId;\n        const showMoveNumber = currentNode.color === 'w';\n\n        // Comment before move\n        if (currentNode.commentBefore) {\n            elements.push(\n                <span key={`comment-before-${currentNode.id}`} className=\"pgn-comment\">\n                    {`{${currentNode.commentBefore}}`}\n                </span>\n            );\n        }\n\n        // Move number for white moves\n        if (showMoveNumber) {\n            elements.push(\n                <span key={`move-num-${currentNode.id}`} className=\"pgn-move-number\">\n                    {currentNode.moveNumber}.\n                </span>\n            );\n        }\n\n        // The move itself\n        const nags = currentNode.nags.map(nagToSymbol).join('');\n        elements.push(\n            <span\n                key={currentNode.id}\n                className={`pgn-move ${isCurrentMove ? 'pgn-move-current' : ''}`}\n                onClick={() => onMoveClick(currentNode!)}\n                style={{ cursor: 'pointer' }}\n            >\n                {currentNode.san}\n                {nags && <span className=\"pgn-nag\">{nags}</span>}\n            </span>\n        );\n\n        // Comment after move\n        if (currentNode.commentAfter) {\n            elements.push(\n                <span key={`comment-after-${currentNode.id}`} className=\"pgn-comment\">\n                    {`{${currentNode.commentAfter}}`}\n                </span>\n            );\n        }\n\n        // Annotations (clock, eval)\n        const annotations: string[] = [];\n        if (currentNode.clock !== undefined) {\n            const hours = Math.floor(currentNode.clock / 3600);\n            const minutes = Math.floor((currentNode.clock % 3600) / 60);\n            const seconds = currentNode.clock % 60;\n            annotations.push(`clk ${hours}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`);\n        }\n        if (currentNode.eval !== undefined) {\n            annotations.push(`eval ${currentNode.eval > 0 ? '+' : ''}${currentNode.eval.toFixed(2)}`);\n        }\n\n        if (annotations.length > 0) {\n            elements.push(\n                <span key={`annotations-${currentNode.id}`} className=\"pgn-annotation\">\n                    [{annotations.join(', ')}]\n                </span>\n            );\n        }\n\n        // Variations\n        if (currentNode.variations.length > 0) {\n            currentNode.variations.forEach((variation, index) => {\n                elements.push(\n                    <div\n                        key={`variation-${currentNode!.id}-${index}`}\n                        className=\"pgn-variation\"\n                        style={{ marginLeft: `${(depth + 1) * 20}px` }}\n                    >\n                        (\n                        {renderMoveTree(\n                            { ...currentNode!, next: variation },\n                            currentNodeId,\n                            onMoveClick,\n                            depth + 1\n                        )}\n                        )\n                    </div>\n                );\n            });\n        }\n\n        currentNode = currentNode.next;\n        moveIndex++;\n    }\n\n    return <>{elements}</>;\n}\n"],"names":["PGNViewer","root","externalCursor","onMoveClick","className","internalCursor","useState","GameCursor","cursor","currentNodeId","setCurrentNodeId","useEffect","handleMoveClick","useCallback","node","jsx","renderMoveTree","depth","elements","currentNode","isCurrentMove","showMoveNumber","jsxs","nags","nagToSymbol","annotations","hours","minutes","seconds","variation","index"],"mappings":"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"}

package/dist/viewer/index.js

@@ -0,0 +1,7 @@
+import { PGNViewer as e } from "./PGNViewer.js";
+import { PGNControls as f } from "./PGNControls.js";
+export {
+  f as PGNControls,
+  e as PGNViewer
+};
+//# sourceMappingURL=index.js.map

package/dist/viewer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "pgn-viewer-parser",
+  "version": "1.0.0",
+  "description": "A production-ready PGN parser and viewer library for chess, with full support for variations, comments, NAGs, and annotations",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./viewer": {
+      "types": "./dist/viewer/index.d.ts",
+      "import": "./dist/viewer/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && vite build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "npm run type-check && npm run test && npm run build"
+  },
+  "keywords": [
+    "chess",
+    "pgn",
+    "parser",
+    "viewer",
+    "react",
+    "nextjs",
+    "typescript",
+    "variations",
+    "tree"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/react": "^18.2.48",
+    "@types/react-dom": "^18.2.18",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.11",
+    "vitest": "^1.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/pgn-viewer-parser.git"
+  }
+}