### CLI Usage of jsmigemo

Source: https://github.com/oguna/jsmigemo/blob/master/README.md

Demonstrates how to use jsmigemo from the command line after installation. It shows an example query and the generated pattern.

```bash
$ npm install jsmigemo
$ jsmigemo
QUERY: kensaku
PATTERN: (kensaku|けんさく|ケンサク|建策|憲[作冊]|検索|献策|研削|羂索|ｋｅｎｓａｋｕ|ｹﾝｻｸ)
```

--------------------------------

### Migemo Class Initialization and Dictionary Setup

Source: https://context7.com/oguna/jsmigemo/llms.txt

Demonstrates how to initialize the Migemo class, load a compact dictionary, and set it for use. This is a prerequisite for performing any queries.

```APIDOC
## Migemo Class Initialization

### Description
Initializes the `Migemo` class and loads a compact dictionary. The dictionary is essential for the `query` method to function correctly.

### Method
```typescript
import { CompactDictionary, Migemo } from "jsmigemo";
import { readFile } from "node:fs/promises";

async function setupMigemo() {
  // Load the dictionary from a file
  const data = await readFile("migemo-compact-dict");
  const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
  const dict = new CompactDictionary(buffer);

  // Initialize Migemo and set the dictionary
  const migemo = new Migemo();
  migemo.setDict(dict);

  return migemo;
}

// Example usage:
setupMigemo().then(migemo => {
  console.log(migemo.query("kensaku"));
});
```

### Parameters
- `dict`: A `CompactDictionary` instance loaded with the dictionary data.
```

--------------------------------

### Install jsmigemo via npm

Source: https://github.com/oguna/jsmigemo/blob/master/README.md

Install the jsmigemo library using npm for use in your Node.js projects.

```bash
npm install jsmigemo
```

--------------------------------

### Node.js Usage of jsmigemo

Source: https://github.com/oguna/jsmigemo/blob/master/README.md

Example of using jsmigemo in a Node.js environment. It involves reading a dictionary file, initializing the dictionary and Migemo, and performing a query.

```javascript
import { readFile } from "node:fs/promises";
import { CompactDictionary, Migemo } from "jsmigemo";

const data = await readFile("migemo-compact-dict");
const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);

const dict = new CompactDictionary(buffer);
const migemo = new Migemo();
migemo.setDict(dict);

console.log(migemo.query("kensaku"));
//=> (kensaku|けんさく|ケンサク|建策|憲[作冊]|検索|献策|研削|羂索|ｋｅｎｓａｋｕ|ｹﾝｻｸ)
```

--------------------------------

### Browser Usage of jsmigemo

Source: https://github.com/oguna/jsmigemo/blob/master/README.md

Example of integrating jsmigemo into a web page. It includes setting up an input field, displaying the regex output, and loading the dictionary from a CDN.

```html
<input id="queryInput" type="text" placeholder="kensaku">
<pre id="regexOutput"></pre>

<script src="https://cdn.jsdelivr.net/npm/jsmigemo/dist/jsmigemo.min.iife.js"></script>
<script>
  const DICT_URL = "https://cdn.jsdelivr.net/npm/jsmigemo/migemo-compact-dict";

  const queryInput = document.getElementById("queryInput");
  const regexOutput = document.getElementById("regexOutput");

  let migemo = null;

  async function setup() {
    const response = await fetch(DICT_URL);
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }

    const buffer = await response.arrayBuffer();
    const dict = new window.jsmigemo.CompactDictionary(buffer);
    migemo = new window.jsmigemo.Migemo();
    migemo.setDict(dict);
  }

  queryInput.addEventListener("input", () => {
    if (!migemo) {
      return;
    }
    regexOutput.textContent = migemo.query(queryInput.value.trim());
  });

  setup().catch((error) => {
    regexOutput.textContent = `辞書の読み込みに失敗: ${error.message}`;
  });
</script>
```

--------------------------------

### Deno Usage of jsmigemo

Source: https://github.com/oguna/jsmigemo/blob/master/README.md

Example of using jsmigemo in a Deno environment. It imports the library from a CDN, reads a dictionary file, and performs a query.

```javascript
import { CompactDictionary, Migemo } from "https://cdn.jsdelivr.net/npm/jsmigemo/dist/jsmigemo.min.mjs";

const data = await Deno.readFile("./migemo-compact-dict");
const dict = new CompactDictionary(data.buffer);
const migemo = new Migemo();
migemo.setDict(dict);

console.log(migemo.query("kensaku"));
//=> (kensaku|けんさく|ケンサク|建策|憲[作冊]|検索|献策|研削|羂索|ｋｅｎｓａｋｕ|ｹﾝｻｸ)
```

