@pokertools/evaluator 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aurelius
+
+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

@@ -0,0 +1,159 @@
+# @pokertools/evaluator
+
+[![npm version](https://img.shields.io/npm/v/@pokertools/evaluator.svg)](https://www.npmjs.com/package/@pokertools/evaluator)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A lightning-fast, strongly-typed Poker Hand Evaluator for Node.js and the browser.
+
+Capable of evaluating **over 16 million 7-card hands per second** on a standard CPU. This library uses a Perfect Hash algorithm (based on Cactus Kev/Paul Senzee) optimized specifically for the V8 JavaScript engine.
+
+## 🚀 Features
+
+- **Extreme Performance:** ~17M evaluations/sec (7-card hands).
+- **Zero Garbage Collection:** Uses static memory buffers to prevent GC overhead during Monte Carlo simulations.
+- **Flexible:** Supports 5, 6, and 7 card hands.
+- **TypeScript:** Written in strict TypeScript with full type definitions.
+- **Lightweight:** Zero runtime dependencies.
+
+## ⚡ Benchmarks
+
+Comparison of 7-card hand evaluation speed (Node.js V8):
+
+| Library                   | Input Type  | Speed (Hands/Sec) | Relative Speed |
+| :------------------------ | :---------- | :---------------- | :------------- |
+| **@pokertools/evaluator** | **Integer** | **~17,900,000**   | **100%**       |
+| phe                       | Integer     | ~16,550,000       | 92.5%          |
+| poker-evaluator           | String      | ~1,390,000        | 7.7%           |
+| pokersolver               | String      | ~73,000           | 0.4%           |
+
+### Raw Output
+
+```text
+🃏 Starting Benchmark: 1000 random 7-card hands per cycle
+----------------------------------------------------------------
+phe (Int)                 |      16,574,257 hands/sec | ±2.26%
+poker-evaluator (Str)     |       1,375,495 hands/sec | ±0.33%
+pokersolver (Str)         |          70,980 hands/sec | ±0.70%
+@pokertools (Int)         |      17,915,292 hands/sec | ±1.56%
+----------------------------------------------------------------
+🚀 WINNER: @pokertools (Int)
+```
+
+_Benchmarks run on an M1 Air. Higher is better._
+
+## 📦 Installation
+
+```bash
+npm install @pokertools/evaluator
+```
+
+## 📖 Usage
+
+### 1. Basic Usage (Strings)
+
+If you are building a UI or simple game logic, string inputs are easiest to work with.
+
+```typescript
+import { evaluateBoard, rankBoard, rankDescription } from "@pokertools/evaluator";
+
+// 1. Get a raw strength score (lower is better)
+const score = evaluateBoard("Ah Kh Qh Jh Th 2c 3c");
+console.log(score); // 1 (Royal Flush is the lowest/best number)
+
+// 2. Get the Rank Category (Enum)
+const rank = rankBoard("Ah As Ks Kd Qs Qd 2c");
+console.log(rankDescription(rank)); // "Two Pair"
+```
+
+### 2. High-Performance Usage (Integers)
+
+If you are building an Equity Calculator or AI Solver, you should convert cards to integers **once** and pass integers around your system. This creates a 12x performance boost by skipping string parsing.
+
+```typescript
+import { evaluate, getCardCode, rank, HandRank } from "@pokertools/evaluator";
+
+// Convert strings to integers once
+const holeCards = [getCardCode("As"), getCardCode("Ah")];
+const board = [getCardCode("Ks"), getCardCode("Kh"), getCardCode("Qs")];
+
+// Combine arrays (Spread operator is fast enough for small arrays)
+const hand = [...holeCards, ...board];
+
+// Evaluate
+const strength = evaluate(hand);
+
+// Check Rank
+if (rank(hand) === HandRank.FullHouse) {
+  console.log("We have a boat!");
+}
+```
+
+## 📚 API Reference
+
+### Core Functions
+
+#### `evaluate(codes: number[]): number`
+
+The fastest evaluation method. Accepts an array of 5, 6, or 7 integers. Returns a raw score (lower is better).
+
+- Royal Flush: 1
+- ...
+- Worst High Card: 7462
+
+#### `evaluateStrings(cards: string[]): number`
+
+Helper to evaluate an array of strings like `['Ah', 'Td', ...]`.
+
+#### `evaluateBoard(board: string): number`
+
+Helper to evaluate a space-separated string like `"Ah Td 2c"`.
+
+### Ranking Helpers
+
+#### `rank(codes: number[]): HandRank`
+
+Returns the `HandRank` enum (0-8) for a set of card integers.
+
+#### `HandRank` (Enum)
+
+```typescript
+enum HandRank {
+  StraightFlush = 0,
+  FourOfAKind = 1,
+  FullHouse = 2,
+  Flush = 3,
+  Straight = 4,
+  ThreeOfAKind = 5,
+  TwoPair = 6,
+  OnePair = 7,
+  HighCard = 8,
+}
+```
+
+#### `rankDescription(rank: HandRank): string`
+
+Returns human-readable strings like "Full House" or "High Card".
+
+### Card Encoding
+
+#### `getCardCode(cardStr: string): number`
+
+Converts a card string (e.g., `"Ah"`) into the optimized integer format used by this library.
+
+#### `stringifyCardCode(code: number): string`
+
+Converts an integer back into a readable string.
+
+## 🧮 Algorithm
+
+This library implements the **Perfect Hash** algorithm.
+
+1.  It first checks for a Flush using a bitmask OR operation.
+2.  If no flush, it calculates a unique prime-product hash (Quinary) based on the rank counts.
+3.  This hash is used as an index into a pre-computed DAG (Directed Acyclic Graph) lookup table to immediately return the hand strength.
+
+This approach avoids expensive sorting or pattern matching operations found in slower libraries.
+
+## License
+
+MIT

package/dist/core/evaluator.d.ts

@@ -0,0 +1,3 @@
+export declare function evaluate5Cards(cards: number[]): number;
+export declare function evaluate6Cards(cards: number[]): number;
+export declare function evaluate7Cards(cards: number[]): number;

package/dist/core/evaluator.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluate5Cards = evaluate5Cards;
+exports.evaluate6Cards = evaluate6Cards;
+exports.evaluate7Cards = evaluate7Cards;
+const bit_masks_1 = require("../tables/bit-masks");
+const dp_1 = require("../tables/dp");
+const flush_1 = require("../tables/flush");
+const no_flush_5_1 = require("../tables/no-flush-5");
+const no_flush_6_1 = require("../tables/no-flush-6");
+const no_flush_7_1 = require("../tables/no-flush-7");
+const hash_1 = require("./hash");
+/**
+ * Static buffers to prevent garbage collection overhead during hot loop evaluations.
+ *
+ * @internal
+ * @warning NOT THREAD-SAFE / NOT RE-ENTRANT
+ *
+ * These static arrays are reused across all evaluate() calls within the same
+ * JavaScript context to eliminate GC pressure during Monte Carlo simulations.
+ *
+ * **Thread Safety Implications:**
+ * - Safe for standard Node.js/Browser single-threaded execution
+ * - Safe for async/await code (each await yields control)
+ * - NOT safe if called recursively (don't call evaluate() from within evaluate())
+ * - NOT safe with SharedArrayBuffer or true multi-threaded contexts
+ * - NOT safe if multiple evaluate() calls are interleaved in the same tick
+ *
+ * **Performance Trade-off:**
+ * Using static buffers provides ~12% speed improvement (17M vs 15M hands/sec)
+ * by avoiding array allocations in the hot path. The non-reentrancy is acceptable
+ * because poker hand evaluation is a synchronous, non-recursive operation.
+ *
+ * @example
+ * // ✅ SAFE: Sequential evaluation
+ * const score1 = evaluate(hand1);
+ * const score2 = evaluate(hand2);
+ *
+ * @example
+ * // ✅ SAFE: Async is OK (yields between calls)
+ * for (const hand of hands) {
+ *   const score = evaluate(hand);
+ *   await saveToDatabase(score);
+ * }
+ *
+ * @example
+ * // ❌ UNSAFE: Recursive call
+ * function badIdea(cards) {
+ *   if (cards.length > 7) {
+ *     return evaluate(cards.slice(0, 7)); // Corrupts static buffers!
+ *   }
+ *   return evaluate(cards);
+ * }
+ */
+const suitBinary = [0, 0, 0, 0];
+const quinary = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+/**
+ * Fast reset of static buffers.
+ * Manual index assignment is faster than .fill(0).
+ */
+function resetBuffers() {
+    suitBinary[0] = 0;
+    suitBinary[1] = 0;
+    suitBinary[2] = 0;
+    suitBinary[3] = 0;
+    quinary[0] = 0;
+    quinary[1] = 0;
+    quinary[2] = 0;
+    quinary[3] = 0;
+    quinary[4] = 0;
+    quinary[5] = 0;
+    quinary[6] = 0;
+    quinary[7] = 0;
+    quinary[8] = 0;
+    quinary[9] = 0;
+    quinary[10] = 0;
+    quinary[11] = 0;
+    quinary[12] = 0;
+}
+function evaluate5Cards(cards) {
+    const c1 = cards[0], c2 = cards[1], c3 = cards[2], c4 = cards[3], c5 = cards[4];
+    resetBuffers();
+    // 1. Calculate Suit Hash
+    const suitHash = bit_masks_1.SUITBIT_BY_ID[c1] +
+        bit_masks_1.SUITBIT_BY_ID[c2] +
+        bit_masks_1.SUITBIT_BY_ID[c3] +
+        bit_masks_1.SUITBIT_BY_ID[c4] +
+        bit_masks_1.SUITBIT_BY_ID[c5];
+    // 2. Populate Rank Frequency (Quinary)
+    quinary[c1 >> 2]++;
+    quinary[c2 >> 2]++;
+    quinary[c3 >> 2]++;
+    quinary[c4 >> 2]++;
+    quinary[c5 >> 2]++;
+    // 3. Check for Flush using DP Table
+    if (dp_1.SUITS_HASH[suitHash]) {
+        suitBinary[c1 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c1];
+        suitBinary[c2 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c2];
+        suitBinary[c3 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c3];
+        suitBinary[c4 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c4];
+        suitBinary[c5 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c5];
+        return flush_1.FLUSH_LOOKUP[suitBinary[dp_1.SUITS_HASH[suitHash] - 1]];
+    }
+    // 4. Check Hash Table
+    const hash = (0, hash_1.hashQuinary)(quinary, 13, 5);
+    return no_flush_5_1.NO_FLUSH_5[hash];
+}
+function evaluate6Cards(cards) {
+    const c1 = cards[0], c2 = cards[1], c3 = cards[2], c4 = cards[3], c5 = cards[4], c6 = cards[5];
+    resetBuffers();
+    const suitHash = bit_masks_1.SUITBIT_BY_ID[c1] +
+        bit_masks_1.SUITBIT_BY_ID[c2] +
+        bit_masks_1.SUITBIT_BY_ID[c3] +
+        bit_masks_1.SUITBIT_BY_ID[c4] +
+        bit_masks_1.SUITBIT_BY_ID[c5] +
+        bit_masks_1.SUITBIT_BY_ID[c6];
+    quinary[c1 >> 2]++;
+    quinary[c2 >> 2]++;
+    quinary[c3 >> 2]++;
+    quinary[c4 >> 2]++;
+    quinary[c5 >> 2]++;
+    quinary[c6 >> 2]++;
+    if (dp_1.SUITS_HASH[suitHash]) {
+        suitBinary[c1 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c1];
+        suitBinary[c2 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c2];
+        suitBinary[c3 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c3];
+        suitBinary[c4 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c4];
+        suitBinary[c5 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c5];
+        suitBinary[c6 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c6];
+        return flush_1.FLUSH_LOOKUP[suitBinary[dp_1.SUITS_HASH[suitHash] - 1]];
+    }
+    const hash = (0, hash_1.hashQuinary)(quinary, 13, 6);
+    return no_flush_6_1.NO_FLUSH_6[hash];
+}
+function evaluate7Cards(cards) {
+    const c1 = cards[0], c2 = cards[1], c3 = cards[2], c4 = cards[3], c5 = cards[4], c6 = cards[5], c7 = cards[6];
+    resetBuffers();
+    const suitHash = bit_masks_1.SUITBIT_BY_ID[c1] +
+        bit_masks_1.SUITBIT_BY_ID[c2] +
+        bit_masks_1.SUITBIT_BY_ID[c3] +
+        bit_masks_1.SUITBIT_BY_ID[c4] +
+        bit_masks_1.SUITBIT_BY_ID[c5] +
+        bit_masks_1.SUITBIT_BY_ID[c6] +
+        bit_masks_1.SUITBIT_BY_ID[c7];
+    quinary[c1 >> 2]++;
+    quinary[c2 >> 2]++;
+    quinary[c3 >> 2]++;
+    quinary[c4 >> 2]++;
+    quinary[c5 >> 2]++;
+    quinary[c6 >> 2]++;
+    quinary[c7 >> 2]++;
+    if (dp_1.SUITS_HASH[suitHash]) {
+        suitBinary[c1 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c1];
+        suitBinary[c2 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c2];
+        suitBinary[c3 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c3];
+        suitBinary[c4 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c4];
+        suitBinary[c5 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c5];
+        suitBinary[c6 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c6];
+        suitBinary[c7 & 0x3] |= bit_masks_1.BINARIES_BY_ID[c7];
+        return flush_1.FLUSH_LOOKUP[suitBinary[dp_1.SUITS_HASH[suitHash] - 1]];
+    }
+    const hash = (0, hash_1.hashQuinary)(quinary, 13, 7);
+    return no_flush_7_1.NO_FLUSH_7[hash];
+}

package/dist/core/hash.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Perfect Hash algorithm for quinary sums.
+ *
+ * @param q - The frequency array of ranks (count of 2s, count of 3s, etc.)
+ * @param len - Number of ranks (always 13)
+ * @param k - Number of cards (5, 6, or 7)
+ */
+export declare function hashQuinary(q: number[], len: number, k: number): number;

package/dist/core/hash.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashQuinary = hashQuinary;
+const dp_1 = require("../tables/dp");
+/**
+ * Perfect Hash algorithm for quinary sums.
+ *
+ * @param q - The frequency array of ranks (count of 2s, count of 3s, etc.)
+ * @param len - Number of ranks (always 13)
+ * @param k - Number of cards (5, 6, or 7)
+ */
+function hashQuinary(q, len, k) {
+    let sum = 0;
+    for (let i = 0; i < len; i++) {
+        sum += dp_1.DP_MATRIX[q[i]][len - i - 1][k];
+        k -= q[i];
+        // Optimization: if we have accounted for all cards (k=0), we can stop early.
+        if (k <= 0)
+            break;
+    }
+    return sum;
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { HandRank } from "./models/hand-rank";
+export { HandRank, HAND_RANK_DESCRIPTIONS } from "./models/hand-rank";
+export { stringifyCardCode, getCardCode, getCardCodes } from "./utils/card";
+/**
+ * Primary entry point.
+ * Evaluates 5, 6, or 7 card integer codes.
+ * Returns a strength score (lower is better).
+ *
+ * @param codes Array of card integers (e.g. generated by getCardCode)
+ */
+export declare function evaluate(codes: number[]): number;
+/**
+ * Evaluates an array of card strings (e.g. ['As', 'Kd', ...]).
+ * Slightly slower than `evaluate` due to parsing overhead.
+ */
+export declare function evaluateStrings(cards: string[]): number;
+/**
+ * Evaluates a board string (e.g. "As Kd Qh ...").
+ */
+export declare function evaluateBoard(board: string): number;
+/**
+ * Returns the HandRank (enum 0-8) for a given set of card integers.
+ * Useful for categorizing hands (e.g. "Full House").
+ */
+export declare function rank(codes: number[]): HandRank;
+/**
+ * Returns the HandRank (enum 0-8) for a given board string.
+ */
+export declare function rankBoard(board: string): HandRank;
+/**
+ * Returns the human-readable name of the hand rank (e.g. "Straight Flush").
+ */
+export declare function rankDescription(rank: HandRank): string;

package/dist/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCardCodes = exports.getCardCode = exports.stringifyCardCode = exports.HAND_RANK_DESCRIPTIONS = exports.HandRank = void 0;
+exports.evaluate = evaluate;
+exports.evaluateStrings = evaluateStrings;
+exports.evaluateBoard = evaluateBoard;
+exports.rank = rank;
+exports.rankBoard = rankBoard;
+exports.rankDescription = rankDescription;
+const evaluator_1 = require("./core/evaluator");
+const card_1 = require("./utils/card");
+const hand_rank_1 = require("./models/hand-rank");
+// Export Constants and Enums for consumers
+var hand_rank_2 = require("./models/hand-rank");
+Object.defineProperty(exports, "HandRank", { enumerable: true, get: function () { return hand_rank_2.HandRank; } });
+Object.defineProperty(exports, "HAND_RANK_DESCRIPTIONS", { enumerable: true, get: function () { return hand_rank_2.HAND_RANK_DESCRIPTIONS; } });
+var card_2 = require("./utils/card");
+Object.defineProperty(exports, "stringifyCardCode", { enumerable: true, get: function () { return card_2.stringifyCardCode; } });
+Object.defineProperty(exports, "getCardCode", { enumerable: true, get: function () { return card_2.getCardCode; } });
+Object.defineProperty(exports, "getCardCodes", { enumerable: true, get: function () { return card_2.getCardCodes; } });
+/**
+ * Primary entry point.
+ * Evaluates 5, 6, or 7 card integer codes.
+ * Returns a strength score (lower is better).
+ *
+ * @param codes Array of card integers (e.g. generated by getCardCode)
+ */
+function evaluate(codes) {
+    const len = codes.length;
+    if (len === 7)
+        return (0, evaluator_1.evaluate7Cards)(codes);
+    if (len === 6)
+        return (0, evaluator_1.evaluate6Cards)(codes);
+    if (len === 5)
+        return (0, evaluator_1.evaluate5Cards)(codes);
+    throw new Error(`Evaluator requires 5, 6, or 7 cards. Received ${len}.`);
+}
+/**
+ * Evaluates an array of card strings (e.g. ['As', 'Kd', ...]).
+ * Slightly slower than `evaluate` due to parsing overhead.
+ */
+function evaluateStrings(cards) {
+    return evaluate((0, card_1.getCardCodes)(cards));
+}
+/**
+ * Evaluates a board string (e.g. "As Kd Qh ...").
+ */
+function evaluateBoard(board) {
+    return evaluate((0, card_1.getBoardCodes)(board));
+}
+/**
+ * Returns the HandRank (enum 0-8) for a given set of card integers.
+ * Useful for categorizing hands (e.g. "Full House").
+ */
+function rank(codes) {
+    return (0, hand_rank_1.getHandRank)(evaluate(codes));
+}
+/**
+ * Returns the HandRank (enum 0-8) for a given board string.
+ */
+function rankBoard(board) {
+    return (0, hand_rank_1.getHandRank)(evaluateBoard(board));
+}
+/**
+ * Returns the human-readable name of the hand rank (e.g. "Straight Flush").
+ */
+function rankDescription(rank) {
+    return hand_rank_1.HAND_RANK_DESCRIPTIONS[rank];
+}

package/dist/models/hand-rank.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Standard Poker Hand Ranks.
+ * Using const enum for inlining performance.
+ */
+export declare const enum HandRank {
+    StraightFlush = 0,
+    FourOfAKind = 1,
+    FullHouse = 2,
+    Flush = 3,
+    Straight = 4,
+    ThreeOfAKind = 5,
+    TwoPair = 6,
+    OnePair = 7,
+    HighCard = 8
+}
+export declare const HAND_RANK_DESCRIPTIONS: Readonly<Record<HandRank, string>>;
+/**
+ * Converts a raw evaluator score into a HandRank category.
+ * Thresholds are based on the specific hash algorithm used.
+ */
+export declare function getHandRank(val: number): HandRank;

package/dist/models/hand-rank.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HAND_RANK_DESCRIPTIONS = exports.HandRank = void 0;
+exports.getHandRank = getHandRank;
+/**
+ * Standard Poker Hand Ranks.
+ * Using const enum for inlining performance.
+ */
+var HandRank;
+(function (HandRank) {
+    HandRank[HandRank["StraightFlush"] = 0] = "StraightFlush";
+    HandRank[HandRank["FourOfAKind"] = 1] = "FourOfAKind";
+    HandRank[HandRank["FullHouse"] = 2] = "FullHouse";
+    HandRank[HandRank["Flush"] = 3] = "Flush";
+    HandRank[HandRank["Straight"] = 4] = "Straight";
+    HandRank[HandRank["ThreeOfAKind"] = 5] = "ThreeOfAKind";
+    HandRank[HandRank["TwoPair"] = 6] = "TwoPair";
+    HandRank[HandRank["OnePair"] = 7] = "OnePair";
+    HandRank[HandRank["HighCard"] = 8] = "HighCard";
+})(HandRank || (exports.HandRank = HandRank = {}));
+exports.HAND_RANK_DESCRIPTIONS = {
+    [0 /* HandRank.StraightFlush */]: "Straight Flush",
+    [1 /* HandRank.FourOfAKind */]: "Four of a Kind",
+    [2 /* HandRank.FullHouse */]: "Full House",
+    [3 /* HandRank.Flush */]: "Flush",
+    [4 /* HandRank.Straight */]: "Straight",
+    [5 /* HandRank.ThreeOfAKind */]: "Three of a Kind",
+    [6 /* HandRank.TwoPair */]: "Two Pair",
+    [7 /* HandRank.OnePair */]: "One Pair",
+    [8 /* HandRank.HighCard */]: "High Card",
+};
+/**
+ * Converts a raw evaluator score into a HandRank category.
+ * Thresholds are based on the specific hash algorithm used.
+ */
+function getHandRank(val) {
+    if (val > 6185)
+        return 8 /* HandRank.HighCard */; // 1277 high cards
+    if (val > 3325)
+        return 7 /* HandRank.OnePair */; // 2860 one pairs
+    if (val > 2467)
+        return 6 /* HandRank.TwoPair */; //  858 two pairs
+    if (val > 1609)
+        return 5 /* HandRank.ThreeOfAKind */; //  858 three-kinds
+    if (val > 1599)
+        return 4 /* HandRank.Straight */; //   10 straights
+    if (val > 322)
+        return 3 /* HandRank.Flush */; // 1277 flushes
+    if (val > 166)
+        return 2 /* HandRank.FullHouse */; //  156 full houses
+    if (val > 10)
+        return 1 /* HandRank.FourOfAKind */; //  156 four-kinds
+    return 0 /* HandRank.StraightFlush */; //   10 straight-flushes
+}

package/dist/tables/bit-masks.d.ts

@@ -0,0 +1,2 @@
+export declare const BINARIES_BY_ID: readonly number[];
+export declare const SUITBIT_BY_ID: readonly number[];

package/dist/tables/bit-masks.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUITBIT_BY_ID = exports.BINARIES_BY_ID = void 0;
+exports.BINARIES_BY_ID = [
+    0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x4, 0x4, 0x4, 0x4, 0x8, 0x8, 0x8, 0x8, 0x10, 0x10, 0x10,
+    0x10, 0x20, 0x20, 0x20, 0x20, 0x40, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80, 0x100, 0x100, 0x100,
+    0x100, 0x200, 0x200, 0x200, 0x200, 0x400, 0x400, 0x400, 0x400, 0x800, 0x800, 0x800, 0x800, 0x1000,
+    0x1000, 0x1000, 0x1000,
+];
+exports.SUITBIT_BY_ID = [
+    0x1, 0x8, 0x40, 0x200, 0x1, 0x8, 0x40, 0x200, 0x1, 0x8, 0x40, 0x200, 0x1, 0x8, 0x40, 0x200, 0x1,
+    0x8, 0x40, 0x200, 0x1, 0x8, 0x40, 0x200, 0x1, 0x8, 0x40, 0x200, 0x1, 0x8, 0x40, 0x200, 0x1, 0x8,
+    0x40, 0x200, 0x1, 0x8, 0x40, 0x200, 0x1, 0x8, 0x40, 0x200, 0x1, 0x8, 0x40, 0x200, 0x1, 0x8, 0x40,
+    0x200,
+];

package/dist/tables/dp.d.ts

@@ -0,0 +1,3 @@
+export declare const CHOOSE_MATRIX: readonly number[][];
+export declare const DP_MATRIX: readonly number[][][];
+export declare const SUITS_HASH: readonly number[];