cjk-number 0.3.0 → 0.4.0

package/README.md

@@ -39,20 +39,31 @@ import {
   hiragana
 } from "cjk-number";
 
-// parse string -> number/bigint
+// parse string -> number / bigint / string
 number.parse("一千零二十三"); // 1023
 number.parse("壹仟零貳拾參"); // 1023
 number.parse("負一百零二"); // -102
 number.parse("一點二三"); // 1.23
-number.parse("一無量大數", { preferBigInt: true }); // 10n ** 68n
+number.parse("一無量大數", { mode: "preferBigInt" }); // 10n ** 68n
+number.parse("一京點一", { mode: "exactDecimal" }); // "10000000000000000.1" (lossless)
 
-// format number/bigint -> string
+// format number/bigint/string -> CJK
 cjkIdeographic.parse(1023); // "一千零二十三"
 tradChineseFormal.parse(1023); // "壹仟零貳拾參"
 simpChineseFormal.parse(1023); // "壹仟零贰拾叁"
 koreanHangulFormal.parse(10n ** 68n); // "일무량대수"
 japaneseFormal.parse(10n ** 68n); // "壱無量大数"
 
+// arithmetic on CJK strings (exact BigFloat engine)
+tradChineseInformal.add(["一兆", "一點五"]); // "一兆零一點五"
+tradChineseInformal.subtract(["一京", "一兆"]); // "九千九百九十九兆"
+tradChineseInformal.multiply(["一億", "一億"]); // "一京"
+tradChineseInformal.divide(["五", "二"]); // "二點五"
+tradChineseInformal.modulo("五", "二"); // "一"
+tradChineseInformal.pow("二", "十"); // "一千零二十四"
+tradChineseInformal.abs("負一兆"); // "一兆"
+["三十", "二", "十一"].sort(tradChineseInformal.compare); // ["二", "十一", "三十"]
+
 // stem/branch
 cjkHeavenlyStem.parse(10); // "癸"
 cjkEarthlyBranch.parse(12); // "亥"
@@ -66,35 +77,66 @@ hiragana.parse(46); // "ん"
 
 ### number.parse(input, options?)
 
-Parses CJK text into number or bigint.
+Parses CJK text into a `number`, `bigint`, or exact decimal `string`.
 
 Options:
 
-- strict?: boolean
-- preferBigInt?: boolean
-- heavenlyStemMode?: "fixed" | "cyclic"
-- earthlyBranchMode?: "fixed" | "cyclic"
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `mode` | `"number" \| "preferBigInt" \| "exactDecimal"` | `"number"` | Controls the output numeric type |
+| `strict` | `boolean` | `false` | Rejects unsupported characters early |
+| `heavenlyStemMode` | `"fixed" \| "cyclic"` | `"fixed"` | How to handle out-of-range stem values |
+| `earthlyBranchMode` | `"fixed" \| "cyclic"` | `"fixed"` | How to handle out-of-range branch values |
+| `explicitTyping` | `ExplicitTyping` | `undefined` | Forces a specific CJK system for parsing |
+
+**`mode` values:**
+
+- `"number"` (default) — returns `number`; auto-promotes to `bigint` if the integer exceeds `Number.MAX_SAFE_INTEGER`.
+- `"preferBigInt"` — always returns `bigint` for integer parse paths.
+- `"exactDecimal"` — returns a lossless decimal `string` (e.g. `"10000000000000000.1"`), bypassing the `MAX_SAFE_INTEGER` restriction for mixed large+decimal values.
 
-Behavior summary:
+**`explicitTyping` values:**
 
-- If the value fits safely, returns number by default.
-- If out of Number safe range, returns bigint automatically.
-- If preferBigInt is true, always returns bigint for integer parse paths.
-- Decimal parse returns number.
+- Choose from any of the available system names (e.g., `"hiraganaIroha"`, `"tradChineseFormal"`, `"koreanHangulFormal"`) to force the parser to use that system's mapping specifically. This is useful for resolving conflicts between systems that share the same symbols (like Hiragana Gojuon vs Iroha).
 
 Examples:
 
 ```js
-number.parse("九千零七兆一", { preferBigInt: true }); // 9007000000000001n
+number.parse("九千零七兆一", { mode: "preferBigInt" }); // 9007000000000001n
 number.parse("癸"); // 10
 number.parse("亥"); // 12
-number.parse("壱京", { preferBigInt: true }); // 10n ** 16n
-number.parse("ぬ"); // 10 (iroha sequence symbol)
+number.parse("壱京", { mode: "preferBigInt" }); // 10n ** 16n
+number.parse("ぬ", { explicitTyping: "hiraganaIroha" }); // 10
+number.parse("ぬ"); // 23 (default gojuon sequence)
+number.parse("一京點一", { mode: "exactDecimal" }); // "10000000000000000.1"
 ```
 
 ### Formatters
 
-All formatters expose parse(value).
+All formatters expose the following methods:
+
+#### `parse(value)`
+
+Formats a `number`, `bigint`, or exact decimal `string` into a CJK numeral string.
+
+#### Arithmetic methods
+
+All numeric formatters (not cyclic/sequence ones) also expose arithmetic methods that accept CJK strings and return a CJK string in the same numeral system:
+
+```js
+tradChineseInformal.add(["一千", "二十三"]); // "一千零二十三"
+tradChineseInformal.subtract(["一京", "一兆"]); // "九千九百九十九兆"
+tradChineseInformal.multiply(["一億", "一億"]); // "一京"
+tradChineseInformal.divide(["五", "二"]); // "二點五"
+tradChineseInformal.modulo("五", "二"); // "一"
+tradChineseInformal.pow("二", "三"); // "八"
+tradChineseInformal.pow("二", 3); // "八" (exponent can be a number)
+tradChineseInformal.abs("負五十"); // "五十"
+tradChineseInformal.compare("三十", "二"); // 1
+["三十", "二", "十一"].sort(tradChineseInformal.compare); // ["二", "十一", "三十"]
+```
+
+All arithmetic uses a **zero-dependency BigFloat engine**: decimal points are scaled out to `BigInt` before any operation, so results like `"一兆" + "一點五"` are exact with no floating-point drift.
 
 Available formatters:
 
