@pai-forge/riichi-mahjong 0.2.0 → 0.3.0

package/dist/errors.js

@@ -0,0 +1,117 @@
+/**
+ * riichi-mahjong ライブラリの基本エラークラス
+ * 全てのカスタムエラーはこのクラスを継承します。
+ */
+export class MahjongError extends Error {
+    /**
+     *
+     */
+    constructor(message) {
+        super(message);
+        this.name = "MahjongError";
+        // TypeScriptでカスタムエラーを正しく動作させるためのハック
+        // TypeScriptでカスタムエラーを正しく動作させるためのハック
+        Object.setPrototypeOf(this, MahjongError.prototype);
+    }
+}
+/**
+ * ツモれなかった場合のエラー (少牌)
+ * 手牌が規定枚数（13枚）より少ない場合にスローされます。
+ */
+export class ShoushaiError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message = "手牌が規定枚数（13枚）より少ないです。") {
+        super(message);
+        this.name = "ShoushaiError";
+        Object.setPrototypeOf(this, ShoushaiError.prototype);
+    }
+}
+/**
+ * 切り忘れの場合のエラー (多牌)
+ * 手牌が規定枚数（13枚）より多い場合にスローされます。
+ */
+export class TahaiError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message = "手牌が規定枚数（13枚）より多いです。") {
+        super(message);
+        this.name = "TahaiError";
+        Object.setPrototypeOf(this, TahaiError.prototype);
+    }
+}
+/**
+ * 引数が不正な場合のエラー
+ * 必要なパラメータが不足している、または不正な値の場合にスローされます。
+ */
+export class MahjongArgumentError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message) {
+        super(message);
+        this.name = "MahjongArgumentError";
+        Object.setPrototypeOf(this, MahjongArgumentError.prototype);
+    }
+}
+/**
+ * 牌IDが重複している場合のエラー
+ * (物理的な牌IDは一意である必要があります)
+ */
+export class DuplicatedHaiIdError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message = "牌IDが重複しています。") {
+        super(message);
+        this.name = "DuplicatedHaiIdError";
+        Object.setPrototypeOf(this, DuplicatedHaiIdError.prototype);
+    }
+}
+/**
+ * 牌の枚数が不正な場合のエラー
+ * (同種の牌は最大4枚までです)
+ */
+export class InvalidHaiQuantityError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message = "同種の牌が5枚以上存在します。") {
+        super(message);
+        this.name = "InvalidHaiQuantityError";
+        Object.setPrototypeOf(this, InvalidHaiQuantityError.prototype);
+    }
+}
+/**
+ * チョンボ（錯和）の基底エラークラス
+ *
+ * 不正な和了宣言に関するエラーの基底クラス。
+ * 具体的なチョンボ種別（役なし、フリテン等）はサブクラスで定義する。
+ */
+export class ChomboError extends MahjongError {
+    /**
+     *
+     */
+    constructor(message = "不正な和了です。") {
+        super(message);
+        this.name = "ChomboError";
+        Object.setPrototypeOf(this, ChomboError.prototype);
+    }
+}
+/**
+ * 役なし和了のエラー
+ *
+ * 和了形は成立しているが、役が一つも成立していない場合にスローされます。
+ */
+export class NoYakuError extends ChomboError {
+    /**
+     *
+     */
+    constructor(message = "役が成立していません。") {
+        super(message);
+        this.name = "NoYakuError";
+        Object.setPrototypeOf(this, NoYakuError.prototype);
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { HaiKindId, Tehai13 } from "../../types";
+/**
+ * 手牌の受け入れ（有効牌）を計算する。
+ * 今回は面子手のみを対象とし、七対子や国士無双は考慮しない。
+ *
+ * @param tehai 手牌 (13枚)
+ * @returns シャンテン数を進める牌のリスト
+ */
+export declare function getUkeire(tehai: Tehai13): HaiKindId[];

package/dist/features/machi/index.js

@@ -0,0 +1,48 @@
+import { countHaiKind } from "../../core/tehai";
+import { calculateMentsuTeShanten } from "../shanten";
+/**
+ * 手牌の受け入れ（有効牌）を計算する。
+ * 今回は面子手のみを対象とし、七対子や国士無双は考慮しない。
+ *
+ * @param tehai 手牌 (13枚)
+ * @returns シャンテン数を進める牌のリスト
+ */
+export function getUkeire(tehai) {
+    const currentShanten = calculateMentsuTeShanten(tehai);
+    const ukeireList = [];
+    // 手牌の全ての牌（純手牌 + 副露）をカウント
+    const allHais = [
+        ...tehai.closed,
+        ...tehai.exposed.flatMap((m) => m.hais),
+    ];
+    const haiCounts = countHaiKind(allHais);
+    // 全34種の牌について、1枚加えてシャンテン数が下がるか試す
+    for (let i = 0; i < 34; i++) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const tile = i;
+        // 4枚使い切っている牌種はスキップ（山に残っていない）
+        if (haiCounts[tile] >= 4) {
+            continue;
+        }
+        // 手牌のコピーを作成（副作用を防ぐため、常に新しいオブジェクトで試行）
+        // Tehai13に1枚足すので、厳密にはTehai14として扱う必要があるが、
+        // calculateMentsuTeShanten は Tehai<HaiKindId> を受け付けるので、
+        // 構造的に { closed, exposed } が適合していればOK。
+        // ただし、Tehai13型に準拠したオブジェクトに1枚足すと枚数オーバーになるため、
+        // バリデーションを通過させるために Tehai14 として構築するか、
+        // calculateMentsuTeShanten 側が Generics で受け入れる点を利用する。
+        // 配列のコピーを作成
+        const newClosed = [...tehai.closed, tile];
+        const newTehai = {
+            closed: newClosed,
+            exposed: tehai.exposed,
+        };
+        // シャンテン数を計算
+        // ここでバリデーションエラーが出ないように、calculateMentsuTeShanten 側は validateTehai を使用している。
+        const newShanten = calculateMentsuTeShanten(newTehai);
+        if (newShanten < currentShanten) {
+            ukeireList.push(tile);
+        }
+    }
+    return ukeireList;
+}

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

@@ -0,0 +1 @@
+export type { MachiType } from "../../core/machi";

package/dist/features/machi/types.js

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

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

@@ -0,0 +1,19 @@
+import type { Tehai } from "../../types";
+export type { MspzString, ExtendedMspzString } from "./mspz";
+export { isExtendedMspz } from "./mspz";
+/**
+ * 標準的なMSPZ文字列（例: "123m456p..."）を解析して手牌オブジェクトを生成します。
+ * 副露牌は含まれません。
+ *
+ * @param input MSPZ形式の文字列
+ * @returns 手牌オブジェクト
+ */
+export declare function parseMspz(input: string): Tehai;
+/**
+ * 拡張MSPZ文字列（例: "123m[123p]..."）を解析して手牌オブジェクトを生成します。
+ * 副露牌（`[...]`）や暗槓（`(...)`）を含めることができます。
+ *
+ * @param input 拡張MSPZ形式の文字列
+ * @returns 手牌オブジェクト
+ */
+export declare function parseExtendedMspz(input: string): Tehai;

package/dist/features/parser/index.js

@@ -0,0 +1,28 @@
+import { parseExtendedMspz as internalParseExtendedMspz, parseMspzToHaiKindIds, asMspz, asExtendedMspz, } from "./mspz";
+export { isExtendedMspz } from "./mspz";
+/**
+ * 標準的なMSPZ文字列（例: "123m456p..."）を解析して手牌オブジェクトを生成します。
+ * 副露牌は含まれません。
+ *
+ * @param input MSPZ形式の文字列
+ * @returns 手牌オブジェクト
+ */
+export function parseMspz(input) {
+    const ids = parseMspzToHaiKindIds(asMspz(input));
+    return {
+        closed: ids,
+        exposed: [],
+    };
+}
+/**
+ * 拡張MSPZ文字列（例: "123m[123p]..."）を解析して手牌オブジェクトを生成します。
+ * 副露牌（`[...]`）や暗槓（`(...)`）を含めることができます。
+ *
+ * @param input 拡張MSPZ形式の文字列
+ * @returns 手牌オブジェクト
+ */
+export function parseExtendedMspz(input) {
+    // parseExtendedMspz returns { closed: HaiKindId[], exposed: CompletedMentsu[] }
+    // which is compatible with Tehai interface.
+    return internalParseExtendedMspz(asExtendedMspz(input));
+}

package/dist/features/parser/mspz.d.ts

@@ -0,0 +1,85 @@
+import { CompletedMentsu, HaiId, HaiKindDistribution, HaiKindId } from "../../types";
+/**
+ * 標準的なMSPZ形式の文字列（拡張記法を含まない）
+ */
+export type MspzString = string & {
+    readonly __brand: "MspzString";
+};
+/**
+ * 拡張MSPZ形式の文字列
+ * 通常のMSPZに加え、`[...]` (副露) や `(...)` (暗槓) を含むことができます。
+ */
+export type ExtendedMspzString = string & {
+    readonly __brand: "ExtendedMspzString";
+};
+/**
+ * 文字列が拡張MSPZ形式（`[` または `(` を含み、かつ正しい書式）かどうかを判定します。
+ * @param input 判定対象の文字列
+ * @returns 拡張MSPZ形式であれば true
+ */
+export declare function isExtendedMspz(input: string): input is ExtendedMspzString;
+/**
+ * 文字列を ExtendedMspzString 型として扱います。
+ * 拡張MSPZ形式であることを検証します。
+ *
+ * @param input 変換対象の文字列
+ * @throws {Error} 拡張MSPZ形式でない場合
+ * @returns ExtendedMspzString
+ */
+export declare function asExtendedMspz(input: string): ExtendedMspzString;
+/**
+ * 文字列が標準的なMSPZ形式（拡張記法を含まず、かつ正しい書式）かどうかを判定します。
+ * @param input 判定対象の文字列
+ * @returns 標準MSPZ形式であれば true
+ */
+export declare function isMspz(input: string): input is MspzString;
+/**
+ * 拡張MSPZ解析結果
+ */
+export interface ExtendedMspzParseResult {
+    readonly closed: readonly HaiKindId[];
+    readonly exposed: readonly CompletedMentsu[];
+}
+/**
+ * 拡張MSPZ形式の文字列を解析して、純手牌と副露のリストに変換します。
+ *
+ * @param input 拡張MSPZ形式の文字列
+ * @returns 解析結果オブジェクト
+ */
+export declare function parseExtendedMspz(input: string): ExtendedMspzParseResult;
+/**
+ * 13枚の牌種ID配列を 34種の牌種分布（所持数分布）に変換します。
+ * @throws {ShoushaiError} 牌の数が13枚より少ない場合
+ * @throws {TahaiError} 牌の数が13枚より多い場合
+ */
+export declare function createDistribution(hais: readonly HaiKindId[]): HaiKindDistribution;
+/**
+ * 13枚の牌ID配列を 34種の牌種分布（所持数分布）に変換します。
+ * @throws {ShoushaiError} 牌の数が13枚より少ない場合
+ * @throws {TahaiError} 牌の数が13枚より多い場合
+ */
+export declare function haiIdsToDistribution(hais: readonly HaiId[]): HaiKindDistribution;
+/**
+ * 13枚の牌種ID配列を MSPZ形式の文字列（例: "123m456p..."）に変換します。
+ * すべての牌をソートして表記します。
+ * @throws {ShoushaiError} 牌の数が13枚より少ない場合
+ * @throws {TahaiError} 牌の数が13枚より多い場合
+ */
+export declare function haiKindIdsToMspzString(hais: readonly HaiKindId[]): string;
+/**
+ * 文字列を MspzString 型として扱います。
+ * 標準的なMSPZ形式（拡張記法を含まない）であることを検証します。
+ *
+ * @param input 変換対象の文字列
+ * @throws {Error} 拡張記法が含まれている場合
+ * @returns MspzString
+ */
+export declare function asMspz(input: string): MspzString;
+/**
+ * MSPZ形式の文字列（例: "123m456p"）を解析して HaiKindId の配列に変換します。
+ * 主にテストデータの作成用途で使用します。
+ *
+ * @param mspz MSPZ形式の文字列
+ * @returns HaiKindId の配列
+ */
+export declare function parseMspzToHaiKindIds(mspz: MspzString): HaiKindId[];

package/dist/features/parser/mspz.js

@@ -0,0 +1,365 @@
+import { asHaiKindId, isTuple3, isTuple4 } from "../../utils/assertions";
+import { ShoushaiError, TahaiError } from "../../errors";
+import { FuroType, HaiKind, MentsuType, Tacha, } from "../../types";
+import { haiIdToKindId, haiKindToNumber } from "../../core/hai";
+// 1つ以上の数字 + 1つのサフィックス (m, p, s, z)
+const BLOCK_PATTERN = "\\d+[mpsz]";
+// 標準的なMSPZ: ブロックの繰り返し (空文字列も許容)
+const STANDARD_MSPZ_REGEX = new RegExp(`^(${BLOCK_PATTERN})*$`);
+// 拡張パート: [...] または (...) で囲まれたブロック (囲みの中も同様のブロック構造)
+// 注: 現在のパーサー実装では、[] の中は単純な BLOCK_PATTERN の連続を許容しているか?
+// parseMentsuString: mspzStringToHaiKindIds を呼んでいる。
+// mspzStringToHaiKindIds: \d+[mpsz] をパースする。
+// したがって、[] の中身も BLOCK_PATTERN の繰り返しであるべき。
+const EXTENDED_BLOCK_PATTERN = `(${BLOCK_PATTERN}|\\[(${BLOCK_PATTERN})+\\]|\\((${BLOCK_PATTERN})+\\))`;
+const EXTENDED_MSPZ_REGEX = new RegExp(`^${EXTENDED_BLOCK_PATTERN}*$`);
+/**
+ * 文字列が拡張MSPZ形式（`[` または `(` を含み、かつ正しい書式）かどうかを判定します。
+ * @param input 判定対象の文字列
+ * @returns 拡張MSPZ形式であれば true
+ */
+export function isExtendedMspz(input) {
+    // ブラケットを含む、かつ拡張書式にマッチする場合のみ true
+    // (ブラケットを含まない適正なMSPZは、ここでの定義上 ExtendedMspzString とはみなさない = MspzString と区別する)
+    return ((input.includes("[") || input.includes("(")) &&
+        EXTENDED_MSPZ_REGEX.test(input));
+}
+/**
+ * 文字列を ExtendedMspzString 型として扱います。
+ * 拡張MSPZ形式であることを検証します。
+ *
+ * @param input 変換対象の文字列
+ * @throws {Error} 拡張MSPZ形式でない場合
+ * @returns ExtendedMspzString
+ */
+export function asExtendedMspz(input) {
+    if (!isExtendedMspz(input)) {
+        throw new Error(`Invalid Extended MSPZ string: ${input}`);
+    }
+    return input;
+}
+/**
+ * 文字列が標準的なMSPZ形式（拡張記法を含まず、かつ正しい書式）かどうかを判定します。
+ * @param input 判定対象の文字列
+ * @returns 標準MSPZ形式であれば true
+ */
+export function isMspz(input) {
+    return STANDARD_MSPZ_REGEX.test(input);
+}
+/**
+ * 拡張MSPZ形式の文字列を解析して、純手牌と副露のリストに変換します。
+ *
+ * @param input 拡張MSPZ形式の文字列
+ * @returns 解析結果オブジェクト
+ */
+export function parseExtendedMspz(input) {
+    const closedParts = [];
+    const exposed = [];
+    let current = "";
+    let mode = "closed";
+    // 文字単位でパース
+    for (const char of input) {
+        if (char === "[") {
+            if (mode !== "closed")
+                throw new Error("Nested brackets are not supported");
+            if (current.length > 0)
+                closedParts.push(current);
+            // current = ""; // OLD
+            current = "["; // NEW: Start capturing with bracket
+            mode = "open";
+        }
+        else if (char === "]") {
+            if (mode !== "open")
+                throw new Error("Unexpected closing bracket ']'");
+            current += "]"; // NEW: End capturing with bracket
+            // exposed.push(parseMentsuString(current, "open")); // OLD
+            exposed.push(parseMentsuFromExtendedMspz(asExtendedMspz(current))); // NEW
+            current = "";
+            mode = "closed";
+        }
+        else if (char === "(") {
+            if (mode !== "closed")
+                throw new Error("Nested parentheses are not supported");
+            if (current.length > 0)
+                closedParts.push(current);
+            // current = ""; // OLD
+            current = "("; // NEW
+            mode = "ankan";
+        }
+        else if (char === ")") {
+            if (mode !== "ankan")
+                throw new Error("Unexpected closing parenthesis ')'");
+            current += ")"; // NEW
+            // exposed.push(parseMentsuString(current, "ankan")); // OLD
+            exposed.push(parseMentsuFromExtendedMspz(asExtendedMspz(current))); // NEW
+            current = "";
+            mode = "closed";
+        }
+        else {
+            current += char;
+        }
+    }
+    // 残りのclosed部分
+    if (current.length > 0) {
+        if (mode !== "closed")
+            throw new Error("Unclosed bracket or parenthesis");
+        closedParts.push(current);
+    }
+    // closed部分を結合してパース
+    const fullClosedMspz = closedParts.join("");
+    const closedIds = parseMspzToHaiKindIds(asMspz(fullClosedMspz));
+    return {
+        closed: closedIds,
+        exposed: exposed,
+    };
+}
+/**
+ * 副露・暗槓のブロック文字列（例: "[123m]", "(11z)"）を解析してCompletedMentsuを生成する内部関数
+ * 括弧の種類から副露か暗槓かを自動判定します。
+ */
+function parseMentsuFromExtendedMspz(block) {
+    let mode;
+    let content;
+    if (block.startsWith("[") && block.endsWith("]")) {
+        mode = "open";
+        content = block.slice(1, -1);
+    }
+    else if (block.startsWith("(") && block.endsWith(")")) {
+        mode = "ankan";
+        content = block.slice(1, -1);
+    }
+    else {
+        throw new Error(`Invalid Extended MSPZ block: ${block} (must be [...] or (...))`);
+    }
+    // 中身は標準MSPZ形式である必要がある
+    const ids = parseMspzToHaiKindIds(asMspz(content));
+    if (ids.length === 0) {
+        throw new Error("Empty mentsu specification");
+    }
+    // 枚数チェック & 種類判定
+    const count = ids.length;
+    const isAllSame = ids.every((id) => id === ids[0]);
+    // 暗槓 (Ankan)
+    if (mode === "ankan") {
+        if (count !== 4 || !isAllSame) {
+            throw new Error(`Invalid Ankan: ${block} (must be 4 identical tiles)`);
+        }
+        if (!isTuple4(ids)) {
+            throw new Error("Internal Error: ids length check mismatch");
+        }
+        const kantsu = {
+            type: MentsuType.Kantsu,
+            hais: ids,
+            // Ankan has no furo info (or minimal)
+        };
+        return kantsu;
+    }
+    // 副露 (Open)
+    if (count === 4 && isAllSame) {
+        // Daiminkan
+        if (!isTuple4(ids)) {
+            throw new Error("Internal Error: ids length check mismatch");
+        }
+        const kantsu = {
+            type: MentsuType.Kantsu,
+            hais: ids,
+            furo: { type: FuroType.Daiminkan, from: Tacha.Toimen }, // Default
+        };
+        return kantsu;
+    }
+    else if (count === 3 && isAllSame) {
+        // Pon
+        if (!isTuple3(ids)) {
+            throw new Error("Internal Error: ids length check mismatch");
+        }
+        const koutsu = {
+            type: MentsuType.Koutsu,
+            hais: ids,
+            furo: { type: FuroType.Pon, from: Tacha.Toimen }, // Default
+        };
+        return koutsu;
+    }
+    else if (count === 3) {
+        // Chi (Should check continuity, strictly speaking but relying on user for now or implicit check)
+        // Minimal check: sorted? mspzStringToHaiKindIds sorts by default?
+        // mspzStringToHaiKindIds does NOT sort across different suits, but "123m" results in sorted array.
+        // Let's assume valid sequence for now.
+        if (!isTuple3(ids)) {
+            throw new Error("Internal Error: ids length check mismatch");
+        }
+        const shuntsu = {
+            type: MentsuType.Shuntsu,
+            hais: ids,
+            furo: { type: FuroType.Chi, from: Tacha.Kamicha }, // Default
+        };
+        return shuntsu;
+    }
+    throw new Error(`Invalid Mentsu specification: ${block} (must be 3 or 4 tiles)`);
+}
+/**
+ * 13枚の牌種ID配列を 34種の牌種分布（所持数分布）に変換します。
+ * @throws {ShoushaiError} 牌の数が13枚より少ない場合
+ * @throws {TahaiError} 牌の数が13枚より多い場合
+ */
+export function createDistribution(hais) {
+    if (hais.length < 13) {
+        throw new ShoushaiError(`Invalid number of tiles: expected 13, got ${hais.length}`);
+    }
+    if (hais.length > 13) {
+        throw new TahaiError(`Invalid number of tiles: expected 13, got ${hais.length}`);
+    }
+    const counts = Array.from({ length: 34 }, () => 0);
+    for (const kind of hais) {
+        counts[kind] = (counts[kind] ?? 0) + 1;
+    }
+    // Tupleへの変換はアサーションが必要だが、生成ロジックが保証しているため安全
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return counts;
+}
+/**
+ * 13枚の牌ID配列を 34種の牌種分布（所持数分布）に変換します。
+ * @throws {ShoushaiError} 牌の数が13枚より少ない場合
+ * @throws {TahaiError} 牌の数が13枚より多い場合
+ */
+export function haiIdsToDistribution(
+// Branded type makes linter think it's mutable object, but it's primitive number.
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+hais) {
+    const kinds = hais.map(haiIdToKindId);
+    return createDistribution(kinds);
+}
+/**
+ * 13枚の牌種ID配列を MSPZ形式の文字列（例: "123m456p..."）に変換します。
+ * すべての牌をソートして表記します。
+ * @throws {ShoushaiError} 牌の数が13枚より少ない場合
+ * @throws {TahaiError} 牌の数が13枚より多い場合
+ */
+export function haiKindIdsToMspzString(hais) {
+    const counts = createDistribution(hais);
+    let result = "";
+    // 萬子
+    const manzu = [];
+    for (let i = 0; i < 9; i++) {
+        const kind = asHaiKindId(HaiKind.ManZu1 + i);
+        const count = counts[kind];
+        for (let j = 0; j < count; j++) {
+            const num = haiKindToNumber(kind);
+            if (num !== undefined)
+                manzu.push(num);
+        }
+    }
+    if (manzu.length > 0) {
+        result += manzu.join("") + "m";
+    }
+    // 筒子
+    const pinzu = [];
+    for (let i = 0; i < 9; i++) {
+        const kind = asHaiKindId(HaiKind.PinZu1 + i);
+        const count = counts[kind];
+        for (let j = 0; j < count; j++) {
+            const num = haiKindToNumber(kind);
+            if (num !== undefined)
+                pinzu.push(num);
+        }
+    }
+    if (pinzu.length > 0) {
+        result += pinzu.join("") + "p";
+    }
+    // 索子
+    const souzu = [];
+    for (let i = 0; i < 9; i++) {
+        const kind = asHaiKindId(HaiKind.SouZu1 + i);
+        const count = counts[kind];
+        for (let j = 0; j < count; j++) {
+            const num = haiKindToNumber(kind);
+            if (num !== undefined)
+                souzu.push(num);
+        }
+    }
+    if (souzu.length > 0) {
+        result += souzu.join("") + "s";
+    }
+    // 字牌
+    const jihai = [];
+    for (let i = 0; i < 7; i++) {
+        const kind = asHaiKindId(HaiKind.Ton + i);
+        const count = counts[kind];
+        for (let j = 0; j < count; j++) {
+            // 字牌は 1-7 で表すことが多い
+            const num = i + 1;
+            jihai.push(num);
+        }
+    }
+    if (jihai.length > 0) {
+        result += jihai.join("") + "z";
+    }
+    return result;
+}
+/**
+ * 文字列を MspzString 型として扱います。
+ * 標準的なMSPZ形式（拡張記法を含まない）であることを検証します。
+ *
+ * @param input 変換対象の文字列
+ * @throws {Error} 拡張記法が含まれている場合
+ * @returns MspzString
+ */
+export function asMspz(input) {
+    if (!isMspz(input)) {
+        throw new Error(`Invalid MSPZ string: ${input}`);
+    }
+    return input;
+}
+/**
+ * MSPZ形式の文字列（例: "123m456p"）を解析して HaiKindId の配列に変換します。
+ * 主にテストデータの作成用途で使用します。
+ *
+ * @param mspz MSPZ形式の文字列
+ * @returns HaiKindId の配列
+ */
+export function parseMspzToHaiKindIds(mspz) {
+    const result = [];
+    let currentNumbers = [];
+    for (const char of mspz) {
+        if (char >= "0" && char <= "9") {
+            currentNumbers.push(parseInt(char, 10));
+        }
+        else {
+            // Suffix handling
+            let base;
+            switch (char) {
+                case "m":
+                    base = HaiKind.ManZu1;
+                    break;
+                case "p":
+                    base = HaiKind.PinZu1;
+                    break;
+                case "s":
+                    base = HaiKind.SouZu1;
+                    break;
+                case "z":
+                    base = HaiKind.Ton;
+                    break;
+                default:
+                    // 無視する
+                    currentNumbers = [];
+                    continue;
+            }
+            for (const num of currentNumbers) {
+                if (char === "z") {
+                    // 字牌: 1=東(27), ... 7=中(33)
+                    if (num >= 1 && num <= 7) {
+                        result.push(asHaiKindId(base + num - 1));
+                    }
+                }
+                else {
+                    // 数牌: 1-9
+                    if (num >= 1) {
+                        result.push(asHaiKindId(base + num - 1));
+                    }
+                }
+            }
+            currentNumbers = [];
+        }
+    }
+    return result;
+}