cjk-number 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,15 @@
 # cjk-number
 
-Convert numbers to and from CJK numeral systems, including traditional/simplified formats, heavenly stems, earthly branches, decimals, negatives, and very large BigInt values.
+Convert numbers between Arabic values and CJK numeral systems.
+
+Supported domains include:
+
+- Traditional and simplified Chinese numerals
+- Formal and informal variants
+- Heavenly stems and earthly branches
+- Korean and Japanese numeric kanji/hanja styles
+- Kana sequence systems (gojuon and iroha)
+- Negative numbers, decimals, and very large BigInt values
 
 ## Install
 
@@ -8,39 +17,56 @@ Convert numbers to and from CJK numeral systems, including traditional/simplifie
 npm install cjk-number
 ```
 
+## Runtime
+
+- Node.js 18+
+- ESM package
+
 ## Quick Start
 
 ```js
 import {
+  integer,
   cjkIdeographic,
-  cjkHeavenlyStem,
-  cjkEarthlyBranch,
-  tradChineseFormal,
   tradChineseInformal,
+  tradChineseFormal,
   simpChineseInformal,
   simpChineseFormal,
-  tradFormalPositionalUnits,
-  integer
+  cjkHeavenlyStem,
+  cjkEarthlyBranch,
+  koreanHangulFormal,
+  japaneseFormal,
+  hiragana
 } from "cjk-number";
 
+// parse string -> number/bigint
 integer.parseInt("一千零二十三"); // 1023
 integer.parseInt("壹仟零貳拾參"); // 1023
-integer.parseInt("癸"); // 10
-integer.parseInt("亥"); // 12
+integer.parseInt("負一百零二"); // -102
+integer.parseInt("一點二三"); // 1.23
+integer.parseInt("一無量大數", { preferBigInt: true }); // 10n ** 68n
 
+// format number/bigint -> string
+cjkIdeographic.parse(1023); // "一千零二十三"
 tradChineseFormal.parse(1023); // "壹仟零貳拾參"
 simpChineseFormal.parse(1023); // "壹仟零贰拾叁"
+koreanHangulFormal.parse(10n ** 68n); // "일무량대수"
+japaneseFormal.parse(10n ** 68n); // "壱無量大数"
+
+// stem/branch
 cjkHeavenlyStem.parse(10); // "癸"
 cjkEarthlyBranch.parse(12); // "亥"
 
-tradFormalPositionalUnits[68]; // "無量大數"
+// sequence systems
+hiragana.parse(1); // "あ"
+hiragana.parse(46); // "ん"
 ```
 
 ## API
 
 ### integer.parseInt(input, options?)
 
-Parses CJK string to number or bigint.
+Parses CJK text into number or bigint.
 
 Options:
 
@@ -49,16 +75,26 @@ Options:
 - heavenlyStemMode?: "fixed" | "cyclic"
 - earthlyBranchMode?: "fixed" | "cyclic"
 
+Behavior summary:
+
+- 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.
+
 Examples:
 
 ```js
-integer.parseInt("負一百零二"); // -102
-integer.parseInt("一點二三"); // 1.23
 integer.parseInt("九千零七兆一", { preferBigInt: true }); // 9007000000000001n
-integer.parseInt("一無量大數", { preferBigInt: true }); // 10n ** 68n
+integer.parseInt("癸"); // 10
+integer.parseInt("亥"); // 12
+integer.parseInt("壱京", { preferBigInt: true }); // 10n ** 16n
+integer.parseInt("ぬ"); // 10 (iroha sequence symbol)
 ```
 
-### Formatter.parse(value)
+### Formatters
+
+All formatters expose parse(value).
 
 Available formatters:
 
@@ -69,6 +105,15 @@ Available formatters:
 - simpChineseFormal
 - cjkHeavenlyStem
 - cjkEarthlyBranch
+- koreanHangulFormal
+- koreanHanjaFormal
+- koreanHanjaInformal
+- japaneseFormal
+- japaneseInformal
+- hiragana
+- hiraganaIroha
+- katakana
+- katakanaIroha
 
 Examples:
 
@@ -82,6 +127,38 @@ cjkHeavenlyStem.parse(11, { mode: "cyclic" }); // "甲"
 cjkEarthlyBranch.parse(13, { mode: "cyclic" }); // "子"
 ```
 