--------------------------------

### Migemo.query() Examples

Source: https://context7.com/oguna/jsmigemo/llms.txt

Illustrates the usage of the Migemo.query() method for single-word searches and generating regular expressions for text matching. Handles empty queries correctly.

```typescript
const migemo = new Migemo();
migemo.setDict(dict);

// 単語検索
console.log(migemo.query("kikai"));
// => (kikai|きかい|キカイ|喜界|器[怪械]|奇[怪恠]|棋界|機[会械]|毀壊|気[塊海]|貴[会海]|鬼[怪怪海界]|ｋｉｋａｉ|ｷｶｲ)

// 空文字は空文字を返す
console.log(migemo.query("")); // => ""

// 生成した正規表現でテキスト検索
const pattern = migemo.query("kensaku");
const regex = new RegExp(pattern);
const text = "全文検索エンジンの実装について";
console.log(regex.test(text)); // => true（「検索」にマッチ）
```

--------------------------------

### Customize Migemo Regex Operators (Rxop)

Source: https://context7.com/oguna/jsmigemo/llms.txt

Demonstrates how to customize the regular expression operators used by Migemo. Includes examples for default, Emacs, and Vim formats.

```typescript
import { Migemo, type Rxop } from "jsmigemo";

const migemo = new Migemo();
migemo.setDict(dict);

// 標準正規表現（デフォルト）
migemo.setRxop(null);
console.log(migemo.query("ko"));
// => (ko|こ|コ|ｋｏ|ｺ)

// Emacs形式（改行マッチあり）
const ESCAPE = "\.[]{}()*+-?^$|";
const emacsRxop: Rxop = ["\|", "\(", ")", "[", "]", "\s-*",
```

```typescript
ESCAPE];
migemo.setRxop(emacsRxop);
console.log(migemo.query("kensaku"));
// => \(kensaku|けんさく|ケンサク|検索|...)

// Vim形式（改行マッチなし）
const VIM_ESCAPE = "\.[]}*+-?^$|";
const vimRxop: Rxop = ["\|", "\%(", ")", "[", "]", "", VIM_ESCAPE];
migemo.setRxop(vimRxop);
console.log(migemo.query("kensaku"));
// => \;%(kensaku|けんさく|ケンサク|検索|...)
```

--------------------------------

### Browser Usage with IIFE and CDN

Source: https://context7.com/oguna/jsmigemo/llms.txt

Integrate jsmigemo into frontend applications for incremental search by loading the IIFE bundle from a CDN. This example demonstrates setting up the dictionary and handling user input for real-time search.

```html
<!DOCTYPE html>
<html lang="ja">
<head><meta charset="UTF-8"><title>Migemo検索デモ</title></head>
<body>
  <input id="queryInput" type="text" placeholder="ローマ字で入力（例: kensaku）">
  <pre id="regexOutput"></pre>
  <div id="results"></div>

  <script src="https://cdn.jsdelivr.net/npm/jsmigemo/dist/jsmigemo.min.iife.js"></script>
  <script>
    const DICT_URL = "https://cdn.jsdelivr.net/npm/jsmigemo/migemo-compact-dict";
    const queryInput = document.getElementById("queryInput");
    const regexOutput = document.getElementById("regexOutput");
    const results = document.getElementById("results");

    let migemo = null;
    const corpus = ["全文検索エンジン", "東京都千代田区", "機械学習アルゴリズム", "自然言語処理"];

    async function setup() {
      const response = await fetch(DICT_URL);
      if (!response.ok) throw new Error(`HTTP ${response.status}`);
      const buffer = await response.arrayBuffer();
      const dict = new window.jsmigemo.CompactDictionary(buffer);
      migemo = new window.jsmigemo.Migemo();
      migemo.setDict(dict);
    }

    queryInput.addEventListener("input", () => {
      if (!migemo || !queryInput.value.trim()) return;
      try {
        const pattern = migemo.query(queryInput.value.trim());
        regexOutput.textContent = pattern;
        const regex = new RegExp(pattern, "i");
        results.innerHTML = corpus
          .filter(item => regex.test(item))
          .map(item => `<div>${item}</div>`)
          .join("");
      } catch (e) {
        regexOutput.textContent = "エラー: " + e.message;
      }
    });

    setup().catch(e => { regexOutput.textContent = "辞書読み込み失敗: " + e.message; });
  </script>
</body>
</html>
```

