@ihabdevteam/core 0.8.0

package/dist/packages/core/src/utils/imageConfig.d.ts

@@ -0,0 +1,48 @@
+declare global {
+    var __ihab_core_image_config__: ((word: string, homonum?: number) => string) | undefined;
+}
+/** @public */
+export declare function configureImageResolver(resolver: (word: string, homonum?: number) => string): void;
+/** @public */
+export declare function getImageResolver(): ((word: string, homonum?: number) => string) | null;
+/**
+ * @public
+ * 단어 이미지 존재 여부 확인 — localStorage 캐시 우선, 없으면 HEAD 요청 후 캐시 저장.
+ * 한 번 확인된 단어는 영구 캐싱되어 다음 접속 시에도 즉시 반환.
+ */
+export declare function checkImageExists(word: string, homonum?: number): Promise<boolean>;
+/** @public 단어 이미지 존재 여부 동기 조회 (캐시에 있을 때만). 없으면 undefined. */
+export declare function getImageExistsCached(word: string, homonum?: number): boolean | undefined;
+/**
+ * @public
+ * 여러 단어의 이미지 존재 여부를 사전 확인 (병렬). localStorage에 영구 저장됨.
+ * - force=false (기본): 캐시에 없는 단어만 확인
+ * - force=true: 캐시 무시하고 전부 재확인
+ * - concurrency: 동시 요청 수 (기본 16)
+ */
+export declare function prewarmImageCache(words: string[], options?: {
+    force?: boolean;
+    concurrency?: number;
+    onProgress?: (done: number, total: number) => void;
+}): Promise<{
+    checked: number;
+    cached: number;
+    total: number;
+}>;
+/**
+ * @public
+ * 현재 캐시에서 이미지 존재 통계를 반환합니다.
+ * 캐시가 비어 있으면 null 반환.
+ */
+export declare function getImageExistenceStats(): {
+    total: number;
+    exists: number;
+} | null;
+/**
+ * @public
+ * 이미지 존재 여부를 일괄 주입 (storage.list() 결과 등 외부에서 미리 계산한 경우).
+ * 기존 캐시에 merge되고, 즉시 localStorage에 저장됩니다.
+ */
+export declare function bulkSetImageExistence(entries: Record<string, boolean>): void;
+/** @public 캐시 초기화 (이미지 데이터 변경 시 호출) */
+export declare function clearImageExistenceCache(): void;

package/dist/packages/core/src/utils/imageConfig.js

