@ihabdevteam/core 0.321.0 → 0.323.0

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

@@ -21,7 +21,7 @@ export function getSavedTables() {
     }
 }
 /** 목록을 통째로 적는다. 저장소가 가득 찼거나(QuotaExceededError) 거부되면(사파리 프라이빗 모드) false. */
-function 적기(tables) {
+function write(tables) {
     try {
         localStorage.setItem(STORAGE_KEY, JSON.stringify(tables));
         return true;
@@ -46,7 +46,7 @@ export function saveTable(name, items, description, searchConfig) {
         description,
         searchConfig,
     };
-    return 적기([newTable, ...tables]) ? newTable : null;
+    return write([newTable, ...tables]) ? newTable : null;
 }
 /**
  * 저장된 단어표를 갱신한다(수정 저장). 지정한 필드만 덮어쓴다.
@@ -56,11 +56,11 @@ export function saveTable(name, items, description, searchConfig) {
  */
 export function updateSavedTable(id, patch) {
     const tables = getSavedTables().map(t => t.id === id ? { ...t, ...patch } : t);
-    return 적기(tables);
+    return write(tables);
 }
 export function deleteTable(id) {
     const tables = getSavedTables().filter(t => t.id !== id);
-    적기(tables);
+    write(tables);
 }
 /** 표를 복사해 목록 맨 앞에 둔다. 원본이 없거나 **저장소에 적지 못하면 `null`**. */
 export function duplicateTable(id) {
@@ -75,5 +75,5 @@ export function duplicateTable(id) {
         name: `${original.name} (복사)`,
         savedAt: new Date().toISOString(),
     };
-    return 적기([copy, ...tables]) ? copy : null;
+    return write([copy, ...tables]) ? copy : null;
 }

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

@@ -20,17 +20,17 @@ export interface TabSessionLike {
  * 여기서 막으면 이 탭이 로그인된 채로 남는다 — 막는 것보다 나쁜 쪽이다.
  *
  * ```ts
- * onAuthStateChange((event, 받은것) => {
+ * onAuthStateChange((event, incoming) => {
  *   getSession().then(({ data }) => {
- *     const 이탭것 = data.session
- *     if (!isSessionForThisTab(받은것, 이탭것)) return   // 다른 탭에서 온 것 — 무시
- *     …이탭것 으로 상태를 맞춘다
+ *     const thisTab = data.session
+ *     if (!isSessionForThisTab(incoming, thisTab)) return   // 다른 탭에서 온 것 — 무시
+ *     …thisTab 으로 상태를 맞춘다
  *   })
  * })
  * ```
  *
- * @param 받은것 이벤트가 실어 온 세션(없을 수 있다)
- * @param 이탭것 `getSession()` 이 이 탭 저장소에서 다시 읽은 세션
+ * @param incoming 이벤트가 실어 온 세션(없을 수 있다)
+ * @param thisTab `getSession()` 이 이 탭 저장소에서 다시 읽은 세션
  * @public
  */
-export declare function isSessionForThisTab(받은것: TabSessionLike | null | undefined, 이탭것: TabSessionLike | null | undefined): boolean;
+export declare function isSessionForThisTab(incoming: TabSessionLike | null | undefined, thisTab: TabSessionLike | null | undefined): boolean;

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

@@ -16,21 +16,21 @@
  * 여기서 막으면 이 탭이 로그인된 채로 남는다 — 막는 것보다 나쁜 쪽이다.
  *
  * ```ts
- * onAuthStateChange((event, 받은것) => {
+ * onAuthStateChange((event, incoming) => {
  *   getSession().then(({ data }) => {
- *     const 이탭것 = data.session
- *     if (!isSessionForThisTab(받은것, 이탭것)) return   // 다른 탭에서 온 것 — 무시
- *     …이탭것 으로 상태를 맞춘다
+ *     const thisTab = data.session
+ *     if (!isSessionForThisTab(incoming, thisTab)) return   // 다른 탭에서 온 것 — 무시
+ *     …thisTab 으로 상태를 맞춘다
  *   })
  * })
  * ```
  *
- * @param 받은것 이벤트가 실어 온 세션(없을 수 있다)
- * @param 이탭것 `getSession()` 이 이 탭 저장소에서 다시 읽은 세션
+ * @param incoming 이벤트가 실어 온 세션(없을 수 있다)
+ * @param thisTab `getSession()` 이 이 탭 저장소에서 다시 읽은 세션
  * @public
  */
-export function isSessionForThisTab(받은것, 이탭것) {
-    if (!받은것)
+export function isSessionForThisTab(incoming, thisTab) {
+    if (!incoming)
         return true;
-    return !!이탭것 && 이탭것.access_token === 받은것.access_token;
+    return !!thisTab && thisTab.access_token === incoming.access_token;
 }

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

@@ -1,5 +1,5 @@
 /** 글자 둘을 한국어 차례로 견준다 */
-export declare function 한글순(a: string, b: string): number;
+export declare function compareKorean(a: string, b: string): number;
 /**
  * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 글자 속 숫자도 수로.**
  *
@@ -13,10 +13,10 @@ export declare function 한글순(a: string, b: string): number;
  * 비어 있는 값(`null`·`undefined`·NaN)은 빈 글자로 본다 — 부르는 쪽이 이미
  * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
  */
-export declare function 칸순(a: unknown, b: unknown): number;
+export declare function compareCell(a: unknown, b: unknown): number;
 /**
- * 표 정렬 한 번의 비교 — 칸순에 방향을 입히되 **빈 값은 오름·내림 모두 맨 뒤.**
- * 방향을 `-칸순` 으로 뒤집기만 하면 빈 값이 오름차순 맨 앞·내림차순 맨 뒤로 오가, 표마다 빈 줄이 다른 끝에 섰다.
+ * 표 정렬 한 번의 비교 — compareCell에 방향을 입히되 **빈 값은 오름·내림 모두 맨 뒤.**
+ * 방향을 `-compareCell` 으로 뒤집기만 하면 빈 값이 오름차순 맨 앞·내림차순 맨 뒤로 오가, 표마다 빈 줄이 다른 끝에 섰다.
  * ListPopup 과 useTableSort().sortRows 가 함께 쓴다.
  */
-export declare function 칸순빈값뒤(a: unknown, b: unknown, asc: boolean): number;
+export declare function compareCellBlankLast(a: unknown, b: unknown, asc: boolean): number;

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 한글순(a, b) {
-    return 콜레이터().compare(a, b);
+export function compareKorean(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;
 }
 /**
  * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 글자 속 숫자도 수로.**
@@ -77,19 +77,19 @@ function 전화열쇠(s) {
  * 비어 있는 값(`null`·`undefined`·NaN)은 빈 글자로 본다 — 부르는 쪽이 이미
  * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
  */
-export function 칸순(a, b) {
-    const 글 = (v) => (v == null || (typeof v === 'number' && Number.isNaN(v)) ? '' : String(v).trim());
-    const sa = 글(a), sb = 글(b);
+export function compareCell(a, 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];
@@ -102,25 +102,25 @@ export function 칸순(a, b) {
             return -1;
         if (typeof y === 'number')
             return 1;
-        const c = 한글순(x, y);
+        const c = compareKorean(x, y);
         if (c !== 0)
             return c;
     }
     if (ka.length !== kb.length)
         return ka.length - kb.length;
-    return 한글순(sa, sb);
+    return compareKorean(sa, sb);
 }
-/* 빈 값 — null·undefined·NaN·빈 글자(빈칸만 있는 글자 포함). 칸순이 '' 로 보는 것과 같은 범위. */
-const 빈칸값 = (v) => v == null || (typeof v === 'number' && Number.isNaN(v)) || (typeof v === 'string' && v.trim() === '');
+/* 빈 값 — null·undefined·NaN·빈 글자(빈칸만 있는 글자 포함). compareCell이 '' 로 보는 것과 같은 범위. */
+const isBlank = (v) => v == null || (typeof v === 'number' && Number.isNaN(v)) || (typeof v === 'string' && v.trim() === '');
 /**
- * 표 정렬 한 번의 비교 — 칸순에 방향을 입히되 **빈 값은 오름·내림 모두 맨 뒤.**
- * 방향을 `-칸순` 으로 뒤집기만 하면 빈 값이 오름차순 맨 앞·내림차순 맨 뒤로 오가, 표마다 빈 줄이 다른 끝에 섰다.
+ * 표 정렬 한 번의 비교 — compareCell에 방향을 입히되 **빈 값은 오름·내림 모두 맨 뒤.**
+ * 방향을 `-compareCell` 으로 뒤집기만 하면 빈 값이 오름차순 맨 앞·내림차순 맨 뒤로 오가, 표마다 빈 줄이 다른 끝에 섰다.
  * ListPopup 과 useTableSort().sortRows 가 함께 쓴다.
  */
-export function 칸순빈값뒤(a, b, asc) {
-    const ea = 빈칸값(a), eb = 빈칸값(b);
+export function compareCellBlankLast(a, b, asc) {
+    const ea = isBlank(a), eb = isBlank(b);
     if (ea || eb)
         return ea === eb ? 0 : ea ? 1 : -1;
-    const c = 칸순(a, b);
+    const c = compareCell(a, b);
     return asc ? c : -c;
 }

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.d.ts

@@ -10,7 +10,7 @@ export type WordAttributeSectionCode = 'grade' | 'syllables' | 'pos' | 'wordType
  * (`undefined` · `null` · `''`, 그리고 공백만 든 것도).
  *
  * 그래서 **맞추개가 이 코드만은 다른 길로 간다** — `word.grade === code` 가 아니라
- * `빈등급인가(word.grade)` 로 본다(`phonemePairSearch.matchesFilters`). 같은 꼴로 재면
+ * `isBlankGrade(word.grade)` 로 본다(`phonemePairSearch.matchesFilters`). 같은 꼴로 재면
  * 한 단어도 안 걸리고, 그런데 **필터는 멀쩡히 켜져 보인다.**
  *
  * **숫자 길에도 안 걸린다** — 아래 `wordAttributeValueCodeOf` 가 등급을 숫자로도 읽는데
@@ -20,7 +20,7 @@ export type WordAttributeSectionCode = 'grade' | 'syllables' | 'pos' | 'wordType
  */
 export declare const GRADE_NONE = "none";
 /** 등급이 비었나 — `'none'` 이 가리키는 그 **빔**을 한 자리에서 판정한다. 공백만 든 것도 빔이다. */
-export declare function 빈등급인가(grade: string | null | undefined): boolean;
+export declare function isBlankGrade(grade: string | null | undefined): boolean;
 /** 등급 코드인가 — `'1'`~`'4'`·`'none'`. 저장된 값을 되읽을 때 **아닌 것은 버린다**(한때 `''` 가 저장됐다). */
 export declare function isGradeCode(v: unknown): v is string;
 /**

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

@@ -21,7 +21,7 @@ import i18n from '../i18n';
  * (`undefined` · `null` · `''`, 그리고 공백만 든 것도).
  *
  * 그래서 **맞추개가 이 코드만은 다른 길로 간다** — `word.grade === code` 가 아니라
- * `빈등급인가(word.grade)` 로 본다(`phonemePairSearch.matchesFilters`). 같은 꼴로 재면
+ * `isBlankGrade(word.grade)` 로 본다(`phonemePairSearch.matchesFilters`). 같은 꼴로 재면
  * 한 단어도 안 걸리고, 그런데 **필터는 멀쩡히 켜져 보인다.**
  *
  * **숫자 길에도 안 걸린다** — 아래 `wordAttributeValueCodeOf` 가 등급을 숫자로도 읽는데
@@ -31,12 +31,12 @@ import i18n from '../i18n';
  */
 export const GRADE_NONE = 'none';
 /** 등급이 비었나 — `'none'` 이 가리키는 그 **빔**을 한 자리에서 판정한다. 공백만 든 것도 빔이다. */
-export function 빈등급인가(grade) {
+export function isBlankGrade(grade) {
     return grade == null || String(grade).trim() === '';
 }
 /** 등급 코드인가 — `'1'`~`'4'`·`'none'`. 저장된 값을 되읽을 때 **아닌 것은 버린다**(한때 `''` 가 저장됐다). */
 export function isGradeCode(v) {
-    return typeof v === 'string' && 등급값.includes(v);
+    return typeof v === 'string' && gradeValues.includes(v);
 }
 /**
  * **등급 코드 집합으로 단어 하나를 거른다 — 이 결정은 여기 하나다.**
@@ -55,46 +55,46 @@ export function matchesGradeCodes(codes, grade) {
     const set = codes instanceof Set ? codes : new Set(codes);
     if (set.size === 0)
         return true;
-    if (빈등급인가(grade))
+    if (isBlankGrade(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 {