japanese_address_parser 1.1.1 → 2.0.0

data/js/node_modules/@geolonia/japanese-numeral/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@geolonia/japanese-numeral",
+  "version": "0.1.15",
+  "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"
+  },
+  "author": "Geolonia Inc.",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/chai": "^4.2.11",
+    "@types/mocha": "^8.0.0",
+    "chai": "^4.2.0",
+    "mocha": "^8.0.1",
+    "ts-node": "^8.10.2",
+    "typescript": "^3.9.6"
+  }
+}

data/js/node_modules/@geolonia/japanese-numeral/src/index.ts

@@ -0,0 +1,78 @@
+import { normalize, splitLargeNumber, largeNumbers, n2kan } from './utils'
+import japaneseNumerics from './japaneseNumerics'
+
+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 = splitLargeNumber(japanese)
+
+    // 万以上の数字を数値に変換
+    for (const key in largeNumbers) {
+      if (numbers[key]) {
+        const n = largeNumbers[key] * numbers[key]
+        number = number + n
+      }
+    }
+
+    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 basePattern = `((${num})(千|阡|仟))?((${num})(百|陌|佰))?((${num})(十|拾))?(${num})?`
+  const pattern = `((${basePattern}兆)?(${basePattern}億)?(${basePattern}(万|萬))?${basePattern})`
+  const regex = new RegExp(pattern, 'g')
+  const match = text.match(regex)
+  if (match) {
+    return match.filter((item) => {
+      if ((! item.match(/^[0-9０-９]+$/)) && (item.length && '兆' !== item && '億' !== item && '万' !== item && '萬' !== item)) {
+        return true
+      } else {
+        return false
+      }
+    })
+  } else {
+    return []
+  }
+}

data/js/node_modules/@geolonia/japanese-numeral/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

data/js/node_modules/@geolonia/japanese-numeral/src/oldJapaneseNumerics.ts

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

data/js/node_modules/@geolonia/japanese-numeral/src/utils.ts

@@ -0,0 +1,124 @@
+import oldJapaneseNumerics from './oldJapaneseNumerics'
+import japaneseNumerics from './japaneseNumerics'
+
+type NumHash = {
+  [key: string]: number;
+}
+
+export const largeNumbers: NumHash = { '兆': 1000000000000, '億': 100000000, '万': 10000 }
+export const smallNumbers: NumHash = { '千': 1000, '百': 100, '十': 10 }
+
+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) {
+  let kanji = japanese
+  const numbers:NumHash = {}
+  for (const key in largeNumbers) {
+    const reg = new RegExp(`(.+)${key}`)
+    const match = kanji.match(reg)
+    if (match) {
+      numbers[key] = kan2n(match[1])
+      kanji = kanji.replace(match[0], '')
+    } else {
+      numbers[key] = 0
+    }
+  }
+
+  if (kanji) {
+    numbers['千'] = kan2n(kanji)
+  } else {
+    numbers['千'] = 0
+  }
+
+  return numbers
+}
+
+/**
+ * 千単位以下の漢数字を数字に変換する（例: 三千 => 3000）
+ *
+ * @param japanese
+ */
+export function kan2n(japanese: string) {
+  if (japanese.match(/^[0-9]+$/)) {
+    return Number(japanese)
+  }
+
+  let kanji = zen2han(japanese)
+  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 {
+      number = number + japaneseNumerics[kanji]
+    }
+  }
+
+  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);
+  });
+}

data/js/node_modules/@geolonia/japanese-numeral/test/test.ts

