@pai-forge/riichi-mahjong 0.1.0 → 0.3.0

package/dist/features/score/lib/fu/constants.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 符計算に関する定数定義
+ */
+export declare const FU_BASE: {
+    readonly NORMAL: 20;
+    readonly CHIITOITSU: 25;
+    readonly KOKUSHI: 20;
+};
+export declare const FU_AGARI: {
+    readonly TSUMO: 2;
+    readonly MENZEN_RON: 10;
+};
+export declare const FU_JANTOU: {
+    readonly YAKUHAI: 2;
+    readonly DOUBLE_WIND_CAP: 2;
+};
+export declare const FU_MACHI: {
+    readonly KANCHAN: 2;
+    readonly PENCHAN: 2;
+    readonly TANKI: 2;
+    readonly RYANMEN: 0;
+    readonly SHANPON: 0;
+};
+export declare const FU_KOUTSU: {
+    readonly SUUPAI_OPEN: 2;
+    readonly SUUPAI_CLOSED: 4;
+    readonly YAOCHU_OPEN: 4;
+    readonly YAOCHU_CLOSED: 8;
+};
+export declare const FU_KANTSU: {
+    readonly SUUPAI_OPEN: 8;
+    readonly SUUPAI_CLOSED: 16;
+    readonly YAOCHU_OPEN: 16;
+    readonly YAOCHU_CLOSED: 32;
+};
+export declare const FU_PINFU_TSUMO = 20;
+export declare const FU_OPEN_PINFU_GLAZE = 30;

package/dist/features/score/lib/fu/constants.js

@@ -0,0 +1,45 @@
+/**
+ * 符計算に関する定数定義
+ */
+// 符底 (FuTei)
+export const FU_BASE = {
+    NORMAL: 20,
+    CHIITOITSU: 25,
+    KOKUSHI: 20, // 便宜上
+};
+// 和了符 (AgariFu)
+export const FU_AGARI = {
+    TSUMO: 2,
+    MENZEN_RON: 10,
+};
+// 雀頭符 (JantouFu)
+export const FU_JANTOU = {
+    YAKUHAI: 2,
+    // 連風牌の扱い（設定により4符または2符）
+    DOUBLE_WIND_CAP: 2,
+};
+// 待ち符 (MachiFu)
+export const FU_MACHI = {
+    KANCHAN: 2,
+    PENCHAN: 2,
+    TANKI: 2,
+    RYANMEN: 0,
+    SHANPON: 0,
+};
+// 面子符 (MentsuFu)
+// [Yaochu/Suupai]_[Open/Closed]
+export const FU_KOUTSU = {
+    SUUPAI_OPEN: 2,
+    SUUPAI_CLOSED: 4,
+    YAOCHU_OPEN: 4,
+    YAOCHU_CLOSED: 8,
+};
+export const FU_KANTSU = {
+    SUUPAI_OPEN: 8,
+    SUUPAI_CLOSED: 16,
+    YAOCHU_OPEN: 16,
+    YAOCHU_CLOSED: 32,
+};
+// 例外処理用定数
+export const FU_PINFU_TSUMO = 20;
+export const FU_OPEN_PINFU_GLAZE = 30; // 喰いタン平和形などの20符切り上げ

package/dist/features/score/lib/fu/index.d.ts

@@ -0,0 +1,11 @@
+import type { HouraStructure, HouraContext } from "../../../yaku/types";
+import type { FuResult } from "./types";
+/**
+ * 手牌の符を計算する (calculateFu)
+ *
+ * @param hand 和了形の手牌構造
+ * @param context 和了コンテキスト (場風、自風、ツモ/ロン等)
+ * @param isPinfu 平和が成立しているかどうか (平和ツモ20符例外の適用に必要)
+ * @returns 符計算結果
+ */
+export declare function calculateFu(hand: HouraStructure, context: HouraContext, isPinfu?: boolean): FuResult;

package/dist/features/score/lib/fu/index.js