--------------------------------

### Generate Binary Dictionary from Text Dictionary

Source: https://context7.com/oguna/jsmigemo/llms.txt

Use this command-line tool to convert a text-based dictionary (like SKK-JISYO) into a compact binary format for jsmigemo. Ensure you have Node.js installed.

```bash
$ node bin/jsmigemo-dict.mjs skk-jisyo.txt migemo-compact-dict
```

--------------------------------

### Load jsmigemo Dictionary and Initialize

Source: https://github.com/oguna/jsmigemo/blob/master/index.html

Fetches the compact dictionary from a URL, creates a CompactDictionary instance, and sets it for the Migemo object. Updates the status badge accordingly.

```javascript
async function loadDictionary() {
  setStatus("辞書を読み込み中...", "loading");
  try {
    if (!window.jsmigemo) {
      throw new Error("jsmigemo script was not loaded");
    }
    const response = await fetch(DICT_URL);
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }
    const buffer = await response.arrayBuffer();
    const dict = new window.jsmigemo.CompactDictionary(buffer);
    migemo = new window.jsmigemo.Migemo();
    migemo.setDict(dict);
    setStatus("辞書読み込み完了", "ready");
    updateView();
  } catch (error) {
    setStatus("辞書読み込み失敗", "error");
    regexOutput.textContent = `辞書の読み込みに失敗: ${error.message}`;
  }
}
```

--------------------------------

### Initialize and Use Migemo Class

Source: https://context7.com/oguna/jsmigemo/llms.txt

Demonstrates loading a dictionary and using the Migemo class to generate search patterns for single words and multi-word phrases. Supports default and Vim-style regex operators.

```typescript
import { readFile } from "node:fs/promises";
import { CompactDictionary, Migemo } from "jsmigemo";

// 辞書の読み込み
const data = await readFile("migemo-compact-dict");
const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
const dict = new CompactDictionary(buffer);

// デフォルト（標準正規表現）
const migemo = new Migemo();
migemo.setDict(dict);

console.log(migemo.query("kensaku"));
// => (kensaku|けんさく|ケンサク|健[作策]|兼作|建策|憲作|検索|献策|県作|研削|羂索|腱索|謙作|賢作|ｋｅｎｓａｋｕ|ｹﾝｻｸ)

// Vim形式の正規表現
const VIM_ESCAPE = "\.[]}*+-?^$|";
migemo.setRxop(["\|", "\%(", ")", "[", "]", "\_s*", VIM_ESCAPE]);
console.log(migemo.query("kensaku"));
// => %(kensaku|けんさく|ケンサク|検索|...)

// 連文節クエリ（大文字区切り）
const result = migemo.query("renBunsetuNoKensaku");
const regex = new RegExp(result);
console.log(regex.test("連文節の検索")); // => true

// 空白区切りの連文節クエリ
const result2 = migemo.query("ren bunsetu no kensaku");
console.log(new RegExp(result2).test("連文節の検索")); // => true
```

--------------------------------

### Load and Initialize jsmigemo Dictionary

Source: https://github.com/oguna/jsmigemo/blob/master/index.html

Fetches the compact dictionary and initializes the jsmigemo instance. Handles status updates for loading and errors.