@@ -0,0 +1,108 @@
+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('一千百十一兆一千百十一億一千百十一万一千百十一'), 1111111111111111)
+    assert.deepEqual(kanji2number('一千百十一兆一千百十一億一千百十一万'), 1111111111110000)
+    assert.deepEqual(kanji2number('一千百十一兆一千百十一億一千百十一'), 1111111100001111)
+    assert.deepEqual(kanji2number('百十一'), 111)
+    assert.deepEqual(kanji2number('三億八'), 300000008)
+    assert.deepEqual(kanji2number('三百八'), 308)
+    assert.deepEqual(kanji2number('三〇八'), 308)
+    assert.deepEqual(kanji2number('二〇二〇'), 2020)
+    assert.deepEqual(kanji2number('二千'), 2000)
+    assert.deepEqual(kanji2number('壱万'), 10000)
+    assert.deepEqual(kanji2number('一二三四'), 1234)
+    assert.deepEqual(kanji2number('壱阡陌拾壱兆壱阡陌拾壱億壱阡陌拾壱萬壱阡陌拾壱'), 1111111111111111)
+    assert.deepEqual(kanji2number('壱仟佰拾壱兆壱仟佰拾壱億壱仟佰拾壱萬壱仟佰拾壱'), 1111111111111111)
+  });
+
+  it('Number should be converted to Japanese kanji', () => {
+    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)
+
+    // @ts-ignore
+    assert.throws(() => kanji2number('三あ八'), TypeError)
+
+    // @ts-ignore
+    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('私は、壱仟佰拾壱兆壱億壱萬円持っています。'))
+  })
+
+  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)
+  })
+});
+
+// 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年十一月二十日です。'))
+})

data/js/node_modules/@geolonia/japanese-numeral/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)
+  })
+});

data/js/node_modules/@geolonia/japanese-numeral/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"
+  ]
+}

data/js/node_modules/@geolonia/normalize-japanese-addresses/.editorconfig

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

data/js/node_modules/@geolonia/normalize-japanese-addresses/.eslintignore

@@ -0,0 +1,2 @@
+/node_modules/
+/dist

data/js/node_modules/@geolonia/normalize-japanese-addresses/.eslintrc.js

@@ -0,0 +1,19 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+  },
+  plugins: ['eslint-plugin-tsdoc'],
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'prettier/@typescript-eslint',
+    'plugin:prettier/recommended',
+  ],
+  rules: {
+    '@typescript-eslint/explicit-module-boundary-types': 0,
+    '@typescript-eslint/ban-ts-comment': 0,
+    '@typescript-eslint/no-var-requires': 0,
+    'tsdoc/syntax': 'error',
+  },
+}

data/js/node_modules/@geolonia/normalize-japanese-addresses/.prettierrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  semi: false,
+  trailingComma: 'all',
+  singleQuote: true,
+  tabWidth: 2,
+}

data/js/node_modules/@geolonia/normalize-japanese-addresses/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 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.

data/js/node_modules/@geolonia/normalize-japanese-addresses/README.md