@@ -0,0 +1,159 @@
+const GLOBAL_KEY = '__ihab_core_image_config__';
+/** @public */
+export function configureImageResolver(resolver) {
+    globalThis[GLOBAL_KEY] = resolver;
+}
+/** @public */
+export function getImageResolver() {
+    return globalThis[GLOBAL_KEY] ?? null;
+}
+// ─── 로컬 캐싱 (localStorage + 메모리) ───────────────────────────────────────
+const LS_KEY = 'word_image_existence_map_v1';
+let memMap = null;
+const inflight = new Map(); // 중복 fetch 방지
+function ensureLoaded() {
+    if (memMap)
+        return memMap;
+    try {
+        const raw = (typeof localStorage !== 'undefined') ? localStorage.getItem(LS_KEY) : null;
+        memMap = raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        memMap = {};
+    }
+    return memMap;
+}
+let savePending = null;
+function scheduleSave() {
+    if (savePending)
+        return;
+    savePending = setTimeout(() => {
+        savePending = null;
+        try {
+            if (typeof localStorage !== 'undefined' && memMap) {
+                localStorage.setItem(LS_KEY, JSON.stringify(memMap));
+            }
+        }
+        catch { }
+    }, 200);
+}
+function keyOf(word, homonum) {
+    return `${word}_${homonum ?? 1}`;
+}
+/**
+ * @public
+ * 단어 이미지 존재 여부 확인 — localStorage 캐시 우선, 없으면 HEAD 요청 후 캐시 저장.
+ * 한 번 확인된 단어는 영구 캐싱되어 다음 접속 시에도 즉시 반환.
+ */
+export async function checkImageExists(word, homonum) {
+    const map = ensureLoaded();
+    const k = keyOf(word, homonum);
+    if (k in map)
+        return map[k];
+    if (inflight.has(k))
+        return inflight.get(k);
+    const resolver = getImageResolver();
+    if (!resolver)
+        return false;
+    const url = resolver(word, homonum);
+    if (!url)
+        return false;
+    // 타임아웃 없으면 HEAD 요청 하나가 응답 없이 걸릴 때 이 확인을 기다리는
+    // 검색 버튼(이미지 있음 필터)이 영구 비활성화된다
+    const p = fetch(url, { method: 'HEAD', signal: AbortSignal.timeout(8000) })
+        .then(res => res.ok)
+        .catch(() => false)
+        .then(ok => {
+        map[k] = ok;
+        scheduleSave();
+        inflight.delete(k);
+        return ok;
+    });
+    inflight.set(k, p);
+    return p;
+}
+/** @public 단어 이미지 존재 여부 동기 조회 (캐시에 있을 때만). 없으면 undefined. */
+export function getImageExistsCached(word, homonum) {
+    const map = ensureLoaded();
+    const k = keyOf(word, homonum);
+    return k in map ? map[k] : undefined;
+}
+/**
+ * @public
+ * 여러 단어의 이미지 존재 여부를 사전 확인 (병렬). localStorage에 영구 저장됨.
+ * - force=false (기본): 캐시에 없는 단어만 확인
+ * - force=true: 캐시 무시하고 전부 재확인
+ * - concurrency: 동시 요청 수 (기본 16)
+ */
+export async function prewarmImageCache(words, options = {}) {
+    const { force = false, concurrency = 16, onProgress } = options;
+    const map = ensureLoaded();
+    const todo = force ? Array.from(new Set(words)) : Array.from(new Set(words)).filter(w => !(keyOf(w) in map));
+    let done = 0;
+    if (todo.length > 0) {
+        let idx = 0;
+        const workers = Array.from({ length: Math.min(concurrency, todo.length) }, async () => {
+            while (idx < todo.length) {
+                const i = idx++;
+                const w = todo[i];
+                const k = keyOf(w);
+                if (!force && (k in map)) {
+                    done++;
+                    onProgress?.(done, todo.length);
+                    continue;
+                }
+                try {
+                    await checkImageExists(w);
+                }
+                catch { }
+                done++;
+                onProgress?.(done, todo.length);
+            }
+        });
+        await Promise.all(workers);
+    }
+    // 즉시 저장 (대기 중인 debounce도 함께)
+    try {
+        if (typeof localStorage !== 'undefined' && memMap) {
+            localStorage.setItem(LS_KEY, JSON.stringify(memMap));
+        }
+    }
+    catch { }
+    return { checked: todo.length, cached: Object.keys(map).length, total: words.length };
+}
+/**
+ * @public
+ * 현재 캐시에서 이미지 존재 통계를 반환합니다.
+ * 캐시가 비어 있으면 null 반환.
+ */
+export function getImageExistenceStats() {
+    const map = ensureLoaded();
+    const values = Object.values(map);
+    if (values.length === 0)
+        return null;
+    return { total: values.length, exists: values.filter(Boolean).length };
+}
+/**
+ * @public
+ * 이미지 존재 여부를 일괄 주입 (storage.list() 결과 등 외부에서 미리 계산한 경우).
+ * 기존 캐시에 merge되고, 즉시 localStorage에 저장됩니다.
+ */
+export function bulkSetImageExistence(entries) {
+    const map = ensureLoaded();
+    Object.assign(map, entries);
+    try {
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem(LS_KEY, JSON.stringify(map));
+        }
+    }
+    catch { }
+}
+/** @public 캐시 초기화 (이미지 데이터 변경 시 호출) */
+export function clearImageExistenceCache() {
+    memMap = {};
+    try {
+        if (typeof localStorage !== 'undefined')
+            localStorage.removeItem(LS_KEY);
+    }
+    catch { }
+}

