@konoui/mjimage 0.0.1

package/dist/mjs/lib/mjimage.js

@@ -0,0 +1,90 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mjimage = void 0;
+var assert_1 = __importDefault(require("assert"));
+var parser_1 = require("./parser");
+var image_1 = require("./image");
+var context_1 = require("./context");
+var table_1 = require("./table");
+var constants_1 = require("./constants");
+var svg_js_1 = require("@svgdotjs/svg.js");
+var tiles_svg_1 = __importDefault(require("./tiles.svg"));
+var defaultQuerySelector = ".mjimage";
+var defaultScale = 1.6;
+var defaultSvgSprite = false;
+var tableRegex = /^\s*table/;
+var minPaiHeight = Math.min(constants_1.TILE_CONTEXT.WIDTH, constants_1.TILE_CONTEXT.HEIGHT);
+var calculateScale = function (scale, textHeight) {
+    return (textHeight / minPaiHeight) * scale;
+};
+var mjimage = (function () {
+    function mjimage() {
+    }
+    mjimage.svgURL = function () {
+        return tiles_svg_1.default;
+    };
+    mjimage.initialize = function (props) {
+        var _a, _b, _c, _d;
+        if (props === void 0) { props = {}; }
+        console.debug("initializing....");
+        var querySelector = (_a = props.querySelector) !== null && _a !== void 0 ? _a : defaultQuerySelector;
+        var handScale = (_b = props.scale) !== null && _b !== void 0 ? _b : defaultScale;
+        var tableScale = (_c = props.tableScale) !== null && _c !== void 0 ? _c : handScale;
+        var svgSprite = (_d = props.svgSprite) !== null && _d !== void 0 ? _d : defaultSvgSprite;
+        if (typeof querySelector === "string")
+            querySelector = [querySelector];
+        var ctx = document.createElement("canvas").getContext("2d");
+        (0, assert_1.default)(ctx != null);
+        querySelector.forEach(function (qs) {
+            console.debug("try to find", qs);
+            var targets = document.querySelectorAll(qs);
+            for (var i = 0; i < targets.length; i++) {
+                var target = targets[i];
+                var input = target.textContent || "";
+                if (input == "") {
+                    console.debug("skip due to not input");
+                    continue;
+                }
+                console.debug("found", input);
+                target.textContent = "";
+                var style = window.getComputedStyle(target, null);
+                var fontSize = parseFloat(style.getPropertyValue("font-size"));
+                var textHeight = fontSize;
+                var svg = (0, svg_js_1.SVG)();
+                try {
+                    if (tableRegex.test(input)) {
+                        var scale = calculateScale(tableScale, textHeight);
+                        var fontCtx = (0, context_1.getTableFontContext)(ctx, scale);
+                        (0, table_1.drawTable)(svg, input, __assign(__assign({}, props), { svgSprite: svgSprite, scale: scale }), fontCtx);
+                    }
+                    else {
+                        var scale = calculateScale(handScale, textHeight);
+                        var blocks = new parser_1.Parser(input).parse();
+                        (0, image_1.drawBlocks)(svg, blocks, __assign(__assign({}, props), { svgSprite: svgSprite, scale: scale }));
+                    }
+                    svg.addTo(target);
+                }
+                catch (e) {
+                    target.textContent = input;
+                    console.error("encounter unexpected error:", e);
+                }
+            }
+        });
+    };
+    return mjimage;
+}());
+exports.mjimage = mjimage;

package/dist/mjs/lib/parser.d.ts