@@ -0,0 +1,23 @@
+import { calculateChiitoitsuFu } from "./lib/chiitoitsu";
+import { calculateKokushiFu } from "./lib/kokushi";
+import { calculateMentsuFu } from "./lib/mentsu";
+/**
+ * 手牌の符を計算する (calculateFu)
+ *
+ * @param hand 和了形の手牌構造
+ * @param context 和了コンテキスト (場風、自風、ツモ/ロン等)
+ * @param isPinfu 平和が成立しているかどうか (平和ツモ20符例外の適用に必要)
+ * @returns 符計算結果
+ */
+export function calculateFu(hand, context, isPinfu = false) {
+    // 1. 七対子 (ChiiToitsu)
+    if (hand.type === "Chiitoitsu") {
+        return calculateChiitoitsuFu();
+    }
+    // 2. 国士無双 (Kokushi)
+    if (hand.type === "Kokushi") {
+        return calculateKokushiFu();
+    }
+    // 3. 面子手 (Mentsu)
+    return calculateMentsuFu(hand, context, isPinfu);
+}

package/dist/features/score/lib/fu/lib/chiitoitsu.d.ts

@@ -0,0 +1,5 @@
+import type { FuResult } from "../types";
+/**
+ * 七対子の符を計算する
+ */
+export declare function calculateChiitoitsuFu(): FuResult;

package/dist/features/score/lib/fu/lib/chiitoitsu.js

@@ -0,0 +1,17 @@
+import { FU_BASE } from "../constants";
+/**
+ * 七対子の符を計算する
+ */
+export function calculateChiitoitsuFu() {
+    const details = {
+        base: FU_BASE.CHIITOITSU,
+        mentsu: 0,
+        jantou: 0,
+        machi: 0,
+        agari: 0,
+    };
+    return {
+        total: FU_BASE.CHIITOITSU,
+        details,
+    };
+}

package/dist/features/score/lib/fu/lib/kokushi.d.ts

@@ -0,0 +1,6 @@
+import type { FuResult } from "../types";
+/**
+ * 国士無双の符を計算する
+ * (点数計算上は役満固定だが、便宜上符底のみを返す)
+ */
+export declare function calculateKokushiFu(): FuResult;

package/dist/features/score/lib/fu/lib/kokushi.js

@@ -0,0 +1,18 @@
+import { FU_BASE } from "../constants";
+/**
+ * 国士無双の符を計算する
+ * (点数計算上は役満固定だが、便宜上符底のみを返す)
+ */
+export function calculateKokushiFu() {
+    const details = {
+        base: FU_BASE.KOKUSHI,
+        mentsu: 0,
+        jantou: 0,
+        machi: 0,
+        agari: 0,
+    };
+    return {
+        total: FU_BASE.KOKUSHI,
+        details,
+    };
+}

package/dist/features/score/lib/fu/lib/mentsu.d.ts

@@ -0,0 +1,11 @@
+import type { FuResult } from "../types";
+import type { HouraContext } from "../../../../yaku/types";
+import type { MentsuHouraStructure } from "../../../../yaku/types";
+/**
+ * 面子手の符を計算する
+ *
+ * @param hand 面子手の構造
+ * @param context 和了コンテキスト
+ * @param isPinfu 平和成立フラグ
+ */
+export declare function calculateMentsuFu(hand: MentsuHouraStructure, context: HouraContext, isPinfu: boolean): FuResult;

package/dist/features/score/lib/fu/lib/mentsu.js