package/dist/packages/core/src/utils/josa.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 문자열 끝 글자에 맞는 주격 조사(이/가)를 고른다.
+ * - 완성된 음절(가~힣): 받침 유무로 판정.
+ * - 낱자음(ㄱ~ㅎ): 이름이 받침으로 끝나므로("기역", "니은"...) '이'.
+ * - 낱모음(ㅏ~ㅣ): 이름이 모음 자체이므로("아", "야"...) '가'.
+ * - 판정 불가(빈 문자열 등 한글이 아닌 값): '가'를 기본값으로 사용.
+ */
+export declare function pickIga(text: string): '이' | '가';
+/** text 뒤에 문맥에 맞는 이/가를 붙여 반환한다. */
+export declare function withIga(text: string): string;
+/**
+ * 문자열 끝 글자에 맞는 목적격 조사(을/를)를 고른다.
+ * 판정 규칙은 pickIga와 동일(받침 있음→'을', 없음→'를').
+ */
+export declare function pickEulReul(text: string): '을' | '를';
+/** text 뒤에 문맥에 맞는 을/를을 붙여 반환한다. */
+export declare function withEulReul(text: string): string;
+/** 보조사 은/는 — 받침 있음→'은', 없음→'는'(낱자음은 받침취급, 낱모음은 '는'). */
+export declare function pickEunNeun(text: string): '은' | '는';
+/** text 뒤에 은/는을 붙여 반환한다. */
+export declare function withEunNeun(text: string): string;
+/** 접속조사 와/과 — 받침 있음→'과', 없음→'와'(낱자음은 받침취급, 낱모음은 '와'). */
+export declare function pickWaGwa(text: string): '와' | '과';
+/** text 뒤에 와/과를 붙여 반환한다. */
+export declare function withWaGwa(text: string): string;
+/** 부사격조사 으로/로 — 받침 없음 또는 ㄹ받침→'로', 그 외 받침→'으로'(낱자 'ㄹ'→'로', 다른 낱자음→'으로', 낱모음→'로'). */
+export declare function pickEuRo(text: string): '으로' | '로';
+/** text 뒤에 으로/로를 붙여 반환한다. */
+export declare function withEuRo(text: string): string;

package/dist/packages/core/src/utils/josa.js