+## System Coverage
+
+### Full numeric systems (large-unit aware)
+
+These support complete number formatting/parsing and large units up to 無量大數 / 无量大数:
+
+- tradChineseInformal
+- tradChineseFormal
+- simpChineseInformal
+- simpChineseFormal
+- koreanHangulFormal
+- koreanHanjaFormal
+- koreanHanjaInformal
+- japaneseFormal
+- japaneseInformal
+
+### Sequence systems
+
+These are order-based symbol sequences, not positional decimal numerals:
+
+- cjkHeavenlyStem: 10 symbols
+- cjkEarthlyBranch: 12 symbols
+- hiragana: modern gojuon sequence (46 symbols)
+- katakana: modern gojuon sequence (46 symbols)
+- hiraganaIroha: traditional iroha sequence (47 symbols, includes ゐ and ゑ)
+- katakanaIroha: traditional iroha sequence (47 symbols, includes ヰ and ヱ)
+
+For sequence formatters:
+
+- fixed mode: only accepts 1..length
+- cyclic mode: wraps by sequence length
+
 ## Supported Large Units
 
 Traditional:
@@ -92,8 +169,43 @@ Simplified:
 
 万, 亿, 兆, 京, 垓, 秭, 穰, 沟, 涧, 正, 载, 极, 恒河沙, 阿僧祇, 那由他, 不可思议, 无量大数
 
+Korean naming set:
+
+만, 억, 조, 경, 해, 자, 양, 구, 간, 정, 재, 극, 항하사, 아승기, 나유타, 불가사의, 무량대수
+
+Japanese naming set:
+
+万, 億, 兆, 京, 垓, 秭, 穣, 溝, 澗, 正, 載, 極, 恒河沙, 阿僧祇, 那由他, 不可思議, 無量大数
+
+Note:
+
+- Historical texts may assign different powers for some high-order names.
+- This package uses a fixed modern 10^4-step progression across supported large-unit systems.
+
+## Strict Mode
+
+strict: true validates input characters against an allowed set.
+
+Use it when you want to reject unexpected symbols early.
+
+```js
+integer.parseInt("一億", { strict: true }); // ok
+integer.parseInt("abc", { strict: true }); // throws SyntaxError
+```
+
+## Error Cases
+
+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
+
 ## Development
 
+Install and verify:
+
 ```sh
 npm install
 npm run typecheck
@@ -101,6 +213,18 @@ npm test
 npm run build
 ```
 
+Release preflight:
+
+```sh
+npm run release:check
+```
+
+Dry-run package content:
+
+```sh
+npm run pack:check
+```
+
 Property-style test environment variables:
 
 - CJK_TEST_SEED (default: 20260327)
