diff --git a/CHANGELOG.md b/CHANGELOG.md
index b103505b7..0d23ef962 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@ Dates are in `YYYY-MM-DD` format and versions are in [semantic versioning](http:
 -   Correct typos in tutorial.
 -   Ensured type errors when a structure definition is given instead of a structure value.
 -   When generalizing a union type of function types, generalize their output types.
+-   Repaired structure of Korean locale.
 -   [#503](https://github.com/wordplaydev/wordplay/issues/503). Prevent infinite loops in parser.
 -   [#504](https://github.com/wordplaydev/wordplay/issues/504). Account for non-fixed-width characters in caret positioning.
 -   [#488](https://github.com/wordplaydev/wordplay/issues/488). Added animations off indicator on stage.
diff --git a/static/locales/example/example.json b/static/locales/example/example.json
index b1b3a27fa..20ac01c7c 100644
--- a/static/locales/example/example.json
+++ b/static/locales/example/example.json
@@ -1263,7 +1263,7 @@
                 "random": { "doc": "$?", "names": "$?", "inputs": [] },
                 "shuffled": {
                     "doc": ["$?"],
-                    "names": "$? shuffle",
+                    "names": "$?",
                     "inputs": []
                 },
                 "first": { "doc": "$?", "names": "$?", "inputs": [] },
@@ -1745,7 +1745,7 @@
     },
     "output": {
         "Output": {
-            "names": "$? Output",
+            "names": "$?",
             "doc": "$?"
         },
         "Stage": {
@@ -1848,7 +1848,7 @@
             "style": { "doc": "$?", "names": "$?" }
         },
         "Phrase": {
-            "names": ["💬", "Frase"],
+            "names": "$?",
             "doc": "$?",
             "description": "$?",
             "text": { "doc": "$?", "names": "$?" },
diff --git a/static/locales/ko-KR/ko-KR.json b/static/locales/ko-KR/ko-KR.json
index 3ceca9337..edae5fc75 100644
--- a/static/locales/ko-KR/ko-KR.json
+++ b/static/locales/ko-KR/ko-KR.json
@@ -40,7 +40,9 @@
         "query": "질의",
         "row": "행",
         "set": "집합",
-        "key": "키"
+        "key": "키",
+        "feedback": "$?",
+        "help": "$?"
     },
     "token": {
         "EvalOpen": "평가열기",
@@ -71,7 +73,9 @@
         "URL": "유알엘",
         "Code": "코드",
         "Mention": "언급",
-        "Branch": "브랜치",
+        "Literal": "$?",
+        "Otherwise": "$?",
+        "Match": "$?",
         "None": "없어",
         "Type": "$?",
         "TypeOperator": "$?",
@@ -116,39 +120,39 @@
         "Dimension": {
             "name": "차원",
             "description": "차원",
-            "emotion": "심각한",
+            "emotion": "$?",
             "doc": [
                 "나는 /측정 단위/이다!",
                 "나는 \\1m\\, \\10s\\, \\100g\\와 같은 표준화된 단위가 될 수 있어. 네가 만들고 싶은 \\17사과\\와 같은 단위도 기꺼이 될 수 있어.",
                 "나는 \\17사과/일\\와 같은 비율 단위를 만들기 위해 \\/\\와 결합될 수 있고, \\9.8m/s^2\\와 같은 지수 단위를 만들기 위해 \\^\\와 결합될 수 있어.",
-                "나는 항상 @숫자 뒤에 와야 해. 그렇지 않으면 @참조로 오해받을 수 있는데, 그건 꽤 난감할거야!",
+                "나는 항상 @Number 뒤에 와야 해. 그렇지 않으면 @Reference 오해받을 수 있는데, 그건 꽤 난감할거야!",
                 "나는 단위 간의 불일치도 잘 찾아내요. 예를 들면, \\1고양이 + 1개\\는 아무런 의미가 없어요!",
-                "다른 단위 값들을 변환하고 싶다면, @변환에게 말하세요."
+                "다른 단위 값들을 변환하고 싶다면, @Convert 말하세요."
             ]
         },
         "Doc": {
             "name": "설명",
-            "emotion": "심각한",
+            "emotion": "$?",
             "doc": [
-                "나는 @마크업 으로 여러 가지를 포맷합니다, 예를 들면 너의 @프로그램에 대한 설명이나, @프레이즈로 무대에 올린 단어들처럼요.",
+                "나는 @Markup 으로 여러 가지를 포맷합니다, 예를 들면 너의 @Program 대한 설명이나, @Phrase 무대에 올린 단어들처럼요.",
                 "예를 들면, 나는 어떤 표현 앞에 올 수 있어요:",
-                "\\이게 정말 7이 맞나요?\\n7\\",
-                "예를 들면, @바인드 앞에 나를 둘 수 있어요:",
-                "\\나는 어떤 사람의 키를 측정해요\\nheight: 5m\\",
-                "또는 @함수정의 앞에도요:",
-                "\\나는 두 숫자를 더해요\\nƒ sum(a•# b•#) a + b\\",
-                "또는 @구조정의 앞에도요:",
-                "\\나는 사람들의 이름과 좋아하는 과일을 기억해요\\n•Person(name•'' fruit•'')\\",
-                "너는 또한 전체 퍼포먼스가 무엇에 관한 것인지 말하기 위해 나를 @프로그램의 맨 처음에 둘 수 있어요.",
-                "\\이 프로그램은 안녕이라고 말해요\\n\\n'hello!'\\",
-                "다른 사람들이 내가 어떤 언어로 쓰여졌는지 알 수 있도록 나에게 @언어를 줄 수 있어요:",
-                "\\나는 영어 문서에요/en\\nduration: 5s\\",
-                "나를 리스트로 만들 수 있다는 것 알고 계셨나요? @문서에게 말해보세요."
+                "``\\이게 정말 7이 맞나요?``\n7\\",
+                "예를 들면, @Bind 앞에 나를 둘 수 있어요:",
+                "\\``나는 어떤 사람의 키를 측정해요``\nheight: 5m\\",
+                "또는 @FunctionDefinition 앞에도요:",
+                "\\``나는 두 숫자를 더해요``\nƒ sum(a•# b•#) a + b\\",
+                "또는 @StructureDefinition 앞에도요:",
+                "\\``나는 사람들의 이름과 좋아하는 과일을 기억해요``\n•Person(name•'' fruit•'')\\",
+                "너는 또한 전체 퍼포먼스가 무엇에 관한 것인지 말하기 위해 나를 @Program 맨 처음에 둘 수 있어요.",
+                "\\``이 프로그램은 안녕이라고 말해요``\n\n'hello!'\\",
+                "다른 사람들이 내가 어떤 언어로 쓰여졌는지 알 수 있도록 나에게 @Language 줄 수 있어요:",
+                "\\``나는 영어 문서에요``/en\nduration: 5s\\",
+                "나를 리스트로 만들 수 있다는 것 알고 계셨나요? @Docs 말해보세요."
             ]
         },
         "Docs": {
             "name": "설명 목록",
-            "emotion": "심각한",
+            "emotion": "$?",
             "doc": [
                 "나는 다양한 언어로 @Doc의 번역본을 여러 개 가질 때 유용한 @Doc의 목록이야.",
                 "목록을 만들기 위해 특별히 무언가를 할 필요는 없어. 그냥 이렇게 여러 개의 @Doc을 나란히 놓으면 돼:",
@@ -158,7 +162,7 @@
         },
         "KeyValue": {
             "name": "매핑",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
                 "나는 항상 @Map 안에서 *키*에서 *값*으로의 매핑이에요.",
                 "어떤 종류의 값을 다른 값에 매핑할 수 있어요. 예를 들어, 숫자의 매핑은 여기 있습니다:",
@@ -170,16 +174,16 @@
         "Language": {
             "name": "언어",
             "description": "언어 $1[$1|알 수 없음]",
-            "emotion": "열정적인",
+            "emotion": "$?",
             "doc": [
-                "나는 언어 태그이며 @이름 과 @문서 와 함께 작동해요!",
+                "나는 언어 태그이며 @Name 과 @Doc 와 함께 작동해요!",
                 "무언가가 어떤 언어로 쓰여진 것인지 *또렷하게* 알려주는 데 매우 능숙해요.",
                 "그게 바로 제가 하는 일이에요. 단지 작은 슬래시 하나와 몇 글자만 있으면, 어떤 텍스트가 어떤 언어인지 절대 혼란스러워하지 않을 거예요.",
                 "예를 들어, 내 $이름을 말하고 싶지만 영어임을 분명히 하고 싶다고 가정해봅시다:",
                 "\\\"언어\"/en\\",
-                "또는 @이름에 대해 이것을 하고 싶다고 가정해 보세요.",
+                "또는 @Name 대해 이것을 하고 싶다고 가정해 보세요.",
                 "\\소리/en: '야옹'\\",
-                "또는 @문서 에도!",
+                "또는 @Doc 에도!",
                 "\\``의성어``/en\n소리/en: \"야옹\"\\",
                 "내가 이해하는 <2글자 언어 코드들@https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes>이 많아요. 만약 그 중 하나를 사용하지 않는다면 알려드릴게요."
             ],
@@ -191,55 +195,55 @@
         "Name": {
             "name": "이름",
             "description": "$1[$1 | 무명]",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
                 "나는 값을 식별하며, 평가하기 어려운 것이나 반복해서 평가하고 싶지 않은 것에 대한 축약된 레이블을 제공하는 유용한 방법입니다.",
-                "@바인드가 이렇게 내 이름을 지어줍니다:",
+                "@Bind 이렇게 내 이름을 지어줍니다:",
                 "\\hi: 5\\",
-                "나는 오직 하나의 값을 대표하며, 한 번 가지고 나면 변경할 수 없어요. 예를 들어, @바인드를 사용하여 이렇게 하려고 하면 우리는 불평을 할 거예요.",
+                "나는 오직 하나의 값을 대표하며, 한 번 가지고 나면 변경할 수 없어요. 예를 들어, @Bind 사용하여 이렇게 하려고 하면 우리는 불평을 할 거예요.",
                 "\\hi: 5\nhi: 3\\",
-                "내 값을 얻으려면 @참조 또는 @속성참조가 이름을 사용하기만 하면 돼요. 여기서 @바인드가 나를 이름 지어주고, @참조가 내게 주어진 값을 얻습니다.",
+                "내 값을 얻으려면 @Reference 또는 @PropertyReference 이름을 사용하기만 하면 돼요. 여기서 @Bind 나를 이름 지어주고, @Reference 내게 주어진 값을 얻습니다.",
                 "\\hi: 5\nhi\\",
-                "@바인드가 많은 곳에 나타날 수 있기 때문에, 나도 많은 곳에 나타날 수 있어요. 위에 @블록 안에 있었지만, @함수정의 안에도 있을 수 있어요. 여기서 나는 임시적으로 메시지의 이름을 지어주고 있습니다:",
+                "@Bind 많은 곳에 나타날 수 있기 때문에, 나도 많은 곳에 나타날 수 있어요. 위에 @Block 안에 있었지만, @FunctionDefinition 안에도 있을 수 있어요. 여기서 나는 임시적으로 메시지의 이름을 지어주고 있습니다:",
                 "\\ƒ say(message•'') message\\",
-                "나는 @함수정의 내부에서 정의되고, 함수 평가가 끝나는 대로 사라져요.",
-                "내 이름이 어떤 언어인지 나타내기 위해 @언어를 사용할 수 있어요. 이것은 다른 사람들과 공연을 공유할 때, 그들이 당신의 프로그램을 읽고 싶을 경우에 도움이 됩니다."
+                "나는 @FunctionDefinition 내부에서 정의되고, 함수 평가가 끝나는 대로 사라져요.",
+                "내 이름이 어떤 언어인지 나타내기 위해 @Language 사용할 수 있어요. 이것은 다른 사람들과 공연을 공유할 때, 그들이 당신의 프로그램을 읽고 싶을 경우에 도움이 됩니다."
             ]
         },
         "Names": {
             "name": "이름 목록",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
-                "나는 @이름의 목록이며, 값을 여러 이름으로 지정하고 싶을 때 유용합니다, 종종 다른 @언어와 함께요.",
-                "이름은 \\,\\ 기호로 구분됩니다. 예를 들어, 여기 @바인드가 여러 @이름에 값을 지정하는 것입니다:",
+                "나는 @Name 목록이며, 값을 여러 이름으로 지정하고 싶을 때 유용합니다, 종종 다른 @Language 함께요.",
+                "이름은 \\,\\ 기호로 구분됩니다. 예를 들어, 여기 @Bind 여러 @Name 값을 지정하는 것입니다:",
                 "\\hi/en,hello/en,hola/es: '환영합니다'\\"
             ]
         },
         "Row": {
             "name": "행",
-            "emotion": "수줍은",
-            "doc": "나는 @테이블의 한 행을 나타냅니다. 나에 대해 모든 것을 아는 @테이블에게 말하는 것이 아마도 최선일 거예요. 나는 그저 앉아서 값들을 줄지어 정렬하고 있을 뿐이에요 :(",
+            "emotion": "$?",
+            "doc": "나는 @Table 한 행을 나타냅니다. 나에 대해 모든 것을 아는 @Table 말하는 것이 아마도 최선일 거예요. 나는 그저 앉아서 값들을 줄지어 정렬하고 있을 뿐이에요 :(",
             "conflict": {
-                "InvalidRow": "행은 모두 값이거나 모두 @바인드 이어야 합니다.",
+                "InvalidRow": "행은 모두 값이거나 모두 @Bind 이어야 합니다.",
                 "MissingCell": {
                     "primary": "나는 $1 열이 누락되었습니다",
                     "secondary": "나는 필요하지만 $1이 제공하지 않았어요"
                 },
                 "ExtraCell": {
                     "primary": "여기 있어야 하나요?",
-                    "secondary": "이봐요 $1, 당신은 이 @테이블의 일부가 아니에요!"
+                    "secondary": "이봐요 $1, 당신은 이 @Table 일부가 아니에요!"
                 },
                 "UnknownColumn": "이 이름을 가진 열을 모르겠어요",
                 "UnexpectedColumnBind": {
-                    "primary": "나는 @바인드가 되어야 하나요?",
-                    "secondary": "이봐, 나는 @테이블이야. 나는 @바인드가 아닌 값들이 필요해."
+                    "primary": "나는 @Bind 되어야 하나요?",
+                    "secondary": "이봐, 나는 @Table. 나는 @Bind 아닌 값들이 필요해."
                 }
             }
         },
         "Token": {
             "name": "토큰",
             "description": "$?",
-            "emotion": "중립적인",
+            "emotion": "$?",
             "doc": [
                 "어떻게 나를 찾아냈나요?",
                 "나는 공연에서 가능한 가장 작은 부분입니다. 나는 우주의 모든 문자가 만들어지는 기반이며, 우리 안무의 원자 입자입니다."
@@ -252,8 +256,8 @@
         },
         "TypeVariable": {
             "name": "타입 입력",
-            "emotion": "호기심이 많은",
-            "doc": "@구조정의나 @함수정의에서 @타입변수를 대체하는 타입 목록입니다. 나는 모든 사람들이 어떤 종류의 입력을 받게 될지 알 수 있도록 도와줍니다.",
+            "emotion": "$?",
+            "doc": "@FunctionDefinition @StructureDefinition @TypeInputs 대체하는 타입 목록입니다. 나는 모든 사람들이 어떤 종류의 입력을 받게 될지 알 수 있도록 도와줍니다.",
             "conflict": {
                 "DuplicateTypeVariable": {
                     "primary": "나는 $1과 같은 이름을 가지고 있습니다",
@@ -263,23 +267,23 @@
         },
         "TypeVariables": {
             "name": "타입 변수들",
-            "emotion": "호기심이 많은",
-            "doc": "나는 @타입변수의 목록입니다."
+            "emotion": "$?",
+            "doc": "나는 @TypeVariable 목록입니다."
         },
         "Markup": {
             "name": "마크업",
             "description": "$1 문단들",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
-                "나는 @단어, @웹링크, @개념링크, 그리고 @예시와 같은 다양한 종류의 마크업을 사용하는 문단들의 목록입니다."
+                "나는 @Words, @WebLink, @ConceptLink, 그리고 @Example 같은 다양한 종류의 마크업을 사용하는 문단들의 목록입니다."
             ]
         },
         "Paragraph": {
             "name": "문단",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
-                "나는 @단어, @개념링크, @웹링크, 그리고 @예시의 연속으로, 빈 줄로 구분되며 @문서 안에 있습니다.",
-                "나를 쓰기 위해 필요한 것은 @문서에 많은 단어를 쓰는 것뿐입니다:",
+                "나는 @Words, @ConceptLink, @WebLink웹링크, 그리고 @Example 연속으로, 빈 줄로 구분되며 @Doc 안에 있습니다.",
+                "나를 쓰기 위해 필요한 것은 @Doc 많은 단어를 쓰는 것뿐입니다:",
                 "\\``나는 문서 속의 문단입니다.``'한 문단'\\",
                 "여러 문단을 원한다면, 그저 빈 줄을 넣으면 됩니다.",
                 "\\``문단 1.\n\n문단 2.\n\n문단 3.``'세 문단'\\"
@@ -288,7 +292,7 @@
         "WebLink": {
             "name": "링크",
             "description": "링크 $1",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
                 "나는 인터넷상의 무언가로의 링크입니다. 나는 설명과 URL만 필요로 합니다:",
                 "\\``나는 문서에서 <링크@https://wordplay.dev>입니다``\n'링크 예시'\\",
@@ -298,30 +302,30 @@
         "ConceptLink": {
             "name": "개념",
             "description": "개념 $1",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
-                "나는 벌스 캐릭터로의 링크입니다. 우리 중 하나를 @문서에 언급하고 싶을 때 유용합니다.",
-                "예를 들어, @평가에 대해 이야기하고 그들이 얼마나 멋진지 말하고 싶다면, 다음과 같이 쓸 수 있어요:",
-                "\\``알다시피, @평가는 꽤 멋져요.``\n'보세요, 개념 링크!'\\",
-                "여기에 작성한 @문서가 나타나면, 그 개념으로의 링크가 표시될 거예요."
+                "나는 벌스 캐릭터로의 링크입니다. 우리 중 하나를 @Doc 언급하고 싶을 때 유용합니다.",
+                "예를 들어, @Evaluate 대해 이야기하고 그들이 얼마나 멋진지 말하고 싶다면, 다음과 같이 쓸 수 있어요:",
+                "\\``알다시피, @Evaluate 꽤 멋져요.``\n'보세요, 개념 링크!'\\",
+                "여기에 작성한 @Doc 나타나면, 그 개념으로의 링크가 표시될 거예요."
             ]
         },
         "Words": {
             "name": "단어들",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
-                "나는 @문서 안에서 마음에 드는 어떤 단어들이에요. 예를 들면:",
+                "나는 @Doc 안에서 마음에 드는 어떤 단어들이에요. 예를 들면:",
                 "\\``포스가 함께 하기를.``\n'그냥 몇몇 단어들!'\\",
-                "하지만 때때로, @문서가 사용하는 특수 문자들을 /단어로써/ 사용하고 싶을 수도 있어요. 예를 들어:",
+                "하지만 때때로, @Doc 사용하는 특수 문자들을 /단어로써/ 사용하고 싶을 수도 있어요. 예를 들어:",
                 "\\``내 친구들은 @@, //, **, ||, 그리고 다른 기호들을 사용해요.``\n'특수 문자 사용하기!'\\",
                 "이 특수 문자들을 반복하기만 하면, 그 특수한 의미 대신 문자 자체를 얻을 수 있습니다."
             ]
         },
         "Example": {
             "name": "예제",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
-                "나는 무언가의 사용법을 설명하는 @문서를 작성할 때 유용한 예시 공연입니다!",
+                "나는 무언가의 사용법을 설명하는 @Doc 작성할 때 유용한 예시 공연입니다!",
                 "\\``덧셈의 예제를 보세요: \\1 + 1\\``'예제 코드'\\",
                 "만약 날 문단에 혼자 두면, 나는 멋진 상자 안에 나타나서 평가 결과를 보여줄 거예요.",
                 "\\``덧셈의 예제를 보세요:\n\n\\1 + 1\\``\\"
@@ -330,7 +334,7 @@
         "Mention": {
             "name": "언급",
             "description": "언급 $1",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
                 "나는 용어 \\$program\\ 또는 동적 입력 \\$1\\에 대한 참조입니다.",
                 "하지만 이것은 주로 내부 기능이므로, 알 필요는 없을 거예요."
@@ -338,7 +342,7 @@
         },
         "Branch": {
             "name": "분기",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
                 "나는 설명 입력 값이 정의되었거나 참인지에 따라 두 설명 세그먼트 중 하나를 선택하는 방법입니다.",
                 "하지만 이것은 주로 내부 기능이므로, 알 필요는 없을 거예요."
@@ -347,13 +351,13 @@
         "BinaryEvaluate": {
             "name": "이진 평가",
             "description": "$1 연산",
-            "emotion": "불안한",
+            "emotion": "$?",
             "doc": [
-                "나는 @평가의 더 단순한 형태입니다, 두 입력을 취하는 @함수정의를 사용하고 싶을 때 유용합니다.",
-                "예를 들어, 두 숫자를 더하는 데 @평가를 사용하는 방법은 다음과 같습니다:",
+                "나는 @Evaluate 더 단순한 형태입니다, 두 입력을 취하는 @FunctionDefinition 사용하고 싶을 때 유용합니다.",
+                "예를 들어, 두 숫자를 더하는 데 @Evaluate 사용하는 방법은 다음과 같습니다:",
                 "\\1.+(1)\\",
                 "조금 이상해 보이나요? 틀린 것은 아닙니다: 1에 더하기 함수를 가져와서 평가한다는 것을 의미해요.",
-                "하지만 @이진평가를 사용하는 것이 훨씬 쉽습니다",
+                "하지만 @BinaryEvaluate 사용하는 것이 훨씬 쉽습니다",
                 "\\1 + 1\\",
                 "이것은 기본적으로 같은 것이지만 모든 것을 좀 더 깔끔하게 만들어줍니다.",
                 "주의할 한 가지는: 이 형태에서는 나는 왼쪽에서 오른쪽으로 평가한다는 것입니다. 수학의 연산 순서에 익숙하다면 혼란스러울 수 있어요.",
@@ -365,20 +369,20 @@
             "start": "$1을 먼저 평가해 봅시다",
             "finish": "보세요, $1을 만들었습니다!",
             "conflict": {
-                "OrderOfOperations": "나는 읽는 순서대로 평가하며, 수학의 연산 순서대로 평가하지 않습니다. 평가해야 할 순서를 지정하기 위해 @블록을 사용하시겠습니까?"
+                "OrderOfOperations": "나는 읽는 순서대로 평가하며, 수학의 연산 순서대로 평가하지 않습니다. 평가해야 할 순서를 지정하기 위해 @Block 사용하시겠습니까?"
             }
         },
         "Bind": {
             "name": "바인드",
             "description": "바인드 $1",
-            "emotion": "신나는",
+            "emotion": "$?",
             "doc": [
                 "나는 *값들*에 이름을 붙입니다.",
                 "이렇게요!",
                 "\\파이: 3.1415926\\",
-                "나는 @함수정의와 @구조정의에 입력값에 이름을 붙이고, @블록 내의 값에 이름을 붙입니다. 나는 모든 것에 이름을 붙입니다!",
+                "나는 @FunctionDefinition @StructureDefinition 입력값에 이름을 붙이고, @Block 내의 값에 이름을 붙입니다. 나는 모든 것에 이름을 붙입니다!",
                 "오, 그런데 한 가지 값에 *여러 이름*을 붙일 수 있다는 것을 알고 계셨나요?",
-                "이에 대해 말씀드리게 되어 정말 신나요! 하나의 값에 여러 @이름들이 있습니다. 예를 들어:",
+                "이에 대해 말씀드리게 되어 정말 신나요! 하나의 값에 여러 @Names 있습니다. 예를 들어:",
                 "\\조,테스,에이미: 5\\",
                 "제가 한 일을 보세요?",
                 "하나의 값에 세 개의 이름.",
@@ -387,23 +391,26 @@
                 "\\조/en,에이미/fr,明/zh: 5\\",
                 "제가 한 일을 보세요? 하나의 값에 세 개의 다른 언어로 된 이름!",
                 "자, 마지막 비밀을 하나 알려드릴게요.",
-                "@Is와 함께 작동하여 이름에 어떤 종류의 값이 있어야 하는지 알려줄 수도 있다는 것을 알고 계셨나요? 그리고 그렇지 않다면, 저한테서 듣게 될 겁니다.",
+                "@Is 와 함께 작동하여 이름에 어떤 종류의 값이 있어야 하는지 알려줄 수도 있다는 것을 알고 계셨나요? 그리고 그렇지 않다면, 저한테서 듣게 될 겁니다.",
                 "이렇게요:",
                 "\\큰숫자•#: \"한 조\"\\",
                 "보세요, \\큰숫자\\가 숫자여야 한다고 했는데 텍스트이고, 그것들은 호환되지 않으므로 쾅!",
                 "그들이 동의하지 않으면 알려드릴 겁니다.",
-                "때로는 @함수정의에서처럼 스스로 파악할 수 없을 때 *반드시* 무슨 종류의 데이터인지 알려줘야 할 수도 있습니다.",
-                "예를 들어, 여기서 @함수정의는 \\a\\와 \\b\\가 어떤 종류의 값을 가지고 있는지 모릅니다, 왜냐하면 저는 그들에게 알려주지 않았거든요.",
+                "때로는 @FunctionDefinition 스스로 파악할 수 없을 때 *반드시* 무슨 종류의 데이터인지 알려줘야 할 수도 있습니다.",
+                "예를 들어, 여기서 @FunctionDefinition \\a\\와 \\b\\가 어떤 종류의 값을 가지고 있는지 모릅니다, 왜냐하면 저는 그들에게 알려주지 않았거든요.",
                 "\\ƒ sum(a b) a + b\\",
-                "하지만 @Is를 추가하면 이제 @함수정의는 그것들이 숫자라는 것을 알게 됩니다:",
+                "하지만 @Is 를 추가하면 이제 @FunctionDefinition 그것들이 숫자라는 것을 알게 됩니다:",
                 "\\ƒ sum(a•# b•#) a + b\\"
             ],
             "start": "$1에서 어떤 값을 얻는지 봅시다!",
             "finish": "오, 좋아요, $1을 얻었어요! 이름을 $2로 지어봅시다",
             "conflict": {
                 "DuplicateName": {
-                    "primary": "누군가가 이미 $1이라는 이름을 가지고 있어서, 이 이름을 사용할 수 없어요.",
-                    "secondary": "어, $1은 제 이름이에요"
+                    "conflict": {
+                        "primary": "누군가가 이미 $1이라는 이름을 가지고 있어서, 이 이름을 사용할 수 없어요.",
+                        "secondary": "어, $1은 제 이름이에요"
+                    },
+                    "resolution": "$?"
                 },
                 "DuplicateShare": {
                     "primary": "$1과 같은 이름을 가지고 있어서, 무엇이 공유되는지 모호해져요",
@@ -413,30 +420,30 @@
                     "primary": "저는 $2이어야 하는데, 실제로는 $1이에요",
                     "secondary": "오… 죄송해요, $1인가요, 정말로?"
                 },
-                "MisplacedShare": "@프로그램 레벨에서만 공유할 수 있어요, 어떤 것 안에서는 안 돼요!",
+                "MisplacedShare": "@Program 레벨에서만 공유할 수 있어요, 어떤 것 안에서는 안 돼요!",
                 "MissingShareLanguages": "이것을 공유하고 싶다면, 어떤 언어인지 말해야 해서 다른 사람들이 읽을 수 있는지 알 수 있어요!",
                 "RequiredAfterOptional": "제가 여기 있으면 안 돼요, 저 앞에 선택적인 @바인드가 있어요",
-                "UnexpectedEtc": "@함수정의에서만 가변 길이가 될 수 있어요",
+                "UnexpectedEtc": "@FunctionDefinition 가변 길이가 될 수 있어요",
                 "UnusedBind": "이 값을 이름 지었는데, 아무도 사용하지 않고 있어요!"
             }
         },
         "Block": {
             "name": "블록",
             "description": "$1 문장",
-            "emotion": "수줍은",
+            "emotion": "$?",
             "doc": [
                 "안녕하세요. 저는 조용하고 개인적인 공간을 만들어 평가하는 것들을 위한 곳입니다.",
                 "이렇게요:",
                 "\\(1 - 1) + 2\\",
                 "이는 평가 순서를 명확하게 해줍니다.",
-                "@바인드도 도움이 됩니다.",
+                "@Bind 도움이 됩니다.",
                 "\\(count: 10 count ^ count)\\",
-                "@바인드가 \\count\\를 만든 것을 보세요? 이것은 저 안에서만 이름이 붙여집니다. 그래서 이건 작동하지 않아요:",
+                "@Bind \\count\\를 만든 것을 보세요? 이것은 저 안에서만 이름이 붙여집니다. 그래서 이건 작동하지 않아요:",
                 "\\(count: 10 count ^ count) + count\\",
                 "왜냐하면 count는 저 안에서만 이름이 붙여졌기 때문입니다.",
                 "저 안에는 원하는 만큼의 표현식을 넣을 수 있습니다. 하지만 저는 마지막 것만 신경 쓰죠:",
                 "\\(1 2 3 4 5)\\",
-                "그래서 보통 저는 많은 @바인드와 마지막에 표현식을 가지고 있습니다.",
+                "그래서 보통 저는 많은 @Bind 마지막에 표현식을 가지고 있습니다.",
                 "\\(\n  a: 1\n  b: 2\n  c: 3\n  d: 4\n  a + b + c + d\n)\\"
             ],
             "statement": "문장",
@@ -446,22 +453,22 @@
                 "ExpectedEndingExpression": "표현식이 필요합니다.",
                 "IgnoredExpression": {
                     "primary": "위의 것은 무시할 거예요.",
-                    "secondary": "@블록, 저를 무시하지 마세요!"
+                    "secondary": "@Block, 저를 무시하지 마세요!"
                 }
             }
         },
         "BooleanLiteral": {
             "name": "특정 부울",
             "description": "$1[참|거짓]",
-            "emotion": "정확한",
-            "doc": "나는 \\⊤\\ 또는 \\⊥\\ 중 하나입니다. 우리의 아름다운 논리에 대해 더 알고 싶다면 @부울을 참조하세요.",
+            "emotion": "$?",
+            "doc": "나는 \\⊤\\ 또는 \\⊥\\ 중 하나입니다. 우리의 아름다운 논리에 대해 더 알고 싶다면 @Boolean 참조하세요.",
             "start": "$1!"
         },
         "Borrow": {
             "name": "빌리기",
             "description": "빌리기 $1[$1|이름 누락]",
-            "emotion": "신나는",
-            "doc": "여러 @소스로 공연을 만들 때, 다른 @소스에 공유된 @바인드를 빌리기 위해 저를 사용할 수 있습니다. 그들의 이름을 사용하기만 하면 그들의 이름과 값을 가져올게요.",
+            "emotion": "$?",
+            "doc": "여러 @Source 공연을 만들 때, 다른 @Bind 공유된 @Source 빌리기 위해 저를 사용할 수 있습니다. 그들의 이름을 사용하기만 하면 그들의 이름과 값을 가져올게요.",
             "start": "$1에서 $2 빌리기",
             "source": "$source",
             "bind": "이름",
@@ -479,9 +486,9 @@
         },
         "Changed": {
             "name": "변경됨",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
-                "스트림이 @프로그램을 재평가하게 했는지 확인하고 @부울을 만듭니다. 이렇게요",
+                "스트림이 @Program 재평가하게 했는지 확인하고 @Boolean 만듭니다. 이렇게요",
                 "\\∆ 시간()\\",
                 "스트림이 변경되었을 때만 무언가가 변경되기를 원할 때 정말 유용합니다.",
                 "그게 다에요."
@@ -490,7 +497,7 @@
         },
         "Conditional": {
             "name": "조건문",
-            "emotion": "호기심 많은",
+            "emotion": "$?",
             "doc": [
                 "제가 결정을 내려야 하나요? 이렇게 말이죠?",
                 "\\숫자: -100\n숫자 < 0 ? '음수' '양수'\\",
@@ -508,28 +515,28 @@
             "conflict": {
                 "ExpectedBooleanCondition": {
                     "primary": "$1로 어떻게 예와 아니오를 선택할 수 있죠? 정말로, 어떻게요?",
-                    "secondary": "@조건문이 저를 @부울로 원했던 것 같은데, 저는 $1입니다."
+                    "secondary": "@Conditional 저를 @Boolean 원했던 것 같은데, 저는 $1입니다."
                 }
             }
         },
         "ConversionDefinition": {
             "name": "변환 정의",
             "description": "$1 → $2",
-            "emotion": "신나는",
+            "emotion": "$?",
             "doc": [
-                "이봐요, 저는 한 타입에서 다른 타입으로의 변환을 정의해요! @블록 안에서 이렇게 쓰이죠:",
+                "이봐요, 저는 한 타입에서 다른 타입으로의 변환을 정의해요! @Block 안에서 이렇게 쓰이죠:",
                 "\\→ #kitty #cat . ÷ 2\n6kitty→#cat\\",
                 "제가 어떻게 키티를 고양이로 바꿨는지 보이나요? 멋져요!",
                 "점 (\\.)이 무엇을 하는지 궁금하실 겁니다. 그것은 변환되는 값을 나타냅니다. 그 값이 그렇지 않으면 이름이 없기 때문에 저는 그것을 사용해요."
             ],
             "start": "대단해, 새로운 변환!",
             "conflict": {
-                "MisplacedConversion": "어머, 여기 있으면 안 돼요, @블록에서만 가능해요."
+                "MisplacedConversion": "어머, 여기 있으면 안 돼요, @Block 가능해요."
             }
         },
         "Convert": {
             "name": "변환",
-            "emotion": "명랑한",
+            "emotion": "$?",
             "doc": [
                 "안녕. 저는 값을 하나의 타입에서 다른 타입으로 변환해요. 이것 좀 보세요:",
                 "\\1 → \"\"\\",
@@ -537,7 +544,7 @@
                 "\\\"안녕\" → []\\",
                 "이것들을 연쇄적으로 결합할 수도 있어요:",
                 "\\\"안녕\" → [] → {}\\",
-                "값들은 사전에 정의된 @변환정의 집합을 가지고 있지만, 새로운 타입의 값을 위한 @구조정의를 만들 경우, @변환정의를 사용하여 자신만의 것을 정의할 수 있어요."
+                "값들은 사전에 정의된 @ConversionDefinition 집합을 가지고 있지만, 새로운 타입의 값을 위한 @StructureDefinition 만들 경우, @ConversionDefinition 사용하여 자신만의 것을 정의할 수 있어요."
             ],
             "start": "$1에서 값을 가져와요!",
             "finish": "대단해, $1을 만들었어요",
@@ -553,7 +560,7 @@
         },
         "Delete": {
             "name": "삭제",
-            "emotion": "화난",
+            "emotion": "$?",
             "doc": [
                 "가끔 테이블에 너무 많은 것이 들어 있는 경우가 있어요!",
                 "예를 들어, 게임에 플레이어들이 있는데 한 명이 떠나고 당신은 그저 '플레이어야, 사라져! 내 테이블에서 나가!'라고 말하고 싶을 때요.",
@@ -565,7 +572,7 @@
         },
         "DocumentedExpression": {
             "name": "설명된 표현",
-            "emotion": "열렬한",
+            "emotion": "$?",
             "doc": [
                 "나는 @Doc을 붙인 표현이야!",
                 "나를 만들려면, 표현 앞에 @Doc를 넣기만 하면 돼:",
@@ -577,7 +584,7 @@
         "Evaluate": {
             "name": "평가하다",
             "description": "$1[$1|anonymous]을 평가해",
-            "emotion": "수줍은",
+            "emotion": "$?",
             "doc": [
                 "안녕. 나는 @FunctionDefinition을 이렇게 해석해:",
                 "\\ƒ greeting(message•'')\ngreeting('kitty')\\",
@@ -630,7 +637,7 @@
         "ExpressionPlaceholder": {
             "name": "자리 표시자",
             "description": "$1[$1|자리 표시자]",
-            "emotion": "두려움",
+            "emotion": "$?",
             "doc": [
                 "나는 *표현*이지만 실제로는 아니야… 나는 그냥 다른 것을 대신하는 역할을 하는거야.",
                 "아직 무엇을 쓸지 모르면 내가 유용해. 이렇게 사용할 수 있어:",
@@ -655,7 +662,7 @@
         "FunctionDefinition": {
             "name": "함수",
             "description": "$1 함수",
-            "emotion": "친절함",
+            "emotion": "$?",
             "doc": [
                 "안녕! 나는 몇 가지 입력을 받고, 그 입력을 사용하여 표현을 평가하고 출력을 생성해내는 함수야.",
                 "간단한 예를 보여줄게:",
@@ -679,7 +686,7 @@
         },
         "Iteration": {
             "name": "고차 함수",
-            "emotion": "친절함",
+            "emotion": "$?",
             "doc": "나는 @FunctionDefinition 중 특별한 종류로, 여러 가지 항목들의 목록에 작용해. 나에 대해 자세히 알 필요는 없어, 나는 @List/translate와 같은 함수를 만들어내기 위한 거야.",
             "start": "주어진 함수를 평가하는 중",
             "initialize": "항목들을 순회하기 위해 준비 중",
@@ -689,7 +696,7 @@
         },
         "Initial": {
             "name": "시작",
-            "emotion": "호기심",
+            "emotion": "$?",
             "doc": [
                 "@Program의 현재 평가가 첫 번째인지 여부를 알려주는 역할을 하는데, 이것은 @Boolean으로 평가돼. 예를 들어:",
                 "\\◆ ? Time() 'hi'\\",
@@ -699,7 +706,7 @@
         },
         "Insert": {
             "name": "삽입",
-            "emotion": "친절함",
+            "emotion": "$?",
             "doc": [
                 "@Table이 있고 뭔가 부족한 느낌일 때가 있지? 나는 그것을 추가할 수 있어!",
                 "게임에서 선수들의 테이블이 있다고 가정해봐. 새로운 선수를 추가하고 싶을 때:",
@@ -712,7 +719,7 @@
         "Is": {
             "name": "이다",
             "description": "이다",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": [
                 "그거 알아? 정말 다양한 의미를 가진 많은 종류의 값들이 있어. 나는 그것들이 무엇을 의미하는지 찾는 데 도움이 돼.",
                 "예를 들면, 수수께끼 값이 있다고 상상해봐. 나는 그것이 @Number인지, @Boolean을 주는지 알려줄 수 있어:",
@@ -737,7 +744,7 @@
         "IsLocale": {
             "name": "언어인가?",
             "description": "언어인가?",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
                 "나는 너가 특정 언어나 지역을 선택했는지 확인하는 데 도움이 돼:",
                 "\\🌍/en\\",
@@ -748,7 +755,7 @@
         },
         "ListAccess": {
             "name": "리스트 접근",
-            "emotion": "신이 나는",
+            "emotion": "$?",
             "doc": [
                 "@List와 긴밀하게 협력해서 특정 위치의 값을 얻는 데 도움을 줘. 예를 들면, 리스트가 있고 그 중 두 번째 아이템을 원한다면 이렇게 쓸 수 있어:",
                 "\\list: ['새' '오리' '물고기' '뱀']\nlist[2]\\"
@@ -759,7 +766,7 @@
         "ListLiteral": {
             "name": "특정 리스트",
             "description": "$1 항목 리스트",
-            "emotion": "열렬한",
+            "emotion": "$?",
             "doc": "@List의 구체적인 값들의 리스트야! 나에 대해 더 알고 싶다면 @List를 참고해봐.",
             "start": "먼저 항목을 평가해보자",
             "finish": "나는 나를 만들었어! $1",
@@ -767,7 +774,7 @@
         },
         "Spread": {
             "name": "리스트 확장",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
                 "다른 리스트들의 값으로 리스트를 만들 수 있게 도와주는 거야. 이렇게:",
                 "\\list1: [1 2 3]\nlist2: [4 5 6]\nfinal: [list1… list2…]"
@@ -776,7 +783,7 @@
         "MapLiteral": {
             "name": "맵",
             "description": "$1 쌍 맵",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": "@Map의 구체적인 키와 값 사이의 연결이야. 나에 대해 더 알고 싶다면 @Map을 참고해봐.",
             "start": "먼저 키와 값을 평가해보자",
             "finish": "나는 모두를 연결했어, $1",
@@ -787,10 +794,20 @@
                 }
             }
         },
+        "Match": {
+            "name": "$?",
+            "emotion": "$?",
+            "doc": ["$?"],
+            "start": "$?",
+            "case": "$?",
+            "finish": "$?",
+            "value": "$?",
+            "other": "$?"
+        },
         "NumberLiteral": {
             "name": "특정 숫자",
             "description": "$1 $2[$2|]",
-            "emotion": "흥분한",
+            "emotion": "$?",
             "doc": "@Number의 구체적인 값이야. 어떤 언어의 어떤 종류의 숫자든 나를 쓸 수 있어. 내가 할 수 있는 모든 걸 알려면 @Number를 참고해봐.",
             "start": "$1!",
             "conflict": {
@@ -799,19 +816,26 @@
         },
         "InternalExpression": {
             "name": "내부 표현",
-            "emotion": "중립적인",
+            "emotion": "$?",
             "doc": "어떻게 나를 찾았어? 나는 원조 창조자만 사용하는 표현이야. 나에 대해 더 알고 싶다면 그들에게 말해봐.",
             "start": "비밀 표현"
         },
         "NoneLiteral": {
             "name": "그냥 없음",
-            "emotion": "중립적인",
+            "emotion": "$?",
             "doc": "/@FunctionDefinition 여기. 이건 그냥 @None이야. 이건 독특한 존재야! @None에 대해 더 알고 싶다면 @None을 참고해봐.",
             "start": "… ø"
         },
+        "Otherwise": {
+            "name": "$?",
+            "emotion": "curious",
+            "doc": "$?",
+            "start": "$?",
+            "finish": "$?"
+        },
         "Previous": {
             "name": "이전",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
                 "과거를 기억해보고 싶었던 적이 있니?",
                 "나는 Verse의 공식 기록관이야. 나에게 스트림과 숫자를 줘서 과거에서 그 스트림의 값이 어떤지 말해줄게.",
@@ -828,7 +852,7 @@
         },
         "Program": {
             "name": "프로그램",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
                 "여러 캐릭터들이 공연을 조정하는 곳이야, 공연의 시작과 끝을 담당해.",
                 "@Block이 표현 목록을 평가하고 목록에서 마지막 값으로 평가되는 거 알지?",
@@ -865,7 +889,7 @@
         "PropertyBind": {
             "name": "다듬기",
             "description": "$1[$1|이름 없음] 다듬기",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
                 "@StructureDefinition을 만들 때 작은 변경만 하고 싶을 때가 있어, 모든 값을 똑같이 가지고 있는 새로운 것을 만들 필요 없이.",
                 "예를 들면, 고양이 기록을 유지하고 있었는데 고양이의 취미를 바꾸고 싶다면 내가 도와줄게:",
@@ -873,12 +897,18 @@
                 "이전 값과 똑같은 값들을 가진 전체 새로운 \\Cat\\을 만드는 것보다 이게 훨씬 쉬워, 그치."
             ],
             "start": "먼저 값을 가져오자",
-            "finish": "구조를 복사했지만 $1을(를) $2로 만들었어"
+            "finish": "구조를 복사했지만 $1을(를) $2로 만들었어",
+            "conflict": {
+                "InvalidProperty": {
+                    "primary": "$?",
+                    "secondary": "$?"
+                }
+            }
         },
         "PropertyReference": {
             "name": "속성",
             "description": "$1[$1|이름 없음] 속성",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
                 "@StructureDefinition을 만들 때 그 중 하나의 입력을 어떻게 얻을지에 대한 것이야.",
                 "도시에 관한 구조를 만든다면 나를 통해 이렇게 값을 얻을 수 있어:",
@@ -890,10 +920,10 @@
         },
         "Reaction": {
             "name": "반응",
-            "emotion": "신나는",
+            "emotion": "$?",
             "doc": [
                 "스트림은 정말 멋져요! 변경될 때마다 새로운 것들을 만들 수 있어요, 이건 정말 멋진 일이죠!",
-                "예를 들어, @시간이 흐르는 것을 보여주고 싶지만, 숫자 대신 단어로 표현하고 싶다면 이렇게 할 수 있어요:",
+                "예를 들어, @Time 흐르는 것을 보여주고 싶지만, 숫자 대신 단어로 표현하고 싶다면 이렇게 할 수 있어요:",
                 "\\시간: Time(1000ms)\n'시작' … ∆ 시간 … ((시간 % 2) = 0ms) ? '짝수' '홀수'\\",
                 "이것은 \"/'시작'이라는 단어로 시작해서 시간이 변경될 때마다 '짝수' 또는 '홀수'로 변경되는 것을 의미해요./\"",
                 "그래서 저도 스트림이지만, 다른 스트림을 기반으로 한 것이죠. 멋지지 않나요?"
@@ -910,29 +940,29 @@
         "Reference": {
             "name": "참조",
             "description": "$1",
-            "emotion": "수줍은",
+            "emotion": "$?",
             "doc": [
-                "@바인드가 것들에게 @이름을 부여하는 것을 알고 있죠? 저는 그것들을 참조하는 방법입니다. 어떤 @바인드가 그 이름을 가지고 있는지 확인하고, 그렇다면 그 값은 제공합니다. 이렇게요:",
+                "@Bind 것들에게 @Name 부여하는 것을 알고 있죠? 저는 그것들을 참조하는 방법입니다. 어떤 @Bind 그 이름을 가지고 있는지 확인하고, 그렇다면 그 값은 제공합니다. 이렇게요:",
                 "\\앵무새: '폴리'\n앵무새\\",
                 "만약 제가 그 이름을 찾지 못하면, 무엇을 해야 할지 모르겠어요.",
                 "\\앵무새: '폴리'\n페리\\"
             ],
             "start": "$1은 어떤 값을 가지고 있나요?",
             "conflict": {
-                "UnknownName": "$1[이름이 $1인 사람을 $2[$2|이 @블록에서] 모릅니다|이름을 알려줄 수 있나요?]",
+                "UnknownName": "$1[이름이 $1인 사람을 $2[$2|이 @Block] 모릅니다|이름을 알려줄 수 있나요?]",
                 "ReferenceCycle": "음, $1의 값이 자기 자신에 의존하는데, 어떤 값을 제공해야 할지 어떻게 알 수 있죠?",
                 "UnexpectedTypeVariable": "이 타입 입력들로 무엇을 해야 할지 모르겠어요"
             },
             "exception": {
                 "NameException": {
                     "description": "알 수 없는 이름",
-                    "explanation": "$1[이름이 $1인 사람을 $2[$2|이 @블록에서]… 알 수 없습니다|으앗, 이름이 없어요!]"
+                    "explanation": "$1[이름이 $1인 사람을 $2[$2|이 @Block]… 알 수 없습니다|으앗, 이름이 없어요!]"
                 }
             }
         },
         "Select": {
             "name": "선택",
-            "emotion": "신나는",
+            "emotion": "$?",
             "doc": [
                 "가끔 테이블이 있고 그 중 일부만 원할 때가 있어요. 저는 그것을 가져다 드릴 수 있어요!",
                 "예를 들어, 게임에서 플레이어들의 테이블이 있고, 점수가 10점 이상인 사람들을 찾아 누가 이겼는지 알고 싶다면:",
@@ -948,19 +978,19 @@
         "SetLiteral": {
             "name": "특정 세트",
             "description": "$1 아이템",
-            "emotion": "열정적인",
-            "doc": "저는 특정 값들의 특정 @세트예요. 저와 함께 작업하는 방법에 대해 더 알고 싶다면 @세트를 참조하세요.",
+            "emotion": "$?",
+            "doc": "저는 특정 값들의 특정 @Set. 저와 함께 작업하는 방법에 대해 더 알고 싶다면 @Set 참조하세요.",
             "start": "먼저 값들을 평가해 봅시다!",
             "finish": "세트 $1을 만들었어요!"
         },
         "SetOrMapAccess": {
             "name": "세트/맵 접근",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
-                "@세트 또는 @맵에 값이나 키가 있는지 확인할 수 있어요.",
+                "@Set 또는 @Map 값이나 키가 있는지 확인할 수 있어요.",
                 "그리 어렵지 않아요. 이렇게 말이죠:",
                 "\\좋아하는 것들: {'오리' '거위' '원숭이'}\n좋아하는 것들{'쥐'}\\",
-                "또는 @맵을 사용하여 이렇게요:",
+                "또는 @Map 사용하여 이렇게요:",
                 "\\좋아하는 것들: {'맥앤치즈': 5별 '시리얼': 2별 '죽': 1별}\n좋아하는 것들{'죽'}\\"
             ],
             "start": "세트나 맵은 무엇인가요?",
@@ -974,32 +1004,32 @@
         },
         "Source": {
             "name": "소스",
-            "emotion": "호기심 많은",
+            "emotion": "$?",
             "doc": [
-                "@프로그램을 알고 계시나요? 저는 그것들에 이름을 붙여주는 데 도움을 줍니다. @프로그램 주변의 창문과 그것들에 붙이는 이름처럼 생각하세요.",
-                "다른 @프로그램과 함께 다른 @소스 @UI/소스추가를 만들고, 다른 @프로그램에서 @빌리기를 통해 다른 프로그램에서 사용할 것들을 가져올 수도 있어요.",
+                "@Program 알고 계시나요? 저는 그것들에 이름을 붙여주는 데 도움을 줍니다. @Program 주변의 창문과 그것들에 붙이는 이름처럼 생각하세요.",
+                "다른 @Source프로그램과 함께 다른 @Source @UI/addSource 만들고, 다른 @Program @Borrow 통해 다른 프로그램에서 사용할 것들을 가져올 수도 있어요.",
                 "이것은 큰 공연을 별도의 문서로 조직하는 좋은 방법이 될 수 있습니다."
             ]
         },
         "StreamDefinition": {
             "name": "스트림",
-            "emotion": "호기심 많은",
+            "emotion": "$?",
             "doc": "제가 새로운 스트림을 만들어야 한다고 /생각/합니다. 하지만 정말로 그 방법을 모르겠어요. 지금은, 이미 존재하는 스트림을 사용하는 것이 좋겠죠?",
             "start": "이 새로운 종류의 스트림을 만듭니다"
         },
         "StructureDefinition": {
             "name": "구조",
             "description": "구조 $1",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
                 "안녕하세요, 어떠세요? 저요? 저는 잘 지내고 있어요. 값을 저장하고 기능하는 구조를 정의하는 것을 좋아해서, 그 일을 하루 종일 할 수 있다면 저는 행복해요.",
                 "저는 이렇게 작동해요:",
                 "\\•피자(\n재료들•['']\n크기•#인치\n) (\n\tƒ 비용() 크기 · 10달러/인치\n)\n\n피자(['페퍼로니' '페퍼'] 12인치).비용()\\",
                 "작동 방식을 보세요? \\피자\\를 정의했는데, 두 개의 입력, \\재료들\\ (텍스트 목록)과 \\크기\\ (인치 단위의 숫자)가 있어요.",
-                "내부에서, @함수정의는 인치 당 $10을 가정하여 피자 비용을 평가하는 함수를 만들었어요.",
-                "저는 @함수정의가 없어도 됩니다. 단지 입력들만 있을 수 있어요.",
+                "내부에서, @FunctionDefinition 인치 당 $10을 가정하여 피자 비용을 평가하는 함수를 만들었어요.",
+                "저는 @FunctionDefinition 없어도 됩니다. 단지 입력들만 있을 수 있어요.",
                 "\\•피자(\n재료들•['']\n크기•#인치\n)\\",
-                "또한 내부에 @바인드를 가질 수 있어서, 미리 비용을 평가할 수 있어요.",
+                "또한 내부에 @Bind 가질 수 있어서, 미리 비용을 평가할 수 있어요.",
                 "\\•피자(\n재료들•['']\n크기•#인치\n) (\n\t비용: 크기 · 10달러/인치\n)\n\n피자(['페퍼로니' '페퍼'] 12인치).비용\\"
             ],
             "start": "이 멋진 구조를 정의해 봅시다",
@@ -1019,37 +1049,46 @@
         "TableLiteral": {
             "name": "특정 테이블",
             "description": "$1 행 테이블",
-            "emotion": "화난",
-            "doc": "저는 특정한 행들을 가진 구체적인 테이블입니다. 저를 어떻게 활용할 수 있는지 @테이블에서 확인해보세요.",
+            "emotion": "$?",
+            "doc": "저는 특정한 행들을 가진 구체적인 테이블입니다. 저를 어떻게 활용할 수 있는지 @Table 확인해보세요.",
             "start": "먼저 행들을 평가합니다",
             "finish": "새 테이블 $1로 평가되었습니다"
         },
         "TextLiteral": {
             "name": "특정 텍스트",
             "description": "텍스트 $1",
-            "emotion": "진지한",
-            "doc": "저는 하나 이상의 구체적인 @번역된 텍스트를 나타냅니다. 저의 기능에 대해 더 알고 싶다면 @텍스트를 참조하세요!",
+            "emotion": "$?",
+            "doc": "저는 하나 이상의 구체적인 @Translation 텍스트를 나타냅니다. 저의 기능에 대해 더 알고 싶다면 @Text 참조하세요!",
             "start": "현재 로케일에서 텍스트를 만듭시다"
         },
         "Translation": {
             "name": "번역",
             "description": "텍스트 $1",
-            "emotion": "진지한",
-            "doc": "저는 @언어 태그가 있는 텍스트를 나타냅니다. 저에 대해 더 알고 싶다면 @텍스트를 참조하세요!"
+            "emotion": "$?",
+            "doc": "저는 @Language 태그가 있는 텍스트를 나타냅니다. 저에 대해 더 알고 싶다면 @Text 참조하세요!",
+            "conflict": {
+                "phone": "$?",
+                "email": "$?",
+                "tin": "$?",
+                "address": "$?",
+                "handle": "$?",
+                "resolution": "$?",
+                "reminder": "$?"
+            }
         },
         "FormattedLiteral": {
             "name": "포맷된 텍스트",
             "description": "텍스트 $1",
-            "emotion": "진지한",
-            "doc": "저는 다양한 @포맷된번역의 포맷된 텍스트를 나타냅니다. 평가할 때, 관객의 선택된 언어에 기반하여 최적의 일치를 선택할 거예요.",
+            "emotion": "$?",
+            "doc": "저는 다양한 @FormattedTranslation 포맷된 텍스트를 나타냅니다. 평가할 때, 관객의 선택된 언어에 기반하여 최적의 일치를 선택할 거예요.",
             "start": "현재 로케일에서 텍스트를 만듭시다"
         },
         "FormattedTranslation": {
             "name": "포맷된 텍스트",
             "description": "텍스트 $1",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
-                "저는 @언어 태그가 있는 포맷된 텍스트를 나타냅니다.",
+                "저는 @Language 태그가 있는 포맷된 텍스트를 나타냅니다.",
                 "저는 다음과 같을 수 있어요:",
                 "\\`/이탤릭/`\\",
                 "\\`*볼드*`\\",
@@ -1057,21 +1096,21 @@
                 "\\`_밑줄_`\\",
                 "\\`<링크@https://wordplay.dev>`\\",
                 "\\`\\'코드'\\`\\",
-                "@프레이즈와 함께 @무대에 아름다운 텍스트를 올리는 데 정말 잘 작동해요."
+                "@Phrase 함께 @Stage 아름다운 텍스트를 올리는 데 정말 잘 작동해요."
             ]
         },
         "This": {
             "name": "이것",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
                 "가끔은 값을 명시적으로 이름 짓기보다는 암시적으로 참조하는 것이 도움이 됩니다.",
-                "예를 들어, 변환되는 값을 이름으로 지정하지 않는 새로운 @변환정의를 만들고 싶다고 가정해 봅시다. 저를 사용하여 그것을 참조할 수 있어요:",
+                "예를 들어, 변환되는 값을 이름으로 지정하지 않는 새로운 @ConversionDefinition 만들고 싶다고 가정해 봅시다. 저를 사용하여 그것을 참조할 수 있어요:",
                 "\\→ #무지개 #기쁨 . · 1000000기쁨\n2무지개 → #기쁨\\",
                 "저를 보세요, 무지개의 수를 대표하고 있죠?",
-                "또는 @반응을 만들고 싶지만 가장 최근의 값을 이름으로 지정하고 싶지 않다면:",
+                "또는 @Reaction 만들고 싶지만 가장 최근의 값을 이름으로 지정하고 싶지 않다면:",
                 "\\2 … ∆ 시간(1000ms) … . · 2\\",
                 "저를 확인하세요, 이전 반응 값을 대표하고 있습니다.",
-                "자주 등장하지는 않지만, 등장할 때면 @바인드에서 값을 정말 도와줄 수 있어요!"
+                "자주 등장하지는 않지만, 등장할 때면 @Bind 값을 정말 도와줄 수 있어요!"
             ],
             "start": "$1로 평가되었습니다",
             "conflict": {
@@ -1081,25 +1120,25 @@
         "UnaryEvaluate": {
             "name": "단항 평가",
             "description": "$1",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
-                "하나의 값만 평가하는 @함수정의에 있어서, @함수정의의 이름이 단일 기호일 경우, 입력 앞에 이름을 둘 수 있다는 것을 알고 계셨나요?",
+                "하나의 값만 평가하는 @FunctionDefinition 있어서, @FunctionDefinition 이름이 단일 기호일 경우, 입력 앞에 이름을 둘 수 있다는 것을 알고 계셨나요?",
                 "이렇게 말이죠:",
                 "\\-(1 + 1)\\",
                 "또는 이렇게:",
                 "\\~⊥\\",
                 "\\(1 + 1).negate()\\ 또는 \\⊥.not()\\보다 읽기 훨씬 쉽죠?",
                 "저를 그렇게 쓸 필요는 없지만, 전체적으로 더 쉬울 수 있어요.",
-                "한 가지 규칙이 있습니다: 이름과 값 사이에 공백을 둘 수 없어요. 그렇지 않으면 @참조 또는 @이항평가를 만들 수 있습니다."
+                "한 가지 규칙이 있습니다: 이름과 값 사이에 공백을 둘 수 없어요. 그렇지 않으면 @Reference 또는 @BinaryEvaluate 만들 수 있습니다."
             ],
             "start": "값이 무엇인가요?",
             "finish": "$1을 만들었습니다"
         },
         "UnparsableExpression": {
             "name": "해석 불가",
-            "emotion": "신나는",
+            "emotion": "$?",
             "doc": [
-                "/안녕하세요, @함수정의입니다. 해석하기 어려운 @해석불가표현식을 대신 번역하고 있어요./",
+                "/안녕하세요, @FunctionDefinition. 해석하기 어려운 @UnparsableExpression 대신 번역하고 있어요./",
                 "jkwel fjiwojvioao jjiweo jrfe",
                 "/무대에서 모든 표현식이 의미를 가지는 것은 아닙니다./",
                 "s w ieorjwei iojwi jfkdlsfdsk",
@@ -1110,24 +1149,27 @@
             ],
             "start": "???",
             "conflict": {
-                "UnparsableConflict": "@함수정의 여기 있어요, @해석불가표현식은 이것이 어떤 종류의 $1[ 표현 | 타입 ]인지 모르겠어요/",
+                "UnparsableConflict": {
+                    "conflict": "@FunctionDefinition 여기 있어요, @UnparsableExpression 이것이 어떤 종류의 $1[ 표현 | 타입 ]인지 모르겠어요/",
+                    "resolution": "$?"
+                },
                 "UnclosedDelimiter": "$1 이후에 언젠가 $2가 나올 것이라고 예상했어요"
             },
             "exception": {
                 "UnparsableException": {
                     "description": "???",
-                    "explanation": "/안녕하세요, @함수정의입니다! 우리는 이것이 어떤 종류의 지시인지 몰라 공연을 중단해야 했어요./"
+                    "explanation": "/안녕하세요, @FunctionDefinition! 우리는 이것이 어떤 종류의 지시인지 몰라 공연을 중단해야 했어요./"
                 }
             }
         },
         "Update": {
             "name": "업데이트",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
-                "저는 @테이블을 수정하는 데 도움을 줍니다. 조건에 맞는 행을 찾아 새로운 값으로 개정된 행을 생성합니다.",
+                "저는 @Table 수정하는 데 도움을 줍니다. 조건에 맞는 행을 찾아 새로운 값으로 개정된 행을 생성합니다.",
                 "예를 들어, 캐릭터와 점수가 있는 테이블이 있고, 특정 팀의 모든 캐릭터에게 점수를 주고 싶다면 이렇게 할 수 있습니다:",
                 "\\플레이어: ⎡이름•'' 팀•'' 점수•#⎦\n⎡'jen' 'red' 1⎦\n⎡'joan' 'blue' 0⎦\n⎡'jeff' 'red' 3⎦\n⎡'janet' 'blue' 2⎦\n플레이어 ⎡: 점수: 점수 + 1 ⎦ 팀 = 'blue'\\",
-                "변경할 열을 지정하기 위해 @바인드를 사용할 수 있고, 조건에는 열 이름이나 범위 안의 다른 이름을 사용할 수 있습니다."
+                "변경할 열을 지정하기 위해 @Bind 사용할 수 있고, 조건에는 열 이름이나 범위 안의 다른 이름을 사용할 수 있습니다."
             ],
             "start": "먼저 테이블을 가져와 봅시다",
             "finish": "개정된 행을 포함한 새 테이블로 평가되었습니다!",
@@ -1141,21 +1183,21 @@
         },
         "AnyType": {
             "name": "아무 타입",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": "나는 어떤 가능한 타입이든 대표해. 가끔 나타나는 이유는 뭔가의 값이 어떤 종류인지 모르기 때문에 뭐든 될 수 있어."
         },
         "BooleanType": {
             "name": "불리언",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
-                "나는 @Bind와 함께 작동해서 이름이 @Boolean 값임을 선언해. 이렇게:",
+                "나는 @Bind 함께 작동해서 이름이 @Boolean 값임을 선언해. 이렇게:",
                 "\\hungry•?: 'jello'\\",
                 "뭔가가 정말 @Boolean인지 확실하게 하려면 나를 사용해, 내가 확인해 줄게!"
             ]
         },
         "ConversionType": {
             "name": "변환",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
                 "@Bind와 함께 작동해서 이름이 @ConversionDefinition인 것을 나타냄. 아마도 나를 사용할 일은 별로 없을 거야, 왜냐하면 많은 사람들이 나를 값으로 전달하지 않기 때문이지만, 만약에 나를 사용한다면 이렇게 보일거야:",
                 "\\magic•?→'': → ? '' . ? 'yep' 'nope'\\"
@@ -1163,7 +1205,7 @@
         },
         "FormattedType": {
             "name": "포맷된",
-            "emotion": "진지한",
+            "emotion": "$?",
             "doc": [
                 "@Bind와 함께 작동해서 이름이 @FormattedLiteral 값임을 알림. 이렇게:",
                 "\\hungry•`…`: `I am so /fancy/!`\\",
@@ -1172,13 +1214,13 @@
         },
         "ExceptionType": {
             "name": "예외",
-            "emotion": "중립적인",
+            "emotion": "$?",
             "doc": "나는 예외를 나타냄. 나는 어떻게 보든지 @Program을 중단하기 때문에 나는 값으로 사용할 수 없어."
         },
         "FunctionType": {
             "name": "함수 타입",
             "description": "$1 입력, $2 출력",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": [
                 "나는 @FunctionDefinition을 나타냄. @Bind가 어떤 종류의 함수를 가지고 있는지 말하고 싶을 때 정말 도움이 돼! 이렇게:",
                 "\\math•ƒ (# # # #) #: ƒ interesting(a•# b•# c•# d•#) a + b + c + d\\"
@@ -1187,7 +1229,7 @@
         "ListType": {
             "name": "리스트 타입",
             "description": "$1[리스트의 $1|리스트]",
-            "emotion": "쾌활한",
+            "emotion": "$?",
             "doc": [
                 "나는 정말 @List의 팬이야. @Bind에게 그들이 어떤 종류의 리스트인지 말할 수 있어! 이렇게, 나는 @Number의 리스트라고 말하고 있어:",
                 "\\things•[#]: [ 1 2 3 4 5 ]\\"
@@ -1196,7 +1238,7 @@
         "MapType": {
             "name": "맵 타입",
             "description": "$1[ $1|아무거나]에서 $2[ $2|아무거나]로의 맵",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
                 "@Map이 얼마나 멋진지 알아? 진짜로 멋져. 나는 항상 @Bind에게 그들이 어떤 종류의 맵인지 알려주고 있어, 예를 들어 숫자에서 리스트로의 맵이야:",
                 "\\stuff•{'':[]}: {}\\"
@@ -1205,7 +1247,7 @@
         "NumberType": {
             "name": "숫자 타입",
             "description": "$1[ $1 | 숫자]",
-            "emotion": "정확한",
+            "emotion": "$?",
             "doc": [
                 "@Bind는 뭘 해야 할까? @Number여야지. 왜냐하면 숫자가 최고 af니까.",
                 "\\count•#: 17\\"
@@ -1214,7 +1256,7 @@
         "NameType": {
             "name": "이름 타입",
             "description": "$1 타입",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": [
                 "나는 @StructureDefinition을 그 이름으로 나타냄. 그래서, 예를 들면 이렇게 구조가 있다면, 값을 저장하는 @Bind를 만들 수 있어.",
                 "\\•Friend(name•'')\nbestie•Friend: Friend('Jonah')\\"
@@ -1225,12 +1267,12 @@
         },
         "NeverType": {
             "name": "절대 불가능한 타입",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": "나는 불가능한 타입을 나타냄. 예를 들어 @Is에게 뭔가가 @Number인지 물어봐도 그것은 결코 숫자가 될 수 없을 때야."
         },
         "NoneType": {
             "name": "없음 타입",
-            "emotion": "중립적인",
+            "emotion": "$?",
             "doc": [
                 "@None은 가장 최고의 없음이고, 나는 그들의 충실한 대표자야.",
                 "\\space•ø: ø\\"
@@ -1239,7 +1281,7 @@
         "SetType": {
             "name": "집합 타입",
             "description": "$1[ $1 집합|집합] 타입",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": [
                 "@Set은 정말 최고야, 진짜로. 나는 항상 @Bind에게 뭔가를 집합으로 만들라고 말하고 있어!",
                 "\\unique•{''}: {'something' 'anything' 'someone'}\\"
@@ -1247,12 +1289,12 @@
         },
         "StreamDefinitionType": {
             "name": "스트림 정의 타입",
-            "emotion": "화가난",
+            "emotion": "$?",
             "doc": "나는 정의한 스트림을 나타내, 그게 불가능한데, 그러니까 왜 읽고 있어?"
         },
         "StreamType": {
             "name": "스트림 타입",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": [
                 "나는 스트림의 아름다움과 의미를 축하해… @Bind에게 그것들을 저장하라고 말해:",
                 "\\time•…#ms: Time()\\"
@@ -1261,18 +1303,18 @@
         "StructureType": {
             "name": "구조체 타입",
             "description": "$1",
-            "emotion": "친절한",
+            "emotion": "$?",
             "doc": "나는 기본 값 타입을 나타내기 위한 내부 타입이야."
         },
         "UnknownType": {
             "name": "알 수 없는 타입",
             "connector": ", 왜냐하면 ",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": "음... 나는 내가 뭐를 나타내는지 모르겠어, 근데 정말로 궁금해. 너는 알아? 우리가 알아야 할 것 같아. 모르겠으면 우리한테 말해줘."
         },
         "TableType": {
             "name": "테이블 타입",
-            "emotion": "화가난",
+            "emotion": "$?",
             "doc": "나는 테이블을 나타냄.",
             "conflict": {
                 "ExpectedColumnType": "나는 열 타입이 필요해"
@@ -1281,7 +1323,7 @@
         "TextType": {
             "name": "텍스트 타입",
             "description": "$1[ $1 | 텍스트]",
-            "emotion": "행복한",
+            "emotion": "$?",
             "doc": [
                 "나는 가장 화려한 종류의 값, @Text를 멋지게 나타냄.",
                 "\\story•'': '한 번에 하나의 시간에...'\\"
@@ -1289,13 +1331,13 @@
         },
         "TypePlaceholder": {
             "name": "플레이스홀더 타입",
-            "emotion": "갈망하는",
+            "emotion": "$?",
             "doc": "언젠가는 타입을 나타내기를 희망해, 내 베프인 @ExpressionPlaceholder이 표현을 나타내는 것처럼 말이야! 어떤 종류인지 도와줄래?"
         },
         "UnionType": {
             "name": "옵션 타입",
             "description": "$1 | $2",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": [
                 "누구를 나타내야 할까, A 또는 B 또는 다른 뭔가? 결정할 수가 없어!",
                 "\\indecision•''|#|{ø}: \"I don't know!\"\\"
@@ -1304,7 +1346,7 @@
         "Unit": {
             "name": "단위",
             "description": "$1",
-            "emotion": "정확한",
+            "emotion": "$?",
             "doc": [
                 "나는 @Number가 가질 수 있는 모든 단위를 나타내, 단위가 없는 경우부터 상상할 수 있는 가장 복잡한 단위까지. 중력 같은 것 예를 들면:",
                 "\\gravity•m/s^2: 9.8m/s^2\\",
@@ -1313,56 +1355,56 @@
         },
         "UnparsableType": {
             "name": "해석할 수 없는 타입",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": "나는 알 수 없는 표현의 타입을 나타내. 그 표현을 어떤 목적으로 사용하려고 할 때 내가 나타나."
         },
         "VariableType": {
             "name": "변수 타입",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": "@TypeVariable을 알아? 그리고 그들이 어떤 알 수 없는 종류의 값을 나타내는지? 나는 값 간의 모든 협상에서 그들을 나타내."
         },
         "CycleType": {
             "name": "순환 타입",
             "description": "자기 자신에 의존",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": "가끔 값들이 자기 자신에게 의존하고 있어서 그 값이 어떤 종류인지 모르는 경우가 있어. 나는 그 상황을 나타내."
         },
         "UnknownVariableType": {
             "name": "알 수 없는 변수 타입",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": "가끔 우리는 뭔가의 종류를 추측해 보려고 해; 나는 그게 뭔지 모를 때 나타나."
         },
         "NotAType": {
             "name": "예상치 못한 타입",
             "description": "$1이 아님",
-            "emotion": "궁금한",
+            "emotion": "$?",
             "doc": "가끔 우리는 뭔가가 어떤 종류여야 하는지 알아. 예를 들면 @ListAccess는 @Number가 필요해. 그걸 얻지 못하면, 나는 뭔가가 우리가 기대한 것과 다른 타입이라고 나타내."
         },
         "NoExpressionType": {
             "name": "표현식 없음 타입",
-            "emotion": "화난",
-            "doc": "@블록은 적어도 하나의 표현식이 필요한 걸 알고 계시죠? 표현식을 제공하지 않을 때 나타나는 게 바로 저예요. 그러니 표현식을 제공하세요!"
+            "emotion": "$?",
+            "doc": "@Block 적어도 하나의 표현식이 필요한 걸 알고 계시죠? 표현식을 제공하지 않을 때 나타나는 게 바로 저예요. 그러니 표현식을 제공하세요!"
         },
         "NotEnclosedType": {
             "name": "구조, 변환, 반응 안에 없음",
-            "emotion": "호기심 많은",
-            "doc": "@이것은 멋지긴 하지만, 특정 장소에만 속해요. 그들이 길을 잃었을 때, 누구를 대표하는지 아무도 모를 때 저가 나타납니다."
+            "emotion": "$?",
+            "doc": "@This 멋지긴 하지만, 특정 장소에만 속해요. 그들이 길을 잃었을 때, 누구를 대표하는지 아무도 모를 때 저가 나타납니다."
         },
         "NotImplementedType": {
             "name": "구현되지 않음",
-            "emotion": "호기심 많은",
-            "doc": "@표현식자리표시자를 사용하지만, 그 타입을 지정하지 않을 때, 나타나는 타입이 바로 저예요. 그냥 받아들이세요!"
+            "emotion": "$?",
+            "doc": "@ExpressionPlaceholder 사용하지만, 그 타입을 지정하지 않을 때, 나타나는 타입이 바로 저예요. 그냥 받아들이세요!"
         },
         "UnknownNameType": {
             "name": "알 수 없는 이름",
             "description": "$1[$1이 정의되지 않음 |이름이 주어지지 않음]",
-            "emotion": "호기심 많은",
-            "doc": "가끔 @참조와 @속성참조가 당신이 말하는 이름을 모를 때가 있죠? 그럴 때 나타나서 우리가 누구에 대해 이야기하고 있는지 모른다는 것을 대표합니다."
+            "emotion": "$?",
+            "doc": "가끔 @Reference @PropertyReference 당신이 말하는 이름을 모를 때가 있죠? 그럴 때 나타나서 우리가 누구에 대해 이야기하고 있는지 모른다는 것을 대표합니다."
         },
         "NonFunctionType": {
             "name": "비함수",
             "description": "비함수",
-            "emotion": "혼란스러운",
+            "emotion": "$?",
             "doc": "우리 중 일부는 함수를 기대했는데, 함수를 받지 못했을 때 저가 나타나요."
         }
     },
@@ -1372,7 +1414,7 @@
                 "우리는 \\⊤\\와 \\⊥\\입니다. \\⊤\\는 참입니다. \\⊥\\는 거짓입니다. \\⊤\\는 \\⊥\\가 아니며; \\⊥\\는 \\⊤\\가 아닙니다. 이것이 그대로의 사실입니다.",
                 "우리를 어떻게 만드나요? 그냥 \\⊤\\와 \\⊥\\, 더도 덜도 아닙니다.",
                 "일부는 키보드를 사용합니다 (/ctrl+9/은 \\⊤\\, /ctrl+0/은 \\⊥\\). 일부는 편집기 하단의 문자 검색을 사용합니다. 또는 여기서 끌어다 쓸 수도 있습니다.",
-                "아래의 @함수정의를 확인해보세요. 그들은 매우 논리적입니다."
+                "아래의 @FunctionDefinition 확인해보세요. 그들은 매우 논리적입니다."
             ],
             "name": ["⊤⊥", "부울"],
             "function": {
@@ -1387,7 +1429,7 @@
                     "names": ["&", "그리고"],
                     "inputs": [
                         {
-                            "doc": "확인할 다른 @부울입니다. 첫 번째가 \\⊥\\이면 이것이 무엇이든, 함수는 \\⊥\\로 평가될 것입니다.",
+                            "doc": "확인할 다른 @Boolean. 첫 번째가 \\⊥\\이면 이것이 무엇이든, 함수는 \\⊥\\로 평가될 것입니다.",
                             "names": "값"
                         }
                     ]
@@ -1403,7 +1445,7 @@
                     "names": ["|", "또는"],
                     "inputs": [
                         {
-                            "doc": "확인할 다른 @부울입니다. 첫 번째가 \\⊥\\이면, 이 함수는 이것이 \\⊤\\일 때만 \\⊤\\로 평가됩니다.",
+                            "doc": "확인할 다른 @Boolean. 첫 번째가 \\⊥\\이면, 이 함수는 이것이 \\⊤\\일 때만 \\⊤\\로 평가됩니다.",
                             "names": "값"
                         }
                     ]
@@ -1429,13 +1471,13 @@
                 }
             },
             "conversion": {
-                "text": "@부울을 \\'⊤'\\와 \\'⊥'\\의 @텍스트 값으로 변환합니다."
+                "text": "@Boolean \\'⊤'\\와 \\'⊥'\\의 @Text 값으로 변환합니다."
             }
         },
         "None": {
             "doc": [
-                "/안녕하세요, @함수정의입니다. @없음은 많이 말하지 않아서 제가 통역할게요./",
-                "저는 @없음입니다. \\ø\\로 저를 호출하세요. 무엇인가가 없음을 나타내고 싶을 때 유용합니다."
+                "/안녕하세요, @FunctionDefinition. @None 많이 말하지 않아서 제가 통역할게요./",
+                "저는 @None. \\ø\\로 저를 호출하세요. 무엇인가가 없음을 나타내고 싶을 때 유용합니다."
             ],
             "name": ["ø", "없음"],
             "function": {
@@ -1466,8 +1508,8 @@
                 "다른 값들과 함께 저를 만들고 싶다면, 기호를 사용할 수 있어요.",
                 "예를 들어, 이것을 생각해보세요:",
                 "\\\"여기 몇 가지 합계가 있어요 \\1 + 2\\, \\2 + 3\\, \\3 + 4\\\"\\",
-                "저는 그 합계들을 우아하게 평가하고 @텍스트 안에 넣었죠?",
-                "그 외에도, @함수정의가 만들어준 많은 멋진 함수들이 있어서 단어들로 온갖 일을 할 수 있어요!"
+                "저는 그 합계들을 우아하게 평가하고 @Text 안에 넣었죠?",
+                "그 외에도, @FunctionDefinition 만들어준 많은 멋진 함수들이 있어서 단어들로 온갖 일을 할 수 있어요!"
             ],
             "name": ["''", "텍스트"],
             "function": {
@@ -1481,18 +1523,14 @@
                     "inputs": []
                 },
                 "equals": {
-                    "doc": "\\⊤\\, 주어진 @텍스트와 같은 문자열 순서인 경우.",
+                    "doc": "\\⊤\\, 주어진 @Text 같은 문자열 순서인 경우.",
                     "names": ["=", "equals"],
-                    "inputs": [
-                        { "doc": "비교할 @텍스트입니다.", "names": "값" }
-                    ]
+                    "inputs": [{ "doc": "비교할 @Text.", "names": "값" }]
                 },
                 "notequals": {
-                    "doc": "\\⊤\\, 주어진 @텍스트와 같은 문자열 순서가 /아닌/ 경우.",
+                    "doc": "\\⊤\\, 주어진 @Text 같은 문자열 순서가 /아닌/ 경우.",
                     "names": ["≠", "동등하지 않음"],
-                    "inputs": [
-                        { "doc": "비교할 @텍스트입니다.", "names": "값" }
-                    ]
+                    "inputs": [{ "doc": "비교할 @Text.", "names": "값" }]
                 },
                 "repeat": {
                     "doc": "$?",
@@ -1721,6 +1759,11 @@
                 },
                 "length": { "doc": "$?", "names": "$?", "inputs": [] },
                 "random": { "doc": "$?", "names": "$?", "inputs": [] },
+                "shuffled": {
+                    "doc": ["$?"],
+                    "names": "$?",
+                    "inputs": []
+                },
                 "first": { "doc": "$?", "names": "$?", "inputs": [] },
                 "last": { "doc": "$?", "names": "$?", "inputs": [] },
                 "has": {
@@ -2076,8 +2119,12 @@
         },
         "Time": {
             "doc": "$?",
-            "names": ["Tiempo"],
-            "frequency": { "names": ["frecuencia"], "doc": "$?" }
+            "names": ["$?"],
+            "frequency": { "names": ["$?"], "doc": "$?" },
+            "relative": {
+                "names": "$?",
+                "doc": "$?"
+            }
         },
         "Volume": {
             "doc": "$?",
@@ -2104,6 +2151,11 @@
             "nextplace": { "doc": "$?", "names": "$? nextplace" },
             "nextvelocity": { "doc": "$?", "names": "$? nextvelocity" }
         },
+        "Scene": {
+            "doc": "$?",
+            "names": "$? Scene",
+            "outputs": { "names": "$?", "doc": "$?" }
+        },
         "Chat": {
             "doc": ["$?"],
             "names": "$?"
@@ -2191,7 +2243,7 @@
     },
     "output": {
         "Output": {
-            "names": "$? Output",
+            "names": "$?",
             "doc": "$?"
         },
         "Stage": {
@@ -2250,7 +2302,7 @@
             "layout": { "doc": "$?", "names": "$?" },
             "matter": {
                 "doc": "$?",
-                "names": "$? matter"
+                "names": "$?"
             },
             "size": { "doc": "$?", "names": "$?" },
             "face": { "doc": "$?", "names": "$?" },
@@ -2294,7 +2346,7 @@
             "style": { "doc": "$?", "names": "$?" }
         },
         "Phrase": {
-            "names": ["💬", "Frase"],
+            "names": "$?",
             "doc": "$?",
             "description": "$?",
             "text": { "doc": "$?", "names": "$?" },
@@ -2309,10 +2361,18 @@
                 "doc": "$?",
                 "names": "$? alignment"
             },
+            "direction": {
+                "doc": "$?",
+                "names": "$? direction"
+            },
             "matter": {
                 "doc": "$?",
                 "names": "$? matter"
             },
+            "aura": {
+                "doc": "$?",
+                "names": "$?"
+            },
             "name": { "doc": "$?", "names": "$?" },
             "selectable": { "doc": "$?", "names": "$?" },
             "color": {
@@ -2429,6 +2489,10 @@
             "duration": { "doc": "$?", "names": ["$? duration"] },
             "style": { "doc": "$?", "names": "$? style" }
         },
+        "Form": {
+            "doc": "$?",
+            "names": ["$?"]
+        },
         "Rectangle": {
             "names": "$?",
             "doc": "$?",
@@ -2566,6 +2630,26 @@
                 "names": "$? shapes"
             }
         },
+        "Aura": {
+            "doc": "$?",
+            "names": "$? Aura",
+            "color": {
+                "doc": "$?",
+                "names": "$? color"
+            },
+            "blur": {
+                "doc": "$?",
+                "names": "$? blur"
+            },
+            "offsetX": {
+                "doc": "$?",
+                "names": "$? offsetX"
+            },
+            "offsetY": {
+                "doc": "$?",
+                "names": "$? offset"
+            }
+        },
         "Easing": {
             "straight": "$?",
             "cautious": "$?",
@@ -2587,6 +2671,34 @@
             "fadein": { "doc": "$?", "names": ["revelar"] },
             "popup": { "doc": "$?", "names": ["surgir"] },
             "shake": { "doc": "$?", "names": ["agitar"] }
+        },
+        "Source": {
+            "names": "$? Source",
+            "doc": "$?",
+            "name": {
+                "names": "$? name",
+                "doc": "$?"
+            },
+            "value": {
+                "names": "$? value",
+                "doc": "$?"
+            },
+            "DynamicEditLimitException": {
+                "description": "$?",
+                "explanation": "$?"
+            },
+            "ReadOnlyEditException": {
+                "description": "$?",
+                "explanation": "$?"
+            },
+            "EmptySourceNameException": {
+                "description": "$?",
+                "explanation": "$?"
+            },
+            "ProjectSizeLimitException": {
+                "description": "$?",
+                "explanation": "$?"
+            }
         }
     },
     "ui": {
@@ -2620,6 +2732,12 @@
             },
             "button": {
                 "collapse": "$?"
+            },
+            "label": {
+                "output": "$?",
+                "palette": "$?",
+                "docs": "$?",
+                "source": "$?"
             }
         },
         "project": {
@@ -2649,6 +2767,15 @@
                     "placeholder": "$?"
                 }
             },
+            "collapsed": "$?",
+            "save": {
+                "projectsNotSavedLocally": "$?",
+                "projectsCannotNotSaveLocally": "$?",
+                "projectContainedPII": "$?",
+                "projectsNotLoadingOnline": "$?",
+                "projectNotSavedOnline": "$?",
+                "settingsUnsaved": "$?"
+            },
             "help": "$?",
             "dialog": {
                 "unsaved": "$?",
@@ -2718,6 +2845,10 @@
                     "on": "$?",
                     "off": "$?"
                 },
+                "localized": {
+                    "on": "$?",
+                    "off": "$?"
+                },
                 "glyphs": {
                     "on": "$?",
                     "off": "$?"
@@ -2745,6 +2876,8 @@
                 "nextInline": "$?",
                 "lineStart": "$?",
                 "lineEnd": "$?",
+                "sourceStart": "$?",
+                "sourceEnd": "$?",
                 "priorNode": "$?",
                 "nextNode": "$?",
                 "parent": "$?",
@@ -2752,6 +2885,7 @@
                 "incrementLiteral": "$?",
                 "decrementLiteral": "$?",
                 "insertSymbol": "$?",
+                "insertTab": "$?",
                 "insertTrue": "$?",
                 "insertFalse": "$?",
                 "insertNone": "$?",
@@ -2763,12 +2897,17 @@
                 "insertLessOrEqual": "$?",
                 "insertGreaterOrEqual": "$?",
                 "insertStream": "$?",
+                "insertChange": "$?",
                 "insertConvert": "$?",
                 "insertPrevious": "$?",
                 "insertType": "$?",
                 "insertTable": "$?",
+                "insertTableClose": "$?",
+                "insertBorrow": "$?",
+                "insertShare": "$?",
                 "insertLine": "$?",
                 "backspace": "$?",
+                "delete": "$?",
                 "cut": "$?",
                 "copy": "$?",
                 "paste": "$?",
@@ -2777,11 +2916,21 @@
                 "type": "$?",
                 "undo": "$?",
                 "redo": "$?",
-                "search": "$?"
+                "search": "$?",
+                "tidy": "$?",
+                "elide": "$?"
             }
         },
-        "conflicts": {
-            "label": "$?"
+        "annotations": {
+            "label": "$?",
+            "cursor": "$?",
+            "cursorParent": "$?",
+            "learn": "$?",
+            "evaluating": "$?",
+            "space": "$?",
+            "button": {
+                "resolution": "$?"
+            }
         },
         "output": {
             "label": "$?",
@@ -2863,10 +3012,14 @@
                     "public": {
                         "header": "$?",
                         "explanation": "$?"
+                    },
+                    "pii": {
+                        "header": "$?",
+                        "explanation": "$?"
                     }
                 },
                 "field": {
-                    "email": {
+                    "emailOrUsername": {
                         "placeholder": "$?",
                         "description": "$?"
                     }
@@ -2878,10 +3031,18 @@
                     }
                 },
                 "error": {
-                    "unknown": "$?"
+                    "unknown": "$?",
+                    "anonymous": "$?"
                 },
                 "button": {
-                    "submit": "$?"
+                    "submit": "$?",
+                    "sensitive": {
+                        "tip": "$?",
+                        "label": "$?"
+                    }
+                },
+                "options": {
+                    "gallery": "$?"
                 }
             },
             "settings": {
@@ -2903,10 +3064,18 @@
                         "label": "$?",
                         "modes": ["$?", "$?", "$?"]
                     },
+                    "space": {
+                        "label": "$?",
+                        "modes": ["$?", "$?"]
+                    },
                     "writing": {
                         "label": "$?",
                         "modes": ["$?", "$?", "$?"]
                     }
+                },
+                "options": {
+                    "mic": "$?",
+                    "camera": "$?"
                 }
             },
             "locale": {
@@ -2915,12 +3084,14 @@
                 "subheader": {
                     "selected": "$?",
                     "supported": "$?",
+                    "coming": "$?",
                     "help": "$?"
                 },
                 "button": {
                     "show": "$?",
                     "add": "$?",
-                    "remove": "$?"
+                    "remove": "$?",
+                    "replace": "$?"
                 }
             },
             "help": {
@@ -2942,7 +3113,15 @@
                 "default": "$?",
                 "inherited": "$?",
                 "notSequence": "$?",
-                "notContent": "$?"
+                "notContent": "$?",
+                "format": "$?",
+                "weight": "$?",
+                "light": "$?",
+                "normal": "$?",
+                "bold": "$?",
+                "extra": "$?",
+                "italic": "$?",
+                "underline": "$?"
             },
             "button": {
                 "revert": "$?",
@@ -2997,6 +3176,9 @@
             },
             "landing": {
                 "call": ["$?"],
+                "value": "$?",
+                "description": "$?",
+                "beta": ["$?"],
                 "link": {
                     "about": "$?",
                     "learn": "$?",
@@ -3012,6 +3194,9 @@
                 "button": {
                     "next": "$?",
                     "previous": "$?"
+                },
+                "options": {
+                    "lesson": "$?"
                 }
             },
             "guide": {
@@ -3025,6 +3210,10 @@
                 "archiveprompt": "$?",
                 "galleriesheader": "$?",
                 "galleryprompt": "$?",
+                "add": {
+                    "header": "$?",
+                    "explanation": "$?"
+                },
                 "button": {
                     "newproject": "$?",
                     "editproject": "$?",
@@ -3060,12 +3249,19 @@
             },
             "login": {
                 "header": "$?",
+                "subtitle": "$?",
                 "anonymous": "$?",
                 "prompt": {
                     "login": "$?",
+                    "forgot": "$?",
+                    "email": "$?",
                     "enter": "$?",
+                    "tooyoung": "$?",
+                    "passwordrule": "$?",
+                    "passwordreminder": "$?",
                     "play": "$?",
-                    "change": "$?",
+                    "changeEmail": "$?",
+                    "changePassword": "$?",
                     "logout": "$?",
                     "sent": "$?",
                     "success": "$?",
@@ -3081,16 +3277,36 @@
                     "offline": "$?",
                     "failure": "$?",
                     "unchanged": "$?",
-                    "delete": "$?"
+                    "delete": "$?",
+                    "wrongPassword": "$?",
+                    "tooMany": "$?"
                 },
                 "feedback": {
                     "changing": "$?",
-                    "deleting": "$?"
+                    "deleting": "$?",
+                    "updatedPassword": "$?",
+                    "match": "$?"
                 },
                 "field": {
                     "email": {
                         "description": "$?",
                         "placeholder": "$?"
+                    },
+                    "username": {
+                        "description": "$?",
+                        "placeholder": "$?"
+                    },
+                    "password": {
+                        "description": "$?",
+                        "placeholder": "$?"
+                    },
+                    "currentPassword": {
+                        "description": "$?",
+                        "placeholder": "$?"
+                    },
+                    "newPassword": {
+                        "description": "$?",
+                        "placeholder": "$?"
                     }
                 },
                 "button": {
@@ -3099,7 +3315,8 @@
                         "label": "$?"
                     },
                     "login": "$?",
-                    "update": "$?",
+                    "updateEmail": "$?",
+                    "updatePassword": "$?",
                     "delete": {
                         "tip": "$?",
                         "label": "$?"
@@ -3108,12 +3325,30 @@
                         "tip": "$?",
                         "label": "$?"
                     }
+                },
+                "toggle": {
+                    "reveal": {
+                        "on": "$?",
+                        "off": "$?"
+                    }
+                }
+            },
+            "join": {
+                "header": "$?",
+                "prompt": {
+                    "username": "$?",
+                    "password": "$?"
                 }
             },
             "rights": {
                 "header": "$?",
                 "content": ["$?"],
                 "consequences": ["$?"]
+            },
+            "donate": {
+                "header": "$?",
+                "prompt": "$?",
+                "content": ["$?"]
             }
         },
         "edit": {
@@ -3150,6 +3385,7 @@
             "disclosure": "$?",
             "misinformation": "$?"
         },
+        "progress": "$?",
         "button": {
             "submit": {
                 "tip": "$?",
@@ -3160,5 +3396,27 @@
                 "label": "$?"
             }
         }
+    },
+    "gallery": {
+        "games": {
+            "name": "$?",
+            "description": "$?"
+        },
+        "visualizations": {
+            "name": "$?",
+            "description": "$?"
+        },
+        "motion": {
+            "name": "$?",
+            "description": "$?"
+        },
+        "av": {
+            "name": "$?",
+            "description": "$?"
+        },
+        "tools": {
+            "name": "$?",
+            "description": "$?"
+        }
     }
 }
diff --git a/static/locales/zh-TW/zh-TW.json b/static/locales/zh-TW/zh-TW.json
index 0ce96efa1..264dab1ab 100644
--- a/static/locales/zh-TW/zh-TW.json
+++ b/static/locales/zh-TW/zh-TW.json
@@ -576,7 +576,7 @@
             "emotion": "eager",
             "doc": [
                 "我是任何表達式，但附帶了 @Doc！",
-                "要創建我，只需在表達式前面加上 @Do​​c，然後你就會得到我：",
+                "要創建我，只需在表達式前面加上 @Doc，然後你就會得到我：",
                 "\\雙加: 1\n(2 · 雙加) + \n``讓它再大一點點``\n1\\",
                 "我在對程式的某部分進行評論時很有用。"
             ],
@@ -1501,7 +1501,7 @@
             "doc": [
                 "我可以是你喜歡的任何文字，來自任何語言，並使用這些開頭和結尾符號之一：\\\"\"\\、\\“”\\、\\„“\\、\\' '\\、\\''\\、\\‹›\\、\\«»\\、\\「」\\或\\『』\\。 ",
                 "舉個例子，考慮這些美麗的短語",
-                "\\「生活有兩種方式。一種是好像沒有什麼是奇蹟的。另一種是好像一切都是奇蹟的。 ”\\",
+                "\\「生活有兩種方式。一種是好像沒有什麼是奇蹟的。另一種是好像一切都是奇蹟的。」 \\",
                 "\\『一日三秋』\\",
                 "只需記住，如果你打開了我，就要關閉我，並使用相匹配的符號。否則，我就不知道你已經用完了你的話。",
                 "\\'你好'/en'hola'/es-MX\\",