package jp
// Port of WanaKana (github.com/WaniKani/WanaKana, MIT License) kana->romaji conversion
// as the core engine for Wapuro style romanization.
// See WANAKANA_LICENSE for original license notice.
import (
_ "embed"
"encoding/json"
"strings"
"unicode"
)
type Style int
const (
Macron Style = iota
Wapuro
Plain
)
// IsHiragana reports whether r is a hiragana character.
func IsHiragana(r rune) bool {
return (r >= 0x3041 && r <= 0x3096) || (r >= 0x309D && r <= 0x309F)
}
// IsKatakana reports whether r is a katakana character, including ー and half-width katakana.
func IsKatakana(r rune) bool {
if r == 'ー' || r == 'ｰ' {
return true
}
if r >= 0x30A1 && r <= 0x30FA {
return true
}
if r >= 0x30FD && r <= 0x30FF {
return true
}
if r >= 0xFF66 && r <= 0xFF9F {
return true
}
return false
}
// IsKana reports whether r is hiragana or katakana.
func IsKana(r rune) bool {
return IsHiragana(r) || IsKatakana(r)
}
// IsKanji reports whether r is a kanji character (CJK unified ideographs + ext A + 々〆ヵヶ).
func IsKanji(r rune) bool {
if r == '々' || r == '〆' || r == 'ヵ' || r == 'ヶ' {
return true
}
if r >= 0x4E00 && r <= 0x9FFF {
return true
}
if r >= 0x3400 && r <= 0x4DBF {
return true
}
if r >= 0xF900 && r <= 0xFAFF {
return true
}
return false
}
// HasJapanese reports whether s contains any kana or kanji.
func HasJapanese(s string) bool {
for _, r := range s {
if IsKana(r) || IsKanji(r) {
return true
}
}
return false
}
func isKanaLetter(r rune) bool {
return IsKana(r) && r != 'ー' && r != 'ｰ'
}
// IsKanaOnly reports whether s contains >=1 kana and only kana/ー/punct/space.
func IsKanaOnly(s string) bool {
hasKana := false
for _, r := range s {
if isKanaLetter(r) {
hasKana = true
continue
}
if r == 'ー' || r == 'ｰ' || unicode.IsPunct(r) || unicode.IsSpace(r) {
continue
}
return false
}
return hasKana
}
var halfwidthKatakana = map[rune]rune{
'｡': '。', '｢': '「', '｣': '」', '､': '、', '･': '・',
'ｦ': 'ヲ', 'ｧ': 'ァ', 'ｨ': 'ィ', 'ｩ': 'ゥ', 'ｪ': 'ェ', 'ｫ': 'ォ',
'ｬ': 'ャ', 'ｭ': 'ュ', 'ｮ': 'ョ', 'ｯ': 'ッ', 'ｰ': 'ー',
'ｱ': 'ア', 'ｲ': 'イ', 'ｳ': 'ウ', 'ｴ': 'エ', 'ｵ': 'オ',
'ｶ': 'カ', 'ｷ': 'キ', 'ｸ': 'ク', 'ｹ': 'ケ', 'ｺ': 'コ',
'ｻ': 'サ', 'ｼ': 'シ', 'ｽ': 'ス', 'ｾ': 'セ', 'ｿ': 'ソ',
'ﾀ': 'タ', 'ﾁ': 'チ', 'ﾂ': 'ツ', 'ﾃ': 'テ', 'ﾄ': 'ト',
'ﾅ': 'ナ', 'ﾆ': 'ニ', 'ﾇ': 'ヌ', 'ﾈ': 'ネ', 'ﾉ': 'ノ',
'ﾊ': 'ハ', 'ﾋ': 'ヒ', 'ﾌ': 'フ', 'ﾍ': 'ヘ', 'ﾎ': 'ホ',
'ﾏ': 'マ', 'ﾐ': 'ミ', 'ﾑ': 'ム', 'ﾒ': 'メ', 'ﾓ': 'モ',
'ﾔ': 'ヤ', 'ﾕ': 'ユ', 'ﾖ': 'ヨ',
'ﾗ': 'ラ', 'ﾘ': 'リ', 'ﾙ': 'ル', 'ﾚ': 'レ', 'ﾛ': 'ロ',
'ﾜ': 'ワ', 'ﾝ': 'ン',
}
var voicedKatakana = map[rune]rune{
'カ': 'ガ', 'キ': 'ギ', 'ク': 'グ', 'ケ': 'ゲ', 'コ': 'ゴ',
'サ': 'ザ', 'シ': 'ジ', 'ス': 'ズ', 'セ': 'ゼ', 'ソ': 'ゾ',
'タ': 'ダ', 'チ': 'ヂ', 'ツ': 'ヅ', 'テ': 'デ', 'ト': 'ド',
'ハ': 'バ', 'ヒ': 'ビ', 'フ': 'ブ', 'ヘ': 'ベ', 'ホ': 'ボ',
'ウ': 'ヴ', 'ワ': 'ヷ', 'ヰ': 'ヸ', 'ヱ': 'ヹ', 'ヲ': 'ヺ',
}
var semiVoicedKatakana = map[rune]rune{
'ハ': 'パ', 'ヒ': 'ピ', 'フ': 'プ', 'ヘ': 'ペ', 'ホ': 'ポ',
}
func normalizeHalfwidth(s string) string {
runes := []rune(s)
var out []rune
for i := 0; i < len(runes); i++ {
r := runes[i]
if r == 'ﾞ' || r == 'ﾟ' {
continue
}
if full, ok := halfwidthKatakana[r]; ok {
if i+1 < len(runes) {
if runes[i+1] == 'ﾞ' {
if v, vok := voicedKatakana[full]; vok {
out = append(out, v)
i++
continue
}
} else if runes[i+1] == 'ﾟ' {
if sv, sok := semiVoicedKatakana[full]; sok {
out = append(out, sv)
i++
continue
}
}
}
out = append(out, full)
} else {
out = append(out, r)
}
}
return string(out)
}
// ToHiragana converts katakana to hiragana, leaving other characters unchanged.
func ToHiragana(s string) string {
s = normalizeHalfwidth(s)
var b strings.Builder
b.Grow(len(s))
for _, r := range s {
if r >= 0x30A1 && r <= 0x30F6 {
b.WriteRune(r - 0x60)
} else if r == 0x30FD {
b.WriteRune(0x309D) // ヽ -> ゝ
} else if r == 0x30FE {
b.WriteRune(0x309E) // ヾ -> ゞ
} else {
b.WriteRune(r)
}
}
return b.String()
}
// ToKatakana converts hiragana to katakana, leaving other characters unchanged.
func ToKatakana(s string) string {
s = normalizeHalfwidth(s)
var b strings.Builder
b.Grow(len(s))
for _, r := range s {
if r >= 0x3041 && r <= 0x3096 {
b.WriteRune(r + 0x60)
} else if r == 0x309D {
b.WriteRune(0x30FD) // ゝ -> ヽ
} else if r == 0x309E {
b.WriteRune(0x30FE) // ゞ -> ヾ
} else {
b.WriteRune(r)
}
}
return b.String()
}
func isSmallAttaching(r rune) bool {
switch r {
case 'ゃ', 'ゅ', 'ょ', 'ぁ', 'ぃ', 'ぅ', 'ぇ', 'ぉ', 'ゎ',
'ャ', 'ュ', 'ョ', 'ァ', 'ィ', 'ゥ', 'ェ', 'ォ', 'ヮ',
'ｬ', 'ｭ', 'ｮ', 'ｧ', 'ｨ', 'ｩ', 'ｪ', 'ｫ':
return true
default:
return false
}
}
// Moras segments kana into moras. Small ゃゅょぁぃぅぇぉ and ゎ attach to the
// previous kana; っ, ん, and ー are each their own mora.
func Moras(kana string) []string {
var moras []string
for _, r := range kana {
if isSmallAttaching(r) && len(moras) > 0 {
moras[len(moras)-1] += string(r)
} else {
moras = append(moras, string(r))
}
}
return moras
}
//go:embed wanakana_tree.json
var wanakanaTreeJSON []byte
type trieNode struct {
val string
children map[rune]*trieNode
}
var wanakanaRoot *trieNode
func parseTrie(raw map[string]interface{}) *trieNode {
n := &trieNode{children: make(map[rune]*trieNode)}
for k, v := range raw {
if k == "" {
if s, ok := v.(string); ok {
n.val = s
}
} else {
r := []rune(k)[0]
if childRaw, ok := v.(map[string]interface{}); ok {
n.children[r] = parseTrie(childRaw)
}
}
}
return n
}
func init() {
var raw map[string]interface{}
if err := json.Unmarshal(wanakanaTreeJSON, &raw); err != nil {
panic(err)
}
wanakanaRoot = parseTrie(raw)
}
func isCharKatakana(r rune) bool {
return r >= 0x30A1 && r <= 0x30FC
}
var wanakanaLongVowels = map[byte]rune{
'a': 'あ',
'i': 'い',
'u': 'う',
'e': 'え',
'o': 'う',
}
// wanakanaKatakanaToHiragana implements WanaKana's katakanaToHiragana transform
// with convertLongVowelMark=true and isDestinationRomaji=true.
func wanakanaKatakanaToHiragana(s string) string {
runes := []rune(s)
var b strings.Builder
var prevKana string
for idx, r := range runes {
if r == '・' || (r == 'ー' && idx < 1) || r == 'ヶ' || r == 'ヵ' {
b.WriteRune(r)
prevKana = ""
continue
}
if prevKana != "" && r == 'ー' && idx > 0 {
romaji := wanakanaApplyMapping(prevKana)
var lastV byte
if len(romaji) > 0 {
lastV = romaji[len(romaji)-1]
}
if isCharKatakana(runes[idx-1]) && lastV == 'o' {
b.WriteRune('お')
} else if mapped, ok := wanakanaLongVowels[lastV]; ok {
b.WriteRune(mapped)
}
continue
}
if r != 'ー' && isCharKatakana(r) {
h := r - 0x60
prevKana = string(h)
b.WriteRune(h)
continue
}
prevKana = ""
b.WriteRune(r)
}
return b.String()
}
// wanakanaApplyMapping implements WanaKana's applyMapping over the Hepburn trie.
func wanakanaApplyMapping(s string) string {
runes := []rune(s)
var b strings.Builder
i := 0
n := len(runes)
for i < n {
curr := wanakanaRoot
lastMatch := ""
lastMatchIdx := -1
j := i
for j < n {
next, ok := curr.children[runes[j]]
if !ok {
break
}
curr = next
if curr.val != "" || (j == i && curr.val == "" && runes[j] == 'っ') {
lastMatch = curr.val
lastMatchIdx = j + 1
}
j++
}
if lastMatchIdx != -1 {
b.WriteString(lastMatch)
i = lastMatchIdx
} else {
b.WriteRune(runes[i])
i++
}
}
return b.String()
}
// ToRomajiWapuro converts kana to Wapuro romaji with 100% WanaKana parity.
func ToRomajiWapuro(s string) string {
hira := wanakanaKatakanaToHiragana(s)
return wanakanaApplyMapping(hira)
}
var dakutenMap = map[rune]rune{
'か': 'が', 'き': 'ぎ', 'く': 'ぐ', 'け': 'げ', 'こ': 'ご',
'さ': 'ざ', 'し': 'じ', 'す': 'ず', 'せ': 'ぜ', 'そ': 'ぞ',
'た': 'だ', 'ち': 'ぢ', 'つ': 'づ', 'て': 'で', 'と': 'ど',
'は': 'ば', 'ひ': 'び', 'ふ': 'ぶ', 'へ': 'べ', 'ほ': 'ぼ',
'カ': 'ガ', 'キ': 'ギ', 'ク': 'グ', 'ケ': 'ゲ', 'コ': 'ゴ',
'サ': 'ザ', 'シ': 'ジ', 'ス': 'ズ', 'セ': 'ゼ', 'ソ': 'ゾ',
'タ': 'ダ', 'チ': 'ヂ', 'ツ': 'ヅ', 'テ': 'デ', 'ト': 'ド',
'ハ': 'バ', 'ヒ': 'ビ', 'フ': 'ブ', 'ヘ': 'ベ', 'ホ': 'ボ',
'ウ': 'ヴ',
}
func expandIterationMarks(kana string) string {
runes := []rune(kana)
var out []rune
for _, r := range runes {
switch r {
case 'ゝ', 'ヽ':
if len(out) > 0 {
out = append(out, out[len(out)-1])
} else {
out = append(out, r)
}
case 'ゞ', 'ヾ':
if len(out) > 0 {
prev := out[len(out)-1]
if voiced, ok := dakutenMap[prev]; ok {
out = append(out, voiced)
} else {
out = append(out, prev)
}
} else {
out = append(out, r)
}
default:
out = append(out, r)
}
}
return string(out)
}
var macronMap = map[rune]rune{
'a': 'ā', 'i': 'ī', 'u': 'ū', 'e': 'ē', 'o': 'ō',
'A': 'Ā', 'I': 'Ī', 'U': 'Ū', 'E': 'Ē', 'O': 'Ō',
}
func lastVowel(s string) rune {
runes := []rune(s)
for i := len(runes) - 1; i >= 0; i-- {
ch := runes[i]
switch ch {
case 'a', 'i', 'u', 'e', 'o':
return ch
case 'ā':
return 'a'
case 'ī':
return 'i'
case 'ū':
return 'u'
case 'ē':
return 'e'
case 'ō':
return 'o'
}
}
return 0
}
func lengthenLastVowel(s string) string {
runes := []rune(s)
for i := len(runes) - 1; i >= 0; i-- {
if mac, ok := macronMap[runes[i]]; ok {
runes[i] = mac
return string(runes)
}
}
return s
}
// Romaji converts kana to Hepburn romaji context-free according to style.
// Wapuro style uses the WanaKana engine.
// Macron and Plain styles apply Hepburn conventions (e.g. ヲ/を -> "o", ー -> macron/drop).
func Romaji(kana string, st Style) string {
if st == Wapuro {
return ToRomajiWapuro(kana)
}
kana = expandIterationMarks(kana)
moras := Moras(kana)
var out []string
for i := 0; i < len(moras); i++ {
m := moras[i]
cur := strings.Join(out, "")
prevV := lastVowel(cur)
if m == "を" || m == "ヲ" {
out = append(out, "o")
continue
}
if m == "っ" || m == "ッ" {
if i+1 < len(moras) {
nxt := ToRomajiWapuro(moras[i+1])
if strings.HasPrefix(nxt, "ch") {
out = append(out, "t")
} else if len(nxt) > 0 && !strings.ContainsRune("aiueo", rune(nxt[0])) {
out = append(out, string(nxt[0]))
}
}
continue
}
if m == "ん" || m == "ン" {
if i+1 < len(moras) {
nxt := ToRomajiWapuro(moras[i+1])
if len(nxt) > 0 && (strings.ContainsRune("aiueo", rune(nxt[0])) || strings.HasPrefix(nxt, "y")) {
out = append(out, "n'")
} else {
out = append(out, "n")
}
} else {
out = append(out, "n")
}
continue
}
if m == "ー" || m == "ｰ" {
if prevV != 0 {
switch st {
case Macron:
out = []string{lengthenLastVowel(cur)}
case Plain:
// drop
}
} else {
out = append(out, "-")
}
continue
}
out = append(out, ToRomajiWapuro(m))
}
return strings.Join(out, "")
}
// RomajiPron converts reading aligned with pronunciation into romaji.
// It merges long vowels when pron has ー and reading has ウ after o/u
// or a vowel repeat (おお, ああ...). It preserves "ei" when reading has イ after e.
// Particles ハ->wa, ヘ->e are romanized according to pron.
// ヲ/を is romanized as "o" in Macron and Plain, and "wo" in Wapuro (unless pron is "o").
// Falls back to Romaji(reading) when pron is empty or alignment fails.
func RomajiPron(reading, pron string, st Style) string {
if pron == "" {
return Romaji(reading, st)
}
rNorm := expandIterationMarks(reading)
pNorm := expandIterationMarks(pron)
rMoras := Moras(ToKatakana(rNorm))
pMoras := Moras(ToKatakana(pNorm))
if len(rMoras) != len(pMoras) {
return Romaji(reading, st)
}
var out []string
for i := 0; i < len(rMoras); i++ {
r := rMoras[i]
p := pMoras[i]
// Particle check
var particle string
if r == "ハ" && p == "ワ" {
particle = "wa"
} else if r == "ヘ" && p == "エ" {
particle = "e"
} else if r == "ヲ" {
if st == Macron || st == Plain {
particle = "o"
} else if p == "オ" {
particle = "o"
} else {
particle = "wo"
}
}
cur := strings.Join(out, "")
prevV := lastVowel(cur)
if p == "ー" || p == "ｰ" {
if r == "イ" && prevV == 'e' {
// Keep "ei"
out = append(out, "i")
} else if r == "ウ" && (prevV == 'o' || prevV == 'u') {
switch st {
case Macron:
out = []string{lengthenLastVowel(cur)}
case Wapuro:
out = append(out, "u")
case Plain:
// drop
}
} else if prevV != 0 && ((prevV == 'a' && r == "ア") ||
(prevV == 'i' && r == "イ") ||
(prevV == 'u' && r == "ウ") ||
(prevV == 'e' && r == "エ") ||
(prevV == 'o' && r == "オ")) {
switch st {
case Macron:
out = []string{lengthenLastVowel(cur)}
case Wapuro:
out = append(out, string(prevV))
case Plain:
// drop
}
} else if r == "ー" || r == "ｰ" {
if prevV != 0 {
switch st {
case Macron:
out = []string{lengthenLastVowel(cur)}
case Wapuro:
out = append(out, string(prevV))
case Plain:
// drop
}
} else {
out = append(out, "-")
}
} else {
if particle != "" {
out = append(out, particle)
} else {
out = append(out, ToRomajiWapuro(r))
}
}
} else if r == "ッ" {
if i+1 < len(rMoras) {
nxt := ToRomajiWapuro(rMoras[i+1])
if strings.HasPrefix(nxt, "ch") {
out = append(out, "t")
} else if len(nxt) > 0 && !strings.ContainsRune("aiueo", rune(nxt[0])) {
out = append(out, string(nxt[0]))
}
}
} else if r == "ン" {
if i+1 < len(rMoras) {
nxt := ToRomajiWapuro(rMoras[i+1])
if len(nxt) > 0 && (strings.ContainsRune("aiueo", rune(nxt[0])) || strings.HasPrefix(nxt, "y")) {
out = append(out, "n'")
} else {
out = append(out, "n")
}
} else {
out = append(out, "n")
}
} else if r == "ー" || r == "ｰ" {
if prevV != 0 {
switch st {
case Macron:
out = []string{lengthenLastVowel(cur)}
case Wapuro:
out = append(out, string(prevV))
case Plain:
// drop
}
} else {
out = append(out, "-")
}
} else {
if particle != "" {
out = append(out, particle)
} else {
out = append(out, ToRomajiWapuro(r))
}
}
}
return strings.Join(out, "")
}