@@ -113,12 +237,6 @@ Example:
 CJK_TEST_SEED=42 CJK_TEST_SAMPLES=1000 CJK_TEST_MAX_DIGITS=69 npm test
 ```
 
-## Notes
-
-- Decimal parsing currently returns number.
-- Very large integers can return bigint when preferBigInt is enabled.
-- Heavenly stem and earthly branch parsing is auto-detected by symbol.
-
 ## License
 
 MIT

package/dist/index.d.ts

@@ -9,7 +9,6 @@ export interface IntegerParseOptions {
     earthlyBranchMode?: CyclicMode;
 }
 type IntegerLike = number | bigint;
-export declare const tradFormalPositionalUnits: string[];
 export declare const integer: {
     parseInt(input: string, options?: IntegerParseOptions): number | bigint;
 };
@@ -34,9 +33,45 @@ export declare const cjkHeavenlyStem: {
 export declare const cjkEarthlyBranch: {
     parse(value: IntegerLike, options?: SystemParseOptions): string;
 };
+export declare const koreanHangulFormal: {
+    parse(value: IntegerLike): string;
+};
+export declare const koreanHanjaFormal: {
+    parse(value: IntegerLike): string;
+};
+export declare const koreanHanjaInformal: {
+    parse(value: IntegerLike): string;
+};
+export declare const japaneseFormal: {
+    parse(value: IntegerLike): string;
+};
+export declare const japaneseInformal: {
+    parse(value: IntegerLike): string;
+};
+export declare const hiragana: {
+    parse(value: IntegerLike, options?: SystemParseOptions): string;
+};
+export declare const hiraganaIroha: {
+    parse(value: IntegerLike, options?: SystemParseOptions): string;
+};
+export declare const katakana: {
+    parse(value: IntegerLike, options?: SystemParseOptions): string;
+};
+export declare const katakanaIroha: {
+    parse(value: IntegerLike, options?: SystemParseOptions): string;
+};
 export declare const systems: {
     heavenlyStem: readonly ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"];
     earthlyBranch: readonly ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"];
+    koreanHangulFormal: readonly ["일", "이", "삼", "사", "오", "육", "칠", "팔", "구"];
+    koreanHanjaFormal: readonly ["壹", "貳", "參", "四", "五", "六", "七", "八", "九"];
+    koreanHanjaInformal: readonly ["一", "二", "三", "四", "五", "六", "七", "八", "九"];
+    japaneseFormal: readonly ["壱", "弐", "参", "四", "五", "六", "七", "八", "九"];
+    japaneseInformal: readonly ["一", "二", "三", "四", "五", "六", "七", "八", "九"];
+    hiragana: readonly ["あ", "い", "う", "え", "お", "か", "き", "く", "け", "こ", "さ", "し", "す", "せ", "そ", "た", "ち", "つ", "て", "と", "な", "に", "ぬ", "ね", "の", "は", "ひ", "ふ", "へ", "ほ", "ま", "み", "む", "め", "も", "や", "ゆ", "よ", "ら", "り", "る", "れ", "ろ", "わ", "を", "ん"];
+    hiraganaIroha: readonly ["い", "ろ", "は", "に", "ほ", "へ", "と", "ち", "り", "ぬ", "る", "を", "わ", "か", "よ", "た", "れ", "そ", "つ", "ね", "な", "ら", "む", "う", "ゐ", "の", "お", "く", "や", "ま", "け", "ふ", "こ", "え", "て", "あ", "さ", "き", "ゆ", "め", "み", "し", "ゑ", "ひ", "も", "せ", "す"];
+    katakana: readonly ["ア", "イ", "ウ", "エ", "オ", "カ", "キ", "ク", "ケ", "コ", "サ", "シ", "ス", "セ", "ソ", "タ", "チ", "ツ", "テ", "ト", "ナ", "ニ", "ヌ", "ネ", "ノ", "ハ", "ヒ", "フ", "ヘ", "ホ", "マ", "ミ", "ム", "メ", "モ", "ヤ", "ユ", "ヨ", "ラ", "リ", "ル", "レ", "ロ", "ワ", "ヲ", "ン"];
+    katakanaIroha: readonly ["イ", "ロ", "ハ", "ニ", "ホ", "ヘ", "ト", "チ", "リ", "ヌ", "ル", "ヲ", "ワ", "カ", "ヨ", "タ", "レ", "ソ", "ツ", "ネ", "ナ", "ラ", "ム", "ウ", "ヰ", "ノ", "オ", "ク", "ヤ", "マ", "ケ", "フ", "コ", "エ", "テ", "ア", "サ", "キ", "ユ", "メ", "ミ", "シ", "ヱ", "ヒ", "モ", "セ", "ス"];
 };
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.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,mBAAmB;IAClC,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,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAwGnC,eAAO,MAAM,yBAAyB,UAA6C,CAAC;AAqXpF,eAAO,MAAM,OAAO;oBACF,MAAM,YAAY,mBAAmB,GAAG,MAAM,GAAG,MAAM;CAGxE,CAAC;AAEF,eAAO,MAAM,cAAc;iBACZ,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,mBAAmB;iBACjB,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,iBAAiB;iBACf,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,mBAAmB;iBACjB,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,iBAAiB;iBACf,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,eAAe;iBACb,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,gBAAgB;iBACd,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,OAAO;;;CAGnB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.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,mBAAmB;IAClC,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,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AA8oBnC,eAAO,MAAM,OAAO;oBACF,MAAM,YAAY,mBAAmB,GAAG,MAAM,GAAG,MAAM;CAGxE,CAAC;AAEF,eAAO,MAAM,cAAc;iBACZ,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,mBAAmB;iBACjB,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,iBAAiB;iBACf,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,mBAAmB;iBACjB,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,iBAAiB;iBACf,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,eAAe;iBACb,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,gBAAgB;iBACd,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,kBAAkB;iBAChB,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,iBAAiB;iBACf,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,mBAAmB;iBACjB,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,cAAc;iBACZ,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,gBAAgB;iBACd,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,QAAQ;iBACN,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,aAAa;iBACX,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,QAAQ;iBACN,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,aAAa;iBACX,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;;;;;;;;CAYnB,CAAC"}

package/dist/index.js

@@ -1,7 +1,109 @@
 const STEMS = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"];
 const BRANCHES = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"];
+const KOREAN_HANGUL_DIGITS = ["일", "이", "삼", "사", "오", "육", "칠", "팔", "구"];
+const KOREAN_HANJA_FORMAL_DIGITS = ["壹", "貳", "參", "四", "五", "六", "七", "八", "九"];
+const KOREAN_HANJA_INFORMAL_DIGITS = ["一", "二", "三", "四", "五", "六", "七", "八", "九"];
+const JAPANESE_FORMAL_DIGITS = ["壱", "弐", "参", "四", "五", "六", "七", "八", "九"];
+const JAPANESE_INFORMAL_DIGITS = ["一", "二", "三", "四", "五", "六", "七", "八", "九"];
+const HIRAGANA = [
+    "あ", "い", "う", "え", "お",
+    "か", "き", "く", "け", "こ",
+    "さ", "し", "す", "せ", "そ",
+    "た", "ち", "つ", "て", "と",
+    "な", "に", "ぬ", "ね", "の",
+    "は", "ひ", "ふ", "へ", "ほ",
+    "ま", "み", "む", "め", "も",
+    "や", "ゆ", "よ",
+    "ら", "り", "る", "れ", "ろ",
+    "わ", "を", "ん"
+];
+const HIRAGANA_IROHA = [
+    "い", "ろ", "は", "に", "ほ", "へ", "と",
+    "ち", "り", "ぬ", "る", "を", "わ", "か",
+    "よ", "た", "れ", "そ", "つ", "ね", "な",
+    "ら", "む", "う", "ゐ", "の", "お", "く",
+    "や", "ま", "け", "ふ", "こ", "え", "て",
+    "あ", "さ", "き", "ゆ", "め", "み", "し",
+    "ゑ", "ひ", "も", "せ", "す"
+];
+const KATAKANA = [
+    "ア", "イ", "ウ", "エ", "オ",
+    "カ", "キ", "ク", "ケ", "コ",
+    "サ", "シ", "ス", "セ", "ソ",
+    "タ", "チ", "ツ", "テ", "ト",
+    "ナ", "ニ", "ヌ", "ネ", "ノ",
+    "ハ", "ヒ", "フ", "ヘ", "ホ",
+    "マ", "ミ", "ム", "メ", "モ",
+    "ヤ", "ユ", "ヨ",
+    "ラ", "リ", "ル", "レ", "ロ",
+    "ワ", "ヲ", "ン"
+];
+const KATAKANA_IROHA = [
+    "イ", "ロ", "ハ", "ニ", "ホ", "ヘ", "ト",
+    "チ", "リ", "ヌ", "ル", "ヲ", "ワ", "カ",
+    "ヨ", "タ", "レ", "ソ", "ツ", "ネ", "ナ",
+    "ラ", "ム", "ウ", "ヰ", "ノ", "オ", "ク",
+    "ヤ", "マ", "ケ", "フ", "コ", "エ", "テ",
+    "ア", "サ", "キ", "ユ", "メ", "ミ", "シ",
+    "ヱ", "ヒ", "モ", "セ", "ス"
+];
+const KOREAN_BIG_UNITS = [
+    "만",
+    "억",
+    "조",
+    "경",
+    "해",
+    "자",
+    "양",
+    "구",
+    "간",
+    "정",
+    "재",
+    "극",
+    "항하사",
+    "아승기",
+    "나유타",
+    "불가사의",
+    "무량대수"
+];
+const JAPANESE_BIG_UNITS = [
+    "万",
+    "億",
+    "兆",
+    "京",
+    "垓",
+    "秭",
+    "穣",
+    "溝",
+    "澗",
+    "正",
+    "載",
+    "極",
+    "恒河沙",
+    "阿僧祇",
+    "那由他",
+    "不可思議",
+    "無量大数"
+];
+const SEQUENCE_SYMBOL_TO_NUMBER = (() => {
+    const map = {};
+    const put = (chars) => {
+        chars.forEach((char, index) => {
+            map[char] = index + 1;
+        });
+    };
+    put(STEMS);
+    put(BRANCHES);
+    put(HIRAGANA);
+    put(HIRAGANA_IROHA);
+    put(KATAKANA);
+    put(KATAKANA_IROHA);
+    return map;
+})();
 const CANONICAL_DIGITS = {
     "零": 0,
+    "영": 0,
+    "령": 0,
     "〇": 0,
     "○": 0,
     "一": 1,
@@ -74,43 +176,74 @@ const SIMP_BIG_UNITS = [
     "不可思议",
     "无量大数"
 ];
-function buildFormalPositionalUnits(bigUnits) {
-    const result = [""];
-    for (const unit of bigUnits) {
-        result.push("拾", "佰", "仟", unit);
-    }
-    return result;
-}
 function createBigUnitOrder(units) {
     return units
         .map((unit, index) => [unit, 10n ** BigInt((index + 1) * 4)])
         .reverse();
 }
-export const tradFormalPositionalUnits = buildFormalPositionalUnits(TRAD_BIG_UNITS);
 const TRAD_INFORMAL_SET = {
     zero: "零",
+    point: "點",
     digits: ["一", "二", "三", "四", "五", "六", "七", "八", "九"],
     smallUnits: ["十", "百", "千"],
     bigUnits: [...TRAD_BIG_UNITS]
 };
 const TRAD_FORMAL_SET = {
     zero: "零",
+    point: "點",
     digits: ["壹", "貳", "參", "肆", "伍", "陸", "柒", "捌", "玖"],
     smallUnits: ["拾", "佰", "仟"],
     bigUnits: [...TRAD_BIG_UNITS]
 };
 const SIMP_INFORMAL_SET = {
     zero: "零",
+    point: "点",
     digits: ["一", "二", "三", "四", "五", "六", "七", "八", "九"],
     smallUnits: ["十", "百", "千"],
     bigUnits: [...SIMP_BIG_UNITS]
 };
 const SIMP_FORMAL_SET = {
     zero: "零",
+    point: "点",
     digits: ["壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"],
     smallUnits: ["拾", "佰", "仟"],
     bigUnits: [...SIMP_BIG_UNITS]
 };
+const KOREAN_HANGUL_SET = {
+    zero: "영",
+    point: "점",
+    digits: [...KOREAN_HANGUL_DIGITS],
+    smallUnits: ["십", "백", "천"],
+    bigUnits: [...KOREAN_BIG_UNITS]
+};
+const KOREAN_HANJA_FORMAL_SET = {
+    zero: "零",
+    point: "점",
+    digits: [...KOREAN_HANJA_FORMAL_DIGITS],
+    smallUnits: ["拾", "佰", "仟"],
+    bigUnits: [...TRAD_BIG_UNITS]
+};
+const KOREAN_HANJA_INFORMAL_SET = {
+    zero: "零",
+    point: "점",
+    digits: [...KOREAN_HANJA_INFORMAL_DIGITS],
+    smallUnits: ["十", "百", "千"],
+    bigUnits: [...TRAD_BIG_UNITS]
+};
+const JAPANESE_FORMAL_SET = {
+    zero: "零",
+    point: "点",
+    digits: [...JAPANESE_FORMAL_DIGITS],
+    smallUnits: ["拾", "百", "千"],
+    bigUnits: [...JAPANESE_BIG_UNITS]
+};
+const JAPANESE_INFORMAL_SET = {
+    zero: "零",
+    point: "点",
+    digits: [...JAPANESE_INFORMAL_DIGITS],
+    smallUnits: ["十", "百", "千"],
+    bigUnits: [...JAPANESE_BIG_UNITS]
+};
 const BIG_UNIT_ORDER = createBigUnitOrder(SIMP_BIG_UNITS);
 function normalizeInput(raw) {
     const trimmed = raw.trim();
@@ -119,9 +252,43 @@ function normalizeInput(raw) {
     }
     return trimmed
         .replace(/負|负/g, "-")
+        .replace(/점/g, ".")
         .replace(/點|点/g, ".")
+        .replace(/무량대수/g, "无量大数")
+        .replace(/불가사의/g, "不可思议")
+        .replace(/나유타/g, "那由他")
+        .replace(/아승기/g, "阿僧祇")
+        .replace(/항하사/g, "恒河沙")
+        .replace(/재/g, "载")
+        .replace(/정/g, "正")
+        .replace(/간/g, "涧")
+        .replace(/구/g, "沟")
+        .replace(/양/g, "穰")
+        .replace(/자/g, "秭")
+        .replace(/해/g, "垓")
+        .replace(/경/g, "京")
+        .replace(/조/g, "兆")
+        .replace(/억/g, "亿")
+        .replace(/만/g, "万")
+        .replace(/천/g, "千")
+        .replace(/백/g, "百")
+        .replace(/십/g, "十")
+        .replace(/일/g, "一")
+        .replace(/이/g, "二")
+        .replace(/삼/g, "三")
+        .replace(/사/g, "四")
+        .replace(/오/g, "五")
+        .replace(/육/g, "六")
+        .replace(/칠/g, "七")
+        .replace(/팔/g, "八")
+        .replace(/구/g, "九")
+        .replace(/壱/g, "一")
+        .replace(/弐/g, "二")
+        .replace(/参/g, "三")
         .replace(/無量大數/g, "无量大数")
+        .replace(/無量大数/g, "无量大数")
         .replace(/不可思議/g, "不可思议")
+        .replace(/穣/g, "穰")
         .replace(/恆河沙/g, "恒河沙")
         .replace(/載/g, "载")
         .replace(/極/g, "极")
@@ -151,7 +318,7 @@ function parseDigitsOnly(input) {
         }
         result += String(digit);
     }
-    return BigInt(result || "0");
+    return BigInt(result);
 }
 function parseSection(section) {
     if (!section) {
@@ -232,7 +399,7 @@ function toBestNumeric(value, preferBigInt) {
     return Number(value);
 }
 function validateStrictCharacters(input) {
-    const allowed = /^[0-9零〇○一二三四五六七八九十百千萬万億亿兆京垓秭穰溝沟澗涧正載载極极恆恒河沙阿僧祇那由他不思議议可無无量大數数點点壹貳贰參叁肆伍陸陆柒捌玖兩两拾佰仟負负.-]+$/;
+    const allowed = /^[0-9零〇○一二三四五六七八九十百千萬万億亿兆京垓秭穰溝沟澗涧正載载極极恆恒河沙阿僧祇那由他不思議议可無无量大數数點点점壹貳贰參叁肆伍陸陆柒捌玖兩两拾佰仟負负壱弐参ぁ-ゟ゠-ヿ가-힣.-]+$/;
     if (!allowed.test(input)) {
         throw new SyntaxError("Input contains unsupported characters in strict mode");
     }
@@ -261,9 +428,6 @@ function parseCycle(input, chars, mode) {
     return value;
 }
 function formatSection(section, set) {
-    if (section === 0) {
-        return "";
-    }
     const values = [1000, 100, 10, 1];
     const units = [set.smallUnits[2], set.smallUnits[1], set.smallUnits[0], ""];
     let output = "";
@@ -307,9 +471,7 @@ function formatChineseInteger(value, set) {
     for (let i = sections.length - 1; i >= 0; i -= 1) {
         const section = sections[i];
         if (section === 0) {
-            if (output) {
-                pendingZero = true;
-            }
+            pendingZero = Boolean(output);
             continue;
         }
         if (output && (pendingZero || section < 1000)) {
@@ -346,20 +508,28 @@ function formatDecimal(value, set) {
         const digit = Number(ch);
         fracText += digit === 0 ? set.zero : set.digits[digit - 1];
     }
-    const withSign = `${intText}點${fracText}`;
+    const withSign = `${intText}${set.point}${fracText}`;
     return negative ? `負${withSign}` : withSign;
 }
 function parseValue(input, options = {}) {
     const modeStem = options.heavenlyStemMode ?? "fixed";
     const modeBranch = options.earthlyBranchMode ?? "fixed";
-    const stemIndex = STEMS.indexOf(input);
-    if (stemIndex >= 0) {
+    try {
         return parseCycle(input, STEMS, modeStem);
     }
-    const branchIndex = BRANCHES.indexOf(input);
-    if (branchIndex >= 0) {
+    catch {
+        // Not a heavenly stem, continue to next parser.
+    }
+    try {
         return parseCycle(input, BRANCHES, modeBranch);
     }
+    catch {
+        // Not an earthly branch, continue to sequence/numeric parsing.
+    }
+    const sequenceValue = SEQUENCE_SYMBOL_TO_NUMBER[input];
+    if (sequenceValue !== undefined) {
+        return sequenceValue;
+    }
     const normalized = normalizeInput(input);
     if (options.strict) {
         validateStrictCharacters(normalized);
@@ -370,9 +540,9 @@ function parseValue(input, options = {}) {
         throw new SyntaxError("Missing numeric content");
     }
     if (body.includes(".")) {
-        const [intRaw, fracRaw] = body.split(".");
+        const [intRaw, fracRaw = ""] = body.split(".");
         const intValue = intRaw ? parseChineseInteger(intRaw) : 0n;
-        const fracValue = parseFractionDigits(fracRaw ?? "");
+        const fracValue = parseFractionDigits(fracRaw);
         if (intValue > BigInt(Number.MAX_SAFE_INTEGER)) {
             throw new RangeError("Decimal parse does not support integer part above MAX_SAFE_INTEGER");
         }
@@ -390,7 +560,7 @@ export const integer = {
 };
 export const cjkIdeographic = {
     parse(value) {
-        if (typeof value === "number" && !Number.isInteger(value)) {
+        if (typeof value === "number") {
             return formatDecimal(value, TRAD_INFORMAL_SET);
         }
         return formatChineseInteger(value, TRAD_INFORMAL_SET);
@@ -398,7 +568,7 @@ export const cjkIdeographic = {
 };
 export const tradChineseInformal = {
     parse(value) {
-        if (typeof value === "number" && !Number.isInteger(value)) {
+        if (typeof value === "number") {
             return formatDecimal(value, TRAD_INFORMAL_SET);
         }
         return formatChineseInteger(value, TRAD_INFORMAL_SET);
@@ -406,7 +576,7 @@ export const tradChineseInformal = {
 };
 export const tradChineseFormal = {
     parse(value) {
-        if (typeof value === "number" && !Number.isInteger(value)) {
+        if (typeof value === "number") {
             return formatDecimal(value, TRAD_FORMAL_SET);
         }
         return formatChineseInteger(value, TRAD_FORMAL_SET);
@@ -414,7 +584,7 @@ export const tradChineseFormal = {
 };
 export const simpChineseInformal = {
     parse(value) {
-        if (typeof value === "number" && !Number.isInteger(value)) {
+        if (typeof value === "number") {
             return formatDecimal(value, SIMP_INFORMAL_SET);
         }
         return formatChineseInteger(value, SIMP_INFORMAL_SET);
@@ -422,7 +592,7 @@ export const simpChineseInformal = {
 };
 export const simpChineseFormal = {
     parse(value) {
-        if (typeof value === "number" && !Number.isInteger(value)) {
+        if (typeof value === "number") {
             return formatDecimal(value, SIMP_FORMAL_SET);
         }
         return formatChineseInteger(value, SIMP_FORMAL_SET);
@@ -438,7 +608,76 @@ export const cjkEarthlyBranch = {
         return fromCycle(value, BRANCHES, options.mode ?? "fixed");
     }
 };
+export const koreanHangulFormal = {
+    parse(value) {
+        if (typeof value === "number") {
+            return formatDecimal(value, KOREAN_HANGUL_SET);
+        }
+        return formatChineseInteger(value, KOREAN_HANGUL_SET);
+    }
+};
+export const koreanHanjaFormal = {
+    parse(value) {
+        if (typeof value === "number") {
+            return formatDecimal(value, KOREAN_HANJA_FORMAL_SET);
+        }
+        return formatChineseInteger(value, KOREAN_HANJA_FORMAL_SET);
+    }
+};
+export const koreanHanjaInformal = {
+    parse(value) {
+        if (typeof value === "number") {
+            return formatDecimal(value, KOREAN_HANJA_INFORMAL_SET);
+        }
+        return formatChineseInteger(value, KOREAN_HANJA_INFORMAL_SET);
+    }
+};
+export const japaneseFormal = {
+    parse(value) {
+        if (typeof value === "number") {
+            return formatDecimal(value, JAPANESE_FORMAL_SET);
+        }
+        return formatChineseInteger(value, JAPANESE_FORMAL_SET);
+    }
+};
+export const japaneseInformal = {
+    parse(value) {
+        if (typeof value === "number") {
+            return formatDecimal(value, JAPANESE_INFORMAL_SET);
+        }
+        return formatChineseInteger(value, JAPANESE_INFORMAL_SET);
+    }
+};
+export const hiragana = {
+    parse(value, options = {}) {
+        return fromCycle(value, HIRAGANA, options.mode ?? "fixed");
+    }
+};
+export const hiraganaIroha = {
+    parse(value, options = {}) {
+        return fromCycle(value, HIRAGANA_IROHA, options.mode ?? "fixed");
+    }
+};
+export const katakana = {
+    parse(value, options = {}) {
+        return fromCycle(value, KATAKANA, options.mode ?? "fixed");
+    }
+};
+export const katakanaIroha = {
+    parse(value, options = {}) {
+        return fromCycle(value, KATAKANA_IROHA, options.mode ?? "fixed");
+    }
+};
 export const systems = {
     heavenlyStem: STEMS,
-    earthlyBranch: BRANCHES
+    earthlyBranch: BRANCHES,
+    koreanHangulFormal: KOREAN_HANGUL_DIGITS,
+    koreanHanjaFormal: KOREAN_HANJA_FORMAL_DIGITS,
+    koreanHanjaInformal: KOREAN_HANJA_INFORMAL_DIGITS,
+    japaneseFormal: JAPANESE_FORMAL_DIGITS,
+    japaneseInformal: JAPANESE_INFORMAL_DIGITS,
+    hiragana: HIRAGANA,
+    hiraganaIroha: HIRAGANA_IROHA,
+    katakana: KATAKANA,
+    katakanaIroha: KATAKANA_IROHA
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cjk-number",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Convert between numbers and CJK number systems",
   "author": "gary2",
   "repository": {
@@ -27,6 +27,7 @@
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
+    "coverage": "vitest run --coverage",
     "dev:test": "vitest",
     "pack:check": "npm pack --dry-run",
     "release:check": "npm run typecheck && npm run test && npm run build && npm run pack:check",
@@ -43,6 +44,7 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^25.5.0",
+    "@vitest/coverage-v8": "^4.1.2",
     "typescript": "^5.8.3",
     "vitest": "^4.1.2"
   }