@konoui/mjimage 0.0.30 → 0.0.32

package/dist/index.d.cts

@@ -0,0 +1,1386 @@
+import { Actor } from 'xstate';
+import { AnyActorRef } from 'xstate';
+import { ArraySchema } from 'valibot';
+import { EventObject } from 'xstate';
+import { G } from '@svgdotjs/svg.js';
+import { Image as Image_2 } from '@svgdotjs/svg.js';
+import { InferOutput } from 'valibot';
+import { MaxValueAction } from 'valibot';
+import { MetaObject } from 'xstate';
+import { MinValueAction } from 'valibot';
+import { NonReducibleUnknown } from 'xstate';
+import { NumberSchema } from 'valibot';
+import { OptionalSchema } from 'valibot';
+import { ParameterizedObject } from 'xstate';
+import { PicklistSchema } from 'valibot';
+import { ProvidedActor } from 'xstate';
+import { SchemaWithPipe } from 'valibot';
+import { StateMachine } from 'xstate';
+import { StateValue } from 'xstate';
+import { StrictObjectSchema } from 'valibot';
+import { StringSchema } from 'valibot';
+import { Svg } from '@svgdotjs/svg.js';
+import { Use } from '@svgdotjs/svg.js';
+
+export declare class ActorHand extends Hand {
+    isBackHand(): boolean;
+    clone(): ActorHand;
+    dec(tiles: readonly Tile[]): Tile[];
+}
+
+export declare abstract class BaseActor {
+    id: string;
+    river: River;
+    placeManager: PlaceManager;
+    scoreManager: ScoreManager;
+    hands: {
+        "1w": ActorHand;
+        "2w": ActorHand;
+        "3w": ActorHand;
+        "4w": ActorHand;
+    };
+    counter: Counter;
+    doraMarkers: Tile[];
+    eventHandler: EventHandler;
+    constructor(id: string, eventHandler: EventHandler);
+    hand(w: Wind): ActorHand;
+    protected abstract setHands(e: DistributeEvent): void;
+    handleEvent(e: PlayerEvent): void;
+}
+
+declare class BaseHelper {
+    readonly tileWidth: number;
+    readonly tileHeight: number;
+    readonly imageHostPath: string;
+    readonly imageHostUrl: string;
+    readonly imageExt: string;
+    readonly scale: number;
+    readonly svgSprite: boolean;
+    constructor(props?: ImageHelperConfig);
+    protected getDiffTileHeightWidth(t: Tile): number;
+    private image;
+    createImage(tile: Tile, x: number, y: number): Image_2 | Use;
+    createTextImage(tile: Tile, x: number, y: number, t: string): G;
+    createRotate90Image(tile: Tile, x: number, y: number, adjustY?: boolean): G;
+    createStick(v: 100 | 1000): Image_2 | Use;
+    static buildID(tile: Tile | 100 | 1000): string;
+    buildURL(tile: Tile | 100 | 1000): string;
+}
+
+export declare const BLOCK: {
+    readonly PON: "pon";
+    readonly CHI: "chi";
+    readonly SHO_KAN: "shokan";
+    readonly DAI_KAN: "daikan";
+    readonly AN_KAN: "ankan";
+    readonly TSUMO: "tsumo";
+    readonly THREE: "three";
+    readonly PAIR: "pair";
+    readonly ISOLATED: "isolated";
+    readonly RUN: "run";
+    readonly HAND: "hand";
+    readonly IMAGE_DORA: "dora";
+    readonly IMAGE_DISCARD: "simple-discard";
+    readonly UNKNOWN: "unknown";
+};
+
+export declare abstract class Block {
+    private readonly _tiles;
+    private readonly _type;
+    constructor(tiles: readonly Tile[], type: BLOCK);
+    static from(v: SerializedBlock): Block | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockPair | BlockRun | BlockThree | BlockHand | BlockIsolated | BlockOther;
+    serialize(): {
+        tiles: string;
+        type: "pon" | "chi" | "shokan" | "daikan" | "ankan" | "tsumo" | "three" | "pair" | "isolated" | "run" | "hand" | "dora" | "simple-discard" | "unknown";
+    };
+    toJSON(): {
+        tiles: string;
+        type: "pon" | "chi" | "shokan" | "daikan" | "ankan" | "tsumo" | "three" | "pair" | "isolated" | "run" | "hand" | "dora" | "simple-discard" | "unknown";
+    };
+    get type(): "pon" | "chi" | "shokan" | "daikan" | "ankan" | "tsumo" | "three" | "pair" | "isolated" | "run" | "hand" | "dora" | "simple-discard" | "unknown";
+    get tiles(): readonly Tile[];
+    abstract toString(): string;
+    is(type: BLOCK): boolean;
+    isCalled(): boolean;
+    clone(override?: {
+        replace?: {
+            idx: number;
+            tile: Tile;
+        };
+    }): Block | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockPair | BlockRun | BlockThree | BlockHand | BlockIsolated | BlockOther;
+    imageSize(scale: number): {
+        width: number;
+        height: number;
+    };
+}
+
+export declare class BlockAnKan extends Block {
+    constructor(tiles: readonly Tile[]);
+    get tilesWithBack(): Tile[];
+    static from(v: SerializedBlock): BlockAnKan;
+    toString(): string;
+}
+
+export declare class BlockCalculator {
+    hand: Hand;
+    constructor(hand: Hand);
+    calc(lastTile: Tile): Block[][];
+    markDrawn(hands: Block[][], lastTile: Tile): Block[][];
+    sevenPairs(): Block[][];
+    thirteenOrphans(): Block[][];
+    nineGates(): Block[][];
+    fourSetsOnePair(): Block[][];
+    private commonAll;
+    private commonByType;
+}
+
+export declare class BlockChi extends Block {
+    constructor(tiles: readonly [Tile, Tile, Tile]);
+    toString(): string;
+}
+
+export declare class BlockDaiKan extends Block {
+    constructor(tiles: readonly Tile[]);
+    toString(): string;
+}
+
+export declare class BlockHand extends Block {
+    constructor(tiles: readonly Tile[]);
+    toString(): string;
+}
+
+export declare class BlockIsolated extends Block {
+    constructor(tile: Tile);
+    toString(): string;
+}
+
+export declare class BlockOther extends Block {
+    constructor(tiles: readonly Tile[], type: BLOCK);
+    toString(): string;
+}
+
+export declare class BlockPair extends Block {
+    constructor(tile1: Tile, tile2: Tile);
+    toString(): string;
+}
+
+export declare class BlockPon extends Block {
+    constructor(tiles: readonly [Tile, Tile, Tile]);
+    toString(): string;
+}
+
+export declare class BlockRun extends Block {
+    constructor(tiles: readonly [Tile, Tile, Tile]);
+    toString(): string;
+}
+
+export declare class BlockShoKan extends Block {
+    constructor(tiles: readonly Tile[]);
+    toString(): string;
+}
+
+export declare class BlockThree extends Block {
+    constructor(tiles: readonly [Tile, Tile, Tile]);
+    toString(): string;
+}
+
+export declare interface BoardContext {
+    doraMarkers: Tile[];
+    blindDoraMarkers?: Tile[];
+    round: Round;
+    myWind: Wind;
+    ronWind?: Wind;
+    sticks?: {
+        reach: number;
+        dead: number;
+    };
+    reached?: 1 | 2;
+    replacementWin?: boolean;
+    quadWin?: boolean;
+    finalWallWin?: boolean;
+    finalDiscardWin?: boolean;
+    oneShotWin?: boolean;
+}
+
+declare type BoardRound = (typeof ROUND_MAP)[keyof typeof ROUND_MAP];
+
+declare type BoardWind = (typeof WIND_MAP)[keyof typeof WIND_MAP];
+
+export declare interface CallEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "PON" | "CHI" | "AN_KAN" | "SHO_KAN" | "DAI_KAN">;
+    iam: Wind;
+    wind: Wind;
+    block: SerializedBlock;
+}
+
+export declare interface Candidate {
+    tile: Tile;
+    candidates: readonly Tile[];
+    shanten: number;
+}
+
+export declare interface ChoiceAfterCalled {
+    id: string;
+    type: Extract<Event_2, "CHOICE_AFTER_CALLED">;
+    wind: Wind;
+    choices: Pick<DrawnChoice, "DISCARD">;
+}
+
+export declare interface ChoiceAfterDiscardedEvent {
+    id: string;
+    type: Extract<Event_2, "CHOICE_AFTER_DISCARDED">;
+    wind: Wind;
+    discarterInfo: {
+        wind: Wind;
+        tile: string;
+    };
+    choices: DiscardedChoice;
+}
+
+export declare interface ChoiceAfterDrawnEvent {
+    id: string;
+    type: Extract<Event_2, "CHOICE_AFTER_DRAWN">;
+    wind: Wind;
+    drawerInfo: {
+        wind: Wind;
+        tile: string;
+    };
+    choices: DrawnChoice;
+}
+
+declare type ChoiceEvent = "PON" | "CHI" | "RON" | "DISCARD" | "TSUMO" | "REACH" | "AN_KAN" | "SHO_KAN" | "DAI_KAN" | "DRAWN_GAME_BY_NINE_TILES";
+
+export declare interface ChoiceForChanKan {
+    id: string;
+    type: Extract<Event_2, "CHOICE_FOR_CHAN_KAN">;
+    wind: Wind;
+    callerInfo: {
+        wind: Wind;
+        tile: string;
+    };
+    choices: Pick<DiscardedChoice, "RON">;
+}
+
+export declare class Controller {
+    wall: Wall;
+    playerIDs: string[];
+    actor: Actor<StateMachine<    {
+    currentWind: Wind;
+    oneShotMap: { [key in Wind]: boolean; };
+    missingMap: { [key in Wind]: boolean; };
+    controller: Controller;
+    genEventID: ReturnType<incrementalIDGenerator>;
+    }, {
+    type: "";
+    } | {
+    type: "NEXT";
+    } | {
+    type: "CHI";
+    block: BlockChi;
+    iam: Wind;
+    } | {
+    type: "PON";
+    block: BlockPon;
+    iam: Wind;
+    } | {
+    type: "RON";
+    ret: WinResult;
+    iam: Wind;
+    targetInfo: {
+    wind: Wind;
+    tile: Tile;
+    };
+    quadWin?: boolean;
+    } | {
+    type: "TSUMO";
+    ret: WinResult;
+    iam: Wind;
+    lastTile: Tile;
+    } | {
+    type: "REACH";
+    tile: Tile;
+    iam: Wind;
+    } | {
+    type: "DISCARD";
+    tile: Tile;
+    iam: Wind;
+    } | {
+    type: "AN_KAN";
+    block: BlockAnKan;
+    iam: Wind;
+    } | {
+    type: "SHO_KAN";
+    block: BlockShoKan;
+    iam: Wind;
+    } | {
+    type: "DAI_KAN";
+    block: BlockDaiKan;
+    iam: Wind;
+    } | {
+    type: "DRAWN_GAME_BY_NINE_TILES";
+    iam: Wind;
+    }, Record<string, AnyActorRef>, ProvidedActor, ParameterizedObject, ParameterizedObject, never, StateValue, string, unknown, NonReducibleUnknown, EventObject, MetaObject, any>>;
+    observer: Observer;
+    handlers: {
+        [id: string]: EventHandler;
+    };
+    mailBox: {
+        [id: string]: PlayerEvent[];
+    };
+    histories: History_2[];
+    debugMode: boolean;
+    snapshot?: string;
+    constructor(players: PlayerProps[], params?: {
+        debug?: boolean;
+    });
+    boardParams(w: Wind): BoardContext;
+    hand(w: Wind): ActorHand;
+    get placeManager(): PlaceManager;
+    get scoreManager(): ScoreManager;
+    get river(): River;
+    next(force?: boolean): void;
+    emit(e: PlayerEvent): void;
+    enqueue(event: PlayerEvent): void;
+    pollReplies(eventID: string, wind: Wind[]): void;
+    export(): History_2[];
+    static load(h: History_2): Controller;
+    start(): void;
+    startGame(): void;
+    finalResult(ret: WinResult, iam: Wind): WinResult;
+    doWin(w: Wind, t: Tile | null | undefined, params?: {
+        quadWin?: boolean;
+        replacementWin?: boolean;
+        oneShot?: boolean;
+        missingRon?: boolean;
+        whoDiscarded?: Wind;
+    }): WinResult | false;
+    doPon(w: Wind, whoDiscarded: Wind, t?: Tile): BlockPon[] | false;
+    doChi(w: Wind, whoDiscarded: Wind, t?: Tile): BlockChi[] | false;
+    redPattern(blocks: BlockChi[], hasRed: boolean): BlockChi[];
+    doReach(w: Wind): Candidate[] | false;
+    doDiscard(w: Wind, called?: BlockChi | BlockPon): Tile[];
+    cannotDiscardTile(called: BlockChi): Tile[];
+    doAnKan(w: Wind): BlockAnKan[] | false;
+    doShoKan(w: Wind): BlockShoKan[] | false;
+    doDaiKan(w: Wind, whoDiscarded: Wind, t: Tile): BlockDaiKan | false;
+    canDrawnGame(w: Wind): boolean;
+    initialHands(): {
+        "1w": string;
+        "2w": string;
+        "3w": string;
+        "4w": string;
+    };
+}
+
+declare type ControllerContext = {
+    currentWind: Wind;
+    oneShotMap: {
+        [key in Wind]: boolean;
+    };
+    missingMap: {
+        [key in Wind]: boolean;
+    };
+    controller: Controller;
+    genEventID: ReturnType<typeof incrementalIDGenerator>;
+};
+
+export declare const convertInput: (i: TableInput) => {
+    discards: DiscardsInput;
+    hands: HandsInput;
+    scoreBoard: ScoreBoardInput;
+};
+
+export declare class Counter {
+    disable: boolean;
+    private c;
+    safeMap: {
+        "1w": {
+            [name: string]: boolean;
+        };
+        "2w": {
+            [name: string]: boolean;
+        };
+        "3w": {
+            [name: string]: boolean;
+        };
+        "4w": {
+            [name: string]: boolean;
+        };
+    };
+    constructor(disable?: boolean);
+    get(t: Tile): number;
+    dec(...tiles: Tile[]): void;
+    addTileToSafeMap(t: Tile, targetUser: Wind): void;
+    isSafeTile(k: Type, n: number, targetUser: Wind): boolean;
+    private key;
+    reset(): void;
+}
+
+export declare const createControllerMachine: (c: Controller) => StateMachine<ControllerContext, {
+type: "";
+} | {
+type: "NEXT";
+} | {
+type: "CHI";
+block: BlockChi;
+iam: Wind;
+} | {
+type: "PON";
+block: BlockPon;
+iam: Wind;
+} | {
+type: "RON";
+ret: WinResult;
+iam: Wind;
+targetInfo: {
+wind: Wind;
+tile: Tile;
+};
+quadWin?: boolean;
+} | {
+type: "TSUMO";
+ret: WinResult;
+iam: Wind;
+lastTile: Tile;
+} | {
+type: "REACH";
+tile: Tile;
+iam: Wind;
+} | {
+type: "DISCARD";
+tile: Tile;
+iam: Wind;
+} | {
+type: "AN_KAN";
+block: BlockAnKan;
+iam: Wind;
+} | {
+type: "SHO_KAN";
+block: BlockShoKan;
+iam: Wind;
+} | {
+type: "DAI_KAN";
+block: BlockDaiKan;
+iam: Wind;
+} | {
+type: "DRAWN_GAME_BY_NINE_TILES";
+iam: Wind;
+}, Record<string, AnyActorRef>, ProvidedActor, ParameterizedObject, ParameterizedObject, never, StateValue, string, unknown, NonReducibleUnknown, EventObject, MetaObject, any>;
+
+export declare const createEventEmitter: () => {
+    emit: (e: PlayerEvent) => void;
+    on: (h: EventHandlerFunc) => void;
+};
+
+export declare const createEventPipe: () => [EventHandler, EventHandler];
+
+export declare const createHand: (helper: ImageHelper, blocks: Block[]) => {
+    e: G;
+    width: number;
+    height: number;
+};
+
+export declare const createLocalGame: (params?: {
+    playerIDs?: string[];
+    debug?: boolean;
+}) => Controller;
+
+export declare const createTable: (helper: ImageHelper, fontCtx: FontContext, handsProps: HandsInput, discardsProps: DiscardsInput, scoreBoardProps: ScoreBoardInput) => {
+    e: G;
+    width: number;
+    height: number;
+};
+
+export declare function createWindMap<T>(initial: T, clone?: boolean): {
+    "1w": T;
+    "2w": T;
+    "3w": T;
+    "4w": T;
+};
+
+export declare const deserializeWinResult: (ret: SerializedWinResult) => WinResult;
+
+declare interface DiscardedChoice {
+    RON: false | SerializedWinResult;
+    PON: false | SerializedBlock[];
+    CHI: false | SerializedBlock[];
+    DAI_KAN: false | SerializedBlock;
+}
+
+export declare interface DiscardEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "DISCARD">;
+    iam: Wind;
+    wind: Wind;
+    tile: string;
+}
+
+export declare interface DiscardsInput {
+    front: Tile[];
+    right: Tile[];
+    opposite: Tile[];
+    left: Tile[];
+}
+
+export declare interface DistributeEvent {
+    id: string;
+    type: Extract<Event_2, "DISTRIBUTE">;
+    hands: {
+        [key in Wind]: string;
+    };
+    wind: Wind;
+    doraMarker: string;
+    players: string[];
+    places: {
+        [key: string]: Wind;
+    };
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    round: Round;
+    scores: {
+        [key: string]: number;
+    };
+}
+
+export declare class DoubleCalculator {
+    hand: Hand;
+    cfg: {
+        doras: Tile[];
+        blindDoras: Tile[];
+        roundWind: Tile;
+        myWind: Tile;
+        reached: 0 | 1 | 2;
+        sticks: {
+            reach: number;
+            dead: number;
+        };
+        replacementWin: boolean;
+        quadWin: boolean;
+        finalWallWin: boolean;
+        finalDiscardWin: boolean;
+        oneShotWin: boolean;
+        orig: BoardContext;
+    };
+    constructor(hand: Hand, params: BoardContext);
+    calc(hands: Block[][]): WinResult | false;
+    calcPatterns(hands: Block[][]): {
+        points: {
+            name: string;
+            double: number;
+        }[];
+        fu: number;
+        hand: Block[];
+    }[];
+    private minus;
+    dA1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dD1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dE1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dF1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dG1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dH1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dI1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dJ1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dK1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dX1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dD2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dE2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dF2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dG2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dH2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dI2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dJ2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA3(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB3(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC3(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA6(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dD13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dE13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dF13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dG13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dH13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dI13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dJ13(h: Block[]): never[];
+    dK13(h: Block[]): never[];
+    calcFu(h: Block[]): number;
+}
+
+export declare const drawBlocks: (svg: Svg, blocks: Block[], config?: ImageHelperConfig, params?: {
+    responsive: boolean;
+}) => void;
+
+export declare interface DrawEvent {
+    id: string;
+    type: Extract<Event_2, "DRAW">;
+    subtype?: "kan";
+    iam: Wind;
+    wind: Wind;
+    tile: string;
+}
+
+declare interface DrawnChoice {
+    TSUMO: false | SerializedWinResult;
+    REACH: false | SerializedCandidate[];
+    AN_KAN: false | SerializedBlock[];
+    SHO_KAN: false | SerializedBlock[];
+    DISCARD: false | string[];
+    DRAWN_GAME_BY_NINE_TILES: boolean;
+}
+
+export declare const drawTable: (svg: Svg, tableInput: string, config: ImageHelperConfig | undefined, fontCtx: FontContext, params?: {
+    responsive: boolean;
+}) => void;
+
+export declare class Efficiency {
+    static calcCandidates(hand: Hand, choices: Tile[]): Candidate[];
+    static candidateTiles(hand: Hand): {
+        shanten: number;
+        candidates: Tile[];
+    };
+    static partialCandidateTiles(input: string): {
+        shanten: number;
+        candidates: Tile[];
+    };
+    static partialShanten(input: string): number;
+}
+
+export declare interface EndEvent {
+    id: string;
+    type: Extract<Event_2, "END_GAME">;
+    subType: "WIN_GAME" | "DRAWN_GAME" | "FOUR_KAN" | "FOUR_WIND" | "NINE_TILES";
+    wind: Wind;
+    scores: {
+        [key: string]: number;
+    };
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    deltas: {
+        [key in Wind]: number;
+    };
+    hands: {
+        [key in Wind]: string;
+    };
+    shouldContinue: boolean;
+}
+
+declare type Event_2 = CallEvent | "DRAW" | "CHOICE_AFTER_DRAWN" | "CHOICE_AFTER_DISCARDED" | "CHOICE_AFTER_CALLED" | "CHOICE_FOR_CHAN_KAN" | "DISTRIBUTE" | "NEW_DORA" | "END_GAME";
+
+export declare interface EventHandler {
+    emit(e: PlayerEvent): void;
+    on(handler: EventHandlerFunc): void;
+}
+
+export declare type EventHandlerFunc = (e: PlayerEvent) => void;
+
+export declare const FONT_FAMILY = "MS Gothic, sans-serif";
+
+export declare interface FontContext {
+    font: {
+        family: string;
+        size: number;
+    };
+    textWidth: number;
+    textHeight: number;
+    numWidth: number;
+    numHeight: number;
+}
+
+export declare class Hand {
+    protected data: HandData;
+    constructor(input: string, allowBackBlock?: boolean);
+    private init;
+    get hands(): Tile[];
+    toString(): string;
+    get called(): readonly (BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan)[];
+    get reached(): boolean;
+    get drawn(): Tile | null;
+    get menzen(): boolean;
+    getArrayLen(t: Type): 2 | 8 | 10;
+    sum(t: Type): number;
+    get(t: Type, n: number): number;
+    inc(tiles: readonly Tile[]): Tile[];
+    dec(tiles: readonly Tile[]): Tile[];
+    draw(t: Tile): void;
+    discard(t: Tile): void;
+    reach(): void;
+    call(b: BlockPon | BlockChi | BlockDaiKan): void;
+    kan(b: BlockAnKan | BlockShoKan): void;
+    clone(): Hand;
+}
+
+export declare interface HandData {
+    [TYPE.M]: TupleOfSize<number, 10>;
+    [TYPE.S]: TupleOfSize<number, 10>;
+    [TYPE.P]: TupleOfSize<number, 10>;
+    [TYPE.Z]: TupleOfSize<number, 8>;
+    [TYPE.BACK]: [string, number];
+    called: readonly (BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan)[];
+    tsumo: Tile | null;
+    reached: boolean;
+}
+
+export declare interface HandsInput {
+    front: Block[];
+    right: Block[];
+    opposite: Block[];
+    left: Block[];
+}
+
+declare interface History_2 {
+    round: Round;
+    scores: {
+        [key in string]: number;
+    };
+    players: {
+        [key in string]: Wind;
+    };
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    wall: WallProps;
+    choiceEvents: {
+        [id: string]: PlayerEvent[];
+    };
+}
+export { History_2 as History }
+
+export declare class ImageHelper extends BaseHelper {
+    readonly blockMargin: number;
+    createBlockHandDiscard(block: Block): G;
+    createBlockPonChiKan(block: Block): G;
+}
+
+export declare interface ImageHelperConfig {
+    scale?: number;
+    imageHostPath?: string;
+    imageHostUrl?: string;
+    imageExt?: "svg" | "webp";
+    svgSprite?: boolean;
+}
+
+export declare function incrementalIDGenerator(start?: number): () => string;
+
+export declare const INPUT_SEPARATOR = ",";
+
+export declare function isNum0(t: Tile): boolean;
+
+export declare function isNum5(t: Tile): boolean;
+
+export declare function isNum5or0(t: Tile): boolean;
+
+export declare class MeasureText {
+    ctx: CanvasRenderingContext2D | null;
+    strText: string;
+    numText: string;
+    constructor(strText?: string, numText?: string);
+    private measure;
+    measureFontContext: (fontFamily: string, fontSize: number) => FontContext;
+    measureTableFontContext: (tableScale: number) => FontContext;
+}
+
+export declare const N19: readonly number[];
+
+export declare interface NewDoraEvent {
+    id: string;
+    type: Extract<Event_2, "NEW_DORA">;
+    doraMarker: string;
+    wind: Wind;
+}
+
+export declare const nextRound: (r: Round) => Round;
+
+export declare const nextWind: (w: Wind) => Wind;
+
+export declare const NZ: readonly number[];
+
+export declare class Observer extends BaseActor {
+    applied: {
+        [id: string]: boolean;
+    };
+    constructor(eventHandler: EventHandler);
+    setHands(e: DistributeEvent): void;
+    handleEvent(e: PlayerEvent): void;
+}
+
+export declare const OPERATOR: {
+    readonly TSUMO: "t";
+    readonly RON: "r";
+    readonly DORA: "d";
+    readonly HORIZONTAL: "-";
+    readonly COLOR_GRAYSCALE: "^";
+};
+
+declare type Operator = (typeof OPERATOR)[keyof typeof OPERATOR];
+
+export declare const optimizeSVG: (draw: Svg) => void;
+
+export declare const parse: (s: string) => {
+    discards: DiscardsInput;
+    hands: HandsInput;
+    scoreBoard: ScoreBoardInput;
+};
+
+export declare class Parser {
+    readonly input: string;
+    readonly maxInputLength = 600;
+    constructor(input: string);
+    parse(): (BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockPair | BlockRun | BlockThree | BlockHand | BlockIsolated | BlockOther)[];
+    tiles(): Tile[];
+    tileSeparators(): (Tile | Separator)[];
+    private makeBlocks;
+    validate(input: string): void;
+}
+
+export declare const parseTableInput: (s: string) => {
+    "1w": {
+        hand: string;
+        discard: string;
+        score: number;
+    };
+    "2w": {
+        hand: string;
+        discard: string;
+        score: number;
+    };
+    "3w": {
+        hand: string;
+        discard: string;
+        score: number;
+    };
+    "4w": {
+        hand: string;
+        discard: string;
+        score: number;
+    };
+    board: {
+        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4";
+        sticks: {
+            reach: number;
+            dead: number;
+        };
+        doras: string[];
+        front: "1w" | "2w" | "3w" | "4w";
+    };
+};
+
+export declare class PlaceManager {
+    private pToW;
+    private wToP;
+    round: Round;
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    constructor(initial: {
+        [key: string]: Wind;
+    }, params?: {
+        round: Round;
+        sticks: {
+            reach: number;
+            dead: number;
+        };
+    });
+    private update;
+    incrementDeadStick(): void;
+    incrementReachStick(): void;
+    nextRound(): void;
+    decrementReachStick(): void;
+    resetDeadStick(): void;
+    resetReachStick(): void;
+    is(r: Round): boolean;
+    wind(id: string): "1w" | "2w" | "3w" | "4w";
+    playerID(w: Wind): string;
+    get playerMap(): {
+        [key: string]: "1w" | "2w" | "3w" | "4w";
+    };
+}
+
+export declare class Player extends BaseActor {
+    river: River;
+    doras: Tile[];
+    constructor(playerID: string, eventHandler: EventHandler);
+    get myWind(): "1w" | "2w" | "3w" | "4w";
+    setHands(e: DistributeEvent): void;
+    handleDiscard(tiles: Tile[]): Tile;
+    handleEvent(e: PlayerEvent): void;
+}
+
+export declare interface PlayerCandidate {
+    tile: Tile;
+    sum: number;
+    candidates: {
+        tile: Tile;
+        n: number;
+    }[];
+    shanten: number;
+}
+
+export declare class PlayerEfficiency {
+    static calcPlayerCandidates(counter: Counter, candidates: Candidate[]): PlayerCandidate[];
+    static selectMinPriority(c: Counter, playerCandidates: PlayerCandidate[], doras: Tile[]): PlayerCandidate;
+    private static calcPriority;
+}
+
+export declare type PlayerEvent = DistributeEvent | EndEvent | CallEvent | RonEvent | TsumoEvent | DiscardEvent | DrawEvent | ReachEvent | NewDoraEvent | ChoiceAfterDrawnEvent | ChoiceAfterDiscardedEvent | ChoiceAfterCalled | ChoiceForChanKan;
+
+export declare interface PlayerProps {
+    id: string;
+    handler: EventHandler;
+}
+
+export declare const prevRound: (r: Round) => "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4";
+
+export declare const prevWind: (w: Wind) => Wind;
+
+export declare function prioritizeDiscardedEvents(events: ChoiceAfterDiscardedEvent[]): {
+    events: ChoiceAfterDiscardedEvent[];
+    type: boolean | keyof DiscardedChoice;
+};
+
+export declare function prioritizeDrawnEvents(events: ChoiceAfterDrawnEvent[]): {
+    events: ChoiceAfterDrawnEvent[];
+    type: boolean | keyof DrawnChoice;
+};
+
+export declare interface ReachEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "REACH">;
+    tile: string;
+    iam: Wind;
+    wind: Wind;
+}
+
+export declare class Replayer {
+    index: number;
+    histories: History_2[];
+    constructor(v: string);
+    next(): void;
+    prev(): void;
+    start(): void;
+    auto(): void;
+}
+
+export declare class RiskRank {
+    static selectTile(c: Counter, targetUsers: Wind[], tiles: Tile[]): Tile;
+    static rank(c: Counter, targetUsers: Wind[], t: Tile): number;
+    static rankZ(c: Counter, targetUser: Wind, t: Tile): number;
+    static rankN(c: Counter, targetUser: Wind, t: Tile): 0 | 5 | 3 | 4 | 6 | 8 | 12;
+}
+
+export declare class River {
+    private m;
+    constructor();
+    discard(t: Tile, w: Wind): void;
+    get lastTile(): {
+        w: Wind;
+        t: Tile;
+        callMarker?: boolean;
+    };
+    discards(w?: Wind): {
+        w: Wind;
+        t: Tile;
+        callMarker?: boolean;
+    }[];
+    markCalled(): void;
+    cannotContinue(): boolean;
+}
+
+export declare interface RonEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "RON">;
+    iam: Wind;
+    wind: Wind;
+    ret: SerializedWinResult;
+    victimInfo: {
+        wind: Wind;
+        tile: string;
+    };
+    pushBackReachStick: boolean;
+}
+
+export declare type Round = keyof typeof ROUND_MAP;
+
+export declare const ROUND_MAP: {
+    readonly "1w1": "東１局";
+    readonly "1w2": "東２局";
+    readonly "1w3": "東３局";
+    readonly "1w4": "東４局";
+    readonly "2w1": "南１局";
+    readonly "2w2": "南２局";
+    readonly "2w3": "南３局";
+    readonly "2w4": "南４局";
+    readonly "3w1": "西1局";
+    readonly "3w2": "西2局";
+    readonly "3w3": "西3局";
+    readonly "3w4": "西4局";
+    readonly "4w1": "北1局";
+    readonly "4w2": "北2局";
+    readonly "4w3": "北3局";
+    readonly "4w4": "北４局";
+};
+
+export declare interface ScoreBoardInput {
+    doras: Tile[];
+    round: BoardRound;
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    scores: {
+        front: number;
+        right: number;
+        opposite: number;
+        left: number;
+    };
+    frontPlace: BoardWind;
+}
+
+export declare class ScoreManager {
+    private reachValue;
+    private m;
+    constructor(initial: {
+        [key: string]: number;
+    });
+    get summary(): {
+        [key: string]: number;
+    };
+    reach(id: string): void;
+    /**
+     * 立直後のロンに対する立直棒の戻し
+     */
+    restoreReachStick(id: string): void;
+    update(result: {
+        "1w": number;
+        "2w": number;
+        "3w": number;
+        "4w": number;
+    }, windMap: {
+        [key: string]: Wind;
+    }): void;
+}
+
+declare type Separator = typeof INPUT_SEPARATOR;
+
+export declare type SerializedBlock = ReturnType<Block["serialize"]>;
+
+declare type SerializedBoardContext = Omit<BoardContext, "doraMarkers" | "blindDoraMarkers"> & {
+    doraMarkers: string[];
+    blindDoraMarkers?: string[];
+};
+
+export declare interface SerializedCandidate {
+    tile: string;
+    candidates: readonly string[];
+    shanten: number;
+}
+
+export declare type SerializedWinResult = Omit<WinResult, "hand" | "boardContext"> & {
+    hand: SerializedBlock[];
+    boardContext: SerializedBoardContext;
+};
+
+export declare class ShantenCalculator {
+    hand: Hand;
+    constructor(hand: Hand);
+    calc(): number;
+    sevenPairs(): number;
+    thirteenOrphans(): number;
+    fourSetsOnePair(): number;
+    private commonByType;
+    private groupRemainingTiles;
+    private calcCommon;
+}
+
+export declare function shuffle<T>(array: T[]): T[];
+
+export declare const TABLE_CONTEXT: {
+    BASE: number;
+};
+
+export declare type TableInput = InferOutput<typeof tableInputSchema>;
+
+declare const tableInputSchema: StrictObjectSchema<    {
+readonly board: StrictObjectSchema<    {
+readonly round: OptionalSchema<PicklistSchema<("1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4")[], undefined>, "1w1">;
+readonly sticks: OptionalSchema<StrictObjectSchema<    {
+readonly reach: OptionalSchema<SchemaWithPipe<[NumberSchema<undefined>, MinValueAction<number, 0, "">, MaxValueAction<number, 9, "">]>, 0>;
+readonly dead: OptionalSchema<SchemaWithPipe<[NumberSchema<undefined>, MinValueAction<number, 0, "">, MaxValueAction<number, 9, "">]>, 0>;
+}, undefined>, {
+readonly reach: 0;
+readonly dead: 0;
+}>;
+readonly doras: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, readonly ["3w"]>;
+readonly front: OptionalSchema<PicklistSchema<("1w" | "2w" | "3w" | "4w")[], undefined>, "1w">;
+}, undefined>;
+readonly "1w": OptionalSchema<StrictObjectSchema<    {
+readonly discard: OptionalSchema<StringSchema<undefined>, "">;
+readonly hand: OptionalSchema<StringSchema<undefined>, "">;
+readonly score: OptionalSchema<NumberSchema<undefined>, 25000>;
+}, undefined>, {
+readonly discard: "";
+readonly hand: "";
+readonly score: 25000;
+}>;
+readonly "2w": OptionalSchema<StrictObjectSchema<    {
+readonly discard: OptionalSchema<StringSchema<undefined>, "">;
+readonly hand: OptionalSchema<StringSchema<undefined>, "">;
+readonly score: OptionalSchema<NumberSchema<undefined>, 25000>;
+}, undefined>, {
+readonly discard: "";
+readonly hand: "";
+readonly score: 25000;
+}>;
+readonly "3w": OptionalSchema<StrictObjectSchema<    {
+readonly discard: OptionalSchema<StringSchema<undefined>, "">;
+readonly hand: OptionalSchema<StringSchema<undefined>, "">;
+readonly score: OptionalSchema<NumberSchema<undefined>, 25000>;
+}, undefined>, {
+readonly discard: "";
+readonly hand: "";
+readonly score: 25000;
+}>;
+readonly "4w": OptionalSchema<StrictObjectSchema<    {
+readonly discard: OptionalSchema<StringSchema<undefined>, "">;
+readonly hand: OptionalSchema<StringSchema<undefined>, "">;
+readonly score: OptionalSchema<NumberSchema<undefined>, 25000>;
+}, undefined>, {
+readonly discard: "";
+readonly hand: "";
+readonly score: 25000;
+}>;
+}, undefined>;
+
+export declare type TableRound = keyof typeof ROUND_MAP;
+
+export declare type TableWind = keyof typeof WIND_MAP;
+
+export declare class Tile {
+    readonly t: Type;
+    readonly n: number;
+    readonly ops: Operator[];
+    constructor(t: Type, n: number, ops?: Operator[]);
+    static from(s: string): Tile;
+    toString(): string;
+    toJSON(): string;
+    clone(override?: {
+        t?: Type;
+        n?: number;
+        remove?: Operator;
+        add?: Operator;
+    }): Tile;
+    has(op: Operator): boolean;
+    isNum(): boolean;
+    equals(t: Tile, ignoreRed?: boolean): boolean;
+    imageSize(scale: number): {
+        width: number;
+        height: number;
+        baseWidth: number;
+        baseHeight: number;
+    };
+}
+
+export declare const TILE_CONTEXT: {
+    WIDTH: number;
+    HEIGHT: number;
+    TEXT_SCALE: number;
+    BLOCK_MARGIN_SCALE: number;
+};
+
+export declare const tileSortFunc: (i: Tile, j: Tile) => number;
+
+export declare interface TsumoEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "TSUMO">;
+    iam: Wind;
+    wind: Wind;
+    lastTile: string;
+    ret: SerializedWinResult;
+}
+
+export declare type TupleOfSize<T, N extends number, R extends unknown[] = []> = R["length"] extends N ? R : TupleOfSize<T, N, [T, ...R]>;
+
+export declare const TYPE: {
+    readonly M: "m";
+    readonly P: "p";
+    readonly S: "s";
+    readonly Z: "z";
+    readonly BACK: "_";
+};
+
+export declare type Type = (typeof TYPE)[keyof typeof TYPE];
+
+export declare class Wall {
+    private walls;
+    private backup;
+    private openedDoraCount;
+    constructor(backup?: WallProps);
+    kan(): Tile;
+    draw(): Tile;
+    openDoraMarker(): Tile;
+    get doraMarkers(): Tile[];
+    get blindDoraMarkers(): Tile[];
+    get canKan(): boolean;
+    get canDraw(): boolean;
+    private init;
+    export(): WallProps;
+    static clone(walls: WallProps): WallProps;
+}
+
+export declare interface WallProps {
+    drawable: string[];
+    dead: string[];
+    replacement: string[];
+    doraMarkers: string[];
+    blindDoraMarkers: string[];
+}
+
+export declare const WIND: {
+    readonly EAST: "1w";
+    readonly SOUTH: "2w";
+    readonly WEST: "3w";
+    readonly NORTH: "4w";
+};
+
+export declare type Wind = keyof typeof WIND_MAP;
+
+export declare const WIND_MAP: {
+    readonly "1w": "東";
+    readonly "2w": "南";
+    readonly "3w": "西";
+    readonly "4w": "北";
+};
+
+export declare interface WinResult {
+    deltas: {
+        [w in Wind]: number;
+    };
+    sum: number;
+    fu: number;
+    points: {
+        name: string;
+        double: number;
+    }[];
+    point: number;
+    hand: Block[];
+    boardContext: BoardContext;
+}
+
+export { }