japanese_address_parser 1.1.1 → 2.0.0

data/js/node_modules/@geolonia/normalize-japanese-addresses/src/normalize.ts

@@ -0,0 +1,299 @@
+import { number2kanji } from '@geolonia/japanese-numeral'
+
+import { kan2num } from './lib/kan2num'
+import { zen2han } from './lib/zen2han'
+import { patchAddr } from './lib/patchAddr'
+import {
+  getPrefectures,
+  getPrefectureRegexPatterns,
+  getCityRegexPatterns,
+  getTownRegexPatterns,
+  getSameNamedPrefectureCityRegexPatterns,
+} from './lib/cacheRegexes'
+import unfetch from 'isomorphic-unfetch'
+import { currentConfig } from './config'
+
+/**
+ * 住所の正規化結果として戻されるオブジェクト
+ */
+export interface NormalizeResult {
+  /** 都道府県 */
+  pref: string
+  /** 市区町村 */
+  city: string
+  /** 町丁目 */
+  town: string
+  /** 正規化後の住所文字列 */
+  addr: string
+  /** 緯度。データが存在しない場合は null */
+  lat: number | null
+  /** 軽度。データが存在しない場合は null */
+  lng: number | null
+  /**
+   * 住所文字列をどこまで判別できたかを表す正規化レベル
+   * - 0 - 都道府県も判別できなかった。
+   * - 1 - 都道府県まで判別できた。
+   * - 2 - 市区町村まで判別できた。
+   * - 3 - 町丁目まで判別できた。
+   */
+  level: number
+}
+
+/**
+ * 正規化関数の {@link normalize} のオプション
+ */
+export interface Option {
+  /**
+   * 正規化を行うレベルを指定します。{@link Option.level}
+   *
+   * @see https://github.com/geolonia/normalize-japanese-addresses#normalizeaddress-string
+   */
+  level: number
+}
+
+/**
+ * 住所を正規化します。
+ *
+ * @param input - 住所文字列
+ * @param option -  正規化のオプション {@link Option}
+ *
+ * @returns 正規化結果のオブジェクト {@link NormalizeResult}
+ *
+ * @see https://github.com/geolonia/normalize-japanese-addresses#normalizeaddress-string
+ */
+export type Normalizer = (
+  input: string,
+  option?: Option,
+) => Promise<NormalizeResult>
+
+export type FetchLike = (
+  input: string,
+) => Promise<Response | { json: () => Promise<unknown> }>
+
+const defaultOption: Option = {
+  level: 3,
+}
+
+export const __internals: { fetch: FetchLike } = {
+  // default fetch
+  fetch: (input: string) => {
+    const fileURL = new URL(`${currentConfig.japaneseAddressesApi}${input}`)
+    return unfetch(fileURL.toString())
+  },
+}
+
+const normalizeTownName = async (addr: string, pref: string, city: string) => {
+  addr = addr.trim().replace(/^大字/, '')
+  const townPatterns = await getTownRegexPatterns(pref, city)
+
+  for (let i = 0; i < townPatterns.length; i++) {
+    const [_town, pattern] = townPatterns[i]
+    const match = addr.match(pattern)
+
+    if (match) {
+      return {
+        town: _town.town,
+        addr: addr.substr(match[0].length),
+        lat: _town.lat,
+        lng: _town.lng,
+      }
+    }
+  }
+}
+
+export const normalize: Normalizer = async (
+  address,
+  option = defaultOption,
+) => {
+  /**
+   * 入力された住所に対して以下の正規化を予め行う。
+   *
+   * 1. `1-2-3` や `四-五-六` のようなフォーマットのハイフンを半角に統一。
+   * 2. 町丁目以前にあるスペースをすべて削除。
+   * 3. 最初に出てくる `1-` や `五-` のような文字列を町丁目とみなして、それ以前のスペースをすべて削除する。
+   */
+  let addr = address
+    .replace(/　/g, ' ')
+    .replace(/ +/g, ' ')
+    .replace(/([０-９Ａ-Ｚａ-ｚ]+)/g, (match) => {
+      // 全角のアラビア数字は問答無用で半角にする
+      return zen2han(match)
+    })
+    // 数字の後または数字の前にくる横棒はハイフンに統一する
+    .replace(
+      /([0-9０-９一二三四五六七八九〇十百千][-－﹣−‐⁃‑‒–—﹘―⎯⏤ーｰ─━])|([-－﹣−‐⁃‑‒–—﹘―⎯⏤ーｰ─━])[0-9０-９一二三四五六七八九〇十]/g,
+      (match) => {
+        return match.replace(/[-－﹣−‐⁃‑‒–—﹘―⎯⏤ーｰ─━]/g, '-')
+      },
+    )
+    .replace(/(.+)(丁目?|番(町|地|丁)|条|軒|線|(の|ノ)町|地割)/, (match) => {
+      return match.replace(/ /g, '') // 町丁目名以前のスペースはすべて削除
+    })
+    .replace(/.+?[0-9一二三四五六七八九〇十百千]-/, (match) => {
+      return match.replace(/ /g, '') // 1番はじめに出てくるアラビア数字以前のスペースを削除
+    })
+
+  let pref = ''
+  let city = ''
+  let town = ''
+  let lat = null
+  let lng = null
+  let level = 0
+
+  // 都道府県名の正規化
+
+  const prefectures = await getPrefectures()
+  const prefs = Object.keys(prefectures)
+  const prefPatterns = getPrefectureRegexPatterns(prefs)
+  const sameNamedPrefectureCityRegexPatterns =
+    getSameNamedPrefectureCityRegexPatterns(prefs, prefectures)
+
+  // 県名が省略されており、かつ市の名前がどこかの都道府県名と同じ場合(例.千葉県千葉市)、
+  // あらかじめ県名を補完しておく。
+  for (let i = 0; i < sameNamedPrefectureCityRegexPatterns.length; i++) {
+    const [prefectureCity, reg] = sameNamedPrefectureCityRegexPatterns[i]
+    const match = addr.match(reg)
+    if (match) {
+      addr = addr.replace(new RegExp(reg), prefectureCity)
+      break
+    }
+  }
+
+  for (let i = 0; i < prefPatterns.length; i++) {
+    const [_pref, pattern] = prefPatterns[i]
+    const match = addr.match(pattern)
+    if (match) {
+      pref = _pref
+      addr = addr.substring(match[0].length) // 都道府県名以降の住所
+      break
+    }
+  }
+
+  if (!pref) {
+    // 都道府県名が省略されている
+    const matched = []
+    for (const _pref in prefectures) {
+      const cities = prefectures[_pref]
+      const cityPatterns = getCityRegexPatterns(_pref, cities)
+
+      addr = addr.trim()
+      for (let i = 0; i < cityPatterns.length; i++) {
+        const [_city, pattern] = cityPatterns[i]
+        const match = addr.match(pattern)
+        if (match) {
+          matched.push({
+            pref: _pref,
+            city: _city,
+            addr: addr.substring(match[0].length),
+          })
+        }
+      }
+    }
+
+    // マッチする都道府県が複数ある場合は町名まで正規化して都道府県名を判別する。（例: 東京都府中市と広島県府中市など）
+    if (1 === matched.length) {
+      pref = matched[0].pref
+    } else {
+      for (let i = 0; i < matched.length; i++) {
+        const normalized = await normalizeTownName(
+          matched[i].addr,
+          matched[i].pref,
+          matched[i].city,
+        )
+        if (normalized) {
+          pref = matched[i].pref
+        }
+      }
+    }
+  }
+
+  if (pref && option.level >= 2) {
+    const cities = prefectures[pref]
+    const cityPatterns = getCityRegexPatterns(pref, cities)
+
+    addr = addr.trim()
+    for (let i = 0; i < cityPatterns.length; i++) {
+      const [_city, pattern] = cityPatterns[i]
+      const match = addr.match(pattern)
+      if (match) {
+        city = _city
+        addr = addr.substring(match[0].length) // 市区町村名以降の住所
+        break
+      }
+    }
+  }
+
+  // 町丁目以降の正規化'
+  if (city && option.level >= 3) {
+    const normalized = await normalizeTownName(addr, pref, city)
+    if (normalized) {
+      town = normalized.town
+      addr = normalized.addr
+      lat = parseFloat(normalized.lat)
+      lng = parseFloat(normalized.lng)
+    }
+
+    addr = addr
+      .replace(/^-/, '')
+      .replace(/([0-9]+)(丁目)/g, (match) => {
+        return match.replace(/([0-9]+)/g, (num) => {
+          return number2kanji(Number(num))
+        })
+      })
+      .replace(
+        /(([0-9〇一二三四五六七八九十百千]+)(番地?)([0-9〇一二三四五六七八九十百千]+)号)\s*(.+)/,
+        '$1 $5',
+      )
+      .replace(
+        /([0-9〇一二三四五六七八九十百千]+)(番地?)([0-9〇一二三四五六七八九十百千]+)号?/,
+        '$1-$3',
+      )
+      .replace(/([0-9〇一二三四五六七八九十百千]+)番地?/, '$1')
+      .replace(/([0-9〇一二三四五六七八九十百千]+)の/g, '$1-')
+      .replace(
+        /([0-9〇一二三四五六七八九十百千]+)[-－﹣−‐⁃‑‒–—﹘―⎯⏤ーｰ─━]/g,
+        (match) => {
+          return kan2num(match).replace(/[-－﹣−‐⁃‑‒–—﹘―⎯⏤ーｰ─━]/g, '-')
+        },
+      )
+      .replace(
+        /[-－﹣−‐⁃‑‒–—﹘―⎯⏤ーｰ─━]([0-9〇一二三四五六七八九十百千]+)/g,
+        (match) => {
+          return kan2num(match).replace(/[-－﹣−‐⁃‑‒–—﹘―⎯⏤ーｰ─━]/g, '-')
+        },
+      )
+      .replace(/([0-9〇一二三四五六七八九十百千]+)-/, (s) => {
+        // `1-` のようなケース
+        return kan2num(s)
+      })
+      .replace(/-([0-9〇一二三四五六七八九十百千]+)/, (s) => {
+        // `-1` のようなケース
+        return kan2num(s)
+      })
+      .replace(/-[^0-9]+([0-9〇一二三四五六七八九十百千]+)/, (s) => {
+        // `-あ1` のようなケース
+        return kan2num(zen2han(s))
+      })
+      .replace(/([0-9〇一二三四五六七八九十百千]+)$/, (s) => {
+        // `串本町串本１２３４` のようなケース
+        return kan2num(s)
+      })
+      .trim()
+  }
+
+  addr = patchAddr(pref, city, town, addr)
+
+  if (pref) level = level + 1
+  if (city) level = level + 1
+  if (town) level = level + 1
+
+  return {
+    pref,
+    city,
+    town,
+    addr,
+    lat,
+    lng,
+    level,
+  }
+}