@@ -0,0 +1,30 @@
+import { BLOCK, OPERATOR, KIND } from "./constants";
+export declare const tileSortFunc: (i: Tile, j: Tile) => number;
+type Kind = (typeof KIND)[keyof typeof KIND];
+export declare function isKind(v: string): [Kind, boolean];
+type Operator = (typeof OPERATOR)[keyof typeof OPERATOR];
+export declare class Tile {
+    k: Kind;
+    n: number;
+    op?: Operator | undefined;
+    constructor(k: Kind, n: number, op?: Operator | undefined);
+    toString(): string;
+    equals(t: Tile, ignoreRed?: boolean): boolean;
+}
+type BLOCK = (typeof BLOCK)[keyof typeof BLOCK];
+export declare class Block {
+    tiles: Tile[];
+    type: BLOCK;
+    constructor(tiles: Tile[], type: BLOCK);
+    toString(): string;
+}
+export declare class Parser {
+    readonly input: string;
+    readonly maxInputLength = 128;
+    constructor(input: string);
+    parse(): Block[];
+    parseInput(): Tile[];
+    private makeBlocks;
+    validate(input: string): void;
+}
+export {};

package/dist/mjs/lib/parser.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = exports.Block = exports.Tile = exports.isKind = exports.tileSortFunc = void 0;
+var lexer_1 = require("./lexer");
+var constants_1 = require("./constants");
+var tileSortFunc = function (i, j) {
+    var _a;
+    if (i.k == j.k) {
+        if (i.n == 0)
+            return 5 - j.n;
+        if (j.n == 0)
+            return i.n - 5;
+        return i.n - j.n;
+    }
+    var lookup = (_a = {},
+        _a[constants_1.KIND.M] = 1,
+        _a[constants_1.KIND.P] = 2,
+        _a[constants_1.KIND.S] = 3,
+        _a[constants_1.KIND.Z] = 4,
+        _a[constants_1.KIND.BACK] = 5,
+        _a[constants_1.KIND.SEPARATOR] = 6,
+        _a);
+    return lookup[i.k] - lookup[j.k];
+};
+exports.tileSortFunc = tileSortFunc;
+function isKind(v) {
+    for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+        var k = _a[_i];
+        if (k == v) {
+            return [v, true];
+        }
+    }
+    return [constants_1.KIND.BACK, false];
+}
+exports.isKind = isKind;
+var Tile = (function () {
+    function Tile(k, n, op) {
+        this.k = k;
+        this.n = n;
+        this.op = op;
+    }
+    Tile.prototype.toString = function () {
+        if (this.k === constants_1.KIND.BACK || this.k === constants_1.KIND.SEPARATOR)
+            return this.k;
+        var op = this.op != null ? this.op : "";
+        return "".concat(op).concat(this.n).concat(this.k);
+    };
+    Tile.prototype.equals = function (t, ignoreRed) {
+        if (ignoreRed === void 0) { ignoreRed = false; }
+        var ok = this.n === t.n;
+        if (ignoreRed)
+            ok || (ok = (this.n == 5 && t.n == 0) || (this.n == 0 && t.n == 5));
+        return this.k === t.k && ok;
+    };
+    return Tile;
+}());
+exports.Tile = Tile;
+var Block = (function () {
+    function Block(tiles, type) {
+        this.tiles = tiles;
+        this.type = type;
+        if (type == constants_1.BLOCK.CHI) {
+            tiles.sort(function (a, b) {
+                if (a.op == constants_1.OPERATOR.HORIZONTAL)
+                    return -1;
+                if (b.op == constants_1.OPERATOR.HORIZONTAL)
+                    return 1;
+                return (0, exports.tileSortFunc)(a, b);
+            });
+            return;
+        }
+        if (type != constants_1.BLOCK.DISCARD) {
+            tiles.sort(exports.tileSortFunc);
+        }
+    }
+    Block.prototype.toString = function () {
+        var result = "";
+        for (var _i = 0, _a = this.tiles; _i < _a.length; _i++) {
+            var t = _a[_i];
+            result += t.toString();
+        }
+        return result;
+    };
+    return Block;
+}());
+exports.Block = Block;
+var Parser = (function () {
+    function Parser(input) {
+        this.input = input;
+        this.maxInputLength = 128;
+        this.input = input.replace(/\s/g, "");
+    }
+    Parser.prototype.parse = function () {
+        var parsed = this.parseInput();
+        return this.makeBlocks(parsed);
+    };
+    Parser.prototype.parseInput = function () {
+        var l = new lexer_1.Lexer(this.input);
+        var res = [];
+        var cluster = [];
+        this.validate(this.input);
+        for (;;) {
+            l.skipWhitespace();
+            var char = l.char;
+            if (char === l.eof)
+                break;
+            var _a = isKindAlias(char, cluster), k = _a[0], isKind_1 = _a[1];
+            if (isKind_1) {
+                if (k == constants_1.KIND.BACK) {
+                    res.push(new Tile(k, 0));
+                    l.readChar();
+                    continue;
+                }
+                if (k == constants_1.KIND.SEPARATOR) {
+                    res.push(new Tile(k, -1));
+                    l.readChar();
+                    continue;
+                }
+                res.push.apply(res, makeTiles(cluster, k));
+                cluster = [];
+                l.readChar();
+                continue;
+            }
+            else {
+                var _b = isOperator(l), t = _b[0], isOp = _b[1];
+                if (isOp) {
+                    l.readChar();
+                    cluster.push(t);
+                    l.readChar();
+                    continue;
+                }
+                var _c = isNumber(char), n = _c[0], isNum = _c[1];
+                if (!isNum)
+                    throw new Error("encounter unexpected number: ".concat(n, " ").concat(char));
+                cluster.push(new Tile(constants_1.KIND.BACK, n));
+            }
+            l.readChar();
+        }
+        if (cluster.length > 0)
+            throw new Error("remaining values ".concat(cluster.toString()));
+        return res;
+    };
+    Parser.prototype.makeBlocks = function (tiles) {
+        var cluster = [];
+        var res = [];
+        if (tiles.length == 0)
+            return res;
+        for (var _i = 0, tiles_1 = tiles; _i < tiles_1.length; _i++) {
+            var t = tiles_1[_i];
+            if (t.k === constants_1.KIND.SEPARATOR) {
+                var type_1 = detectBlockType(cluster);
+                var b_1 = new Block(cluster, type_1);
+                res.push(b_1);
+                cluster = [];
+                continue;
+            }
+            cluster.push(t);
+        }
+        var type = detectBlockType(cluster);
+        var b = new Block(cluster, type);
+        res.push(b);
+        cluster = [];
+        return res;
+    };
+    Parser.prototype.validate = function (input) {
+        if (input.length == 0)
+            return;
+        if (input.length > this.maxInputLength)
+            throw new Error("exceeded maximum input length");
+        var lastChar = input.charAt(input.length - 1);
+        var _a = isKindAlias(lastChar, [new Tile(constants_1.KIND.BACK, 1)]), _ = _a[0], isKind = _a[1];
+        if (!isKind)
+            throw new Error("last character(".concat(lastChar, ") is not kind value"));
+    };
+    return Parser;
+}());
+exports.Parser = Parser;
+function detectBlockType(tiles) {
+    if (tiles.length === 0)
+        return constants_1.BLOCK.UNKNOWN;
+    if (tiles.length === 1) {
+        if (tiles[0].op === constants_1.OPERATOR.DORA)
+            return constants_1.BLOCK.DORA;
+        if (tiles[0].op === constants_1.OPERATOR.TSUMO)
+            return constants_1.BLOCK.TSUMO;
+        return constants_1.BLOCK.HAND;
+    }
+    var sameAll = tiles.filter(function (v) { return v.equals(tiles[0], true); }).length == tiles.length;
+    var numOfHorizontals = tiles.filter(function (v) { return v.op == constants_1.OPERATOR.HORIZONTAL; }).length;
+    var numOfTsumoDoraTiles = tiles.filter(function (v) { return v.op == constants_1.OPERATOR.TSUMO || v.op == constants_1.OPERATOR.DORA; }).length;
+    var numOfBackTiles = tiles.filter(function (v) { return v.k == constants_1.KIND.BACK; }).length;
+    if (numOfTsumoDoraTiles > 0)
+        return constants_1.BLOCK.UNKNOWN;
+    if (numOfHorizontals == 0 && numOfBackTiles == 0)
+        return constants_1.BLOCK.HAND;
+    if (tiles.length === 3) {
+        return sameAll ? constants_1.BLOCK.PON : constants_1.BLOCK.CHI;
+    }
+    if (tiles.length == 4 && numOfBackTiles == 2)
+        return constants_1.BLOCK.AN_KAN;
+    if (tiles.length == 4 && sameAll) {
+        if (numOfHorizontals == 1)
+            return constants_1.BLOCK.DAI_KAN;
+        if (numOfHorizontals == 2)
+            return constants_1.BLOCK.SHO_KAN;
+    }
+    if (numOfHorizontals == 1)
+        return constants_1.BLOCK.DISCARD;
+    return constants_1.BLOCK.UNKNOWN;
+}
+function makeTiles(cluster, k) {
+    return cluster.map(function (v) {
+        return new Tile(k, v.n, v.op);
+    });
+}
+function isKindAlias(s, cluster) {
+    var _a = isKind(s), k = _a[0], ok = _a[1];
+    if (ok)
+        return [k, true];
+    var isAlias = s === "w" || s === "d";
+    if (isAlias && cluster.length > 0) {
+        for (var i = 0; i < cluster.length; i++) {
+            if (s === "d")
+                cluster[i].n += 4;
+        }
+        return [constants_1.KIND.Z, true];
+    }
+    return [constants_1.KIND.BACK, false];
+}
+function isNumber(v) {
+    var valid = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+    return [Number(v), valid.includes(v)];
+}
+function isOperator(l) {
+    for (var _i = 0, _a = Object.values(constants_1.OPERATOR); _i < _a.length; _i++) {
+        var op = _a[_i];
+        if (op == l.char) {
+            var _b = isNumber(l.peekChar()), n = _b[0], ok = _b[1];
+            if (!ok)
+                return [new Tile(constants_1.KIND.BACK, 0), false];
+            return [new Tile(constants_1.KIND.BACK, n, op), true];
+        }
+    }
+    return [new Tile(constants_1.KIND.BACK, 0), false];
+}

