@bukkentime/japanese-numeral 1.1.0-rc.0

package/.claude/settings.local.json

@@ -0,0 +1,16 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git checkout:*)",
+      "Bash(npm test:*)",
+      "Bash(npm install:*)",
+      "Bash(npx mocha:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(gh api:*)",
+      "Bash(gh pr:*)",
+      "Bash(git fetch:*)",
+      "Bash(npx tsc:*)"
+    ]
+  }
+}

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2

package/.github/workflows/build.yml

@@ -0,0 +1,42 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
+
+name: build
+
+on:
+  push:
+    branches:
+      - "*"
+    tags:
+      - "*"
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        node-version: [14, 16, 18, 20]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm install
+      - run: npm test
+      - run: npm run build
+
+  publish:
+    needs: test
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          registry-url: https://registry.npmjs.org/
+      - run: npm install
+      - run: npm run build
+      - run: npm publish --access=public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Geolonia Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+# @geolonia/japanese-numeral
+
+[![https://github.com/geolonia/wwwdiff/japanese-numeral](https://github.com/geolonia/japanese-numeral/workflows/test/badge.svg)](https://github.com/geolonia/japanese-numeral/actions?query=workflow%3Atest)
+[![npm version](https://badge.fury.io/js/%40geolonia%2Fjapanese-numeral.svg)](https://badge.fury.io/js/%40geolonia%2Fjapanese-numeral)
+
+Converts Japanese Kanji numeral <=> number.
+
+## Installation
+
+```bash
+$ npm install @geolonia/japanese-numeral --save
+```
+
+## Usage
+
+### kanji2number()
+
+Converts Japanese Kanji numeral to number.
+
+```javascript
+import { kanji2number } from '@geolonia/japanese-numeral'
+
+console.log(kanji2number('一千百十一兆一千百十一億一千百十一万一千百十一')) // 1111111111111111
+
+// `一千` を `千` と記述しても同じ結果になる。
+console.log(kanji2number('千百十一兆千百十一億千百十一万千百十一')) // 1111111111111111
+
+// 漢数字のゼロ `〇` を使用することも可能。
+console.log(kanji2number('二〇二〇')) // 2020
+
+// 数字と漢数字が混ざった表記にも対応
+console.log(kanji2number('2億3千430万')) // 234300000
+console.log(kanji2number('２億３千４５６万７８９０')) // 234567890 （数字は全角でも可）
+
+// 小数と漢数字の組み合わせにも対応（価格表記等）
+console.log(kanji2number("8.5万")); // 85000
+console.log(kanji2number("1.2兆")); // 1200000000000
+```
+
+### number2kanji()
+
+Converts number to Japanese Kanji numeral.
+
+```javascript
+import { number2kanji } from '@geolonia/japanese-numeral'
+
+console.log(number2kanji(1111111111111111)) // 千百十一兆千百十一億千百十一万千百十一
+```
+
+### findKanjiNumbers()
+
+Finds the Japanese numeral numbers as an array.
+
+```javascript
+import { findKanjiNumbers } from '@geolonia/japanese-numeral'
+
+console.log(findKanjiNumbers('今日は二千二十年十一月二十日です。')) // [ '二千二十', '十一', '二十' ]
+console.log(findKanjiNumbers('今日は二〇二〇年十一月二十日です。')) // [ '二〇二〇', '十一', '二十' ]
+console.log(findKanjiNumbers('わたしは二千二十億円もっています。')) // [ '二千二十億' ]
+console.log(findKanjiNumbers('わたしは二〇二〇億円もっています。')) // [ '二〇二〇億' ]
+console.log(findKanjiNumbers('わたしは1億2000万円もっています。')) // [ '1億2000万' ]
+console.log(findKanjiNumbers("家賃は8.5万円です。")); // [ '8.5万' ]
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export declare function kanji2number(japanese: string): number;
+export declare function number2kanji(num: number): string;
+export declare function findKanjiNumbers(text: string): string[];

package/dist/index.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findKanjiNumbers = exports.number2kanji = exports.kanji2number = void 0;
+const utils_1 = require("./utils");
+const japaneseNumerics_1 = require("./japaneseNumerics");
+function parseDecimalCoefficient(coefficient) {
+    const normalized = (0, utils_1.zen2han)(coefficient);
+    const match = normalized.match(/^([0-9]+)\.([0-9]+)$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        digits: BigInt(`${match[1]}${match[2]}`),
+        scale: 10n ** BigInt(match[2].length),
+    };
+}
+function kanji2number(japanese) {
+    japanese = (0, utils_1.normalize)(japanese);
+    if (japanese.match('〇') || japanese.match(/^[〇一二三四五六七八九]+$/)) {
+        for (const key in japaneseNumerics_1.default) {
+            const reg = new RegExp(key, 'g');
+            japanese = japanese.replace(reg, japaneseNumerics_1.default[key].toString());
+        }
+        return Number(japanese);
+    }
+    else {
+        let number = 0;
+        const { numbers, raw } = (0, utils_1.splitLargeNumberParts)(japanese);
+        // 万以上の数字を数値に変換
+        for (const key in utils_1.largeNumbers) {
+            if (numbers[key]) {
+                const decimal = parseDecimalCoefficient(raw[key]);
+                if (decimal) {
+                    const unit = BigInt(utils_1.largeNumbers[key]);
+                    if (unit % decimal.scale !== 0n) {
+                        throw new TypeError('The attribute of kanji2number() must be a Japanese numeral as integer.');
+                    }
+                    number = number + Number(decimal.digits * (unit / decimal.scale));
+                }
+                else {
+                    number = number + utils_1.largeNumbers[key] * numbers[key];
+                }
+            }
+        }
+        if (!Number.isInteger(number) || !Number.isInteger(numbers['千'])) {
+            throw new TypeError('The attribute of kanji2number() must be a Japanese numeral as integer.');
+        }
+        // 千以下の数字を足す
+        return number + numbers['千'];
+    }
+}
+exports.kanji2number = kanji2number;
+function number2kanji(num) {
+    if (!num.toString().match(/^[0-9]+$/)) {
+        throw new TypeError('The attribute of number2kanji() must be integer.');
+    }
+    const kanjiNumbers = Object.keys(japaneseNumerics_1.default);
+    let number = num;
+    let kanji = '';
+    // 万以上の数字を漢字に変換
+    for (const key in utils_1.largeNumbers) {
+        const n = Math.floor(number / utils_1.largeNumbers[key]);
+        if (n) {
+            number = number - (n * utils_1.largeNumbers[key]);
+            kanji = `${kanji}${(0, utils_1.n2kan)(n)}${key}`;
+        }
+    }
+    if (number) {
+        kanji = `${kanji}${(0, utils_1.n2kan)(number)}`;
+    }
+    return kanji || '〇';
+}
+exports.number2kanji = number2kanji;
+function findKanjiNumbers(text) {
+    const num = '([0-9０-９]*)|([〇一二三四五六七八九壱壹弐弍貳貮参參肆伍陸漆捌玖]*)';
+    const decimalArabicNum = '[0-9０-９]+[.．][0-9０-９]+';
+    const decimalSmallUnitPattern = `(${decimalArabicNum})(千|阡|仟|百|陌|佰|十|拾)`;
+    // Decimal coefficients are valid as standalone Arabic-decimal prefixes before a single unit.
+    const basePattern = `((${num})(千|阡|仟))?((${num})(百|陌|佰))?((${num})(十|拾))?(${num})?`;
+    const largeUnitPattern = `((${decimalArabicNum})|(${basePattern}))`;
+    const trailingPattern = `((${decimalSmallUnitPattern})|(${basePattern}))`;
+    const pattern = `(((${largeUnitPattern}兆)?(${largeUnitPattern}億)?(${largeUnitPattern}(万|萬))?${trailingPattern}))`;
+    const regex = new RegExp(pattern, 'g');
+    const matches = Array.from(text.matchAll(regex), (match) => ({
+        index: match.index || 0,
+        value: match[1],
+    }));
+    if (matches.length) {
+        return matches.filter((match) => {
+            const previous = match.index > 0 ? text[match.index - 1] : '';
+            if ((previous === '.' || previous === '．') || ((previous >= '0' && previous <= '9') || (previous >= '０' && previous <= '９')) && match.value.match(/^[0-9０-９]/)) {
+                return false;
+            }
+            if ((!match.value.match(/^[0-9０-９.．]+$/)) && (match.value.length && '兆' !== match.value && '億' !== match.value && '万' !== match.value && '萬' !== match.value)) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }).map((match) => match.value);
+    }
+    else {
+        return [];
+    }
+}
+exports.findKanjiNumbers = findKanjiNumbers;

package/dist/japaneseNumerics.d.ts

@@ -0,0 +1,5 @@
+type japaneseNumericsType = {
+    [key: string]: number;
+};
+declare const japaneseNumerics: japaneseNumericsType;
+export default japaneseNumerics;

package/dist/japaneseNumerics.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const japaneseNumerics = {
+    〇: 0,
+    一: 1,
+    二: 2,
+    三: 3,
+    四: 4,
+    五: 5,
+    六: 6,
+    七: 7,
+    八: 8,
+    九: 9,
+    '０': 0,
+    '１': 1,
+    '２': 2,
+    '３': 3,
+    '４': 4,
+    '５': 5,
+    '６': 6,
+    '７': 7,
+    '８': 8,
+    '９': 9,
+};
+exports.default = japaneseNumerics;

package/dist/oldJapaneseNumerics.d.ts

@@ -0,0 +1,5 @@
+type oldJapaneseNumericsType = {
+    [key: string]: string;
+};
+declare const oldJapaneseNumerics: oldJapaneseNumericsType;
+export default oldJapaneseNumerics;

package/dist/oldJapaneseNumerics.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const oldJapaneseNumerics = {
+    零: '〇',
+    壱: '一',
+    壹: '一',
+    弐: '二',
+    弍: '二',
+    貳: '二',
+    貮: '二',
+    参: '三',
+    參: '三',
+    肆: '四',
+    伍: '五',
+    陸: '六',
+    漆: '七',
+    捌: '八',
+    玖: '九',
+    拾: '十',
+    廿: '二十',
+    陌: '百',
+    佰: '百',
+    阡: '千',
+    仟: '千',
+    萬: '万',
+};
+exports.default = oldJapaneseNumerics;

package/dist/utils.d.ts

@@ -0,0 +1,40 @@
+type NumHash = {
+    [key: string]: number;
+};
+type StringHash = {
+    [key: string]: string;
+};
+export type SplitLargeNumberParts = {
+    numbers: NumHash;
+    raw: StringHash;
+};
+export declare const largeNumbers: NumHash;
+export declare const smallNumbers: NumHash;
+export declare function normalize(japanese: string): string;
+/**
+ * 漢数字を兆、億、万単位に分割する
+ */
+export declare function splitLargeNumber(japanese: string): NumHash;
+/**
+ * 漢数字を兆、億、万単位に分割し、各係数の生文字列も返す
+ */
+export declare function splitLargeNumberParts(japanese: string): SplitLargeNumberParts;
+/**
+ * 千単位以下の漢数字を数字に変換する（例: 三千 => 3000）
+ *
+ * @param japanese
+ */
+export declare function kan2n(japanese: string): number;
+/**
+ * Converts number less than 10000 to kanji.
+ *
+ * @param num
+ */
+export declare function n2kan(num: number): string;
+/**
+ * Converts double-width number to number as string.
+ *
+ * @param num
+ */
+export declare function zen2han(str: string): string;
+export {};

package/dist/utils.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zen2han = exports.n2kan = exports.kan2n = exports.splitLargeNumberParts = exports.splitLargeNumber = exports.normalize = exports.smallNumbers = exports.largeNumbers = void 0;
+const oldJapaneseNumerics_1 = require("./oldJapaneseNumerics");
+const japaneseNumerics_1 = require("./japaneseNumerics");
+exports.largeNumbers = { '兆': 1000000000000, '億': 100000000, '万': 10000 };
+exports.smallNumbers = { '千': 1000, '百': 100, '十': 10 };
+function parseDecimalValue(japanese) {
+    const normalized = zen2han(japanese);
+    const match = normalized.match(/^([0-9]+)\.([0-9]+)$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        digits: Number(`${match[1]}${match[2]}`),
+        scale: 10 ** match[2].length,
+    };
+}
+function normalize(japanese) {
+    for (const key in oldJapaneseNumerics_1.default) {
+        const reg = new RegExp(key, 'g');
+        japanese = japanese.replace(reg, oldJapaneseNumerics_1.default[key]);
+    }
+    return japanese;
+}
+exports.normalize = normalize;
+/**
+ * 漢数字を兆、億、万単位に分割する
+ */
+function splitLargeNumber(japanese) {
+    return splitLargeNumberParts(japanese).numbers;
+}
+exports.splitLargeNumber = splitLargeNumber;
+/**
+ * 漢数字を兆、億、万単位に分割し、各係数の生文字列も返す
+ */
+function splitLargeNumberParts(japanese) {
+    let kanji = japanese;
+    const numbers = {};
+    const raw = {};
+    for (const key in exports.largeNumbers) {
+        const reg = new RegExp(`(.+)${key}`);
+        const match = kanji.match(reg);
+        if (match) {
+            raw[key] = match[1];
+            numbers[key] = kan2n(match[1]);
+            kanji = kanji.replace(match[0], '');
+        }
+        else {
+            raw[key] = '';
+            numbers[key] = 0;
+        }
+    }
+    if (kanji) {
+        raw['千'] = kanji;
+        numbers['千'] = kan2n(kanji);
+    }
+    else {
+        raw['千'] = '';
+        numbers['千'] = 0;
+    }
+    return { numbers, raw };
+}
+exports.splitLargeNumberParts = splitLargeNumberParts;
+/**
+ * 千単位以下の漢数字を数字に変換する（例: 三千 => 3000）
+ *
+ * @param japanese
+ */
+function kan2n(japanese) {
+    if (japanese.match(/^[0-9]+$/)) {
+        return Number(japanese);
+    }
+    let kanji = zen2han(japanese);
+    // Allow decimal coefficients (e.g. "8.5" from "8.5万") so that
+    // kan2n returns 8.5 and the caller can multiply by the unit value.
+    // Previously this fell through to the kanji-character loop, which
+    // has no mapping for "." and silently produced an incorrect result.
+    if (kanji.match(/^[0-9]+\.[0-9]+$/)) {
+        return Number(kanji);
+    }
+    const decimalUnitMatch = kanji.match(/^([0-9]+\.[0-9]+)(千|百|十)$/);
+    if (decimalUnitMatch) {
+        const decimal = parseDecimalValue(decimalUnitMatch[1]);
+        const unit = exports.smallNumbers[decimalUnitMatch[2]];
+        if (!decimal || unit % decimal.scale !== 0) {
+            return NaN;
+        }
+        return decimal.digits * (unit / decimal.scale);
+    }
+    let number = 0;
+    for (const key in exports.smallNumbers) {
+        const reg = new RegExp(`(.*)${key}`);
+        const match = kanji.match(reg);
+        if (match) {
+            let n = 1;
+            if (match[1]) {
+                if (match[1].match(/^[0-9]+$/)) {
+                    n = Number(match[1]);
+                }
+                else {
+                    n = japaneseNumerics_1.default[match[1]];
+                }
+            }
+            number = number + (n * exports.smallNumbers[key]);
+            kanji = kanji.replace(match[0], '');
+        }
+    }
+    if (kanji) {
+        if (kanji.match(/^[0-9]+$/)) {
+            number = number + Number(kanji);
+        }
+        else {
+            for (let index = 0; index < kanji.length; index++) {
+                const char = kanji[index];
+                const digit = kanji.length - index - 1;
+                number = number + japaneseNumerics_1.default[char] * (10 ** digit);
+            }
+        }
+    }
+    return number;
+}
+exports.kan2n = kan2n;
+/**
+ * Converts number less than 10000 to kanji.
+ *
+ * @param num
+ */
+function n2kan(num) {
+    const kanjiNumbers = Object.keys(japaneseNumerics_1.default);
+    let number = num;
+    let kanji = '';
+    for (const key in exports.smallNumbers) {
+        const n = Math.floor(number / exports.smallNumbers[key]);
+        if (n) {
+            number = number - (n * exports.smallNumbers[key]);
+            if (1 === n) {
+                kanji = `${kanji}${key}`;
+            }
+            else {
+                kanji = `${kanji}${kanjiNumbers[n]}${key}`;
+            }
+        }
+    }
+    if (number) {
+        kanji = `${kanji}${kanjiNumbers[number]}`;
+    }
+    return kanji;
+}
+exports.n2kan = n2kan;
+/**
+ * Converts double-width number to number as string.
+ *
+ * @param num
+ */
+function zen2han(str) {
+    return str.replace(/[０-９]/g, (s) => {
+        return String.fromCharCode(s.charCodeAt(0) - 0xFEE0);
+    }).replace(/．/g, '.');
+}
+exports.zen2han = zen2han;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@bukkentime/japanese-numeral",
+  "version": "1.1.0-rc.0",
+  "description": "Converts Japanese Kanji numeral to number.",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "mocha -r ts-node/register test/*.ts",
+    "test:watch": "npm test -- --watch --watch-files src/**/*.ts --watch-files test/**/*.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/geolonia/japanese-numeral.git"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "author": "Geolonia Inc.",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/chai": "^4.3.5",
+    "@types/mocha": "^10.0.1",
+    "chai": "^4.3.8",
+    "mocha": "^10.2.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  }
+}

package/src/index.ts

@@ -0,0 +1,114 @@
+import { normalize, splitLargeNumberParts, largeNumbers, n2kan, zen2han } from './utils'
+import japaneseNumerics from './japaneseNumerics'
+
+function parseDecimalCoefficient(coefficient: string) {
+  const normalized = zen2han(coefficient)
+  const match = normalized.match(/^([0-9]+)\.([0-9]+)$/)
+
+  if (!match) {
+    return null
+  }
+
+  return {
+    digits: BigInt(`${match[1]}${match[2]}`),
+    scale: 10n ** BigInt(match[2].length),
+  }
+}
+
+export function kanji2number(japanese: string) {
+  japanese = normalize(japanese)
+
+  if (japanese.match('〇') || japanese.match(/^[〇一二三四五六七八九]+$/)) {
+    for (const key in japaneseNumerics) {
+      const reg = new RegExp(key, 'g')
+      japanese = japanese.replace(reg, japaneseNumerics[key].toString())
+    }
+
+    return Number(japanese)
+  } else {
+    let number = 0
+    const { numbers, raw } = splitLargeNumberParts(japanese)
+
+    // 万以上の数字を数値に変換
+    for (const key in largeNumbers) {
+      if (numbers[key]) {
+        const decimal = parseDecimalCoefficient(raw[key])
+        if (decimal) {
+          const unit = BigInt(largeNumbers[key])
+          if (unit % decimal.scale !== 0n) {
+            throw new TypeError('The attribute of kanji2number() must be a Japanese numeral as integer.')
+          }
+
+          number = number + Number(decimal.digits * (unit / decimal.scale))
+        } else {
+          number = number + largeNumbers[key] * numbers[key]
+        }
+      }
+    }
+
+    if (!Number.isInteger(number) || !Number.isInteger(numbers['千'])) {
+      throw new TypeError('The attribute of kanji2number() must be a Japanese numeral as integer.')
+    }
+
+    // 千以下の数字を足す
+    return number + numbers['千']
+  }
+}
+
+
+export function number2kanji(num: number) {
+  if (!num.toString().match(/^[0-9]+$/)) {
+    throw new TypeError('The attribute of number2kanji() must be integer.')
+  }
+
+  const kanjiNumbers = Object.keys(japaneseNumerics)
+  let number = num
+  let kanji = ''
+
+  // 万以上の数字を漢字に変換
+  for (const key in largeNumbers) {
+    const n = Math.floor(number / largeNumbers[key])
+    if (n) {
+      number = number - (n * largeNumbers[key])
+      kanji = `${kanji}${n2kan(n)}${key}`
+    }
+  }
+
+  if (number) {
+    kanji = `${kanji}${n2kan(number)}`
+  }
+
+  return kanji || '〇'
+}
+
+export function findKanjiNumbers(text: string) {
+  const num = '([0-9０-９]*)|([〇一二三四五六七八九壱壹弐弍貳貮参參肆伍陸漆捌玖]*)'
+  const decimalArabicNum = '[0-9０-９]+[.．][0-9０-９]+'
+  const decimalSmallUnitPattern = `(${decimalArabicNum})(千|阡|仟|百|陌|佰|十|拾)`
+  // Decimal coefficients are valid as standalone Arabic-decimal prefixes before a single unit.
+  const basePattern = `((${num})(千|阡|仟))?((${num})(百|陌|佰))?((${num})(十|拾))?(${num})?`
+  const largeUnitPattern = `((${decimalArabicNum})|(${basePattern}))`
+  const trailingPattern = `((${decimalSmallUnitPattern})|(${basePattern}))`
+  const pattern = `(((${largeUnitPattern}兆)?(${largeUnitPattern}億)?(${largeUnitPattern}(万|萬))?${trailingPattern}))`
+  const regex = new RegExp(pattern, 'g')
+  const matches = Array.from(text.matchAll(regex), (match) => ({
+    index: match.index || 0,
+    value: match[1],
+  }))
+  if (matches.length) {
+    return matches.filter((match) => {
+      const previous = match.index > 0 ? text[match.index - 1] : ''
+      if ((previous === '.' || previous === '．') || ((previous >= '0' && previous <= '9') || (previous >= '０' && previous <= '９')) && match.value.match(/^[0-9０-９]/)) {
+        return false
+      }
+
+      if ((! match.value.match(/^[0-9０-９.．]+$/)) && (match.value.length && '兆' !== match.value && '億' !== match.value && '万' !== match.value && '萬' !== match.value)) {
+        return true
+      } else {
+        return false
+      }
+    }).map((match) => match.value)
+  } else {
+    return []
+  }
+}

package/src/japaneseNumerics.ts

@@ -0,0 +1,28 @@
+type japaneseNumericsType = {
+  [key: string]: number
+}
+
+const japaneseNumerics: japaneseNumericsType = {
+  〇: 0,
+  一: 1,
+  二: 2,
+  三: 3,
+  四: 4,
+  五: 5,
+  六: 6,
+  七: 7,
+  八: 8,
+  九: 9,
+  '０': 0,
+  '１': 1,
+  '２': 2,
+  '３': 3,
+  '４': 4,
+  '５': 5,
+  '６': 6,
+  '７': 7,
+  '８': 8,
+  '９': 9,
+}
+
+export default japaneseNumerics

package/src/oldJapaneseNumerics.ts

@@ -0,0 +1,30 @@
+type oldJapaneseNumericsType = {
+  [key: string]: string
+}
+
+const oldJapaneseNumerics: oldJapaneseNumericsType = {
+  零: '〇',
+  壱: '一',
+  壹: '一',
+  弐: '二',
+  弍: '二',
+  貳: '二',
+  貮: '二',
+  参: '三',
+  參: '三',
+  肆: '四',
+  伍: '五',
+  陸: '六',
+  漆: '七',
+  捌: '八',
+  玖: '九',
+  拾: '十',
+  廿: '二十',
+  陌: '百',
+  佰: '百',
+  阡: '千',
+  仟: '千',
+  萬: '万',
+}
+
+export default oldJapaneseNumerics

package/src/utils.ts

@@ -0,0 +1,185 @@
+import oldJapaneseNumerics from './oldJapaneseNumerics'
+import japaneseNumerics from './japaneseNumerics'
+
+type NumHash = {
+  [key: string]: number;
+}
+
+type StringHash = {
+  [key: string]: string;
+}
+
+export type SplitLargeNumberParts = {
+  numbers: NumHash;
+  raw: StringHash;
+}
+
+export const largeNumbers: NumHash = { '兆': 1000000000000, '億': 100000000, '万': 10000 }
+export const smallNumbers: NumHash = { '千': 1000, '百': 100, '十': 10 }
+
+function parseDecimalValue(japanese: string) {
+  const normalized = zen2han(japanese)
+  const match = normalized.match(/^([0-9]+)\.([0-9]+)$/)
+
+  if (!match) {
+    return null
+  }
+
+  return {
+    digits: Number(`${match[1]}${match[2]}`),
+    scale: 10 ** match[2].length,
+  }
+}
+
+export function normalize(japanese: string) {
+  for (const key in oldJapaneseNumerics) {
+    const reg = new RegExp(key, 'g')
+    japanese = japanese.replace(reg, oldJapaneseNumerics[key])
+  }
+  return japanese
+}
+
+/**
+ * 漢数字を兆、億、万単位に分割する
+ */
+export function splitLargeNumber(japanese: string) {
+  return splitLargeNumberParts(japanese).numbers
+}
+
+/**
+ * 漢数字を兆、億、万単位に分割し、各係数の生文字列も返す
+ */
+export function splitLargeNumberParts(japanese: string): SplitLargeNumberParts {
+  let kanji = japanese
+  const numbers:NumHash = {}
+  const raw:StringHash = {}
+  for (const key in largeNumbers) {
+    const reg = new RegExp(`(.+)${key}`)
+    const match = kanji.match(reg)
+    if (match) {
+      raw[key] = match[1]
+      numbers[key] = kan2n(match[1])
+      kanji = kanji.replace(match[0], '')
+    } else {
+      raw[key] = ''
+      numbers[key] = 0
+    }
+  }
+
+  if (kanji) {
+    raw['千'] = kanji
+    numbers['千'] = kan2n(kanji)
+  } else {
+    raw['千'] = ''
+    numbers['千'] = 0
+  }
+
+  return { numbers, raw }
+}
+
+/**
+ * 千単位以下の漢数字を数字に変換する（例: 三千 => 3000）
+ *
+ * @param japanese
+ */
+export function kan2n(japanese: string) {
+  if (japanese.match(/^[0-9]+$/)) {
+    return Number(japanese)
+  }
+
+  let kanji = zen2han(japanese)
+
+  // Allow decimal coefficients (e.g. "8.5" from "8.5万") so that
+  // kan2n returns 8.5 and the caller can multiply by the unit value.
+  // Previously this fell through to the kanji-character loop, which
+  // has no mapping for "." and silently produced an incorrect result.
+  if (kanji.match(/^[0-9]+\.[0-9]+$/)) {
+    return Number(kanji)
+  }
+
+  const decimalUnitMatch = kanji.match(/^([0-9]+\.[0-9]+)(千|百|十)$/)
+  if (decimalUnitMatch) {
+    const decimal = parseDecimalValue(decimalUnitMatch[1])
+    const unit = smallNumbers[decimalUnitMatch[2]]
+
+    if (!decimal || unit % decimal.scale !== 0) {
+      return NaN
+    }
+
+    return decimal.digits * (unit / decimal.scale)
+  }
+
+  let number = 0
+  for (const key in smallNumbers) {
+    const reg = new RegExp(`(.*)${key}`)
+    const match = kanji.match(reg)
+    if (match) {
+      let n = 1
+      if (match[1]) {
+        if (match[1].match(/^[0-9]+$/)) {
+          n = Number(match[1])
+        } else {
+          n = japaneseNumerics[match[1]]
+        }
+      }
+
+      number = number + (n * smallNumbers[key])
+
+      kanji = kanji.replace(match[0], '')
+    }
+  }
+
+  if (kanji) {
+    if (kanji.match(/^[0-9]+$/)) {
+      number = number + Number(kanji)
+    } else {
+      for (let index = 0; index < kanji.length; index++) {
+        const char = kanji[index];
+        const digit = kanji.length - index - 1
+        number = number + japaneseNumerics[char] * (10 ** digit)
+
+      }
+    }
+  }
+
+  return number
+}
+
+/**
+ * Converts number less than 10000 to kanji.
+ *
+ * @param num
+ */
+export function n2kan(num: number) {
+  const kanjiNumbers = Object.keys(japaneseNumerics)
+  let number = num
+  let kanji = ''
+  for (const key in smallNumbers) {
+    const n = Math.floor(number / smallNumbers[key])
+    if (n) {
+      number = number - (n * smallNumbers[key])
+      if (1 === n) {
+        kanji = `${kanji}${key}`
+      } else {
+        kanji = `${kanji}${kanjiNumbers[n]}${key}`
+      }
+    }
+  }
+
+  if (number) {
+    kanji = `${kanji}${kanjiNumbers[number]}`
+  }
+
+  return kanji
+}
+
+/**
+ * Converts double-width number to number as string.
+ *
+ * @param num
+ */
+export function zen2han(str: string) {
+  return str.replace(/[０-９]/g, (s) => {
+      return String.fromCharCode(s.charCodeAt(0) - 0xFEE0);
+  }).replace(/．/g, '.');
+}

package/test/test.ts

@@ -0,0 +1,204 @@
+import { kanji2number, number2kanji, findKanjiNumbers } from '../src'
+import { assert } from 'chai'
+
+describe('Tests for japaneseNumeral.', () => {
+  it('Japanese numeric should be parsed as numbers.', () => {
+    assert.deepEqual(kanji2number('〇'), 0)
+    assert.deepEqual(kanji2number('零'), 0)
+    assert.deepEqual(kanji2number('一千百十一兆一千百十一億一千百十一万一千百十一'), 1111111111111111)
+    assert.deepEqual(kanji2number('一千百十一兆一千百十一億一千百十一万'), 1111111111110000)
+    assert.deepEqual(kanji2number('一千百十一兆一千百十一億一千百十一'), 1111111100001111)
+    assert.deepEqual(kanji2number('百十一'), 111)
+    assert.deepEqual(kanji2number('三億八'), 300000008)
+    assert.deepEqual(kanji2number('三百八'), 308)
+    assert.deepEqual(kanji2number('三五〇'), 350)
+    assert.deepEqual(kanji2number('三〇八'), 308)
+    assert.deepEqual(kanji2number('二〇二〇'), 2020)
+    assert.deepEqual(kanji2number('十'), 10)
+    assert.deepEqual(kanji2number('二千'), 2000)
+    assert.deepEqual(kanji2number('壱万'), 10000)
+    assert.deepEqual(kanji2number('弍万'), 20000)
+    assert.deepEqual(kanji2number('一二三四'), 1234)
+    assert.deepEqual(kanji2number('千二三四'), 1234)
+    assert.deepEqual(kanji2number('千二百三四'), 1234)
+    assert.deepEqual(kanji2number('千二百三十四'), 1234)
+    assert.deepEqual(kanji2number('壱阡陌拾壱兆壱阡陌拾壱億壱阡陌拾壱萬壱阡陌拾壱'), 1111111111111111)
+    assert.deepEqual(kanji2number('壱仟佰拾壱兆壱仟佰拾壱億壱仟佰拾壱萬壱仟佰拾壱'), 1111111111111111)
+  });
+
+  it('Number should be converted to Japanese kanji', () => {
+    assert.deepEqual(number2kanji(0), '〇')
+    assert.deepEqual(number2kanji(1110), '千百十')
+    assert.deepEqual(number2kanji(1111111111111111), '千百十一兆千百十一億千百十一万千百十一')
+    assert.deepEqual(number2kanji(1111113111111111), '千百十一兆千百三十一億千百十一万千百十一')
+    assert.deepEqual(number2kanji(1000000000000000), '千兆')
+    assert.deepEqual(number2kanji(1200000), '百二十万')
+    assert.deepEqual(number2kanji(18), '十八')
+    assert.deepEqual(number2kanji(100100000), '一億十万')
+  });
+
+  it('should returns the instance of TypeError', () => {
+    // @ts-ignore
+    assert.throws(() => number2kanji('hello'), TypeError)
+
+    assert.throws(() => kanji2number('三あ八'), TypeError)
+    assert.throws(() => kanji2number('あ'), TypeError)
+    assert.throws(() => kanji2number('三五十'), TypeError)
+  });
+
+  it('should find Japanese Kanji numbers.', () => {
+    assert.deepEqual([ '二千二十', '十一', '二十' ], findKanjiNumbers('今日は二千二十年十一月二十日です。'))
+    assert.deepEqual([ '二〇二〇', '十一', '二十' ], findKanjiNumbers('今日は二〇二〇年十一月二十日です。'))
+    assert.deepEqual([ '二千二十億' ], findKanjiNumbers('わたしは二千二十億円もっています。'))
+    assert.deepEqual([ '二〇二〇億' ], findKanjiNumbers('わたしは二〇二〇億円もっています。'))
+    assert.deepEqual([ '八百六十三' ], findKanjiNumbers('今日のランチは八百六十三円でした。'))
+    assert.deepEqual([ '八六三' ], findKanjiNumbers('今日のランチは八六三円でした。'))
+    assert.deepEqual([ '三千' ], findKanjiNumbers('今月のお小遣いは三千円です。'))
+    assert.deepEqual([ '五', '千' ], findKanjiNumbers('青森県五所川原市金木町喜良市千苅６２−８'))
+    assert.deepEqual([ '1億2000万' ], findKanjiNumbers('わたしは1億2000万円もっています。'))
+    assert.deepEqual([ '六' ], findKanjiNumbers('香川県仲多度郡まんのう町勝浦字家六２０９４番地１'))
+  })
+
+  it('should not find Japanese Kanji numbers.', () => {
+    assert.deepEqual(0, findKanjiNumbers('栗沢町万字寿町').length)
+    assert.deepEqual(0, findKanjiNumbers('私は億ションに住んでいます').length)
+  })
+
+  it('should find mixed Japanese Kanji numbers.', () => {
+    assert.deepEqual([ '２千20', '十一', '二十' ], findKanjiNumbers('今日は２千20年十一月二十日です。'))
+  })
+
+  it('should find old Japanese Kanji numbers.', () => {
+    assert.deepEqual([ '壱', '弐' ], findKanjiNumbers('私が住んでいるのは壱番館の弐号室です。'))
+    assert.deepEqual([ '弍' ], findKanjiNumbers('私は、ハイツ弍号棟に住んでいます。'))
+    assert.deepEqual([ '壱阡陌拾壱兆壱億壱萬', ], findKanjiNumbers('私は、壱阡陌拾壱兆壱億壱萬円持っています。'))
+    assert.deepEqual([ '壱仟佰拾壱兆壱億壱萬', ], findKanjiNumbers('私は、壱仟佰拾壱兆壱億壱萬円持っています。'))
+  })
+
+  it('should convert mixed Japanese Kanji numbers to numbers.', () => {
+    assert.deepEqual(kanji2number('100万'), 1000000)
+    assert.deepEqual(kanji2number('5百'), 500)
+    assert.deepEqual(kanji2number('7十'), 70)
+    assert.deepEqual(kanji2number('4千８百'), 4800)
+    assert.deepEqual(kanji2number('4千８百万'), 48000000)
+    assert.deepEqual(kanji2number('3億4千８百万'), 348000000)
+    assert.deepEqual(kanji2number('3億4千８百万6'), 348000006)
+    assert.deepEqual(kanji2number('2百億'), 20000000000)
+  })
+
+  it('`4千8百21` should be converted to `4821`', () => {
+    assert.deepEqual(kanji2number('4千8百21'), 4821)
+  })
+
+  it('`1千2百億8百21` should be converted to `120000000821`', () => {
+    assert.deepEqual(kanji2number('1千2百35億8百21'), 123500000821)
+  })
+
+  it('`2億3千430万` should be converted to `234300000`', () => {
+    assert.deepEqual(kanji2number('2億3千430万'), 234300000)
+  })
+
+  it('`２億３千４５６万７８９０` should be converted to `234567890`', () => {
+    assert.deepEqual(kanji2number('２億３千４５６万７８９０'), 234567890)
+  })
+
+  it('`１２３` should be converted to `123`', () => {
+    assert.deepEqual(kanji2number('１２３'), 123)
+  })
+
+  // Issue #20: decimal Arabic-kanji numerals (e.g. 8.5万円, 25.24億円)
+  describe('findKanjiNumbers should recognize decimal Arabic-kanji numerals as single tokens', () => {
+    it('decimal + 万: common rent price like 8.5万円', () => {
+      assert.deepEqual(findKanjiNumbers('家賃は8.5万円です。'), ['8.5万'])
+    })
+
+    it('decimal + 億: property price like 25.24億円', () => {
+      assert.deepEqual(findKanjiNumbers('売上は25.24億円でした。'), ['25.24億'])
+    })
+
+    it('should handle precision in numbers like 1.20兆円', () => {
+      assert.deepEqual(findKanjiNumbers('予算は1.20兆円です。'), ['1.20兆'])
+    })
+
+    it('should not extract standalone decimals without kanji units', () => {
+      assert.deepEqual(findKanjiNumbers('値段は8.5です'), [])
+    })
+
+    it('full-width decimal: ８．５万 should be found as a single token', () => {
+      assert.deepEqual(findKanjiNumbers('家賃は８．５万円です。'), ['８．５万'])
+    })
+
+    it('should extract decimal rent and fee amounts written with small units', () => {
+      assert.deepEqual(findKanjiNumbers('家賃は8.5千円です。'), ['8.5千'])
+      assert.deepEqual(findKanjiNumbers('手数料は8.5百円です。'), ['8.5百'])
+      assert.deepEqual(findKanjiNumbers('割引は8.5十円です。'), ['8.5十'])
+    })
+
+    it('should still find kanji numerals in text like article numbers and mixed labels', () => {
+      assert.deepEqual(findKanjiNumbers('第2二十条'), ['二十'])
+      assert.deepEqual(findKanjiNumbers('3三'), ['三'])
+    })
+
+    it('should stop before broken decimal-large-unit strings from OCR or scraped text', () => {
+      assert.deepEqual(findKanjiNumbers('1千2.3億'), ['1千2'])
+      assert.deepEqual(findKanjiNumbers('1百2.3万'), ['1百2'])
+    })
+  })
+
+  describe('kanji2number should convert decimal Arabic-kanji numerals', () => {
+    it('decimal + 千/百/十: 8.5千 = 8,500, 8.5百 = 850, 8.5十 = 85', () => {
+      assert.deepEqual(kanji2number('8.5千'), 8500)
+      assert.deepEqual(kanji2number('8.5百'), 850)
+      assert.deepEqual(kanji2number('8.5十'), 85)
+    })
+
+    it('decimal + 万: 8.5万 = 85,000', () => {
+      assert.deepEqual(kanji2number('8.5万'), 85000)
+    })
+
+    it('decimal + 億: 25.24億 = 2,524,000,000', () => {
+      assert.deepEqual(kanji2number('25.24億'), 2524000000)
+    })
+
+    it('precision in numbers', () => {
+      assert.deepEqual(kanji2number('1.20兆'), 1200000000000)
+    })
+
+    it('should not suffer from floating-point drift: 0.29億 = 29,000,000', () => {
+      assert.deepEqual(kanji2number('0.29億'), 29000000)
+    })
+
+    it('full-width decimal: ８．５万 = 85,000', () => {
+      assert.deepEqual(kanji2number('８．５万'), 85000)
+    })
+
+    it('should support tiny but integral decimal coefficients like 0.0000000001兆', () => {
+      assert.deepEqual(kanji2number('0.0000000001兆'), 100)
+    })
+
+    it('should reject non-integral results like 0.00009万', () => {
+      assert.throws(() => kanji2number('0.00009万'), TypeError)
+    })
+
+    it('should reject high-precision non-integral results like 1.0000000001万', () => {
+      assert.throws(() => kanji2number('1.0000000001万'), TypeError)
+    })
+
+    it('should reject large-coefficient non-integral results like 10000000.00000001万', () => {
+      assert.throws(() => kanji2number('10000000.00000001万'), TypeError)
+    })
+
+    it('should still reject mixed decimal-small-unit hybrids like 1.2千3百', () => {
+      assert.throws(() => kanji2number('1.2千3百'), TypeError)
+    })
+  })
+});
+
+// https://github.com/geolonia/normalize-japanese-addresses/issues/94
+it('should find Japanese Kanji number `六` in `香川県仲多度郡まんのう町勝浦字家六２０９４番地１`.', () => {
+  assert.deepEqual([ '六' ], findKanjiNumbers('香川県仲多度郡まんのう町勝浦字家六２０９４番地１'))
+})
+
+it('should find Japanese Kanji number in `今日は２千20年十一月二十日です。`.', () => {
+  assert.deepEqual([ '２千20', '十一', '二十' ], findKanjiNumbers('今日は２千20年十一月二十日です。'))
+})

package/test/utils.ts

@@ -0,0 +1,17 @@
+import { n2kan, kan2n } from '../src/utils'
+import { assert } from 'chai'
+
+describe('Tests for utils.', () => {
+  it('Small Japanese numeric should be parsed as numbers.', () => {
+    assert.deepEqual(n2kan(1111), '千百十一')
+    assert.deepEqual(n2kan(3111), '三千百十一')
+    assert.deepEqual(n2kan(1000), '千')
+    assert.deepEqual(n2kan(5), '五')
+  });
+
+  it('`kan2n()` should returns value as expected.', () => {
+    assert.deepEqual(kan2n('三千'), 3000)
+    assert.deepEqual(kan2n('22'), 22)
+    assert.deepEqual(kan2n('１２３'), 123)
+  })
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "pretty": true,
+    "newLine": "lf",
+    "outDir": "dist"
+  },
+  "files": [
+    "./src/index.ts"
+  ]
+}