```javascript
const DICT_URL = "https://cdn.jsdelivr.net/npm/jsmigemo/migemo-compact-dict";
const VALID_HASHES = new Set(["#demo-regex", "#demo-text", "#demo-list"]);
const WAGAHAI_TEXT = "吾輩は猫である。名前はまだ無い。\n" +
"どこで生れたかとんと見当がつかぬ。何でも薄暗いじめじめした所でニャーニャー泣いていた事だけは記憶している。吾輩はここで始めて人間というものを見た。しかもあとで聞くとそれは書生という人間中で一番獰悪な種族であったそうだ。この書生というのは時々我々を捕まえて煮て食うという話である。しかしその当時は何という考もなかったから別段恐しいとも思わなかった。ただ彼の掌に載せられてスーと持ち上げられた時何だかフワフワした感じがあったばかりである。掌の上で少し落ちついて書生の顔を見たのがいわゆる人間というものの見始めであろう。この時妙なものだと思った感じが今でも残っている。第一毛をもって装飾されべきはずの顔がつるつるしてまるで薬缶だ。その後猫にもだいぶ逢ったがこんな片輪には一度も出会わした事がない。のみならず顔の真中があまりに突起している。そうしてその穴の中から時々ぷうぷうと煙を吹く。どうも咽せぽくて実に弱った。これが人間の飲む煙草というものである事はようやくこの頃知った。";
const PREFECTURES = [
  "北海道", "青森県", "岩手県", "宮城県", "秋田県", "山形県", "福島県", "茨城県", "栃木県", "群馬県", "埼玉県", "千葉県", "東京都", "神奈川県", "新潟県", "富山県", "石川県", "福井県", "山梨県", "長野県", "岐阜県", "静岡県", "愛知県", "三重県", "滋賀県", "京都府", "大阪府", "兵庫県", "奈良県", "和歌山県", "鳥取県", "島根県", "岡山県", "広島県", "山口県", "徳島県", "香川県", "愛媛県", "高知県", "福岡県", "佐賀県", "長崎県", "熊本県", "大分県", "宮崎県", "鹿児島県", "沖縄県"
];

const queryInput = document.getElementById("queryInput");
const regexOutput = document.getElementById("regexOutput");
const wagahai = document.getElementById("wagahai");
const listCount = document.getElementById("listCount");
const prefectureList = document.getElementById("prefectureList");
const statusBadge = document.getElementById("statusBadge");

let migemo = null;

const escapeMap = { "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" };
const escapeHtml = (text) => text.replace(/[&<>
```

--------------------------------

### CompactDictionaryBuilder.build

Source: https://context7.com/oguna/jsmigemo/llms.txt

Builds a compact binary dictionary from a text-based dictionary data (hiragana key to an array of kanji readings).

```APIDOC
## CompactDictionaryBuilder.build(dict: Map<string, string[]>): ArrayBuffer

テキスト形式の辞書データ（ひらがなキー → 漢字表記の配列）から、コンパクトなバイナリ辞書を生成します。LOUDSTrieでキートライと値トライを構築し、マッピング情報を含むバイナリ`ArrayBuffer`を返します。

### Usage
```typescript
import { CompactDictionaryBuilder } from "jsmigemo";
import { writeFileSync } from "fs";

// 辞書データを手動で構築
const dict = new Map<string, string[]>([
  ["けんさく", ["検索", "研削", "献策"]],
  ["にほん",   ["日本", "二本"]],
  ["とうきょう", ["東京"]],
]);

// バイナリ辞書をビルド
const arrayBuffer = CompactDictionaryBuilder.build(dict);

// ファイルに保存
writeFileSync("my-compact-dict", Buffer.from(arrayBuffer));
console.log(`辞書ファイル生成完了: ${arrayBuffer.byteLength} bytes`);

// 生成した辞書を即座に使用
const { CompactDictionary, Migemo } = await import("jsmigemo");
const builtDict = new CompactDictionary(arrayBuffer);
const migemo = new Migemo();
migemo.setDict(builtDict);
console.log(migemo.query("kensaku")); // => (kensaku|けんさく|ケンサク|検索|研削|献策|ｋｅｎｓａｋｕ|ｹﾝｻｸ)
```
```

--------------------------------

### Generate Compact Dictionary File

Source: https://github.com/oguna/jsmigemo/blob/master/README.md

Command to generate a compact dictionary file from a text dictionary file using the provided script. This is necessary for using jsmigemo with custom dictionaries.

```shell
> node  bin/jsmigemo-dict.mjs <text-dict-file> <compact-dict-file>
```

--------------------------------

### jsmigemo CLI Commands

Source: https://context7.com/oguna/jsmigemo/llms.txt

Command-line interface for jsmigemo, supporting interactive and direct word conversions, with options for output format.

```APIDOC
## CLIコマンド

`jsmigemo`コマンドはNode.js環境でインタラクティブな変換や単語指定での変換をサポートします。`-v`でVim形式、`-e`でEmacs形式の正規表現を出力できます。

### Usage
```bash
# インストール
npm install -g jsmigemo

# インタラクティブモード
$ jsmigemo
QUERY: kensaku
PATTERN: (kensaku|けんさく|ケンサク|健[作策]|兼作|建策|憲作|検索|献策|県作|研削|羂索|腱索|謙作|賢作|ｋｅｎｓａｋｕ|ｹﾝｻｸ)

# 単語を直接指定して終了
$ jsmigemo --word tokyo
(tokyo|とうきょう|トウキョウ|東京|ｔｏｋｙｏ|ﾄｳｷｮｳ)