@@ -0,0 +1,103 @@
+const HANGUL_SYLLABLE_BASE = 0xAC00;
+const HANGUL_SYLLABLE_END = 0xD7A3;
+const CONSONANT_JAMO = /[ㄱ-ㅎ]/;
+const VOWEL_JAMO = /[ㅏ-ㅣ]/;
+// 문자열 끝의 실제 한글(음절 또는 낱자모) 글자를 찾는다 — 따옴표 등 뒤에 붙는
+// 문장부호는 건너뛴다(예: "'ㄹ'"의 마지막 문자는 "'"지만 판정에 쓸 글자는 "ㄹ").
+function lastHangulChar(text) {
+    for (let i = text.length - 1; i >= 0; i--) {
+        const ch = text[i];
+        const code = ch.charCodeAt(0);
+        if ((code >= HANGUL_SYLLABLE_BASE && code <= HANGUL_SYLLABLE_END) || CONSONANT_JAMO.test(ch) || VOWEL_JAMO.test(ch)) {
+            return ch;
+        }
+    }
+    return null;
+}
+/**
+ * 문자열 끝 글자에 맞는 주격 조사(이/가)를 고른다.
+ * - 완성된 음절(가~힣): 받침 유무로 판정.
+ * - 낱자음(ㄱ~ㅎ): 이름이 받침으로 끝나므로("기역", "니은"...) '이'.
+ * - 낱모음(ㅏ~ㅣ): 이름이 모음 자체이므로("아", "야"...) '가'.
+ * - 판정 불가(빈 문자열 등 한글이 아닌 값): '가'를 기본값으로 사용.
+ */
+export function pickIga(text) {
+    const ch = lastHangulChar(text);
+    if (!ch)
+        return '가';
+    const code = ch.charCodeAt(0);
+    if (code >= HANGUL_SYLLABLE_BASE && code <= HANGUL_SYLLABLE_END) {
+        return (code - HANGUL_SYLLABLE_BASE) % 28 !== 0 ? '이' : '가';
+    }
+    return CONSONANT_JAMO.test(ch) ? '이' : '가';
+}
+/** text 뒤에 문맥에 맞는 이/가를 붙여 반환한다. */
+export function withIga(text) {
+    return `${text}${pickIga(text)}`;
+}
+/**
+ * 문자열 끝 글자에 맞는 목적격 조사(을/를)를 고른다.
+ * 판정 규칙은 pickIga와 동일(받침 있음→'을', 없음→'를').
+ */
+export function pickEulReul(text) {
+    const ch = lastHangulChar(text);
+    if (!ch)
+        return '를';
+    const code = ch.charCodeAt(0);
+    if (code >= HANGUL_SYLLABLE_BASE && code <= HANGUL_SYLLABLE_END) {
+        return (code - HANGUL_SYLLABLE_BASE) % 28 !== 0 ? '을' : '를';
+    }
+    return CONSONANT_JAMO.test(ch) ? '을' : '를';
+}
+/** text 뒤에 문맥에 맞는 을/를을 붙여 반환한다. */
+export function withEulReul(text) {
+    return `${text}${pickEulReul(text)}`;
+}
+/** 보조사 은/는 — 받침 있음→'은', 없음→'는'(낱자음은 받침취급, 낱모음은 '는'). */
+export function pickEunNeun(text) {
+    const ch = lastHangulChar(text);
+    if (!ch)
+        return '는';
+    const code = ch.charCodeAt(0);
+    if (code >= HANGUL_SYLLABLE_BASE && code <= HANGUL_SYLLABLE_END) {
+        return (code - HANGUL_SYLLABLE_BASE) % 28 !== 0 ? '은' : '는';
+    }
+    return CONSONANT_JAMO.test(ch) ? '은' : '는';
+}
+/** text 뒤에 은/는을 붙여 반환한다. */
+export function withEunNeun(text) {
+    return `${text}${pickEunNeun(text)}`;
+}
+/** 접속조사 와/과 — 받침 있음→'과', 없음→'와'(낱자음은 받침취급, 낱모음은 '와'). */
+export function pickWaGwa(text) {
+    const ch = lastHangulChar(text);
+    if (!ch)
+        return '와';
+    const code = ch.charCodeAt(0);
+    if (code >= HANGUL_SYLLABLE_BASE && code <= HANGUL_SYLLABLE_END) {
+        return (code - HANGUL_SYLLABLE_BASE) % 28 !== 0 ? '과' : '와';
+    }
+    return CONSONANT_JAMO.test(ch) ? '과' : '와';
+}
+/** text 뒤에 와/과를 붙여 반환한다. */
+export function withWaGwa(text) {
+    return `${text}${pickWaGwa(text)}`;
+}
+/** 부사격조사 으로/로 — 받침 없음 또는 ㄹ받침→'로', 그 외 받침→'으로'(낱자 'ㄹ'→'로', 다른 낱자음→'으로', 낱모음→'로'). */
+export function pickEuRo(text) {
+    const ch = lastHangulChar(text);
+    if (!ch)
+        return '로';
+    const code = ch.charCodeAt(0);
+    if (code >= HANGUL_SYLLABLE_BASE && code <= HANGUL_SYLLABLE_END) {
+        const jong = (code - HANGUL_SYLLABLE_BASE) % 28;
+        return (jong === 0 || jong === 8) ? '로' : '으로';
+    }
+    if (ch === 'ㄹ')
+        return '로';
+    return CONSONANT_JAMO.test(ch) ? '으로' : '로';
+}
+/** text 뒤에 으로/로를 붙여 반환한다. */
+export function withEuRo(text) {
+    return `${text}${pickEuRo(text)}`;
+}

