@ihabdevteam/core 0.322.0 → 0.323.0

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

@@ -1,11 +1,11 @@
 /* 목소리 목록을 기다리는 말 — 하나만 둔다. 전에는 기다리는 리스너가 부를 때마다 줄을 서고 stopSpeaking 이 치우지 못해,
    `speak('하나'); speak('둘'); stopSpeaking()` 뒤 목소리가 뜨는 순간 멈췄던 말이 모두 나왔다. */
-let 기다림 = null;
+let pendingWait = null;
 /** voiceschanged 가 끝내 안 오는 환경(목소리 없음)에서도 말은 건다 — 안 그러면 onEnd 가 영영 안 불렸다 */
-const 목소리기다림MS = 1500;
-function 기다림치우기() {
-    기다림?.치우기();
-    기다림 = null;
+const VOICE_WAIT_MS = 1500;
+function clearPendingWait() {
+    pendingWait?.clear();
+    pendingWait = null;
 }
 /** @public */
 export function speak(text, { onEnd, rate = 0.9 } = {}) {
@@ -14,9 +14,9 @@ export function speak(text, { onEnd, rate = 0.9 } = {}) {
         return;
     }
     const synth = window.speechSynthesis;
-    기다림치우기();
+    clearPendingWait();
     const doSpeak = () => {
-        기다림치우기();
+        clearPendingWait();
         synth.cancel();
         const u = new SpeechSynthesisUtterance(text);
         const voices = synth.getVoices();
@@ -47,18 +47,18 @@ export function speak(text, { onEnd, rate = 0.9 } = {}) {
         doSpeak();
         return;
     }
-    const 시계 = setTimeout(doSpeak, 목소리기다림MS);
+    const timer = setTimeout(doSpeak, VOICE_WAIT_MS);
     synth.addEventListener('voiceschanged', doSpeak, { once: true });
-    기다림 = {
-        치우기: () => {
-            clearTimeout(시계);
+    pendingWait = {
+        clear: () => {
+            clearTimeout(timer);
             synth.removeEventListener('voiceschanged', doSpeak);
         },
     };
 }
 /** @public */
 export function stopSpeaking() {
-    기다림치우기();
+    clearPendingWait();
     if (typeof window !== 'undefined' && 'speechSynthesis' in window)
         window.speechSynthesis.cancel();
 }

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

@@ -14,16 +14,6 @@ export declare function compareKorean(a: string, b: string): number;
  * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
  */
 export declare function compareCell(a: unknown, b: unknown): number;
-/**
- * @deprecated **`compareCell` 을 쓴다 — 같은 함수다.**
- *
- * 2026-10-13 공개 이름을 영어로 옮기며(사장님 지시) 옛 이름을 남겼다. 말귀가
- * `import { 칸순 } from '@ihabdevteam/core/utils/textSort'` 를 **다섯 줄**에서
- * 쓰고 있어 한 번에 걷으면 그쪽이 통째로 빨개진다. 옮긴 뒤 알려 주면 걷는다.
- *
- * 같은 꼴로 남겨 둔 것이 또 있다 — `useTableSort()` 의 `정렬`·`칸`.
- */
-export declare const 칸순: typeof compareCell;
 /**
  * 표 정렬 한 번의 비교 — compareCell에 방향을 입히되 **빈 값은 오름·내림 모두 맨 뒤.**
  * 방향을 `-compareCell` 으로 뒤집기만 하면 빈 값이 오름차순 맨 앞·내림차순 맨 뒤로 오가, 표마다 빈 줄이 다른 끝에 섰다.

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

@@ -10,44 +10,44 @@
  *
  * 콜레이터는 만드는 값이 비싸다 — 한 번만 만들어 쓴다.
  */
-const 콜레이터 = (() => {
-    let 것 = null;
+const collator = (() => {
+    let it = null;
     return () => {
-        if (!것)
-            것 = new Intl.Collator('ko');
-        return 것;
+        if (!it)
+            it = new Intl.Collator('ko');
+        return it;
     };
 })();
 /** 글자 둘을 한국어 차례로 견준다 */
 export function compareKorean(a, b) {
-    return 콜레이터().compare(a, b);
+    return collator().compare(a, b);
 }
-const 조각열쇠 = new Map();
-function 조각내기(s) {
-    const 있음 = 조각열쇠.get(s);
-    if (있음)
-        return 있음;
+const pieceCache = new Map();
+function toPieces(s) {
+    const hit = pieceCache.get(s);
+    if (hit)
+        return hit;
     const out = [];
     // 뒤돌아보기(?<=) 는 iOS 15 Safari 가 못 읽어 모듈째 깨지므로 쓰지 않는다 — 빼기표 앞 글자를 손으로 본다
     const re = /-?\d+(?:\.\d+)?/g;
-    let 끝 = 0;
+    let end = 0;
     for (let m = re.exec(s); m; m = re.exec(s)) {
-        let 시작 = m.index;
-        let 수 = m[0];
-        if (수[0] === '-' && 시작 > 0 && !/\s/.test(s[시작 - 1])) {
-            시작 += 1;
-            수 = 수.slice(1);
+        let start = m.index;
+        let numText = m[0];
+        if (numText[0] === '-' && start > 0 && !/\s/.test(s[start - 1])) {
+            start += 1;
+            numText = numText.slice(1);
         }
-        if (시작 > 끝)
-            out.push(s.slice(끝, 시작));
-        out.push(Number(수));
-        끝 = m.index + m[0].length;
+        if (start > end)
+            out.push(s.slice(end, start));
+        out.push(Number(numText));
+        end = m.index + m[0].length;
     }
-    if (끝 < s.length)
-        out.push(s.slice(끝));
-    if (조각열쇠.size > 5000)
-        조각열쇠.clear();
-    조각열쇠.set(s, out);
+    if (end < s.length)
+        out.push(s.slice(end));
+    if (pieceCache.size > 5000)
+        pieceCache.clear();
+    pieceCache.set(s, out);
     return out;
 }
 /* **전화번호 꼴**(숫자·하이픈·빈칸만, 숫자 9–11자리, 0 으로 시작 — 1 로 시작하면 하이픈·빈칸이 있을 때만)은 숫자만 뽑은 **글자 조각 하나**가 열쇠다.
@@ -55,14 +55,14 @@ function 조각내기(s) {
    '010-…' 뒤에 서서, 같은 번호가 하이픈 유무로 표의 다른 자리로 갔다.
    두 값이 모두 전화 꼴이면 숫자 글자끼리 견주는 셈이 된다. 한쪽만 전화 꼴일 때도 **값마다 열쇠가 하나로 정해져** 있어야
    차례가 돌지 않는다(값 쌍마다 규칙을 고르면 A<B<C<A 가 생긴다) — 글자 조각이라 수 조각 뒤, 다른 글자와는 한국어 차례. */
-function 전화열쇠(s) {
+function phoneKey(s) {
     if (!/^[\d\s-]+$/.test(s))
         return null;
-    const 숫자 = s.replace(/\D/g, '');
-    if (숫자.length < 9 || 숫자.length > 11)
+    const digits = s.replace(/\D/g, '');
+    if (digits.length < 9 || digits.length > 11)
         return null;
     // 0 으로 시작하면 전화. 1 로 시작하면 하이픈·빈칸이 있을 때만 — 하이픈 없는 '1234567890' 같은 번호 ID 는 수로 둔다
-    return 숫자[0] === '0' || (숫자[0] === '1' && s !== 숫자) ? 숫자 : null;
+    return digits[0] === '0' || (digits[0] === '1' && s !== digits) ? digits : null;
 }
 /**
  * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 글자 속 숫자도 수로.**
@@ -78,18 +78,18 @@ function 전화열쇠(s) {
  * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
  */
 export function compareCell(a, b) {
-    const 글 = (v) => (v == null || (typeof v === 'number' && Number.isNaN(v)) ? '' : String(v).trim());
-    const sa = 글(a), sb = 글(b);
+    const text = (v) => (v == null || (typeof v === 'number' && Number.isNaN(v)) ? '' : String(v).trim());
+    const sa = text(a), sb = text(b);
     if (sa === sb)
         return 0;
     /* 수(number)는 글로 바꿔 쪼개지 않고 **수 조각 하나** 로 — '1e+21'·'1e-7' 로 쪼개면 1e21 이 5 앞에, -Infinity 가 끝에 섰다 */
-    const 열쇠 = (v, s) => {
+    const keyOf = (v, s) => {
         if (typeof v === 'number' && !Number.isNaN(v))
             return [v];
-        const 전화 = 전화열쇠(s);
-        return 전화 !== null ? [전화] : 조각내기(s);
+        const phone = phoneKey(s);
+        return phone !== null ? [phone] : toPieces(s);
     };
-    const ka = 열쇠(a, sa), kb = 열쇠(b, sb);
+    const ka = keyOf(a, sa), kb = keyOf(b, sb);
     const n = Math.min(ka.length, kb.length);
     for (let i = 0; i < n; i++) {
         const x = ka[i], y = kb[i];
@@ -110,25 +110,15 @@ export function compareCell(a, b) {
         return ka.length - kb.length;
     return compareKorean(sa, sb);
 }
-/**
- * @deprecated **`compareCell` 을 쓴다 — 같은 함수다.**
- *
- * 2026-10-13 공개 이름을 영어로 옮기며(사장님 지시) 옛 이름을 남겼다. 말귀가
- * `import { 칸순 } from '@ihabdevteam/core/utils/textSort'` 를 **다섯 줄**에서
- * 쓰고 있어 한 번에 걷으면 그쪽이 통째로 빨개진다. 옮긴 뒤 알려 주면 걷는다.
- *
- * 같은 꼴로 남겨 둔 것이 또 있다 — `useTableSort()` 의 `정렬`·`칸`.
- */
-export const 칸순 = compareCell;
 /* 빈 값 — null·undefined·NaN·빈 글자(빈칸만 있는 글자 포함). compareCell이 '' 로 보는 것과 같은 범위. */
-const 빈칸값 = (v) => v == null || (typeof v === 'number' && Number.isNaN(v)) || (typeof v === 'string' && v.trim() === '');
+const isBlank = (v) => v == null || (typeof v === 'number' && Number.isNaN(v)) || (typeof v === 'string' && v.trim() === '');
 /**
  * 표 정렬 한 번의 비교 — compareCell에 방향을 입히되 **빈 값은 오름·내림 모두 맨 뒤.**
  * 방향을 `-compareCell` 으로 뒤집기만 하면 빈 값이 오름차순 맨 앞·내림차순 맨 뒤로 오가, 표마다 빈 줄이 다른 끝에 섰다.
  * ListPopup 과 useTableSort().sortRows 가 함께 쓴다.
  */
 export function compareCellBlankLast(a, b, asc) {
-    const ea = 빈칸값(a), eb = 빈칸값(b);
+    const ea = isBlank(a), eb = isBlank(b);
     if (ea || eb)
         return ea === eb ? 0 : ea ? 1 : -1;
     const c = compareCell(a, b);

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

@@ -18,10 +18,10 @@ export function getSavedTheme() {
 export function applyTheme(mode) {
     /* 세 값만 받는다 — 설정은 서버(JSON)에서 오기도 해서 타입만 믿고 그대로 박으면, 이 속성을 글자로 옮겨 짓는 인쇄 문서에
        `"><script>` 가 끼어들었다. 모르는 값은 기본(light)으로. */
-    const 값 = mode === 'light' || mode === 'dark' || mode === 'auto' ? mode : DEFAULT_THEME;
+    const value = mode === 'light' || mode === 'dark' || mode === 'auto' ? mode : DEFAULT_THEME;
     try {
-        document.documentElement.setAttribute('data-theme', 값);
-        localStorage.setItem(STORAGE_KEY, 값);
+        document.documentElement.setAttribute('data-theme', value);
+        localStorage.setItem(STORAGE_KEY, value);
     }
     catch { }
 }

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

@@ -24,7 +24,7 @@
  * 여기서 멋대로 UTC 로 돌리면 그 뜻이 깎인다. 읽히는지만 보고 **그대로** 둔다.
  * `Date`·숫자(epoch)로 오면 그때는 쓸 글자가 없으니 ISO 로 짓는다.
  */
-function 때(v) {
+function timeOf(v) {
     if (typeof v === 'string') {
         const s = v.trim();
         if (!s)
@@ -87,8 +87,8 @@ export function toItemResults(raw) {
             correct: itemCorrectness(r),
             /* 칸 이름은 **camelCase 와 snake_case 둘 다** 본다 — 화면이 서버 꼴(`shown_at`)을 그대로
                들고 있는 자리가 있다. 이름이 하나라고 믿었다가 조용히 떨어뜨리는 것이 이 청의 뿌리다. */
-            shownAt: 때(r.shownAt) ?? 때(r.shown_at),
-            answeredAt: 때(r.answeredAt) ?? 때(r.answered_at),
+            shownAt: timeOf(r.shownAt) ?? timeOf(r.shown_at),
+            answeredAt: timeOf(r.answeredAt) ?? timeOf(r.answered_at),
         };
     });
 }

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

@@ -80,13 +80,13 @@ export async function checkAudioExists(word) {
     // 한 번의 통신 끊김·서버 장애가 그 단어를 세션 내내 '음성 없음'으로 고정해, '음성 있음' 필터에서
     // 통째로 빠진다. 실패는 지워서 다음 호출이 다시 물어보게 한다 — 단 **이 요청이 담은 칸일 때만**:
     // clearAudioExistsCache() 뒤 새로 담긴 확인을 늦게 끝난 옛 요청이 지우면 같은 주소를 또 묻는다.
-    const 확인안됨 = () => {
+    const onUnconfirmed = () => {
         if (audioExistsCache.get(url) === promise)
             audioExistsCache.delete(url);
         return false;
     };
     const promise = fetch(url, { method: 'HEAD', signal: timeoutSignal(8000) })
-        .then(res => (res.status >= 500 ? 확인안됨() : res.ok), 확인안됨);
+        .then(res => (res.status >= 500 ? onUnconfirmed() : res.ok), onUnconfirmed);
     audioExistsCache.set(url, promise);
     return promise;
 }

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

@@ -36,7 +36,7 @@ export function isBlankGrade(grade) {
 }
 /** 등급 코드인가 — `'1'`~`'4'`·`'none'`. 저장된 값을 되읽을 때 **아닌 것은 버린다**(한때 `''` 가 저장됐다). */
 export function isGradeCode(v) {
-    return typeof v === 'string' && 등급값.includes(v);
+    return typeof v === 'string' && gradeValues.includes(v);
 }
 /**
  * **등급 코드 집합으로 단어 하나를 거른다 — 이 결정은 여기 하나다.**
@@ -59,42 +59,42 @@ export function matchesGradeCodes(codes, grade) {
         return set.has(GRADE_NONE);
     return set.has(String(grade));
 }
-const 섹션들 = ['grade', 'syllables', 'pos', 'wordType'];
+const sectionCodes = ['grade', 'syllables', 'pos', 'wordType'];
 /** 등급 코드 — `'none'` 은 **등급이 빈 단어**다(값이 아니라 **빔**이다. GRADE_NONE 주석을 볼 것) */
-const 등급값 = ['1', '2', '3', '4', 'none'];
-const 음절값 = ['1', '2', '3', '4', '5+'];
-const 품사값 = ['noun', 'verb', 'modifier'];
-const 어종값 = ['native', 'sino', 'foreign', 'mixed'];
-const 코드값 = { grade: 등급값, syllables: 음절값, pos: 품사값, wordType: 어종값 };
+const gradeValues = ['1', '2', '3', '4', 'none'];
+const syllableValues = ['1', '2', '3', '4', '5+'];
+const posValues = ['noun', 'verb', 'modifier'];
+const wordTypeValues = ['native', 'sino', 'foreign', 'mixed'];
+const valuesBySection = { grade: gradeValues, syllables: syllableValues, pos: posValues, wordType: wordTypeValues };
 /** 품사 코드 → 사전 품사 약자(단어의 pos 에 들어 있는지 본다) · 어종 코드 → 사전 어종 값 */
 export const POS_CODE_TARGETS = { noun: ['명', '수'], verb: ['동', '형'], modifier: ['부', '관'] };
 export const WORD_TYPE_CODE_VALUES = { native: '고유', sino: '한자', foreign: '외래', mixed: '혼종' };
 /* 사전 밖의 옛 라벨 — phonemePairSearch 의 DEFAULT_PAIR_FILTER_KEYS 가 쓰던 것(쉼표 뒤 빈칸 없음·'난이도 등급') */
-const 옛섹션 = { grade: ['난이도 등급'] };
-const 옛값 = {
+const legacySectionLabels = { grade: ['난이도 등급'] };
+const legacyValueLabels = {
     pos: { noun: ['체언(명사,수사)'], verb: ['용언(동사,형용사)'], modifier: ['수식언(부사,관형사)'] },
 };
 /* 언어마다 한 번 만든다 — matchesFilters 는 낱말(2만여 개)마다 불린다. 사전이 더해지면(addResourceBundle) 비운다 */
-const 사전들 = new Map();
+const dictCache = new Map();
 try {
-    i18n.store?.on?.('added', () => 사전들.clear());
+    i18n.store?.on?.('added', () => dictCache.clear());
 }
 catch { /* 없는 환경 */ }
-function 사전(lng) {
-    const 있음 = 사전들.get(lng);
-    if (있음)
-        return 있음;
+function dictFor(lng) {
+    const hit = dictCache.get(lng);
+    if (hit)
+        return hit;
     const t = i18n.getFixedT(lng);
     const d = {
-        섹션: {
+        section: {
             grade: t('wordSearch.filter.difficulty', '등급'),
             syllables: t('wordSearch.filter.syllables', '음절 수'),
             pos: t('wordSearch.filter.partOfSpeech', '품사'),
             wordType: t('wordSearch.filter.wordType', '유형'),
         },
-        값: {
+        value: {
             grade: {
-                ...Object.fromEntries(등급값.filter(n => n !== GRADE_NONE).map((n) => [n, t('wordSearch.filter.grade', { n: Number(n), defaultValue: `${n}등급` })])),
+                ...Object.fromEntries(gradeValues.filter(n => n !== GRADE_NONE).map((n) => [n, t('wordSearch.filter.grade', { n: Number(n), defaultValue: `${n}등급` })])),
                 /* **`없음` 은 숫자 틀을 안 쓴다** — `t('…grade', { n: Number('none') })` 은 `NaN등급` 이 된다 */
                 [GRADE_NONE]: t('wordSearch.filter.gradeNone', '없음'),
             },
@@ -115,36 +115,36 @@ function 사전(lng) {
             },
         },
     };
-    사전들.set(lng, d);
+    dictCache.set(lng, d);
     return d;
 }
-const 언어들 = () => Array.from(new Set([i18n.language, 'ko', 'en'].filter((x) => !!x)));
+const languages = () => Array.from(new Set([i18n.language, 'ko', 'en'].filter((x) => !!x)));
 /** 섹션 라벨(어느 언어든·옛 라벨·코드) → 섹션 코드. 속성 섹션이 아니면 null. */
 export function wordAttributeSectionOf(label) {
-    if (섹션들.includes(label))
+    if (sectionCodes.includes(label))
         return label;
-    for (const lng of 언어들()) {
-        const d = 사전(lng);
-        for (const s of 섹션들)
-            if (d.섹션[s] === label)
+    for (const lng of languages()) {
+        const d = dictFor(lng);
+        for (const s of sectionCodes)
+            if (d.section[s] === label)
                 return s;
     }
-    for (const s of 섹션들)
-        if (옛섹션[s]?.includes(label))
+    for (const s of sectionCodes)
+        if (legacySectionLabels[s]?.includes(label))
             return s;
     return null;
 }
 /** 한 섹션의 값(코드·어느 언어 라벨·옛 라벨) → 값 코드. 못 읽으면 null. */
 export function wordAttributeValueCodeOf(section, value) {
-    if (코드값[section].includes(value))
+    if (valuesBySection[section].includes(value))
         return value;
-    for (const lng of 언어들()) {
-        const 표 = 사전(lng).값[section];
-        for (const [code, label] of Object.entries(표))
+    for (const lng of languages()) {
+        const table = dictFor(lng).value[section];
+        for (const [code, label] of Object.entries(table))
             if (label === value)
                 return code;
     }
-    for (const [code, labels] of Object.entries(옛값[section] ?? {}))
+    for (const [code, labels] of Object.entries(legacyValueLabels[section] ?? {}))
         if (labels.includes(value))
             return code;
     /* 등급·음절은 숫자로도 읽는다('Grade 3'·'3등급'·'6음절') — 사전에 없는 꼴이 와도 풀리지 않게 */
@@ -160,9 +160,9 @@ export function wordAttributeValueCodeOf(section, value) {
 }
 /** 코드 → 지금 언어의 라벨. `'none'` 도 사전 꼴로 나온다(숫자 틀 `{{n}}등급` 에 넣으면 `NaN등급` 이 된다). 모르는 코드는 그대로. */
 export function wordAttributeValueLabelOf(section, code, lng = i18n.language) {
-    return 사전(lng).값[section][code] ?? code;
+    return dictFor(lng).value[section][code] ?? code;
 }
-const 배열로 = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : typeof v === 'string' && v ? [v] : []);
+const toArray = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : typeof v === 'string' && v ? [v] : []);
 /**
  * @public filterSelected(라벨 열쇠·라벨 값, 어느 언어든 섞여 있어도) → **코드 모양**. 저장할 때 쓴다.
  * 속성 섹션(등급·음절 수·품사·어종)만 담고, 그 밖의 섹션(초성·선택·단어 입력 등)은 뺀다. 못 읽는 값은 버린다.
@@ -173,7 +173,7 @@ export function toWordAttributeFilterCodes(selected) {
         const s = wordAttributeSectionOf(k);
         if (!s)
             continue;
-        for (const raw of 배열로(v)) {
+        for (const raw of toArray(v)) {
             const c = wordAttributeValueCodeOf(s, raw);
             if (!c)
                 continue;
@@ -188,12 +188,12 @@ export function toWordAttributeFilterCodes(selected) {
  * @public 코드 모양 → 지정한 언어(기본: 지금 i18n 언어)의 **라벨 filterSelected**. FilterPanel 의 selected 로 그대로 쓴다.
  */
 export function wordAttributeFilterFromCodes(codes, lng = i18n.language) {
-    const d = 사전(lng || 'ko');
+    const d = dictFor(lng || 'ko');
     const out = {};
-    for (const s of 섹션들) {
-        const labels = (codes?.[s] ?? []).map((c) => d.값[s][c]).filter((x) => !!x);
+    for (const s of sectionCodes) {
+        const labels = (codes?.[s] ?? []).map((c) => d.value[s][c]).filter((x) => !!x);
         if (labels.length)
-            out[d.섹션[s]] = labels;
+            out[d.section[s]] = labels;
     }
     return out;
 }
@@ -203,17 +203,17 @@ export function wordAttributeFilterFromCodes(codes, lng = i18n.language) {
  * 들어 있으면 합친다.
  */
 export function normalizeWordAttributeFilter(selected, lng = i18n.language) {
-    const 남김 = {};
+    const kept = {};
     for (const [k, v] of Object.entries(selected ?? {}))
         if (!wordAttributeSectionOf(k))
-            남김[k] = v;
-    return { ...남김, ...wordAttributeFilterFromCodes(toWordAttributeFilterCodes(selected), lng) };
+            kept[k] = v;
+    return { ...kept, ...wordAttributeFilterFromCodes(toWordAttributeFilterCodes(selected), lng) };
 }
 /** 라벨이 어느 언어의 섹션 라벨인가 — 토글이 그 언어로 값을 적게 */
 export function wordAttributeLabelLanguageOf(label) {
-    for (const lng of 언어들()) {
-        const d = 사전(lng);
-        if (섹션들.some((s) => d.섹션[s] === label))
+    for (const lng of languages()) {
+        const d = dictFor(lng);
+        if (sectionCodes.some((s) => d.section[s] === label))
             return lng;
     }
     return i18n.language || 'ko';

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

@@ -147,10 +147,10 @@ position) {
             else if (position === 'tail')
                 i = matchesAt(pw, L - 1) ? L - 1 : -1;
             else if (position === 'mid') {
-                const 처음 = selParts.includes('cho') ? 1 : 0; // 첫 초성은 어두다
-                const 마지막 = selParts.includes('jong') ? L - 2 : L - 1; // 마지막 받침은 어말이다
+                const first = selParts.includes('cho') ? 1 : 0; // 첫 초성은 어두다
+                const last = selParts.includes('jong') ? L - 2 : L - 1; // 마지막 받침은 어말이다
                 i = -1;
-                for (let k = 처음; k <= 마지막; k++)
+                for (let k = first; k <= last; k++)
                     if (matchesAt(pw, k)) {
                         i = k;
                         break;

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

@@ -145,7 +145,7 @@ async function buildIndexAsync(items, onProgress) {
     return result;
 }
 /** 캐시를 비우거나 새 빌드를 시작할 때 오른다 — 늦게 끝난 옛 빌드가 캐시에 쓰지 못하게 */
-let 빌드세대 = 0;
+let buildGeneration = 0;
 /**
  * @public
  * 단어 리스트로부터 대립쌍 인덱스를 빌드 (또는 캐시된 결과 반환).
@@ -166,9 +166,9 @@ export async function buildPairIndex(items, options = {}) {
     }
     /* 세대가 그대로일 때만 캐시에 담는다 — 빌드 중 clearPairIndexCache() 가 불렸거나 더 새 빌드가 시작됐으면, 늦게 끝난 옛
        빌드가 방금 지운 캐시를 되살리거나 새 인덱스를 옛 것으로 덮었다. 부른 쪽에는 만든 것을 그대로 돌려준다. */
-    const 내세대 = ++빌드세대;
+    const myGeneration = ++buildGeneration;
     const built = await buildIndexAsync(items, options.onProgress);
-    if (내세대 === 빌드세대) {
+    if (myGeneration === buildGeneration) {
         memIndex = built;
         memSig = sig;
         saveToLocalStorage(built, sig);
@@ -189,7 +189,7 @@ export function getPairIndex() {
 }
 /** @public 캐시 초기화 */
 export function clearPairIndexCache() {
-    빌드세대 += 1;
+    buildGeneration += 1;
     memIndex = null;
     memSig = null;
     try {

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

@@ -141,14 +141,14 @@ export function getChangeCardTitle(typeKey, item) {
         if (change) {
             // 1음절: "옆"에서 … / 2음절: "사과"의 "과"에서 …  ('더하면'은 에서 대신 에)
             const head = one ? `"${word}"` : `"${word}"의 "${from}"`;
-            const 곳 = change.kind === 'add' ? '에' : '에서';
+            const particle = change.kind === 'add' ? '에' : '에서';
             const f = `"${change.from}"${josaEulReul(josaBaseOf(change.from))}`;
             const t = `"${change.to}"${josaEuRo(josaBaseOf(change.to))}`;
             if (change.kind === 'add')
-                return `${head}${곳} 받침 "${change.to}"${josaEulReul(josaBaseOf(change.to))} 더하면 무엇이 되나요?`;
+                return `${head}${particle} 받침 "${change.to}"${josaEulReul(josaBaseOf(change.to))} 더하면 무엇이 되나요?`;
             if (change.kind === 'remove')
-                return `${head}${곳} 받침 ${f} 빼면 무엇이 되나요?`;
-            return `${head}${곳} ${PART_LABEL[change.part]} ${f} ${t} 바꾸면 무엇이 되나요?`;
+                return `${head}${particle} 받침 ${f} 빼면 무엇이 되나요?`;
+            return `${head}${particle} ${PART_LABEL[change.part]} ${f} ${t} 바꾸면 무엇이 되나요?`;
         }
     }
     if (typeKey === 'CHANGE_1_PHONEME_IN_1SYLL') {

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

@@ -417,12 +417,12 @@ async function _buildUsablePool(opts) {
     let posContrastMap = null;
     if (posContrast) {
         const mapKey = _posContrastCacheKey(opts);
-        const 이미지집합 = excludeNoImage ? getImageOkWordSet() : null;
-        const 전 = _posContrastCache.get(mapKey);
-        posContrastMap = 전 && 전.이미지집합 === 이미지집합
-            ? 전.map
+        const imageOkSet = excludeNoImage ? getImageOkWordSet() : null;
+        const cached = _posContrastCache.get(mapKey);
+        posContrastMap = cached && cached.imageOkSet === imageOkSet
+            ? cached.map
             : buildMultiPartPosContrast(composition, allOkArr, decompOf, sameStructureOnly, phonemeView, pronOfWord);
-        _posContrastCache.set(mapKey, { 이미지집합, map: posContrastMap });
+        _posContrastCache.set(mapKey, { imageOkSet, map: posContrastMap });
     }
     // candidates 크기 제한 — 이미지 필터 이후이므로 okCandidates 기반
     const RANDOM_CAND_CAP = 500; // random: classifyPairDifficulty 없으나 루프 자체 제한
@@ -471,28 +471,28 @@ async function _buildUsablePool(opts) {
         else if (useRandomPool) {
             // 'random' 또는 null(difficulty:false 타입): 음운론적 제약은 없지만,
             // 정답과 오답의 음절수는 같아야 한다(단어 길이만으로 정답을 짐작하지 못하도록) — 본 단어와 다른 단어 + 음절수(글자수) 동일
-            const 쓸수있음 = (other) => other !== w.w && other.length === w.w.length && pronOfWord(other) !== wPron;
+            const canUse = (other) => other !== w.w && other.length === w.w.length && pronOfWord(other) !== wPron;
             /* 셈(fullCount — 가능 단어 수 안내)은 **서로 소리가 다른 오답이 보기 수 − 1 개** 있는지까지만 본다(countUsableWords 가 그
                기준으로 센다). 2.2만 후보마다 600개를 끝까지 걸러 칩 한 번에 300ms 넘게 멈췄다. */
             if (opts.fullCount) {
                 const need = Math.max(1, (opts.choicesPerItem ?? 3) - 1);
-                const 고름 = [];
-                const 소리 = new Set();
+                const picked = [];
+                const prons = new Set();
                 for (const other of distractorPool) {
-                    if (!쓸수있음(other))
+                    if (!canUse(other))
                         continue;
                     const p = pronOfWord(other);
-                    if (소리.has(p))
+                    if (prons.has(p))
                         continue;
-                    소리.add(p);
-                    고름.push(other);
-                    if (고름.length >= need)
+                    prons.add(p);
+                    picked.push(other);
+                    if (picked.length >= need)
                         break;
                 }
-                usable = 고름;
+                usable = picked;
             }
             else
-                usable = distractorPool.filter(쓸수있음);
+                usable = distractorPool.filter(canUse);
         }
         else {
             // cho/jung/jong: 발음 기반 pairIndex에서 해당 종류 대립쌍 조회(공용 엔진). 구조 필터는 후처리에서 일괄.

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

@@ -73,10 +73,10 @@ async function genIncluded(opts) {
         const syllables = [...pron]; // 한 글자 = 한 음절
         /* 음소를 골랐으면 **그 음소를 가진 음절**을 들려준다 — 전에는 아무 음절이나 골라 초성 ㄱ 을 골라도 '가방' 의 '방' 을
            들려주었다(고른 음소와 무관한 훈련). 들리는 음절(발음)에 그 음소가 없으면 전처럼 아무 음절. */
-        const 고른음절 = comp && primarySelPart(comp)
+        const pickedPart = comp && primarySelPart(comp)
             ? syllables.filter(s => { const p = parseSyllable(s); return !!p && syllMatchesComp(p, comp); })
             : [];
-        const targetSyllable = pickOne(고른음절.length ? 고른음절 : syllables);
+        const targetSyllable = pickOne(pickedPart.length ? pickedPart : syllables);
         if (!targetSyllable)
             continue;
         // 오답: targetSyllable이 발음에 포함되지 않고, 정답과 음절수(글자수)가 같으며, 발음이 다른 단어.
@@ -357,7 +357,7 @@ async function genMerge3Syll(opts) {
 }
 /* 탈락 문제의 '실단어' 집합 — '이미지 있는 단어만' 이면 이미지 있는 낱말로. 전에는 늘 전체 낱말이라, 이미지만 켠(앱 기본) 탈락 카드의
    정답·오답이 이미지 없는 낱말(관상 → 상·땅·탕)로 나와 글자를 숨긴 카드가 빈칸이 됐다. 음절 바꾸기와 같은 방식. */
-function 탈락낱말집합(opts) {
+function droppedWordSet(opts) {
     const all = MVP.map(w => w.w);
     return opts.excludeNoImage ? filterByCachedImage(all) : new Set(all);
 }
@@ -368,7 +368,7 @@ async function genDrop1From2Syll(opts) {
     // 편집기와 동일한 대립쌍 오답을 item에 심는다(공유 코어 buildDropContrastProblem).
     // 러너(WordManipulationTrainingPagePopup)가 preset distractors를 그대로 쓰므로 자동생성도 편집기 품질이 된다.
     const pronMap = getPronMap();
-    const wordSet = 탈락낱말집합(opts);
+    const wordSet = droppedWordSet(opts);
     const phonemeView = opts.phonemeView ?? 'char';
     const out = [];
     for (const e of shuffle(pool)) {
@@ -398,7 +398,7 @@ async function genDrop1From3Syll(opts) {
     const pool = (await buildUsablePool({ ...opts })).filter(e => e.word.s === 3);
     // 편집기와 동일한 대립쌍 오답을 item에 심는다(공유 코어 buildDropContrast3Problem).
     const pronMap = getPronMap();
-    const wordSet = 탈락낱말집합(opts);
+    const wordSet = droppedWordSet(opts);
     const phonemeView = opts.phonemeView ?? 'char';
     const out = [];
     for (const e of shuffle(pool)) {
@@ -436,7 +436,7 @@ async function genDropCompound(opts) {
     // 2음절 낱말은 1음절 조각 둘로만 나뉘어 합성어가 될 수 없다(buildDropCompoundProblem) — 3음절부터
     const pool = (await buildUsablePool({ ...opts })).filter(e => e.word.s >= 3);
     const pronMap = getPronMap();
-    const wordSet = 탈락낱말집합(opts);
+    const wordSet = droppedWordSet(opts);
     const phonemeView = opts.phonemeView ?? 'char';
     const out = [];
     for (const e of shuffle(pool)) {

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

@@ -4,7 +4,7 @@
  * 타입은 문자열이지만 서버에서는 **월·일이 null 로 오기도 한다**(연도만 적은 옛 기록). 그대로 끼우면 화면에
  * `2026.null.null` 이 찍혔고, 정렬 열쇠를 만들 때는 `null.padStart` 에서 표가 통째로 터졌다. 빈 값은 '' 로 다룬다.
  */
-type 칸값 = string | number | null | undefined;
+type CellValue = string | number | null | undefined;
 /**
  * 화면에 적을 착용일.
  *
@@ -18,7 +18,7 @@ type 칸값 = string | number | null | undefined;
  * `lang` 을 안 주면 **예전 그대로** 점 꼴이다(`2026.09.09`) — 부르는 자리가 말을 모르는 곳도 있을
  * 수 있어 깨지지 않게 둔다. 화면에 그리는 자리는 주는 쪽이 맞다.
  */
-export declare function formatWornDate(year: 칸값, month: 칸값, day: 칸값, lang?: string): string;
+export declare function formatWornDate(year: CellValue, month: CellValue, day: CellValue, lang?: string): string;
 /** 착용일 정렬 열쇠 — 자리수를 채워(`2026-05-02`) 글자 비교가 날짜 차례와 같게. 연도가 없으면 ''. */
-export declare function wornDateSortKey(year: 칸값, month: 칸값, day: 칸값): string;
+export declare function wornDateSortKey(year: CellValue, month: CellValue, day: CellValue): string;
 export {};