# Vim形式で出力
$ jsmigemo --vim --word kensaku
\%(kensaku\|けんさく\|ケンサク\|検索\|...\)

# Emacs形式で出力
$ jsmigemo --emacs --word kensaku
\(kensaku\|けんさく\|ケンサク\|検索\|...\)

# カスタム辞書ファイルを指定
$ jsmigemo --dict /path/to/my-migemo-dict --word hana
```
```

--------------------------------

### Build Compact Dictionary from Map

Source: https://context7.com/oguna/jsmigemo/llms.txt

Builds a compact binary dictionary from a Map of hiragana keys to string arrays. The generated ArrayBuffer can be saved to a file and used immediately.

```typescript
import { CompactDictionaryBuilder } from "jsmigemo";
import { writeFileSync } from "fs";

// 辞書データを手動で構築
const dict = new Map<string, string[]>([
  ["けんさく", ["検索", "研削", "献策"]],
  ["にほん",   ["日本", "二本"]],
  ["とうきょう", ["東京"]],
]);

// バイナリ辞書をビルド
const arrayBuffer = CompactDictionaryBuilder.build(dict);

// ファイルに保存
writeFileSync("my-compact-dict", Buffer.from(arrayBuffer));
console.log(`辞書ファイル生成完了: ${arrayBuffer.byteLength} bytes`);

// 生成した辞書を即座に使用
const { CompactDictionary, Migemo } = await import("jsmigemo");
const builtDict = new CompactDictionary(arrayBuffer);
const migemo = new Migemo();
migemo.setDict(builtDict);
console.log(migemo.query("kensaku")); // => (kensaku|けんさく|ケンサク|検索|研削|献策|ｋｅｎｓａｋｕ|ｹﾝｻｸ)
```

--------------------------------

### jsmigemo CLI Commands

Source: https://context7.com/oguna/jsmigemo/llms.txt

The jsmigemo CLI tool supports interactive conversion and conversion with specified words in Node.js environments. It can output Vim or Emacs format regular expressions.

```bash
# インストール
npm install -g jsmigemo

# インタラクティブモード
$ jsmigemo
QUERY: kensaku
PATTERN: (kensaku|けんさく|ケンサク|健[作策]|兼作|建策|憲作|検索|献策|県作|研削|羂索|腱索|謙作|賢作|ｋｅｎｓａｋｕ|ｹﾝｻｸ)

# 単語を直接指定して終了
$ jsmigemo --word tokyo
(tokyo|とうきょう|トウキョウ|東京|ｔｏｋｙｏ|ﾄｳｷｮｳ)

# Vim形式で出力
$ jsmigemo --vim --word kensaku
\%(kensaku\|けんさく\|ケンサク\|検索\|...\)

# Emacs形式で出力
$ jsmigemo --emacs --word kensaku
\(kensaku\|けんさく\|ケンサク\|検索\|...\)

# カスタム辞書ファイルを指定
$ jsmigemo --dict /path/to/my-migemo-dict --word hana

```

--------------------------------

### Migemo.setRxop(rxop: Rxop | null)

Source: https://context7.com/oguna/jsmigemo/llms.txt

Allows customization of the regular expression operators used in the generated regex. This is useful for adapting the output to different regex engines like Vim or Emacs.

```APIDOC
## Migemo.setRxop(rxop: Rxop | null)

### Description
Customizes the regular expression operators (OR, grouping, character classes, etc.). This enables compatibility with different regex syntaxes, such as those used in Vim or Emacs.

### Method
```typescript
import { Migemo, type Rxop } from "jsmigemo";

const migemo = new Migemo();
migemo.setDict(dict);

// Reset to default operators
migemo.setRxop(null);

// Emacs style operators
const ESCAPE = "\\.[]{}()*+-?^$|";
const emacsRxop: Rxop = ["\\|", "\\(", ")", "[", "]", "\\s-*", ESCAPE];
migemo.setRxop(emacsRxop);

// Vim style operators
const VIM_ESCAPE = "\\.[]}*+-?^$|";
const vimRxop: Rxop = ["\\|", "\\%(", ")", "[", "]", "", VIM_ESCAPE];
migemo.setRxop(vimRxop);
```

### Parameters
- `rxop` (Rxop | null): An array defining the regex operators in the order: [OR, Group Start, Group End, Class Start, Class End, Newline Match, Escape String]. Pass `null` to reset to default settings.
```

--------------------------------

### Replace Romaji Processor with Custom Logic

Source: https://context7.com/oguna/jsmigemo/llms.txt

