164 files changed, 3766 insertions, 2402 deletions

diff --git a/doc/docs/.vitepress/config.mts b/doc/docs/.vitepress/config.mts
index 9491a8d..cae1d89 100644
--- a/doc/docs/.vitepress/config.mts
+++ b/doc/docs/.vitepress/config.mts
@@ -1,338 +1,388 @@
-import { readFileSync } from 'fs';
-import {
-  dirname,
-  resolve,
-} from 'path';
-import { fileURLToPath } from 'url';
-import { defineConfig } from 'vitepress';
+import { readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { defineConfig } from "vitepress";
 
-import darkPlus from '@shikijs/themes/dark-plus';
-import lightPlus from '@shikijs/themes/light-plus';
+import darkPlus from "@shikijs/themes/dark-plus";
+import lightPlus from "@shikijs/themes/light-plus";
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const yuescriptGrammarPath = resolve(__dirname, 'grammars/yuescript.tmLanguage.json')
-const yuescriptGrammar = JSON.parse(readFileSync(yuescriptGrammarPath, 'utf-8'))
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const yuescriptGrammarPath = resolve(
+  __dirname,
+  "grammars/yuescript.tmLanguage.json",
+);
+const yuescriptGrammar = JSON.parse(
+  readFileSync(yuescriptGrammarPath, "utf-8"),
+);
 const yuescriptLanguage = {
   ...yuescriptGrammar,
-  name: 'yuescript',
-  scopeName: 'source.yuescript',
-  aliases: ['yue'],
-}
+  name: "yuescript",
+  scopeName: "source.yuescript",
+  aliases: ["yue"],
+};
 
 const sidebarText = {
   de: {
-    introduction: 'Einführung',
-    installation: 'Installation',
-    usage: 'Verwendung',
-    macro: 'Makro',
-    operator: 'Operatoren',
-    module: 'Modul',
-    assignment: 'Zuweisung',
-    destructuringAssignment: 'Destrukturierende Zuweisung',
-    ifAssignment: 'If-Zuweisung',
-    varargsAssignment: 'Varargs-Zuweisung',
-    whitespace: 'Leerraum',
-    comment: 'Kommentare',
-    try: 'Try/Catch',
-    attributes: 'Attribute',
-    literals: 'Literale',
-    functionLiterals: 'Funktionsliterale',
-    backcalls: 'Backcalls',
-    tableLiterals: 'Tabellenliterale',
-    comprehensions: 'Comprehensions',
-    forLoop: 'For-Schleife',
-    whileLoop: 'While-Schleife',
-    continueStatement: 'Continue-Anweisung',
-    conditionals: 'Bedingungen',
-    lineDecorators: 'Zeilen-Dekoratoren',
-    switch: 'Switch',
-    objectOrientedProgramming: 'Objektorientierte Programmierung',
-    withStatement: 'With-Anweisung',
-    do: 'Do',
-    functionStubs: 'Funktions-Stubs',
-    usingClause: 'Die Using-Klausel; Kontrolle destruktiver Zuweisung',
-    yuescriptLibrary: 'Die YueScript-Bibliothek',
-    licenseMit: 'Lizenz: MIT',
+    introduction: "Einführung",
+    installation: "Installation",
+    usage: "Verwendung",
+    macro: "Makro",
+    operator: "Operatoren",
+    module: "Modul",
+    assignment: "Zuweisung",
+    destructuringAssignment: "Destrukturierende Zuweisung",
+    ifAssignment: "If-Zuweisung",
+    varargsAssignment: "Varargs-Zuweisung",
+    whitespace: "Leerraum",
+    comment: "Kommentare",
+    try: "Try/Catch",
+    attributes: "Attribute",
+    literals: "Literale",
+    functionLiterals: "Funktionsliterale",
+    backcalls: "Backcalls",
+    tableLiterals: "Tabellenliterale",
+    comprehensions: "Comprehensions",
+    forLoop: "For-Schleife",
+    whileLoop: "While-Schleife",
+    continueStatement: "Continue-Anweisung",
+    conditionals: "Bedingungen",
+    lineDecorators: "Zeilen-Dekoratoren",
+    switch: "Switch",
+    objectOrientedProgramming: "Objektorientierte Programmierung",
+    withStatement: "With-Anweisung",
+    do: "Do",
+    functionStubs: "Funktions-Stubs",
+    usingClause: "Die Using-Klausel; Kontrolle destruktiver Zuweisung",
+    yuescriptLibrary: "Die YueScript-Bibliothek",
+    licenseMit: "Lizenz: MIT",
   },
   en: {
-    introduction: 'Introduction',
-    installation: 'Installation',
-    usage: 'Usage',
-    macro: 'Macro',
-    operator: 'Operator',
-    module: 'Module',
-    assignment: 'Assignment',
-    destructuringAssignment: 'Destructuring Assignment',
-    ifAssignment: 'If Assignment',
-    varargsAssignment: 'Varargs Assignment',
-    whitespace: 'Whitespace',
-    comment: 'Comment',
-    try: 'Try',
-    attributes: 'Attributes',
-    literals: 'Literals',
-    functionLiterals: 'Function Literals',
-    backcalls: 'Backcalls',
-    tableLiterals: 'Table Literals',
-    comprehensions: 'Comprehensions',
-    forLoop: 'For Loop',
-    whileLoop: 'While Loop',
-    continueStatement: 'Continue Statement',
-    conditionals: 'Conditionals',
-    lineDecorators: 'Line Decorators',
-    switch: 'Switch',
-    objectOrientedProgramming: 'Object Oriented Programming',
-    withStatement: 'With Statement',
-    do: 'Do',
-    functionStubs: 'Function Stubs',
-    usingClause: 'The Using Clause; Controlling Destructive Assignment',
-    yuescriptLibrary: 'The YueScript Library',
-    licenseMit: 'License: MIT',
+    introduction: "Introduction",
+    installation: "Installation",
+    usage: "Usage",
+    macro: "Macro",
+    operator: "Operator",
+    module: "Module",
+    assignment: "Assignment",
+    destructuringAssignment: "Destructuring Assignment",
+    ifAssignment: "If Assignment",
+    varargsAssignment: "Varargs Assignment",
+    whitespace: "Whitespace",
+    comment: "Comment",
+    try: "Try",
+    attributes: "Attributes",
+    literals: "Literals",
+    functionLiterals: "Function Literals",
+    backcalls: "Backcalls",
+    tableLiterals: "Table Literals",
+    comprehensions: "Comprehensions",
+    forLoop: "For Loop",
+    whileLoop: "While Loop",
+    continueStatement: "Continue Statement",
+    conditionals: "Conditionals",
+    lineDecorators: "Line Decorators",
+    switch: "Switch",
+    objectOrientedProgramming: "Object Oriented Programming",
+    withStatement: "With Statement",
+    do: "Do",
+    functionStubs: "Function Stubs",
+    usingClause: "The Using Clause; Controlling Destructive Assignment",
+    yuescriptLibrary: "The YueScript Library",
+    licenseMit: "License: MIT",
   },
   idId: {
-    introduction: 'Pendahuluan',
-    installation: 'Instalasi',
-    usage: 'Penggunaan',
-    macro: 'Makro',
-    operator: 'Operator',
-    module: 'Modul',
-    assignment: 'Penugasan',
-    destructuringAssignment: 'Penugasan Destrukturisasi',
-    ifAssignment: 'Penugasan If',
-    varargsAssignment: 'Penugasan Varargs',
-    whitespace: 'Spasi Kosong',
-    comment: 'Komentar',
-    try: 'Coba',
-    attributes: 'Atribut',
-    literals: 'Literal',
-    functionLiterals: 'Literal Fungsi',
-    backcalls: 'Pemanggilan Mundur',
-    tableLiterals: 'Literal Tabel',
-    comprehensions: 'Kompresi',
-    forLoop: 'Perulangan For',
-    whileLoop: 'Perulangan While',
-    continueStatement: 'Pernyataan Lanjutkan',
-    conditionals: 'Percabangan',
-    lineDecorators: 'Dekorator Baris',
-    switch: 'Switch',
-    objectOrientedProgramming: 'Pemrograman Berorientasi Objek',
-    withStatement: 'Pernyataan With',
-    do: 'Do',
-    functionStubs: 'Fungsi Sementara',
-    usingClause: 'Klausa Using; Mengontrol Penugasan Destruktif',
-    yuescriptLibrary: 'Pustaka YueScript',
-    licenseMit: 'Lisensi: MIT',
+    introduction: "Pendahuluan",
+    installation: "Instalasi",
+    usage: "Penggunaan",
+    macro: "Makro",
+    operator: "Operator",
+    module: "Modul",
+    assignment: "Penugasan",
+    destructuringAssignment: "Penugasan Destrukturisasi",
+    ifAssignment: "Penugasan If",
+    varargsAssignment: "Penugasan Varargs",
+    whitespace: "Spasi Kosong",
+    comment: "Komentar",
+    try: "Coba",
+    attributes: "Atribut",
+    literals: "Literal",
+    functionLiterals: "Literal Fungsi",
+    backcalls: "Pemanggilan Mundur",
+    tableLiterals: "Literal Tabel",
+    comprehensions: "Kompresi",
+    forLoop: "Perulangan For",
+    whileLoop: "Perulangan While",
+    continueStatement: "Pernyataan Lanjutkan",
+    conditionals: "Percabangan",
+    lineDecorators: "Dekorator Baris",
+    switch: "Switch",
+    objectOrientedProgramming: "Pemrograman Berorientasi Objek",
+    withStatement: "Pernyataan With",
+    do: "Do",
+    functionStubs: "Fungsi Sementara",
+    usingClause: "Klausa Using; Mengontrol Penugasan Destruktif",
+    yuescriptLibrary: "Pustaka YueScript",
+    licenseMit: "Lisensi: MIT",
   },
   ptBr: {
-    introduction: 'Introdução',
-    installation: 'Instalação',
-    usage: 'Uso',
-    macro: 'Macro',
-    operator: 'Operadores',
-    module: 'Módulo',
-    assignment: 'Atribuição',
-    destructuringAssignment: 'Atribuição com desestruturação',
-    ifAssignment: 'Atribuição com if',
-    varargsAssignment: 'Atribuição de varargs',
-    whitespace: 'Espaços em branco',
-    comment: 'Comentários',
-    try: 'Try/Catch',
-    attributes: 'Atributos',
-    literals: 'Literais',
-    functionLiterals: 'Literais de função',
-    backcalls: 'Backcalls',
-    tableLiterals: 'Literais de tabela',
-    comprehensions: 'Compreensões',
-    forLoop: 'Laço for',
-    whileLoop: 'Laço while',
-    continueStatement: 'Instrução continue',
-    conditionals: 'Condicionais',
-    lineDecorators: 'Decoradores de linha',
-    switch: 'Switch',
-    objectOrientedProgramming: 'Programação orientada a objetos',
-    withStatement: 'Instrução with',
-    do: 'Do',
-    functionStubs: 'Stubs de função',
-    usingClause: 'Cláusula using; controlando atribuição destrutiva',
-    yuescriptLibrary: 'A biblioteca do YueScript',
-    licenseMit: 'Licença: MIT',
+    introduction: "Introdução",
+    installation: "Instalação",
+    usage: "Uso",
+    macro: "Macro",
+    operator: "Operadores",
+    module: "Módulo",
+    assignment: "Atribuição",
+    destructuringAssignment: "Atribuição com desestruturação",
+    ifAssignment: "Atribuição com if",
+    varargsAssignment: "Atribuição de varargs",
+    whitespace: "Espaços em branco",
+    comment: "Comentários",
+    try: "Try/Catch",
+    attributes: "Atributos",
+    literals: "Literais",
+    functionLiterals: "Literais de função",
+    backcalls: "Backcalls",
+    tableLiterals: "Literais de tabela",
+    comprehensions: "Compreensões",
+    forLoop: "Laço for",
+    whileLoop: "Laço while",
+    continueStatement: "Instrução continue",
+    conditionals: "Condicionais",
+    lineDecorators: "Decoradores de linha",
+    switch: "Switch",
+    objectOrientedProgramming: "Programação orientada a objetos",
+    withStatement: "Instrução with",
+    do: "Do",
+    functionStubs: "Stubs de função",
+    usingClause: "Cláusula using; controlando atribuição destrutiva",
+    yuescriptLibrary: "A biblioteca do YueScript",
+    licenseMit: "Licença: MIT",
   },
   zh: {
-    introduction: '介绍',
-    installation: '安装',
-    usage: '使用方法',
-    macro: '宏',
-    operator: '操作符',
-    module: '模块',
-    assignment: '赋值',
-    destructuringAssignment: '解构赋值',
-    ifAssignment: 'if 赋值',
-    varargsAssignment: '可变参数赋值',
-    whitespace: '空白',
-    comment: '注释',
-    try: '错误处理',
-    attributes: '属性',
-    literals: '字面量',
-    functionLiterals: '函数字面量',
-    backcalls: '反向回调',
-    tableLiterals: '表格字面量',
-    comprehensions: '推导式',
-    forLoop: 'for 循环',
-    whileLoop: 'while 循环',
-    continueStatement: 'continue 语句',
-    conditionals: '条件语句',
-    lineDecorators: '代码行修饰符',
-    switch: 'switch 语句',
-    objectOrientedProgramming: '面向对象编程',
-    withStatement: 'with 语句',
-    do: 'do 语句',
-    functionStubs: '函数存根',
-    usingClause: '使用 using 语句：防止破坏性赋值',
-    yuescriptLibrary: '月之脚本语言库',
-    licenseMit: 'MIT 许可证',
+    introduction: "介绍",
+    installation: "安装",
+    usage: "使用方法",
+    macro: "宏",
+    operator: "操作符",
+    module: "模块",
+    assignment: "赋值",
+    destructuringAssignment: "解构赋值",
+    ifAssignment: "if 赋值",
+    varargsAssignment: "可变参数赋值",
+    whitespace: "空白",
+    comment: "注释",
+    try: "错误处理",
+    attributes: "属性",
+    literals: "字面量",
+    functionLiterals: "函数字面量",
+    backcalls: "反向回调",
+    tableLiterals: "表格字面量",
+    comprehensions: "推导式",
+    forLoop: "for 循环",
+    whileLoop: "while 循环",
+    continueStatement: "continue 语句",
+    conditionals: "条件语句",
+    lineDecorators: "代码行修饰符",
+    switch: "switch 语句",
+    objectOrientedProgramming: "面向对象编程",
+    withStatement: "with 语句",
+    do: "do 语句",
+    functionStubs: "函数存根",
+    usingClause: "使用 using 语句：防止破坏性赋值",
+    yuescriptLibrary: "月之脚本语言库",
+    licenseMit: "MIT 许可证",
   },
-} as const
+} as const;
 
-type SidebarLocale = keyof typeof sidebarText
+type SidebarLocale = keyof typeof sidebarText;
 
 type SidebarGroupText = {
-  gettingStarted: string
-  languageBasics: string
-  assignment: string
-  functions: string
-  controlFlow: string
-  dataStructures: string
-  objects: string
-  advancedFeatures: string
-  reference: string
-}
+  gettingStarted: string;
+  languageBasics: string;
+  assignment: string;
+  functions: string;
+  controlFlow: string;
+  dataStructures: string;
+  objects: string;
+  advancedFeatures: string;
+  reference: string;
+};
 
 const sidebarGroups: Record<SidebarLocale, SidebarGroupText> = {
   de: {
-    gettingStarted: 'Erste Schritte',
-    languageBasics: 'Sprachgrundlagen',
-    assignment: 'Zuweisung',
-    functions: 'Funktionen',
-    controlFlow: 'Kontrollfluss',
-    dataStructures: 'Datenstrukturen',
-    objects: 'Objekte',
-    advancedFeatures: 'Erweiterte Funktionen',
-    reference: 'Referenz',
+    gettingStarted: "Erste Schritte",
+    languageBasics: "Sprachgrundlagen",
+    assignment: "Zuweisung",
+    functions: "Funktionen",
+    controlFlow: "Kontrollfluss",
+    dataStructures: "Datenstrukturen",
+    objects: "Objekte",
+    advancedFeatures: "Erweiterte Funktionen",
+    reference: "Referenz",
   },
   en: {
-    gettingStarted: 'Getting Started',
-    languageBasics: 'Language Basics',
-    assignment: 'Assignment',
-    functions: 'Functions',
-    controlFlow: 'Control Flow',
-    dataStructures: 'Data Structures',
-    objects: 'Objects',
-    advancedFeatures: 'Advanced Features',
-    reference: 'Reference',
+    gettingStarted: "Getting Started",
+    languageBasics: "Language Basics",
+    assignment: "Assignment",
+    functions: "Functions",
+    controlFlow: "Control Flow",
+    dataStructures: "Data Structures",
+    objects: "Objects",
+    advancedFeatures: "Advanced Features",
+    reference: "Reference",
   },
   idId: {
-    gettingStarted: 'Memulai',
-    languageBasics: 'Dasar-dasar Bahasa',
-    assignment: 'Penugasan',
-    functions: 'Fungsi',
-    controlFlow: 'Alur Kontrol',
-    dataStructures: 'Struktur Data',
-    objects: 'Objek',
-    advancedFeatures: 'Fitur Lanjutan',
-    reference: 'Referensi',
+    gettingStarted: "Memulai",
+    languageBasics: "Dasar-dasar Bahasa",
+    assignment: "Penugasan",
+    functions: "Fungsi",
+    controlFlow: "Alur Kontrol",
+    dataStructures: "Struktur Data",
+    objects: "Objek",
+    advancedFeatures: "Fitur Lanjutan",
+    reference: "Referensi",
   },
   ptBr: {
-    gettingStarted: 'Primeiros passos',
-    languageBasics: 'Fundamentos da linguagem',
-    assignment: 'Atribuição',
-    functions: 'Funções',
-    controlFlow: 'Controle de fluxo',
-    dataStructures: 'Estruturas de dados',
-    objects: 'Objetos',
-    advancedFeatures: 'Recursos avançados',
-    reference: 'Referência',
+    gettingStarted: "Primeiros passos",
+    languageBasics: "Fundamentos da linguagem",
+    assignment: "Atribuição",
+    functions: "Funções",
+    controlFlow: "Controle de fluxo",
+    dataStructures: "Estruturas de dados",
+    objects: "Objetos",
+    advancedFeatures: "Recursos avançados",
+    reference: "Referência",
   },
   zh: {
-    gettingStarted: '起步',
-    languageBasics: '语言基础',
-    assignment: '赋值',
-    functions: '函数',
-    controlFlow: '控制流',
-    dataStructures: '数据结构',
-    objects: '面向对象',
-    advancedFeatures: '高级特性',
-    reference: '参考',
+    gettingStarted: "起步",
+    languageBasics: "语言基础",
+    assignment: "赋值",
+    functions: "函数",
+    controlFlow: "控制流",
+    dataStructures: "数据结构",
+    objects: "面向对象",
+    advancedFeatures: "高级特性",
+    reference: "参考",
   },
-}
+};
 
 function createSidebar(basePath: string, locale: SidebarLocale) {
-  const text = sidebarText[locale]
-  const group = sidebarGroups[locale]
+  const text = sidebarText[locale];
+  const group = sidebarGroups[locale];
   return [
     {
       text: group.gettingStarted,
       items: [
-        { text: text.introduction, link: `${basePath}/getting-started/introduction` },
-        { text: text.installation, link: `${basePath}/getting-started/installation` },
+        {
+          text: text.introduction,
+          link: `${basePath}/getting-started/introduction`,
+        },
+        {
+          text: text.installation,
+          link: `${basePath}/getting-started/installation`,
+        },
         { text: text.usage, link: `${basePath}/getting-started/usage` },
-      ]
+      ],
     },
     {
       text: group.languageBasics,
       collapsed: true,
       items: [
-        { text: text.whitespace, link: `${basePath}/language-basics/whitespace` },
+        {
+          text: text.whitespace,
+          link: `${basePath}/language-basics/whitespace`,
+        },
         { text: text.comment, link: `${basePath}/language-basics/comment` },
         { text: text.literals, link: `${basePath}/language-basics/literals` },
         { text: text.operator, link: `${basePath}/language-basics/operator` },
-        { text: text.attributes, link: `${basePath}/language-basics/attributes` },
-      ]
+        {
+          text: text.attributes,
+          link: `${basePath}/language-basics/attributes`,
+        },
+      ],
     },
     {
       text: group.assignment,
       collapsed: true,
       items: [
         { text: text.assignment, link: `${basePath}/assignment/assignment` },
-        { text: text.destructuringAssignment, link: `${basePath}/assignment/destructuring-assignment` },
-        { text: text.ifAssignment, link: `${basePath}/assignment/if-assignment` },
-        { text: text.varargsAssignment, link: `${basePath}/assignment/varargs-assignment` },
-        { text: text.usingClause, link: `${basePath}/assignment/the-using-clause-controlling-destructive-assignment` },
-      ]
+        {
+          text: text.destructuringAssignment,
+          link: `${basePath}/assignment/destructuring-assignment`,
+        },
+        {
+          text: text.ifAssignment,
+          link: `${basePath}/assignment/if-assignment`,
+        },
+        {
+          text: text.varargsAssignment,
+          link: `${basePath}/assignment/varargs-assignment`,
+        },
+        {
+          text: text.usingClause,
+          link: `${basePath}/assignment/the-using-clause-controlling-destructive-assignment`,
+        },
+      ],
     },
     {
       text: group.functions,
       collapsed: true,
       items: [
-        { text: text.functionLiterals, link: `${basePath}/functions/function-literals` },
+        {
+          text: text.functionLiterals,
+          link: `${basePath}/functions/function-literals`,
+        },
         { text: text.backcalls, link: `${basePath}/functions/backcalls` },
-        { text: text.functionStubs, link: `${basePath}/functions/function-stubs` },
-      ]
+        {
+          text: text.functionStubs,
+          link: `${basePath}/functions/function-stubs`,
+        },
+      ],
     },
     {
       text: group.controlFlow,
       collapsed: true,
       items: [
-        { text: text.conditionals, link: `${basePath}/control-flow/conditionals` },
+        {
+          text: text.conditionals,
+          link: `${basePath}/control-flow/conditionals`,
+        },
         { text: text.forLoop, link: `${basePath}/control-flow/for-loop` },
         { text: text.whileLoop, link: `${basePath}/control-flow/while-loop` },
-        { text: text.continueStatement, link: `${basePath}/control-flow/continue` },
+        {
+          text: text.continueStatement,
+          link: `${basePath}/control-flow/continue`,
+        },
         { text: text.switch, link: `${basePath}/control-flow/switch` },
-      ]
+      ],
     },
     {
       text: group.dataStructures,
       collapsed: true,
       items: [
-        { text: text.tableLiterals, link: `${basePath}/data-structures/table-literals` },
-        { text: text.comprehensions, link: `${basePath}/data-structures/comprehensions` },
-      ]
+        {
+          text: text.tableLiterals,
+          link: `${basePath}/data-structures/table-literals`,
+        },
+        {
+          text: text.comprehensions,
+          link: `${basePath}/data-structures/comprehensions`,
+        },
+      ],
     },
     {
       text: group.objects,
       collapsed: true,
       items: [
-        { text: text.objectOrientedProgramming, link: `${basePath}/objects/object-oriented-programming` },
-        { text: text.withStatement, link: `${basePath}/objects/with-statement` },
-      ]
+        {
+          text: text.objectOrientedProgramming,
+          link: `${basePath}/objects/object-oriented-programming`,
+        },
+        {
+          text: text.withStatement,
+          link: `${basePath}/objects/with-statement`,
+        },
+      ],
     },
     {
       text: group.advancedFeatures,
@@ -340,46 +390,104 @@ function createSidebar(basePath: string, locale: SidebarLocale) {
       items: [
         { text: text.macro, link: `${basePath}/advanced/macro` },
         { text: text.module, link: `${basePath}/advanced/module` },
-        { text: text.lineDecorators, link: `${basePath}/advanced/line-decorators` },
+        {
+          text: text.lineDecorators,
+          link: `${basePath}/advanced/line-decorators`,
+        },
         { text: text.do, link: `${basePath}/advanced/do` },
         { text: text.try, link: `${basePath}/advanced/try` },
-      ]
+      ],
     },
     {
       text: group.reference,
       collapsed: true,
       items: [
-        { text: text.yuescriptLibrary, link: `${basePath}/reference/the-yuescript-library` },
+        {
+          text: text.yuescriptLibrary,
+          link: `${basePath}/reference/the-yuescript-library`,
+        },
         { text: text.licenseMit, link: `${basePath}/reference/license-mit` },
-      ]
+      ],
     },
-  ]
+  ];
 }
 
 export default defineConfig({
-  title: 'YueScript',
-  description: 'A language that compiles to Lua',
-  base: '/',
+  title: "YueScript",
+  description: "A language that compiles to Lua",
+  base: "/",
   head: [
-    ['meta', { name: 'theme-color', content: '#b4ac8f' }],
-    ['meta', { name: 'apple-mobile-web-app-capable', content: 'yes' }],
-    ['meta', { name: 'apple-mobile-web-app-status-bar-style', content: 'black' }],
-    ['meta', { property: 'og:title', content: 'YueScript' }],
-    ['meta', { property: 'og:description', content: 'A language that compiles to Lua' }],
-    ['meta', { property: 'og:type', content: 'website' }],
-    ['meta', { property: 'og:image', content: '/image/yuescript.png' }],
-    ['meta', { property: 'og:image:secure_url', content: '/image/yuescript.png' }],
-    ['meta', { property: 'og:image:type', content: 'image/png' }],
-    ['meta', { property: 'og:image:width', content: '1200' }],
-    ['meta', { property: 'og:image:height', content: '1200' }],
-    ['link', { rel: 'icon', href: '/image/favicon/favicon-16x16.png', sizes: '16x16', type: 'image/png' }],
-    ['link', { rel: 'icon', href: '/image/favicon/favicon-32x32.png', sizes: '32x32', type: 'image/png' }],
-    ['link', { rel: 'apple-touch-icon', href: '/image/favicon/apple-touch-icon.png', sizes: '180x180', type: 'image/png' }],
-    ['link', { rel: 'android-chrome', href: '/image/favicon/android-chrome-192x192.png', sizes: '192x192', type: 'image/png' }],
-    ['link', { rel: 'android-chrome', href: '/image/favicon/android-chrome-512x512.png', sizes: '512x512', type: 'image/png' }],
-    ['script', {}, 'window.global = window;'],
+    ["meta", { name: "theme-color", content: "#b4ac8f" }],
+    ["meta", { name: "apple-mobile-web-app-capable", content: "yes" }],
+    [
+      "meta",
+      { name: "apple-mobile-web-app-status-bar-style", content: "black" },
+    ],
+    ["meta", { property: "og:title", content: "YueScript" }],
+    [
+      "meta",
+      {
+        property: "og:description",
+        content: "A language that compiles to Lua",
+      },
+    ],
+    ["meta", { property: "og:type", content: "website" }],
+    ["meta", { property: "og:image", content: "/image/yuescript.png" }],
+    [
+      "meta",
+      { property: "og:image:secure_url", content: "/image/yuescript.png" },
+    ],
+    ["meta", { property: "og:image:type", content: "image/png" }],
+    ["meta", { property: "og:image:width", content: "1200" }],
+    ["meta", { property: "og:image:height", content: "1200" }],
+    [
+      "link",
+      {
+        rel: "icon",
+        href: "/image/favicon/favicon-16x16.png",
+        sizes: "16x16",
+        type: "image/png",
+      },
+    ],
     [
-      'script',
+      "link",
+      {
+        rel: "icon",
+        href: "/image/favicon/favicon-32x32.png",
+        sizes: "32x32",
+        type: "image/png",
+      },
+    ],
+    [
+      "link",
+      {
+        rel: "apple-touch-icon",
+        href: "/image/favicon/apple-touch-icon.png",
+        sizes: "180x180",
+        type: "image/png",
+      },
+    ],
+    [
+      "link",
+      {
+        rel: "android-chrome",
+        href: "/image/favicon/android-chrome-192x192.png",
+        sizes: "192x192",
+        type: "image/png",
+      },
+    ],
+    [
+      "link",
+      {
+        rel: "android-chrome",
+        href: "/image/favicon/android-chrome-512x512.png",
+        sizes: "512x512",
+        type: "image/png",
+      },
+    ],
+    ["script", {}, "window.global = window;"],
+    [
+      "script",
       {},
       `var Module = {
   onRuntimeInitialized: function() {
@@ -400,16 +508,14 @@ export default defineConfig({
   s.src = '/js/yuescript.js';
   s.async = true;
   document.head.appendChild(s);
-})();`
-    ]
+})();`,
+    ],
   ],
   vite: {
-    publicDir: resolve(__dirname, 'public'),
+    publicDir: resolve(__dirname, "public"),
   },
   markdown: {
-    languages: [
-      yuescriptLanguage,
-    ],
+    languages: [yuescriptLanguage],
     theme: {
       light: lightPlus,
       dark: darkPlus,
@@ -417,74 +523,74 @@ export default defineConfig({
   },
   locales: {
     root: {
-      label: 'English',
-      lang: 'en-US',
-      description: 'A language that compiles to Lua',
+      label: "English",
+      lang: "en-US",
+      description: "A language that compiles to Lua",
       themeConfig: {
         nav: [
-          { text: 'Documentation', link: '/doc/' },
-          { text: 'Try yue!', link: '/try/' },
-          { text: 'GitHub', link: 'https://github.com/IppClub/Yuescript' }
+          { text: "Documentation", link: "/doc/" },
+          { text: "Try yue!", link: "/try/" },
+          { text: "GitHub", link: "https://github.com/IppClub/Yuescript" },
         ],
-        sidebar: createSidebar('/doc', 'en'),
-      }
+        sidebar: createSidebar("/doc", "en"),
+      },
     },
-    'id-id': {
-      label: 'Bahasa Indonesia',
-      lang: 'id-ID',
-      description: 'Bahasa yang dikompilasi ke Lua',
+    "id-id": {
+      label: "Bahasa Indonesia",
+      lang: "id-ID",
+      description: "Bahasa yang dikompilasi ke Lua",
       themeConfig: {
         nav: [
-          { text: 'Dokumentasi', link: '/id-id/doc/' },
-          { text: 'Coba Yue!', link: '/id-id/try/' },
-          { text: 'GitHub', link: 'https://github.com/IppClub/Yuescript' }
+          { text: "Dokumentasi", link: "/id-id/doc/" },
+          { text: "Coba Yue!", link: "/id-id/try/" },
+          { text: "GitHub", link: "https://github.com/IppClub/Yuescript" },
         ],
-        sidebar: createSidebar('/id-id/doc', 'idId'),
-      }
+        sidebar: createSidebar("/id-id/doc", "idId"),
+      },
     },
     de: {
-      label: 'Deutsch',
-      lang: 'de-DE',
-      description: 'Eine Sprache, die zu Lua kompiliert',
+      label: "Deutsch",
+      lang: "de-DE",
+      description: "Eine Sprache, die zu Lua kompiliert",
       themeConfig: {
         nav: [
-          { text: 'Dokumentation', link: '/de/doc/' },
-          { text: 'Yue ausprobieren!', link: '/de/try/' },
-          { text: 'GitHub', link: 'https://github.com/IppClub/Yuescript' }
+          { text: "Dokumentation", link: "/de/doc/" },
+          { text: "Yue ausprobieren!", link: "/de/try/" },
+          { text: "GitHub", link: "https://github.com/IppClub/Yuescript" },
         ],
-        sidebar: createSidebar('/de/doc', 'de'),
-      }
+        sidebar: createSidebar("/de/doc", "de"),
+      },
     },
-    'pt-br': {
-      label: 'Português (Brasil)',
-      lang: 'pt-BR',
-      description: 'Uma linguagem que compila para Lua',
+    "pt-br": {
+      label: "Português (Brasil)",
+      lang: "pt-BR",
+      description: "Uma linguagem que compila para Lua",
       themeConfig: {
         nav: [
-          { text: 'Documentação', link: '/pt-br/doc/' },
-          { text: 'Experimente Yue!', link: '/pt-br/try/' },
-          { text: 'GitHub', link: 'https://github.com/IppClub/Yuescript' }
+          { text: "Documentação", link: "/pt-br/doc/" },
+          { text: "Experimente Yue!", link: "/pt-br/try/" },
+          { text: "GitHub", link: "https://github.com/IppClub/Yuescript" },
         ],
-        sidebar: createSidebar('/pt-br/doc', 'ptBr'),
-      }
+        sidebar: createSidebar("/pt-br/doc", "ptBr"),
+      },
     },
     zh: {
-      label: '简体中文',
-      lang: 'zh-CN',
-      description: '一门编译到 Lua 的语言',
+      label: "简体中文",
+      lang: "zh-CN",
+      description: "一门编译到 Lua 的语言",
       themeConfig: {
         nav: [
-          { text: '文档', link: '/zh/doc/' },
-          { text: '试一试!', link: '/zh/try/' },
-          { text: 'GitHub', link: 'https://github.com/IppClub/Yuescript' }
+          { text: "文档", link: "/zh/doc/" },
+          { text: "试一试!", link: "/zh/try/" },
+          { text: "GitHub", link: "https://github.com/IppClub/Yuescript" },
         ],
-        sidebar: createSidebar('/zh/doc', 'zh'),
-      }
+        sidebar: createSidebar("/zh/doc", "zh"),
+      },
     },
   },
   themeConfig: {
     search: {
-      provider: 'local'
-    }
-  }
-})
+      provider: "local",
+    },
+  },
+});
diff --git a/doc/docs/.vitepress/env.d.ts b/doc/docs/.vitepress/env.d.ts
index 0f28852..f01ea51 100644
--- a/doc/docs/.vitepress/env.d.ts
+++ b/doc/docs/.vitepress/env.d.ts
@@ -1,19 +1,19 @@
 /// <reference types="vitepress/client" />
 
-declare module '*.vue' {
-  import type { DefineComponent } from 'vue'
-  const component: DefineComponent<{}, {}, any>
-  export default component
+declare module "*.vue" {
+  import type { DefineComponent } from "vue";
+  const component: DefineComponent<{}, {}, any>;
+  export default component;
 }
 
 declare global {
   interface Window {
     yue?: {
-      version: () => string
-      tolua: (code: string, ...args: unknown[]) => [string, string]
-      exec: (code: string) => string
-    }
+      version: () => string;
+      tolua: (code: string, ...args: unknown[]) => [string, string];
+      exec: (code: string) => string;
+    };
   }
 }
 
-export {}
+export {};
diff --git a/doc/docs/.vitepress/grammars/yuescript.tmLanguage.json b/doc/docs/.vitepress/grammars/yuescript.tmLanguage.json
index 62ac5fb..3a57344 100644
--- a/doc/docs/.vitepress/grammars/yuescript.tmLanguage.json
+++ b/doc/docs/.vitepress/grammars/yuescript.tmLanguage.json
@@ -1,689 +1,687 @@
 {
-        "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
-        "scopeName": "source.yue",
-        "name": "YueScript",
-        "fileTypes": [
-                "yue"
-        ],
-        "patterns": [
-                {
-                        "match": "\\A(#!).*$\\n?",
-                        "name": "comment.line.shebang.yue",
-                        "captures": {
-                                "1": {
-                                        "name": "punctuation.definition.comment.yue"
-                                }
-                        }
-                },
-                {
-                        "match": "(\\(.*?\\))?\\s*([=-]>)",
-                        "name": "meta.inline.function.yue",
-                        "captures": {
-                                "1": {
-                                        "name": "variable.parameter.function.yue"
-                                },
-                                "2": {
-                                        "name": "storage.type.function.yue"
-                                }
-                        }
-                },
-                {
-                        "match": "(?<=^|\\bdo\\b|[=-]>)\\s*(\\(.*?\\))?\\s*(<[=-]\\s*(?=[a-zA-Z_]))",
-                        "name": "meta.inline.function.yue",
-                        "captures": {
-                                "1": {
-                                        "name": "variable.parameter.function.yue"
-                                },
-                                "2": {
-                                        "name": "storage.type.function.yue"
-                                }
-                        }
-                },
-                {
-                        "match": "(\\b[A-Z]\\w*)\\s*",
-                        "name": "entity.name.type.class.yue",
-                        "captures": {
-                                "1": {
-                                        "name": "entity.name.type.class"
-                                }
-                        }
-                },
-                {
-                        "begin": "\\[(=*)\\[",
-                        "beginCaptures": {
-                                "0": {
-                                        "name": "punctuation.definition.string.begin.yue"
-                                }
-                        },
-                        "end": "\\]\\1\\]",
-                        "endCaptures": {
-                                "0": {
-                                        "name": "punctuation.definition.string.end.yue"
-                                }
-                        },
-                        "name": "string.quoted.other.multiline.yue"
-                },
-                {
-                        "begin": "(?<!-)--\\[\\[",
-                        "captures": {
-                                "0": {
-                                        "name": "punctuation.definition.comment.yue"
-                                }
-                        },
-                        "end": "\\]\\]",
-                        "name": "comment.block.yue",
-                        "patterns": [
-                                {
-                                        "match": "@\\w*",
-                                        "name": "storage.type.annotation.yue"
-                                }
-                        ]
-                },
-                {
-                        "begin": "(?<!-)--",
-                        "end": "(?:[ \\t]*\\n)",
-                        "name": "comment.line.yue",
-                        "patterns": [
-                                {
-                                        "match": "@\\w*",
-                                        "name": "storage.type.annotation.yuescript"
-                                }
-                        ],
-                        "captures": {
-                                "0": {
-                                        "name": "punctuation.definition.comment.yue"
-                                }
-                        }
-                },
-                {
-                        "match": "(::)\\s*[a-zA-Z_][a-zA-Z0-9_]*\\s*(::)",
-                        "name": "string.tag.lua",
-                        "captures": {
-                                "1": {
-                                        "name": "punctuation.section.embedded.begin.yue"
-                                },
-                                "2": {
-                                        "name": "punctuation.section.embedded.end.yue"
-                                }
-                        }
-                },
-                {
-                        "patterns": [
-                                {
-                                        "match": "<\\b(?:mode|name|add|sub|mul|div|mod|pow|unm|idiv|band|bor|bxor|bnot|shl|shr|concat|len|eq|lt|le|index|newindex|call|metatable|gc|close|tostring|pairs|ipairs)\\b>",
-                                        "name": "constant.language.yue"
-                                },
-                                {
-                                        "match": "<>",
-                                        "name": "constant.language.yue"
-                                },
-                                {
-                                        "match": "<(\"(?:\\\\\"|[^\"])*\")>",
-                                        "name": "constant.language.yue",
-                                        "captures": {
-                                                "1": {
-                                                        "name": "string.quoted.double.yue"
-                                                }
-                                        }
-                                },
-                                {
-                                        "match": "<('(?:\\\\'|[^'])*')>",
-                                        "name": "constant.language.yue",
-                                        "captures": {
-                                                "1": {
-                                                        "name": "string.quoted.single.yue"
-                                                }
-                                        }
-                                },
-                                {
-                                        "match": "<\\w+>",
-                                        "name": "invalid.illegal.yue"
-                                }
-                        ]
-                },
-                {
-                        "match": "(\\+|\\-|\\*|/|%|\\^|//|\\||\\&|>>|<<|(?<!\\?)\\?{2}(?!\\?)|(?<!\\.)\\.{2}(?!\\.)|\\band|\\bor)=?",
-                        "name": "keyword.operator.yue"
-                },
-                {
-                        "match": "\\[\\]\\s*=",
-                        "name": "keyword.operator.yue"
-                },
-                {
-                        "match": "==|~=|\\!=|>|>=|<|<=",
-                        "name": "keyword.operator.yue"
-                },
-                {
-                        "match": "#|\\-|~|\\?|!",
-                        "name": "keyword.operator.yue"
-                },
-                {
-                        "match": "\\|>|=|:=|(?<!:):(?!:)|,|\\b_\\b",
-                        "name": "keyword.operator.yue"
-                },
-                {
-                        "match": "(?<!\\.)\\.{3}(?!\\.)(?!\\w+)",
-                        "name": "constant.language.yue"
-                },
-                {
-                        "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:import|as|from|export|macro|local|global|close|const|class|extends|using)\\b(?!:)",
-                        "name": "keyword.yue"
-                },
-                {
-                        "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:if|then|else|elseif|until|unless|switch|when|with|do|for|while|repeat|return|continue|break|try|catch|goto)\\b(?!:)",
-                        "name": "keyword.control.yue"
-                },
-                {
-                        "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:or|and|in|not)\\b(?!:)",
-                        "name": "keyword.control.yue"
-                },
-                {
-                        "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:true|false|nil)\\b(?!:)",
-                        "name": "constant.language.boolean.yue"
-                },
-                {
-                        "match": "\\b(?<![\\.|:|::|\\\\|\\$])(function|end)(?!:)\\b",
-                        "name": "invalid.illegal.yue"
-                },
-                {
-                        "match": "((?<!\\.)\\.{4,}(?!\\.))",
-                        "name": "invalid.illegal.yue"
-                },
-                {
-                        "begin": "(?<=\\s|^)(\\{)(?=.+?\\}\\s+[:=])",
-                        "beginCaptures": {
-                                "0": {
-                                        "name": "keyword.control.yue"
-                                }
-                        },
-                        "end": "(\\}\\s*[:=])",
-                        "endCaptures": {
-                                "0": {
-                                        "name": "keyword.control.yue"
-                                }
-                        },
-                        "name": "meta.variable.assignment.destructured.object.yue",
-                        "patterns": [
-                                {
-                                        "include": "#expression"
-                                }
-                        ]
-                },
-                {
-                        "match": "(?<=[ \t]*)\\b(?:new)\\b(?=:(?:\\s*\\(.*\\))?\\s*=>)",
-                        "name": "variable.language.yue"
-                },
-                {
-                        "match": "(?x)\n\t\t\t\t(?<=^|\\s)\n\t\t\t\t(?=@?[a-zA-Z\\$_]\\??)\n\t\t\t\t(\n\t\t\t\t\t@?[a-zA-Z\\$_]\\??(\\w|\\$|:|\\.)*\\s*\n\t\t\t\t\t(?=[:=](\\s*\\(.*\\))?\\s*([=-]>))\n\t\t\t\t)\n\t\t\t",
-                        "name": "meta.function.yue",
-                        "captures": {
-                                "1": {
-                                        "name": "entity.name.function.yue"
-                                },
-                                "2": {
-                                        "name": "entity.name.function.yue"
-                                },
-                                "3": {
-                                        "name": "variable.parameter.function.yue"
-                                },
-                                "4": {
-                                        "name": "storage.type.function.yue"
-                                }
-                        }
-                },
-                {
-                        "match": "\\b__(class|base|init|inherited|mode|name|add|sub|mul|div|mod|pow|unm|idiv|band|bor|bxor|bnot|shl|shr|concat|len|eq|lt|le|index|newindex|call|metatable|gc|close|tostring|pairs|ipairs)\\b",
-                        "name": "entity.name.function.yue"
-                },
-                {
-                        "match": "(?:\\bclass\\b)\\s+(@?[a-zA-Z\\$_][\\w\\.]*)?(?:\\s+(?:\\bextends\\b)\\s+(@?[a-zA-Z\\$\\._][\\w\\.]*))?",
-                        "name": "meta.class.yue",
-                        "captures": {
-                                "1": {
-                                        "name": "storage.type.class.yue"
-                                },
-                                "2": {
-                                        "name": "entity.name.type.class.yue"
-                                },
-                                "3": {
-                                        "name": "keyword.control.inheritance.yue"
-                                },
-                                "4": {
-                                        "name": "entity.other.inherited-class.yue"
-                                }
-                        }
-                },
-                {
-                        "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:_ENV|_G|_VERSION|arg)\\b(?!(?:\\s*(?:(?:\\+|\\-|\\*|/|%|\\^|//|\\||\\&|>>|<<|(?<!\\?)\\?{2}(?!\\?)|(?<!\\.)\\.{2}(?!\\.)|\\band|\\bor)?=|:=)\\s*|:))",
-                        "name": "constant.language.yue"
-                },
-                {
-                        "include": "#expression"
-                },
-                {
-                        "match": ",[ \\t]*",
-                        "name": "meta.delimiter.object.comma.yue"
-                },
-                {
-                        "match": "\\.|::|\\\\",
-                        "name": "meta.delimiter.method.yue"
-                },
-                {
-                        "match": "\\{|\\}",
-                        "name": "meta.brace.curly.yue"
-                },
-                {
-                        "match": "\\(|\\)",
-                        "name": "meta.brace.round.yue"
-                },
-                {
-                        "match": "\\[|\\]",
-                        "name": "meta.brace.square.yue"
-                }
-        ],
-        "repository": {
-                "expression": {
-                        "patterns": [
-                                {
-                                        "include": "#string"
-                                },
-                                {
-                                        "include": "#numeric"
-                                },
-                                {
-                                        "include": "#builtins"
-                                },
-                                {
-                                        "include": "#variable_name"
-                                }
-                        ]
-                },
-                "keyword": {
-                        "patterns": [
-                                {
-                                        "match": "\\b(?:import|as|from|export|macro|local|global|close|const|class|extends|using)\\b",
-                                        "name": "keyword.yue"
-                                },
-                                {
-                                        "match": "\\b(?:if|then|else|elseif|until|unless|switch|when|with|do|for|while|repeat|return|continue|break|try|catch|goto)\\b",
-                                        "name": "keyword.control.yue"
-                                },
-                                {
-                                        "match": "\\b(?:or|and|in|not)\\b",
-                                        "name": "keyword.operator.yue"
-                                }
-                        ]
-                },
-                "string": {
-                        "patterns": [
-                                {
-                                        "include": "#single_quoted_string"
-                                },
-                                {
-                                        "include": "#double_quoted_string"
-                                }
-                        ]
-                },
-                "string_format_code": {
-                        "patterns": [
-                                {
-                                        "match": "%(%|a|A|c|d|e|E|f|g|G|i|o|p|q|s|u|x|X)",
-                                        "name": "constant.character.yue"
-                                }
-                        ]
-                },
-                "string_escape_sequence": {
-                        "patterns": [
-                                {
-                                        "match": "\\\\([abfnrtvz\\'\"\\\\]|\\d{1,3}|x\\h{2}|u\\{\\h+\\})",
-                                        "name": "constant.character.yue"
-                                },
-                                {
-                                        "match": "\\\\.",
-                                        "name": "invalid.illegal.yue"
-                                }
-                        ]
-                },
-                "double_quoted_string": {
-                        "patterns": [
-                                {
-                                        "begin": "\"",
-                                        "beginCaptures": {
-                                                "0": {
-                                                        "name": "punctuation.definition.string.begin.yue"
-                                                }
-                                        },
-                                        "end": "\"",
-                                        "endCaptures": {
-                                                "0": {
-                                                        "name": "punctuation.definition.string.end.yue"
-                                                }
-                                        },
-                                        "name": "string.quoted.double.yue",
-                                        "patterns": [
-                                                {
-                                                        "include": "#string_escape_sequence"
-                                                },
-                                                {
-                                                        "include": "#interpolated_yue"
-                                                },
-                                                {
-                                                        "include": "#string_format_code"
-                                                }
-                                        ]
-                                }
-                        ]
-                },
-                "single_quoted_string": {
-                        "patterns": [
-                                {
-                                        "begin": "'",
-                                        "beginCaptures": {
-                                                "0": {
-                                                        "name": "punctuation.definition.string.begin.yue"
-                                                }
-                                        },
-                                        "end": "'",
-                                        "endCaptures": {
-                                                "0": {
-                                                        "name": "punctuation.definition.string.end.yue"
-                                                }
-                                        },
-                                        "name": "string.quoted.single.yue",
-                                        "patterns": [
-                                                {
-                                                        "include": "#string_escape_sequence"
-                                                },
-                                                {
-                                                        "include": "#string_format_code"
-                                                }
-                                        ]
-                                }
-                        ]
-                },
-                "interpolated_yue": {
-                        "patterns": [
-                                {
-                                        "begin": "\\#\\{",
-                                        "captures": {
-                                                "0": {
-                                                        "name": "punctuation.section.embedded.yue"
-                                                }
-                                        },
-                                        "end": "\\}",
-                                        "name": "source.yue.embedded.source",
-                                        "patterns": [
-                                                {
-                                                        "include": "$self"
-                                                }
-                                        ]
-                                }
-                        ]
-                },
-                "variable_name": {
-                        "patterns": [
-                                {
-                                        "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)(\\b(?:self)\\b)(?!:)\\b",
-                                        "name": "invalid.deprecated.yue"
-                                },
-                                {
-                                        "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:super)\\b(?!(?:\\s*(?:(?:\\+|\\-|\\*|/|%|\\^|//|\\||\\&|>>|<<|(?<!\\?)\\?{2}(?!\\?)|(?<!\\.)\\.{2}(?!\\.)|\\band|\\bor)?=|:=)\\s*|:))",
-                                        "name": "variable.language.yue"
-                                },
-                                {
-                                        "match": "(?:\\${2,}|@{3,})(?:(?:\\b[a-zA-Z_]\\w*)?((?:\\.|::|\\\\)\\b[a-zA-Z_]\\w*)*\\b)?",
-                                        "name": "invalid.illegal.yue"
-                                },
-                                {
-                                        "match": "(?<!\\$)\\$\\b[a-zA-Z_]\\w*\\b",
-                                        "name": "entity.name.function.preprocessor.yue"
-                                },
-                                {
-                                        "match": "(?<!\\$)\\$(?!\\$)",
-                                        "name": "invalid.illegal.yue"
-                                },
-                                {
-                                        "match": "(?<![\\$@])@@(?:(?:\\b[a-zA-Z_]\\w*)?((?:\\.|::|\\\\)\\b[a-zA-Z_]\\w*)*\\b)?",
-                                        "name": "variable.other.static.yue"
-                                },
-                                {
-                                        "match": "(?<![\\$@])@(?:(?:\\b[a-zA-Z_]\\w*)?((?:\\.|::|\\\\)\\b[a-zA-Z_]\\w*)*\\b)?",
-                                        "name": "variable.other.member.yue"
-                                },
-                                {
-                                        "match": "(?<![\\$@])\\b[a-zA-Z_]\\w*((?:\\.|::|\\\\)\\b[a-zA-Z_]\\w*\\b)*",
-                                        "name": "variable.assignment.yue"
-                                },
-                                {
-                                        "match": "(?<![\\$@])\\b([a-zA-Z\\$_]\\w*(\\.\\w+)*)\\b",
-                                        "name": "variable.assignment.yue",
-                                        "captures": {
-                                                "1": {
-                                                        "name": "variable.assignment.yue"
-                                                }
-                                        }
-                                }
-                        ]
-                },
-                "numeric": {
-                        "patterns": [
-                                {
-                                        "match": "\\b([\\d_]+(\\.[\\d_]+)?|\\.[\\d_]+)(e[+\\-]?[\\d_]+)?\\b",
-                                        "name": "constant.numeric.yue"
-                                },
-                                {
-                                        "match": "\\b0x(((?:\\h|\\h[\\h_]*\\h)(\\.(?:\\h|\\h[\\h_]*\\h))?)|\\.(?:\\h|\\h[\\h_]*\\h))\\b",
-                                        "name": "constant.numeric.yue"
-                                },
-                                {
-                                        "match": "\\b\\d(?:\\w|\\.|:|::|\\\\)+\\b",
-                                        "name": "invalid.illegal.yue"
-                                }
-                        ]
-                },
-                "builtins": {
-                        "patterns": [
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*(?:lpeg|lpeglabel)(?:(?:\\.|::|\\\\)(?:B|C|Carg|Cb|Cc|Cf|Cg|Cmt|Cp|Cs|Ct|P|R|S|T|V|locale|match|pcode|ptree|setmaxstack|type|utfR|version))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*(?:re|relabel)(?:(?:\\.|::|\\\\)(?:calcline|compile|find|gsub|match|updatelocale))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*coroutine(?:(?:\\.|::|\\\\)(?:close|create|isyieldable|resume|running|status|wrap|yield))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*debug(?:(?:\\.|::|\\\\)(?:debug|gethook|getinfo|getlocal|getmetatable|getregistry|getupvalue|getuservalue|setcstacklimit|sethook|setlocal|setmetatable|setupvalue|setuservalue|traceback|upvalueid|upvaluejoin))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*io(?:(?:\\.|::|\\\\)(?:close|flush|input|lines|open|output|popen|read|stderr|stdin|stdout|tmpfile|type|write))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*math(?:(?:\\.|::|\\\\)(?:abs|acos|asin|atan|atan2|ceil|cos|cosh|deg|exp|floor|fmod|frexp|huge|ldexp|log|log10|max|maxinteger|min|mininteger|modf|pi|pow|rad|random|randomseed|sin|sinh|sqrt|tan|tanh|tointeger|type|ult))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*os(?:(?:\\.|::|\\\\)(?:clock|date|difftime|execute|exit|getenv|remove|rename|setlocale|time|tmpname))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*package(?:(?:\\.|::|\\\\)(?:config|cpath|loaded|loadlib|path|preload|searchers|searchpath))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.Date(?:(?:\\.|::|\\\\)(?:Format|Interval|_class|_init|add|cast|catch|class_of|day|diff|hour|is_a|is_weekend|last_day|min|month|month_name|sec|set|toLocal|toUTC|tzone|weekday_name|yday|year))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.List(?:(?:\\.|::|\\\\)(?:_class|_create|_init|_name|append|cast|catch|chop|class_of|clear|clone|concat|contains|count|default_map|default_map_with|extend|filter|foreach|foreachm|get|index|insert|is_a|iter|iterate|join|len|map|map2|mapm|minmax|new|partition|pop|push|put|range|reduce|remove|remove_value|reverse|slice|slice_assign|sort|sorted|splice|split|transform))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.Map(?:(?:\\.|::|\\\\)(?:_class|_init|_name|cast|catch|class_of|get|getvalues|is_a|items|iter|keys|len|set|setdefault|update|values))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.MultiMap(?:(?:\\.|::|\\\\)(?:_base|_class|_init|_name|_parent_with_init|cast|catch|class_of|get|getvalues|is_a|items|iter|keys|len|set|setdefault|update|values))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.OrderedMap(?:(?:\\.|::|\\\\)(?:_base|_class|_init|_name|_parent_with_init|cast|catch|class_of|get|getvalues|insert|is_a|items|iter|keys|len|set|setdefault|sort|update|values))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.Set(?:(?:\\.|::|\\\\)(?:_base|_class|_init|_name|_parent_with_init|cast|catch|class_of|difference|get|getvalues|intersection|is_a|isdisjoint|isempty|issubset|items|iter|keys|len|map|set|setdefault|symmetric_difference|union|update|values))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.app(?:(?:\\.|::|\\\\)(?:appfile|lua|parse_args|platform|require_here|script_name))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.array2d(?:(?:\\.|::|\\\\)(?:column|columns|default_range|extract_cols|extract_rows|flatten|forall|iter|map|map2|move|new|parse_range|product|range|reduce2|reduce_cols|reduce_rows|remove_col|remove_row|reshape|row|rows|set|size|slice|swap_cols|swap_rows|transpose|write))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.class(?:(?:\\.|::|\\\\)(?:properties))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.compat(?:(?:\\.|::|\\\\)(?:dir_separator|execute|getfenv|is_windows|jit|load|lua51|setfenv))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.comprehension(?:(?:\\.|::|\\\\)(?:new))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.config(?:(?:\\.|::|\\\\)(?:lines|read))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.data(?:(?:\\.|::|\\\\)(?:filter|new|query|read|write))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.dir(?:(?:\\.|::|\\\\)(?:clonetree|copyfile|dirtree|filter|fnmatch|getallfiles|getdirectories|getfiles|makepath|movefile|rmtree|walk))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.file(?:(?:\\.|::|\\\\)(?:access_time|copy|creation_time|delete|modified_time|move|read|write))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.func(?:(?:\\.|::|\\\\)(?:And|Args|Eq|Ge|Gt|I|Le|Len|Lt|Nil|Not|Or|PE|Var|_|_0|_1|_2|_3|_4|_5|bind|bind1|collect_values|compose|curry|import|instantiate|isPE|lookup_imported_name|register|repr|tail))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.input(?:(?:\\.|::|\\\\)(?:alltokens|create_getter|fields|numbers|words))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.lapp(?:(?:\\.|::|\\\\)(?:add_type|assert|callback|error|open|process_options_string|quit|show_usage_error))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.lexer(?:(?:\\.|::|\\\\)(?:cpp|expecting|get_keywords|get_separated_list|getline|getrest|insert|lineno|lua|scan|skipws))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.luabalanced(?:(?:\\.|::|\\\\)(?:gsub|match_bracketed|match_explist|match_expression|match_namelist|match_string))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.operator(?:(?:\\.|::|\\\\)(?:add|call|concat|div|eq|ge|gt|index|land|le|len|lnot|lor|lt|match|mod|mul|neq|nop|optable|pow|sub|table|unm))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.path(?:(?:\\.|::|\\\\)(?:abspath|attrib|basename|chdir|common_prefix|currentdir|dir|dirname|dirsep|exists|expanduser|extension|getatime|getctime|getmtime|getsize|is_windows|isabs|isdir|isfile|islink|join|link_attrib|mkdir|normcase|normpath|package_path|relpath|rmdir|sep|splitext|splitpath|tmpname))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.permute(?:(?:\\.|::|\\\\)(?:iter|list_iter|list_table|order_iter|order_table|table))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.pretty(?:(?:\\.|::|\\\\)(?:debug|dump|load|number|read|write))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.seq(?:(?:\\.|::|\\\\)(?:copy|copy2|copy_tuples|count|count_map|enum|equal_to|filter|foreach|greater_than|import|iter|keys|last|less_than|lines|list|map|mapmethod|matching|minmax|printall|random|range|reduce|skip|sort|splice|sum|take|unique|zip))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.sip(?:(?:\\.|::|\\\\)(?:compile|create_pattern|create_spec_fun|custom_pattern|fields|match|match_at_start|pattern|read))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.strict(?:(?:\\.|::|\\\\)(?:closed_module|make_all_strict|module))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.stringio(?:(?:\\.|::|\\\\)(?:create|lines|open))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.stringx(?:(?:\\.|::|\\\\)(?:Template|at|capitalize|center|count|dedent|endswith|expandtabs|fill|format_operator|import|indent|isalnum|isalpha|isdigit|islower|isspace|isupper|join|lfind|lines|ljust|lstrip|partition|quote_string|replace|rfind|rjust|rpartition|rstrip|shorten|split|splitlines|splitv|startswith|strip|title|wrap))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.tablex(?:(?:\\.|::|\\\\)(?:_normalize_slice|clear|compare|compare_no_order|copy|count_map|deepcompare|deepcopy|difference|filter|find|find_if|foreach|foreachi|icopy|imap|imap2|index_by|index_map|insertvalues|intersection|keys|makeset|map|map2|map_named_method|mapn|merge|move|new|pairmap|range|readonly|reduce|removevalues|rfind|search|set|size|sort|sortv|sub|transform|union|update|values|zip))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.template(?:(?:\\.|::|\\\\)(?:compile|substitute))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.test(?:(?:\\.|::|\\\\)(?:asserteq|asserteq2|assertmatch|assertraise|complain|error_handler|timer|tuple))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.text(?:(?:\\.|::|\\\\)(?:Template|at|capitalize|center|count|dedent|endswith|expandtabs|fill|format_operator|import|indent|isalnum|isalpha|isdigit|islower|isspace|isupper|join|lfind|lines|ljust|lstrip|partition|quote_string|replace|rfind|rjust|rpartition|rstrip|shorten|split|splitlines|splitv|startswith|strip|title|wrap))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.types(?:(?:\\.|::|\\\\)(?:is_callable|is_empty|is_indexable|is_integer|is_iterable|is_type|is_writeable|to_bool|type))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.url(?:(?:\\.|::|\\\\)(?:quote|unquote))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.utils(?:(?:\\.|::|\\\\)(?:_VERSION|add_function_factory|array_tostring|assert_arg|assert_string|bind1|bind2|choose|dir_separator|enum|escape|execute|executeex|fprintf|function_arg|getfenv|import|is_type|is_windows|jit|kpairs|load|lua51|memoize|npairs|on_error|pack|patterns|printf|quit|quote_arg|raise|raise_deprecation|readfile|readlines|set_deprecation_func|setfenv|split|splitv|stdmt|string_lambda|unpack|writefile))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.xml(?:(?:\\.|::|\\\\)(?:basic_parse|clone|compare|elem|is_tag|new|parse|parsehtml|tags|tostring|walk|xml_escape|xml_unescape))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*string(?:(?:\\.|::|\\\\)(?:byte|char|dump|find|format|gmatch|gsub|len|lower|match|pack|packsize|rep|reverse|sub|unpack|upper))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*table(?:(?:\\.|::|\\\\)(?:concat|insert|move|pack|remove|sort|unpack))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*utf8(?:(?:\\.|::|\\\\)(?:char|charpattern|codepoint|codes|len|offset))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*yue(?:(?:\\.|::|\\\\)(?:check|dofile|file_exist|find_modulepath|format|insert_loader|is_ast|loadfile|loadstring|macro_env|options|p|pcall|read_file|to_ast|to_lua|traceback|version|yue_compiled))?\\b"
-                                },
-                                {
-                                        "name": "support.function.library.yue",
-                                        "match": "\\b(?:_G(?:\\.|:|::|\\\\))*(?:_G|_VERSION|arg|assert|collectgarbage|coroutine|debug|dofile|error|getmetatable|io|ipairs|lfs|load|loadfile|math|next|os|package|pairs|pcall|print|rawequal|rawget|rawlen|rawset|require|select|setmetatable|string|table|tonumber|tostring|type|utf8|warn|xpcall)\\b"
-                                }
-                        ]
-                }
-        }
-}
\ No newline at end of file
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "scopeName": "source.yue",
+  "name": "YueScript",
+  "fileTypes": ["yue"],
+  "patterns": [
+    {
+      "match": "\\A(#!).*$\\n?",
+      "name": "comment.line.shebang.yue",
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.comment.yue"
+        }
+      }
+    },
+    {
+      "match": "(\\(.*?\\))?\\s*([=-]>)",
+      "name": "meta.inline.function.yue",
+      "captures": {
+        "1": {
+          "name": "variable.parameter.function.yue"
+        },
+        "2": {
+          "name": "storage.type.function.yue"
+        }
+      }
+    },
+    {
+      "match": "(?<=^|\\bdo\\b|[=-]>)\\s*(\\(.*?\\))?\\s*(<[=-]\\s*(?=[a-zA-Z_]))",
+      "name": "meta.inline.function.yue",
+      "captures": {
+        "1": {
+          "name": "variable.parameter.function.yue"
+        },
+        "2": {
+          "name": "storage.type.function.yue"
+        }
+      }
+    },
+    {
+      "match": "(\\b[A-Z]\\w*)\\s*",
+      "name": "entity.name.type.class.yue",
+      "captures": {
+        "1": {
+          "name": "entity.name.type.class"
+        }
+      }
+    },
+    {
+      "begin": "\\[(=*)\\[",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.yue"
+        }
+      },
+      "end": "\\]\\1\\]",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.yue"
+        }
+      },
+      "name": "string.quoted.other.multiline.yue"
+    },
+    {
+      "begin": "(?<!-)--\\[\\[",
+      "captures": {
+        "0": {
+          "name": "punctuation.definition.comment.yue"
+        }
+      },
+      "end": "\\]\\]",
+      "name": "comment.block.yue",
+      "patterns": [
+        {
+          "match": "@\\w*",
+          "name": "storage.type.annotation.yue"
+        }
+      ]
+    },
+    {
+      "begin": "(?<!-)--",
+      "end": "(?:[ \\t]*\\n)",
+      "name": "comment.line.yue",
+      "patterns": [
+        {
+          "match": "@\\w*",
+          "name": "storage.type.annotation.yuescript"
+        }
+      ],
+      "captures": {
+        "0": {
+          "name": "punctuation.definition.comment.yue"
+        }
+      }
+    },
+    {
+      "match": "(::)\\s*[a-zA-Z_][a-zA-Z0-9_]*\\s*(::)",
+      "name": "string.tag.lua",
+      "captures": {
+        "1": {
+          "name": "punctuation.section.embedded.begin.yue"
+        },
+        "2": {
+          "name": "punctuation.section.embedded.end.yue"
+        }
+      }
+    },
+    {
+      "patterns": [
+        {
+          "match": "<\\b(?:mode|name|add|sub|mul|div|mod|pow|unm|idiv|band|bor|bxor|bnot|shl|shr|concat|len|eq|lt|le|index|newindex|call|metatable|gc|close|tostring|pairs|ipairs)\\b>",
+          "name": "constant.language.yue"
+        },
+        {
+          "match": "<>",
+          "name": "constant.language.yue"
+        },
+        {
+          "match": "<(\"(?:\\\\\"|[^\"])*\")>",
+          "name": "constant.language.yue",
+          "captures": {
+            "1": {
+              "name": "string.quoted.double.yue"
+            }
+          }
+        },
+        {
+          "match": "<('(?:\\\\'|[^'])*')>",
+          "name": "constant.language.yue",
+          "captures": {
+            "1": {
+              "name": "string.quoted.single.yue"
+            }
+          }
+        },
+        {
+          "match": "<\\w+>",
+          "name": "invalid.illegal.yue"
+        }
+      ]
+    },
+    {
+      "match": "(\\+|\\-|\\*|/|%|\\^|//|\\||\\&|>>|<<|(?<!\\?)\\?{2}(?!\\?)|(?<!\\.)\\.{2}(?!\\.)|\\band|\\bor)=?",
+      "name": "keyword.operator.yue"
+    },
+    {
+      "match": "\\[\\]\\s*=",
+      "name": "keyword.operator.yue"
+    },
+    {
+      "match": "==|~=|\\!=|>|>=|<|<=",
+      "name": "keyword.operator.yue"
+    },
+    {
+      "match": "#|\\-|~|\\?|!",
+      "name": "keyword.operator.yue"
+    },
+    {
+      "match": "\\|>|=|:=|(?<!:):(?!:)|,|\\b_\\b",
+      "name": "keyword.operator.yue"
+    },
+    {
+      "match": "(?<!\\.)\\.{3}(?!\\.)(?!\\w+)",
+      "name": "constant.language.yue"
+    },
+    {
+      "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:import|as|from|export|macro|local|global|close|const|class|extends|using)\\b(?!:)",
+      "name": "keyword.yue"
+    },
+    {
+      "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:if|then|else|elseif|until|unless|switch|when|with|do|for|while|repeat|return|continue|break|try|catch|goto)\\b(?!:)",
+      "name": "keyword.control.yue"
+    },
+    {
+      "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:or|and|in|not)\\b(?!:)",
+      "name": "keyword.control.yue"
+    },
+    {
+      "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:true|false|nil)\\b(?!:)",
+      "name": "constant.language.boolean.yue"
+    },
+    {
+      "match": "\\b(?<![\\.|:|::|\\\\|\\$])(function|end)(?!:)\\b",
+      "name": "invalid.illegal.yue"
+    },
+    {
+      "match": "((?<!\\.)\\.{4,}(?!\\.))",
+      "name": "invalid.illegal.yue"
+    },
+    {
+      "begin": "(?<=\\s|^)(\\{)(?=.+?\\}\\s+[:=])",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.control.yue"
+        }
+      },
+      "end": "(\\}\\s*[:=])",
+      "endCaptures": {
+        "0": {
+          "name": "keyword.control.yue"
+        }
+      },
+      "name": "meta.variable.assignment.destructured.object.yue",
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ]
+    },
+    {
+      "match": "(?<=[ \t]*)\\b(?:new)\\b(?=:(?:\\s*\\(.*\\))?\\s*=>)",
+      "name": "variable.language.yue"
+    },
+    {
+      "match": "(?x)\n\t\t\t\t(?<=^|\\s)\n\t\t\t\t(?=@?[a-zA-Z\\$_]\\??)\n\t\t\t\t(\n\t\t\t\t\t@?[a-zA-Z\\$_]\\??(\\w|\\$|:|\\.)*\\s*\n\t\t\t\t\t(?=[:=](\\s*\\(.*\\))?\\s*([=-]>))\n\t\t\t\t)\n\t\t\t",
+      "name": "meta.function.yue",
+      "captures": {
+        "1": {
+          "name": "entity.name.function.yue"
+        },
+        "2": {
+          "name": "entity.name.function.yue"
+        },
+        "3": {
+          "name": "variable.parameter.function.yue"
+        },
+        "4": {
+          "name": "storage.type.function.yue"
+        }
+      }
+    },
+    {
+      "match": "\\b__(class|base|init|inherited|mode|name|add|sub|mul|div|mod|pow|unm|idiv|band|bor|bxor|bnot|shl|shr|concat|len|eq|lt|le|index|newindex|call|metatable|gc|close|tostring|pairs|ipairs)\\b",
+      "name": "entity.name.function.yue"
+    },
+    {
+      "match": "(?:\\bclass\\b)\\s+(@?[a-zA-Z\\$_][\\w\\.]*)?(?:\\s+(?:\\bextends\\b)\\s+(@?[a-zA-Z\\$\\._][\\w\\.]*))?",
+      "name": "meta.class.yue",
+      "captures": {
+        "1": {
+          "name": "storage.type.class.yue"
+        },
+        "2": {
+          "name": "entity.name.type.class.yue"
+        },
+        "3": {
+          "name": "keyword.control.inheritance.yue"
+        },
+        "4": {
+          "name": "entity.other.inherited-class.yue"
+        }
+      }
+    },
+    {
+      "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:_ENV|_G|_VERSION|arg)\\b(?!(?:\\s*(?:(?:\\+|\\-|\\*|/|%|\\^|//|\\||\\&|>>|<<|(?<!\\?)\\?{2}(?!\\?)|(?<!\\.)\\.{2}(?!\\.)|\\band|\\bor)?=|:=)\\s*|:))",
+      "name": "constant.language.yue"
+    },
+    {
+      "include": "#expression"
+    },
+    {
+      "match": ",[ \\t]*",
+      "name": "meta.delimiter.object.comma.yue"
+    },
+    {
+      "match": "\\.|::|\\\\",
+      "name": "meta.delimiter.method.yue"
+    },
+    {
+      "match": "\\{|\\}",
+      "name": "meta.brace.curly.yue"
+    },
+    {
+      "match": "\\(|\\)",
+      "name": "meta.brace.round.yue"
+    },
+    {
+      "match": "\\[|\\]",
+      "name": "meta.brace.square.yue"
+    }
+  ],
+  "repository": {
+    "expression": {
+      "patterns": [
+        {
+          "include": "#string"
+        },
+        {
+          "include": "#numeric"
+        },
+        {
+          "include": "#builtins"
+        },
+        {
+          "include": "#variable_name"
+        }
+      ]
+    },
+    "keyword": {
+      "patterns": [
+        {
+          "match": "\\b(?:import|as|from|export|macro|local|global|close|const|class|extends|using)\\b",
+          "name": "keyword.yue"
+        },
+        {
+          "match": "\\b(?:if|then|else|elseif|until|unless|switch|when|with|do|for|while|repeat|return|continue|break|try|catch|goto)\\b",
+          "name": "keyword.control.yue"
+        },
+        {
+          "match": "\\b(?:or|and|in|not)\\b",
+          "name": "keyword.operator.yue"
+        }
+      ]
+    },
+    "string": {
+      "patterns": [
+        {
+          "include": "#single_quoted_string"
+        },
+        {
+          "include": "#double_quoted_string"
+        }
+      ]
+    },
+    "string_format_code": {
+      "patterns": [
+        {
+          "match": "%(%|a|A|c|d|e|E|f|g|G|i|o|p|q|s|u|x|X)",
+          "name": "constant.character.yue"
+        }
+      ]
+    },
+    "string_escape_sequence": {
+      "patterns": [
+        {
+          "match": "\\\\([abfnrtvz\\'\"\\\\]|\\d{1,3}|x\\h{2}|u\\{\\h+\\})",
+          "name": "constant.character.yue"
+        },
+        {
+          "match": "\\\\.",
+          "name": "invalid.illegal.yue"
+        }
+      ]
+    },
+    "double_quoted_string": {
+      "patterns": [
+        {
+          "begin": "\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.yue"
+            }
+          },
+          "end": "\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.yue"
+            }
+          },
+          "name": "string.quoted.double.yue",
+          "patterns": [
+            {
+              "include": "#string_escape_sequence"
+            },
+            {
+              "include": "#interpolated_yue"
+            },
+            {
+              "include": "#string_format_code"
+            }
+          ]
+        }
+      ]
+    },
+    "single_quoted_string": {
+      "patterns": [
+        {
+          "begin": "'",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.yue"
+            }
+          },
+          "end": "'",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.yue"
+            }
+          },
+          "name": "string.quoted.single.yue",
+          "patterns": [
+            {
+              "include": "#string_escape_sequence"
+            },
+            {
+              "include": "#string_format_code"
+            }
+          ]
+        }
+      ]
+    },
+    "interpolated_yue": {
+      "patterns": [
+        {
+          "begin": "\\#\\{",
+          "captures": {
+            "0": {
+              "name": "punctuation.section.embedded.yue"
+            }
+          },
+          "end": "\\}",
+          "name": "source.yue.embedded.source",
+          "patterns": [
+            {
+              "include": "$self"
+            }
+          ]
+        }
+      ]
+    },
+    "variable_name": {
+      "patterns": [
+        {
+          "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)(\\b(?:self)\\b)(?!:)\\b",
+          "name": "invalid.deprecated.yue"
+        },
+        {
+          "match": "(?x)\\b(?<!\\.|:|::|\\\\|\\$)\\b(?:super)\\b(?!(?:\\s*(?:(?:\\+|\\-|\\*|/|%|\\^|//|\\||\\&|>>|<<|(?<!\\?)\\?{2}(?!\\?)|(?<!\\.)\\.{2}(?!\\.)|\\band|\\bor)?=|:=)\\s*|:))",
+          "name": "variable.language.yue"
+        },
+        {
+          "match": "(?:\\${2,}|@{3,})(?:(?:\\b[a-zA-Z_]\\w*)?((?:\\.|::|\\\\)\\b[a-zA-Z_]\\w*)*\\b)?",
+          "name": "invalid.illegal.yue"
+        },
+        {
+          "match": "(?<!\\$)\\$\\b[a-zA-Z_]\\w*\\b",
+          "name": "entity.name.function.preprocessor.yue"
+        },
+        {
+          "match": "(?<!\\$)\\$(?!\\$)",
+          "name": "invalid.illegal.yue"
+        },
+        {
+          "match": "(?<![\\$@])@@(?:(?:\\b[a-zA-Z_]\\w*)?((?:\\.|::|\\\\)\\b[a-zA-Z_]\\w*)*\\b)?",
+          "name": "variable.other.static.yue"
+        },
+        {
+          "match": "(?<![\\$@])@(?:(?:\\b[a-zA-Z_]\\w*)?((?:\\.|::|\\\\)\\b[a-zA-Z_]\\w*)*\\b)?",
+          "name": "variable.other.member.yue"
+        },
+        {
+          "match": "(?<![\\$@])\\b[a-zA-Z_]\\w*((?:\\.|::|\\\\)\\b[a-zA-Z_]\\w*\\b)*",
+          "name": "variable.assignment.yue"
+        },
+        {
+          "match": "(?<![\\$@])\\b([a-zA-Z\\$_]\\w*(\\.\\w+)*)\\b",
+          "name": "variable.assignment.yue",
+          "captures": {
+            "1": {
+              "name": "variable.assignment.yue"
+            }
+          }
+        }
+      ]
+    },
+    "numeric": {
+      "patterns": [
+        {
+          "match": "\\b([\\d_]+(\\.[\\d_]+)?|\\.[\\d_]+)(e[+\\-]?[\\d_]+)?\\b",
+          "name": "constant.numeric.yue"
+        },
+        {
+          "match": "\\b0x(((?:\\h|\\h[\\h_]*\\h)(\\.(?:\\h|\\h[\\h_]*\\h))?)|\\.(?:\\h|\\h[\\h_]*\\h))\\b",
+          "name": "constant.numeric.yue"
+        },
+        {
+          "match": "\\b\\d(?:\\w|\\.|:|::|\\\\)+\\b",
+          "name": "invalid.illegal.yue"
+        }
+      ]
+    },
+    "builtins": {
+      "patterns": [
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*(?:lpeg|lpeglabel)(?:(?:\\.|::|\\\\)(?:B|C|Carg|Cb|Cc|Cf|Cg|Cmt|Cp|Cs|Ct|P|R|S|T|V|locale|match|pcode|ptree|setmaxstack|type|utfR|version))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*(?:re|relabel)(?:(?:\\.|::|\\\\)(?:calcline|compile|find|gsub|match|updatelocale))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*coroutine(?:(?:\\.|::|\\\\)(?:close|create|isyieldable|resume|running|status|wrap|yield))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*debug(?:(?:\\.|::|\\\\)(?:debug|gethook|getinfo|getlocal|getmetatable|getregistry|getupvalue|getuservalue|setcstacklimit|sethook|setlocal|setmetatable|setupvalue|setuservalue|traceback|upvalueid|upvaluejoin))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*io(?:(?:\\.|::|\\\\)(?:close|flush|input|lines|open|output|popen|read|stderr|stdin|stdout|tmpfile|type|write))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*math(?:(?:\\.|::|\\\\)(?:abs|acos|asin|atan|atan2|ceil|cos|cosh|deg|exp|floor|fmod|frexp|huge|ldexp|log|log10|max|maxinteger|min|mininteger|modf|pi|pow|rad|random|randomseed|sin|sinh|sqrt|tan|tanh|tointeger|type|ult))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*os(?:(?:\\.|::|\\\\)(?:clock|date|difftime|execute|exit|getenv|remove|rename|setlocale|time|tmpname))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*package(?:(?:\\.|::|\\\\)(?:config|cpath|loaded|loadlib|path|preload|searchers|searchpath))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.Date(?:(?:\\.|::|\\\\)(?:Format|Interval|_class|_init|add|cast|catch|class_of|day|diff|hour|is_a|is_weekend|last_day|min|month|month_name|sec|set|toLocal|toUTC|tzone|weekday_name|yday|year))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.List(?:(?:\\.|::|\\\\)(?:_class|_create|_init|_name|append|cast|catch|chop|class_of|clear|clone|concat|contains|count|default_map|default_map_with|extend|filter|foreach|foreachm|get|index|insert|is_a|iter|iterate|join|len|map|map2|mapm|minmax|new|partition|pop|push|put|range|reduce|remove|remove_value|reverse|slice|slice_assign|sort|sorted|splice|split|transform))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.Map(?:(?:\\.|::|\\\\)(?:_class|_init|_name|cast|catch|class_of|get|getvalues|is_a|items|iter|keys|len|set|setdefault|update|values))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.MultiMap(?:(?:\\.|::|\\\\)(?:_base|_class|_init|_name|_parent_with_init|cast|catch|class_of|get|getvalues|is_a|items|iter|keys|len|set|setdefault|update|values))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.OrderedMap(?:(?:\\.|::|\\\\)(?:_base|_class|_init|_name|_parent_with_init|cast|catch|class_of|get|getvalues|insert|is_a|items|iter|keys|len|set|setdefault|sort|update|values))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.Set(?:(?:\\.|::|\\\\)(?:_base|_class|_init|_name|_parent_with_init|cast|catch|class_of|difference|get|getvalues|intersection|is_a|isdisjoint|isempty|issubset|items|iter|keys|len|map|set|setdefault|symmetric_difference|union|update|values))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.app(?:(?:\\.|::|\\\\)(?:appfile|lua|parse_args|platform|require_here|script_name))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.array2d(?:(?:\\.|::|\\\\)(?:column|columns|default_range|extract_cols|extract_rows|flatten|forall|iter|map|map2|move|new|parse_range|product|range|reduce2|reduce_cols|reduce_rows|remove_col|remove_row|reshape|row|rows|set|size|slice|swap_cols|swap_rows|transpose|write))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.class(?:(?:\\.|::|\\\\)(?:properties))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.compat(?:(?:\\.|::|\\\\)(?:dir_separator|execute|getfenv|is_windows|jit|load|lua51|setfenv))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.comprehension(?:(?:\\.|::|\\\\)(?:new))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.config(?:(?:\\.|::|\\\\)(?:lines|read))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.data(?:(?:\\.|::|\\\\)(?:filter|new|query|read|write))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.dir(?:(?:\\.|::|\\\\)(?:clonetree|copyfile|dirtree|filter|fnmatch|getallfiles|getdirectories|getfiles|makepath|movefile|rmtree|walk))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.file(?:(?:\\.|::|\\\\)(?:access_time|copy|creation_time|delete|modified_time|move|read|write))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.func(?:(?:\\.|::|\\\\)(?:And|Args|Eq|Ge|Gt|I|Le|Len|Lt|Nil|Not|Or|PE|Var|_|_0|_1|_2|_3|_4|_5|bind|bind1|collect_values|compose|curry|import|instantiate|isPE|lookup_imported_name|register|repr|tail))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.input(?:(?:\\.|::|\\\\)(?:alltokens|create_getter|fields|numbers|words))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.lapp(?:(?:\\.|::|\\\\)(?:add_type|assert|callback|error|open|process_options_string|quit|show_usage_error))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.lexer(?:(?:\\.|::|\\\\)(?:cpp|expecting|get_keywords|get_separated_list|getline|getrest|insert|lineno|lua|scan|skipws))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.luabalanced(?:(?:\\.|::|\\\\)(?:gsub|match_bracketed|match_explist|match_expression|match_namelist|match_string))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.operator(?:(?:\\.|::|\\\\)(?:add|call|concat|div|eq|ge|gt|index|land|le|len|lnot|lor|lt|match|mod|mul|neq|nop|optable|pow|sub|table|unm))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.path(?:(?:\\.|::|\\\\)(?:abspath|attrib|basename|chdir|common_prefix|currentdir|dir|dirname|dirsep|exists|expanduser|extension|getatime|getctime|getmtime|getsize|is_windows|isabs|isdir|isfile|islink|join|link_attrib|mkdir|normcase|normpath|package_path|relpath|rmdir|sep|splitext|splitpath|tmpname))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.permute(?:(?:\\.|::|\\\\)(?:iter|list_iter|list_table|order_iter|order_table|table))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.pretty(?:(?:\\.|::|\\\\)(?:debug|dump|load|number|read|write))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.seq(?:(?:\\.|::|\\\\)(?:copy|copy2|copy_tuples|count|count_map|enum|equal_to|filter|foreach|greater_than|import|iter|keys|last|less_than|lines|list|map|mapmethod|matching|minmax|printall|random|range|reduce|skip|sort|splice|sum|take|unique|zip))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.sip(?:(?:\\.|::|\\\\)(?:compile|create_pattern|create_spec_fun|custom_pattern|fields|match|match_at_start|pattern|read))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.strict(?:(?:\\.|::|\\\\)(?:closed_module|make_all_strict|module))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.stringio(?:(?:\\.|::|\\\\)(?:create|lines|open))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.stringx(?:(?:\\.|::|\\\\)(?:Template|at|capitalize|center|count|dedent|endswith|expandtabs|fill|format_operator|import|indent|isalnum|isalpha|isdigit|islower|isspace|isupper|join|lfind|lines|ljust|lstrip|partition|quote_string|replace|rfind|rjust|rpartition|rstrip|shorten|split|splitlines|splitv|startswith|strip|title|wrap))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.tablex(?:(?:\\.|::|\\\\)(?:_normalize_slice|clear|compare|compare_no_order|copy|count_map|deepcompare|deepcopy|difference|filter|find|find_if|foreach|foreachi|icopy|imap|imap2|index_by|index_map|insertvalues|intersection|keys|makeset|map|map2|map_named_method|mapn|merge|move|new|pairmap|range|readonly|reduce|removevalues|rfind|search|set|size|sort|sortv|sub|transform|union|update|values|zip))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.template(?:(?:\\.|::|\\\\)(?:compile|substitute))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.test(?:(?:\\.|::|\\\\)(?:asserteq|asserteq2|assertmatch|assertraise|complain|error_handler|timer|tuple))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.text(?:(?:\\.|::|\\\\)(?:Template|at|capitalize|center|count|dedent|endswith|expandtabs|fill|format_operator|import|indent|isalnum|isalpha|isdigit|islower|isspace|isupper|join|lfind|lines|ljust|lstrip|partition|quote_string|replace|rfind|rjust|rpartition|rstrip|shorten|split|splitlines|splitv|startswith|strip|title|wrap))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.types(?:(?:\\.|::|\\\\)(?:is_callable|is_empty|is_indexable|is_integer|is_iterable|is_type|is_writeable|to_bool|type))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.url(?:(?:\\.|::|\\\\)(?:quote|unquote))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.utils(?:(?:\\.|::|\\\\)(?:_VERSION|add_function_factory|array_tostring|assert_arg|assert_string|bind1|bind2|choose|dir_separator|enum|escape|execute|executeex|fprintf|function_arg|getfenv|import|is_type|is_windows|jit|kpairs|load|lua51|memoize|npairs|on_error|pack|patterns|printf|quit|quote_arg|raise|raise_deprecation|readfile|readlines|set_deprecation_func|setfenv|split|splitv|stdmt|string_lambda|unpack|writefile))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*pl\\.xml(?:(?:\\.|::|\\\\)(?:basic_parse|clone|compare|elem|is_tag|new|parse|parsehtml|tags|tostring|walk|xml_escape|xml_unescape))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*string(?:(?:\\.|::|\\\\)(?:byte|char|dump|find|format|gmatch|gsub|len|lower|match|pack|packsize|rep|reverse|sub|unpack|upper))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*table(?:(?:\\.|::|\\\\)(?:concat|insert|move|pack|remove|sort|unpack))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*utf8(?:(?:\\.|::|\\\\)(?:char|charpattern|codepoint|codes|len|offset))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*yue(?:(?:\\.|::|\\\\)(?:check|dofile|file_exist|find_modulepath|format|insert_loader|is_ast|loadfile|loadstring|macro_env|options|p|pcall|read_file|to_ast|to_lua|traceback|version|yue_compiled))?\\b"
+        },
+        {
+          "name": "support.function.library.yue",
+          "match": "\\b(?:_G(?:\\.|:|::|\\\\))*(?:_G|_VERSION|arg|assert|collectgarbage|coroutine|debug|dofile|error|getmetatable|io|ipairs|lfs|load|loadfile|math|next|os|package|pairs|pcall|print|rawequal|rawget|rawlen|rawset|require|select|setmetatable|string|table|tonumber|tostring|type|utf8|warn|xpcall)\\b"
+        }
+      ]
+    }
+  }
+}
diff --git a/doc/docs/.vitepress/theme/components/CompilerModal.vue b/doc/docs/.vitepress/theme/components/CompilerModal.vue
index c00443e..19d5830 100755
--- a/doc/docs/.vitepress/theme/components/CompilerModal.vue
+++ b/doc/docs/.vitepress/theme/components/CompilerModal.vue
@@ -7,41 +7,41 @@
 </template>
 
 <script>
-import YueCompiler from './YueCompiler.vue'
+import YueCompiler from "./YueCompiler.vue";
 
 export default {
   components: {
-    YueCompiler
+    YueCompiler,
   },
   data() {
     return {
       isOpen: false,
-      content: ''
-    }
+      content: "",
+    };
   },
   mounted() {
     this.handleOpen = (event) => {
-      this.content = event?.detail || ''
-      this.isOpen = true
-    }
+      this.content = event?.detail || "";
+      this.isOpen = true;
+    };
     this.handleKeydown = (event) => {
-      if (event.key === 'Escape' && this.isOpen) {
-        this.close()
+      if (event.key === "Escape" && this.isOpen) {
+        this.close();
       }
-    }
-    window.addEventListener('yue:open-compiler', this.handleOpen)
-    window.addEventListener('keydown', this.handleKeydown)
+    };
+    window.addEventListener("yue:open-compiler", this.handleOpen);
+    window.addEventListener("keydown", this.handleKeydown);
   },
   beforeUnmount() {
-    window.removeEventListener('yue:open-compiler', this.handleOpen)
-    window.removeEventListener('keydown', this.handleKeydown)
+    window.removeEventListener("yue:open-compiler", this.handleOpen);
+    window.removeEventListener("keydown", this.handleKeydown);
   },
   methods: {
     close() {
-      this.isOpen = false
-    }
-  }
-}
+      this.isOpen = false;
+    },
+  },
+};
 </script>
 
 <style scoped>
@@ -63,5 +63,4 @@ export default {
   background: #ffffff;
   box-shadow: 0 20px 40px rgba(0, 0, 0, 0.2);
 }
-
 </style>
diff --git a/doc/docs/.vitepress/theme/components/HomeFooter.vue b/doc/docs/.vitepress/theme/components/HomeFooter.vue
index 5ee116c..640b4a7 100644
--- a/doc/docs/.vitepress/theme/components/HomeFooter.vue
+++ b/doc/docs/.vitepress/theme/components/HomeFooter.vue
@@ -1,7 +1,7 @@
 <script setup lang="ts">
-import { useData } from 'vitepress'
+import { useData } from "vitepress";
 
-const { frontmatter } = useData()
+const { frontmatter } = useData();
 </script>
 
 <template>
diff --git a/doc/docs/.vitepress/theme/components/YueCompiler.vue b/doc/docs/.vitepress/theme/components/YueCompiler.vue
index a49692b..d9a3702 100755
--- a/doc/docs/.vitepress/theme/components/YueCompiler.vue
+++ b/doc/docs/.vitepress/theme/components/YueCompiler.vue
@@ -1,5 +1,5 @@
 <template>
-  <div style="width: 100%; height: auto;">
+  <div style="width: 100%; height: auto">
     <div class="parent">
       <div class="editor-section">
         <div class="childTitle">YueScript {{ info }}</div>
@@ -10,7 +10,9 @@
       <div class="editor-section">
         <div class="childTitle">Lua</div>
         <div class="editor-container">
-          <pre class="code-output language-lua"><code v-html="highlightedLua"></code></pre>
+          <pre
+            class="code-output language-lua"
+          ><code v-html="highlightedLua"></code></pre>
         </div>
       </div>
     </div>
@@ -22,447 +24,555 @@
 </template>
 
 <script>
-import pkg from 'prismjs/components/prism-core.js'
-const { highlight, languages } = pkg
-import 'prismjs/components/prism-moonscript'
-import 'prismjs/components/prism-lua'
-import { EditorState, Compartment } from '@codemirror/state'
-import { EditorView, keymap, lineNumbers } from '@codemirror/view'
+import pkg from "prismjs/components/prism-core.js";
+const { highlight, languages } = pkg;
+import "prismjs/components/prism-moonscript";
+import "prismjs/components/prism-lua";
+import { EditorState, Compartment } from "@codemirror/state";
+import { EditorView, keymap, lineNumbers } from "@codemirror/view";
 import {
   indentUnit,
   StreamLanguage,
   syntaxHighlighting,
-  HighlightStyle
-} from '@codemirror/language'
-import { tags } from '@lezer/highlight'
-import { history, indentWithTab } from '@codemirror/commands'
-import { defaultKeymap, historyKeymap } from '@codemirror/commands'
-import { simpleMode } from '@codemirror/legacy-modes/mode/simple-mode'
+  HighlightStyle,
+} from "@codemirror/language";
+import { tags } from "@lezer/highlight";
+import { history, indentWithTab } from "@codemirror/commands";
+import { defaultKeymap, historyKeymap } from "@codemirror/commands";
+import { simpleMode } from "@codemirror/legacy-modes/mode/simple-mode";
 
 /* shikijs/themes/light-plus: editor.background #FFFFFF, editor.foreground #000000 */
 const lightPlusTheme = EditorView.theme(
   {
-    '&': {
-      height: '100%',
-      backgroundColor: '#FFFFFF',
-      color: '#000000',
-      fontSize: '14px'
+    "&": {
+      height: "100%",
+      backgroundColor: "#FFFFFF",
+      color: "#000000",
+      fontSize: "14px",
     },
-    '&.cm-focused': {
-      outline: 'none'
+    "&.cm-focused": {
+      outline: "none",
     },
-    '.cm-content': {
+    ".cm-content": {
       fontFamily:
         "ui-monospace, 'Menlo', 'Monaco', 'Consolas', 'Liberation Mono', 'Courier New', monospace",
-      lineHeight: '1.375'
+      lineHeight: "1.375",
     },
-    '.cm-gutters': {
-      backgroundColor: '#FFFFFF',
-      color: '#6e6e6e',
-      borderRight: 'none'
+    ".cm-gutters": {
+      backgroundColor: "#FFFFFF",
+      color: "#6e6e6e",
+      borderRight: "none",
     },
-    '.cm-activeLine': {
-      backgroundColor: 'transparent'
+    ".cm-activeLine": {
+      backgroundColor: "transparent",
     },
-    '.cm-activeLineGutter': {
-      backgroundColor: 'transparent'
+    ".cm-activeLineGutter": {
+      backgroundColor: "transparent",
     },
-    '.cm-selectionBackground': {
-      backgroundColor: '#add6ff'
+    ".cm-selectionBackground": {
+      backgroundColor: "#add6ff",
     },
-    '&.cm-focused .cm-selectionBackground': {
-      backgroundColor: '#add6ff'
+    "&.cm-focused .cm-selectionBackground": {
+      backgroundColor: "#add6ff",
     },
-    '.cm-cursor': {
-      borderLeftColor: '#000000'
+    ".cm-cursor": {
+      borderLeftColor: "#000000",
+    },
+    ".cm-matchingBracket": {
+      backgroundColor: "#c9def5",
     },
-    '.cm-matchingBracket': {
-      backgroundColor: '#c9def5'
-    }
   },
-  { dark: false }
-)
+  { dark: false },
+);
 
 /* shikijs/themes/dark-plus: editor.background #1E1E1E, editor.foreground #D4D4D4 */
 const darkPlusTheme = EditorView.theme(
   {
-    '&': {
-      height: '100%',
-      backgroundColor: '#1E1E1E',
-      color: '#D4D4D4',
-      fontSize: '14px'
+    "&": {
+      height: "100%",
+      backgroundColor: "#1E1E1E",
+      color: "#D4D4D4",
+      fontSize: "14px",
     },
-    '&.cm-focused': {
-      outline: 'none'
+    "&.cm-focused": {
+      outline: "none",
     },
-    '.cm-content': {
+    ".cm-content": {
       fontFamily:
         "ui-monospace, 'Menlo', 'Monaco', 'Consolas', 'Liberation Mono', 'Courier New', monospace",
-      lineHeight: '1.375'
+      lineHeight: "1.375",
     },
-    '.cm-gutters': {
-      backgroundColor: '#1E1E1E',
-      color: '#858585',
-      borderRight: 'none'
+    ".cm-gutters": {
+      backgroundColor: "#1E1E1E",
+      color: "#858585",
+      borderRight: "none",
     },
-    '.cm-activeLine': {
-      backgroundColor: 'transparent'
+    ".cm-activeLine": {
+      backgroundColor: "transparent",
     },
-    '.cm-activeLineGutter': {
-      backgroundColor: 'transparent'
+    ".cm-activeLineGutter": {
+      backgroundColor: "transparent",
     },
-    '.cm-selectionBackground': {
-      backgroundColor: '#264f78'
+    ".cm-selectionBackground": {
+      backgroundColor: "#264f78",
     },
-    '&.cm-focused .cm-selectionBackground': {
-      backgroundColor: '#264f78'
+    "&.cm-focused .cm-selectionBackground": {
+      backgroundColor: "#264f78",
     },
-    '.cm-cursor': {
-      borderLeftColor: '#aeafad'
+    ".cm-cursor": {
+      borderLeftColor: "#aeafad",
+    },
+    ".cm-matchingBracket": {
+      backgroundColor: "#3a3d41",
     },
-    '.cm-matchingBracket': {
-      backgroundColor: '#3a3d41'
-    }
   },
-  { dark: true }
-)
+  { dark: true },
+);
 
 /* shikijs/themes/light-plus tokenColors */
-const lightPlusHighlightStyle = HighlightStyle.define([
-  { tag: tags.comment, color: '#008000' },
-  { tag: tags.keyword, color: '#AF00DB' },
-  { tag: [tags.operator, tags.punctuation], color: '#000000' },
-  { tag: [tags.string, tags.special(tags.string)], color: '#a31515' },
-  { tag: tags.regexp, color: '#811f3f' },
-  { tag: [tags.number, tags.bool, tags.null], color: '#098658' },
-  { tag: tags.function(tags.variableName), color: '#795e26' },
-  { tag: tags.typeName, color: '#267f99' },
-  { tag: tags.className, color: '#267f99' },
-  { tag: tags.propertyName, color: '#001080' },
-  { tag: tags.tagName, color: '#800000' },
-  { tag: tags.attributeName, color: '#e50000' },
-  { tag: tags.meta, color: '#666666' },
-  { tag: tags.invalid, color: '#cd3131' },
-  // Additional tags for YueScript - ensure all token types have styles
-  { tag: tags.variableName, color: '#001080' },
-  { tag: tags.constant(tags.name), color: '#098658' },
-  { tag: tags.constant(tags.variableName), color: '#098658' },
-  { tag: tags.constant, color: '#098658' },
-  { tag: tags.definition(tags.variableName), color: '#001080' },
-  { tag: tags.modifier, color: '#AF00DB' },
-  { tag: tags.namespace, color: '#267f99' },
-  { tag: tags.labelName, color: '#795e26' },
-  { tag: tags.character, color: '#098658' },
-  { tag: tags.literal, color: '#098658' },
-  { tag: tags.bracket, color: '#000000' },
-  { tag: tags.squareBracket, color: '#000000' },
-  { tag: tags.paren, color: '#000000' },
-  { tag: tags.brace, color: '#000000' }
-], { fallback: true })
+const lightPlusHighlightStyle = HighlightStyle.define(
+  [
+    { tag: tags.comment, color: "#008000" },
+    { tag: tags.keyword, color: "#AF00DB" },
+    { tag: [tags.operator, tags.punctuation], color: "#000000" },
+    { tag: [tags.string, tags.special(tags.string)], color: "#a31515" },
+    { tag: tags.regexp, color: "#811f3f" },
+    { tag: [tags.number, tags.bool, tags.null], color: "#098658" },
+    { tag: tags.function(tags.variableName), color: "#795e26" },
+    { tag: tags.typeName, color: "#267f99" },
+    { tag: tags.className, color: "#267f99" },
+    { tag: tags.propertyName, color: "#001080" },
+    { tag: tags.tagName, color: "#800000" },
+    { tag: tags.attributeName, color: "#e50000" },
+    { tag: tags.meta, color: "#666666" },
+    { tag: tags.invalid, color: "#cd3131" },
+    // Additional tags for YueScript - ensure all token types have styles
+    { tag: tags.variableName, color: "#001080" },
+    { tag: tags.constant(tags.name), color: "#098658" },
+    { tag: tags.constant(tags.variableName), color: "#098658" },
+    { tag: tags.constant, color: "#098658" },
+    { tag: tags.definition(tags.variableName), color: "#001080" },
+    { tag: tags.modifier, color: "#AF00DB" },
+    { tag: tags.namespace, color: "#267f99" },
+    { tag: tags.labelName, color: "#795e26" },
+    { tag: tags.character, color: "#098658" },
+    { tag: tags.literal, color: "#098658" },
+    { tag: tags.bracket, color: "#000000" },
+    { tag: tags.squareBracket, color: "#000000" },
+    { tag: tags.paren, color: "#000000" },
+    { tag: tags.brace, color: "#000000" },
+  ],
+  { fallback: true },
+);
 
 /* shikijs/themes/dark-plus tokenColors */
-const darkPlusHighlightStyle = HighlightStyle.define([
-  { tag: tags.comment, color: '#6a9955' },
-  { tag: tags.keyword, color: '#C586C0' },
-  { tag: [tags.operator, tags.punctuation], color: '#d4d4d4' },
-  { tag: [tags.string, tags.special(tags.string)], color: '#ce9178' },
-  { tag: tags.regexp, color: '#d16969' },
-  { tag: [tags.number, tags.bool, tags.null], color: '#b5cea8' },
-  { tag: tags.function(tags.variableName), color: '#dcdcaa' },
-  { tag: tags.typeName, color: '#4ec9b0' },
-  { tag: tags.className, color: '#4ec9b0' },
-  { tag: tags.propertyName, color: '#9cdcfe' },
-  { tag: tags.tagName, color: '#569cd6' },
-  { tag: tags.attributeName, color: '#9cdcfe' },
-  { tag: tags.meta, color: '#d4d4d4' },
-  { tag: tags.invalid, color: '#f44747' },
-  // Additional tags for YueScript - ensure all token types have styles
-  { tag: tags.variableName, color: '#9cdcfe' },
-  { tag: tags.constant(tags.name), color: '#b5cea8' },
-  { tag: tags.constant(tags.variableName), color: '#b5cea8' },
-  { tag: tags.constant, color: '#b5cea8' },
-  { tag: tags.definition(tags.variableName), color: '#9cdcfe' },
-  { tag: tags.modifier, color: '#C586C0' },
-  { tag: tags.namespace, color: '#4ec9b0' },
-  { tag: tags.labelName, color: '#dcdcaa' },
-  { tag: tags.character, color: '#b5cea8' },
-  { tag: tags.literal, color: '#b5cea8' },
-  { tag: tags.bracket, color: '#d4d4d4' },
-  { tag: tags.squareBracket, color: '#d4d4d4' },
-  { tag: tags.paren, color: '#d4d4d4' },
-  { tag: tags.brace, color: '#d4d4d4' }
-], { fallback: true })
+const darkPlusHighlightStyle = HighlightStyle.define(
+  [
+    { tag: tags.comment, color: "#6a9955" },
+    { tag: tags.keyword, color: "#C586C0" },
+    { tag: [tags.operator, tags.punctuation], color: "#d4d4d4" },
+    { tag: [tags.string, tags.special(tags.string)], color: "#ce9178" },
+    { tag: tags.regexp, color: "#d16969" },
+    { tag: [tags.number, tags.bool, tags.null], color: "#b5cea8" },
+    { tag: tags.function(tags.variableName), color: "#dcdcaa" },
+    { tag: tags.typeName, color: "#4ec9b0" },
+    { tag: tags.className, color: "#4ec9b0" },
+    { tag: tags.propertyName, color: "#9cdcfe" },
+    { tag: tags.tagName, color: "#569cd6" },
+    { tag: tags.attributeName, color: "#9cdcfe" },
+    { tag: tags.meta, color: "#d4d4d4" },
+    { tag: tags.invalid, color: "#f44747" },
+    // Additional tags for YueScript - ensure all token types have styles
+    { tag: tags.variableName, color: "#9cdcfe" },
+    { tag: tags.constant(tags.name), color: "#b5cea8" },
+    { tag: tags.constant(tags.variableName), color: "#b5cea8" },
+    { tag: tags.constant, color: "#b5cea8" },
+    { tag: tags.definition(tags.variableName), color: "#9cdcfe" },
+    { tag: tags.modifier, color: "#C586C0" },
+    { tag: tags.namespace, color: "#4ec9b0" },
+    { tag: tags.labelName, color: "#dcdcaa" },
+    { tag: tags.character, color: "#b5cea8" },
+    { tag: tags.literal, color: "#b5cea8" },
+    { tag: tags.bracket, color: "#d4d4d4" },
+    { tag: tags.squareBracket, color: "#d4d4d4" },
+    { tag: tags.paren, color: "#d4d4d4" },
+    { tag: tags.brace, color: "#d4d4d4" },
+  ],
+  { fallback: true },
+);
 
 export default {
   props: {
     compileronly: {
       type: Boolean,
-      default: false
+      default: false,
     },
     displayonly: {
       type: Boolean,
-      default: false
+      default: false,
     },
     text: {
       type: String,
-      default: ''
-    }
+      default: "",
+    },
   },
   data() {
     return {
-      info: 'Loading',
+      info: "Loading",
       readonly: true,
-      code: '',
-      compiled: '',
-      result: '',
+      code: "",
+      compiled: "",
+      result: "",
       windowWidth: 0,
       editorView: null,
       readOnlyCompartment: null,
       themeCompartment: null,
       highlightCompartment: null,
-      themeObserver: null
-    }
+      themeObserver: null,
+    };
   },
   computed: {
     isMobileLayout() {
-      return this.windowWidth <= 768
+      return this.windowWidth <= 768;
     },
     highlightedLua() {
-      return highlight(this.compiled || '', languages.lua)
-    }
+      return highlight(this.compiled || "", languages.lua);
+    },
   },
   mounted() {
-    this.windowWidth = window.innerWidth
-    window.addEventListener('resize', this.handleResize)
-    this.observeTheme()
+    this.windowWidth = window.innerWidth;
+    window.addEventListener("resize", this.handleResize);
+    this.observeTheme();
 
-    const initialCode = this.text !== '' ? this.text : ''
-    this.code = initialCode
-    this.codeChanged(initialCode)
-    this.initEditor(initialCode)
+    const initialCode = this.text !== "" ? this.text : "";
+    this.code = initialCode;
+    this.codeChanged(initialCode);
+    this.initEditor(initialCode);
     this.$nextTick(() => {
-      this.focusEditorToEnd()
-    })
+      this.focusEditorToEnd();
+    });
 
     const check = ((self) => {
       return () => {
         if (window.yue) {
-          self.info = window.yue.version()
-          self.readonly = false
-          this.refreshEditorReadOnly()
+          self.info = window.yue.version();
+          self.readonly = false;
+          this.refreshEditorReadOnly();
         } else {
-          setTimeout(check, 100)
+          setTimeout(check, 100);
         }
-      }
-    })(this)
-    check()
+      };
+    })(this);
+    check();
   },
   beforeUnmount() {
-    window.removeEventListener('resize', this.handleResize)
+    window.removeEventListener("resize", this.handleResize);
     if (this.editorView) {
-      this.editorView.destroy()
-      this.editorView = null
+      this.editorView.destroy();
+      this.editorView = null;
     }
     if (this.themeObserver) {
-      this.themeObserver.disconnect()
-      this.themeObserver = null
+      this.themeObserver.disconnect();
+      this.themeObserver = null;
     }
   },
   methods: {
     focusEditorToEnd() {
       if (!this.editorView) {
-        return
+        return;
       }
-      const docLength = this.editorView.state.doc.length
+      const docLength = this.editorView.state.doc.length;
       this.editorView.dispatch({
         selection: { anchor: docLength },
-        scrollIntoView: true
-      })
-      this.editorView.focus()
+        scrollIntoView: true,
+      });
+      this.editorView.focus();
     },
     handleResize() {
-      this.windowWidth = window.innerWidth
+      this.windowWidth = window.innerWidth;
     },
     isDarkTheme() {
-      return document.documentElement.classList.contains('dark')
+      return document.documentElement.classList.contains("dark");
     },
     observeTheme() {
       if (this.themeObserver) {
-        return
+        return;
       }
       this.themeObserver = new MutationObserver(() => {
-        this.refreshEditorTheme()
-      })
+        this.refreshEditorTheme();
+      });
       this.themeObserver.observe(document.documentElement, {
         attributes: true,
-        attributeFilter: ['class']
-      })
+        attributeFilter: ["class"],
+      });
     },
     initEditor(initialCode) {
       if (!this.$refs.codeEditor) {
-        return
+        return;
       }
 
       const yuescriptMode = simpleMode({
         start: [
           // Shebang
-          { regex: /^#!.*/, token: 'comment' },
+          { regex: /^#!.*/, token: "comment" },
           // Multiline string: [=[...]=] with any number of =
-          { regex: /\[(=*)\[/, token: 'string', push: 'luaString' },
+          { regex: /\[(=*)\[/, token: "string", push: "luaString" },
           // Block comment: --[[...]] (but not ---)
-          { regex: /--\[\[/, token: 'comment', push: 'commentBlock' },
+          { regex: /--\[\[/, token: "comment", push: "commentBlock" },
           // Line comment: -- (but not ---)
-          { regex: /--(?!-).*/, token: 'comment' },
+          { regex: /--(?!-).*/, token: "comment" },
           // Double quoted string with interpolation #{...}
-          { regex: /"/, token: 'string', push: 'doubleString' },
+          { regex: /"/, token: "string", push: "doubleString" },
           // Single quoted string
-          { regex: /'/, token: 'string', push: 'singleString' },
+          { regex: /'/, token: "string", push: "singleString" },
           // Tag: ::name::
-          { regex: /(::)\s*[a-zA-Z_][a-zA-Z0-9_]*\s*(::)/, token: 'tagName' },
+          { regex: /(::)\s*[a-zA-Z_][a-zA-Z0-9_]*\s*(::)/, token: "tagName" },
           // Class definition: class Name extends Base
-          { regex: /\bclass\b\s+(@?[a-zA-Z$_][\w.]*)?(?:\s+\bextends\b\s+(@?[a-zA-Z$._][\w.]*))?/, token: 'keyword' },
+          {
+            regex:
+              /\bclass\b\s+(@?[a-zA-Z$_][\w.]*)?(?:\s+\bextends\b\s+(@?[a-zA-Z$._][\w.]*))?/,
+            token: "keyword",
+          },
           // Function definition: name: => or name := => or name(params): =>
-          { regex: /(@?[a-zA-Z$_]\??[\w$:.]*\s*[:=]\s*(?:\([^)]*\))?\s*[=-]>)/, token: 'function' },
+          {
+            regex: /(@?[a-zA-Z$_]\??[\w$:.]*\s*[:=]\s*(?:\([^)]*\))?\s*[=-]>)/,
+            token: "function",
+          },
           // Destructured assignment: { ... } := or { ... } =
-          { regex: /\{\s*[^}]*\}\s*[:=]/, token: 'keyword' },
+          { regex: /\{\s*[^}]*\}\s*[:=]/, token: "keyword" },
           // Keywords (must come before operators to catch 'and', 'or', 'in', 'not')
-          { regex: /\b(?:import|as|from|export|macro|local|global|close|const|class|extends|using)\b(?![:\w])/, token: 'keyword' },
+          {
+            regex:
+              /\b(?:import|as|from|export|macro|local|global|close|const|class|extends|using)\b(?![:\w])/,
+            token: "keyword",
+          },
           // Control keywords
-          { regex: /\b(?:if|then|else|elseif|until|unless|switch|when|with|do|for|while|repeat|return|continue|break|try|catch|goto)\b(?![:\w])/, token: 'keyword' },
-          { regex: /\b(?:or|and|in|not)\b(?![:\w])/, token: 'keyword' },
+          {
+            regex:
+              /\b(?:if|then|else|elseif|until|unless|switch|when|with|do|for|while|repeat|return|continue|break|try|catch|goto)\b(?![:\w])/,
+            token: "keyword",
+          },
+          { regex: /\b(?:or|and|in|not)\b(?![:\w])/, token: "keyword" },
           // Boolean and nil
-          { regex: /\b(?:true|false|nil)\b(?![:\w])/, token: 'number' },
+          { regex: /\b(?:true|false|nil)\b(?![:\w])/, token: "number" },
           // Invalid: function/end
-          { regex: /\b(?:function|end)\b(?![:\w])/, token: 'invalid' },
+          { regex: /\b(?:function|end)\b(?![:\w])/, token: "invalid" },
           // Invalid: self (deprecated)
-          { regex: /\bself\b(?![:\w])/, token: 'invalid' },
+          { regex: /\bself\b(?![:\w])/, token: "invalid" },
           // super keyword
-          { regex: /\bsuper\b(?![:\w])/, token: 'variable' },
+          { regex: /\bsuper\b(?![:\w])/, token: "variable" },
           // Invalid variables: $$, $@, @@@, standalone $
-          { regex: /\$\$+/, token: 'invalid' },
-          { regex: /@@@+/, token: 'invalid' },
-          { regex: /\$(?!\w)/, token: 'invalid' },
+          { regex: /\$\$+/, token: "invalid" },
+          { regex: /@@@+/, token: "invalid" },
+          { regex: /\$(?!\w)/, token: "invalid" },
           // Special operators: <mode>, <>, <"string">, <'string'>, <word> (invalid)
-          { regex: /<\b(?:mode|name|add|sub|mul|div|mod|pow|unm|idiv|band|bor|bxor|bnot|shl|shr|concat|len|eq|lt|le|index|newindex|call|metatable|gc|close|tostring|pairs|ipairs)\b>/, token: 'constant' },
-          { regex: /<>/, token: 'constant' },
-          { regex: /<"[^"]*">/, token: 'constant' },
-          { regex: /<'[^']*'>/, token: 'constant' },
-          { regex: /<\w+>/, token: 'invalid' },
+          {
+            regex:
+              /<\b(?:mode|name|add|sub|mul|div|mod|pow|unm|idiv|band|bor|bxor|bnot|shl|shr|concat|len|eq|lt|le|index|newindex|call|metatable|gc|close|tostring|pairs|ipairs)\b>/,
+            token: "constant",
+          },
+          { regex: /<>/, token: "constant" },
+          { regex: /<"[^"]*">/, token: "constant" },
+          { regex: /<'[^']*'>/, token: "constant" },
+          { regex: /<\w+>/, token: "invalid" },
           // Operators (and/or removed since they're keywords, ?? must not match ???)
-          { regex: /(\+|\-|\*|\/|%|\^|\/\/|\||\&|>>|<<|\.\.)=?/, token: 'operator' },
-          { regex: /\?\?(?!\?)/, token: 'operator' },
-          { regex: /\[\]\s*=/, token: 'operator' },
-          { regex: /==|~=|!=|>|>=|<|<=/, token: 'operator' },
-          { regex: /#|~|\?|!/, token: 'operator' },
-          { regex: /\|>|=|:=|:(?!:)|,|\b_\b/, token: 'operator' },
-          { regex: /\.\.\.(?!\.)/, token: 'constant' },
+          {
+            regex: /(\+|\-|\*|\/|%|\^|\/\/|\||\&|>>|<<|\.\.)=?/,
+            token: "operator",
+          },
+          { regex: /\?\?(?!\?)/, token: "operator" },
+          { regex: /\[\]\s*=/, token: "operator" },
+          { regex: /==|~=|!=|>|>=|<|<=/, token: "operator" },
+          { regex: /#|~|\?|!/, token: "operator" },
+          { regex: /\|>|=|:=|:(?!:)|,|\b_\b/, token: "operator" },
+          { regex: /\.\.\.(?!\.)/, token: "constant" },
           // Invalid: 4+ dots
-          { regex: /\.{4,}/, token: 'invalid' },
+          { regex: /\.{4,}/, token: "invalid" },
           // Class name (capitalized) - must come after keywords
-          { regex: /\b[A-Z]\w*\b/, token: 'typeName' },
+          { regex: /\b[A-Z]\w*\b/, token: "typeName" },
           // Special variables: $variable (preprocessor), @variable (member), @@variable (static)
-          { regex: /\$\b[a-zA-Z_]\w*\b/, token: 'variable-2' },
-          { regex: /@@(?:(?:\b[a-zA-Z_]\w*)?((?:\.|::|\\)\b[a-zA-Z_]\w*\b)*)?/, token: 'variable-2' },
-          { regex: /@(?:(?:\b[a-zA-Z_]\w*)?((?:\.|::|\\)\b[a-zA-Z_]\w*\b)*)?/, token: 'variable-2' },
+          { regex: /\$\b[a-zA-Z_]\w*\b/, token: "variable-2" },
+          {
+            regex: /@@(?:(?:\b[a-zA-Z_]\w*)?((?:\.|::|\\)\b[a-zA-Z_]\w*\b)*)?/,
+            token: "variable-2",
+          },
+          {
+            regex: /@(?:(?:\b[a-zA-Z_]\w*)?((?:\.|::|\\)\b[a-zA-Z_]\w*\b)*)?/,
+            token: "variable-2",
+          },
           // Magic methods: __class, __base, etc.
-          { regex: /\b__(?:class|base|init|inherited|mode|name|add|sub|mul|div|mod|pow|unm|idiv|band|bor|bxor|bnot|shl|shr|concat|len|eq|lt|le|index|newindex|call|metatable|gc|close|tostring|pairs|ipairs)\b/, token: 'function' },
+          {
+            regex:
+              /\b__(?:class|base|init|inherited|mode|name|add|sub|mul|div|mod|pow|unm|idiv|band|bor|bxor|bnot|shl|shr|concat|len|eq|lt|le|index|newindex|call|metatable|gc|close|tostring|pairs|ipairs)\b/,
+            token: "function",
+          },
           // Numbers: decimal, hex, with underscores
-          { regex: /\b([\d_]+(\.[\d_]+)?|\.[\d_]+)(e[+\-]?[\d_]+)?\b/i, token: 'number' },
-          { regex: /\b0x([0-9a-fA-F]([0-9a-fA-F_]*[0-9a-fA-F])?(\.[0-9a-fA-F]([0-9a-fA-F_]*[0-9a-fA-F])?)?|\.[0-9a-fA-F]([0-9a-fA-F_]*[0-9a-fA-F])?)\b/i, token: 'number' },
+          {
+            regex: /\b([\d_]+(\.[\d_]+)?|\.[\d_]+)(e[+\-]?[\d_]+)?\b/i,
+            token: "number",
+          },
+          {
+            regex:
+              /\b0x([0-9a-fA-F]([0-9a-fA-F_]*[0-9a-fA-F])?(\.[0-9a-fA-F]([0-9a-fA-F_]*[0-9a-fA-F])?)?|\.[0-9a-fA-F]([0-9a-fA-F_]*[0-9a-fA-F])?)\b/i,
+            token: "number",
+          },
           // Invalid number
-          { regex: /\b\d(?:\w|\.|:|::|\\)+\b/, token: 'invalid' },
+          { regex: /\b\d(?:\w|\.|:|::|\\)+\b/, token: "invalid" },
           // Built-in constants
-          { regex: /\b(?:_ENV|_G|_VERSION|arg)\b(?![:\w])/, token: 'constant' },
+          { regex: /\b(?:_ENV|_G|_VERSION|arg)\b(?![:\w])/, token: "constant" },
           // Built-in functions - comprehensive list
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*(?:lpeg|lpeglabel)(?:(?:\\.|::|\\)(?:B|C|Carg|Cb|Cc|Cf|Cg|Cmt|Cp|Cs|Ct|P|R|S|T|V|locale|match|pcode|ptree|setmaxstack|type|utfR|version))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*(?:re|relabel)(?:(?:\\.|::|\\)(?:calcline|compile|find|gsub|match|updatelocale))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*coroutine(?:(?:\\.|::|\\)(?:close|create|isyieldable|resume|running|status|wrap|yield))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*debug(?:(?:\\.|::|\\)(?:debug|gethook|getinfo|getlocal|getmetatable|getregistry|getupvalue|getuservalue|setcstacklimit|sethook|setlocal|setmetatable|setupvalue|setuservalue|traceback|upvalueid|upvaluejoin))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*io(?:(?:\\.|::|\\)(?:close|flush|input|lines|open|output|popen|read|stderr|stdin|stdout|tmpfile|type|write))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*math(?:(?:\\.|::|\\)(?:abs|acos|asin|atan|atan2|ceil|cos|cosh|deg|exp|floor|fmod|frexp|huge|ldexp|log|log10|max|maxinteger|min|mininteger|modf|pi|pow|rad|random|randomseed|sin|sinh|sqrt|tan|tanh|tointeger|type|ult))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*os(?:(?:\\.|::|\\)(?:clock|date|difftime|execute|exit|getenv|remove|rename|setlocale|time|tmpname))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*package(?:(?:\\.|::|\\)(?:config|cpath|loaded|loadlib|path|preload|searchers|searchpath))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*string(?:(?:\\.|::|\\)(?:byte|char|dump|find|format|gmatch|gsub|len|lower|match|pack|packsize|rep|reverse|sub|unpack|upper))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*table(?:(?:\\.|::|\\)(?:concat|insert|move|pack|remove|sort|unpack))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*utf8(?:(?:\\.|::|\\)(?:char|charpattern|codepoint|codes|len|offset))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*yue(?:(?:\\.|::|\\)(?:check|dofile|file_exist|find_modulepath|format|insert_loader|is_ast|loadfile|loadstring|macro_env|options|p|pcall|read_file|to_ast|to_lua|traceback|version|yue_compiled))?\b/, token: 'function' },
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*(?:assert|collectgarbage|dofile|error|getmetatable|ipairs|lfs|load|loadfile|next|pairs|pcall|print|rawequal|rawget|rawlen|rawset|require|select|setmetatable|tonumber|tostring|type|warn|xpcall)\b/, token: 'function' },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*(?:lpeg|lpeglabel)(?:(?:\\.|::|\\)(?:B|C|Carg|Cb|Cc|Cf|Cg|Cmt|Cp|Cs|Ct|P|R|S|T|V|locale|match|pcode|ptree|setmaxstack|type|utfR|version))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*(?:re|relabel)(?:(?:\\.|::|\\)(?:calcline|compile|find|gsub|match|updatelocale))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*coroutine(?:(?:\\.|::|\\)(?:close|create|isyieldable|resume|running|status|wrap|yield))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*debug(?:(?:\\.|::|\\)(?:debug|gethook|getinfo|getlocal|getmetatable|getregistry|getupvalue|getuservalue|setcstacklimit|sethook|setlocal|setmetatable|setupvalue|setuservalue|traceback|upvalueid|upvaluejoin))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*io(?:(?:\\.|::|\\)(?:close|flush|input|lines|open|output|popen|read|stderr|stdin|stdout|tmpfile|type|write))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*math(?:(?:\\.|::|\\)(?:abs|acos|asin|atan|atan2|ceil|cos|cosh|deg|exp|floor|fmod|frexp|huge|ldexp|log|log10|max|maxinteger|min|mininteger|modf|pi|pow|rad|random|randomseed|sin|sinh|sqrt|tan|tanh|tointeger|type|ult))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*os(?:(?:\\.|::|\\)(?:clock|date|difftime|execute|exit|getenv|remove|rename|setlocale|time|tmpname))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*package(?:(?:\\.|::|\\)(?:config|cpath|loaded|loadlib|path|preload|searchers|searchpath))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*string(?:(?:\\.|::|\\)(?:byte|char|dump|find|format|gmatch|gsub|len|lower|match|pack|packsize|rep|reverse|sub|unpack|upper))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*table(?:(?:\\.|::|\\)(?:concat|insert|move|pack|remove|sort|unpack))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*utf8(?:(?:\\.|::|\\)(?:char|charpattern|codepoint|codes|len|offset))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*yue(?:(?:\\.|::|\\)(?:check|dofile|file_exist|find_modulepath|format|insert_loader|is_ast|loadfile|loadstring|macro_env|options|p|pcall|read_file|to_ast|to_lua|traceback|version|yue_compiled))?\b/,
+            token: "function",
+          },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*(?:assert|collectgarbage|dofile|error|getmetatable|ipairs|lfs|load|loadfile|next|pairs|pcall|print|rawequal|rawget|rawlen|rawset|require|select|setmetatable|tonumber|tostring|type|warn|xpcall)\b/,
+            token: "function",
+          },
           // pl.* library functions (penlight)
-          { regex: /\b(?:_G(?:\\.|:|::|\\))*pl\.(?:Date|List|Map|MultiMap|OrderedMap|Set|app|array2d|class|compat|comprehension|config|data|dir|file|func|input|lapp|lexer|luabalanced|operator|path|permute|pretty|seq|sip|strict|stringio|stringx|tablex|template|test|text|types|url|utils|xml)(?:(?:\\.|::|\\)\w+)?\b/, token: 'function' },
+          {
+            regex:
+              /\b(?:_G(?:\\.|:|::|\\))*pl\.(?:Date|List|Map|MultiMap|OrderedMap|Set|app|array2d|class|compat|comprehension|config|data|dir|file|func|input|lapp|lexer|luabalanced|operator|path|permute|pretty|seq|sip|strict|stringio|stringx|tablex|template|test|text|types|url|utils|xml)(?:(?:\\.|::|\\)\w+)?\b/,
+            token: "function",
+          },
           // Arrow functions: (params) => or <= name
-          { regex: /\([^)]*\)\s*[=-]>/, token: 'operator' },
-          { regex: /\([^)]*\)?\s*<[=-]\s*(?=[a-zA-Z_])/, token: 'operator' },
+          { regex: /\([^)]*\)\s*[=-]>/, token: "operator" },
+          { regex: /\([^)]*\)?\s*<[=-]\s*(?=[a-zA-Z_])/, token: "operator" },
           // new keyword before arrow function
-          { regex: /\bnew\b(?=:\s*\([^)]*\)?\s*[=-]>)/, token: 'variable' },
+          { regex: /\bnew\b(?=:\s*\([^)]*\)?\s*[=-]>)/, token: "variable" },
           // Brackets and delimiters
-          { regex: /[()\[\]{}]/, token: 'bracket' },
-          { regex: /\.|::|\\/, token: 'operator' },
+          { regex: /[()\[\]{}]/, token: "bracket" },
+          { regex: /\.|::|\\/, token: "operator" },
           // Variable names (with dot notation support)
-          { regex: /[a-zA-Z_$][\w$]*(?:(?:\.|::|\\)[a-zA-Z_$][\w$]*)*/, token: 'variable' }
+          {
+            regex: /[a-zA-Z_$][\w$]*(?:(?:\.|::|\\)[a-zA-Z_$][\w$]*)*/,
+            token: "variable",
+          },
         ],
         commentBlock: [
-          { regex: /.*?\]\]/, token: 'comment', pop: true },
-          { regex: /@\w*/, token: 'typeName' },
-          { regex: /.*/, token: 'comment' }
+          { regex: /.*?\]\]/, token: "comment", pop: true },
+          { regex: /@\w*/, token: "typeName" },
+          { regex: /.*/, token: "comment" },
         ],
         luaString: [
           // Match closing ]=] where number of = matches opening
           // This is a simplified version - matches ]=] with 0 or more =
-          { regex: /\](=*)\]/, token: 'string', pop: true },
-          { regex: /.*/, token: 'string' }
+          { regex: /\](=*)\]/, token: "string", pop: true },
+          { regex: /.*/, token: "string" },
         ],
         doubleString: [
-          { regex: /"/, token: 'string', pop: true },
-          { regex: /\\[abfnrtvz\\'"]/, token: 'constant' },
-          { regex: /\\\d{1,3}/, token: 'constant' },
-          { regex: /\\x[0-9a-fA-F]{2}/, token: 'constant' },
-          { regex: /\\u\{[0-9a-fA-F]+\}/, token: 'constant' },
-          { regex: /\\\./, token: 'invalid' },
-          { regex: /#\{/, token: 'operator', push: 'interpolation' },
-          { regex: /%[%aAcdeEfgiopsuxX]/, token: 'constant' },
-          { regex: /[^"\\#%]+/, token: 'string' }
+          { regex: /"/, token: "string", pop: true },
+          { regex: /\\[abfnrtvz\\'"]/, token: "constant" },
+          { regex: /\\\d{1,3}/, token: "constant" },
+          { regex: /\\x[0-9a-fA-F]{2}/, token: "constant" },
+          { regex: /\\u\{[0-9a-fA-F]+\}/, token: "constant" },
+          { regex: /\\\./, token: "invalid" },
+          { regex: /#\{/, token: "operator", push: "interpolation" },
+          { regex: /%[%aAcdeEfgiopsuxX]/, token: "constant" },
+          { regex: /[^"\\#%]+/, token: "string" },
         ],
         singleString: [
-          { regex: /'/, token: 'string', pop: true },
-          { regex: /\\[abfnrtvz\\']/, token: 'string' },
-          { regex: /\\\d{1,3}/, token: 'string' },
-          { regex: /\\x[0-9a-fA-F]{2}/, token: 'string' },
-          { regex: /\\u\{[0-9a-fA-F]+\}/, token: 'string' },
-          { regex: /\\\./, token: 'invalid' },
-          { regex: /%[%aAcdeEfgiopsuxX]/, token: 'constant' },
-          { regex: /[^'\\%]+/, token: 'string' }
+          { regex: /'/, token: "string", pop: true },
+          { regex: /\\[abfnrtvz\\']/, token: "string" },
+          { regex: /\\\d{1,3}/, token: "string" },
+          { regex: /\\x[0-9a-fA-F]{2}/, token: "string" },
+          { regex: /\\u\{[0-9a-fA-F]+\}/, token: "string" },
+          { regex: /\\\./, token: "invalid" },
+          { regex: /%[%aAcdeEfgiopsuxX]/, token: "constant" },
+          { regex: /[^'\\%]+/, token: "string" },
         ],
         interpolation: [
-          { regex: /\}/, token: 'operator', pop: true },
-          { regex: /\{/, token: 'operator', push: 'interpolation' },
-          { regex: /"(?:[^\\"]|\\.)*"?/, token: 'string' },
-          { regex: /'(?:[^\\']|\\.)*'?/, token: 'string' },
-          { regex: /\b(?:import|as|from|export|macro|local|global|close|const|class|extends|using|if|then|else|elseif|until|unless|switch|when|with|do|for|while|repeat|return|continue|break|try|catch|goto|or|and|in|not|true|false|nil)\b/, token: 'keyword' },
-          { regex: /\b[A-Z]\w*\b/, token: 'typeName' },
-          { regex: /[a-zA-Z_$][\w$]*/, token: 'variable' },
-          { regex: /(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?/i, token: 'number' },
-          { regex: /[+\-/*=<>!]=?|[~^|&%]/, token: 'operator' },
-          { regex: /[()\[\]{}]/, token: 'bracket' },
-          { regex: /[^}]/, token: 'variable' }
+          { regex: /\}/, token: "operator", pop: true },
+          { regex: /\{/, token: "operator", push: "interpolation" },
+          { regex: /"(?:[^\\"]|\\.)*"?/, token: "string" },
+          { regex: /'(?:[^\\']|\\.)*'?/, token: "string" },
+          {
+            regex:
+              /\b(?:import|as|from|export|macro|local|global|close|const|class|extends|using|if|then|else|elseif|until|unless|switch|when|with|do|for|while|repeat|return|continue|break|try|catch|goto|or|and|in|not|true|false|nil)\b/,
+            token: "keyword",
+          },
+          { regex: /\b[A-Z]\w*\b/, token: "typeName" },
+          { regex: /[a-zA-Z_$][\w$]*/, token: "variable" },
+          { regex: /(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?/i, token: "number" },
+          { regex: /[+\-/*=<>!]=?|[~^|&%]/, token: "operator" },
+          { regex: /[()\[\]{}]/, token: "bracket" },
+          { regex: /[^}]/, token: "variable" },
         ],
         languageData: {
-          name: 'yuescript'
-        }
-      })
+          name: "yuescript",
+        },
+      });
 
-      this.readOnlyCompartment = new Compartment()
-      this.themeCompartment = new Compartment()
-      this.highlightCompartment = new Compartment()
+      this.readOnlyCompartment = new Compartment();
+      this.themeCompartment = new Compartment();
+      this.highlightCompartment = new Compartment();
       const updateListener = EditorView.updateListener.of((update) => {
         if (!update.docChanged) {
-          return
+          return;
         }
-        const nextCode = update.state.doc.toString()
-        this.code = nextCode
-        this.codeChanged(nextCode)
-      })
+        const nextCode = update.state.doc.toString();
+        this.code = nextCode;
+        this.codeChanged(nextCode);
+      });
 
-      const isDark = this.isDarkTheme()
+      const isDark = this.isDarkTheme();
 
       const state = EditorState.create({
         doc: initialCode,
@@ -471,84 +581,88 @@ export default {
           history(),
           keymap.of([...defaultKeymap, ...historyKeymap, indentWithTab]),
           StreamLanguage.define(yuescriptMode),
-          indentUnit.of('  '),
+          indentUnit.of("  "),
           this.readOnlyCompartment.of(EditorState.readOnly.of(this.readonly)),
           this.highlightCompartment.of(
             syntaxHighlighting(
               isDark ? darkPlusHighlightStyle : lightPlusHighlightStyle,
-              { fallback: true }
-            )
+              { fallback: true },
+            ),
           ),
           updateListener,
-          this.themeCompartment.of(isDark ? darkPlusTheme : lightPlusTheme)
-        ]
-      })
+          this.themeCompartment.of(isDark ? darkPlusTheme : lightPlusTheme),
+        ],
+      });
 
       this.editorView = new EditorView({
         state,
-        parent: this.$refs.codeEditor
-      })
+        parent: this.$refs.codeEditor,
+      });
     },
     refreshEditorTheme() {
-      if (!this.editorView || !this.themeCompartment || !this.highlightCompartment) {
-        return
+      if (
+        !this.editorView ||
+        !this.themeCompartment ||
+        !this.highlightCompartment
+      ) {
+        return;
       }
-      const isDark = this.isDarkTheme()
+      const isDark = this.isDarkTheme();
       this.editorView.dispatch({
         effects: [
           this.themeCompartment.reconfigure(
-            isDark ? darkPlusTheme : lightPlusTheme
+            isDark ? darkPlusTheme : lightPlusTheme,
           ),
           this.highlightCompartment.reconfigure(
             syntaxHighlighting(
               isDark ? darkPlusHighlightStyle : lightPlusHighlightStyle,
-              { fallback: true }
-            )
-          )
-        ]
-      })
+              { fallback: true },
+            ),
+          ),
+        ],
+      });
     },
     refreshEditorReadOnly() {
       if (!this.editorView || !this.readOnlyCompartment) {
-        return
+        return;
       }
       this.editorView.dispatch({
         effects: this.readOnlyCompartment.reconfigure(
-          EditorState.readOnly.of(this.readonly)
-        )
-      })
+          EditorState.readOnly.of(this.readonly),
+        ),
+      });
     },
     runCode() {
-      if (window.yue && this.compiled !== '') {
-        let res = ''
+      if (window.yue && this.compiled !== "") {
+        let res = "";
         try {
-          res = window.yue.exec(this.code)
+          res = window.yue.exec(this.code);
         } catch (err) {
-          res = err
+          res = err;
         }
-        this.result = res
+        this.result = res;
       }
     },
     codeChanged(text) {
       if (window.yue) {
         let res = [
-          '',
-          'compiler error, and please help opening an issue for this. Thanks a lot!'
-        ]
+          "",
+          "compiler error, and please help opening an issue for this. Thanks a lot!",
+        ];
         try {
-          res = window.yue.tolua(text, true, !this.displayonly, true)
-          if (res[0] !== '') {
-            this.compiled = res[0]
+          res = window.yue.tolua(text, true, !this.displayonly, true);
+          if (res[0] !== "") {
+            this.compiled = res[0];
           } else {
-            this.compiled = res[1]
+            this.compiled = res[1];
           }
         } catch (error) {
-          this.compiled = res[1]
+          this.compiled = res[1];
         }
       }
-    }
-  }
-}
+    },
+  },
+};
 </script>
 
 <style scoped>
diff --git a/doc/docs/.vitepress/theme/components/YueDisplay.vue b/doc/docs/.vitepress/theme/components/YueDisplay.vue
index 507ace0..b270f21 100755
--- a/doc/docs/.vitepress/theme/components/YueDisplay.vue
+++ b/doc/docs/.vitepress/theme/components/YueDisplay.vue
@@ -1,7 +1,7 @@
 <template>
   <div>
     <button class="button" @click="compile()">Compile</button>
-    <div style="display: none;">
+    <div style="display: none">
       <slot></slot>
     </div>
   </div>
@@ -11,14 +11,16 @@
 export default {
   methods: {
     compile() {
-      const node = this.$el.children[1]
-      const pre = node.querySelector('pre')
-      const codeNode = pre?.querySelector('code') || pre || node
-      const code = (codeNode?.textContent || '').replace(/\r\n?/g, '\n')
-      window.dispatchEvent(new CustomEvent('yue:open-compiler', { detail: code }))
-    }
-  }
-}
+      const node = this.$el.children[1];
+      const pre = node.querySelector("pre");
+      const codeNode = pre?.querySelector("code") || pre || node;
+      const code = (codeNode?.textContent || "").replace(/\r\n?/g, "\n");
+      window.dispatchEvent(
+        new CustomEvent("yue:open-compiler", { detail: code }),
+      );
+    },
+  },
+};
 </script>
 
 <style scoped>
diff --git a/doc/docs/.vitepress/theme/custom.css b/doc/docs/.vitepress/theme/custom.css
index 3cf51d7..4050784 100644
--- a/doc/docs/.vitepress/theme/custom.css
+++ b/doc/docs/.vitepress/theme/custom.css
@@ -1,19 +1,21 @@
-@import '@fontsource/merriweather/400.css';
-@import '@fontsource/merriweather/700.css';
-@import '@fontsource/merriweather/900.css';
-@import '@fontsource/merriweather/400-italic.css';
-@import '@fontsource/merriweather/700-italic.css';
-@import '@fontsource/merriweather/900-italic.css';
+@import "@fontsource/merriweather/400.css";
+@import "@fontsource/merriweather/700.css";
+@import "@fontsource/merriweather/900.css";
+@import "@fontsource/merriweather/400-italic.css";
+@import "@fontsource/merriweather/700-italic.css";
+@import "@fontsource/merriweather/900-italic.css";
 
-@import '@fontsource/noto-serif-sc/400.css';
-@import '@fontsource/noto-serif-sc/700.css';
-@import '@fontsource/noto-serif-sc/900.css';
+@import "@fontsource/noto-serif-sc/400.css";
+@import "@fontsource/noto-serif-sc/700.css";
+@import "@fontsource/noto-serif-sc/900.css";
 
 :root {
   /* --- TYPOGRAPHY --- */
   /* Keep standard sans-serif for body text for readability */
   --vp-font-family-base: system-ui, sans-serif;
-  --vp-font-family-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  --vp-font-family-mono:
+    ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono",
+    "Courier New", monospace;
 
   /* --- BRAND COLORS (Original Moon Gold) --- */
   --vp-c-brand-1: #b4ac8f;
@@ -27,11 +29,11 @@
 
   /* --- LIGHT MODE THEME --- */
   /* A warmer, "creamy" paper feel instead of harsh white */
-  --vp-c-bg: #FDFBF7;
-  --vp-c-bg-soft: #F7F5F0;
+  --vp-c-bg: #fdfbf7;
+  --vp-c-bg-soft: #f7f5f0;
+
   /* Slightly darker for sidebars */
-  --vp-c-bg-alt: #F0EDE5;
-  /* For code blocks/inputs */
+  --vp-c-bg-alt: #f0ede5;
 
   /* Text Colors: Deep Navy instead of pure black for softer contrast */
   --vp-c-text-1: #1a202c;
@@ -44,6 +46,7 @@
     width: 450px !important;
   }
 }
+
 .VPHero :deep(.image-src) {
   max-width: 450px;
   max-height: 450px;
@@ -52,20 +55,20 @@
 /* --- DARK MODE THEME (Midnight Blue) --- */
 .dark {
   /* Deep Midnight Blue background (replaces standard grey) */
-  --vp-c-bg: #0B0E14;
+  --vp-c-bg: #0b0e14;
   --vp-c-bg-soft: #131722;
+
   /* Sidebar/Nav */
-  --vp-c-bg-alt: #1A1F2E;
-  /* Code blocks/inputs */
+  --vp-c-bg-alt: #1a1f2e;
 
   /* Text Colors: Moonlight Silver */
-  --vp-c-text-1: #E2E8F0;
-  --vp-c-text-2: #94A3B8;
+  --vp-c-text-1: #e2e8f0;
+  --vp-c-text-2: #94a3b8;
 
   /* Adjust border colors to blend with blue, not grey */
-  --vp-c-border: #1E293B;
-  --vp-c-divider: #1E293B;
-  --vp-c-gutter: #1E293B;
+  --vp-c-border: #1e293b;
+  --vp-c-divider: #1e293b;
+  --vp-c-gutter: #1e293b;
 }
 
 /* --- HEADINGS: Apply the Serif Font --- */
@@ -78,16 +81,19 @@ h6,
 .VPFeature .title,
 .VPHero .name,
 .VPNavBarTitle .title {
-  font-family: 'Merriweather', 'Noto Serif SC', serif !important;
+  font-family: "Merriweather", "Noto Serif SC", serif !important;
   letter-spacing: -0.02em;
   /* Tighter tracking looks more professional on serifs */
 }
 
+.VPNavBarTitle .title {
+  font-size: 1.1rem;
+}
+
 /* Make the Hero Title (YueScript) feel more "Editorial" */
 .VPHero .name {
   font-weight: 900 !important;
   color: var(--vp-c-brand-1);
-  /* Optional: Adds a subtle glow in dark mode */
   text-shadow: 0 0 20px rgba(180, 172, 143, 0.2);
 }
 
@@ -103,7 +109,6 @@ h6,
   background-color: var(--vp-c-brand-1) !important;
 }
 
-
 /* Prism theme for YueCompiler output (shikijs/themes light-plus & dark-plus) */
 .code-output,
 .code-output code {
@@ -124,7 +129,7 @@ h6,
 }
 
 .code-output .token.keyword {
-  color: #AF00DB;
+  color: #af00db;
 }
 
 .code-output .token.operator,
@@ -171,7 +176,7 @@ h6,
 }
 
 .dark .code-output .token.keyword {
-  color: #C586C0;
+  color: #c586c0;
 }
 
 .dark .code-output .token.operator,
@@ -215,5 +220,5 @@ h6,
 /* --- CODE BLOCKS --- */
 /* Slight adjustment to code block background to fit the midnight theme */
 .dark .vp-code-group .tabs label {
-  background-color: #1A1F2E;
+  background-color: #1a1f2e;
 }
\ No newline at end of file
diff --git a/doc/docs/.vitepress/theme/index.ts b/doc/docs/.vitepress/theme/index.ts
index 0ee45fe..70145d5 100644
--- a/doc/docs/.vitepress/theme/index.ts
+++ b/doc/docs/.vitepress/theme/index.ts
@@ -1,28 +1,28 @@
-import DefaultTheme from 'vitepress/theme'
-import type { Theme } from 'vitepress'
-import { h } from 'vue'
-import './custom.css'
+import DefaultTheme from "vitepress/theme";
+import type { Theme } from "vitepress";
+import { h } from "vue";
+import "./custom.css";
 
 // @ts-ignore
-import CompilerModal from './components/CompilerModal.vue'
+import CompilerModal from "./components/CompilerModal.vue";
 // @ts-ignore
-import HomeFooter from './components/HomeFooter.vue'
+import HomeFooter from "./components/HomeFooter.vue";
 // @ts-ignore
-import YueCompiler from './components/YueCompiler.vue'
+import YueCompiler from "./components/YueCompiler.vue";
 // @ts-ignore
-import YueDisplay from './components/YueDisplay.vue'
+import YueDisplay from "./components/YueDisplay.vue";
 
 const theme: Theme = {
   extends: DefaultTheme,
   Layout: () =>
     h(DefaultTheme.Layout, null, {
-      'layout-bottom': () => [h(HomeFooter), h(CompilerModal)]
+      "layout-bottom": () => [h(HomeFooter), h(CompilerModal)],
     }),
   enhanceApp({ app }) {
-    app.component('CompilerModal', CompilerModal)
-    app.component('YueCompiler', YueCompiler)
-    app.component('YueDisplay', YueDisplay)
-  }
-}
+    app.component("CompilerModal", CompilerModal);
+    app.component("YueCompiler", YueCompiler);
+    app.component("YueDisplay", YueDisplay);
+  },
+};
 
-export default theme
+export default theme;
diff --git a/doc/docs/de/doc/advanced/do.md b/doc/docs/de/doc/advanced/do.md
index 6f81f9d..265a5ba 100644
--- a/doc/docs/de/doc/advanced/do.md
+++ b/doc/docs/de/doc/advanced/do.md
@@ -8,6 +8,7 @@ do
   print var
 print var -- nil hier
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ counter = do
 print counter!
 print counter!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -53,6 +55,7 @@ tbl = {
     1234
 }
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/advanced/line-decorators.md b/doc/docs/de/doc/advanced/line-decorators.md
index dd26925..dbeaeb5 100644
--- a/doc/docs/de/doc/advanced/line-decorators.md
+++ b/doc/docs/de/doc/advanced/line-decorators.md
@@ -5,6 +5,7 @@ Zur Vereinfachung können `for`-Schleifen und `if`-Anweisungen auf einzelne Anwe
 ```yuescript
 print "Hallo Welt" if name == "Rob"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -18,6 +19,7 @@ Und mit einfachen Schleifen:
 ```yuescript
 print "Element: ", item for item in *items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +35,7 @@ game\update! while game\isRunning!
 
 reader\parse_line! until reader\eof!
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/advanced/macro.md b/doc/docs/de/doc/advanced/macro.md
index a3e155a..a030aea 100644
--- a/doc/docs/de/doc/advanced/macro.md
+++ b/doc/docs/de/doc/advanced/macro.md
@@ -32,6 +32,7 @@ macro and = (...) -> "#{ table.concat {...}, ' and ' }"
 if $and f1!, f2!, f3!
   print "OK"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -94,6 +95,7 @@ if cond then
 end
 ]==]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -142,6 +144,7 @@ import "utils" as {
 }
 [1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
 ```
+
 <YueDisplay>
 
 ```yue
@@ -172,6 +175,7 @@ Es gibt einige eingebaute Makros, aber du kannst sie überschreiben, indem du Ma
 print $FILE -- String des aktuellen Modulnamens
 print $LINE -- gibt 2 aus
 ```
+
 <YueDisplay>
 
 ```yue
@@ -238,6 +242,7 @@ macro printNumAndStr = (num `Num, str `String) -> |
 
 $printNumAndStr 123, "hallo"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -262,6 +267,7 @@ macro printNumAndStr = (num, str) ->
 
 $printNumAndStr 123, "hallo"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/advanced/module.md b/doc/docs/de/doc/advanced/module.md
index bdc5d86..f20deec 100644
--- a/doc/docs/de/doc/advanced/module.md
+++ b/doc/docs/de/doc/advanced/module.md
@@ -28,6 +28,7 @@ do
   import "lpeg" as :C, :Ct, :Cmt
   import "export" as {one, two, Something:{umm:{ch}}}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -67,6 +68,7 @@ do
   import table.concat
   print concat ["a", tostring 1]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -98,6 +100,7 @@ do
   print FLAG
   FLAG = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -140,6 +143,7 @@ export y = ->
 export class Something
   umm: "cool"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -166,6 +170,7 @@ Benannter Export mit Destructuring.
 export :loadstring, to_lua: tolua = yue
 export {itemA: {:fieldA = 'default'}} = tb
 ```
+
 <YueDisplay>
 
 ```yue
@@ -182,6 +187,7 @@ export.itemA = tb
 export.<index> = items
 export["a-b-c"] = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -208,6 +214,7 @@ else
 export with tmp
   j = 2000
 ```
+
 <YueDisplay>
 
 ```yue
@@ -234,6 +241,7 @@ export default ->
   print "hallo"
   123
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/advanced/try.md b/doc/docs/de/doc/advanced/try.md
index 4550e92..2505967 100644
--- a/doc/docs/de/doc/advanced/try.md
+++ b/doc/docs/de/doc/advanced/try.md
@@ -29,6 +29,7 @@ catch err
     print yue.traceback err
   print result
 ```
+
 <YueDisplay>
 
 ```yue
@@ -82,6 +83,7 @@ catch e
   print e
   e
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/assignment/assignment.md b/doc/docs/de/doc/assignment/assignment.md
index b74501f..ed56e46 100644
--- a/doc/docs/de/doc/assignment/assignment.md
+++ b/doc/docs/de/doc/assignment/assignment.md
@@ -7,6 +7,7 @@ hello = "world"
 a, b, c = 1, 2, 3
 hello = 123 -- nutzt die bestehende Variable
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ x %= 10
 s ..= "world" -- legt eine neue lokale Variable an, wenn sie nicht existiert
 arg or= "default value"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -54,6 +56,7 @@ Mit verketteten Zuweisungen kannst du mehrere Variablen auf denselben Wert setze
 a = b = c = d = e = 0
 x = y = z = f!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -81,6 +84,7 @@ do
   a = 1
   B = 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -120,6 +124,7 @@ do
   B = 2
   local Temp = "a local value"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/assignment/destructuring-assignment.md b/doc/docs/de/doc/assignment/destructuring-assignment.md
index 0a08e22..5582468 100644
--- a/doc/docs/de/doc/assignment/destructuring-assignment.md
+++ b/doc/docs/de/doc/assignment/destructuring-assignment.md
@@ -12,6 +12,7 @@ thing = [1, 2]
 [a, b] = thing
 print a, b
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,6 +38,7 @@ print hello, the_day
 
 :day = obj -- einfache Destructuring-Zuweisung ohne Klammern ist ok
 ```
+
 <YueDisplay>
 
 ```yue
@@ -68,6 +70,7 @@ obj2 = {
 {numbers: [first, second], properties: {color: color}} = obj2
 print first, second, color
 ```
+
 <YueDisplay>
 
 ```yue
@@ -95,6 +98,7 @@ Wenn die Destructuring-Anweisung kompliziert ist, kannst du sie gerne auf mehrer
   }
 } = obj2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -113,6 +117,7 @@ Es ist üblich, Werte aus einer Tabelle zu extrahieren und ihnen lokale Variable
 ```yuescript
 {:concat, :insert} = table
 ```
+
 <YueDisplay>
 
 ```yue
@@ -126,6 +131,7 @@ Das ist effektiv dasselbe wie `import`, aber du kannst Felder umbenennen, indem
 ```yuescript
 {:mix, :max, random: rand} = math
 ```
+
 <YueDisplay>
 
 ```yue
@@ -139,6 +145,7 @@ Du kannst Standardwerte beim Destructuring angeben, z. B.:
 ```yuescript
 {:name = "namenlos", :job = "arbeitlos"} = person
 ```
+
 <YueDisplay>
 
 ```yue
@@ -152,6 +159,7 @@ Du kannst `_` als Platzhalter verwenden, wenn du eine Listen-Destructuring-Zuwei
 ```yuescript
 [_, two, _, four] = items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -171,6 +179,7 @@ print first  -- gibt aus: erster
 print bulk   -- gibt aus: {"zweiter", "dritter", "vierter"}
 print last   -- gibt aus: letzter
 ```
+
 <YueDisplay>
 
 ```yue
@@ -195,6 +204,7 @@ Der Spread-Operator kann an unterschiedlichen Positionen verwendet werden, um un
 -- Alles außer den mittleren Elementen erfassen
 [first, ..._, last] = orders
 ```
+
 <YueDisplay>
 
 ```yue
@@ -223,6 +233,7 @@ tuples = [
 for [left, right] in *tuples
   print left, right
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/assignment/if-assignment.md b/doc/docs/de/doc/assignment/if-assignment.md
index 884a8d2..21bc8be 100644
--- a/doc/docs/de/doc/assignment/if-assignment.md
+++ b/doc/docs/de/doc/assignment/if-assignment.md
@@ -6,6 +6,7 @@
 if user := database.find_user "moon"
   print user.name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -23,6 +24,7 @@ elseif world := os.getenv "world"
 else
   print "nichts :("
 ```
+
 <YueDisplay>
 
 ```yue
@@ -43,6 +45,7 @@ if success, result := pcall -> "Ergebnis ohne Probleme erhalten"
   print result -- Variable result ist im Scope
 print "OK"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +65,7 @@ while byte := stream\read_one!
   -- mit dem Byte etwas anfangen
   print byte
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/assignment/the-using-clause-controlling-destructive-assignment.md b/doc/docs/de/doc/assignment/the-using-clause-controlling-destructive-assignment.md
index 63bf016..ce8a45c 100644
--- a/doc/docs/de/doc/assignment/the-using-clause-controlling-destructive-assignment.md
+++ b/doc/docs/de/doc/assignment/the-using-clause-controlling-destructive-assignment.md
@@ -17,6 +17,7 @@ my_func!
 
 print i -- wird 0 ausgeben
 ```
+
 <YueDisplay>
 
 ```yue
@@ -52,6 +53,7 @@ my_func = (using nil) ->
 my_func!
 print i -- gibt 100 aus, i bleibt unverändert
 ```
+
 <YueDisplay>
 
 ```yue
@@ -80,6 +82,7 @@ my_func = (add using k, i) ->
 my_func(22)
 print i, k -- diese wurden aktualisiert
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/assignment/varargs-assignment.md b/doc/docs/de/doc/assignment/varargs-assignment.md
index b211a8a..96927fa 100644
--- a/doc/docs/de/doc/assignment/varargs-assignment.md
+++ b/doc/docs/de/doc/assignment/varargs-assignment.md
@@ -10,6 +10,7 @@ count = select '#', ...
 first = select 1, ...
 print ok, count, first
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/control-flow/conditionals.md b/doc/docs/de/doc/control-flow/conditionals.md
index d20e6e3..56663d1 100644
--- a/doc/docs/de/doc/control-flow/conditionals.md
+++ b/doc/docs/de/doc/control-flow/conditionals.md
@@ -7,6 +7,7 @@ if have_coins
 else
   print "Keine Münzen"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -25,6 +26,7 @@ Eine Kurzsyntax für einzelne Anweisungen kann ebenfalls verwendet werden:
 have_coins = false
 if have_coins then print "Münzen erhalten" else print "Keine Münzen"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -40,6 +42,7 @@ Da `if`-Anweisungen als Ausdrücke verwendet werden können, kann man das auch s
 have_coins = false
 print if have_coins then "Münzen erhalten" else "Keine Münzen"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -65,6 +68,7 @@ else
 
 print message -- gibt aus: Ich bin sehr groß
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,6 +94,7 @@ Das Gegenteil von `if` ist `unless`:
 unless os.date("%A") == "Monday"
   print "Es ist nicht Montag!"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -102,6 +107,7 @@ unless os.date("%A") == "Monday"
 ```yuescript
 print "You're lucky!" unless math.random! > 0.1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -123,6 +129,7 @@ if a in [1, 3, 5, 7]
 if a in list
   print "Prüfen, ob `a` in einer Liste ist"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/control-flow/continue.md b/doc/docs/de/doc/control-flow/continue.md
index a6210d4..4b5ccdc 100644
--- a/doc/docs/de/doc/control-flow/continue.md
+++ b/doc/docs/de/doc/control-flow/continue.md
@@ -9,6 +9,7 @@ while i < 10
   continue if i % 2 == 0
   print i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ odds = for x in *my_numbers
   continue if x % 2 == 1
   x
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/control-flow/for-loop.md b/doc/docs/de/doc/control-flow/for-loop.md
index 3bf63d4..827d983 100644
--- a/doc/docs/de/doc/control-flow/for-loop.md
+++ b/doc/docs/de/doc/control-flow/for-loop.md
@@ -12,6 +12,7 @@ for k = 1, 15, 2 -- ein optionaler Schritt
 for key, value in pairs object
   print key, value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +34,7 @@ Die Slicing- und **\***-Operatoren können verwendet werden, genau wie bei Compr
 for item in *items[2, 4]
   print item
 ```
+
 <YueDisplay>
 
 ```yue
@@ -49,6 +51,7 @@ for item in *items do print item
 
 for j = 1, 10, 3 do print j
 ```
+
 <YueDisplay>
 
 ```yue
@@ -70,6 +73,7 @@ doubled_evens = for i = 1, 20
   else
     i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,6 +94,7 @@ Beispiel: die erste Zahl größer als 10 finden:
 first_large = for n in *numbers
   break n if n > 10
 ```
+
 <YueDisplay>
 
 ```yue
@@ -112,6 +117,7 @@ func_b = -> return for i = 1, 10 do i
 print func_a! -- gibt nil aus
 print func_b! -- gibt Tabellenobjekt aus
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/control-flow/switch.md b/doc/docs/de/doc/control-flow/switch.md
index 81e08bd..5e5107b 100644
--- a/doc/docs/de/doc/control-flow/switch.md
+++ b/doc/docs/de/doc/control-flow/switch.md
@@ -11,6 +11,7 @@ switch name := "Dan"
   else
     print "Ich kenne dich nicht mit dem Namen #{name}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -39,6 +40,7 @@ next_number = switch b
   else
     error "so hoch kann ich nicht zählen!"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +64,7 @@ msg = switch math.random(1, 5)
   when 2 then "Du hast fast Glück"
   else "nicht so viel Glück"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -87,6 +90,7 @@ switch math.random(1, 5) when 1
 else
   print "nicht so viel Glück"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -124,6 +128,7 @@ for item in *items
     when :width, :height
       print "Größe #{width}, #{height}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -154,6 +159,7 @@ switch item
   when {pos: {:x = 50, :y = 200}}
     print "Vec2 #{x}, #{y}" -- Tabellen-Destrukturierung greift trotzdem
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +187,7 @@ switch tb
   when [1, 2, b = 3] -- b hat einen Standardwert
     print "1, 2, #{b}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -206,6 +213,7 @@ switch tb
   else
     print "ungültig"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -231,6 +239,7 @@ switch tb
   else
     print "ungültig"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -257,6 +266,7 @@ switch tb
     ]
     print "getroffen", fourth
 ```
+
 <YueDisplay>
 
 ```yue
@@ -282,6 +292,7 @@ switch segments
     print "Ressource:", resource -- gibt aus: "logs"
     print "Aktion:", action -- gibt aus: "view"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/control-flow/while-loop.md b/doc/docs/de/doc/control-flow/while-loop.md
index a875bf9..6d9f089 100644
--- a/doc/docs/de/doc/control-flow/while-loop.md
+++ b/doc/docs/de/doc/control-flow/while-loop.md
@@ -10,6 +10,7 @@ while i > 0
 
 while running == true do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ until i == 0
 
 until running == false do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +58,7 @@ repeat
   i -= 1
 until i == 0
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/data-structures/comprehensions.md b/doc/docs/de/doc/data-structures/comprehensions.md
index 7e00c57..4d74e06 100644
--- a/doc/docs/de/doc/data-structures/comprehensions.md
+++ b/doc/docs/de/doc/data-structures/comprehensions.md
@@ -10,6 +10,7 @@ Das folgende Beispiel erstellt eine Kopie der `items`-Tabelle, aber mit verdoppe
 items = [ 1, 2, 3, 4 ]
 doubled = [item * 2 for i, item in ipairs items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ Die Elemente in der neuen Tabelle können mit einer `when`-Klausel eingeschränk
 ```yuescript
 slice = [item for i, item in ipairs items when i > 1 and i < 3]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,6 +39,7 @@ Da es üblich ist, über die Werte einer numerisch indizierten Tabelle zu iterie
 ```yuescript
 doubled = [item * 2 for item in *items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ data =
 flat = [...v for k,v in pairs data]
 -- flat ist jetzt [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -79,6 +83,7 @@ y_coords = [9, 2, 3]
 points = [ [x, y] for x in *x_coords \
 for y in *y_coords]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -96,6 +101,7 @@ Numerische `for`-Schleifen können ebenfalls in Comprehensions verwendet werden:
 ```yuescript
 evens = [i for i = 1, 100 when i % 2 == 0]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -119,6 +125,7 @@ thing = {
 
 thing_copy = {k, v for k, v in pairs thing}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -136,6 +143,7 @@ thing_copy = {k, v for k, v in pairs thing}
 ```yuescript
 no_color = {k, v for k, v in pairs thing when k != "color"}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -150,6 +158,7 @@ Der **\***-Operator wird ebenfalls unterstützt. Hier erstellen wir eine Nachsch
 numbers = [1, 2, 3, 4]
 sqrts = {i, math.sqrt i for i in *numbers}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -167,6 +176,7 @@ In diesem Beispiel konvertieren wir ein Array von Paaren in eine Tabelle, wobei
 tuples = [ ["hallo", "Welt"], ["foo", "bar"]]
 tbl = {unpack tuple for tuple in *tuples}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -185,6 +195,7 @@ Hier setzen wir die minimalen und maximalen Grenzen und nehmen alle Elemente mit
 ```yuescript
 slice = [item for item in *items[1, 5]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -198,6 +209,7 @@ Jedes der Slice-Argumente kann weggelassen werden, um einen sinnvollen Standard
 ```yuescript
 slice = [item for item in *items[2,]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -211,6 +223,7 @@ Wenn die Mindestgrenze weggelassen wird, ist sie standardmäßig 1. Hier geben w
 ```yuescript
 slice = [item for item in *items[,,2]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -225,6 +238,7 @@ Sowohl die Mindest- als auch die Maximalgrenze können negativ sein; dann werden
 -- die letzten 4 Elemente nehmen
 slice = [item for item in *items[-4,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -239,6 +253,7 @@ Die Schrittweite kann ebenfalls negativ sein, wodurch die Elemente in umgekehrte
 ```yuescript
 reverse_slice = [item for item in *items[-1,1,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -258,6 +273,7 @@ sub_list = items[2, 4]
 -- die letzten 4 Elemente nehmen
 last_four_items = items[-4, -1]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/data-structures/table-literals.md b/doc/docs/de/doc/data-structures/table-literals.md
index 46181d7..4b127d8 100644
--- a/doc/docs/de/doc/data-structures/table-literals.md
+++ b/doc/docs/de/doc/data-structures/table-literals.md
@@ -5,6 +5,7 @@ Wie in Lua werden Tabellen mit geschweiften Klammern definiert.
 ```yuescript
 some_values = [1, 2, 3, 4]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -22,6 +23,7 @@ some_values = {
   ["Lieblingsessen"]: "Reis"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ profile =
   shoe_size: 13,
   favorite_foods: ["Eis", "Donuts"]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -63,6 +66,7 @@ values = {
   occupation: "Verbrechensbekämpfung"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -83,6 +87,7 @@ my_function dance: "Tango", partner: "keiner"
 
 y = type: "Hund", legs: 4, tails: 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +106,7 @@ tbl = {
   end: "Hunger"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -121,6 +127,7 @@ person = { :hair, :height, shoe_size: 40 }
 
 print_table :hair, :height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -141,6 +148,7 @@ t = {
   "Hallo Welt": true
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -158,6 +166,7 @@ Lua-Tabellen haben einen Array-Teil und einen Hash-Teil, aber manchmal möchte m
 some_values = [1, 2, 3, 4]
 list_with_one_element = [1, ]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/functions/backcalls.md b/doc/docs/de/doc/functions/backcalls.md
index dbac86b..08b012d 100644
--- a/doc/docs/de/doc/functions/backcalls.md
+++ b/doc/docs/de/doc/functions/backcalls.md
@@ -6,6 +6,7 @@ Backcalls werden verwendet, um Callbacks zu entkoppeln (unnesting). Sie werden m
 x <- f
 print "hallo" .. x
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ Fat-Arrow-Funktionen sind ebenfalls verfügbar.
 <= f
 print @value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ Du kannst einen Platzhalter angeben, an welcher Stelle die Backcall-Funktion als
 (x) <- map _, [1, 2, 3]
 x * 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ result, msg = do
   check info
 print result, msg
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/functions/function-literals.md b/doc/docs/de/doc/functions/function-literals.md
index d3bfb11..1c9b00f 100644
--- a/doc/docs/de/doc/functions/function-literals.md
+++ b/doc/docs/de/doc/functions/function-literals.md
@@ -6,6 +6,7 @@ Alle Funktionen werden mit einem Funktionsausdruck erstellt. Eine einfache Funkt
 my_function = ->
 my_function() -- leere Funktion aufrufen
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ func_b = ->
   value = 100
   print "Der Wert:", value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ Wenn eine Funktion keine Argumente hat, kann sie mit dem `!`-Operator statt leer
 func_a!
 func_b()
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +59,7 @@ Funktionen mit Argumenten werden erstellt, indem der Pfeil von einer Argumentlis
 ```yuescript
 sum = (x, y) -> print "Summe", x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -72,6 +76,7 @@ print sum 10, 20
 
 a b c "a", "b", "c"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -88,6 +93,7 @@ Um Mehrdeutigkeiten beim Aufruf zu vermeiden, können die Argumente auch in Klam
 ```yuescript
 print "x:", sum(10, 20), "y:", sum(30, 40)
 ```
+
 <YueDisplay>
 
 ```yue
@@ -104,6 +110,7 @@ Funktionen wandeln die letzte Anweisung im Funktionskörper in ein `return` um.
 sum = (x, y) -> x + y
 print "Die Summe ist ", sum 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +125,7 @@ Wenn du explizit zurückgeben willst, verwende `return`:
 ```yuescript
 sum = (x, y) -> return x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -132,6 +140,7 @@ Wie in Lua können Funktionen mehrere Werte zurückgeben. Die letzte Anweisung m
 mystery = (x, y) -> x + y, x - y
 a, b = mystery 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -148,6 +157,7 @@ Da es in Lua üblich ist, beim Methodenaufruf ein Objekt als erstes Argument zu
 ```yuescript
 func = (num) => @value + num
 ```
+
 <YueDisplay>
 
 ```yue
@@ -165,6 +175,7 @@ my_function = (name = "etwas", height = 100) ->
   print "Hallo, ich bin", name
   print "Meine Größe ist", height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +192,7 @@ Der Ausdruck für den Standardwert wird im Funktionskörper in der Reihenfolge d
 some_args = (x = 100, y = x + 1000) ->
   print x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -202,6 +214,7 @@ b = x-10
 c = x -y
 d = x- z
 ```
+
 <YueDisplay>
 
 ```yue
@@ -223,6 +236,7 @@ Steht ein Leerzeichen zwischen Variable und String-Literal, verhält sich der Au
 x = func"hallo" + 100
 y = func "hallo" + 100
 ```
+
 <YueDisplay>
 
 ```yue
@@ -247,6 +261,7 @@ cool_func 1, 2,
   5, 6,
   7, 8
 ```
+
 <YueDisplay>
 
 ```yue
@@ -269,6 +284,7 @@ my_func 5, 6, 7,
     9, 1, 2,
   5, 4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -289,6 +305,7 @@ x = [
   8, 9, 10
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -309,6 +326,7 @@ y = [ my_func 1, 2, 3,
   5, 6, 7
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -335,6 +353,7 @@ if func 1, 2, 3,
   print "hallo"
   print "Ich bin innerhalb der if-Bedingung"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -357,8 +376,8 @@ if func 1, 2, 3,
 
 YueScript unterstützt jetzt Destructuring von Funktionsparametern, wenn das Argument ein Objekt ist. Es gibt zwei Formen von Destructuring-Tabellenliteralen:
 
-* **Geschweifte Klammern/Objektparameter**, die optionale Standardwerte erlauben, wenn Felder fehlen (z. B. `{:a, :b}`, `{a: a1 = 123}`).
-* **Unverpackte einfache Tabellensyntax**, die mit einer Sequenz aus Key-Value- oder Shorthand-Bindings beginnt und so lange läuft, bis ein anderer Ausdruck sie beendet (z. B. `:a, b: b1, :c`). Diese Form extrahiert mehrere Felder aus demselben Objekt.
+- **Geschweifte Klammern/Objektparameter**, die optionale Standardwerte erlauben, wenn Felder fehlen (z. B. `{:a, :b}`, `{a: a1 = 123}`).
+- **Unverpackte einfache Tabellensyntax**, die mit einer Sequenz aus Key-Value- oder Shorthand-Bindings beginnt und so lange läuft, bis ein anderer Ausdruck sie beendet (z. B. `:a, b: b1, :c`). Diese Form extrahiert mehrere Felder aus demselben Objekt.
 
 ```yuescript
 f1 = (:a, :b, :c) ->
@@ -372,6 +391,7 @@ f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
 arg1 = {a: 0}
 f2 arg1, arg2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -401,6 +421,7 @@ findFirstEven = (list): nil ->
         if sub % 2 == 0
           return sub
 ```
+
 <YueDisplay>
 
 ```yue
@@ -425,6 +446,7 @@ findFirstEven = (list) ->
           return sub
   nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -466,6 +488,7 @@ process = (...args) ->
 
 process 1, nil, 3, nil, 5
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/functions/function-stubs.md b/doc/docs/de/doc/functions/function-stubs.md
index 66b3ddb..cd4382a 100644
--- a/doc/docs/de/doc/functions/function-stubs.md
+++ b/doc/docs/de/doc/functions/function-stubs.md
@@ -24,6 +24,7 @@ run_callback my_object.write
 -- bindet das Objekt in eine neue Funktion ein
 run_callback my_object\write
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/getting-started/usage.md b/doc/docs/de/doc/getting-started/usage.md
index f3c9333..2c10406 100644
--- a/doc/docs/de/doc/getting-started/usage.md
+++ b/doc/docs/de/doc/getting-started/usage.md
@@ -4,49 +4,51 @@
 
 YueScript-Modul in Lua verwenden:
 
-* **Fall 1**
-
-        "your_yuescript_entry.yue" in Lua require'n.
-        ```Lua
-        require("yue")("your_yuescript_entry")
-        ```
-        Dieser Code funktioniert weiterhin, wenn du "your_yuescript_entry.yue" im gleichen Pfad zu "your_yuescript_entry.lua" kompilierst. In den restlichen YueScript-Dateien verwendest du einfach normales **require** oder **import**. Die Zeilennummern in Fehlermeldungen werden korrekt behandelt.
-
-* **Fall 2**
-
-        YueScript-Modul require'n und das Fehlermapping manuell umschreiben.
-
-        ```lua
-        local yue = require("yue")
-        yue.insert_loader()
-        local success, result = xpcall(function()
-          return require("yuescript_module_name")
-        end, function(err)
-          return yue.traceback(err)
-        end)
-        ```
-
-* **Fall 3**
-
-        Die YueScript-Compilerfunktion in Lua verwenden.
-
-        ```lua
-        local yue = require("yue")
-        local codes, err, globals = yue.to_lua([[
-          f = ->
-            print "Hallo Welt"
-          f!
-        ]],{
-          implicit_return_root = true,
-          reserve_line_number = true,
-          lint_global = true,
-          space_over_tab = false,
-          options = {
-            target = "5.4",
-            path = "/script"
-          }
-        })
-        ```
+- **Fall 1**
+
+  "your_yuescript_entry.yue" in Lua require'n.
+
+  ```Lua
+  require("yue")("your_yuescript_entry")
+  ```
+
+  Dieser Code funktioniert weiterhin, wenn du "your_yuescript_entry.yue" im gleichen Pfad zu "your_yuescript_entry.lua" kompilierst. In den restlichen YueScript-Dateien verwendest du einfach normales **require** oder **import**. Die Zeilennummern in Fehlermeldungen werden korrekt behandelt.
+
+- **Fall 2**
+
+  YueScript-Modul require'n und das Fehlermapping manuell umschreiben.
+
+  ```lua
+  local yue = require("yue")
+  yue.insert_loader()
+  local success, result = xpcall(function()
+    return require("yuescript_module_name")
+  end, function(err)
+    return yue.traceback(err)
+  end)
+  ```
+
+- **Fall 3**
+
+  Die YueScript-Compilerfunktion in Lua verwenden.
+
+  ```lua
+  local yue = require("yue")
+  local codes, err, globals = yue.to_lua([[
+    f = ->
+      print "Hallo Welt"
+    f!
+  ]],{
+    implicit_return_root = true,
+    reserve_line_number = true,
+    lint_global = true,
+    space_over_tab = false,
+    options = {
+      target = "5.4",
+      path = "/script"
+    }
+  })
+  ```
 
 ## YueScript-Tool
 
diff --git a/doc/docs/de/doc/language-basics/attributes.md b/doc/docs/de/doc/language-basics/attributes.md
index 0fa3654..8c37d82 100644
--- a/doc/docs/de/doc/language-basics/attributes.md
+++ b/doc/docs/de/doc/language-basics/attributes.md
@@ -6,6 +6,7 @@ Syntax-Unterstützung für Lua-5.4-Attribute. Du kannst weiterhin die Deklaratio
 const a = 123
 close _ = <close>: -> print "Außerhalb des Gültigkeitsbereichs."
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ Du kannst Destructuring mit als konstant markierten Variablen verwenden.
 const {:a, :b, c, d} = tb
 -- a = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ Du kannst auch eine globale Variable als `const` deklarieren.
 global const Constant = 123
 -- Constant = 1
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/language-basics/comment.md b/doc/docs/de/doc/language-basics/comment.md
index dec9bb0..0216162 100644
--- a/doc/docs/de/doc/language-basics/comment.md
+++ b/doc/docs/de/doc/language-basics/comment.md
@@ -12,6 +12,7 @@ Alles okay.
 
 func --[[Port]] 3000, --[[IP]] "192.168.1.1"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/language-basics/literals.md b/doc/docs/de/doc/language-basics/literals.md
index 55a5aaa..23e8582 100644
--- a/doc/docs/de/doc/language-basics/literals.md
+++ b/doc/docs/de/doc/language-basics/literals.md
@@ -12,6 +12,7 @@ some_string = "Hier ist ein String
 -- String-Interpolation gibt es nur in doppelt angeführten Strings.
 print "Ich bin mir zu #{math.random! * 100}% sicher."
 ```
+
 <YueDisplay>
 
 ```yue
@@ -34,6 +35,7 @@ integer = 1_000_000
 hex = 0xEF_BB_BF
 binary = 0B10011
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +57,7 @@ str = |
     - item1
     - #{expr}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -78,6 +81,7 @@ fn = ->
       bar: baz
   return str
 ```
+
 <YueDisplay>
 
 ```yue
@@ -99,6 +103,7 @@ str = |
   path: "C:\Program Files\App"
   note: 'He said: "#{Hello}!"'
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/language-basics/operator.md b/doc/docs/de/doc/language-basics/operator.md
index a7b8c5c..12143d5 100644
--- a/doc/docs/de/doc/language-basics/operator.md
+++ b/doc/docs/de/doc/language-basics/operator.md
@@ -1,11 +1,12 @@
 # Operatoren
 
-Alle binären und unären Operatoren von Lua sind verfügbar. Zusätzlich ist **!=** ein Alias für **~=**, und entweder **\** oder **::** kann für verkettete Funktionsaufrufe wie `tb\func!` oder `tb::func!` verwendet werden. Außerdem bietet YueScript einige spezielle Operatoren für ausdrucksstärkeren Code.
+Alle binären und unären Operatoren von Lua sind verfügbar. Zusätzlich ist **!=** ein Alias für **~=**, und entweder **\*\* oder **::\*\* kann für verkettete Funktionsaufrufe wie `tb\func!` oder `tb::func!` verwendet werden. Außerdem bietet YueScript einige spezielle Operatoren für ausdrucksstärkeren Code.
 
 ```yuescript
 tb\func! if tb ~= nil
 tb::func! if tb != nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -27,6 +28,7 @@ a = 5
 print 1 <= a <= 10
 -- Ausgabe: true
 ```
+
 <YueDisplay>
 
 ```yue
@@ -64,6 +66,7 @@ print v(1) > v(2) <= v(3)
   false
 ]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +104,7 @@ Der Operator **[] =** wird verwendet, um Werte an Tabellen anzuhängen.
 tab = []
 tab[] = "Wert"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +122,7 @@ tbB = [4, 5, 6]
 tbA[] = ...tbB
 -- tbA ist jetzt [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -149,6 +154,7 @@ a = {1, 2, 3, x: 1}
 b = {4, 5, y: 1}
 merge = {...a, ...b}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -179,6 +185,7 @@ last = data.items[#]
 second_last = data.items[#-1]
 data.items[#] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -212,6 +219,7 @@ print d.value
 
 close _ = <close>: -> print "Außerhalb des Gültigkeitsbereichs"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -245,6 +253,7 @@ print tb.value
 tb.<> = __index: {item: "hallo"}
 print tb.item
 ```
+
 <YueDisplay>
 
 ```yue
@@ -266,6 +275,7 @@ Destrukturiere Metatable mit Metamethoden-Schlüssel, der von **<>** umschlossen
 {item, :new, :<close>, <index>: getter} = tb
 print item, new, close, getter
 ```
+
 <YueDisplay>
 
 ```yue
@@ -293,6 +303,7 @@ with? io.open "test.txt", "w"
   \write "hello"
   \close!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -329,6 +340,7 @@ readFile "example.txt"
   |> render
   |> print
 ```
+
 <YueDisplay>
 
 ```yue
@@ -357,6 +369,7 @@ func a ?? {}
 
 a ??= false
 ```
+
 <YueDisplay>
 
 ```yue
@@ -414,6 +427,7 @@ tb =
       tb: { }
 
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/language-basics/whitespace.md b/doc/docs/de/doc/language-basics/whitespace.md
index 9d5889d..0915692 100644
--- a/doc/docs/de/doc/language-basics/whitespace.md
+++ b/doc/docs/de/doc/language-basics/whitespace.md
@@ -9,6 +9,7 @@ Eine Anweisung endet normalerweise an einem Zeilenumbruch. Du kannst auch ein Se
 ```yuescript
 a = 1; b = 2; print a + b
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ Rx.Observable
   \map (value) -> value .. '!'
   \subscribe print
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/objects/object-oriented-programming.md b/doc/docs/de/doc/objects/object-oriented-programming.md
index 1c116a3..706cfda 100644
--- a/doc/docs/de/doc/objects/object-oriented-programming.md
+++ b/doc/docs/de/doc/objects/object-oriented-programming.md
@@ -15,6 +15,7 @@ class Inventory
     else
       @items[name] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -46,6 +47,7 @@ inv = Inventory!
 inv\add_item "T-Shirt"
 inv\add_item "Hose"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -77,6 +79,7 @@ b\give_item "Hemd"
 -- gibt sowohl Hose als auch Hemd aus
 print item for item in *a.clothes
 ```
+
 <YueDisplay>
 
 ```yue
@@ -104,6 +107,7 @@ class Person
   new: =>
     @clothes = []
 ```
+
 <YueDisplay>
 
 ```yue
@@ -125,6 +129,7 @@ class BackPack extends Inventory
     if #@items > size then error "Rucksack ist voll"
     super name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -151,6 +156,7 @@ class Shelf
 -- gibt aus: Shelf wurde von Cupboard geerbt
 class Cupboard extends Shelf
 ```
+
 <YueDisplay>
 
 ```yue
@@ -189,6 +195,7 @@ class MyClass extends ParentClass
     -- super als Wert entspricht der Elternklasse:
     assert super == ParentClass
 ```
+
 <YueDisplay>
 
 ```yue
@@ -217,6 +224,7 @@ assert b.__class == BackPack
 
 print BackPack.size -- gibt 10 aus
 ```
+
 <YueDisplay>
 
 ```yue
@@ -247,6 +255,7 @@ Der Name der Klasse, wie sie deklariert wurde, wird im Feld `__name` gespeichert
 ```yuescript
 print BackPack.__name -- gibt Backpack aus
 ```
+
 <YueDisplay>
 
 ```yue
@@ -272,6 +281,7 @@ Things\some_func!
 -- Klassenvariablen in Instanzen nicht sichtbar
 assert Things().some_func == nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -300,6 +310,7 @@ Counter!
 
 print Counter.count -- gibt 2 aus
 ```
+
 <YueDisplay>
 
 ```yue
@@ -322,6 +333,7 @@ Die Aufrufsemantik von `@@` ist ähnlich wie bei `@`. Wenn du einen `@@`-Namen a
 ```yuescript
 @@hello 1,2,3,4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -340,6 +352,7 @@ Hier ist eine alternative Möglichkeit, eine Klassenvariable zu erstellen:
 class Things
   @class_var = "Hallo Welt"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -361,6 +374,7 @@ class MoreThings
   some_method: =>
     log "Hallo Welt: " .. secret
 ```
+
 <YueDisplay>
 
 ```yue
@@ -384,6 +398,7 @@ Wenn sie alleine verwendet werden, sind sie Aliase für `self` und `self.__class
 assert @ == self
 assert @@ == self.__class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -398,6 +413,7 @@ Zum Beispiel kannst du mit `@@` in einer Instanzmethode schnell eine neue Instan
 ```yuescript
 some_instance_method = (...) => @@ ...
 ```
+
 <YueDisplay>
 
 ```yue
@@ -423,6 +439,7 @@ class Something
     @@biz = biz
     @@baz = baz
 ```
+
 <YueDisplay>
 
 ```yue
@@ -448,6 +465,7 @@ new = (@fieldA, @fieldB) => @
 obj = new {}, 123, "abc"
 print obj
 ```
+
 <YueDisplay>
 
 ```yue
@@ -467,6 +485,7 @@ x = class Bucket
   drops: 0
   add_drop: => @drops += 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -487,6 +506,7 @@ BigBucket = class extends Bucket
 
 assert Bucket.__name == "BigBucket"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -503,6 +523,7 @@ Du kannst sogar den Körper weglassen und eine leere anonyme Klasse schreiben:
 ```yuescript
 x = class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -532,6 +553,7 @@ y\func!
 
 assert y.__class.__parent ~= X -- X ist nicht die Elternklasse von Y
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/objects/with-statement.md b/doc/docs/de/doc/objects/with-statement.md
index 446f837..adeeda6 100644
--- a/doc/docs/de/doc/objects/with-statement.md
+++ b/doc/docs/de/doc/objects/with-statement.md
@@ -15,6 +15,7 @@ with Person!
   \save!
   print .name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +34,7 @@ Das `with`-Statement kann auch als Ausdruck verwendet werden und gibt den Wert z
 file = with File "Lieblingsessen.txt"
   \set_encoding "utf8"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -52,6 +54,7 @@ create_person = (name,  relatives) ->
 
 me = create_person "Leaf", [dad, mother, sister]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -74,6 +77,7 @@ with str := "Hallo"
   print "Original:", str
   print "Großbuchstaben:", \upper!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -95,6 +99,7 @@ with tb
     ["key-name"] = value
   [] = "abc" -- an "tb" anhängen
 ```
+
 <YueDisplay>
 
 ```yue
@@ -115,6 +120,7 @@ with tb
 with? obj
   print obj.name
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/de/doc/reference/the-yuescript-library.md b/doc/docs/de/doc/reference/the-yuescript-library.md
index 1838ced..0c371bf 100644
--- a/doc/docs/de/doc/reference/the-yuescript-library.md
+++ b/doc/docs/de/doc/reference/the-yuescript-library.md
@@ -17,6 +17,7 @@ Die YueScript-Sprachbibliothek.
 Die YueScript-Version.
 
 **Signatur:**
+
 ```lua
 version: string
 ```
@@ -30,6 +31,7 @@ version: string
 Der Dateitrennzeichen-String der aktuellen Plattform.
 
 **Signatur:**
+
 ```lua
 dirsep: string
 ```
@@ -43,6 +45,7 @@ dirsep: string
 Der Cache für kompilierten Modulcode.
 
 **Signatur:**
+
 ```lua
 yue_compiled: {string: string}
 ```
@@ -56,6 +59,7 @@ yue_compiled: {string: string}
 Die YueScript-Compilerfunktion. Sie kompiliert YueScript-Code zu Lua-Code.
 
 **Signatur:**
+
 ```lua
 to_lua: function(code: string, config?: Config):
     --[[codes]] string | nil,
@@ -65,17 +69,17 @@ to_lua: function(code: string, config?: Config):
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| code | string | Der YueScript-Code. |
-| config | Config | [Optional] Die Compiler-Optionen. |
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| code      | string | Der YueScript-Code.               |
+| config    | Config | [Optional] Die Compiler-Optionen. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| string \| nil | Der kompilierte Lua-Code oder `nil`, falls die Kompilierung fehlgeschlagen ist. |
-| string \| nil | Die Fehlermeldung oder `nil`, falls die Kompilierung erfolgreich war. |
+| Rückgabetyp                         | Beschreibung                                                                                                              |
+| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| string \| nil                       | Der kompilierte Lua-Code oder `nil`, falls die Kompilierung fehlgeschlagen ist.                                           |
+| string \| nil                       | Die Fehlermeldung oder `nil`, falls die Kompilierung erfolgreich war.                                                     |
 | {{string, integer, integer}} \| nil | Die globalen Variablen im Code (mit Name, Zeile und Spalte) oder `nil`, wenn die Compiler-Option `lint_global` false ist. |
 
 ### file_exist
@@ -87,21 +91,22 @@ to_lua: function(code: string, config?: Config):
 Prüft, ob eine Quelldatei existiert. Kann überschrieben werden, um das Verhalten anzupassen.
 
 **Signatur:**
+
 ```lua
 file_exist: function(filename: string): boolean
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| filename | string | Der Dateiname. |
+| Parameter | Typ    | Beschreibung   |
+| --------- | ------ | -------------- |
+| filename  | string | Der Dateiname. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| boolean | Ob die Datei existiert. |
+| Rückgabetyp | Beschreibung            |
+| ----------- | ----------------------- |
+| boolean     | Ob die Datei existiert. |
 
 ### read_file
 
@@ -112,21 +117,22 @@ file_exist: function(filename: string): boolean
 Liest eine Quelldatei. Kann überschrieben werden, um das Verhalten anzupassen.
 
 **Signatur:**
+
 ```lua
 read_file: function(filename: string): string
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| filename | string | Der Dateiname. |
+| Parameter | Typ    | Beschreibung   |
+| --------- | ------ | -------------- |
+| filename  | string | Der Dateiname. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| string | Der Dateiinhalt. |
+| Rückgabetyp | Beschreibung     |
+| ----------- | ---------------- |
+| string      | Der Dateiinhalt. |
 
 ### insert_loader
 
@@ -137,21 +143,22 @@ read_file: function(filename: string): string
 Fügt den YueScript-Loader in die Package-Loader (Searcher) ein.
 
 **Signatur:**
+
 ```lua
 insert_loader: function(pos?: integer): boolean
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| pos | integer | [Optional] Position, an der der Loader eingefügt wird. Standard ist 3. |
+| Parameter | Typ     | Beschreibung                                                           |
+| --------- | ------- | ---------------------------------------------------------------------- |
+| pos       | integer | [Optional] Position, an der der Loader eingefügt wird. Standard ist 3. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| boolean | Ob der Loader erfolgreich eingefügt wurde. Scheitert, wenn er bereits eingefügt ist. |
+| Rückgabetyp | Beschreibung                                                                         |
+| ----------- | ------------------------------------------------------------------------------------ |
+| boolean     | Ob der Loader erfolgreich eingefügt wurde. Scheitert, wenn er bereits eingefügt ist. |
 
 ### remove_loader
 
@@ -162,15 +169,16 @@ insert_loader: function(pos?: integer): boolean
 Entfernt den YueScript-Loader aus den Package-Loadern (Searchern).
 
 **Signatur:**
+
 ```lua
 remove_loader: function(): boolean
 ```
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| boolean | Ob der Loader erfolgreich entfernt wurde. Scheitert, wenn er nicht eingefügt ist. |
+| Rückgabetyp | Beschreibung                                                                      |
+| ----------- | --------------------------------------------------------------------------------- |
+| boolean     | Ob der Loader erfolgreich entfernt wurde. Scheitert, wenn er nicht eingefügt ist. |
 
 ### loadstring
 
@@ -181,6 +189,7 @@ remove_loader: function(): boolean
 Lädt YueScript-Code aus einem String in eine Funktion.
 
 **Signatur:**
+
 ```lua
 loadstring: function(input: string, chunkname: string, env: table, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -189,19 +198,19 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| input | string | Der YueScript-Code. |
-| chunkname | string | Der Name des Code-Chunks. |
-| env | table | Die Environment-Tabelle. |
-| config | Config | [Optional] Die Compiler-Optionen. |
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| input     | string | Der YueScript-Code.               |
+| chunkname | string | Der Name des Code-Chunks.         |
+| env       | table  | Die Environment-Tabelle.          |
+| config    | Config | [Optional] Die Compiler-Optionen. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
 | function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
-| string \| nil | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
 
 ### loadstring
 
@@ -212,6 +221,7 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 Lädt YueScript-Code aus einem String in eine Funktion.
 
 **Signatur:**
+
 ```lua
 loadstring: function(input: string, chunkname: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -220,18 +230,18 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| input | string | Der YueScript-Code. |
-| chunkname | string | Der Name des Code-Chunks. |
-| config | Config | [Optional] Die Compiler-Optionen. |
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| input     | string | Der YueScript-Code.               |
+| chunkname | string | Der Name des Code-Chunks.         |
+| config    | Config | [Optional] Die Compiler-Optionen. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
 | function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
-| string \| nil | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
 
 ### loadstring
 
@@ -242,6 +252,7 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 Lädt YueScript-Code aus einem String in eine Funktion.
 
 **Signatur:**
+
 ```lua
 loadstring: function(input: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -250,17 +261,17 @@ loadstring: function(input: string, config?: Config):
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| input | string | Der YueScript-Code. |
-| config | Config | [Optional] Die Compiler-Optionen. |
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| input     | string | Der YueScript-Code.               |
+| config    | Config | [Optional] Die Compiler-Optionen. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
 | function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
-| string \| nil | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
 
 ### loadfile
 
@@ -271,6 +282,7 @@ loadstring: function(input: string, config?: Config):
 Lädt YueScript-Code aus einer Datei in eine Funktion.
 
 **Signatur:**
+
 ```lua
 loadfile: function(filename: string, env: table, config?: Config):
     nil | function(...: any): (any...),
@@ -279,18 +291,18 @@ loadfile: function(filename: string, env: table, config?: Config):
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| filename | string | Der Dateiname. |
-| env | table | Die Environment-Tabelle. |
-| config | Config | [Optional] Die Compiler-Optionen. |
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| filename  | string | Der Dateiname.                    |
+| env       | table  | Die Environment-Tabelle.          |
+| config    | Config | [Optional] Die Compiler-Optionen. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
 | function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
-| string \| nil | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
 
 ### loadfile
 
@@ -301,6 +313,7 @@ loadfile: function(filename: string, env: table, config?: Config):
 Lädt YueScript-Code aus einer Datei in eine Funktion.
 
 **Signatur:**
+
 ```lua
 loadfile: function(filename: string, config?: Config):
     nil | function(...: any): (any...),
@@ -309,17 +322,17 @@ loadfile: function(filename: string, config?: Config):
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| filename | string | Der Dateiname. |
-| config | Config | [Optional] Die Compiler-Optionen. |
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| filename  | string | Der Dateiname.                    |
+| config    | Config | [Optional] Die Compiler-Optionen. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
 | function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
-| string \| nil | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
 
 ### dofile
 
@@ -330,23 +343,24 @@ loadfile: function(filename: string, config?: Config):
 Lädt YueScript-Code aus einer Datei in eine Funktion und führt sie aus.
 
 **Signatur:**
+
 ```lua
 dofile: function(filename: string, env: table, config?: Config): any...
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| filename | string | Der Dateiname. |
-| env | table | Die Environment-Tabelle. |
-| config | Config | [Optional] Die Compiler-Optionen. |
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| filename  | string | Der Dateiname.                    |
+| env       | table  | Die Environment-Tabelle.          |
+| config    | Config | [Optional] Die Compiler-Optionen. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| any... | Die Rückgabewerte der geladenen Funktion. |
+| Rückgabetyp | Beschreibung                              |
+| ----------- | ----------------------------------------- |
+| any...      | Die Rückgabewerte der geladenen Funktion. |
 
 ### dofile
 
@@ -357,22 +371,23 @@ dofile: function(filename: string, env: table, config?: Config): any...
 Lädt YueScript-Code aus einer Datei in eine Funktion und führt sie aus.
 
 **Signatur:**
+
 ```lua
 dofile: function(filename: string, config?: Config): any...
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| filename | string | Der Dateiname. |
-| config | Config | [Optional] Die Compiler-Optionen. |
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| filename  | string | Der Dateiname.                    |
+| config    | Config | [Optional] Die Compiler-Optionen. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| any... | Die Rückgabewerte der geladenen Funktion. |
+| Rückgabetyp | Beschreibung                              |
+| ----------- | ----------------------------------------- |
+| any...      | Die Rückgabewerte der geladenen Funktion. |
 
 ### find_modulepath
 
@@ -383,21 +398,22 @@ dofile: function(filename: string, config?: Config): any...
 Löst den YueScript-Modulnamen in einen Dateipfad auf.
 
 **Signatur:**
+
 ```lua
 find_modulepath: function(name: string): string
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| name | string | Der Modulname. |
+| Parameter | Typ    | Beschreibung   |
+| --------- | ------ | -------------- |
+| name      | string | Der Modulname. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| string | Der Dateipfad. |
+| Rückgabetyp | Beschreibung   |
+| ----------- | -------------- |
+| string      | Der Dateipfad. |
 
 ### pcall
 
@@ -410,21 +426,22 @@ Fängt Fehler ab und gibt einen Statuscode sowie Ergebnisse oder ein Fehlerobjek
 Schreibt die Fehlerzeilennummer bei Fehlern auf die ursprüngliche Zeilennummer im YueScript-Code um.
 
 **Signatur:**
+
 ```lua
 pcall: function(f: function, ...: any): boolean, any...
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| f | function | Die aufzurufende Funktion. |
-| ... | any | Argumente für die Funktion. |
+| Parameter | Typ      | Beschreibung                |
+| --------- | -------- | --------------------------- |
+| f         | function | Die aufzurufende Funktion.  |
+| ...       | any      | Argumente für die Funktion. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
+| Rückgabetyp  | Beschreibung                                         |
+| ------------ | ---------------------------------------------------- |
 | boolean, ... | Statuscode und Funktionsresultate oder Fehlerobjekt. |
 
 ### require
@@ -437,21 +454,22 @@ Lädt ein Modul (Lua oder YueScript).
 Schreibt die Fehlerzeilennummer auf die ursprüngliche Zeilennummer im YueScript-Code um, wenn das Modul ein YueScript-Modul ist und das Laden fehlschlägt.
 
 **Signatur:**
+
 ```lua
 require: function(name: string): any...
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| modname | string | Der Name des zu ladenden Moduls. |
+| Parameter | Typ    | Beschreibung                     |
+| --------- | ------ | -------------------------------- |
+| modname   | string | Der Name des zu ladenden Moduls. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| any | Der Wert in `package.loaded[modname]`, falls das Modul bereits geladen ist. Andernfalls wird ein Loader gesucht und der finale Wert von `package.loaded[modname]` sowie Loader-Daten als zweites Ergebnis zurückgegeben. |
+| Rückgabetyp | Beschreibung                                                                                                                                                                                                             |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| any         | Der Wert in `package.loaded[modname]`, falls das Modul bereits geladen ist. Andernfalls wird ein Loader gesucht und der finale Wert von `package.loaded[modname]` sowie Loader-Daten als zweites Ergebnis zurückgegeben. |
 
 ### p
 
@@ -462,15 +480,16 @@ require: function(name: string): any...
 Inspiziert die Struktur der übergebenen Werte und gibt String-Repräsentationen aus.
 
 **Signatur:**
+
 ```lua
 p: function(...: any)
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| ... | any | Die zu inspizierenden Werte. |
+| Parameter | Typ | Beschreibung                 |
+| --------- | --- | ---------------------------- |
+| ...       | any | Die zu inspizierenden Werte. |
 
 ### options
 
@@ -481,6 +500,7 @@ p: function(...: any)
 Die aktuellen Compiler-Optionen.
 
 **Signatur:**
+
 ```lua
 options: Config.Options
 ```
@@ -494,21 +514,22 @@ options: Config.Options
 Die Traceback-Funktion, die Stacktrace-Zeilennummern auf die ursprünglichen Zeilennummern im YueScript-Code umschreibt.
 
 **Signatur:**
+
 ```lua
 traceback: function(message: string): string
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| message | string | Die Traceback-Nachricht. |
+| Parameter | Typ    | Beschreibung             |
+| --------- | ------ | ------------------------ |
+| message   | string | Die Traceback-Nachricht. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| string | Die umgeschriebene Traceback-Nachricht. |
+| Rückgabetyp | Beschreibung                            |
+| ----------- | --------------------------------------- |
+| string      | Die umgeschriebene Traceback-Nachricht. |
 
 ### is_ast
 
@@ -519,22 +540,23 @@ traceback: function(message: string): string
 Prüft, ob der Code dem angegebenen AST entspricht.
 
 **Signatur:**
+
 ```lua
 is_ast: function(astName: string, code: string): boolean
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| astName | string | Der AST-Name. |
-| code | string | Der Code. |
+| Parameter | Typ    | Beschreibung  |
+| --------- | ------ | ------------- |
+| astName   | string | Der AST-Name. |
+| code      | string | Der Code.     |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| boolean | Ob der Code dem AST entspricht. |
+| Rückgabetyp | Beschreibung                    |
+| ----------- | ------------------------------- |
+| boolean     | Ob der Code dem AST entspricht. |
 
 ### AST
 
@@ -545,6 +567,7 @@ is_ast: function(astName: string, code: string): boolean
 Die AST-Typdefinition mit Name, Zeile, Spalte und Unterknoten.
 
 **Signatur:**
+
 ```lua
 type AST = {string, integer, integer, any}
 ```
@@ -558,6 +581,7 @@ type AST = {string, integer, integer, any}
 Konvertiert Code in AST.
 
 **Signatur:**
+
 ```lua
 to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
     --[[AST]] AST | nil,
@@ -566,18 +590,18 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| code | string | Der Code. |
-| flattenLevel | integer | [Optional] Der Flatten-Level. Höher bedeutet mehr Flattening. Standard ist 0. Maximum ist 2. |
-| astName | string | [Optional] Der AST-Name. Standard ist "File". |
-| reserveComment | boolean | [Optional] Ob die ursprünglichen Kommentare beibehalten werden. Standard ist false. |
+| Parameter      | Typ     | Beschreibung                                                                                 |
+| -------------- | ------- | -------------------------------------------------------------------------------------------- |
+| code           | string  | Der Code.                                                                                    |
+| flattenLevel   | integer | [Optional] Der Flatten-Level. Höher bedeutet mehr Flattening. Standard ist 0. Maximum ist 2. |
+| astName        | string  | [Optional] Der AST-Name. Standard ist "File".                                                |
+| reserveComment | boolean | [Optional] Ob die ursprünglichen Kommentare beibehalten werden. Standard ist false.          |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| AST \| nil | Der AST oder `nil`, falls die Konvertierung fehlgeschlagen ist. |
+| Rückgabetyp   | Beschreibung                                                           |
+| ------------- | ---------------------------------------------------------------------- |
+| AST \| nil    | Der AST oder `nil`, falls die Konvertierung fehlgeschlagen ist.        |
 | string \| nil | Die Fehlermeldung oder `nil`, falls die Konvertierung erfolgreich war. |
 
 ### format
@@ -589,25 +613,26 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 Formatiert den YueScript-Code.
 
 **Signatur:**
+
 ```lua
 format: function(code: string, tabSize?: number, reserveComment?: boolean): string
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| code | string | Der Code. |
-| tabSize | integer | [Optional] Die Tab-Größe. Standard ist 4. |
+| Parameter      | Typ     | Beschreibung                                                                       |
+| -------------- | ------- | ---------------------------------------------------------------------------------- |
+| code           | string  | Der Code.                                                                          |
+| tabSize        | integer | [Optional] Die Tab-Größe. Standard ist 4.                                          |
 | reserveComment | boolean | [Optional] Ob die ursprünglichen Kommentare beibehalten werden. Standard ist true. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| string | Der formatierte Code. |
+| Rückgabetyp | Beschreibung          |
+| ----------- | --------------------- |
+| string      | Der formatierte Code. |
 
-### __call
+### \_\_call
 
 **Typ:** Metamethod.
 
@@ -617,21 +642,22 @@ Required das YueScript-Modul.
 Schreibt die Fehlerzeilennummer bei Ladefehlern auf die ursprüngliche Zeilennummer im YueScript-Code um.
 
 **Signatur:**
+
 ```lua
 metamethod __call: function(self: yue, module: string): any...
 ```
 
 **Parameter:**
 
-| Parameter | Typ | Beschreibung |
-| --- | --- | --- |
-| module | string | Der Modulname. |
+| Parameter | Typ    | Beschreibung   |
+| --------- | ------ | -------------- |
+| module    | string | Der Modulname. |
 
 **Rückgabe:**
 
-| Rückgabetyp | Beschreibung |
-| --- | --- |
-| any | Der Modulwert. |
+| Rückgabetyp | Beschreibung   |
+| ----------- | -------------- |
+| any         | Der Modulwert. |
 
 ## Config
 
@@ -648,6 +674,7 @@ Die Compiler-Optionen.
 Ob der Compiler die globalen Variablen im Code sammeln soll.
 
 **Signatur:**
+
 ```lua
 lint_global: boolean
 ```
@@ -661,6 +688,7 @@ lint_global: boolean
 Ob der Compiler für den Root-Codeblock ein implizites Return verwenden soll.
 
 **Signatur:**
+
 ```lua
 implicit_return_root: boolean
 ```
@@ -674,6 +702,7 @@ implicit_return_root: boolean
 Ob der Compiler die ursprüngliche Zeilennummer im kompilierten Code beibehalten soll.
 
 **Signatur:**
+
 ```lua
 reserve_line_number: boolean
 ```
@@ -687,6 +716,7 @@ reserve_line_number: boolean
 Ob der Compiler die ursprünglichen Kommentare im kompilierten Code beibehalten soll.
 
 **Signatur:**
+
 ```lua
 reserve_comment: boolean
 ```
@@ -700,6 +730,7 @@ reserve_comment: boolean
 Ob der Compiler statt Tabzeichen Leerzeichen verwenden soll.
 
 **Signatur:**
+
 ```lua
 space_over_tab: boolean
 ```
@@ -713,6 +744,7 @@ space_over_tab: boolean
 Ob der Compiler den zu kompilierenden Code als dasselbe aktuell kompilierte Modul behandeln soll. Nur für internen Gebrauch.
 
 **Signatur:**
+
 ```lua
 same_module: boolean
 ```
@@ -726,6 +758,7 @@ same_module: boolean
 Ob die Compiler-Fehlermeldung einen Zeilennummern-Offset enthalten soll. Nur für internen Gebrauch.
 
 **Signatur:**
+
 ```lua
 line_offset: integer
 ```
@@ -739,6 +772,7 @@ line_offset: integer
 Die Ziel-Lua-Version.
 
 **Signatur:**
+
 ```lua
 enum LuaTarget
   "5.1"
@@ -758,6 +792,7 @@ end
 Zusätzliche Optionen für die Kompilierung.
 
 **Signatur:**
+
 ```lua
 options: Options
 ```
@@ -777,6 +812,7 @@ Zusätzliche Compiler-Optionen.
 Die Ziel-Lua-Version für die Kompilierung.
 
 **Signatur:**
+
 ```lua
 target: LuaTarget
 ```
@@ -790,6 +826,7 @@ target: LuaTarget
 Zusätzlicher Modul-Suchpfad.
 
 **Signatur:**
+
 ```lua
 path: string
 ```
@@ -803,6 +840,7 @@ path: string
 Ob lokale Variablen in Traceback-Fehlermeldungen ausgegeben werden sollen. Standard ist false.
 
 **Signatur:**
+
 ```lua
 dump_locals: boolean
 ```
@@ -816,6 +854,7 @@ dump_locals: boolean
 Ob Fehlermeldungen vereinfacht werden sollen. Standard ist true.
 
 **Signatur:**
+
 ```lua
 simplified: boolean
 ```
diff --git a/doc/docs/de/index.md b/doc/docs/de/index.md
index 1a923b2..94bd00f 100644
--- a/doc/docs/de/index.md
+++ b/doc/docs/de/index.md
@@ -21,4 +21,5 @@ footer:
   message: MIT-Lizenz.
   copyright: Copyright © 2017-2026 Li Jin. Alle Rechte vorbehalten.
 ---
+
 ---
diff --git a/doc/docs/de/try/index.md b/doc/docs/de/try/index.md
index f8c3193..4c17c6c 100755
--- a/doc/docs/de/try/index.md
+++ b/doc/docs/de/try/index.md
@@ -1,4 +1,5 @@
 # YueScript Online-Compiler
+
 ---
 
 Probiere YueScript im Browser mit WASM aus.
diff --git a/doc/docs/doc/advanced/do.md b/doc/docs/doc/advanced/do.md
index 4990d6f..c4b3e30 100644
--- a/doc/docs/doc/advanced/do.md
+++ b/doc/docs/doc/advanced/do.md
@@ -8,6 +8,7 @@ do
   print var
 print var -- nil here
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ counter = do
 print counter!
 print counter!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -53,6 +55,7 @@ tbl = {
     1234
 }
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/advanced/line-decorators.md b/doc/docs/doc/advanced/line-decorators.md
index 292bc77..16b447c 100644
--- a/doc/docs/doc/advanced/line-decorators.md
+++ b/doc/docs/doc/advanced/line-decorators.md
@@ -5,6 +5,7 @@ For convenience, the for loop and if statement can be applied to single statemen
 ```yuescript
 print "hello world" if name == "Rob"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -18,6 +19,7 @@ And with basic loops:
 ```yuescript
 print "item: ", item for item in *items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +35,7 @@ game\update! while game\isRunning!
 
 reader\parse_line! until reader\eof!
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/advanced/macro.md b/doc/docs/doc/advanced/macro.md
index 6d194c3..c057f40 100644
--- a/doc/docs/doc/advanced/macro.md
+++ b/doc/docs/doc/advanced/macro.md
@@ -32,6 +32,7 @@ macro and = (...) -> "#{ table.concat {...}, ' and ' }"
 if $and f1!, f2!, f3!
   print "OK"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -68,6 +69,7 @@ if $and f1!, f2!, f3!
 ## Insert Raw Codes
 
 A macro function can either return a YueScript string or a config table containing Lua codes.
+
 ```yuescript
 macro yueFunc = (var) -> "local #{var} = ->"
 $yueFunc funcA
@@ -93,6 +95,7 @@ if cond then
 end
 ]==]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -126,6 +129,7 @@ end
 ## Export Macro
 
 Macro functions can be exported from a module and get imported in another module. You have to put export macro functions in a single file to be used, and only macro definition, macro importing and macro expansion in place can be put into the macro exporting module.
+
 ```yuescript
 -- file: utils.yue
 export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
@@ -140,6 +144,7 @@ import "utils" as {
 }
 [1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
 ```
+
 <YueDisplay>
 
 ```yue
@@ -165,10 +170,12 @@ import "utils" as {
 ## Builtin Macro
 
 There are some builtin macros but you can override them by declaring macros with the same names.
+
 ```yuescript
 print $FILE -- get string of current module name
 print $LINE -- get number 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -235,6 +242,7 @@ macro printNumAndStr = (num `Num, str `String) -> |
 
 $printNumAndStr 123, "hello"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -259,6 +267,7 @@ macro printNumAndStr = (num, str) ->
 
 $printNumAndStr 123, "hello"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/advanced/module.md b/doc/docs/doc/advanced/module.md
index c955092..0ba2d90 100644
--- a/doc/docs/doc/advanced/module.md
+++ b/doc/docs/doc/advanced/module.md
@@ -28,6 +28,7 @@ do
   import "lpeg" as :C, :Ct, :Cmt
   import "export" as {one, two, Something:{umm:{ch}}}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -67,6 +68,7 @@ do
   import table.concat
   print concat ["a", tostring 1]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -98,6 +100,7 @@ do
   print FLAG
   FLAG = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -140,6 +143,7 @@ export y = ->
 export class Something
   umm: "cool"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -166,6 +170,7 @@ Doing named export with destructuring.
 export :loadstring, to_lua: tolua = yue
 export {itemA: {:fieldA = 'default'}} = tb
 ```
+
 <YueDisplay>
 
 ```yue
@@ -182,6 +187,7 @@ export.itemA = tb
 export.<index> = items
 export["a-b-c"] = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -208,6 +214,7 @@ else
 export with tmp
   j = 2000
 ```
+
 <YueDisplay>
 
 ```yue
@@ -234,6 +241,7 @@ export default ->
   print "hello"
   123
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/advanced/try.md b/doc/docs/doc/advanced/try.md
index 23c7877..c890f09 100644
--- a/doc/docs/doc/advanced/try.md
+++ b/doc/docs/doc/advanced/try.md
@@ -29,6 +29,7 @@ catch err
     print yue.traceback err
   print result
 ```
+
 <YueDisplay>
 
 ```yue
@@ -82,6 +83,7 @@ catch e
   print e
   e
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/assignment/assignment.md b/doc/docs/doc/assignment/assignment.md
index 4dac6f4..cabbc45 100644
--- a/doc/docs/doc/assignment/assignment.md
+++ b/doc/docs/doc/assignment/assignment.md
@@ -7,6 +7,7 @@ hello = "world"
 a, b, c = 1, 2, 3
 hello = 123 -- uses the existing variable
 ```
+
 <YueDisplay>
 
 ```yue
@@ -20,6 +21,7 @@ hello = 123 -- uses the existing variable
 ## Perform Update
 
 You can perform update assignment with many binary operators.
+
 ```yuescript
 x = 1
 x += 1
@@ -30,6 +32,7 @@ x %= 10
 s ..= "world" -- will add a new local if local variable is not exist
 arg or= "default value"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -48,10 +51,12 @@ arg or= "default value"
 ## Chaining Assignment
 
 You can do chaining assignment to assign multiple items to hold the same value.
+
 ```yuescript
 a = b = c = d = e = 0
 x = y = z = f!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +67,7 @@ x = y = z = f!
 </YueDisplay>
 
 ## Explicit Locals
+
 ```yuescript
 do
   local a = 1
@@ -78,6 +84,7 @@ do
   a = 1
   B = 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -100,6 +107,7 @@ do
 </YueDisplay>
 
 ## Explicit Globals
+
 ```yuescript
 do
   global a = 1
@@ -116,6 +124,7 @@ do
   B = 2
   local Temp = "a local value"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/assignment/destructuring-assignment.md b/doc/docs/doc/assignment/destructuring-assignment.md
index e7b8046..750f09e 100644
--- a/doc/docs/doc/assignment/destructuring-assignment.md
+++ b/doc/docs/doc/assignment/destructuring-assignment.md
@@ -12,6 +12,7 @@ thing = [1, 2]
 [a, b] = thing
 print a, b
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,6 +38,7 @@ print hello, the_day
 
 :day = obj -- OK to do simple destructuring without braces
 ```
+
 <YueDisplay>
 
 ```yue
@@ -68,6 +70,7 @@ obj2 = {
 {numbers: [first, second], properties: {color: color}} = obj2
 print first, second, color
 ```
+
 <YueDisplay>
 
 ```yue
@@ -95,6 +98,7 @@ If the destructuring statement is complicated, feel free to spread it out over a
   }
 } = obj2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -113,6 +117,7 @@ It's common to extract values from at table and assign them the local variables
 ```yuescript
 {:concat, :insert} = table
 ```
+
 <YueDisplay>
 
 ```yue
@@ -126,6 +131,7 @@ This is effectively the same as import, but we can rename fields we want to extr
 ```yuescript
 {:mix, :max, random: rand} = math
 ```
+
 <YueDisplay>
 
 ```yue
@@ -139,6 +145,7 @@ You can write default values while doing destructuring like:
 ```yuescript
 {:name = "nameless", :job = "jobless"} = person
 ```
+
 <YueDisplay>
 
 ```yue
@@ -152,6 +159,7 @@ You can use `_` as placeholder when doing a list destructuring:
 ```yuescript
 [_, two, _, four] = items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -171,6 +179,7 @@ print first  -- prints: first
 print bulk   -- prints: {"second", "third", "fourth"}
 print last   -- prints: last
 ```
+
 <YueDisplay>
 
 ```yue
@@ -195,6 +204,7 @@ The spread operator can be used in different positions to capture different rang
 -- Capture things except the middle elements
 [first, ..._, last] = orders
 ```
+
 <YueDisplay>
 
 ```yue
@@ -223,6 +233,7 @@ tuples = [
 for [left, right] in *tuples
   print left, right
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/assignment/if-assignment.md b/doc/docs/doc/assignment/if-assignment.md
index 02984e8..99f94b4 100644
--- a/doc/docs/doc/assignment/if-assignment.md
+++ b/doc/docs/doc/assignment/if-assignment.md
@@ -6,6 +6,7 @@
 if user := database.find_user "moon"
   print user.name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -23,6 +24,7 @@ elseif world := os.getenv "world"
 else
   print "nothing :("
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,11 +39,13 @@ else
 </YueDisplay>
 
 If assignment with multiple return values. Only the first value is getting checked, other values are scoped.
+
 ```yuescript
 if success, result := pcall -> "get result without problems"
   print result -- variable result is scoped
 print "OK"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -61,6 +65,7 @@ while byte := stream\read_one!
   -- do something with the byte
   print byte
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/assignment/the-using-clause-controlling-destructive-assignment.md b/doc/docs/doc/assignment/the-using-clause-controlling-destructive-assignment.md
index fb9b740..20ba236 100644
--- a/doc/docs/doc/assignment/the-using-clause-controlling-destructive-assignment.md
+++ b/doc/docs/doc/assignment/the-using-clause-controlling-destructive-assignment.md
@@ -17,6 +17,7 @@ my_func!
 
 print i -- will print 0
 ```
+
 <YueDisplay>
 
 ```yue
@@ -52,6 +53,7 @@ my_func = (using nil) ->
 my_func!
 print i -- prints 100, i is unaffected
 ```
+
 <YueDisplay>
 
 ```yue
@@ -80,6 +82,7 @@ my_func = (add using k, i) ->
 my_func(22)
 print i, k -- these have been updated
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/assignment/varargs-assignment.md b/doc/docs/doc/assignment/varargs-assignment.md
index 1d66680..145274c 100644
--- a/doc/docs/doc/assignment/varargs-assignment.md
+++ b/doc/docs/doc/assignment/varargs-assignment.md
@@ -1,6 +1,6 @@
 # Varargs Assignment
 
-You can assign the results returned from a function  to a varargs symbol `...`. And then access its content using the Lua way.
+You can assign the results returned from a function to a varargs symbol `...`. And then access its content using the Lua way.
 
 ```yuescript
 list = [1, 2, 3, 4, 5]
@@ -10,6 +10,7 @@ count = select '#', ...
 first = select 1, ...
 print ok, count, first
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/control-flow/conditionals.md b/doc/docs/doc/control-flow/conditionals.md
index 1bda514..1bcc838 100644
--- a/doc/docs/doc/control-flow/conditionals.md
+++ b/doc/docs/doc/control-flow/conditionals.md
@@ -7,6 +7,7 @@ if have_coins
 else
   print "No coins"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -25,6 +26,7 @@ A short syntax for single statements can also be used:
 have_coins = false
 if have_coins then print "Got coins" else print "No coins"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -40,6 +42,7 @@ Because if statements can be used as expressions, this can also be written as:
 have_coins = false
 print if have_coins then "Got coins" else "No coins"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -65,6 +68,7 @@ else
 
 print message -- prints: I am very tall
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,6 +94,7 @@ The opposite of if is unless:
 unless os.date("%A") == "Monday"
   print "it is not Monday!"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -102,6 +107,7 @@ unless os.date("%A") == "Monday"
 ```yuescript
 print "You're lucky!" unless math.random! > 0.1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -123,6 +129,7 @@ if a in [1, 3, 5, 7]
 if a in list
   print "checking if `a` is in a list"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/control-flow/continue.md b/doc/docs/doc/control-flow/continue.md
index b000765..8708b5a 100644
--- a/doc/docs/doc/control-flow/continue.md
+++ b/doc/docs/doc/control-flow/continue.md
@@ -9,6 +9,7 @@ while i < 10
   continue if i % 2 == 0
   print i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ odds = for x in *my_numbers
   continue if x % 2 == 1
   x
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/control-flow/for-loop.md b/doc/docs/doc/control-flow/for-loop.md
index cabcde5..b92e94e 100644
--- a/doc/docs/doc/control-flow/for-loop.md
+++ b/doc/docs/doc/control-flow/for-loop.md
@@ -12,6 +12,7 @@ for k = 1, 15, 2 -- an optional step provided
 for key, value in pairs object
   print key, value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +34,7 @@ The slicing and **\*** operators can be used, just like with comprehensions:
 for item in *items[2, 4]
   print item
 ```
+
 <YueDisplay>
 
 ```yue
@@ -49,6 +51,7 @@ for item in *items do print item
 
 for j = 1, 10, 3 do print j
 ```
+
 <YueDisplay>
 
 ```yue
@@ -70,6 +73,7 @@ doubled_evens = for i = 1, 20
   else
     i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,6 +94,7 @@ For example, to find the first number greater than 10:
 first_large = for n in *numbers
   break n if n > 10
 ```
+
 <YueDisplay>
 
 ```yue
@@ -112,6 +117,7 @@ func_b = -> return for i = 1, 10 do i
 print func_a! -- prints nil
 print func_b! -- prints table object
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/control-flow/switch.md b/doc/docs/doc/control-flow/switch.md
index f503a80..7787b64 100644
--- a/doc/docs/doc/control-flow/switch.md
+++ b/doc/docs/doc/control-flow/switch.md
@@ -11,6 +11,7 @@ switch name := "Dan"
   else
     print "I don't know about you with name #{name}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -39,6 +40,7 @@ next_number = switch b
   else
     error "can't count that high!"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +64,7 @@ msg = switch math.random(1, 5)
   when 2 then "you are almost lucky"
   else "not so lucky"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -87,6 +90,7 @@ switch math.random(1, 5) when 1
 else
   print "not so lucky"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -124,6 +128,7 @@ for item in *items
     when :width, :height
       print "size #{width}, #{height}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -154,6 +159,7 @@ switch item
   when {pos: {:x = 50, :y = 200}}
     print "Vec2 #{x}, #{y}" -- table destructuring will still pass
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +187,7 @@ switch tb
   when [1, 2, b = 3] -- b has a default value
     print "1, 2, #{b}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -206,6 +213,7 @@ switch tb
   else
     print "invalid"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -231,6 +239,7 @@ switch tb
   else
     print "invalid"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -257,6 +266,7 @@ switch tb
     ]
     print "matched", fourth
 ```
+
 <YueDisplay>
 
 ```yue
@@ -282,6 +292,7 @@ switch segments
     print "Resource:", resource -- prints: "logs"
     print "Action:", action -- prints: "view"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/control-flow/while-loop.md b/doc/docs/doc/control-flow/while-loop.md
index 502935e..02e82d6 100644
--- a/doc/docs/doc/control-flow/while-loop.md
+++ b/doc/docs/doc/control-flow/while-loop.md
@@ -10,6 +10,7 @@ while i > 0
 
 while running == true do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ until i == 0
 
 until running == false do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +58,7 @@ repeat
   i -= 1
 until i == 0
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/data-structures/comprehensions.md b/doc/docs/doc/data-structures/comprehensions.md
index 3a92167..94fbf38 100644
--- a/doc/docs/doc/data-structures/comprehensions.md
+++ b/doc/docs/doc/data-structures/comprehensions.md
@@ -10,6 +10,7 @@ The following creates a copy of the items table but with all the values doubled.
 items = [ 1, 2, 3, 4 ]
 doubled = [item * 2 for i, item in ipairs items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ The items included in the new table can be restricted with a when clause:
 ```yuescript
 slice = [item for i, item in ipairs items when i > 1 and i < 3]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,6 +39,7 @@ Because it is common to iterate over the values of a numerically indexed table,
 ```yuescript
 doubled = [item * 2 for item in *items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ data =
 flat = [...v for k,v in pairs data]
 -- flat is now [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -79,6 +83,7 @@ y_coords = [9, 2, 3]
 points = [ [x, y] for x in *x_coords \
 for y in *y_coords]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -96,6 +101,7 @@ Numeric for loops can also be used in comprehensions:
 ```yuescript
 evens = [i for i = 1, 100 when i % 2 == 0]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -119,6 +125,7 @@ thing = {
 
 thing_copy = {k, v for k, v in pairs thing}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -136,6 +143,7 @@ thing_copy = {k, v for k, v in pairs thing}
 ```yuescript
 no_color = {k, v for k, v in pairs thing when k != "color"}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -150,6 +158,7 @@ The **\*** operator is also supported. Here we create a square root look up tabl
 numbers = [1, 2, 3, 4]
 sqrts = {i, math.sqrt i for i in *numbers}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -167,6 +176,7 @@ In this example we convert an array of pairs to a table where the first item in
 tuples = [ ["hello", "world"], ["foo", "bar"]]
 tbl = {unpack tuple for tuple in *tuples}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -185,6 +195,7 @@ Here we can set the minimum and maximum bounds, taking all items with indexes be
 ```yuescript
 slice = [item for item in *items[1, 5]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -198,6 +209,7 @@ Any of the slice arguments can be left off to use a sensible default. In this ex
 ```yuescript
 slice = [item for item in *items[2,]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -211,6 +223,7 @@ If the minimum bound is left out, it defaults to 1. Here we only provide a step
 ```yuescript
 slice = [item for item in *items[,,2]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -225,6 +238,7 @@ Both the minimum and maximum bounds can be negative, which means that the bounds
 -- take the last 4 items
 slice = [item for item in *items[-4,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -239,6 +253,7 @@ The step size can also be negative, which means that the items are taken in reve
 ```yuescript
 reverse_slice = [item for item in *items[-1,1,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -258,6 +273,7 @@ sub_list = items[2, 4]
 -- take the last 4 items
 last_four_items = items[-4, -1]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/data-structures/table-literals.md b/doc/docs/doc/data-structures/table-literals.md
index c1adcab..23f9fc5 100644
--- a/doc/docs/doc/data-structures/table-literals.md
+++ b/doc/docs/doc/data-structures/table-literals.md
@@ -5,6 +5,7 @@ Like in Lua, tables are delimited in curly braces.
 ```yuescript
 some_values = [1, 2, 3, 4]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -22,6 +23,7 @@ some_values = {
   ["favorite food"]: "rice"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ profile =
   shoe_size: 13,
   favorite_foods: ["ice cream", "donuts"]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -63,6 +66,7 @@ values = {
   occupation: "crime fighting"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -83,6 +87,7 @@ my_function dance: "Tango", partner: "none"
 
 y = type: "dog", legs: 4, tails: 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +106,7 @@ tbl = {
   end: "hunger"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -121,6 +127,7 @@ person = { :hair, :height, shoe_size: 40 }
 
 print_table :hair, :height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -141,6 +148,7 @@ t = {
   "hello world": true
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -158,6 +166,7 @@ Lua tables have both an array part and a hash part, but sometimes you want to ma
 some_values = [1, 2, 3, 4]
 list_with_one_element = [1, ]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/functions/backcalls.md b/doc/docs/doc/functions/backcalls.md
index e34331e..a1d9f39 100644
--- a/doc/docs/doc/functions/backcalls.md
+++ b/doc/docs/doc/functions/backcalls.md
@@ -6,6 +6,7 @@ Backcalls are used for unnesting callbacks. They are defined using arrows pointe
 x <- f
 print "hello" .. x
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ Fat arrow functions are also available.
 <= f
 print @value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ You can specify a placeholder for where you want the backcall function to go as
 (x) <- map _, [1, 2, 3]
 x * 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ result, msg = do
   check info
 print result, msg
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/functions/function-literals.md b/doc/docs/doc/functions/function-literals.md
index 316e07c..ed37e52 100644
--- a/doc/docs/doc/functions/function-literals.md
+++ b/doc/docs/doc/functions/function-literals.md
@@ -6,6 +6,7 @@ All functions are created using a function expression. A simple function is deno
 my_function = ->
 my_function() -- call the empty function
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ func_b = ->
   value = 100
   print "The value:", value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ If a function has no arguments, it can be called using the ! operator, instead o
 func_a!
 func_b()
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +59,7 @@ Functions with arguments can be created by preceding the arrow with a list of ar
 ```yuescript
 sum = (x, y) -> print "sum", x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -72,6 +76,7 @@ print sum 10, 20
 
 a b c "a", "b", "c"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -88,6 +93,7 @@ In order to avoid ambiguity in when calling functions, parentheses can also be u
 ```yuescript
 print "x:", sum(10, 20), "y:", sum(30, 40)
 ```
+
 <YueDisplay>
 
 ```yue
@@ -104,6 +110,7 @@ Functions will coerce the last statement in their body into a return statement,
 sum = (x, y) -> x + y
 print "The sum is ", sum 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +125,7 @@ And if you need to explicitly return, you can use the return keyword:
 ```yuescript
 sum = (x, y) -> return x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -132,6 +140,7 @@ Just like in Lua, functions can return multiple values. The last statement must
 mystery = (x, y) -> x + y, x - y
 a, b = mystery 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -148,6 +157,7 @@ Because it is an idiom in Lua to send an object as the first argument when calli
 ```yuescript
 func = (num) => @value + num
 ```
+
 <YueDisplay>
 
 ```yue
@@ -165,6 +175,7 @@ my_function = (name = "something", height = 100) ->
   print "Hello I am", name
   print "My height is", height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +192,7 @@ An argument default value expression is evaluated in the body of the function in
 some_args = (x = 100, y = x + 1000) ->
   print x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -202,6 +214,7 @@ b = x-10
 c = x -y
 d = x- z
 ```
+
 <YueDisplay>
 
 ```yue
@@ -223,6 +236,7 @@ Where there is a space following a variable and a string literal, the function c
 x = func"hello" + 100
 y = func "hello" + 100
 ```
+
 <YueDisplay>
 
 ```yue
@@ -247,6 +261,7 @@ cool_func 1, 2,
   5, 6,
   7, 8
 ```
+
 <YueDisplay>
 
 ```yue
@@ -269,6 +284,7 @@ my_func 5, 6, 7,
     9, 1, 2,
   5, 4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -289,6 +305,7 @@ x = [
   8, 9, 10
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -309,6 +326,7 @@ y = [ my_func 1, 2, 3,
   5, 6, 7
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -335,6 +353,7 @@ if func 1, 2, 3,
   print "hello"
   print "I am inside if"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -357,9 +376,9 @@ if func 1, 2, 3,
 
 YueScript now supports destructuring function parameters when the argument is an object. Two forms of destructuring table literals are available:
 
-* **Curly-brace wrapped literals/object parameters**, allowing optional default values when fields are missing (e.g., `{:a, :b}`, `{a: a1 = 123}`).
+- **Curly-brace wrapped literals/object parameters**, allowing optional default values when fields are missing (e.g., `{:a, :b}`, `{a: a1 = 123}`).
 
-* **Unwrapped simple table syntax**, starting with a sequence of key-value or shorthand bindings and continuing until another expression terminates it (e.g., `:a, b: b1, :c`). This form extracts multiple fields from the same object.
+- **Unwrapped simple table syntax**, starting with a sequence of key-value or shorthand bindings and continuing until another expression terminates it (e.g., `:a, b: b1, :c`). This form extracts multiple fields from the same object.
 
 ```yuescript
 f1 = (:a, :b, :c) ->
@@ -373,6 +392,7 @@ f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
 arg1 = {a: 0}
 f2 arg1, arg2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -402,6 +422,7 @@ findFirstEven = (list): nil ->
         if sub % 2 == 0
           return sub
 ```
+
 <YueDisplay>
 
 ```yue
@@ -426,6 +447,7 @@ findFirstEven = (list) ->
           return sub
   nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -467,6 +489,7 @@ process = (...args) ->
 
 process 1, nil, 3, nil, 5
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/functions/function-stubs.md b/doc/docs/doc/functions/function-stubs.md
index 57a8b0c..59ce00c 100644
--- a/doc/docs/doc/functions/function-stubs.md
+++ b/doc/docs/doc/functions/function-stubs.md
@@ -24,6 +24,7 @@ run_callback my_object.write
 -- lets us bundle the object into a new function
 run_callback my_object\write
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/getting-started/introduction.md b/doc/docs/doc/getting-started/introduction.md
index 9a76b23..0b2beed 100644
--- a/doc/docs/doc/getting-started/introduction.md
+++ b/doc/docs/doc/getting-started/introduction.md
@@ -102,4 +102,4 @@ export 🌛 = "Script of Moon"
 
 ## About Dora SSR
 
-YueScript is being developed and maintained alongside the open-source game engine [Dora SSR](https://github.com/Dora-SSR/Dora-SSR). It has been used to create engine tools, game demos and prototypes, validating its capabilities in real-world scenarios while enhancing the Dora SSR development experience.
\ No newline at end of file
+YueScript is being developed and maintained alongside the open-source game engine [Dora SSR](https://github.com/Dora-SSR/Dora-SSR). It has been used to create engine tools, game demos and prototypes, validating its capabilities in real-world scenarios while enhancing the Dora SSR development experience.
diff --git a/doc/docs/doc/getting-started/usage.md b/doc/docs/doc/getting-started/usage.md
index 45161c6..8818dd0 100644
--- a/doc/docs/doc/getting-started/usage.md
+++ b/doc/docs/doc/getting-started/usage.md
@@ -4,49 +4,51 @@
 
 Use YueScript module in Lua:
 
-* **Case 1**
-
-        Require "your_yuescript_entry.yue" in Lua.
-        ```Lua
-        require("yue")("your_yuescript_entry")
-        ```
-        And this code still works when you compile "your_yuescript_entry.yue"  to "your_yuescript_entry.lua" in the same path. In the rest YueScript files just use the normal **require** or **import**. The code line numbers in error messages will also be handled correctly.
-
-* **Case 2**
-
-        Require YueScript module and rewite message by hand.
-
-        ```lua
-        local yue = require("yue")
-        yue.insert_loader()
-        local success, result = xpcall(function()
-          return require("yuescript_module_name")
-        end, function(err)
-          return yue.traceback(err)
-        end)
-        ```
-
-* **Case 3**
-
-        Use the YueScript compiler function in Lua.
-
-        ```lua
-        local yue = require("yue")
-        local codes, err, globals = yue.to_lua([[
-          f = ->
-            print "hello world"
-          f!
-        ]],{
-          implicit_return_root = true,
-          reserve_line_number = true,
-          lint_global = true,
-          space_over_tab = false,
-          options = {
-            target = "5.4",
-            path = "/script"
-          }
-        })
-        ```
+- **Case 1**
+
+  Require "your_yuescript_entry.yue" in Lua.
+
+  ```Lua
+  require("yue")("your_yuescript_entry")
+  ```
+
+  And this code still works when you compile "your_yuescript_entry.yue" to "your_yuescript_entry.lua" in the same path. In the rest YueScript files just use the normal **require** or **import**. The code line numbers in error messages will also be handled correctly.
+
+- **Case 2**
+
+  Require YueScript module and rewite message by hand.
+
+  ```lua
+  local yue = require("yue")
+  yue.insert_loader()
+  local success, result = xpcall(function()
+    return require("yuescript_module_name")
+  end, function(err)
+    return yue.traceback(err)
+  end)
+  ```
+
+- **Case 3**
+
+  Use the YueScript compiler function in Lua.
+
+  ```lua
+  local yue = require("yue")
+  local codes, err, globals = yue.to_lua([[
+    f = ->
+      print "hello world"
+    f!
+  ]],{
+    implicit_return_root = true,
+    reserve_line_number = true,
+    lint_global = true,
+    space_over_tab = false,
+    options = {
+      target = "5.4",
+      path = "/script"
+    }
+  })
+  ```
 
 ## YueScript Tool
 
@@ -96,16 +98,17 @@ Options:
    Execute without options to enter REPL, type symbol '$'
    in a single line to start/stop multi-line mode
 ```
+
 Use cases:
 
-Recursively compile every YueScript file with extension **.yue** under current path:  **yue .**
+Recursively compile every YueScript file with extension **.yue** under current path: **yue .**
 
-Compile and save results to a target path:  **yue -t /target/path/ .**
+Compile and save results to a target path: **yue -t /target/path/ .**
 
-Compile and reserve debug info:  **yue -l .**
+Compile and reserve debug info: **yue -l .**
 
-Compile and generate minified codes:  **yue -m .**
+Compile and generate minified codes: **yue -m .**
 
-Execute raw codes:  **yue -e 'print 123'**
+Execute raw codes: **yue -e 'print 123'**
 
-Execute a YueScript file:  **yue -e main.yue**
+Execute a YueScript file: **yue -e main.yue**
diff --git a/doc/docs/doc/language-basics/attributes.md b/doc/docs/doc/language-basics/attributes.md
index e6fd5a7..068a56a 100644
--- a/doc/docs/doc/language-basics/attributes.md
+++ b/doc/docs/doc/language-basics/attributes.md
@@ -6,6 +6,7 @@ Syntax support for Lua 5.4 attributes. And you can still use both the `const` an
 const a = 123
 close _ = <close>: -> print "Out of scope."
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ You can do desctructuring with variables attributed as constant.
 const {:a, :b, c, d} = tb
 -- a = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ You can also declare a global variable to be `const`.
 global const Constant = 123
 -- Constant = 1
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/language-basics/comment.md b/doc/docs/doc/language-basics/comment.md
index b67c97d..ee637dd 100644
--- a/doc/docs/doc/language-basics/comment.md
+++ b/doc/docs/doc/language-basics/comment.md
@@ -12,6 +12,7 @@ It's OK.
 
 func --[[port]] 3000, --[[ip]] "192.168.1.1"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/language-basics/literals.md b/doc/docs/doc/language-basics/literals.md
index e097c62..17b823f 100644
--- a/doc/docs/doc/language-basics/literals.md
+++ b/doc/docs/doc/language-basics/literals.md
@@ -12,6 +12,7 @@ some_string = "Here is a string
 -- String interpolation is only available in double quoted strings.
 print "I am #{math.random! * 100}% sure."
 ```
+
 <YueDisplay>
 
 ```yue
@@ -34,6 +35,7 @@ integer = 1_000_000
 hex = 0xEF_BB_BF
 binary = 0B10011
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +57,7 @@ str = |
     - item1
     - #{expr}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -78,6 +81,7 @@ fn = ->
       bar: baz
   return str
 ```
+
 <YueDisplay>
 
 ```yue
@@ -99,6 +103,7 @@ str = |
   path: "C:\Program Files\App"
   note: 'He said: "#{Hello}!"'
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/language-basics/operator.md b/doc/docs/doc/language-basics/operator.md
index 9a2e89b..6de5c17 100644
--- a/doc/docs/doc/language-basics/operator.md
+++ b/doc/docs/doc/language-basics/operator.md
@@ -6,6 +6,7 @@ All of Lua's binary and unary operators are available. Additionally **!=** is as
 tb\func! if tb ~= nil
 tb::func! if tb != nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -27,6 +28,7 @@ a = 5
 print 1 <= a <= 10
 -- output: true
 ```
+
 <YueDisplay>
 
 ```yue
@@ -64,6 +66,7 @@ print v(1) > v(2) <= v(3)
   false
 ]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +104,7 @@ The **[] =** operator is used to append values to tables.
 tab = []
 tab[] = "Value"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +122,7 @@ tbB = [4, 5, 6]
 tbA[] = ...tbB
 -- tbA is now [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -149,6 +154,7 @@ a = {1, 2, 3, x: 1}
 b = {4, 5, y: 1}
 merge = {...a, ...b}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -179,6 +185,7 @@ last = data.items[#]
 second_last = data.items[#-1]
 data.items[#] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -212,6 +219,7 @@ print d.value
 
 close _ = <close>: -> print "out of scope"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -245,6 +253,7 @@ print tb.value
 tb.<> = __index: {item: "hello"}
 print tb.item
 ```
+
 <YueDisplay>
 
 ```yue
@@ -266,6 +275,7 @@ Destruct metatable with metamethod key surrounded by **<>**.
 {item, :new, :<close>, <index>: getter} = tb
 print item, new, close, getter
 ```
+
 <YueDisplay>
 
 ```yue
@@ -293,6 +303,7 @@ with? io.open "test.txt", "w"
   \write "hello"
   \close!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -329,6 +340,7 @@ readFile "example.txt"
   |> render
   |> print
 ```
+
 <YueDisplay>
 
 ```yue
@@ -349,6 +361,7 @@ readFile "example.txt"
 ## Nil Coalescing
 
 The nil-coalescing operator **??** returns the value of its left-hand operand if it isn't **nil**; otherwise, it evaluates the right-hand operand and returns its result. The **??** operator doesn't evaluate its right-hand operand if the left-hand operand evaluates to non-nil.
+
 ```yuescript
 local a, b, c, d
 a = b ?? c ?? d
@@ -356,6 +369,7 @@ func a ?? {}
 
 a ??= false
 ```
+
 <YueDisplay>
 
 ```yue
@@ -413,6 +427,7 @@ tb =
       tb: { }
 
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/language-basics/whitespace.md b/doc/docs/doc/language-basics/whitespace.md
index d742a2b..3b67e48 100644
--- a/doc/docs/doc/language-basics/whitespace.md
+++ b/doc/docs/doc/language-basics/whitespace.md
@@ -9,6 +9,7 @@ A statement normally ends at a line break. You can also use a semicolon `;` to e
 ```yuescript
 a = 1; b = 2; print a + b
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ Rx.Observable
   \map (value) -> value .. '!'
   \subscribe print
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/objects/object-oriented-programming.md b/doc/docs/doc/objects/object-oriented-programming.md
index 6a8559e..781ab65 100644
--- a/doc/docs/doc/objects/object-oriented-programming.md
+++ b/doc/docs/doc/objects/object-oriented-programming.md
@@ -15,6 +15,7 @@ class Inventory
     else
       @items[name] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -46,6 +47,7 @@ inv = Inventory!
 inv\add_item "t-shirt"
 inv\add_item "pants"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -77,6 +79,7 @@ b\give_item "shirt"
 -- will print both pants and shirt
 print item for item in *a.clothes
 ```
+
 <YueDisplay>
 
 ```yue
@@ -104,6 +107,7 @@ class Person
   new: =>
     @clothes = []
 ```
+
 <YueDisplay>
 
 ```yue
@@ -125,6 +129,7 @@ class BackPack extends Inventory
     if #@items > size then error "backpack is full"
     super name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -141,7 +146,7 @@ Here we extend our Inventory class, and limit the amount of items it can carry.
 
 In this example, we don't define a constructor on the subclass, so the parent class' constructor is called when we make a new instance. If we did define a constructor then we can use the super method to call the parent constructor.
 
-Whenever a class inherits from another, it sends a message to the parent class by calling the method __inherited on the parent class if it exists. The function receives two arguments, the class that is being inherited and the child class.
+Whenever a class inherits from another, it sends a message to the parent class by calling the method \_\_inherited on the parent class if it exists. The function receives two arguments, the class that is being inherited and the child class.
 
 ```yuescript
 class Shelf
@@ -151,6 +156,7 @@ class Shelf
 -- will print: Shelf was inherited by Cupboard
 class Cupboard extends Shelf
 ```
+
 <YueDisplay>
 
 ```yue
@@ -189,6 +195,7 @@ class MyClass extends ParentClass
     -- super as a value is equal to the parent class:
     assert super == ParentClass
 ```
+
 <YueDisplay>
 
 ```yue
@@ -209,7 +216,7 @@ class MyClass extends ParentClass
 
 ## Types
 
-Every instance of a class carries its type with it. This is stored in the special __class property. This property holds the class object. The class object is what we call to build a new instance. We can also index the class object to retrieve class methods and properties.
+Every instance of a class carries its type with it. This is stored in the special \_\_class property. This property holds the class object. The class object is what we call to build a new instance. We can also index the class object to retrieve class methods and properties.
 
 ```yuescript
 b = BackPack!
@@ -217,6 +224,7 @@ assert b.__class == BackPack
 
 print BackPack.size -- prints 10
 ```
+
 <YueDisplay>
 
 ```yue
@@ -238,15 +246,16 @@ A class is made up of two tables. The class table itself, and the base table. Th
 
 The class object's metatable reads properties from the base if they don't exist in the class object. This means we can access functions and properties directly from the class.
 
-It is important to note that assigning to the class object does not assign into the base, so it's not a valid way to add new methods to instances. Instead the base must explicitly be changed. See the __base field below.
+It is important to note that assigning to the class object does not assign into the base, so it's not a valid way to add new methods to instances. Instead the base must explicitly be changed. See the \_\_base field below.
 
 The class object has a couple special properties:
 
-The name of the class as when it was declared is stored as a string in the __name field of the class object.
+The name of the class as when it was declared is stored as a string in the \_\_name field of the class object.
 
 ```yuescript
 print BackPack.__name -- prints Backpack
 ```
+
 <YueDisplay>
 
 ```yue
@@ -255,9 +264,9 @@ print BackPack.__name -- prints Backpack
 
 </YueDisplay>
 
-The base object is stored in __base. We can modify this table to add functionality to instances that have already been created and ones that are yet to be created.
+The base object is stored in \_\_base. We can modify this table to add functionality to instances that have already been created and ones that are yet to be created.
 
-If the class extends from anything, the parent class object is stored in __parent.
+If the class extends from anything, the parent class object is stored in \_\_parent.
 
 ## Class Variables
 
@@ -272,6 +281,7 @@ Things\some_func!
 -- class variables not visible in instances
 assert Things().some_func == nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -286,7 +296,7 @@ assert Things().some_func == nil
 
 </YueDisplay>
 
-In expressions, we can use @@ to access a value that is stored in the __class of self. Thus, @@hello is shorthand for self.__class.hello.
+In expressions, we can use @@ to access a value that is stored in the **class of self. Thus, @@hello is shorthand for self.**class.hello.
 
 ```yuescript
 class Counter
@@ -300,6 +310,7 @@ Counter!
 
 print Counter.count -- prints 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -322,6 +333,7 @@ The calling semantics of @@ are similar to @. Calling a @@ name will pass the cl
 ```yuescript
 @@hello 1,2,3,4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -340,6 +352,7 @@ Here is an alternative way to create a class variable compared to what's describ
 class Things
   @class_var = "hello world"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -361,6 +374,7 @@ class MoreThings
   some_method: =>
     log "hello world: " .. secret
 ```
+
 <YueDisplay>
 
 ```yue
@@ -376,14 +390,15 @@ class MoreThings
 
 ## @ and @@ Values
 
-When @ and @@ are prefixed in front of a name they represent, respectively, that name accessed in self and self.__class.
+When @ and @@ are prefixed in front of a name they represent, respectively, that name accessed in self and self.\_\_class.
 
-If they are used all by themselves, they are aliases for self and self.__class.
+If they are used all by themselves, they are aliases for self and self.\_\_class.
 
 ```yuescript
 assert @ == self
 assert @@ == self.__class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -398,6 +413,7 @@ For example, a quick way to create a new instance of the same class from an inst
 ```yuescript
 some_instance_method = (...) => @@ ...
 ```
+
 <YueDisplay>
 
 ```yue
@@ -423,6 +439,7 @@ class Something
     @@biz = biz
     @@baz = baz
 ```
+
 <YueDisplay>
 
 ```yue
@@ -448,6 +465,7 @@ new = (@fieldA, @fieldB) => @
 obj = new {}, 123, "abc"
 print obj
 ```
+
 <YueDisplay>
 
 ```yue
@@ -467,6 +485,7 @@ x = class Bucket
   drops: 0
   add_drop: => @drops += 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -479,7 +498,7 @@ x = class Bucket
 
 ## Anonymous classes
 
-The name can be left out when declaring a class. The __name attribute will be nil, unless the class expression is in an assignment. The name on the left hand side of the assignment is used instead of nil.
+The name can be left out when declaring a class. The \_\_name attribute will be nil, unless the class expression is in an assignment. The name on the left hand side of the assignment is used instead of nil.
 
 ```yuescript
 BigBucket = class extends Bucket
@@ -487,6 +506,7 @@ BigBucket = class extends Bucket
 
 assert Bucket.__name == "BigBucket"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -503,6 +523,7 @@ You can even leave off the body, meaning you can write a blank anonymous class l
 ```yuescript
 x = class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -532,6 +553,7 @@ y\func!
 
 assert y.__class.__parent ~= X -- X is not parent of Y
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/objects/with-statement.md b/doc/docs/doc/objects/with-statement.md
index 7786803..5d7fea3 100644
--- a/doc/docs/doc/objects/with-statement.md
+++ b/doc/docs/doc/objects/with-statement.md
@@ -1,6 +1,5 @@
 # With Statement
 
-
 A common pattern involving the creation of an object is calling a series of functions and setting a series of properties immediately after creating it.
 
 This results in repeating the name of the object multiple times in code, adding unnecessary noise. A common solution to this is to pass a table in as an argument which contains a collection of keys and values to overwrite. The downside to this is that the constructor of this object must support this form.
@@ -16,6 +15,7 @@ with Person!
   \save!
   print .name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -34,6 +34,7 @@ The with statement can also be used as an expression which returns the value it
 file = with File "favorite_foods.txt"
   \set_encoding "utf8"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -53,6 +54,7 @@ create_person = (name,  relatives) ->
 
 me = create_person "Leaf", [dad, mother, sister]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -75,6 +77,7 @@ with str := "Hello"
   print "original:", str
   print "upper:", \upper!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -96,6 +99,7 @@ with tb
     ["key-name"] = value
   [] = "abc" -- appending to "tb"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -116,6 +120,7 @@ with tb
 with? obj
   print obj.name
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/doc/reference/the-yuescript-library.md b/doc/docs/doc/reference/the-yuescript-library.md
index 3761755..817bfab 100644
--- a/doc/docs/doc/reference/the-yuescript-library.md
+++ b/doc/docs/doc/reference/the-yuescript-library.md
@@ -17,6 +17,7 @@ The YueScript language library.
 The YueScript version.
 
 **Signature:**
+
 ```lua
 version: string
 ```
@@ -30,6 +31,7 @@ version: string
 The file separator for the current platform.
 
 **Signature:**
+
 ```lua
 dirsep: string
 ```
@@ -43,6 +45,7 @@ dirsep: string
 The compiled module code cache.
 
 **Signature:**
+
 ```lua
 yue_compiled: {string: string}
 ```
@@ -56,6 +59,7 @@ yue_compiled: {string: string}
 The YueScript compiling function. It compiles the YueScript code to Lua code.
 
 **Signature:**
+
 ```lua
 to_lua: function(code: string, config?: Config):
     --[[codes]] string | nil,
@@ -65,17 +69,17 @@ to_lua: function(code: string, config?: Config):
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| code | string | The YueScript code. |
-| config | Config | [Optional] The compiler options. |
+| Parameter | Type   | Description                      |
+| --------- | ------ | -------------------------------- |
+| code      | string | The YueScript code.              |
+| config    | Config | [Optional] The compiler options. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| string \| nil | The compiled Lua code, or nil if the compilation failed. |
-| string \| nil | The error message, or nil if the compilation succeeded. |
+| Return Type                         | Description                                                                                                                   |
+| ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| string \| nil                       | The compiled Lua code, or nil if the compilation failed.                                                                      |
+| string \| nil                       | The error message, or nil if the compilation succeeded.                                                                       |
 | {{string, integer, integer}} \| nil | The global variables appearing in the code (with name, row and column), or nil if the compiler option `lint_global` is false. |
 
 ### file_exist
@@ -87,21 +91,22 @@ to_lua: function(code: string, config?: Config):
 The source file existence checking function. Can be overridden to customize the behavior.
 
 **Signature:**
+
 ```lua
 file_exist: function(filename: string): boolean
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| filename | string | The file name. |
+| Parameter | Type   | Description    |
+| --------- | ------ | -------------- |
+| filename  | string | The file name. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| boolean | Whether the file exists. |
+| Return Type | Description              |
+| ----------- | ------------------------ |
+| boolean     | Whether the file exists. |
 
 ### read_file
 
@@ -112,21 +117,22 @@ file_exist: function(filename: string): boolean
 The source file reading function. Can be overridden to customize the behavior.
 
 **Signature:**
+
 ```lua
 read_file: function(filename: string): string
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| filename | string | The file name. |
+| Parameter | Type   | Description    |
+| --------- | ------ | -------------- |
+| filename  | string | The file name. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| string | The file content. |
+| Return Type | Description       |
+| ----------- | ----------------- |
+| string      | The file content. |
 
 ### insert_loader
 
@@ -137,21 +143,22 @@ read_file: function(filename: string): string
 Insert the YueScript loader to the package loaders (searchers).
 
 **Signature:**
+
 ```lua
 insert_loader: function(pos?: integer): boolean
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| pos | integer | [Optional] The position to insert the loader. Default is 3. |
+| Parameter | Type    | Description                                                 |
+| --------- | ------- | ----------------------------------------------------------- |
+| pos       | integer | [Optional] The position to insert the loader. Default is 3. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| boolean | Whether the loader is inserted successfully. It will fail if the loader is already inserted. |
+| Return Type | Description                                                                                  |
+| ----------- | -------------------------------------------------------------------------------------------- |
+| boolean     | Whether the loader is inserted successfully. It will fail if the loader is already inserted. |
 
 ### remove_loader
 
@@ -162,15 +169,16 @@ insert_loader: function(pos?: integer): boolean
 Remove the YueScript loader from the package loaders (searchers).
 
 **Signature:**
+
 ```lua
 remove_loader: function(): boolean
 ```
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| boolean | Whether the loader is removed successfully. It will fail if the loader is not inserted. |
+| Return Type | Description                                                                             |
+| ----------- | --------------------------------------------------------------------------------------- |
+| boolean     | Whether the loader is removed successfully. It will fail if the loader is not inserted. |
 
 ### loadstring
 
@@ -181,6 +189,7 @@ remove_loader: function(): boolean
 Loads YueScript code from a string into a function.
 
 **Signature:**
+
 ```lua
 loadstring: function(input: string, chunkname: string, env: table, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -189,19 +198,19 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| input | string | The YueScript code. |
-| chunkname | string | The name of the code chunk. |
-| env | table | The environment table. |
-| config | Config | [Optional] The compiler options. |
+| Parameter | Type   | Description                      |
+| --------- | ------ | -------------------------------- |
+| input     | string | The YueScript code.              |
+| chunkname | string | The name of the code chunk.      |
+| env       | table  | The environment table.           |
+| config    | Config | [Optional] The compiler options. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| function \| nil | The loaded function, or nil if the loading failed. |
-| string \| nil | The error message, or nil if the loading succeeded. |
+| Return Type     | Description                                         |
+| --------------- | --------------------------------------------------- |
+| function \| nil | The loaded function, or nil if the loading failed.  |
+| string \| nil   | The error message, or nil if the loading succeeded. |
 
 ### loadstring
 
@@ -212,6 +221,7 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 Loads YueScript code from a string into a function.
 
 **Signature:**
+
 ```lua
 loadstring: function(input: string, chunkname: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -220,18 +230,18 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| input | string | The YueScript code. |
-| chunkname | string | The name of the code chunk. |
-| config | Config | [Optional] The compiler options. |
+| Parameter | Type   | Description                      |
+| --------- | ------ | -------------------------------- |
+| input     | string | The YueScript code.              |
+| chunkname | string | The name of the code chunk.      |
+| config    | Config | [Optional] The compiler options. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| function \| nil | The loaded function, or nil if the loading failed. |
-| string \| nil | The error message, or nil if the loading succeeded. |
+| Return Type     | Description                                         |
+| --------------- | --------------------------------------------------- |
+| function \| nil | The loaded function, or nil if the loading failed.  |
+| string \| nil   | The error message, or nil if the loading succeeded. |
 
 ### loadstring
 
@@ -242,6 +252,7 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 Loads YueScript code from a string into a function.
 
 **Signature:**
+
 ```lua
 loadstring: function(input: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -250,17 +261,17 @@ loadstring: function(input: string, config?: Config):
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| input | string | The YueScript code. |
-| config | Config | [Optional] The compiler options. |
+| Parameter | Type   | Description                      |
+| --------- | ------ | -------------------------------- |
+| input     | string | The YueScript code.              |
+| config    | Config | [Optional] The compiler options. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| function \| nil | The loaded function, or nil if the loading failed. |
-| string \| nil | The error message, or nil if the loading succeeded. |
+| Return Type     | Description                                         |
+| --------------- | --------------------------------------------------- |
+| function \| nil | The loaded function, or nil if the loading failed.  |
+| string \| nil   | The error message, or nil if the loading succeeded. |
 
 ### loadfile
 
@@ -271,6 +282,7 @@ loadstring: function(input: string, config?: Config):
 Loads YueScript code from a file into a function.
 
 **Signature:**
+
 ```lua
 loadfile: function(filename: string, env: table, config?: Config):
     nil | function(...: any): (any...),
@@ -279,18 +291,18 @@ loadfile: function(filename: string, env: table, config?: Config):
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| filename | string | The file name. |
-| env | table | The environment table. |
-| config | Config | [Optional] The compiler options. |
+| Parameter | Type   | Description                      |
+| --------- | ------ | -------------------------------- |
+| filename  | string | The file name.                   |
+| env       | table  | The environment table.           |
+| config    | Config | [Optional] The compiler options. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| function \| nil | The loaded function, or nil if the loading failed. |
-| string \| nil | The error message, or nil if the loading succeeded. |
+| Return Type     | Description                                         |
+| --------------- | --------------------------------------------------- |
+| function \| nil | The loaded function, or nil if the loading failed.  |
+| string \| nil   | The error message, or nil if the loading succeeded. |
 
 ### loadfile
 
@@ -301,6 +313,7 @@ loadfile: function(filename: string, env: table, config?: Config):
 Loads YueScript code from a file into a function.
 
 **Signature:**
+
 ```lua
 loadfile: function(filename: string, config?: Config):
     nil | function(...: any): (any...),
@@ -309,17 +322,17 @@ loadfile: function(filename: string, config?: Config):
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| filename | string | The file name. |
-| config | Config | [Optional] The compiler options. |
+| Parameter | Type   | Description                      |
+| --------- | ------ | -------------------------------- |
+| filename  | string | The file name.                   |
+| config    | Config | [Optional] The compiler options. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| function \| nil | The loaded function, or nil if the loading failed. |
-| string \| nil | The error message, or nil if the loading succeeded. |
+| Return Type     | Description                                         |
+| --------------- | --------------------------------------------------- |
+| function \| nil | The loaded function, or nil if the loading failed.  |
+| string \| nil   | The error message, or nil if the loading succeeded. |
 
 ### dofile
 
@@ -330,23 +343,24 @@ loadfile: function(filename: string, config?: Config):
 Loads YueScript code from a file into a function and executes it.
 
 **Signature:**
+
 ```lua
 dofile: function(filename: string, env: table, config?: Config): any...
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| filename | string | The file name. |
-| env | table | The environment table. |
-| config | Config | [Optional] The compiler options. |
+| Parameter | Type   | Description                      |
+| --------- | ------ | -------------------------------- |
+| filename  | string | The file name.                   |
+| env       | table  | The environment table.           |
+| config    | Config | [Optional] The compiler options. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| any... | The return values of the loaded function. |
+| Return Type | Description                               |
+| ----------- | ----------------------------------------- |
+| any...      | The return values of the loaded function. |
 
 ### dofile
 
@@ -357,22 +371,23 @@ dofile: function(filename: string, env: table, config?: Config): any...
 Loads YueScript code from a file into a function and executes it.
 
 **Signature:**
+
 ```lua
 dofile: function(filename: string, config?: Config): any...
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| filename | string | The file name. |
-| config | Config | [Optional] The compiler options. |
+| Parameter | Type   | Description                      |
+| --------- | ------ | -------------------------------- |
+| filename  | string | The file name.                   |
+| config    | Config | [Optional] The compiler options. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| any... | The return values of the loaded function. |
+| Return Type | Description                               |
+| ----------- | ----------------------------------------- |
+| any...      | The return values of the loaded function. |
 
 ### find_modulepath
 
@@ -383,21 +398,22 @@ dofile: function(filename: string, config?: Config): any...
 Resolves the YueScript module name to the file path.
 
 **Signature:**
+
 ```lua
 find_modulepath: function(name: string): string
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| name | string | The module name. |
+| Parameter | Type   | Description      |
+| --------- | ------ | ---------------- |
+| name      | string | The module name. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| string | The file path. |
+| Return Type | Description    |
+| ----------- | -------------- |
+| string      | The file path. |
 
 ### pcall
 
@@ -410,21 +426,22 @@ Catches any errors and returns a status code and results or error object.
 Rewrites the error line number to the original line number in the YueScript code when errors occur.
 
 **Signature:**
+
 ```lua
 pcall: function(f: function, ...: any): boolean, any...
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| f | function | The function to call. |
-| ... | any | Arguments to pass to the function. |
+| Parameter | Type     | Description                        |
+| --------- | -------- | ---------------------------------- |
+| f         | function | The function to call.              |
+| ...       | any      | Arguments to pass to the function. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
+| Return Type  | Description                                       |
+| ------------ | ------------------------------------------------- |
 | boolean, ... | Status code and function results or error object. |
 
 ### require
@@ -437,21 +454,22 @@ Loads a given module. Can be either a Lua module or a YueScript module.
 Rewrites the error line number to the original line number in the YueScript code if the module is a YueScript module and loading fails.
 
 **Signature:**
+
 ```lua
 require: function(name: string): any...
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| modname | string | The name of the module to load. |
+| Parameter | Type   | Description                     |
+| --------- | ------ | ------------------------------- |
+| modname   | string | The name of the module to load. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| any | The value stored at package.loaded[modname] if the module is already loaded.Otherwise, tries to find a loader and returns the final value of package.loaded[modname] and a loader data as a second result. |
+| Return Type | Description                                                                                                                                                                                                |
+| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| any         | The value stored at package.loaded[modname] if the module is already loaded.Otherwise, tries to find a loader and returns the final value of package.loaded[modname] and a loader data as a second result. |
 
 ### p
 
@@ -462,15 +480,16 @@ require: function(name: string): any...
 Inspects the structures of the passed values and prints string representations.
 
 **Signature:**
+
 ```lua
 p: function(...: any)
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| ... | any | The values to inspect. |
+| Parameter | Type | Description            |
+| --------- | ---- | ---------------------- |
+| ...       | any  | The values to inspect. |
 
 ### options
 
@@ -481,6 +500,7 @@ p: function(...: any)
 The current compiler options.
 
 **Signature:**
+
 ```lua
 options: Config.Options
 ```
@@ -494,21 +514,22 @@ options: Config.Options
 The traceback function that rewrites the stack trace line numbers to the original line numbers in the YueScript code.
 
 **Signature:**
+
 ```lua
 traceback: function(message: string): string
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| message | string | The traceback message. |
+| Parameter | Type   | Description            |
+| --------- | ------ | ---------------------- |
+| message   | string | The traceback message. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| string | The rewritten traceback message. |
+| Return Type | Description                      |
+| ----------- | -------------------------------- |
+| string      | The rewritten traceback message. |
 
 ### is_ast
 
@@ -519,22 +540,23 @@ traceback: function(message: string): string
 Checks whether the code matches the specified AST.
 
 **Signature:**
+
 ```lua
 is_ast: function(astName: string, code: string): boolean
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| astName | string | The AST name. |
-| code | string | The code. |
+| Parameter | Type   | Description   |
+| --------- | ------ | ------------- |
+| astName   | string | The AST name. |
+| code      | string | The code.     |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| boolean | Whether the code matches the AST. |
+| Return Type | Description                       |
+| ----------- | --------------------------------- |
+| boolean     | Whether the code matches the AST. |
 
 ### AST
 
@@ -545,6 +567,7 @@ is_ast: function(astName: string, code: string): boolean
 The AST type definition with name, row, column and sub nodes.
 
 **Signature:**
+
 ```lua
 type AST = {string, integer, integer, any}
 ```
@@ -558,6 +581,7 @@ type AST = {string, integer, integer, any}
 Converts the code to the AST.
 
 **Signature:**
+
 ```lua
 to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
     --[[AST]] AST | nil,
@@ -566,18 +590,18 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| code | string | The code. |
-| flattenLevel | integer | [Optional] The flatten level. Higher level means more flattening. Default is 0. Maximum is 2. |
-| astName | string | [Optional] The AST name. Default is "File". |
-| reserveComment | boolean | [Optional] Whether to reserve the original comments. Default is false. |
+| Parameter      | Type    | Description                                                                                   |
+| -------------- | ------- | --------------------------------------------------------------------------------------------- |
+| code           | string  | The code.                                                                                     |
+| flattenLevel   | integer | [Optional] The flatten level. Higher level means more flattening. Default is 0. Maximum is 2. |
+| astName        | string  | [Optional] The AST name. Default is "File".                                                   |
+| reserveComment | boolean | [Optional] Whether to reserve the original comments. Default is false.                        |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| AST \| nil | The AST, or nil if the conversion failed. |
+| Return Type   | Description                                            |
+| ------------- | ------------------------------------------------------ |
+| AST \| nil    | The AST, or nil if the conversion failed.              |
 | string \| nil | The error message, or nil if the conversion succeeded. |
 
 ### format
@@ -589,25 +613,26 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 Formats the YueScript code.
 
 **Signature:**
+
 ```lua
 format: function(code: string, tabSize?: number, reserveComment?: boolean): string
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| code | string | The code. |
-| tabSize | integer | [Optional] The tab size. Default is 4. |
+| Parameter      | Type    | Description                                                           |
+| -------------- | ------- | --------------------------------------------------------------------- |
+| code           | string  | The code.                                                             |
+| tabSize        | integer | [Optional] The tab size. Default is 4.                                |
 | reserveComment | boolean | [Optional] Whether to reserve the original comments. Default is true. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| string | The formatted code. |
+| Return Type | Description         |
+| ----------- | ------------------- |
+| string      | The formatted code. |
 
-### __call
+### \_\_call
 
 **Type:** Metamethod.
 
@@ -617,21 +642,22 @@ Requires the YueScript module.
 Rewrites the error line number to the original line number in the YueScript code when loading fails.
 
 **Signature:**
+
 ```lua
 metamethod __call: function(self: yue, module: string): any...
 ```
 
 **Parameters:**
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| module | string | The module name. |
+| Parameter | Type   | Description      |
+| --------- | ------ | ---------------- |
+| module    | string | The module name. |
 
 **Returns:**
 
-| Return Type | Description |
-| --- | --- |
-| any | The module value. |
+| Return Type | Description       |
+| ----------- | ----------------- |
+| any         | The module value. |
 
 ## Config
 
@@ -648,6 +674,7 @@ The compiler compile options.
 Whether the compiler should collect the global variables appearing in the code.
 
 **Signature:**
+
 ```lua
 lint_global: boolean
 ```
@@ -661,6 +688,7 @@ lint_global: boolean
 Whether the compiler should do an implicit return for the root code block.
 
 **Signature:**
+
 ```lua
 implicit_return_root: boolean
 ```
@@ -674,6 +702,7 @@ implicit_return_root: boolean
 Whether the compiler should reserve the original line number in the compiled code.
 
 **Signature:**
+
 ```lua
 reserve_line_number: boolean
 ```
@@ -687,6 +716,7 @@ reserve_line_number: boolean
 Whether the compiler should reserve the original comments in the compiled code.
 
 **Signature:**
+
 ```lua
 reserve_comment: boolean
 ```
@@ -700,6 +730,7 @@ reserve_comment: boolean
 Whether the compiler should use the space character instead of the tab character in the compiled code.
 
 **Signature:**
+
 ```lua
 space_over_tab: boolean
 ```
@@ -713,6 +744,7 @@ space_over_tab: boolean
 Whether the compiler should treat the code to be compiled as the same currently being compiled module. For internal use only.
 
 **Signature:**
+
 ```lua
 same_module: boolean
 ```
@@ -726,6 +758,7 @@ same_module: boolean
 Whether the compiler error message should include the line number offset. For internal use only.
 
 **Signature:**
+
 ```lua
 line_offset: integer
 ```
@@ -739,6 +772,7 @@ line_offset: integer
 The target Lua version enumeration.
 
 **Signature:**
+
 ```lua
 enum LuaTarget
   "5.1"
@@ -758,6 +792,7 @@ end
 The extra options to be passed to the compilation function.
 
 **Signature:**
+
 ```lua
 options: Options
 ```
@@ -777,6 +812,7 @@ The extra compiler options definition.
 The target Lua version for the compilation.
 
 **Signature:**
+
 ```lua
 target: LuaTarget
 ```
@@ -790,6 +826,7 @@ target: LuaTarget
 The extra module search path.
 
 **Signature:**
+
 ```lua
 path: string
 ```
@@ -803,6 +840,7 @@ path: string
 Whether to dump the local variables in the traceback error message. Default is false.
 
 **Signature:**
+
 ```lua
 dump_locals: boolean
 ```
@@ -816,6 +854,7 @@ dump_locals: boolean
 Whether to simplify the error message. Default is true.
 
 **Signature:**
+
 ```lua
 simplified: boolean
 ```
diff --git a/doc/docs/id-id/doc/advanced/do.md b/doc/docs/id-id/doc/advanced/do.md
index ebbd2e2..ac75531 100644
--- a/doc/docs/id-id/doc/advanced/do.md
+++ b/doc/docs/id-id/doc/advanced/do.md
@@ -8,6 +8,7 @@ do
   print var
 print var -- nil di sini
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ counter = do
 print counter!
 print counter!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -53,6 +55,7 @@ tbl = {
     1234
 }
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/advanced/line-decorators.md b/doc/docs/id-id/doc/advanced/line-decorators.md
index e90e205..d968b1f 100644
--- a/doc/docs/id-id/doc/advanced/line-decorators.md
+++ b/doc/docs/id-id/doc/advanced/line-decorators.md
@@ -5,6 +5,7 @@ Untuk kemudahan, loop for dan pernyataan if dapat diterapkan pada pernyataan tun
 ```yuescript
 print "hello world" if name == "Rob"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -18,6 +19,7 @@ Dan dengan loop dasar:
 ```yuescript
 print "item: ", item for item in *items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +35,7 @@ game\update! while game\isRunning!
 
 reader\parse_line! until reader\eof!
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/advanced/macro.md b/doc/docs/id-id/doc/advanced/macro.md
index ce0bafa..d33ec5b 100644
--- a/doc/docs/id-id/doc/advanced/macro.md
+++ b/doc/docs/id-id/doc/advanced/macro.md
@@ -32,6 +32,7 @@ macro and = (...) -> "#{ table.concat {...}, ' and ' }"
 if $and f1!, f2!, f3!
   print "OK"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -68,6 +69,7 @@ if $and f1!, f2!, f3!
 ## Menyisipkan Kode Mentah
 
 Fungsi macro bisa mengembalikan string YueScript atau tabel konfigurasi yang berisi kode Lua.
+
 ```yuescript
 macro yueFunc = (var) -> "local #{var} = ->"
 $yueFunc funcA
@@ -93,6 +95,7 @@ if cond then
 end
 ]==]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -126,6 +129,7 @@ end
 ## Export Macro
 
 Fungsi macro dapat diekspor dari modul dan diimpor di modul lain. Anda harus menaruh fungsi macro export dalam satu file agar dapat digunakan, dan hanya definisi macro, impor macro, dan ekspansi macro yang boleh ada di modul export macro.
+
 ```yuescript
 -- file: utils.yue
 export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
@@ -140,6 +144,7 @@ import "utils" as {
 }
 [1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
 ```
+
 <YueDisplay>
 
 ```yue
@@ -165,10 +170,12 @@ import "utils" as {
 ## Macro Bawaan
 
 Ada beberapa macro bawaan tetapi Anda bisa menimpanya dengan mendeklarasikan macro dengan nama yang sama.
+
 ```yuescript
 print $FILE -- mendapatkan string nama modul saat ini
 print $LINE -- mendapatkan angka 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -235,6 +242,7 @@ macro printNumAndStr = (num `Num, str `String) -> |
 
 $printNumAndStr 123, "hello"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -259,6 +267,7 @@ macro printNumAndStr = (num, str) ->
 
 $printNumAndStr 123, "hello"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/advanced/module.md b/doc/docs/id-id/doc/advanced/module.md
index dd97a32..103e3f6 100644
--- a/doc/docs/id-id/doc/advanced/module.md
+++ b/doc/docs/id-id/doc/advanced/module.md
@@ -28,6 +28,7 @@ do
   import "lpeg" as :C, :Ct, :Cmt
   import "export" as {one, two, Something:{umm:{ch}}}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -67,6 +68,7 @@ do
   import table.concat
   print concat ["a", tostring 1]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -98,6 +100,7 @@ do
   print FLAG
   FLAG = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -140,6 +143,7 @@ export y = ->
 export class Something
   umm: "cool"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -166,6 +170,7 @@ Melakukan export bernama dengan destrukturisasi.
 export :loadstring, to_lua: tolua = yue
 export {itemA: {:fieldA = 'default'}} = tb
 ```
+
 <YueDisplay>
 
 ```yue
@@ -182,6 +187,7 @@ export.itemA = tb
 export.<index> = items
 export["a-b-c"] = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -208,6 +214,7 @@ else
 export with tmp
   j = 2000
 ```
+
 <YueDisplay>
 
 ```yue
@@ -234,6 +241,7 @@ export default ->
   print "hello"
   123
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/advanced/try.md b/doc/docs/id-id/doc/advanced/try.md
index 6607451..4e63004 100644
--- a/doc/docs/id-id/doc/advanced/try.md
+++ b/doc/docs/id-id/doc/advanced/try.md
@@ -29,6 +29,7 @@ catch err
     print yue.traceback err
   print result
 ```
+
 <YueDisplay>
 
 ```yue
@@ -82,6 +83,7 @@ catch e
   print e
   e
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/assignment/assignment.md b/doc/docs/id-id/doc/assignment/assignment.md
index d9fd45d..34e18fd 100644
--- a/doc/docs/id-id/doc/assignment/assignment.md
+++ b/doc/docs/id-id/doc/assignment/assignment.md
@@ -7,6 +7,7 @@ hello = "world"
 a, b, c = 1, 2, 3
 hello = 123 -- menggunakan variabel yang sudah ada
 ```
+
 <YueDisplay>
 
 ```yue
@@ -20,6 +21,7 @@ hello = 123 -- menggunakan variabel yang sudah ada
 ## Pembaruan Nilai
 
 Anda dapat melakukan assignment pembaruan dengan banyak operator biner.
+
 ```yuescript
 x = 1
 x += 1
@@ -30,6 +32,7 @@ x %= 10
 s ..= "world" -- akan menambah local baru jika variabel local belum ada
 arg or= "default value"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -48,10 +51,12 @@ arg or= "default value"
 ## Assignment Berantai
 
 Anda bisa melakukan assignment berantai untuk menetapkan beberapa item ke nilai yang sama.
+
 ```yuescript
 a = b = c = d = e = 0
 x = y = z = f!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +67,7 @@ x = y = z = f!
 </YueDisplay>
 
 ## Local Eksplisit
+
 ```yuescript
 do
   local a = 1
@@ -78,6 +84,7 @@ do
   a = 1
   B = 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -100,6 +107,7 @@ do
 </YueDisplay>
 
 ## Global Eksplisit
+
 ```yuescript
 do
   global a = 1
@@ -116,6 +124,7 @@ do
   B = 2
   local Temp = "a local value"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/assignment/destructuring-assignment.md b/doc/docs/id-id/doc/assignment/destructuring-assignment.md
index ba591fd..b9956a8 100644
--- a/doc/docs/id-id/doc/assignment/destructuring-assignment.md
+++ b/doc/docs/id-id/doc/assignment/destructuring-assignment.md
@@ -12,6 +12,7 @@ thing = [1, 2]
 [a, b] = thing
 print a, b
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,6 +38,7 @@ print hello, the_day
 
 :day = obj -- OK untuk destrukturisasi sederhana tanpa kurung
 ```
+
 <YueDisplay>
 
 ```yue
@@ -68,6 +70,7 @@ obj2 = {
 {numbers: [first, second], properties: {color: color}} = obj2
 print first, second, color
 ```
+
 <YueDisplay>
 
 ```yue
@@ -95,6 +98,7 @@ Jika pernyataan destrukturisasi kompleks, Anda bisa memecahnya ke beberapa baris
   }
 } = obj2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -113,6 +117,7 @@ Umumnya mengekstrak nilai dari tabel lalu menugaskannya ke variabel local dengan
 ```yuescript
 {:concat, :insert} = table
 ```
+
 <YueDisplay>
 
 ```yue
@@ -126,6 +131,7 @@ Ini secara efektif sama seperti import, tetapi kita dapat mengganti nama field y
 ```yuescript
 {:mix, :max, random: rand} = math
 ```
+
 <YueDisplay>
 
 ```yue
@@ -139,6 +145,7 @@ Anda bisa menulis nilai default saat destrukturisasi seperti:
 ```yuescript
 {:name = "nameless", :job = "jobless"} = person
 ```
+
 <YueDisplay>
 
 ```yue
@@ -152,6 +159,7 @@ Anda dapat menggunakan `_` sebagai placeholder saat destrukturisasi list:
 ```yuescript
 [_, two, _, four] = items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -171,6 +179,7 @@ print first  -- prints: first
 print bulk   -- prints: {"second", "third", "fourth"}
 print last   -- prints: last
 ```
+
 <YueDisplay>
 
 ```yue
@@ -195,6 +204,7 @@ Operator spread dapat digunakan pada posisi berbeda untuk menangkap rentang yang
 -- Tangkap semuanya kecuali elemen tengah
 [first, ..._, last] = orders
 ```
+
 <YueDisplay>
 
 ```yue
@@ -223,6 +233,7 @@ tuples = [
 for [left, right] in *tuples
   print left, right
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/assignment/if-assignment.md b/doc/docs/id-id/doc/assignment/if-assignment.md
index b30d0d9..e212859 100644
--- a/doc/docs/id-id/doc/assignment/if-assignment.md
+++ b/doc/docs/id-id/doc/assignment/if-assignment.md
@@ -6,6 +6,7 @@ Blok `if` dan `elseif` dapat menerima assignment sebagai ganti ekspresi kondisio
 if user := database.find_user "moon"
   print user.name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -23,6 +24,7 @@ elseif world := os.getenv "world"
 else
   print "nothing :("
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,11 +39,13 @@ else
 </YueDisplay>
 
 Assignment if dengan beberapa nilai return. Hanya nilai pertama yang dicek, nilai lainnya tetap berada dalam scope.
+
 ```yuescript
 if success, result := pcall -> "get result without problems"
   print result -- variabel result berada dalam scope
 print "OK"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -61,6 +65,7 @@ while byte := stream\read_one!
   -- lakukan sesuatu dengan byte
   print byte
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/assignment/the-using-clause-controlling-destructive-assignment.md b/doc/docs/id-id/doc/assignment/the-using-clause-controlling-destructive-assignment.md
index 6953138..6e47f0c 100644
--- a/doc/docs/id-id/doc/assignment/the-using-clause-controlling-destructive-assignment.md
+++ b/doc/docs/id-id/doc/assignment/the-using-clause-controlling-destructive-assignment.md
@@ -17,6 +17,7 @@ my_func!
 
 print i -- akan mencetak 0
 ```
+
 <YueDisplay>
 
 ```yue
@@ -52,6 +53,7 @@ my_func = (using nil) ->
 my_func!
 print i -- mencetak 100, i tidak terpengaruh
 ```
+
 <YueDisplay>
 
 ```yue
@@ -80,6 +82,7 @@ my_func = (add using k, i) ->
 my_func(22)
 print i, k -- ini telah diperbarui
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/assignment/varargs-assignment.md b/doc/docs/id-id/doc/assignment/varargs-assignment.md
index f24652f..9c5c8a3 100644
--- a/doc/docs/id-id/doc/assignment/varargs-assignment.md
+++ b/doc/docs/id-id/doc/assignment/varargs-assignment.md
@@ -10,6 +10,7 @@ count = select '#', ...
 first = select 1, ...
 print ok, count, first
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/control-flow/conditionals.md b/doc/docs/id-id/doc/control-flow/conditionals.md
index 4f08b16..861eae6 100644
--- a/doc/docs/id-id/doc/control-flow/conditionals.md
+++ b/doc/docs/id-id/doc/control-flow/conditionals.md
@@ -7,6 +7,7 @@ if have_coins
 else
   print "Tidak ada koin"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -25,6 +26,7 @@ Sintaks pendek untuk pernyataan tunggal juga bisa digunakan:
 have_coins = false
 if have_coins then print "Dapat koin" else print "Tidak ada koin"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -40,6 +42,7 @@ Karena pernyataan if dapat digunakan sebagai ekspresi, ini juga bisa ditulis seb
 have_coins = false
 print if have_coins then "Dapat koin" else "Tidak ada koin"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -65,6 +68,7 @@ else
 
 print message -- prints: Saya sangat tinggi
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,6 +94,7 @@ Kebalikan dari if adalah unless:
 unless os.date("%A") == "Monday"
   print "hari ini bukan Senin!"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -102,6 +107,7 @@ unless os.date("%A") == "Monday"
 ```yuescript
 print "Kamu beruntung!" unless math.random! > 0.1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -123,6 +129,7 @@ if a in [1, 3, 5, 7]
 if a in list
   print "memeriksa apakah `a` ada di dalam daftar"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/control-flow/continue.md b/doc/docs/id-id/doc/control-flow/continue.md
index 3d7a68c..798a44b 100644
--- a/doc/docs/id-id/doc/control-flow/continue.md
+++ b/doc/docs/id-id/doc/control-flow/continue.md
@@ -9,6 +9,7 @@ while i < 10
   continue if i % 2 == 0
   print i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ odds = for x in *my_numbers
   continue if x % 2 == 1
   x
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/control-flow/for-loop.md b/doc/docs/id-id/doc/control-flow/for-loop.md
index 91ba22e..65386f7 100644
--- a/doc/docs/id-id/doc/control-flow/for-loop.md
+++ b/doc/docs/id-id/doc/control-flow/for-loop.md
@@ -12,6 +12,7 @@ for k = 1, 15, 2 -- an optional step provided
 for key, value in pairs object
   print key, value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +34,7 @@ Operator slicing dan **\*** dapat digunakan, seperti pada comprehension:
 for item in *items[2, 4]
   print item
 ```
+
 <YueDisplay>
 
 ```yue
@@ -49,6 +51,7 @@ for item in *items do print item
 
 for j = 1, 10, 3 do print j
 ```
+
 <YueDisplay>
 
 ```yue
@@ -70,6 +73,7 @@ doubled_evens = for i = 1, 20
   else
     i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,6 +94,7 @@ Contohnya, untuk menemukan angka pertama yang lebih besar dari 10:
 first_large = for n in *numbers
   break n if n > 10
 ```
+
 <YueDisplay>
 
 ```yue
@@ -112,6 +117,7 @@ func_b = -> return for i = 1, 10 do i
 print func_a! -- prints nil
 print func_b! -- prints table object
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/control-flow/switch.md b/doc/docs/id-id/doc/control-flow/switch.md
index ced4748..1b7b86e 100644
--- a/doc/docs/id-id/doc/control-flow/switch.md
+++ b/doc/docs/id-id/doc/control-flow/switch.md
@@ -11,6 +11,7 @@ switch name := "Dan"
   else
     print "I don't know about you with name #{name}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -39,6 +40,7 @@ next_number = switch b
   else
     error "can't count that high!"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +64,7 @@ msg = switch math.random(1, 5)
   when 2 then "you are almost lucky"
   else "not so lucky"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -87,6 +90,7 @@ switch math.random(1, 5) when 1
 else
   print "not so lucky"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -124,6 +128,7 @@ for item in *items
     when :width, :height
       print "size #{width}, #{height}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -154,6 +159,7 @@ switch item
   when {pos: {:x = 50, :y = 200}}
     print "Vec2 #{x}, #{y}" -- table destructuring will still pass
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +187,7 @@ switch tb
   when [1, 2, b = 3] -- b has a default value
     print "1, 2, #{b}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -206,6 +213,7 @@ switch tb
   else
     print "invalid"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -231,6 +239,7 @@ switch tb
   else
     print "invalid"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -257,6 +266,7 @@ switch tb
     ]
     print "matched", fourth
 ```
+
 <YueDisplay>
 
 ```yue
@@ -282,6 +292,7 @@ switch segments
     print "Resource:", resource -- prints: "logs"
     print "Action:", action -- prints: "view"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/control-flow/while-loop.md b/doc/docs/id-id/doc/control-flow/while-loop.md
index cd93c91..3e302cc 100644
--- a/doc/docs/id-id/doc/control-flow/while-loop.md
+++ b/doc/docs/id-id/doc/control-flow/while-loop.md
@@ -10,6 +10,7 @@ while i > 0
 
 while running == true do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ until i == 0
 
 until running == false do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +58,7 @@ repeat
   i -= 1
 until i == 0
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/data-structures/comprehensions.md b/doc/docs/id-id/doc/data-structures/comprehensions.md
index 3a2a9ff..c5a8f7b 100644
--- a/doc/docs/id-id/doc/data-structures/comprehensions.md
+++ b/doc/docs/id-id/doc/data-structures/comprehensions.md
@@ -10,6 +10,7 @@ Berikut membuat salinan tabel `items` tetapi semua nilainya digandakan.
 items = [ 1, 2, 3, 4 ]
 doubled = [item * 2 for i, item in ipairs items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ Item yang disertakan dalam tabel baru bisa dibatasi dengan klausa `when`:
 ```yuescript
 slice = [item for i, item in ipairs items when i > 1 and i < 3]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,6 +39,7 @@ Karena umum untuk mengiterasi nilai dari tabel berindeks numerik, operator **\**
 ```yuescript
 doubled = [item * 2 for item in *items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ data =
 flat = [...v for k,v in pairs data]
 -- flat sekarang [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -79,6 +83,7 @@ y_coords = [9, 2, 3]
 points = [ [x, y] for x in *x_coords \
 for y in *y_coords]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -96,6 +101,7 @@ Perulangan for numerik juga bisa digunakan dalam komprehensi:
 ```yuescript
 evens = [i for i = 1, 100 when i % 2 == 0]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -119,6 +125,7 @@ thing = {
 
 thing_copy = {k, v for k, v in pairs thing}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -136,6 +143,7 @@ thing_copy = {k, v for k, v in pairs thing}
 ```yuescript
 no_color = {k, v for k, v in pairs thing when k != "color"}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -150,6 +158,7 @@ Operator **\*** juga didukung. Di sini kita membuat tabel lookup akar kuadrat un
 numbers = [1, 2, 3, 4]
 sqrts = {i, math.sqrt i for i in *numbers}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -167,6 +176,7 @@ Dalam contoh ini kita mengonversi array pasangan menjadi tabel di mana item pert
 tuples = [ ["hello", "world"], ["foo", "bar"]]
 tbl = {unpack tuple for tuple in *tuples}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -185,6 +195,7 @@ Di sini kita bisa menetapkan batas minimum dan maksimum, mengambil semua item de
 ```yuescript
 slice = [item for item in *items[1, 5]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -198,6 +209,7 @@ Salah satu argumen slice boleh dikosongkan untuk menggunakan default yang masuk
 ```yuescript
 slice = [item for item in *items[2,]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -211,6 +223,7 @@ Jika batas minimum dikosongkan, defaultnya adalah 1. Di sini kita hanya memberik
 ```yuescript
 slice = [item for item in *items[,,2]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -225,6 +238,7 @@ Batas minimum dan maksimum bisa bernilai negatif, yang berarti batas dihitung da
 -- ambil 4 item terakhir
 slice = [item for item in *items[-4,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -239,6 +253,7 @@ Ukuran langkah juga bisa negatif, yang berarti item diambil dalam urutan terbali
 ```yuescript
 reverse_slice = [item for item in *items[-1,1,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -258,6 +273,7 @@ sub_list = items[2, 4]
 -- ambil 4 item terakhir
 last_four_items = items[-4, -1]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/data-structures/table-literals.md b/doc/docs/id-id/doc/data-structures/table-literals.md
index df32f1c..c190f00 100644
--- a/doc/docs/id-id/doc/data-structures/table-literals.md
+++ b/doc/docs/id-id/doc/data-structures/table-literals.md
@@ -5,6 +5,7 @@ Seperti di Lua, tabel dibatasi dengan kurung kurawal.
 ```yuescript
 some_values = [1, 2, 3, 4]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -22,6 +23,7 @@ some_values = {
   ["favorite food"]: "rice"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ profile =
   shoe_size: 13,
   favorite_foods: ["ice cream", "donuts"]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -63,6 +66,7 @@ values = {
   occupation: "crime fighting"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -83,6 +87,7 @@ my_function dance: "Tango", partner: "none"
 
 y = type: "dog", legs: 4, tails: 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +106,7 @@ tbl = {
   end: "hunger"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -121,6 +127,7 @@ person = { :hair, :height, shoe_size: 40 }
 
 print_table :hair, :height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -141,6 +148,7 @@ t = {
   "hello world": true
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -158,6 +166,7 @@ Tabel Lua memiliki bagian array dan bagian hash, tetapi terkadang Anda ingin mem
 some_values = [1, 2, 3, 4]
 list_with_one_element = [1, ]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/functions/backcalls.md b/doc/docs/id-id/doc/functions/backcalls.md
index 8d542ee..9de64c3 100644
--- a/doc/docs/id-id/doc/functions/backcalls.md
+++ b/doc/docs/id-id/doc/functions/backcalls.md
@@ -6,6 +6,7 @@ Backcall digunakan untuk meratakan callback yang bersarang. Backcall didefinisik
 x <- f
 print "hello" .. x
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ Fungsi panah tebal juga tersedia.
 <= f
 print @value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ Anda dapat menentukan placeholder untuk posisi fungsi backcall sebagai parameter
 (x) <- map _, [1, 2, 3]
 x * 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ result, msg = do
   check info
 print result, msg
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/functions/function-literals.md b/doc/docs/id-id/doc/functions/function-literals.md
index 589a26d..67ae158 100644
--- a/doc/docs/id-id/doc/functions/function-literals.md
+++ b/doc/docs/id-id/doc/functions/function-literals.md
@@ -6,6 +6,7 @@ Semua fungsi dibuat menggunakan ekspresi fungsi. Fungsi sederhana ditandai denga
 my_function = ->
 my_function() -- memanggil fungsi kosong
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ func_b = ->
   value = 100
   print "The value:", value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ Jika fungsi tidak memiliki argumen, ia dapat dipanggil menggunakan operator `!`,
 func_a!
 func_b()
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +59,7 @@ Fungsi dengan argumen dapat dibuat dengan menaruh daftar nama argumen dalam tand
 ```yuescript
 sum = (x, y) -> print "sum", x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -72,6 +76,7 @@ print sum 10, 20
 
 a b c "a", "b", "c"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -88,6 +93,7 @@ Untuk menghindari ambiguitas saat memanggil fungsi, tanda kurung juga bisa digun
 ```yuescript
 print "x:", sum(10, 20), "y:", sum(30, 40)
 ```
+
 <YueDisplay>
 
 ```yue
@@ -104,6 +110,7 @@ Fungsi akan memaksa pernyataan terakhir di badannya menjadi pernyataan return, i
 sum = (x, y) -> x + y
 print "The sum is ", sum 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +125,7 @@ Dan jika Anda perlu return secara eksplisit, Anda bisa menggunakan kata kunci `r
 ```yuescript
 sum = (x, y) -> return x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -132,6 +140,7 @@ Seperti di Lua, fungsi dapat mengembalikan beberapa nilai. Pernyataan terakhir h
 mystery = (x, y) -> x + y, x - y
 a, b = mystery 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -148,6 +157,7 @@ Karena sudah menjadi idiom di Lua untuk mengirim objek sebagai argumen pertama s
 ```yuescript
 func = (num) => @value + num
 ```
+
 <YueDisplay>
 
 ```yue
@@ -165,6 +175,7 @@ my_function = (name = "something", height = 100) ->
   print "Hello I am", name
   print "My height is", height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +192,7 @@ Ekspresi nilai default argumen dievaluasi di dalam badan fungsi sesuai urutan de
 some_args = (x = 100, y = x + 1000) ->
   print x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -202,6 +214,7 @@ b = x-10
 c = x -y
 d = x- z
 ```
+
 <YueDisplay>
 
 ```yue
@@ -223,6 +236,7 @@ Ketika ada spasi setelah variabel dan literal string, pemanggilan fungsi bertind
 x = func"hello" + 100
 y = func "hello" + 100
 ```
+
 <YueDisplay>
 
 ```yue
@@ -247,6 +261,7 @@ cool_func 1, 2,
   5, 6,
   7, 8
 ```
+
 <YueDisplay>
 
 ```yue
@@ -269,6 +284,7 @@ my_func 5, 6, 7,
     9, 1, 2,
   5, 4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -289,6 +305,7 @@ x = [
   8, 9, 10
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -309,6 +326,7 @@ y = [ my_func 1, 2, 3,
   5, 6, 7
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -335,6 +353,7 @@ if func 1, 2, 3,
   print "hello"
   print "I am inside if"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -357,9 +376,9 @@ if func 1, 2, 3,
 
 YueScript kini mendukung destrukturisasi parameter fungsi ketika argumen berupa objek. Dua bentuk destrukturisasi literal tabel tersedia:
 
-* **Literal berkurung kurawal/parameter objek**, memungkinkan nilai default opsional ketika field hilang (misalnya, `{:a, :b}`, `{a: a1 = 123}`).
+- **Literal berkurung kurawal/parameter objek**, memungkinkan nilai default opsional ketika field hilang (misalnya, `{:a, :b}`, `{a: a1 = 123}`).
 
-* **Sintaks tabel sederhana tanpa pembungkus**, dimulai dengan urutan key-value atau binding singkat dan berlanjut sampai ekspresi lain menghentikannya (misalnya, `:a, b: b1, :c`). Bentuk ini mengekstrak beberapa field dari objek yang sama.
+- **Sintaks tabel sederhana tanpa pembungkus**, dimulai dengan urutan key-value atau binding singkat dan berlanjut sampai ekspresi lain menghentikannya (misalnya, `:a, b: b1, :c`). Bentuk ini mengekstrak beberapa field dari objek yang sama.
 
 ```yuescript
 f1 = (:a, :b, :c) ->
@@ -373,6 +392,7 @@ f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
 arg1 = {a: 0}
 f2 arg1, arg2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -402,6 +422,7 @@ findFirstEven = (list): nil ->
         if sub % 2 == 0
           return sub
 ```
+
 <YueDisplay>
 
 ```yue
@@ -426,6 +447,7 @@ findFirstEven = (list) ->
           return sub
   nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -467,6 +489,7 @@ process = (...args) ->
 
 process 1, nil, 3, nil, 5
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/functions/function-stubs.md b/doc/docs/id-id/doc/functions/function-stubs.md
index 57ed5c1..87dfd73 100644
--- a/doc/docs/id-id/doc/functions/function-stubs.md
+++ b/doc/docs/id-id/doc/functions/function-stubs.md
@@ -24,6 +24,7 @@ run_callback my_object.write
 -- memungkinkan kita membundel objek ke fungsi baru
 run_callback my_object\write
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/getting-started/usage.md b/doc/docs/id-id/doc/getting-started/usage.md
index 85cad07..a9523f7 100644
--- a/doc/docs/id-id/doc/getting-started/usage.md
+++ b/doc/docs/id-id/doc/getting-started/usage.md
@@ -4,49 +4,51 @@
 
 Gunakan modul YueScript di Lua:
 
-* **Kasus 1**
-
-        Require "your_yuescript_entry.yue" di Lua.
-        ```Lua
-        require("yue")("your_yuescript_entry")
-        ```
-        Dan kode ini tetap bekerja ketika Anda mengompilasi "your_yuescript_entry.yue" menjadi "your_yuescript_entry.lua" di path yang sama. Pada file YueScript lainnya cukup gunakan **require** atau **import** biasa. Nomor baris pada pesan error juga akan ditangani dengan benar.
-
-* **Kasus 2**
-
-        Require modul YueScript dan tulis ulang pesan secara manual.
-
-        ```lua
-        local yue = require("yue")
-        yue.insert_loader()
-        local success, result = xpcall(function()
-          return require("yuescript_module_name")
-        end, function(err)
-          return yue.traceback(err)
-        end)
-        ```
-
-* **Kasus 3**
-
-        Gunakan fungsi kompiler YueScript di Lua.
-
-        ```lua
-        local yue = require("yue")
-        local codes, err, globals = yue.to_lua([[
-          f = ->
-            print "hello world"
-          f!
-        ]],{
-          implicit_return_root = true,
-          reserve_line_number = true,
-          lint_global = true,
-          space_over_tab = false,
-          options = {
-            target = "5.4",
-            path = "/script"
-          }
-        })
-        ```
+- **Kasus 1**
+
+  Require "your_yuescript_entry.yue" di Lua.
+
+  ```Lua
+  require("yue")("your_yuescript_entry")
+  ```
+
+  Dan kode ini tetap bekerja ketika Anda mengompilasi "your_yuescript_entry.yue" menjadi "your_yuescript_entry.lua" di path yang sama. Pada file YueScript lainnya cukup gunakan **require** atau **import** biasa. Nomor baris pada pesan error juga akan ditangani dengan benar.
+
+- **Kasus 2**
+
+  Require modul YueScript dan tulis ulang pesan secara manual.
+
+  ```lua
+  local yue = require("yue")
+  yue.insert_loader()
+  local success, result = xpcall(function()
+    return require("yuescript_module_name")
+  end, function(err)
+    return yue.traceback(err)
+  end)
+  ```
+
+- **Kasus 3**
+
+  Gunakan fungsi kompiler YueScript di Lua.
+
+  ```lua
+  local yue = require("yue")
+  local codes, err, globals = yue.to_lua([[
+    f = ->
+      print "hello world"
+    f!
+  ]],{
+    implicit_return_root = true,
+    reserve_line_number = true,
+    lint_global = true,
+    space_over_tab = false,
+    options = {
+      target = "5.4",
+      path = "/script"
+    }
+  })
+  ```
 
 ## Tool YueScript
 
@@ -99,14 +101,14 @@ Opsi:
 
 Gunakan kasus:
 
-Kompilasi semua file YueScript dengan ekstensi **.yue** secara rekursif di bawah path saat ini:  **yue .**
+Kompilasi semua file YueScript dengan ekstensi **.yue** secara rekursif di bawah path saat ini: **yue .**
 
-Kompilasi dan simpan hasil ke path target:  **yue -t /target/path/ .**
+Kompilasi dan simpan hasil ke path target: **yue -t /target/path/ .**
 
-Kompilasi dan pertahankan info debug:  **yue -l .**
+Kompilasi dan pertahankan info debug: **yue -l .**
 
-Kompilasi dan hasilkan kode yang diminisasi:  **yue -m .**
+Kompilasi dan hasilkan kode yang diminisasi: **yue -m .**
 
-Eksekusi kode mentah:  **yue -e 'print 123'**
+Eksekusi kode mentah: **yue -e 'print 123'**
 
-Eksekusi file YueScript:  **yue -e main.yue**
+Eksekusi file YueScript: **yue -e main.yue**
diff --git a/doc/docs/id-id/doc/language-basics/attributes.md b/doc/docs/id-id/doc/language-basics/attributes.md
index 5b92947..20b7c9c 100644
--- a/doc/docs/id-id/doc/language-basics/attributes.md
+++ b/doc/docs/id-id/doc/language-basics/attributes.md
@@ -6,6 +6,7 @@ Dukungan sintaks untuk atribut Lua 5.4. Anda juga masih bisa menggunakan deklara
 const a = 123
 close _ = <close>: -> print "Out of scope."
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ Anda dapat melakukan destrukturisasi dengan variabel yang diberi atribut sebagai
 const {:a, :b, c, d} = tb
 -- a = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ Anda juga bisa mendeklarasikan variabel global sebagai `const`.
 global const Constant = 123
 -- Constant = 1
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/language-basics/comment.md b/doc/docs/id-id/doc/language-basics/comment.md
index 99f7b51..058c66b 100644
--- a/doc/docs/id-id/doc/language-basics/comment.md
+++ b/doc/docs/id-id/doc/language-basics/comment.md
@@ -12,6 +12,7 @@ Tidak masalah.
 
 func --[[port]] 3000, --[[ip]] "192.168.1.1"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/language-basics/literals.md b/doc/docs/id-id/doc/language-basics/literals.md
index c17c310..93a547b 100644
--- a/doc/docs/id-id/doc/language-basics/literals.md
+++ b/doc/docs/id-id/doc/language-basics/literals.md
@@ -12,6 +12,7 @@ some_string = "Here is a string
 -- Interpolasi string hanya tersedia pada string dengan tanda kutip ganda.
 print "I am #{math.random! * 100}% sure."
 ```
+
 <YueDisplay>
 
 ```yue
@@ -34,6 +35,7 @@ integer = 1_000_000
 hex = 0xEF_BB_BF
 binary = 0B10011
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +57,7 @@ str = |
     - item1
     - #{expr}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -78,6 +81,7 @@ fn = ->
       bar: baz
   return str
 ```
+
 <YueDisplay>
 
 ```yue
@@ -99,6 +103,7 @@ str = |
   path: "C:\Program Files\App"
   note: 'He said: "#{Hello}!"'
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/language-basics/operator.md b/doc/docs/id-id/doc/language-basics/operator.md
index f3fe092..6e0030a 100644
--- a/doc/docs/id-id/doc/language-basics/operator.md
+++ b/doc/docs/id-id/doc/language-basics/operator.md
@@ -6,6 +6,7 @@ Semua operator biner dan unari Lua tersedia. Selain itu **!=** adalah alias untu
 tb\func! if tb ~= nil
 tb::func! if tb != nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -27,6 +28,7 @@ a = 5
 print 1 <= a <= 10
 -- output: true
 ```
+
 <YueDisplay>
 
 ```yue
@@ -64,6 +66,7 @@ print v(1) > v(2) <= v(3)
   false
 ]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +104,7 @@ Operator **[] =** digunakan untuk menambahkan nilai ke tabel.
 tab = []
 tab[] = "Value"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +122,7 @@ tbB = [4, 5, 6]
 tbA[] = ...tbB
 -- tbA sekarang [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -149,6 +154,7 @@ a = {1, 2, 3, x: 1}
 b = {4, 5, y: 1}
 merge = {...a, ...b}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -179,6 +185,7 @@ last = data.items[#]
 second_last = data.items[#-1]
 data.items[#] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -212,6 +219,7 @@ print d.value
 
 close _ = <close>: -> print "out of scope"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -245,6 +253,7 @@ print tb.value
 tb.<> = __index: {item: "hello"}
 print tb.item
 ```
+
 <YueDisplay>
 
 ```yue
@@ -266,6 +275,7 @@ Destrukturisasi metatable dengan kunci metamethod yang dikelilingi **<>**.
 {item, :new, :<close>, <index>: getter} = tb
 print item, new, close, getter
 ```
+
 <YueDisplay>
 
 ```yue
@@ -293,6 +303,7 @@ with? io.open "test.txt", "w"
   \write "hello"
   \close!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -329,6 +340,7 @@ readFile "example.txt"
   |> render
   |> print
 ```
+
 <YueDisplay>
 
 ```yue
@@ -349,6 +361,7 @@ readFile "example.txt"
 ## Nil Coalescing
 
 Operator nil-coalescing **??** mengembalikan nilai dari operan kiri jika bukan **nil**; jika tidak, operator mengevaluasi operan kanan dan mengembalikan hasilnya. Operator **??** tidak mengevaluasi operan kanan jika operan kiri bernilai non-nil.
+
 ```yuescript
 local a, b, c, d
 a = b ?? c ?? d
@@ -356,6 +369,7 @@ func a ?? {}
 
 a ??= false
 ```
+
 <YueDisplay>
 
 ```yue
@@ -413,6 +427,7 @@ tb =
       tb: { }
 
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/language-basics/whitespace.md b/doc/docs/id-id/doc/language-basics/whitespace.md
index bdc124e..486bcaa 100644
--- a/doc/docs/id-id/doc/language-basics/whitespace.md
+++ b/doc/docs/id-id/doc/language-basics/whitespace.md
@@ -9,6 +9,7 @@ Sebuah pernyataan biasanya berakhir pada pergantian baris. Anda juga bisa memaka
 ```yuescript
 a = 1; b = 2; print a + b
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ Rx.Observable
   \map (value) -> value .. '!'
   \subscribe print
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/objects/object-oriented-programming.md b/doc/docs/id-id/doc/objects/object-oriented-programming.md
index 96c19d7..7d5d420 100644
--- a/doc/docs/id-id/doc/objects/object-oriented-programming.md
+++ b/doc/docs/id-id/doc/objects/object-oriented-programming.md
@@ -15,6 +15,7 @@ class Inventory
     else
       @items[name] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -46,6 +47,7 @@ inv = Inventory!
 inv\add_item "t-shirt"
 inv\add_item "pants"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -77,6 +79,7 @@ b\give_item "shirt"
 -- akan mencetak pants dan shirt
 print item for item in *a.clothes
 ```
+
 <YueDisplay>
 
 ```yue
@@ -104,6 +107,7 @@ class Person
   new: =>
     @clothes = []
 ```
+
 <YueDisplay>
 
 ```yue
@@ -125,6 +129,7 @@ class BackPack extends Inventory
     if #@items > size then error "backpack is full"
     super name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -151,6 +156,7 @@ class Shelf
 -- akan mencetak: Shelf was inherited by Cupboard
 class Cupboard extends Shelf
 ```
+
 <YueDisplay>
 
 ```yue
@@ -189,6 +195,7 @@ class MyClass extends ParentClass
     -- super sebagai nilai sama dengan kelas induk:
     assert super == ParentClass
 ```
+
 <YueDisplay>
 
 ```yue
@@ -217,6 +224,7 @@ assert b.__class == BackPack
 
 print BackPack.size -- mencetak 10
 ```
+
 <YueDisplay>
 
 ```yue
@@ -247,6 +255,7 @@ Nama kelas saat dideklarasikan disimpan sebagai string di field `__name` pada ob
 ```yuescript
 print BackPack.__name -- mencetak Backpack
 ```
+
 <YueDisplay>
 
 ```yue
@@ -272,6 +281,7 @@ Things\some_func!
 -- variabel kelas tidak terlihat pada instance
 assert Things().some_func == nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -300,6 +310,7 @@ Counter!
 
 print Counter.count -- mencetak 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -322,6 +333,7 @@ Semantik pemanggilan `@@` mirip dengan `@`. Memanggil nama `@@` akan meneruskan
 ```yuescript
 @@hello 1,2,3,4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -340,6 +352,7 @@ Berikut cara alternatif untuk membuat variabel kelas dibandingkan yang dijelaska
 class Things
   @class_var = "hello world"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -361,6 +374,7 @@ class MoreThings
   some_method: =>
     log "hello world: " .. secret
 ```
+
 <YueDisplay>
 
 ```yue
@@ -384,6 +398,7 @@ Jika digunakan sendirian, keduanya adalah alias untuk `self` dan `self.__class`.
 assert @ == self
 assert @@ == self.__class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -398,6 +413,7 @@ Contohnya, cara cepat untuk membuat instance baru dari kelas yang sama dari meth
 ```yuescript
 some_instance_method = (...) => @@ ...
 ```
+
 <YueDisplay>
 
 ```yue
@@ -423,6 +439,7 @@ class Something
     @@biz = biz
     @@baz = baz
 ```
+
 <YueDisplay>
 
 ```yue
@@ -448,6 +465,7 @@ new = (@fieldA, @fieldB) => @
 obj = new {}, 123, "abc"
 print obj
 ```
+
 <YueDisplay>
 
 ```yue
@@ -467,6 +485,7 @@ x = class Bucket
   drops: 0
   add_drop: => @drops += 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -487,6 +506,7 @@ BigBucket = class extends Bucket
 
 assert Bucket.__name == "BigBucket"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -503,6 +523,7 @@ Anda bahkan bisa menghilangkan badan kelas, artinya Anda bisa menulis kelas anon
 ```yuescript
 x = class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -532,6 +553,7 @@ y\func!
 
 assert y.__class.__parent ~= X -- X bukan parent dari Y
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/objects/with-statement.md b/doc/docs/id-id/doc/objects/with-statement.md
index 3c0a8a5..96a3efd 100644
--- a/doc/docs/id-id/doc/objects/with-statement.md
+++ b/doc/docs/id-id/doc/objects/with-statement.md
@@ -15,6 +15,7 @@ with Person!
   \save!
   print .name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +34,7 @@ Pernyataan `with` juga bisa digunakan sebagai ekspresi yang mengembalikan nilai
 file = with File "favorite_foods.txt"
   \set_encoding "utf8"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -52,6 +54,7 @@ create_person = (name,  relatives) ->
 
 me = create_person "Leaf", [dad, mother, sister]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -74,6 +77,7 @@ with str := "Hello"
   print "original:", str
   print "upper:", \upper!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -95,6 +99,7 @@ with tb
     ["key-name"] = value
   [] = "abc" -- menambahkan ke "tb"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -115,6 +120,7 @@ with tb
 with? obj
   print obj.name
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/id-id/doc/reference/the-yuescript-library.md b/doc/docs/id-id/doc/reference/the-yuescript-library.md
index 0a398a5..3adfe63 100644
--- a/doc/docs/id-id/doc/reference/the-yuescript-library.md
+++ b/doc/docs/id-id/doc/reference/the-yuescript-library.md
@@ -17,6 +17,7 @@ Pustaka bahasa YueScript.
 Versi YueScript.
 
 **Signature:**
+
 ```lua
 version: string
 ```
@@ -30,6 +31,7 @@ version: string
 Pemisah file untuk platform saat ini.
 
 **Signature:**
+
 ```lua
 dirsep: string
 ```
@@ -43,6 +45,7 @@ dirsep: string
 Cache kode modul yang telah dikompilasi.
 
 **Signature:**
+
 ```lua
 yue_compiled: {string: string}
 ```
@@ -56,6 +59,7 @@ yue_compiled: {string: string}
 Fungsi kompilasi YueScript. Mengompilasi kode YueScript menjadi kode Lua.
 
 **Signature:**
+
 ```lua
 to_lua: function(code: string, config?: Config):
     --[[codes]] string | nil,
@@ -65,17 +69,17 @@ to_lua: function(code: string, config?: Config):
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| code | string | Kode YueScript. |
-| config | Config | [Opsional] Opsi kompiler. |
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| code      | string | Kode YueScript.           |
+| config    | Config | [Opsional] Opsi kompiler. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| string \| nil | Kode Lua hasil kompilasi, atau nil jika kompilasi gagal. |
-| string \| nil | Pesan error, atau nil jika kompilasi berhasil. |
+| Tipe Return                         | Deskripsi                                                                                                                         |
+| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| string \| nil                       | Kode Lua hasil kompilasi, atau nil jika kompilasi gagal.                                                                          |
+| string \| nil                       | Pesan error, atau nil jika kompilasi berhasil.                                                                                    |
 | {{string, integer, integer}} \| nil | Variabel global yang muncul dalam kode (dengan nama, baris, dan kolom), atau nil jika opsi kompiler `lint_global` bernilai false. |
 
 ### file_exist
@@ -87,21 +91,22 @@ to_lua: function(code: string, config?: Config):
 Fungsi untuk memeriksa keberadaan file sumber. Dapat ditimpa untuk menyesuaikan perilaku.
 
 **Signature:**
+
 ```lua
 file_exist: function(filename: string): boolean
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| filename | string | Nama file. |
+| Parameter | Tipe   | Deskripsi  |
+| --------- | ------ | ---------- |
+| filename  | string | Nama file. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| boolean | Apakah file ada. |
+| Tipe Return | Deskripsi        |
+| ----------- | ---------------- |
+| boolean     | Apakah file ada. |
 
 ### read_file
 
@@ -112,21 +117,22 @@ file_exist: function(filename: string): boolean
 Fungsi untuk membaca file sumber. Dapat ditimpa untuk menyesuaikan perilaku.
 
 **Signature:**
+
 ```lua
 read_file: function(filename: string): string
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| filename | string | Nama file. |
+| Parameter | Tipe   | Deskripsi  |
+| --------- | ------ | ---------- |
+| filename  | string | Nama file. |
 
 **Return:**
 
 | Tipe Return | Deskripsi |
-| --- | --- |
-| string | Isi file. |
+| ----------- | --------- |
+| string      | Isi file. |
 
 ### insert_loader
 
@@ -137,21 +143,22 @@ read_file: function(filename: string): string
 Menyisipkan loader YueScript ke package loaders (searchers).
 
 **Signature:**
+
 ```lua
 insert_loader: function(pos?: integer): boolean
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| pos | integer | [Opsional] Posisi untuk menyisipkan loader. Default adalah 3. |
+| Parameter | Tipe    | Deskripsi                                                     |
+| --------- | ------- | ------------------------------------------------------------- |
+| pos       | integer | [Opsional] Posisi untuk menyisipkan loader. Default adalah 3. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| boolean | Apakah loader berhasil disisipkan. Akan gagal jika loader sudah disisipkan. |
+| Tipe Return | Deskripsi                                                                   |
+| ----------- | --------------------------------------------------------------------------- |
+| boolean     | Apakah loader berhasil disisipkan. Akan gagal jika loader sudah disisipkan. |
 
 ### remove_loader
 
@@ -162,15 +169,16 @@ insert_loader: function(pos?: integer): boolean
 Menghapus loader YueScript dari package loaders (searchers).
 
 **Signature:**
+
 ```lua
 remove_loader: function(): boolean
 ```
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| boolean | Apakah loader berhasil dihapus. Akan gagal jika loader belum disisipkan. |
+| Tipe Return | Deskripsi                                                                |
+| ----------- | ------------------------------------------------------------------------ |
+| boolean     | Apakah loader berhasil dihapus. Akan gagal jika loader belum disisipkan. |
 
 ### loadstring
 
@@ -181,6 +189,7 @@ remove_loader: function(): boolean
 Memuat kode YueScript dari string menjadi fungsi.
 
 **Signature:**
+
 ```lua
 loadstring: function(input: string, chunkname: string, env: table, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -189,19 +198,19 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| input | string | Kode YueScript. |
-| chunkname | string | Nama chunk kode. |
-| env | table | Tabel environment. |
-| config | Config | [Opsional] Opsi kompiler. |
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| input     | string | Kode YueScript.           |
+| chunkname | string | Nama chunk kode.          |
+| env       | table  | Tabel environment.        |
+| config    | Config | [Opsional] Opsi kompiler. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
 | function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
-| string \| nil | Pesan error, atau nil jika pemuatan berhasil. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
 
 ### loadstring
 
@@ -212,6 +221,7 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 Memuat kode YueScript dari string menjadi fungsi.
 
 **Signature:**
+
 ```lua
 loadstring: function(input: string, chunkname: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -220,18 +230,18 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| input | string | Kode YueScript. |
-| chunkname | string | Nama chunk kode. |
-| config | Config | [Opsional] Opsi kompiler. |
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| input     | string | Kode YueScript.           |
+| chunkname | string | Nama chunk kode.          |
+| config    | Config | [Opsional] Opsi kompiler. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
 | function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
-| string \| nil | Pesan error, atau nil jika pemuatan berhasil. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
 
 ### loadstring
 
@@ -242,6 +252,7 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 Memuat kode YueScript dari string menjadi fungsi.
 
 **Signature:**
+
 ```lua
 loadstring: function(input: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -250,17 +261,17 @@ loadstring: function(input: string, config?: Config):
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| input | string | Kode YueScript. |
-| config | Config | [Opsional] Opsi kompiler. |
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| input     | string | Kode YueScript.           |
+| config    | Config | [Opsional] Opsi kompiler. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
 | function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
-| string \| nil | Pesan error, atau nil jika pemuatan berhasil. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
 
 ### loadfile
 
@@ -271,6 +282,7 @@ loadstring: function(input: string, config?: Config):
 Memuat kode YueScript dari file menjadi fungsi.
 
 **Signature:**
+
 ```lua
 loadfile: function(filename: string, env: table, config?: Config):
     nil | function(...: any): (any...),
@@ -279,18 +291,18 @@ loadfile: function(filename: string, env: table, config?: Config):
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| filename | string | Nama file. |
-| env | table | Tabel environment. |
-| config | Config | [Opsional] Opsi kompiler. |
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| filename  | string | Nama file.                |
+| env       | table  | Tabel environment.        |
+| config    | Config | [Opsional] Opsi kompiler. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
 | function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
-| string \| nil | Pesan error, atau nil jika pemuatan berhasil. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
 
 ### loadfile
 
@@ -301,6 +313,7 @@ loadfile: function(filename: string, env: table, config?: Config):
 Memuat kode YueScript dari file menjadi fungsi.
 
 **Signature:**
+
 ```lua
 loadfile: function(filename: string, config?: Config):
     nil | function(...: any): (any...),
@@ -309,17 +322,17 @@ loadfile: function(filename: string, config?: Config):
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| filename | string | Nama file. |
-| config | Config | [Opsional] Opsi kompiler. |
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| filename  | string | Nama file.                |
+| config    | Config | [Opsional] Opsi kompiler. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
 | function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
-| string \| nil | Pesan error, atau nil jika pemuatan berhasil. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
 
 ### dofile
 
@@ -330,23 +343,24 @@ loadfile: function(filename: string, config?: Config):
 Memuat kode YueScript dari file menjadi fungsi dan mengeksekusinya.
 
 **Signature:**
+
 ```lua
 dofile: function(filename: string, env: table, config?: Config): any...
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| filename | string | Nama file. |
-| env | table | Tabel environment. |
-| config | Config | [Opsional] Opsi kompiler. |
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| filename  | string | Nama file.                |
+| env       | table  | Tabel environment.        |
+| config    | Config | [Opsional] Opsi kompiler. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| any... | Nilai return dari fungsi yang dimuat. |
+| Tipe Return | Deskripsi                             |
+| ----------- | ------------------------------------- |
+| any...      | Nilai return dari fungsi yang dimuat. |
 
 ### dofile
 
@@ -357,22 +371,23 @@ dofile: function(filename: string, env: table, config?: Config): any...
 Memuat kode YueScript dari file menjadi fungsi dan mengeksekusinya.
 
 **Signature:**
+
 ```lua
 dofile: function(filename: string, config?: Config): any...
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| filename | string | Nama file. |
-| config | Config | [Opsional] Opsi kompiler. |
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| filename  | string | Nama file.                |
+| config    | Config | [Opsional] Opsi kompiler. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| any... | Nilai return dari fungsi yang dimuat. |
+| Tipe Return | Deskripsi                             |
+| ----------- | ------------------------------------- |
+| any...      | Nilai return dari fungsi yang dimuat. |
 
 ### find_modulepath
 
@@ -383,21 +398,22 @@ dofile: function(filename: string, config?: Config): any...
 Menguraikan nama modul YueScript menjadi path file.
 
 **Signature:**
+
 ```lua
 find_modulepath: function(name: string): string
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| name | string | Nama modul. |
+| Parameter | Tipe   | Deskripsi   |
+| --------- | ------ | ----------- |
+| name      | string | Nama modul. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| string | Path file. |
+| Tipe Return | Deskripsi  |
+| ----------- | ---------- |
+| string      | Path file. |
 
 ### pcall
 
@@ -410,21 +426,22 @@ Menangkap error apa pun dan mengembalikan kode status beserta hasil atau objek e
 Menulis ulang nomor baris error ke nomor baris asli di kode YueScript saat error terjadi.
 
 **Signature:**
+
 ```lua
 pcall: function(f: function, ...: any): boolean, any...
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| f | function | Fungsi yang akan dipanggil. |
-| ... | any | Argumen yang diteruskan ke fungsi. |
+| Parameter | Tipe     | Deskripsi                          |
+| --------- | -------- | ---------------------------------- |
+| f         | function | Fungsi yang akan dipanggil.        |
+| ...       | any      | Argumen yang diteruskan ke fungsi. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
+| Tipe Return  | Deskripsi                                      |
+| ------------ | ---------------------------------------------- |
 | boolean, ... | Kode status dan hasil fungsi atau objek error. |
 
 ### require
@@ -437,21 +454,22 @@ Memuat modul tertentu. Bisa berupa modul Lua atau modul YueScript.
 Menulis ulang nomor baris error ke nomor baris asli di kode YueScript jika modul adalah modul YueScript dan pemuatan gagal.
 
 **Signature:**
+
 ```lua
 require: function(name: string): any...
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| modname | string | Nama modul yang akan dimuat. |
+| Parameter | Tipe   | Deskripsi                    |
+| --------- | ------ | ---------------------------- |
+| modname   | string | Nama modul yang akan dimuat. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| any | Nilai yang disimpan di package.loaded[modname] jika modul sudah dimuat. Jika belum, mencoba mencari loader dan mengembalikan nilai akhir package.loaded[modname] serta data loader sebagai hasil kedua. |
+| Tipe Return | Deskripsi                                                                                                                                                                                               |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| any         | Nilai yang disimpan di package.loaded[modname] jika modul sudah dimuat. Jika belum, mencoba mencari loader dan mengembalikan nilai akhir package.loaded[modname] serta data loader sebagai hasil kedua. |
 
 ### p
 
@@ -462,15 +480,16 @@ require: function(name: string): any...
 Memeriksa struktur nilai yang diteruskan dan mencetak representasi string.
 
 **Signature:**
+
 ```lua
 p: function(...: any)
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| ... | any | Nilai yang akan diperiksa. |
+| Parameter | Tipe | Deskripsi                  |
+| --------- | ---- | -------------------------- |
+| ...       | any  | Nilai yang akan diperiksa. |
 
 ### options
 
@@ -481,6 +500,7 @@ p: function(...: any)
 Opsi kompiler saat ini.
 
 **Signature:**
+
 ```lua
 options: Config.Options
 ```
@@ -494,21 +514,22 @@ options: Config.Options
 Fungsi traceback yang menulis ulang nomor baris stack trace ke nomor baris asli di kode YueScript.
 
 **Signature:**
+
 ```lua
 traceback: function(message: string): string
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| message | string | Pesan traceback. |
+| Parameter | Tipe   | Deskripsi        |
+| --------- | ------ | ---------------- |
+| message   | string | Pesan traceback. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| string | Pesan traceback yang telah ditulis ulang. |
+| Tipe Return | Deskripsi                                 |
+| ----------- | ----------------------------------------- |
+| string      | Pesan traceback yang telah ditulis ulang. |
 
 ### is_ast
 
@@ -519,22 +540,23 @@ traceback: function(message: string): string
 Memeriksa apakah kode cocok dengan AST yang ditentukan.
 
 **Signature:**
+
 ```lua
 is_ast: function(astName: string, code: string): boolean
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| astName | string | Nama AST. |
-| code | string | Kode. |
+| Parameter | Tipe   | Deskripsi |
+| --------- | ------ | --------- |
+| astName   | string | Nama AST. |
+| code      | string | Kode.     |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| boolean | Apakah kode cocok dengan AST. |
+| Tipe Return | Deskripsi                     |
+| ----------- | ----------------------------- |
+| boolean     | Apakah kode cocok dengan AST. |
 
 ### AST
 
@@ -545,6 +567,7 @@ is_ast: function(astName: string, code: string): boolean
 Definisi tipe AST dengan nama, baris, kolom, dan sub-node.
 
 **Signature:**
+
 ```lua
 type AST = {string, integer, integer, any}
 ```
@@ -558,6 +581,7 @@ type AST = {string, integer, integer, any}
 Mengonversi kode menjadi AST.
 
 **Signature:**
+
 ```lua
 to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
     --[[AST]] AST | nil,
@@ -566,18 +590,18 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| code | string | Kode. |
-| flattenLevel | integer | [Opsional] Tingkat perataan. Semakin tinggi berarti semakin rata. Default 0. Maksimum 2. |
-| astName | string | [Opsional] Nama AST. Default "File". |
-| reserveComment | boolean | [Opsional] Apakah akan mempertahankan komentar asli. Default false. |
+| Parameter      | Tipe    | Deskripsi                                                                                |
+| -------------- | ------- | ---------------------------------------------------------------------------------------- |
+| code           | string  | Kode.                                                                                    |
+| flattenLevel   | integer | [Opsional] Tingkat perataan. Semakin tinggi berarti semakin rata. Default 0. Maksimum 2. |
+| astName        | string  | [Opsional] Nama AST. Default "File".                                                     |
+| reserveComment | boolean | [Opsional] Apakah akan mempertahankan komentar asli. Default false.                      |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| AST \| nil | AST, atau nil jika konversi gagal. |
+| Tipe Return   | Deskripsi                                     |
+| ------------- | --------------------------------------------- |
+| AST \| nil    | AST, atau nil jika konversi gagal.            |
 | string \| nil | Pesan error, atau nil jika konversi berhasil. |
 
 ### format
@@ -589,25 +613,26 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 Memformat kode YueScript.
 
 **Signature:**
+
 ```lua
 format: function(code: string, tabSize?: number, reserveComment?: boolean): string
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| code | string | Kode. |
-| tabSize | integer | [Opsional] Ukuran tab. Default 4. |
+| Parameter      | Tipe    | Deskripsi                                                     |
+| -------------- | ------- | ------------------------------------------------------------- |
+| code           | string  | Kode.                                                         |
+| tabSize        | integer | [Opsional] Ukuran tab. Default 4.                             |
 | reserveComment | boolean | [Opsional] Apakah mempertahankan komentar asli. Default true. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| string | Kode yang telah diformat. |
+| Tipe Return | Deskripsi                 |
+| ----------- | ------------------------- |
+| string      | Kode yang telah diformat. |
 
-### __call
+### \_\_call
 
 **Tipe:** Metamethod.
 
@@ -617,21 +642,22 @@ Me-require modul YueScript.
 Menulis ulang nomor baris error ke nomor baris asli di kode YueScript saat pemuatan gagal.
 
 **Signature:**
+
 ```lua
 metamethod __call: function(self: yue, module: string): any...
 ```
 
 **Parameter:**
 
-| Parameter | Tipe | Deskripsi |
-| --- | --- | --- |
-| module | string | Nama modul. |
+| Parameter | Tipe   | Deskripsi   |
+| --------- | ------ | ----------- |
+| module    | string | Nama modul. |
 
 **Return:**
 
-| Tipe Return | Deskripsi |
-| --- | --- |
-| any | Nilai modul. |
+| Tipe Return | Deskripsi    |
+| ----------- | ------------ |
+| any         | Nilai modul. |
 
 ## Config
 
@@ -648,6 +674,7 @@ Opsi kompilasi kompiler.
 Apakah kompiler harus mengumpulkan variabel global yang muncul dalam kode.
 
 **Signature:**
+
 ```lua
 lint_global: boolean
 ```
@@ -661,6 +688,7 @@ lint_global: boolean
 Apakah kompiler harus melakukan return implisit untuk blok kode root.
 
 **Signature:**
+
 ```lua
 implicit_return_root: boolean
 ```
@@ -674,6 +702,7 @@ implicit_return_root: boolean
 Apakah kompiler harus mempertahankan nomor baris asli di kode hasil kompilasi.
 
 **Signature:**
+
 ```lua
 reserve_line_number: boolean
 ```
@@ -687,6 +716,7 @@ reserve_line_number: boolean
 Apakah kompiler harus mempertahankan komentar asli di kode hasil kompilasi.
 
 **Signature:**
+
 ```lua
 reserve_comment: boolean
 ```
@@ -700,6 +730,7 @@ reserve_comment: boolean
 Apakah kompiler harus menggunakan karakter spasi alih-alih tab di kode hasil kompilasi.
 
 **Signature:**
+
 ```lua
 space_over_tab: boolean
 ```
@@ -713,6 +744,7 @@ space_over_tab: boolean
 Apakah kompiler harus memperlakukan kode yang akan dikompilasi sebagai modul yang sama dengan modul yang sedang dikompilasi. Untuk penggunaan internal saja.
 
 **Signature:**
+
 ```lua
 same_module: boolean
 ```
@@ -726,6 +758,7 @@ same_module: boolean
 Apakah pesan error kompiler harus menyertakan offset nomor baris. Untuk penggunaan internal saja.
 
 **Signature:**
+
 ```lua
 line_offset: integer
 ```
@@ -739,6 +772,7 @@ line_offset: integer
 Enumerasi versi Lua target.
 
 **Signature:**
+
 ```lua
 enum LuaTarget
   "5.1"
@@ -758,6 +792,7 @@ end
 Opsi tambahan untuk diteruskan ke fungsi kompilasi.
 
 **Signature:**
+
 ```lua
 options: Options
 ```
@@ -777,6 +812,7 @@ Definisi opsi kompiler tambahan.
 Versi Lua target untuk kompilasi.
 
 **Signature:**
+
 ```lua
 target: LuaTarget
 ```
@@ -790,6 +826,7 @@ target: LuaTarget
 Path pencarian modul tambahan.
 
 **Signature:**
+
 ```lua
 path: string
 ```
@@ -803,6 +840,7 @@ path: string
 Apakah akan menampilkan variabel local dalam pesan error traceback. Default false.
 
 **Signature:**
+
 ```lua
 dump_locals: boolean
 ```
@@ -816,6 +854,7 @@ dump_locals: boolean
 Apakah akan menyederhanakan pesan error. Default true.
 
 **Signature:**
+
 ```lua
 simplified: boolean
 ```
diff --git a/doc/docs/id-id/try/index.md b/doc/docs/id-id/try/index.md
index c31dc1c..c5127e2 100755
--- a/doc/docs/id-id/try/index.md
+++ b/doc/docs/id-id/try/index.md
@@ -5,6 +5,7 @@ next: false
 ---
 
 # Kompiler Online YueScript
+
 ---
 
 Coba YueScript di browser dengan WASM.
diff --git a/doc/docs/pt-br/doc/advanced/do.md b/doc/docs/pt-br/doc/advanced/do.md
index f13d8aa..503c551 100644
--- a/doc/docs/pt-br/doc/advanced/do.md
+++ b/doc/docs/pt-br/doc/advanced/do.md
@@ -8,6 +8,7 @@ do
   print var
 print var -- nil aqui
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ counter = do
 print counter!
 print counter!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -53,6 +55,7 @@ tbl = {
     1234
 }
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/advanced/line-decorators.md b/doc/docs/pt-br/doc/advanced/line-decorators.md
index 94d1004..aaf34ea 100644
--- a/doc/docs/pt-br/doc/advanced/line-decorators.md
+++ b/doc/docs/pt-br/doc/advanced/line-decorators.md
@@ -5,6 +5,7 @@ Por conveniência, o loop for e a instrução if podem ser aplicados a instruç�
 ```yuescript
 print "hello world" if name == "Rob"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -18,6 +19,7 @@ E com loops básicos:
 ```yuescript
 print "item: ", item for item in *items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +35,7 @@ game\update! while game\isRunning!
 
 reader\parse_line! until reader\eof!
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/advanced/macro.md b/doc/docs/pt-br/doc/advanced/macro.md
index 846d506..18d33e0 100644
--- a/doc/docs/pt-br/doc/advanced/macro.md
+++ b/doc/docs/pt-br/doc/advanced/macro.md
@@ -32,6 +32,7 @@ macro and = (...) -> "#{ table.concat {...}, ' and ' }"
 if $and f1!, f2!, f3!
   print "OK"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -68,6 +69,7 @@ if $and f1!, f2!, f3!
 ## Inserir códigos brutos
 
 Uma função macro pode retornar uma string YueScript ou uma tabela de configuração contendo códigos Lua.
+
 ```yuescript
 macro yueFunc = (var) -> "local #{var} = ->"
 $yueFunc funcA
@@ -93,6 +95,7 @@ if cond then
 end
 ]==]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -126,6 +129,7 @@ end
 ## Exportar macro
 
 Funções macro podem ser exportadas de um módulo e importadas em outro módulo. Você deve colocar funções export macro em um único arquivo para uso, e apenas definição de macro, importação de macro e expansão de macro inline podem ser colocadas no módulo exportador de macro.
+
 ```yuescript
 -- arquivo: utils.yue
 export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
@@ -140,6 +144,7 @@ import "utils" as {
 }
 [1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
 ```
+
 <YueDisplay>
 
 ```yue
@@ -164,10 +169,12 @@ import "utils" as {
 ## Macro embutida
 
 Existem algumas macros embutidas, mas você pode sobrescrevê-las declarando macros com os mesmos nomes.
+
 ```yuescript
 print $FILE -- obtém string do nome do módulo atual
 print $LINE -- obtém número 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -234,6 +241,7 @@ macro printNumAndStr = (num `Num, str `String) -> |
 
 $printNumAndStr 123, "hello"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -258,6 +266,7 @@ macro printNumAndStr = (num, str) ->
 
 $printNumAndStr 123, "hello"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/advanced/module.md b/doc/docs/pt-br/doc/advanced/module.md
index 34fd106..ed13107 100644
--- a/doc/docs/pt-br/doc/advanced/module.md
+++ b/doc/docs/pt-br/doc/advanced/module.md
@@ -28,6 +28,7 @@ do
   import "lpeg" as :C, :Ct, :Cmt
   import "export" as {one, two, Something:{umm:{ch}}}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -67,6 +68,7 @@ do
   import table.concat
   print concat ["a", tostring 1]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -98,6 +100,7 @@ do
   print FLAG
   FLAG = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -140,6 +143,7 @@ export y = ->
 export class Something
   umm: "cool"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -166,6 +170,7 @@ Fazendo export nomeado com desestruturação.
 export :loadstring, to_lua: tolua = yue
 export {itemA: {:fieldA = 'default'}} = tb
 ```
+
 <YueDisplay>
 
 ```yue
@@ -182,6 +187,7 @@ export.itemA = tb
 export.<index> = items
 export["a-b-c"] = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -208,6 +214,7 @@ else
 export with tmp
   j = 2000
 ```
+
 <YueDisplay>
 
 ```yue
@@ -234,6 +241,7 @@ export default ->
   print "hello"
   123
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/advanced/try.md b/doc/docs/pt-br/doc/advanced/try.md
index fbb4e87..0223feb 100644
--- a/doc/docs/pt-br/doc/advanced/try.md
+++ b/doc/docs/pt-br/doc/advanced/try.md
@@ -29,6 +29,7 @@ catch err
     print yue.traceback err
   print result
 ```
+
 <YueDisplay>
 
 ```yue
@@ -82,6 +83,7 @@ catch e
   print e
   e
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/assignment/assignment.md b/doc/docs/pt-br/doc/assignment/assignment.md
index 1da6bb0..ac3838f 100644
--- a/doc/docs/pt-br/doc/assignment/assignment.md
+++ b/doc/docs/pt-br/doc/assignment/assignment.md
@@ -7,6 +7,7 @@ hello = "world"
 a, b, c = 1, 2, 3
 hello = 123 -- usa a variável existente
 ```
+
 <YueDisplay>
 
 ```yue
@@ -20,6 +21,7 @@ hello = 123 -- usa a variável existente
 ## Atualização
 
 Você pode realizar atribuição de atualização com muitos operadores binários.
+
 ```yuescript
 x = 1
 x += 1
@@ -30,6 +32,7 @@ x %= 10
 s ..= "world" -- adiciona um novo local se a variável local não existir
 arg or= "valor padrão"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -48,10 +51,12 @@ arg or= "valor padrão"
 ## Atribuição encadeada
 
 Você pode fazer atribuição encadeada para atribuir múltiplos itens ao mesmo valor.
+
 ```yuescript
 a = b = c = d = e = 0
 x = y = z = f!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +67,7 @@ x = y = z = f!
 </YueDisplay>
 
 ## Locais explícitos
+
 ```yuescript
 do
   local a = 1
@@ -78,6 +84,7 @@ do
   a = 1
   B = 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -100,6 +107,7 @@ do
 </YueDisplay>
 
 ## Globais explícitos
+
 ```yuescript
 do
   global a = 1
@@ -116,6 +124,7 @@ do
   B = 2
   local Temp = "um valor local"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/assignment/destructuring-assignment.md b/doc/docs/pt-br/doc/assignment/destructuring-assignment.md
index 7692885..0c96d4a 100644
--- a/doc/docs/pt-br/doc/assignment/destructuring-assignment.md
+++ b/doc/docs/pt-br/doc/assignment/destructuring-assignment.md
@@ -12,6 +12,7 @@ thing = [1, 2]
 [a, b] = thing
 print a, b
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,6 +38,7 @@ print hello, the_day
 
 :day = obj -- OK fazer desestruturação simples sem chaves
 ```
+
 <YueDisplay>
 
 ```yue
@@ -68,6 +70,7 @@ obj2 = {
 {numbers: [first, second], properties: {color: color}} = obj2
 print first, second, color
 ```
+
 <YueDisplay>
 
 ```yue
@@ -95,6 +98,7 @@ Se a instrução de desestruturação for complicada, sinta-se à vontade para e
   }
 } = obj2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -113,6 +117,7 @@ Se a instrução de desestruturação for complicada, sinta-se à vontade para e
 ```yuescript
 {:concat, :insert} = table
 ```
+
 <YueDisplay>
 
 ```yue
@@ -126,6 +131,7 @@ Isso é efetivamente o mesmo que import, mas podemos renomear campos que queremo
 ```yuescript
 {:mix, :max, random: rand} = math
 ```
+
 <YueDisplay>
 
 ```yue
@@ -139,6 +145,7 @@ Você pode escrever valores padrão ao fazer desestruturação:
 ```yuescript
 {:name = "sem nome", :job = "sem emprego"} = person
 ```
+
 <YueDisplay>
 
 ```yue
@@ -152,6 +159,7 @@ Você pode usar `_` como placeholder ao fazer desestruturação de lista:
 ```yuescript
 [_, two, _, four] = items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -171,6 +179,7 @@ print first  -- imprime: first
 print bulk   -- imprime: {"second", "third", "fourth"}
 print last   -- imprime: last
 ```
+
 <YueDisplay>
 
 ```yue
@@ -195,6 +204,7 @@ O operador spread pode ser usado em diferentes posições para capturar diferent
 -- Capturar tudo exceto os elementos do meio
 [first, ..._, last] = orders
 ```
+
 <YueDisplay>
 
 ```yue
@@ -223,6 +233,7 @@ tuples = [
 for [left, right] in *tuples
   print left, right
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/assignment/if-assignment.md b/doc/docs/pt-br/doc/assignment/if-assignment.md
index 84094ed..7b1a852 100644
--- a/doc/docs/pt-br/doc/assignment/if-assignment.md
+++ b/doc/docs/pt-br/doc/assignment/if-assignment.md
@@ -6,6 +6,7 @@ Os blocos `if` e `elseif` podem receber uma atribuição no lugar de uma express
 if user := database.find_user "moon"
   print user.name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -23,6 +24,7 @@ elseif world := os.getenv "world"
 else
   print "nada :("
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,11 +39,13 @@ else
 </YueDisplay>
 
 Atribuição em if com múltiplos valores de retorno. Apenas o primeiro valor é verificado, os outros valores estão no escopo.
+
 ```yuescript
 if success, result := pcall -> "obter resultado sem problemas"
   print result -- variável result está no escopo
 print "OK"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -61,6 +65,7 @@ while byte := stream\read_one!
   -- fazer algo com o byte
   print byte
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/assignment/the-using-clause-controlling-destructive-assignment.md b/doc/docs/pt-br/doc/assignment/the-using-clause-controlling-destructive-assignment.md
index 02d4162..c49aa15 100644
--- a/doc/docs/pt-br/doc/assignment/the-using-clause-controlling-destructive-assignment.md
+++ b/doc/docs/pt-br/doc/assignment/the-using-clause-controlling-destructive-assignment.md
@@ -17,6 +17,7 @@ my_func!
 
 print i -- vai imprimir 0
 ```
+
 <YueDisplay>
 
 ```yue
@@ -52,6 +53,7 @@ my_func = (using nil) ->
 my_func!
 print i -- imprime 100, i não é afetado
 ```
+
 <YueDisplay>
 
 ```yue
@@ -80,6 +82,7 @@ my_func = (add using k, i) ->
 my_func(22)
 print i, k -- estes foram atualizados
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/assignment/varargs-assignment.md b/doc/docs/pt-br/doc/assignment/varargs-assignment.md
index 0aab540..6ac67e0 100644
--- a/doc/docs/pt-br/doc/assignment/varargs-assignment.md
+++ b/doc/docs/pt-br/doc/assignment/varargs-assignment.md
@@ -10,6 +10,7 @@ count = select '#', ...
 first = select 1, ...
 print ok, count, first
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/control-flow/conditionals.md b/doc/docs/pt-br/doc/control-flow/conditionals.md
index 94e41ec..bc12d4e 100644
--- a/doc/docs/pt-br/doc/control-flow/conditionals.md
+++ b/doc/docs/pt-br/doc/control-flow/conditionals.md
@@ -7,6 +7,7 @@ if have_coins
 else
   print "Sem moedas"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -25,6 +26,7 @@ Uma sintaxe curta para instruções únicas também pode ser usada:
 have_coins = false
 if have_coins then print "Tem moedas" else print "Sem moedas"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -40,6 +42,7 @@ Como instruções if podem ser usadas como expressões, isso também pode ser es
 have_coins = false
 print if have_coins then "Tem moedas" else "Sem moedas"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -65,6 +68,7 @@ else
 
 print message -- imprime: Sou muito alto
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,6 +94,7 @@ O oposto de if é unless:
 unless os.date("%A") == "Monday"
   print "não é segunda-feira!"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -102,6 +107,7 @@ unless os.date("%A") == "Monday"
 ```yuescript
 print "Você tem sorte!" unless math.random! > 0.1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -123,6 +129,7 @@ if a in [1, 3, 5, 7]
 if a in list
   print "verificando se `a` está na lista"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/control-flow/continue.md b/doc/docs/pt-br/doc/control-flow/continue.md
index 8a3cdff..645bcb4 100644
--- a/doc/docs/pt-br/doc/control-flow/continue.md
+++ b/doc/docs/pt-br/doc/control-flow/continue.md
@@ -9,6 +9,7 @@ while i < 10
   continue if i % 2 == 0
   print i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ odds = for x in *my_numbers
   continue if x % 2 == 1
   x
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/control-flow/for-loop.md b/doc/docs/pt-br/doc/control-flow/for-loop.md
index dfd8285..4c99e6d 100644
--- a/doc/docs/pt-br/doc/control-flow/for-loop.md
+++ b/doc/docs/pt-br/doc/control-flow/for-loop.md
@@ -12,6 +12,7 @@ for k = 1, 15, 2 -- um passo opcional fornecido
 for key, value in pairs object
   print key, value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +34,7 @@ Os operadores de slicing e **\*** podem ser usados, assim como com compreensões
 for item in *items[2, 4]
   print item
 ```
+
 <YueDisplay>
 
 ```yue
@@ -49,6 +51,7 @@ for item in *items do print item
 
 for j = 1, 10, 3 do print j
 ```
+
 <YueDisplay>
 
 ```yue
@@ -70,6 +73,7 @@ doubled_evens = for i = 1, 20
   else
     i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,6 +94,7 @@ Por exemplo, para encontrar o primeiro número maior que 10:
 first_large = for n in *numbers
   break n if n > 10
 ```
+
 <YueDisplay>
 
 ```yue
@@ -112,6 +117,7 @@ func_b = -> return for i = 1, 10 do i
 print func_a! -- imprime nil
 print func_b! -- imprime objeto table
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/control-flow/switch.md b/doc/docs/pt-br/doc/control-flow/switch.md
index 5c87327..bc41bad 100644
--- a/doc/docs/pt-br/doc/control-flow/switch.md
+++ b/doc/docs/pt-br/doc/control-flow/switch.md
@@ -11,6 +11,7 @@ switch name := "Dan"
   else
     print "Não sei quem você é com o nome #{name}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -39,6 +40,7 @@ next_number = switch b
   else
     error "não consigo contar tão alto!"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +64,7 @@ msg = switch math.random(1, 5)
   when 2 then "você quase tem sorte"
   else "não tão sortudo"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -87,6 +90,7 @@ switch math.random(1, 5) when 1
 else
   print "não tão sortudo"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -124,6 +128,7 @@ for item in *items
     when :width, :height
       print "tamanho #{width}, #{height}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -154,6 +159,7 @@ switch item
   when {pos: {:x = 50, :y = 200}}
     print "Vec2 #{x}, #{y}" -- a desestruturação de tabela ainda passará
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +187,7 @@ switch tb
   when [1, 2, b = 3] -- b tem valor padrão
     print "1, 2, #{b}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -206,6 +213,7 @@ switch tb
   else
     print "inválido"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -231,6 +239,7 @@ switch tb
   else
     print "inválido"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -257,6 +266,7 @@ switch tb
     ]
     print "correspondido", fourth
 ```
+
 <YueDisplay>
 
 ```yue
@@ -282,6 +292,7 @@ switch segments
     print "Recurso:", resource -- imprime: "logs"
     print "Ação:", action -- imprime: "view"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/control-flow/while-loop.md b/doc/docs/pt-br/doc/control-flow/while-loop.md
index f47f00c..2deb5aa 100644
--- a/doc/docs/pt-br/doc/control-flow/while-loop.md
+++ b/doc/docs/pt-br/doc/control-flow/while-loop.md
@@ -10,6 +10,7 @@ while i > 0
 
 while running == true do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ until i == 0
 
 until running == false do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +58,7 @@ repeat
   i -= 1
 until i == 0
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/data-structures/comprehensions.md b/doc/docs/pt-br/doc/data-structures/comprehensions.md
index 1694813..9651352 100644
--- a/doc/docs/pt-br/doc/data-structures/comprehensions.md
+++ b/doc/docs/pt-br/doc/data-structures/comprehensions.md
@@ -10,6 +10,7 @@ O seguinte cria uma cópia da tabela items mas com todos os valores dobrados.
 items = [ 1, 2, 3, 4 ]
 doubled = [item * 2 for i, item in ipairs items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ Os itens incluídos na nova tabela podem ser restringidos com uma cláusula when
 ```yuescript
 slice = [item for i, item in ipairs items when i > 1 and i < 3]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,6 +39,7 @@ Como é comum iterar sobre os valores de uma tabela indexada numericamente, um o
 ```yuescript
 doubled = [item * 2 for item in *items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ data =
 flat = [...v for k,v in pairs data]
 -- flat agora é [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -79,6 +83,7 @@ y_coords = [9, 2, 3]
 points = [ [x, y] for x in *x_coords \
 for y in *y_coords]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -96,6 +101,7 @@ Loops for numéricos também podem ser usados em compreensões:
 ```yuescript
 evens = [i for i = 1, 100 when i % 2 == 0]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -119,6 +125,7 @@ thing = {
 
 thing_copy = {k, v for k, v in pairs thing}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -136,6 +143,7 @@ thing_copy = {k, v for k, v in pairs thing}
 ```yuescript
 no_color = {k, v for k, v in pairs thing when k != "color"}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -150,6 +158,7 @@ O operador **\*** também é suportado. Aqui criamos uma tabela de consulta de r
 numbers = [1, 2, 3, 4]
 sqrts = {i, math.sqrt i for i in *numbers}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -167,6 +176,7 @@ Neste exemplo convertemos um array de pares em uma tabela onde o primeiro item d
 tuples = [ ["hello", "world"], ["foo", "bar"]]
 tbl = {unpack tuple for tuple in *tuples}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -185,6 +195,7 @@ Aqui podemos definir os limites mínimo e máximo, pegando todos os itens com í
 ```yuescript
 slice = [item for item in *items[1, 5]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -198,6 +209,7 @@ Qualquer um dos argumentos do slice pode ser omitido para usar um padrão sensat
 ```yuescript
 slice = [item for item in *items[2,]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -211,6 +223,7 @@ Se o limite mínimo for omitido, ele usa como padrão 1. Aqui fornecemos apenas
 ```yuescript
 slice = [item for item in *items[,,2]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -225,6 +238,7 @@ Tanto o limite mínimo quanto o máximo podem ser negativos, o que significa que
 -- pegar os últimos 4 itens
 slice = [item for item in *items[-4,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -239,6 +253,7 @@ O tamanho do passo também pode ser negativo, o que significa que os itens são
 ```yuescript
 reverse_slice = [item for item in *items[-1,1,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -258,6 +273,7 @@ sub_list = items[2, 4]
 -- pegar os últimos 4 itens
 last_four_items = items[-4, -1]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/data-structures/table-literals.md b/doc/docs/pt-br/doc/data-structures/table-literals.md
index f0fbdc5..23817ff 100644
--- a/doc/docs/pt-br/doc/data-structures/table-literals.md
+++ b/doc/docs/pt-br/doc/data-structures/table-literals.md
@@ -5,6 +5,7 @@ Como no Lua, as tabelas são delimitadas por chaves.
 ```yuescript
 some_values = [1, 2, 3, 4]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -22,6 +23,7 @@ some_values = {
   ["favorite food"]: "rice"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ profile =
   shoe_size: 13,
   favorite_foods: ["ice cream", "donuts"]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -63,6 +66,7 @@ values = {
   occupation: "crime fighting"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -83,6 +87,7 @@ my_function dance: "Tango", partner: "none"
 
 y = type: "dog", legs: 4, tails: 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +106,7 @@ tbl = {
   end: "hunger"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -121,6 +127,7 @@ person = { :hair, :height, shoe_size: 40 }
 
 print_table :hair, :height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -141,6 +148,7 @@ t = {
   "hello world": true
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -158,6 +166,7 @@ As tabelas Lua têm tanto uma parte array quanto uma parte hash, mas às vezes v
 some_values = [1, 2, 3, 4]
 list_with_one_element = [1, ]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/functions/backcalls.md b/doc/docs/pt-br/doc/functions/backcalls.md
index 924c10a..bc327a3 100644
--- a/doc/docs/pt-br/doc/functions/backcalls.md
+++ b/doc/docs/pt-br/doc/functions/backcalls.md
@@ -6,6 +6,7 @@ Backcalls são usados para desaninhar callbacks. Eles são definidos usando seta
 x <- f
 print "hello" .. x
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ Funções seta "fat" também estão disponíveis.
 <= f
 print @value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ Você pode especificar um placeholder para onde deseja que a função backcall v
 (x) <- map _, [1, 2, 3]
 x * 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ result, msg = do
   check info
 print result, msg
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/functions/function-literals.md b/doc/docs/pt-br/doc/functions/function-literals.md
index e63888f..590af71 100644
--- a/doc/docs/pt-br/doc/functions/function-literals.md
+++ b/doc/docs/pt-br/doc/functions/function-literals.md
@@ -6,6 +6,7 @@ Todas as funções são criadas usando uma expressão de função. Uma função
 my_function = ->
 my_function() -- chama a função vazia
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ func_b = ->
   value = 100
   print "The value:", value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ Se uma função não tem argumentos, ela pode ser chamada usando o operador !, e
 func_a!
 func_b()
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +59,7 @@ Funções com argumentos podem ser criadas precedendo a seta com uma lista de no
 ```yuescript
 sum = (x, y) -> print "sum", x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -72,6 +76,7 @@ print sum 10, 20
 
 a b c "a", "b", "c"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -88,6 +93,7 @@ Para evitar ambiguidade ao chamar funções, parênteses também podem ser usado
 ```yuescript
 print "x:", sum(10, 20), "y:", sum(30, 40)
 ```
+
 <YueDisplay>
 
 ```yue
@@ -104,6 +110,7 @@ As funções convertem a última instrução em seu corpo em uma instrução de
 sum = (x, y) -> x + y
 print "The sum is ", sum 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +125,7 @@ E se você precisar retornar explicitamente, pode usar a palavra-chave return:
 ```yuescript
 sum = (x, y) -> return x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -132,6 +140,7 @@ Assim como no Lua, as funções podem retornar múltiplos valores. A última ins
 mystery = (x, y) -> x + y, x - y
 a, b = mystery 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -148,6 +157,7 @@ Como é um idioma em Lua enviar um objeto como primeiro argumento ao chamar um m
 ```yuescript
 func = (num) => @value + num
 ```
+
 <YueDisplay>
 
 ```yue
@@ -165,6 +175,7 @@ my_function = (name = "something", height = 100) ->
   print "Hello I am", name
   print "My height is", height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +192,7 @@ Uma expressão de valor padrão de argumento é avaliada no corpo da função na
 some_args = (x = 100, y = x + 1000) ->
   print x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -202,6 +214,7 @@ b = x-10
 c = x -y
 d = x- z
 ```
+
 <YueDisplay>
 
 ```yue
@@ -223,6 +236,7 @@ Quando há um espaço após uma variável e um literal de string, a chamada de f
 x = func"hello" + 100
 y = func "hello" + 100
 ```
+
 <YueDisplay>
 
 ```yue
@@ -247,6 +261,7 @@ cool_func 1, 2,
   5, 6,
   7, 8
 ```
+
 <YueDisplay>
 
 ```yue
@@ -269,6 +284,7 @@ my_func 5, 6, 7,
     9, 1, 2,
   5, 4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -289,6 +305,7 @@ x = [
   8, 9, 10
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -309,6 +326,7 @@ y = [ my_func 1, 2, 3,
   5, 6, 7
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -335,6 +353,7 @@ if func 1, 2, 3,
   print "hello"
   print "I am inside if"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -357,9 +376,9 @@ if func 1, 2, 3,
 
 YueScript agora suporta desestruturação de parâmetros de função quando o argumento é um objeto. Duas formas de literais de tabela de desestruturação estão disponíveis:
 
-* **Literais/parâmetros de objeto envolvidos em chaves**, permitindo valores padrão opcionais quando os campos estão ausentes (ex.: `{:a, :b}`, `{a: a1 = 123}`).
+- **Literais/parâmetros de objeto envolvidos em chaves**, permitindo valores padrão opcionais quando os campos estão ausentes (ex.: `{:a, :b}`, `{a: a1 = 123}`).
 
-* **Sintaxe de tabela simples não envolvida**, começando com uma sequência de ligações chave-valor ou abreviadas e continuando até outra expressão terminá-la (ex.: `:a, b: b1, :c`). Esta forma extrai múltiplos campos do mesmo objeto.
+- **Sintaxe de tabela simples não envolvida**, começando com uma sequência de ligações chave-valor ou abreviadas e continuando até outra expressão terminá-la (ex.: `:a, b: b1, :c`). Esta forma extrai múltiplos campos do mesmo objeto.
 
 ```yuescript
 f1 = (:a, :b, :c) ->
@@ -373,6 +392,7 @@ f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
 arg1 = {a: 0}
 f2 arg1, arg2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -402,6 +422,7 @@ findFirstEven = (list): nil ->
         if sub % 2 == 0
           return sub
 ```
+
 <YueDisplay>
 
 ```yue
@@ -426,6 +447,7 @@ findFirstEven = (list) ->
           return sub
   nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -467,6 +489,7 @@ process = (...args) ->
 
 process 1, nil, 3, nil, 5
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/functions/function-stubs.md b/doc/docs/pt-br/doc/functions/function-stubs.md
index d13f8ed..74b7821 100644
--- a/doc/docs/pt-br/doc/functions/function-stubs.md
+++ b/doc/docs/pt-br/doc/functions/function-stubs.md
@@ -24,6 +24,7 @@ run_callback my_object.write
 -- nos permite empacotar o objeto em uma nova função
 run_callback my_object\write
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/getting-started/usage.md b/doc/docs/pt-br/doc/getting-started/usage.md
index 7653838..055c6c2 100644
--- a/doc/docs/pt-br/doc/getting-started/usage.md
+++ b/doc/docs/pt-br/doc/getting-started/usage.md
@@ -4,49 +4,51 @@
 
 Use o módulo YueScript em Lua:
 
-* **Caso 1**
-
-        Use require em "your_yuescript_entry.yue" no Lua.
-        ```Lua
-        require("yue")("your_yuescript_entry")
-        ```
-        E esse código continua funcionando quando você compila "your_yuescript_entry.yue" para "your_yuescript_entry.lua" no mesmo caminho. Nos demais arquivos YueScript, use normalmente o **require** ou **import**. Os números de linha nas mensagens de erro também serão tratados corretamente.
-
-* **Caso 2**
-
-        Requerer o módulo YueScript e reescrever a mensagem manualmente.
-
-        ```lua
-        local yue = require("yue")
-        yue.insert_loader()
-        local success, result = xpcall(function()
-          return require("yuescript_module_name")
-        end, function(err)
-          return yue.traceback(err)
-        end)
-        ```
-
-* **Caso 3**
-
-        Usar a função compiladora do YueScript em Lua.
-
-        ```lua
-        local yue = require("yue")
-        local codes, err, globals = yue.to_lua([[
-          f = ->
-            print "hello world"
-          f!
-        ]],{
-          implicit_return_root = true,
-          reserve_line_number = true,
-          lint_global = true,
-          space_over_tab = false,
-          options = {
-            target = "5.4",
-            path = "/script"
-          }
-        })
-        ```
+- **Caso 1**
+
+  Use require em "your_yuescript_entry.yue" no Lua.
+
+  ```Lua
+  require("yue")("your_yuescript_entry")
+  ```
+
+  E esse código continua funcionando quando você compila "your_yuescript_entry.yue" para "your_yuescript_entry.lua" no mesmo caminho. Nos demais arquivos YueScript, use normalmente o **require** ou **import**. Os números de linha nas mensagens de erro também serão tratados corretamente.
+
+- **Caso 2**
+
+  Requerer o módulo YueScript e reescrever a mensagem manualmente.
+
+  ```lua
+  local yue = require("yue")
+  yue.insert_loader()
+  local success, result = xpcall(function()
+    return require("yuescript_module_name")
+  end, function(err)
+    return yue.traceback(err)
+  end)
+  ```
+
+- **Caso 3**
+
+  Usar a função compiladora do YueScript em Lua.
+
+  ```lua
+  local yue = require("yue")
+  local codes, err, globals = yue.to_lua([[
+    f = ->
+      print "hello world"
+    f!
+  ]],{
+    implicit_return_root = true,
+    reserve_line_number = true,
+    lint_global = true,
+    space_over_tab = false,
+    options = {
+      target = "5.4",
+      path = "/script"
+    }
+  })
+  ```
 
 ## Ferramenta YueScript
 
diff --git a/doc/docs/pt-br/doc/language-basics/attributes.md b/doc/docs/pt-br/doc/language-basics/attributes.md
index 8e27f21..18bc585 100644
--- a/doc/docs/pt-br/doc/language-basics/attributes.md
+++ b/doc/docs/pt-br/doc/language-basics/attributes.md
@@ -6,6 +6,7 @@ Suporte de sintaxe para atributos do Lua 5.4. E você ainda pode usar tanto a de
 const a = 123
 close _ = <close>: -> print "Fora do escopo."
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ Você pode fazer desestruturação com variáveis atribuídas como constante.
 const {:a, :b, c, d} = tb
 -- a = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ Você também pode declarar uma variável global como `const`.
 global const Constant = 123
 -- Constant = 1
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/language-basics/comment.md b/doc/docs/pt-br/doc/language-basics/comment.md
index ed3102d..6316084 100644
--- a/doc/docs/pt-br/doc/language-basics/comment.md
+++ b/doc/docs/pt-br/doc/language-basics/comment.md
@@ -12,6 +12,7 @@ Está OK.
 
 func --[[port]] 3000, --[[ip]] "192.168.1.1"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/language-basics/literals.md b/doc/docs/pt-br/doc/language-basics/literals.md
index b32b73a..6db3f01 100644
--- a/doc/docs/pt-br/doc/language-basics/literals.md
+++ b/doc/docs/pt-br/doc/language-basics/literals.md
@@ -12,6 +12,7 @@ some_string = "Aqui está uma string
 -- Interpolação de string está disponível apenas em strings com aspas duplas.
 print "Tenho #{math.random! * 100}% de certeza."
 ```
+
 <YueDisplay>
 
 ```yue
@@ -34,6 +35,7 @@ integer = 1_000_000
 hex = 0xEF_BB_BF
 binary = 0B10011
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +57,7 @@ str = |
     - item1
     - #{expr}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -78,6 +81,7 @@ fn = ->
       bar: baz
   return str
 ```
+
 <YueDisplay>
 
 ```yue
@@ -99,6 +103,7 @@ str = |
   path: "C:\Program Files\App"
   note: 'Ele disse: "#{Hello}!"'
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/language-basics/operator.md b/doc/docs/pt-br/doc/language-basics/operator.md
index aba9c50..6371343 100644
--- a/doc/docs/pt-br/doc/language-basics/operator.md
+++ b/doc/docs/pt-br/doc/language-basics/operator.md
@@ -6,6 +6,7 @@ Todos os operadores binários e unários do Lua estão disponíveis. Além disso
 tb\func! if tb ~= nil
 tb::func! if tb != nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -27,6 +28,7 @@ a = 5
 print 1 <= a <= 10
 -- saída: true
 ```
+
 <YueDisplay>
 
 ```yue
@@ -64,6 +66,7 @@ print v(1) > v(2) <= v(3)
   false
 ]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +104,7 @@ O operador **[] =** é usado para anexar valores a tabelas.
 tab = []
 tab[] = "Value"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +122,7 @@ tbB = [4, 5, 6]
 tbA[] = ...tbB
 -- tbA agora é [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -149,6 +154,7 @@ a = {1, 2, 3, x: 1}
 b = {4, 5, y: 1}
 merge = {...a, ...b}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -179,6 +185,7 @@ last = data.items[#]
 second_last = data.items[#-1]
 data.items[#] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -212,6 +219,7 @@ print d.value
 
 close _ = <close>: -> print "fora do escopo"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -245,6 +253,7 @@ print tb.value
 tb.<> = __index: {item: "hello"}
 print tb.item
 ```
+
 <YueDisplay>
 
 ```yue
@@ -266,6 +275,7 @@ Desestruture a metatable com chave de metamétodo cercada por **<>**.
 {item, :new, :<close>, <index>: getter} = tb
 print item, new, close, getter
 ```
+
 <YueDisplay>
 
 ```yue
@@ -293,6 +303,7 @@ with? io.open "test.txt", "w"
   \write "hello"
   \close!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -329,6 +340,7 @@ readFile "example.txt"
   |> render
   |> print
 ```
+
 <YueDisplay>
 
 ```yue
@@ -349,6 +361,7 @@ readFile "example.txt"
 ## Coalescência de nil
 
 O operador de coalescência de nil **??** retorna o valor do operando esquerdo se não for **nil**; caso contrário, avalia o operando direito e retorna seu resultado. O operador **??** não avalia seu operando direito se o operando esquerdo avaliar para não-nil.
+
 ```yuescript
 local a, b, c, d
 a = b ?? c ?? d
@@ -356,6 +369,7 @@ func a ?? {}
 
 a ??= false
 ```
+
 <YueDisplay>
 
 ```yue
@@ -413,6 +427,7 @@ tb =
       tb: { }
 
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/language-basics/whitespace.md b/doc/docs/pt-br/doc/language-basics/whitespace.md
index df844f9..bad11d1 100644
--- a/doc/docs/pt-br/doc/language-basics/whitespace.md
+++ b/doc/docs/pt-br/doc/language-basics/whitespace.md
@@ -9,6 +9,7 @@ Uma instrução normalmente termina em uma quebra de linha. Você também pode u
 ```yuescript
 a = 1; b = 2; print a + b
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ Rx.Observable
   \map (value) -> value .. '!'
   \subscribe print
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/objects/object-oriented-programming.md b/doc/docs/pt-br/doc/objects/object-oriented-programming.md
index 3d5f061..54a559a 100644
--- a/doc/docs/pt-br/doc/objects/object-oriented-programming.md
+++ b/doc/docs/pt-br/doc/objects/object-oriented-programming.md
@@ -15,6 +15,7 @@ class Inventory
     else
       @items[name] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -46,6 +47,7 @@ inv = Inventory!
 inv\add_item "t-shirt"
 inv\add_item "pants"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -77,6 +79,7 @@ b\give_item "shirt"
 -- vai imprimir tanto pants quanto shirt
 print item for item in *a.clothes
 ```
+
 <YueDisplay>
 
 ```yue
@@ -104,6 +107,7 @@ class Person
   new: =>
     @clothes = []
 ```
+
 <YueDisplay>
 
 ```yue
@@ -125,6 +129,7 @@ class BackPack extends Inventory
     if #@items > size then error "backpack is full"
     super name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -141,7 +146,7 @@ Aqui estendemos nossa classe Inventory e limitamos a quantidade de itens que ela
 
 Neste exemplo, não definimos um construtor na subclasse, então o construtor da classe pai é chamado quando criamos uma nova instância. Se definirmos um construtor, podemos usar o método super para chamar o construtor pai.
 
-Sempre que uma classe herda de outra, ela envia uma mensagem à classe pai chamando o método __inherited na classe pai se ele existir. A função recebe dois argumentos: a classe que está sendo herdada e a classe filha.
+Sempre que uma classe herda de outra, ela envia uma mensagem à classe pai chamando o método \_\_inherited na classe pai se ele existir. A função recebe dois argumentos: a classe que está sendo herdada e a classe filha.
 
 ```yuescript
 class Shelf
@@ -151,6 +156,7 @@ class Shelf
 -- vai imprimir: Shelf was inherited by Cupboard
 class Cupboard extends Shelf
 ```
+
 <YueDisplay>
 
 ```yue
@@ -189,6 +195,7 @@ class MyClass extends ParentClass
     -- super como valor é igual à classe pai:
     assert super == ParentClass
 ```
+
 <YueDisplay>
 
 ```yue
@@ -209,7 +216,7 @@ class MyClass extends ParentClass
 
 ## Tipos
 
-Cada instância de uma classe carrega seu tipo consigo. Isso é armazenado na propriedade especial __class. Esta propriedade contém o objeto da classe. O objeto da classe é o que chamamos para construir uma nova instância. Também podemos indexar o objeto da classe para recuperar métodos e propriedades da classe.
+Cada instância de uma classe carrega seu tipo consigo. Isso é armazenado na propriedade especial \_\_class. Esta propriedade contém o objeto da classe. O objeto da classe é o que chamamos para construir uma nova instância. Também podemos indexar o objeto da classe para recuperar métodos e propriedades da classe.
 
 ```yuescript
 b = BackPack!
@@ -217,6 +224,7 @@ assert b.__class == BackPack
 
 print BackPack.size -- imprime 10
 ```
+
 <YueDisplay>
 
 ```yue
@@ -238,15 +246,16 @@ Uma classe é composta por duas tabelas. A própria tabela da classe e a tabela
 
 A metatable do objeto da classe lê propriedades da base se não existirem no objeto da classe. Isso significa que podemos acessar funções e propriedades diretamente da classe.
 
-É importante notar que atribuir ao objeto da classe não atribui à base, então não é uma forma válida de adicionar novos métodos às instâncias. Em vez disso, a base deve ser alterada explicitamente. Veja o campo __base abaixo.
+É importante notar que atribuir ao objeto da classe não atribui à base, então não é uma forma válida de adicionar novos métodos às instâncias. Em vez disso, a base deve ser alterada explicitamente. Veja o campo \_\_base abaixo.
 
 O objeto da classe tem algumas propriedades especiais:
 
-O nome da classe quando foi declarada é armazenado como string no campo __name do objeto da classe.
+O nome da classe quando foi declarada é armazenado como string no campo \_\_name do objeto da classe.
 
 ```yuescript
 print BackPack.__name -- imprime Backpack
 ```
+
 <YueDisplay>
 
 ```yue
@@ -255,9 +264,9 @@ print BackPack.__name -- imprime Backpack
 
 </YueDisplay>
 
-O objeto base é armazenado em __base. Podemos modificar esta tabela para adicionar funcionalidade a instâncias que já foram criadas e às que ainda serão criadas.
+O objeto base é armazenado em \_\_base. Podemos modificar esta tabela para adicionar funcionalidade a instâncias que já foram criadas e às que ainda serão criadas.
 
-Se a classe estende de algo, o objeto da classe pai é armazenado em __parent.
+Se a classe estende de algo, o objeto da classe pai é armazenado em \_\_parent.
 
 ## Variáveis de classe
 
@@ -272,6 +281,7 @@ Things\some_func!
 -- variáveis de classe não visíveis em instâncias
 assert Things().some_func == nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -286,7 +296,7 @@ assert Things().some_func == nil
 
 </YueDisplay>
 
-Em expressões, podemos usar @@ para acessar um valor armazenado no __class de self. Assim, @@hello é abreviação para self.__class.hello.
+Em expressões, podemos usar @@ para acessar um valor armazenado no **class de self. Assim, @@hello é abreviação para self.**class.hello.
 
 ```yuescript
 class Counter
@@ -300,6 +310,7 @@ Counter!
 
 print Counter.count -- imprime 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -322,6 +333,7 @@ A semântica de chamada de @@ é semelhante a @. Chamar um nome @@ passará a cl
 ```yuescript
 @@hello 1,2,3,4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -340,6 +352,7 @@ Aqui está uma forma alternativa de criar variável de classe comparada ao descr
 class Things
   @class_var = "hello world"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -361,6 +374,7 @@ class MoreThings
   some_method: =>
     log "hello world: " .. secret
 ```
+
 <YueDisplay>
 
 ```yue
@@ -376,14 +390,15 @@ class MoreThings
 
 ## Valores @ e @@
 
-Quando @ e @@ são prefixados na frente de um nome, eles representam, respectivamente, esse nome acessado em self e self.__class.
+Quando @ e @@ são prefixados na frente de um nome, eles representam, respectivamente, esse nome acessado em self e self.\_\_class.
 
-Se forem usados sozinhos, são aliases para self e self.__class.
+Se forem usados sozinhos, são aliases para self e self.\_\_class.
 
 ```yuescript
 assert @ == self
 assert @@ == self.__class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -398,6 +413,7 @@ Por exemplo, uma forma rápida de criar uma nova instância da mesma classe a pa
 ```yuescript
 some_instance_method = (...) => @@ ...
 ```
+
 <YueDisplay>
 
 ```yue
@@ -423,6 +439,7 @@ class Something
     @@biz = biz
     @@baz = baz
 ```
+
 <YueDisplay>
 
 ```yue
@@ -448,6 +465,7 @@ new = (@fieldA, @fieldB) => @
 obj = new {}, 123, "abc"
 print obj
 ```
+
 <YueDisplay>
 
 ```yue
@@ -467,6 +485,7 @@ x = class Bucket
   drops: 0
   add_drop: => @drops += 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -479,7 +498,7 @@ x = class Bucket
 
 ## Classes anônimas
 
-O nome pode ser omitido ao declarar uma classe. O atributo __name será nil, a menos que a expressão da classe esteja em uma atribuição. O nome no lado esquerdo da atribuição é usado em vez de nil.
+O nome pode ser omitido ao declarar uma classe. O atributo \_\_name será nil, a menos que a expressão da classe esteja em uma atribuição. O nome no lado esquerdo da atribuição é usado em vez de nil.
 
 ```yuescript
 BigBucket = class extends Bucket
@@ -487,6 +506,7 @@ BigBucket = class extends Bucket
 
 assert Bucket.__name == "BigBucket"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -503,6 +523,7 @@ Você pode até omitir o corpo, significando que pode escrever uma classe anôni
 ```yuescript
 x = class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -532,6 +553,7 @@ y\func!
 
 assert y.__class.__parent ~= X -- X não é pai de Y
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/objects/with-statement.md b/doc/docs/pt-br/doc/objects/with-statement.md
index 6495d09..e5a56e5 100644
--- a/doc/docs/pt-br/doc/objects/with-statement.md
+++ b/doc/docs/pt-br/doc/objects/with-statement.md
@@ -15,6 +15,7 @@ with Person!
   \save!
   print .name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +34,7 @@ A instrução with também pode ser usada como expressão que retorna o valor ao
 file = with File "favorite_foods.txt"
   \set_encoding "utf8"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -52,6 +54,7 @@ create_person = (name,  relatives) ->
 
 me = create_person "Leaf", [dad, mother, sister]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -74,6 +77,7 @@ with str := "Hello"
   print "original:", str
   print "upper:", \upper!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -95,6 +99,7 @@ with tb
     ["key-name"] = value
   [] = "abc" -- anexando a "tb"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -115,6 +120,7 @@ with tb
 with? obj
   print obj.name
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/pt-br/doc/reference/the-yuescript-library.md b/doc/docs/pt-br/doc/reference/the-yuescript-library.md
index 2a65ffb..7775cd5 100644
--- a/doc/docs/pt-br/doc/reference/the-yuescript-library.md
+++ b/doc/docs/pt-br/doc/reference/the-yuescript-library.md
@@ -17,6 +17,7 @@ A biblioteca da linguagem YueScript.
 A versão do YueScript.
 
 **Assinatura:**
+
 ```lua
 version: string
 ```
@@ -30,6 +31,7 @@ version: string
 O separador de arquivos da plataforma atual.
 
 **Assinatura:**
+
 ```lua
 dirsep: string
 ```
@@ -43,6 +45,7 @@ dirsep: string
 O cache de código de módulo compilado.
 
 **Assinatura:**
+
 ```lua
 yue_compiled: {string: string}
 ```
@@ -56,6 +59,7 @@ yue_compiled: {string: string}
 A função de compilação do YueScript. Compila o código YueScript para código Lua.
 
 **Assinatura:**
+
 ```lua
 to_lua: function(code: string, config?: Config):
     --[[codes]] string | nil,
@@ -65,17 +69,17 @@ to_lua: function(code: string, config?: Config):
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| code | string | O código YueScript. |
-| config | Config | [Opcional] As opções do compilador. |
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| code      | string | O código YueScript.                 |
+| config    | Config | [Opcional] As opções do compilador. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| string \| nil | O código Lua compilado, ou nil se a compilação falhou. |
-| string \| nil | A mensagem de erro, ou nil se a compilação foi bem-sucedida. |
+| Tipo de Retorno                     | Descrição                                                                                                                        |
+| ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| string \| nil                       | O código Lua compilado, ou nil se a compilação falhou.                                                                           |
+| string \| nil                       | A mensagem de erro, ou nil se a compilação foi bem-sucedida.                                                                     |
 | {{string, integer, integer}} \| nil | As variáveis globais que aparecem no código (com nome, linha e coluna), ou nil se a opção do compilador `lint_global` for false. |
 
 ### file_exist
@@ -87,21 +91,22 @@ to_lua: function(code: string, config?: Config):
 Função de verificação de existência do arquivo fonte. Pode ser sobrescrita para personalizar o comportamento.
 
 **Assinatura:**
+
 ```lua
 file_exist: function(filename: string): boolean
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| filename | string | O nome do arquivo. |
+| Parâmetro | Tipo   | Descrição          |
+| --------- | ------ | ------------------ |
+| filename  | string | O nome do arquivo. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| boolean | Se o arquivo existe. |
+| Tipo de Retorno | Descrição            |
+| --------------- | -------------------- |
+| boolean         | Se o arquivo existe. |
 
 ### read_file
 
@@ -112,21 +117,22 @@ file_exist: function(filename: string): boolean
 Função de leitura do arquivo fonte. Pode ser sobrescrita para personalizar o comportamento.
 
 **Assinatura:**
+
 ```lua
 read_file: function(filename: string): string
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| filename | string | O nome do arquivo. |
+| Parâmetro | Tipo   | Descrição          |
+| --------- | ------ | ------------------ |
+| filename  | string | O nome do arquivo. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| string | O conteúdo do arquivo. |
+| Tipo de Retorno | Descrição              |
+| --------------- | ---------------------- |
+| string          | O conteúdo do arquivo. |
 
 ### insert_loader
 
@@ -137,21 +143,22 @@ read_file: function(filename: string): string
 Insere o carregador YueScript nos carregadores de pacote (searchers).
 
 **Assinatura:**
+
 ```lua
 insert_loader: function(pos?: integer): boolean
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| pos | integer | [Opcional] A posição para inserir o carregador. Padrão é 3. |
+| Parâmetro | Tipo    | Descrição                                                   |
+| --------- | ------- | ----------------------------------------------------------- |
+| pos       | integer | [Opcional] A posição para inserir o carregador. Padrão é 3. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| boolean | Se o carregador foi inserido com sucesso. Falhará se o carregador já estiver inserido. |
+| Tipo de Retorno | Descrição                                                                              |
+| --------------- | -------------------------------------------------------------------------------------- |
+| boolean         | Se o carregador foi inserido com sucesso. Falhará se o carregador já estiver inserido. |
 
 ### remove_loader
 
@@ -162,15 +169,16 @@ insert_loader: function(pos?: integer): boolean
 Remove o carregador YueScript dos carregadores de pacote (searchers).
 
 **Assinatura:**
+
 ```lua
 remove_loader: function(): boolean
 ```
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| boolean | Se o carregador foi removido com sucesso. Falhará se o carregador não estiver inserido. |
+| Tipo de Retorno | Descrição                                                                               |
+| --------------- | --------------------------------------------------------------------------------------- |
+| boolean         | Se o carregador foi removido com sucesso. Falhará se o carregador não estiver inserido. |
 
 ### loadstring
 
@@ -181,6 +189,7 @@ remove_loader: function(): boolean
 Carrega código YueScript de uma string em uma função.
 
 **Assinatura:**
+
 ```lua
 loadstring: function(input: string, chunkname: string, env: table, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -189,19 +198,19 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| input | string | O código YueScript. |
-| chunkname | string | O nome do chunk de código. |
-| env | table | A tabela de ambiente. |
-| config | Config | [Opcional] As opções do compilador. |
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| input     | string | O código YueScript.                 |
+| chunkname | string | O nome do chunk de código.          |
+| env       | table  | A tabela de ambiente.               |
+| config    | Config | [Opcional] As opções do compilador. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| function \| nil | A função carregada, ou nil se o carregamento falhou. |
-| string \| nil | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
 
 ### loadstring
 
@@ -212,6 +221,7 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 Carrega código YueScript de uma string em uma função.
 
 **Assinatura:**
+
 ```lua
 loadstring: function(input: string, chunkname: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -220,18 +230,18 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| input | string | O código YueScript. |
-| chunkname | string | O nome do chunk de código. |
-| config | Config | [Opcional] As opções do compilador. |
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| input     | string | O código YueScript.                 |
+| chunkname | string | O nome do chunk de código.          |
+| config    | Config | [Opcional] As opções do compilador. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| function \| nil | A função carregada, ou nil se o carregamento falhou. |
-| string \| nil | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
 
 ### loadstring
 
@@ -242,6 +252,7 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 Carrega código YueScript de uma string em uma função.
 
 **Assinatura:**
+
 ```lua
 loadstring: function(input: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -250,17 +261,17 @@ loadstring: function(input: string, config?: Config):
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| input | string | O código YueScript. |
-| config | Config | [Opcional] As opções do compilador. |
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| input     | string | O código YueScript.                 |
+| config    | Config | [Opcional] As opções do compilador. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| function \| nil | A função carregada, ou nil se o carregamento falhou. |
-| string \| nil | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
 
 ### loadfile
 
@@ -271,6 +282,7 @@ loadstring: function(input: string, config?: Config):
 Carrega código YueScript de um arquivo em uma função.
 
 **Assinatura:**
+
 ```lua
 loadfile: function(filename: string, env: table, config?: Config):
     nil | function(...: any): (any...),
@@ -279,18 +291,18 @@ loadfile: function(filename: string, env: table, config?: Config):
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| filename | string | O nome do arquivo. |
-| env | table | A tabela de ambiente. |
-| config | Config | [Opcional] As opções do compilador. |
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| filename  | string | O nome do arquivo.                  |
+| env       | table  | A tabela de ambiente.               |
+| config    | Config | [Opcional] As opções do compilador. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| function \| nil | A função carregada, ou nil se o carregamento falhou. |
-| string \| nil | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
 
 ### loadfile
 
@@ -301,6 +313,7 @@ loadfile: function(filename: string, env: table, config?: Config):
 Carrega código YueScript de um arquivo em uma função.
 
 **Assinatura:**
+
 ```lua
 loadfile: function(filename: string, config?: Config):
     nil | function(...: any): (any...),
@@ -309,17 +322,17 @@ loadfile: function(filename: string, config?: Config):
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| filename | string | O nome do arquivo. |
-| config | Config | [Opcional] As opções do compilador. |
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| filename  | string | O nome do arquivo.                  |
+| config    | Config | [Opcional] As opções do compilador. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| function \| nil | A função carregada, ou nil se o carregamento falhou. |
-| string \| nil | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
 
 ### dofile
 
@@ -330,23 +343,24 @@ loadfile: function(filename: string, config?: Config):
 Carrega código YueScript de um arquivo em uma função e o executa.
 
 **Assinatura:**
+
 ```lua
 dofile: function(filename: string, env: table, config?: Config): any...
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| filename | string | O nome do arquivo. |
-| env | table | A tabela de ambiente. |
-| config | Config | [Opcional] As opções do compilador. |
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| filename  | string | O nome do arquivo.                  |
+| env       | table  | A tabela de ambiente.               |
+| config    | Config | [Opcional] As opções do compilador. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| any... | Os valores de retorno da função carregada. |
+| Tipo de Retorno | Descrição                                  |
+| --------------- | ------------------------------------------ |
+| any...          | Os valores de retorno da função carregada. |
 
 ### dofile
 
@@ -357,22 +371,23 @@ dofile: function(filename: string, env: table, config?: Config): any...
 Carrega código YueScript de um arquivo em uma função e o executa.
 
 **Assinatura:**
+
 ```lua
 dofile: function(filename: string, config?: Config): any...
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| filename | string | O nome do arquivo. |
-| config | Config | [Opcional] As opções do compilador. |
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| filename  | string | O nome do arquivo.                  |
+| config    | Config | [Opcional] As opções do compilador. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| any... | Os valores de retorno da função carregada. |
+| Tipo de Retorno | Descrição                                  |
+| --------------- | ------------------------------------------ |
+| any...          | Os valores de retorno da função carregada. |
 
 ### find_modulepath
 
@@ -383,21 +398,22 @@ dofile: function(filename: string, config?: Config): any...
 Resolve o nome do módulo YueScript para o caminho do arquivo.
 
 **Assinatura:**
+
 ```lua
 find_modulepath: function(name: string): string
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| name | string | O nome do módulo. |
+| Parâmetro | Tipo   | Descrição         |
+| --------- | ------ | ----------------- |
+| name      | string | O nome do módulo. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| string | O caminho do arquivo. |
+| Tipo de Retorno | Descrição             |
+| --------------- | --------------------- |
+| string          | O caminho do arquivo. |
 
 ### pcall
 
@@ -410,22 +426,23 @@ Captura quaisquer erros e retorna um código de status e resultados ou objeto de
 Reescreve o número da linha do erro para o número da linha original no código YueScript quando ocorrem erros.
 
 **Assinatura:**
+
 ```lua
 pcall: function(f: function, ...: any): boolean, any...
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| f | function | A função a chamar. |
-| ... | any | Argumentos a passar para a função. |
+| Parâmetro | Tipo     | Descrição                          |
+| --------- | -------- | ---------------------------------- |
+| f         | function | A função a chamar.                 |
+| ...       | any      | Argumentos a passar para a função. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| boolean, ... | Código de status e resultados da função ou objeto de erro. |
+| Tipo de Retorno | Descrição                                                  |
+| --------------- | ---------------------------------------------------------- |
+| boolean, ...    | Código de status e resultados da função ou objeto de erro. |
 
 ### require
 
@@ -437,21 +454,22 @@ Carrega um módulo dado. Pode ser um módulo Lua ou um módulo YueScript.
 Reescreve o número da linha do erro para o número da linha original no código YueScript se o módulo for um módulo YueScript e o carregamento falhar.
 
 **Assinatura:**
+
 ```lua
 require: function(name: string): any...
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| modname | string | O nome do módulo a carregar. |
+| Parâmetro | Tipo   | Descrição                    |
+| --------- | ------ | ---------------------------- |
+| modname   | string | O nome do módulo a carregar. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| any | O valor armazenado em package.loaded[modname] se o módulo já estiver carregado. Caso contrário, tenta encontrar um carregador e retorna o valor final de package.loaded[modname] e os dados do carregador como segundo resultado. |
+| Tipo de Retorno | Descrição                                                                                                                                                                                                                         |
+| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| any             | O valor armazenado em package.loaded[modname] se o módulo já estiver carregado. Caso contrário, tenta encontrar um carregador e retorna o valor final de package.loaded[modname] e os dados do carregador como segundo resultado. |
 
 ### p
 
@@ -462,15 +480,16 @@ require: function(name: string): any...
 Inspeciona as estruturas dos valores passados e imprime representações em string.
 
 **Assinatura:**
+
 ```lua
 p: function(...: any)
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| ... | any | Os valores a inspecionar. |
+| Parâmetro | Tipo | Descrição                 |
+| --------- | ---- | ------------------------- |
+| ...       | any  | Os valores a inspecionar. |
 
 ### options
 
@@ -481,6 +500,7 @@ p: function(...: any)
 As opções atuais do compilador.
 
 **Assinatura:**
+
 ```lua
 options: Config.Options
 ```
@@ -494,21 +514,22 @@ options: Config.Options
 A função traceback que reescreve os números das linhas do stack trace para os números das linhas originais no código YueScript.
 
 **Assinatura:**
+
 ```lua
 traceback: function(message: string): string
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| message | string | A mensagem de traceback. |
+| Parâmetro | Tipo   | Descrição                |
+| --------- | ------ | ------------------------ |
+| message   | string | A mensagem de traceback. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| string | A mensagem de traceback reescrita. |
+| Tipo de Retorno | Descrição                          |
+| --------------- | ---------------------------------- |
+| string          | A mensagem de traceback reescrita. |
 
 ### is_ast
 
@@ -519,22 +540,23 @@ traceback: function(message: string): string
 Verifica se o código corresponde ao AST especificado.
 
 **Assinatura:**
+
 ```lua
 is_ast: function(astName: string, code: string): boolean
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| astName | string | O nome do AST. |
-| code | string | O código. |
+| Parâmetro | Tipo   | Descrição      |
+| --------- | ------ | -------------- |
+| astName   | string | O nome do AST. |
+| code      | string | O código.      |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| boolean | Se o código corresponde ao AST. |
+| Tipo de Retorno | Descrição                       |
+| --------------- | ------------------------------- |
+| boolean         | Se o código corresponde ao AST. |
 
 ### AST
 
@@ -545,6 +567,7 @@ is_ast: function(astName: string, code: string): boolean
 A definição do tipo AST com nome, linha, coluna e subnós.
 
 **Assinatura:**
+
 ```lua
 type AST = {string, integer, integer, any}
 ```
@@ -558,6 +581,7 @@ type AST = {string, integer, integer, any}
 Converte o código para o AST.
 
 **Assinatura:**
+
 ```lua
 to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
     --[[AST]] AST | nil,
@@ -566,19 +590,19 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| code | string | O código. |
-| flattenLevel | integer | [Opcional] O nível de achatamento. Nível mais alto significa mais achatamento. Padrão é 0. Máximo é 2. |
-| astName | string | [Opcional] O nome do AST. Padrão é "File". |
-| reserveComment | boolean | [Opcional] Se deve preservar os comentários originais. Padrão é false. |
+| Parâmetro      | Tipo    | Descrição                                                                                              |
+| -------------- | ------- | ------------------------------------------------------------------------------------------------------ |
+| code           | string  | O código.                                                                                              |
+| flattenLevel   | integer | [Opcional] O nível de achatamento. Nível mais alto significa mais achatamento. Padrão é 0. Máximo é 2. |
+| astName        | string  | [Opcional] O nome do AST. Padrão é "File".                                                             |
+| reserveComment | boolean | [Opcional] Se deve preservar os comentários originais. Padrão é false.                                 |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| AST \| nil | O AST, ou nil se a conversão falhou. |
-| string \| nil | A mensagem de erro, ou nil se a conversão foi bem-sucedida. |
+| Tipo de Retorno | Descrição                                                   |
+| --------------- | ----------------------------------------------------------- |
+| AST \| nil      | O AST, ou nil se a conversão falhou.                        |
+| string \| nil   | A mensagem de erro, ou nil se a conversão foi bem-sucedida. |
 
 ### format
 
@@ -589,25 +613,26 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 Formata o código YueScript.
 
 **Assinatura:**
+
 ```lua
 format: function(code: string, tabSize?: number, reserveComment?: boolean): string
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| code | string | O código. |
-| tabSize | integer | [Opcional] O tamanho da tabulação. Padrão é 4. |
+| Parâmetro      | Tipo    | Descrição                                                             |
+| -------------- | ------- | --------------------------------------------------------------------- |
+| code           | string  | O código.                                                             |
+| tabSize        | integer | [Opcional] O tamanho da tabulação. Padrão é 4.                        |
 | reserveComment | boolean | [Opcional] Se deve preservar os comentários originais. Padrão é true. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| string | O código formatado. |
+| Tipo de Retorno | Descrição           |
+| --------------- | ------------------- |
+| string          | O código formatado. |
 
-### __call
+### \_\_call
 
 **Tipo:** Metamétodo.
 
@@ -617,21 +642,22 @@ Requer o módulo YueScript.
 Reescreve o número da linha do erro para o número da linha original no código YueScript quando o carregamento falha.
 
 **Assinatura:**
+
 ```lua
 metamethod __call: function(self: yue, module: string): any...
 ```
 
 **Parâmetros:**
 
-| Parâmetro | Tipo | Descrição |
-| --- | --- | --- |
-| module | string | O nome do módulo. |
+| Parâmetro | Tipo   | Descrição         |
+| --------- | ------ | ----------------- |
+| module    | string | O nome do módulo. |
 
 **Retorna:**
 
-| Tipo de Retorno | Descrição |
-| --- | --- |
-| any | O valor do módulo. |
+| Tipo de Retorno | Descrição          |
+| --------------- | ------------------ |
+| any             | O valor do módulo. |
 
 ## Config
 
@@ -648,6 +674,7 @@ As opções de compilação do compilador.
 Se o compilador deve coletar as variáveis globais que aparecem no código.
 
 **Assinatura:**
+
 ```lua
 lint_global: boolean
 ```
@@ -661,6 +688,7 @@ lint_global: boolean
 Se o compilador deve fazer retorno implícito para o bloco de código raiz.
 
 **Assinatura:**
+
 ```lua
 implicit_return_root: boolean
 ```
@@ -674,6 +702,7 @@ implicit_return_root: boolean
 Se o compilador deve preservar o número da linha original no código compilado.
 
 **Assinatura:**
+
 ```lua
 reserve_line_number: boolean
 ```
@@ -687,6 +716,7 @@ reserve_line_number: boolean
 Se o compilador deve preservar os comentários originais no código compilado.
 
 **Assinatura:**
+
 ```lua
 reserve_comment: boolean
 ```
@@ -700,6 +730,7 @@ reserve_comment: boolean
 Se o compilador deve usar o caractere de espaço em vez do caractere de tabulação no código compilado.
 
 **Assinatura:**
+
 ```lua
 space_over_tab: boolean
 ```
@@ -713,6 +744,7 @@ space_over_tab: boolean
 Se o compilador deve tratar o código a ser compilado como o mesmo módulo que está sendo compilado atualmente. Apenas para uso interno.
 
 **Assinatura:**
+
 ```lua
 same_module: boolean
 ```
@@ -726,6 +758,7 @@ same_module: boolean
 Se a mensagem de erro do compilador deve incluir o deslocamento do número da linha. Apenas para uso interno.
 
 **Assinatura:**
+
 ```lua
 line_offset: integer
 ```
@@ -739,6 +772,7 @@ line_offset: integer
 A enumeração da versão alvo do Lua.
 
 **Assinatura:**
+
 ```lua
 enum LuaTarget
   "5.1"
@@ -758,6 +792,7 @@ end
 As opções extras a serem passadas para a função de compilação.
 
 **Assinatura:**
+
 ```lua
 options: Options
 ```
@@ -777,6 +812,7 @@ A definição das opções extras do compilador.
 A versão alvo do Lua para a compilação.
 
 **Assinatura:**
+
 ```lua
 target: LuaTarget
 ```
@@ -790,6 +826,7 @@ target: LuaTarget
 O caminho de busca de módulo extra.
 
 **Assinatura:**
+
 ```lua
 path: string
 ```
@@ -803,6 +840,7 @@ path: string
 Se deve incluir as variáveis locais na mensagem de erro do traceback. Padrão é false.
 
 **Assinatura:**
+
 ```lua
 dump_locals: boolean
 ```
@@ -816,6 +854,7 @@ dump_locals: boolean
 Se deve simplificar a mensagem de erro. Padrão é true.
 
 **Assinatura:**
+
 ```lua
 simplified: boolean
 ```
diff --git a/doc/docs/pt-br/index.md b/doc/docs/pt-br/index.md
index 818bb58..e62095f 100644
--- a/doc/docs/pt-br/index.md
+++ b/doc/docs/pt-br/index.md
@@ -21,4 +21,5 @@ footer:
   message: Licença MIT.
   copyright: Copyright © 2017-2026 Li Jin. Todos os direitos reservados.
 ---
+
 ---
diff --git a/doc/docs/pt-br/try/index.md b/doc/docs/pt-br/try/index.md
index 624b3bf..918162d 100755
--- a/doc/docs/pt-br/try/index.md
+++ b/doc/docs/pt-br/try/index.md
@@ -1,4 +1,5 @@
 # Compilador online do YueScript
+
 ---
 
 Experimente YueScript no navegador com WASM.
diff --git a/doc/docs/try/index.md b/doc/docs/try/index.md
index 85a903b..37d513d 100755
--- a/doc/docs/try/index.md
+++ b/doc/docs/try/index.md
@@ -5,6 +5,7 @@ next: false
 ---
 
 # YueScript Online Compiler
+
 ---
 
 Try YueScript in the browser with WASM.
diff --git a/doc/docs/zh/doc/advanced/do.md b/doc/docs/zh/doc/advanced/do.md
index 52dca26..a2d5d19 100644
--- a/doc/docs/zh/doc/advanced/do.md
+++ b/doc/docs/zh/doc/advanced/do.md
@@ -8,6 +8,7 @@ do
   print var
 print var -- 这里是nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ counter = do
 print counter!
 print counter!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -53,6 +55,7 @@ tbl = {
     1234
 }
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/advanced/line-decorators.md b/doc/docs/zh/doc/advanced/line-decorators.md
index 86a1bd9..853e396 100644
--- a/doc/docs/zh/doc/advanced/line-decorators.md
+++ b/doc/docs/zh/doc/advanced/line-decorators.md
@@ -5,6 +5,7 @@
 ```yuescript
 print "你好，世界" if name == "Rob"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -18,6 +19,7 @@ print "你好，世界" if name == "Rob"
 ```yuescript
 print "项目: ", item for item in *items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +35,7 @@ game\update! while game\isRunning!
 
 reader\parse_line! until reader\eof!
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/advanced/macro.md b/doc/docs/zh/doc/advanced/macro.md
index 91be42c..64cfa6d 100644
--- a/doc/docs/zh/doc/advanced/macro.md
+++ b/doc/docs/zh/doc/advanced/macro.md
@@ -32,6 +32,7 @@ macro and = (...) -> "#{ table.concat {...}, ' and ' }"
 if $and f1!, f2!, f3!
   print "OK"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -94,6 +95,7 @@ if cond then
 end
 ]==]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -142,6 +144,7 @@ import "utils" as {
 }
 [1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
 ```
+
 <YueDisplay>
 
 ```yue
@@ -172,6 +175,7 @@ import "utils" as {
 print $FILE -- 获取当前模块名称的字符串
 print $LINE -- 获取当前代码行数：2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -202,6 +206,7 @@ macro BodyType = $Enum(
 print "有效的枚举类型:", $BodyType Static
 -- print "编译报错的枚举类型:", $BodyType Unknown
 ```
+
 <YueDisplay>
 
 ```yue
@@ -237,6 +242,7 @@ macro printNumAndStr = (num `Num, str `String) -> |
 
 $printNumAndStr 123, "hello"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -261,6 +267,7 @@ macro printNumAndStr = (num, str) ->
 
 $printNumAndStr 123, "hello"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/advanced/module.md b/doc/docs/zh/doc/advanced/module.md
index bae6618..6c90f0e 100644
--- a/doc/docs/zh/doc/advanced/module.md
+++ b/doc/docs/zh/doc/advanced/module.md
@@ -28,6 +28,7 @@ do
   import "lpeg" as :C, :Ct, :Cmt
   import "export" as {one, two, Something:{umm:{ch}}}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -67,6 +68,7 @@ do
   import table.concat
   print concat ["a", tostring 1]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -98,6 +100,7 @@ do
   print FLAG
   FLAG = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -140,6 +143,7 @@ export y = ->
 export class Something
   umm: "cool"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -166,6 +170,7 @@ export class Something
 export :loadstring, to_lua: tolua = yue
 export {itemA: {:fieldA = '默认值'}} = tb
 ```
+
 <YueDisplay>
 
 ```yue
@@ -182,6 +187,7 @@ export.itemA = tb
 export.<index> = items
 export["a-b-c"] = 123
 ```
+
 <YueDisplay>
 
 ```yue
@@ -208,6 +214,7 @@ else
 export with tmp
   j = 2000
 ```
+
 <YueDisplay>
 
 ```yue
@@ -234,6 +241,7 @@ export default ->
   print "你好"
   123
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/advanced/try.md b/doc/docs/zh/doc/advanced/try.md
index b4de24d..ef90831 100644
--- a/doc/docs/zh/doc/advanced/try.md
+++ b/doc/docs/zh/doc/advanced/try.md
@@ -29,6 +29,7 @@ catch err
     print yue.traceback err
   print result
 ```
+
 <YueDisplay>
 
 ```yue
@@ -82,6 +83,7 @@ catch e
   print e
   e
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/assignment/assignment.md b/doc/docs/zh/doc/assignment/assignment.md
index 49561fb..7245e18 100644
--- a/doc/docs/zh/doc/assignment/assignment.md
+++ b/doc/docs/zh/doc/assignment/assignment.md
@@ -7,6 +7,7 @@ hello = "world"
 a, b, c = 1, 2, 3
 hello = 123 -- 访问现有的变量
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ x %= 10
 s ..= "world" -- 如果执行更新的局部变量不存在，将新建一个局部变量
 arg or= "默认值"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -54,6 +56,7 @@ arg or= "默认值"
 a = b = c = d = e = 0
 x = y = z = f!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -81,6 +84,7 @@ do
   a = 1
   B = 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -120,6 +124,7 @@ do
   B = 2
   local Temp = "一个局部值"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/assignment/destructuring-assignment.md b/doc/docs/zh/doc/assignment/destructuring-assignment.md
index 29219d3..469071f 100644
--- a/doc/docs/zh/doc/assignment/destructuring-assignment.md
+++ b/doc/docs/zh/doc/assignment/destructuring-assignment.md
@@ -12,8 +12,8 @@ thing = [1, 2]
 [a, b] = thing
 print a, b
 ```
-<YueDisplay>
 
+<YueDisplay>
 
 ```yue
 thing = [1, 2]
@@ -38,6 +38,7 @@ print hello, the_day
 
 :day = obj -- 可以不带大括号进行简单的解构
 ```
+
 <YueDisplay>
 
 ```yue
@@ -69,6 +70,7 @@ obj2 = {
 {numbers: [first, second], properties: {color: color}} = obj2
 print first, second, color
 ```
+
 <YueDisplay>
 
 ```yue
@@ -96,6 +98,7 @@ print first, second, color
   }
 } = obj2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -114,6 +117,7 @@ print first, second, color
 ```yuescript
 {:concat, :insert} = table
 ```
+
 <YueDisplay>
 
 ```yue
@@ -127,6 +131,7 @@ print first, second, color
 ```yuescript
 {:mix, :max, random: rand} = math
 ```
+
 <YueDisplay>
 
 ```yue
@@ -140,6 +145,7 @@ print first, second, color
 ```yuescript
 {:name = "nameless", :job = "jobless"} = person
 ```
+
 <YueDisplay>
 
 ```yue
@@ -153,6 +159,7 @@ print first, second, color
 ```yuescript
 [_, two, _, four] = items
 ```
+
 <YueDisplay>
 
 ```yue
@@ -172,6 +179,7 @@ print first  -- 打印: first
 print bulk   -- 打印: {"second", "third", "fourth"}
 print last   -- 打印: last
 ```
+
 <YueDisplay>
 
 ```yue
@@ -196,6 +204,7 @@ print last   -- 打印: last
 -- 跳过中间的元素，只捕获第一个和最后一个元素
 [first, ..._, last] = orders
 ```
+
 <YueDisplay>
 
 ```yue
@@ -224,6 +233,7 @@ tuples = [
 for [left, right] in *tuples
   print left, right
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/assignment/if-assignment.md b/doc/docs/zh/doc/assignment/if-assignment.md
index e4077e1..915b1d5 100644
--- a/doc/docs/zh/doc/assignment/if-assignment.md
+++ b/doc/docs/zh/doc/assignment/if-assignment.md
@@ -6,6 +6,7 @@
 if user := database.find_user "moon"
   print user.name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -23,6 +24,7 @@ elseif world := os.getenv "world"
 else
   print "什么都没有 :("
 ```
+
 <YueDisplay>
 
 ```yue
@@ -43,6 +45,7 @@ if success, result := pcall -> "无报错地获取结果"
   print result -- 变量 result 是有作用域的
 print "好的"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +65,7 @@ while byte := stream\read_one!
   -- 对 byte 做一些操作
   print byte
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/assignment/the-using-clause-controlling-destructive-assignment.md b/doc/docs/zh/doc/assignment/the-using-clause-controlling-destructive-assignment.md
index 722de6f..8a9acf4 100644
--- a/doc/docs/zh/doc/assignment/the-using-clause-controlling-destructive-assignment.md
+++ b/doc/docs/zh/doc/assignment/the-using-clause-controlling-destructive-assignment.md
@@ -17,6 +17,7 @@ my_func!
 
 print i -- 将打印 0
 ```
+
 <YueDisplay>
 
 ```yue
@@ -52,6 +53,7 @@ my_func = (using nil) ->
 my_func!
 print i -- 打印 100，i 没有受到影响
 ```
+
 <YueDisplay>
 
 ```yue
@@ -80,6 +82,7 @@ my_func = (add using k, i) ->
 my_func(22)
 print i, k -- 这些已经被更新
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/assignment/varargs-assignment.md b/doc/docs/zh/doc/assignment/varargs-assignment.md
index 6cc4278..cc9206e 100644
--- a/doc/docs/zh/doc/assignment/varargs-assignment.md
+++ b/doc/docs/zh/doc/assignment/varargs-assignment.md
@@ -10,6 +10,7 @@ count = select '#', ...
 first = select 1, ...
 print ok, count, first
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/control-flow/conditionals.md b/doc/docs/zh/doc/control-flow/conditionals.md
index ba77f40..3a4d5d1 100644
--- a/doc/docs/zh/doc/control-flow/conditionals.md
+++ b/doc/docs/zh/doc/control-flow/conditionals.md
@@ -7,6 +7,7 @@ if have_coins
 else
   print "没有硬币"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -25,6 +26,7 @@ else
 have_coins = false
 if have_coins then print "有硬币" else print "没有硬币"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -40,6 +42,7 @@ if have_coins then print "有硬币" else print "没有硬币"
 have_coins = false
 print if have_coins then "有硬币" else "没有硬币"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -65,6 +68,7 @@ else
 
 print message -- 打印: 我很高
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,8 +94,8 @@ print message -- 打印: 我很高
 unless os.date("%A") == "Monday"
   print "今天不是星期一！"
 ```
-<YueDisplay>
 
+<YueDisplay>
 
 ```yue
 unless os.date("%A") == "Monday"
@@ -103,6 +107,7 @@ unless os.date("%A") == "Monday"
 ```yuescript
 print "你真幸运！" unless math.random! > 0.1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -124,6 +129,7 @@ if a in [1, 3, 5, 7]
 if a in list
   print "检查`a`是否在列表中"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/control-flow/continue.md b/doc/docs/zh/doc/control-flow/continue.md
index 9fab8a3..3b1a093 100644
--- a/doc/docs/zh/doc/control-flow/continue.md
+++ b/doc/docs/zh/doc/control-flow/continue.md
@@ -9,6 +9,7 @@ while i < 10
   continue if i % 2 == 0
   print i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ odds = for x in *my_numbers
   continue if x % 2 == 1
   x
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/control-flow/for-loop.md b/doc/docs/zh/doc/control-flow/for-loop.md
index 212ff81..52180b7 100644
--- a/doc/docs/zh/doc/control-flow/for-loop.md
+++ b/doc/docs/zh/doc/control-flow/for-loop.md
@@ -12,6 +12,7 @@ for k = 1, 15, 2 -- 提供了一个遍历的步长
 for key, value in pairs object
   print key, value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -33,6 +34,7 @@ for key, value in pairs object
 for item in *items[2, 4]
   print item
 ```
+
 <YueDisplay>
 
 ```yue
@@ -49,6 +51,7 @@ for item in *items do print item
 
 for j = 1, 10, 3 do print j
 ```
+
 <YueDisplay>
 
 ```yue
@@ -70,6 +73,7 @@ doubled_evens = for i = 1, 20
   else
     i
 ```
+
 <YueDisplay>
 
 ```yue
@@ -90,6 +94,7 @@ doubled_evens = for i = 1, 20
 first_large = for n in *numbers
   break n if n > 10
 ```
+
 <YueDisplay>
 
 ```yue
@@ -110,6 +115,7 @@ func_b = -> return for i = 1, 10 do i
 print func_a! -- 打印 nil
 print func_b! -- 打印 table 对象
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/control-flow/switch.md b/doc/docs/zh/doc/control-flow/switch.md
index 700bc2a..69ba5b5 100644
--- a/doc/docs/zh/doc/control-flow/switch.md
+++ b/doc/docs/zh/doc/control-flow/switch.md
@@ -11,6 +11,7 @@ switch name := "Dan"
   else
     print "我不认识你，你的名字是#{name}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -39,6 +40,7 @@ next_number = switch b
   else
     error "数字数得太大了！"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -62,6 +64,7 @@ msg = switch math.random(1, 5)
   when 2 then "你差点很幸运"
   else "不太幸运"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -87,6 +90,7 @@ switch math.random(1, 5) when 1
 else
   print "不太幸运"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -124,6 +128,7 @@ for item in *items
     when :width, :height
       print "尺寸 #{width}, #{height}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -154,6 +159,7 @@ switch item
   when {pos: {:x = 50, :y = 200}}
     print "Vec2 #{x}, #{y}" -- 表格解构仍然会通过
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +187,7 @@ switch tb
   when [1, 2, b = 3] -- 变量b有默认值
     print "1, 2, #{b}"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -206,6 +213,7 @@ switch tb
   else
     print "无效值"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -231,6 +239,7 @@ switch tb
   else
     print "无效值"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -257,6 +266,7 @@ switch tb
     ]
     print "匹配成功", fourth
 ```
+
 <YueDisplay>
 
 ```yue
@@ -282,6 +292,7 @@ switch segments
     print "Resource:", resource -- 打印: "logs"
     print "Action:", action -- 打印: "view"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/control-flow/while-loop.md b/doc/docs/zh/doc/control-flow/while-loop.md
index 5995890..3c624fe 100644
--- a/doc/docs/zh/doc/control-flow/while-loop.md
+++ b/doc/docs/zh/doc/control-flow/while-loop.md
@@ -10,6 +10,7 @@ while i > 0
 
 while running == true do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -31,6 +32,7 @@ until i == 0
 
 until running == false do my_function!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +58,7 @@ repeat
   i -= 1
 until i == 0
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/data-structures/comprehensions.md b/doc/docs/zh/doc/data-structures/comprehensions.md
index fd25b22..62f0896 100644
--- a/doc/docs/zh/doc/data-structures/comprehensions.md
+++ b/doc/docs/zh/doc/data-structures/comprehensions.md
@@ -10,6 +10,7 @@
 items = [1, 2, 3, 4]
 doubled = [item * 2 for i, item in ipairs items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ doubled = [item * 2 for i, item in ipairs items]
 ```yuescript
 slice = [item for i, item in ipairs items when i > 1 and i < 3]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -37,6 +39,7 @@ slice = [item for i, item in ipairs items when i > 1 and i < 3]
 ```yuescript
 doubled = [item * 2 for item in *items]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ data =
 flat = [...v for k,v in pairs data]
 -- flat 现在为 [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -79,6 +83,7 @@ y_coords = [9, 2, 3]
 points = [ [x, y] for x in *x_coords \
 for y in *y_coords]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -96,6 +101,7 @@ for y in *y_coords]
 ```yuescript
 evens = [i for i = 1, 100 when i % 2 == 0]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -119,6 +125,7 @@ thing = {
 
 thing_copy = {k, v for k, v in pairs thing}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -136,6 +143,7 @@ thing_copy = {k, v for k, v in pairs thing}
 ```yuescript
 no_color = {k, v for k, v in pairs thing when k != "color"}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -150,6 +158,7 @@ no_color = {k, v for k, v in pairs thing when k != "color"}
 numbers = [1, 2, 3, 4]
 sqrts = {i, math.sqrt i for i in *numbers}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -167,6 +176,7 @@ sqrts = {i, math.sqrt i for i in *numbers}
 tuples = [ ["hello", "world"], ["foo", "bar"]]
 tbl = {unpack tuple for tuple in *tuples}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -185,6 +195,7 @@ tbl = {unpack tuple for tuple in *tuples}
 ```yuescript
 slice = [item for item in *items[1, 5]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -198,6 +209,7 @@ slice = [item for item in *items[1, 5]]
 ```yuescript
 slice = [item for item in *items[2,]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -211,8 +223,8 @@ slice = [item for item in *items[2,]]
 ```yuescript
 slice = [item for item in *items[,,2]]
 ```
-<YueDisplay>
 
+<YueDisplay>
 
 ```yue
 slice = [item for item in *items[,,2]]
@@ -226,6 +238,7 @@ slice = [item for item in *items[,,2]]
 -- 取最后4个元素
 slice = [item for item in *items[-4,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -240,6 +253,7 @@ slice = [item for item in *items[-4,-1]]
 ```yuescript
 reverse_slice = [item for item in *items[-1,1,-1]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -259,6 +273,7 @@ sub_list = items[2, 4]
 -- 取最后4个元素作为新的列表
 last_four_items = items[-4, -1]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/data-structures/table-literals.md b/doc/docs/zh/doc/data-structures/table-literals.md
index a111950..a8ff9b8 100644
--- a/doc/docs/zh/doc/data-structures/table-literals.md
+++ b/doc/docs/zh/doc/data-structures/table-literals.md
@@ -5,6 +5,7 @@
 ```yuescript
 some_values = [1, 2, 3, 4]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -22,6 +23,7 @@ some_values = {
   ["favorite food"]: "rice"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ profile =
   shoe_size: 13,
   favorite_foods: ["冰淇淋", "甜甜圈"]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -63,6 +66,7 @@ values = {
   occupation: "打击犯罪"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -83,6 +87,7 @@ my_function dance: "探戈", partner: "无"
 
 y = type: "狗", legs: 4, tails: 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +106,7 @@ tbl = {
   end: "饥饿"
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -121,6 +127,7 @@ person = { :hair, :height, shoe_size: 40 }
 
 print_table :hair, :height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -141,6 +148,7 @@ t = {
   "你好 世界": true
 }
 ```
+
 <YueDisplay>
 
 ```yue
@@ -158,6 +166,7 @@ t = {
 some_values = [ 1, 2, 3, 4 ]
 list_with_one_element = [ 1, ]
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/functions/backcalls.md b/doc/docs/zh/doc/functions/backcalls.md
index 4c32fac..7baac90 100644
--- a/doc/docs/zh/doc/functions/backcalls.md
+++ b/doc/docs/zh/doc/functions/backcalls.md
@@ -6,6 +6,7 @@
 x <- f
 print "hello" .. x
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ print "hello" .. x
 <= f
 print @value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ print @value
 (x) <- map _, [1, 2, 3]
 x * 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -55,6 +58,7 @@ result, msg = do
   check info
 print result, msg
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/functions/function-literals.md b/doc/docs/zh/doc/functions/function-literals.md
index efe920b..163d155 100644
--- a/doc/docs/zh/doc/functions/function-literals.md
+++ b/doc/docs/zh/doc/functions/function-literals.md
@@ -6,6 +6,7 @@
 my_function = ->
 my_function() -- 调用空函数
 ```
+
 <YueDisplay>
 
 ```yue
@@ -24,6 +25,7 @@ func_b = ->
   value = 100
   print "这个值是：", value
 ```
+
 <YueDisplay>
 
 ```yue
@@ -42,6 +44,7 @@ func_b = ->
 func_a!
 func_b()
 ```
+
 <YueDisplay>
 
 ```yue
@@ -56,6 +59,7 @@ func_b()
 ```yuescript
 sum = (x, y) -> print "数字的和", x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -72,6 +76,7 @@ print sum 10, 20
 
 a b c "a", "b", "c"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -88,6 +93,7 @@ a b c "a", "b", "c"
 ```yuescript
 print "x:", sum(10, 20), "y:", sum(30, 40)
 ```
+
 <YueDisplay>
 
 ```yue
@@ -104,6 +110,7 @@ print "x:", sum(10, 20), "y:", sum(30, 40)
 sum = (x, y) -> x + y
 print "数字的和是", sum 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +125,7 @@ print "数字的和是", sum 10, 20
 ```yuescript
 sum = (x, y) -> return x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -132,6 +140,7 @@ sum = (x, y) -> return x + y
 mystery = (x, y) -> x + y, x - y
 a, b = mystery 10, 20
 ```
+
 <YueDisplay>
 
 ```yue
@@ -148,6 +157,7 @@ a, b = mystery 10, 20
 ```yuescript
 func = (num) => @value + num
 ```
+
 <YueDisplay>
 
 ```yue
@@ -165,6 +175,7 @@ my_function = (name = "某物", height = 100) ->
   print "你好，我是", name
   print "我的高度是", height
 ```
+
 <YueDisplay>
 
 ```yue
@@ -181,6 +192,7 @@ my_function = (name = "某物", height = 100) ->
 some_args = (x = 100, y = x + 1000) ->
   print x + y
 ```
+
 <YueDisplay>
 
 ```yue
@@ -202,6 +214,7 @@ b = x-10
 c = x -y
 d = x- z
 ```
+
 <YueDisplay>
 
 ```yue
@@ -223,6 +236,7 @@ d = x- z
 x = func"hello" + 100
 y = func "hello" + 100
 ```
+
 <YueDisplay>
 
 ```yue
@@ -247,6 +261,7 @@ cool_func 1, 2,
   5, 6,
   7, 8
 ```
+
 <YueDisplay>
 
 ```yue
@@ -269,6 +284,7 @@ my_func 5, 6, 7,
     9, 1, 2,
   5, 4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -289,6 +305,7 @@ x = [
   8, 9, 10
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -309,6 +326,7 @@ y = [ my_func 1, 2, 3,
   5, 6, 7
 ]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -335,6 +353,7 @@ if func 1, 2, 3,
   print "hello"
   print "我在if内部"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -373,6 +392,7 @@ f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
 arg1 = {a: 0}
 f2 arg1, arg2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -402,6 +422,7 @@ findFirstEven = (list): nil ->
         if sub % 2 == 0
           return sub
 ```
+
 <YueDisplay>
 
 ```yue
@@ -426,6 +447,7 @@ findFirstEven = (list) ->
           return sub
   nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -467,6 +489,7 @@ process = (...args) ->
 
 process 1, nil, 3, nil, 5
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/functions/function-stubs.md b/doc/docs/zh/doc/functions/function-stubs.md
index af08feb..888c3eb 100644
--- a/doc/docs/zh/doc/functions/function-stubs.md
+++ b/doc/docs/zh/doc/functions/function-stubs.md
@@ -24,6 +24,7 @@ run_callback my_object.write
 -- 让我们把对象捆绑到一个新函数中
 run_callback my_object\write
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/getting-started/introduction.md b/doc/docs/zh/doc/getting-started/introduction.md
index 827d163..7911363 100644
--- a/doc/docs/zh/doc/getting-started/introduction.md
+++ b/doc/docs/zh/doc/getting-started/introduction.md
@@ -5,6 +5,7 @@
 Yue（月）是中文中“月亮”的名称。
 
 ## 月之脚本概览
+
 ```yuescript
 -- 导入语法
 import p, to_lua from "yue"
@@ -49,6 +50,7 @@ with apple
 -- 类似js的导出语法
 export 🌛 = "月之脚本"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/getting-started/usage.md b/doc/docs/zh/doc/getting-started/usage.md
index b9d84d4..c9bad2e 100644
--- a/doc/docs/zh/doc/getting-started/usage.md
+++ b/doc/docs/zh/doc/getting-started/usage.md
@@ -4,49 +4,51 @@
 
 &emsp;&emsp;在 Lua 中使用月之脚本模块：
 
-* **用法 1**
-
-        &emsp;&emsp;在 Lua 中引入 "你的脚本入口文件.yue"。
-
-        ```Lua
-        require("yue")("你的脚本入口文件")
-        ```
-
-        &emsp;&emsp;当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import** 进行脚本引用即可。错误消息中的代码行号也会被正确处理。
-
-* **用法 2**
-
-        &emsp;&emsp;手动引入月之脚本模块并重写错误消息来帮助调试。
-        ```lua
-        local yue = require("yue")
-        yue.insert_loaders()
-        local success, result = xpcall(function()
-          return require("yuescript_module_name")
-        end, function(err)
-          return yue.traceback(err)
-        end)
-        ```
-
-* **用法 3**
-
-        &emsp;&emsp;在 Lua 中使用月之脚本编译器功能。
-        ```lua
-        local yue = require("yue")
-        local codes, err, globals = yue.to_lua([[
-        f = ->
-          print "hello world"
-        f!
-        ]],{
-          implicit_return_root = true,
-          reserve_line_number = true,
-          lint_global = true,
-          space_over_tab = false,
-          options = {
-            target = "5.4",
-            path = "/script"
-          }
-        })
-        ```
+- **用法 1**
+
+  &emsp;&emsp;在 Lua 中引入 "你的脚本入口文件.yue"。
+
+  ```Lua
+  require("yue")("你的脚本入口文件")
+  ```
+
+  &emsp;&emsp;当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import** 进行脚本引用即可。错误消息中的代码行号也会被正确处理。
+
+- **用法 2**
+
+  &emsp;&emsp;手动引入月之脚本模块并重写错误消息来帮助调试。
+
+  ```lua
+  local yue = require("yue")
+  yue.insert_loaders()
+  local success, result = xpcall(function()
+    return require("yuescript_module_name")
+  end, function(err)
+    return yue.traceback(err)
+  end)
+  ```
+
+- **用法 3**
+
+  &emsp;&emsp;在 Lua 中使用月之脚本编译器功能。
+
+  ```lua
+  local yue = require("yue")
+  local codes, err, globals = yue.to_lua([[
+  f = ->
+    print "hello world"
+  f!
+  ]],{
+    implicit_return_root = true,
+    reserve_line_number = true,
+    lint_global = true,
+    space_over_tab = false,
+    options = {
+      target = "5.4",
+      path = "/script"
+    }
+  })
+  ```
 
 ## 月之脚本编译工具
 
diff --git a/doc/docs/zh/doc/language-basics/attributes.md b/doc/docs/zh/doc/language-basics/attributes.md
index 3dc3b0b..43bc5f9 100644
--- a/doc/docs/zh/doc/language-basics/attributes.md
+++ b/doc/docs/zh/doc/language-basics/attributes.md
@@ -6,6 +6,7 @@
 const a = 123
 close _ = <close>: -> print "超出范围。"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -21,6 +22,7 @@ close _ = <close>: -> print "超出范围。"
 const {:a, :b, c, d} = tb
 -- a = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -36,6 +38,7 @@ const {:a, :b, c, d} = tb
 global const Constant = 123
 -- Constant = 1
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/language-basics/comment.md b/doc/docs/zh/doc/language-basics/comment.md
index f6a7b4e..0e69979 100644
--- a/doc/docs/zh/doc/language-basics/comment.md
+++ b/doc/docs/zh/doc/language-basics/comment.md
@@ -12,6 +12,7 @@ str = --[[
 
 func --[[端口]] 3000, --[[ip]] "192.168.1.1"
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/language-basics/literals.md b/doc/docs/zh/doc/language-basics/literals.md
index 1592bae..0837c71 100644
--- a/doc/docs/zh/doc/language-basics/literals.md
+++ b/doc/docs/zh/doc/language-basics/literals.md
@@ -12,6 +12,7 @@ some_string = "这是一个字符串
 -- 字符串插值只在双引号字符串中可用。
 print "我有#{math.random! * 100}%的把握。"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -34,8 +35,8 @@ integer = 1_000_000
 hex = 0xEF_BB_BF
 binary = 0B10011
 ```
-<YueDisplay>
 
+<YueDisplay>
 
 ```yue
 integer = 1_000_000
@@ -56,6 +57,7 @@ str = |
     - item1
     - #{expr}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -79,6 +81,7 @@ fn = ->
       bar: baz
   return str
 ```
+
 <YueDisplay>
 
 ```yue
@@ -100,6 +103,7 @@ str = |
   path: "C:\Program Files\App"
   note: 'He said: "#{Hello}!"'
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/language-basics/operator.md b/doc/docs/zh/doc/language-basics/operator.md
index 6c9fc5b..d948667 100644
--- a/doc/docs/zh/doc/language-basics/operator.md
+++ b/doc/docs/zh/doc/language-basics/operator.md
@@ -6,6 +6,7 @@
 tb\func! if tb ~= nil
 tb::func! if tb != nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -27,6 +28,7 @@ a = 5
 print 1 <= a <= 10
 -- 输出：true
 ```
+
 <YueDisplay>
 
 ```yue
@@ -64,6 +66,7 @@ print v(1) > v(2) <= v(3)
   false
 ]]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -101,6 +104,7 @@ print v(1) > v(2) <= v(3)
 tab = []
 tab[] = "Value"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -118,6 +122,7 @@ tbB = [4, 5, 6]
 tbA[] = ...tbB
 -- tbA 现在为 [1, 2, 3, 4, 5, 6]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -149,6 +154,7 @@ a = {1, 2, 3, x: 1}
 b = {4, 5, y: 1}
 merge = {...a, ...b}
 ```
+
 <YueDisplay>
 
 ```yue
@@ -179,6 +185,7 @@ last = data.items[#]
 second_last = data.items[#-1]
 data.items[#] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -212,6 +219,7 @@ print d.value
 
 close _ = <close>: -> print "超出范围"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -245,8 +253,8 @@ print tb.value
 tb.<> = __index: {item: "hello"}
 print tb.item
 ```
-<YueDisplay>
 
+<YueDisplay>
 
 ```yue
 -- 使用包含字段 "value" 的元表创建
@@ -267,6 +275,7 @@ print tb.item
 {item, :new, :<close>, <index>: getter} = tb
 print item, new, close, getter
 ```
+
 <YueDisplay>
 
 ```yue
@@ -294,6 +303,7 @@ with? io.open "test.txt", "w"
   \write "你好"
   \close!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -330,6 +340,7 @@ readFile "example.txt"
   |> render
   |> print
 ```
+
 <YueDisplay>
 
 ```yue
@@ -358,6 +369,7 @@ func a ?? {}
 
 a ??= false
 ```
+
 <YueDisplay>
 
 ```yue
@@ -414,6 +426,7 @@ tb =
       func: => @value + 2
       tb: { }
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/language-basics/whitespace.md b/doc/docs/zh/doc/language-basics/whitespace.md
index 1886e23..e27165f 100644
--- a/doc/docs/zh/doc/language-basics/whitespace.md
+++ b/doc/docs/zh/doc/language-basics/whitespace.md
@@ -9,6 +9,7 @@
 ```yuescript
 a = 1; b = 2; print a + b
 ```
+
 <YueDisplay>
 
 ```yue
@@ -29,6 +30,7 @@ Rx.Observable
   \map (value) -> value .. '!'
   \subscribe print
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/objects/object-oriented-programming.md b/doc/docs/zh/doc/objects/object-oriented-programming.md
index 9eb94d8..04f816a 100644
--- a/doc/docs/zh/doc/objects/object-oriented-programming.md
+++ b/doc/docs/zh/doc/objects/object-oriented-programming.md
@@ -15,6 +15,7 @@ class Inventory
     else
       @items[name] = 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -44,8 +45,8 @@ inv = Inventory!
 inv\add_item "t-shirt"
 inv\add_item "pants"
 ```
-<YueDisplay>
 
+<YueDisplay>
 
 ```yue
 inv = Inventory!
@@ -76,6 +77,7 @@ b\give_item "shirt"
 -- 会同时打印出裤子和衬衫
 print item for item in *a.clothes
 ```
+
 <YueDisplay>
 
 ```yue
@@ -103,6 +105,7 @@ class Person
   new: =>
     @clothes = []
 ```
+
 <YueDisplay>
 
 ```yue
@@ -124,6 +127,7 @@ class BackPack extends Inventory
     if #@items > size then error "背包已满"
     super name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -150,6 +154,7 @@ class Shelf
 -- 将打印: Shelf 被 Cupboard 继承
 class Cupboard extends Shelf
 ```
+
 <YueDisplay>
 
 ```yue
@@ -186,6 +191,7 @@ class MyClass extends ParentClass
     -- super 作为值等于父类：
     assert super == ParentClass
 ```
+
 <YueDisplay>
 
 ```yue
@@ -214,6 +220,7 @@ assert b.__class == BackPack
 
 print BackPack.size -- 打印 10
 ```
+
 <YueDisplay>
 
 ```yue
@@ -235,13 +242,14 @@ print BackPack.size -- 打印 10
 
 &emsp;&emsp;如果在类对象的元表中找不到某个属性，系统会从基表中检索该属性。这就意味着我们可以直接从类本身访问到其方法和属性。
 
-&emsp;&emsp;需要特别注意的是，对类对象的赋值并不会影响到基表，因此这不是向实例添加新方法的正确方式。相反，需要直接修改基表。关于这点，可以参考下面的 “__base” 字段。
+&emsp;&emsp;需要特别注意的是，对类对象的赋值并不会影响到基表，因此这不是向实例添加新方法的正确方式。相反，需要直接修改基表。关于这点，可以参考下面的 “\_\_base” 字段。
 
-&emsp;&emsp;此外，类对象包含几个特殊的属性：当类被声明时，类的名称会作为一个字符串存储在类对象的 “__name” 字段中。
+&emsp;&emsp;此外，类对象包含几个特殊的属性：当类被声明时，类的名称会作为一个字符串存储在类对象的 “\_\_name” 字段中。
 
 ```yuescript
 print BackPack.__name -- 打印 Backpack
 ```
+
 <YueDisplay>
 
 ```yue
@@ -267,6 +275,7 @@ Things\some_func!
 -- 类变量在实例中不可见
 assert Things().some_func == nil
 ```
+
 <YueDisplay>
 
 ```yue
@@ -295,6 +304,7 @@ Counter!
 
 print Counter.count -- 输出 2
 ```
+
 <YueDisplay>
 
 ```yue
@@ -317,6 +327,7 @@ print Counter.count -- 输出 2
 ```yuescript
 @@hello 1,2,3,4
 ```
+
 <YueDisplay>
 
 ```yue
@@ -335,6 +346,7 @@ print Counter.count -- 输出 2
 class Things
   @class_var = "hello world"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -356,6 +368,7 @@ class MoreThings
   some_method: =>
     log "hello world: " .. secret
 ```
+
 <YueDisplay>
 
 ```yue
@@ -379,6 +392,7 @@ class MoreThings
 assert @ == self
 assert @@ == self.__class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -393,6 +407,7 @@ assert @@ == self.__class
 ```yuescript
 some_instance_method = (...) => @@ ...
 ```
+
 <YueDisplay>
 
 ```yue
@@ -418,6 +433,7 @@ class Something
     @@biz = biz
     @@baz = baz
 ```
+
 <YueDisplay>
 
 ```yue
@@ -443,6 +459,7 @@ new = (@fieldA, @fieldB) => @
 obj = new {}, 123, "abc"
 print obj
 ```
+
 <YueDisplay>
 
 ```yue
@@ -462,6 +479,7 @@ x = class Bucket
   drops: 0
   add_drop: => @drops += 1
 ```
+
 <YueDisplay>
 
 ```yue
@@ -482,6 +500,7 @@ BigBucket = class extends Bucket
 
 assert Bucket.__name == "BigBucket"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -498,6 +517,7 @@ assert Bucket.__name == "BigBucket"
 ```yuescript
 x = class
 ```
+
 <YueDisplay>
 
 ```yue
@@ -527,6 +547,7 @@ y\func!
 
 assert y.__class.__parent ~= X -- X 不是 Y 的父类
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/objects/with-statement.md b/doc/docs/zh/doc/objects/with-statement.md
index fbd3633..0925050 100644
--- a/doc/docs/zh/doc/objects/with-statement.md
+++ b/doc/docs/zh/doc/objects/with-statement.md
@@ -1,6 +1,5 @@
 # with 语句
 
-
 在编写 Lua 代码时，我们在创建对象后的常见操作是立即调用这个对象一系列操作函数并设置一系列属性。
 
 这导致在代码中多次重复引用对象的名称，增加了不必要的文本噪音。一个常见的解决方案是在创建对象时，在构造函数传入一个表，该表包含要覆盖设置的键和值的集合。这样做的缺点是该对象的构造函数必须支持这种初始化形式。
@@ -16,6 +15,7 @@ with Person!
   \save!
   print .name
 ```
+
 <YueDisplay>
 
 ```yue
@@ -34,6 +34,7 @@ with 语句也可以用作一个表达式，并返回它的代码块正在处理
 file = with File "favorite_foods.txt"
   \set_encoding "utf8"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -53,6 +54,7 @@ create_person = (name,  relatives) ->
 
 me = create_person "Leaf", [dad, mother, sister]
 ```
+
 <YueDisplay>
 
 ```yue
@@ -75,6 +77,7 @@ with str := "你好"
   print "原始:", str
   print "大写:", \upper!
 ```
+
 <YueDisplay>
 
 ```yue
@@ -96,6 +99,7 @@ with tb
     ["key-name"] = value
   [] = "abc" -- 追加到 "tb"
 ```
+
 <YueDisplay>
 
 ```yue
@@ -116,6 +120,7 @@ with tb
 with? obj
   print obj.name
 ```
+
 <YueDisplay>
 
 ```yue
diff --git a/doc/docs/zh/doc/reference/license-mit.md b/doc/docs/zh/doc/reference/license-mit.md
index 24b5b15..7979663 100644
--- a/doc/docs/zh/doc/reference/license-mit.md
+++ b/doc/docs/zh/doc/reference/license-mit.md
@@ -1,6 +1,6 @@
 # MIT 许可证
 
-版权 (c) 2017-2026 李瑾  \<dragon-fly@qq.com\>
+版权 (c) 2017-2026 李瑾 \<dragon-fly@qq.com\>
 
 特此免费授予任何获得本软件副本和相关文档文件（下称“软件”）的人不受限制地处置该软件的权利，包括不受限制地使用、复制、修改、合并、发布、分发、转授许可和/或出售该软件副本，以及再授权被配发了本软件的人如上的权利，须在下列条件下：
 上述版权声明和本许可声明应包含在该软件的所有副本或实质成分中。
diff --git a/doc/docs/zh/doc/reference/the-yuescript-library.md b/doc/docs/zh/doc/reference/the-yuescript-library.md
index 54e26f7..9565b01 100644
--- a/doc/docs/zh/doc/reference/the-yuescript-library.md
+++ b/doc/docs/zh/doc/reference/the-yuescript-library.md
@@ -17,6 +17,7 @@
 月之脚本版本。
 
 **签名：**
+
 ```lua
 version: string
 ```
@@ -30,6 +31,7 @@ version: string
 当前平台的文件分隔符。
 
 **签名：**
+
 ```lua
 dirsep: string
 ```
@@ -43,6 +45,7 @@ dirsep: string
 编译模块代码缓存。
 
 **签名：**
+
 ```lua
 yue_compiled: {string: string}
 ```
@@ -56,6 +59,7 @@ yue_compiled: {string: string}
 月之脚本的编译函数。它将 YueScript 代码编译为 Lua 代码。
 
 **签名：**
+
 ```lua
 to_lua: function(code: string, config?: Config):
     --[[codes]] string | nil,
@@ -65,17 +69,17 @@ to_lua: function(code: string, config?: Config):
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| code | string | YueScript 代码。 |
+| 参数名 | 类型   | 描述                |
+| ------ | ------ | ------------------- |
+| code   | string | YueScript 代码。    |
 | config | Config | [可选] 编译器选项。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| string \| nil | 编译后的 Lua 代码，如果编译失败则为 nil。 |
-| string \| nil | 错误消息，如果编译成功则为 nil。 |
+| 返回类型                            | 描述                                                                                       |
+| ----------------------------------- | ------------------------------------------------------------------------------------------ |
+| string \| nil                       | 编译后的 Lua 代码，如果编译失败则为 nil。                                                  |
+| string \| nil                       | 错误消息，如果编译成功则为 nil。                                                           |
 | {{string, integer, integer}} \| nil | 代码中出现的全局变量（带有名称、行和列），如果编译器选项 `lint_global` 为 false 则为 nil。 |
 
 ### file_exist
@@ -87,21 +91,22 @@ to_lua: function(code: string, config?: Config):
 检查源文件是否存在的函数。可以覆盖该函数以自定义行为。
 
 **签名：**
+
 ```lua
 file_exist: function(filename: string): boolean
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
+| 参数名   | 类型   | 描述     |
+| -------- | ------ | -------- |
 | filename | string | 文件名。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| boolean | 文件是否存在。 |
+| 返回类型 | 描述           |
+| -------- | -------------- |
+| boolean  | 文件是否存在。 |
 
 ### read_file
 
@@ -112,21 +117,22 @@ file_exist: function(filename: string): boolean
 读取源文件的函数。可以覆盖该函数以自定义行为。
 
 **签名：**
+
 ```lua
 read_file: function(filename: string): string
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
+| 参数名   | 类型   | 描述     |
+| -------- | ------ | -------- |
 | filename | string | 文件名。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| string | 文件内容。 |
+| 返回类型 | 描述       |
+| -------- | ---------- |
+| string   | 文件内容。 |
 
 ### insert_loader
 
@@ -137,21 +143,22 @@ read_file: function(filename: string): string
 将 YueScript 加载器插入到 Lua 包加载器（搜索器）中。
 
 **签名：**
+
 ```lua
 insert_loader: function(pos?: integer): boolean
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| pos | integer | [可选] 要插入加载器的位置。默认为 3。 |
+| 参数名 | 类型    | 描述                                  |
+| ------ | ------- | ------------------------------------- |
+| pos    | integer | [可选] 要插入加载器的位置。默认为 3。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| boolean | 是否成功插入加载器。如果加载器已经插入，则返回失败。 |
+| 返回类型 | 描述                                                 |
+| -------- | ---------------------------------------------------- |
+| boolean  | 是否成功插入加载器。如果加载器已经插入，则返回失败。 |
 
 ### remove_loader
 
@@ -162,15 +169,16 @@ insert_loader: function(pos?: integer): boolean
 从 Lua 包加载器（搜索器）中移除 YueScript 加载器。
 
 **签名：**
+
 ```lua
 remove_loader: function(): boolean
 ```
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| boolean | 是否成功移除加载器。如果加载器未插入，则返回失败。 |
+| 返回类型 | 描述                                               |
+| -------- | -------------------------------------------------- |
+| boolean  | 是否成功移除加载器。如果加载器未插入，则返回失败。 |
 
 ### loadstring
 
@@ -181,6 +189,7 @@ remove_loader: function(): boolean
 将 YueScript 代码字符串加载为一个函数。
 
 **签名：**
+
 ```lua
 loadstring: function(input: string, chunkname: string, env: table, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -189,19 +198,19 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| input | string | YueScript 代码。 |
-| chunkname | string | 代码块的名称。 |
-| env | table | 环境表。 |
-| config | Config | [可选] 编译器选项。 |
+| 参数名    | 类型   | 描述                |
+| --------- | ------ | ------------------- |
+| input     | string | YueScript 代码。    |
+| chunkname | string | 代码块的名称。      |
+| env       | table  | 环境表。            |
+| config    | Config | [可选] 编译器选项。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
 | function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
 
 ### loadstring
 
@@ -212,6 +221,7 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 将 YueScript 代码字符串加载为一个函数。
 
 **签名：**
+
 ```lua
 loadstring: function(input: string, chunkname: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -220,18 +230,18 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| input | string | YueScript 代码。 |
-| chunkname | string | 代码块的名称。 |
-| config | Config | [可选] 编译器选项。 |
+| 参数名    | 类型   | 描述                |
+| --------- | ------ | ------------------- |
+| input     | string | YueScript 代码。    |
+| chunkname | string | 代码块的名称。      |
+| config    | Config | [可选] 编译器选项。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
 | function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
 
 ### loadstring
 
@@ -242,6 +252,7 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 将 YueScript 代码字符串加载为一个函数。
 
 **签名：**
+
 ```lua
 loadstring: function(input: string, config?: Config):
     --[[loaded function]] nil | function(...: any): (any...),
@@ -250,17 +261,17 @@ loadstring: function(input: string, config?: Config):
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| input | string | YueScript 代码。 |
+| 参数名 | 类型   | 描述                |
+| ------ | ------ | ------------------- |
+| input  | string | YueScript 代码。    |
 | config | Config | [可选] 编译器选项。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
 | function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
 
 ### loadfile
 
@@ -271,6 +282,7 @@ loadstring: function(input: string, config?: Config):
 将 YueScript 代码文件加载为一个函数。
 
 **签名：**
+
 ```lua
 loadfile: function(filename: string, env: table, config?: Config):
     nil | function(...: any): (any...),
@@ -279,18 +291,18 @@ loadfile: function(filename: string, env: table, config?: Config):
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-| env | table | 环境表。 |
-| config | Config | [可选] 编译器选项。 |
+| 参数名   | 类型   | 描述                |
+| -------- | ------ | ------------------- |
+| filename | string | 文件名。            |
+| env      | table  | 环境表。            |
+| config   | Config | [可选] 编译器选项。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
 | function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
 
 ### loadfile
 
@@ -301,6 +313,7 @@ loadfile: function(filename: string, env: table, config?: Config):
 将 YueScript 代码文件加载为一个函数。
 
 **签名：**
+
 ```lua
 loadfile: function(filename: string, config?: Config):
     nil | function(...: any): (any...),
@@ -309,17 +322,17 @@ loadfile: function(filename: string, config?: Config):
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-| config | Config | [可选] 编译器选项。 |
+| 参数名   | 类型   | 描述                |
+| -------- | ------ | ------------------- |
+| filename | string | 文件名。            |
+| config   | Config | [可选] 编译器选项。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
 | function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
 
 ### dofile
 
@@ -330,23 +343,24 @@ loadfile: function(filename: string, config?: Config):
 将 YueScript 代码文件加载为一个函数并执行。
 
 **签名：**
+
 ```lua
 dofile: function(filename: string, env: table, config?: Config): any...
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-| env | table | 环境表。 |
-| config | Config | [可选] 编译器选项。 |
+| 参数名   | 类型   | 描述                |
+| -------- | ------ | ------------------- |
+| filename | string | 文件名。            |
+| env      | table  | 环境表。            |
+| config   | Config | [可选] 编译器选项。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| any... | 加载的函数执行后的返回值。 |
+| 返回类型 | 描述                       |
+| -------- | -------------------------- |
+| any...   | 加载的函数执行后的返回值。 |
 
 ### dofile
 
@@ -357,22 +371,23 @@ dofile: function(filename: string, env: table, config?: Config): any...
 将 YueScript 代码文件加载为一个函数并执行。
 
 **签名：**
+
 ```lua
 dofile: function(filename: string, config?: Config): any...
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-| config | Config | [可选] 编译器选项。 |
+| 参数名   | 类型   | 描述                |
+| -------- | ------ | ------------------- |
+| filename | string | 文件名。            |
+| config   | Config | [可选] 编译器选项。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| any... | 加载的函数执行后的返回值。 |
+| 返回类型 | 描述                       |
+| -------- | -------------------------- |
+| any...   | 加载的函数执行后的返回值。 |
 
 ### find_modulepath
 
@@ -383,21 +398,22 @@ dofile: function(filename: string, config?: Config): any...
 将 YueScript 模块名解析为文件路径。
 
 **签名：**
+
 ```lua
 find_modulepath: function(name: string): string
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| name | string | 模块名。 |
+| 参数名 | 类型   | 描述     |
+| ------ | ------ | -------- |
+| name   | string | 模块名。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| string | 文件路径。 |
+| 返回类型 | 描述       |
+| -------- | ---------- |
+| string   | 文件路径。 |
 
 ### pcall
 
@@ -410,21 +426,22 @@ find_modulepath: function(name: string): string
 当发生错误时，将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
 
 **签名：**
+
 ```lua
 pcall: function(f: function, ...: any): boolean, any...
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| f | function | 要调用的函数。 |
-| ... | any | 要传递给函数的参数。 |
+| 参数名 | 类型     | 描述                 |
+| ------ | -------- | -------------------- |
+| f      | function | 要调用的函数。       |
+| ...    | any      | 要传递给函数的参数。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
+| 返回类型     | 描述                         |
+| ------------ | ---------------------------- |
 | boolean, ... | 状态码和函数结果或错误信息。 |
 
 ### require
@@ -437,21 +454,22 @@ pcall: function(f: function, ...: any): boolean, any...
 如果模块是 YueScript 模块且加载失败，则将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
 
 **签名：**
+
 ```lua
 require: function(name: string): any...
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
+| 参数名  | 类型   | 描述             |
+| ------- | ------ | ---------------- |
 | modname | string | 要加载的模块名。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| any | 如果模块已经加载，则返回 package.loaded[modname] 中存储的值。否则，尝试查找加载器并返回 package.loaded[modname] 的最终值和加载器数据作为第二个结果。 |
+| 返回类型 | 描述                                                                                                                                                 |
+| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| any      | 如果模块已经加载，则返回 package.loaded[modname] 中存储的值。否则，尝试查找加载器并返回 package.loaded[modname] 的最终值和加载器数据作为第二个结果。 |
 
 ### p
 
@@ -462,15 +480,16 @@ require: function(name: string): any...
 检查传递的值的内部结构，并打印值出它的字符串表示。
 
 **签名：**
+
 ```lua
 p: function(...: any)
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| ... | any | 要检查的值。 |
+| 参数名 | 类型 | 描述         |
+| ------ | ---- | ------------ |
+| ...    | any  | 要检查的值。 |
 
 ### options
 
@@ -481,6 +500,7 @@ p: function(...: any)
 当前编译器选项。
 
 **签名：**
+
 ```lua
 options: Config.Options
 ```
@@ -494,21 +514,22 @@ options: Config.Options
 重写堆栈跟踪中的行号为 YueScript 代码中的原始行号的 traceback 函数。
 
 **签名：**
+
 ```lua
 traceback: function(message: string): string
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
+| 参数名  | 类型   | 描述           |
+| ------- | ------ | -------------- |
 | message | string | 堆栈跟踪消息。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| string | 重写后的堆栈跟踪消息。 |
+| 返回类型 | 描述                   |
+| -------- | ---------------------- |
+| string   | 重写后的堆栈跟踪消息。 |
 
 ### is_ast
 
@@ -519,22 +540,23 @@ traceback: function(message: string): string
 检查代码是否匹配指定的 AST。
 
 **签名：**
+
 ```lua
 is_ast: function(astName: string, code: string): boolean
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
+| 参数名  | 类型   | 描述       |
+| ------- | ------ | ---------- |
 | astName | string | AST 名称。 |
-| code | string | 代码。 |
+| code    | string | 代码。     |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| boolean | 代码是否匹配 AST。 |
+| 返回类型 | 描述               |
+| -------- | ------------------ |
+| boolean  | 代码是否匹配 AST。 |
 
 ### AST
 
@@ -545,6 +567,7 @@ is_ast: function(astName: string, code: string): boolean
 AST 类型定义，带有名称、行、列和子节点。
 
 **签名：**
+
 ```lua
 type AST = {string, integer, integer, any}
 ```
@@ -558,6 +581,7 @@ type AST = {string, integer, integer, any}
 将代码转换为 AST。
 
 **签名：**
+
 ```lua
 to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
     --[[AST]] AST | nil,
@@ -566,18 +590,18 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| code | string | 代码。 |
-| flattenLevel | integer | [可选] 扁平化级别。级别越高，会消除更多的 AST 结构的嵌套。默认为 0。最大为 2。 |
-| astName | string | [可选] AST 名称。默认为 "File"。 |
-| reserveComment | boolean | [可选] 是否保留原始注释。默认为 false。 |
+| 参数名         | 类型    | 描述                                                                           |
+| -------------- | ------- | ------------------------------------------------------------------------------ |
+| code           | string  | 代码。                                                                         |
+| flattenLevel   | integer | [可选] 扁平化级别。级别越高，会消除更多的 AST 结构的嵌套。默认为 0。最大为 2。 |
+| astName        | string  | [可选] AST 名称。默认为 "File"。                                               |
+| reserveComment | boolean | [可选] 是否保留原始注释。默认为 false。                                        |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| AST \| nil | AST，如果转换失败则为 nil。 |
+| 返回类型      | 描述                             |
+| ------------- | -------------------------------- |
+| AST \| nil    | AST，如果转换失败则为 nil。      |
 | string \| nil | 错误消息，如果转换成功则为 nil。 |
 
 ### format
@@ -589,25 +613,26 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveC
 格式化 YueScript 代码。
 
 **签名：**
+
 ```lua
 format: function(code: string, tabSize?: number, reserveComment?: boolean): string
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| code | string | 代码。 |
-| tabSize | integer | [可选] 制表符大小。默认为 4。 |
+| 参数名         | 类型    | 描述                                   |
+| -------------- | ------- | -------------------------------------- |
+| code           | string  | 代码。                                 |
+| tabSize        | integer | [可选] 制表符大小。默认为 4。          |
 | reserveComment | boolean | [可选] 是否保留原始注释。默认为 true。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| string | 格式化后的代码。 |
+| 返回类型 | 描述             |
+| -------- | ---------------- |
+| string   | 格式化后的代码。 |
 
-### __call
+### \_\_call
 
 **类型：** 元方法。
 
@@ -617,21 +642,22 @@ format: function(code: string, tabSize?: number, reserveComment?: boolean): stri
 如果发生加载失败，则将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
 
 **签名：**
+
 ```lua
 metamethod __call: function(self: yue, module: string): any...
 ```
 
 **参数：**
 
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
+| 参数名 | 类型   | 描述     |
+| ------ | ------ | -------- |
 | module | string | 模块名。 |
 
 **返回值：**
 
-| 返回类型 | 描述 |
-| --- | --- |
-| any | 模块值。 |
+| 返回类型 | 描述     |
+| -------- | -------- |
+| any      | 模块值。 |
 
 ## Config
 
@@ -648,6 +674,7 @@ metamethod __call: function(self: yue, module: string): any...
 编译器是否应该收集代码中出现的全局变量。
 
 **签名：**
+
 ```lua
 lint_global: boolean
 ```
@@ -661,6 +688,7 @@ lint_global: boolean
 编译器是否应该对根层级的代码块进行隐式的表达式返回。
 
 **签名：**
+
 ```lua
 implicit_return_root: boolean
 ```
@@ -674,6 +702,7 @@ implicit_return_root: boolean
 编译器是否应该在编译后的代码中保留原始行号。
 
 **签名：**
+
 ```lua
 reserve_line_number: boolean
 ```
@@ -687,6 +716,7 @@ reserve_line_number: boolean
 编译器是否应该在编译后的代码中保留原始注释。
 
 **签名：**
+
 ```lua
 reserve_comment: boolean
 ```
@@ -700,6 +730,7 @@ reserve_comment: boolean
 编译器是否应该在编译后的代码中使用空格字符而不是制表符字符。
 
 **签名：**
+
 ```lua
 space_over_tab: boolean
 ```
@@ -713,6 +744,7 @@ space_over_tab: boolean
 编译器是否应该将要编译的代码视为当前正在编译的模块。仅供编译器内部使用。
 
 **签名：**
+
 ```lua
 same_module: boolean
 ```
@@ -726,6 +758,7 @@ same_module: boolean
 编译器错误消息是否应该包含行号偏移量。仅供编译器内部使用。
 
 **签名：**
+
 ```lua
 line_offset: integer
 ```
@@ -739,6 +772,7 @@ line_offset: integer
 目标 Lua 版本枚举。
 
 **签名：**
+
 ```lua
 enum LuaTarget
   "5.1"
@@ -758,6 +792,7 @@ end
 要传递给编译函数的额外选项。
 
 **签名：**
+
 ```lua
 options: Options
 ```
@@ -777,6 +812,7 @@ options: Options
 编译目标 Lua 版本。
 
 **签名：**
+
 ```lua
 target: LuaTarget
 ```
@@ -790,6 +826,7 @@ target: LuaTarget
 额外模块搜索路径。
 
 **签名：**
+
 ```lua
 path: string
 ```
@@ -803,6 +840,7 @@ path: string
 是否在回溯错误消息中输出代码块的局部变量。默认为 false。
 
 **签名：**
+
 ```lua
 dump_locals: boolean
 ```
@@ -816,6 +854,7 @@ dump_locals: boolean
 是否简化输出的错误消息。默认为 true。
 
 **签名：**
+
 ```lua
 simplified: boolean
 ```
diff --git a/doc/docs/zh/try/index.md b/doc/docs/zh/try/index.md
index c5678b7..7e198b0 100755
--- a/doc/docs/zh/try/index.md
+++ b/doc/docs/zh/try/index.md
@@ -5,6 +5,7 @@ next: false
 ---
 
 # 月之脚本的在线编译器
+
 ---
 
 在这里试试 WASM 版的 YueScript 吧。