@pai-forge/riichi-mahjong 0.1.0

package/dist/features/yaku/lib/definitions/iipeiko.js

@@ -0,0 +1,46 @@
+import { createYakuDefinition } from "../../factory";
+const IIPEIKO_YAKU = {
+    name: "Iipeikou",
+    han: {
+        open: 0, // 門前限定
+        closed: 1,
+    },
+};
+const checkIipeiko = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const shuntsuList = hand.fourMentsu.filter((mentsu) => mentsu.type === "Shuntsu");
+    // 順子が2つ未満なら一盃口はあり得ない
+    if (shuntsuList.length < 2) {
+        return false;
+    }
+    // 同じ順子が2つあるか探す
+    // haisの内容比較が必要。Shuntsu.haisはソート済みであることを前提とするか、
+    // ここで比較用キーを作って判定する。
+    // ライブラリの仕様としてShuntsuのhaisは [T, T, T] だが順序保証は型定義上は明示されていないものの、
+    // 一般的な実装として昇順になっているはず。
+    // 安全のため、各順子の牌をソートした文字列などをキーにして比較する。
+    // ただし、Shuntsu定義上 [T, T, T] で、順子である以上連続しているため、
+    // 先頭の牌（最小の牌）が同じで、種類（萬子/筒子/索子）が同じなら同一順子とみなせる。
+    // しかし HaiKindId の単純な数値比較で十分。
+    // 例えば 1m, 2m, 3m の順子は [0, 1, 2]。
+    // 順子の構成牌IDが完全一致するかどうかを見れば良い。
+    for (let i = 0; i < shuntsuList.length; i++) {
+        for (let j = i + 1; j < shuntsuList.length; j++) {
+            const shuntsuA = shuntsuList[i];
+            const shuntsuB = shuntsuList[j];
+            if (!shuntsuA || !shuntsuB)
+                continue;
+            // 牌のID列が完全に一致するか
+            const isSame = shuntsuA.hais[0] === shuntsuB.hais[0] &&
+                shuntsuA.hais[1] === shuntsuB.hais[1] &&
+                shuntsuA.hais[2] === shuntsuB.hais[2];
+            if (isSame) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+export const iipeikoDefinition = createYakuDefinition(IIPEIKO_YAKU, checkIipeiko);

package/dist/features/yaku/lib/definitions/ikkitsuukan.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const ikkitsuukanDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/ikkitsuukan.js

@@ -0,0 +1,56 @@
+import { createYakuDefinition } from "../../factory";
+const IKKITSUUKAN_YAKU = {
+    name: "Ikkitsuukan",
+    han: {
+        open: 1,
+        closed: 2,
+    },
+};
+const checkIkkitsuukan = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const shuntsuList = hand.fourMentsu.filter((mentsu) => mentsu.type === "Shuntsu");
+    if (shuntsuList.length < 3) {
+        return false;
+    }
+    // 順子リストから3つの組み合わせを全てチェックし、一気通貫の条件を満たすものを探す
+    // 条件:
+    // 1. 3つの順子が全て同じ色（萬子、筒子、索子のいずれか）であること
+    // 2. 3つの順子がそれぞれ 1-2-3, 4-5-6, 7-8-9 であること
+    //    （インデックスの余りが 0, 3, 6 となること）
+    for (let i = 0; i < shuntsuList.length; i++) {
+        for (let j = i + 1; j < shuntsuList.length; j++) {
+            for (let k = j + 1; k < shuntsuList.length; k++) {
+                const s1 = shuntsuList[i];
+                const s2 = shuntsuList[j];
+                const s3 = shuntsuList[k];
+                if (!s1 || !s2 || !s3)
+                    continue;
+                const firstHai1 = s1.hais[0];
+                const firstHai2 = s2.hais[0];
+                const firstHai3 = s3.hais[0];
+                const suit1 = Math.floor(firstHai1 / 9);
+                const suit2 = Math.floor(firstHai2 / 9);
+                const suit3 = Math.floor(firstHai3 / 9);
+                // 全て同じ色でなければならない
+                if (suit1 !== suit2 || suit2 !== suit3)
+                    continue;
+                // 字牌が含まれていないかチェック（念のため）
+                if (suit1 > 2)
+                    continue;
+                // 数値（インデックス）を取得
+                const num1 = firstHai1 % 9;
+                const num2 = firstHai2 % 9;
+                const num3 = firstHai3 % 9;
+                // 0 (1-2-3), 3 (4-5-6), 6 (7-8-9) が揃っていれば成立
+                const nums = new Set([num1, num2, num3]);
+                if (nums.has(0) && nums.has(3) && nums.has(6)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+export const ikkitsuukanDefinition = createYakuDefinition(IKKITSUUKAN_YAKU, checkIkkitsuukan);

package/dist/features/yaku/lib/definitions/index.d.ts

@@ -0,0 +1,30 @@
+import type { YakuDefinition } from "../../types";
+export * from "./tanyao";
+export * from "./pinfu";
+export * from "./iipeiko";
+export * from "./ryanpeiko";
+export * from "./sanankou";
+export * from "./suuankou";
+export * from "./sankantsu";
+export * from "./suukantsu";
+export * from "./toitoi";
+export * from "./chiitoitsu";
+export * from "./honchan";
+export * from "./junchan";
+export * from "./honroutou";
+export * from "./chinroutou";
+export * from "./shousangen";
+export * from "./daisangen";
+export * from "./tsuuiisou";
+export * from "./ryuuiisou";
+export * from "./shousuushii";
+export * from "./daisuushii";
+export * from "./chuuren-poutou";
+export * from "./kokushi";
+export * from "./sanshoku-doujun";
+export * from "./sanshoku-doukou";
+export * from "./ikkitsuukan";
+export * from "./honitsu";
+export * from "./chinitsu";
+export * from "./yakuhai";
+export declare const ALL_YAKU_DEFINITIONS: YakuDefinition[];

package/dist/features/yaku/lib/definitions/index.js

@@ -0,0 +1,90 @@
+import { tanyaoDefinition } from "./tanyao";
+import { pinfuDefinition } from "./pinfu";
+import { iipeikoDefinition } from "./iipeiko";
+import { ryanpeikouDefinition } from "./ryanpeiko";
+import { sanankouDefinition } from "./sanankou";
+import { suuankouDefinition } from "./suuankou";
+import { sankantsuDefinition } from "./sankantsu";
+import { suukantsuDefinition } from "./suukantsu";
+import { toitoiDefinition } from "./toitoi";
+import { chiitoitsuDefinition } from "./chiitoitsu";
+import { honchanDefinition } from "./honchan";
+import { junchanDefinition } from "./junchan";
+import { honroutouDefinition } from "./honroutou";
+import { chinroutouDefinition } from "./chinroutou";
+import { shousangenDefinition } from "./shousangen";
+import { daisangenDefinition } from "./daisangen";
+import { tsuuiisouDefinition } from "./tsuuiisou";
+import { ryuuiisouDefinition } from "./ryuuiisou";
+import { shousuushiiDefinition } from "./shousuushii";
+import { daisuushiiDefinition } from "./daisuushii";
+import { chuurenPoutouDefinition } from "./chuuren-poutou";
+import { kokushiDefinition } from "./kokushi";
+import { sanshokuDoujunDefinition } from "./sanshoku-doujun";
+import { sanshokuDoukouDefinition } from "./sanshoku-doukou";
+import { ikkitsuukanDefinition } from "./ikkitsuukan";
+import { honitsuDefinition } from "./honitsu";
+import { chinitsuDefinition } from "./chinitsu";
+import { hakuDefinition, hatsuDefinition, chunDefinition } from "./yakuhai";
+import { menzenTsumoDefinition } from "./menzen-tsumo";
+export * from "./tanyao";
+export * from "./pinfu";
+export * from "./iipeiko";
+export * from "./ryanpeiko";
+export * from "./sanankou";
+export * from "./suuankou";
+export * from "./sankantsu";
+export * from "./suukantsu";
+export * from "./toitoi";
+export * from "./chiitoitsu";
+export * from "./honchan";
+export * from "./junchan";
+export * from "./honroutou";
+export * from "./chinroutou";
+export * from "./shousangen";
+export * from "./daisangen";
+export * from "./tsuuiisou";
+export * from "./ryuuiisou";
+export * from "./shousuushii";
+export * from "./daisuushii";
+export * from "./chuuren-poutou";
+export * from "./kokushi";
+export * from "./sanshoku-doujun";
+export * from "./sanshoku-doukou";
+export * from "./ikkitsuukan";
+export * from "./honitsu";
+export * from "./chinitsu";
+export * from "./yakuhai";
+export const ALL_YAKU_DEFINITIONS = [
+    tanyaoDefinition,
+    pinfuDefinition,
+    iipeikoDefinition,
+    ryanpeikouDefinition,
+    sanankouDefinition,
+    suuankouDefinition,
+    sankantsuDefinition,
+    suukantsuDefinition,
+    toitoiDefinition,
+    chiitoitsuDefinition,
+    honchanDefinition,
+    junchanDefinition,
+    honroutouDefinition,
+    chinroutouDefinition,
+    shousangenDefinition,
+    daisangenDefinition,
+    tsuuiisouDefinition,
+    ryuuiisouDefinition,
+    shousuushiiDefinition,
+    daisuushiiDefinition,
+    chuurenPoutouDefinition,
+    kokushiDefinition,
+    sanshokuDoujunDefinition,
+    sanshokuDoukouDefinition,
+    ikkitsuukanDefinition,
+    honitsuDefinition,
+    chinitsuDefinition,
+    hakuDefinition,
+    hatsuDefinition,
+    chunDefinition,
+    menzenTsumoDefinition,
+];

package/dist/features/yaku/lib/definitions/junchan.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const junchanDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/junchan.js

@@ -0,0 +1,25 @@
+import { isSuupai, isYaochu } from "../../../../core/hai";
+import { createYakuDefinition } from "../../factory";
+const JUNCHAN_YAKU = {
+    name: "Junchan",
+    han: {
+        open: 2,
+        closed: 3,
+    },
+};
+const checkJunchan = (hand) => {
+    if (hand.type !== "Mentsu")
+        return false;
+    const allBlocks = [hand.jantou, ...hand.fourMentsu];
+    // 1. 全ての面子・雀頭に老頭牌（1・9）が含まれること
+    // isYaochu(k) && isSuupai(k) で「字牌を除く么九牌」＝「老頭牌」となる
+    const allHasRoutou = allBlocks.every((block) => block.hais.some((k) => isYaochu(k) && isSuupai(k)));
+    if (!allHasRoutou)
+        return false;
+    // 2. 少なくとも1つの順子が含まれること（清老頭の除外）
+    const hasShuntsu = hand.fourMentsu.some((m) => m.type === "Shuntsu");
+    if (!hasShuntsu)
+        return false;
+    return true;
+};
+export const junchanDefinition = createYakuDefinition(JUNCHAN_YAKU, checkJunchan);

package/dist/features/yaku/lib/definitions/kokushi.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const kokushiDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/kokushi.js

@@ -0,0 +1,12 @@
+import { createYakuDefinition } from "../../factory";
+const checkKokushi = (hand) => {
+    return hand.type === "Kokushi";
+};
+const KOKUSHI_HAN = {
+    closed: 13,
+    open: 0,
+};
+export const kokushiDefinition = createYakuDefinition({
+    name: "KokushiMusou",
+    han: KOKUSHI_HAN,
+}, checkKokushi);

package/dist/features/yaku/lib/definitions/menzen-tsumo.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const menzenTsumoDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/menzen-tsumo.js

@@ -0,0 +1,8 @@
+import { createYakuDefinition } from "../../factory";
+const definition = {
+    name: "MenzenTsumo",
+    han: { open: 0, closed: 1 },
+};
+export const menzenTsumoDefinition = createYakuDefinition(definition, (hand, context) => {
+    return context.isMenzen && !!context.isTsumo;
+});

package/dist/features/yaku/lib/definitions/pinfu.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const pinfuDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/pinfu.js

@@ -0,0 +1,40 @@
+import { HaiKind } from "../../../../types";
+import { classifyMachi } from "../../../../core/machi";
+import { MahjongArgumentError } from "../../../../errors";
+import { createYakuDefinition } from "../../factory";
+const PINFU_YAKU = {
+    name: "Pinfu",
+    han: {
+        open: 0,
+        closed: 1,
+    },
+};
+const checkPinfu = (hand, context) => {
+    // 1. 門前であること
+    if (!context.isMenzen)
+        return false;
+    if (hand.type !== "Mentsu")
+        return false;
+    // 2. 雀頭が役牌でないこと
+    // 三元牌、場風、自風が含まれていないことを確認
+    const jantouKind = hand.jantou.hais[0];
+    if (context.bakaze === undefined || context.jikaze === undefined) {
+        throw new MahjongArgumentError("Pinfu check requires bakaze and jikaze in context");
+    }
+    const yakuhaiList = [
+        HaiKind.Haku,
+        HaiKind.Hatsu,
+        HaiKind.Chun,
+        context.bakaze,
+        context.jikaze,
+    ];
+    if (yakuhaiList.includes(jantouKind))
+        return false;
+    // 3. 全て順子であること
+    if (!hand.fourMentsu.every((m) => m.type === "Shuntsu"))
+        return false;
+    // 4. 両面待ちであること
+    const waitType = classifyMachi(hand, context.agariHai);
+    return waitType === "Ryanmen";
+};
+export const pinfuDefinition = createYakuDefinition(PINFU_YAKU, checkPinfu);

package/dist/features/yaku/lib/definitions/ryanpeiko.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const ryanpeikouDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/ryanpeiko.js

@@ -0,0 +1,33 @@
+import { createYakuDefinition } from "../../factory";
+const RYANPEIKOU_YAKU = {
+    name: "Ryanpeikou",
+    han: {
+        open: 0, // 門前限定
+        closed: 3,
+    },
+};
+const checkRyanpeikou = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const shuntsuList = hand.fourMentsu.filter((mentsu) => mentsu.type === "Shuntsu");
+    // 順子が4つなければ二盃口はあり得ない
+    if (shuntsuList.length < 4) {
+        return false;
+    }
+    // 各順子の出現数をカウントする
+    // Shuntsuは [T, T, T] で、先頭の牌IDが同じなら同じ順子とみなす
+    const shuntsuCounts = new Map();
+    for (const shuntsu of shuntsuList) {
+        const key = shuntsu.hais[0];
+        const currentCount = shuntsuCounts.get(key) ?? 0;
+        shuntsuCounts.set(key, currentCount + 1);
+    }
+    let pairCount = 0;
+    for (const count of shuntsuCounts.values()) {
+        // 同じ順子が2つで1ペア。4つなら2ペア。
+        pairCount += Math.floor(count / 2);
+    }
+    return pairCount >= 2;
+};
+export const ryanpeikouDefinition = createYakuDefinition(RYANPEIKOU_YAKU, checkRyanpeikou);

package/dist/features/yaku/lib/definitions/ryuuiisou.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const ryuuiisouDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/ryuuiisou.js

@@ -0,0 +1,43 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const RYUUIISOU_YAKU = {
+    name: "Ryuuiisou",
+    han: {
+        open: 13,
+        closed: 13,
+    },
+};
+const GREEN_TILES = new Set([
+    HaiKind.SouZu2,
+    HaiKind.SouZu3,
+    HaiKind.SouZu4,
+    HaiKind.SouZu6,
+    HaiKind.SouZu8,
+    HaiKind.Hatsu,
+]);
+const isGreen = (id) => {
+    return GREEN_TILES.has(id);
+};
+const checkRyuuiisou = (hand) => {
+    const allHais = [];
+    if (hand.type === "Mentsu") {
+        // 面子手の場合
+        for (const mentsu of hand.fourMentsu) {
+            allHais.push(...mentsu.hais);
+        }
+        allHais.push(...hand.jantou.hais);
+    }
+    else if (hand.type === "Chiitoitsu") {
+        // 七対子の場合
+        for (const pair of hand.pairs) {
+            allHais.push(...pair.hais);
+        }
+    }
+    else {
+        // 国士無双など
+        return false;
+    }
+    // 全ての牌が緑色牌であれば成立
+    return allHais.every(isGreen);
+};
+export const ryuuiisouDefinition = createYakuDefinition(RYUUIISOU_YAKU, checkRyuuiisou);

package/dist/features/yaku/lib/definitions/sanankou.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const sanankouDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/sanankou.js

@@ -0,0 +1,49 @@
+import { createYakuDefinition } from "../../factory";
+const SANANKOU_YAKU = {
+    name: "Sanankou",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkSanankou = (hand, context) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 刻子・槓子を抽出
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    let ankouCount = 0;
+    for (const triplet of triplets) {
+        // 副露している刻子は暗刻ではない
+        if (triplet.furo)
+            continue;
+        const isAgariHaiInTriplet = triplet.hais.includes(context.agariHai);
+        // ロン和了の場合、和了牌を含む刻子は明刻扱いとなる（シャボ待ちの場合）。
+        // ただし、単騎待ちの場合は暗刻扱いとなる。
+        // 単騎待ちかどうかの判定: 雀頭の牌が和了牌と同じかどうか
+        const isTanki = hand.jantou.hais[0] === context.agariHai;
+        if (context.isTsumo) {
+            // ツモなら、副露していなければ全て暗刻
+            ankouCount++;
+        }
+        else {
+            // ロン和了の場合
+            if (isAgariHaiInTriplet) {
+                // 和了牌を含む刻子の場合
+                if (isTanki) {
+                    // 単騎待ちなら暗刻
+                    ankouCount++;
+                }
+                else {
+                    // シャボ（等の）待ちでロンした場合は明刻扱いなのでカウントしない
+                }
+            }
+            else {
+                // 和了牌を含まない刻子は暗刻
+                ankouCount++;
+            }
+        }
+    }
+    return ankouCount >= 3;
+};
+export const sanankouDefinition = createYakuDefinition(SANANKOU_YAKU, checkSanankou);

package/dist/features/yaku/lib/definitions/sankantsu.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const sankantsuDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/sankantsu.js

@@ -0,0 +1,18 @@
+import { createYakuDefinition } from "../../factory";
+const SANKANTSU_YAKU = {
+    name: "Sankantsu",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkSankantsu = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 槓子を抽出
+    const kantsuList = hand.fourMentsu.filter((m) => m.type === "Kantsu");
+    // 2. 槓子が3つ以上あれば成立
+    return kantsuList.length >= 3;
+};
+export const sankantsuDefinition = createYakuDefinition(SANKANTSU_YAKU, checkSankantsu);

package/dist/features/yaku/lib/definitions/sanshoku-doujun.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const sanshokuDoujunDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/sanshoku-doujun.js

@@ -0,0 +1,58 @@
+import { createYakuDefinition } from "../../factory";
+const SANSHOKU_DOUJUN_YAKU = {
+    name: "SanshokuDoujun",
+    han: {
+        open: 1,
+        closed: 2,
+    },
+};
+const checkSanshokuDoujun = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const shuntsuList = hand.fourMentsu.filter((mentsu) => mentsu.type === "Shuntsu");
+    if (shuntsuList.length < 3) {
+        return false;
+    }
+    // 順子リストから3つの組み合わせを全てチェックし、三色同順の条件を満たすものを探す
+    // 条件:
+    // 1. 3つの順子がそれぞれ異なる色（萬子、筒子、索子）であること
+    // 2. 3つの順子の構成数字が同じであること（例: 123m, 123p, 123s）
+    // ヘルパーロジック:
+    // HaiKindId の範囲: 0-8 (ManZu), 9-17 (PinZu), 18-26 (SouZu)
+    // 9で割った商が色（0, 1, 2）、余りが数値（0-8）を表す
+    for (let i = 0; i < shuntsuList.length; i++) {
+        for (let j = i + 1; j < shuntsuList.length; j++) {
+            for (let k = j + 1; k < shuntsuList.length; k++) {
+                const s1 = shuntsuList[i];
+                const s2 = shuntsuList[j];
+                const s3 = shuntsuList[k];
+                if (!s1 || !s2 || !s3)
+                    continue;
+                const firstHai1 = s1.hais[0];
+                const firstHai2 = s2.hais[0];
+                const firstHai3 = s3.hais[0];
+                const suit1 = Math.floor(firstHai1 / 9);
+                const suit2 = Math.floor(firstHai2 / 9);
+                const suit3 = Math.floor(firstHai3 / 9);
+                // 異なる色（0, 1, 2）でなければならない
+                const suits = new Set([suit1, suit2, suit3]);
+                if (suits.size !== 3)
+                    continue;
+                // 全て数牌（0, 1, 2）でなければならない
+                // ※通常、Shuntsuに字牌は含まれないが、念のためチェック
+                if (suit1 > 2 || suit2 > 2 || suit3 > 2)
+                    continue;
+                // 数値（インデックス）が一致するかチェック
+                const num1 = firstHai1 % 9;
+                const num2 = firstHai2 % 9;
+                const num3 = firstHai3 % 9;
+                if (num1 === num2 && num2 === num3) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+export const sanshokuDoujunDefinition = createYakuDefinition(SANSHOKU_DOUJUN_YAKU, checkSanshokuDoujun);

package/dist/features/yaku/lib/definitions/sanshoku-doukou.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const sanshokuDoukouDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/sanshoku-doukou.js

@@ -0,0 +1,53 @@
+import { createYakuDefinition } from "../../factory";
+const SANSHOKU_DOUKOU_YAKU = {
+    name: "SanshokuDoukou",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkSanshokuDoukou = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    // 1. 刻子・槓子を抽出
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    if (triplets.length < 3) {
+        return false;
+    }
+    // 2. 刻子の組み合わせ(3つ)をチェック
+    for (let i = 0; i < triplets.length; i++) {
+        for (let j = i + 1; j < triplets.length; j++) {
+            for (let k = j + 1; k < triplets.length; k++) {
+                const t1 = triplets[i];
+                const t2 = triplets[j];
+                const t3 = triplets[k];
+                if (!t1 || !t2 || !t3)
+                    continue;
+                const id1 = t1.hais[0];
+                const id2 = t2.hais[0];
+                const id3 = t3.hais[0];
+                // 字牌が含まれていたら対象外 (字牌ID >= 27)
+                if (id1 >= 27 || id2 >= 27 || id3 >= 27)
+                    continue;
+                const suit1 = Math.floor(id1 / 9);
+                const suit2 = Math.floor(id2 / 9);
+                const suit3 = Math.floor(id3 / 9);
+                // ※ 0:萬子, 1:筒子, 2:索子
+                const suits = new Set([suit1, suit2, suit3]);
+                // 異なる3色でなければならない
+                if (suits.size !== 3)
+                    continue;
+                const num1 = id1 % 9;
+                const num2 = id2 % 9;
+                const num3 = id3 % 9;
+                // 同じ数字でなければならない
+                if (num1 === num2 && num2 === num3) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+export const sanshokuDoukouDefinition = createYakuDefinition(SANSHOKU_DOUKOU_YAKU, checkSanshokuDoukou);

package/dist/features/yaku/lib/definitions/shousangen.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const shousangenDefinition: YakuDefinition;

package/dist/features/yaku/lib/definitions/shousangen.js

@@ -0,0 +1,28 @@
+import { createYakuDefinition } from "../../factory";
+import { HaiKind } from "../../../../types";
+const SHOUSANGEN_YAKU = {
+    name: "Shousangen",
+    han: {
+        open: 2,
+        closed: 2,
+    },
+};
+const checkShousangen = (hand) => {
+    if (hand.type !== "Mentsu") {
+        return false;
+    }
+    const sangenpai = [HaiKind.Haku, HaiKind.Hatsu, HaiKind.Chun];
+    // 1. 三元牌の刻子・槓子をカウント
+    let sangenKoutsuCount = 0;
+    const triplets = hand.fourMentsu.filter((m) => m.type === "Koutsu" || m.type === "Kantsu");
+    for (const triplet of triplets) {
+        if (sangenpai.includes(triplet.hais[0])) {
+            sangenKoutsuCount++;
+        }
+    }
+    // 2. 三元牌の雀頭があるかチェック
+    const isSangenJantou = sangenpai.includes(hand.jantou.hais[0]);
+    // 小三元の条件: 三元牌の刻子が2つ かつ 三元牌の雀頭が1つ
+    return sangenKoutsuCount === 2 && isSangenJantou;
+};
+export const shousangenDefinition = createYakuDefinition(SHOUSANGEN_YAKU, checkShousangen);

package/dist/features/yaku/lib/definitions/shousuushii.d.ts

@@ -0,0 +1,2 @@
+import type { YakuDefinition } from "../../types";
+export declare const shousuushiiDefinition: YakuDefinition;