diff --git a/static/locales/ko-KR/ko-KR.json b/static/locales/ko-KR/ko-KR.json
new file mode 100644
index 000000000..65bf96ff6
--- /dev/null
+++ b/static/locales/ko-KR/ko-KR.json
@@ -0,0 +1,3091 @@
+{
+    "$schema": "../../schemas/Locale.json",
+    "language": "ko",
+    "region": "KR",
+    "wordplay": "워드플레이",
+    "newProject": "새 프로젝트",
+    "term": {
+        "evaluate": "평가",
+        "bind": "바인드",
+        "decide": "결정",
+        "document": "문서화",
+        "project": "프로젝트",
+        "source": "원본",
+        "input": "입력",
+        "output": "출력",
+        "convert": "변환",
+        "act": "동작",
+        "scene": "장면",
+        "phrase": "구문",
+        "group": "그룹",
+        "stage": "스테이지",
+        "type": "유형",
+        "start": "시작",
+        "entered": "입력된",
+        "changed": "변경된",
+        "moved": "이동된",
+        "name": "이름",
+        "value": "값",
+        "text": "텍스트",
+        "boolean": "불리언",
+        "map": "맵",
+        "number": "숫자",
+        "function": "함수",
+        "exception": "예외",
+        "table": "테이블",
+        "none": "없음",
+        "list": "목록",
+        "stream": "스트림",
+        "structure": "구조",
+        "index": "인덱스",
+        "query": "질의",
+        "row": "행",
+        "set": "집합",
+        "key": "키"
+    },
+    "token": {
+        "EvalOpen": "평가열기",
+        "EvalClose": "평가닫기",
+        "SetOpen": "설정열기",
+        "SetClose": "설정닫기",
+        "ListOpen": "목록열기",
+        "ListClose": "목록닫기",
+        "TagOpen": "태그열기",
+        "TagClose": "태그닫기",
+        "Bind": "바인드",
+        "Access": "접근",
+        "Function": "함수",
+        "Borrow": "빌리다",
+        "Share": "공유",
+        "Convert": "변환",
+        "Doc": "문서",
+        "Formatted": "형식화된",
+        "FormattedType": "형식화된유형",
+        "Words": "단어",
+        "Link": "링크",
+        "Italic": "이탤릭체",
+        "Underline": "밑줄",
+        "Light": "가는",
+        "Bold": "굵은",
+        "Extra": "엑스트라",
+        "Concept": "개념",
+        "URL": "유알엘",
+        "Code": "코드",
+        "Mention": "언급",
+        "Branch": "브랜치",
+        "None": "없어",
+        "Type": "$?",
+        "TypeOperator": "$?",
+        "TypeOpen": "$?",
+        "TypeClose": "$?",
+        "Separator": "$?",
+        "Language": "$?",
+        "Region": "$?",
+        "BooleanType": "$?",
+        "NumberType": "$?",
+        "JapaneseNumeral": "$?",
+        "RomanNumeral": "$?",
+        "Pi": "파이",
+        "Infinity": "무한대",
+        "TableOpen": "테이블 열기",
+        "TableClose": "테이블 닫기",
+        "Select": "선택",
+        "Insert": "삽입",
+        "Update": "업데이트",
+        "Delete": "삭제",
+        "Union": "합집합",
+        "Stream": "스트림",
+        "Change": "변경",
+        "Initial": "초기",
+        "Previous": "이전",
+        "Placeholder": "플레이스홀더",
+        "Etc": "기타",
+        "This": "이것",
+        "Operator": "연산자",
+        "Conditional": "조건문",
+        "Text": "텍스트",
+        "Number": "숫자",
+        "Decimal": "십진",
+        "Base": "진법",
+        "Boolean": "불리언",
+        "Name": "이름",
+        "Unknown": "알 수 없음",
+        "Locale": "로캘",
+        "End": "종료"
+    },
+    "node": {
+        "Dimension": {
+            "name": "차원",
+            "description": "차원",
+            "emotion": "심각한",
+            "doc": [
+                "나는 /측정 단위/이다!",
+                "나는 \\1m\\, \\10s\\, \\100g\\와 같은 표준화된 단위가 될 수 있어. 네가 만들고 싶은 \\17사과\\와 같은 단위도 기꺼이 될 수 있어.",
+                "나는 \\17사과/일\\와 같은 비율 단위를 만들기 위해 \\/\\와 결합될 수 있고, \\9.8m/s^2\\와 같은 지수 단위를 만들기 위해 \\^\\와 결합될 수 있어.",
+                "나는 항상 @숫자 뒤에 와야 해. 그렇지 않으면 @참조로 오해받을 수 있는데, 그건 꽤 난감할거야!",
+                "나는 단위 간의 불일치도 잘 찾아내요. 예를 들면, \\1고양이 + 1개\\는 아무런 의미가 없어요!",
+                "다른 단위 값들을 변환하고 싶다면, @변환에게 말하세요."
+            ]
+        },
+        "Doc": {
+            "name": "설명",
+            "emotion": "심각한",
+            "doc": [
+                "나는 @마크업 으로 여러 가지를 포맷합니다, 예를 들면 너의 @프로그램에 대한 설명이나, @프레이즈로 무대에 올린 단어들처럼요.",
+                "예를 들면, 나는 어떤 표현 앞에 올 수 있어요:",
+                "\\이게 정말 7이 맞나요?\\n7\\",
+                "예를 들면, @바인드 앞에 나를 둘 수 있어요:",
+                "\\나는 어떤 사람의 키를 측정해요\\nheight: 5m\\",
+                "또는 @함수정의 앞에도요:", 
+                "\\나는 두 숫자를 더해요\\nƒ sum(a•# b•#) a + b\\",
+                "또는 @구조정의 앞에도요:",
+                "\\나는 사람들의 이름과 좋아하는 과일을 기억해요\\n•Person(name•'' fruit•'')\\",
+                "너는 또한 전체 퍼포먼스가 무엇에 관한 것인지 말하기 위해 나를 @프로그램의 맨 처음에 둘 수 있어요.",
+                "\\이 프로그램은 안녕이라고 말해요\\n\\n'hello!'\\",
+                "다른 사람들이 내가 어떤 언어로 쓰여졌는지 알 수 있도록 나에게 @언어를 줄 수 있어요:",
+                "\\나는 영어 문서에요/en\\nduration: 5s\\",
+                "나를 리스트로 만들 수 있다는 것 알고 계셨나요? @문서에게 말해보세요."
+            ]
+        },
+        "Docs": {
+            "name": "설명 목록",
+            "emotion": "심각한",
+            "doc": [
+                "나는 다양한 언어로 @Doc의 번역본을 여러 개 가질 때 유용한 @Doc의 목록이야.",
+                "목록을 만들기 위해 특별히 무언가를 할 필요는 없어. 그냥 이렇게 여러 개의 @Doc을 나란히 놓으면 돼:",
+                "\\Hello/en\\nHola/es\\ngreeting: '…'\\"
+            ],
+            "start": "문서의 값을 만들기!"
+        },
+        "KeyValue": {
+            "name": "매핑",
+            "emotion": "친절한",
+            "doc": [
+                "나는 항상 @Map 안에서 *키*에서 *값*으로의 매핑이에요.",
+                "어떤 종류의 값을 다른 값에 매핑할 수 있어요. 예를 들어, 숫자의 매핑은 여기 있습니다:",
+                "\\{1:1}\\",
+                "또는 텍스트에서 숫자로의 매핑:",
+                "\\{'토끼':1}\\"
+            ],
+        },
+        "Language": {
+            "name": "언어",
+            "description": "언어 $1[$1|알 수 없음]",
+            "emotion": "열정적인",
+            "doc": [
+                "나는 언어 태그이며 @이름 과 @문서 와 함께 작동해요!",
+                "무언가가 어떤 언어로 쓰여진 것인지 *또렷하게* 알려주는 데 매우 능숙해요.",
+                "그게 바로 제가 하는 일이에요. 단지 작은 슬래시 하나와 몇 글자만 있으면, 어떤 텍스트가 어떤 언어인지 절대 혼란스러워하지 않을 거예요.",
+                "예를 들어, 내 $이름을 말하고 싶지만 영어임을 분명히 하고 싶다고 가정해봅시다:",
+                "\\\"언어\"/en\\",
+                "또는 @이름에 대해 이것을 하고 싶다고 가정해 보세요.",
+                "\\소리/en: '야옹'\\",
+                "또는 @문서 에도!",
+                "\\``의성어``/en\n소리/en: \"야옹\"\\",
+                "내가 이해하는 <2글자 언어 코드들@https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes>이 많아요. 만약 그 중 하나를 사용하지 않는다면 알려드릴게요."
+            ],
+            "conflict": {
+                "UnknownLanguage": "이 언어를 모르겠어요",
+                "MissingLanguage": "언어가 빠져 있어요. 하나 추가해 줄 수 있나요?"
+            }
+        },
+        "Name": {
+            "name": "이름",
+            "description": "$1[$1 | 무명]",
+            "emotion": "친절한",
+            "doc": [
+                "나는 값을 식별하며, 평가하기 어려운 것이나 반복해서 평가하고 싶지 않은 것에 대한 축약된 레이블을 제공하는 유용한 방법입니다.",
+                "@바인드가 이렇게 내 이름을 지어줍니다:",
+                "\\hi: 5\\",
+                "나는 오직 하나의 값을 대표하며, 한 번 가지고 나면 변경할 수 없어요. 예를 들어, @바인드를 사용하여 이렇게 하려고 하면 우리는 불평을 할 거예요.",
+                "\\hi: 5\nhi: 3\\",
+                "내 값을 얻으려면 @참조 또는 @속성참조가 이름을 사용하기만 하면 돼요. 여기서 @바인드가 나를 이름 지어주고, @참조가 내게 주어진 값을 얻습니다.",
+                "\\hi: 5\nhi\\",
+                "@바인드가 많은 곳에 나타날 수 있기 때문에, 나도 많은 곳에 나타날 수 있어요. 위에 @블록 안에 있었지만, @함수정의 안에도 있을 수 있어요. 여기서 나는 임시적으로 메시지의 이름을 지어주고 있습니다:",
+                "\\ƒ say(message•'') message\\",
+                "나는 @함수정의 내부에서 정의되고, 함수 평가가 끝나는 대로 사라져요.",
+                "내 이름이 어떤 언어인지 나타내기 위해 @언어를 사용할 수 있어요. 이것은 다른 사람들과 공연을 공유할 때, 그들이 당신의 프로그램을 읽고 싶을 경우에 도움이 됩니다."
+            ]
+        },
+        "Names": {
+            "name": "이름 목록",
+            "emotion": "친절한",
+            "doc": [
+                "나는 @이름의 목록이며, 값을 여러 이름으로 지정하고 싶을 때 유용합니다, 종종 다른 @언어와 함께요.",
+                "이름은 \\,\\ 기호로 구분됩니다. 예를 들어, 여기 @바인드가 여러 @이름에 값을 지정하는 것입니다:",
+                "\\hi/en,hello/en,hola/es: '환영합니다'\\"
+            ]
+        },
+        "Row": {
+            "name": "행",
+            "emotion": "수줍은",
+            "doc": "나는 @테이블의 한 행을 나타냅니다. 나에 대해 모든 것을 아는 @테이블에게 말하는 것이 아마도 최선일 거예요. 나는 그저 앉아서 값들을 줄지어 정렬하고 있을 뿐이에요 :(",
+            "conflict": {
+                "InvalidRow": "행은 모두 값이거나 모두 @바인드 이어야 합니다.",
+                "MissingCell": { 
+                    "primary": "나는 $1 열이 누락되었습니다", 
+                    "secondary": "나는 필요하지만 $1이 제공하지 않았어요"
+                },
+                "ExtraCell": {
+                    "primary": "여기 있어야 하나요?",
+                    "secondary": "이봐요 $1, 당신은 이 @테이블의 일부가 아니에요!"
+                },
+                "UnknownColumn": "이 이름을 가진 열을 모르겠어요",
+                "UnexpectedColumnBind": {
+                    "primary": "나는 @바인드가 되어야 하나요?",,
+                    "secondary": "이봐, 나는 @테이블이야. 나는 @바인드가 아닌 값들이 필요해."
+                }
+            }
+        },
+        "Token": {
+            "name": "토큰",
+            "description": "$?",
+            "emotion": "중립적인",
+            "doc": [
+                "어떻게 나를 찾아냈나요?",
+                "나는 공연에서 가능한 가장 작은 부분입니다. 나는 우주의 모든 문자가 만들어지는 기반이며, 우리 안무의 원자 입자입니다."
+            ]
+        },
+        "TypeInputs": {
+            "name": "$?",
+            "emotion": "$?",
+            "doc": "$?"
+        },
+        "TypeVariable": {
+            "name": "타입 입력",
+            "emotion": "호기심이 많은",
+            "doc": "@구조정의나 @함수정의에서 @타입변수를 대체하는 타입 목록입니다. 나는 모든 사람들이 어떤 종류의 입력을 받게 될지 알 수 있도록 도와줍니다.",
+            "conflict": {
+                "DuplicateTypeVariable": { 
+                    "primary": "나는 $1과 같은 이름을 가지고 있습니다", 
+                    "secondary": "나는 $1과 같은 이름을 가지고 있습니다" 
+                }
+            }
+        },
+        "TypeVariables": {
+            "name": "타입 변수들",
+            "emotion": "호기심이 많은",
+            "doc": "나는 @타입변수의 목록입니다."
+        },
+        "Markup": {
+            "name": "마크업",
+            "description": "$1 문단들",
+            "emotion": "진지한",
+            "doc": [
+                "나는 @단어, @웹링크, @개념링크, 그리고 @예시와 같은 다양한 종류의 마크업을 사용하는 문단들의 목록입니다."
+            ]
+        },
+        "Paragraph": {
+            "name": "문단",
+            "emotion": "진지한",
+            "doc": [
+                "나는 @단어, @개념링크, @웹링크, 그리고 @예시의 연속으로, 빈 줄로 구분되며 @문서 안에 있습니다.",
+                "나를 쓰기 위해 필요한 것은 @문서에 많은 단어를 쓰는 것뿐입니다:",
+                "\\``나는 문서 속의 문단입니다.``'한 문단'\\",
+                "여러 문단을 원한다면, 그저 빈 줄을 넣으면 됩니다.",
+                "\\``문단 1.\n\n문단 2.\n\n문단 3.``'세 문단'\\"
+            ]
+        },
+        "WebLink": {
+            "name": "링크",
+            "description": "링크 $1",
+            "emotion": "진지한",
+            "doc": [
+                "나는 인터넷상의 무언가로의 링크입니다. 나는 설명과 URL만 필요로 합니다:",
+                "\\``나는 문서에서 <링크@https://wordplay.dev>입니다``\n'링크 예시'\\",
+                "누군가 나를 선택한다면, URL로 새 창을 열게 됩니다."
+            ]
+        },
+        "ConceptLink": {
+            "name": "개념",
+            "description": "개념 $1",
+            "emotion": "진지한",
+            "doc": [
+                "나는 벌스 캐릭터로의 링크입니다. 우리 중 하나를 @문서에 언급하고 싶을 때 유용합니다.",
+                "예를 들어, @평가에 대해 이야기하고 그들이 얼마나 멋진지 말하고 싶다면, 다음과 같이 쓸 수 있어요:",
+                "\\``알다시피, @평가는 꽤 멋져요.``\n'보세요, 개념 링크!'\\",
+                "여기에 작성한 @문서가 나타나면, 그 개념으로의 링크가 표시될 거예요."
+            ]
+        },
+        "Words": {
+            "name": "단어들",
+            "emotion": "진지한",
+            "doc": [
+                "나는 @문서 안에서 마음에 드는 어떤 단어들이에요. 예를 들면:",
+                "\\``포스가 함께 하기를.``\n'그냥 몇몇 단어들!'\\",
+                "하지만 때때로, @문서가 사용하는 특수 문자들을 /단어로써/ 사용하고 싶을 수도 있어요. 예를 들어:",
+                "\\``내 친구들은 @@, //, **, ||, 그리고 다른 기호들을 사용해요.``\n'특수 문자 사용하기!'\\",
+                "이 특수 문자들을 반복하기만 하면, 그 특수한 의미 대신 문자 자체를 얻을 수 있습니다."
+            ]
+        },
+        "Example": {
+            "name": "예제",
+            "emotion": "진지한",
+            "doc": [
+                "나는 무언가의 사용법을 설명하는 @문서를 작성할 때 유용한 예시 공연입니다!",
+                "\\``덧셈의 예제를 보세요: \\1 + 1\\``'예제 코드'\\",
+                "만약 날 문단에 혼자 두면, 나는 멋진 상자 안에 나타나서 평가 결과를 보여줄 거예요.",
+                "\\``덧셈의 예제를 보세요:\n\n\\1 + 1\\``\\"
+            ]
+        },
+        "Mention": {
+            "name": "언급",
+            "description": "언급 $1",
+            "emotion": "진지한",
+            "doc": [
+                "나는 용어 \\$program\\ 또는 동적 입력 \\$1\\에 대한 참조입니다.",
+                "하지만 이것은 주로 내부 기능이므로, 알 필요는 없을 거예요."
+            ]
+        },
+        "Branch": {
+            "name": "분기",
+            "emotion": "진지한",
+            "doc": [
+                "나는 설명 입력 값이 정의되었거나 참인지에 따라 두 설명 세그먼트 중 하나를 선택하는 방법입니다.",
+                "하지만 이것은 주로 내부 기능이므로, 알 필요는 없을 거예요."
+            ]
+        },
+        "BinaryEvaluate": {
+            "name": "이진 평가",
+            "description": "$1 연산",
+            "emotion": "불안한",
+            "doc": [
+                "나는 @평가의 더 단순한 형태입니다, 두 입력을 취하는 @함수정의를 사용하고 싶을 때 유용합니다.",
+                "예를 들어, 두 숫자를 더하는 데 @평가를 사용하는 방법은 다음과 같습니다:",
+                "\\1.+(1)\\",
+                "조금 이상해 보이나요? 틀린 것은 아닙니다: 1에 더하기 함수를 가져와서 평가한다는 것을 의미해요.",
+                "하지만 @이진평가를 사용하는 것이 훨씬 쉽습니다",
+                "\\1 + 1\\",
+                "이것은 기본적으로 같은 것이지만 모든 것을 좀 더 깔끔하게 만들어줍니다.",
+                "주의할 한 가지는: 이 형태에서는 나는 왼쪽에서 오른쪽으로 평가한다는 것입니다. 수학의 연산 순서에 익숙하다면 혼란스러울 수 있어요.",
+                "이것은 당신이 예상하지 못한 방식으로 평가됩니다:",
+                "\\1 + 2 · 3 + 4\\",
+                "수학에서는 곱셈이 먼저 오고 그 다음에 덧셈이 오므로 결과는 \\11\\이 될 것입니다. 하지만 읽는 순서대로 평가하기 때문에 결과는 \\13\\이 됩니다."
+            ],
+            "right": "입력",
+            "start": "$1을 먼저 평가해 봅시다",
+            "finish": "보세요, $1을 만들었습니다!",
+            "conflict": {
+                "OrderOfOperations": "나는 읽는 순서대로 평가하며, 수학의 연산 순서대로 평가하지 않습니다. 평가해야 할 순서를 지정하기 위해 @블록을 사용하시겠습니까?"
+            }
+        },
+        "Bind": {
+            "name": "바인드",
+            "description": "바인드 $1",
+            "emotion": "신나는",
+            "doc": [
+                "나는 *값들*에 이름을 붙입니다.",
+                "이렇게요!",
+                "\\파이: 3.1415926\\",
+                "나는 @함수정의와 @구조정의에 입력값에 이름을 붙이고, @블록 내의 값에 이름을 붙입니다. 나는 모든 것에 이름을 붙입니다!",
+                "오, 그런데 한 가지 값에 *여러 이름*을 붙일 수 있다는 것을 알고 계셨나요?",
+                "이에 대해 말씀드리게 되어 정말 신나요! 하나의 값에 여러 @이름들이 있습니다. 예를 들어:",
+                "\\조,테스,에이미: 5\\",
+                "제가 한 일을 보세요?",
+                "하나의 값에 세 개의 이름.",
+                "그 다섯을 그 이름 중 *아무거나*로 참조할 수 있습니다.",
+                "특히 여러 언어로 이름을 지정하고 싶을 때 유용합니다:",
+                "\\조/en,에이미/fr,明/zh: 5\\",
+                "제가 한 일을 보세요? 하나의 값에 세 개의 다른 언어로 된 이름!",
+                "자, 마지막 비밀을 하나 알려드릴게요.",
+                "@Is와 함께 작동하여 이름에 어떤 종류의 값이 있어야 하는지 알려줄 수도 있다는 것을 알고 계셨나요? 그리고 그렇지 않다면, 저한테서 듣게 될 겁니다.",
+                "이렇게요:",
+                "\\큰숫자•#: \"한 조\"\\",
+                "보세요, \\큰숫자\\가 숫자여야 한다고 했는데 텍스트이고, 그것들은 호환되지 않으므로 쾅!",
+                "그들이 동의하지 않으면 알려드릴 겁니다.",
+                "때로는 @함수정의에서처럼 스스로 파악할 수 없을 때 *반드시* 무슨 종류의 데이터인지 알려줘야 할 수도 있습니다.",
+                "예를 들어, 여기서 @함수정의는 \\a\\와 \\b\\가 어떤 종류의 값을 가지고 있는지 모릅니다, 왜냐하면 저는 그들에게 알려주지 않았거든요.",
+                "\\ƒ sum(a b) a + b\\",
+                "하지만 @Is를 추가하면 이제 @함수정의는 그것들이 숫자라는 것을 알게 됩니다:",
+                "\\ƒ sum(a•# b•#) a + b\\"
+            ],
+            "start": "$1에서 어떤 값을 얻는지 봅시다!",
+            "finish": "오, 좋아요, $1을 얻었어요! 이름을 $2로 지어봅시다",
+            "conflict": {
+                "DuplicateName": {
+                    "primary": "누군가가 이미 $1이라는 이름을 가지고 있어서, 이 이름을 사용할 수 없어요.",
+                    "secondary": "어, $1은 제 이름이에요" 
+                },
+                "DuplicateShare": {
+                     "primary": "$1과 같은 이름을 가지고 있어서, 무엇이 공유되는지 모호해져요", 
+                     "secondary": "$1과 같은 이름을 가지고 있어요"
+                    },
+                "IncompatibleType": {
+                    "primary": "저는 $2이어야 하는데, 실제로는 $1이에요", 
+                    "secondary": "오… 죄송해요, $1인가요, 정말로?"
+                },
+                "MisplacedShare": "@프로그램 레벨에서만 공유할 수 있어요, 어떤 것 안에서는 안 돼요!",
+                "MissingShareLanguages": "이것을 공유하고 싶다면, 어떤 언어인지 말해야 해서 다른 사람들이 읽을 수 있는지 알 수 있어요!",
+                "RequiredAfterOptional": "제가 여기 있으면 안 돼요, 저 앞에 선택적인 @바인드가 있어요",
+                "UnexpectedEtc": "@함수정의에서만 가변 길이가 될 수 있어요",
+                "UnusedBind": "이 값을 이름 지었는데, 아무도 사용하지 않고 있어요!"
+            }
+        },
+        "Block": {
+            "name": "블록",
+            "description": "$1 문장",
+            "emotion": "수줍은",
+            "doc": [
+                "안녕하세요. 저는 조용하고 개인적인 공간을 만들어 평가하는 것들을 위한 곳입니다.",
+                "이렇게요:",
+                "\\(1 - 1) + 2\\",
+                "이는 평가 순서를 명확하게 해줍니다.",
+                "@바인드도 도움이 됩니다.",
+                "\\(count: 10 count ^ count)\\",
+                "@바인드가 \\count\\를 만든 것을 보세요? 이것은 저 안에서만 이름이 붙여집니다. 그래서 이건 작동하지 않아요:",
+                "\\(count: 10 count ^ count) + count\\",
+                "왜냐하면 count는 저 안에서만 이름이 붙여졌기 때문입니다.",
+                "저 안에는 원하는 만큼의 표현식을 넣을 수 있습니다. 하지만 저는 마지막 것만 신경 쓰죠:",
+                "\\(1 2 3 4 5)\\",
+                "그래서 보통 저는 많은 @바인드와 마지막에 표현식을 가지고 있습니다.",
+                "\\(\n  a: 1\n  b: 2\n  c: 3\n  d: 4\n  a + b + c + d\n)\\"
+            ],
+            "statement": "문장",
+            "start": "첫 번째 표현식",
+            "finish": "끝났어요, $1을 얻었습니다",
+            "conflict": {
+                "ExpectedEndingExpression": "표현식이 필요합니다.",
+                "IgnoredExpression": {
+                    "primary": "위의 것은 무시할 거예요.",
+                    "secondary": "@블록, 저를 무시하지 마세요!"
+                }
+            }
+        },
+        "BooleanLiteral": {
+            "name": "특정 부울",
+            "description": "$1[참|거짓]",
+            "emotion": "정확한",
+            "doc": "나는 \\⊤\\ 또는 \\⊥\\ 중 하나입니다. 우리의 아름다운 논리에 대해 더 알고 싶다면 @부울을 참조하세요.",
+            "start": "$1!"
+        },
+        "Borrow": {
+            "name": "빌리기",
+            "description": "빌리기 $1[$1|이름 누락]",
+            "emotion": "신나는",
+            "doc": "여러 @소스로 공연을 만들 때, 다른 @소스에 공유된 @바인드를 빌리기 위해 저를 사용할 수 있습니다. 그들의 이름을 사용하기만 하면 그들의 이름과 값을 가져올게요.",
+            "start": "$1에서 $2 빌리기",
+            "source": "$source",
+            "bind": "이름",
+            "version": "버전",
+            "conflict": {
+                "UnknownBorrow": "이 이름을 가진 $source를 모르겠어요",
+                "BorrowCycle": "이것은 $1에 의존하는데, $1은 이 $source에 의존하므로 프로그램을 평가할 수 없어요"
+            },
+            "exception": {
+                "CycleException": {
+                    "description": "빌리기 순환",
+                    "explanation": "$1이 자기 자신에게 의존하고 있어요"
+                }
+            }
+        },
+        "Changed": {
+            "name": "변경됨",
+            "emotion": "진지한",
+            "doc": [
+                "스트림이 @프로그램을 재평가하게 했는지 확인하고 @부울을 만듭니다. 이렇게요",
+                "\\∆ 시간()\\",
+                "스트림이 변경되었을 때만 무언가가 변경되기를 원할 때 정말 유용합니다.",
+                "그게 다에요."
+            ],
+            "start": "$1이 변경되었는지 보자구요…"
+        },
+        "Conditional": {
+            "name": "조건문",
+            "emotion": "호기심 많은",
+            "doc": [
+                "제가 결정을 내려야 하나요? 이렇게 말이죠?",
+                "\\숫자: -100\n숫자 < 0 ? '음수' '양수'\\",
+                "하지만 우리가 어떻게 결정을 내리는지에 대해 생각해 본 적 있나요?",
+                "결정이 단순히 예 아니면 아니오로만 이루어져야 한다고 생각하지 않나요? \\⊤\\와 \\⊥\\ 사이에서 결정하는 것이 전부일까요?",
+                "이것들이 우리가 내릴 수 있는 유일한 종류의 결정이라면, 세상에 대한 중요한 맥락을 놓치고 있지 않을까 걱정되지 않나요?"
+            ],
+            "start": "$1이 참인지 보자",
+            "else": "$1[코드를 건너뛰는 중 | 코드를 건너뛰지 않는 중]",
+            "afterthen": "예스를 완료했으니, 노는 건너뛸까요?",
+            "finish": "아마도 $1인가요?",
+            "condition": "조건",
+            "yes": "예",
+            "no": "아니오",
+            "conflict": {
+                "ExpectedBooleanCondition": {
+                    "primary": "$1로 어떻게 예와 아니오를 선택할 수 있죠? 정말로, 어떻게요?",
+                    "secondary": "@조건문이 저를 @부울로 원했던 것 같은데, 저는 $1입니다."
+                }
+            }
+        },
+        "ConversionDefinition": {
+            "name": "변환 정의",
+            "description": "$1 → $2",
+            "emotion": "신나는",
+            "doc": [
+                "이봐요, 저는 한 타입에서 다른 타입으로의 변환을 정의해요! @블록 안에서 이렇게 쓰이죠:",
+                "\\→ #kitty #cat . ÷ 2\n6kitty→#cat\\",
+                "제가 어떻게 키티를 고양이로 바꿨는지 보이나요? 멋져요!",
+                "점 (\\.)이 무엇을 하는지 궁금하실 겁니다. 그것은 변환되는 값을 나타냅니다. 그 값이 그렇지 않으면 이름이 없기 때문에 저는 그것을 사용해요."
+            ],
+            "start": "대단해, 새로운 변환!",
+            "conflict": {
+                "MisplacedConversion": "어머, 여기 있으면 안 돼요, @블록에서만 가능해요."
+            }
+        },
+        "Convert": {
+            "name": "변환",
+            "emotion": "명랑한",
+            "doc": [
+                "안녕. 저는 값을 하나의 타입에서 다른 타입으로 변환해요. 이것 좀 보세요:",
+                "\\1 → \"\"\\",
+                "\\5초 → #ms\\",
+                "\\\"안녕\" → []\\",
+                "이것들을 연쇄적으로 결합할 수도 있어요:",
+                "\\\"안녕\" → [] → {}\\",
+                "값들은 사전에 정의된 @변환정의 집합을 가지고 있지만, 새로운 타입의 값을 위한 @구조정의를 만들 경우, @변환정의를 사용하여 자신만의 것을 정의할 수 있어요."
+            ],
+            "start": "$1에서 값을 가져와요!",
+            "finish": "대단해, $1을 만들었어요",
+            "conflict": {
+                "UnknownConversion": "앗, $1을 $2로 변환하는 방법이 없네요"
+            },
+            "exception": {
+                "ConversionException": {
+                    "description": "불가능한 변환",
+                    "explanation": "$1에서 $2로 변환하는 방법을 모르겠어요"
+                }
+            }
+        },
+        "Delete": {
+            "name": "삭제",
+            "emotion": "화난",
+            "doc": [
+                "가끔 테이블에 너무 많은 것이 들어 있는 경우가 있어요!",
+                "예를 들어, 게임에 플레이어들이 있는데 한 명이 떠나고 당신은 그저 '플레이어야, 사라져! 내 테이블에서 나가!'라고 말하고 싶을 때요.",
+                "\\플레이어: ⎡이름•'' 팀•'' 점수•#⎦\n⎡'jen' 'red' 8⎦\n⎡'joan' 'blue' 11⎦\n⎡'jeff' 'red' 9⎦\n⎡'janet' 'blue' 7⎦\n플레이어 ⎡- 이름 = 'jeff'\\",
+                "휴, Jeff가 사라졌어요. 안녕, JEFF. 저는 원본 테이블을 변경하지 않고, JEFF가 없는 새 테이블을 만든다는 걸 기억하세요. 어디에 둘지 결정하는 것은 당신의 몫이에요."
+            ],
+            "start": "먼저 테이블을 가져오자",
+            "finish": "일치하는 행 없이 새로운 테이블을 만들었어요!"
+        },
+        "DocumentedExpression": {
+            "name": "설명된 표현",
+            "emotion": "열렬한",
+            "doc": [
+                "나는 @Doc을 붙인 표현이야!",
+                "나를 만들려면, 표현 앞에 @Doc를 넣기만 하면 돼:",
+                "\\doubleplus: 1\n(2 · doubleplus) + \n``조금만 더 크게 만들어보자``\n1\\",
+                "나는 프로그래밍에 코멘트를 달 때 유용해"
+            ],
+            "start": "이 표현을 해석해보자!"
+        },
+        "Evaluate": {
+            "name": "평가하다",
+            "description": "$1[$1|anonymous]을 평가해",
+            "emotion": "수줍은",
+            "doc": [
+                "안녕. 나는 @FunctionDefinition을 이렇게 해석해:",
+                "\\ƒ greeting(message•'')\ngreeting('kitty')\\",
+                "어디에서든지 함수가 나올수 있어. 예를들자면, @Text도 함수가 있어, 이렇게 말이야:",
+                "\\'kitty'.length()\\",
+                "만약 그 함수가 한글자의 이름을 가지고 있다면, @BinaryEvaluate 라고 적으면 돼.",
+                "\\'kitty' ⊆ 'itty'\\",
+                "이건 저것과 같은 일을 해:",
+                "\\'kitty'.⊆('itty')\\",
+                "물론, @FunctionDefinition 없이는 나는 아무것도 하지 못해. 내가 하는 것은 입력을 주고 그것의 다음 단계를 따를 뿐이야."
+            ],
+            "start": "먼저 입력된 수 부터 해석해 볼까?",
+            "evaluate": "이젠 함수를 해석해보자",
+            "finish": "나는 $1로 해석했어",
+            "function": "함수",
+            "input": "입력",
+            "conflict": {
+                "IncompatibleInput": {
+                    "primary": "나는 $1였어야 하는데, $2이야",
+                    "secondary": "음, $1 대신 $2를 받았어"
+                },
+                "UnexpectedTypeInput": {
+                    "primary": "난 이런 입력 수 를 예상 하지 않았어",
+                    "secondary": "이런, 내가 여기 있어야 하는것이 아니니?"
+                },
+                "MisplacedInput": "이 입력은 순서가 잘못 돼었어.",
+                "MissingInput": {
+                    "primary": "$1가 필요한데, 넣어 줄 수 있어?",
+                    "secondary": "이 입력이 필요한데, $2는 그걸 제공하지 않았어"
+                },
+                "NotInstantiable": "나는 @StructureDefinition로 만들 수 없어, 구현되지 못한 함수들이 있기 때문이야.",
+                "UnexpectedInput": {
+                    "primary": "예상 하지 못한 입력 수야 $1",
+                    "secondary": "이런, 내가 여기 있어야 하는것이 아니니?"
+                },
+                "UnknownInput": {
+                    "primary": "이런 이름의 입력수는 모르는걸",
+                    "secondary": "나는 여기에 속하지 않는것 같아"
+                },
+                "InputListMustBeLast": "list of inputs must be last"
+            },
+            "exception": {
+                "FunctionException": {
+                    "description": "unknown function",
+                    "explanation": "oh no, $1 isn't a function in $2[$2|this @Block]!"
+                }
+            }
+        },
+        "ExpressionPlaceholder": {
+            "name": "자리 표시자",
+            "description": "$1[$1|자리 표시자]",
+            "emotion": "두려움",
+            "doc": [
+              "나는 *표현*이지만 실제로는 아니야… 나는 그냥 다른 것을 대신하는 역할을 하는거야.",
+              "아직 무엇을 쓸지 모르면 내가 유용해. 이렇게 사용할 수 있어:",
+              "\\1 + _\\",
+              "우리가 뭘 더하는 건지 알아? 나는 몰라. 네가 말해줘.",
+              "또는 누군가가 @Evaluate로 함수를 평가하고 있었다면, 나는 함수를 대신할 수 있어.",
+              "\\_(1 2 3)\\",
+              "난는 @Stage에 있을 때 싫어!"
+            ],
+            "start": "악, 어떻게 해야 할지 모르겠어!",
+            "placeholder": "표현",
+            "conflict": {
+              "Placeholder": "누군가가 내 자리를 대신할 수 있을까?"
+            },
+            "exception": {
+              "UnimplementedException": {
+                "description": "구현되지 않음",
+                "explanation": "어떻게 해야 할지 모르겠어!"
+              }
+            }
+          },
+          "FunctionDefinition": {
+            "name": "함수",
+            "description": "$1 함수",
+            "emotion": "친절함",
+            "doc": [
+              "안녕! 나는 몇 가지 입력을 받고, 그 입력을 사용하여 표현을 평가하고 출력을 생성해내는 함수야.",
+              "간단한 예를 보여줄게:",
+              "\\ƒ repeat(message•'') message · 5\nrepeat('hi')\\",
+              "이 함수는 하나의 입력, \\message\\를 가지고 있고 @Text/repeat 함수를 사용하여 메시지를 다섯 번 반복해.",
+              "다양한 입력으로 무언가를 반복해서 평가하고 싶을 때 정말 유용해요!",
+              "나는 여러 작은 트릭을 알고 있어. 예를 들자면, 난 이름이 없어도 돼. 나는 여기서 바로 @Evaluate 값으로 이동하고 있어.",
+              "\\(ƒ(message•'') message · 5)('hi')\\",
+              "또는, 어떤 숫자 입력이든 사용할 수 있는 함수도 있어. 입력 이름 뒤에 \\…\\ 문자를 사용하면 돼.",
+              "\\ƒ yes(messages…•'') messages.sans('no')\nyes('yes' 'yes' 'no' 'yes' 'no')\\",
+              "'no'를 모두 제거했지? messages는 @List이기 때문에 @List/sansAll을 사용할 수 있었어.",
+              "가끔씩 나는 내가 생산하는 값의 종류를 명확하게 하고 싶을 때 있어. 그럴 때는 입력 목록 뒤에 @Is를 추가해:",
+              "\\ƒ add(x•# y•#)•'' x + y\\",
+              "이것에 문제가 있는 것을 알 수 있을 것야: @Text으로 평가된다고 말하고 있지만 두 개의 @Number를 가져가고 있어. 일관성이 없을 때 알려드릴 수 있어",
+              "물론 @Evaluate 없이는 전혀 유용하지 않아. 그들이 나를 유지시키거든."
+            ],
+            "start": "이 함수를 만들어 보자!",
+            "conflict": {
+              "NoExpression": "평가할 표현이 필요해. 추가할 수 있을까?"
+            }
+          },
+          "Iteration": {
+            "name": "고차 함수",
+            "emotion": "친절함",
+            "doc": "나는 @FunctionDefinition 중 특별한 종류로, 여러 가지 항목들의 목록에 작용해. 나에 대해 자세히 알 필요는 없어, 나는 @List/translate와 같은 함수를 만들어내기 위한 거야.",
+            "start": "주어진 함수를 평가하는 중",
+            "initialize": "항목들을 순회하기 위해 준비 중",
+            "next": "다음 항목으로 이동 중",
+            "check": "계속할지 결정하는 중",
+            "finish": "$1로 평가되었습니다"
+          },
+          "Initial": {
+            "name": "시작",
+            "emotion": "호기심",
+            "doc": [
+              "@Program의 현재 평가가 첫 번째인지 여부를 알려주는 역할을 하는데, 이것은 @Boolean으로 평가돼. 예를 들어:",
+              "\\◆ ? Time() 'hi'\\",
+              "너는 보지 못했겠지만, 첫 번째 평가는 시간이었지만 그 후의 모든 시간 동안 나는 \\⊥\\였고, @Conditional이 \\⊤\\으로 만들었어.",
+              "나는 스트림을 다룰 때 유용해, 첫 번째 시간에만 뭔가를 하고 싶을 때나 첫 번째 시간에는 아예 하고 싶지 않을 때 말이야!"
+            ]
+          },
+          "Insert": {
+            "name": "삽입",
+            "emotion": "친절함",
+            "doc": [
+              "@Table이 있고 뭔가 부족한 느낌일 때가 있지? 나는 그것을 추가할 수 있어!",
+              "게임에서 선수들의 테이블이 있다고 가정해봐. 새로운 선수를 추가하고 싶을 때:",
+              "\\players: ⎡name•'' team•'' points•#⎦\n⎡'jen' 'red' 1⎦\n⎡'joan' 'blue' 0⎦\n⎡'jeff' 'red' 3⎦\n⎡'janet' 'blue' 2⎦\nplayers ⎡+ 'jason' 'red' 0⎦\\",
+              "그저 기억해둬야 할 것은, Verse의 모든 것처럼 나는 테이블을 변경하지 않고 수정한다는 거야. 그래서 너는 수정한 테이블을 어디에 놓을지 결정해야 해. 아마도 @Reaction에서 입력에 대한 테이블을 수정하고 @Bind에 저장하려고 할 거."
+            ],
+            "start": "테이블을 업데이트할 위치를 찾아봐요",
+            "finish": "수정된 행이 있는 새로운 테이블을 만들었어요!"
+          },
+            "Is": {
+              "name": "이다",
+              "description": "이다",
+              "emotion": "궁금한",
+              "doc": [
+                "그거 알아? 정말 다양한 의미를 가진 많은 종류의 값들이 있어. 나는 그것들이 무엇을 의미하는지 찾는 데 도움이 돼.",
+                "예를 들면, 수수께끼 값이 있다고 상상해봐. 나는 그것이 @Number인지, @Boolean을 주는지 알려줄 수 있어:",
+                "\\mystery: '비밀!'\nmystery•#\\",
+                "숫자가 아니기 때문에 \\⊥\\로 만들어졌어. 그런데 그게 @TextType인지 확인하면?",
+                "\\mystery: '비밀!'\nmystery•''\\",
+                "그러면 \\⊤\\가 돼!",
+                "어떤 @Name이 특정 종류의 값인지 알아야 할 때 정말 도움이 돼."
+              ],
+              "start": "우리 먼저 $1의 값을 가져오자",
+              "finish": "$1[값은 $2|값은 $2가 아님]",
+              "conflict": {
+                "ImpossibleType": "이건 결코 이 타입이 될 수 없어"
+              },
+              "exception": {
+                "TypeException": {
+                  "description": "호환되지 않는 값",
+                  "explanation": "$1을(를) 기대했지만 $2을(를) 받았어"
+                }
+              }
+            },
+            "IsLocale": {
+              "name": "언어인가?",
+              "description": "언어인가?",
+              "emotion": "친절한",
+              "doc": [
+                "나는 너가 특정 언어나 지역을 선택했는지 확인하는 데 도움이 돼:",
+                "\\🌍/en\\",
+                "\\🌍/es-MX\\",
+                "이것은 선택된 언어에 따라 공연을 변경하고 싶을 때 유용하다."
+              ],
+              "start": "그 언어는 $1 야?"
+            },
+            "ListAccess": {
+              "name": "리스트 접근",
+              "emotion": "신이 나는",
+              "doc": [
+                "@List와 긴밀하게 협력해서 특정 위치의 값을 얻는 데 도움을 줘. 예를 들면, 리스트가 있고 그 중 두 번째 아이템을 원한다면 이렇게 쓸 수 있어:",
+                "\\list: ['새' '오리' '물고기' '뱀']\nlist[2]\\"
+              ],
+              "start": "먼저 리스트 $1의 값을 가져오자",
+              "finish": "아이템은 $2야!"
+            },
+            "ListLiteral": {
+              "name": "특정 리스트",
+              "description": "$1 항목 리스트",
+              "emotion": "열렬한",
+              "doc": "@List의 구체적인 값들의 리스트야! 나에 대해 더 알고 싶다면 @List를 참고해봐.",
+              "start": "먼저 항목을 평가해보자",
+              "finish": "나는 나를 만들었어! $1",
+              "item": "항목"
+            },
+            "Spread": {
+              "name": "리스트 확장",
+              "emotion": "진지한",
+              "doc": [
+                "다른 리스트들의 값으로 리스트를 만들 수 있게 도와주는 거야. 이렇게:",
+                "\\list1: [1 2 3]\nlist2: [4 5 6]\nfinal: [list1… list2…]"
+              ]
+            },
+            "MapLiteral": {
+              "name": "맵",
+              "description": "$1 쌍 맵",
+              "emotion": "친절한",
+              "doc": "@Map의 구체적인 키와 값 사이의 연결이야. 나에 대해 더 알고 싶다면 @Map을 참고해봐.",
+              "start": "먼저 키와 값을 평가해보자",
+              "finish": "나는 모두를 연결했어, $1",
+              "conflict": {
+                "NotAKeyValue": {
+                  "primary": "내 키 중 하나에 값이 누락돼있어",
+                  "secondary": "어? 내 값이 어디 갔지?"
+                }
+              }
+            },
+            "NumberLiteral": {
+              "name": "특정 숫자",
+              "description": "$1 $2[$2|]",
+              "emotion": "흥분한",
+              "doc": "@Number의 구체적인 값이야. 어떤 언어의 어떤 종류의 숫자든 나를 쓸 수 있어. 내가 할 수 있는 모든 걸 알려면 @Number를 참고해봐.",
+              "start": "$1!",
+              "conflict": {
+                "NotANumber": "나는 모든 숫자를 알고 있을 줄 알았는데, 이건 모르는 숫자야"
+              }
+            },
+            "InternalExpression": {
+              "name": "내부 표현",
+              "emotion": "중립적인",
+              "doc": "어떻게 나를 찾았어? 나는 원조 창조자만 사용하는 표현이야. 나에 대해 더 알고 싶다면 그들에게 말해봐.",
+              "start": "비밀 표현"
+            },
+            "NoneLiteral": {
+              "name": "그냥 없음",
+              "emotion": "중립적인",
+              "doc": "/@FunctionDefinition 여기. 이건 그냥 @None이야. 이건 독특한 존재야! @None에 대해 더 알고 싶다면 @None을 참고해봐.",
+              "start": "… ø"
+            },
+            "Previous": {
+              "name": "이전",
+              "emotion": "진지한",
+              "doc": [
+                "과거를 기억해보고 싶었던 적이 있니?",
+                "나는 Verse의 공식 기록관이야. 나에게 스트림과 숫자를 줘서 과거에서 그 스트림의 값이 어떤지 말해줄게.",
+                "예를 들면, 다섯 번째로 @Time이 얼마나 전이었는지 여기에 있어:",
+                "\\← 5 Time(1000ms)\\",
+                "5초 동안 @None이고 갑자기 이전 시간이 나타난 거 봐.",
+                "마지막 몇 가지 값을 원한다면 화살표를 두 번 주면 돼. 그러면 숫자를 개수로 해석해서 여러 값이 나오게 돼:",
+                "\\←← 5 Time(1000ms)\\",
+                "한 번이 아니라 이전 다섯 번의 시간이 나오는 거 봐.",
+                "과거에 의존하는 공연을 만들고 싶을 때 도움이 돼."
+              ],
+              "start": "먼저 $1을(를) 가져와볼까",
+              "finish": "스트림 값은 $1으로 평가됐어"
+            },
+            "Program": {
+              "name": "프로그램",
+              "emotion": "진지한",
+              "doc": [
+                "여러 캐릭터들이 공연을 조정하는 곳이야, 공연의 시작과 끝을 담당해.",
+                "@Block이 표현 목록을 평가하고 목록에서 마지막 값으로 평가되는 거 알지?",
+                "나도 똑같아, 내 값을 내가 있는 표현에 주는 대신에 @Stage에 넣어.",
+                "값은 뭐든 될 수 있어: @Number, @Text, 또는 @Boolean, @List, @Set, @Map 같은 복잡한 거나 @Phrase, @Group, @Stage 같은 것도 될 수 있어.",
+                "너에게 값 하나를 보여주지 않으면 너에게 값을 요청할 거야.",
+                "공연 중에 문제가 발생하면 그 문제를 보여줄게.",
+                "그리고 공연이 *스트림*에 의존하면 그 스트림이 변경될 때마다 다시평가할 거야."
+              ],
+              "unevaluated": "선택한 노드가 평가되지 않았어",
+              "start": "$1[$1 스트림이 $2으로 변경됐어!|첫 번째 평가다]",
+              "halt": "예외 발생, 중지 중",
+              "finish": "다 끝났어, 나는 $1으로 평가됐어",
+              "done": "평가 중인 것이 없어",
+              "exception": {
+                "BlankException": {
+                  "description": "빈 프로그램",
+                  "explanation": "쇼를 해보자! 어디서 시작할까?"
+                },
+                "EvaluationLimitException": {
+                  "description": "평가 제한",
+                  "explanation": "@Evaluate와 나는 평가하는 게 지겨워, 특히 $1에게.\n\n$1이 계속 자기 자신을 끝없이 평가하고 있는 건 아닌지 확인할 수 있을까?"
+                },
+                "StepLimitException": {
+                  "description": "단계 제한",
+                  "explanation": "단계가 너무 많아. 너무 많아서 끝낼 수 없어! 공연을 더 간단하게 만들 수 있을까?"
+                },
+                "ValueException": {
+                  "description": "값 누락",
+                  "explanation": "값을 기대했는데 받지 못했어!"
+                }
+              }
+            },
+            "PropertyBind": {
+              "name": "다듬기",
+              "description": "$1[$1|이름 없음] 다듬기",
+              "emotion": "친절한",
+              "doc": [
+                "@StructureDefinition을 만들 때 작은 변경만 하고 싶을 때가 있어, 모든 값을 똑같이 가지고 있는 새로운 것을 만들 필요 없이.",
+                "예를 들면, 고양이 기록을 유지하고 있었는데 고양이의 취미를 바꾸고 싶다면 내가 도와줄게:",
+                "\\•Cat(name•'' color•'' hobby•'')\n\nkitty: Cat('스프링클스' '주황' '핥기')\nkitty.hobby:'깨물기'\\",
+                "이전 값과 똑같은 값들을 가진 전체 새로운 \\Cat\\을 만드는 것보다 이게 훨씬 쉬워, 그치."
+              ],
+              "start": "먼저 값을 가져오자",
+              "finish": "구조를 복사했지만 $1을(를) $2로 만들었어"
+            },
+            "PropertyReference": {
+                "name": "속성",
+                "description": "$1[$1|이름 없음] 속성",
+                "emotion": "친절한",
+                "doc": [
+                "@StructureDefinition을 만들 때 그 중 하나의 입력을 어떻게 얻을지에 대한 것이야.",
+                "도시에 관한 구조를 만든다면 나를 통해 이렇게 값을 얻을 수 있어:",
+                "\\•City(name•'' population•#people)\n\nportland: City('포틀랜드' 800000people)\n\nportland.population\\"
+              ],
+                "start": "먼저 값을 가져오자",
+                "finish": "구조를 복사했지만 $1으로 $2을 사용했어",
+                "property": "$?"
+            },
+            "Reaction": {
+                "name": "반응",
+                "emotion": "신나는",
+                "doc": [
+                    "스트림은 정말 멋져요! 변경될 때마다 새로운 것들을 만들 수 있어요, 이건 정말 멋진 일이죠!",
+                    "예를 들어, @시간이 흐르는 것을 보여주고 싶지만, 숫자 대신 단어로 표현하고 싶다면 이렇게 할 수 있어요:",
+                    "\\시간: Time(1000ms)\n'시작' … ∆ 시간 … ((시간 % 2) = 0ms) ? '짝수' '홀수'\\",
+                    "이것은 \"/'시작'이라는 단어로 시작해서 시간이 변경될 때마다 '짝수' 또는 '홀수'로 변경되는 것을 의미해요./\"",
+                    "그래서 저도 스트림이지만, 다른 스트림을 기반으로 한 것이죠. 멋지지 않나요?"
+                ],
+                "start": "스트림을 업데이트해야 하는지 봅시다",
+                "finish": "새 스트림 값은 $1입니다",
+                "initial": "초기",
+                "condition": "조건",
+                "next": "다음",
+                "conflict": {
+                "ExpectedStream": "$1이 스트림을 참조하지 않으므로, 저는 반응하지 않을 거예요!"
+            }
+        },
+        "Reference": {
+            "name": "참조",
+            "description": "$1",
+            "emotion": "수줍은",
+            "doc": [
+                "@바인드가 것들에게 @이름을 부여하는 것을 알고 있죠? 저는 그것들을 참조하는 방법입니다. 어떤 @바인드가 그 이름을 가지고 있는지 확인하고, 그렇다면 그 값은 제공합니다. 이렇게요:",
+                "\\앵무새: '폴리'\n앵무새\\",
+                "만약 제가 그 이름을 찾지 못하면, 무엇을 해야 할지 모르겠어요.",
+                "\\앵무새: '폴리'\n페리\\"
+            ],
+            "start": "$1은 어떤 값을 가지고 있나요?",
+            "conflict": {
+                "UnknownName": "$1[이름이 $1인 사람을 $2[$2|이 @블록에서] 모릅니다|이름을 알려줄 수 있나요?]",
+                "ReferenceCycle": "음, $1의 값이 자기 자신에 의존하는데, 어떤 값을 제공해야 할지 어떻게 알 수 있죠?",
+                "UnexpectedTypeVariable": "이 타입 입력들로 무엇을 해야 할지 모르겠어요"
+            },
+            "exception": {
+                "NameException": {
+                    "description": "알 수 없는 이름",
+                    "explanation": "$1[이름이 $1인 사람을 $2[$2|이 @블록에서]… 알 수 없습니다|으앗, 이름이 없어요!]"
+                }
+            }
+        },
+        "Select": {
+            "name": "선택",
+            "emotion": "신나는",
+            "doc": [
+                "가끔 테이블이 있고 그 중 일부만 원할 때가 있어요. 저는 그것을 가져다 드릴 수 있어요!",
+                "예를 들어, 게임에서 플레이어들의 테이블이 있고, 점수가 10점 이상인 사람들을 찾아 누가 이겼는지 알고 싶다면:",
+                "\\플레이어: ⎡이름•'' 팀•'' 점수•#⎦\n⎡'jen' 'red' 8⎦\n⎡'joan' 'blue' 11⎦\n⎡'jeff' 'red' 9⎦\n⎡'janet' 'blue' 7⎦\n플레이어 ⎡? 이름 ⎦ 점수 ≥ 10\\",
+                "그렇게 해서, 저는 승자들의 행 목록을 얻었어요! 저는 테이블을 변경하지 않고 새로운 테이블을 만든다는 것을 기억하세요. 어디에 둘지 결정해야 합니다."
+            ],
+            "start": "먼저 테이블을 가져와 봅시다",
+            "finish": "선택된 행과 열만 있는 새로운 테이블을 만들었어요!",
+            "conflict": {
+                "ExpectedSelectName": "적어도 하나의 열 이름이 필요해요."
+            }
+        },
+        "SetLiteral": {
+            "name": "특정 세트",
+            "description": "$1 아이템",
+            "emotion": "열정적인",
+            "doc": "저는 특정 값들의 특정 @세트예요. 저와 함께 작업하는 방법에 대해 더 알고 싶다면 @세트를 참조하세요.",
+            "start": "먼저 값들을 평가해 봅시다!",
+            "finish": "세트 $1을 만들었어요!"
+        },
+        "SetOrMapAccess": {
+            "name": "세트/맵 접근",
+            "emotion": "친절한",
+            "doc": [
+                "@세트 또는 @맵에 값이나 키가 있는지 확인할 수 있어요.",
+                "그리 어렵지 않아요. 이렇게 말이죠:",
+                "\\좋아하는 것들: {'오리' '거위' '원숭이'}\n좋아하는 것들{'쥐'}\\",
+                "또는 @맵을 사용하여 이렇게요:",
+                "\\좋아하는 것들: {'맥앤치즈': 5별 '시리얼': 2별 '죽': 1별}\n좋아하는 것들{'죽'}\\"
+            ],
+            "start": "세트나 맵은 무엇인가요?",
+            "finish": "값은 $1입니다",
+            "conflict": {
+                "IncompatibleKey": {
+                    "primary": "$1 키를 예상했습니다", 
+                    "secondary": "$2 대신 $1을 받았습니다" 
+                }
+            }
+        },
+        "Source": {
+            "name": "소스",
+            "emotion": "호기심 많은",
+            "doc": [
+                "@프로그램을 알고 계시나요? 저는 그것들에 이름을 붙여주는 데 도움을 줍니다. @프로그램 주변의 창문과 그것들에 붙이는 이름처럼 생각하세요.",
+                "다른 @프로그램과 함께 다른 @소스 @UI/소스추가를 만들고, 다른 @프로그램에서 @빌리기를 통해 다른 프로그램에서 사용할 것들을 가져올 수도 있어요.",
+                "이것은 큰 공연을 별도의 문서로 조직하는 좋은 방법이 될 수 있습니다."
+            ]
+        },
+        "StreamDefinition": {
+            "name": "스트림",
+            "emotion": "호기심 많은",
+            "doc": "제가 새로운 스트림을 만들어야 한다고 /생각/합니다. 하지만 정말로 그 방법을 모르겠어요. 지금은, 이미 존재하는 스트림을 사용하는 것이 좋겠죠?",
+            "start": "이 새로운 종류의 스트림을 만듭니다"
+        },
+        "StructureDefinition": {
+            "name": "구조",
+            "description": "구조 $1",
+            "emotion": "친절한",
+            "doc": [
+                "안녕하세요, 어떠세요? 저요? 저는 잘 지내고 있어요. 값을 저장하고 기능하는 구조를 정의하는 것을 좋아해서, 그 일을 하루 종일 할 수 있다면 저는 행복해요.",
+                "저는 이렇게 작동해요:",
+                "\\•피자(\n재료들•['']\n크기•#인치\n) (\n\tƒ 비용() 크기 · 10달러/인치\n)\n\n피자(['페퍼로니' '페퍼'] 12인치).비용()\\",
+                "작동 방식을 보세요? \\피자\\를 정의했는데, 두 개의 입력, \\재료들\\ (텍스트 목록)과 \\크기\\ (인치 단위의 숫자)가 있어요.",
+                "내부에서, @함수정의는 인치 당 $10을 가정하여 피자 비용을 평가하는 함수를 만들었어요.",
+                "저는 @함수정의가 없어도 됩니다. 단지 입력들만 있을 수 있어요.",
+                "\\•피자(\n재료들•['']\n크기•#인치\n)\\",
+                "또한 내부에 @바인드를 가질 수 있어서, 미리 비용을 평가할 수 있어요.",
+                "\\•피자(\n재료들•['']\n크기•#인치\n) (\n\t비용: 크기 · 10달러/인치\n)\n\n피자(['페퍼로니' '페퍼'] 12인치).비용\\"
+            ],
+            "start": "이 멋진 구조를 정의해 봅시다",
+            "conflict": {
+                "DisallowedInputs": "제 인터페이스 함수 중 하나 이상이 구현되지 않았기 때문에 입력을 가질 수 없어요",
+                "IncompleteImplementation": "제 함수들은 모두 구현되거나, 하나도 구현되지 않아야 해요. 어정쩡한 혼합은 안 됩니다!",
+                "NotAnInterface": "저는 인터페이스가 아니에요; 구조는 다른 구조가 아닌 인터페이스만 구현할 수 있어요",
+                "UnimplementedInterface": "저는 $1을 구현하지만 $2를 구현하지 않았어요"
+            }
+        },
+        "TableLiteral": {
+            "name": "특정 테이블",
+            "description": "$1 행 테이블",
+            "emotion": "화난",
+            "doc": "저는 특정한 행들을 가진 구체적인 테이블입니다. 저를 어떻게 활용할 수 있는지 @테이블에서 확인해보세요.",
+            "start": "먼저 행들을 평가합니다",
+            "finish": "새 테이블 $1로 평가되었습니다"
+        },
+        "TextLiteral": {
+            "name": "특정 텍스트",
+            "description": "텍스트 $1",
+            "emotion": "진지한",
+            "doc": "저는 하나 이상의 구체적인 @번역된 텍스트를 나타냅니다. 저의 기능에 대해 더 알고 싶다면 @텍스트를 참조하세요!",
+            "start": "현재 로케일에서 텍스트를 만듭시다"
+        },
+        "Translation": {
+            "name": "번역",
+            "description": "텍스트 $1",
+            "emotion": "진지한",
+            "doc": "저는 @언어 태그가 있는 텍스트를 나타냅니다. 저에 대해 더 알고 싶다면 @텍스트를 참조하세요!"
+        },
+        "FormattedLiteral": {
+            "name": "포맷된 텍스트",
+            "description": "텍스트 $1",
+            "emotion": "진지한",
+            "doc": "저는 다양한 @포맷된번역의 포맷된 텍스트를 나타냅니다. 평가할 때, 관객의 선택된 언어에 기반하여 최적의 일치를 선택할 거예요.",
+            "start": "현재 로케일에서 텍스트를 만듭시다"
+        },
+        "FormattedTranslation": {
+            "name": "포맷된 텍스트",
+            "description": "텍스트 $1",
+            "emotion": "진지한",
+            "doc": [
+                "저는 @언어 태그가 있는 포맷된 텍스트를 나타냅니다.",
+                "저는 다음과 같을 수 있어요:",
+                "\\`/이탤릭/`\\",
+                "\\`*볼드*`\\",
+                "\\`^엑스트라 볼드^`\\",
+                "\\`_밑줄_`\\",
+                "\\`<링크@https://wordplay.dev>`\\",
+                "\\`\\'코드'\\`\\",
+                "@프레이즈와 함께 @무대에 아름다운 텍스트를 올리는 데 정말 잘 작동해요."
+            ]
+        },
+        "This": {
+            "name": "이것",
+            "emotion": "진지한",
+            "doc": [
+                "가끔은 값을 명시적으로 이름 짓기보다는 암시적으로 참조하는 것이 도움이 됩니다.",
+                "예를 들어, 변환되는 값을 이름으로 지정하지 않는 새로운 @변환정의를 만들고 싶다고 가정해 봅시다. 저를 사용하여 그것을 참조할 수 있어요:",
+                "\\→ #무지개 #기쁨 . · 1000000기쁨\n2무지개 → #기쁨\\",
+                "저를 보세요, 무지개의 수를 대표하고 있죠?",
+                "또는 @반응을 만들고 싶지만 가장 최근의 값을 이름으로 지정하고 싶지 않다면:",
+                "\\2 … ∆ 시간(1000ms) … . · 2\\",
+                "저를 확인하세요, 이전 반응 값을 대표하고 있습니다.",
+                "자주 등장하지는 않지만, 등장할 때면 @바인드에서 값을 정말 도와줄 수 있어요!"
+            ],
+            "start": "$1로 평가되었습니다",
+            "conflict": {
+                "MisplacedThis": "저는 구조, 변환, 또는 반응 안에서만 허용됩니다."
+            }
+        },
+        "UnaryEvaluate": {
+            "name": "단항 평가",
+            "description": "$1",
+            "emotion": "친절한",
+            "doc": [
+                "하나의 값만 평가하는 @함수정의에 있어서, @함수정의의 이름이 단일 기호일 경우, 입력 앞에 이름을 둘 수 있다는 것을 알고 계셨나요?",
+                "이렇게 말이죠:",
+                "\\-(1 + 1)\\",
+                "또는 이렇게:",
+                "\\~⊥\\",
+                "\\(1 + 1).negate()\\ 또는 \\⊥.not()\\보다 읽기 훨씬 쉽죠?",
+                "저를 그렇게 쓸 필요는 없지만, 전체적으로 더 쉬울 수 있어요.",
+                "한 가지 규칙이 있습니다: 이름과 값 사이에 공백을 둘 수 없어요. 그렇지 않으면 @참조 또는 @이항평가를 만들 수 있습니다."
+            ],
+            "start": "값이 무엇인가요?",
+            "finish": "$1을 만들었습니다"
+        },
+        "UnparsableExpression": {
+            "name": "해석 불가",
+            "emotion": "신나는",
+            "doc": [
+                "/안녕하세요, @함수정의입니다. 해석하기 어려운 @해석불가표현식을 대신 번역하고 있어요./",
+                "jkwel fjiwojvioao jjiweo jrfe",
+                "/무대에서 모든 표현식이 의미를 가지는 것은 아닙니다./",
+                "s w ieorjwei iojwi jfkdlsfdsk",
+                "/실제로, 전혀 말이 되지 않는 말을 할 수 있는 것들이 많죠./",
+                "dsk sdlk jdkfiewipapweiurb,v kdsfdsf",
+                "/그럴 때 저는 나타나요, 왜냐하면 당신이 무엇을 의미했는지 모르거든요./",
+                "결국엔 당신이 연출가이니, 당신만이 무엇을 의미했을지 알겠죠!"
+            ],
+            "start": "???",
+            "conflict": {
+                "UnparsableConflict": "@함수정의 여기 있어요, @해석불가표현식은 이것이 어떤 종류의 $1[ 표현 | 타입 ]인지 모르겠어요/",
+                "UnclosedDelimiter": "$1 이후에 언젠가 $2가 나올 것이라고 예상했어요"
+            },
+            "exception": {
+                "UnparsableException": {
+                    "description": "???",
+                    "explanation": "/안녕하세요, @함수정의입니다! 우리는 이것이 어떤 종류의 지시인지 몰라 공연을 중단해야 했어요./"
+                }
+            }
+        },
+        "Update": {
+            "name": "업데이트",
+            "emotion": "친절한",
+            "doc": [
+                "저는 @테이블을 수정하는 데 도움을 줍니다. 조건에 맞는 행을 찾아 새로운 값으로 개정된 행을 생성합니다.",
+                "예를 들어, 캐릭터와 점수가 있는 테이블이 있고, 특정 팀의 모든 캐릭터에게 점수를 주고 싶다면 이렇게 할 수 있습니다:",
+                "\\플레이어: ⎡이름•'' 팀•'' 점수•#⎦\n⎡'jen' 'red' 1⎦\n⎡'joan' 'blue' 0⎦\n⎡'jeff' 'red' 3⎦\n⎡'janet' 'blue' 2⎦\n플레이어 ⎡: 점수: 점수 + 1 ⎦ 팀 = 'blue'\\",
+                "변경할 열을 지정하기 위해 @바인드를 사용할 수 있고, 조건에는 열 이름이나 범위 안의 다른 이름을 사용할 수 있습니다."
+            ],
+            "start": "먼저 테이블을 가져와 봅시다",
+            "finish": "개정된 행을 포함한 새 테이블로 평가되었습니다!",
+            "conflict": {
+                "ExpectedColumnBind": "모든 열에 대한 값을 필요로 합니다",
+                "IncompatibleCellType": {
+                    "primary": "$1이 필요했지만, $2를 받았습니다",
+                    "secondary": "$2를 받았습니다"
+                }
+            }
+        },
+        "AnyType": {
+            "name": "아무 타입",
+            "emotion": "궁금한",
+            "doc": "나는 어떤 가능한 타입이든 대표해. 가끔 나타나는 이유는 뭔가의 값이 어떤 종류인지 모르기 때문에 뭐든 될 수 있어."
+        },
+        "BooleanType": {
+            "name": "불리언",
+            "emotion": "친절한",
+            "doc": [
+              "나는 @Bind와 함께 작동해서 이름이 @Boolean 값임을 선언해. 이렇게:",
+              "\\hungry•?: 'jello'\\",
+              "뭔가가 정말 @Boolean인지 확실하게 하려면 나를 사용해, 내가 확인해 줄게!"
+            ]
+        },
+        "ConversionType": {
+            "name": "변환",
+            "emotion": "진지한",
+            "doc": [
+              "@Bind와 함께 작동해서 이름이 @ConversionDefinition인 것을 나타냄. 아마도 나를 사용할 일은 별로 없을 거야, 왜냐하면 많은 사람들이 나를 값으로 전달하지 않기 때문이지만, 만약에 나를 사용한다면 이렇게 보일거야:",
+              "\\magic•?→'': → ? '' . ? 'yep' 'nope'\\"
+            ]
+        },
+        "FormattedType": {
+            "name": "포맷된",
+            "emotion": "진지한",
+            "doc": [
+              "@Bind와 함께 작동해서 이름이 @FormattedLiteral 값임을 알림. 이렇게:",
+              "\\hungry•`…`: `I am so /fancy/!`\\",
+              "뭔가가 정말 @FormattedLiteral 값인지 확인하려면 이렇게 확인해 봐."
+            ]
+        },
+        "ExceptionType": {
+            "name": "예외",
+            "emotion": "중립적인",
+            "doc": "나는 예외를 나타냄. 나는 어떻게 보든지 @Program을 중단하기 때문에 나는 값으로 사용할 수 없어."
+        },
+        "FunctionType": {
+            "name": "함수 타입",
+            "description": "$1 입력, $2 출력",
+            "emotion": "궁금한",
+            "doc": [
+              "나는 @FunctionDefinition을 나타냄. @Bind가 어떤 종류의 함수를 가지고 있는지 말하고 싶을 때 정말 도움이 돼! 이렇게:",
+              "\\math•ƒ (# # # #) #: ƒ interesting(a•# b•# c•# d•#) a + b + c + d\\"
+            ]
+        },
+        "ListType": {
+            "name": "리스트 타입",
+            "description": "$1[리스트의 $1|리스트]",
+            "emotion": "쾌활한",
+            "doc": [
+              "나는 정말 @List의 팬이야. @Bind에게 그들이 어떤 종류의 리스트인지 말할 수 있어! 이렇게, 나는 @Number의 리스트라고 말하고 있어:",
+              "\\things•[#]: [ 1 2 3 4 5 ]\\"
+            ]
+        },
+        "MapType": {
+            "name": "맵 타입",
+            "description": "$1[ $1|아무거나]에서 $2[ $2|아무거나]로의 맵",
+            "emotion": "친절한",
+            "doc": [
+              "@Map이 얼마나 멋진지 알아? 진짜로 멋져. 나는 항상 @Bind에게 그들이 어떤 종류의 맵인지 알려주고 있어, 예를 들어 숫자에서 리스트로의 맵이야:",
+              "\\stuff•{'':[]}: {}\\"
+            ]
+        },
+        "NumberType": {
+            "name": "숫자 타입",
+            "description": "$1[ $1 | 숫자]",
+            "emotion": "정확한",
+            "doc": [
+              "@Bind는 뭘 해야 할까? @Number여야지. 왜냐하면 숫자가 최고 af니까.",
+              "\\count•#: 17\\"
+            ]
+        },
+        "NameType": {
+            "name": "이름 타입",
+            "description": "$1 타입",
+            "emotion": "궁금한",
+            "doc": [
+              "나는 @StructureDefinition을 그 이름으로 나타냄. 그래서, 예를 들면 이렇게 구조가 있다면, 값을 저장하는 @Bind를 만들 수 있어.",
+              "\\•Friend(name•'')\nbestie•Friend: Friend('Jonah')\\"
+            ],
+            "conflict": {
+              "UnknownTypeName": "타입 이름은 구조 또는 타입 변수를 참조할 수 있지만 이것은 $1을 참조함"
+            }
+        },
+        "NeverType": {
+            "name": "절대 불가능한 타입",
+            "emotion": "궁금한",
+            "doc": "나는 불가능한 타입을 나타냄. 예를 들어 @Is에게 뭔가가 @Number인지 물어봐도 그것은 결코 숫자가 될 수 없을 때야."
+        },
+        "NoneType": {
+            "name": "없음 타입",
+            "emotion": "중립적인",
+            "doc": [
+              "@None은 가장 최고의 없음이고, 나는 그들의 충실한 대표자야.",
+              "\\space•ø: ø\\"
+            ]
+        },
+        "SetType": {
+            "name": "집합 타입",
+            "description": "$1[ $1 집합|집합] 타입",
+            "emotion": "친절한",
+            "doc": [
+              "@Set은 정말 최고야, 진짜로. 나는 항상 @Bind에게 뭔가를 집합으로 만들라고 말하고 있어!",
+              "\\unique•{''}: {'something' 'anything' 'someone'}\\"
+            ]
+        },
+        "StreamDefinitionType": {
+            "name": "스트림 정의 타입",
+            "emotion": "화가난",
+            "doc": "나는 정의한 스트림을 나타내, 그게 불가능한데, 그러니까 왜 읽고 있어?"
+        },
+        "StreamType": {
+            "name": "스트림 타입",
+            "emotion": "궁금한",
+            "doc": [
+              "나는 스트림의 아름다움과 의미를 축하해… @Bind에게 그것들을 저장하라고 말해:",
+              "\\time•…#ms: Time()\\"
+            ]
+        },
+        "StructureType": {
+            "name": "구조체 타입",
+            "description": "$1",
+            "emotion": "친절한",
+            "doc": "나는 기본 값 타입을 나타내기 위한 내부 타입이야."
+        },
+        "UnknownType": {
+            "name": "알 수 없는 타입",
+            "connector": ", 왜냐하면 ",
+            "emotion": "궁금한",
+            "doc": "음... 나는 내가 뭐를 나타내는지 모르겠어, 근데 정말로 궁금해. 너는 알아? 우리가 알아야 할 것 같아. 모르겠으면 우리한테 말해줘."
+        },
+        "TableType": {
+            "name": "테이블 타입",
+            "emotion": "화가난",
+            "doc": "나는 테이블을 나타냄.",
+            "conflict": {
+              "ExpectedColumnType": "나는 열 타입이 필요해"
+            }
+        },
+        "TextType": {
+            "name": "텍스트 타입",
+            "description": "$1[ $1 | 텍스트]",
+            "emotion": "행복한",
+            "doc": [
+              "나는 가장 화려한 종류의 값, @Text를 멋지게 나타냄.",
+              "\\story•'': '한 번에 하나의 시간에...'\\"
+            ]
+        },
+        "TypePlaceholder": {
+            "name": "플레이스홀더 타입",
+            "emotion": "갈망하는",
+            "doc": "언젠가는 타입을 나타내기를 희망해, 내 베프인 @ExpressionPlaceholder이 표현을 나타내는 것처럼 말이야! 어떤 종류인지 도와줄래?"
+        },
+        "UnionType": {
+            "name": "옵션 타입",
+            "description": "$1 | $2",
+            "emotion": "궁금한",
+            "doc": [
+              "누구를 나타내야 할까, A 또는 B 또는 다른 뭔가? 결정할 수가 없어!",
+              "\\indecision•''|#|{ø}: \"I don't know!\"\\"
+            ]
+        },
+        "Unit": {
+            "name": "단위",
+            "description": "$1",
+            "emotion": "정확한",
+            "doc": [
+              "나는 @Number가 가질 수 있는 모든 단위를 나타내, 단위가 없는 경우부터 상상할 수 있는 가장 복잡한 단위까지. 중력 같은 것 예를 들면:",
+              "\\gravity•m/s^2: 9.8m/s^2\\",
+              "@Bind에서 나타나지만 @Number 바로 뒤에서도 나타나. 나는 숫자가 같은 종류인지 확인하는 데 도움을 주고, 그렇지 않으면 분명히 알려줄 거야, 실수라면 말이야!"
+            ]
+        },
+        "UnparsableType": {
+            "name": "해석할 수 없는 타입",
+            "emotion": "궁금한",
+            "doc": "나는 알 수 없는 표현의 타입을 나타내. 그 표현을 어떤 목적으로 사용하려고 할 때 내가 나타나."
+        },
+        "VariableType": {
+            "name": "변수 타입",
+            "emotion": "궁금한",
+            "doc": "@TypeVariable을 알아? 그리고 그들이 어떤 알 수 없는 종류의 값을 나타내는지? 나는 값 간의 모든 협상에서 그들을 나타내."
+        },
+        "CycleType": {
+            "name": "순환 타입",
+            "description": "자기 자신에 의존",
+            "emotion": "궁금한",
+            "doc": "가끔 값들이 자기 자신에게 의존하고 있어서 그 값이 어떤 종류인지 모르는 경우가 있어. 나는 그 상황을 나타내."
+          },
+        "UnknownVariableType": {
+            "name": "알 수 없는 변수 타입",
+            "emotion": "궁금한",
+            "doc": "가끔 우리는 뭔가의 종류를 추측해 보려고 해; 나는 그게 뭔지 모를 때 나타나."
+        },
+        "NotAType": {
+            "name": "예상치 못한 타입",
+            "description": "$1이 아님",
+            "emotion": "궁금한",
+            "doc": "가끔 우리는 뭔가가 어떤 종류여야 하는지 알아. 예를 들면 @ListAccess는 @Number가 필요해. 그걸 얻지 못하면, 나는 뭔가가 우리가 기대한 것과 다른 타입이라고 나타내."
+        },
+        "NoExpressionType": {
+            "name": "표현식 없음 타입",
+            "emotion": "화난",
+            "doc": "@블록은 적어도 하나의 표현식이 필요한 걸 알고 계시죠? 표현식을 제공하지 않을 때 나타나는 게 바로 저예요. 그러니 표현식을 제공하세요!"
+        },
+        "NotEnclosedType": {
+            "name": "구조, 변환, 반응 안에 없음",
+            "emotion": "호기심 많은",
+            "doc": "@이것은 멋지긴 하지만, 특정 장소에만 속해요. 그들이 길을 잃었을 때, 누구를 대표하는지 아무도 모를 때 저가 나타납니다."
+        },
+        "NotImplementedType": {
+            "name": "구현되지 않음",
+            "emotion": "호기심 많은",
+            "doc": "@표현식자리표시자를 사용하지만, 그 타입을 지정하지 않을 때, 나타나는 타입이 바로 저예요. 그냥 받아들이세요!"
+        },
+        "UnknownNameType": {
+            "name": "알 수 없는 이름",
+            "description": "$1[$1이 정의되지 않음 |이름이 주어지지 않음]",
+            "emotion": "호기심 많은",
+            "doc": "가끔 @참조와 @속성참조가 당신이 말하는 이름을 모를 때가 있죠? 그럴 때 나타나서 우리가 누구에 대해 이야기하고 있는지 모른다는 것을 대표합니다."
+        },
+        "NonFunctionType": {
+            "name": "비함수",
+            "description": "비함수",
+            "emotion": "혼란스러운",
+            "doc": "우리 중 일부는 함수를 기대했는데, 함수를 받지 못했을 때 저가 나타나요."
+        }
+    },
+    "basis": {
+        "Boolean": {
+            "doc": [
+                "우리는 \\⊤\\와 \\⊥\\입니다. \\⊤\\는 참입니다. \\⊥\\는 거짓입니다. \\⊤\\는 \\⊥\\가 아니며; \\⊥\\는 \\⊤\\가 아닙니다. 이것이 그대로의 사실입니다.",
+                "우리를 어떻게 만드나요? 그냥 \\⊤\\와 \\⊥\\, 더도 덜도 아닙니다.",
+                "일부는 키보드를 사용합니다 (/ctrl+9/은 \\⊤\\, /ctrl+0/은 \\⊥\\). 일부는 편집기 하단의 문자 검색을 사용합니다. 또는 여기서 끌어다 쓸 수도 있습니다.",
+                "아래의 @함수정의를 확인해보세요. 그들은 매우 논리적입니다."
+            ],
+            "name": ["⊤⊥", "부울"],
+            "function": {
+                "and": {
+                    "doc": [
+                        "두 값이 모두 \\⊤\\일 때만 \\⊤\\로 평가합니다. 많은 것들이 모두 참인지 결정하는 데 도움이 됩니다. 가능한 결과는 네 가지뿐입니다",
+                        "\\⊤ & ⊤\\",
+                        "\\⊤ & ⊥\\",
+                        "\\⊥ & ⊤\\",
+                        "\\⊥ & ⊥\\"
+                    ],
+                    "names": ["&", "그리고"],
+                    "inputs": [
+                        {
+                            "doc": "확인할 다른 @부울입니다. 첫 번째가 \\⊥\\이면 이것이 무엇이든, 함수는 \\⊥\\로 평가될 것입니다.",
+                            "names": "값" 
+                        }
+                    ]
+                },
+                "or": {
+                    "doc": [
+                        "두 값 중 *하나라도* \\⊤\\일 때 \\⊤\\로 평가합니다. 많은 것들 중 하나라도 참인지 결정하는 데 도움이 됩니다. 가능한 결과는 네 가지뿐입니다",
+                        "\\⊤ | ⊤\\",
+                        "\\⊤ | ⊥\\",
+                        "\\⊥ | ⊤\\",
+                        "\\⊥ | ⊥\\"
+                    ],
+                    "names": ["|", "또는"],
+                    "inputs": [
+                        {
+                            "doc": "확인할 다른 @부울입니다. 첫 번째가 \\⊥\\이면, 이 함수는 이것이 \\⊤\\일 때만 \\⊤\\로 평가됩니다.",
+                            "names": "값"
+                        }
+                    ]
+                },
+                "not": {
+                    "doc": "저는 제 자신의 반대를 얻습니다: 만약 \\⊤\\이라면 \\⊥\\를, 만약 \\⊥\\라면 \\⊤\\를 줍니다.",
+                    "names": ["~", "아님"],
+                    "inputs": [] 
+                },
+                "equals": {
+                    "doc": "둘 다 \\⊤\\이거나 둘 다 \\⊥\\일 경우 \\⊤\\입니다.",
+                    "names": ["=", "동등"],
+                    "inputs": [
+                        { "doc": "확인할 다른 값입니다.", "names": "값" }
+                    ]
+                },
+                "notequal": {
+                    "doc": "둘 다 반대일 경우 \\⊤\\입니다.",
+                    "names": ["≠", "동등하지 않음"],
+                    "inputs": [
+                        { "doc": "확인할 다른 값입니다.", "names": "값" }
+                    ]
+                }
+            },
+            "conversion": {
+                "text": "@부울을 \\'⊤'\\와 \\'⊥'\\의 @텍스트 값으로 변환합니다."
+            }
+        },
+        "None": {
+            "doc": [
+                "/안녕하세요, @함수정의입니다. @없음은 많이 말하지 않아서 제가 통역할게요./",
+                "저는 @없음입니다. \\ø\\로 저를 호출하세요. 무엇인가가 없음을 나타내고 싶을 때 유용합니다."
+            ],
+            "name": ["ø", "없음"],
+            "function": {
+                "equals": {
+                    "doc": "다른 값도 아무것도 아닌가요? 그렇지 않다면, \\⊥\\이겠죠.",
+                    "names": ["=", "동등"],
+                    "inputs": [{ "doc": "다른 값입니다.", "names": "값" }]
+                },
+                "notequals": {
+                    "doc": "다른 값이 /아무것도 아니지 않나요?/",
+                    "names": ["≠", "동등하지 않음"],
+                    "inputs": [{ "doc": "다른 값입니다.", "names": "값" }]
+                }
+            },
+            "conversion": {
+                "text": "\\ø\\를 \\'ø'\\로 만들고 싶나요? 이것이 바로 그 기회입니다." 
+            }
+        },
+        "Text": {
+            "doc": [
+                "저는 원하는 어떤 텍스트도 될 수 있어요, 어떤 언어든, 이런 여는 기호와 닫는 기호를 사용해서: \\\"\"\\, \\“”\\, \\„“\\, \\''\\, \\‘’\\, \\‹›\\, \\«»\\, \\「」\\, 또는 \\『』\\.",
+                "예를 들어, 이 아름다운 문구들을 생각해보세요",
+                "\\“인생을 사는 방법은 두 가지 뿐이다. 하나는 아무것도 기적이 아닌 것처럼 사는 것이고, 다른 하나는 모든 것이 기적인 것처럼 사는 것이다.”\\",
+                "\\『一日三秋』\\",
+                "저를 열면 닫아야 하고, 매칭되는 기호를 사용해야 한다는 것을 기억하세요. 그렇지 않으면 당신의 말이 끝났다는 것을 알 수 없어요.",
+                "\\'hello'/en'hola'/es-MX\\",
+                "저에게 언어 태그를 달거나 여러 번역을 제공할 수도 있어요. 현재 선택된 언어가 있다면 해당 언어로 평가될 거예요.",
+                "다른 값들과 함께 저를 만들고 싶다면, 기호를 사용할 수 있어요.",
+                "예를 들어, 이것을 생각해보세요:",
+                "\\\"여기 몇 가지 합계가 있어요 \\1 + 2\\, \\2 + 3\\, \\3 + 4\\\"\\",
+                "저는 그 합계들을 우아하게 평가하고 @텍스트 안에 넣었죠?",
+                "그 외에도, @함수정의가 만들어준 많은 멋진 함수들이 있어서 단어들로 온갖 일을 할 수 있어요!"
+            ],
+            "name": ["''", "텍스트"],
+            "function": {
+                "length": {
+                    "doc": [
+                        "저는 텍스트의 가독 가능한 문자 수로 평가됩니다; 한 글자는 한 문자, 하나의 이모지도 한 문자입니다. 예를 들어:",
+                        "\\'hello'.length()\\",
+                        "\\'🐈📚'.length()\\"
+                    ],
+                    "names": ["📏", "길이"],
+                    "inputs": [] 
+                },
+                "equals": {
+                    "doc": "\\⊤\\, 주어진 @텍스트와 같은 문자열 순서인 경우.",
+                    "names": ["=", "equals"],
+                    "inputs": [
+                        { "doc": "비교할 @텍스트입니다.", "names": "값" }
+                    ]
+                },
+                "notequals": {
+                    "doc": "\\⊤\\, 주어진 @텍스트와 같은 문자열 순서가 /아닌/ 경우.",
+                    "names": ["≠", "동등하지 않음"],
+                    "inputs": [{ "doc": "비교할 @텍스트입니다.", "names": "값" }]
+                },
+                "repeat": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "segment": {
+                    "doc": "$?",
+                    "names": ["segmentar"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "combine": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "has": {
+                    "doc": "$?",
+                    "names": ["tiene"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "starts": {
+                    "doc": "$?",
+                    "names": ["$? starts"],
+                    "inputs": [{ "doc": "$?", "names": "texto" }]
+                },
+                "ends": {
+                    "doc": "$?",
+                    "names": ["$? ends"],
+                    "inputs": [{ "doc": "$?", "names": "texto" }]
+                }
+            },
+            "conversion": { "list": "$?", "number": "$?" }
+        },
+        "Number": {
+            "doc": "$?",
+            "name": "$?",
+            "function": {
+                "add": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "subtract": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "multiply": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "divide": {
+                    "doc": "$?",
+                    "names": ["÷", "divide"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "remainder": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "positive": {
+                    "doc": "$?",
+                    "names": ["$? positive"],
+                    "inputs": []
+                },
+                "round": {
+                    "doc": "$?",
+                    "names": ["$? round"],
+                    "inputs": []
+                },
+                "roundDown": {
+                    "doc": "$?",
+                    "names": ["$? down"],
+                    "inputs": []
+                },
+                "roundUp": {
+                    "doc": "$?",
+                    "names": ["$? up"],
+                    "inputs": []
+                },
+                "power": {
+                    "doc": "$?",
+                    "names": ["^", "power"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "root": {
+                    "doc": "$?",
+                    "names": ["√", "root"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "lessThan": {
+                    "doc": "$?",
+                    "names": ["<", "lessthan"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "lessOrEqual": {
+                    "doc": "$?",
+                    "names": ["≤", "lessorequal"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "greaterThan": {
+                    "doc": "$?",
+                    "names": [">", "greaterthan"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "greaterOrEqual": {
+                    "doc": "$?",
+                    "names": ["≥", "greaterorequal"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "equal": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "notequal": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "cos": {
+                    "doc": "$?",
+                    "names": ["cos", "cosine"],
+                    "inputs": []
+                },
+                "sin": { "doc": "$?", "names": ["sin", "sine"], "inputs": [] },
+                "min": {
+                    "doc": "$?",
+                    "names": "$? min",
+                    "inputs": [
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        }
+                    ]
+                },
+                "max": {
+                    "doc": "$?",
+                    "names": "$? max",
+                    "inputs": [
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        }
+                    ]
+                }
+            },
+            "conversion": {
+                "text": "$?",
+                "list": "$?",
+                "s2m": "$?",
+                "s2h": "$?",
+                "s2day": "$?",
+                "s2wk": "$?",
+                "s2year": "$?",
+                "s2ms": "$?",
+                "ms2s": "$?",
+                "min2s": "$?",
+                "h2s": "$?",
+                "day2s": "$?",
+                "wk2s": "$?",
+                "yr2s": "$?",
+                "m2pm": "$?",
+                "m2nm": "$?",
+                "m2micro": "$?",
+                "m2mm": "$?",
+                "m2cm": "$?",
+                "m2dm": "$?",
+                "m2km": "$?",
+                "m2Mm": "$?",
+                "m2Gm": "$?",
+                "m2Tm": "$?",
+                "pm2m": "$?",
+                "nm2m": "$?",
+                "micro2m": "$?",
+                "mm2m": "$?",
+                "cm2m": "$?",
+                "dm2m": "$?",
+                "km2m": "$?",
+                "Mm2m": "$?",
+                "Gm2m": "$?",
+                "Tm2m": "$?",
+                "km2mi": "$?",
+                "mi2km": "$?",
+                "cm2in": "$?",
+                "in2cm": "$?",
+                "m2ft": "$?",
+                "ft2m": "$?",
+                "g2mg": "$?",
+                "mg2g": "$?",
+                "g2kg": "$?",
+                "kg2g": "$?",
+                "g2oz": "$?",
+                "oz2g": "$?",
+                "oz2lb": "$?",
+                "lb2oz": "$?"
+            }
+        },
+        "List": {
+            "doc": "$?",
+            "name": "$?",
+            "kind": "$?",
+            "out": "$?",
+            "outofbounds": "$?",
+            "function": {
+                "add": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "append": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "replace": {
+                    "doc": "$?",
+                    "names": ["reemplazar"],
+                    "inputs": [
+                        { "doc": "$?", "names": "$?" },
+                        { "doc": "$?", "names": "$?" }
+                    ]
+                },
+                "length": { "doc": "$?", "names": "$?", "inputs": [] },
+                "random": { "doc": "$?", "names": "$?", "inputs": [] },
+                "first": { "doc": "$?", "names": "$?", "inputs": [] },
+                "last": { "doc": "$?", "names": "$?", "inputs": [] },
+                "has": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "join": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "subsequence": {
+                    "doc": "$?",
+                    "names": "$? subsequence",
+                    "inputs": [
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        },
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        }
+                    ]
+                },
+                "sansFirst": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": []
+                },
+                "sansLast": { "doc": "$?", "names": "$?", "inputs": [] },
+                "sans": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "sansAll": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "reverse": { "doc": "$?", "names": "$?", "inputs": [] },
+                "equals": {
+                    "doc": "$?",
+                    "names": ["=", "equals"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "notequals": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "translate": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }],
+                    "translator": [
+                        { "doc": "$?", "names": "$? item" },
+                        { "doc": "$?", "names": "$? index" },
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        }
+                    ]
+                },
+                "filter": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }],
+                    "checker": [
+                        { "doc": "$?", "names": "$? item" },
+                        { "doc": "$?", "names": "$? index" },
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        }
+                    ]
+                },
+                "all": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }],
+                    "checker": [
+                        { "doc": "$?", "names": "$? item" },
+                        { "doc": "$?", "names": "$? index" },
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        }
+                    ]
+                },
+                "until": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }],
+                    "checker": [
+                        { "doc": "$?", "names": "$? item" },
+                        { "doc": "$?", "names": "$? index" },
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        }
+                    ]
+                },
+                "find": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }],
+                    "checker": [
+                        { "doc": "$?", "names": "$? value" },
+                        { "doc": "$?", "names": "$? index" },
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        }
+                    ]
+                },
+                "combine": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [
+                        { "doc": "$?", "names": "$?" },
+                        { "doc": "$?", "names": "$?" }
+                    ],
+                    "combiner": [
+                        { "doc": "$?", "names": "$?" },
+                        { "doc": "$?", "names": "$?" },
+                        { "doc": "$?", "names": "$?" },
+                        {
+                            "doc": "$?",
+                            "names": "$?"
+                        }
+                    ]
+                },
+                "sorted": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$", "names": "$? sequencer" }],
+                    "sequencer": [{ "doc": "$?", "names": "$? value" }]
+                }
+            },
+            "conversion": { "text": "$?", "set": "$?" }
+        },
+        "Set": {
+            "doc": "$?",
+            "name": "$?",
+            "kind": "$?",
+            "out": "$?",
+            "function": {
+                "size": {
+                    "doc": "$?",
+                    "names": "$? size",
+                    "inputs": []
+                },
+                "equals": {
+                    "doc": "$?",
+                    "names": ["=", "equals"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "notequals": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "add": {
+                    "doc": "$?",
+                    "names": ["add", "+"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "remove": {
+                    "doc": "$?",
+                    "names": ["remove", "-"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "union": {
+                    "doc": "$?",
+                    "names": ["union", "∪"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "intersection": {
+                    "doc": "$?",
+                    "names": ["intersection", "∩"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "difference": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "filter": {
+                    "doc": "$?",
+                    "names": "filter",
+                    "inputs": [{ "doc": "$?", "names": "$? checker" }],
+                    "checker": [
+                        { "doc": "$?", "names": "$? value" },
+                        {
+                            "doc": "$?",
+                            "names": "$? set"
+                        }
+                    ]
+                },
+                "translate": {
+                    "doc": "$?",
+                    "names": "translate",
+                    "inputs": [{ "doc": "$?", "names": "$? translator" }],
+                    "translator": [
+                        { "doc": "$?", "names": "$? value" },
+                        {
+                            "doc": "$?",
+                            "names": "$? set"
+                        }
+                    ]
+                }
+            },
+            "conversion": { "text": "$?", "list": "$?" }
+        },
+        "Map": {
+            "doc": "$?",
+            "name": "$?",
+            "key": "$?",
+            "value": "$?",
+            "result": "$?",
+            "function": {
+                "size": {
+                    "doc": "$?",
+                    "names": "$? size",
+                    "inputs": []
+                },
+                "equals": {
+                    "doc": "$?",
+                    "names": ["=", "equals"],
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "notequals": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "set": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [
+                        { "doc": "$?", "names": "$?" },
+                        { "doc": "$?", "names": "$?" }
+                    ]
+                },
+                "unset": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "remove": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$?" }]
+                },
+                "filter": {
+                    "doc": "$?",
+                    "names": "filter",
+                    "inputs": [{ "doc": "$?", "names": "$? checker" }],
+                    "checker": [
+                        { "doc": "$?", "names": "$? key" },
+                        { "doc": "$?", "names": "$? value" },
+                        { "doc": "$?", "names": "$?" }
+                    ]
+                },
+                "translate": {
+                    "doc": "$?",
+                    "names": "translate",
+                    "inputs": [{ "doc": "$?", "names": "$? translator" }],
+                    "translator": [
+                        { "doc": "$?", "names": "$? key" },
+                        { "doc": "$?", "names": "$? value" },
+                        { "doc": "$?", "names": "$?" }
+                    ]
+                }
+            },
+            "conversion": { "text": "$?", "set": "$?", "list": "$?" }
+        },
+        "Table": {
+            "doc": "$?",
+            "name": "$?",
+            "row": "$?",
+            "function": {
+                "equals": {
+                    "doc": "$?",
+                    "names": "$? equals",
+                    "inputs": [{ "doc": "$?", "names": "$? value" }]
+                },
+                "notequal": {
+                    "doc": "$?",
+                    "names": "$?",
+                    "inputs": [{ "doc": "$?", "names": "$? value" }]
+                }
+            },
+            "conversion": {
+                "list": "$?",
+                "text": "$?"
+            }
+        },
+        "Structure": {
+            "doc": "$?",
+            "name": "$?",
+            "function": {
+                "equals": {
+                    "doc": "$?",
+                    "names": "$? =",
+                    "inputs": [
+                        {
+                            "doc": "$?",
+                            "names": "$? value"
+                        }
+                    ]
+                },
+                "notequal": {
+                    "doc": "$?",
+                    "names": "$? ≠",
+                    "inputs": [
+                        {
+                            "doc": "$?",
+                            "names": "$? value"
+                        }
+                    ]
+                }
+            },
+            "conversion": {
+                "text": "$?"
+            }
+        }
+    },
+    "input": {
+        "Random": {
+            "doc": "$?",
+            "names": ["Azar"],
+            "inputs": [
+                { "names": "$?", "doc": "$?" },
+                { "names": "$?", "doc": "$?" }
+            ]
+        },
+        "Choice": { "doc": "$?", "names": ["Selección", "Elección"] },
+        "Button": {
+            "doc": "$?",
+            "names": ["Botón"],
+            "down": { "names": "$?", "doc": "$?" }
+        },
+        "Pointer": { "doc": "$?", "names": ["Puntero"] },
+        "Key": {
+            "doc": "$?",
+            "names": ["Teclado"],
+            "key": { "names": "$?", "doc": "$?" },
+            "down": { "names": "$?", "doc": "$?" }
+        },
+        "Time": {
+            "doc": "$?",
+            "names": ["Tiempo"],
+            "frequency": { "names": ["frecuencia"], "doc": "$?" }
+        },
+        "Volume": {
+            "doc": "$?",
+            "names": "$? Volume",
+            "frequency": { "names": ["frecuencia"], "doc": "$?" }
+        },
+        "Pitch": {
+            "doc": "$?",
+            "names": "$? Pitch",
+            "frequency": { "names": ["frecuencia"], "doc": "$?" }
+        },
+        "Camera": {
+            "doc": "$?",
+            "names": ["Cámara"],
+            "width": { "names": ["ancho"], "doc": "$?" },
+            "height": { "names": ["altura"], "doc": "$?" },
+            "frequency": { "names": ["frecuencia"], "doc": "$?" }
+        },
+        "Motion": {
+            "names": "movimiento",
+            "doc": "$?",
+            "place": { "doc": "$?", "names": "$? place" },
+            "velocity": { "doc": "$?", "names": "$? velocity" },
+            "nextplace": { "doc": "$?", "names": "$? nextplace" },
+            "nextvelocity": { "doc": "$?", "names": "$? nextvelocity" }
+        },
+        "Chat": {
+            "doc": ["$?"],
+            "names": "$?"
+        },
+        "Placement": {
+            "doc": ["$?"],
+            "names": "$? Placement",
+            "inputs": [
+                {
+                    "doc": "$?",
+                    "names": "$? start"
+                },
+                {
+                    "doc": "$?",
+                    "names": "$? distance"
+                },
+                {
+                    "doc": "$?",
+                    "names": "$? horizontal"
+                },
+                {
+                    "doc": "$?",
+                    "names": "$? vertical"
+                },
+                {
+                    "doc": "$?",
+                    "names": "$? depth"
+                }
+            ]
+        },
+        "Webpage": {
+            "doc": ["$?"],
+            "names": "$? webpage",
+            "url": { "doc": "$?", "names": "$? url" },
+            "query": { "doc": "$?", "names": "$? query" },
+            "frequency": { "doc": "$?", "names": "$? frequency" },
+            "error": {
+                "invalid": "$?",
+                "unvailable": "$?",
+                "notHTML": "$?",
+                "noConnection": "$?",
+                "limit": "$?"
+            }
+        },
+        "Collision": {
+            "names": "$? Collision",
+            "doc": "$?",
+            "subject": {
+                "names": "$? name",
+                "doc": "$?"
+            },
+            "object": {
+                "names": "$? other",
+                "doc": "$?"
+            }
+        },
+        "Rebound": {
+            "names": "$? Rebound",
+            "doc": "$?",
+            "direction": {
+                "names": "$? direction",
+                "doc": "$?"
+            },
+            "subject": {
+                "names": "$? subject",
+                "doc": "$?"
+            },
+            "object": {
+                "names": "$? object",
+                "doc": "$?"
+            }
+        },
+        "Direction": {
+            "names": "$? Direction",
+            "doc": "$?",
+            "x": {
+                "names": "$? x",
+                "doc": "$?"
+            },
+            "y": {
+                "names": "$? y",
+                "doc": "$?"
+            }
+        }
+    },
+    "output": {
+        "Output": {
+            "names": "$? Output",
+            "doc": "$?"
+        },
+        "Stage": {
+            "names": "$?",
+            "doc": "$?",
+            "description": "$?",
+            "content": { "doc": "$?", "names": "$?" },
+            "frame": { "doc": "$?", "names": "$?" },
+            "size": { "doc": "$?", "names": "$?" },
+            "face": { "doc": "$?", "names": "$?" },
+            "place": { "doc": "$?", "names": "$?" },
+            "name": { "doc": "$?", "names": "$?" },
+            "selectable": { "doc": "$?", "names": "$?" },
+            "color": {
+                "doc": "$?",
+                "names": "$? color"
+            },
+            "background": { "doc": "$?", "names": "$? background" },
+            "opacity": {
+                "doc": "$?",
+                "names": "$? opacity"
+            },
+            "offset": {
+                "doc": "$?",
+                "names": "$? offset"
+            },
+            "rotation": {
+                "doc": "$?",
+                "names": "$? rotation"
+            },
+            "scale": {
+                "doc": "$?",
+                "names": "$? scale"
+            },
+            "flipx": {
+                "doc": "$?",
+                "names": "$? flipx"
+            },
+            "flipy": {
+                "doc": "$?",
+                "names": "$? flipy"
+            },
+            "entering": { "doc": "$?", "names": "$?" },
+            "resting": { "doc": "$?", "names": "$?" },
+            "moving": { "doc": "$?", "names": "$?" },
+            "exiting": { "doc": "$?", "names": "$?" },
+            "duration": { "doc": "$?", "names": ["duración"] },
+            "style": { "doc": "$?", "names": "$?" },
+            "gravity": { "doc": "$?", "names": "$?" }
+        },
+        "Group": {
+            "names": "$?",
+            "doc": "$?",
+            "description": "$?",
+            "content": { "doc": "$?", "names": "$?" },
+            "layout": { "doc": "$?", "names": "$?" },
+            "matter": {
+                "doc": "$?",
+                "names": "$? matter"
+            },
+            "size": { "doc": "$?", "names": "$?" },
+            "face": { "doc": "$?", "names": "$?" },
+            "place": { "doc": "$?", "names": "$?" },
+            "name": { "doc": "$?", "names": "$?" },
+            "selectable": { "doc": "$?", "names": "$?" },
+            "color": {
+                "doc": "$?",
+                "names": "$? color"
+            },
+            "background": { "doc": "$?", "names": "$? background" },
+            "opacity": {
+                "doc": "$?",
+                "names": "$? opacity"
+            },
+            "offset": {
+                "doc": "$?",
+                "names": "$? offset"
+            },
+            "rotation": {
+                "doc": "$?",
+                "names": "$? rotation"
+            },
+            "scale": {
+                "doc": "$?",
+                "names": "$? scale"
+            },
+            "flipx": {
+                "doc": "$?",
+                "names": "$? flipx"
+            },
+            "flipy": {
+                "doc": "$?",
+                "names": "$? flipy"
+            },
+            "entering": { "doc": "$?", "names": "$?" },
+            "resting": { "doc": "$?", "names": "$?" },
+            "moving": { "doc": "$?", "names": "$?" },
+            "exiting": { "doc": "$?", "names": "$?" },
+            "duration": { "doc": "$?", "names": ["duración"] },
+            "style": { "doc": "$?", "names": "$?" }
+        },
+        "Phrase": {
+            "names": ["💬", "Frase"],
+            "doc": "$?",
+            "description": "$?",
+            "text": { "doc": "$?", "names": "$?" },
+            "size": { "doc": "$?", "names": "$?" },
+            "face": { "doc": "$?", "names": "$?" },
+            "place": { "doc": "$?", "names": "$?" },
+            "wrap": {
+                "doc": "$?",
+                "names": "$? wrap"
+            },
+            "alignment": {
+                "doc": "$?",
+                "names": "$? alignment"
+            },
+            "matter": {
+                "doc": "$?",
+                "names": "$? matter"
+            },
+            "name": { "doc": "$?", "names": "$?" },
+            "selectable": { "doc": "$?", "names": "$?" },
+            "color": {
+                "doc": "$?",
+                "names": "$? color"
+            },
+            "background": { "doc": "$?", "names": "$? background" },
+            "opacity": {
+                "doc": "$?",
+                "names": "$? opacity"
+            },
+            "offset": {
+                "doc": "$?",
+                "names": "$? offset"
+            },
+            "rotation": {
+                "doc": "$?",
+                "names": "$? rotation"
+            },
+            "scale": {
+                "doc": "$?",
+                "names": "$? scale"
+            },
+            "flipx": {
+                "doc": "$?",
+                "names": "$? flipx"
+            },
+            "flipy": {
+                "doc": "$?",
+                "names": "$? flipy"
+            },
+            "entering": { "doc": "$?", "names": "$?" },
+            "resting": { "doc": "$?", "names": "$?" },
+            "moving": { "doc": "$?", "names": "$?" },
+            "exiting": { "doc": "$?", "names": "$?" },
+            "duration": { "doc": "$?", "names": ["$? duration"] },
+            "style": { "doc": "$?", "names": "$?" }
+        },
+        "Arrangement": { "names": ["Arrangement"], "doc": "$?" },
+        "Row": {
+            "names": ["Fila"],
+            "doc": "$?",
+            "description": "$?",
+            "alignment": {
+                "doc": "$?",
+                "names": "$? alignment"
+            },
+            "padding": { "doc": "$?", "names": "$?" }
+        },
+        "Stack": {
+            "names": "$?",
+            "doc": "$?",
+            "description": "$?",
+            "padding": { "doc": "$?", "names": "$?" },
+            "alignment": {
+                "doc": "$?",
+                "names": "$? alignment"
+            }
+        },
+        "Grid": {
+            "names": "$?",
+            "doc": "$?",
+            "description": "$?",
+            "rows": { "doc": "$?", "names": "$?" },
+            "columns": { "doc": "$?", "names": "$?" },
+            "padding": { "doc": "$?", "names": "$?" },
+            "cellWidth": { "doc": "$?", "names": "$?" },
+            "cellHeight": { "doc": "$?", "names": "$?" }
+        },
+        "Free": {
+            "names": "$?",
+            "doc": "$?",
+            "description": "$?"
+        },
+        "Shape": {
+            "names": "$? shape",
+            "doc": "$?",
+            "form": { "doc": "$?", "names": "$? form" },
+            "name": { "doc": "$?", "names": "$? name" },
+            "selectable": { "doc": "$?", "names": "$? selectable" },
+            "color": {
+                "doc": "$?",
+                "names": "$? color"
+            },
+            "background": { "doc": "$?", "names": "$? background" },
+            "opacity": {
+                "doc": "$?",
+                "names": "$? opacity"
+            },
+            "offset": {
+                "doc": "$?",
+                "names": "$? offset"
+            },
+            "rotation": {
+                "doc": "$?",
+                "names": "$? rotation"
+            },
+            "scale": {
+                "doc": "$?",
+                "names": "$? scale"
+            },
+            "flipx": {
+                "doc": "$?",
+                "names": "$? flipx"
+            },
+            "flipy": {
+                "doc": "$?",
+                "names": "$? flipy"
+            },
+            "entering": { "doc": "$?", "names": "$? entering" },
+            "resting": { "doc": "$?", "names": "$? resting" },
+            "moving": { "doc": "$?", "names": "$? moving" },
+            "exiting": { "doc": "$?", "names": "$? exiting" },
+            "duration": { "doc": "$?", "names": ["$? duration"] },
+            "style": { "doc": "$?", "names": "$? style" }
+        },
+        "Rectangle": {
+            "names": "$?",
+            "doc": "$?",
+            "left": { "doc": "$?", "names": "$?" },
+            "top": { "doc": "$?", "names": "$?" },
+            "right": { "doc": "$?", "names": "$?" },
+            "bottom": { "doc": "$?", "names": "$?" },
+            "z": { "doc": "$?", "names": "$? z" }
+        },
+        "Pose": {
+            "names": "$?",
+            "doc": "$?",
+            "duration": { "doc": "$?", "names": "$?" },
+            "style": { "doc": "$?", "names": "$?" },
+            "color": { "doc": "$?", "names": "$?" },
+            "opacity": { "doc": "$?", "names": "$?" },
+            "offset": { "doc": "$?", "names": "$?" },
+            "rotation": { "doc": "$?", "names": "$?" },
+            "scale": { "doc": "$?", "names": "$?" },
+            "flipx": { "doc": "$?", "names": "$?" },
+            "flipy": { "doc": "$?", "names": "$?" },
+            "description": "$?"
+        },
+        "Color": {
+            "names": "$?",
+            "doc": "$?",
+            "lightness": { "doc": "$?", "names": ["luminosidad"] },
+            "chroma": { "doc": "$?", "names": ["croma"] },
+            "hue": { "doc": "$?", "names": ["matiz"] }
+        },
+        "Sequence": {
+            "names": "$?",
+            "doc": "$?",
+            "poses": { "doc": "$?", "names": "$?" },
+            "duration": {
+                "doc": "$?",
+                "names": "$? duration"
+            },
+            "style": {
+                "doc": "$?",
+                "names": "$? style"
+            },
+            "count": { "doc": "$?", "names": "$? count" }
+        },
+        "Place": {
+            "names": ["Posición"],
+            "doc": "$?",
+            "x": { "doc": "$?", "names": "$? x" },
+            "y": { "doc": "$?", "names": "$? y" },
+            "z": { "doc": "$?", "names": "$? z" },
+            "rotation": { "doc": "$?", "names": "$? rotation" }
+        },
+        "Velocity": {
+            "doc": "$?",
+            "names": "$? Velocity",
+            "x": {
+                "doc": "$?",
+                "names": "$? x"
+            },
+            "y": {
+                "doc": "$?",
+                "names": "$? y"
+            },
+            "angle": {
+                "doc": "$? ",
+                "names": "$? angle"
+            }
+        },
+        "Matter": {
+            "doc": "$?",
+            "names": "$? Matter",
+            "mass": { "doc": "$?", "names": "$? mass" },
+            "bounciness": {
+                "doc": "$?",
+                "names": "$? bounciness"
+            },
+            "friction": {
+                "doc": "$?",
+                "names": "$? friction"
+            },
+            "roundedness": {
+                "doc": "$?",
+                "names": "$? roundedness"
+            },
+            "text": {
+                "doc": "$?",
+                "names": "$? text"
+            },
+            "shapes": {
+                "doc": "$?",
+                "names": "$? shapes"
+            }
+        },
+        "Easing": {
+            "straight": "$?",
+            "cautious": "$?",
+            "pokey": "$?",
+            "zippy": "$?"
+        },
+        "sequence": {
+            "sway": {
+                "doc": "$?",
+                "names": ["vaivén"],
+                "angle": { "doc": "$?", "names": ["ángulo"] }
+            },
+            "bounce": {
+                "doc": "$?",
+                "names": ["rebotar"],
+                "height": { "doc": "$?", "names": ["altura"] }
+            },
+            "spin": { "doc": "$?", "names": ["girar"] },
+            "fadein": { "doc": "$?", "names": ["revelar"] },
+            "popup": { "doc": "$?", "names": ["surgir"] },
+            "shake": { "doc": "$?", "names": ["agitar"] }
+        }
+    },
+    "ui": {
+        "font": {
+            "app": "Noto Sans",
+            "code": "Noto Mono"
+        },
+        "phrases": {
+            "welcome": "$?"
+        },
+        "widget": {
+            "confirm": { "cancel": "$?" },
+            "dialog": {
+                "close": "$?"
+            },
+            "loading": {
+                "message": "$?"
+            },
+            "home": "$?"
+        },
+        "tile": {
+            "toggle": {
+                "fullscreen": {
+                    "on": "$?",
+                    "off": "$?"
+                },
+                "show": {
+                    "on": "$?",
+                    "off": "$?"
+                }
+            },
+            "button": {
+                "collapse": "$?"
+            }
+        },
+        "project": {
+            "error": {
+                "unknown": "$?"
+            },
+            "button": {
+                "showCollaborators": "$?",
+                "removeCollaborator": "$?",
+                "copy": "$?",
+                "addSource": "$?",
+                "duplicate": "$?",
+                "revert": "$?",
+                "focusOutput": "$?",
+                "focusSource": "$?",
+                "focusDocs": "$?",
+                "focusPalette": "$?",
+                "focusCycle": "$?"
+            },
+            "field": {
+                "name": {
+                    "description": "$?",
+                    "placeholder": "$?"
+                }
+            },
+            "help": "$?"
+        },
+        "gallery": {
+            "untitled": "$?",
+            "subheader": {
+                "curators": {
+                    "header": "$?",
+                    "explanation": "$?"
+                },
+                "creators": {
+                    "header": "$?",
+                    "explanation": "$?"
+                },
+                "delete": {
+                    "header": "$?",
+                    "explanation": "$?"
+                }
+            },
+            "confirm": {
+                "delete": {
+                    "description": "$?",
+                    "prompt": "$?"
+                },
+                "remove": {
+                    "description": "$?",
+                    "prompt": "$?"
+                }
+            },
+            "error": {
+                "unknown": "$?"
+            },
+            "field": {
+                "name": {
+                    "description": "$?",
+                    "placeholder": "$?"
+                },
+                "description": {
+                    "description": "$?",
+                    "placeholder": "$?"
+                }
+            }
+        },
+        "source": {
+            "label": "$?",
+            "empty": "$?",
+            "overwritten": "$?",
+            "confirm": {
+                "delete": {
+                    "description": "$?",
+                    "prompt": "$?"
+                }
+            },
+            "toggle": {
+                "blocks": {
+                    "on": "$?",
+                    "off": "$?"
+                },
+                "glyphs": {
+                    "on": "$?",
+                    "off": "$?"
+                }
+            },
+            "button": {
+                "selectOutput": "$?",
+                "expandSequence": "$?"
+            },
+            "field": {
+                "name": {
+                    "description": "$?",
+                    "placeholder": "$?"
+                }
+            },
+            "menu": {
+                "label": "$?",
+                "show": "$?",
+                "back": "$?"
+            },
+            "cursor": {
+                "priorLine": "$?",
+                "nextLine": "$?",
+                "priorInline": "$?",
+                "nextInline": "$?",
+                "lineStart": "$?",
+                "lineEnd": "$?",
+                "priorNode": "$?",
+                "nextNode": "$?",
+                "parent": "$?",
+                "selectAll": "$?",
+                "incrementLiteral": "$?",
+                "decrementLiteral": "$?",
+                "insertSymbol": "$?",
+                "insertTrue": "$?",
+                "insertFalse": "$?",
+                "insertNone": "$?",
+                "insertNotEqual": "$?",
+                "insertProduct": "$?",
+                "insertQuotient": "$?",
+                "insertDegree": "$?",
+                "insertFunction": "$?",
+                "insertLessOrEqual": "$?",
+                "insertGreaterOrEqual": "$?",
+                "insertStream": "$?",
+                "insertConvert": "$?",
+                "insertPrevious": "$?",
+                "insertType": "$?",
+                "insertTable": "$?",
+                "insertLine": "$?",
+                "backspace": "$?",
+                "cut": "$?",
+                "copy": "$?",
+                "paste": "$?",
+                "parenthesize": "$?",
+                "enumerate": "$?",
+                "type": "$?",
+                "undo": "$?",
+                "redo": "$?",
+                "search": "$?"
+            }
+        },
+        "conflicts": {
+            "label": "$?"
+        },
+        "output": {
+            "label": "$?",
+            "toggle": {
+                "grid": {
+                    "on": "$?",
+                    "off": "$?"
+                },
+                "fit": {
+                    "on": "$?",
+                    "off": "$?"
+                },
+                "paint": {
+                    "on": "$?",
+                    "off": "$?"
+                }
+            },
+            "field": {
+                "key": {
+                    "description": "$?",
+                    "placeholder": "$?"
+                }
+            },
+            "button": {
+                "submit": "$?"
+            }
+        },
+        "timeline": {
+            "label": "$?",
+            "slider": "$?",
+            "button": {
+                "play": "$?",
+                "pause": "$?",
+                "backStep": "$?",
+                "backNode": "$?",
+                "backInput": "$?",
+                "out": "$?",
+                "forwardStep": "$?",
+                "forwardNode": "$?",
+                "forwardInput": "$?",
+                "present": "$?",
+                "start": "$?",
+                "reset": "$?"
+            }
+        },
+        "docs": {
+            "label": "$?",
+            "link": "$?",
+            "learn": "$?",
+            "nodoc": "$?",
+            "button": {
+                "home": "$?",
+                "back": "$?"
+            },
+            "field": {
+                "search": "$?"
+            },
+            "header": {
+                "inputs": "$?",
+                "interfaces": "$?",
+                "properties": "$?",
+                "functions": "$?",
+                "conversions": "$?"
+            }
+        },
+        "dialog": {
+            "share": {
+                "header": "$?",
+                "explanation": "$?",
+                "subheader": {
+                    "collaborators": {
+                        "header": "$?",
+                        "explanation": "$?"
+                    },
+                    "gallery": {
+                        "header": "$?",
+                        "explanation": "$?"
+                    },
+                    "public": {
+                        "header": "$?",
+                        "explanation": "$?"
+                    }
+                },
+                "field": {
+                    "email": {
+                        "placeholder": "$?",
+                        "description": "$?"
+                    }
+                },
+                "mode": {
+                    "public": {
+                        "label": "$?",
+                        "modes": ["$?", "$?"]
+                    }
+                },
+                "error": {
+                    "unknown": "$?"
+                },
+                "button": {
+                    "submit": "$?"
+                }
+            },
+            "settings": {
+                "header": "$?",
+                "explanation": "$?",
+                "button": {
+                    "show": "$?"
+                },
+                "mode": {
+                    "layout": {
+                        "label": "$?",
+                        "modes": ["$?", "$?", "$?", "$?"]
+                    },
+                    "animate": {
+                        "label": "$?",
+                        "modes": ["$?", "$?", "$?", "$?", "$?"]
+                    },
+                    "dark": {
+                        "label": "$?",
+                        "modes": ["$?", "$?", "$?"]
+                    },
+                    "writing": {
+                        "label": "$?",
+                        "modes": ["$?", "$?", "$?"]
+                    }
+                }
+            },
+            "locale": {
+                "header": "$?",
+                "explanation": "$?",
+                "subheader": {
+                    "selected": "$?",
+                    "supported": "$?",
+                    "help": "$?"
+                },
+                "button": {
+                    "show": "$?",
+                    "add": "$?",
+                    "remove": "$?"
+                }
+            },
+            "help": {
+                "header": "$?",
+                "explanation": "$?",
+                "subheader": {
+                    "moveCursor": "$?",
+                    "editCode": "$?",
+                    "insertCode": "$?",
+                    "debug": "$?"
+                }
+            }
+        },
+        "palette": {
+            "label": "$?",
+            "labels": {
+                "mixed": "$?",
+                "computed": "$?",
+                "default": "$?",
+                "inherited": "$?",
+                "notSequence": "$?",
+                "notContent": "$?"
+            },
+            "button": {
+                "revert": "$?",
+                "set": "$?",
+                "addPhrase": "$?",
+                "addGroup": "$?",
+                "addShape": "$?",
+                "addMotion": "$?",
+                "addPlacement": "$?",
+                "remove": "$?",
+                "up": "$?",
+                "down": "$?",
+                "edit": "$?",
+                "sequence": "$?",
+                "createPhrase": "$?",
+                "createGroup": "$?",
+                "createStage": "$?"
+            },
+            "prompt": {
+                "offerPhrase": "$?",
+                "offerGroup": "$?",
+                "offerStage": "$?",
+                "pauseToEdit": "$?",
+                "editing": "$?"
+            },
+            "field": {
+                "coordinate": "$?",
+                "text": "$?"
+            },
+            "sequence": {
+                "button": {
+                    "add": "$?",
+                    "remove": "$?",
+                    "up": "$?",
+                    "down": "$?"
+                },
+                "field": {
+                    "percent": "$?"
+                }
+            }
+        },
+        "save": {
+            "saving": "$?",
+            "saved": "$?",
+            "local": "$?",
+            "unsaved": "$?"
+        },
+        "page": {
+            "unknown": {
+                "header": "$?",
+                "message": "$?"
+            },
+            "landing": {
+                "call": ["$?"],
+                "link": {
+                    "about": "$?",
+                    "learn": "$?",
+                    "projects": "$?",
+                    "galleries": "$?",
+                    "rights": "$?"
+                }
+            },
+            "learn": {
+                "header": "$?",
+                "error": "$?",
+                "button": {
+                    "next": "$?",
+                    "previous": "$?"
+                }
+            },
+            "projects": {
+                "header": "$?",
+                "projectprompt": "$?",
+                "archiveheader": "$?",
+                "archiveprompt": "$?",
+                "galleriesheader": "$?",
+                "galleryprompt": "$?",
+                "button": {
+                    "newproject": "$?",
+                    "editproject": "$?",
+                    "newgallery": "$?",
+                    "unarchive": "$?"
+                },
+                "confirm": {
+                    "archive": {
+                        "description": "$?",
+                        "prompt": "$?"
+                    },
+                    "delete": {
+                        "description": "$?",
+                        "prompt": "$?"
+                    }
+                },
+                "error": {
+                    "noaccess": "$?",
+                    "nogalleryedits": "$?",
+                    "newgallery": "$?",
+                    "nodeletes": "$?",
+                    "delete": "$?"
+                }
+            },
+            "galleries": {
+                "header": "$?",
+                "prompt": "$?",
+                "examples": "ejemplos"
+            },
+            "about": {
+                "header": "$?",
+                "content": ["$?"]
+            },
+            "login": {
+                "header": "$?",
+                "anonymous": "$?",
+                "prompt": {
+                    "login": "$?",
+                    "enter": "$?",
+                    "play": "$?",
+                    "change": "$?",
+                    "logout": "$?",
+                    "sent": "$?",
+                    "success": "$?",
+                    "confirm": "$?",
+                    "delete": "$?",
+                    "reallyDelete": "$?",
+                    "name": "$?"
+                },
+                "error": {
+                    "expired": "$?",
+                    "invalid": "$?",
+                    "email": "$?",
+                    "offline": "$?",
+                    "failure": "$?",
+                    "unchanged": "$?",
+                    "delete": "$?"
+                },
+                "feedback": {
+                    "changing": "$?",
+                    "deleting": "$?"
+                },
+                "field": {
+                    "email": {
+                        "description": "$?",
+                        "placeholder": "$?"
+                    }
+                },
+                "button": {
+                    "logout": {
+                        "tip": "$?",
+                        "label": "$?"
+                    },
+                    "login": "$?",
+                    "update": "$?",
+                    "delete": {
+                        "tip": "$?",
+                        "label": "$?"
+                    },
+                    "reallyDelete": {
+                        "tip": "$?",
+                        "label": "$?"
+                    }
+                }
+            },
+            "rights": {
+                "header": "$?",
+                "content": ["$?"],
+                "consequences": ["$?"]
+            }
+        },
+        "edit": {
+            "node": "$?",
+            "before": "$?",
+            "inside": "$?",
+            "between": "$?",
+            "line": "$?",
+            "conflicts": "$?",
+            "assign": "$?",
+            "append": "$?",
+            "remove": "$?",
+            "replace": "$?",
+            "wrap": "$?",
+            "unwrap": "$?",
+            "bind": "$?"
+        },
+        "template": {
+            "unwritten": "$?",
+            "unparsable": "$?"
+        }
+    },
+    "moderation": {
+        "warning": { "header": "$?", "explanation": "$?" },
+        "blocked": { "header": "$?", "explanation": "$?" },
+        "unmoderated": { "header": "$?", "explanation": "$?" },
+        "moderate": {
+            "header": "$?",
+            "explanation": "$?"
+        },
+        "flags": {
+            "violence": "$?",
+            "dehumanization": "$?",
+            "disclosure": "$?",
+            "misinformation": "$?"
+        },
+        "button": {
+            "submit": {
+                "tip": "$?",
+                "label": "$?"
+            },
+            "skip": {
+                "tip": "$?",
+                "label": "$?"
+            }
+        }
+    }
+}