Shows how to replace the default Romaji conversion logic with a custom implementation, such as using AZIK array input. Requires defining custom RomanEntry objects.

```typescript
import { Migemo, RomajiProcessor1, RomanEntry } from "jsmigemo";
import { readFileSync } from "fs";

// AZIK配列のカスタムローマ字テーブルを読み込む
const data = readFileSync("test/romantable_azik.txt", "utf-8");
const romanEntries: RomanEntry[] = [];
for (const line of data.split("\n")) {
  const [roman, hiragana] = line.trim().split("\t");
  if (roman && hiragana) {
    romanEntries.push(new RomanEntry(roman, hiragana, 0));
  }
}

const rp = new RomajiProcessor1(romanEntries);
const migemo = new Migemo();
migemo.setDict(dict);
migemo.setRomajiProcessor(rp);

// AZIKでは "keq" が "けん" に変換される
console.log(migemo.query("keqsaku"));
// => (keqsaku|けんさく|ケンサク|健[作策]|兼作|建策|憲作|検索|献策|県作|研削|羂索|腱索|謙作|賢作|ｋｅｑｓａｋｕ|ｹﾝｻｸ)
```

--------------------------------

### Update View based on User Input and Migemo Results

Source: https://github.com/oguna/jsmigemo/blob/master/index.html

Updates the regex output, highlights text, and filters a list based on the current query and Migemo's generated regex. Resets the view if the query is empty or Migemo is not initialized.

```javascript
function updateView() {
  const query = queryInput.value.trim();
  if (!query || !migemo) {
    resetView();
    return;
  }
  const source = migemo.query(query);
  regexOutput.textContent = source;
  let highlightRegex;
  let filterRegex;
  try {
    highlightRegex = new RegExp(source, "giu");
    filterRegex = new RegExp(source, "iu");
  } catch (error) {
    regexOutput.textContent = `正規表現の生成に失敗: ${error.message}`;
    resetView();
    return;
  }
  wagahai.innerHTML = highlight(WAGAHAI_TEXT, highlightRegex);
  const filtered = PREFECTURES.filter((name) => filterRegex.test(name));
  renderList(filtered, highlightRegex);
  listCount.textContent = `${filtered.length}件 / 全${PREFECTURES.length}件`;
}
```

--------------------------------

### Load and Search Compact Dictionary

Source: https://context7.com/oguna/jsmigemo/llms.txt

Loads a compact dictionary from an ArrayBuffer for exact and predictive searches. Suitable for both Node.js and browser environments.

```typescript
import { readFile } from "node:fs/promises";
import { CompactDictionary } from "jsmigemo";

const data = await readFile("migemo-compact-dict");
const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
const dict = new CompactDictionary(buffer);

// 完全一致検索: "けんさく" に対応する漢字表記を取得
for (const value of dict.search("けんさく")) {
  console.log(value); // => "検索", "献策", "研削" など
}

// 前方一致検索: "けん" で始まるすべての候補を取得
for (const value of dict.predictiveSearch("けん")) {
  console.log(value); // => "けんさく"から始まる語の変換候補をすべて列挙
}

// ブラウザでの使用例
const response = await fetch("https://cdn.jsdelivr.net/npm/jsmigemo/migemo-compact-dict");
const arrayBuffer = await response.arrayBuffer();
const browserDict = new CompactDictionary(arrayBuffer);
```

--------------------------------

### Character Type Conversion Utilities

Source: https://context7.com/oguna/jsmigemo/llms.txt

Provides utility functions for converting between half-width and full-width characters, and from hiragana to katakana. These are also used internally by Migemo query processing.

```typescript
import { han2zen_conv, zen2han_conv, hira2kata_conv } from "jsmigemo";

// 半角→全角変換
console.log(han2zen_conv("kensaku")); // => "ｋｅｎｓａｋｕ"
console.log(han2zen_conv("ABC123"));  // => "ＡＢＣ１２３"
console.log(han2zen_conv("ｹﾝｻｸ"));  // => "ケンサク"

// 全角→半角変換
console.log(zen2han_conv("ｋｅｎｓａｋｕ")); // => "kensaku"
console.log(zen2han_conv("ケンサク"));       // => "ｹﾝｻｸ"
console.log(zen2han_conv("ＡＢＣ"));         // => "ABC"

// ひらがな→カタカナ変換
console.log(hira2kata_conv("けんさく")); // => "ケンサク"
console.log(hira2kata_conv("とうきょう")); // => "トウキョウ"
console.log(hira2kata_conv("まじかる☆")); // => "マジカル☆"（非ひらがなはそのまま）
```

