feat(860-2): 서고 단가산출 목록 「고친 줄」 → 「고친 칸」 = 줄 쌓기 파란 테두리 칸 수(늘 0 이던 것)

- 서버 `M02_Sk_EditCount` — 지금 수식 문서 대 위 층 문서(읽기 답 층바탕.위) 값 칸 · 단위 · 금액 줄 칸 + 더한 · 차례 바뀐 · 빠진 줄 + 기계 고침 칸 · 따로 아님 = 0
- 짝 = `common_util_line_stack_diff.ts` docDiff(화면 파란 테두리) · 거울 시험 test_860_2_edit_count(수식 문서 전수 × 고침 갈래 · 같음)
- 열 이름 「고친 칸」(칸 수라 줄 아님) · 목록 칸 이름 고친줄수 → 고친칸수
- 옛 셈(덮개 · 더한줄 · 뺀줄 줄 수) 걷음 — 새 꼴 SK 는 옛 칸이 없어 늘 0 이었음
- test_717_2a: 칸 이름만 고침 · test_858_shelf_golden: 지문 다시 뜸 — 바뀐 갈래 다섯은 목록 줄 「고친칸수」 칸만(이름 · 값을 옛 꼴로 되돌리면 옛 지문과 같음 확인)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-19 10:12:17 +09:00
co-authored by Claude Opus 5.5
parent df80ecd3cd
commit f7850e21ab
10 changed files with 328 additions and 17 deletions
+4 -2
View File
@@ -369,7 +369,7 @@ def summary(
out["안이은줄"] = sum(
1 for x in fixes if not x.get("비율") and not any((x.get("이음") or {}).values())
)
# 717-2a 목록 열 — 바탕(로직 「키 이름」 | 참조 키 | None) · 고친 줄 수 · 쓰는 곳 수
# 717-2a 목록 열 — 바탕(로직 「키 이름」 | 참조 키 | None) · 고친 칸 수(860-2 ②) · 쓰는 곳 수
if kind == "sangeun":
top, (layer, owner) = doc.get("바탕") or {}, where(folder)
logic = top.get("로직")
@@ -379,7 +379,9 @@ def summary(
name = (m01doc.docs().get(str(logic)) or {}).get("이름") or ""
out["바탕"] = f"{logic} {name}".strip() # 없는 기초 = 키만(셈 때 까닭)
out["고친줄수"] = sum(len(doc.get(k) or ()) for k in ("덮개", "더한줄", "뺀줄"))
from M02_MasterTemplete import M02_Sk_EditCount as edit_count
out["고친칸수"] = edit_count.of_sk(doc) # 줄 쌓기 파란 테두리 칸 수(860-2 ②)
# SK 마다 모든 층 훑음 — 파일 읽기는 판 기억(`M02_Library_Uses.ids_of`)이라 처음 한 번만 무거움
from M02_MasterTemplete import M02_Library_Uses as uses
+1 -1
View File
@@ -172,7 +172,7 @@ def summaries(folder: str | Path, rows: list[dict[str, Any]]) -> None:
row.update(recs[name]["요약"])
if dirty:
_save(key, recs)
sk = [row for row in lib if row["종류"] == "sangeun" and "고친줄수" in row]
sk = [row for row in lib if row["종류"] == "sangeun" and "고친칸수" in row]
if sk:
from M02_MasterTemplete import M02_Library_Uses as library_uses
@@ -3,7 +3,7 @@
* 서고 목록표(51-4 · 717-2a) — 좌측 일위대가 · 단가산출 층 단추를 누르면 상세 칸에 뜸.
* 표 = 고름 · 키 · 구분 · 상세구분(51-12) · 이름 · 단위 · 기준 금액(서버 1 단위 계) · 고친 날 · 줄 누름 = 그 문서 상세 ·
* 일위대가 = 안 이은 줄 수(729-3 · 서버 `summary` · 0 은 빈칸).
* 단가산출 = 구분 둘 대신 바탕(M01 로직 · 없으면 「바탕 없음」) · 고친 줄 수 · 쓰는 곳 수(서버 `summary`).
* 단가산출 = 구분 둘 대신 바탕(M01 로직 · 없으면 「바탕 없음」) · 고친 칸 수(860-2 ② 줄 쌓기 파란 테두리) · 쓰는 곳 수(서버 `summary`).
* 머리 [생성] · [복사](고른 줄) · [삭제](고른 줄 · 쓰는 곳 있으면 서버 409 까닭 그대로).
* 꼴 = M01 단가산출 로직 목록 — 찾기 줄(`buildHeadFilters`) · 쪽(`buildPager`) · 표(`m01-master__grid`) 를 M01 에서 import.
* ========================================================================== */
@@ -45,7 +45,7 @@ type Row = TemplateInfo & {
구분?: string | null;
상세구분?: string | null;
바탕?: string | null;
고친줄수?: number;
고친칸수?: number;
쓰는곳수?: number;
/** 일위대가 안 이은 고정 줄 수(729-2 summary) */
안이은줄?: number;
@@ -75,7 +75,7 @@ export const sangeunBlank = (name: string): Record<string, unknown> => ({
바탕: null,
더한줄: [],
});
/** 표 열 — 머리 글 · 줄 값(일위대가 = 구분 둘 · 단가산출 = 바탕 · 고친 줄 · 쓰는 곳) */
/** 표 열 — 머리 글 · 줄 값(일위대가 = 구분 둘 · 단가산출 = 바탕 · 고친 칸 · 쓰는 곳) */
const COLUMNS: Record<LibraryKind, () => [string, (row: Row) => string][]> = {
precombo: () => [
[tc("Lib_Key"), (r) => r.이름],
@@ -92,7 +92,7 @@ const COLUMNS: Record<LibraryKind, () => [string, (row: Row) => string][]> = {
[tc("Lib_Name"), (r) => r.제목 ?? ""],
[tc("Lib_Unit"), (r) => r.단위 ?? ""],
[L("M02_SangeunBase"), (r) => r.바탕 || L("M02_SangeunNoBase")],
[L("M02_SangeunEdited"), (r) => String(r.고친줄수 ?? 0)],
[L("M02_SangeunEdited"), (r) => String(r.고친칸수 ?? 0)],
[L("M02_SangeunUsers"), (r) => String(r.쓰는곳수 ?? 0)],
[tc("Lib_Base"), (r) => money(r.기준금액)],
[tc("Lib_Date"), (r) => dateText(r.수정일, "")],
+180
View File
@@ -0,0 +1,180 @@
"""M02 단가산출(SK) 내가 고친 칸 수(PLAN 860-2 ② · 요구 910) — 서고 › 단가산출 목록 「고친 칸」 열.
파이썬 · TS 짝 — 짝 = `common_util/common_util_line_stack_diff.ts` `docDiff`
(줄 쌓기 파란 테두리 · 위 층 없이 = 나만) · 거울 시험 `resources/tester/test_860_2_edit_count.py`.
셈 = 지금 수식 문서(`수식.문서`) 대 위 층 문서(읽기 답 `층바탕.위` · `M02_Doc_Sk_Path.layers`) —
값 칸(`v:` 값 정의 · `u:` 단위 · `m:` 금액 줄 이름 · 단가 · 수량 · 단위 · 비목) +
줄 틀(더한 줄 · 차례 바뀐 줄) + 빠진 줄 +
기계 고침(`기계덮음` — 기계마다 값 칸 수 · 조종원 · 잡품 목록 하나씩).
줄 쌓기 차림(항목 제목 `t:` · 글 줄 `g:`)은 값이 아니라 안 셈.
따로 아닌 SK(파생 = 고침 없음) = 0 · 위 층 문서를 모름 = 기계 고침만.
"""
from __future__ import annotations
import json
import re
from typing import Any
from M02_MasterTemplete import M02_Doc_Copy as dc # 수식 문서 기호 열쇠 `dc.md.var_id`
LINE_FIELDS = ("이름", "단가", "수량", "단위", "비목")
COVER = "기계덮음"
_NO = object() # TS undefined
_NUM = re.compile(r"^-?[\d,]*\.?\d+$")
def canon(x: Any) -> Any:
"""견줌 꼴(TS `canon`) — 수 글 = 수 · 빈 값 = 없음 · 글 띄어쓰기 뺌 · 묶음 칸 차례 무시."""
if x is None or x is _NO:
return _NO
if isinstance(x, str):
t = re.sub(r"\s+", "", x)
if not t:
return _NO
if _NUM.match(t):
try:
return _num(float(t.replace(",", "")))
except ValueError:
return t
return t
if isinstance(x, list):
return [None if (v := canon(y)) is _NO else v for y in x] if x else _NO
if isinstance(x, dict):
out = {k: v for k in sorted(x) if (v := canon(x[k])) is not _NO}
return out or _NO
if isinstance(x, float):
return _num(x)
return x
def _num(v: float) -> Any:
return int(v) if v.is_integer() else v
def same(a: Any, b: Any) -> bool:
return canon(a) == canon(b)
def _key(x: Any) -> str:
"""금액 줄 짝 열쇠(TS `JSON.stringify(canon(단가))`)."""
got = canon(x)
return "∅" if got is _NO else json.dumps(got, ensure_ascii=False, sort_keys=True)
def _vars(doc: dict) -> dict[str, dict]:
return {dc.md.var_id(v): v for v in doc.get("변수") or [] if isinstance(v, dict)}
def _steps(doc: dict) -> dict[str, str]:
return {
str(x.get("기호") if x.get("기호") is not None else ""): str(
x.get("식") if x.get("식") is not None else ""
)
for x in doc.get("식") or []
if isinstance(x, dict)
}
def _value_at(vars_: dict, steps: dict, vid: str) -> Any:
v, s = vars_.get(vid), steps.get(vid, _NO)
if not v and s is _NO:
return _NO
v = v or {}
return {"변수": True if v else _NO, "연결": v.get("연결"), "식": s, "이름": v.get("이름")}
def _line_val(line: Any, field: str) -> Any:
if not isinstance(line, dict):
return _NO
if field == "이름":
return {"이름": line.get("이름"), "규격": line.get("규격")}
return line.get(field)
def match_lines(now: list, up: list) -> list[int]:
"""금액 줄 짝(TS `matchLines`) — 지금 차례 → 위 층 차례(-1 = 없음)."""
pool: dict[str, list[int]] = {}
for j, line in enumerate(up):
pool.setdefault(_key(line.get("단가")), []).append(j)
out = []
for line in now:
hit = pool.get(_key(line.get("단가")))
out.append(hit.pop(0) if hit else -1)
free = [j for j in range(len(up)) if j not in out]
for i, line in enumerate(now):
if out[i] >= 0 or canon(line.get("이름")) is _NO:
continue
at = next((n for n, j in enumerate(free) if same(up[j].get("이름"), line.get("이름"))), -1)
if at >= 0:
out[i] = free.pop(at)
return out
def _moved(match: list[int]) -> set[int]:
"""차례 바뀐 짝 줄 — 가장 긴 오름 차례에 안 든 것(TS `movedOf`)."""
at = [(b, i) for i, b in enumerate(match) if b >= 0]
size, prev = [], []
for k, (b, _) in enumerate(at):
size.append(1)
prev.append(-1)
for p in range(k):
if at[p][0] < b and size[p] + 1 > size[k]:
size[k], prev[k] = size[p] + 1, p
keep: set[int] = set()
k = size.index(max(size)) if size else -1
while k >= 0:
keep.add(at[k][1])
k = prev[k]
return {i for _, i in at if i not in keep}
def count(now: Any, up: Any) -> int:
"""지금 문서 대 위 층 — 내가 고친 값 칸 + 줄 틀 + 빠진 줄(기계 고침 뺌 · `covers`)."""
now, up = (x if isinstance(x, dict) else {} for x in (now, up))
nv, uv, ns, us = _vars(now), _vars(up), _steps(now), _steps(up)
marks = 0
for vid in {*nv, *ns}:
marks += not same(_value_at(nv, ns, vid), _value_at(uv, us, vid))
if vid in uv or (nv.get(vid) or {}).get("단위"):
marks += not same((nv.get(vid) or {}).get("단위"), (uv.get(vid) or {}).get("단위"))
nl = [x if isinstance(x, dict) else {} for x in now.get("금액") or []]
ul = [x if isinstance(x, dict) else {} for x in up.get("금액") or []]
match = match_lines(nl, ul)
for i, b in enumerate(match):
if b >= 0:
marks += sum(not same(_line_val(nl[i], f), _line_val(ul[b], f)) for f in LINE_FIELDS)
lines = sum(b < 0 for b in match) + len(_moved(match))
has_items = any(now.get(k) for k in ("쌓기", "금액", "변수", "식"))
gone = sum(j not in match for j in range(len(ul))) if has_items else 0
return marks + lines + gone
def covers(doc: Any) -> int:
"""기계 고침 칸 — 기계마다 값 칸 수 + 조종원 · 잡품 목록 하나씩."""
cover = doc.get(COVER) if isinstance(doc, dict) else None
if not isinstance(cover, dict):
return 0
return sum(
len(one.get("값") or {}) + bool(one.get("조종원")) + bool(one.get("잡품"))
for one in cover.values()
if isinstance(one, dict)
)
def of_sk(sk: Any) -> int:
"""SK 문서 → 내가 고친 칸 수(목록 「고친 칸」) · 따로 아님 = 0 · 못 셈 = 0."""
from M02_MasterTemplete import M02_Doc_Sk as dsk
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_MasterTemplete_Store as store
held = sk.get(dsk.KEY) if isinstance(sk, dict) else None
if not (isinstance(held, dict) and held.get("따로")) or not dsk.own(sk):
return 0
try:
copy = path.current(sk)
up = path.layers(copy, sk).get("위")
except (store.StoreError, ArithmeticError, KeyError, TypeError, ValueError):
return 0
doc = copy.get("문서") or {}
return (count(doc, up) if up else 0) + covers(doc)
@@ -8,6 +8,8 @@
* 금액 줄 짝 = 단가 글(같으면 차례대로) › 남은 줄은 이름 · 줄 틀 = 더한 줄 · 차례 바뀐 줄 · 빠진 줄 = 항목마다 되살림 목록
* 견줌 = 수 · 수 글 같음 · 빈 칸 = 없음 · 글 사이 띄어쓰기 무시(표시 탓 다름 0)
* 되돌림 = 칸 하나(`resetPath`) · 빠진 줄 되살림(`restoreLines` — 그 줄이 부르는 기호까지) — 부른 쪽 `change` 안에서
* 파이썬 짝(860-2 ② 고친 칸 수 · 값 칸 v: u: m: + 줄 틀 + 빠진 줄) = `M02_MasterTemplete/M02_Sk_EditCount.py` ·
* 거울 시험 `resources/tester/test_860_2_edit_count.py`
* ========================================================================== */
import {
@@ -4,7 +4,7 @@
"precombo.나무": "d08cff9db9575c99",
"precombo.되돌림": "c6cee923af63dbde",
"precombo.만들기": "e53ad45acbf386bc",
"precombo.목록": "8794b5e2d7a11999",
"precombo.목록": "b4b9fb3defffd3b3",
"precombo.복사": "ea957146cf361b70",
"precombo.붙여넣기": "236bf55301ef9045",
"precombo.쓰는곳": "8f68c3d2501f7a53",
@@ -16,7 +16,7 @@
"sangeun.나무": "991823a8c1fe1913",
"sangeun.되돌림": "dd36436bdac1a6a7",
"sangeun.만들기": "2155d280fd6d97ae",
"sangeun.목록": "61e043f162549b4b",
"sangeun.목록": "d7c68b66e2cc8021",
"sangeun.복사": "40edbd4d0644186f",
"sangeun.붙여넣기": "57cfb7bb522a80d3",
"sangeun.쓰는곳": "2c9ec1824709481f",
@@ -31,9 +31,9 @@
"공유.요청": "762ba10d5af57643",
"권한.같은회사남": "2d3d50a90583497d",
"권한.남의회사관리": "a1213c908c70528f",
"권한.시스템": "62482b9feacef35d",
"권한.일반": "1c5a65215f7e254e",
"권한.회사관리": "c08e29bffd8dd114",
"권한.시스템": "33b6241129a9bce3",
"권한.일반": "3f3009d92f5f403b",
"권한.회사관리": "cd2c0f1d3073201e",
"내기계.고치기": "3f00365dbfb77cee",
"내기계.만들기": "20f5562f02c276f8",
"내기계.목록": "064102da4c9740d6",
@@ -0,0 +1,30 @@
/* 860-2 ② 고친 칸 수 헬퍼 — common_util_line_stack_diff.ts `docDiff`(위 층 없이 = 나만)를 트랜스파일해 Node 로 돌림.
* stdin = [{문서, 위}] → [값 칸(v: · u: · m:) 표시 수 + 줄 틀 수 + 빠진 줄 수](짝 = M02_Sk_EditCount.count)
*/
const fs = require("fs");
const path = require("path");
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
const cache = new Map();
function load(at) {
if (cache.has(at)) return cache.get(at);
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
}).outputText;
const box = { exports: {} };
cache.set(at, box.exports);
const need = (p) =>
p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
new Function("exports", "module", "require", js)(box.exports, box, need);
return box.exports;
}
const df = load(path.join(__dirname, "..", "..", "common_util", "common_util_line_stack_diff.ts"));
const cases = JSON.parse(fs.readFileSync(0, "utf8"));
const out = cases.map(({ 문서, 위 }) => {
const g = df.docDiff(문서, 위);
const marks = [...g.marks].filter(([p, m]) => /^[vum]:/.test(p) && m.diff === "mine").length;
const gone = [...g.gone.values()].reduce((n, x) => n + x.at.length, 0);
return marks + g.lines.size + gone;
});
process.stdout.write(JSON.stringify(out));
+4 -4
View File
@@ -1,6 +1,6 @@
"""M02 단가산출 칸 목록 줄(PLAN 717-2a · `M02_Labor_Ref.summary` sangeun 갈래) — 임시 storage.
바탕 = 로직 「키 이름」 · 참조 = SK 키 · 없음 = None · 고친 줄 수 = 덮개 + 더한줄 + 뺀줄 ·
바탕 = 로직 「키 이름」 · 참조 = SK 키 · 없음 = None · 고친 칸 수 = 줄 쌓기 파란 테두리 칸(860-2 ② · `M02_Sk_EditCount`) ·
쓰는 곳 수 = 그 SK 를 바탕 · 더한줄로 담은 문서 수 · 일위대가(precombo) 줄엔 안 붙음.
"""
@@ -34,7 +34,7 @@ def test_sangeun_row_base_edits_users(world):
name = m01_doc.docs()[PCT]["이름"] # 기초 이름 = 수식 문서(855 L3)
row = _row(mine, "sangeun", a)
assert row["바탕"] == f"{PCT} {name}".strip()
assert row["고친줄수"] == 0 and row["쓰는곳수"] == 0
assert row["고친칸수"] == 0 and row["쓰는곳수"] == 0
assert row["제목"] == "목록 시험" and row["단위"] == "㎡"
# 바탕 참조 SK(740-1) = 저장 때 펼쳐 담음 → 바탕 = 기초 · 쓰는 곳 0
b = _sk(mine, 바탕={"참조": {**MINE, "키": a}})
@@ -43,11 +43,11 @@ def test_sangeun_row_base_edits_users(world):
# 바탕 없음
c = _sk(mine)
row_c = _row(mine, "sangeun", c)
assert row_c["바탕"] is None and row_c["고친줄수"] == 0
assert row_c["바탕"] is None and row_c["고친칸수"] == 0
def test_precombo_row_has_no_sangeun_fields(world):
with store.at(world["personal"]):
sc = refs.create("precombo", {"이름": "조합", "담은로직": []})["이름"]
row = _row(world["personal"], "precombo", sc)
assert not {"바탕", "고친줄수", "쓰는곳수"} & set(row)
assert not {"바탕", "고친칸수", "쓰는곳수"} & set(row)
+97
View File
@@ -0,0 +1,97 @@
"""860-2 ② 서고 › 단가산출 목록 「고친 칸」 = 내가 고친 칸 수(요구 910).
짝 = `M02_MasterTemplete/M02_Sk_EditCount.py`(목록 셈) ↔
`common_util/common_util_line_stack_diff.ts` `docDiff`(줄 쌓기 파란 테두리 · 위 층 없이 = 나만) —
수식 문서 전수에 같은 고침을 얹어 두 셈이 같음.
서버 — SK 칸 고침 저장 = 목록 「고친 칸」 1 · 기계 값 고침 더함 · 다 되돌리면 0(파생).
"""
import copy as cp
import importlib
import json
import os
import subprocess
from M02_MasterTemplete import M02_Sk_EditCount as ec
ml = importlib.import_module("master_doc_link")
mcv = importlib.import_module("master_doc_cover")
HERE = os.path.dirname(os.path.abspath(__file__))
def _node(cases):
proc = subprocess.run(
["node", os.path.join(HERE, "helper_860_2_edit_count.cjs")],
input=json.dumps(cases, ensure_ascii=False),
capture_output=True,
text=True,
encoding="utf-8",
)
assert proc.returncode == 0, proc.stderr[-2000:]
return json.loads(proc.stdout)
def _js(d):
return json.loads(json.dumps(ml._norm(d), ensure_ascii=False, default=str))
def _edits(doc):
"""같은 문서에 얹는 고침 갈래 — 값 · 단위 · 수량 · 줄 뺌 · 줄 더함 · 차례 · 이름."""
out = [cp.deepcopy(doc)]
money = doc.get("금액") or []
if doc.get("변수"):
d = cp.deepcopy(doc)
d["변수"][0]["연결"] = {**(d["변수"][0].get("연결") or {}), "값": 12345}
d["변수"][-1]["단위"] = "시험단위"
out.append(d)
if money:
d = cp.deepcopy(doc)
d["금액"][0]["수량"] = f"({money[0].get('수량')}) × 2"
d["금액"].append({**money[-1], "단가": "1234", "이름": "시험 줄"})
out.append(d)
d = cp.deepcopy(doc)
d["금액"].pop()
out.append(d)
if len(money) > 2:
d = cp.deepcopy(doc)
d["금액"][0], d["금액"][1] = d["금액"][1], d["금액"][0]
d["금액"][-1]["이름"] = "바꾼 이름"
out.append(d)
return out
def test_거울_전수_파이썬_TS_같음():
cases = []
for _, d in sorted(ml.load_all().items()):
up = _js(d)
cases += [{"문서": now, "위": up} for now in _edits(up)]
assert len(cases) >= 6000
want = _node(cases)
got = [ec.count(c["문서"], c["위"]) for c in cases]
bad = [(i, g, w) for i, (g, w) in enumerate(zip(got, want)) if g != w]
assert not bad, bad[:5]
assert got[0] == 0 and max(got) > 3 # 고침 없음 = 0 · 고침 = 셈
def test_서버_SK_고친_칸(tmp_path, monkeypatch):
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from resources.tester.test_m02_labor_ref import world as make
me = make.__wrapped__(tmp_path, monkeypatch)["personal"]
with store.at(me):
body = {"이름": "sub6임시 고친칸", "단위": "㎥", "바탕": {"로직": "GF000099"}, "더한줄": []}
key = refs.create("sangeun", body)["이름"]
row = lambda: refs.summary(me, "sangeun", key)["고친칸수"] # noqa: E731
assert row() == 0
first = path.read(key)
doc = cp.deepcopy(first["문서"])
doc["금액"][0]["수량"] = f"({doc['금액'][0]['수량']}) × 2"
path.save(key, {"문서": doc, "판": first["판"]})
assert row() == 1
doc[mcv.COVER] = {"0201-0070": {"값": {"가격": 900000}}} # 굴착기 0.7㎥ — GF000099 기계
path.save(key, {"문서": doc, "판": path.read(key)["판"]})
assert row() == 2 # 수량 1 + 기계 값 1
path.save(key, {"문서": first["문서"], "판": path.read(key)["판"]})
assert row() == 0 # 다 되돌림 = 파생
+1 -1
View File
@@ -158,7 +158,7 @@ export const ui_locales_m2 = {
M02_SangeunNewHere: ["여기에 새 단가산출", "New unit-price analysis here"],
M02_SangeunBase: ["바탕", "Base"],
M02_SangeunNoBase: ["바탕 없음", "No base"],
M02_SangeunEdited: ["고친 줄", "Edited rows"],
M02_SangeunEdited: ["고친 칸", "Edited cells"],
M02_SangeunUsers: ["쓰는 곳", "Used by"],
M02_SangeunUnit: ["단위(1 단위 값)", "Unit (value per 1)"],
M02_SangeunNeed: ["비우면 저장 안 됨", "Required"],