### Install Development Tools

Source: https://github.com/dahlia/gukhanmun/blob/main/CONTRIBUTING.md

Install all the development tools and dependencies configured for the project using mise.

```sh
mise install
```

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

### Install @gukhanmun/opendict-cdb

Source: https://github.com/dahlia/gukhanmun/blob/main/packages/opendict-cdb/README.md

Install the package using your preferred package manager.

```bash
npm  add     @gukhanmun/opendict-cdb
pnpm add     @gukhanmun/opendict-cdb
yarn add     @gukhanmun/opendict-cdb
bun  add     @gukhanmun/opendict-cdb
den o add jsr:@gukhanmun/opendict-cdb
```

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

### Install @gukhanmun/stdict-cdb

Source: https://github.com/dahlia/gukhanmun/blob/main/packages/stdict-cdb/README.md

Install the package using your preferred package manager.

```bash
npm  add     @gukhanmun/stdict-cdb
pnpm add     @gukhanmun/stdict-cdb
yarn add     @gukhanmun/stdict-cdb
bun  add     @gukhanmun/stdict-cdb
den o add jsr:@gukhanmun/stdict-cdb
```

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

### Install @gukhanmun/napi

Source: https://github.com/dahlia/gukhanmun/blob/main/packages/napi/README.md

Install the package using npm, pnpm, yarn, or bun. For Deno, use the npm specifier.

```bash
npm  add     @gukhanmun/napi
pnpm add     @gukhanmun/napi
yarn add     @gukhanmun/napi
bun  add     @gukhanmun/napi
den o add npm:@gukhanmun/napi
```

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

### Install @gukhanmun/stdict-fst

Source: https://github.com/dahlia/gukhanmun/blob/main/packages/stdict-fst/README.md

Install the package using your preferred package manager (npm, pnpm, yarn, bun, or deno).

```bash
npm  add     @gukhanmun/stdict-fst
pnpm add     @gukhanmun/stdict-fst
yarn add     @gukhanmun/stdict-fst
bun  add     @gukhanmun/stdict-fst
den o add jsr:@gukhanmun/stdict-fst
```

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

### Install @gukhanmun/opendict-fst

Source: https://github.com/dahlia/gukhanmun/blob/main/packages/opendict-fst/README.md

Install the package using your preferred package manager (npm, pnpm, yarn, bun, or deno).

```bash
npm  add     @gukhanmun/opendict-fst
pnpm add     @gukhanmun/opendict-fst
yarn add     @gukhanmun/opendict-fst
bun  add     @gukhanmun/opendict-fst
deno add jsr:@gukhanmun/opendict-fst
```

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

### Install Gukhanmun CLI via mise

Source: https://github.com/dahlia/gukhanmun/blob/main/README.md

Installs the Gukhanmun command-line tool globally using mise. Omit the -g flag to install only for the current project.

```sh
mise use -g aqua:dahlia/gukhanmun
```

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

### Install @gukhanmun/wasm

Source: https://github.com/dahlia/gukhanmun/blob/main/packages/wasm/README.md

Install the package using npm, pnpm, yarn, bun, or deno.

```bash
npm  add     @gukhanmun/wasm
pnpm add     @gukhanmun/wasm
yarn add     @gukhanmun/wasm
bun  add     @gukhanmun/wasm
den o add jsr:@gukhanmun/wasm
```

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

### Start Local Development Server

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/README.md

Start the local dev server from the workspace root. Builds all required packages first.

```sh
mise run docs-dev

```

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

### Minimal Gukhanmun Rust Example

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/rust/start.md

Demonstrates the basic setup of a Gukhanmun converter using a preset and converting plain text. Ensure the 'gukhanmun' crate is added to your Cargo.toml.

```rust
use gukhanmun::{Builder, Preset};

fn main() -> gukhanmun::Result<()> {
    let converter = Builder::with_preset(Preset::KoKr).build()?;
    let output = converter.convert_text_to_string("漢字를 한글로")?;
    println!("{output}");  // 한자를 한글로
    Ok(())
}
```

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

