Upload 65 files

.editorconfig

@@ -0,0 +1,17 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+[*.md]
+indent_size = 4
+indent_style = tab

.gitignore

@@ -0,0 +1,11 @@
+node_modules
+dist
+build
+out
+cache
+.envrc
+*.0x
+*.7z
+/settings.json
+explorer
+geolonia-japanese-addresses-v2-*.tgz

.tool-versions

@@ -0,0 +1 @@
+nodejs 22.9.0

DATA.md

@@ -0,0 +1,12 @@
+# データ作成について
+
+下記元データのリンク
+
+* [全アドレスデータ](https://catalog.registries.digital.go.jp/rc/dataset/ba000001) (位置参照拡張含む、**地番マスターは含まず**)
+* [日本 都道府県マスター データセット `mt_pref_all`](https://catalog.registries.digital.go.jp/rc/dataset/ba-o1-000000_g2-000001) [位置参照拡張 `mt_pref_pos_all`](https://catalog.registries.digital.go.jp/rc/dataset/ba-o1-000000_g2-000012)
+* [日本 市区町村マスター データセット `mt_city_all`](https://catalog.registries.digital.go.jp/rc/dataset/ba-o1-000000_g2-000002) [位置参照拡張 `mt_city_pos_all`](https://catalog.registries.digital.go.jp/rc/dataset/ba-o1-000000_g2-000013)
+* [日本 町字マスター データセット `mt_town_all`](https://catalog.registries.digital.go.jp/rc/dataset/ba-o1-000000_g2-000003) [位置参照拡張 `mt_town_pos_all`](https://catalog.registries.digital.go.jp/rc/dataset/ba000004) <- こちらの mt_town_pos_all は zip 内に1つのCSVファイルではなく、それぞれの都道府県に分けられた csv.zip が含まれています
+* [全国　住居表示-住居マスター　データセット `mt_rsdtdsp_rsdt_all`](https://catalog.registries.digital.go.jp/rc/dataset/ba000003) [位置参照拡張 `mt_rsdtdsp_rsdt_pos_all`](https://catalog.registries.digital.go.jp/rc/dataset/ba000006)
+* 地番マスター（全国データなし、それぞれの市区町村個別でダウンロード）
+  * (都道府県)(市区町村) `mt_parcel_cityXXXXXX` 位置参照拡張 `mt_parcel_pos_cityXXXXXX`
+  * [北海道北斗市](https://catalog.registries.digital.go.jp/rc/dataset/ba-o1-012360_g2-000010) [位置参照拡張](https://catalog.registries.digital.go.jp/rc/dataset/ba-o1-012360_g2-000011)

Dockerfile

@@ -0,0 +1,24 @@
+# 1. ベースイメージにNode.jsを使う
+FROM node:18
+
+# 2. 作業ディレクトリを設定
+WORKDIR /app
+
+# 3. パッケージとソースをコピー
+COPY package*.json ./
+COPY . .
+
+# 4. 依存関係をインストール
+RUN npm install
+
+# 5. ビルド（Viteを使用）
+RUN npm run build
+
+# 6. serve（静的ファイルサーバー）をグローバルにインストール
+RUN npm install -g serve
+
+# 7. ポート指定（HF Spacesは7860が標準）
+EXPOSE 7860
+
+# 8. buildフォルダを静的に提供
+CMD ["serve", "-s", "dist", "-l", "7860"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 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.

README.md

@@ -1,10 +1,185 @@
----
-title: Japanese Addresses V2
-emoji: 🐨
-colorFrom: blue
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Geolonia 住所データツール v2
+
+[![NPM Version](https://img.shields.io/npm/v/%40geolonia%2Fjapanese-addresses-v2)](https://www.npmjs.com/package/@geolonia/japanese-addresses-v2)
+
+全国の住所データを HTTP API として公開するためのツールを公開いたします。
+
+本データは、デジタル庁が整備する「[アドレス・ベース・レジストリ](https://www.digital.go.jp/policies/base_registry_address)」を元に加工し、様々なアプリケーションから便利に使えるように整理したものとなります。
+
+以前、「[Geolonia 住所データ](https://github.com/geolonia/japanese-addresses)」を管理しましたが、v2は従来版と比べて下記の違いがあります。
+
+* 住居表示住所データと対応（番地・号までのデータが含まれる）
+* 地番住所のデータと対応（住居表示住所が導入されていない地域のデータが含まれる）
+
+[リリースノート](https://github.com/geolonia/japanese-addresses-v2/releases)
+
+## API
+
+このデータを使用した API をご提供しています。現在、制限無しの無料公開をしていますが、様子見ながら公開を停止や変更など行うことがあります。商用稼働は、ご自身でデータを作成しホスティングすることを強くおすすめします。 Geolonia は有償で管理・ホスティングするサービスありますので、ご利用の方はお問い合わせてください。
+
+#### 都道府県エンドポイント
+
+```
+https://japanese-addresses-v2.geoloniamaps.com/api/ja.json
+```
+
+例: [https://japanese-addresses-v2.geoloniamaps.com/api/ja.json](https://japanese-addresses-v2.geoloniamaps.com/api/ja.json)
+
+```
+{ "meta": { "updated": 00000 }, "data": [
+  {
+	"code": 10006,
+	"pref": "北海道",
+	"point": [
+	  141.347906782,
+	  43.0639406375
+	]
+	"cities": [
+	  {
+		"code": 11011,
+		"city": "札幌市",
+		"ward": "中央区",
+		"point": [
+		  141.35389,
+		  43.061414
+		]
+	  },
+	  ...
+	]
+  },
+  ...
+```
+
+#### 町字エンドポイント
+
+```
+https://japanese-addresses-v2.geoloniamaps.com/api/ja/<都道府県名>/<市区町村名>.json
+```
+
+※ 都道府県名及び市区町村名は URL エンコードを行ってください。
+
+例: [https://japanese-addresses-v2.geoloniamaps.com/api/ja/%E6%9D%B1%E4%BA%AC%E9%83%BD/%E6%96%B0%E5%AE%BF%E5%8C%BA.json](https://japanese-addresses-v2.geoloniamaps.com/api/ja/%E6%9D%B1%E4%BA%AC%E9%83%BD/%E6%96%B0%E5%AE%BF%E5%8C%BA.json)
+
+```
+{ "meta": { "updated": 00000 }, "data": [
+  ...
+  // 地番情報なしの住居表示未実施大字「新宿区北町」
+  {"machiaza_id":"0001000","oaza_cho":"北町","point":[139.735037,35.69995]},
+
+  // 地番情報ありの住居表示実施「新宿区新宿三丁目」
+  {"machiaza_id":"0020003","oaza_cho":"新宿","chome":"三丁目","rsdt":true,"point":[139.703563,35.691227],"csv_ranges":{"住居表示":{"start":151421,"length":19193},"地番":{"start":189779,"length":8895}}},
+  ...
+```
+
+### 注意
+
+* 町丁目エンドポイントは、すべての地名を網羅しているわけではありません。
+* アドレス・ベース・レジストリの整備状況によって住居表示が実施されている町字でも住居表示住所のデータが無いや、地番住所のデータが無いなどのことがあります。また、住居表示や地番の文字列が存在しても位置情報データがまだ存在しないケースもあります。
+
+## 住所データ・ API のビルド
+
+```shell
+$ git clone [email protected]:geolonia/japanese-addresses-v2.git
+$ cd japanese-addresses-v2
+$ npm install
+$ npm run run:all # APIを全て生成する
+
+# オプション
+$ npm run run:01_make_prefecture_city # 都道府県・市区町村のみ作成
+$ npm run run:02_make_machi_aza # 町字API作成
+$ npm run run:03_make_rsdt # 住居表示住所API作成 (町字APIが先に作らないとエラーになります)
+$ npm run run:04_make_chiban # 地番住所API作成 (町字APIが先に作らないとエラーになります)
+```
+
+#### APIビルド設定
+
+`settings.json` に設定を入れてください。内容は `src/lib/settings.ts` を参照してください。
+
+例えば、出力を北海道にしぼりたい場合は下記のように設定してください。
+
+```json
+{
+	"lgCodes": ["^01"]
+}
+```
+
+#### アーカイブファイル作成
+
+`deploy/01a_create_archive.sh` を参照してください
+
+### API の構成
+
+```shell
+└── api
+    ├── ja
+    │   │── {都道府県名}
+    │   │   ├── {市区町村名}-住居表示.txt
+    │   │   ├── {市区町村名}-地番.txt
+    │   │   └── {市区町村名}.json     # 町字一覧
+    │   └── {都道府県名}.json         # 市区町村一覧
+    └── ja.json                     # 都道府県と市区町村の一覧
+```
+
+各ファイルの詳細な仕様は、 `src/data.ts` の型定義を参照してください。
+
+#### `txt` ファイル内のフォーマットについて
+
+`-地番.txt` と `-住居表示.txt` は容量節約のため、市区町村の住所を全て一つのファイルに集約するものです。そのテキストファイルのフォーマットは下記となります。
+
+
+```
+<町字1>,<start byte position>,<length in bytes>
+<町字2>,<start byte position>,<length in bytes>
+...
+=END=
+<padding>地番,<町字1>
+prc_num1,prc_num2,prc_num3,lng,lat
+1,,,<経度>,<緯度>
+...
+```
+
+論理的な構造としては
+
+1. ファイル全体のヘッダー
+	1. ファイル内の町字（丁目、小字含む）一覧
+		1. それぞれのデータのバイトレンジ（開始バイト数、容量バイト数）
+1. 町字データ（ループ）
+	1. 町字データのヘッダー
+		1. 地番・住居表示か
+		1. カラム名定義
+	1. 住所・位置情報データ
+
+ヘッダーは5万バイトの倍数となります。末尾に `=END=` を挿入し、残りまで `0x20` (半角スペース)で埋めます。クライアントは `=END=` を確認できるまで、5万バイトずつ読み込むことをおすすめします。
+
+また、 `api/ja/{都道府県名}/{市区町村名}.json` エンドポイントにも、 `csv_ranges` にヘッダーの start / length 情報入っているので、市区町村エンドポイントを既に読み込まれている場合はそのまま利用することをおすすめしております。
+
+## 出典
+
+本データは、以下のデータを元に、毎月 Geolonia にて更新作業を行っています。
+
+「アドレス・ベース・レジストリ」（デジタル庁）[住居表示住所・住居マスターデータセット](https://catalog.registries.digital.go.jp/) をもとに株式会社 Geolonia が作成したものです。
+
+## 貢献方法
+
+* 本データに不具合がある場合には、[Issue](https://github.com/geolonia/japanese-addresses-v2/issues) または[プルリクエスト](https://github.com/geolonia/japanese-addresses-v2/pulls)にてご報告ください。
+
+## japanese-addresses-v2を使っているプロジェクト
+
+* [normalize-japanese-addresses](https://github.com/geolonia/normalize-japanese-addresses) 日本の住所を正規化するライブラリ
+
+## スポンサー
+
+* [一般社団法人 不動産テック協会](https://retechjapan.org/)
+
+## 関連情報
+
+* [【プレスリリース】不動産テック協会、Geolonia と共同で不動産情報の共通 ID 付与の取り組みを開始](https://retechjapan.org/news/archives/pressrelease-20200731/)
+* [【プレスリリース】日本全国の住所マスターデータをオープンデータとして無料公開](https://geolonia.com/pressrelease/2020/08/05/japanese-addresses.html)
+
+## ライセンス
+
+Geolonia 住所データのライセンスは以下のとおりです。
+
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/deed.ja)
+
+注: リポジトリに同梱されているデータ生成用のスクリプトのライセンスは MIT ライセンスとします。

deploy/01_sync_to_s3.sh

@@ -0,0 +1,14 @@
+#!/bin/bash -e
+
+aws s3 sync \
+  --cache-control="max-age=86400, public" \
+  --exclude="*" \
+  --include="*.txt" \
+  --content-type="text/plain; charset=utf-8" \
+  ./out/ s3://japanese-addresses-v2.geoloniamaps.com/
+aws s3 sync \
+  --cache-control="max-age=86400, public" \
+  --exclude="*" \
+  --include="*.json" \
+  --content-type="application/json; charset=utf-8" \
+  ./out/ s3://japanese-addresses-v2.geoloniamaps.com/

deploy/01a_create_archive.sh

@@ -0,0 +1,5 @@
+#!/bin/bash -e
+
+cd "$(dirname "$0")"/../out
+tar -cf "api.tar" ./api
+zstd -T0 -19 --rm -z "api.tar"

deploy/02_clear_cloudflare_cache.sh

@@ -0,0 +1,11 @@
+#!/bin/bash -e
+
+curl  --request POST \
+      --url https://api.cloudflare.com/client/v4/zones/$CLOUDFLARE_ZONE_ID/purge_cache \
+      --header 'Content-Type: application/json' \
+      --header "Authorization: Bearer ${CLOUDFLARE_TOKEN}" \
+      --data '{
+        "files": [
+          "https://japanese-addresses-v2.geoloniamaps.com/api/ja.json"
+        ]
+      }'

docs/index.html

@@ -0,0 +1,182 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Geolonia japanese-addresses-v2</title>
+  <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
+  <script src="https://cdn.geolonia.com/v1/embed?geolonia-api-key=YOUR-API-KEY"></script>
+  <style type="text/css">
+    .hierarchical-list {
+      list-style-type: none;
+      padding-left: 20px;
+      position: relative;
+    }
+
+    .hierarchical-list li {
+      position: relative;
+      padding-left: 20px;
+    }
+
+    /* Vertical line connecting parent to child */
+    .hierarchical-list li::before {
+      content: "";
+      position: absolute;
+      top: 12px;
+      left: -10px;
+      border-left: 1px solid #777;
+      height: 100%;
+      width: 1px;
+    }
+
+    /* Horizontal line to connect list item to its parent */
+    .hierarchical-list li::after {
+      content: "";
+      position: absolute;
+      top: 12px;
+      left: -10px;
+      border-top: 1px solid #777;
+      width: 20px;
+    }
+    .hierarchical-list li:last-child::before {
+      content: "";
+      height: 12px;
+    }
+    .hierarchical-list ul {
+      padding-left: 20px;
+      list-style-type: none;
+    }
+    .hierarchical-list ul li::before {
+      top: 0;
+      height: 100%;
+    }
+    .hierarchical-list > li:last-child::before {
+      content: none;
+    }
+
+    .hierarchical-list li span {
+      margin-left: 10px;
+    }
+  </style>
+</head>
+<body>
+  <div id="root"></div>
+
+  <div class="container" style="margin-top: 80px; border-top: 3px solid #dedede; padding: 8px;">
+    <p style="text-align: center;"><a href="https://github.com/geolonia/japanese-addresses-v2">@geolonia/japanese-addresses-v2</a></p>
+  </div>
+
+  <script src="https://unpkg.com/[email protected]/umd/react.production.min.js"></script>
+  <script src="https://unpkg.com/[email protected]/umd/react-dom.production.min.js"></script>
+  <script type="module">
+    import htm from 'https://unpkg.com/[email protected]/dist/htm.module.js?module';
+    const html = htm.bind(React.createElement);
+    const API_ROOT = 'https://japanese-addresses-v2.geoloniamaps.com/api';
+
+    const toPercent = (num, total) => {
+      return ((num / total) * 100).toFixed(3);
+    };
+
+    const StatsTable = ({ stats }) => {
+      return html`
+        <ul className="hierarchical-list">
+          <li>
+            <strong>都道府県</strong>
+            <span>${stats.prefCount.toLocaleString()}</span>
+          </li>
+          <li>
+            <strong>市区町村 (政令指定都市の区を含む)</strong>
+            <span>${stats.lgCount.toLocaleString()}</span>
+          </li>
+          <li>
+            <strong>町字・丁目</strong>
+            <span>${stats.machiAzaCount.toLocaleString()}</span>
+            <ul>
+              <li>
+                <strong>住居表示あり</strong>
+                <span>${stats.machiAzaWithRsdtCount.toLocaleString()} (${toPercent(stats.machiAzaWithRsdtCount, stats.machiAzaCount)}%)</span>
+              </li>
+              <li>
+                <strong>地番あり</strong>
+                <span>${stats.machiAzaWithChibanCount.toLocaleString()} (${toPercent(stats.machiAzaWithChibanCount, stats.machiAzaCount)}%)</span>
+              </li>
+              <li>
+                <strong>住居表示と地番両方あり</strong>
+                <span>${stats.machiAzaWithChibanAndRsdtCount.toLocaleString()} (${toPercent(stats.machiAzaWithChibanAndRsdtCount, stats.machiAzaCount)}%)</span>
+              </li>
+            </ul>
+          </li>
+          <li>
+            <strong>住居表示住所</strong>
+            <span>${stats.rsdtCount.toLocaleString()}</span>
+            <ul>
+              <li>
+                <strong>位置情報あり</strong>
+                <span>${stats.rsdtWithPosCount.toLocaleString()} (${toPercent(stats.rsdtWithPosCount, stats.rsdtCount)}%)</span>
+              </li>
+            </ul>
+          </li>
+          <li>
+            <strong>地番住所</strong>
+            <span>${stats.chibanCount.toLocaleString()}</span>
+            <ul>
+              <li>
+                <strong>位置情報あり</strong>
+                <span>${stats.chibanWithPosCount.toLocaleString()} (${toPercent(stats.chibanWithPosCount, stats.chibanCount)}%)</span>
+              </li>
+            </ul>
+          </li>
+        </ul>
+      `;
+    };
+
+    const Stats = ({ updated }) => {
+      const [stats, setStats] = React.useState(null);
+
+      React.useEffect(() => {
+        fetch(`${API_ROOT}/stats.json?v=${updated}`)
+          .then((response) => response.json())
+          .then((data) => {
+            setStats(data);
+          });
+      }, [updated]);
+
+      const updatedFmt = new Date(updated * 1000).toLocaleString();
+
+      return html`
+        <div>
+          <h2>API内容の統計情報</h2>
+          <p>最終更新: ${updatedFmt}</p>
+          ${stats ? html`<${StatsTable} stats=${stats} />` : '読込中...'}
+        </div>
+      `;
+    };
+
+    const App = () => {
+      const [pref, setPref] = React.useState(null);
+      React.useEffect(() => {
+        fetch(`${API_ROOT}/ja.json`)
+          .then((response) => response.json())
+          .then((data) => {
+            setPref(data);
+          });
+      }, []);
+
+      return html`
+        <div class="container mt-4">
+          <h1><code>@geolonia/japanese-addresses-v2</code>について</h1>
+          <p>
+            全国の都道府県、市区町村、町字・丁目、住居表示住所、地番住所のデータを HTTP API として提供しています。このページは、API の内容を確認するためのデモページです。
+          </p>
+          <p>
+            詳しくは、 <a href="https://github.com/geolonia/japanese-addresses-v2">GitHub レポジトリ</a> をご覧ください。
+          </p>
+
+          ${pref ? html`<${Stats} updated=${pref.meta.updated} />` : null}
+        </div>
+      `;
+    }
+
+    ReactDOM.render(html`<${App} />`, document.getElementById("root"));
+  </script>
+</body>

eslint.config.mjs

@@ -0,0 +1,26 @@
+//@ts-check
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  tseslint.configs.recommended,
+  tseslint.configs.recommendedTypeChecked,
+  {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    }
+  },
+  {
+    ignores: [
+      'cache',
+      'node_modules',
+      'dist',
+      'eslint.config.mjs',
+      // '**/*.test.ts',
+    ],
+  }
+);

package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@geolonia/japanese-addresses-v2",
+  "type": "module",
+  "version": "0.0.5",
+  "description": "",
+  "exports": {
+    "import": "./dist/esm/data.mjs",
+    "require": "./dist/cjs/data.cjs",
+    "types": "./dist/esm/data.d.ts"
+  },
+  "main": "./dist/cjs/data.cjs",
+  "types": "./dist/esm/data.d.ts",
+  "scripts": {
+    "prepack": "npm run clean && npm run build",
+    "clean": "shx rm -rf ./dist",
+    "build:proto": "protoc --plugin=./node_modules/.bin/protoc-gen-ts_proto --ts_proto_out=. ./src/address_data.proto",
+    "build:dev": "tsc",
+    "build": "tsc -p tsconfig.dist-cjs.json && tsc -p tsconfig.dist-esm.json && mv ./dist/cjs/data.js ./dist/cjs/data.cjs && mv ./dist/esm/data.js ./dist/esm/data.mjs",
+    "clear:cache": "shx rm -rf ./cache",
+    "run:all": "npm run run:01_make_prefecture_city && npm run run:02_make_machi_aza && npm run run:03_make_rsdt && npm run run:04_make_chiban && npm run run:10_refresh_csv_ranges && npm run run:99_create_stats",
+    "run:01_make_prefecture_city": "tsx ./src/01_make_prefecture_city.ts",
+    "run:02_make_machi_aza": "tsx ./src/02_make_machi_aza.ts",
+    "run:03_make_rsdt": "node --max-old-space-size=8192 --import tsx ./src/03_make_rsdt.ts",
+    "run:04_make_chiban": "node --max-old-space-size=8192 --import tsx ./src/04_make_chiban.ts",
+    "run:10_refresh_csv_ranges": "tsx ./src/10_refresh_csv_ranges.ts",
+    "run:99_create_stats": "tsx ./src/99_create_stats.ts",
+    "create:archive": "rm ./api.7z; 7zz a ./api.7z ./out/api",
+    "start": "http-server --cors=\"*\" ./out",
+    "lint": "eslint ./src",
+    "test": "glob -c \"node --test --import tsx\" \"./src/**/*.test.ts\""
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "files": [
+    "dist/**/*"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "@tsconfig/node22": "^22.0.0",
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/cli-progress": "^3.11.6",
+    "@types/node": "^22.10.2",
+    "@types/proj4": "^2.5.5",
+    "@types/unzipper": "^0.10.10",
+    "better-sqlite3": "^11.7.2",
+    "cli-progress": "^3.12.0",
+    "csv-parse": "^5.6.0",
+    "eslint": "^9.17.0",
+    "glob": "^11.0.0",
+    "http-server": "^14.1.1",
+    "iconv-lite": "^0.6.3",
+    "lru-cache": "^11.0.2",
+    "proj4": "^2.12.1",
+    "shx": "^0.3.4",
+    "ts-proto": "^2.6.1",
+    "tsx": "^4.19.1",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.19.1",
+    "undici": "^7.2.1",
+    "unzipper": "^0.12.3"
+  }
+}

src/01_make_prefecture_city.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import main from './processes/01_make_prefecture_city.js';
+
+main(process.argv)
+  .then(() => {
+    process.exit(0);
+  })
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

src/02_make_machi_aza.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import main from './processes/02_make_machi_aza.js';
+
+main(process.argv)
+  .then(() => {
+    process.exit(0);
+  })
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

src/03_make_rsdt.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import main from './processes/03_make_rsdt.js';
+
+main(process.argv)
+  .then(() => {
+    process.exit(0);
+  })
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

src/04_make_chiban.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import main from './processes/04_make_chiban.js';
+
+main(process.argv)
+  .then(() => {
+    process.exit(0);
+  })
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

src/10_refresh_csv_ranges.ts

@@ -0,0 +1,10 @@
+import main from './processes/10_refresh_csv_ranges.js';
+
+main(process.argv)
+  .then(() => {
+    process.exit(0);
+  })
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

src/99_create_stats.ts

@@ -0,0 +1,9 @@
+import main from './processes/99_create_stats.js';
+
+main(process.argv)
+  .then(() => {
+    process.exit(0);
+  }).catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

src/address_data.proto

@@ -0,0 +1,53 @@
+message Header {
+  required Kind kind = 1;
+  // required string name = 2;
+  repeated HeaderRow rows = 3;
+}
+
+message HeaderRow {
+  required string name = 1;
+  required uint32 offset = 2;
+  required uint32 length = 3;
+}
+
+enum Kind {
+  RSDT = 0;
+  CHIBAN = 1;
+}
+
+message Section {
+  required Kind kind = 1;
+  required string name = 2;
+
+  repeated RsdtRow rsdt_rows = 3;
+  repeated ChibanRow chiban_rows = 4;
+}
+
+message RsdtRow {
+  optional uint32 blk_num = 1;
+  required uint32 rsdt_num = 2;
+  optional uint32 rsdt_num2 = 3;
+  optional LngLatPoint point = 4;
+
+  /** These strings are only used if the data cannot be expressed by an integer. */
+  optional string blk_num_str = 5;
+  optional string rsdt_num_str = 6;
+  optional string rsdt_num2_str = 7;
+}
+
+message ChibanRow {
+  required uint32 prc_num1 = 1;
+  optional uint32 prc_num2 = 2;
+  optional uint32 prc_num3 = 3;
+  optional LngLatPoint point = 4;
+
+  /** These strings are only used if the data cannot be expressed by an integer. */
+  optional string prc_num1_str = 5;
+  optional string prc_num2_str = 6;
+  optional string prc_num3_str = 7;
+}
+
+message LngLatPoint {
+  required double lng = 1;
+  required double lat = 2;
+}

src/address_data.ts

@@ -0,0 +1,763 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.2.0
+//   protoc               v5.28.1
+// source: src/address_data.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export const protobufPackage = "";
+
+export enum Kind {
+  RSDT = 0,
+  CHIBAN = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function kindFromJSON(object: any): Kind {
+  switch (object) {
+    case 0:
+    case "RSDT":
+      return Kind.RSDT;
+    case 1:
+    case "CHIBAN":
+      return Kind.CHIBAN;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Kind.UNRECOGNIZED;
+  }
+}
+
+export function kindToJSON(object: Kind): string {
+  switch (object) {
+    case Kind.RSDT:
+      return "RSDT";
+    case Kind.CHIBAN:
+      return "CHIBAN";
+    case Kind.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface Header {
+  kind: Kind;
+  /** required string name = 2; */
+  rows: HeaderRow[];
+}
+
+export interface HeaderRow {
+  name: string;
+  offset: number;
+  length: number;
+}
+
+export interface Section {
+  kind: Kind;
+  name: string;
+  rsdtRows: RsdtRow[];
+  chibanRows: ChibanRow[];
+}
+
+export interface RsdtRow {
+  blkNum?: number | undefined;
+  rsdtNum: number;
+  rsdtNum2?: number | undefined;
+  point?:
+    | LngLatPoint
+    | undefined;
+  /** These strings are only used if the data cannot be expressed by an integer. */
+  blkNumStr?: string | undefined;
+  rsdtNumStr?: string | undefined;
+  rsdtNum2Str?: string | undefined;
+}
+
+export interface ChibanRow {
+  prcNum1: number;
+  prcNum2?: number | undefined;
+  prcNum3?: number | undefined;
+  point?:
+    | LngLatPoint
+    | undefined;
+  /** These strings are only used if the data cannot be expressed by an integer. */
+  prcNum1Str?: string | undefined;
+  prcNum2Str?: string | undefined;
+  prcNum3Str?: string | undefined;
+}
+
+export interface LngLatPoint {
+  lng: number;
+  lat: number;
+}
+
+function createBaseHeader(): Header {
+  return { kind: 0, rows: [] };
+}
+
+export const Header: MessageFns<Header> = {
+  encode(message: Header, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.kind !== 0) {
+      writer.uint32(8).int32(message.kind);
+    }
+    for (const v of message.rows) {
+      HeaderRow.encode(v!, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Header {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHeader();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.kind = reader.int32() as any;
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.rows.push(HeaderRow.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Header {
+    return {
+      kind: isSet(object.kind) ? kindFromJSON(object.kind) : 0,
+      rows: globalThis.Array.isArray(object?.rows) ? object.rows.map((e: any) => HeaderRow.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: Header): unknown {
+    const obj: any = {};
+    if (message.kind !== 0) {
+      obj.kind = kindToJSON(message.kind);
+    }
+    if (message.rows?.length) {
+      obj.rows = message.rows.map((e) => HeaderRow.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Header>, I>>(base?: I): Header {
+    return Header.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Header>, I>>(object: I): Header {
+    const message = createBaseHeader();
+    message.kind = object.kind ?? 0;
+    message.rows = object.rows?.map((e) => HeaderRow.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseHeaderRow(): HeaderRow {
+  return { name: "", offset: 0, length: 0 };
+}
+
+export const HeaderRow: MessageFns<HeaderRow> = {
+  encode(message: HeaderRow, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.offset !== 0) {
+      writer.uint32(16).uint32(message.offset);
+    }
+    if (message.length !== 0) {
+      writer.uint32(24).uint32(message.length);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): HeaderRow {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHeaderRow();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.offset = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.length = reader.uint32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): HeaderRow {
+    return {
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      offset: isSet(object.offset) ? globalThis.Number(object.offset) : 0,
+      length: isSet(object.length) ? globalThis.Number(object.length) : 0,
+    };
+  },
+
+  toJSON(message: HeaderRow): unknown {
+    const obj: any = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.offset !== 0) {
+      obj.offset = Math.round(message.offset);
+    }
+    if (message.length !== 0) {
+      obj.length = Math.round(message.length);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<HeaderRow>, I>>(base?: I): HeaderRow {
+    return HeaderRow.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<HeaderRow>, I>>(object: I): HeaderRow {
+    const message = createBaseHeaderRow();
+    message.name = object.name ?? "";
+    message.offset = object.offset ?? 0;
+    message.length = object.length ?? 0;
+    return message;
+  },
+};
+
+function createBaseSection(): Section {
+  return { kind: 0, name: "", rsdtRows: [], chibanRows: [] };
+}
+
+export const Section: MessageFns<Section> = {
+  encode(message: Section, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.kind !== 0) {
+      writer.uint32(8).int32(message.kind);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    for (const v of message.rsdtRows) {
+      RsdtRow.encode(v!, writer.uint32(26).fork()).join();
+    }
+    for (const v of message.chibanRows) {
+      ChibanRow.encode(v!, writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Section {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSection();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.kind = reader.int32() as any;
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.rsdtRows.push(RsdtRow.decode(reader, reader.uint32()));
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.chibanRows.push(ChibanRow.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Section {
+    return {
+      kind: isSet(object.kind) ? kindFromJSON(object.kind) : 0,
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      rsdtRows: globalThis.Array.isArray(object?.rsdtRows) ? object.rsdtRows.map((e: any) => RsdtRow.fromJSON(e)) : [],
+      chibanRows: globalThis.Array.isArray(object?.chibanRows)
+        ? object.chibanRows.map((e: any) => ChibanRow.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: Section): unknown {
+    const obj: any = {};
+    if (message.kind !== 0) {
+      obj.kind = kindToJSON(message.kind);
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.rsdtRows?.length) {
+      obj.rsdtRows = message.rsdtRows.map((e) => RsdtRow.toJSON(e));
+    }
+    if (message.chibanRows?.length) {
+      obj.chibanRows = message.chibanRows.map((e) => ChibanRow.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Section>, I>>(base?: I): Section {
+    return Section.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Section>, I>>(object: I): Section {
+    const message = createBaseSection();
+    message.kind = object.kind ?? 0;
+    message.name = object.name ?? "";
+    message.rsdtRows = object.rsdtRows?.map((e) => RsdtRow.fromPartial(e)) || [];
+    message.chibanRows = object.chibanRows?.map((e) => ChibanRow.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseRsdtRow(): RsdtRow {
+  return { blkNum: 0, rsdtNum: 0, rsdtNum2: 0, point: undefined, blkNumStr: "", rsdtNumStr: "", rsdtNum2Str: "" };
+}
+
+export const RsdtRow: MessageFns<RsdtRow> = {
+  encode(message: RsdtRow, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.blkNum !== undefined && message.blkNum !== 0) {
+      writer.uint32(8).uint32(message.blkNum);
+    }
+    if (message.rsdtNum !== 0) {
+      writer.uint32(16).uint32(message.rsdtNum);
+    }
+    if (message.rsdtNum2 !== undefined && message.rsdtNum2 !== 0) {
+      writer.uint32(24).uint32(message.rsdtNum2);
+    }
+    if (message.point !== undefined) {
+      LngLatPoint.encode(message.point, writer.uint32(34).fork()).join();
+    }
+    if (message.blkNumStr !== undefined && message.blkNumStr !== "") {
+      writer.uint32(42).string(message.blkNumStr);
+    }
+    if (message.rsdtNumStr !== undefined && message.rsdtNumStr !== "") {
+      writer.uint32(50).string(message.rsdtNumStr);
+    }
+    if (message.rsdtNum2Str !== undefined && message.rsdtNum2Str !== "") {
+      writer.uint32(58).string(message.rsdtNum2Str);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RsdtRow {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRsdtRow();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.blkNum = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.rsdtNum = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.rsdtNum2 = reader.uint32();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.point = LngLatPoint.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.blkNumStr = reader.string();
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.rsdtNumStr = reader.string();
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+
+          message.rsdtNum2Str = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RsdtRow {
+    return {
+      blkNum: isSet(object.blkNum) ? globalThis.Number(object.blkNum) : 0,
+      rsdtNum: isSet(object.rsdtNum) ? globalThis.Number(object.rsdtNum) : 0,
+      rsdtNum2: isSet(object.rsdtNum2) ? globalThis.Number(object.rsdtNum2) : 0,
+      point: isSet(object.point) ? LngLatPoint.fromJSON(object.point) : undefined,
+      blkNumStr: isSet(object.blkNumStr) ? globalThis.String(object.blkNumStr) : "",
+      rsdtNumStr: isSet(object.rsdtNumStr) ? globalThis.String(object.rsdtNumStr) : "",
+      rsdtNum2Str: isSet(object.rsdtNum2Str) ? globalThis.String(object.rsdtNum2Str) : "",
+    };
+  },
+
+  toJSON(message: RsdtRow): unknown {
+    const obj: any = {};
+    if (message.blkNum !== undefined && message.blkNum !== 0) {
+      obj.blkNum = Math.round(message.blkNum);
+    }
+    if (message.rsdtNum !== 0) {
+      obj.rsdtNum = Math.round(message.rsdtNum);
+    }
+    if (message.rsdtNum2 !== undefined && message.rsdtNum2 !== 0) {
+      obj.rsdtNum2 = Math.round(message.rsdtNum2);
+    }
+    if (message.point !== undefined) {
+      obj.point = LngLatPoint.toJSON(message.point);
+    }
+    if (message.blkNumStr !== undefined && message.blkNumStr !== "") {
+      obj.blkNumStr = message.blkNumStr;
+    }
+    if (message.rsdtNumStr !== undefined && message.rsdtNumStr !== "") {
+      obj.rsdtNumStr = message.rsdtNumStr;
+    }
+    if (message.rsdtNum2Str !== undefined && message.rsdtNum2Str !== "") {
+      obj.rsdtNum2Str = message.rsdtNum2Str;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<RsdtRow>, I>>(base?: I): RsdtRow {
+    return RsdtRow.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<RsdtRow>, I>>(object: I): RsdtRow {
+    const message = createBaseRsdtRow();
+    message.blkNum = object.blkNum ?? 0;
+    message.rsdtNum = object.rsdtNum ?? 0;
+    message.rsdtNum2 = object.rsdtNum2 ?? 0;
+    message.point = (object.point !== undefined && object.point !== null)
+      ? LngLatPoint.fromPartial(object.point)
+      : undefined;
+    message.blkNumStr = object.blkNumStr ?? "";
+    message.rsdtNumStr = object.rsdtNumStr ?? "";
+    message.rsdtNum2Str = object.rsdtNum2Str ?? "";
+    return message;
+  },
+};
+
+function createBaseChibanRow(): ChibanRow {
+  return { prcNum1: 0, prcNum2: 0, prcNum3: 0, point: undefined, prcNum1Str: "", prcNum2Str: "", prcNum3Str: "" };
+}
+
+export const ChibanRow: MessageFns<ChibanRow> = {
+  encode(message: ChibanRow, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.prcNum1 !== 0) {
+      writer.uint32(8).uint32(message.prcNum1);
+    }
+    if (message.prcNum2 !== undefined && message.prcNum2 !== 0) {
+      writer.uint32(16).uint32(message.prcNum2);
+    }
+    if (message.prcNum3 !== undefined && message.prcNum3 !== 0) {
+      writer.uint32(24).uint32(message.prcNum3);
+    }
+    if (message.point !== undefined) {
+      LngLatPoint.encode(message.point, writer.uint32(34).fork()).join();
+    }
+    if (message.prcNum1Str !== undefined && message.prcNum1Str !== "") {
+      writer.uint32(42).string(message.prcNum1Str);
+    }
+    if (message.prcNum2Str !== undefined && message.prcNum2Str !== "") {
+      writer.uint32(50).string(message.prcNum2Str);
+    }
+    if (message.prcNum3Str !== undefined && message.prcNum3Str !== "") {
+      writer.uint32(58).string(message.prcNum3Str);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ChibanRow {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChibanRow();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.prcNum1 = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.prcNum2 = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.prcNum3 = reader.uint32();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.point = LngLatPoint.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.prcNum1Str = reader.string();
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.prcNum2Str = reader.string();
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+
+          message.prcNum3Str = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ChibanRow {
+    return {
+      prcNum1: isSet(object.prcNum1) ? globalThis.Number(object.prcNum1) : 0,
+      prcNum2: isSet(object.prcNum2) ? globalThis.Number(object.prcNum2) : 0,
+      prcNum3: isSet(object.prcNum3) ? globalThis.Number(object.prcNum3) : 0,
+      point: isSet(object.point) ? LngLatPoint.fromJSON(object.point) : undefined,
+      prcNum1Str: isSet(object.prcNum1Str) ? globalThis.String(object.prcNum1Str) : "",
+      prcNum2Str: isSet(object.prcNum2Str) ? globalThis.String(object.prcNum2Str) : "",
+      prcNum3Str: isSet(object.prcNum3Str) ? globalThis.String(object.prcNum3Str) : "",
+    };
+  },
+
+  toJSON(message: ChibanRow): unknown {
+    const obj: any = {};
+    if (message.prcNum1 !== 0) {
+      obj.prcNum1 = Math.round(message.prcNum1);
+    }
+    if (message.prcNum2 !== undefined && message.prcNum2 !== 0) {
+      obj.prcNum2 = Math.round(message.prcNum2);
+    }
+    if (message.prcNum3 !== undefined && message.prcNum3 !== 0) {
+      obj.prcNum3 = Math.round(message.prcNum3);
+    }
+    if (message.point !== undefined) {
+      obj.point = LngLatPoint.toJSON(message.point);
+    }
+    if (message.prcNum1Str !== undefined && message.prcNum1Str !== "") {
+      obj.prcNum1Str = message.prcNum1Str;
+    }
+    if (message.prcNum2Str !== undefined && message.prcNum2Str !== "") {
+      obj.prcNum2Str = message.prcNum2Str;
+    }
+    if (message.prcNum3Str !== undefined && message.prcNum3Str !== "") {
+      obj.prcNum3Str = message.prcNum3Str;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ChibanRow>, I>>(base?: I): ChibanRow {
+    return ChibanRow.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ChibanRow>, I>>(object: I): ChibanRow {
+    const message = createBaseChibanRow();
+    message.prcNum1 = object.prcNum1 ?? 0;
+    message.prcNum2 = object.prcNum2 ?? 0;
+    message.prcNum3 = object.prcNum3 ?? 0;
+    message.point = (object.point !== undefined && object.point !== null)
+      ? LngLatPoint.fromPartial(object.point)
+      : undefined;
+    message.prcNum1Str = object.prcNum1Str ?? "";
+    message.prcNum2Str = object.prcNum2Str ?? "";
+    message.prcNum3Str = object.prcNum3Str ?? "";
+    return message;
+  },
+};
+
+function createBaseLngLatPoint(): LngLatPoint {
+  return { lng: 0, lat: 0 };
+}
+
+export const LngLatPoint: MessageFns<LngLatPoint> = {
+  encode(message: LngLatPoint, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.lng !== 0) {
+      writer.uint32(9).double(message.lng);
+    }
+    if (message.lat !== 0) {
+      writer.uint32(17).double(message.lat);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): LngLatPoint {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLngLatPoint();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 9) {
+            break;
+          }
+
+          message.lng = reader.double();
+          continue;
+        case 2:
+          if (tag !== 17) {
+            break;
+          }
+
+          message.lat = reader.double();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): LngLatPoint {
+    return {
+      lng: isSet(object.lng) ? globalThis.Number(object.lng) : 0,
+      lat: isSet(object.lat) ? globalThis.Number(object.lat) : 0,
+    };
+  },
+
+  toJSON(message: LngLatPoint): unknown {
+    const obj: any = {};
+    if (message.lng !== 0) {
+      obj.lng = message.lng;
+    }
+    if (message.lat !== 0) {
+      obj.lat = message.lat;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<LngLatPoint>, I>>(base?: I): LngLatPoint {
+    return LngLatPoint.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<LngLatPoint>, I>>(object: I): LngLatPoint {
+    const message = createBaseLngLatPoint();
+    message.lng = object.lng ?? 0;
+    message.lat = object.lat ?? 0;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}

src/data.ts

@@ -0,0 +1,191 @@
+/** 注意: [経度, 緯度] の順 */
+export type LngLat = [number, number];
+
+export type SinglePrefecture = {
+  /** 全国地方公共団体コード */
+  code: number;
+  /** 都道府県名 */
+  pref: string;
+
+  /** 都道府県名 (カナ) */
+  pref_k: string;
+
+  /** 都道府県名 (ローマ字) */
+  pref_r: string;
+
+  /** 代表点 (県庁の位置) */
+  point: LngLat;
+
+  cities: SingleCity[];
+};
+
+/**
+ * SinglePrefecture から都道府県名を取得します。
+ * @param pref SinglePrefecture
+ * @returns string
+ */
+export function prefectureName(pref: SinglePrefecture): string {
+  return pref.pref;
+}
+
+type Api<T> = {
+  meta: {
+    /** データ更新日(UNIX時間; 秒) */
+    updated: number;
+  };
+  data: T;
+}
+
+/**
+ * 都道府県、市区町村一覧API
+ * 政令都市の場合は区で区切ります
+ * @file api/ja.json
+ */
+export type PrefectureApi = Api<SinglePrefecture[]>;
+
+export type SingleCity = {
+  /** 全国地方公共団体コード */
+  code: number;
+  /** 郡名 */
+  county?: string;
+  /** 郡名 (カナ) */
+  county_k?: string;
+  /** 郡名 (ローマ字) */
+  county_r?: string;
+
+  /** 市区町村名 */
+  city: string;
+  /** 市区町村名 (カナ) */
+  city_k: string;
+  /** 市区町村名 (ローマ字) */
+  city_r: string;
+
+  /** 政令市区名 */
+  ward?: string;
+  /** 政令市区名 (カナ) */
+  ward_k?: string;
+  /** 政令市区名 (ローマ字) */
+  ward_r?: string;
+
+  /** 代表点 (自治体役場の位置) */
+  point: LngLat;
+};
+
+/**
+ * SingleCity から市区町村名を取得します。郡名と政令市区名を含めます。
+ * @param city SingleCity
+ * @returns string
+ */
+export function cityName(city: SingleCity): string {
+  return `${city.county || ''}${city.city}${city.ward || ''}`;
+}
+
+/**
+ * 市区町村一覧API
+ * @file api/ja/{都道府県名}.json
+ */
+export type CityApi = Api<SingleCity[]>;
+
+export type SingleMachiAza = {
+  /** ABR上の「町字ID」 */
+  machiaza_id: string;
+
+  /** 大字・町名 */
+  oaza_cho?: string;
+  /** 大字・町名 (カナ) */
+  oaza_cho_k?: string;
+  /** 大字・町名 (ローマ字) */
+  oaza_cho_r?: string;
+
+  /** 丁目名 */
+  chome?: string;
+  /** 丁目名 (数字) */
+  chome_n?: number;
+
+  /** 小字名 */
+  koaza?: string;
+  /** 小字名 (カナ) */
+  koaza_k?: string;
+  /** 小字名 (ローマ字) */
+  koaza_r?: string;
+
+  /** 住居表示住所の情報の存在。値が存在しない場合は、住居表示住所の情報は存在しません。 */
+  rsdt?: true;
+
+  /** 代表点 */
+  point?: LngLat;
+
+  /** CSV APIに付加情報が存在する場合、この町字のバイト範囲を指定します。 */
+  csv_ranges?: {
+    ["住居表示"]?: { start: number; length: number; };
+    ["地番"]?: { start: number; length: number; };
+  }
+};
+
+/**
+ * SingleMachiAza から町字名を取得します。大字・丁目・小字を含めます。
+ * @param machiAza SingleMachiAza
+ * @returns string
+ */
+export function machiAzaName(machiAza: SingleMachiAza): string {
+  return `${machiAza.oaza_cho || ''}${machiAza.chome || ''}${machiAza.koaza || ''}`;
+}
+
+/**
+ * 町字一覧API
+ * @file api/ja/{都道府県名}/{市区町村名}.json
+ */
+export type MachiAzaApi = Api<SingleMachiAza[]>;
+
+export type SingleRsdt = {
+  /** 街区符号 */
+  blk_num?: string;
+  /** 住居番号 */
+  rsdt_num: string;
+  /** 住居番号2 */
+  rsdt_num2?: string;
+
+  /** 代表点 */
+  point?: LngLat;
+};
+
+/**
+ * SingleRsdt の街区符号・住居番号・住居番号2を `-` で区切った文字列を返します。
+ * @param rsdt SingleRsdt
+ * @returns string
+ */
+export function rsdtToString(rsdt: SingleRsdt): string {
+  return [rsdt.blk_num, rsdt.rsdt_num, rsdt.rsdt_num2].filter(Boolean).join('-');
+}
+
+/**
+ * {市区町村名}-住居表示.json は類似なデータフォーマットを使います。
+ * @file api/ja/{都道府県名}/{市区町村名}-住居表示.json
+ */
+export type RsdtApi = {
+  machiAza: SingleMachiAza;
+  rsdts: SingleRsdt[];
+}[];
+
+export type SingleChiban = {
+  /** 地番1 */
+  prc_num1: string;
+  /** 地番2 */
+  prc_num2?: string;
+  /** 地番3 */
+  prc_num3?: string;
+
+  /** 代表点 */
+  point?: LngLat;
+};
+
+/**
+ * SingleChiban の地番1・地番2・地番3を `-` で区切った文字列を返します。
+ * @param chiban SingleChiban
+ * @returns string
+ */
+export function chibanToString(chiban: SingleChiban): string {
+  return [chiban.prc_num1, chiban.prc_num2, chiban.prc_num3]
+    .filter(Boolean)
+    .join('-');
+}

src/lib/abr_mlit_merge_tools.ts

@@ -0,0 +1,29 @@
+import { SingleMachiAza } from "../data.js";
+import { NlftpMlitDataRow } from "./mlit_nlftp.js";
+
+export function filterMlitDataByPrefCity(mlitData: NlftpMlitDataRow[], prefName: string, cityName: string): NlftpMlitDataRow[] {
+  return mlitData.filter(row => row.pref_name === prefName && row.city_name === cityName);
+}
+
+export function createMergedApiData(abrData: SingleMachiAza[], mlitData: NlftpMlitDataRow[]): SingleMachiAza[] {
+  const out = abrData;
+
+  for (const row of mlitData) {
+    // ABRデータに重複があるかのチェック
+    if (abrData.find(a => (
+      (a.oaza_cho === row.oaza_cho && a.chome === row.chome) || // 大字と丁目が一致する場合
+      (a.koaza === row.oaza_cho) || // 小字が一致する場合
+      ((a.oaza_cho || '') + (a.koaza || '') === row.oaza_cho) // 大字と小字を結合したものが一致する場合
+    ))) {
+      continue;
+    }
+    out.push({
+      machiaza_id: row.machiaza_id,
+      oaza_cho: row.oaza_cho,
+      chome: row.chome,
+      point: row.point,
+    })
+  }
+
+  return out;
+}

src/lib/ckan.test.ts

@@ -0,0 +1,29 @@
+import assert from 'node:assert';
+import test from 'node:test';
+
+import * as ckan from './ckan.js';
+
+await test.describe('ckan', async () => {
+  await test('ckanPackageSearch works', async () => {
+    const res = await ckan.ckanPackageSearch('香川県高松市');
+    assert.ok(res.length > 0);
+  });
+
+  await test('getCkanPackageById works', async () => {
+    const res = await ckan.getCkanPackageById('ba-o1-000000_g2-000001');
+    assert.strictEqual(res.name, 'ba-o1-000000_g2-000001');
+  });
+
+  await test.describe('downloadAndExtract', async () => {
+    await test('should download, unzip, and parse the CSV file', async () => {
+      const res = ckan.downloadAndExtract<Record<string, string>>('https://catalog.registries.digital.go.jp/rsc/address/mt_town_city372013.csv.zip');
+      let count = 0;
+      for await (const row of res) {
+        count += 1;
+        // make sure all rows are parsed, and the header row is not in the results
+        assert.strictEqual(row['lg_code'], '372013');
+      }
+      assert.ok(count > 0);
+    });
+  });
+});

src/lib/ckan.ts

@@ -0,0 +1,167 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+import { parse as csvParse } from 'csv-parse';
+
+import { fetch } from 'undici';
+import { unzipAndExtractZipBuffer } from './zip_tools.js';
+import { getDownloadStream } from './fetch_tools.js';
+import { lgCodeMatch, loadSettings } from './settings.js';
+
+const CKAN_BASE_REGISTRY_URL = `https://catalog.registries.digital.go.jp/rc`
+const USER_AGENT = 'curl/8.7.1';
+const CACHE_DIR = path.join(import.meta.dirname, '..', '..', 'cache');
+
+export type CKANResponse<T = CKANResponseInner> = {
+  success: false
+} | {
+  success: true
+  result: T
+}
+
+type CKANResponseInner = (
+  CKANPackageSearchResultList |
+  CKANPackageSearchResult
+);
+
+export type CKANPackageSearchResultList = {
+  count: number,
+  sort: string,
+  results: CKANPackageSearchResult[]
+}
+
+export type CKANPackageSearchResult = {
+  id: string
+  metadata_created: string,
+  metadata_modified: string,
+  name: string,
+  notes: string,
+  num_resources: number,
+  num_tags: number,
+  title: string,
+  type: string,
+  extras: { [key: string]: string }[],
+  resources: CKANPackageResource[],
+}
+
+export type CKANPackageResource = {
+  description: string
+  last_modified: string
+  id: string
+  url: string
+  format: string
+}
+
+export async function ckanPackageSearch(query: string): Promise<CKANPackageSearchResult[]> {
+  const cacheKey = `package_search_${query}.json`;
+  const cacheFile = path.join(CACHE_DIR, 'ckan', cacheKey);
+
+  let json: CKANResponse<CKANPackageSearchResultList>;
+  if (fs.existsSync(cacheFile)) {
+    json = await fs.promises.readFile(cacheFile, 'utf-8')
+      .then((data) => JSON.parse(data) as CKANResponse<CKANPackageSearchResultList>);
+  } else {
+    const url = new URL(`${CKAN_BASE_REGISTRY_URL}/api/3/action/package_search`);
+    url.searchParams.set('q', query);
+    const res = await fetch(url.toString(), {
+      headers: {
+        'User-Agent': USER_AGENT,
+      },
+    });
+    json = await res.json() as CKANResponse<CKANPackageSearchResultList>;
+
+    await fs.promises.mkdir(path.dirname(cacheFile), { recursive: true });
+    await fs.promises.writeFile(cacheFile, JSON.stringify(json));
+  }
+
+  if (!json.success) {
+    throw new Error('CKAN API returned an error: ' + JSON.stringify(json));
+  }
+
+  return json.result.results;
+}
+
+export async function getCkanPackageById(id: string): Promise<CKANPackageSearchResult> {
+  const cacheKey = `package_show_${id}.json`;
+  const cacheFile = path.join(CACHE_DIR, 'ckan', cacheKey);
+
+  let json: CKANResponse<CKANPackageSearchResult>;
+  if (fs.existsSync(cacheFile)) {
+    json = await fs.promises.readFile(cacheFile, 'utf-8')
+      .then((data) => JSON.parse(data) as CKANResponse<CKANPackageSearchResult>);
+  } else {
+    const url = new URL(`${CKAN_BASE_REGISTRY_URL}/api/3/action/package_show`);
+    url.searchParams.set('id', id);
+    const res = await fetch(url.toString(), {
+      headers: {
+        'User-Agent': USER_AGENT,
+      },
+    });
+    json = await res.json() as CKANResponse<CKANPackageSearchResult>;
+
+    await fs.promises.mkdir(path.dirname(cacheFile), { recursive: true });
+    await fs.promises.writeFile(cacheFile, JSON.stringify(json));
+  }
+  if (!json.success) {
+    throw new Error('CKAN API returned an error: ' + JSON.stringify(json));
+  }
+  return json.result;
+}
+
+export function getUrlForCSVResource(res: CKANPackageSearchResult): string | undefined {
+  return res.resources.find((resource) => resource.format.startsWith('CSV'))?.url;
+}
+
+export type CSVParserIterator<T> = AsyncIterableIterator<T>;
+
+export async function *combineCSVParserIterators<T>(...iterators: CSVParserIterator<T>[]): CSVParserIterator<T> {
+  for (const i of iterators) {
+    yield* i;
+  }
+}
+
+export async function *downloadAndExtract<T>(url: string): CSVParserIterator<T> {
+  const bodyStream = await getDownloadStream(url);
+  const fileEntries = unzipAndExtractZipBuffer(bodyStream);
+  for await (const entry of fileEntries) {
+    const csvParser = csvParse(entry, { quote: false });
+    let header: string[] | undefined = undefined;
+    for await (const r of csvParser) {
+      const record = r as string[];
+      // save header
+      if (typeof header === 'undefined') {
+        header = record;
+        continue;
+      }
+      yield record.reduce<Record<string, string>>((acc, value, index) => {
+        acc[header![index]] = value;
+        return acc;
+      }, {}) as T;
+    }
+  }
+}
+
+export async function *getAndStreamCSVDataForId<T = Record<string, string>>(id: string): CSVParserIterator<T> {
+  const res = await getCkanPackageById(id);
+  const url = getUrlForCSVResource(res);
+  if (!url) {
+    throw new Error('No CSV resource found');
+  }
+  const settings = await loadSettings();
+  for await (const record of downloadAndExtract<T>(url)) {
+    const lgCode = (record as {'lg_code': string})['lg_code'];
+    if (!lgCodeMatch(settings, lgCode)) { continue; }
+    yield record;
+  }
+}
+
+export async function getAndParseCSVDataForId<T = Record<string, string>>(id: string): Promise<T[]> {
+  return Array.fromAsync(getAndStreamCSVDataForId<T>(id));
+}
+
+export function findResultByTypeAndArea(results: CKANPackageSearchResult[], dataType: string, area: string): CKANPackageSearchResult | undefined {
+  return results.find((result) => (
+    result.extras.findIndex((extra) => (extra.key === "データセット種別" && extra.value === dataType)) > 0 &&
+    result.extras.findIndex((extra) => (extra.key === "対象地域" && extra.value === area)) > 0
+  ));
+}

src/lib/ckan_data/chiban.ts

@@ -0,0 +1,83 @@
+export type ChibanData = {
+  /// 全国地方公共団体コード
+  lg_code: string
+  /// 町字ID
+  machiaza_id: string
+  /// 地番ID
+  prc_id: string
+  /// 市区町村名
+  city: string
+  /// 政令市区名
+  ward: string
+  /// 大字・町名
+  oaza_cho: string
+  /// 丁目名
+  chome: string
+  /// 小字名
+  koaza: string
+  /// 地番1
+  prc_num1: string
+  /// 地番2
+  prc_num2: string
+  /// 地番3
+  prc_num3: string
+  /// 住居表示フラグ
+  rsdt_addr_flg: string
+  /// 地番レコード区分フラグ
+  prc_rec_flg: string
+  /// 地番区域コード
+  prc_area_code: string
+  /// 効力発生日
+  efct_date: string
+  /// 廃止日
+  ablt_date: string
+  /// 原典資料コード
+  src_code: string
+  /// 備考
+  remarks: string
+  /// 不動産番号
+  real_prop_num: string
+};
+
+export type ChibanPosData = {
+  /// 全国地方公共団体コード
+  lg_code: string;
+  /// 町字ID
+  machiaza_id: string;
+  /// 地番ID
+  prc_id: string;
+  /// 代表点_経度
+  rep_lon: string;
+  /// 代表点_緯度
+  rep_lat: string;
+  /// 代表点_座標参照系
+  rep_srid: string;
+  /// 代表点_地図情報レベル
+  rep_scale: string;
+  /// 代表点_原典資料コード
+  rep_src_code: string;
+  /// ポリゴン_ファイル名
+  plygn_fname: string;
+  /// ポリゴン_キーコード
+  plygn_kcode: string;
+  /// ポリゴン_データフォーマット
+  plygn_fmt: string;
+  /// ポリゴン_座標参照系
+  plygn_srid: string;
+  /// ポリゴン_地図情報レベル
+  plygn_scale: string;
+  /// ポリゴン_原典資料コード
+  plygn_src_code: string;
+  /// 法務省地図_市区町村コード
+  moj_map_city_code: string;
+  /// 法務省地図_大字コード
+  moj_map_oaza_code: string;
+  /// 法務省地図_丁目コード
+  moj_map_chome_code: string;
+  /// 法務省地図_小字コード
+  moj_map_koaza_code: string;
+  /// 法務省地図_予備コード
+  moj_map_spare_code: string;
+  /// 法務省地図_筆id
+  moj_map_brushid: string;
+};

src/lib/ckan_data/city.ts

@@ -0,0 +1,70 @@
+export type CityData = {
+  /// 全国地方公共団体コード
+  lg_code: string;
+  /// 都道府県名
+  pref: string;
+  /// 都道府県名_カナ
+  pref_kana: string;
+  /// 都道府県名_英字
+  pref_roma: string;
+  /// 郡名
+  county: string;
+  /// 郡名_カナ
+  county_kana: string;
+  /// 郡名_英字
+  county_roma: string;
+  /// 市区町村名
+  city: string;
+  /// 市区町村名_カナ
+  city_kana: string;
+  /// 市区町村名_英字
+  city_roma: string;
+  /// 政令市区名
+  ward: string;
+  /// 政令市区名_カナ
+  ward_kana: string;
+  /// 政令市区名_英字
+  ward_roma: string;
+  /// 効力発生日
+  efct_date: string;
+  /// 廃止日
+  ablt_date: string;
+  /// 備考
+  remarks: string;
+};
+
+export type CityPosData = {
+  /// 全国地方公共団体コード
+  lg_code: string;
+  /// 代表点_経度
+  rep_lon: string;
+  /// 代表点_緯度
+  rep_lat: string;
+  /// 代表点_座標参照系
+  rep_srid: string;
+  /// 代表点_地図情報レベル
+  rep_scale: string;
+  /// ポリゴン_ファイル名
+  plygn_fname: string;
+  /// ポリゴン_キーコード
+  plygn_kcode: string;
+  /// ポリゴン_データフォーマット
+  plygn_fmt: string;
+  /// ポリゴン_座標参照系
+  plygn_srid: string;
+  /// ポリゴン_地図情報レベル
+  plygn_scale: string;
+};
+
+export type CityDataWithPos = CityData & CityPosData;
+
+export function mergeCityData(cityData: CityData[], cityPosData: CityPosData[]): CityDataWithPos[] {
+  const out: CityDataWithPos[] = [];
+  for (const city of cityData) {
+    const pos = cityPosData.find((pos) => pos.lg_code === city.lg_code);
+    if (pos) {
+      out.push({ ...city, ...pos });
+    }
+  }
+  return out;
+}

src/lib/ckan_data/index.test.ts

@@ -0,0 +1,55 @@
+import assert from 'node:assert';
+import test, { describe } from 'node:test';
+
+import * as index from './index.js';
+
+await describe('ckan_data/index', async () => {
+  await describe('joinAsyncIterators', async () => {
+    await test('it correctly joins two async iterators when they are ordered', async () => {
+      const one = async function*(){
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        yield *[
+          { id: 100, name: 'Alice' },
+          { id: 101, name: 'Bob' }
+        ];
+      };
+      const two = async function*(){
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        yield *[
+          { id: 100, age: 500 },
+          { id: 101, age: 501 }
+        ];
+      };
+
+      const res = await Array.fromAsync(
+        index.mergeDataLeftJoin(one(), two(), ['id'])
+      );
+
+      assert.deepStrictEqual(res, [
+        { id: 100, name: 'Alice', age: 500 },
+        { id: 101, name: 'Bob', age: 501 },
+      ]);
+    });
+
+    await test('it correctly joins two async iterators when they are out of order', async () => {
+      const one = async function *() {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        yield *[{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }];
+      };
+      const two = async function *() {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        yield *[{ id: 2, age: 30 }, { id: 1, age: 25 }, { id: 4, age: 35 }];
+      };
+
+      const res = await Array.fromAsync(
+        index.mergeDataLeftJoin(one(), two(), ['id'])
+      );
+
+      assert.deepStrictEqual(res, [
+        { id: 1, name: 'Alice', age: 25 },
+        { id: 2, name: 'Bob', age: 30 },
+        { id: 3, name: 'Charlie' },
+      ]);
+    });
+  });
+});

src/lib/ckan_data/index.ts

@@ -0,0 +1,70 @@
+import Database from "better-sqlite3";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _createKey(data: any, keys: string[]): string {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return keys.map((key) => `${data[key]}`).join("|");
+}
+
+export async function *mergeDataLeftJoin<T, U>(left: AsyncIterableIterator<T>, right: AsyncIterableIterator<U>, keys: string[], memory: boolean = false): AsyncIterableIterator<(T | T & U)> {
+  let tmpDbPath = ":memory:";
+
+  if (!memory) {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "merge-data-left-join-"));
+    tmpDbPath = path.join(tmpDir, "db.sqlite3");
+    console.log(`Creating temporary database: ${tmpDbPath}`);
+  }
+
+  const db = new Database(tmpDbPath);
+  db.pragma("synchronous = OFF");
+  db.pragma("journal_mode = MEMORY");
+  db.exec(`
+    CREATE TABLE l (
+      key TEXT,
+      data JSONB
+    );
+    CREATE TABLE r (
+      key TEXT,
+      data JSONB
+    );
+  `);
+  const stmt1 = db.prepare("INSERT INTO l VALUES (?, ?)");
+  const stmt2 = db.prepare("INSERT INTO r VALUES (?, ?)");
+
+  await Promise.all([
+    pipeline(left, async function (source) {
+      for await (const data of source) {
+        stmt1.run(_createKey(data, keys), JSON.stringify(data));
+      }
+    }),
+    pipeline(right, async function (source) {
+      for await (const data of source) {
+        stmt2.run(_createKey(data, keys), JSON.stringify(data));
+      }
+    }),
+  ]);
+  db.exec(`
+    CREATE INDEX l_key ON l(key);
+    CREATE INDEX r_key ON r(key);
+  `);
+
+  const select = db.prepare<void[], {d01: string, d02: string}>(`
+    SELECT
+      json_patch(l.data, coalesce(r.data, '{}')) AS d01
+    FROM
+      l
+      LEFT JOIN r ON l.key = r.key
+  `);
+  for (const data of select.iterate()) {
+    yield JSON.parse(data.d01);
+  }
+
+  db.close();
+  if (!memory) {
+    await fs.rm(path.dirname(tmpDbPath), { recursive: true });
+  }
+}

src/lib/ckan_data/machi_aza.ts

@@ -0,0 +1,117 @@
+export type MachiAzaData = {
+  /// 全国地方公共団体コード
+  lg_code: string;
+  /// 町字ID
+  machiaza_id: string;
+  /// 町字区分コード
+  machiaza_type: string;
+  /// 都道府県名
+  pref: string;
+  /// 都道府県名_カナ
+  pref_kana: string;
+  /// 都道府県名_英字
+  pref_roma: string;
+  /// 郡名
+  county: string;
+  /// 郡名_カナ
+  county_kana: string;
+  /// 郡名_英字
+  county_roma: string;
+  /// 市区町村名
+  city: string;
+  /// 市区町村名_カナ
+  city_kana: string;
+  /// 市区町村名_英字
+  city_roma: string;
+  /// 政令市区名
+  ward: string;
+  /// 政令市区名_カナ
+  ward_kana: string;
+  /// 政令市区名_英字
+  ward_roma: string;
+  /// 大字・町名
+  oaza_cho: string;
+  /// 大字・町名_カナ
+  oaza_cho_kana: string;
+  /// 大字・町名_英字
+  oaza_cho_roma: string;
+  /// 丁目名
+  chome: string;
+  /// 丁目名_カナ
+  chome_kana: string;
+  /// 丁目名_数字
+  chome_number: string;
+  /// 小字名
+  koaza: string;
+  /// 小字名_カナ
+  koaza_kana: string;
+  /// 小字名_英字
+  koaza_roma: string;
+  /// 同一町字識別情報
+  machiaza_dist: string;
+  /// 住居表示フラグ
+  rsdt_addr_flg: string;
+  /// 住居表示方式コード
+  rsdt_addr_mtd_code: string;
+  /// 大字・町名_通称フラグ
+  oaza_cho_aka_flg: string;
+  /// 小字名_通称コード
+  koaza_aka_code: string;
+  /// 大字・町名_電子国土基本図外字
+  oaza_cho_gsi_uncmn: string;
+  /// 小字名_電子国土基本図外字
+  koaza_gsi_uncmn: string;
+  /// 状態フラグ
+  status_flg: string;
+  /// 起番フラグ
+  wake_num_flg: string;
+  /// 効力発生日
+  efct_date: string;
+  /// 廃止日
+  ablt_date: string;
+  /// 原典資料コード
+  src_code: string;
+  /// 郵便番号
+  post_code: string;
+  /// 備考
+  remarks: string;
+};
+
+export type MachiAzaPosData = {
+  /// 全国地方公共団体コード
+  lg_code: string;
+  /// 町字ID
+  machiaza_id: string;
+  /// 住居表示フラグ
+  rsdt_addr_flg: string;
+  /// 代表点_経度
+  rep_lon: string;
+  /// 代表点_緯度
+  rep_lat: string;
+  /// 代表点_座標参照系
+  rep_srid: string;
+  /// 代表点_地図情報レベル
+  rep_scale: string;
+  /// 代表点_原典資料コード
+  rep_src_code: string;
+  /// ポリゴン_ファイル名
+  plygn_fname: string;
+  /// ポリゴン_キーコード
+  plygn_kcode: string;
+  /// ポリゴン_データフォーマット
+  plygn_fmt: string;
+  /// ポリゴン_座標参照系
+  plygn_srid: string;
+  /// ポリゴン_地図情報レベル
+  plygn_scale: string;
+  /// ポリゴン_原典資料コード
+  plygn_src_code: string;
+  /// 位置参照情報_大字町丁目コード
+  pos_oaza_cho_chome_code: string;
+  /// 位置参照情報_データ整備年度
+  pos_data_mnt_year: string;
+  /// 国勢調査_境界_小地域（町丁・字等別）_KEY_CODE
+  cns_bnd_s_area_kcode: string;
+  /// 国勢調査_境界_データ整備年度
+  cns_bnd_year: string;
+};

src/lib/ckan_data/prefecture.ts

@@ -0,0 +1,52 @@
+export type PrefData = {
+  /// 全国地方公共団体コード
+  lg_code: string;
+  /// 都道府県名
+  pref: string;
+  /// 都道府県名_カナ
+  pref_kana: string;
+  /// 都道府県名_英字
+  pref_roma: string;
+  /// 効力発生日
+  efct_date: string;
+  /// 廃止日
+  ablt_date: string;
+  /// 備考
+  remarks: string;
+};
+
+export type PrefPosData = {
+  /// 全国地方公共団体コード
+  lg_code: string;
+  /// 代表点_経度
+  rep_lon: string;
+  /// 代表点_緯度
+  rep_lat: string;
+  /// 代表点_座標参照系
+  rep_srid: string;
+  /// 代表点_地図情報レベル
+  rep_scale: string;
+  /// ポリゴン_ファイル名
+  plygn_fname: string;
+  /// ポリゴン_キーコード
+  plygn_kcode: string;
+  /// ポリゴン_データフォーマット
+  plygn_fmt: string;
+  /// ポリゴン_座標参照系
+  plygn_srid: string;
+  /// ポリゴン_地図情報レベル
+  plygn_scale: string;
+};
+
+export type PrefDataWithPos = PrefData & PrefPosData;
+
+export function mergePrefectureData(prefData: PrefData[], prefPosData: PrefPosData[]): PrefDataWithPos[] {
+  const out: PrefDataWithPos[] = [];
+  for (const pref of prefData) {
+    const pos = prefPosData.find((pos) => pos.lg_code === pref.lg_code);
+    if (pos) {
+      out.push({ ...pref, ...pos });
+    }
+  }
+  return out;
+}

src/lib/ckan_data/rsdtdsp_rsdt.ts

@@ -0,0 +1,88 @@
+import { mergeDataLeftJoin } from "./index.js";
+
+export type RsdtdspRsdtData = {
+  /// 全国地方公共団体コード
+  lg_code: string;
+  /// 町字ID
+  machiaza_id: string;
+  /// 街区ID
+  blk_id: string;
+  /// 住居ID
+  rsdt_id: string;
+  /// 住居2ID
+  rsdt2_id: string;
+  /// 市区町村名
+  city: string;
+  /// 政令市区名
+  ward: string;
+  /// 大字・町名
+  oaza_cho: string;
+  /// 丁目名
+  chome: string;
+  /// 小字名
+  koaza: string;
+  /// 街区符号
+  blk_num: string;
+  /// 住居番号
+  rsdt_num: string;
+  /// 住居番号2
+  rsdt_num2: string;
+  /// 基礎番号・住居番号区分
+  basic_rsdt_div: string;
+  /// 住居表示フラグ
+  rsdt_addr_flg: string;
+  /// 住居表示方式コード
+  rsdt_addr_mtd_code: string;
+  /// 状態フラグ
+  status_flg: string;
+  /// 効力発生日
+  efct_date: string;
+  /// 廃止日
+  ablt_date: string;
+  /// 原典資料コード
+  src_code: string;
+  /// 備考
+  remarks: string;
+};
+
+export type RsdtdspRsdtPosData = {
+  /// 全国地方公共団体コード
+  lg_code: string;
+  /// 町字ID
+  machiaza_id: string;
+  /// 街区ID
+  blk_id: string;
+  /// 住居ID
+  rsdt_id: string;
+  /// 住居2ID
+  rsdt2_id: string;
+  /// 住居表示フラグ
+  rsdt_addr_flg: string;
+  /// 住居表示方式コード
+  rsdt_addr_mtd_code: string;
+  /// 代表点_経度
+  rep_lon: string;
+  /// 代表点_緯度
+  rep_lat: string;
+  /// 代表点_座標参照系
+  rep_srid: string;
+  /// 代表点_地図情報レベル
+  rep_scale: string;
+  /// 代表点_原典資料コード
+  rep_src_code: string;
+  /// 電子国土基本図（地名情報）「住居表示住所」_住所コード（可読）
+  rsdt_addr_code_rdbl: string;
+  /// 電子国土基本図（地名情報）「住居表示住所」_データ整備日
+  rsdt_addr_data_mnt_date: string;
+  /// 基礎番号・住居番号区分
+  basic_rsdt_div: string;
+};
+
+export type RsdtdspRsdtDataWithPos = RsdtdspRsdtData | RsdtdspRsdtData & RsdtdspRsdtPosData;
+
+export function mergeRsdtdspRsdtData(
+  rsdtdspRsdtData: AsyncIterableIterator<RsdtdspRsdtData>,
+  rsdtdspRsdtPosData: AsyncIterableIterator<RsdtdspRsdtPosData>
+): AsyncIterableIterator<RsdtdspRsdtDataWithPos> {
+  return mergeDataLeftJoin(rsdtdspRsdtData, rsdtdspRsdtPosData, ["lg_code", "machiaza_id", "blk_id", "rsdt_id", "rsdt2_id"]);
+}

src/lib/fetch_tools.ts

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+import { fetch } from 'undici';
+
+const USER_AGENT = 'curl/8.7.1';
+const CACHE_DIR = path.join(import.meta.dirname, '..', '..', 'cache');
+
+export async function getDownloadStream(url: string): Promise<Buffer> {
+  const cacheKey = url.replace(/[^a-zA-Z0-9]/g, '_');
+  const cacheFile = path.join(CACHE_DIR, 'files', cacheKey);
+
+  let buffer: Buffer;
+  if (!fs.existsSync(cacheFile)) {
+    // console.log(`Downloading ${url}`);
+    const res = await fetch(url, {
+      headers: {
+        'User-Agent': USER_AGENT,
+      },
+    });
+
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    }
+
+    await fs.promises.mkdir(path.dirname(cacheFile), { recursive: true });
+    const body = await res.arrayBuffer();
+    buffer = Buffer.from(body);
+    await fs.promises.writeFile(cacheFile, buffer);
+  } else {
+    buffer = await fs.promises.readFile(cacheFile);
+  }
+
+  return buffer;
+}

src/lib/mlit_nlftp.test.ts

@@ -0,0 +1,20 @@
+import assert from 'node:assert';
+import test from 'node:test';
+
+import {
+  downloadAndExtractNlftpMlitFile,
+} from './mlit_nlftp.js';
+
+await test.describe('downloadAndExtractNlftpMlitFile', async () => {
+  await test('it works', async () => {
+    // 沖縄県
+    const data = await downloadAndExtractNlftpMlitFile('47');
+    assert.strictEqual(data.length, 1228);
+    assert.strictEqual(data[0].machiaza_id, 'MLIT:472010001001');
+    assert.strictEqual(data[0].pref_name, '沖縄県');
+    assert.strictEqual(data[0].city_name, '那覇市');
+    assert.strictEqual(data[0].oaza_cho, '古波蔵');
+    assert.strictEqual(data[0].chome, '一丁目');
+    assert.strictEqual(data[0].point.length, 2);
+  });
+});

src/lib/mlit_nlftp.ts

@@ -0,0 +1,92 @@
+import { parse as csvParse } from 'csv-parse';
+import iconv from 'iconv-lite';
+
+import { unzipAndExtractZipBuffer } from './zip_tools.js';
+import { getDownloadStream } from './fetch_tools.js';
+
+const SKIP_ROWS = new Set([
+  // 国土数値情報では「柿さき町」で登録されているが、ABRには「柿崎町」として登録されている。
+  // 柿崎町を優先するので、「柿さき町」はスキップする。
+  '愛知県/安城市/柿さき町',
+]);
+
+export type NlftpMlitDataRow = {
+  machiaza_id: string
+
+  pref_name: string
+  city_name: string
+
+  oaza_cho: string
+  chome?: string
+  point: [number, number]
+}
+
+// type NlftpMlitCsvRow = {
+//  0 "都道府県コード": string
+//  1 "都道府県名": string
+//  2 "市区町村コード": string
+//  3 "市区町村名": string
+//  4 "大字町丁目コード": string
+//  5 "大字町丁目名": string
+//  6 "緯度": string
+//  7 "経度": string
+//  8 "原典資料コード": string
+//  9 "大字・字・丁目区分コード": string
+// }
+
+function parseRows(rows: string[][]): NlftpMlitDataRow[] {
+  // remove header row
+  rows.shift();
+  // sort by code (should already be sorted, just in case)
+  rows.sort((a, b) => {
+    return a[4].localeCompare(b[4]);
+  });
+
+  const result: NlftpMlitDataRow[] = [];
+  for (const row of rows) {
+    if (SKIP_ROWS.has(`${row[1]}/${row[3]}/${row[5]}`)) continue;
+
+    let oaza_cho = row[5];
+    let chome: string | undefined = undefined;
+    const chomeMatch = oaza_cho.match(/^(.*?)([一二三四五六七八九十]+丁目)$/);
+    if (chomeMatch) {
+      oaza_cho = chomeMatch[1];
+      chome = chomeMatch[2];
+    }
+
+    result.push({
+      machiaza_id: `MLIT:${row[4]}`,
+      pref_name: row[1],
+      city_name: row[3],
+      oaza_cho,
+      chome,
+      point: [
+        parseFloat(row[7]), // longitude
+        parseFloat(row[6]), // latitude
+      ],
+    });
+  }
+
+  return result;
+}
+
+/**
+ * 国土数値情報からデータをダウンロードしパースします。
+ * 参照: https://nlftp.mlit.go.jp/isj/
+ */
+export async function downloadAndExtractNlftpMlitFile(prefCode: string): Promise<NlftpMlitDataRow[]> {
+  const version = '17.0b'; // 大字・町丁目レベル位置参照情報
+  // 22.0a は街区レベル位置参照情報なので、ここには必要ない
+  const url = `https://nlftp.mlit.go.jp/isj/dls/data/${version}/${prefCode}000-${version}.zip`;
+  const bodyStream = await getDownloadStream(url);
+  const entries = unzipAndExtractZipBuffer(bodyStream);
+  for await (const entry of entries) {
+    if (entry.path.slice(-4) !== '.csv') continue;
+    const decoded = iconv.decode(entry, 'Shift_JIS');
+    const rows = await Array.fromAsync<string[]>(
+      csvParse(decoded)
+    );
+    return parseRows(rows);
+  }
+  throw new Error('No CSV file detected in archive file');
+}

src/lib/proj.test.ts

@@ -0,0 +1,12 @@
+import assert from 'node:assert';
+import test from 'node:test';
+
+import proj from './proj.js';
+
+await test.describe('proj', async () => {
+  await test('should project coordinates from EPSG:6668 to EPSG:4326', () => {
+    const coords = [139.6917, 35.6895];
+    const projected = proj('EPSG:6668', 'EPSG:4326', coords);
+    assert.deepStrictEqual(projected, [139.6917, 35.6895]);
+  });
+});

src/lib/proj.ts

@@ -0,0 +1,22 @@
+import proj4 from "proj4";
+import { LngLat } from "../data.js";
+
+proj4.defs("EPSG:4612","+proj=longlat +ellps=GRS80 +no_defs +type=crs");
+proj4.defs("EPSG:6668","+proj=longlat +ellps=GRS80 +no_defs +type=crs");
+
+export default proj4;
+
+type DataRowWithGeometry = {
+  rep_lon: string
+  rep_lat: string
+  rep_srid: string
+};
+
+/**
+ * Reprojects Address Base Registry lon/lat data to EPSG:4326
+ * @returns
+ */
+export function projectABRData(dataRow: DataRowWithGeometry): LngLat {
+  const input: LngLat = [parseFloat(dataRow.rep_lon), parseFloat(dataRow.rep_lat)];
+  return proj4(dataRow.rep_srid, "EPSG:4326", input);
+}

src/lib/settings.test.ts

@@ -0,0 +1,59 @@
+import assert from 'node:assert';
+import test, { describe, before, after } from 'node:test';
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import * as settings from './settings.js';
+
+const fixtureDir = path.join(import.meta.dirname, '..', '..', 'test', 'fixtures', 'lib', 'settings');
+
+before(async () => {
+  await fs.copyFile(path.join(fixtureDir, 'settings.json'), path.join(process.cwd(), 'settings.json'));
+});
+
+after(async () => {
+  await fs.rm(path.join(process.cwd(), 'settings.json'));
+  delete process.env.SETTINGS_JSON;
+  delete process.env.SETTINGS_PATH;
+});
+
+await test('loadSettings', async () => {
+  const parsedSettings = await settings.loadSettings();
+  assert.equal(parsedSettings.lgCodes.length, 1);
+  assert.ok(parsedSettings.lgCodes[0].test('011002'));
+  assert.ok(!parsedSettings.lgCodes[0].test('131002'));
+});
+
+await describe('lgCodeMatch', async () => {
+  await test('basic settings', () => {
+    const settingsData = settings.parseSettings({
+      lgCodes: ['^01', '^13', '472018'],
+    });
+    assert.ok(settings.lgCodeMatch(settingsData, '011002'));
+    assert.ok(settings.lgCodeMatch(settingsData, '131002'));
+    assert.ok(!settings.lgCodeMatch(settingsData, '465054'));
+    assert.ok(settings.lgCodeMatch(settingsData, '472018'));
+  });
+
+  await test('市区町村まで指定されているときは、都道府県全体に対してマッチする', () => {
+    const settingsData = settings.parseSettings({
+      lgCodes: ['131002', '472018'],
+    });
+    assert.ok(settings.lgCodeMatch(settingsData, '131002'));
+    assert.ok(settings.lgCodeMatch(settingsData, '130001'));
+
+    assert.ok(settings.lgCodeMatch(settingsData, '472018'));
+    assert.ok(settings.lgCodeMatch(settingsData, '470007'));
+
+    assert.ok(!settings.lgCodeMatch(settingsData, '011002'));
+    assert.ok(!settings.lgCodeMatch(settingsData, '460001'));
+  });
+});
+
+await test('loadSettings with overwritten JSON', async () => {
+  process.env.SETTINGS_JSON = JSON.stringify({ lgCodes: ['^99'] });
+  const parsedSettings = await settings.loadSettings();
+  assert.equal(parsedSettings.lgCodes.length, 1);
+  assert.ok(parsedSettings.lgCodes[0].test('990000'));
+});

src/lib/settings.ts

@@ -0,0 +1,91 @@
+import { LRUCache } from 'lru-cache';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+const settingsPath = () => {
+  if (process.env.SETTINGS_JSON) return "json:" + process.env.SETTINGS_JSON;
+  if (process.env.SETTINGS_PATH) return process.env.SETTINGS_PATH;
+  return path.join(process.cwd(), "settings.json");
+}
+
+/** settings.json */
+type Settings = {
+  /**
+   * 出力する自治体のデータを制限するためのフィルター
+   * 全国地方公共団体コードをマッチする正規表現の文字列を配列で指定してください。
+   * OR条件で指定されたコードのいずれかに一致するデータのみ出力されます。
+   *
+   * 設定されていない場合は、全てのデータが出力されます。
+   *
+   * 例: ["011002", "012025"] は、北海道札幌市と北海道函館市のデータのみ出力されます。
+   * 例: ["^01"] は、北海道の全ての自治体のデータのみ出力されます。
+   */
+  lgCodes?: string[];
+}
+
+const DEFAULT_SETTINGS: Settings = {};
+
+// ---
+
+async function loadRawSettings(input: string): Promise<Settings> {
+  if (input.startsWith("json:")) {
+    return JSON.parse(input.slice(5)) as Settings;
+  }
+
+  try {
+    const settingsData = await fs.readFile(input, "utf-8");
+    return JSON.parse(settingsData) as Settings;
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "ENOENT") {
+      return DEFAULT_SETTINGS;
+    }
+    throw e;
+  }
+}
+
+export function parseSettings(settings: Settings): ParsedSettings {
+  return {
+    lgCodes: settings.lgCodes?.map((code) => new RegExp(code)) || [],
+  };
+}
+
+const settingsCache = new LRUCache<string, ParsedSettings>({
+  max: 10,
+  fetchMethod: async (key) => {
+    const rawSettings = await loadRawSettings(key);
+    return parseSettings(rawSettings);
+  },
+});
+
+export type ParsedSettings = {
+  lgCodes: RegExp[];
+}
+
+export async function loadSettings(): Promise<ParsedSettings> {
+  const settings = await settingsCache.fetch(settingsPath());
+  if (!settings) {
+    return { lgCodes: [] };
+  }
+  return settings;
+}
+
+export function lgCodeMatch(settings: ParsedSettings, lgCode: string): boolean {
+  if (settings.lgCodes.length === 0) {
+    return true;
+  }
+  for (const re of settings.lgCodes) {
+    if (re.test(lgCode)) {
+      return true;
+    }
+
+    // re が市区町村まで指定されている場合は、都道府県全体に対してマッチする
+    const cityCodeMatch = re.source.match(/^\^?(\d{2})\d{3}/);
+    if (cityCodeMatch) {
+      const prefCode = cityCodeMatch[1];
+      if (lgCode.startsWith(prefCode + '000')) {
+        return true;
+      }
+    }
+  }
+  return false;
+}

src/lib/zip_tools.test.ts

@@ -0,0 +1,57 @@
+import assert from 'node:assert';
+import test from 'node:test';
+
+import path from 'node:path';
+import fs from 'node:fs';
+
+import * as zip_tools from './zip_tools.js';
+
+const fixtureDir = path.join(import.meta.dirname, '..', '..', 'test', 'fixtures', 'lib', 'zip_tools');
+
+await test.describe('unzipAndExtractZipFile', async () => {
+  await test('it works for a single layer of zip', async () => {
+    const filePath = path.join(fixtureDir, 'single_level.csv.zip');
+    const stream = fs.createReadStream(filePath);
+    const files = await Array.fromAsync(zip_tools.unzipAndExtractZipFile(stream));
+    assert.strictEqual(files.length, 1);
+    const file0 = Buffer.concat(await Array.fromAsync(files[0])).toString('utf-8');
+    assert.strictEqual(file0, `It,works!\n\n`);
+  });
+
+  await test('it works for a double layer of zip', async () => {
+    const filePath = path.join(fixtureDir, 'double_level.csv.zip');
+    const stream = fs.createReadStream(filePath);
+    const files = await Array.fromAsync(zip_tools.unzipAndExtractZipFile(stream));
+    assert.strictEqual(files.length, 2);
+
+    const file0 = Buffer.concat(await Array.fromAsync(files[0])).toString('utf-8');
+    assert.strictEqual(file0, `It,works!\nDouble,1\n`);
+
+    const file1 = Buffer.concat(await Array.fromAsync(files[1])).toString('utf-8');
+    assert.strictEqual(file1, `It,works!\nDouble,2\n`);
+  });
+});
+
+await test.describe('unzipAndExtractZipBuffer', async () => {
+  await test('it works for a single layer of zip', async () => {
+    const filePath = path.join(fixtureDir, 'single_level.csv.zip');
+    const buffer = await fs.promises.readFile(filePath);
+    const files = await Array.fromAsync(zip_tools.unzipAndExtractZipBuffer(buffer));
+    assert.strictEqual(files.length, 1);
+    const file0 = files[0].toString('utf-8');
+    assert.strictEqual(file0, `It,works!\n\n`);
+  });
+
+  await test('it works for a double layer of zip', async () => {
+    const filePath = path.join(fixtureDir, 'double_level.csv.zip');
+    const buffer = await fs.promises.readFile(filePath);
+    const files = await Array.fromAsync(zip_tools.unzipAndExtractZipBuffer(buffer));
+    assert.strictEqual(files.length, 2);
+
+    const file0 = files[0].toString('utf-8');
+    assert.strictEqual(file0, `It,works!\nDouble,1\n`);
+
+    const file1 = files[1].toString('utf-8');
+    assert.strictEqual(file1, `It,works!\nDouble,2\n`);
+  });
+});

src/lib/zip_tools.ts

@@ -0,0 +1,33 @@
+import { Readable } from 'node:stream';
+import unzipper, { Entry } from 'unzipper';
+
+/**
+ * A function to unzip a file that may or may not contain another zip file.
+ * The zip file is extracted and each file is returned as a readable stream.
+ */
+export async function *unzipAndExtractZipFile(zipFile: Readable): AsyncGenerator<Entry> {
+  const files = zipFile.pipe(unzipper.Parse({forceStream: true}));
+  for await (const entry_ of files) {
+    const entry = entry_ as Entry;
+    if (entry.type === 'File' && entry.path.endsWith('.zip')) {
+      yield *unzipAndExtractZipFile(entry);
+    } else if (entry.type === 'File' && entry.path.endsWith('.csv')) {
+      yield entry;
+    } else {
+      entry.autodrain();
+    }
+  }
+}
+
+export async function *unzipAndExtractZipBuffer(zipFile: Buffer): AsyncGenerator<Buffer & {path: string}> {
+  const directory = await unzipper.Open.buffer(zipFile);
+  for (const file of directory.files) {
+    if (file.type === 'File' && file.path.endsWith('.zip')) {
+      const content = await file.buffer();
+      yield *unzipAndExtractZipBuffer(content);
+    } else if (file.type === 'File' && file.path.endsWith('.csv')) {
+      const content = await file.buffer();
+      yield Object.assign(content, {path: file.path});
+    }
+  }
+}

src/processes/01_make_prefecture_city.test.ts

@@ -0,0 +1,32 @@
+import assert from 'node:assert';
+import test from 'node:test';
+
+import fs from 'node:fs/promises';
+import main from './01_make_prefecture_city.js';
+import { PrefectureApi } from '../data.js';
+
+await test.describe('with Hokkaido filter', async () => {
+  test.before(() => {
+    process.env.SETTINGS_JSON = JSON.stringify({ lgCodes: ['^01'] });
+  });
+
+  test.after(() => {
+    delete process.env.SETTINGS_JSON;
+  });
+
+  await test('it generates the API', async () => {
+    await fs.rm('./out/api_hokkaido', { recursive: true, force: true });
+    await main(['', '', './out/api_hokkaido']);
+    assert.ok(true);
+
+    const ja = JSON.parse(await fs.readFile('./out/api_hokkaido/ja.json', 'utf-8')) as PrefectureApi;
+    const jaData = ja.data;
+    assert.equal(jaData.length, 1);
+    const hokkaido = jaData[0];
+    assert.equal(hokkaido.pref, '北海道');
+    const cities = hokkaido.cities;
+    assert.equal(cities.length, 194);
+    assert.equal(cities[0].city, '札幌市');
+  });
+});
+

src/processes/01_make_prefecture_city.ts

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { getAndParseCSVDataForId } from '../lib/ckan.js';
+import { CityApi, PrefectureApi, SingleCity, SinglePrefecture } from '../data.js';
+import { projectABRData } from '../lib/proj.js';
+import { CityData, CityPosData, mergeCityData } from '../lib/ckan_data/city.js';
+import { mergePrefectureData, PrefData, PrefPosData } from '../lib/ckan_data/prefecture.js';
+
+function outputCityData(outDir: string, prefName: string, apiData: CityApi, prefectureApi: PrefectureApi) {
+  // 政令都市の「区名」が無い場合は出力から除外する
+  const filteredApiData = apiData.data.filter((city) => {
+    return (
+      // 区名がある場合はそのまま出力
+      city.ward !== undefined ||
+      // 区名が無い場合は、同じ市区町村名で区名があるデータが無いか確認（ある＝政令都市のため、出力しない。ない＝政令都市ではない）
+      apiData.data.filter((c2) => c2.city === city.city).every((c2) => c2.ward === undefined)
+    );
+  });
+  apiData.data = filteredApiData;
+
+  prefectureApi.data.find((pref) => pref.pref === prefName)!.cities = filteredApiData;
+
+  const outFile = path.join(outDir, 'ja', `${prefName}.json`);
+  fs.mkdirSync(path.dirname(outFile), { recursive: true });
+  fs.writeFileSync(outFile, JSON.stringify(apiData));
+  console.log(`${prefName.padEnd(4, '　')}: ${filteredApiData.length.toString(10).padEnd(3, ' ')} 件の市区町村を出力した`);
+}
+
+async function main(argv: string[]) {
+  const updated = Math.floor(Date.now() / 1000);
+  const outDir = argv[2] || path.join(import.meta.dirname, '..', '..', 'out', 'api');
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const [
+    prefMain,
+    prefPos,
+
+    main,
+    pos,
+  ] = await Promise.all([
+    getAndParseCSVDataForId<PrefData>('ba-o1-000000_g2-000001'), // 都道府県
+    getAndParseCSVDataForId<PrefPosData>('ba-o1-000000_g2-000012'), // 位置参照拡張
+
+    getAndParseCSVDataForId<CityData>('ba-o1-000000_g2-000002'), // 市区町村
+    getAndParseCSVDataForId<CityPosData>('ba-o1-000000_g2-000013'), // 位置参照拡張
+  ]);
+  const rawData = mergeCityData(main, pos);
+
+  const prefApiData: SinglePrefecture[] = [];
+  const rawPrefData = mergePrefectureData(prefMain, prefPos);
+
+  for (const raw of rawPrefData) {
+    prefApiData.push({
+      code: parseInt(raw.lg_code),
+      pref: raw.pref,
+      pref_k: raw.pref_kana,
+      pref_r: raw.pref_roma,
+      point: projectABRData(raw),
+      cities: [],
+    });
+  }
+
+  const prefApi: PrefectureApi = {
+    meta: {
+      updated,
+    },
+    data: prefApiData,
+  };
+
+  let lastPref: string | undefined = undefined;
+  let allCount = 0;
+  const processedLgCodes: Set<string> = new Set();
+  let apiData: SingleCity[] = [];
+  for (const raw of rawData) {
+    allCount++;
+    if (lastPref !== raw.pref && lastPref !== undefined) {
+      const api: CityApi = {
+        meta: {
+          updated,
+        },
+        data: apiData,
+      };
+      outputCityData(outDir, lastPref, api, prefApi);
+      apiData = [];
+    }
+    if (lastPref !== raw.pref) {
+      lastPref = raw.pref;
+    }
+    apiData.push({
+      code: parseInt(raw.lg_code),
+      county: raw.county === '' ? undefined : raw.county,
+      county_k: raw.county_kana === '' ? undefined : raw.county_kana,
+      county_r: raw.county_roma === '' ? undefined : raw.county_roma,
+      city: raw.city,
+      city_k: raw.city_kana,
+      city_r: raw.city_roma,
+      ward: raw.ward === '' ? undefined : raw.ward,
+      ward_k: raw.ward_kana === '' ? undefined : raw.ward_kana,
+      ward_r: raw.ward_roma === '' ? undefined : raw.ward_roma,
+      point: projectABRData(raw),
+    });
+    processedLgCodes.add(raw.lg_code);
+  }
+  if (lastPref) {
+    const api: CityApi = {
+      meta: {
+        updated,
+      },
+      data: apiData,
+    };
+    outputCityData(outDir, lastPref, api, prefApi);
+  }
+
+  const outFile = path.join(outDir, 'ja.json');
+  fs.writeFileSync(outFile, JSON.stringify(prefApi));
+
+  console.log(`全国: ${allCount} ${processedLgCodes.size} 件の市区町村を出力した`);
+}
+
+export default main;

src/processes/02_machi_aza.ts

@@ -0,0 +1,23 @@
+import { SingleMachiAza } from "../data.js";
+import { MachiAzaData, MachiAzaPosData } from "../lib/ckan_data/machi_aza.js";
+import { projectABRData } from "../lib/proj.js";
+
+export function rawToMachiAza(raw: MachiAzaData | (MachiAzaData & MachiAzaPosData)): SingleMachiAza {
+  return {
+    machiaza_id: raw.machiaza_id,
+
+    oaza_cho: raw.oaza_cho === '' ? undefined : raw.oaza_cho,
+    oaza_cho_k: raw.oaza_cho_kana === '' ? undefined : raw.oaza_cho_kana,
+    oaza_cho_r: raw.oaza_cho_roma === '' ? undefined : raw.oaza_cho_roma,
+
+    chome: raw.chome === '' ? undefined : raw.chome,
+    chome_n: raw.chome_number === '' ? undefined : parseInt(raw.chome_number, 10),
+
+    koaza: raw.koaza === '' ? undefined : raw.koaza,
+    koaza_k: raw.koaza_kana === '' ? undefined : raw.koaza_kana,
+    koaza_r: raw.koaza_roma === '' ? undefined : raw.koaza_roma,
+
+    rsdt: raw.rsdt_addr_flg === '1' ? true : undefined,
+    point: 'rep_srid' in raw ? projectABRData(raw) : undefined,
+  };
+}

src/processes/02_make_machi_aza.test.ts

@@ -0,0 +1,28 @@
+import assert from 'node:assert';
+import test from 'node:test';
+
+import fs from 'node:fs/promises';
+import main from './02_make_machi_aza.js';
+import { MachiAzaApi } from '../data.js';
+
+await test.describe('with filter for 452092 (宮崎県えびの市)', async () => {
+  test.before(() => {
+    process.env.SETTINGS_JSON = JSON.stringify({ lgCodes: ['452092'] });
+  });
+
+  test.after(() => {
+    delete process.env.SETTINGS_JSON;
+  });
+
+  await test('it generates the API', async () => {
+    await fs.rm('./out/api_miyazaki_ebino', { recursive: true, force: true });
+    await main(['', '', './out/api_miyazaki_ebino']);
+    assert.ok(true);
+
+    const e = JSON.parse(await fs.readFile('./out/api_miyazaki_ebino/ja/宮崎県/えびの市.json', 'utf-8')) as MachiAzaApi;
+    const eData = e.data;
+    assert(eData.length > 100);
+    assert(eData.find((city) => city.machiaza_id === '0000110')?.koaza === '下村');
+  });
+});
+

src/processes/02_make_machi_aza.ts

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { getAndStreamCSVDataForId } from '../lib/ckan.js';
+import { MachiAzaApi, SingleMachiAza } from '../data.js';
+import { MachiAzaData, MachiAzaPosData } from '../lib/ckan_data/machi_aza.js';
+import { mergeDataLeftJoin } from '../lib/ckan_data/index.js';
+import { rawToMachiAza } from './02_machi_aza.js';
+import { downloadAndExtractNlftpMlitFile, NlftpMlitDataRow } from '../lib/mlit_nlftp.js';
+import { createMergedApiData, filterMlitDataByPrefCity } from '../lib/abr_mlit_merge_tools.js';
+
+async function outputMachiAzaData(
+  outDir: string,
+  prefName: string,
+  cityName: string,
+  api: MachiAzaApi,
+): Promise<number> {
+  const outFile = path.join(outDir, 'ja', prefName, `${cityName}.json`);
+  await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
+  await fs.promises.writeFile(outFile, JSON.stringify(api));
+  console.log(`${prefName.padEnd(4, '　')} ${cityName.padEnd(10, '　')}: ${api.data.length.toString(10).padEnd(4, ' ')} 件の町字を出力した`);
+  return api.data.length;
+}
+
+async function main(argv: string[]) {
+  const updated = Math.floor(Date.now() / 1000);
+  const outDir = argv[2] || path.join(import.meta.dirname, '..', '..', 'out', 'api');
+  fs.mkdirSync(outDir, { recursive: true });
+
+
+  const mainStream = getAndStreamCSVDataForId<MachiAzaData>('ba-o1-000000_g2-000003');
+  const posStream = getAndStreamCSVDataForId<MachiAzaPosData>('ba000004');
+  const rawData = mergeDataLeftJoin(mainStream, posStream, ['lg_code', 'machiaza_id']);
+  // const rawData = mergeMachiAzaData(mainStream, posStream);
+
+  let lastLGCode: string | undefined = undefined;
+  let lastPrefName: string | undefined = undefined;
+  let lastCityName: string | undefined = undefined;
+  let lastMlitData: NlftpMlitDataRow[] | undefined = undefined;
+  let allCount = 0;
+  let apiData: SingleMachiAza[] = [];
+  for await (const raw of rawData) {
+    if (lastLGCode !== raw.lg_code && lastLGCode !== undefined) {
+      const filteredMlit = filterMlitDataByPrefCity(lastMlitData!, lastPrefName!, lastCityName!);
+      apiData = createMergedApiData(apiData, filteredMlit);
+      const api: MachiAzaApi = { meta: { updated }, data: apiData };
+      allCount += await outputMachiAzaData(outDir, lastPrefName!, lastCityName!, api);
+      apiData = [];
+    }
+    if (lastPrefName !== raw.pref) {
+      // 都道府県が変わったので、都道府県レベルの新しいデータを取得する
+      lastMlitData = await downloadAndExtractNlftpMlitFile(raw.lg_code.slice(0, 2));
+    }
+    if (lastLGCode !== raw.lg_code) {
+      lastLGCode = raw.lg_code;
+      lastPrefName = raw.pref;
+      lastCityName = `${raw.county}${raw.city}${raw.ward}`;
+    }
+
+    apiData.push(rawToMachiAza(raw));
+  }
+  if (lastLGCode) {
+    const filteredMlit = filterMlitDataByPrefCity(lastMlitData!, lastPrefName!, lastCityName!);
+    apiData = createMergedApiData(apiData, filteredMlit);
+    const api: MachiAzaApi = { meta: { updated }, data: apiData };
+    allCount += await outputMachiAzaData(outDir, lastPrefName!, lastCityName!, api);
+  }
+
+  console.log(`全国: ${allCount} 件の町字を出力した`);
+}
+
+export default main;

src/processes/03_make_rsdt.test.ts

@@ -0,0 +1,26 @@
+import assert from 'node:assert';
+import test from 'node:test';
+
+import fs from 'node:fs/promises';
+import main from './03_make_rsdt.js';
+import { getRangesFromCSV } from './10_refresh_csv_ranges.js';
+
+await test.describe('with filter for 131059 (東京都文京区)', async () => {
+  test.before(() => {
+    process.env.SETTINGS_JSON = JSON.stringify({ lgCodes: ['131059'] });
+  });
+
+  test.after(() => {
+    delete process.env.SETTINGS_JSON;
+  });
+
+  await test('it generates the API', async () => {
+    await fs.rm('./out/api_tokyo_bunkyo', { recursive: true, force: true });
+    await main(['', '', './out/api_tokyo_bunkyo']);
+    assert.ok(true);
+
+    const headers = await getRangesFromCSV('./out/api_tokyo_bunkyo/ja/東京都/文京区-住居表示.txt');
+    assert(typeof headers !== 'undefined');
+    assert.equal(headers[0].name, '白山一丁目');
+  });
+});

src/processes/03_make_rsdt.ts

@@ -0,0 +1,251 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ckanPackageSearch, combineCSVParserIterators, CSVParserIterator, findResultByTypeAndArea, getAndParseCSVDataForId, getAndStreamCSVDataForId } from '../lib/ckan.js';
+import { mergeRsdtdspRsdtData, RsdtdspRsdtData, RsdtdspRsdtPosData } from '../lib/ckan_data/rsdtdsp_rsdt.js';
+import { machiAzaName, RsdtApi, SingleRsdt } from '../data.js';
+import { projectABRData } from '../lib/proj.js';
+import { MachiAzaData } from '../lib/ckan_data/machi_aza.js';
+import { rawToMachiAza } from './02_machi_aza.js';
+import { loadSettings } from '../lib/settings.js';
+
+const HEADER_CHUNK_SIZE = 50_000;
+// const HEADER_PBF_CHUNK_SIZE = 8_192;
+
+function getOutPath(ma: MachiAzaData) {
+  return path.join(
+    ma.pref,
+    `${ma.county}${ma.city}${ma.ward}`,
+  );
+}
+
+type HeaderRow = {
+  name: string;
+  offset: number;
+  length: number;
+}
+
+function serializeApiDataTxt(apiData: RsdtApi): { headerIterations: number, headerData: HeaderRow[], data: Buffer } {
+  const outSections: Buffer[] = [];
+  for ( const { machiAza, rsdts } of apiData ) {
+    let outSection = `住居表示,${machiAzaName(machiAza)}\n` +
+                     `blk_num,rsdt_num,rsdt_num2,lng,lat\n`;
+    for (const rsdt of rsdts) {
+      outSection += `${rsdt.blk_num || ''},${rsdt.rsdt_num},${rsdt.rsdt_num2 || ''},${rsdt.point?.[0] || ''},${rsdt.point?.[1] || ''}\n`;
+    }
+    outSections.push(Buffer.from(outSection, 'utf8'));
+  }
+
+  const createHeader = (iterations = 1) => {
+    let header = '';
+    const headerMaxSize = HEADER_CHUNK_SIZE * iterations;
+    let lastBytePos = headerMaxSize;
+    const headerData: HeaderRow[] = [];
+    for (const [index, section] of outSections.entries()) {
+      const ma = apiData[index].machiAza;
+
+      header += `${machiAzaName(ma)},${lastBytePos},${section.length}\n`;
+      headerData.push({
+        name: machiAzaName(ma),
+        offset: lastBytePos,
+        length: section.length,
+      });
+      lastBytePos += section.length;
+    }
+    const headerBuf = Buffer.from(header + '=END=\n', 'utf8');
+    if (headerBuf.length > headerMaxSize) {
+      return createHeader(iterations + 1);
+    } else {
+      const padding = Buffer.alloc(headerMaxSize - headerBuf.length);
+      padding.fill(0x20);
+      return {
+        iterations,
+        data: headerData,
+        buffer: Buffer.concat([headerBuf, padding])
+      };
+    }
+  };
+
+  const header = createHeader();
+  return {
+    headerIterations: header.iterations,
+    headerData: header.data,
+    data: Buffer.concat([header.buffer, ...outSections]),
+  };
+}
+
+// function _stringIfNotInteger(value: string | undefined) {
+//   if (!value) { return undefined; }
+//   return /^\d+$/.test(value) ? undefined : value;
+// }
+
+// function serializeApiDataPbf(apiData: RsdtApi): Buffer {
+//   let outSections: Buffer[] = [];
+//   for ( const { machiAza, rsdts } of apiData ) {
+//     const section: AddrData.Section = {
+//       kind: AddrData.Kind.RSDT,
+//       name: machiAzaName(machiAza),
+//       rsdtRows: [],
+//       chibanRows: [],
+//     }
+//     for (const rsdt of rsdts) {
+//       section.rsdtRows.push({
+//         blkNum: rsdt.blk_num ? parseInt(rsdt.blk_num, 10) : undefined,
+//         rsdtNum: parseInt(rsdt.rsdt_num, 10),
+//         rsdtNum2: rsdt.rsdt_num2 ? parseInt(rsdt.rsdt_num2, 10) : undefined,
+//         point: rsdt.point ? { lng: rsdt.point[0], lat: rsdt.point[1] } : undefined,
+//         blkNumStr: _stringIfNotInteger(rsdt.blk_num),
+//         rsdtNumStr: _stringIfNotInteger(rsdt.rsdt_num),
+//         rsdtNum2Str: _stringIfNotInteger(rsdt.rsdt_num2),
+//       });
+//     }
+//     const sectionBuf = Buffer.from(AddrData.Section.encode(section).finish());
+//     outSections.push(sectionBuf);
+//   }
+
+//   const createHeader = (iterations = 1) => {
+//     const header: AddrData.Header = {
+//       kind: AddrData.Kind.RSDT,
+//       rows: [],
+//     };
+//     const headerMaxSize = HEADER_PBF_CHUNK_SIZE * iterations;
+//     let lastBytePos = headerMaxSize;
+//     for (const [index, section] of outSections.entries()) {
+//       const ma = apiData[index].machiAza;
+
+//       header.rows.push({
+//         name: machiAzaName(ma),
+//         offset: lastBytePos,
+//         length: section.length,
+//       });
+//       lastBytePos += section.length;
+//     }
+//     const headerBuf = Buffer.from(AddrData.Header.encode(header).finish());
+//     if (headerBuf.length > headerMaxSize) {
+//       return createHeader(iterations + 1);
+//     } else {
+//       const padding = Buffer.alloc(headerMaxSize - headerBuf.length);
+//       padding.fill(0x00);
+//       return Buffer.concat([headerBuf, padding]);
+//     }
+//   };
+
+//   const header = createHeader();
+//   return Buffer.concat([header, ...outSections]);
+// }
+
+async function outputRsdtData(outDir: string, outFilename: string, apiData: RsdtApi) {
+  // const machiAzaJSON = path.join(outDir, 'ja', outFilename + '.json');
+  // fs.mkdirSync(path.dirname(machiAzaJSON), { recursive: true });
+  // fs.writeFileSync(outFileJSON, JSON.stringify(apiData));
+
+  const outFileTXT = path.join(outDir, 'ja', outFilename + '-住居表示.txt');
+  const txt = serializeApiDataTxt(apiData);
+  await fs.promises.mkdir(path.dirname(outFileTXT), { recursive: true });
+  await fs.promises.writeFile(outFileTXT, txt.data);
+
+  // const outFilePbf = path.join(outDir, 'ja', outFilename + '.pbf');
+  // fs.writeFileSync(outFilePbf, serializeApiDataPbf(apiData));
+
+  console.log(`${outFilename}-住居表示: ${apiData.length.toString(10).padEnd(4, ' ')} 件の町字を出力した`);
+}
+
+async function main(argv: string[]) {
+  const outDir = argv[2] || path.join(import.meta.dirname, '..', '..', 'out', 'api');
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const machiAzaData = await getAndParseCSVDataForId<MachiAzaData>('ba-o1-000000_g2-000003'); // 市区町村 & 町字
+  const machiAzaDataByCode = new Map(machiAzaData.map((city) => [
+    `${city.lg_code}|${city.machiaza_id}`,
+    city
+  ]));
+
+  // 鹿児島県
+  // const mainStream = getAndStreamCSVDataForId<RsdtdspRsdtData>('ba-o1-460001_g2-000005');
+  // const posStream = getAndStreamCSVDataForId<RsdtdspRsdtPosData>('ba-o1-460001_g2-000008');
+
+  const hasFilter = (await loadSettings()).lgCodes.length > 0;
+
+  let mainStream: CSVParserIterator<RsdtdspRsdtData>;
+  let posStream: CSVParserIterator<RsdtdspRsdtPosData>;
+  if (!hasFilter) {
+    mainStream = getAndStreamCSVDataForId<RsdtdspRsdtData>('ba000003');
+    posStream = getAndStreamCSVDataForId<RsdtdspRsdtPosData>('ba000006');
+  } else {
+    // machiAzaData が既にフィルターされているので、そこからユニークな都道府県のみ抽出し、そのストリームのみ読み込むようにする
+    const prefs = new Set(machiAzaData.map((ma) => ma.pref));
+
+    const mainStreams: CSVParserIterator<RsdtdspRsdtData>[] = [];
+    const posStreams: CSVParserIterator<RsdtdspRsdtPosData>[] = [];
+    for (const pref of prefs) {
+      const mainSearchQuery = `${pref} 住居表示-住居マスター データセット`;
+      const mainResults = await ckanPackageSearch(mainSearchQuery);
+      const main = findResultByTypeAndArea(mainResults, '住居表示-住居マスター（都道府県）', pref);
+      if (!main) {
+        throw new Error(`「${pref}」の住居表示-住居マスター データセットが見つかりませんでした`);
+      }
+      mainStreams.push(getAndStreamCSVDataForId<RsdtdspRsdtData>(main.id));
+
+      const posSearchQuery = `${pref} 住居表示-住居マスター位置参照拡張 データセット`;
+      const posResults = await ckanPackageSearch(posSearchQuery);
+      const pos = findResultByTypeAndArea(posResults, '住居表示-住居マスター位置参照拡張（都道府県）', pref);
+      if (!pos) {
+        throw new Error(`「${pref}」の住居表示-住居マスター位置参照拡張 データセットが見つかりませんでした`);
+      }
+      posStreams.push(getAndStreamCSVDataForId<RsdtdspRsdtPosData>(pos.id));
+    }
+    mainStream = combineCSVParserIterators(...mainStreams);
+    posStream = combineCSVParserIterators(...posStreams);
+  }
+  const rawData = mergeRsdtdspRsdtData(mainStream, posStream);
+
+  let lastOutPath: string | undefined = undefined;
+
+  let apiData: RsdtApi = [];
+  let currentRsdtList: SingleRsdt[] = [];
+  let currentMachiAza: MachiAzaData | undefined = undefined;
+  for await (const raw of rawData) {
+    const ma = machiAzaDataByCode.get(`${raw.lg_code}|${raw.machiaza_id}`);
+    if (!ma) {
+      continue;
+    }
+    const thisOutPath = getOutPath(ma);
+    if (currentMachiAza && (currentMachiAza.machiaza_id !== ma.machiaza_id || currentMachiAza.lg_code !== ma.lg_code)) {
+      if (currentRsdtList.length > 0) {
+        apiData.push({
+          machiAza: rawToMachiAza(currentMachiAza),
+          rsdts: currentRsdtList,
+        });
+      }
+      currentMachiAza = ma;
+      currentRsdtList = [];
+    }
+    if (lastOutPath !== thisOutPath && lastOutPath !== undefined) {
+      await outputRsdtData(outDir, lastOutPath, apiData);
+      apiData = [];
+    }
+    if (lastOutPath !== thisOutPath) {
+      lastOutPath = thisOutPath;
+    }
+    if (!currentMachiAza) {
+      currentMachiAza = ma;
+    }
+
+    currentRsdtList.push({
+      blk_num: raw.blk_num === '' ? undefined : raw.blk_num,
+      rsdt_num: raw.rsdt_num,
+      rsdt_num2: raw.rsdt_num2 === '' ? undefined : raw.rsdt_num2,
+      point: 'rep_srid' in raw ? projectABRData(raw) : undefined,
+    });
+  }
+  if (currentMachiAza && currentRsdtList.length > 0) {
+    apiData.push({
+      machiAza: rawToMachiAza(currentMachiAza),
+      rsdts: currentRsdtList,
+    });
+  }
+  if (lastOutPath) {
+    await outputRsdtData(outDir, lastOutPath, apiData);
+  }
+}
+
+export default main;