@@ -0,0 +1,136 @@
+import { isYaochu } from "../../../../../core/hai";
+import { HaiKind } from "../../../../../types";
+import { classifyMachi } from "../../../../../core/machi";
+import { FU_BASE, FU_KOUTSU, FU_KANTSU, FU_JANTOU, FU_MACHI, FU_AGARI, FU_PINFU_TSUMO, FU_OPEN_PINFU_GLAZE, } from "../constants";
+/** 有効な符の値 */
+const VALID_FU_VALUES = [
+    20, 25, 30, 40, 50, 60, 70, 80, 90, 100, 110,
+];
+/**
+ * 数値を Fu 型に変換する（無効な値の場合はエラー）
+ */
+function toFu(value) {
+    const fu = VALID_FU_VALUES.find((f) => f === value);
+    if (fu === undefined) {
+        throw new Error(`Invalid fu value: ${value}`);
+    }
+    return fu;
+}
+/**
+ * 面子手の符を計算する
+ *
+ * @param hand 面子手の構造
+ * @param context 和了コンテキスト
+ * @param isPinfu 平和成立フラグ
+ */
+export function calculateMentsuFu(hand, context, isPinfu) {
+    const details = {
+        base: FU_BASE.NORMAL,
+        mentsu: 0,
+        jantou: 0,
+        machi: 0,
+        agari: 0,
+    };
+    // 1. 面子符 (MentsuFu)
+    for (const mentsu of hand.fourMentsu) {
+        let fu = 0;
+        const isYaochuMentsu = isYaochu(mentsu.hais[0]);
+        if (mentsu.type === "Koutsu") {
+            // 刻子
+            const openFu = isYaochuMentsu
+                ? FU_KOUTSU.YAOCHU_OPEN
+                : FU_KOUTSU.SUUPAI_OPEN;
+            const closedFu = isYaochuMentsu
+                ? FU_KOUTSU.YAOCHU_CLOSED
+                : FU_KOUTSU.SUUPAI_CLOSED;
+            fu = closedFu;
+            // 明刻判定
+            let isOpen = !!mentsu.furo;
+            if (!isOpen && !context.isTsumo) {
+                // ロン和了で、かつその牌を含む刻子であれば明刻扱い
+                if (mentsu.hais.includes(context.agariHai)) {
+                    isOpen = true;
+                }
+            }
+            if (isOpen) {
+                fu = openFu;
+            }
+            details.mentsu += fu;
+        }
+        else if (mentsu.type === "Kantsu") {
+            // 槓子
+            const openFu = isYaochuMentsu
+                ? FU_KANTSU.YAOCHU_OPEN
+                : FU_KANTSU.SUUPAI_OPEN;
+            const closedFu = isYaochuMentsu
+                ? FU_KANTSU.YAOCHU_CLOSED
+                : FU_KANTSU.SUUPAI_CLOSED;
+            fu = closedFu;
+            if (mentsu.furo) {
+                fu = openFu;
+            }
+            details.mentsu += fu;
+        }
+    }
+    // 2. 雀頭符 (JantouFu)
+    const headHai = hand.jantou.hais[0];
+    let jantouFu = 0;
+    if (headHai === HaiKind.Haku ||
+        headHai === HaiKind.Hatsu ||
+        headHai === HaiKind.Chun) {
+        jantouFu += FU_JANTOU.YAKUHAI;
+    }
+    if (headHai === context.bakaze) {
+        jantouFu += FU_JANTOU.YAKUHAI;
+    }
+    if (headHai === context.jikaze) {
+        jantouFu += FU_JANTOU.YAKUHAI;
+    }
+    // 連風牌の加算上限
+    if (jantouFu > FU_JANTOU.DOUBLE_WIND_CAP) {
+        jantouFu = FU_JANTOU.DOUBLE_WIND_CAP;
+    }
+    details.jantou = jantouFu;
+    // 3. 待ち符 (MachiFu)
+    const machiType = classifyMachi(hand, context.agariHai);
+    if (machiType === "Kanchan")
+        details.machi = FU_MACHI.KANCHAN;
+    else if (machiType === "Penchan")
+        details.machi = FU_MACHI.PENCHAN;
+    else if (machiType === "Tanki")
+        details.machi = FU_MACHI.TANKI;
+    else
+        details.machi = 0; // Ryanmen, Shanpon
+    // 4. 和了符 (AgariFu)
+    if (context.isTsumo) {
+        if (!isPinfu) {
+            details.agari = FU_AGARI.TSUMO;
+        }
+    }
+    else {
+        if (context.isMenzen) {
+            details.agari = FU_AGARI.MENZEN_RON;
+        }
+    }
+    // 合計
+    let sum = details.base +
+        details.mentsu +
+        details.jantou +
+        details.machi +
+        details.agari;
+    // 平和ツモ例外
+    if (isPinfu && context.isTsumo) {
+        return { total: FU_PINFU_TSUMO, details };
+    }
+    // 切り上げ (喰いタン平和形など)
+    if (sum === 20 && !context.isTsumo && !context.isMenzen) {
+        sum = FU_OPEN_PINFU_GLAZE;
+    }
+    else {
+        sum = Math.ceil(sum / 10) * 10;
+    }
+    return {
+        total: toFu(sum),
+        details,
+    };
+}

package/dist/features/score/lib/fu/types.d.ts