### Install @gukhanmun/types

Source: https://github.com/dahlia/gukhanmun/blob/main/packages/types/README.md

Install the @gukhanmun/types package using your preferred package manager.

```bash
npm  add     @gukhanmun/types
pnpm add     @gukhanmun/types
yarn add     @gukhanmun/types
bun  add     @gukhanmun/types
den o add jsr:@gukhanmun/types
```

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

### Install @gukhanmun/napi

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/install.mdx

Install the Node-API implementation of Gukhanmun for faster server-side performance in Node.js, Deno, and Bun.

```bash
add @gukhanmun/napi
```

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

### Install gukhanmun-mkdict with Cargo

Source: https://github.com/dahlia/gukhanmun/blob/main/crates/gukhanmun-mkdict/README.md

Install the gukhanmun-mkdict CLI tool using Cargo if you have a Rust toolchain available.

```sh
cargo install gukhanmun-mkdict
```

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

### Install gukhanmun-cli

Source: https://github.com/dahlia/gukhanmun/blob/main/crates/gukhanmun-cli/README.md

Install the gukhanmun-cli tool using Cargo, the Rust package manager.

```sh
cargo install gukhanmun-cli
```

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

### Install Gukhanmun CLI from crates.io

Source: https://github.com/dahlia/gukhanmun/blob/main/README.md

Installs the gukhanmun-cli and gukhanmun-mkdict binaries from crates.io using Cargo. Ensure ~/.cargo/bin is on your PATH.

```sh
cargo install gukhanmun-cli gukhanmun-mkdict
```

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

### Install WebAssembly Package

Source: https://github.com/dahlia/gukhanmun/blob/main/README.md

Install the WebAssembly package for most JavaScript environments using npm, pnpm, yarn, bun, or deno.

```sh
npm  add       @gukhanmun/wasm @gukhanmun/stdict-fst
pnpm add       @gukhanmun/wasm @gukhanmun/stdict-fst
yarn add       @gukhanmun/wasm @gukhanmun/stdict-fst
bun  add       @gukhanmun/wasm @gukhanmun/stdict-fst
den o add --jsr @gukhanmun/wasm @gukhanmun/stdict-fst
```

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

### Examples of 'Assisted-by' Trailer

Source: https://github.com/dahlia/gukhanmun/blob/main/AI_POLICY.md

Provide specific examples of how to format the 'Assisted-by' trailer for different AI tools and models. Include a separate line for each tool used.

```git
Assisted-by: Claude Code:claude-sonnet-4-6
```

```git
Assisted-by: Cursor:claude-opus-4-7
```

```git
Assisted-by: GitHub Copilot:gpt-4o
```

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

### Install Gukhanmun CLI via winget

Source: https://github.com/dahlia/gukhanmun/blob/main/README.md

Installs the Gukhanmun command-line tool on Windows using the Windows Package Manager.

```pwsh
winget install HongMinhee.Gukhanmun
```

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

### Install @gukhanmun/wasm

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/install.mdx

Install the WebAssembly implementation of Gukhanmun, recommended for broad compatibility across browsers, Node.js, Deno, and Bun.

```bash
npm add @gukhanmun/wasm
```

```bash
yarn add @gukhanmun/wasm
```

```bash
pnpm add @gukhanmun/wasm
```

```bash
bun add @gukhanmun/wasm
```

```bash
deno add jsr:@gukhanmun/wasm
```

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

### CSV Input Example

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/internals/dictionary-format.md

Example of the CSV input format, which uses the same header names as TSV.

```csv
hanja,hangul,require_hanja,require_hangul
天地,천지,true,false
```

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

### Install Standard Korean Dictionary (FST)

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/install.mdx

Install the FST format of the Standard Korean Dictionary separately. This is the preferred format for most use cases.

```bash
npm add @gukhanmun/stdict-fst
```

```bash
yarn add @gukhanmun/stdict-fst
```

```bash
pnpm add @gukhanmun/stdict-fst
```

```bash
bun add @gukhanmun/stdict-fst
```