--------------------------------

### han2zen_conv / zen2han_conv / hira2kata_conv

Source: https://context7.com/oguna/jsmigemo/llms.txt

Utility functions for character type conversion: half-width to full-width, full-width to half-width, and hiragana to katakana.

```APIDOC
## han2zen_conv / zen2han_conv / hira2kata_conv

文字種変換のユーティリティ関数です。半角→全角、全角→半角、ひらがな→カタカナの変換を行います。Migemoクエリ処理の内部でも使用されており、単独で呼び出すことも可能です。

### Usage
```typescript
import { han2zen_conv, zen2han_conv, hira2kata_conv } from "jsmigemo";

// 半角→全角変換
console.log(han2zen_conv("kensaku")); // => "ｋｅｎｓａｋｕ"
console.log(han2zen_conv("ABC123"));  // => "ＡＢＣ１２３"
console.log(han2zen_conv("ｹﾝｻｸ"));  // => "ケンサク"

// 全角→半角変換
console.log(zen2han_conv("ｋｅｎｓａｋｕ")); // => "kensaku"
console.log(zen2han_conv("ケンサク"));       // => "ｹﾝｻｸ"
console.log(zen2han_conv("ＡＢＣ"));         // => "ABC"

// ひらがな→カタカナ変換
console.log(hira2kata_conv("けんさく")); // => "ケンサク"
console.log(hira2kata_conv("とうきょう")); // => "トウキョウ"
console.log(hira2kata_conv("まじかる☆")); // => "マジカル☆"（非ひらがなはそのまま）
```
```

--------------------------------

### Migemo.setRomajiProcessor(processor: RomajiProcessor)

Source: https://context7.com/oguna/jsmigemo/llms.txt

Enables replacement of the default Romaji to Hiragana conversion logic. This allows support for custom Romaji input schemes like AZIK.

```APIDOC
## Migemo.setRomajiProcessor(processor: RomajiProcessor)

### Description
Replaces the default Romaji processing logic with a custom implementation. This is useful for supporting alternative Romaji input systems or custom conversion rules.

### Method
```typescript
import { Migemo, RomajiProcessor1, RomanEntry } from "jsmigemo";
import { readFileSync } from "fs";

// Example: Using AZIK Romaji table
const data = readFileSync("test/romantable_azik.txt", "utf-8");
const romanEntries: RomanEntry[] = [];
for (const line of data.split("\n")) {
  const [roman, hiragana] = line.trim().split("\t");
  if (roman && hiragana) {
    romanEntries.push(new RomanEntry(roman, hiragana, 0));
  }
}

const rp = new RomajiProcessor1(romanEntries);
const migemo = new Migemo();
migemo.setDict(dict);
migemo.setRomajiProcessor(rp);

console.log(migemo.query("keqsaku")); // Using AZIK input
```

### Parameters
- `processor` (RomajiProcessor): An instance of a `RomajiProcessor` class or a compatible custom implementation.
```

--------------------------------

### CompactDictionary Class

Source: https://context7.com/oguna/jsmigemo/llms.txt

Provides methods for searching within a compact dictionary loaded from an ArrayBuffer. Supports exact and predictive searches.

```APIDOC
## CompactDictionary Class

LOUDSトライ構造を使ったコンパクトな辞書クラス。バイナリ形式の`ArrayBuffer`から辞書を読み込み、完全一致検索(`search`)と前方一致検索(`predictiveSearch`)を提供します。

### Usage
```typescript
import { readFile } from "node:fs/promises";
import { CompactDictionary } from "jsmigemo";

const data = await readFile("migemo-compact-dict");
const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
const dict = new CompactDictionary(buffer);

// 完全一致検索: "けんさく" に対応する漢字表記を取得
for (const value of dict.search("けんさく")) {
  console.log(value); // => "検索", "献策", "研削" など
}

// 前方一致検索: "けん" で始まるすべての候補を取得
for (const value of dict.predictiveSearch("けん")) {
  console.log(value); // => "けんさく"から始まる語の変換候補をすべて列挙
}

// ブラウザでの使用例
const response = await fetch("https://cdn.jsdelivr.net/npm/jsmigemo/migemo-compact-dict");
const arrayBuffer = await response.arrayBuffer();
const browserDict = new CompactDictionary(arrayBuffer);
```
```

--------------------------------

### Migemo.queryAWord(word: string): string