@@ -0,0 +1,144 @@
+# @geolonia/normalize-japanese-addresses
+
+![build](https://github.com/geolonia/normalize-japanese-addresses/workflows/build/badge.svg)
+
+オープンソースの住所正規化ライブラリです。
+
+経産省の [IMI コンポーネントツール](https://info.gbiz.go.jp/tools/imi_tools/)のジオコーディングの仕組みからインスピレーションをうけて開発しました。
+
+## デモ
+
+https://codepen.io/geolonia/pen/oNBrqzL
+
+## 使い方
+
+ライブラリは npm レジストリで `@geolonia/normalize-japanese-addresses` として配布されています。
+npm コマンドなどを使ってインストールして下さい。
+
+```shell
+$ npm install @geolonia/normalize-japanese-addresses -S
+```
+
+### `normalize(address: string)`
+
+住所を正規化します。
+
+```javascript
+const { normalize } = require('@geolonia/normalize-japanese-addresses')
+normalize('北海道札幌市西区24-2-2-3-3').then(result => {
+  console.log(result); // {"pref": "北海道", "city": "札幌市西区", "town": "二十四軒二条二丁目", "addr": "3-3", "lat": 43.074273, "lng": 141.315099, "level"; 3}
+})
+```
+
+住所の正規化結果として戻されるオブジェクトには、`level` プロパティが含まれます。`level` には、住所文字列のどこまでを判別できたかを以下の数値で格納しています。
+
+* `0` - 都道府県も判別できなかった。
+* `1` - 都道府県まで判別できた。
+* `2` - 市区町村まで判別できた。
+* `3` - 町丁目まで判別できた。
+
+例えば都道府県名のみを正規化したい場合、`level` オプションで指定することで処理を早くすることができます。
+
+```javascript
+const { normalize } = require('@geolonia/normalize-japanese-addresses')
+normalize('北海道札幌市西区24-2-2-3-3', {level}).then(result => {
+  console.log(result); // {"pref": "北海道", "city": "", "town": "", "addr": "札幌市西区二十四軒二条二丁目3-3", "lat": null, "lng": null, "level"; 1}
+})
+```
+
+### オプション
+
+#### `config.townCacheSize: number`
+
+＠geolonia/normalize-japanese-addresses は市区町村毎の最新の町丁目のデータを web API から取得し住所の正規化を行います。 `townCacheSize` オプションはキャッシュする市区町村の数を変更します。デフォルトは 1,000 件になっています。
+
+#### `config.japaneseAddressesApi: string`
+
+町丁目データを配信する web API のエンドポイントを指定します。デフォルトは `https://geolonia.github.io/japanese-addresses/api/ja` です。この API から配信されるデータのディレクトリ構成は [Geolonia 住所データ](https://github.com/geolonia/japanese-addresses/tree/develop/api)を参考にしてください。
+
+このオプションに対して `file://` 形式の URL を指定することで、ローカルファイルとして保存したファイルを参照することができます。
+
+```shell
+# Geolonia 住所データのダウンロード
+$ curl -sL https://github.com/geolonia/japanese-addresses/archive/refs/heads/master.tar.gz | tar xvf -
+```
+
+```javascript
+const { config, normalize } = require('@geolonia/normalize-japanese-addresses')
+config.japaneseAddressesApi = 'file:///path/to/japanese-addresses-master/api/ja'
+
+(function(){
+  for (address of addresses) {
+    await normalize(address)
+  }
+})()
+```
+
+## 正規化の内容
+
+* `XXX郡` などの郡の名前が省略されている住所に対しては、それを補完します。
+* 住所に含まれるアルファベットと数字を半角に統一します。
+* 京都の通り名を削除します。
+* 新字体と旧字体のゆらぎを吸収して、国交省の位置参照情報に記載されている地名にあわせます。
+* `ヶケが`、`ヵカか力`、`之ノの`、`ッツっつ` などのゆらぎを吸収して、国交省の位置参照情報に記載されている地名にあわせます。
+* `釜`と`竈`、`埠頭`と`ふ頭`などの漢字のゆらぎを吸収します。
+* 町丁目レベルに記載されている数字は、国交省の位置参照情報にあわせて、すべて漢数字に変換します。
+* 番地や号レベルに記載されている数字はアラビア数字に変換し、`番地` などの文字列は `-` に変換します。
+* 住所の末尾に建物名がある場合は、なるべくなにもしないでそのまま返す仕様になっていますが、できればあらかじめ分離していただいたほうがいいかもしれません。
+
+参考:
+
+* [ゆらぎを処理している文字列に関しては、ソースコードを御覧ください。](https://github.com/geolonia/normalize-japanese-addresses/blob/master/src/lib/dict.ts)
+* [変換前、変換後の住所の例はテストコードを御覧ください。](https://github.com/geolonia/normalize-japanese-addresses/blob/master/test/main.test.ts)
+
+
+## 開発者向け情報
+
+まず、以下のコマンドで環境を用意してください。
+
+```shell
+$ git clone git@github.com:geolonia/normalize-japanese-addresses.git
+$ cd normalize-japanese-addresses
+$ npm install
+```
+
+次に、以下を実行してコンパイルをおこないます。
+
+```shell
+$ npm run build
+```
+
+dist フォルダ以下に main.js など必要なファイルが生成されるので、
+
+```
+const { normalize } = require('./dist/main-node.js')
+normalize('北海道札幌市西区24-2-2-3-3', {level: 3}).then(result => {
+  console.log(result); // {"pref": "北海道", "city": "", "town": "", "addr": "札幌市西区二十四軒二条二丁目3-3", "level"; 1}
+})
+```
+
+という内容で sample.js を用意したら、
+
+```shell
+$ node sample.js
+```
+
+でサンプルファイルを実行することができます。
+
+## 注意
+
+* この正規化エンジンは、住所の「名寄せ」を目的としており、たとえば京都の「通り名」は削除します。
+  * 郵便や宅急便などに使用される住所としては、問題ないと考えています。
+* この正規化エンジンは、町丁目及び小字レベルまでは対応していますが、それ以降については対応しておりません。
+* 住居表示が未整備の地域については全体的に苦手です。
+
+### 貢献方法
+
+プルリクエストや Issue はいつでも歓迎します。
+
+## ライセンス、利用規約
+
+- ソースコードのライセンスは MIT ライセンスです。
+- ご利用に際しましては、できればソーシャルでのシェア、[Geolonia](https://geolonia.com/) へのリンクの設置などをしていただけると、開発者たちのモチベーションが上がると思います。
+
+住所の正規化を工夫すれば精度があがりそうなので、そのあたりのアイディアを募集しています。

data/js/node_modules/@geolonia/normalize-japanese-addresses/dist/config.d.ts

@@ -0,0 +1,6 @@
+export interface Config {
+    japaneseAddressesApi: string;
+    /** 町丁目のデータを何件までキャッシュするか。デフォルト 1,000 */
+    townCacheSize: number;
+}
+export declare const currentConfig: Config;

data/js/node_modules/@geolonia/normalize-japanese-addresses/dist/lib/cacheRegexes.d.ts

@@ -0,0 +1,18 @@
+declare type PrefectureList = {
+    [key: string]: string[];
+};
+interface SingleTown {
+    town: string;
+    koaza: string;
+    lat: string;
+    lng: string;
+}
+declare type TownList = SingleTown[];
+export declare const getPrefectures: () => Promise<PrefectureList>;
+export declare const cachePrefectures: (data: PrefectureList) => PrefectureList;
+export declare const getPrefectureRegexPatterns: (prefs: string[]) => [string, string][];
+export declare const getCityRegexPatterns: (pref: string, cities: string[]) => [string, string][];
+export declare const getTowns: (pref: string, city: string) => Promise<TownList>;
+export declare const getTownRegexPatterns: (pref: string, city: string) => Promise<[SingleTown, string][]>;
+export declare const getSameNamedPrefectureCityRegexPatterns: (prefs: string[], prefList: PrefectureList) => [string, string][];
+export {};

data/js/node_modules/@geolonia/normalize-japanese-addresses/dist/lib/dict.d.ts

@@ -0,0 +1,2 @@
+export declare const jisKanji: (str: string) => string;
+export declare const toRegexPattern: (string: string) => string;

data/js/node_modules/@geolonia/normalize-japanese-addresses/dist/lib/kan2num.d.ts

@@ -0,0 +1 @@
+export declare const kan2num: (string: string) => string;

data/js/node_modules/@geolonia/normalize-japanese-addresses/dist/lib/patchAddr.d.ts

@@ -0,0 +1 @@
+export declare const patchAddr: (pref: string, city: string, town: string, addr: string) => string;

data/js/node_modules/@geolonia/normalize-japanese-addresses/dist/lib/zen2han.d.ts

@@ -0,0 +1 @@
+export declare const zen2han: (str: string) => string;