```bash
deno add jsr:@gukhanmun/stdict-fst
```

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

### Verify Gukhanmun installation

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/cli/install.md

Checks if the Gukhanmun CLI and gukhanmun-mkdict tools are installed and accessible by running their help commands.

```sh
gukhanmun --help
gukhanmun-mkdict --help
```

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

### Install Standard Korean Dictionary (CDB)

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/install.mdx

Install the CDB format of the Standard Korean Dictionary separately. This format differs in lookup characteristics from the FST package.

```bash
npm add @gukhanmun/stdict-cdb
```

```bash
yarn add @gukhanmun/stdict-cdb
```

```bash
pnpm add @gukhanmun/stdict-cdb
```

```bash
bun add @gukhanmun/stdict-cdb
```

```bash
deno add jsr:@gukhanmun/stdict-cdb
```

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

### Canonical TSV Input Example

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/internals/dictionary-format.md

Example of the UTF-8 TSV input format with required and optional columns.

```tsv
hanja	hangul	require_hanja	require_hangul	category
天地	천지	false	false	basic
漢字	한자	true	false	basic
色깔論	색깔론	false	true	mixed
```

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

### Load Gukhanmun with WASM backend

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/start.md

Initialize the Gukhanmun library using the WASM backend and a dictionary. This is the minimal setup required for basic conversions.

```typescript
import { load } from "@gukhanmun/wasm";
import { stdictFst } from "@gukhanmun/stdict-fst";

const g = await load({
  dictionaries: [await stdictFst()],
});

console.log(g.convert("漢字를 한글로"));
// → 한자를 한글로
```

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

### Low-Level HTML Fragment Reader and Writer Setup

Source: https://github.com/dahlia/gukhanmun/blob/main/crates/gukhanmun-html/README.md

Demonstrates the direct construction of HtmlFragmentReader and HtmlFragmentWriter for use within the Gukhanmun pipeline. For most use cases, the umbrella crate is more convenient.

```rust
use gukhanmun_core::{MapDictionary, RenderMode};
use gukhanmun_html::{HtmlFragmentReader, HtmlFragmentWriter};

let mut dict = MapDictionary::new();
dict.insert("漢字", "한자");

// Low-level: construct a reader and writer explicitly via the pipeline.
// For most uses the umbrella crate is more convenient.

```

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

### Install Node-API Package

Source: https://github.com/dahlia/gukhanmun/blob/main/README.md

Install the Node-API package for better server-side performance when a native dependency is acceptable. Supports npm, pnpm, yarn, bun, and deno.

```sh
npm  add     @gukhanmun/napi     @gukhanmun/stdict-fst
pnpm add     @gukhanmun/napi     @gukhanmun/stdict-fst
yarn add     @gukhanmun/napi     @gukhanmun/stdict-fst
bun  add     @gukhanmun/napi     @gukhanmun/stdict-fst
den o add npm:@gukhanmun/napi jsr:@gukhanmun/stdict-fst
```

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

### Bumping to Next Development Version

Source: https://github.com/dahlia/gukhanmun/blob/main/CONTRIBUTING.md

After a successful release, immediately start the next development cycle by bumping the version. This command uses 'mise' to execute the version bump.

```sh
mise run bump-execute -- 1.2.5
git push
```

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

### JSONL Input Example

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/internals/dictionary-format.md

Example of a JSON Lines input format, where each line is a JSON object. Boolean fields accept snake_case or camelCase.

```json
{"hanja":"漢字","hangul":"한자","requireHanja":false,"requireHangul":true}
```

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

### Example Directives TSV File

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/cli/directives.md

This TSV file demonstrates how to configure directives. It includes examples for forcing hangul readings for specific proper nouns ('東京', '北京') and suppressing annotations for all names containing a middle dot using a glob pattern.

```tsv
# Force reading for proper nouns
require-hanja	東京	literal
require-hanja	北京	literal
# Suppress annotation for all middle-dot separated names
skip-annotation	*·*	glob
```

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

### Install Open Korean Dictionary (FST)

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/install.mdx