Source: https://context7.com/oguna/jsmigemo/llms.txt

An internal method primarily used for generating regex for a single word. It handles the conversion from Romaji to Hiragana, Katakana, and various character forms.

```APIDOC
## Migemo.queryAWord(word: string): string

### Description
This method is intended for internal use to generate a regular expression for a single Romaji word. It performs the necessary conversions and dictionary lookups to cover all possible Japanese representations of the word.

### Method
```typescript
console.log(migemo.queryAWord("ka"));
// Example Output: (ka|か|カ|ｋａ|ｶ)

console.log(migemo.queryAWord("tokyo"));
// Example Output: A regex matching "tokyo", "とうきょう", "トウキョウ", "東京", etc.
```

### Parameters
- `word` (string): The single Romaji word to process.

### Response
- Returns a string representing a regular expression for the single word.
```

--------------------------------

### Migemo.query(word: string): string

Source: https://context7.com/oguna/jsmigemo/llms.txt

Generates a regular expression string from a Romaji query. It supports single-word queries and multi-word queries separated by uppercase letters or spaces.

```APIDOC
## Migemo.query(word: string): string

### Description
Converts a Romaji input string into a comprehensive regular expression that matches various Japanese character forms (Hiragana, Katakana, Kanji, full-width, half-width).

### Method
```typescript
console.log(migemo.query("kensaku"));
// Example Output: (kensaku|けんさく|ケンサク|健[作策]|兼作|建策|憲作|検索|献策|県作|研削|羂索|腱索|謙作|賢作|ｋｅｎｓａｋｕ|ｹﾝｻｸ)

console.log(migemo.query("renBunsetuNoKensaku")); // Multi-word query with uppercase separators
console.log(migemo.query("ren bunsetu no kensaku")); // Multi-word query with space separators

console.log(migemo.query("")); // Returns an empty string for empty input
```

### Parameters
- `word` (string): The Romaji input query. Can be a single word or multiple words separated by uppercase letters or spaces.

### Response
- Returns a string representing a regular expression.
```

--------------------------------

### Migemo.queryAWord() Usage

Source: https://context7.com/oguna/jsmigemo/llms.txt

Shows the internal method Migemo.queryAWord() which generates a regex for a single word, converting Romaji to Hiragana, Katakana, and full/half-width characters.

```typescript
const migemo = new Migemo();
migemo.setDict(dict);

// 1単語の処理
console.log(migemo.queryAWord("ka"));
// => (ka|か|カ|ｋａ|ｶ)

console.log(migemo.queryAWord("tokyo"));
// => ローマ字・ひらがな・カタカナ・漢字（東京など）を含む正規表現
```

--------------------------------

### RomajiProcessor1 / RomajiProcessor2

Source: https://context7.com/oguna/jsmigemo/llms.txt

Classes responsible for converting romaji to hiragana. Supports exact and predictive conversions.

```APIDOC
## RomajiProcessor1 / RomajiProcessor2 クラス

ローマ字からひらがなへの変換を担うクラスです。`RomajiProcessor1`は二分探索ベース、`RomajiProcessor2`はDoubleArrayトライベースの実装です。`romajiToHiragana()`で確定変換、`romajiToHiraganaPredictively()`で入力途中の予測変換候補を返します。

### Usage
```typescript
import { RomajiProcessor1, RomajiProcessor2 } from "jsmigemo";

// RomajiProcessor2（デフォルト、高速）
const rp2 = RomajiProcessor2.build();
console.log(rp2.romajiToHiragana("kensaku")); // => "けんさく"
console.log(rp2.romajiToHiragana("tokyo"));   // => "とうきょう"
console.log(rp2.romajiToHiragana("sha"));     // => "しゃ"

// 予測変換（入力途中）
const result = rp2.romajiToHiraganaPredictively("ken");
console.log(result.prefix);   // => "け"（確定済み部分）
console.log(result.suffixes); // => ["ん"]（候補サフィックス）

// RomajiProcessor1（カスタム辞書対応）
const rp1 = RomajiProcessor1.build();
console.log(rp1.romajiToHiragana("chi")); // => "ち"
console.log(rp1.romajiToHiragana("tsu")); // => "つ"

// 入力途中の予測
const pred = rp1.romajiToHiraganaPredictively("ky");
console.log(pred.prefix);   // => ""
console.log(pred.suffixes); // => ["きゃ", "きぃ", "きゅ", "きぇ", "きょ"]（複数候補）
```
```