@@ -0,0 +1,56 @@
+import type { Fu } from "../../../../types";
+/**
+ * 符の構成要素 (FuDetails)
+ *
+ * 符計算の内訳を保持するインターフェース。
+ */
+export interface FuDetails {
+    /**
+     * 符底 (FuTei)
+     *
+     * 一般的な和了形: 20符
+     * 七対子: 25符
+     */
+    readonly base: 20 | 25;
+    /**
+     * 面子符の合計 (MentsuFu)
+     *
+     * 刻子・槓子による加算符。順子は0符。
+     */
+    readonly mentsu: number;
+    /**
+     * 雀頭符 (JantouFu)
+     *
+     * 役牌の対子による加算符。
+     */
+    readonly jantou: number;
+    /**
+     * 待ち符 (MachiFu)
+     *
+     * 単騎・嵌張・辺張待ちによる加算符（2符）。
+     */
+    readonly machi: number;
+    /**
+     * 和了符 (AgariFu)
+     *
+     * ツモ和了: 2符
+     * 門前ロン: 10符
+     */
+    readonly agari: number;
+}
+/**
+ * 符計算結果 (FuResult)
+ */
+export interface FuResult {
+    /**
+     * 最終的な符数 (Total)
+     *
+     * 内訳の合計を10符単位で切り上げたもの。
+     * (例: 22符 -> 30符)
+     */
+    readonly total: Fu;
+    /**
+     * 計算の内訳
+     */
+    readonly details: FuDetails;
+}

package/dist/features/score/lib/fu/types.js

@@ -0,0 +1 @@
+export {};

package/dist/features/score/types.d.ts

@@ -0,0 +1,78 @@
+import type { Fu, HaiKindId, Kazehai } from "../../types";
+import type { HouraContext } from "../yaku/types";
+/**
+ * 点数計算用コンテキスト (ScoreContext)
+ *
+ * HouraContext を拡張し、点数計算に必要な追加情報を持つ。
+ *
+ * HouraContext は役判定に特化しており、isOya は役の成立・翻数に影響しない。
+ * isOya は支払い計算（親ロン/子ロン、親ツモ/子ツモの倍率差）にのみ必要なため、
+ * 点数計算用のコンテキストとして分離している。
+ */
+export interface ScoreContext extends HouraContext {
+    /** 和了者が親かどうか */
+    readonly isOya: boolean;
+}
+export interface ScoreCalculationConfig {
+    /** 和了牌 */
+    agariHai: HaiKindId;
+    /** ツモ和了かどうか (必須) */
+    isTsumo: boolean;
+    /** 自風 (必須) */
+    jikaze: Kazehai;
+    /** 場風 (必須) */
+    bakaze: Kazehai;
+    /** ドラ表示牌 (必須、なければ空配列) */
+    doraMarkers: readonly HaiKindId[];
+    /** 裏ドラ表示牌 (任意) */
+    uraDoraMarkers?: readonly HaiKindId[];
+}
+/** ロン和了時の支払い */
+export interface Ron {
+    type: "ron";
+    /** 振り込んだプレイヤーが支払う点数 */
+    amount: number;
+}
+/** 子のツモ和了時の支払い */
+export interface KoTsumo {
+    type: "koTsumo";
+    /** [子の支払い, 親の支払い] */
+    readonly amount: readonly [number, number];
+}
+/** 親のツモ和了時の支払い */
+export interface OyaTsumo {
+    type: "oyaTsumo";
+    /** 子全員が支払う点数（オール） */
+    amount: number;
+}
+/** 支払い情報 */
+export type Payment = Ron | KoTsumo | OyaTsumo;
+/**
+ * 点数レベル (ScoreLevel)
+ *
+ * 翻数と基本点から決まる点数の区分。
+ * 満貫以上では符に関係なく固定の基本点が適用される。
+ */
+export declare const ScoreLevel: {
+    /** 満貫未満（通常計算） */
+    readonly Normal: "Normal";
+    /** 満貫（5翻、または基本点2000以上） */
+    readonly Mangan: "Mangan";
+    /** 跳満（6-7翻） */
+    readonly Haneman: "Haneman";
+    /** 倍満（8-10翻） */
+    readonly Baiman: "Baiman";
+    /** 三倍満（11-12翻） */
+    readonly Sanbaiman: "Sanbaiman";
+    /** 役満（13翻以上） */
+    readonly Yakuman: "Yakuman";
+    /** ダブル役満（26翻以上、または役満複合） */
+    readonly DoubleYakuman: "DoubleYakuman";
+};
+export type ScoreLevel = (typeof ScoreLevel)[keyof typeof ScoreLevel];
+export interface ScoreResult {
+    han: number;
+    fu: Fu;
+    scoreLevel: ScoreLevel;
+    payment: Payment;
+}

package/dist/features/score/types.js