package/dist/packages/core/src/utils/koreanPronunciation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 표기를 표준발음에 가깝게 변환한다. 한글 음절이 아닌 문자가 섞여 있으면 원문을 그대로 돌려준다
+ * (숫자·영문·공백이 든 입력을 어설프게 건드리지 않기 위함).
+ *
+ * 단어 데이터의 SP 컬럼과는 표기 규약이 다르다. 그쪽은 청각 훈련용이라 ㅔ/ㅚ/ㅖ를
+ * ㅐ/ㅙ/ㅒ로 합쳐 적는데(되다→돼다 412건 대 8건으로 확립된 규약이다) 이 함수는
+ * 표준발음 그대로 둔다. 그래서 라이브 표본 173건 대조에서 64.7%만 일치했다.
+ *
+ * 지금 이 함수를 쓰는 곳은 두 군데뿐이고 둘 다 사람이 보고 고치는 입력 보조다 —
+ * 단어 제안 폼의 표준발음 자동 채움, 단어 관리의 새 단어 발음 제안. 훈련 문제
+ * 생성이나 검색에는 쓰이지 않는다. 규약을 맞추려 해도 파급은 그 둘뿐이지만,
+ * 모음 합치기는 '표준발음'이 아니라 이 데이터의 표기 규약이라 이름과 어긋난다 —
+ * 옵션으로 열지 별도 함수로 둘지는 정해야 한다.
+ * @public
+ */
+export declare function toStandardPronunciation(word: string): string;

package/dist/packages/core/src/utils/koreanPronunciation.js