package/dist/mjs/lib/table-parser.d.ts

@@ -0,0 +1,220 @@
+import { z } from "zod";
+import { Tile, Block } from "./parser";
+import { WIND_MAP, ROUND_MAP } from "./constants";
+declare const tableInputSchema: z.ZodObject<{
+    "1w": z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        discard: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        hand: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        score: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strict", z.ZodTypeAny, {
+        discard: string;
+        hand: string;
+        score: number;
+    }, {
+        discard?: string | undefined;
+        hand?: string | undefined;
+        score?: number | undefined;
+    }>>>;
+    "2w": z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        discard: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        hand: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        score: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strict", z.ZodTypeAny, {
+        discard: string;
+        hand: string;
+        score: number;
+    }, {
+        discard?: string | undefined;
+        hand?: string | undefined;
+        score?: number | undefined;
+    }>>>;
+    "3w": z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        discard: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        hand: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        score: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strict", z.ZodTypeAny, {
+        discard: string;
+        hand: string;
+        score: number;
+    }, {
+        discard?: string | undefined;
+        hand?: string | undefined;
+        score?: number | undefined;
+    }>>>;
+    "4w": z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        discard: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        hand: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        score: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strict", z.ZodTypeAny, {
+        discard: string;
+        hand: string;
+        score: number;
+    }, {
+        discard?: string | undefined;
+        hand?: string | undefined;
+        score?: number | undefined;
+    }>>>;
+    board: z.ZodObject<{
+        round: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4">, z.ZodLiteral<"1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4">, ...z.ZodLiteral<"1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4">[]]>>>;
+        sticks: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            reach: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            dead: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            reach: number;
+            dead: number;
+        }, {
+            reach?: number | undefined;
+            dead?: number | undefined;
+        }>>>;
+        doras: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        front: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"1w" | "2w" | "3w" | "4w">, z.ZodLiteral<"1w" | "2w" | "3w" | "4w">, ...z.ZodLiteral<"1w" | "2w" | "3w" | "4w">[]]>>>;
+    }, "strict", z.ZodTypeAny, {
+        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4";
+        sticks: {
+            reach: number;
+            dead: number;
+        };
+        doras: string[];
+        front: "1w" | "2w" | "3w" | "4w";
+    }, {
+        round?: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | undefined;
+        sticks?: {
+            reach?: number | undefined;
+            dead?: number | undefined;
+        } | undefined;
+        doras?: string[] | undefined;
+        front?: "1w" | "2w" | "3w" | "4w" | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    "1w": {
+        discard: string;
+        hand: string;
+        score: number;
+    };
+    "2w": {
+        discard: string;
+        hand: string;
+        score: number;
+    };
+    "3w": {
+        discard: string;
+        hand: string;
+        score: number;
+    };
+    "4w": {
+        discard: string;
+        hand: string;
+        score: number;
+    };
+    board: {
+        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4";
+        sticks: {
+            reach: number;
+            dead: number;
+        };
+        doras: string[];
+        front: "1w" | "2w" | "3w" | "4w";
+    };
+}, {
+    board: {
+        round?: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | undefined;
+        sticks?: {
+            reach?: number | undefined;
+            dead?: number | undefined;
+        } | undefined;
+        doras?: string[] | undefined;
+        front?: "1w" | "2w" | "3w" | "4w" | undefined;
+    };
+    "1w"?: {
+        discard?: string | undefined;
+        hand?: string | undefined;
+        score?: number | undefined;
+    } | undefined;
+    "2w"?: {
+        discard?: string | undefined;
+        hand?: string | undefined;
+        score?: number | undefined;
+    } | undefined;
+    "3w"?: {
+        discard?: string | undefined;
+        hand?: string | undefined;
+        score?: number | undefined;
+    } | undefined;
+    "4w"?: {
+        discard?: string | undefined;
+        hand?: string | undefined;
+        score?: number | undefined;
+    } | undefined;
+}>;
+export type TableInput = z.infer<typeof tableInputSchema>;
+export interface DiscardsInput {
+    front: Tile[];
+    right: Tile[];
+    opposite: Tile[];
+    left: Tile[];
+}
+export interface HandsInput {
+    front: Block[];
+    right: Block[];
+    opposite: Block[];
+    left: Block[];
+}
+export interface ScoreBoardInput {
+    doras: Tile[];
+    round: BoardRound;
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    scores: {
+        front: number;
+        right: number;
+        opposite: number;
+        left: number;
+    };
+    frontPlace: BoardWind;
+}
+type BoardRound = (typeof ROUND_MAP)[keyof typeof ROUND_MAP];
+type BoardWind = (typeof WIND_MAP)[keyof typeof WIND_MAP];
+export declare const parse: (s: string) => {
+    discards: DiscardsInput;
+    hands: HandsInput;
+    scoreBoard: ScoreBoardInput;
+};
+export declare const parseTableInput: (s: string) => {
+    "1w": {
+        discard: string;
+        hand: string;
+        score: number;
+    };
+    "2w": {
+        discard: string;
+        hand: string;
+        score: number;
+    };
+    "3w": {
+        discard: string;
+        hand: string;
+        score: number;
+    };
+    "4w": {
+        discard: string;
+        hand: string;
+        score: number;
+    };
+    board: {
+        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4";
+        sticks: {
+            reach: number;
+            dead: number;
+        };
+        doras: string[];
+        front: "1w" | "2w" | "3w" | "4w";
+    };
+};
+export declare const convertInput: (i: TableInput) => {
+    discards: DiscardsInput;
+    hands: HandsInput;
+    scoreBoard: ScoreBoardInput;
+};
+export {};

