@konoui/mjimage 0.0.1 → 0.0.2

package/dist/mjs/lib/calculator/index.js

@@ -0,0 +1,1390 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleCalculator = exports.TileCalculator = exports.ExShantenCalculator = exports.ShantenCalculator = exports.Hand = void 0;
+var assert_1 = __importDefault(require("assert"));
+var constants_1 = require("../constants");
+var parser_1 = require("../parser");
+var Hand = (function () {
+    function Hand(input) {
+        var _a;
+        this.data = (_a = {},
+            _a[constants_1.KIND.M] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            _a[constants_1.KIND.P] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            _a[constants_1.KIND.S] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            _a[constants_1.KIND.Z] = [0, 0, 0, 0, 0, 0, 0, 0],
+            _a[constants_1.KIND.BACK] = [0],
+            _a.called = [],
+            _a.reached = false,
+            _a.tsumo = null,
+            _a);
+        this.init(input);
+    }
+    Hand.prototype.init = function (input) {
+        var blocks = new parser_1.Parser(input).parse();
+        for (var _i = 0, blocks_1 = blocks; _i < blocks_1.length; _i++) {
+            var b = blocks_1[_i];
+            if (b.isCalled()) {
+                this.data.called.push(b);
+                continue;
+            }
+            else if (b.is(constants_1.BLOCK.TSUMO)) {
+                var t = b.tiles[0];
+                this.inc([t]);
+                this.data.tsumo = t;
+                continue;
+            }
+            else if (b.is(constants_1.BLOCK.HAND)) {
+                this.inc(b.tiles);
+                continue;
+            }
+            else if (input.split("").every(function (v) { return v === constants_1.KIND.BACK; })) {
+                this.inc(b.tiles);
+                continue;
+            }
+            throw new Error("unexpected block ".concat(b.type, " ").concat(b.toString()));
+        }
+    };
+    Object.defineProperty(Hand.prototype, "hands", {
+        get: function () {
+            var tiles = [];
+            for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+                var k = _a[_i];
+                for (var n = 0; n < this.getArrayLen(k); n++) {
+                    var count = this.get(k, n);
+                    if (k != constants_1.KIND.Z && n == 5)
+                        count -= this.get(k, 0);
+                    for (var i = 0; i < count; i++) {
+                        tiles.push(new parser_1.Tile(k, n));
+                    }
+                }
+            }
+            if (this.drawn != null) {
+                var idx = tiles.findIndex(function (t) { return t.equals(t); });
+                (0, assert_1.default)(idx >= 0, "hand has drawn: ".concat(this.drawn, " but no tile in hands"));
+                tiles[idx].add(constants_1.OPERATOR.TSUMO);
+            }
+            (0, assert_1.default)(tiles.length > 0, "no tiles in hand ".concat(tiles.length, ", called: ").concat(this.called, ", data: ").concat(JSON.stringify(this.data, null, 2)));
+            return tiles;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Hand.prototype.toString = function () {
+        var c = "";
+        for (var _i = 0, _a = this.called; _i < _a.length; _i++) {
+            var b_1 = _a[_i];
+            c = "".concat(c, ",").concat(b_1.toString());
+        }
+        var tiles = this.hands;
+        var b = new parser_1.Block(tiles, constants_1.BLOCK.HAND).toString();
+        return "".concat(b).concat(c);
+    };
+    Object.defineProperty(Hand.prototype, "called", {
+        get: function () {
+            return this.data.called.concat();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Hand.prototype, "reached", {
+        get: function () {
+            return this.data.reached;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Hand.prototype, "drawn", {
+        get: function () {
+            return this.data.tsumo;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Hand.prototype, "menzen", {
+        get: function () {
+            return this.called.some(function (v) { return !(v instanceof parser_1.BlockAnKan); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Hand.prototype.getArrayLen = function (k) {
+        return this.data[k].length;
+    };
+    Hand.prototype.sum = function (k) {
+        var sum = 0;
+        for (var n = 1; n < this.getArrayLen(k); n++)
+            sum += this.get(k, n);
+        return sum;
+    };
+    Hand.prototype.get = function (k, n) {
+        return this.data[k][n];
+    };
+    Hand.prototype.inc = function (tiles) {
+        var backup = [];
+        for (var _i = 0, tiles_1 = tiles; _i < tiles_1.length; _i++) {
+            var t = tiles_1[_i];
+            if (t.k != constants_1.KIND.BACK && this.get(t.k, t.n) > 4) {
+                this.dec(backup);
+                throw new Error("unable to increase ".concat(t, " in ").concat(this.toString()));
+            }
+            backup.push(t);
+            if (!(t.k == constants_1.KIND.Z || t.k == constants_1.KIND.BACK) && t.n == 0) {
+                this.data[t.k][5] += 1;
+            }
+            this.data[t.k][t.n] += 1;
+            if (t.k != constants_1.KIND.Z &&
+                t.n == 5 &&
+                this.get(t.k, 5) == 4 &&
+                this.get(t.k, 0) == 0) {
+                this.data[t.k][0] = 1;
+                var c = backup.pop().clone();
+                c.n = 0;
+                backup.push(c);
+            }
+        }
+        return backup;
+    };
+    Hand.prototype.dec = function (tiles) {
+        if (this.hands.every(function (t) { return t.k == constants_1.KIND.BACK; })) {
+            var toRemove = tiles.map(function (v) { return new parser_1.Tile(constants_1.KIND.BACK, 0); });
+            this.data[constants_1.KIND.BACK][0] -= tiles.length;
+            return toRemove;
+        }
+        var backup = [];
+        for (var _i = 0, tiles_2 = tiles; _i < tiles_2.length; _i++) {
+            var t = tiles_2[_i];
+            if (this.get(t.k, t.n) < 1) {
+                this.inc(backup);
+                throw new Error("unable to decrease ".concat(t.toString(), " in ").concat(this.toString()));
+            }
+            backup.push(t);
+            if (!(t.k == constants_1.KIND.Z || t.k == constants_1.KIND.BACK) && t.n == 0) {
+                this.data[t.k][5] -= 1;
+            }
+            this.data[t.k][t.n] -= 1;
+            if (t.k != constants_1.KIND.Z &&
+                t.n == 5 &&
+                this.get(t.k, 5) == 0 &&
+                this.get(t.k, 0) > 0) {
+                this.data[t.k][0] = 0;
+                var c = backup.pop().clone();
+                c.n = 0;
+                backup.push(c);
+            }
+        }
+        return backup;
+    };
+    Hand.prototype.draw = function (t) {
+        t.add(constants_1.OPERATOR.TSUMO);
+        this.inc([t]);
+        this.data.tsumo = t;
+        return;
+    };
+    Hand.prototype.discard = function (t) {
+        this.dec([t]);
+        this.data.tsumo = null;
+        return;
+    };
+    Hand.prototype.reach = function () {
+        if (!this.canReach)
+            throw new Error("cannot reach");
+        if (this.data.reached)
+            throw new Error("already reached");
+        this.data.reached = true;
+    };
+    Hand.prototype.call = function (b) {
+        if (!(b instanceof parser_1.BlockPon ||
+            b instanceof parser_1.BlockChi ||
+            b instanceof parser_1.BlockDaiKan))
+            throw new Error("unexpected input ".concat(b, " ").concat(b.type));
+        var toRemove = b.tiles.filter(function (v) { return !v.has(constants_1.OPERATOR.HORIZONTAL); });
+        if (toRemove.length != b.tiles.length - 1)
+            throw new Error("removal: ".concat(toRemove, " block: ").concat(b));
+        this.dec(toRemove);
+        this.data.called.push(b);
+        this.data.tsumo = null;
+        return;
+    };
+    Hand.prototype.kan = function (b) {
+        if (b instanceof parser_1.BlockAnKan) {
+            var t = b.tiles.filter(function (v) { return v.k != constants_1.KIND.BACK && v.n != 0; });
+            this.dec([t[0], t[0], t[0], t[0]]);
+            this.data.called.push(b);
+            this.data.tsumo = null;
+            return;
+        }
+        if (b instanceof parser_1.BlockShoKan) {
+            var idx = this.data.called.findIndex(function (v) { return v.is(constants_1.BLOCK.PON) && v.tiles[0].equals(b.tiles[0], true); });
+            if (idx == -1)
+                throw new Error("unable to find ".concat(b.tiles[0]));
+            var t = b.tiles[0].clone();
+            if (t.isNum() && t.n == 0) {
+                t = new parser_1.Tile(t.k, 5);
+            }
+            this.data.called.splice(idx, 1);
+            this.dec([t]);
+            this.data.called.push(b);
+            this.data.tsumo = null;
+            return;
+        }
+        throw new Error("unexpected input ".concat(b));
+    };
+    Object.defineProperty(Hand.prototype, "canReach", {
+        get: function () {
+            return this.called.filter(function (b) { return !(b instanceof parser_1.BlockAnKan); }).length == 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Hand.prototype.clone = function () {
+        var c = new Hand(this.toString());
+        c.data.called = this.called.map(function (b) { return b.clone(); });
+        c.data.reached = this.data.reached;
+        c.data.tsumo = this.data.tsumo == null ? null : this.data.tsumo.clone();
+        return c;
+    };
+    return Hand;
+}());
+exports.Hand = Hand;
+var ShantenCalculator = (function () {
+    function ShantenCalculator(hand) {
+        this.hand = hand;
+    }
+    ShantenCalculator.prototype.calc = function () {
+        return Math.min(this.sevenPairs(), this.thirteenOrphans(), this.fourSetsOnePair());
+    };
+    ShantenCalculator.prototype.sevenPairs = function () {
+        if (this.hand.called.length > 0)
+            return Infinity;
+        var nPairs = 0;
+        var nIsolated = 0;
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            for (var n = 1; n < this.hand.getArrayLen(k); n++) {
+                if (this.hand.get(k, n) == 2)
+                    nPairs++;
+                if (this.hand.get(k, n) == 1)
+                    nIsolated++;
+            }
+        }
+        if (nPairs > 7)
+            nPairs = 7;
+        if (nPairs + nIsolated >= 7)
+            nIsolated = 7 - nPairs;
+        return 13 - 2 * nPairs - nIsolated;
+    };
+    ShantenCalculator.prototype.thirteenOrphans = function () {
+        if (this.hand.called.length > 0)
+            return Infinity;
+        var nOrphans = 0;
+        var nPairs = 0;
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            if (k == constants_1.KIND.BACK)
+                continue;
+            var nn = k == constants_1.KIND.Z ? [1, 2, 3, 4, 5, 6, 7] : [1, 9];
+            for (var _b = 0, nn_1 = nn; _b < nn_1.length; _b++) {
+                var n = nn_1[_b];
+                if (this.hand.get(k, n) >= 1)
+                    nOrphans++;
+                if (this.hand.get(k, n) >= 2)
+                    nPairs++;
+            }
+        }
+        return nPairs >= 1 ? 12 - nOrphans : 13 - nOrphans;
+    };
+    ShantenCalculator.prototype.fourSetsOnePair = function () {
+        var _this = this;
+        var calc = function (hasPair) {
+            var z = [0, 0, 0];
+            var k = constants_1.KIND.Z;
+            for (var n = 1; n < _this.hand.getArrayLen(k); n++) {
+                if (_this.hand.get(k, n) >= 3)
+                    z[0]++;
+                else if (_this.hand.get(k, n) == 2)
+                    z[1]++;
+                else if (_this.hand.get(k, n) == 1)
+                    z[2]++;
+            }
+            var min = 13;
+            var mr = _this.commonByKind(constants_1.KIND.M);
+            var pr = _this.commonByKind(constants_1.KIND.P);
+            var sr = _this.commonByKind(constants_1.KIND.S);
+            for (var _i = 0, _a = [mr.patternA, mr.patternB]; _i < _a.length; _i++) {
+                var m = _a[_i];
+                for (var _b = 0, _c = [pr.patternA, pr.patternB]; _b < _c.length; _b++) {
+                    var p = _c[_b];
+                    for (var _d = 0, _e = [sr.patternA, sr.patternB]; _d < _e.length; _d++) {
+                        var s = _e[_d];
+                        var v = [_this.hand.called.length, 0, 0];
+                        for (var i = 0; i < 3; i++) {
+                            v[i] += m[i] + p[i] + s[i] + z[i];
+                        }
+                        var r = _this.calcCommon(v[0], v[1], v[2], hasPair);
+                        if (r < min) {
+                            min = r;
+                        }
+                    }
+                }
+            }
+            return min;
+        };
+        var min = calc(false);
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            for (var n = 1; n < this.hand.getArrayLen(k); n++) {
+                if (this.hand.get(k, n) >= 2) {
+                    var tiles = this.hand.dec([new parser_1.Tile(k, n), new parser_1.Tile(k, n)]);
+                    var r = calc(true);
+                    this.hand.inc(tiles);
+                    if (r < min) {
+                        min = r;
+                    }
+                }
+            }
+        }
+        return min;
+    };
+    ShantenCalculator.prototype.commonByKind = function (k, n) {
+        if (n === void 0) { n = 1; }
+        if (n > 9)
+            return this.groupRemainingTiles(k);
+        var max = this.commonByKind(k, n + 1);
+        if (n <= 7 &&
+            this.hand.get(k, n) > 0 &&
+            this.hand.get(k, n + 1) > 0 &&
+            this.hand.get(k, n + 2) > 0) {
+            var tiles = this.hand.dec([
+                new parser_1.Tile(k, n),
+                new parser_1.Tile(k, n + 1),
+                new parser_1.Tile(k, n + 2),
+            ]);
+            var r = this.commonByKind(k, n);
+            this.hand.inc(tiles);
+            r.patternA[0]++, r.patternB[0]++;
+            if (r.patternA[2] < max.patternA[2] ||
+                (r.patternA[2] == max.patternA[2] && r.patternA[1] < max.patternA[1])) {
+                max.patternA = r.patternA;
+            }
+            if (r.patternB[0] > max.patternB[0] ||
+                (r.patternB[0] == max.patternB[0] && r.patternB[1] > max.patternB[1])) {
+                max.patternB = r.patternB;
+            }
+        }
+        if (this.hand.get(k, n) >= 3) {
+            var tiles = this.hand.dec([
+                new parser_1.Tile(k, n),
+                new parser_1.Tile(k, n),
+                new parser_1.Tile(k, n),
+            ]);
+            var r = this.commonByKind(k, n);
+            this.hand.inc(tiles);
+            r.patternA[0]++, r.patternB[0]++;
+            if (r.patternA[2] < max.patternA[2] ||
+                (r.patternA[2] == max.patternA[2] && r.patternA[1] < max.patternA[1])) {
+                max.patternA = r.patternA;
+            }
+            if (r.patternB[0] > max.patternB[0] ||
+                (r.patternB[0] == max.patternB[0] && r.patternB[1] > max.patternB[1])) {
+                max.patternB = r.patternB;
+            }
+        }
+        return max;
+    };
+    ShantenCalculator.prototype.groupRemainingTiles = function (k) {
+        var nSerialPairs = 0;
+        var nIsolated = 0;
+        var nTiles = 0;
+        for (var n = 1; n < this.hand.getArrayLen(k); n++) {
+            nTiles += this.hand.get(k, n);
+            if (n <= 7 &&
+                this.hand.get(k, n + 1) == 0 &&
+                this.hand.get(k, n + 2) == 0) {
+                nSerialPairs += nTiles >> 1;
+                nIsolated += nTiles % 2;
+                nTiles = 0;
+            }
+        }
+        nSerialPairs += nTiles >> 1;
+        nIsolated += nTiles % 2;
+        return {
+            patternA: [0, nSerialPairs, nIsolated],
+            patternB: [0, nSerialPairs, nIsolated],
+        };
+    };
+    ShantenCalculator.prototype.calcCommon = function (nSet, nSerialPair, nIsolated, hasPair) {
+        var n = hasPair ? 4 : 5;
+        if (nSet > 4) {
+            nSerialPair += nSet - 4;
+            nSet = 4;
+        }
+        if (nSet + nSerialPair > 4) {
+            nIsolated += nSet + nSerialPair - 4;
+            nSerialPair = 4 - nSet;
+        }
+        if (nSet + nSerialPair + nIsolated > n) {
+            nIsolated = n - nSet - nSerialPair;
+        }
+        if (hasPair)
+            nSerialPair++;
+        return 13 - nSet * 3 - nSerialPair * 2 - nIsolated;
+    };
+    return ShantenCalculator;
+}());
+exports.ShantenCalculator = ShantenCalculator;
+var ExShantenCalculator = (function () {
+    function ExShantenCalculator(h) {
+        this.h = h;
+        this.c = new ShantenCalculator(h);
+    }
+    ExShantenCalculator.prototype.menzen = function () {
+        return this.h.menzen ? this.c.calc() : Number.POSITIVE_INFINITY;
+    };
+    ExShantenCalculator.prototype.yakuhai = function () {
+        var three = 0;
+        var vPon = null;
+        for (var _i = 0, _a = [1, 2, 3, 4, 5, 6, 7]; _i < _a.length; _i++) {
+            var n = _a[_i];
+            if (this.h.get(constants_1.KIND.Z, n) >= 3)
+                three++;
+            else if (this.h.get(constants_1.KIND.Z, n) == 2) {
+                var t = new parser_1.Tile(constants_1.KIND.Z, n);
+                vPon = new parser_1.BlockPon([t, t.clone(), t.clone()]);
+            }
+            else
+                for (var _b = 0, _c = this.h.called; _b < _c.length; _b++) {
+                    var b = _c[_b];
+                    if (b.tiles[0].k == constants_1.KIND.Z && b.tiles[0].n == n)
+                        three++;
+                }
+        }
+        if (three > 0)
+            return this.c.calc();
+        if (vPon) {
+            var cloned = this.h.clone();
+            cloned.call(vPon);
+            return new ShantenCalculator(cloned).calc() + 1;
+        }
+        return Number.POSITIVE_INFINITY;
+    };
+    ExShantenCalculator.prototype.tanyao = function () { };
+    return ExShantenCalculator;
+}());
+exports.ExShantenCalculator = ExShantenCalculator;
+var TileCalculator = (function () {
+    function TileCalculator(hand) {
+        this.hand = hand;
+    }
+    TileCalculator.prototype.calc = function (lastTile) {
+        if (this.hand.drawn != null)
+            lastTile = this.hand.drawn;
+        return this.markDrawn(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], this.sevenPairs(), true), this.thirteenOrphans(), true), this.nineGates(), true), this.fourSetsOnePair(), true), lastTile);
+    };
+    TileCalculator.prototype.markDrawn = function (hands, lastTile) {
+        if (hands.length == 0)
+            return [];
+        var op = this.hand.drawn != null
+            ? constants_1.OPERATOR.TSUMO
+            : lastTile.has(constants_1.OPERATOR.TSUMO)
+                ? constants_1.OPERATOR.TSUMO
+                : constants_1.OPERATOR.RON;
+        var indexes = [];
+        for (var i = 0; i < hands.length; i++) {
+            var hand = hands[i];
+            var m = {};
+            for (var j = 0; j < hand.length; j++) {
+                var block = hand[j];
+                if (block.isCalled())
+                    continue;
+                var k = block.tiles.findIndex(function (t) { return t.equals(lastTile, true); });
+                if (k < 0)
+                    continue;
+                var key = buildKey(block);
+                if (m[key])
+                    continue;
+                m[key] = true;
+                indexes.push([i, j, k]);
+            }
+        }
+        if (indexes.length == 0)
+            throw new Error("found no tile ".concat(lastTile.toString(), " in hands ").concat(hands[0].toString()));
+        var newHands = [];
+        for (var _i = 0, indexes_1 = indexes; _i < indexes_1.length; _i++) {
+            var _a = indexes_1[_i], hidx = _a[0], bidx = _a[1], tidx = _a[2];
+            var hand = hands[hidx];
+            var newHand = hand.map(function (block) { return block.clone(); });
+            newHand[bidx].tiles[tidx].add(op);
+            newHands.push(newHand);
+        }
+        return newHands;
+    };
+    TileCalculator.prototype.sevenPairs = function () {
+        if (this.hand.called.length > 0)
+            return [];
+        var ret = [];
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            if (k == constants_1.KIND.BACK)
+                continue;
+            for (var n = 1; n < this.hand.getArrayLen(k); n++) {
+                var v = this.hand.get(k, n);
+                if (v == 2)
+                    ret.push(new parser_1.BlockPair(new parser_1.Tile(k, n), new parser_1.Tile(k, n)));
+                else if (v == 0)
+                    continue;
+                else
+                    return [];
+            }
+        }
+        return [ret];
+    };
+    TileCalculator.prototype.thirteenOrphans = function () {
+        var ret = [];
+        var pairs = "";
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            if (k == constants_1.KIND.BACK)
+                continue;
+            var nn = k == constants_1.KIND.Z ? [1, 2, 3, 4, 5, 6, 7] : [1, 9];
+            for (var _b = 0, nn_2 = nn; _b < nn_2.length; _b++) {
+                var n = nn_2[_b];
+                if (this.hand.get(k, n) == 1)
+                    ret.push(new parser_1.BlockIsolated(new parser_1.Tile(k, n)));
+                else if (this.hand.get(k, n) == 2 && pairs == "")
+                    ret.unshift(new parser_1.BlockPair(new parser_1.Tile(k, n), new parser_1.Tile(k, n)));
+                else
+                    return [];
+            }
+        }
+        return [ret];
+    };
+    TileCalculator.prototype.nineGates = function () {
+        var _this = this;
+        var cond = function (k, n, want) {
+            return want.includes(_this.hand.get(k, n));
+        };
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            if (k == constants_1.KIND.BACK)
+                continue;
+            if (k == constants_1.KIND.Z)
+                continue;
+            var cond1 = cond(k, 1, [3, 4]) &&
+                cond(k, 9, [3, 4]) &&
+                cond(k, 2, [1, 2]) &&
+                cond(k, 3, [1, 2]) &&
+                cond(k, 4, [1, 2]) &&
+                cond(k, 5, [1, 2]) &&
+                cond(k, 6, [1, 2]) &&
+                cond(k, 7, [1, 2]) &&
+                cond(k, 8, [1, 2]);
+            var cond2 = this.hand.sum(k) == 14;
+            if (cond1 && cond2) {
+                return [[new parser_1.Block(this.hand.hands, constants_1.BLOCK.HAND)]];
+            }
+        }
+        return [];
+    };
+    TileCalculator.prototype.fourSetsOnePair = function () {
+        var ret = [];
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            if (k == constants_1.KIND.BACK)
+                continue;
+            var _loop_1 = function (n) {
+                if (this_1.hand.get(k, n) >= 2) {
+                    var tiles_3 = this_1.hand.dec([new parser_1.Tile(k, n), new parser_1.Tile(k, n)]);
+                    var v = this_1.commonAll()
+                        .filter(function (arr) { return arr.length == 4; })
+                        .map(function (arr) {
+                        arr.unshift(new parser_1.BlockPair(tiles_3[0], tiles_3[1]));
+                        return arr;
+                    });
+                    ret = __spreadArray(__spreadArray([], ret, true), v, true);
+                    this_1.hand.inc(tiles_3);
+                }
+            };
+            var this_1 = this;
+            for (var n = 1; n < this.hand.getArrayLen(k); n++) {
+                _loop_1(n);
+            }
+        }
+        return ret;
+    };
+    TileCalculator.prototype.commonAll = function () {
+        var _this = this;
+        var handleZ = function () {
+            var z = [];
+            var k = constants_1.KIND.Z;
+            for (var n = 1; n < _this.hand.getArrayLen(k); n++) {
+                if (_this.hand.get(k, n) == 0)
+                    continue;
+                else if (_this.hand.get(k, n) != 3)
+                    return [];
+                z.push(new parser_1.BlockThree([new parser_1.Tile(k, n), new parser_1.Tile(k, n), new parser_1.Tile(k, n)]));
+            }
+            return z.length == 0 ? [] : [z];
+        };
+        var vvv = [
+            this.commonByKind(constants_1.KIND.M),
+            this.commonByKind(constants_1.KIND.P),
+            this.commonByKind(constants_1.KIND.S),
+            handleZ(),
+            [this.hand.called],
+        ].sort(function (a, b) { return b.length - a.length; });
+        var ret = vvv[0].concat();
+        for (var i = 0; i < ret.length; i++) {
+            for (var j = 1; j < vvv.length; j++) {
+                for (var _i = 0, _a = vvv[j]; _i < _a.length; _i++) {
+                    var arr = _a[_i];
+                    ret[i] = __spreadArray(__spreadArray([], ret[i], true), arr, true);
+                }
+            }
+        }
+        return ret;
+    };
+    TileCalculator.prototype.commonByKind = function (k, n) {
+        if (n === void 0) { n = 1; }
+        if (n > 9)
+            return [];
+        if (this.hand.get(k, n) == 0)
+            return this.commonByKind(k, n + 1);
+        var ret = [];
+        if (n <= 7 &&
+            this.hand.get(k, n) > 0 &&
+            this.hand.get(k, n + 1) > 0 &&
+            this.hand.get(k, n + 2) > 0) {
+            var tiles = this.hand.dec([
+                new parser_1.Tile(k, n),
+                new parser_1.Tile(k, n + 1),
+                new parser_1.Tile(k, n + 2),
+            ]);
+            var nested = this.commonByKind(k, n);
+            this.hand.inc(tiles);
+            if (nested.length == 0)
+                nested.push([]);
+            for (var _i = 0, nested_1 = nested; _i < nested_1.length; _i++) {
+                var arr = nested_1[_i];
+                arr.unshift(new parser_1.BlockRun([tiles[0], tiles[1], tiles[2]]));
+                ret.push(arr);
+            }
+        }
+        if (this.hand.get(k, n) == 3) {
+            var tiles = this.hand.dec([
+                new parser_1.Tile(k, n),
+                new parser_1.Tile(k, n),
+                new parser_1.Tile(k, n),
+            ]);
+            var nested = this.commonByKind(k, n);
+            this.hand.inc(tiles);
+            if (nested.length == 0)
+                nested.push([]);
+            for (var _a = 0, nested_2 = nested; _a < nested_2.length; _a++) {
+                var arr = nested_2[_a];
+                arr.unshift(new parser_1.BlockThree([tiles[0], tiles[1], tiles[2]]));
+                ret.push(arr);
+            }
+        }
+        return ret;
+    };
+    return TileCalculator;
+}());
+exports.TileCalculator = TileCalculator;
+var DoubleCalculator = (function () {
+    function DoubleCalculator(hand, params) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.hand = hand;
+        this.cfg = {
+            doras: params.doraMarkers.map(function (v) { return toDora(v); }),
+            blindDoras: params.blindDoraMarkers == null
+                ? []
+                : params.blindDoraMarkers.map(function (v) { return toDora(v); }),
+            roundWind: new parser_1.Parser(params.round.substring(0, 2)).parse()[0].tiles[0],
+            myWind: new parser_1.Parser(params.myWind).parse()[0].tiles[0],
+            reached: (_a = params.reached) !== null && _a !== void 0 ? _a : 0,
+            sticks: (_b = params.sticks) !== null && _b !== void 0 ? _b : { dead: 0, reach: 0 },
+            replacementWin: (_c = params.replacementWin) !== null && _c !== void 0 ? _c : false,
+            quadWin: (_d = params.quadWin) !== null && _d !== void 0 ? _d : false,
+            finalWallWin: (_e = params.finalWallWin) !== null && _e !== void 0 ? _e : false,
+            finalDiscardWin: (_f = params.finalDiscardWin) !== null && _f !== void 0 ? _f : false,
+            oneShotWin: (_g = params.oneShotWin) !== null && _g !== void 0 ? _g : false,
+            orig: params,
+        };
+    }
+    DoubleCalculator.prototype.calc = function (hands) {
+        var patterns = this.calcPatterns(hands);
+        if (patterns.length == 0)
+            return false;
+        var max = [0, 0];
+        var idx = 0;
+        for (var i = 0; i < patterns.length; i++) {
+            var pt = patterns[i];
+            var sum_1 = pt.points.reduce(function (a, b) {
+                return a + b.double;
+            }, 0);
+            if (sum_1 > max[0]) {
+                idx = i;
+                max[0] = sum_1;
+                max[1] = pt.fu;
+            }
+            else if (sum_1 == max[0] && pt.fu > max[1]) {
+                idx = i;
+                max[0] = sum_1;
+                max[1] = pt.fu;
+            }
+        }
+        var ceil = function (v, p) {
+            if (p === void 0) { p = 100; }
+            return Math.ceil(v / p) * p;
+        };
+        var fu = max[1] != 25 ? ceil(max[1], 10) : 25;
+        var sum = max[0];
+        var base = fu * Math.pow(2, (sum + 2));
+        switch (sum) {
+            case 26:
+                base = 16000;
+                break;
+            case 13:
+                base = 8000;
+                break;
+            case 12:
+            case 11:
+                base = 6000;
+                break;
+            case 10:
+            case 9:
+            case 8:
+                base = 6000;
+                break;
+            case 7:
+            case 6:
+                base = 4000;
+                break;
+            case 5:
+                base = 2000;
+                break;
+        }
+        if (sum > 13 && sum < 26)
+            base = 8000;
+        var isTsumo = patterns[idx].hand.some(function (b) {
+            return b.tiles.some(function (t) { return t.has(constants_1.OPERATOR.TSUMO); });
+        });
+        var myWind = this.cfg.orig.myWind;
+        var isParent = myWind == "1w";
+        var deltas = {
+            "1w": 0,
+            "2w": 0,
+            "3w": 0,
+            "4w": 0,
+        };
+        if (!isTsumo) {
+            var deadPoint = this.cfg.sticks.dead * 300;
+            if (this.cfg.orig.ronWind == null)
+                throw new Error("ron wind is not specified in the parameters");
+            var coefficient = isParent ? 6 : 4;
+            var point = ceil(base * coefficient) + deadPoint;
+            deltas[myWind] += point;
+            deltas[this.cfg.orig.ronWind] -= point;
+        }
+        else {
+            var deadPoint = this.cfg.sticks.dead * 100;
+            if (isParent) {
+                var point = ceil(base * 2);
+                deltas["1w"] += point * 3 + deadPoint * 3;
+                deltas["2w"] -= point + deadPoint;
+                deltas["3w"] -= point + deadPoint;
+                deltas["4w"] -= point + deadPoint;
+            }
+            else {
+                for (var _i = 0, _a = Object.values(constants_1.WIND); _i < _a.length; _i++) {
+                    var key = _a[_i];
+                    if (key == myWind)
+                        continue;
+                    var coefficient = key == "1w" ? 2 : 1;
+                    var point = ceil(base * coefficient) + deadPoint;
+                    deltas[key] -= point;
+                    deltas[myWind] += point;
+                }
+            }
+        }
+        deltas[myWind] += 1000 * this.cfg.sticks.reach;
+        var v = {
+            deltas: deltas,
+            sum: sum,
+            fu: fu,
+            points: patterns[idx].points,
+            point: deltas[myWind],
+            hand: patterns[idx].hand,
+            params: this.cfg.orig,
+        };
+        return v;
+    };
+    DoubleCalculator.prototype.calcPatterns = function (hands) {
+        var ret = [];
+        if (hands.length == 0)
+            return ret;
+        for (var _i = 0, hands_1 = hands; _i < hands_1.length; _i++) {
+            var hand = hands_1[_i];
+            var v = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], this.dA13(hand), true), this.dB13(hand), true), this.dC13(hand), true), this.dD13(hand), true), this.dE13(hand), true), this.dF13(hand), true), this.dG13(hand), true), this.dH13(hand), true), this.dI13(hand), true), this.dJ13(hand), true), this.dK13(hand), true);
+            if (v.length == 0)
+                continue;
+            ret.push({
+                points: v,
+                fu: 30,
+                hand: hand,
+            });
+        }
+        if (ret.length > 0)
+            return ret;
+        for (var _a = 0, hands_2 = hands; _a < hands_2.length; _a++) {
+            var hand = hands_2[_a];
+            var fu = this.calcFu(hand);
+            var v = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], this.dA1(hand), true), this.dB1(hand), true), this.dC1(hand), true), this.dD1(hand), true), this.dE1(hand), true), this.dF1(hand), true), this.dG1(hand), true), this.dH1(hand), true), this.dI1(hand), true), this.dJ1(hand), true), this.dK1(hand), true), this.dA2(hand), true), this.dB2(hand), true), this.dC2(hand), true), this.dD2(hand), true), this.dE2(hand), true), this.dF2(hand), true), this.dG2(hand), true), this.dH2(hand), true), this.dI2(hand), true), this.dJ2(hand), true), this.dA3(hand), true), this.dB3(hand), true), this.dC3(hand), true), this.dA6(hand), true);
+            if (v.length > 0)
+                v.push.apply(v, this.dX1(hand));
+            ret.push({
+                points: v,
+                fu: fu,
+                hand: hand,
+            });
+        }
+        return ret;
+    };
+    DoubleCalculator.prototype.minus = function () {
+        return this.hand.canReach ? 0 : 1;
+    };
+    DoubleCalculator.prototype.dA1 = function (h) {
+        if (this.cfg.reached == 1)
+            return [{ name: "立直", double: 1 }];
+        if (this.cfg.reached == 2)
+            return [{ name: "ダブルリーチ", double: 2 }];
+        return [];
+    };
+    DoubleCalculator.prototype.dB1 = function (h) {
+        if (this.minus() != 0)
+            return [];
+        if (this.hand.drawn == null)
+            [];
+        var cond = h.some(function (b) { return b.tiles.some(function (t) { return t.has(constants_1.OPERATOR.TSUMO); }); });
+        return cond ? [{ name: "門前清自摸和", double: 1 }] : [];
+    };
+    DoubleCalculator.prototype.dC1 = function (h) {
+        if (this.minus() != 0)
+            return [];
+        var fu = this.calcFu(h);
+        if (fu == 20)
+            return [{ name: "平和", double: 1 }];
+        if (!h.some(function (b) { return b.tiles.some(function (t) { return t.has(constants_1.OPERATOR.TSUMO); }); })) {
+            if (fu == 30)
+                return [{ name: "平和", double: 1 }];
+        }
+        return [];
+    };
+    DoubleCalculator.prototype.dD1 = function (h) {
+        var cond = h.some(function (block) {
+            return block.tiles.some(function (t) { return t.k == constants_1.KIND.Z || [1, 9].includes(t.n); });
+        });
+        return cond ? [] : [{ name: "断么九", double: 1 }];
+    };
+    DoubleCalculator.prototype.dE1 = function (h) {
+        if (this.minus() != 0)
+            return [];
+        var count = countSameBlocks(h);
+        return count == 1 ? [{ name: "一盃口", double: 1 }] : [];
+    };
+    DoubleCalculator.prototype.dF1 = function (h) {
+        var _this = this;
+        var ret = [];
+        h.forEach(function (block) {
+            if (block instanceof parser_1.BlockPair)
+                return;
+            var tile = block.tiles[0];
+            if (tile.k == constants_1.KIND.Z) {
+                if (tile.equals(_this.cfg.myWind))
+                    ret.push({ name: "自風", double: 1 });
+                if (tile.equals(_this.cfg.roundWind))
+                    ret.push({ name: "場風", double: 1 });
+                if (tile.n == 5)
+                    ret.push({ name: "白", double: 1 });
+                if (tile.n == 6)
+                    ret.push({ name: "發", double: 1 });
+                if (tile.n == 7)
+                    ret.push({ name: "中", double: 1 });
+            }
+        });
+        return ret;
+    };
+    DoubleCalculator.prototype.dG1 = function (h) {
+        return this.cfg.oneShotWin ? [{ name: "一発", double: 1 }] : [];
+    };
+    DoubleCalculator.prototype.dH1 = function (h) {
+        return this.cfg.replacementWin ? [{ name: "嶺上開花", double: 1 }] : [];
+    };
+    DoubleCalculator.prototype.dI1 = function (h) {
+        return this.cfg.quadWin ? [{ name: "搶槓", double: 1 }] : [];
+    };
+    DoubleCalculator.prototype.dJ1 = function (h) {
+        return this.cfg.finalWallWin ? [{ name: "海底摸月", double: 1 }] : [];
+    };
+    DoubleCalculator.prototype.dK1 = function (h) {
+        return this.cfg.finalDiscardWin ? [{ name: "河底撈魚", double: 1 }] : [];
+    };
+    DoubleCalculator.prototype.dX1 = function (h) {
+        var dcount = 0;
+        var rcount = 0;
+        var bcount = 0;
+        for (var _i = 0, h_1 = h; _i < h_1.length; _i++) {
+            var b = h_1[_i];
+            for (var _a = 0, _b = b.tiles; _a < _b.length; _a++) {
+                var t = _b[_a];
+                for (var _c = 0, _d = this.cfg.doras; _c < _d.length; _c++) {
+                    var d = _d[_c];
+                    if (t.equals(d, true))
+                        dcount++;
+                }
+                for (var _e = 0, _f = this.cfg.blindDoras; _e < _f.length; _e++) {
+                    var d = _f[_e];
+                    if (t.equals(d, true))
+                        bcount++;
+                }
+                if (t.n == 0)
+                    rcount++;
+            }
+        }
+        var ret = [];
+        if (dcount > 0)
+            ret.push({ name: "ドラ", double: dcount });
+        if (rcount > 0)
+            ret.push({ name: "赤ドラ", double: rcount });
+        if (this.hand.reached && bcount > 0)
+            ret.push({ name: "裏ドラ", double: bcount });
+        return ret;
+    };
+    DoubleCalculator.prototype.dA2 = function (h) {
+        return h.length == 7 ? [{ name: "七対子", double: 2 }] : [];
+    };
+    DoubleCalculator.prototype.dB2 = function (h) {
+        var check = function (bb) {
+            return bb instanceof parser_1.BlockRun || bb instanceof parser_1.BlockChi;
+        };
+        var _loop_2 = function (block) {
+            if (!check(block))
+                return "continue";
+            var tile = block.minTile();
+            if (tile.k == constants_1.KIND.Z)
+                return "continue";
+            var filteredKinds = [constants_1.KIND.M, constants_1.KIND.P, constants_1.KIND.S].filter(function (v) { return v != tile.k; });
+            var cond1 = h.some(function (b) {
+                var newTile = new parser_1.Tile(filteredKinds[0], tile.n);
+                return check(b) && newTile.equals(b.minTile(), true);
+            });
+            var cond2 = h.some(function (b) {
+                var newTile = new parser_1.Tile(filteredKinds[1], tile.n);
+                return check(b) && newTile.equals(b.minTile(), true);
+            });
+            if (cond1 && cond2)
+                return { value: [{ name: "三色同順", double: 2 - this_2.minus() }] };
+        };
+        var this_2 = this;
+        for (var _i = 0, h_2 = h; _i < h_2.length; _i++) {
+            var block = h_2[_i];
+            var state_1 = _loop_2(block);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+        return [];
+    };
+    DoubleCalculator.prototype.dC2 = function (h) {
+        if (h.length == 7)
+            return [];
+        var cond = h.every(function (b) {
+            return b instanceof parser_1.BlockAnKan ||
+                b instanceof parser_1.BlockShoKan ||
+                b instanceof parser_1.BlockDaiKan ||
+                b instanceof parser_1.BlockThree ||
+                b instanceof parser_1.BlockPon ||
+                b instanceof parser_1.BlockPair;
+        });
+        return cond ? [{ name: "対々和", double: 2 }] : [];
+    };
+    DoubleCalculator.prototype.dD2 = function (h) {
+        if (this.minus() != 0)
+            return [];
+        var l = h.filter(function (b) {
+            return ((b instanceof parser_1.BlockAnKan || b instanceof parser_1.BlockThree) &&
+                !b.tiles.some(function (t) { return t.has(constants_1.OPERATOR.RON); }));
+        }).length;
+        return l >= 3 ? [{ name: "三暗刻", double: 2 }] : [];
+    };
+    DoubleCalculator.prototype.dE2 = function (h) {
+        var l = h.filter(function (b) {
+            return b instanceof parser_1.BlockAnKan ||
+                b instanceof parser_1.BlockShoKan ||
+                b instanceof parser_1.BlockDaiKan;
+        }).length;
+        return l >= 3 ? [{ name: "三槓子", double: 2 }] : [];
+    };
+    DoubleCalculator.prototype.dF2 = function (h) {
+        var check = function (b) {
+            return (b instanceof parser_1.BlockAnKan ||
+                b instanceof parser_1.BlockShoKan ||
+                b instanceof parser_1.BlockDaiKan ||
+                b instanceof parser_1.BlockThree ||
+                b instanceof parser_1.BlockPon);
+        };
+        var _loop_3 = function (block) {
+            if (!check(block))
+                return "continue";
+            var tile = block.minTile();
+            if (tile.k == constants_1.KIND.Z)
+                return "continue";
+            var filteredKinds = [constants_1.KIND.M, constants_1.KIND.P, constants_1.KIND.S].filter(function (v) { return v != tile.k; });
+            var cond1 = h.some(function (b) {
+                var newTile = new parser_1.Tile(filteredKinds[0], tile.n);
+                return check(b) && newTile.equals(b.minTile(), true);
+            });
+            var cond2 = h.some(function (b) {
+                var newTile = new parser_1.Tile(filteredKinds[1], tile.n);
+                return check(b) && newTile.equals(b.minTile(), true);
+            });
+            if (cond1 && cond2)
+                return { value: [{ name: "三色同刻", double: 2 }] };
+        };
+        for (var _i = 0, h_3 = h; _i < h_3.length; _i++) {
+            var block = h_3[_i];
+            var state_2 = _loop_3(block);
+            if (typeof state_2 === "object")
+                return state_2.value;
+        }
+        return [];
+    };
+    DoubleCalculator.prototype.dG2 = function (h) {
+        var l = h.filter(function (b) {
+            var t = b.tiles[0];
+            return t.k == constants_1.KIND.Z && [5, 6, 7].includes(t.n);
+        }).length;
+        return l == 3 ? [{ name: "小三元", double: 2 }] : [];
+    };
+    DoubleCalculator.prototype.dH2 = function (h) {
+        var cond = h.every(function (b) {
+            var values = b.tiles[0].k == constants_1.KIND.Z ? [1, 2, 3, 4, 5, 6, 7] : [1, 9];
+            return b.tiles.every(function (t) { return values.includes(t.n); });
+        });
+        return cond ? [{ name: "混老頭", double: 2 }] : [];
+    };
+    DoubleCalculator.prototype.dI2 = function (h) {
+        if (!h.some(function (b) { return b instanceof parser_1.BlockRun; }) && !(h.length == 7))
+            return [];
+        if (!h.some(function (b) { return b.tiles[0].k == constants_1.KIND.Z; }))
+            return [];
+        var cond = h.every(function (block) {
+            var values = block.tiles[0].k == constants_1.KIND.Z ? [1, 2, 3, 4, 5, 6, 7] : [1, 9];
+            return block.tiles.some(function (t) { return values.includes(t.n); });
+        });
+        return cond ? [{ name: "混全帯么九", double: 2 - this.minus() }] : [];
+    };
+    DoubleCalculator.prototype.dJ2 = function (h) {
+        var _a;
+        if (this.minus() != 0)
+            return [];
+        var m = (_a = {},
+            _a[constants_1.KIND.M] = [0, 0, 0],
+            _a[constants_1.KIND.S] = [0, 0, 0],
+            _a[constants_1.KIND.P] = [0, 0, 0],
+            _a);
+        for (var _i = 0, h_4 = h; _i < h_4.length; _i++) {
+            var block = h_4[_i];
+            var tile = block.minTile();
+            if (tile.k == constants_1.KIND.BACK)
+                continue;
+            if (tile.k == constants_1.KIND.Z)
+                continue;
+            if (!(block instanceof parser_1.BlockRun))
+                continue;
+            if (tile.n == 1)
+                m[tile.k][0]++;
+            if (tile.n == 4)
+                m[tile.k][1]++;
+            if (tile.n == 7)
+                m[tile.k][2]++;
+        }
+        for (var _b = 0, _c = Object.values(m); _b < _c.length; _b++) {
+            var v = _c[_b];
+            if (v.filter(function (v) { return v > 0; }).length == v.length)
+                return [{ name: "一気通貫", double: 2 - this.minus() }];
+        }
+        return [];
+    };
+    DoubleCalculator.prototype.dA3 = function (h) {
+        var cond = !h.some(function (block) { return block.tiles[0].k == constants_1.KIND.Z; });
+        if (cond)
+            return [];
+        var _loop_4 = function (k) {
+            var ok = h.every(function (b) { return b.tiles[0].k == constants_1.KIND.Z || b.tiles[0].k == k; });
+            if (ok)
+                return { value: [{ name: "混一色", double: 3 - this_3.minus() }] };
+        };
+        var this_3 = this;
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            var state_3 = _loop_4(k);
+            if (typeof state_3 === "object")
+                return state_3.value;
+        }
+        return [];
+    };
+    DoubleCalculator.prototype.dB3 = function (h) {
+        if (!h.some(function (b) { return b instanceof parser_1.BlockRun; }) && !(h.length == 7))
+            return [];
+        if (h.some(function (b) { return b.tiles[0].k == constants_1.KIND.Z; }))
+            return [];
+        var cond = h.every(function (b) {
+            var values = b.tiles[0].k == constants_1.KIND.Z ? [1, 2, 3, 4, 5, 6, 7] : [1, 9];
+            return b.tiles.some(function (t) { return values.includes(t.n); });
+        });
+        return cond ? [{ name: "純全帯么九色", double: 3 - this.minus() }] : [];
+    };
+    DoubleCalculator.prototype.dC3 = function (h) {
+        if (this.minus() != 0)
+            return [];
+        var count = countSameBlocks(h);
+        return count == 2 ? [{ name: "ニ盃口", double: 3 }] : [];
+    };
+    DoubleCalculator.prototype.dA6 = function (h) {
+        if (h.some(function (block) { return block.tiles[0].k == constants_1.KIND.Z; }))
+            return [];
+        var _loop_5 = function (k) {
+            if (k == constants_1.KIND.Z)
+                return "continue";
+            var ok = h.every(function (v) { return v.tiles[0].k == k; });
+            if (ok)
+                return { value: [{ name: "清一色", double: 6 - this_4.minus() }] };
+        };
+        var this_4 = this;
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            var state_4 = _loop_5(k);
+            if (typeof state_4 === "object")
+                return state_4.value;
+        }
+        return [];
+    };
+    DoubleCalculator.prototype.dA13 = function (h) {
+        if (h.length != 13)
+            return [];
+        var double = h.some(function (b) {
+            return b instanceof parser_1.BlockPair &&
+                b.tiles.some(function (t) { return t.has(constants_1.OPERATOR.TSUMO) || t.has(constants_1.OPERATOR.RON); });
+        });
+        return double
+            ? [{ name: "国士無双13面待ち", double: 26 }]
+            : [{ name: "国士無双", double: 13 }];
+    };
+    DoubleCalculator.prototype.dB13 = function (h) {
+        return h.length == 1 ? [{ name: "九蓮宝燈", double: 13 }] : [];
+    };
+    DoubleCalculator.prototype.dC13 = function (h) {
+        if (h.length == 7)
+            return [];
+        var cond1 = h.every(function (b) {
+            return b instanceof parser_1.BlockAnKan ||
+                (b instanceof parser_1.BlockThree &&
+                    !b.tiles.some(function (t) { return t.has(constants_1.OPERATOR.RON); })) ||
+                b instanceof parser_1.BlockPair;
+        });
+        if (!cond1)
+            return [];
+        var cond2 = h.some(function (b) {
+            return b instanceof parser_1.BlockPair &&
+                b.tiles.every(function (t) { return t.has(constants_1.OPERATOR.TSUMO) || t.has(constants_1.OPERATOR.RON); });
+        });
+        return cond2
+            ? [{ name: "四暗刻単騎待ち", double: 26 }]
+            : [{ name: "四暗刻", double: 13 }];
+    };
+    DoubleCalculator.prototype.dD13 = function (h) {
+        if (h.length == 13)
+            return [];
+        var z = [5, 6, 7];
+        var cond = h.filter(function (b) {
+            return !(b instanceof parser_1.BlockPair) &&
+                b.tiles.some(function (t) { return t.k == constants_1.KIND.Z && z.includes(t.n); });
+        }).length == 3;
+        return cond ? [{ name: "大三元", double: 13 }] : [];
+    };
+    DoubleCalculator.prototype.dE13 = function (h) {
+        var cond = h.every(function (b) { return b.tiles.every(function (t) { return t.k == constants_1.KIND.Z; }); });
+        return cond ? [{ name: "字一色", double: 13 }] : [];
+    };
+    DoubleCalculator.prototype.dF13 = function (h) {
+        var cond = h.every(function (b) {
+            return b.tiles.every(function (t) { return t.k != constants_1.KIND.Z && [1, 9].includes(t.n); });
+        });
+        return cond ? [{ name: "清老頭", double: 13 }] : [];
+    };
+    DoubleCalculator.prototype.dG13 = function (h) {
+        var cond = h.filter(function (b) {
+            return b instanceof parser_1.BlockAnKan ||
+                b instanceof parser_1.BlockShoKan ||
+                b instanceof parser_1.BlockDaiKan;
+        }).length == 4;
+        return cond ? [{ name: "四槓子", double: 13 }] : [];
+    };
+    DoubleCalculator.prototype.dH13 = function (h) {
+        if (h.length == 13)
+            return [];
+        if (h.length == 7)
+            return [];
+        var zn = [1, 2, 3, 4];
+        var cond1 = h.filter(function (b) { return b.tiles.some(function (t) { return t.k == constants_1.KIND.Z && zn.includes(t.n); }); })
+            .length == 4;
+        if (!cond1)
+            return [];
+        var cond2 = h
+            .find(function (b) { return b instanceof parser_1.BlockPair; })
+            .tiles.some(function (t) { return t.k == constants_1.KIND.Z && zn.includes(t.n); });
+        return cond2
+            ? [{ name: "小四喜", double: 13 }]
+            : [{ name: "大四喜", double: 13 }];
+    };
+    DoubleCalculator.prototype.dI13 = function (h) {
+        var check = function (t) {
+            if (t.equals(new parser_1.Tile(constants_1.KIND.Z, 6)))
+                return true;
+            if (t.k == constants_1.KIND.S && [2, 3, 4, 6, 8].includes(t.n))
+                return true;
+            return false;
+        };
+        return h.every(function (b) { return b.tiles.every(function (t) { return check(t); }); })
+            ? [{ name: "緑一色", double: 13 }]
+            : [];
+    };
+    DoubleCalculator.prototype.dJ13 = function (h) {
+        return [];
+    };
+    DoubleCalculator.prototype.dK13 = function (h) {
+        return [];
+    };
+    DoubleCalculator.prototype.calcFu = function (h) {
+        var base = 20;
+        var fu = base;
+        var myWind = this.cfg.myWind.n;
+        var round = this.cfg.roundWind.n;
+        if (h.length == 7)
+            return 25;
+        var lastBlock = h.find(function (b) {
+            return b.tiles.some(function (t) { return t.has(constants_1.OPERATOR.TSUMO) || t.has(constants_1.OPERATOR.RON); });
+        });
+        var isCalled = this.minus() == 1;
+        var isTsumo = lastBlock.tiles.some(function (t) { return t.has(constants_1.OPERATOR.TSUMO); });
+        var calcTriple = function (b, base) {
+            var tile = b.tiles[0];
+            if (tile.k == constants_1.KIND.Z && [5, 6, 7].includes(tile.n))
+                return base * 2;
+            else if (tile.k == constants_1.KIND.Z && [myWind, round].includes(tile.n))
+                return base * 2;
+            else if ([1, 9].includes(tile.n))
+                return base * 2;
+            else
+                return base;
+        };
+        for (var _i = 0, h_5 = h; _i < h_5.length; _i++) {
+            var b = h_5[_i];
+            switch (true) {
+                case b instanceof parser_1.BlockThree:
+                    var v = b.tiles.some(function (t) { return t.has(constants_1.OPERATOR.RON); }) ? 2 : 4;
+                    fu += calcTriple(b, v);
+                    break;
+                case b instanceof parser_1.BlockPon:
+                    fu += calcTriple(b, 2);
+                    break;
+                case b instanceof parser_1.BlockDaiKan || b instanceof parser_1.BlockShoKan:
+                    fu += calcTriple(b, 8);
+                    break;
+                case b instanceof parser_1.BlockAnKan:
+                    fu += calcTriple(b, 16);
+                    break;
+            }
+        }
+        var calcLast = function (b) {
+            if (b instanceof parser_1.BlockThree)
+                return 0;
+            if (b instanceof parser_1.BlockPair)
+                return 2;
+            var tiles = b.tiles;
+            var idx = tiles.findIndex(function (t) { return t.has(constants_1.OPERATOR.TSUMO) || t.has(constants_1.OPERATOR.RON); });
+            if (idx == 1)
+                return 2;
+            else if (idx == 0 && tiles[2].n == 9)
+                return 2;
+            else if (idx == 2 && tiles[0].n == 1)
+                return 2;
+            return 0;
+        };
+        fu += calcLast(lastBlock);
+        var pair = h.find(function (b) { return b instanceof parser_1.BlockPair; });
+        var tile = pair.tiles[0];
+        if (tile.k == constants_1.KIND.Z) {
+            if ([5, 6, 7].includes(tile.n))
+                fu += 2;
+            if (tile.n == round)
+                fu += 2;
+            if (tile.n == myWind)
+                fu += 2;
+        }
+        var isAllRuns = false;
+        if (!isCalled && fu == base)
+            isAllRuns = true;
+        if (isTsumo && !isAllRuns)
+            fu += 2;
+        if (!isTsumo && !isCalled)
+            fu += 10;
+        if (!isTsumo && !isCalled && fu == 30)
+            isAllRuns = true;
+        if (isCalled && fu == base)
+            fu = 30;
+        return fu;
+    };
+    return DoubleCalculator;
+}());
+exports.DoubleCalculator = DoubleCalculator;
+var buildKey = function (b) {
+    return b.tiles.reduce(function (a, b) { return "".concat(a).concat(b.n).concat(b.k); }, "");
+};
+var countSameBlocks = function (h) {
+    var m = {};
+    for (var _i = 0, h_6 = h; _i < h_6.length; _i++) {
+        var b = h_6[_i];
+        if (!(b instanceof parser_1.BlockRun))
+            continue;
+        var key = buildKey(b);
+        if (m[key] == null)
+            m[key] = 1;
+        else
+            m[key]++;
+    }
+    var count = 0;
+    for (var key in m) {
+        var v = m[key];
+        if (v >= 2)
+            count++;
+    }
+    return count;
+};
+var toDora = function (doraMarker) {
+    var n = doraMarker.isNum() && doraMarker.n == 0 ? 5 : doraMarker.n;
+    var k = doraMarker.k;
+    return new parser_1.Tile(k, (n % 9) + 1);
+};