@@ -0,0 +1,223 @@
+/**
+ * 한글 표준발음 근사 변환 (표기 → 소리)
+ *
+ * '단어 관리'에서 개인 단어를 추가할 때 표준 발음 칸의 **추천값**을 만드는 용도다.
+ * 사전에 없는 단어라 조회할 수 없으므로 표기에서 규칙으로 유도한다.
+ *
+ * 한계 — 이 변환은 "표기만 보고" 적용할 수 있는 규칙만 다룬다. 표준발음법에는 형태소
+ * 경계·품사·어휘 예외에 기대는 항목이 있어(예: 용언 어간 뒤 경음화, 사이시옷, 한자어
+ * ㄹ 뒤 경음화) 표기만으로는 판정할 수 없다. 그래서 결과는 항상 사용자가 확인·수정할
+ * 수 있는 자리(placeholder/추천)에만 쓰고, 저장값으로 강제하지 않는다.
+ *
+ * @public
+ */
+import { parseSyllable, composeSyllable } from './koreanSyllable';
+// ── 인덱스 상수 (koreanSyllable의 CHOSEONG/JONGSEONG 배열 순서) ──────────────
+const CHO_G = 0, CHO_GG = 1, CHO_N = 2, CHO_D = 3, CHO_DD = 4, CHO_R = 5, CHO_M = 6, CHO_B = 7, CHO_BB = 8, CHO_S = 9, CHO_SS = 10, CHO_NG = 11, CHO_J = 12, CHO_JJ = 13, CHO_CH = 14, CHO_K = 15, CHO_T = 16, CHO_P = 17, CHO_H = 18;
+const JONG_NONE = 0, JONG_G = 1, JONG_GS = 3, JONG_N = 4, JONG_NJ = 5, JONG_NH = 6, JONG_D = 7, JONG_R = 8, JONG_RG = 9, JONG_RM = 10, JONG_RB = 11, JONG_RS = 12, JONG_RT = 13, JONG_RH = 15, JONG_M = 16, JONG_B = 17, JONG_BS = 18, JONG_NG = 21, JONG_H = 27;
+const JUNG_I = 20; // 'ㅣ'
+/** 홑받침이 모음 앞에서 연음될 때 다음 음절 초성이 되는 값. 없으면 연음하지 않는다(ㅇ·ㅎ). */
+const JONG_TO_CHO = {
+    1: CHO_G, 2: CHO_GG, 4: CHO_N, 7: CHO_D, 8: CHO_R, 16: CHO_M, 17: CHO_B,
+    19: CHO_S, 20: CHO_SS, 22: CHO_J, 23: CHO_CH, 24: CHO_K, 25: CHO_T, 26: CHO_P,
+};
+/** 겹받침이 모음 앞에서 갈라질 때 [앞에 남는 종성, 뒤로 넘어가는 초성]. ㅅ 계열은 된소리로 넘어간다. */
+const CLUSTER_LINK = {
+    [JONG_GS]: [JONG_G, CHO_SS], // ㄳ → ㄱ + ㅆ  (값이 → 갑씨)
+    [JONG_NJ]: [JONG_N, CHO_J], // ㄵ → ㄴ + ㅈ  (앉아 → 안자)
+    [JONG_RG]: [JONG_R, CHO_G], // ㄺ → ㄹ + ㄱ  (읽어 → 일거)
+    [JONG_RM]: [JONG_R, CHO_M], // ㄻ → ㄹ + ㅁ  (젊어 → 절머)
+    [JONG_RB]: [JONG_R, CHO_B], // ㄼ → ㄹ + ㅂ  (넓어 → 널버)
+    [JONG_RS]: [JONG_R, CHO_SS], // ㄽ → ㄹ + ㅆ
+    [JONG_RT]: [JONG_R, CHO_T], // ㄾ → ㄹ + ㅌ  (핥아 → 할타)
+    14: [JONG_R, CHO_P], // ㄿ → ㄹ + ㅍ
+    [JONG_BS]: [JONG_B, CHO_SS], // ㅄ → ㅂ + ㅆ  (없어 → 업써)
+};
+/** ㅎ을 품은 겹받침 — 모음 앞에서 ㅎ이 탈락하고 남은 자음만 연음된다. */
+const H_CLUSTER_LINK = {
+    [JONG_NH]: CHO_N, // ㄶ → ㄴ  (많은 → 마는)
+    [JONG_RH]: CHO_R, // ㅀ → ㄹ  (싫어 → 시러)
+};
+/** 자음 앞·어말에서의 대표음(음절 끝소리 규칙 + 겹받침 단순화). */
+const JONG_REPRESENTATIVE = {
+    2: JONG_G, 24: JONG_G, 3: JONG_G, 9: JONG_G, // ㄲㅋㄳㄺ → ㄱ
+    5: JONG_N, 6: JONG_N, // ㄵㄶ → ㄴ
+    19: JONG_D, 20: JONG_D, 22: JONG_D, 23: JONG_D, 25: JONG_D, 27: JONG_D, // ㅅㅆㅈㅊㅌㅎ → ㄷ
+    11: JONG_R, 12: JONG_R, 13: JONG_R, 15: JONG_R, // ㄼㄽㄾㅀ → ㄹ
+    10: JONG_M, // ㄻ → ㅁ
+    14: JONG_B, 18: JONG_B, 26: JONG_B, // ㄿㅄㅍ → ㅂ
+};
+/** ㅎ과 만나 거센소리가 되는 짝. */
+const ASPIRATE = { [CHO_G]: CHO_K, [CHO_D]: CHO_T, [CHO_B]: CHO_P, [CHO_J]: CHO_CH };
+/** 된소리 짝. */
+const TENSE = { [CHO_G]: CHO_GG, [CHO_D]: CHO_DD, [CHO_B]: CHO_BB, [CHO_S]: CHO_SS, [CHO_J]: CHO_JJ };
+/**
+ * 겹받침 어간 뒤에서 어미 첫소리가 된소리가 되는 경우(표준발음법 제24·25항).
+ * ㄳ·ㄺ은 대표음이 ㄱ이라 일반 경음화 규칙에 이미 걸리므로 여기서 다루지 않는다.
+ */
+const TENSE_AFTER_CLUSTER = new Set([JONG_NJ, JONG_RM, JONG_RB, JONG_RS, JONG_RT, JONG_RH, JONG_BS]);
+/** ㄼ이 자음 앞에서 예외적으로 [ㅂ]이 되는 어간 — '밟-'(표준발음법 제10항 다만). */
+const RB_AS_B = new Set(['밟']);
+/**
+ * 표기를 표준발음에 가깝게 변환한다. 한글 음절이 아닌 문자가 섞여 있으면 원문을 그대로 돌려준다
+ * (숫자·영문·공백이 든 입력을 어설프게 건드리지 않기 위함).
+ *
+ * 단어 데이터의 SP 컬럼과는 표기 규약이 다르다. 그쪽은 청각 훈련용이라 ㅔ/ㅚ/ㅖ를
+ * ㅐ/ㅙ/ㅒ로 합쳐 적는데(되다→돼다 412건 대 8건으로 확립된 규약이다) 이 함수는
+ * 표준발음 그대로 둔다. 그래서 라이브 표본 173건 대조에서 64.7%만 일치했다.
+ *
+ * 지금 이 함수를 쓰는 곳은 두 군데뿐이고 둘 다 사람이 보고 고치는 입력 보조다 —
+ * 단어 제안 폼의 표준발음 자동 채움, 단어 관리의 새 단어 발음 제안. 훈련 문제
+ * 생성이나 검색에는 쓰이지 않는다. 규약을 맞추려 해도 파급은 그 둘뿐이지만,
+ * 모음 합치기는 '표준발음'이 아니라 이 데이터의 표기 규약이라 이름과 어긋난다 —
+ * 옵션으로 열지 별도 함수로 둘지는 정해야 한다.
+ * @public
+ */
+export function toStandardPronunciation(word) {
+    const trimmed = (word ?? '').trim();
+    if (!trimmed)
+        return '';
+    const chars = [...trimmed];
+    const parsed = chars.map(parseSyllable);
+    if (parsed.some(p => p === null))
+        return trimmed;
+    const s = parsed;
+    for (let i = 0; i < s.length; i++) {
+        const cur = s[i];
+        const next = s[i + 1];
+        const origJong = cur.jong;
+        // 마지막 음절 — 끝소리 규칙만 적용하고 끝낸다.
+        if (!next) {
+            cur.jong = JONG_REPRESENTATIVE[cur.jong] ?? cur.jong;
+            break;
+        }
+        if (cur.jong === JONG_NONE)
+            continue;
+        // ── (1) 뒤 음절이 모음으로 시작(초성 ㅇ) ──────────────────────────────
+        if (next.cho === CHO_NG) {
+            // 구개음화 — ㄷ/ㅌ 받침 + '이' (굳이 → 구지, 같이 → 가치, 핥이다 → 할치다)
+            if (next.jung === JUNG_I) {
+                if (cur.jong === JONG_D) {
+                    cur.jong = JONG_NONE;
+                    next.cho = CHO_J;
+                    continue;
+                }
+                if (cur.jong === 25) {
+                    cur.jong = JONG_NONE;
+                    next.cho = CHO_CH;
+                    continue;
+                }
+                if (cur.jong === JONG_RT) {
+                    cur.jong = JONG_R;
+                    next.cho = CHO_CH;
+                    continue;
+                }
+            }
+            // ㅎ 탈락 (좋아 → 조아)
+            if (cur.jong === JONG_H) {
+                cur.jong = JONG_NONE;
+                continue;
+            }
+            // ㅎ을 품은 겹받침 — ㅎ만 떨어지고 남은 자음이 연음 (많은 → 마는)
+            const hLink = H_CLUSTER_LINK[cur.jong];
+            if (hLink !== undefined) {
+                cur.jong = JONG_NONE;
+                next.cho = hLink;
+                continue;
+            }
+            // 겹받침 — 앞 자음은 남고 뒤 자음만 연음
+            const link = CLUSTER_LINK[cur.jong];
+            if (link) {
+                cur.jong = link[0];
+                next.cho = link[1];
+                continue;
+            }
+            // 홑받침 연음 (ㅇ 받침은 그대로 둔다: 강이 → 강이)
+            const cho = JONG_TO_CHO[cur.jong];
+            if (cho !== undefined) {
+                cur.jong = JONG_NONE;
+                next.cho = cho;
+            }
+            continue;
+        }
+        // ── (2) 거센소리되기 ────────────────────────────────────────────────
+        // 받침 ㅎ 계열 + ㄱㄷㅂㅈ (놓다 → 노타, 많다 → 만타, 옳다 → 올타)
+        if ((cur.jong === JONG_H || cur.jong === JONG_NH || cur.jong === JONG_RH) && ASPIRATE[next.cho] !== undefined) {
+            next.cho = ASPIRATE[next.cho];
+            cur.jong = cur.jong === JONG_NH ? JONG_N : cur.jong === JONG_RH ? JONG_R : JONG_NONE;
+            continue;
+        }
+        // 받침 ㄱㄷㅂㅈ 계열 + 초성 ㅎ (먹히다 → 머키다, 앉히다 → 안치다, 읽히다 → 일키다)
+        if (next.cho === CHO_H) {
+            if (cur.jong === JONG_NJ) {
+                cur.jong = JONG_N;
+                next.cho = CHO_CH;
+                continue;
+            }
+            if (cur.jong === JONG_RG) {
+                cur.jong = JONG_R;
+                next.cho = CHO_K;
+                continue;
+            }
+            if (cur.jong === JONG_RB) {
+                cur.jong = JONG_R;
+                next.cho = CHO_P;
+                continue;
+            }
+            const rep = JONG_REPRESENTATIVE[cur.jong] ?? cur.jong;
+            if (rep === JONG_G) {
+                cur.jong = JONG_NONE;
+                next.cho = CHO_K;
+                continue;
+            }
+            if (rep === JONG_D) {
+                cur.jong = JONG_NONE;
+                next.cho = CHO_T;
+                continue;
+            }
+            if (rep === JONG_B) {
+                cur.jong = JONG_NONE;
+                next.cho = CHO_P;
+                continue;
+            }
+        }
+        // ── (3) 자음 앞 — 끝소리 규칙(겹받침 단순화 포함) ────────────────────
+        let rep = JONG_REPRESENTATIVE[cur.jong] ?? cur.jong;
+        if (origJong === JONG_RB && RB_AS_B.has(chars[i]))
+            rep = JONG_B; // 밟다 → 밥따
+        cur.jong = rep;
+        // ── (4) 된소리되기 ──────────────────────────────────────────────────
+        if (TENSE[next.cho] !== undefined &&
+            (rep === JONG_G || rep === JONG_D || rep === JONG_B || TENSE_AFTER_CLUSTER.has(origJong))) {
+            next.cho = TENSE[next.cho];
+        }
+        // ── (5) 비음되기 — ㄱㄷㅂ + ㄴㅁ (국물 → 궁물, 받는 → 반는, 밥물 → 밤물) ──
+        if (next.cho === CHO_N || next.cho === CHO_M) {
+            if (cur.jong === JONG_G)
+                cur.jong = JONG_NG;
+            else if (cur.jong === JONG_D)
+                cur.jong = JONG_N;
+            else if (cur.jong === JONG_B)
+                cur.jong = JONG_M;
+        }
+        // ── (6) ㄹ이 얽힌 변동 ──────────────────────────────────────────────
+        if (next.cho === CHO_R) {
+            if (cur.jong === JONG_N)
+                cur.jong = JONG_R; // 신라 → 실라(유음화)
+            else if (cur.jong === JONG_M || cur.jong === JONG_NG)
+                next.cho = CHO_N; // 침략 → 침냑
+            else if (cur.jong === JONG_G) {
+                cur.jong = JONG_NG;
+                next.cho = CHO_N;
+            } // 독립 → 동닙
+            else if (cur.jong === JONG_B) {
+                cur.jong = JONG_M;
+                next.cho = CHO_N;
+            } // 협력 → 혐녁
+        }
+        else if (cur.jong === JONG_R && next.cho === CHO_N) {
+            next.cho = CHO_R; // 설날 → 설랄(유음화)
+        }
+    }
+    return s.map(x => composeSyllable(x.cho, x.jung, x.jong)).join('');
+}