@@ -119,7 +161,7 @@ Examples:
 
 ```js
 tradChineseInformal.parse(-320); // "負三百二十"
-simpChineseInformal.parse(12.34); // "十二點三四"
+simpChineseInformal.parse(12.34); // "十二点三四"
 tradChineseFormal.parse(10n ** 68n); // "壹無量大數"
 simpChineseFormal.parse(10n ** 64n); // "壹不可思议"
 
@@ -197,10 +239,11 @@ number.parse("abc", { strict: true }); // throws SyntaxError
 
 Common thrown errors:
 
-- SyntaxError: unsupported/invalid text shape
-- RangeError: invalid formatter range in fixed sequence mode
-- RangeError: non-integer passed to integer-only paths
-- RangeError: decimal parse integer part exceeds Number.MAX_SAFE_INTEGER
+- `SyntaxError`: unsupported or invalid text shape
+- `RangeError`: invalid formatter range in fixed sequence mode
+- `RangeError`: non-integer passed to integer-only paths
+- `RangeError`: decimal parse integer part exceeds `Number.MAX_SAFE_INTEGER` — use `{ mode: "exactDecimal" }` to bypass
+- `RangeError`: division by zero in `divide` or `modulo`
 
 ## Development
 

package/dist/constants.d.ts

@@ -4,7 +4,7 @@ export declare const BRANCHES: readonly ["子", "丑", "寅", "卯", "辰", "巳
 export declare const KOREAN_HANGUL_DIGITS: readonly ["일", "이", "삼", "사", "오", "육", "칠", "팔", "구"];
 export declare const KOREAN_HANJA_FORMAL_DIGITS: readonly ["壹", "貳", "參", "四", "五", "六", "七", "八", "九"];
 export declare const KOREAN_HANJA_INFORMAL_DIGITS: readonly ["一", "二", "三", "四", "五", "六", "七", "八", "九"];
-export declare const JAPANESE_FORMAL_DIGITS: readonly ["壱", "弐", "参", "四", "五", "六", "七", "八", "九"];
+export declare const JAPANESE_FORMAL_DIGITS: readonly ["壱", "弍", "参", "四", "伍", "六", "七", "八", "九"];
 export declare const JAPANESE_INFORMAL_DIGITS: readonly ["一", "二", "三", "四", "五", "六", "七", "八", "九"];
 export declare const HIRAGANA: readonly ["あ", "い", "う", "え", "お", "か", "き", "く", "け", "こ", "さ", "し", "す", "せ", "そ", "た", "ち", "つ", "て", "と", "な", "に", "ぬ", "ね", "の", "は", "ひ", "ふ", "へ", "ほ", "ま", "み", "む", "め", "も", "や", "ゆ", "よ", "ら", "り", "る", "れ", "ろ", "わ", "を", "ん"];
 export declare const HIRAGANA_IROHA: readonly ["い", "ろ", "は", "に", "ほ", "へ", "と", "ち", "り", "ぬ", "る", "を", "わ", "か", "よ", "た", "れ", "そ", "つ", "ね", "な", "ら", "む", "う", "ゐ", "の", "お", "く", "や", "ま", "け", "ふ", "こ", "え", "て", "あ", "さ", "き", "ゆ", "め", "み", "し", "ゑ", "ひ", "も", "せ", "す"];

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,eAAO,MAAM,KAAK,6DAWR,CAAC;AACX,eAAO,MAAM,QAAQ,uEAaX,CAAC;AACX,eAAO,MAAM,oBAAoB,wDAUvB,CAAC;AACX,eAAO,MAAM,0BAA0B,wDAU7B,CAAC;AACX,eAAO,MAAM,4BAA4B,wDAU/B,CAAC;AACX,eAAO,MAAM,sBAAsB,wDAUzB,CAAC;AACX,eAAO,MAAM,wBAAwB,wDAU3B,CAAC;AACX,eAAO,MAAM,QAAQ,iPA+CX,CAAC;AACX,eAAO,MAAM,cAAc,sPAgDjB,CAAC;AACX,eAAO,MAAM,QAAQ,iPA+CX,CAAC;AACX,eAAO,MAAM,cAAc,sPAgDjB,CAAC;AAEX,eAAO,MAAM,gBAAgB,4GAkBnB,CAAC;AAEX,eAAO,MAAM,kBAAkB,4GAkBrB,CAAC;AAEX,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAgBzD,CAAC;AAEL,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA6BnD,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAO9C,CAAC;AAEF,eAAO,MAAM,cAAc,4GAkBjB,CAAC;AAEX,eAAO,MAAM,cAAc,4GAkBjB,CAAC;AAWX,eAAO,MAAM,iBAAiB,EAAE,QAM/B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAM7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,QAM/B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAM7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,QAM/B,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,QAMrC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,QAMvC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAMjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,QAMnC,CAAC;AAEF,eAAO,MAAM,cAAc,oBAAqC,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,eAAO,MAAM,KAAK,6DAWR,CAAC;AACX,eAAO,MAAM,QAAQ,uEAaX,CAAC;AACX,eAAO,MAAM,oBAAoB,wDAUvB,CAAC;AACX,eAAO,MAAM,0BAA0B,wDAU7B,CAAC;AACX,eAAO,MAAM,4BAA4B,wDAU/B,CAAC;AACX,eAAO,MAAM,sBAAsB,wDAUzB,CAAC;AACX,eAAO,MAAM,wBAAwB,wDAU3B,CAAC;AACX,eAAO,MAAM,QAAQ,iPA+CX,CAAC;AACX,eAAO,MAAM,cAAc,sPAgDjB,CAAC;AACX,eAAO,MAAM,QAAQ,iPA+CX,CAAC;AACX,eAAO,MAAM,cAAc,sPAgDjB,CAAC;AAEX,eAAO,MAAM,gBAAgB,4GAkBnB,CAAC;AAEX,eAAO,MAAM,kBAAkB,4GAkBrB,CAAC;AAEX,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAmBzD,CAAC;AAEL,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA6BnD,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAO9C,CAAC;AAEF,eAAO,MAAM,cAAc,4GAkBjB,CAAC;AAEX,eAAO,MAAM,cAAc,4GAkBjB,CAAC;AAWX,eAAO,MAAM,iBAAiB,EAAE,QAO/B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAO7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,QAO/B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAO7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,QAO/B,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,QAOrC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,QAOvC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAOjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,QAOnC,CAAC;AAEF,eAAO,MAAM,cAAc,oBAAqC,CAAC"}

package/dist/constants.js

@@ -59,10 +59,10 @@ export const KOREAN_HANJA_INFORMAL_DIGITS = [
 ];
 export const JAPANESE_FORMAL_DIGITS = [
     "壱",
-    "弐",
+    "弍",
     "参",
     "四",
-    "五",
+    "伍",
     "六",
     "七",
     "八",
@@ -315,7 +315,10 @@ export const SEQUENCE_SYMBOL_TO_NUMBER = (() => {
     const map = {};
     const put = (chars) => {
         chars.forEach((char, index) => {
-            map[char] = index + 1;
+            // Prioritize the first mapping we encounter (e.g. Gojuon over Iroha)
+            if (map[char] === undefined) {
+                map[char] = index + 1;
+            }
         });
     };
     put(STEMS);
@@ -413,6 +416,7 @@ export const TRAD_INFORMAL_SET = {
     digits: ["一", "二", "三", "四", "五", "六", "七", "八", "九"],
     smallUnits: ["十", "百", "千"],
     bigUnits: [...TRAD_BIG_UNITS],
+    dropTenOne: true,
 };
 export const TRAD_FORMAL_SET = {
     zero: "零",
@@ -420,6 +424,7 @@ export const TRAD_FORMAL_SET = {
     digits: ["壹", "貳", "參", "肆", "伍", "陸", "柒", "捌", "玖"],
     smallUnits: ["拾", "佰", "仟"],
     bigUnits: [...TRAD_BIG_UNITS],
+    dropTenOne: false,
 };
 export const SIMP_INFORMAL_SET = {
     zero: "零",
@@ -427,6 +432,7 @@ export const SIMP_INFORMAL_SET = {
     digits: ["一", "二", "三", "四", "五", "六", "七", "八", "九"],
     smallUnits: ["十", "百", "千"],
     bigUnits: [...SIMP_BIG_UNITS],
+    dropTenOne: true,
 };
 export const SIMP_FORMAL_SET = {
     zero: "零",
@@ -434,6 +440,7 @@ export const SIMP_FORMAL_SET = {
     digits: ["壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"],
     smallUnits: ["拾", "佰", "仟"],
     bigUnits: [...SIMP_BIG_UNITS],
+    dropTenOne: false,
 };
 export const KOREAN_HANGUL_SET = {
     zero: "영",
@@ -441,6 +448,7 @@ export const KOREAN_HANGUL_SET = {
     digits: [...KOREAN_HANGUL_DIGITS],
     smallUnits: ["십", "백", "천"],
     bigUnits: [...KOREAN_BIG_UNITS],
+    dropTenOne: false,
 };
 export const KOREAN_HANJA_FORMAL_SET = {
     zero: "零",
@@ -448,6 +456,7 @@ export const KOREAN_HANJA_FORMAL_SET = {
     digits: [...KOREAN_HANJA_FORMAL_DIGITS],
     smallUnits: ["拾", "佰", "仟"],
     bigUnits: [...TRAD_BIG_UNITS],
+    dropTenOne: false,
 };
 export const KOREAN_HANJA_INFORMAL_SET = {
     zero: "零",
@@ -455,6 +464,7 @@ export const KOREAN_HANJA_INFORMAL_SET = {
     digits: [...KOREAN_HANJA_INFORMAL_DIGITS],
     smallUnits: ["十", "百", "千"],
     bigUnits: [...TRAD_BIG_UNITS],
+    dropTenOne: true,
 };
 export const JAPANESE_FORMAL_SET = {
     zero: "零",
@@ -462,6 +472,7 @@ export const JAPANESE_FORMAL_SET = {
     digits: [...JAPANESE_FORMAL_DIGITS],
     smallUnits: ["拾", "百", "千"],
     bigUnits: [...JAPANESE_BIG_UNITS],
+    dropTenOne: false,
 };
 export const JAPANESE_INFORMAL_SET = {
     zero: "零",
@@ -469,5 +480,6 @@ export const JAPANESE_INFORMAL_SET = {
     digits: [...JAPANESE_INFORMAL_DIGITS],
     smallUnits: ["十", "百", "千"],
     bigUnits: [...JAPANESE_BIG_UNITS],
+    dropTenOne: true,
 };
 export const BIG_UNIT_ORDER = createBigUnitOrder(SIMP_BIG_UNITS);

package/dist/index.d.ts

@@ -1,54 +1,575 @@
 import { SystemParseOptions, NumberParseOptions, NumberLike } from "./types.js";
 export * from "./types.js";
 export declare const number: {
-    parse(input: string, options?: NumberParseOptions): number | bigint;
+    /**
+     * Parses a CJK numeric string into a number, bigint, or exact decimal string.
+     *
+     * @param input The CJK numeric string to parse.
+     * @param options Options defining how to handle the parse.
+     *   - `mode: "preferBigInt"` – return `bigint` for integers.
+     *   - `mode: "exactDecimal"` – return decimals as lossless strings, bypassing float limits.
+     * @returns The parsed number, bigint, or exact decimal string.
+     */
+    parse(input: string, options?: NumberParseOptions): number | bigint | string;
 };
 export declare const cjkIdeographic: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const tradChineseInformal: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const tradChineseFormal: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const simpChineseInformal: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const simpChineseFormal: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const koreanHangulFormal: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const koreanHanjaFormal: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const koreanHanjaInformal: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const japaneseFormal: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const japaneseInformal: {
+    /**
+     * Formats a numeric value into the specific CJK numeral system.
+     *
+     * @param value The number or bigint to format.
+     * @returns The formatted string representation in the respective CJK system.
+     */
     parse(value: NumberLike): string;
+    /**
+     * Adds multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to add.
+     * @returns The sum of the CJK numeric strings.
+     */
+    add(values: string[]): string;
+    /**
+     * Subtracts multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to subtract.
+     * @returns The difference of the CJK numeric strings.
+     */
+    subtract(values: string[]): string;
+    /**
+     * Multiplies multiple CJK numeric strings together.
+     * @param values The CJK numeric strings to multiply.
+     * @returns The product of the CJK numeric strings.
+     */
+    multiply(values: string[]): string;
+    /**
+     * Divides multiple CJK numeric strings from the first one.
+     * @param values The CJK numeric strings to divide.
+     * @returns The quotient of the CJK numeric strings.
+     */
+    divide(values: string[]): string;
+    /**
+     * Calculates the remainder of the first string divided by the second.
+     */
+    modulo(a: string, b: string): string;
+    /**
+     * Raises the first string to the power of the second string or a number.
+     */
+    pow(base: string, exponent: string | number): string;
+    /**
+     * Returns the absolute value of the string.
+     */
+    abs(value: string): string;
+    /**
+     * Compares two strings. Useful for Array.prototype.sort().
+     * @returns 1 if a > b, -1 if a < b, 0 if equal.
+     */
+    compare(a: string, b: string): number;
 };
 export declare const cjkHeavenlyStem: {
+    /**
+     * Formats a numeric value into the corresponding character of the cyclic sequence.
+     *
+     * @param value The number or bigint to format.
+     * @param options Options defining how to handle sequence boundaries (e.g., 'fixed' or 'cyclic' mode).
+     * @returns The character mapped to the specific sequence position.
+     */
     parse(value: NumberLike, options?: SystemParseOptions): string;
 };
 export declare const cjkEarthlyBranch: {
+    /**
+     * Formats a numeric value into the corresponding character of the cyclic sequence.
+     *
+     * @param value The number or bigint to format.
+     * @param options Options defining how to handle sequence boundaries (e.g., 'fixed' or 'cyclic' mode).
+     * @returns The character mapped to the specific sequence position.
+     */
     parse(value: NumberLike, options?: SystemParseOptions): string;
 };
 export declare const hiragana: {
+    /**
+     * Formats a numeric value into the corresponding character of the cyclic sequence.
+     *
+     * @param value The number or bigint to format.
+     * @param options Options defining how to handle sequence boundaries (e.g., 'fixed' or 'cyclic' mode).
+     * @returns The character mapped to the specific sequence position.
+     */
     parse(value: NumberLike, options?: SystemParseOptions): string;
 };
 export declare const hiraganaIroha: {
+    /**
+     * Formats a numeric value into the corresponding character of the cyclic sequence.
+     *
+     * @param value The number or bigint to format.
+     * @param options Options defining how to handle sequence boundaries (e.g., 'fixed' or 'cyclic' mode).
+     * @returns The character mapped to the specific sequence position.
+     */
     parse(value: NumberLike, options?: SystemParseOptions): string;
 };
 export declare const katakana: {
+    /**
+     * Formats a numeric value into the corresponding character of the cyclic sequence.
+     *
+     * @param value The number or bigint to format.
+     * @param options Options defining how to handle sequence boundaries (e.g., 'fixed' or 'cyclic' mode).
+     * @returns The character mapped to the specific sequence position.
+     */
     parse(value: NumberLike, options?: SystemParseOptions): string;
 };
 export declare const katakanaIroha: {
+    /**
+     * Formats a numeric value into the corresponding character of the cyclic sequence.
+     *
+     * @param value The number or bigint to format.
+     * @param options Options defining how to handle sequence boundaries (e.g., 'fixed' or 'cyclic' mode).
+     * @returns The character mapped to the specific sequence position.
+     */
     parse(value: NumberLike, options?: SystemParseOptions): string;
 };
 export declare const systems: {
@@ -57,7 +578,7 @@ export declare const systems: {
     koreanHangulFormal: readonly ["일", "이", "삼", "사", "오", "육", "칠", "팔", "구"];
     koreanHanjaFormal: readonly ["壹", "貳", "參", "四", "五", "六", "七", "八", "九"];
     koreanHanjaInformal: readonly ["一", "二", "三", "四", "五", "六", "七", "八", "九"];
-    japaneseFormal: readonly ["壱", "弐", "参", "四", "五", "六", "七", "八", "九"];
+    japaneseFormal: readonly ["壱", "弍", "参", "四", "伍", "六", "七", "八", "九"];
     japaneseInformal: readonly ["一", "二", "三", "四", "五", "六", "七", "八", "九"];
     hiragana: readonly ["あ", "い", "う", "え", "お", "か", "き", "く", "け", "こ", "さ", "し", "す", "せ", "そ", "た", "ち", "つ", "て", "と", "な", "に", "ぬ", "ね", "の", "は", "ひ", "ふ", "へ", "ほ", "ま", "み", "む", "め", "も", "や", "ゆ", "よ", "ら", "り", "る", "れ", "ろ", "わ", "を", "ん"];
     hiraganaIroha: readonly ["い", "ろ", "は", "に", "ほ", "へ", "と", "ち", "り", "ぬ", "る", "を", "わ", "か", "よ", "た", "れ", "そ", "つ", "ね", "な", "ら", "む", "う", "ゐ", "の", "お", "く", "や", "ま", "け", "ふ", "こ", "え", "て", "あ", "さ", "き", "ゆ", "め", "み", "し", "ゑ", "ひ", "も", "せ", "す"];

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,EAEV,MAAM,YAAY,CAAC;AA4BpB,cAAc,YAAY,CAAC;AA8b3B,eAAO,MAAM,MAAM;iBACJ,MAAM,YAAY,kBAAkB,GAAG,MAAM,GAAG,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,cAAc;iBAvBV,UAAU,GAAG,MAAM;CAuByB,CAAC;AAC9D,eAAO,MAAM,mBAAmB;iBAxBf,UAAU,GAAG,MAAM;CAwB8B,CAAC;AACnE,eAAO,MAAM,iBAAiB;iBAzBb,UAAU,GAAG,MAAM;CAyB0B,CAAC;AAC/D,eAAO,MAAM,mBAAmB;iBA1Bf,UAAU,GAAG,MAAM;CA0B8B,CAAC;AACnE,eAAO,MAAM,iBAAiB;iBA3Bb,UAAU,GAAG,MAAM;CA2B0B,CAAC;AAC/D,eAAO,MAAM,kBAAkB;iBA5Bd,UAAU,GAAG,MAAM;CA4B6B,CAAC;AAClE,eAAO,MAAM,iBAAiB;iBA7Bb,UAAU,GAAG,MAAM;CA6BkC,CAAC;AACvE,eAAO,MAAM,mBAAmB;iBA9Bf,UAAU,GAAG,MAAM;CA8BsC,CAAC;AAC3E,eAAO,MAAM,cAAc;iBA/BV,UAAU,GAAG,MAAM;CA+B2B,CAAC;AAChE,eAAO,MAAM,gBAAgB;iBAhCZ,UAAU,GAAG,MAAM;CAgC+B,CAAC;AAEpE,eAAO,MAAM,eAAe;iBAvBX,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CAuBd,CAAC;AACzD,eAAO,MAAM,gBAAgB;iBAxBZ,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CAwBV,CAAC;AAC7D,eAAO,MAAM,QAAQ;iBAzBJ,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CAyBlB,CAAC;AACrD,eAAO,MAAM,aAAa;iBA1BT,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CA0BP,CAAC;AAChE,eAAO,MAAM,QAAQ;iBA3BJ,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CA2BlB,CAAC;AACrD,eAAO,MAAM,aAAa;iBA5BT,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CA4BP,CAAC;AAEhE,eAAO,MAAM,OAAO;;;;;;;;;;;;CAYnB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,EAEX,MAAM,YAAY,CAAC;AA4BpB,cAAc,YAAY,CAAC;AA8oB3B,eAAO,MAAM,MAAM;IACjB;;;;;;;;OAQG;iBACU,MAAM,YAAY,kBAAkB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM;CAG7E,CAAC;AAEF,eAAO,MAAM,cAAc;IAvIvB;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CAsCoB,CAAC;AAC9D,eAAO,MAAM,mBAAmB;IAxI5B;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CAuCyB,CAAC;AACnE,eAAO,MAAM,iBAAiB;IAzI1B;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CAwCqB,CAAC;AAC/D,eAAO,MAAM,mBAAmB;IA1I5B;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CAyCyB,CAAC;AACnE,eAAO,MAAM,iBAAiB;IA3I1B;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CA0CqB,CAAC;AAC/D,eAAO,MAAM,kBAAkB;IA5I3B;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CA2CwB,CAAC;AAClE,eAAO,MAAM,iBAAiB;IA7I1B;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CA4C6B,CAAC;AACvE,eAAO,MAAM,mBAAmB;IA9I5B;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CA6CiC,CAAC;AAC3E,eAAO,MAAM,cAAc;IA/IvB;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CA8CsB,CAAC;AAChE,eAAO,MAAM,gBAAgB;IAhJzB;;;;;OAKG;iBACU,UAAU,GAAG,MAAM;IAMhC;;;;OAIG;gBACS,MAAM,EAAE,GAAG,MAAM;IAQ7B;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;qBACc,MAAM,EAAE,GAAG,MAAM;IAQlC;;;;OAIG;mBACY,MAAM,EAAE,GAAG,MAAM;IAQhC;;OAEG;cACO,MAAM,KAAK,MAAM,GAAG,MAAM;IAKpC;;OAEG;cACO,MAAM,YAAY,MAAM,GAAG,MAAM,GAAG,MAAM;IAKpD;;OAEG;eACQ,MAAM,GAAG,MAAM;IAU1B;;;OAGG;eACQ,MAAM,KAAK,MAAM,GAAG,MAAM;CA+C0B,CAAC;AAEpE,eAAO,MAAM,eAAe;IAvCxB;;;;;;OAMG;iBACU,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CAgCd,CAAC;AACzD,eAAO,MAAM,gBAAgB;IAxCzB;;;;;;OAMG;iBACU,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CAiCV,CAAC;AAC7D,eAAO,MAAM,QAAQ;IAzCjB;;;;;;OAMG;iBACU,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CAkClB,CAAC;AACrD,eAAO,MAAM,aAAa;IA1CtB;;;;;;OAMG;iBACU,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CAmCP,CAAC;AAChE,eAAO,MAAM,QAAQ;IA3CjB;;;;;;OAMG;iBACU,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CAoClB,CAAC;AACrD,eAAO,MAAM,aAAa;IA5CtB;;;;;;OAMG;iBACU,UAAU,YAAW,kBAAkB,GAAQ,MAAM;CAqCP,CAAC;AAEhE,eAAO,MAAM,OAAO;;;;;;;;;;;;CAYnB,CAAC"}

package/dist/index.js

@@ -34,6 +34,7 @@ const NORMALIZE_MAP = {
     팔: "八",
     구: "九",
     壱: "一",
+    弍: "二",
     弐: "二",
     参: "三",
     無量大數: "无量大数",
@@ -77,9 +78,10 @@ function normalizeInput(raw) {
     return result;
 }
 function toBigInt(value) {
-    if (typeof value === "bigint") {
+    if (typeof value === "bigint")
         return value;
-    }
+    if (typeof value === "string")
+        return BigInt(value);
     if (!Number.isFinite(value) || !Number.isInteger(value)) {
         throw new RangeError("Expected an integer value");
     }
@@ -163,7 +165,7 @@ function parseFractionDigits(raw) {
         }
         decimal += String(digit);
     }
-    return Number(`0.${decimal}`);
+    return decimal;
 }
 function toBestNumeric(value, preferBigInt) {
     if (preferBigInt) {
@@ -223,7 +225,7 @@ function formatSection(section, set) {
             pendingZero = false;
         }
         const isTenPosition = value === 10;
-        const canDropOne = isTenPosition && digit === 1 && output.length === 0;
+        const canDropOne = isTenPosition && digit === 1 && output.length === 0 && (set.dropTenOne ?? true);
         if (!canDropOne) {
             output += set.digits[digit - 1];
         }
@@ -267,17 +269,15 @@ function formatChineseNumber(value, set) {
     return negative ? `負${output}` : output;
 }
 function formatDecimal(value, set) {
-    if (!Number.isFinite(value)) {
+    if (typeof value === "number" && !Number.isFinite(value)) {
         throw new RangeError("Expected a finite number");
     }
-    if (Number.isInteger(value)) {
-        return formatChineseNumber(value, set);
-    }
-    const negative = value < 0;
-    const source = String(Math.abs(value));
-    const [intPart, fracPart] = source.split(".");
+    const source = String(value);
+    const negative = source.startsWith("-");
+    const absSource = negative ? source.slice(1) : source;
+    const [intPart = "0", fracPart] = absSource.split(".");
     if (!fracPart) {
-        return formatChineseNumber(value, set);
+        return formatChineseNumber(BigInt(intPart), set);
     }
     const intText = formatChineseNumber(BigInt(intPart), set);
     let fracText = "";
@@ -291,18 +291,35 @@ function formatDecimal(value, set) {
 function parseValue(input, options = {}) {
     const modeStem = options.heavenlyStemMode ?? "fixed";
     const modeBranch = options.earthlyBranchMode ?? "fixed";
-    try {
+    const explicit = options.explicitTyping;
+    if (explicit === "cjkHeavenlyStem") {
         return parseCycle(input, STEMS, modeStem);
     }
-    catch {
-        // Not a heavenly stem, continue to next parser.
-    }
-    try {
+    if (explicit === "cjkEarthlyBranch") {
         return parseCycle(input, BRANCHES, modeBranch);
     }
-    catch {
-        // Not an earthly branch, continue to sequence/numeric parsing.
+    if (explicit === "hiragana") {
+        const idx = HIRAGANA.indexOf(input);
+        if (idx >= 0)
+            return idx + 1;
+    }
+    if (explicit === "hiraganaIroha") {
+        const idx = HIRAGANA_IROHA.indexOf(input);
+        if (idx >= 0)
+            return idx + 1;
+    }
+    if (explicit === "katakana") {
+        const idx = KATAKANA.indexOf(input);
+        if (idx >= 0)
+            return idx + 1;
     }
+    if (explicit === "katakanaIroha") {
+        const idx = KATAKANA_IROHA.indexOf(input);
+        if (idx >= 0)
+            return idx + 1;
+    }
+    // Handle other explicit numeric systems by validating characters?
+    // Or just fall through if not a sequence symbol.
     const sequenceValue = SEQUENCE_SYMBOL_TO_NUMBER[input];
     if (sequenceValue !== undefined) {
         return sequenceValue;
@@ -319,35 +336,225 @@ function parseValue(input, options = {}) {
     if (body.includes(".")) {
         const [intRaw, fracRaw = ""] = body.split(".");
         const intValue = intRaw ? parseChineseNumber(intRaw) : 0n;
-        const fracValue = parseFractionDigits(fracRaw);
+        const fracDigits = parseFractionDigits(fracRaw);
+        if (options.mode === "exactDecimal") {
+            // Exact path: return a lossless decimal string.
+            const exact = `${intValue}.${fracDigits}`;
+            return negative ? `-${exact}` : exact;
+        }
+        // Legacy path: fall back to Number (may lose precision for very large integers).
         if (intValue > BigInt(Number.MAX_SAFE_INTEGER)) {
-            throw new RangeError("Decimal parse does not support integer part above MAX_SAFE_INTEGER");
+            throw new RangeError("Decimal parse does not support integer part above MAX_SAFE_INTEGER. Use { mode: \"exactDecimal\" } to bypass.");
         }
-        const composed = Number(intValue) + fracValue;
+        const composed = Number(intValue) + Number(`0.${fracDigits}`);
         return negative ? -composed : composed;
     }
     const parsed = parseChineseNumber(body);
     const signed = negative ? -parsed : parsed;
-    return toBestNumeric(signed, options.preferBigInt ?? false);
+    return toBestNumeric(signed, options.mode === "preferBigInt");
+}
+function toScaleFormat(val) {
+    const str = String(val);
+    const isNeg = str.startsWith("-");
+    const abs = isNeg ? str.slice(1) : str;
+    const parts = abs.split(".");
+    return {
+        intPart: parts[0] || "0",
+        fracPart: parts[1] || "",
+        isNeg,
+    };
+}
+function alignScales(a, b) {
+    const parsedA = toScaleFormat(a);
+    const parsedB = toScaleFormat(b);
+    const maxDec = Math.max(parsedA.fracPart.length, parsedB.fracPart.length);
+    const strA = parsedA.intPart + parsedA.fracPart.padEnd(maxDec, "0");
+    const strB = parsedB.intPart + parsedB.fracPart.padEnd(maxDec, "0");
+    const bigA = BigInt(strA) * (parsedA.isNeg ? -1n : 1n);
+    const bigB = BigInt(strB) * (parsedB.isNeg ? -1n : 1n);
+    return { bigA, bigB, scale: maxDec };
+}
+function applyScale(val, scale) {
+    let str = (val < 0n ? -val : val).toString();
+    if (scale === 0)
+        return (val < 0n ? "-" : "") + str;
+    str = str.padStart(scale + 1, "0");
+    const intPart = str.slice(0, -scale);
+    const fracPart = str.slice(-scale).replace(/0+$/, "");
+    const joined = fracPart ? `${intPart || "0"}.${fracPart}` : (intPart || "0");
+    return (val < 0n ? "-" : "") + joined;
+}
+function mixedAdd(a, b) {
+    const { bigA, bigB, scale } = alignScales(a, b);
+    return applyScale(bigA + bigB, scale);
+}
+function mixedSubtract(a, b) {
+    const { bigA, bigB, scale } = alignScales(a, b);
+    return applyScale(bigA - bigB, scale);
+}
+function mixedMultiply(a, b) {
+    const { bigA, bigB, scale } = alignScales(a, b);
+    return applyScale(bigA * bigB, scale * 2);
+}
+function mixedDivide(a, b) {
+    const { bigA, bigB } = alignScales(a, b);
+    if (bigB === 0n)
+        throw new RangeError("Division by zero");
+    const EXTRA = 16n;
+    const result = (bigA * (10n ** EXTRA)) / bigB;
+    return applyScale(result, Number(EXTRA));
+}
+function mixedModulo(a, b) {
+    const { bigA, bigB, scale } = alignScales(a, b);
+    return applyScale(bigA % bigB, scale);
+}
+function mixedPow(base, exponent) {
+    const parsedExp = toScaleFormat(exponent);
+    if (parsedExp.fracPart.length > 0)
+        return Number(base) ** Number(exponent);
+    const expNum = BigInt(parsedExp.intPart) * (parsedExp.isNeg ? -1n : 1n);
+    if (expNum < 0n)
+        return Number(base) ** Number(exponent);
+    const parsedBase = toScaleFormat(base);
+    const baseBig = BigInt(parsedBase.intPart + parsedBase.fracPart);
+    const scale = parsedBase.fracPart.length * Number(expNum);
+    const result = baseBig ** expNum;
+    return applyScale(parsedBase.isNeg && expNum % 2n !== 0n ? -result : result, scale);
+}
+function mixedCompare(a, b) {
+    const { bigA, bigB } = alignScales(a, b);
+    return bigA > bigB ? 1 : bigA < bigB ? -1 : 0;
 }
 function createSystem(set) {
     return {
+        /**
+         * Formats a numeric value into the specific CJK numeral system.
+         *
+         * @param value The number or bigint to format.
+         * @returns The formatted string representation in the respective CJK system.
+         */
         parse(value) {
-            if (typeof value === "number") {
+            if (String(value).includes(".")) {
                 return formatDecimal(value, set);
             }
             return formatChineseNumber(value, set);
         },
+        /**
+         * Adds multiple CJK numeric strings together.
+         * @param values The CJK numeric strings to add.
+         * @returns The sum of the CJK numeric strings.
+         */
+        add(values) {
+            if (values.length === 0) {
+                return set.zero;
+            }
+            const [first, ...rest] = values.map((v) => number.parse(v));
+            const sum = rest.reduce(mixedAdd, first);
+            return this.parse(sum);
+        },
+        /**
+         * Subtracts multiple CJK numeric strings from the first one.
+         * @param values The CJK numeric strings to subtract.
+         * @returns The difference of the CJK numeric strings.
+         */
+        subtract(values) {
+            if (values.length === 0) {
+                return set.zero;
+            }
+            const [first, ...rest] = values.map((v) => number.parse(v));
+            const diff = rest.reduce(mixedSubtract, first);
+            return this.parse(diff);
+        },
+        /**
+         * Multiplies multiple CJK numeric strings together.
+         * @param values The CJK numeric strings to multiply.
+         * @returns The product of the CJK numeric strings.
+         */
+        multiply(values) {
+            if (values.length === 0) {
+                return set.zero;
+            }
+            const [first, ...rest] = values.map((v) => number.parse(v));
+            const product = rest.reduce(mixedMultiply, first);
+            return this.parse(product);
+        },
+        /**
+         * Divides multiple CJK numeric strings from the first one.
+         * @param values The CJK numeric strings to divide.
+         * @returns The quotient of the CJK numeric strings.
+         */
+        divide(values) {
+            if (values.length === 0) {
+                return set.zero;
+            }
+            const [first, ...rest] = values.map((v) => number.parse(v));
+            const quotient = rest.reduce(mixedDivide, first);
+            return this.parse(quotient);
+        },
+        /**
+         * Calculates the remainder of the first string divided by the second.
+         */
+        modulo(a, b) {
+            const numA = number.parse(a);
+            const numB = number.parse(b);
+            return this.parse(mixedModulo(numA, numB));
+        },
+        /**
+         * Raises the first string to the power of the second string or a number.
+         */
+        pow(base, exponent) {
+            const numBase = number.parse(base);
+            const numExp = typeof exponent === "string" ? number.parse(exponent) : exponent;
+            return this.parse(mixedPow(numBase, numExp));
+        },
+        /**
+         * Returns the absolute value of the string.
+         */
+        abs(value) {
+            const num = number.parse(value);
+            if (typeof num === "bigint") {
+                return this.parse(num < 0n ? -num : num);
+            }
+            if (typeof num === "string") {
+                return this.parse(num.startsWith("-") ? num.slice(1) : num);
+            }
+            return this.parse(Math.abs(num));
+        },
+        /**
+         * Compares two strings. Useful for Array.prototype.sort().
+         * @returns 1 if a > b, -1 if a < b, 0 if equal.
+         */
+        compare(a, b) {
+            const numA = number.parse(a);
+            const numB = number.parse(b);
+            return mixedCompare(numA, numB);
+        },
     };
 }
 function createCyclicSystem(chars) {
     return {
+        /**
+         * Formats a numeric value into the corresponding character of the cyclic sequence.
+         *
+         * @param value The number or bigint to format.
+         * @param options Options defining how to handle sequence boundaries (e.g., 'fixed' or 'cyclic' mode).
+         * @returns The character mapped to the specific sequence position.
+         */
         parse(value, options = {}) {
             return fromCycle(value, chars, options.mode ?? "fixed");
         },
     };
 }
 export const number = {
+    /**
+     * Parses a CJK numeric string into a number, bigint, or exact decimal string.
+     *
+     * @param input The CJK numeric string to parse.
+     * @param options Options defining how to handle the parse.
+     *   - `mode: "preferBigInt"` – return `bigint` for integers.
+     *   - `mode: "exactDecimal"` – return decimals as lossless strings, bypassing float limits.
+     * @returns The parsed number, bigint, or exact decimal string.
+     */
     parse(input, options) {
         return parseValue(input, options);
     },

package/dist/types.d.ts

@@ -1,14 +1,74 @@
+/**
+ * Controls the cyclic mode of the heavenly stem and earthly branch.
+ * - `"fixed"` – always return fixed heavenly stem and earthly branch characters.
+ * - `"cyclic"` – return cyclic heavenly stem and earthly branch characters.
+ */
 export type CyclicMode = "fixed" | "cyclic";
+/**
+ * Options for parsing CJK text into a number.
+ */
 export interface SystemParseOptions {
     mode?: CyclicMode;
 }
+/**
+ * Controls the numeric output type of `number.parse`.
+ * - `"number"`       – always return a JS `number` (default).
+ * - `"preferBigInt"` – return `bigint` for integers; `number` only for decimals.
+ * - `"exactDecimal"` – return decimals as a lossless string (e.g. `"10000000000000000.5"`),
+ *                      bypassing JS float precision limits. Integers still return `bigint`.
+ */
+export type NumberMode = "number" | "preferBigInt" | "exactDecimal";
+/**
+ * Controls the explicit typing of the output.
+ * - `"cjkIdeographic"` – always return CJK ideographic characters.
+ * - `"tradChineseInformal"` – always return traditional Chinese informal characters.
+ * - `"tradChineseFormal"` – always return traditional Chinese formal characters.
+ * - `"simpChineseInformal"` – always return simplified Chinese informal characters.
+ * - `"simpChineseFormal"` – always return simplified Chinese formal characters.
+ * - `"cjkHeavenlyStem"` – always return CJK heavenly stem characters.
+ * - `"cjkEarthlyBranch"` – always return CJK earthly branch characters.
+ * - `"koreanHangulFormal"` – always return Korean hangul formal characters.
+ * - `"koreanHanjaFormal"` – always return Korean hanja formal characters.
+ * - `"koreanHanjaInformal"` – always return Korean hanja informal characters.
+ * - `"japaneseFormal"` – always return Japanese formal characters.
+ * - `"japaneseInformal"` – always return Japanese informal characters.
+ * - `"hiragana"` – always return hiragana characters.
+ * - `"hiraganaIroha"` – always return hiragana iroha characters.
+ * - `"katakana"` – always return katakana characters.
+ * - `"katakanaIroha"` – always return katakana iroha characters.
+ */
+export type ExplicitTyping = "cjkIdeographic" | "tradChineseInformal" | "tradChineseFormal" | "simpChineseInformal" | "simpChineseFormal" | "cjkHeavenlyStem" | "cjkEarthlyBranch" | "koreanHangulFormal" | "koreanHanjaFormal" | "koreanHanjaInformal" | "japaneseFormal" | "japaneseInformal" | "hiragana" | "hiraganaIroha" | "katakana" | "katakanaIroha";
 export interface NumberParseOptions {
+    /** Controls whether to reject unsupported characters early. Defaults to `false`. */
     strict?: boolean;
-    preferBigInt?: boolean;
+    /** Controls the numeric output type. Defaults to `"number"`. */
+    mode?: NumberMode;
+    /** Controls the heavenly stem mode. Defaults to `"fixed"`. */
     heavenlyStemMode?: CyclicMode;
+    /** Controls the earthly branch mode. Defaults to `"fixed"`. */
     earthlyBranchMode?: CyclicMode;
+    /**
+     * Controls the explicit typing of the output.
+     * - `"cjkIdeographic"` – always return CJK ideographic characters.
+     * - `"tradChineseInformal"` – always return traditional Chinese informal characters.
+     * - `"tradChineseFormal"` – always return traditional Chinese formal characters.
+     * - `"simpChineseInformal"` – always return simplified Chinese informal characters.
+     * - `"simpChineseFormal"` – always return simplified Chinese formal characters.
+     * - `"cjkHeavenlyStem"` – always return CJK heavenly stem characters.
+     * - `"cjkEarthlyBranch"` – always return CJK earthly branch characters.
+     * - `"koreanHangulFormal"` – always return Korean hangul formal characters.
+     * - `"koreanHanjaFormal"` – always return Korean hanja formal characters.
+     * - `"koreanHanjaInformal"` – always return Korean hanja informal characters.
+     * - `"japaneseFormal"` – always return Japanese formal characters.
+     * - `"japaneseInformal"` – always return Japanese informal characters.
+     * - `"hiragana"` – always return hiragana characters.
+     * - `"hiraganaIroha"` – always return hiragana iroha characters.
+     * - `"katakana"` – always return katakana characters.
+     * - `"katakanaIroha"` – always return katakana iroha characters.
+     */
+    explicitTyping?: ExplicitTyping;
 }
-export type NumberLike = number | bigint;
+export type NumberLike = number | bigint | string;
 export type DigitArray9 = readonly [
     string,
     string,
@@ -26,5 +86,6 @@ export interface DigitSet {
     digits: DigitArray9;
     smallUnits: [string, string, string];
     bigUnits: string[];
+    dropTenOne?: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE5C,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,UAAU,CAAC;IAC9B,iBAAiB,CAAC,EAAE,UAAU,CAAC;CAChC;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AAEzC,MAAM,MAAM,WAAW,GAAG,SAAS;IACjC,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;CACP,CAAC;AAEF,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,cAAc,GAAG,cAAc,CAAC;AAEpE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,oBAAoB,GAAG,mBAAmB,GAAG,qBAAqB,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,UAAU,GAAG,eAAe,GAAG,UAAU,GAAG,eAAe,CAAC;AAE9V,MAAM,WAAW,kBAAkB;IACjC,oFAAoF;IACpF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,gEAAgE;IAChE,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,8DAA8D;IAC9D,gBAAgB,CAAC,EAAE,UAAU,CAAC;IAC9B,+DAA+D;IAC/D,iBAAiB,CAAC,EAAE,UAAU,CAAC;IAC/B;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAElD,MAAM,MAAM,WAAW,GAAG,SAAS;IACjC,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;CACP,CAAC;AAEF,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cjk-number",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Convert between numbers and CJK number systems",
   "author": "tse-wei-chen",
   "repository": {