package/dist/mjs/lib/table-parser.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertInput = exports.parseTableInput = exports.parse = void 0;
+var js_yaml_1 = require("js-yaml");
+var zod_1 = require("zod");
+var parser_1 = require("./parser");
+var constants_1 = require("./constants");
+var windInputSchema = zod_1.z
+    .object({
+    discard: zod_1.z.string().max(50).optional().default(""),
+    hand: zod_1.z.string().max(25).optional().default(""),
+    score: zod_1.z.number().optional().default(25000),
+})
+    .strict()
+    .optional()
+    .default({ discard: "", hand: "", score: 25000 });
+var windInputsSchema = zod_1.z
+    .object({
+    "1w": windInputSchema,
+    "2w": windInputSchema,
+    "3w": windInputSchema,
+    "4w": windInputSchema,
+})
+    .strict();
+function unionOfLiterals(constants) {
+    var literals = constants.map(function (x) { return zod_1.z.literal(x); });
+    return zod_1.z.union(literals);
+}
+var boardInputSchema = zod_1.z
+    .object({
+    round: unionOfLiterals(Object.keys(constants_1.ROUND_MAP))
+        .optional()
+        .default("1w1"),
+    sticks: zod_1.z
+        .object({
+        reach: zod_1.z.number().max(9).gte(0).optional().default(0),
+        dead: zod_1.z.number().max(9).gte(0).optional().default(0),
+    })
+        .optional()
+        .default({ reach: 0, dead: 0 }),
+    doras: zod_1.z.array(zod_1.z.string()).max(4).optional().default(["3w"]),
+    front: unionOfLiterals(Object.keys(constants_1.WIND_MAP))
+        .optional()
+        .default("1w"),
+})
+    .strict();
+var tableInputSchema = windInputsSchema.extend({
+    board: boardInputSchema,
+});
+var parse = function (s) {
+    var d = (0, exports.parseTableInput)(s);
+    return (0, exports.convertInput)(d);
+};
+exports.parse = parse;
+var parseTableInput = function (s) {
+    var rawInput = (0, js_yaml_1.load)(s);
+    var ret = tableInputSchema.safeParse(rawInput.table);
+    if (!ret.success) {
+        throw ret.error;
+    }
+    return ret.data;
+};
+exports.parseTableInput = parseTableInput;
+var convertInput = function (i) {
+    var frontPlace = i.board.front;
+    var m = createPlaceMap(frontPlace);
+    var f = function (w) {
+        return i[w].discard.replace(/\r?\n/g, "");
+    };
+    var discards = {
+        front: new parser_1.Parser(f(m.front)).parseInput(),
+        right: new parser_1.Parser(f(m.right)).parseInput(),
+        opposite: new parser_1.Parser(f(m.opposite)).parseInput(),
+        left: new parser_1.Parser(f(m.left)).parseInput(),
+    };
+    var hands = {
+        front: new parser_1.Parser(i[m.front].hand).parse(),
+        right: new parser_1.Parser(i[m.right].hand).parse(),
+        opposite: new parser_1.Parser(i[m.opposite].hand).parse(),
+        left: new parser_1.Parser(i[m.left].hand).parse(),
+    };
+    var scoreBoard = {
+        round: constants_1.ROUND_MAP[i.board.round],
+        frontPlace: constants_1.WIND_MAP[frontPlace],
+        sticks: i.board.sticks,
+        doras: i.board.doras.map(function (v) {
+            return new parser_1.Parser(v).parseInput()[0];
+        }),
+        scores: {
+            front: i[m.front].score,
+            right: i[m.right].score,
+            opposite: i[m.opposite].score,
+            left: i[m.left].score,
+        },
+    };
+    return { discards: discards, hands: hands, scoreBoard: scoreBoard };
+};
+exports.convertInput = convertInput;
+var createPlaceMap = function (front) {
+    var f = function (start, v) {
+        var ret = "".concat(v, "w");
+        if (v > 4)
+            ret = "".concat(v - start, "w");
+        return ret;
+    };
+    var start = Number(front[0]);
+    var m = {
+        front: front,
+        right: f(start, start + 1),
+        opposite: f(start, start + 2),
+        left: f(start, start + 3),
+    };
+    return m;
+};