data/js/node_modules/@geolonia/normalize-japanese-addresses/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true
+  },
+  "include": ["src"],
+  "exclude": ["__test__", "src/**/*.test.ts", "dist", "node_modules"]
+}

data/js/node_modules/isomorphic-unfetch/browser.js

@@ -0,0 +1 @@
+module.exports = self.fetch || (self.fetch = require('unfetch').default || require('unfetch'));

data/js/node_modules/isomorphic-unfetch/index.d.ts

@@ -0,0 +1,19 @@
+import {
+  Body as NodeBody,
+  Headers as NodeHeaders,
+  Request as NodeRequest,
+  Response as NodeResponse,
+  RequestInit as NodeRequestInit
+} from "node-fetch";
+
+declare namespace unfetch {
+  export type IsomorphicHeaders = Headers | NodeHeaders;
+  export type IsomorphicBody = Body | NodeBody;
+  export type IsomorphicResponse = Response | NodeResponse;
+  export type IsomorphicRequest = Request | NodeRequest;
+  export type IsomorphicRequestInit = RequestInit | NodeRequestInit;
+}
+
+declare const unfetch: typeof fetch;
+
+export default unfetch;

data/js/node_modules/isomorphic-unfetch/index.js

@@ -0,0 +1,6 @@
+function r(m){return m && m.default || m;}
+module.exports = global.fetch = global.fetch || (
+	typeof process=='undefined' ? r(require('unfetch')) : (function(url, opts) {
+		return r(require('node-fetch'))(String(url).replace(/^\/\//g,'https://'), opts);
+	})
+);

data/js/node_modules/isomorphic-unfetch/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "isomorphic-unfetch",
+  "version": "3.1.0",
+  "description": "Switches between unfetch & node-fetch for client & server.",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "browser.js"
+  ],
+  "license": "MIT",
+  "repository": "developit/unfetch",
+  "browser": "browser.js",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "node-fetch": "^2.6.1",
+    "unfetch": "^4.2.0"
+  }
+}