@@ -0,0 +1,22 @@
+/**
+ * 点数レベル (ScoreLevel)
+ *
+ * 翻数と基本点から決まる点数の区分。
+ * 満貫以上では符に関係なく固定の基本点が適用される。
+ */
+export const ScoreLevel = {
+    /** 満貫未満（通常計算） */
+    Normal: "Normal",
+    /** 満貫（5翻、または基本点2000以上） */
+    Mangan: "Mangan",
+    /** 跳満（6-7翻） */
+    Haneman: "Haneman",
+    /** 倍満（8-10翻） */
+    Baiman: "Baiman",
+    /** 三倍満（11-12翻） */
+    Sanbaiman: "Sanbaiman",
+    /** 役満（13翻以上） */
+    Yakuman: "Yakuman",
+    /** ダブル役満（26翻以上、または役満複合） */
+    DoubleYakuman: "DoubleYakuman",
+};

package/dist/features/yaku/factory.d.ts

@@ -3,7 +3,7 @@ import { YakuDefinition, HouraContext } from "./types";
 /**
  * 役定義を作成するファクトリ関数
  *
- * @param yaku 役の設定情報（名前、飜数など）
+ * @param yaku 役の設定情報（名前、翻数など）
  * @param check 役の成立条件を判定する関数 (真偽値を返す)
  * @returns YakuDefinition (isSatisfied, getHansu を持つ)
  */

package/dist/features/yaku/factory.js

@@ -1,7 +1,7 @@
 /**
  * 役定義を作成するファクトリ関数
  *
- * @param yaku 役の設定情報（名前、飜数など）
+ * @param yaku 役の設定情報（名前、翻数など）
  * @param check 役の成立条件を判定する関数 (真偽値を返す)
  * @returns YakuDefinition (isSatisfied, getHansu を持つ)
  */

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

@@ -1,12 +1,21 @@
 import type { Tehai14, HaiKindId } from "../../types";
-import type { YakuResult } from "./types";
+import type { YakuResult, HouraStructure } from "./types";
+import type { HouraContext } from "./types";
 export type { HouraStructure, YakuResult, YakuName, Hansu, TehaiYaku, YakuHanConfig, Yakuhai, } from "./types";
 export * from "./lib";
+/**
+ * 単一の和了構造に対して役を判定する
+ *
+ * @param hand 和了構造（面子手、七対子、国士無双のいずれか）
+ * @param context 和了コンテキスト
+ * @returns 成立した役と翻数のリスト
+ */
+export declare function detectYakuForStructure(hand: HouraStructure, context: HouraContext): YakuResult;
 /**
  * 手牌の構造役を検出する
  *
  * @param tehai 判定対象の手牌
  * @param agariHai 和了牌
- * @returns 成立した役と飜数のリスト（最も高得点となる解釈の結果）
+ * @returns 成立した役と翻数のリスト（最も高得点となる解釈の結果）
  */
 export declare function detectYaku(tehai: Tehai14, agariHai: HaiKindId, bakaze?: HaiKindId, jikaze?: HaiKindId, doraMarkers?: readonly HaiKindId[], uraDoraMarkers?: readonly HaiKindId[], isTsumo?: boolean): YakuResult;

package/dist/features/yaku/index.js

@@ -2,18 +2,41 @@ import { getHouraStructures } from "./lib/structures";
 import { isMenzen, isKazehai } from "./utils";
 import { ALL_YAKU_DEFINITIONS } from "./lib/definitions";
 export * from "./lib";
