@pai-forge/riichi-mahjong 0.3.5 → 0.3.6

package/dist/index.js

@@ -203,6 +203,481 @@ const YAOCHU_KIND_IDS = [
 function isYaochu(kind) {
   return YAOCHU_KIND_IDS.some((k) => k === kind);
 }
+const defaultErrorConfig = {
+  withStackTrace: false
+};
+const createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
+  return {
+    data,
+    message,
+    stack: maybeStack
+  };
+};
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+class ResultAsync {
+  constructor(res) {
+    this._promise = res;
+  }
+  static fromSafePromise(promise) {
+    const newPromise = promise.then((value) => new Ok(value));
+    return new ResultAsync(newPromise);
+  }
+  static fromPromise(promise, errorFn) {
+    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+    return new ResultAsync(newPromise);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromThrowable(fn, errorFn) {
+    return (...args) => {
+      return new ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+        try {
+          return new Ok(yield fn(...args));
+        } catch (error) {
+          return new Err(errorFn ? errorFn(error) : error);
+        }
+      }))());
+    };
+  }
+  static combine(asyncResultList) {
+    return combineResultAsyncList(asyncResultList);
+  }
+  static combineWithAllErrors(asyncResultList) {
+    return combineResultAsyncListWithAllErrors(asyncResultList);
+  }
+  map(f) {
+    return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      return new Ok(yield f(res.value));
+    })));
+  }
+  andThrough(f) {
+    return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newRes = yield f(res.value);
+      if (newRes.isErr()) {
+        return new Err(newRes.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  andTee(f) {
+    return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      try {
+        yield f(res.value);
+      } catch (e) {
+      }
+      return new Ok(res.value);
+    })));
+  }
+  orTee(f) {
+    return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      try {
+        yield f(res.error);
+      } catch (e) {
+      }
+      return new Err(res.error);
+    })));
+  }
+  mapErr(f) {
+    return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      return new Err(yield f(res.error));
+    })));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return new ResultAsync(this._promise.then((res) => {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newValue = f(res.value);
+      return newValue instanceof ResultAsync ? newValue._promise : newValue;
+    }));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return f(res.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  match(ok2, _err) {
+    return this._promise.then((res) => res.match(ok2, _err));
+  }
+  unwrapOr(t) {
+    return this._promise.then((res) => res.unwrapOr(t));
+  }
+  /**
+   * @deprecated will be removed in 9.0.0.
+   *
+   * You can use `safeTry` without this method.
+   * @example
+   * ```typescript
+   * safeTry(async function* () {
+   *   const okValue = yield* yourResult
+   * })
+   * ```
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap() {
+    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+    });
+  }
+  // Makes ResultAsync implement PromiseLike<Result>
+  then(successCallback, failureCallback) {
+    return this._promise.then(successCallback, failureCallback);
+  }
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, arguments, function* _a() {
+      const result = yield __await(this._promise);
+      if (result.isErr()) {
+        yield yield __await(errAsync(result.error));
+      }
+      return yield __await(result.value);
+    });
+  }
+}
+function errAsync(err2) {
+  return new ResultAsync(Promise.resolve(new Err(err2)));
+}
+const combineResultList = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr()) {
+      acc = err(result.error);
+      break;
+    } else {
+      acc.map((list) => list.push(result.value));
+    }
+  }
+  return acc;
+};
+const combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+const combineResultListWithAllErrors = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr() && acc.isErr()) {
+      acc.error.push(result.error);
+    } else if (result.isErr() && acc.isOk()) {
+      acc = err([result.error]);
+    } else if (result.isOk() && acc.isOk()) {
+      acc.value.push(result.value);
+    }
+  }
+  return acc;
+};
+const combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result2) {
+  function fromThrowable(fn, errorFn) {
+    return (...args) => {
+      try {
+        const result = fn(...args);
+        return ok(result);
+      } catch (e) {
+        return err(errorFn ? errorFn(e) : e);
+      }
+    };
+  }
+  Result2.fromThrowable = fromThrowable;
+  function combine(resultList) {
+    return combineResultList(resultList);
+  }
+  Result2.combine = combine;
+  function combineWithAllErrors(resultList) {
+    return combineResultListWithAllErrors(resultList);
+  }
+  Result2.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+function ok(value) {
+  return new Ok(value);
+}
+function err(err2) {
+  return new Err(err2);
+}
+class Ok {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  map(f) {
+    return ok(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  mapErr(_f) {
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThrough(f) {
+    return f(this.value).map((_value) => this.value);
+  }
+  andTee(f) {
+    try {
+      f(this.value);
+    } catch (e) {
+    }
+    return ok(this.value);
+  }
+  orTee(_f) {
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(_f) {
+    return ok(this.value);
+  }
+  asyncAndThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  asyncAndThrough(f) {
+    return f(this.value).map(() => this.value);
+  }
+  asyncMap(f) {
+    return ResultAsync.fromSafePromise(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  unwrapOr(_v) {
+    return this.value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  match(ok2, _err) {
+    return ok2(this.value);
+  }
+  safeUnwrap() {
+    const value = this.value;
+    return (function* () {
+      return value;
+    })();
+  }
+  _unsafeUnwrap(_) {
+    return this.value;
+  }
+  _unsafeUnwrapErr(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-this-alias, require-yield
+  *[Symbol.iterator]() {
+    return this.value;
+  }
+}
+class Err {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  map(_f) {
+    return err(this.error);
+  }
+  mapErr(f) {
+    return err(f(this.error));
+  }
+  andThrough(_f) {
+    return err(this.error);
+  }
+  andTee(_f) {
+    return err(this.error);
+  }
+  orTee(f) {
+    try {
+      f(this.error);
+    } catch (e) {
+    }
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(_f) {
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return f(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncAndThen(_f) {
+    return errAsync(this.error);
+  }
+  asyncAndThrough(_f) {
+    return errAsync(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncMap(_f) {
+    return errAsync(this.error);
+  }
+  unwrapOr(v) {
+    return v;
+  }
+  match(_ok, err2) {
+    return err2(this.error);
+  }
+  safeUnwrap() {
+    const error = this.error;
+    return (function* () {
+      yield err(error);
+      throw new Error("Do not use this generator out of `safeTry`");
+    })();
+  }
+  _unsafeUnwrap(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+  }
+  _unsafeUnwrapErr(_) {
+    return this.error;
+  }
+  *[Symbol.iterator]() {
+    const self = this;
+    yield self;
+    return self;
+  }
+}
+Result.fromThrowable;
 function calculateTehaiCount(tehai) {
   return tehai.closed.length + tehai.exposed.length * 3;
 }
@@ -213,41 +688,47 @@ function countHaiKind(hais) {
   }
   return counts;
 }
-function assertTehai13(tehai) {
+function validateTehai13(tehai) {
   const count = calculateTehaiCount(tehai);
   if (count < 13) {
-    throw new ShoushaiError();
+    return err(new ShoushaiError());
   }
   if (count > 13) {
-    throw new TahaiError();
+    return err(new TahaiError());
   }
-  validateHaiConsistency(tehai);
-}
-function validateTehai13(tehai) {
-  assertTehai13(tehai);
+  const consRes = validateHaiConsistency(tehai);
+  if (consRes.isErr()) {
+    return err(consRes.error);
+  }
+  return ok(tehai);
 }
-function assertTehai14(tehai) {
+function validateTehai14(tehai) {
   const count = calculateTehaiCount(tehai);
   if (count < 14) {
-    throw new ShoushaiError();
+    return err(new ShoushaiError());
   }
   if (count > 14) {
-    throw new TahaiError();
+    return err(new TahaiError());
   }
-  validateHaiConsistency(tehai);
-}
-function validateTehai14(tehai) {
-  assertTehai14(tehai);
+  const consRes = validateHaiConsistency(tehai);
+  if (consRes.isErr()) {
+    return err(consRes.error);
+  }
+  return ok(tehai);
 }
 function validateTehai(tehai) {
   const count = calculateTehaiCount(tehai);
   if (count < 13) {
-    throw new ShoushaiError();
+    return err(new ShoushaiError());
   }
   if (count > 14) {
-    throw new TahaiError();
+    return err(new TahaiError());
   }
-  validateHaiConsistency(tehai);
+  const consRes = validateHaiConsistency(tehai);
+  if (consRes.isErr()) {
+    return err(consRes.error);
+  }
+  return ok(tehai);
 }
 function validateHaiConsistency(tehai) {
   const allHais = [
@@ -258,7 +739,7 @@ function validateHaiConsistency(tehai) {
   if (isHaiIdMode) {
     const uniqueIds = new Set(allHais);
     if (uniqueIds.size !== allHais.length) {
-      throw new DuplicatedHaiIdError();
+      return err(new DuplicatedHaiIdError());
     }
   }
   const counts = /* @__PURE__ */ new Map();
@@ -266,26 +747,17 @@ function validateHaiConsistency(tehai) {
     const kind = isHaiIdMode ? haiIdToKindId(hai) : hai;
     const current = counts.get(kind) ?? 0;
     if (current + 1 > 4) {
-      throw new InvalidHaiQuantityError();
+      return err(new InvalidHaiQuantityError());
     }
     counts.set(kind, current + 1);
   }
+  return ok(void 0);
 }
 function isTehai13(tehai) {
-  try {
-    validateTehai13(tehai);
-    return true;
-  } catch {
-    return false;
-  }
+  return validateTehai13(tehai).isOk();
 }
 function isTehai14(tehai) {
-  try {
-    validateTehai14(tehai);
-    return true;
-  } catch {
-    return false;
-  }
+  return validateTehai14(tehai).isOk();
 }
 function isValidShuntsu(kindIds) {
   if (!isTuple3(kindIds)) return false;
@@ -544,11 +1016,12 @@ function countTaatsu(counts) {
   return taatsu;
 }
 function calculateShanten(tehai, useChiitoitsu = true, useKokushi = true) {
-  validateTehai13(tehai);
+  const valRes = validateTehai13(tehai);
+  if (valRes.isErr()) return err(valRes.error);
   const chiitoitsuShanten = useChiitoitsu ? calculateChiitoitsuShanten(tehai) : Infinity;
   const kokushiShanten = useKokushi ? calculateKokushiShanten(tehai) : Infinity;
   const mentsuShanten = calculateMentsuTeShanten(tehai);
-  return Math.min(chiitoitsuShanten, kokushiShanten, mentsuShanten);
+  return ok(Math.min(chiitoitsuShanten, kokushiShanten, mentsuShanten));
 }
 function getUkeire(tehai) {
   const currentShanten = calculateMentsuTeShanten(tehai);
@@ -765,17 +1238,68 @@ function analyzeIshokuPattern(hand) {
     suupaiSuit: isAllSameType ? firstSuupaiType : void 0
   };
 }
-function createYakuDefinition(yaku, check) {
-  return {
-    yaku,
-    isSatisfied: check,
-    getHansu: (hand, context) => {
-      if (!check(hand, context)) {
-        return 0;
+class YakuBuilder {
+  /**
+   *
+   */
+  constructor(yaku) {
+    this.yaku = yaku;
+  }
+  predicates = [];
+  hanCalculator;
+  /**
+   *
+   */
+  require(predicate) {
+    this.predicates.push(predicate);
+    return this;
+  }
+  /**
+   *
+   */
+  menzenOnly() {
+    this.predicates.push((hand, context) => context.isMenzen);
+    return this;
+  }
+  /**
+   *
+   */
+  dynamicHan(calculator) {
+    this.hanCalculator = calculator;
+    return this;
+  }
+  /**
+   *
+   */
+  build() {
+    const yaku = this.yaku;
+    const predicates = this.predicates;
+    const calculator = this.hanCalculator;
+    return {
+      yaku,
+      isSatisfied(hand, context) {
+        return predicates.every((pred) => pred(hand, context));
+      },
+      getHansu(hand, context) {
+        if (!this.isSatisfied(hand, context)) {
+          return 0;
+        }
+        if (calculator) {
+          return calculator(hand, context);
+        }
+        return context.isMenzen ? yaku.han.closed : yaku.han.open;
       }
-      return context.isMenzen ? yaku.han.closed : yaku.han.open;
+    };
+  }
+}
+function createYaku(name, closedHan, openHan = 0) {
+  return new YakuBuilder({
+    name,
+    han: {
+      closed: closedHan,
+      open: openHan
     }
-  };
+  });
 }
 const TANYAO_YAKU = {
   name: "Tanyao",
@@ -792,10 +1316,11 @@ const checkTanyao = (hand) => {
   }
   return true;
 };
-const tanyaoDefinition = createYakuDefinition(
-  TANYAO_YAKU,
-  checkTanyao
-);
+const tanyaoDefinition = createYaku(
+  TANYAO_YAKU.name,
+  TANYAO_YAKU.han.closed,
+  TANYAO_YAKU.han.open
+).require(checkTanyao).build();
 const PINFU_YAKU = {
   name: "Pinfu",
   han: {
@@ -825,10 +1350,11 @@ const checkPinfu = (hand, context) => {
   const waitType = classifyMachi(hand, context.agariHai);
   return waitType === "Ryanmen";
 };
-const pinfuDefinition = createYakuDefinition(
-  PINFU_YAKU,
-  checkPinfu
-);
+const pinfuDefinition = createYaku(
+  PINFU_YAKU.name,
+  PINFU_YAKU.han.closed,
+  PINFU_YAKU.han.open
+).require(checkPinfu).build();
 const IIPEIKO_YAKU = {
   name: "Iipeikou",
   han: {
@@ -841,10 +1367,11 @@ const checkIipeikou = (hand) => {
   const pairCount = countShuntsuPairs(hand);
   return pairCount === 1;
 };
-const iipeikouDefinition = createYakuDefinition(
-  IIPEIKO_YAKU,
-  checkIipeikou
-);
+const iipeikouDefinition = createYaku(
+  IIPEIKO_YAKU.name,
+  IIPEIKO_YAKU.han.closed,
+  IIPEIKO_YAKU.han.open
+).require(checkIipeikou).build();
 const RYANPEIKOU_YAKU = {
   name: "Ryanpeikou",
   han: {
@@ -866,20 +1393,14 @@ const checkRyanpeikou = (hand) => {
   const pairCount = countShuntsuPairs(hand);
   return pairCount >= 2;
 };
-const ryanpeikouDefinition = createYakuDefinition(
-  RYANPEIKOU_YAKU,
-  checkRyanpeikou
-);
-const SANANKOU_YAKU = {
-  name: "Sanankou",
-  han: {
-    open: 2,
-    closed: 2
-  }
-};
-const checkSanankou = (hand, context) => {
+const ryanpeikouDefinition = createYaku(
+  RYANPEIKOU_YAKU.name,
+  RYANPEIKOU_YAKU.han.closed,
+  RYANPEIKOU_YAKU.han.open
+).require(checkRyanpeikou).build();
+const countAnkou = (hand, context) => {
   if (hand.type !== "Mentsu") {
-    return false;
+    return 0;
   }
   const triplets = hand.fourMentsu.filter(
     (m) => m.type === "Koutsu" || m.type === "Kantsu"
@@ -901,12 +1422,69 @@ const checkSanankou = (hand, context) => {
       }
     }
   }
+  return ankouCount;
+};
+const countSpecificKoutsu = (hand, targetKinds) => {
+  if (hand.type !== "Mentsu") {
+    return 0;
+  }
+  let count = 0;
+  const triplets = hand.fourMentsu.filter(
+    (m) => m.type === "Koutsu" || m.type === "Kantsu"
+  );
+  for (const triplet of triplets) {
+    if (targetKinds.includes(triplet.hais[0])) {
+      count++;
+    }
+  }
+  return count;
+};
+const isAllHaisMatch = (hand, predicate) => {
+  if (hand.type === "Mentsu") {
+    const allHais = [
+      ...hand.fourMentsu.flatMap((m) => m.hais),
+      ...hand.jantou.hais
+    ];
+    return allHais.every(predicate);
+  } else if (hand.type === "Chiitoitsu") {
+    const allHais = hand.pairs.flatMap((p) => p.hais);
+    return allHais.every(predicate);
+  } else {
+    return hand.yaochu.every(predicate);
+  }
+};
+const getShuntsuCombinations3 = (shuntsuList) => {
+  const combos = [];
+  for (let i = 0; i < shuntsuList.length; i++) {
+    for (let j = i + 1; j < shuntsuList.length; j++) {
+      for (let k = j + 1; k < shuntsuList.length; k++) {
+        const s1 = shuntsuList[i];
+        const s2 = shuntsuList[j];
+        const s3 = shuntsuList[k];
+        if (s1 && s2 && s3) {
+          combos.push([s1, s2, s3]);
+        }
+      }
+    }
+  }
+  return combos;
+};
+const SANANKOU_YAKU = {
+  name: "Sanankou",
+  han: {
+    open: 2,
+    closed: 2
+  }
+};
+const checkSanankou = (hand, context) => {
+  const ankouCount = countAnkou(hand, context);
   return ankouCount >= 3;
 };
-const sanankouDefinition = createYakuDefinition(
-  SANANKOU_YAKU,
-  checkSanankou
-);
+const sanankouDefinition = createYaku(
+  SANANKOU_YAKU.name,
+  SANANKOU_YAKU.han.closed,
+  SANANKOU_YAKU.han.open
+).require(checkSanankou).build();
 const SUUANKOU_YAKU = {
   name: "Suuankou",
   han: {
@@ -917,29 +1495,7 @@ const SUUANKOU_YAKU = {
   }
 };
 const checkSuuankou = (hand, context) => {
-  if (hand.type !== "Mentsu") {
-    return false;
-  }
-  const triplets = hand.fourMentsu.filter(
-    (m) => m.type === "Koutsu" || m.type === "Kantsu"
-  );
-  let ankouCount = 0;
-  for (const triplet of triplets) {
-    if (triplet.furo) continue;
-    const isAgariHaiInTriplet = triplet.hais.includes(context.agariHai);
-    const isTanki = hand.jantou.hais[0] === context.agariHai;
-    if (context.isTsumo) {
-      ankouCount++;
-    } else {
-      if (isAgariHaiInTriplet) {
-        if (isTanki) {
-          ankouCount++;
-        }
-      } else {
-        ankouCount++;
-      }
-    }
-  }
+  const ankouCount = countAnkou(hand, context);
   return ankouCount === 4;
 };
 const suuankouDefinition = {
@@ -968,10 +1524,11 @@ const checkSankantsu = (hand) => {
   const kantsuList = hand.fourMentsu.filter((m) => m.type === "Kantsu");
   return kantsuList.length >= 3;
 };
-const sankantsuDefinition = createYakuDefinition(
-  SANKANTSU_YAKU,
-  checkSankantsu
-);
+const sankantsuDefinition = createYaku(
+  SANKANTSU_YAKU.name,
+  SANKANTSU_YAKU.han.closed,
+  SANKANTSU_YAKU.han.open
+).require(checkSankantsu).build();
 const SUUKANTSU_YAKU = {
   name: "Suukantsu",
   han: {
@@ -986,10 +1543,11 @@ const checkSuukantsu = (hand) => {
   const kantsuList = hand.fourMentsu.filter((m) => m.type === "Kantsu");
   return kantsuList.length === 4;
 };
-const suukantsuDefinition = createYakuDefinition(
-  SUUKANTSU_YAKU,
-  checkSuukantsu
-);
+const suukantsuDefinition = createYaku(
+  SUUKANTSU_YAKU.name,
+  SUUKANTSU_YAKU.han.closed,
+  SUUKANTSU_YAKU.han.open
+).require(checkSuukantsu).build();
 const TOITOI_YAKU = {
   name: "Toitoi",
   han: {
@@ -1005,10 +1563,11 @@ const checkToitoi = (hand) => {
     (mentsu) => mentsu.type === "Koutsu" || mentsu.type === "Kantsu"
   );
 };
-const toitoiDefinition = createYakuDefinition(
-  TOITOI_YAKU,
-  checkToitoi
-);
+const toitoiDefinition = createYaku(
+  TOITOI_YAKU.name,
+  TOITOI_YAKU.han.closed,
+  TOITOI_YAKU.han.open
+).require(checkToitoi).build();
 const CHIITOITSU_YAKU = {
   name: "Chiitoitsu",
   han: {
@@ -1020,10 +1579,11 @@ const CHIITOITSU_YAKU = {
 const checkChiitoitsu = (hand) => {
   return hand.type === "Chiitoitsu";
 };
-const chiitoitsuDefinition = createYakuDefinition(
-  CHIITOITSU_YAKU,
-  checkChiitoitsu
-);
+const chiitoitsuDefinition = createYaku(
+  CHIITOITSU_YAKU.name,
+  CHIITOITSU_YAKU.han.closed,
+  CHIITOITSU_YAKU.han.open
+).require(checkChiitoitsu).build();
 const HONCHAN_YAKU = {
   name: "Honchan",
   han: {
@@ -1046,10 +1606,11 @@ const checkHonchan = (hand) => {
   if (!hasJihai) return false;
   return true;
 };
-const honchanDefinition = createYakuDefinition(
-  HONCHAN_YAKU,
-  checkHonchan
-);
+const honchanDefinition = createYaku(
+  HONCHAN_YAKU.name,
+  HONCHAN_YAKU.han.closed,
+  HONCHAN_YAKU.han.open
+).require(checkHonchan).build();
 const JUNCHAN_YAKU = {
   name: "Junchan",
   han: {
@@ -1068,10 +1629,11 @@ const checkJunchan = (hand) => {
   if (!hasShuntsu) return false;
   return true;
 };
-const junchanDefinition = createYakuDefinition(
-  JUNCHAN_YAKU,
-  checkJunchan
-);
+const junchanDefinition = createYaku(
+  JUNCHAN_YAKU.name,
+  JUNCHAN_YAKU.han.closed,
+  JUNCHAN_YAKU.han.open
+).require(checkJunchan).build();
 const HONROUTOU_YAKU = {
   name: "Honroutou",
   han: {
@@ -1098,10 +1660,11 @@ const checkHonroutou = (hand) => {
   if (!hasJihai) return false;
   return true;
 };
-const honroutouDefinition = createYakuDefinition(
-  HONROUTOU_YAKU,
-  checkHonroutou
-);
+const honroutouDefinition = createYaku(
+  HONROUTOU_YAKU.name,
+  HONROUTOU_YAKU.han.closed,
+  HONROUTOU_YAKU.han.open
+).require(checkHonroutou).build();
 const CHINROUTOU_YAKU = {
   name: "Chinroutou",
   han: {
@@ -1118,10 +1681,11 @@ const checkChinroutou = (hand) => {
   if (!allRoutou) return false;
   return true;
 };
-const chinroutouDefinition = createYakuDefinition(
-  CHINROUTOU_YAKU,
-  checkChinroutou
-);
+const chinroutouDefinition = createYaku(
+  CHINROUTOU_YAKU.name,
+  CHINROUTOU_YAKU.han.closed,
+  CHINROUTOU_YAKU.han.open
+).require(checkChinroutou).build();
 const SHOUSANGEN_YAKU = {
   name: "Shousangen",
   han: {
@@ -1134,22 +1698,15 @@ const checkShousangen = (hand) => {
     return false;
   }
   const sangenpai = [HaiKind.Haku, HaiKind.Hatsu, HaiKind.Chun];
-  let sangenKoutsuCount = 0;
-  const triplets = hand.fourMentsu.filter(
-    (m) => m.type === "Koutsu" || m.type === "Kantsu"
-  );
-  for (const triplet of triplets) {
-    if (sangenpai.includes(triplet.hais[0])) {
-      sangenKoutsuCount++;
-    }
-  }
+  const sangenKoutsuCount = countSpecificKoutsu(hand, sangenpai);
   const isSangenJantou = sangenpai.includes(hand.jantou.hais[0]);
   return sangenKoutsuCount === 2 && isSangenJantou;
 };
-const shousangenDefinition = createYakuDefinition(
-  SHOUSANGEN_YAKU,
-  checkShousangen
-);
+const shousangenDefinition = createYaku(
+  SHOUSANGEN_YAKU.name,
+  SHOUSANGEN_YAKU.han.closed,
+  SHOUSANGEN_YAKU.han.open
+).require(checkShousangen).build();
 const DAISANGEN_YAKU = {
   name: "Daisangen",
   han: {
@@ -1158,25 +1715,15 @@ const DAISANGEN_YAKU = {
   }
 };
 const checkDaisangen = (hand) => {
-  if (hand.type !== "Mentsu") {
-    return false;
-  }
   const sangenpai = [HaiKind.Haku, HaiKind.Hatsu, HaiKind.Chun];
-  let sangenKoutsuCount = 0;
-  const triplets = hand.fourMentsu.filter(
-    (m) => m.type === "Koutsu" || m.type === "Kantsu"
-  );
-  for (const triplet of triplets) {
-    if (sangenpai.includes(triplet.hais[0])) {
-      sangenKoutsuCount++;
-    }
-  }
+  const sangenKoutsuCount = countSpecificKoutsu(hand, sangenpai);
   return sangenKoutsuCount === 3;
 };
-const daisangenDefinition = createYakuDefinition(
-  DAISANGEN_YAKU,
-  checkDaisangen
-);
+const daisangenDefinition = createYaku(
+  DAISANGEN_YAKU.name,
+  DAISANGEN_YAKU.han.closed,
+  DAISANGEN_YAKU.han.open
+).require(checkDaisangen).build();
 const TSUUIISOU_YAKU = {
   name: "Tsuuiisou",
   han: {
@@ -1188,25 +1735,13 @@ const isJihai = (id) => {
   return id >= HaiKind.Ton && id <= HaiKind.Chun;
 };
 const checkTsuuiisou = (hand) => {
-  const allHais = [];
-  if (hand.type === "Mentsu") {
-    for (const mentsu of hand.fourMentsu) {
-      allHais.push(...mentsu.hais);
-    }
-    allHais.push(...hand.jantou.hais);
-  } else if (hand.type === "Chiitoitsu") {
-    for (const pair of hand.pairs) {
-      allHais.push(...pair.hais);
-    }
-  } else {
-    return false;
-  }
-  return allHais.every(isJihai);
+  return isAllHaisMatch(hand, isJihai);
 };
-const tsuuiisouDefinition = createYakuDefinition(
-  TSUUIISOU_YAKU,
-  checkTsuuiisou
-);
+const tsuuiisouDefinition = createYaku(
+  TSUUIISOU_YAKU.name,
+  TSUUIISOU_YAKU.han.closed,
+  TSUUIISOU_YAKU.han.open
+).require(checkTsuuiisou).build();
 const RYUUIISOU_YAKU = {
   name: "Ryuuiisou",
   han: {
@@ -1226,25 +1761,13 @@ const isGreen = (id) => {
   return GREEN_TILES.has(id);
 };
 const checkRyuuiisou = (hand) => {
-  const allHais = [];
-  if (hand.type === "Mentsu") {
-    for (const mentsu of hand.fourMentsu) {
-      allHais.push(...mentsu.hais);
-    }
-    allHais.push(...hand.jantou.hais);
-  } else if (hand.type === "Chiitoitsu") {
-    for (const pair of hand.pairs) {
-      allHais.push(...pair.hais);
-    }
-  } else {
-    return false;
-  }
-  return allHais.every(isGreen);
+  return isAllHaisMatch(hand, isGreen);
 };
-const ryuuiisouDefinition = createYakuDefinition(
-  RYUUIISOU_YAKU,
-  checkRyuuiisou
-);
+const ryuuiisouDefinition = createYaku(
+  RYUUIISOU_YAKU.name,
+  RYUUIISOU_YAKU.han.closed,
+  RYUUIISOU_YAKU.han.open
+).require(checkRyuuiisou).build();
 const SHOUSUUSHII_YAKU = {
   name: "Shousuushii",
   han: {
@@ -1262,22 +1785,15 @@ const checkShousuushii = (hand) => {
     HaiKind.Sha,
     HaiKind.Pei
   ];
-  let windKoutsuCount = 0;
-  const triplets = hand.fourMentsu.filter(
-    (m) => m.type === "Koutsu" || m.type === "Kantsu"
-  );
-  for (const triplet of triplets) {
-    if (windTiles.includes(triplet.hais[0])) {
-      windKoutsuCount++;
-    }
-  }
+  const windKoutsuCount = countSpecificKoutsu(hand, windTiles);
   const isWindJantou = windTiles.includes(hand.jantou.hais[0]);
   return windKoutsuCount === 3 && isWindJantou;
 };
-const shousuushiiDefinition = createYakuDefinition(
-  SHOUSUUSHII_YAKU,
-  checkShousuushii
-);
+const shousuushiiDefinition = createYaku(
+  SHOUSUUSHII_YAKU.name,
+  SHOUSUUSHII_YAKU.han.closed,
+  SHOUSUUSHII_YAKU.han.open
+).require(checkShousuushii).build();
 const DAISUUSHII_YAKU = {
   name: "Daisuushii",
   han: {
@@ -1287,30 +1803,20 @@ const DAISUUSHII_YAKU = {
   }
 };
 const checkDaisuushii = (hand) => {
-  if (hand.type !== "Mentsu") {
-    return false;
-  }
   const windTiles = [
     HaiKind.Ton,
     HaiKind.Nan,
     HaiKind.Sha,
     HaiKind.Pei
   ];
-  let windKoutsuCount = 0;
-  const triplets = hand.fourMentsu.filter(
-    (m) => m.type === "Koutsu" || m.type === "Kantsu"
-  );
-  for (const triplet of triplets) {
-    if (windTiles.includes(triplet.hais[0])) {
-      windKoutsuCount++;
-    }
-  }
+  const windKoutsuCount = countSpecificKoutsu(hand, windTiles);
   return windKoutsuCount === 4;
 };
-const daisuushiiDefinition = createYakuDefinition(
-  DAISUUSHII_YAKU,
-  checkDaisuushii
-);
+const daisuushiiDefinition = createYaku(
+  DAISUUSHII_YAKU.name,
+  DAISUUSHII_YAKU.han.closed,
+  DAISUUSHII_YAKU.han.open
+).require(checkDaisuushii).build();
 const CHUUREN_POUTOU_YAKU = {
   name: "ChuurenPoutou",
   han: {
@@ -1353,24 +1859,22 @@ const checkChuurenPoutou = (hand, context) => {
   }
   return true;
 };
-const chuurenPoutouDefinition = createYakuDefinition(
-  CHUUREN_POUTOU_YAKU,
-  checkChuurenPoutou
-);
+const chuurenPoutouDefinition = createYaku(
+  CHUUREN_POUTOU_YAKU.name,
+  CHUUREN_POUTOU_YAKU.han.closed,
+  CHUUREN_POUTOU_YAKU.han.open
+).require(checkChuurenPoutou).build();
 const checkKokushi = (hand) => {
   return hand.type === "Kokushi";
 };
 const KOKUSHI_HAN = {
-  closed: 13,
-  open: 0
+  closed: 13
 };
-const kokushiDefinition = createYakuDefinition(
-  {
-    name: "KokushiMusou",
-    han: KOKUSHI_HAN
-  },
-  checkKokushi
-);
+const kokushiDefinition = createYaku(
+  "KokushiMusou",
+  KOKUSHI_HAN.closed,
+  0
+).require(checkKokushi).build();
 const SANSHOKU_DOUJUN_YAKU = {
   name: "SanshokuDoujun",
   han: {
@@ -1388,37 +1892,30 @@ const checkSanshokuDoujun = (hand) => {
   if (shuntsuList.length < 3) {
     return false;
   }
-  for (let i = 0; i < shuntsuList.length; i++) {
-    for (let j = i + 1; j < shuntsuList.length; j++) {
-      for (let k = j + 1; k < shuntsuList.length; k++) {
-        const s1 = shuntsuList[i];
-        const s2 = shuntsuList[j];
-        const s3 = shuntsuList[k];
-        if (!s1 || !s2 || !s3) continue;
-        const firstHai1 = s1.hais[0];
-        const firstHai2 = s2.hais[0];
-        const firstHai3 = s3.hais[0];
-        const suit1 = Math.floor(firstHai1 / 9);
-        const suit2 = Math.floor(firstHai2 / 9);
-        const suit3 = Math.floor(firstHai3 / 9);
-        const suits = /* @__PURE__ */ new Set([suit1, suit2, suit3]);
-        if (suits.size !== 3) continue;
-        if (suit1 > 2 || suit2 > 2 || suit3 > 2) continue;
-        const num1 = firstHai1 % 9;
-        const num2 = firstHai2 % 9;
-        const num3 = firstHai3 % 9;
-        if (num1 === num2 && num2 === num3) {
-          return true;
-        }
-      }
+  for (const [s1, s2, s3] of getShuntsuCombinations3(shuntsuList)) {
+    const firstHai1 = s1.hais[0];
+    const firstHai2 = s2.hais[0];
+    const firstHai3 = s3.hais[0];
+    const suit1 = Math.floor(firstHai1 / 9);
+    const suit2 = Math.floor(firstHai2 / 9);
+    const suit3 = Math.floor(firstHai3 / 9);
+    const suits = /* @__PURE__ */ new Set([suit1, suit2, suit3]);
+    if (suits.size !== 3) continue;
+    if (suit1 > 2 || suit2 > 2 || suit3 > 2) continue;
+    const num1 = firstHai1 % 9;
+    const num2 = firstHai2 % 9;
+    const num3 = firstHai3 % 9;
+    if (num1 === num2 && num2 === num3) {
+      return true;
     }
   }
   return false;
 };
-const sanshokuDoujunDefinition = createYakuDefinition(
-  SANSHOKU_DOUJUN_YAKU,
-  checkSanshokuDoujun
-);
+const sanshokuDoujunDefinition = createYaku(
+  SANSHOKU_DOUJUN_YAKU.name,
+  SANSHOKU_DOUJUN_YAKU.han.closed,
+  SANSHOKU_DOUJUN_YAKU.han.open
+).require(checkSanshokuDoujun).build();
 const SANSHOKU_DOUKOU_YAKU = {
   name: "SanshokuDoukou",
   han: {
@@ -1463,10 +1960,11 @@ const checkSanshokuDoukou = (hand) => {
   }
   return false;
 };
-const sanshokuDoukouDefinition = createYakuDefinition(
-  SANSHOKU_DOUKOU_YAKU,
-  checkSanshokuDoukou
-);
+const sanshokuDoukouDefinition = createYaku(
+  SANSHOKU_DOUKOU_YAKU.name,
+  SANSHOKU_DOUKOU_YAKU.han.closed,
+  SANSHOKU_DOUKOU_YAKU.han.open
+).require(checkSanshokuDoukou).build();
 const IKKITSUUKAN_YAKU = {
   name: "Ikkitsuukan",
   han: {
@@ -1484,37 +1982,30 @@ const checkIkkitsuukan = (hand) => {
   if (shuntsuList.length < 3) {
     return false;
   }
-  for (let i = 0; i < shuntsuList.length; i++) {
-    for (let j = i + 1; j < shuntsuList.length; j++) {
-      for (let k = j + 1; k < shuntsuList.length; k++) {
-        const s1 = shuntsuList[i];
-        const s2 = shuntsuList[j];
-        const s3 = shuntsuList[k];
-        if (!s1 || !s2 || !s3) continue;
-        const firstHai1 = s1.hais[0];
-        const firstHai2 = s2.hais[0];
-        const firstHai3 = s3.hais[0];
-        const suit1 = Math.floor(firstHai1 / 9);
-        const suit2 = Math.floor(firstHai2 / 9);
-        const suit3 = Math.floor(firstHai3 / 9);
-        if (suit1 !== suit2 || suit2 !== suit3) continue;
-        if (suit1 > 2) continue;
-        const num1 = firstHai1 % 9;
-        const num2 = firstHai2 % 9;
-        const num3 = firstHai3 % 9;
-        const nums = /* @__PURE__ */ new Set([num1, num2, num3]);
-        if (nums.has(0) && nums.has(3) && nums.has(6)) {
-          return true;
-        }
-      }
+  for (const [s1, s2, s3] of getShuntsuCombinations3(shuntsuList)) {
+    const firstHai1 = s1.hais[0];
+    const firstHai2 = s2.hais[0];
+    const firstHai3 = s3.hais[0];
+    const suit1 = Math.floor(firstHai1 / 9);
+    const suit2 = Math.floor(firstHai2 / 9);
+    const suit3 = Math.floor(firstHai3 / 9);
+    if (suit1 !== suit2 || suit2 !== suit3) continue;
+    if (suit1 > 2) continue;
+    const num1 = firstHai1 % 9;
+    const num2 = firstHai2 % 9;
+    const num3 = firstHai3 % 9;
+    const nums = /* @__PURE__ */ new Set([num1, num2, num3]);
+    if (nums.has(0) && nums.has(3) && nums.has(6)) {
+      return true;
     }
   }
   return false;
 };
-const ikkitsuukanDefinition = createYakuDefinition(
-  IKKITSUUKAN_YAKU,
-  checkIkkitsuukan
-);
+const ikkitsuukanDefinition = createYaku(
+  IKKITSUUKAN_YAKU.name,
+  IKKITSUUKAN_YAKU.han.closed,
+  IKKITSUUKAN_YAKU.han.open
+).require(checkIkkitsuukan).build();
 const HONITSU_YAKU = {
   name: "Honitsu",
   han: {
@@ -1527,10 +2018,11 @@ const checkHonitsu = (hand) => {
   if (result === void 0) return false;
   return result.hasJihai && result.suupaiSuit !== void 0;
 };
-const honitsuDefinition = createYakuDefinition(
-  HONITSU_YAKU,
-  checkHonitsu
-);
+const honitsuDefinition = createYaku(
+  HONITSU_YAKU.name,
+  HONITSU_YAKU.han.closed,
+  HONITSU_YAKU.han.open
+).require(checkHonitsu).build();
 const CHINITSU_YAKU = {
   name: "Chinitsu",
   han: {
@@ -1543,10 +2035,11 @@ const checkChinitsu = (hand) => {
   if (result === void 0) return false;
   return !result.hasJihai && result.suupaiSuit !== void 0;
 };
-const chinitsuDefinition = createYakuDefinition(
-  CHINITSU_YAKU,
-  checkChinitsu
-);
+const chinitsuDefinition = createYaku(
+  CHINITSU_YAKU.name,
+  CHINITSU_YAKU.han.closed,
+  CHINITSU_YAKU.han.open
+).require(checkChinitsu).build();
 function createYakuhaiDefinition(name, tile) {
   const HAN_CONFIG = { closed: 1, open: 1 };
   const check = (hand) => {
@@ -1560,7 +2053,11 @@ function createYakuhaiDefinition(name, tile) {
     }
     return false;
   };
-  return createYakuDefinition({ name, han: HAN_CONFIG }, check);
+  return createYaku(
+    name,
+    HAN_CONFIG.closed,
+    HAN_CONFIG.open
+  ).require(check).build();
 }
 const hakuDefinition = createYakuhaiDefinition("Haku", HaiKind.Haku);
 const hatsuDefinition = createYakuhaiDefinition("Hatsu", HaiKind.Hatsu);
@@ -1569,12 +2066,13 @@ const definition = {
   name: "MenzenTsumo",
   han: { open: 0, closed: 1 }
 };
-const menzenTsumoDefinition = createYakuDefinition(
-  definition,
-  (hand, context) => {
-    return context.isMenzen && !!context.isTsumo;
-  }
-);
+const menzenTsumoDefinition = createYaku(
+  definition.name,
+  definition.han.closed,
+  definition.han.open
+).require((hand, context) => {
+  return context.isMenzen && !!context.isTsumo;
+}).build();
 const ALL_YAKU_DEFINITIONS = [
   tanyaoDefinition,
   pinfuDefinition,
@@ -1659,9 +2157,9 @@ function isExtendedMspz(input) {
 }
 function asExtendedMspz(input) {
   if (!isExtendedMspz(input)) {
-    throw new MspzParseError(`Invalid Extended MSPZ string: ${input}`);
+    return err(new MspzParseError(`Invalid Extended MSPZ string: ${input}`));
   }
-  return input;
+  return ok(input);
 }
 function isMspz(input) {
   return STANDARD_MSPZ_REGEX.test(input);
@@ -1674,28 +2172,36 @@ function parseExtendedMspz$1(input) {
   for (const char of input) {
     if (char === "[") {
       if (mode !== "closed")
-        throw new MspzParseError("Nested brackets are not supported");
+        return err(new MspzParseError("Nested brackets are not supported"));
       if (current.length > 0) closedParts.push(current);
       current = "[";
       mode = "open";
     } else if (char === "]") {
       if (mode !== "open")
-        throw new MspzParseError("Unexpected closing bracket ']'");
+        return err(new MspzParseError("Unexpected closing bracket ']'"));
       current += "]";
-      exposed.push(parseMentsuFromExtendedMspz(asExtendedMspz(current)));
+      const extMspzRes = asExtendedMspz(current);
+      if (extMspzRes.isErr()) return err(extMspzRes.error);
+      const mentsuRes = parseMentsuFromExtendedMspz(extMspzRes.value);
+      if (mentsuRes.isErr()) return err(mentsuRes.error);
+      exposed.push(mentsuRes.value);
       current = "";
       mode = "closed";
     } else if (char === "(") {
       if (mode !== "closed")
-        throw new MspzParseError("Nested parentheses are not supported");
+        return err(new MspzParseError("Nested parentheses are not supported"));
       if (current.length > 0) closedParts.push(current);
       current = "(";
       mode = "ankan";
     } else if (char === ")") {
       if (mode !== "ankan")
-        throw new MspzParseError("Unexpected closing parenthesis ')'");
+        return err(new MspzParseError("Unexpected closing parenthesis ')'"));
       current += ")";
-      exposed.push(parseMentsuFromExtendedMspz(asExtendedMspz(current)));
+      const extMspzRes = asExtendedMspz(current);
+      if (extMspzRes.isErr()) return err(extMspzRes.error);
+      const mentsuRes = parseMentsuFromExtendedMspz(extMspzRes.value);
+      if (mentsuRes.isErr()) return err(mentsuRes.error);
+      exposed.push(mentsuRes.value);
       current = "";
       mode = "closed";
     } else {
@@ -1704,15 +2210,17 @@ function parseExtendedMspz$1(input) {
   }
   if (current.length > 0) {
     if (mode !== "closed")
-      throw new MspzParseError("Unclosed bracket or parenthesis");
+      return err(new MspzParseError("Unclosed bracket or parenthesis"));
     closedParts.push(current);
   }
   const fullClosedMspz = closedParts.join("");
-  const closedIds = parseMspzToHaiKindIds(asMspz(fullClosedMspz));
-  return {
+  const mspzRes = asMspz(fullClosedMspz);
+  if (mspzRes.isErr()) return err(mspzRes.error);
+  const closedIds = parseMspzToHaiKindIds(mspzRes.value);
+  return ok({
     closed: closedIds,
     exposed
-  };
+  });
 }
 function parseMentsuFromExtendedMspz(block) {
   let mode;
@@ -1724,35 +2232,45 @@ function parseMentsuFromExtendedMspz(block) {
     mode = "ankan";
     content = block.slice(1, -1);
   } else {
-    throw new MspzParseError(
-      `Invalid Extended MSPZ block: ${block} (must be [...] or (...))`
+    return err(
+      new MspzParseError(
+        `Invalid Extended MSPZ block: ${block} (must be [...] or (...))`
+      )
     );
   }
-  const ids = parseMspzToHaiKindIds(asMspz(content));
+  const mspzRes = asMspz(content);
+  if (mspzRes.isErr()) return err(mspzRes.error);
+  const ids = parseMspzToHaiKindIds(mspzRes.value);
   if (ids.length === 0) {
-    throw new MspzParseError("Empty mentsu specification");
+    return err(new MspzParseError("Empty mentsu specification"));
   }
   const count = ids.length;
   const isAllSame = ids.every((id) => id === ids[0]);
   if (mode === "ankan") {
     if (count !== 4 || !isAllSame) {
-      throw new MspzParseError(
-        `Invalid Ankan: ${block} (must be 4 identical tiles)`
+      return err(
+        new MspzParseError(
+          `Invalid Ankan: ${block} (must be 4 identical tiles)`
+        )
       );
     }
     if (!isTuple4(ids)) {
-      throw new MspzParseError("Internal Error: ids length check mismatch");
+      return err(
+        new MspzParseError("Internal Error: ids length check mismatch")
+      );
     }
     const kantsu = {
       type: MentsuType.Kantsu,
       hais: ids
       // Ankan has no furo info (or minimal)
     };
-    return kantsu;
+    return ok(kantsu);
   }
   if (count === 4 && isAllSame) {
     if (!isTuple4(ids)) {
-      throw new MspzParseError("Internal Error: ids length check mismatch");
+      return err(
+        new MspzParseError("Internal Error: ids length check mismatch")
+      );
     }
     const kantsu = {
       type: MentsuType.Kantsu,
@@ -1760,10 +2278,12 @@ function parseMentsuFromExtendedMspz(block) {
       furo: { type: FuroType.Daiminkan, from: Tacha.Toimen }
       // Default
     };
-    return kantsu;
+    return ok(kantsu);
   } else if (count === 3 && isAllSame) {
     if (!isTuple3(ids)) {
-      throw new MspzParseError("Internal Error: ids length check mismatch");
+      return err(
+        new MspzParseError("Internal Error: ids length check mismatch")
+      );
     }
     const koutsu = {
       type: MentsuType.Koutsu,
@@ -1771,10 +2291,12 @@ function parseMentsuFromExtendedMspz(block) {
       furo: { type: FuroType.Pon, from: Tacha.Toimen }
       // Default
     };
-    return koutsu;
+    return ok(koutsu);
   } else if (count === 3) {
     if (!isTuple3(ids)) {
-      throw new MspzParseError("Internal Error: ids length check mismatch");
+      return err(
+        new MspzParseError("Internal Error: ids length check mismatch")
+      );
     }
     const shuntsu = {
       type: MentsuType.Shuntsu,
@@ -1782,17 +2304,19 @@ function parseMentsuFromExtendedMspz(block) {
       furo: { type: FuroType.Chi, from: Tacha.Kamicha }
       // Default
     };
-    return shuntsu;
+    return ok(shuntsu);
   }
-  throw new MspzParseError(
-    `Invalid Mentsu specification: ${block} (must be 3 or 4 tiles)`
+  return err(
+    new MspzParseError(
+      `Invalid Mentsu specification: ${block} (must be 3 or 4 tiles)`
+    )
   );
 }
 function asMspz(input) {
   if (!isMspz(input)) {
-    throw new MspzParseError(`Invalid MSPZ string: ${input}`);
+    return err(new MspzParseError(`Invalid MSPZ string: ${input}`));
   }
-  return input;
+  return ok(input);
 }
 function parseMspzToHaiKindIds(mspz) {
   const result = [];
@@ -1836,14 +2360,20 @@ function parseMspzToHaiKindIds(mspz) {
   return result;
 }
 function parseMspz(input) {
-  const ids = parseMspzToHaiKindIds(asMspz(input));
-  return {
+  const mspzRes = asMspz(input);
+  if (mspzRes.isErr()) return err(mspzRes.error);
+  const ids = parseMspzToHaiKindIds(mspzRes.value);
+  return ok({
     closed: ids,
     exposed: []
-  };
+  });
 }
 function parseExtendedMspz(input) {
-  return parseExtendedMspz$1(asExtendedMspz(input));
+  const extMspzRes = asExtendedMspz(input);
+  if (extMspzRes.isErr()) return err(extMspzRes.error);
+  const parsedRes = parseExtendedMspz$1(extMspzRes.value);
+  if (parsedRes.isErr()) return err(parsedRes.error);
+  return ok(parsedRes.value);
 }
 const FU_BASE = {
   NORMAL: 20,
@@ -2192,8 +2722,6 @@ export {
   Tacha,
   TahaiError,
   YAOCHU_KIND_IDS,
-  assertTehai13,
-  assertTehai14,
   calculateScoreForTehai,
   calculateShanten,
   classifyMachi,
@@ -2220,6 +2748,8 @@ export {
   kindIdToHaiType,
   parseExtendedMspz,
   parseMspz,
-  validateTehai
+  validateTehai,
+  validateTehai13,
+  validateTehai14
 };
 //# sourceMappingURL=index.js.map