data/js/node_modules/isomorphic-unfetch/readme.md

@@ -0,0 +1,53 @@
+# Isomorphic Unfetch
+
+Switches between [unfetch](https://github.com/developit/unfetch) & [node-fetch](https://github.com/bitinn/node-fetch) for client & server.
+
+## Install
+
+This project uses [node](http://nodejs.org) and [npm](https://npmjs.com). Go check them out if you don't have them locally installed.
+
+```sh
+$ npm i isomorphic-unfetch
+```
+
+Then with a module bundler like [rollup](http://rollupjs.org/) or [webpack](https://webpack.js.org/), use as you would anything else:
+
+```javascript
+// using ES6 modules
+import fetch from 'isomorphic-unfetch'
+
+// using CommonJS modules
+const fetch = require('isomorphic-unfetch')
+```
+
+## Usage
+
+As a [**ponyfill**](https://ponyfill.com):
+
+```js
+import fetch from 'isomorphic-unfetch';
+
+fetch('/foo.json')
+  .then( r => r.json() )
+  .then( data => {
+    console.log(data);
+  });
+```
+
+Globally, as a [**polyfill**](https://ponyfill.com/#polyfill):
+
+```js
+import 'isomorphic-unfetch';
+
+// "fetch" is now installed globally if it wasn't already available
+
+fetch('/foo.json')
+  .then( r => r.json() )
+  .then( data => {
+    console.log(data);
+  });
+```
+
+## License
+
+[MIT License](LICENSE.md) © [Jason Miller](https://jasonformat.com/)

data/js/node_modules/lru-cache/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/js/node_modules/lru-cache/README.md

@@ -0,0 +1,166 @@
+# lru cache
+
+A cache object that deletes the least-recently-used items.
+
+[![Build Status](https://travis-ci.org/isaacs/node-lru-cache.svg?branch=master)](https://travis-ci.org/isaacs/node-lru-cache) [![Coverage Status](https://coveralls.io/repos/isaacs/node-lru-cache/badge.svg?service=github)](https://coveralls.io/github/isaacs/node-lru-cache)
+
+## Installation:
+
+```javascript
+npm install lru-cache --save
+```
+
+## Usage:
+
+```javascript
+var LRU = require("lru-cache")
+  , options = { max: 500
+              , length: function (n, key) { return n * 2 + key.length }
+              , dispose: function (key, n) { n.close() }
+              , maxAge: 1000 * 60 * 60 }
+  , cache = new LRU(options)
+  , otherCache = new LRU(50) // sets just the max size
+
+cache.set("key", "value")
+cache.get("key") // "value"
+
+// non-string keys ARE fully supported
+// but note that it must be THE SAME object, not
+// just a JSON-equivalent object.
+var someObject = { a: 1 }
+cache.set(someObject, 'a value')
+// Object keys are not toString()-ed
+cache.set('[object Object]', 'a different value')
+assert.equal(cache.get(someObject), 'a value')
+// A similar object with same keys/values won't work,
+// because it's a different object identity
+assert.equal(cache.get({ a: 1 }), undefined)
+
+cache.reset()    // empty the cache
+```
+
+If you put more stuff in it, then items will fall out.
+
+If you try to put an oversized thing in it, then it'll fall out right
+away.
+
+## Options
+
+* `max` The maximum size of the cache, checked by applying the length
+  function to all values in the cache.  Not setting this is kind of
+  silly, since that's the whole purpose of this lib, but it defaults
+  to `Infinity`.  Setting it to a non-number or negative number will
+  throw a `TypeError`.  Setting it to 0 makes it be `Infinity`.
+* `maxAge` Maximum age in ms.  Items are not pro-actively pruned out
+  as they age, but if you try to get an item that is too old, it'll
+  drop it and return undefined instead of giving it to you.
+  Setting this to a negative value will make everything seem old!
+  Setting it to a non-number will throw a `TypeError`.
+* `length` Function that is used to calculate the length of stored
+  items.  If you're storing strings or buffers, then you probably want
+  to do something like `function(n, key){return n.length}`.  The default is
+  `function(){return 1}`, which is fine if you want to store `max`
+  like-sized things.  The item is passed as the first argument, and
+  the key is passed as the second argumnet.
+* `dispose` Function that is called on items when they are dropped
+  from the cache.  This can be handy if you want to close file
+  descriptors or do other cleanup tasks when items are no longer
+  accessible.  Called with `key, value`.  It's called *before*
+  actually removing the item from the internal cache, so if you want
+  to immediately put it back in, you'll have to do that in a
+  `nextTick` or `setTimeout` callback or it won't do anything.
+* `stale` By default, if you set a `maxAge`, it'll only actually pull
+  stale items out of the cache when you `get(key)`.  (That is, it's
+  not pre-emptively doing a `setTimeout` or anything.)  If you set
+  `stale:true`, it'll return the stale value before deleting it.  If
+  you don't set this, then it'll return `undefined` when you try to
+  get a stale entry, as if it had already been deleted.
+* `noDisposeOnSet` By default, if you set a `dispose()` method, then
+  it'll be called whenever a `set()` operation overwrites an existing
+  key.  If you set this option, `dispose()` will only be called when a
+  key falls out of the cache, not when it is overwritten.
+* `updateAgeOnGet` When using time-expiring entries with `maxAge`,
+  setting this to `true` will make each item's effective time update
+  to the current time whenever it is retrieved from cache, causing it
+  to not expire.  (It can still fall out of cache based on recency of
+  use, of course.)
+
+## API
+
+* `set(key, value, maxAge)`
+* `get(key) => value`
+
+    Both of these will update the "recently used"-ness of the key.
+    They do what you think. `maxAge` is optional and overrides the
+    cache `maxAge` option if provided.
+
+    If the key is not found, `get()` will return `undefined`.
+
+    The key and val can be any value.
+
+* `peek(key)`
+
+    Returns the key value (or `undefined` if not found) without
+    updating the "recently used"-ness of the key.
+
+    (If you find yourself using this a lot, you *might* be using the
+    wrong sort of data structure, but there are some use cases where
+    it's handy.)
+
+* `del(key)`
+
+    Deletes a key out of the cache.
+
+* `reset()`
+
+    Clear the cache entirely, throwing away all values.
+
+* `has(key)`
+
+    Check if a key is in the cache, without updating the recent-ness
+    or deleting it for being stale.
+
+* `forEach(function(value,key,cache), [thisp])`
+
+    Just like `Array.prototype.forEach`.  Iterates over all the keys
+    in the cache, in order of recent-ness.  (Ie, more recently used
+    items are iterated over first.)
+
+* `rforEach(function(value,key,cache), [thisp])`
+
+    The same as `cache.forEach(...)` but items are iterated over in
+    reverse order.  (ie, less recently used items are iterated over
+    first.)
+
+* `keys()`
+
+    Return an array of the keys in the cache.
+
+* `values()`
+
+    Return an array of the values in the cache.
+
+* `length`
+
+    Return total length of objects in cache taking into account
+    `length` options function.
+
+* `itemCount`
+
+    Return total quantity of objects currently in cache. Note, that
+    `stale` (see options) items are returned as part of this item
+    count.
+
+* `dump()`
+
+    Return an array of the cache entries ready for serialization and usage
+    with 'destinationCache.load(arr)`.
+
+* `load(cacheEntriesArray)`
+
+    Loads another cache entries array, obtained with `sourceCache.dump()`,
+    into the cache. The destination cache is reset before loading new entries
+
+* `prune()`
+
+    Manually iterates over the entire cache proactively pruning old entries