Install the FST format of the Open Korean Dictionary. This package provides category loaders for general, North Korean, dialect, and archaic Korean.

```bash
npm add @gukhanmun/opendict-fst
```

```bash
yarn add @gukhanmun/opendict-fst
```

```bash
pnpm add @gukhanmun/opendict-fst
```

```bash
bun add @gukhanmun/opendict-fst
```

```bash
deno add jsr:@gukhanmun/opendict-fst
```

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

### Install Open Korean Dictionary (CDB)

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/install.mdx

Install the CDB format of the Open Korean Dictionary. This package also provides category loaders for various Korean language categories.

```bash
npm add @gukhanmun/opendict-cdb
```

```bash
yarn add @gukhanmun/opendict-cdb
```

```bash
pnpm add @gukhanmun/opendict-cdb
```

```bash
bun add @gukhanmun/opendict-cdb
```

```bash
deno add jsr:@gukhanmun/opendict-cdb
```

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

### Input Format Example (TSV)

Source: https://github.com/dahlia/gukhanmun/blob/main/crates/gukhanmun-mkdict/README.md

Demonstrates the expected tab-separated value (TSV) input format for hanja dictionary entries, including an optional third column for marks.

```text
漢字	한자
北京	베이징
學校	학교	require_hanja
```

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

### Use Glob Patterns for Hanja Directives

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/cli/directives.md

Utilize glob pattern variants of directives to apply overrides to multiple hanja characters matching a shell-style pattern. Examples include matching hanja starting with '東', those in the set '京' or '津', and those starting with '中'.

```sh
gukhanmun --require-hanja-glob "東*" input.txt
```

```sh
gukhanmun --require-hangul-glob "北[京津]" input.txt
```

```sh
gukhanmun --skip-annotation-glob "中*" input.txt
```

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

### Build Production Static Site

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/README.md