+/**
+ * 単一の和了構造に対して役を判定する
+ *
+ * @param hand 和了構造（面子手、七対子、国士無双のいずれか）
+ * @param context 和了コンテキスト
+ * @returns 成立した役と翻数のリスト
+ */
+export function detectYakuForStructure(hand, context) {
+    const result = [];
+    for (const definition of ALL_YAKU_DEFINITIONS) {
+        if (definition.isSatisfied(hand, context)) {
+            const hansu = definition.getHansu(hand, context);
+            if (hansu === 0)
+                continue;
+            result.push([definition.yaku.name, hansu]);
+        }
+    }
+    return result;
+}
+/**
+ * YakuResult から総翻数を計算する
+ */
+function getTotalHan(yakuResult) {
+    return yakuResult.reduce((sum, [, han]) => sum + han, 0);
+}
 /**
  * 手牌の構造役を検出する
  *
  * @param tehai 判定対象の手牌
  * @param agariHai 和了牌
- * @returns 成立した役と飜数のリスト（最も高得点となる解釈の結果）
+ * @returns 成立した役と翻数のリスト（最も高得点となる解釈の結果）
  */
 export function detectYaku(tehai, agariHai, bakaze, jikaze, doraMarkers, uraDoraMarkers, isTsumo) {
-    // 1. 基本情報の抽出
-    const isMenzenValue = isMenzen(tehai);
     const context = {
-        isMenzen: isMenzenValue,
+        isMenzen: isMenzen(tehai),
         agariHai,
         bakaze: bakaze !== undefined && isKazehai(bakaze) ? bakaze : undefined,
         jikaze: jikaze !== undefined && isKazehai(jikaze) ? jikaze : undefined,
@@ -21,42 +44,16 @@ export function detectYaku(tehai, agariHai, bakaze, jikaze, doraMarkers, uraDora
         uraDoraMarkers: uraDoraMarkers ?? [],
         isTsumo,
     };
+    const structuralInterpretations = getHouraStructures(tehai);
     let bestResult = [];
     let maxHan = -1;
-    // 2. 手牌の構造分解（面子手、七対子、国士無双）と役判定
-    const structuralInterpretations = getHouraStructures(tehai);
     for (const hand of structuralInterpretations) {
-        const currentResult = [];
-        let currentHan = 0;
-        for (const definition of ALL_YAKU_DEFINITIONS) {
-            if (definition.isSatisfied(hand, context)) {
-                const hansu = definition.getHansu(hand, context);
-                // 喰い下がり0の場合は不成立 (getHansuが0を返すはずだが念のため)
-                if (hansu === 0)
-                    continue;
-                // TODO: 役牌のダブル役（ダブ東など）の場合、現状の YakuhaiDefinition は Han * count を返すが、
-                // YakuResult の形式としては [Name, TotalHan] なのか [Name, Han], [Name, Han] なのか議論が必要。
-                // 現状の実装: [checker.yaku.name, hanValue] を count 回 push していた。
-                // 新しい getHansu は total han を返すため、1回 push すればよいのか？
-                // しかし役の数え方としては「役牌：白」「役牌：發」は別だが、「ダブ東」は「役牌：東」が2つ？
-                // 一般的には「自風 東」「場風 東」という2つの役扱い。
-                // しかしここでは YakuhaiDefinition が汎用的になっている。
-                // ユーザー要望の simple refactor に従い、getHansu が返す値をそのまま1つの役として扱う。
-                // ただし Yakuhai の getHansu は (open * count) を返しているので、
-                // ダブ東なら 2飜 の役が1つ、という扱いになる。
-                currentResult.push([definition.yaku.name, hansu]);
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                currentHan += hansu;
-            }
-        }
+        const currentResult = detectYakuForStructure(hand, context);
+        const currentHan = getTotalHan(currentResult);
         if (currentHan > maxHan) {
             maxHan = currentHan;
             bestResult = currentResult;
         }
     }
-    // どの構造としても解釈できない、または役が成立しない場合は空配列
-    if (maxHan === -1) {
-        return [];
-    }
     return bestResult;
 }

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

@@ -3,7 +3,7 @@ import { HaiKind } from "../../../../types";
 const DAISUUSHII_YAKU = {
     name: "Daisuushii",
     han: {
-        // TODO: ダブル役満（26飜）とするかはルールによるため、一旦通常の役満として実装
+        // TODO: ダブル役満（26翻）とするかはルールによるため、一旦通常の役満として実装
         open: 13,
         closed: 13,
     },

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

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

package/dist/features/yaku/lib/definitions/{iipeiko.js → iipeikou.js}

@@ -6,7 +6,7 @@ const IIPEIKO_YAKU = {
         closed: 1,
     },
 };
-const checkIipeiko = (hand) => {
+const checkIipeikou = (hand) => {
     if (hand.type !== "Mentsu") {
         return false;
     }
@@ -43,4 +43,4 @@ const checkIipeiko = (hand) => {
     }
     return false;
 };
-export const iipeikoDefinition = createYakuDefinition(IIPEIKO_YAKU, checkIipeiko);
+export const iipeikouDefinition = createYakuDefinition(IIPEIKO_YAKU, checkIipeikou);

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

@@ -1,8 +1,8 @@
 import type { YakuDefinition } from "../../types";
 export * from "./tanyao";
 export * from "./pinfu";
-export * from "./iipeiko";
-export * from "./ryanpeiko";
+export * from "./iipeikou";
+export * from "./ryanpeikou";
 export * from "./sanankou";
 export * from "./suuankou";
 export * from "./sankantsu";