Build the static site for deployment. The output lands in *doc_build/*.

```sh
mise run docs-build

```

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

### Preview Production Build Locally

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/README.md

To preview the production build locally, run from this directory.

```sh
pnpm run preview

```

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

### List Available Project Commands

Source: https://github.com/dahlia/gukhanmun/blob/main/CONTRIBUTING.md

View all the available development tasks and commands that can be run within the project using mise.

```sh
mise tasks
```

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

### Basic Text Conversion with Custom Dictionary

Source: https://github.com/dahlia/gukhanmun/blob/main/crates/gukhanmun-core/README.md

Demonstrates how to use `MapDictionary` for custom mappings and `convert_plain_text` for basic hanja-to-hangul conversion.

```rust
use gukhanmun_core::{MapDictionary, RenderMode, convert_plain_text};

let mut dict = MapDictionary::new();
dict.insert("漢字", "한자");
dict.insert("北京", "베이징");

let output = convert_plain_text("漢字 北京", &dict, RenderMode::HangulOnly);
assert_eq!(output, "한자 베이징");

```

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

### Add New Documentation Page Frontmatter

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/README.md

When adding a new page, create a *.md* or *.mdx* file and include a `description` frontmatter field for SEO.

```md
---
title: Page title
description: One-sentence summary of this page.
---

```

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

### Blessing New Fixtures

Source: https://github.com/dahlia/gukhanmun/blob/main/CONTRIBUTING.md

Run this command to capture the current converter output as a new fixture baseline. Ensure your working tree is clean before running.

```sh
GUKHANMUN_BLESS_FIXTURES=1 cargo test -p gukhanmun --test fixtures <filter>
```

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

### Display full help information

Source: https://github.com/dahlia/gukhanmun/blob/main/crates/gukhanmun-cli/README.md

Display the complete help message for the gukhanmun command, showing all available options and their descriptions.

```sh
# Print full help:
 gukhanmun --help
```

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

### Use Ko-Kp Preset with Bundled Open Korean Dictionary

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/rust/dictionary.md

Initialize a converter using the 'ko-kp' preset, which enables North Korean orthography and includes the bundled Open Korean Dictionary.

```rust
let converter = Builder::with_preset(Preset::KoKp).build()?;
assert_eq!(converter.convert_text_to_string("歷史와 來日")?, "력사와 래일");
```

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

### Run Individual Development Commands

Source: https://github.com/dahlia/gukhanmun/blob/main/CONTRIBUTING.md

Execute specific development commands such as formatting, linting, and testing.

```sh
mise run fmt
mise run fmt-check
mise run clippy
mise run ci
mise run doc
mise run test
mise run typecheck
```

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

### Disclosing AI Assistance in Commit Messages

Source: https://github.com/dahlia/gukhanmun/blob/main/CONTRIBUTING.md

Example of how to disclose AI assistance in commit messages using the 'Assisted-by' trailer. Each AI tool used should have its own line.

```sh
Assisted-by: Claude Code:claude-opus-4-8
Assisted-by: Codex:gpt-5.5
```

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

### Load Gukhanmun with NAPI backend

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/start.md

Initialize the Gukhanmun library using the NAPI backend. The API remains the same as the WASM backend, only the import path differs.

```typescript
import { load } from "@gukhanmun/napi";
import { stdictFst } from "@gukhanmun/stdict-fst";

const g = await load({
  dictionaries: [await stdictFst()],
});
```

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

### Load and Use Standard Korean Dictionary FST

Source: https://github.com/dahlia/gukhanmun/blob/main/packages/stdict-fst/README.md

Load the FST dictionary and use it to convert Hanja to Hangul. This example demonstrates integrating the dictionary with the @gukhanmun/wasm package.

```typescript
import { load } from "@gukhanmun/wasm";
import { stdictFst } from "@gukhanmun/stdict-fst";

const g = await load({ dictionaries: [await stdictFst()] });
console.log(g.convert("漢字를 한글로")); // "한자를 한글로"
```

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

### Basic Command-Line Conversion

Source: https://github.com/dahlia/gukhanmun/blob/main/README.md

Demonstrates basic text conversion from Chinese to Korean using the gukhanmun command-line tool.

```sh
echo "漢字 北京 標識" | gukhanmun
# → 한자 베이징 표지
```

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

### Initialize and Access the Korean Dictionary

Source: https://github.com/dahlia/gukhanmun/blob/main/crates/gukhanmun-stdict/README.md

Import and call the `ko_kr()` function to get a reference to the South Korean Standard Dictionary. The dictionary is decoded once and cached for the process lifetime.

```rust
use gukhanmun_stdict::ko_kr;

let dict = ko_kr();
// dict: &'static FstDictionary — decoded once, shared for the process lifetime

```

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

### Streaming Guarantee Example

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/streaming.md

Verifies the streaming guarantee by comparing the output of g.convert() with the concatenated output from a g.stream() operation. This ensures that streaming produces the same result as converting the full document at once.

```typescript
import type { Gukhanmun } from "@gukhanmun/types";
const g: Gukhanmun = {} as unknown as Gukhanmun;
const chunkA: string = "";
const chunkB: string = "";
const chunkC: string = "";
// ---cut-before---
// These are always equivalent:
const result1 = g.convert(chunkA + chunkB + chunkC, "html");

// and
const stream = g.stream("html");
const writer = stream.writable.getWriter();
await writer.write(chunkA);
await writer.write(chunkB);
await writer.write(chunkC);
await writer.close();
const result2 = stream.readable
  .getReader()
  .read()
  .then(({ value }) => value || "");

import assert from "node:assert/strict";
assert.strictEqual(result1, result2);
```

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

### Load Dictionary from File

Source: https://github.com/dahlia/gukhanmun/blob/main/crates/gukhanmun-fst/README.md

Instantiate FstDictionary by opening a dictionary file from the disk. This method owns the bytes internally.

```rust
use gukhanmun_fst::FstDictionary;

// From a file on disk (owns the bytes internally):
let dict = FstDictionary::open("stdict.gukfst")?;

```

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

### Applying Directives in Gukhanmun

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/directives.md

Example of loading Gukhanmun with custom directives to override annotations for specific hanja characters. This demonstrates how to use 'requireHanja', 'requireHangul', and 'skipAnnotation' when initializing the library.

```typescript
import { load } from "@gukhanmun/wasm";
import { stdictFst } from "@gukhanmun/stdict-fst";

const g = await load({
  dictionaries: [await stdictFst()],
  directives: {
    requireHanja:   ["漢", "字"],
    requireHangul:  ["東"],
    skipAnnotation: ["中"],
  },
});
```

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

### Previewing a Version Bump

Source: https://github.com/dahlia/gukhanmun/blob/main/CONTRIBUTING.md

Run this command to preview version bump changes without modifying any files. It shows the planned updates to workspace and dependency versions.

```sh
mise run bump -- 1.2.5
```

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

### Suppress Annotation with --skip-annotation

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/cli/directives.md

Use the --skip-annotation flag to prevent any annotation for a specific hanja character, leaving it as-is in the output. This example suppresses annotation for '中'.

```sh
gukhanmun --skip-annotation 中 input.txt
```

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

### Build Dictionary Files with gukhanmun-mkdict

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/internals/design.md

Use gukhanmun-mkdict to build CDB and FST dictionary files from various input formats. Supports merging, validation, and metadata embedding.

```bash
gukhanmun-mkdict [OPTIONS] -o OUTPUT <INPUT>...
```

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

### Predicate-Based Directives for Pattern Matching

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/rust/directives.md

Supply a closure as a predicate for pattern-based directive rules. This allows for dynamic annotation overrides based on string patterns, such as hanja starting with a specific character.

```rust
builder.directive_predicate(
    |hanja: &str| hanja.starts_with('東'),
    DirectiveAction::RequireHanja,
);
```

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

### Extract and Normalize Dictionary Words in Rust

Source: https://github.com/dahlia/gukhanmun/blob/main/crates/gukhanmun-dict-extract/README.md

Use the `keys_from_originals` function to assemble lookup keys and `normalize_word` to clean dictionary headwords. This example demonstrates stripping homograph digits, hyphens, and spaces from a word.

```rust
use gukhanmun_dict_extract::{keys_from_originals, normalize_word};

// Assemble lookup keys from original-language records
let keys = keys_from_originals(&original_language_infos);

// Normalize dictionary head words (stripping homograph digits, hyphens, and spaces)
let clean_word = normalize_word("힐난-조03");
assert_eq!(clean_word, "힐난조");

```

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

### Load and Use North Korean Dictionary CDB

Source: https://github.com/dahlia/gukhanmun/blob/main/packages/opendict-cdb/README.md

Load the North Korean dictionary CDB using the 'load' function from @gukhanmun/napi and perform a conversion. This example demonstrates integrating the CDB with the NAPI module for dictionary lookups.

```typescript
import { load } from "@gukhanmun/napi";
import { opendictNorthKoreanCdb } from "@gukhanmun/opendict-cdb";

const g = await load({
  preset: "ko-kp",
  dictionaries: [await opendictNorthKoreanCdb()]
});
console.log(g.convert("歷史와 來日")); // "력사와 래일"
```

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

### Load Custom Dictionary from File Path (Node.js/Deno/Bun)

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/javascript/dictionary.md

Load a custom dictionary using a direct filesystem path. This is only supported in Node.js, Deno, and Bun environments.

```typescript
import { load } from "@gukhanmun/napi";

const g = await load({
  dictionaries: [{ format: "fst", data: "/data/domain.gukfst" }],
});
```

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

### Force Hangul Reading with --require-hangul

Source: https://github.com/dahlia/gukhanmun/blob/main/docs/en/guide/cli/directives.md

Use the --require-hangul flag to force the hangul reading to be displayed alongside the hanja. This is particularly useful in 'original' rendering mode. This example forces the hangul reading for '東'.

```sh
gukhanmun --rendering original --require-hangul 東 input.txt
```

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

### Run Fast Pre-commit Checks

Source: https://github.com/dahlia/gukhanmun/blob/main/CONTRIBUTING.md

Execute quick checks suitable for pre-commit hooks to ensure code quality.

```sh
mise run check
```