Splited docs.

72 files changed, 11167 insertions, 10968 deletions

diff --git a/doc/docs/.vitepress/config.mts b/doc/docs/.vitepress/config.mts
index da3876d..4c20685 100644
--- a/doc/docs/.vitepress/config.mts
+++ b/doc/docs/.vitepress/config.mts
@@ -15,6 +15,140 @@ const moonscriptLanguage = {
   aliases: ['yue', 'yuescript', 'moon'],
 }
 
+// Generate sidebar configuration function
+function createSidebar(basePath: string, zh: boolean) {
+  return [
+    {
+      text: zh ? '介绍' : 'Introduction',
+      link: `${basePath}/introduction`,
+    },
+    {
+      text: zh ? '安装' : 'Installation',
+      link: `${basePath}/installation`,
+    },
+    {
+      text: zh ? '使用方法' : 'Usage',
+      link: `${basePath}/usage`,
+    },
+    {
+      text: zh ? '宏' : 'Macro',
+      link: `${basePath}/macro`,
+    },
+    {
+      text: zh ? '操作符' : 'Operator',
+      link: `${basePath}/operator`,
+    },
+    {
+      text: zh ? '模块' : 'Module',
+      link: `${basePath}/module`,
+    },
+    {
+      text: zh ? '赋值' : 'Assignment',
+      link: `${basePath}/assignment`,
+    },
+    {
+      text: zh ? '解构赋值' : 'Destructuring Assignment',
+      link: `${basePath}/destructuring-assignment`,
+    },
+    {
+      text: zh ? 'If 赋值' : 'If Assignment',
+      link: `${basePath}/if-assignment`,
+    },
+    {
+      text: zh ? '可变参数赋值' : 'Varargs Assignment',
+      link: `${basePath}/varargs-assignment`,
+    },
+    {
+      text: zh ? '空白' : 'Whitespace',
+      link: `${basePath}/whitespace`,
+    },
+    {
+      text: zh ? '注释' : 'Comment',
+      link: `${basePath}/comment`,
+    },
+    {
+      text: zh ? '错误处理' : 'Try',
+      link: `${basePath}/try`,
+    },
+    {
+      text: zh ? '属性' : 'Attributes',
+      link: `${basePath}/attributes`,
+    },
+    {
+      text: zh ? '字面量' : 'Literals',
+      link: `${basePath}/literals`,
+    },
+    {
+      text: zh ? '函数字面量' : 'Function Literals',
+      link: `${basePath}/function-literals`,
+    },
+    {
+      text: zh ? '反向回调' : 'Backcalls',
+      link: `${basePath}/backcalls`,
+    },
+    {
+      text: zh ? '表格字面量' : 'Table Literals',
+      link: `${basePath}/table-literals`,
+    },
+    {
+      text: zh ? '推导式' : 'Comprehensions',
+      link: `${basePath}/comprehensions`,
+    },
+    {
+      text: zh ? 'for 循环' : 'For Loop',
+      link: `${basePath}/for-loop`,
+    },
+    {
+      text: zh ? 'while 循环' : 'While Loop',
+      link: `${basePath}/while-loop`,
+    },
+    {
+      text: zh ? 'continue 语句' : 'Continue Statement',
+      link: `${basePath}/continue`,
+    },
+    {
+      text: zh ? '条件语句' : 'Conditionals',
+      link: `${basePath}/conditionals`,
+    },
+    {
+      text: zh ? '代码行修饰符' : 'Line Decorators',
+      link: `${basePath}/line-decorators`,
+    },
+    {
+      text: zh ? 'switch 语句' : 'Switch',
+      link: `${basePath}/switch`,
+    },
+    {
+      text: zh ? '面向对象编程' : 'Object Oriented Programming',
+      link: `${basePath}/object-oriented-programming`,
+    },
+    {
+      text: zh ? 'with 语句' : 'With Statement',
+      link: `${basePath}/with-statement`,
+    },
+    {
+      text: zh ? 'do 语句' : 'Do',
+      link: `${basePath}/do`,
+    },
+    {
+      text: zh ? '函数存根' : 'Function Stubs',
+      link: `${basePath}/function-stubs`,
+    },
+    {
+      text: zh ? '使用 using 语句：防止破坏性赋值' : 'The Using Clause; Controlling Destructive Assignment',
+      link: `${basePath}/the-using-clause-controlling-destructive-assignment`,
+    },
+    {
+      text: zh ? '月之脚本语言库' : 'The YueScript Library',
+      link: `${basePath}/the-yuescript-library`,
+    },
+    {
+      text: zh ? 'MIT 许可证' : 'Licence: MIT',
+      link: `${basePath}/licence-mit`,
+    },
+  ]
+}
+
 export default defineConfig({
   title: 'YueScript',
   description: 'A language that compiles to Lua',
@@ -84,7 +218,8 @@ export default defineConfig({
           { text: 'Document', link: '/doc/' },
           { text: 'Try yue!', link: '/try/' },
           { text: 'Github', link: 'https://github.com/IppClub/Yuescript' }
-        ]
+        ],
+        sidebar: createSidebar('/doc', false),
       }
     },
     zh: {
@@ -96,7 +231,8 @@ export default defineConfig({
           { text: '文档', link: '/zh/doc/' },
           { text: '试一试!', link: '/zh/try/' },
           { text: 'Github', link: 'https://github.com/IppClub/Yuescript' }
-        ]
+        ],
+        sidebar: createSidebar('/zh/doc', true),
       }
     }
   }
diff --git a/doc/docs/.vitepress/theme/components/YueCompiler.vue b/doc/docs/.vitepress/theme/components/YueCompiler.vue
index dcea692..13a5524 100755
--- a/doc/docs/.vitepress/theme/components/YueCompiler.vue
+++ b/doc/docs/.vitepress/theme/components/YueCompiler.vue
@@ -46,7 +46,7 @@ const lightPlusTheme = EditorView.theme(
       height: '100%',
       backgroundColor: '#FFFFFF',
       color: '#000000',
-      fontSize: '0.8em'
+      fontSize: '14px'
     },
     '&.cm-focused': {
       outline: 'none'
@@ -90,7 +90,7 @@ const darkPlusTheme = EditorView.theme(
       height: '100%',
       backgroundColor: '#1E1E1E',
       color: '#D4D4D4',
-      fontSize: '0.8em'
+      fontSize: '14px'
     },
     '&.cm-focused': {
       outline: 'none'
diff --git a/doc/docs/.vitepress/theme/custom.css b/doc/docs/.vitepress/theme/custom.css
index 7b4e593..bd89528 100644
--- a/doc/docs/.vitepress/theme/custom.css
+++ b/doc/docs/.vitepress/theme/custom.css
@@ -19,6 +19,7 @@
 .code-output code {
   background: #ffffff;
   color: #000000;
+  font-size: 14px;
 }
 
 .dark .code-output,
diff --git a/doc/docs/.vitepress/theme/index.ts b/doc/docs/.vitepress/theme/index.ts
index 398df17..c4ec3d7 100644
--- a/doc/docs/.vitepress/theme/index.ts
+++ b/doc/docs/.vitepress/theme/index.ts
@@ -1,5 +1,6 @@
 import DefaultTheme from 'vitepress/theme'
 import type { Theme } from 'vitepress'
+import { h } from 'vue'
 import './custom.css'
 
 // @ts-ignore
@@ -11,6 +12,10 @@ import YueDisplay from './components/YueDisplay.vue'
 
 const theme: Theme = {
   extends: DefaultTheme,
+  Layout: () =>
+    h(DefaultTheme.Layout, null, {
+      'layout-bottom': () => h(CompilerModal)
+    }),
   enhanceApp({ app }) {
     app.component('CompilerModal', CompilerModal)
     app.component('YueCompiler', YueCompiler)
diff --git a/doc/docs/doc/assignment.md b/doc/docs/doc/assignment.md
new file mode 100644
index 0000000..4dac6f4
--- /dev/null
+++ b/doc/docs/doc/assignment.md
@@ -0,0 +1,138 @@
+# Assignment
+
+The variable is dynamic typed and is defined as local by default. But you can change the scope of declaration by **local** and **global** statement.
+
+```yuescript
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- uses the existing variable
+```
+<YueDisplay>
+
+```yue
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- uses the existing variable
+```
+
+</YueDisplay>
+
+## Perform Update
+
+You can perform update assignment with many binary operators.
+```yuescript
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- will add a new local if local variable is not exist
+arg or= "default value"
+```
+<YueDisplay>
+
+```yue
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- will add a new local if local variable is not exist
+arg or= "default value"
+```
+
+</YueDisplay>
+
+## 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
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+</YueDisplay>
+
+## Explicit Locals
+```yuescript
+do
+  local a = 1
+  local *
+  print "forward declare all variables as locals"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "only forward declare upper case variables"
+  a = 1
+  B = 2
+```
+<YueDisplay>
+
+```yue
+do
+  local a = 1
+  local *
+  print "forward declare all variables as locals"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "only forward declare upper case variables"
+  a = 1
+  B = 2
+```
+
+</YueDisplay>
+
+## Explicit Globals
+```yuescript
+do
+  global a = 1
+  global *
+  print "declare all variables as globals"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global X = 1
+  global ^
+  print "only declare upper case variables as globals"
+  a = 1
+  B = 2
+  local Temp = "a local value"
+```
+<YueDisplay>
+
+```yue
+do
+  global a = 1
+  global *
+  print "declare all variables as globals"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global X = 1
+  global ^
+  print "only declare upper case variables as globals"
+  a = 1
+  B = 2
+  local Temp = "a local value"
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/attributes.md b/doc/docs/doc/attributes.md
new file mode 100644
index 0000000..e6fd5a7
--- /dev/null
+++ b/doc/docs/doc/attributes.md
@@ -0,0 +1,46 @@
+# Attributes
+
+Syntax support for Lua 5.4 attributes. And you can still use both the `const` and `close` declaration and get constant check and scoped callback working when targeting Lua versions below 5.4.
+
+```yuescript
+const a = 123
+close _ = <close>: -> print "Out of scope."
+```
+<YueDisplay>
+
+```yue
+const a = 123
+close _ = <close>: -> print "Out of scope."
+```
+
+</YueDisplay>
+
+You can do desctructuring with variables attributed as constant.
+
+```yuescript
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+<YueDisplay>
+
+```yue
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+</YueDisplay>
+
+You can also declare a global variable to be `const`.
+
+```yuescript
+global const Constant = 123
+-- Constant = 1
+```
+<YueDisplay>
+
+```yue
+global const Constant = 123
+-- Constant = 1
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/backcalls.md b/doc/docs/doc/backcalls.md
new file mode 100644
index 0000000..e34331e
--- /dev/null
+++ b/doc/docs/doc/backcalls.md
@@ -0,0 +1,69 @@
+# Backcalls
+
+Backcalls are used for unnesting callbacks. They are defined using arrows pointed to the left as the last parameter by default filling in a function call. All the syntax is mostly the same as regular arrow functions except that it is just pointing the other way and the function body does not require indent.
+
+```yuescript
+x <- f
+print "hello" .. x
+```
+<YueDisplay>
+
+```yue
+x <- f
+print "hello" .. x
+```
+
+</YueDisplay>
+
+Fat arrow functions are also available.
+
+```yuescript
+<= f
+print @value
+```
+<YueDisplay>
+
+```yue
+<= f
+print @value
+```
+
+</YueDisplay>
+
+You can specify a placeholder for where you want the backcall function to go as a parameter.
+
+```yuescript
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+<YueDisplay>
+
+```yue
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+</YueDisplay>
+
+If you wish to have further code after your backcalls, you can set them aside with a do statement. And the parentheses can be omitted with non-fat arrow functions.
+
+```yuescript
+result, msg = do
+  data <- readAsync "filename.txt"
+  print data
+  info <- processAsync data
+  check info
+print result, msg
+```
+<YueDisplay>
+
+```yue
+result, msg = do
+  data <- readAsync "filename.txt"
+  print data
+  info <- processAsync data
+  check info
+print result, msg
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/comment.md b/doc/docs/doc/comment.md
new file mode 100644
index 0000000..b67c97d
--- /dev/null
+++ b/doc/docs/doc/comment.md
@@ -0,0 +1,30 @@
+# Comment
+
+```yuescript
+-- I am a comment
+
+str = --[[
+This is a multi-line comment.
+It's OK.
+]] strA \ -- comment 1
+  .. strB \ -- comment 2
+  .. strC
+
+func --[[port]] 3000, --[[ip]] "192.168.1.1"
+```
+<YueDisplay>
+
+```yue
+-- I am a comment
+
+str = --[[
+This is a multi-line comment.
+It's OK.
+]] strA \ -- comment 1
+  .. strB \ -- comment 2
+  .. strC
+
+func --[[port]] 3000, --[[ip]] "192.168.1.1"
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/comprehensions.md b/doc/docs/doc/comprehensions.md
new file mode 100644
index 0000000..3a92167
--- /dev/null
+++ b/doc/docs/doc/comprehensions.md
@@ -0,0 +1,271 @@
+# Comprehensions
+
+Comprehensions provide a convenient syntax for constructing a new table by iterating over some existing object and applying an expression to its values. There are two kinds of comprehensions: list comprehensions and table comprehensions. They both produce Lua tables; list comprehensions accumulate values into an array-like table, and table comprehensions let you set both the key and the value on each iteration.
+
+## List Comprehensions
+
+The following creates a copy of the items table but with all the values doubled.
+
+```yuescript
+items = [ 1, 2, 3, 4 ]
+doubled = [item * 2 for i, item in ipairs items]
+```
+<YueDisplay>
+
+```yue
+items = [ 1, 2, 3, 4 ]
+doubled = [item * 2 for i, item in ipairs items]
+```
+
+</YueDisplay>
+
+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
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+</YueDisplay>
+
+Because it is common to iterate over the values of a numerically indexed table, an **\*** operator is introduced. The doubled example can be rewritten as:
+
+```yuescript
+doubled = [item * 2 for item in *items]
+```
+<YueDisplay>
+
+```yue
+doubled = [item * 2 for item in *items]
+```
+
+</YueDisplay>
+
+In list comprehensions, you can also use the spread operator `...` to flatten nested lists, achieving a flat map effect:
+
+```yuescript
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat is now [1, 2, 3, 4, 5, 6]
+```
+<YueDisplay>
+
+```yue
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat is now [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+The for and when clauses can be chained as much as desired. The only requirement is that a comprehension has at least one for clause.
+
+Using multiple for clauses is the same as using nested loops:
+
+```yuescript
+x_coords = [4, 5, 6, 7]
+y_coords = [9, 2, 3]
+
+points = [ [x, y] for x in *x_coords \
+for y in *y_coords]
+```
+<YueDisplay>
+
+```yue
+x_coords = [4, 5, 6, 7]
+y_coords = [9, 2, 3]
+
+points = [ [x, y] for x in *x_coords \
+for y in *y_coords]
+```
+
+</YueDisplay>
+
+Numeric for loops can also be used in comprehensions:
+
+```yuescript
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+<YueDisplay>
+
+```yue
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+</YueDisplay>
+
+## Table Comprehensions
+
+The syntax for table comprehensions is very similar, only differing by using **{** and **}** and taking two values from each iteration.
+
+This example makes a copy of the tablething:
+
+```yuescript
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+<YueDisplay>
+
+```yue
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+</YueDisplay>
+
+```yuescript
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+<YueDisplay>
+
+```yue
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+</YueDisplay>
+
+The **\*** operator is also supported. Here we create a square root look up table for a few numbers.
+
+```yuescript
+numbers = [1, 2, 3, 4]
+sqrts = {i, math.sqrt i for i in *numbers}
+```
+<YueDisplay>
+
+```yue
+numbers = [1, 2, 3, 4]
+sqrts = {i, math.sqrt i for i in *numbers}
+```
+
+</YueDisplay>
+
+The key-value tuple in a table comprehension can also come from a single expression, in which case the expression should return two values. The first is used as the key and the second is used as the value:
+
+In this example we convert an array of pairs to a table where the first item in the pair is the key and the second is the value.
+
+```yuescript
+tuples = [ ["hello", "world"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+<YueDisplay>
+
+```yue
+tuples = [ ["hello", "world"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+
+</YueDisplay>
+
+## Slicing
+
+A special syntax is provided to restrict the items that are iterated over when using the **\*** operator. This is equivalent to setting the iteration bounds and a step size in a for loop.
+
+Here we can set the minimum and maximum bounds, taking all items with indexes between 1 and 5 inclusive:
+
+```yuescript
+slice = [item for item in *items[1, 5]]
+```
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[1, 5]]
+```
+
+</YueDisplay>
+
+Any of the slice arguments can be left off to use a sensible default. In this example, if the max index is left off it defaults to the length of the table. This will take everything but the first element:
+
+```yuescript
+slice = [item for item in *items[2,]]
+```
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[2,]]
+```
+
+</YueDisplay>
+
+If the minimum bound is left out, it defaults to 1. Here we only provide a step size and leave the other bounds blank. This takes all odd indexed items: (1, 3, 5, …)
+
+```yuescript
+slice = [item for item in *items[,,2]]
+```
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[,,2]]
+```
+
+</YueDisplay>
+
+Both the minimum and maximum bounds can be negative, which means that the bounds are counted from the end of the table.
+
+```yuescript
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+```
+<YueDisplay>
+
+```yue
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+```
+
+</YueDisplay>
+
+The step size can also be negative, which means that the items are taken in reverse order.
+
+```yuescript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+<YueDisplay>
+
+```yue
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+</YueDisplay>
+
+### Slicing Expression
+
+Slicing can also be used as an expression. This is useful for getting a sub-list of a table.
+
+```yuescript
+-- take the 2nd and 4th items as a new list
+sub_list = items[2, 4]
+
+-- take the last 4 items
+last_four_items = items[-4, -1]
+```
+<YueDisplay>
+
+```yue
+-- take the 2nd and 4th items as a new list
+sub_list = items[2, 4]
+
+-- take the last 4 items
+last_four_items = items[-4, -1]
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/conditionals.md b/doc/docs/doc/conditionals.md
new file mode 100644
index 0000000..5ba81cf
--- /dev/null
+++ b/doc/docs/doc/conditionals.md
@@ -0,0 +1,149 @@
+# Conditionals
+
+```yuescript
+have_coins = false
+if have_coins
+  print "Got coins"
+else
+  print "No coins"
+```
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins
+  print "Got coins"
+else
+  print "No coins"
+```
+
+</YueDisplay>
+
+A short syntax for single statements can also be used:
+
+```yuescript
+have_coins = false
+if have_coins then print "Got coins" else print "No coins"
+```
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins then print "Got coins" else print "No coins"
+```
+
+</YueDisplay>
+
+Because if statements can be used as expressions, this can also be written as:
+
+```yuescript
+have_coins = false
+print if have_coins then "Got coins" else "No coins"
+```
+<YueDisplay>
+
+```yue
+have_coins = false
+print if have_coins then "Got coins" else "No coins"
+```
+
+</YueDisplay>
+
+Conditionals can also be used in return statements and assignments:
+
+```yuescript
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "I am very tall"
+else
+  "I am not so tall"
+
+print message -- prints: I am very tall
+```
+<YueDisplay>
+
+```yue
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "I am very tall"
+else
+  "I am not so tall"
+
+print message -- prints: I am very tall
+```
+
+</YueDisplay>
+
+The opposite of if is unless:
+
+```yuescript
+unless os.date("%A") == "Monday"
+  print "it is not Monday!"
+```
+<YueDisplay>
+
+```yue
+unless os.date("%A") == "Monday"
+  print "it is not Monday!"
+```
+
+</YueDisplay>
+
+```yuescript
+print "You're lucky!" unless math.random! > 0.1
+```
+<YueDisplay>
+
+```yue
+print "You're lucky!" unless math.random! > 0.1
+```
+
+</YueDisplay>
+
+## In Expression
+
+You can write range checking code with an `in-expression`.
+
+```yuescript
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "checking equality with discrete values"
+
+if a in list
+  print "checking if `a` is in a list"
+```
+<YueDisplay>
+
+```yue
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "checking equality with discrete values"
+
+if a in list
+  print "checking if `a` is in a list"
+```
+
+</YueDisplay>
+
+```yuescript
+print "You're lucky!" unless math.random! > 0.1
+```
+<YueDisplay>
+
+```yue
+print "You're lucky!" unless math.random! > 0.1
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/continue.md b/doc/docs/doc/continue.md
new file mode 100644
index 0000000..b000765
--- /dev/null
+++ b/doc/docs/doc/continue.md
@@ -0,0 +1,41 @@
+# Continue
+
+A continue statement can be used to skip the current iteration in a loop.
+
+```yuescript
+i = 0
+while i < 10
+  i += 1
+  continue if i % 2 == 0
+  print i
+```
+<YueDisplay>
+
+```yue
+i = 0
+while i < 10
+  i += 1
+  continue if i % 2 == 0
+  print i
+```
+
+</YueDisplay>
+
+continue can also be used with loop expressions to prevent that iteration from accumulating into the result. This examples filters the array table into just even numbers:
+
+```yuescript
+my_numbers = [1, 2, 3, 4, 5, 6]
+odds = for x in *my_numbers
+  continue if x % 2 == 1
+  x
+```
+<YueDisplay>
+
+```yue
+my_numbers = [1, 2, 3, 4, 5, 6]
+odds = for x in *my_numbers
+  continue if x % 2 == 1
+  x
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/destructuring-assignment.md b/doc/docs/doc/destructuring-assignment.md
new file mode 100644
index 0000000..8967eb3
--- /dev/null
+++ b/doc/docs/doc/destructuring-assignment.md
@@ -0,0 +1,240 @@
+# Destructuring Assignment
+
+Destructuring assignment is a way to quickly extract values from a table by their name or position in array based tables.
+
+Typically when you see a table literal, {1,2,3}, it is on the right hand side of an assignment because it is a value. Destructuring assignment swaps the role of the table literal, and puts it on the left hand side of an assign statement.
+
+This is best explained with examples. Here is how you would unpack the first two values from a table:
+
+```yuescript
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+<YueDisplay>
+
+```yue
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+</YueDisplay>
+
+In the destructuring table literal, the key represents the key to read from the right hand side, and the value represents the name the read value will be assigned to.
+
+```yuescript
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- OK to do simple destructuring without braces
+```
+<YueDisplay>
+
+```yue
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- OK to do simple destructuring without braces
+```
+
+</YueDisplay>
+
+This also works with nested data structures as well:
+
+```yuescript
+obj2 = {
+  numbers: [1, 2, 3, 4]
+  properties: {
+    color: "green"
+    height: 13.5
+  }
+}
+
+{numbers: [first, second], properties: {color: color}} = obj2
+print first, second, color
+```
+<YueDisplay>
+
+```yue
+obj2 = {
+  numbers: [1, 2, 3, 4]
+  properties: {
+    color: "green"
+    height: 13.5
+  }
+}
+
+{numbers: [first, second]} = obj2
+print first, second, color
+```
+
+</YueDisplay>
+
+If the destructuring statement is complicated, feel free to spread it out over a few lines. A slightly more complicated example:
+
+```yuescript
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+<YueDisplay>
+
+```yue
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+</YueDisplay>
+
+It's common to extract values from at table and assign them the local variables that have the same name as the key. In order to avoid repetition we can use the **:** prefix operator:
+
+```yuescript
+{:concat, :insert} = table
+```
+<YueDisplay>
+
+```yue
+{:concat, :insert} = table
+```
+
+</YueDisplay>
+
+This is effectively the same as import, but we can rename fields we want to extract by mixing the syntax:
+
+```yuescript
+{:mix, :max, random: rand} = math
+```
+<YueDisplay>
+
+```yue
+{:mix, :max, random: rand} = math
+```
+
+</YueDisplay>
+
+You can write default values while doing destructuring like:
+
+```yuescript
+{:name = "nameless", :job = "jobless"} = person
+```
+<YueDisplay>
+
+```yue
+{:name = "nameless", :job = "jobless"} = person
+```
+
+</YueDisplay>
+
+You can use `_` as placeholder when doing a list destructuring:
+
+```yuescript
+[_, two, _, four] = items
+```
+<YueDisplay>
+
+```yue
+[_, two, _, four] = items
+```
+
+</YueDisplay>
+
+## Range Destructuring
+
+You can use the spread operator `...` in list destructuring to capture a range of values. This is useful when you want to extract specific elements from the beginning and end of a list while collecting the rest in between.
+
+```yuescript
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- prints: first
+print bulk   -- prints: {"second", "third", "fourth"}
+print last   -- prints: last
+```
+<YueDisplay>
+
+```yue
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- prints: first
+print bulk   -- prints: {"second", "third", "fourth"}
+print last   -- prints: last
+```
+
+</YueDisplay>
+
+The spread operator can be used in different positions to capture different ranges, and you can use `_` as a placeholder for the values you don't want to capture:
+
+```yuescript
+-- Capture everything after first element
+[first, ...rest] = orders
+
+-- Capture everything before last element
+[...start, last] = orders
+
+-- Capture things except the middle elements
+[first, ..._, last] = orders
+```
+<YueDisplay>
+
+```yue
+-- Capture everything after first element
+[first, ...rest] = orders
+
+-- Capture everything before last element
+[...start, last] = orders
+
+-- Capture things except the middle elements
+[first, ..._, last] = orders
+```
+
+</YueDisplay>
+
+## Destructuring In Other Places
+
+Destructuring can also show up in places where an assignment implicitly takes place. An example of this is a for loop:
+
+```yuescript
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+<YueDisplay>
+
+```yue
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+</YueDisplay>
+
+We know each element in the array table is a two item tuple, so we can unpack it directly in the names clause of the for statement using a destructure.
diff --git a/doc/docs/doc/do.md b/doc/docs/doc/do.md
new file mode 100644
index 0000000..4990d6f
--- /dev/null
+++ b/doc/docs/doc/do.md
@@ -0,0 +1,66 @@
+# Do
+
+When used as a statement, do works just like it does in Lua.
+
+```yuescript
+do
+  var = "hello"
+  print var
+print var -- nil here
+```
+<YueDisplay>
+
+```yue
+do
+  var = "hello"
+  print var
+print var -- nil here
+```
+
+</YueDisplay>
+
+YueScript's **do** can also be used an expression . Allowing you to combine multiple lines into one. The result of the do expression is the last statement in its body.
+
+```yuescript
+counter = do
+  i = 0
+  ->
+    i += 1
+    i
+
+print counter!
+print counter!
+```
+<YueDisplay>
+
+```yue
+counter = do
+  i = 0
+  ->
+    i += 1
+    i
+
+print counter!
+print counter!
+```
+
+</YueDisplay>
+
+```yuescript
+tbl = {
+  key: do
+    print "assigning key!"
+    1234
+}
+```
+<YueDisplay>
+
+```yue
+tbl = {
+  key: do
+    print "assigning key!"
+    1234
+}
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/for-loop.md b/doc/docs/doc/for-loop.md
new file mode 100644
index 0000000..cabcde5
--- /dev/null
+++ b/doc/docs/doc/for-loop.md
@@ -0,0 +1,127 @@
+# For Loop
+
+There are two for loop forms, just like in Lua. A numeric one and a generic one:
+
+```yuescript
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- an optional step provided
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+<YueDisplay>
+
+```yue
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- an optional step provided
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+
+</YueDisplay>
+
+The slicing and **\*** operators can be used, just like with comprehensions:
+
+```yuescript
+for item in *items[2, 4]
+  print item
+```
+<YueDisplay>
+
+```yue
+for item in *items[2, 4]
+  print item
+```
+
+</YueDisplay>
+
+A shorter syntax is also available for all variations when the body is only a single line:
+
+```yuescript
+for item in *items do print item
+
+for j = 1, 10, 3 do print j
+```
+<YueDisplay>
+
+```yue
+for item in *items do print item
+
+for j = 1, 10, 3 do print j
+```
+
+</YueDisplay>
+
+A for loop can also be used as an expression. The last statement in the body of the for loop is coerced into an expression and appended to an accumulating array table.
+
+Doubling every even number:
+
+```yuescript
+doubled_evens = for i = 1, 20
+  if i % 2 == 0
+    i * 2
+  else
+    i
+```
+<YueDisplay>
+
+```yue
+doubled_evens = for i = 1, 20
+  if i % 2 == 0
+    i * 2
+  else
+    i
+```
+
+</YueDisplay>
+
+In addition, for loops support break with a return value, allowing the loop itself to be used as an expression that exits early with a meaningful result.
+
+For example, to find the first number greater than 10:
+
+```yuescript
+first_large = for n in *numbers
+  break n if n > 10
+```
+<YueDisplay>
+
+```yue
+first_large = for n in *numbers
+  break n if n > 10
+```
+
+</YueDisplay>
+
+This break-with-value syntax enables concise and expressive search or early-exit patterns directly within loop expressions.
+
+You can also filter values by combining the for loop expression with the continue statement.
+
+For loops at the end of a function body are not accumulated into a table for a return value (Instead the function will return nil). Either an explicit return statement can be used, or the loop can be converted into a list comprehension.
+
+```yuescript
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- prints nil
+print func_b! -- prints table object
+```
+<YueDisplay>
+
+```yue
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- prints nil
+print func_b! -- prints table object
+```
+
+</YueDisplay>
+
+This is done to avoid the needless creation of tables for functions that don't need to return the results of the loop.
diff --git a/doc/docs/doc/function-literals.md b/doc/docs/doc/function-literals.md
new file mode 100644
index 0000000..316e07c
--- /dev/null
+++ b/doc/docs/doc/function-literals.md
@@ -0,0 +1,494 @@
+# Function Literals
+
+All functions are created using a function expression. A simple function is denoted using the arrow: **->**.
+
+```yuescript
+my_function = ->
+my_function() -- call the empty function
+```
+<YueDisplay>
+
+```yue
+my_function = ->
+my_function() -- call the empty function
+```
+
+</YueDisplay>
+
+The body of the function can either be one statement placed directly after the arrow, or it can be a series of statements indented on the following lines:
+
+```yuescript
+func_a = -> print "hello world"
+
+func_b = ->
+  value = 100
+  print "The value:", value
+```
+<YueDisplay>
+
+```yue
+func_a = -> print "hello world"
+
+func_b = ->
+  value = 100
+  print "The value:", value
+```
+
+</YueDisplay>
+
+If a function has no arguments, it can be called using the ! operator, instead of empty parentheses. The ! invocation is the preferred way to call functions with no arguments.
+
+```yuescript
+func_a!
+func_b()
+```
+<YueDisplay>
+
+```yue
+func_a!
+func_b()
+```
+
+</YueDisplay>
+
+Functions with arguments can be created by preceding the arrow with a list of argument names in parentheses:
+
+```yuescript
+sum = (x, y) -> print "sum", x + y
+```
+<YueDisplay>
+
+```yue
+sum = (x, y) -> print "sum", x + y
+```
+
+</YueDisplay>
+
+Functions can be called by listing the arguments after the name of an expression that evaluates to a function. When chaining together function calls, the arguments are applied to the closest function to the left.
+
+```yuescript
+sum 10, 20
+print sum 10, 20
+
+a b c "a", "b", "c"
+```
+<YueDisplay>
+
+```yue
+sum 10, 20
+print sum 10, 20
+
+a b c "a", "b", "c"
+```
+
+</YueDisplay>
+
+In order to avoid ambiguity in when calling functions, parentheses can also be used to surround the arguments. This is required here in order to make sure the right arguments get sent to the right functions.
+
+```yuescript
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+<YueDisplay>
+
+```yue
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+</YueDisplay>
+
+There must not be any space between the opening parenthesis and the function.
+
+Functions will coerce the last statement in their body into a return statement, this is called implicit return:
+
+```yuescript
+sum = (x, y) -> x + y
+print "The sum is ", sum 10, 20
+```
+<YueDisplay>
+
+```yue
+sum = (x, y) -> x + y
+print "The sum is ", sum 10, 20
+```
+
+</YueDisplay>
+
+And if you need to explicitly return, you can use the return keyword:
+
+```yuescript
+sum = (x, y) -> return x + y
+```
+<YueDisplay>
+
+```yue
+sum = (x, y) -> return x + y
+```
+
+</YueDisplay>
+
+Just like in Lua, functions can return multiple values. The last statement must be a list of values separated by commas:
+
+```yuescript
+mystery = (x, y) -> x + y, x - y
+a, b = mystery 10, 20
+```
+<YueDisplay>
+
+```yue
+mystery = (x, y) -> x + y, x - y
+a, b = mystery 10, 20
+```
+
+</YueDisplay>
+
+## Fat Arrows
+
+Because it is an idiom in Lua to send an object as the first argument when calling a method, a special syntax is provided for creating functions which automatically includes a self argument.
+
+```yuescript
+func = (num) => @value + num
+```
+<YueDisplay>
+
+```yue
+func = (num) => @value + num
+```
+
+</YueDisplay>
+
+## Argument Defaults
+
+It is possible to provide default values for the arguments of a function. An argument is determined to be empty if its value is nil. Any nil arguments that have a default value will be replace before the body of the function is run.
+
+```yuescript
+my_function = (name = "something", height = 100) ->
+  print "Hello I am", name
+  print "My height is", height
+```
+<YueDisplay>
+
+```yue
+my_function = (name = "something", height = 100) ->
+  print "Hello I am", name
+  print "My height is", height
+```
+
+</YueDisplay>
+
+An argument default value expression is evaluated in the body of the function in the order of the argument declarations. For this reason default values have access to previously declared arguments.
+
+```yuescript
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+<YueDisplay>
+
+```yue
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+</YueDisplay>
+
+## Considerations
+
+Because of the expressive parentheses-less way of calling functions, some restrictions must be put in place to avoid parsing ambiguity involving whitespace.
+
+The minus sign plays two roles, a unary negation operator and a binary subtraction operator. Consider how the following examples compile:
+
+```yuescript
+a = x - 10
+b = x-10
+c = x -y
+d = x- z
+```
+<YueDisplay>
+
+```yue
+a = x - 10
+b = x-10
+c = x -y
+d = x- z
+```
+
+</YueDisplay>
+
+The precedence of the first argument of a function call can be controlled using whitespace if the argument is a literal string. In Lua, it is common to leave off parentheses when calling a function with a single string or table literal.
+
+When there is no space between a variable and a string literal, the function call takes precedence over any following expressions. No other arguments can be passed to the function when it is called this way.
+
+Where there is a space following a variable and a string literal, the function call acts as show above. The string literal belongs to any following expressions (if they exist), which serves as the argument list.
+
+```yuescript
+x = func"hello" + 100
+y = func "hello" + 100
+```
+<YueDisplay>
+
+```yue
+x = func"hello" + 100
+y = func "hello" + 100
+```
+
+</YueDisplay>
+
+## Multi-line arguments
+
+When calling functions that take a large number of arguments, it is convenient to split the argument list over multiple lines. Because of the white-space sensitive nature of the language, care must be taken when splitting up the argument list.
+
+If an argument list is to be continued onto the next line, the current line must end in a comma. And the following line must be indented more than the current indentation. Once indented, all other argument lines must be at the same level of indentation to be part of the argument list
+
+```yuescript
+my_func 5, 4, 3,
+  8, 9, 10
+
+cool_func 1, 2,
+  3, 4,
+  5, 6,
+  7, 8
+```
+<YueDisplay>
+
+```yue
+my_func 5, 4, 3,
+  8, 9, 10
+
+cool_func 1, 2,
+  3, 4,
+  5, 6,
+  7, 8
+```
+
+</YueDisplay>
+
+This type of invocation can be nested. The level of indentation is used to determine to which function the arguments belong to.
+
+```yuescript
+my_func 5, 6, 7,
+  6, another_func 6, 7, 8,
+    9, 1, 2,
+  5, 4
+```
+<YueDisplay>
+
+```yue
+my_func 5, 6, 7,
+  6, another_func 6, 7, 8,
+    9, 1, 2,
+  5, 4
+```
+
+</YueDisplay>
+
+Because tables also use the comma as a delimiter, this indentation syntax is helpful for letting values be part of the argument list instead of being part of the table.
+
+```yuescript
+x = [
+  1, 2, 3, 4, a_func 4, 5,
+    5, 6,
+  8, 9, 10
+]
+```
+<YueDisplay>
+
+```yue
+x = [
+  1, 2, 3, 4, a_func 4, 5,
+    5, 6,
+  8, 9, 10
+]
+```
+
+</YueDisplay>
+
+Although uncommon, notice how we can give a deeper indentation for function arguments if we know we will be using a lower indentation further on.
+
+```yuescript
+y = [ my_func 1, 2, 3,
+   4, 5,
+  5, 6, 7
+]
+```
+<YueDisplay>
+
+```yue
+y = [ my_func 1, 2, 3,
+   4, 5,
+  5, 6, 7
+]
+```
+
+</YueDisplay>
+
+The same thing can be done with other block level statements like conditionals. We can use indentation level to determine what statement a value belongs to:
+
+```yuescript
+if func 1, 2, 3,
+  "hello",
+  "world"
+    print "hello"
+    print "I am inside if"
+
+if func 1, 2, 3,
+    "hello",
+    "world"
+  print "hello"
+  print "I am inside if"
+```
+<YueDisplay>
+
+```yue
+if func 1, 2, 3,
+  "hello",
+  "world"
+    print "hello"
+    print "I am inside if"
+
+if func 1, 2, 3,
+    "hello",
+    "world"
+  print "hello"
+  print "I am inside if"
+```
+
+</YueDisplay>
+
+## Parameter Destructuring
+
+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}`).
+
+* **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) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+```
+<YueDisplay>
+
+```yue
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+```
+
+</YueDisplay>
+
+## Prefixed Return Expression
+
+When working with deeply nested function bodies, it can be tedious to maintain readability and consistency of the return value. To address this, YueScript introduces the **Prefixed Return Expression** syntax. Its form is as follows:
+
+```yuescript
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+```
+<YueDisplay>
+
+```yue
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+```
+
+</YueDisplay>
+
+This is equivalent to:
+
+```yuescript
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+```
+<YueDisplay>
+
+```yue
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+```
+
+</YueDisplay>
+
+The only difference is that you can move the final return expression before the `->` or `=>` token to indicate the function’s implicit return value as the last statement. This way, even in functions with multiple nested loops or conditional branches, you no longer need to write a trailing return expression at the end of the function body, making the logic structure more straightforward and easier to follow.
+
+## Named Varargs
+
+You can use the `(...t) ->` syntax to automatically store varargs into a named table. This table will contain all passed arguments (including `nil` values), and the `n` field of the table will store the actual number of arguments passed (including `nil` values).
+
+```yuescript
+f = (...t) ->
+  print "argument count:", t.n
+  print "table length:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- Handling cases with nil values
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+<YueDisplay>
+
+```yue
+f = (...t) ->
+  print "argument count:", t.n
+  print "table length:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- Handling cases with nil values
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/function-stubs.md b/doc/docs/doc/function-stubs.md
new file mode 100644
index 0000000..57a8b0c
--- /dev/null
+++ b/doc/docs/doc/function-stubs.md
@@ -0,0 +1,48 @@
+# Function Stubs
+
+It is common to pass a function from an object around as a value, for example, passing an instance method into a function as a callback. If the function expects the object it is operating on as the first argument then you must somehow bundle that object with the function so it can be called properly.
+
+The function stub syntax is a shorthand for creating a new closure function that bundles both the object and function. This new function calls the wrapped function in the correct context of the object.
+
+Its syntax is the same as calling an instance method with the \ operator but with no argument list provided.
+
+```yuescript
+my_object = {
+  value: 1000
+  write: => print "the value:", @value
+}
+
+run_callback = (func) ->
+  print "running callback..."
+  func!
+
+-- this will not work:
+-- the function has to no reference to my_object
+run_callback my_object.write
+
+-- function stub syntax
+-- lets us bundle the object into a new function
+run_callback my_object\write
+```
+<YueDisplay>
+
+```yue
+my_object = {
+  value: 1000
+  write: => print "the value:", @value
+}
+
+run_callback = (func) ->
+  print "running callback..."
+  func!
+
+-- this will not work:
+-- the function has to no reference to my_object
+run_callback my_object.write
+
+-- function stub syntax
+-- lets us bundle the object into a new function
+run_callback my_object\write
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/if-assignment.md b/doc/docs/doc/if-assignment.md
new file mode 100644
index 0000000..02984e8
--- /dev/null
+++ b/doc/docs/doc/if-assignment.md
@@ -0,0 +1,72 @@
+# If Assignment
+
+`if` and `elseif` blocks can take an assignment in place of a conditional expression. Upon evaluating the conditional, the assignment will take place and the value that was assigned to will be used as the conditional expression. The assigned variable is only in scope for the body of the conditional, meaning it is never available if the value is not truthy. And you have to use "the walrus operator" `:=` instead of `=` to do assignment.
+
+```yuescript
+if user := database.find_user "moon"
+  print user.name
+```
+<YueDisplay>
+
+```yue
+if user := database.find_user "moon"
+  print user.name
+```
+
+</YueDisplay>
+
+```yuescript
+if hello := os.getenv "hello"
+  print "You have hello", hello
+elseif world := os.getenv "world"
+  print "you have world", world
+else
+  print "nothing :("
+```
+<YueDisplay>
+
+```yue
+if hello := os.getenv "hello"
+  print "You have hello", hello
+elseif world := os.getenv "world"
+  print "you have world", world
+else
+  print "nothing :("
+```
+
+</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
+if success, result := pcall -> "get result without problems"
+  print result -- variable result is scoped
+print "OK"
+```
+
+</YueDisplay>
+
+## While Assignment
+
+You can also use if assignment in a while loop to get the value as the loop condition.
+
+```yuescript
+while byte := stream\read_one!
+  -- do something with the byte
+  print byte
+```
+<YueDisplay>
+
+```yue
+while byte := stream\read_one!
+  -- do something with the byte
+  print byte
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/index.md b/doc/docs/doc/index.md
index 6de2ce7..b7f609b 100755
--- a/doc/docs/doc/index.md
+++ b/doc/docs/doc/index.md
@@ -1,5520 +1,11 @@
 ---
-sidebar: auto
 title: Reference
 ---
 
-# YueScript
+# YueScript Documentation
 
-<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em;"/>
+<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em; padding-bottom: 2em;"/>
 
-## Introduction
-
-YueScript is a dynamic language that compiles to Lua. And it's a [MoonScript](https://github.com/leafo/moonscript) dialect. The codes written in YueScript are expressive and extremely concise. And it is suitable for writing some changing application logic with more maintainable codes and runs in a Lua embeded environment such as games or website servers.
-
-Yue (月) is the name of moon in Chinese and it's pronounced as [jyɛ].
-
-### An Overview of YueScript
-```yuescript
--- import syntax
-import p, to_lua from "yue"
-
--- object literals
-inventory =
-  equipment:
-    - "sword"
-    - "shield"
-  items:
-    - name: "potion"
-      count: 10
-    - name: "bread"
-      count: 3
-
--- list comprehension
-map = (arr, action) ->
-  [action item for item in *arr]
-
-filter = (arr, cond) ->
-  [item for item in *arr when cond item]
-
-reduce = (arr, init, action): init ->
-  init = action init, item for item in *arr
-
--- pipe operator
-[1, 2, 3]
-  |> map (x) -> x * 2
-  |> filter (x) -> x > 4
-  |> reduce 0, (a, b) -> a + b
-  |> print
-
--- metatable manipulation
-apple =
-  size: 15
-  <index>:
-    color: 0x00ffff
-
-with apple
-  p .size, .color, .<index> if .<>?
-
--- js-like export syntax
-export 🌛 = "月之脚本"
-```
-
-<YueDisplay>
-
-```yue
--- import syntax
-import p, to_lua from "yue"
-
--- object literals
-inventory =
-  equipment:
-    - "sword"
-    - "shield"
-  items:
-    - name: "potion"
-      count: 10
-    - name: "bread"
-      count: 3
-
--- list comprehension
-map = (arr, action) ->
-  [action item for item in *arr]
-
-filter = (arr, cond) ->
-  [item for item in *arr when cond item]
-
-reduce = (arr, init, action): init ->
-  init = action init, item for item in *arr
-
--- pipe operator
-[1, 2, 3]
-  |> map (x) -> x * 2
-  |> filter (x) -> x > 4
-  |> reduce 0, (a, b) -> a + b
-  |> print
-
--- metatable manipulation
-apple =
-  size: 15
-  <index>:
-    color: 0x00ffff
-
-with apple
-  p .size, .color, .<index> if .<>?
-
--- js-like export syntax
-export 🌛 = "月之脚本"
-```
-
-</YueDisplay>
-
-## Installation
-
-* **Lua Module**
-
-&emsp;Install [luarocks](https://luarocks.org), a package manager for Lua modules. Then install it as a Lua module and executable with:
-
-```
-> luarocks install yuescript
-```
-
-&emsp;Or you can build `yue.so` file with:
-
-```
-> make shared LUAI=/usr/local/include/lua LUAL=/usr/local/lib/lua
-```
-
-&emsp;Then get the binary file from path **bin/shared/yue.so**.
-
-* **Build Binary Tool**
-
-&emsp;Clone this repo, then build and install executable with:
-```
-> make install
-```
-
-&emsp;Build YueScript tool without macro feature:
-```
-> make install NO_MACRO=true
-```
-
-&emsp;Build YueScript tool without built-in Lua binary:
-```
-> make install NO_LUA=true
-```
-
-* **Download Precompiled Binary**
-
-&emsp;You can download precompiled binary files, including binary executable files compatible with different Lua versions and library files.
-
-&emsp;Download precompiled binary files from [here](https://github.com/IppClub/YueScript/releases).
-
-## Usage
-
-### Lua Module
-
-&emsp;Use YueScript module in Lua:
-
-* **Case 1**
-Require "your_yuescript_entry.yue" in Lua.
-```Lua
-require("yue")("your_yuescript_entry")
-```
-&emsp;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
-
-&emsp;Use YueScript tool with:
-```sh
-> yue -h
-Usage: yue
-       [options] [<file/directory>] ...
-       yue -e <code_or_file> [args...]
-       yue -w [<directory>] [options]
-       yue -
-
-Notes:
-   - '-' / '--' must be the first and only argument.
-   - '-o/--output' can not be used with multiple input files.
-   - '-w/--watch' can not be used with file input (directory only).
-   - with '-e/--execute', remaining tokens are treated as script args.
-
-Options:
-   -h, --help                 Show this help message and exit.
-   -e <str>, --execute <str>  Execute a file or raw codes
-   -m, --minify               Generate minified codes
-   -r, --rewrite              Rewrite output to match original line numbers
-   -t <output_to>, --output-to <output_to>
-                              Specify where to place compiled files
-   -o <file>, --output <file> Write output to file
-   -p, --print                Write output to standard out
-   -b, --benchmark            Dump compile time (doesn't write output)
-   -g, --globals              Dump global variables used in NAME LINE COLUMN
-   -s, --spaces               Use spaces in generated codes instead of tabs
-   -l, --line-numbers         Write line numbers from source codes
-   -j, --no-implicit-return   Disable implicit return at end of file
-   -c, --reserve-comments     Reserve comments before statement from source codes
-   -w [<dir>], --watch [<dir>]
-                              Watch changes and compile every file under directory
-   -v, --version              Print version
-   -                          Read from standard in, print to standard out
-                              (Must be first and only argument)
-   --                         Same as '-' (kept for backward compatibility)
-
-   --target <version>         Specify the Lua version that codes will be generated to
-                              (version can only be 5.1 to 5.5)
-   --path <path_str>          Append an extra Lua search path string to package.path
-   --<key>=<value>            Pass compiler option in key=value form (existing behavior)
-
-   Execute without options to enter REPL, type symbol '$'
-   in a single line to start/stop multi-line mode
-```
-&emsp;&emsp;Use cases:
-
-&emsp;&emsp;Recursively compile every YueScript file with extension **.yue** under current path:  **yue .**
-
-&emsp;&emsp;Compile and save results to a target path:  **yue -t /target/path/ .**
-
-&emsp;&emsp;Compile and reserve debug info:  **yue -l .**
-
-&emsp;&emsp;Compile and generate minified codes:  **yue -m .**
-
-&emsp;&emsp;Execute raw codes:  **yue -e 'print 123'**
-
-&emsp;&emsp;Execute a YueScript file:  **yue -e main.yue**
-
-## Macro
-
-### Common Usage
-
-Macro function is used for evaluating a string in the compile time and insert the generated codes into final compilation.
-
-```yuescript
-macro PI2 = -> math.pi * 2
-area = $PI2 * 5
-
-macro HELLO = -> "'hello world'"
-print $HELLO
-
-macro config = (debugging) ->
-  global debugMode = debugging == "true"
-  ""
-
-macro asserts = (cond) ->
-  debugMode and "assert #{cond}" or ""
-
-macro assert = (cond) ->
-  debugMode and "assert #{cond}" or "#{cond}"
-
-$config true
-$asserts item ~= nil
-
-$config false
-value = $assert item
-
--- the passed expressions are treated as strings
-macro and = (...) -> "#{ table.concat {...}, ' and ' }"
-if $and f1!, f2!, f3!
-  print "OK"
-```
-<YueDisplay>
-
-```yue
-macro PI2 = -> math.pi * 2
-area = $PI2 * 5
-
-macro HELLO = -> "'hello world'"
-print $HELLO
-
-macro config = (debugging) ->
-  global debugMode = debugging == "true"
-  ""
-
-macro asserts = (cond) ->
-  debugMode and "assert #{cond}" or ""
-
-macro assert = (cond) ->
-  debugMode and "assert #{cond}" or "#{cond}"
-
-$config true
-$asserts item ~= nil
-
-$config false
-value = $assert item
-
--- the passed expressions are treated as strings
-macro and = (...) -> "#{ table.concat {...}, ' and ' }"
-if $and f1!, f2!, f3!
-  print "OK"
-```
-
-</YueDisplay>
-
-### 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
-funcA = -> "fail to assign to the Yue macro defined variable"
-
-macro luaFunc = (var) -> {
-  code: "local function #{var}() end"
-  type: "lua"
-}
-$luaFunc funcB
-funcB = -> "fail to assign to the Lua macro defined variable"
-
-macro lua = (code) -> {
-  :code
-  type: "lua"
-}
-
--- the raw string leading and ending symbols are auto trimed
-$lua[==[
--- raw Lua codes insertion
-if cond then
-  print("output")
-end
-]==]
-```
-<YueDisplay>
-
-```yue
-macro yueFunc = (var) -> "local #{var} = ->"
-$yueFunc funcA
-funcA = -> "fail to assign to the Yue macro defined variable"
-
-macro luaFunc = (var) -> {
-  code: "local function #{var}() end"
-  type: "lua"
-}
-$luaFunc funcB
-funcB = -> "fail to assign to the Lua macro defined variable"
-
-macro lua = (code) -> {
-  :code
-  type: "lua"
-}
-
--- the raw string leading and ending symbols are auto trimed
-$lua[==[
--- raw Lua codes insertion
-if cond then
-  print("output")
-end
-]==]
-```
-
-</YueDisplay>
-
-### 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}]"
-export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
-export macro foreach = (items, action) -> "for _ in *#{items}
-  #{action}"
-
--- file main.yue
-import "utils" as {
-  $, -- symbol to import all macros
-  $foreach: $each -- rename macro $foreach to $each
-}
-[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
-```
-<YueDisplay>
-
-```yue
--- file: utils.yue
-export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
-export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
-export macro foreach = (items, action) -> "for _ in *#{items}
-  #{action}"
--- file main.yue
--- import function is not available in browser, try it in a real environment
---[[
-import "utils" as {
-  $, -- symbol to import all macros
-  $foreach: $each -- rename macro $foreach to $each
-}
-[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
-]]
-```
-
-</YueDisplay>
-
-### 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
-print $FILE -- get string of current module name
-print $LINE -- get number 2
-```
-
-</YueDisplay>
-
-### Generating Macros with Macros
-
-In YueScript, macro functions allow you to generate code at compile time. By nesting macro functions, you can create more complex generation patterns. This feature enables you to define a macro function that generates another macro function, allowing for more dynamic code generation.
-
-```yuescript
-macro Enum = (...) ->
-  items = {...}
-  itemSet = {item, true for item in *items}
-  (item) ->
-    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
-    "\"#{item}\""
-
-macro BodyType = $Enum(
-  Static
-  Dynamic
-  Kinematic
-)
-
-print "Valid enum type:", $BodyType Static
--- print "Compilation error with enum type:", $BodyType Unknown
-```
-
-<YueDisplay>
-
-```yue
-macro Enum = (...) ->
-  items = {...}
-  itemSet = {item, true for item in *items}
-  (item) ->
-    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
-    "\"#{item}\""
-
-macro BodyType = $Enum(
-  Static
-  Dynamic
-  Kinematic
-)
-
-print "Valid enum type:", $BodyType Static
--- print "Compilation error with enum type:", $BodyType Unknown
-```
-
-</YueDisplay>
-
-### Argument Validation
-
-You can declare the expected AST node types in the argument list, and check whether the incoming macro arguments meet the expectations at compile time.
-
-```yuescript
-macro printNumAndStr = (num `Num, str `String) -> |
-  print(
-    #{num}
-    #{str}
-  )
-
-$printNumAndStr 123, "hello"
-```
-<YueDisplay>
-
-```yue
-macro printNumAndStr = (num `Num, str `String) -> |
-  print(
-    #{num}
-    #{str}
-  )
-
-$printNumAndStr 123, "hello"
-```
-
-</YueDisplay>
-
-If you need more flexible argument checking, you can use the built-in `$is_ast` macro function to manually check at the appropriate place.
-
-```yuescript
-macro printNumAndStr = (num, str) ->
-  error "expected Num as first argument" unless $is_ast Num, num
-  error "expected String as second argument" unless $is_ast String, str
-  "print(#{num}, #{str})"
-
-$printNumAndStr 123, "hello"
-```
-<YueDisplay>
-
-```yue
-macro printNumAndStr = (num, str) ->
-  error "expected Num as first argument" unless $is_ast Num, num
-  error "expected String as second argument" unless $is_ast String, str
-  "print(#{num}, #{str})"
-
-$printNumAndStr 123, "hello"
-```
-
-</YueDisplay>
-
-For more details about available AST nodes, please refer to the uppercased definitions in [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp).
-
-## Operator
-
-All of Lua's binary and unary operators are available. Additionally **!=** is as an alias for **~=**, and either **\\** or **::** can be used to write a chaining function call like `tb\func!` or `tb::func!`. And Yuescipt offers some other special operators to write more expressive codes.
-
-```yuescript
-tb\func! if tb ~= nil
-tb::func! if tb != nil
-```
-<YueDisplay>
-
-```yue
-tb\func! if tb ~= nil
-tb::func! if tb != nil
-```
-
-</YueDisplay>
-
-### Chaining Comparisons
-
-Comparisons can be arbitrarily chained:
-
-```yuescript
-print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
--- output: true
-
-a = 5
-print 1 <= a <= 10
--- output: true
-```
-<YueDisplay>
-
-```yue
-print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
--- output: true
-
-a = 5
-print 1 <= a <= 10
--- output: true
-```
-
-</YueDisplay>
-
-Note the evaluation behavior of chained comparisons:
-
-```yuescript
-v = (x) ->
-  print x
-  x
-
-print v(1) < v(2) <= v(3)
---[[
-  output:
-  2
-  1
-  3
-  true
-]]
-
-print v(1) > v(2) <= v(3)
---[[
-  output:
-  2
-  1
-  false
-]]
-```
-<YueDisplay>
-
-```yue
-v = (x) ->
-  print x
-  x
-
-print v(1) < v(2) <= v(3)
---[[
-  output:
-  2
-  1
-  3
-  true
-]]
-
-print v(1) > v(2) <= v(3)
---[[
-  output:
-  2
-  1
-  false
-]]
-```
-
-</YueDisplay>
-
-The middle expression is only evaluated once, rather than twice as it would be if the expression were written as `v(1) < v(2) and v(2) <= v(3)`. However, the order of evaluations in a chained comparison is undefined. It is strongly recommended not to use expressions with side effects (such as printing) in chained comparisons. If side effects are required, the short-circuit `and` operator should be used explicitly.
-
-### Table Appending
-The **[] =** operator is used to append values to tables.
-
-```yuescript
-tab = []
-tab[] = "Value"
-```
-<YueDisplay>
-
-```yue
-tab = []
-tab[] = "Value"
-```
-
-</YueDisplay>
-
-You can also use the spread operator `...` to append all elements from one list to another:
-
-```yuescript
-tbA = [1, 2, 3]
-tbB = [4, 5, 6]
-tbA[] = ...tbB
--- tbA is now [1, 2, 3, 4, 5, 6]
-```
-<YueDisplay>
-
-```yue
-tbA = [1, 2, 3]
-tbB = [4, 5, 6]
-tbA[] = ...tbB
--- tbA is now [1, 2, 3, 4, 5, 6]
-```
-
-</YueDisplay>
-
-### Table Spreading
-
-You can concatenate array tables or hash tables using spread operator `...` before expressions in table literals.
-
-```yuescript
-parts =
-  * "shoulders"
-  * "knees"
-lyrics =
-  * "head"
-  * ...parts
-  * "and"
-  * "toes"
-
-copy = {...other}
-
-a = {1, 2, 3, x: 1}
-b = {4, 5, y: 1}
-merge = {...a, ...b}
-```
-<YueDisplay>
-
-```yue
-parts =
-  * "shoulders"
-  * "knees"
-lyrics =
-  * "head"
-  * ...parts
-  * "and"
-  * "toes"
-
-copy = {...other}
-
-a = {1, 2, 3, x: 1}
-b = {4, 5, y: 1}
-merge = {...a, ...b}
-```
-
-</YueDisplay>
-
-### Table Reversed Indexing
-
-You can use the **#** operator to get the last elements of a table.
-
-```yuescript
-last = data.items[#]
-second_last = data.items[#-1]
-data.items[#] = 1
-```
-<YueDisplay>
-
-```yue
-last = data.items[#]
-second_last = data.items[#-1]
-data.items[#] = 1
-```
-
-</YueDisplay>
-
-### Metatable
-
-The **<>** operator can be used as a shortcut for metatable manipulation.
-
-* **Metatable Creation**
-Create normal table with empty bracekets **<>** or metamethod key which is surrounded by **<>**.
-
-```yuescript
-mt = {}
-add = (right) => <>: mt, value: @value + right.value
-mt.__add = add
-
-a = <>: mt, value: 1
- -- set field with variable of the same name
-b = :<add>, value: 2
-c = <add>: mt.__add, value: 3
-
-d = a + b + c
-print d.value
-
-close _ = <close>: -> print "out of scope"
-```
-<YueDisplay>
-
-```yue
-mt = {}
-add = (right) => <>: mt, value: @value + right.value
-mt.__add = add
-
-a = <>: mt, value: 1
- -- set field with variable of the same name
-b = :<add>, value: 2
-c = <add>: mt.__add, value: 3
-
-d = a + b + c
-print d.value
-
-close _ = <close>: -> print "out of scope"
-```
-
-</YueDisplay>
-
-* **Metatable Accessing**
-Accessing metatable with **<>** or metamethod name surrounded by **<>** or writing some expression in **<>**.
-
-```yuescript
--- create with metatable containing field "value"
-tb = <"value">: 123
-tb.<index> = tb.<>
-print tb.value
-
-tb.<> = __index: {item: "hello"}
-print tb.item
-```
-<YueDisplay>
-
-```yue
--- create with metatable containing field "value"
-tb = <"value">: 123
-tb.<index> = tb.<>
-print tb.value
-tb.<> = __index: {item: "hello"}
-print tb.item
-```
-
-</YueDisplay>
-
-* **Metatable Destructure**
-Destruct metatable with metamethod key surrounded by **<>**.
-
-```yuescript
-{item, :new, :<close>, <index>: getter} = tb
-print item, new, close, getter
-```
-<YueDisplay>
-
-```yue
-{item, :new, :<close>, <index>: getter} = tb
-print item, new, close, getter
-```
-
-</YueDisplay>
-
-### Existence
-
-The **?** operator can be used in a variety of contexts to check for existence.
-
-```yuescript
-func?!
-print abc?["hello world"]?.xyz
-
-x = tab?.value
-len = utf8?.len or string?.len or (o) -> #o
-
-if print and x?
-  print x
-
-with? io.open "test.txt", "w"
-  \write "hello"
-  \close!
-```
-<YueDisplay>
-
-```yue
-func?!
-print abc?["hello world"]?.xyz
-
-x = tab?.value
-len = utf8?.len or string?.len or (o) -> #o
-
-if print and x?
-  print x
-
-with? io.open "test.txt", "w"
-  \write "hello"
-  \close!
-```
-
-</YueDisplay>
-
-### Piping
-
-Instead of a series of nested function calls, you can pipe values with operator **|>**.
-
-```yuescript
-"hello" |> print
-1 |> print 2 -- insert pipe item as the first argument
-2 |> print 1, _, 3 -- pipe with a placeholder
-
--- pipe expression in multiline
-readFile "example.txt"
-  |> extract language, {}
-  |> parse language
-  |> emit
-  |> render
-  |> print
-```
-<YueDisplay>
-
-```yue
-"hello" |> print
-1 |> print 2 -- insert pipe item as the first argument
-2 |> print 1, _, 3 -- pipe with a placeholder
--- pipe expression in multiline
-readFile "example.txt"
-  |> extract language, {}
-  |> parse language
-  |> emit
-  |> render
-  |> print
-```
-
-</YueDisplay>
-
-### 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
-func a ?? {}
-
-a ??= false
-```
-<YueDisplay>
-
-```yue
-local a, b, c, d
-a = b ?? c ?? d
-func a ?? {}
-a ??= false
-```
-
-</YueDisplay>
-
-### Implicit Object
-
-You can write a list of implicit structures that starts with the symbol **\*** or **-** inside a table block. If you are creating implicit object, the fields of the object must be with the same indent.
-
-```yuescript
--- assignment with implicit object
-list =
-  * 1
-  * 2
-  * 3
-
--- function call with implicit object
-func
-  * 1
-  * 2
-  * 3
-
--- return with implicit object
-f = ->
-  return
-    * 1
-    * 2
-    * 3
-
--- table with implicit object
-tb =
-  name: "abc"
-
-  values:
-    - "a"
-    - "b"
-    - "c"
-
-  objects:
-    - name: "a"
-      value: 1
-      func: => @value + 1
-      tb:
-        fieldA: 1
-
-    - name: "b"
-      value: 2
-      func: => @value + 2
-      tb: { }
-
-```
-<YueDisplay>
-
-```yue
--- assignment with implicit object
-list =
-  * 1
-  * 2
-  * 3
-
--- function call with implicit object
-func
-  * 1
-  * 2
-  * 3
-
--- return with implicit object
-f = ->
-  return
-    * 1
-    * 2
-    * 3
-
--- table with implicit object
-tb =
-  name: "abc"
-
-  values:
-    - "a"
-    - "b"
-    - "c"
-
-  objects:
-    - name: "a"
-      value: 1
-      func: => @value + 1
-      tb:
-        fieldA: 1
-
-    - name: "b"
-      value: 2
-      func: => @value + 2
-      tb: { }
-```
-
-</YueDisplay>
-
-## Module
-
-### Import
-
-The import statement is a syntax sugar for requiring a module or help extracting items from an imported module. The imported items are const by default.
-
-```yuescript
--- used as table destructuring
-do
-  import insert, concat from table
-  -- report error when assigning to insert, concat
-  import C, Ct, Cmt from require "lpeg"
-  -- shortcut for implicit requiring
-  import x, y, z from 'mymodule'
-  -- import with Python style
-  from 'module' import a, b, c
-
--- shortcut for requring a module
-do
-  import 'module'
-  import 'module_x'
-  import "d-a-s-h-e-s"
-  import "module.part"
-
--- requring module with aliasing or table destructuring
-do
-  import "player" as PlayerModule
-  import "lpeg" as :C, :Ct, :Cmt
-  import "export" as {one, two, Something:{umm:{ch}}}
-```
-<YueDisplay>
-
-```yue
--- used as table destructuring
-do
-  import insert, concat from table
-  -- report error when assigning to insert, concat
-  import C, Ct, Cmt from require "lpeg"
-  -- shortcut for implicit requiring
-  import x, y, z from 'mymodule'
-  -- import with Python style
-  from 'module' import a, b, c
-
--- shortcut for requring a module
-do
-  import 'module'
-  import 'module_x'
-  import "d-a-s-h-e-s"
-  import "module.part"
-
--- requring module with aliasing or table destructuring
-do
-  import "player" as PlayerModule
-  import "lpeg" as :C, :Ct, :Cmt
-  import "export" as {one, two, Something:{umm:{ch}}}
-```
-
-</YueDisplay>
-
-### Import Global
-
-You can import specific globals into local variables with `import`. When importing a chain of global variable accessings, the last field will be assigned to the local variable.
-
-```yuescript
-do
-  import tostring
-  import table.concat
-  print concat ["a", tostring 1]
-```
-<YueDisplay>
-
-```yue
-do
-  import tostring
-  import table.concat
-  print concat ["a", tostring 1]
-```
-
-</YueDisplay>
-
-#### Automatic Import
-
-You can place `import global` at the top of a block to automatically import all names that have not been explicitly declared or assigned in the current scope as globals. These implicit imports are treated as local consts that reference the corresponding globals at the position of the statement.
-
-Names that are explicitly declared as globals in the same scope will not be imported, so you can still assign to them.
-
-```yuescript
-do
-  import global
-  print "hello"
-  math.random 3
-  -- print = nil -- error: imported globals are const
-
-do
-  -- explicit global variable will not be imported
-  import global
-  global FLAG
-  print FLAG
-  FLAG = 123
-```
-<YueDisplay>
-
-```yue
-do
-  import global
-  print "hello"
-  math.random 3
-  -- print = nil -- error: imported globals are const
-
-do
-  -- explicit global variable will not be imported
-  import global
-  global FLAG
-  print FLAG
-  FLAG = 123
-```
-
-</YueDisplay>
-
-### Export
-
-The export statement offers a concise way to define modules.
-
-* **Named Export**
-Named export will define a local variable as well as adding a field in the exported table.
-
-```yuescript
-export a, b, c = 1, 2, 3
-export cool = "cat"
-
-export What = if this
-  "abc"
-else
-  "def"
-
-export y = ->
-  hallo = 3434
-
-export class Something
-  umm: "cool"
-```
-<YueDisplay>
-
-```yue
-export a, b, c = 1, 2, 3
-export cool = "cat"
-
-export What = if this
-  "abc"
-else
-  "def"
-
-export y = ->
-  hallo = 3434
-
-export class Something
-  umm: "cool"
-```
-
-</YueDisplay>
-
-Doing named export with destructuring.
-
-```yuescript
-export :loadstring, to_lua: tolua = yue
-export {itemA: {:fieldA = 'default'}} = tb
-```
-<YueDisplay>
-
-```yue
-export :loadstring, to_lua: tolua = yue
-export {itemA: {:fieldA = 'default'}} = tb
-```
-
-</YueDisplay>
-
-Export named items from module without creating local variables.
-
-```yuescript
-export.itemA = tb
-export.<index> = items
-export["a-b-c"] = 123
-```
-<YueDisplay>
-
-```yue
-export.itemA = tb
-export.<index> = items
-export["a-b-c"] = 123
-```
-
-</YueDisplay>
-
-* **Unnamed Export**
-Unnamed export will add the target item into the array part of the exported table.
-
-```yuescript
-d, e, f = 3, 2, 1
-export d, e, f
-
-export if this
-  123
-else
-  456
-
-export with tmp
-  j = 2000
-```
-<YueDisplay>
-
-```yue
-d, e, f = 3, 2, 1
-export d, e, f
-
-export if this
-  123
-else
-  456
-
-export with tmp
-  j = 2000
-```
-
-</YueDisplay>
-
-* **Default Export**
-Using the **default** keyword in export statement to replace the exported table with any thing.
-
-```yuescript
-export default ->
-  print "hello"
-  123
-```
-<YueDisplay>
-
-```yue
-export default ->
-  print "hello"
-  123
-```
-
-</YueDisplay>
-
-## Assignment
-
-The variable is dynamic typed and is defined as local by default. But you can change the scope of declaration by **local** and **global** statement.
-
-```yuescript
-hello = "world"
-a, b, c = 1, 2, 3
-hello = 123 -- uses the existing variable
-```
-<YueDisplay>
-
-```yue
-hello = "world"
-a, b, c = 1, 2, 3
-hello = 123 -- uses the existing variable
-```
-
-</YueDisplay>
-
-### Perform Update
-
-You can perform update assignment with many binary operators.
-```yuescript
-x = 1
-x += 1
-x -= 1
-x *= 10
-x /= 10
-x %= 10
-s ..= "world" -- will add a new local if local variable is not exist
-arg or= "default value"
-```
-<YueDisplay>
-
-```yue
-x = 1
-x += 1
-x -= 1
-x *= 10
-x /= 10
-x %= 10
-s ..= "world" -- will add a new local if local variable is not exist
-arg or= "default value"
-```
-
-</YueDisplay>
-
-### 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
-a = b = c = d = e = 0
-x = y = z = f!
-```
-
-</YueDisplay>
-
-### Explicit Locals
-```yuescript
-do
-  local a = 1
-  local *
-  print "forward declare all variables as locals"
-  x = -> 1 + y + z
-  y, z = 2, 3
-  global instance = Item\new!
-
-do
-  local X = 1
-  local ^
-  print "only forward declare upper case variables"
-  a = 1
-  B = 2
-```
-<YueDisplay>
-
-```yue
-do
-  local a = 1
-  local *
-  print "forward declare all variables as locals"
-  x = -> 1 + y + z
-  y, z = 2, 3
-  global instance = Item\new!
-
-do
-  local X = 1
-  local ^
-  print "only forward declare upper case variables"
-  a = 1
-  B = 2
-```
-
-</YueDisplay>
-
-### Explicit Globals
-```yuescript
-do
-  global a = 1
-  global *
-  print "declare all variables as globals"
-  x = -> 1 + y + z
-  y, z = 2, 3
-
-do
-  global X = 1
-  global ^
-  print "only declare upper case variables as globals"
-  a = 1
-  B = 2
-  local Temp = "a local value"
-```
-<YueDisplay>
-
-```yue
-do
-  global a = 1
-  global *
-  print "declare all variables as globals"
-  x = -> 1 + y + z
-  y, z = 2, 3
-
-do
-  global X = 1
-  global ^
-  print "only declare upper case variables as globals"
-  a = 1
-  B = 2
-  local Temp = "a local value"
-```
-
-</YueDisplay>
-
-## Destructuring Assignment
-
-Destructuring assignment is a way to quickly extract values from a table by their name or position in array based tables.
-
-Typically when you see a table literal, {1,2,3}, it is on the right hand side of an assignment because it is a value. Destructuring assignment swaps the role of the table literal, and puts it on the left hand side of an assign statement.
-
-This is best explained with examples. Here is how you would unpack the first two values from a table:
-
-```yuescript
-thing = [1, 2]
-
-[a, b] = thing
-print a, b
-```
-<YueDisplay>
-
-```yue
-thing = [1, 2]
-
-[a, b] = thing
-print a, b
-```
-
-</YueDisplay>
-
-In the destructuring table literal, the key represents the key to read from the right hand side, and the value represents the name the read value will be assigned to.
-
-```yuescript
-obj = {
-  hello: "world"
-  day: "tuesday"
-  length: 20
-}
-
-{hello: hello, day: the_day} = obj
-print hello, the_day
-
-:day = obj -- OK to do simple destructuring without braces
-```
-<YueDisplay>
-
-```yue
-obj = {
-  hello: "world"
-  day: "tuesday"
-  length: 20
-}
-
-{hello: hello, day: the_day} = obj
-print hello, the_day
-
-:day = obj -- OK to do simple destructuring without braces
-```
-
-</YueDisplay>
-
-This also works with nested data structures as well:
-
-```yuescript
-obj2 = {
-  numbers: [1, 2, 3, 4]
-  properties: {
-    color: "green"
-    height: 13.5
-  }
-}
-
-{numbers: [first, second], properties: {color: color}} = obj2
-print first, second, color
-```
-<YueDisplay>
-
-```yue
-obj2 = {
-  numbers: [1, 2, 3, 4]
-  properties: {
-    color: "green"
-    height: 13.5
-  }
-}
-
-{numbers: [first, second]} = obj2
-print first, second, color
-```
-
-</YueDisplay>
-
-If the destructuring statement is complicated, feel free to spread it out over a few lines. A slightly more complicated example:
-
-```yuescript
-{
-  numbers: [first, second]
-  properties: {
-    color: color
-  }
-} = obj2
-```
-<YueDisplay>
-
-```yue
-{
-  numbers: [first, second]
-  properties: {
-    color: color
-  }
-} = obj2
-```
-
-</YueDisplay>
-
-It's common to extract values from at table and assign them the local variables that have the same name as the key. In order to avoid repetition we can use the **:** prefix operator:
-
-```yuescript
-{:concat, :insert} = table
-```
-<YueDisplay>
-
-```yue
-{:concat, :insert} = table
-```
-
-</YueDisplay>
-
-This is effectively the same as import, but we can rename fields we want to extract by mixing the syntax:
-
-```yuescript
-{:mix, :max, random: rand} = math
-```
-<YueDisplay>
-
-```yue
-{:mix, :max, random: rand} = math
-```
-
-</YueDisplay>
-
-You can write default values while doing destructuring like:
-
-```yuescript
-{:name = "nameless", :job = "jobless"} = person
-```
-<YueDisplay>
-
-```yue
-{:name = "nameless", :job = "jobless"} = person
-```
-
-</YueDisplay>
-
-You can use `_` as placeholder when doing a list destructuring:
-
-```yuescript
-[_, two, _, four] = items
-```
-<YueDisplay>
-
-```yue
-[_, two, _, four] = items
-```
-
-</YueDisplay>
-
-### Range Destructuring
-
-You can use the spread operator `...` in list destructuring to capture a range of values. This is useful when you want to extract specific elements from the beginning and end of a list while collecting the rest in between.
-
-```yuescript
-orders = ["first", "second", "third", "fourth", "last"]
-[first, ...bulk, last] = orders
-print first  -- prints: first
-print bulk   -- prints: {"second", "third", "fourth"}
-print last   -- prints: last
-```
-<YueDisplay>
-
-```yue
-orders = ["first", "second", "third", "fourth", "last"]
-[first, ...bulk, last] = orders
-print first  -- prints: first
-print bulk   -- prints: {"second", "third", "fourth"}
-print last   -- prints: last
-```
-
-</YueDisplay>
-
-The spread operator can be used in different positions to capture different ranges, and you can use `_` as a placeholder for the values you don't want to capture:
-
-```yuescript
--- Capture everything after first element
-[first, ...rest] = orders
-
--- Capture everything before last element
-[...start, last] = orders
-
--- Capture things except the middle elements
-[first, ..._, last] = orders
-```
-<YueDisplay>
-
-```yue
--- Capture everything after first element
-[first, ...rest] = orders
-
--- Capture everything before last element
-[...start, last] = orders
-
--- Capture things except the middle elements
-[first, ..._, last] = orders
-```
-
-</YueDisplay>
-
-### Destructuring In Other Places
-
-Destructuring can also show up in places where an assignment implicitly takes place. An example of this is a for loop:
-
-```yuescript
-tuples = [
-  ["hello", "world"]
-  ["egg", "head"]
-]
-
-for [left, right] in *tuples
-  print left, right
-```
-<YueDisplay>
-
-```yue
-tuples = [
-  ["hello", "world"]
-  ["egg", "head"]
-]
-
-for [left, right] in *tuples
-  print left, right
-```
-
-</YueDisplay>
-
-We know each element in the array table is a two item tuple, so we can unpack it directly in the names clause of the for statement using a destructure.
-
-## If Assignment
-
-`if` and `elseif` blocks can take an assignment in place of a conditional expression. Upon evaluating the conditional, the assignment will take place and the value that was assigned to will be used as the conditional expression. The assigned variable is only in scope for the body of the conditional, meaning it is never available if the value is not truthy. And you have to use "the walrus operator" `:=` instead of `=` to do assignment.
-
-```yuescript
-if user := database.find_user "moon"
-  print user.name
-```
-<YueDisplay>
-
-```yue
-if user := database.find_user "moon"
-  print user.name
-```
-
-</YueDisplay>
-
-```yuescript
-if hello := os.getenv "hello"
-  print "You have hello", hello
-elseif world := os.getenv "world"
-  print "you have world", world
-else
-  print "nothing :("
-```
-<YueDisplay>
-
-```yue
-if hello := os.getenv "hello"
-  print "You have hello", hello
-elseif world := os.getenv "world"
-  print "you have world", world
-else
-  print "nothing :("
-```
-
-</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
-if success, result := pcall -> "get result without problems"
-  print result -- variable result is scoped
-print "OK"
-```
-
-</YueDisplay>
-
-### While Assignment
-
-You can also use if assignment in a while loop to get the value as the loop condition.
-```yuescript
-while byte := stream\read_one!
-  -- do something with the byte
-  print byte
-```
-<YueDisplay>
-
-```yue
-while byte := stream\read_one!
-  -- do something with the byte
-  print byte
-```
-
-</YueDisplay>
-
-## Varargs Assignment
-
-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]
-fn = (ok) -> ok, table.unpack list
-ok, ... = fn true
-count = select '#', ...
-first = select 1, ...
-print ok, count, first
-```
-<YueDisplay>
-
-```yue
-list = [1, 2, 3, 4, 5]
-fn = (ok) -> ok, table.unpack list
-ok, ... = fn true
-count = select '#', ...
-first = select 1, ...
-print ok, count, first
-```
-
-</YueDisplay>
-
-## Whitespace
-
-YueScript is a whitespace significant language. You have to write some code block in the same indent with space **' '** or tab **'\t'** like function body, value list and some control blocks. And expressions containing different whitespaces might mean different things. Tab is treated like 4 space, but it's better not mix the use of spaces and tabs.
-
-### Statement Separator
-
-A statement normally ends at a line break. You can also use a semicolon `;` to explicitly terminate a statement, which allows writing multiple statements on the same line:
-
-```yuescript
-a = 1; b = 2; print a + b
-```
-<YueDisplay>
-
-```yue
-a = 1; b = 2; print a + b
-```
-
-</YueDisplay>
-
-### Multiline Chaining
-
-You can write multi-line chaining function calls with a same indent.
-```yuescript
-Rx.Observable
-  .fromRange 1, 8
-  \filter (x) -> x % 2 == 0
-  \concat Rx.Observable.of 'who do we appreciate'
-  \map (value) -> value .. '!'
-  \subscribe print
-```
-<YueDisplay>
-
-```yue
-Rx.Observable
-  .fromRange 1, 8
-  \filter (x) -> x % 2 == 0
-  \concat Rx.Observable.of 'who do we appreciate'
-  \map (value) -> value .. '!'
-  \subscribe print
-```
-
-</YueDisplay>
-
-## Comment
-
-```yuescript
--- I am a comment
-
-str = --[[
-This is a multi-line comment.
-It's OK.
-]] strA \ -- comment 1
-  .. strB \ -- comment 2
-  .. strC
-
-func --[[port]] 3000, --[[ip]] "192.168.1.1"
-```
-<YueDisplay>
-
-```yue
--- I am a comment
-
-str = --[[
-This is a multi-line comment.
-It's OK.
-]] strA \ -- comment 1
-  .. strB \ -- comment 2
-  .. strC
-
-func --[[port]] 3000, --[[ip]] "192.168.1.1"
-```
-
-</YueDisplay>
-
-## Try
-
-The syntax for Lua error handling in a common form.
-
-```yuescript
-try
-  func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try
-  func 1, 2, 3
-catch err
-  yue.traceback err
-
-try func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try func 1, 2, 3
-
-try
-  print "trying"
-  func 1, 2, 3
-
--- working with if assignment pattern
-if success, result := try func 1, 2, 3
-catch err
-    print yue.traceback err
-  print result
-```
-<YueDisplay>
-
-```yue
-try
-  func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try
-  func 1, 2, 3
-catch err
-  yue.traceback err
-
-try func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try func 1, 2, 3
-
-try
-  print "trying"
-  func 1, 2, 3
-
--- working with if assignment pattern
-if success, result := try func 1, 2, 3
-catch err
-    print yue.traceback err
-  print result
-```
-
-</YueDisplay>
-
-### Try?
-
-`try?` is a simplified use for error handling syntax that omit the boolean status from the `try` statement, and it will return the result from the try block when success, return nil instead of error object otherwise.
-
-```yuescript
-a, b, c = try? func!
-
--- with nil coalescing operator
-a = (try? func!) ?? "default"
-
--- as function argument
-f try? func!
-
--- with catch block
-f try?
-  print 123
-  func!
-catch e
-  print e
-  e
-```
-<YueDisplay>
-
-```yue
-a, b, c = try? func!
-
--- with nil coalescing operator
-a = (try? func!) ?? "default"
-
--- as function argument
-f try? func!
-
--- with catch block
-f try?
-  print 123
-  func!
-catch e
-  print e
-  e
-```
-
-</YueDisplay>
-
-## Attributes
-
-Syntax support for Lua 5.4 attributes. And you can still use both the `const` and `close` declaration and get constant check and scoped callback working when targeting Lua versions below 5.4.
-
-```yuescript
-const a = 123
-close _ = <close>: -> print "Out of scope."
-```
-<YueDisplay>
-
-```yue
-const a = 123
-close _ = <close>: -> print "Out of scope."
-```
-
-</YueDisplay>
-
-You can do desctructuring with variables attributed as constant.
-
-```yuescript
-const {:a, :b, c, d} = tb
--- a = 1
-```
-<YueDisplay>
-
-```yue
-const {:a, :b, c, d} = tb
--- a = 1
-```
-
-</YueDisplay>
-
-You can also declare a global variable to be `const`.
-
-```yuescript
-global const Constant = 123
--- Constant = 1
-```
-<YueDisplay>
-
-```yue
-global const Constant = 123
--- Constant = 1
-```
-
-</YueDisplay>
-
-## Literals
-
-All of the primitive literals in Lua can be used. This applies to numbers, strings, booleans, and **nil**.
-
-Unlike Lua, Line breaks are allowed inside of single and double quote strings without an escape sequence:
-
-```yuescript
-some_string = "Here is a string
-  that has a line break in it."
-
--- You can mix expressions into string literals using #{} syntax.
--- String interpolation is only available in double quoted strings.
-print "I am #{math.random! * 100}% sure."
-```
-<YueDisplay>
-
-```yue
-some_string = "Here is a string
-  that has a line break in it."
-
--- You can mix expressions into string literals using #{} syntax.
--- String interpolation is only available in double quoted strings.
-print "I am #{math.random! * 100}% sure."
-```
-
-</YueDisplay>
-
-### Number Literals
-
-You can use underscores in a number literal to increase readability.
-
-```yuescript
-integer = 1_000_000
-hex = 0xEF_BB_BF
-binary = 0B10011
-```
-<YueDisplay>
-
-```yue
-integer = 1_000_000
-hex = 0xEF_BB_BF
-binary = 0B10011
-```
-
-</YueDisplay>
-
-### YAML Multiline String
-
-The `|` prefix introduces a YAML-style multiline string literal:
-
-```yuescript
-str = |
-  key: value
-  list:
-    - item1
-    - #{expr}
-```
-<YueDisplay>
-
-```yue
-str = |
-  key: value
-  list:
-    - item1
-    - #{expr}
-```
-
-</YueDisplay>
-
-This allows writing structured multiline text conveniently. All line breaks and indentation are preserved relative to the first non-empty line, and expressions inside `#{...}` are interpolated automatically as `tostring(expr)`.
-
-YAML Multiline String automatically detects the common leading whitespace prefix (minimum indentation across all non-empty lines) and removes it from all lines. This makes it easy to indent your code visually without affecting the resulting string content.
-
-```yuescript
-fn = ->
-  str = |
-    foo:
-      bar: baz
-  return str
-```
-<YueDisplay>
-
-```yue
-fn = ->
-  str = |
-    foo:
-      bar: baz
-  return str
-```
-
-</YueDisplay>
-
-Internal indentation is preserved relative to the removed common prefix, allowing clean nested structures.
-
-All special characters like quotes (`"`) and backslashes (`\`) in the YAMLMultiline block are automatically escaped so that the generated Lua string is syntactically valid and behaves as expected.
-
-```yuescript
-str = |
-  path: "C:\Program Files\App"
-  note: 'He said: "#{Hello}!"'
-```
-<YueDisplay>
-
-```yue
-str = |
-  path: "C:\Program Files\App"
-  note: 'He said: "#{Hello}!"'
-```
-
-</YueDisplay>
-
-## Function Literals
-
-All functions are created using a function expression. A simple function is denoted using the arrow: **->**.
-
-```yuescript
-my_function = ->
-my_function() -- call the empty function
-```
-<YueDisplay>
-
-```yue
-my_function = ->
-my_function() -- call the empty function
-```
-
-</YueDisplay>
-
-The body of the function can either be one statement placed directly after the arrow, or it can be a series of statements indented on the following lines:
-
-```yuescript
-func_a = -> print "hello world"
-
-func_b = ->
-  value = 100
-  print "The value:", value
-```
-<YueDisplay>
-
-```yue
-func_a = -> print "hello world"
-
-func_b = ->
-  value = 100
-  print "The value:", value
-```
-
-</YueDisplay>
-
-If a function has no arguments, it can be called using the ! operator, instead of empty parentheses. The ! invocation is the preferred way to call functions with no arguments.
-
-```yuescript
-func_a!
-func_b()
-```
-<YueDisplay>
-
-```yue
-func_a!
-func_b()
-```
-
-</YueDisplay>
-
-Functions with arguments can be created by preceding the arrow with a list of argument names in parentheses:
-
-```yuescript
-sum = (x, y) -> print "sum", x + y
-```
-<YueDisplay>
-
-```yue
-sum = (x, y) -> print "sum", x + y
-```
-
-</YueDisplay>
-
-Functions can be called by listing the arguments after the name of an expression that evaluates to a function. When chaining together function calls, the arguments are applied to the closest function to the left.
-
-```yuescript
-sum 10, 20
-print sum 10, 20
-
-a b c "a", "b", "c"
-```
-<YueDisplay>
-
-```yue
-sum 10, 20
-print sum 10, 20
-
-a b c "a", "b", "c"
-```
-
-</YueDisplay>
-
-In order to avoid ambiguity in when calling functions, parentheses can also be used to surround the arguments. This is required here in order to make sure the right arguments get sent to the right functions.
-
-```yuescript
-print "x:", sum(10, 20), "y:", sum(30, 40)
-```
-<YueDisplay>
-
-```yue
-print "x:", sum(10, 20), "y:", sum(30, 40)
-```
-
-</YueDisplay>
-
-There must not be any space between the opening parenthesis and the function.
-
-Functions will coerce the last statement in their body into a return statement, this is called implicit return:
-
-```yuescript
-sum = (x, y) -> x + y
-print "The sum is ", sum 10, 20
-```
-<YueDisplay>
-
-```yue
-sum = (x, y) -> x + y
-print "The sum is ", sum 10, 20
-```
-
-</YueDisplay>
-
-And if you need to explicitly return, you can use the return keyword:
-
-```yuescript
-sum = (x, y) -> return x + y
-```
-<YueDisplay>
-
-```yue
-sum = (x, y) -> return x + y
-```
-
-</YueDisplay>
-
-Just like in Lua, functions can return multiple values. The last statement must be a list of values separated by commas:
-
-```yuescript
-mystery = (x, y) -> x + y, x - y
-a, b = mystery 10, 20
-```
-<YueDisplay>
-
-```yue
-mystery = (x, y) -> x + y, x - y
-a, b = mystery 10, 20
-```
-
-</YueDisplay>
-
-### Fat Arrows
-
-Because it is an idiom in Lua to send an object as the first argument when calling a method, a special syntax is provided for creating functions which automatically includes a self argument.
-
-```yuescript
-func = (num) => @value + num
-```
-<YueDisplay>
-
-```yue
-func = (num) => @value + num
-```
-
-</YueDisplay>
-
-### Argument Defaults
-
-It is possible to provide default values for the arguments of a function. An argument is determined to be empty if its value is nil. Any nil arguments that have a default value will be replace before the body of the function is run.
-
-```yuescript
-my_function = (name = "something", height = 100) ->
-  print "Hello I am", name
-  print "My height is", height
-```
-<YueDisplay>
-
-```yue
-my_function = (name = "something", height = 100) ->
-  print "Hello I am", name
-  print "My height is", height
-```
-
-</YueDisplay>
-
-An argument default value expression is evaluated in the body of the function in the order of the argument declarations. For this reason default values have access to previously declared arguments.
-
-```yuescript
-some_args = (x = 100, y = x + 1000) ->
-  print x + y
-```
-<YueDisplay>
-
-```yue
-some_args = (x = 100, y = x + 1000) ->
-  print x + y
-```
-
-</YueDisplay>
-
-### Considerations
-
-Because of the expressive parentheses-less way of calling functions, some restrictions must be put in place to avoid parsing ambiguity involving whitespace.
-
-The minus sign plays two roles, a unary negation operator and a binary subtraction operator. Consider how the following examples compile:
-
-```yuescript
-a = x - 10
-b = x-10
-c = x -y
-d = x- z
-```
-<YueDisplay>
-
-```yue
-a = x - 10
-b = x-10
-c = x -y
-d = x- z
-```
-
-</YueDisplay>
-
-The precedence of the first argument of a function call can be controlled using whitespace if the argument is a literal string. In Lua, it is common to leave off parentheses when calling a function with a single string or table literal.
-
-When there is no space between a variable and a string literal, the function call takes precedence over any following expressions. No other arguments can be passed to the function when it is called this way.
-
-Where there is a space following a variable and a string literal, the function call acts as show above. The string literal belongs to any following expressions (if they exist), which serves as the argument list.
-
-```yuescript
-x = func"hello" + 100
-y = func "hello" + 100
-```
-<YueDisplay>
-
-```yue
-x = func"hello" + 100
-y = func "hello" + 100
-```
-
-</YueDisplay>
-
-### Multi-line arguments
-
-When calling functions that take a large number of arguments, it is convenient to split the argument list over multiple lines. Because of the white-space sensitive nature of the language, care must be taken when splitting up the argument list.
-
-If an argument list is to be continued onto the next line, the current line must end in a comma. And the following line must be indented more than the current indentation. Once indented, all other argument lines must be at the same level of indentation to be part of the argument list
-
-```yuescript
-my_func 5, 4, 3,
-  8, 9, 10
-
-cool_func 1, 2,
-  3, 4,
-  5, 6,
-  7, 8
-```
-<YueDisplay>
-
-```yue
-my_func 5, 4, 3,
-  8, 9, 10
-
-cool_func 1, 2,
-  3, 4,
-  5, 6,
-  7, 8
-```
-
-</YueDisplay>
-
-This type of invocation can be nested. The level of indentation is used to determine to which function the arguments belong to.
-
-```yuescript
-my_func 5, 6, 7,
-  6, another_func 6, 7, 8,
-    9, 1, 2,
-  5, 4
-```
-<YueDisplay>
-
-```yue
-my_func 5, 6, 7,
-  6, another_func 6, 7, 8,
-    9, 1, 2,
-  5, 4
-```
-
-</YueDisplay>
-
-Because tables also use the comma as a delimiter, this indentation syntax is helpful for letting values be part of the argument list instead of being part of the table.
-
-```yuescript
-x = [
-  1, 2, 3, 4, a_func 4, 5,
-    5, 6,
-  8, 9, 10
-]
-```
-<YueDisplay>
-
-```yue
-x = [
-  1, 2, 3, 4, a_func 4, 5,
-    5, 6,
-  8, 9, 10
-]
-```
-
-</YueDisplay>
-
-Although uncommon, notice how we can give a deeper indentation for function arguments if we know we will be using a lower indentation further on.
-
-```yuescript
-y = [ my_func 1, 2, 3,
-   4, 5,
-  5, 6, 7
-]
-```
-<YueDisplay>
-
-```yue
-y = [ my_func 1, 2, 3,
-   4, 5,
-  5, 6, 7
-]
-```
-
-</YueDisplay>
-
-The same thing can be done with other block level statements like conditionals. We can use indentation level to determine what statement a value belongs to:
-
-```yuescript
-if func 1, 2, 3,
-  "hello",
-  "world"
-    print "hello"
-    print "I am inside if"
-
-if func 1, 2, 3,
-    "hello",
-    "world"
-  print "hello"
-  print "I am inside if"
-```
-<YueDisplay>
-
-```yue
-if func 1, 2, 3,
-  "hello",
-  "world"
-    print "hello"
-    print "I am inside if"
-
-if func 1, 2, 3,
-    "hello",
-    "world"
-  print "hello"
-  print "I am inside if"
-```
-
-</YueDisplay>
-
-### Parameter Destructuring
-
-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}`).
-
-* **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) ->
-  print a, b, c
-
-f1 a: 1, b: "2", c: {}
-
-f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
-  print a1, b, c
-
-arg1 = {a: 0}
-f2 arg1, arg2
-```
-<YueDisplay>
-
-```yue
-f1 = (:a, :b, :c) ->
-  print a, b, c
-
-f1 a: 1, b: "2", c: {}
-
-f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
-print a1, b, c
-
-arg1 = {a: 0}
-f2 arg1, arg2
-```
-
-</YueDisplay>
-
-### Prefixed Return Expression
-
-When working with deeply nested function bodies, it can be tedious to maintain readability and consistency of the return value. To address this, YueScript introduces the **Prefixed Return Expression** syntax. Its form is as follows:
-
-```yuescript
-findFirstEven = (list): nil ->
-  for item in *list
-    if type(item) == "table"
-      for sub in *item
-        if sub % 2 == 0
-          return sub
-```
-<YueDisplay>
-
-```yue
-findFirstEven = (list): nil ->
-  for item in *list
-    if type(item) == "table"
-      for sub in *item
-        if sub % 2 == 0
-          return sub
-```
-
-</YueDisplay>
-
-This is equivalent to:
-
-```yuescript
-findFirstEven = (list) ->
-  for item in *list
-    if type(item) == "table"
-      for sub in *item
-        if sub % 2 == 0
-          return sub
-  nil
-```
-<YueDisplay>
-
-```yue
-findFirstEven = (list) ->
-  for item in *list
-    if type(item) == "table"
-      for sub in *item
-        if sub % 2 == 0
-          return sub
-  nil
-```
-
-</YueDisplay>
-
-The only difference is that you can move the final return expression before the `->` or `=>` token to indicate the function’s implicit return value as the last statement. This way, even in functions with multiple nested loops or conditional branches, you no longer need to write a trailing return expression at the end of the function body, making the logic structure more straightforward and easier to follow.
-
-### Named Varargs
-
-You can use the `(...t) ->` syntax to automatically store varargs into a named table. This table will contain all passed arguments (including `nil` values), and the `n` field of the table will store the actual number of arguments passed (including `nil` values).
-
-```yuescript
-f = (...t) ->
-  print "argument count:", t.n
-  print "table length:", #t
-  for i = 1, t.n
-    print t[i]
-
-f 1, 2, 3
-f "a", "b", "c", "d"
-f!
-
--- Handling cases with nil values
-process = (...args) ->
-  sum = 0
-  for i = 1, args.n
-    if args[i] != nil and type(args[i]) == "number"
-      sum += args[i]
-  sum
-
-process 1, nil, 3, nil, 5
-```
-<YueDisplay>
-
-```yue
-f = (...t) ->
-  print "argument count:", t.n
-  print "table length:", #t
-  for i = 1, t.n
-    print t[i]
-
-f 1, 2, 3
-f "a", "b", "c", "d"
-f!
-
--- Handling cases with nil values
-process = (...args) ->
-  sum = 0
-  for i = 1, args.n
-    if args[i] != nil and type(args[i]) == "number"
-      sum += args[i]
-  sum
-
-process 1, nil, 3, nil, 5
-```
-
-</YueDisplay>
-
-## Backcalls
-
-Backcalls are used for unnesting callbacks. They are defined using arrows pointed to the left as the last parameter by default filling in a function call. All the syntax is mostly the same as regular arrow functions except that it is just pointing the other way and the function body does not require indent.
-
-```yuescript
-<- f
-print "hello"
-```
-<YueDisplay>
-
-```yue
-<- f
-print "hello"
-```
-
-</YueDisplay>
-
-Fat arrow functions are also available.
-
-```yuescript
-<= f
-print @value
-```
-<YueDisplay>
-
-```yue
-<= f
-print @value
-```
-
-</YueDisplay>
-
-You can specify a placeholder for where you want the backcall function to go as a parameter.
-
-```yuescript
-(x) <- map _, [1, 2, 3]
-x * 2
-```
-<YueDisplay>
-
-```yue
-(x) <- map _, [1, 2, 3]
-x * 2
-```
-
-</YueDisplay>
-
-If you wish to have further code after your backcalls, you can set them aside with a do statement. And the parentheses can be omitted with non-fat arrow functions.
-
-```yuescript
-result, msg = do
-  data <- readAsync "filename.txt"
-  print data
-  info <- processAsync data
-  check info
-print result, msg
-```
-<YueDisplay>
-
-```yue
-result, msg = do
-  data <- readAsync "filename.txt"
-  print data
-  info <- processAsync data
-  check info
-print result, msg
-```
-
-</YueDisplay>
-
-## Table Literals
-
-Like in Lua, tables are delimited in curly braces.
-
-```yuescript
-some_values = [1, 2, 3, 4]
-```
-<YueDisplay>
-
-```yue
-some_values = [1, 2, 3, 4]
-```
-
-</YueDisplay>
-
-Unlike Lua, assigning a value to a key in a table is done with **:** (instead of **=**).
-
-```yuescript
-some_values = {
-  name: "Bill",
-  age: 200,
-  ["favorite food"]: "rice"
-}
-```
-<YueDisplay>
-
-```yue
-some_values = {
-  name: "Bill",
-  age: 200,
-  ["favorite food"]: "rice"
-}
-```
-
-</YueDisplay>
-
-The curly braces can be left off if a single table of key value pairs is being assigned.
-
-```yuescript
-profile =
-  height: "4 feet",
-  shoe_size: 13,
-  favorite_foods: ["ice cream", "donuts"]
-```
-<YueDisplay>
-
-```yue
-profile =
-  height: "4 feet",
-  shoe_size: 13,
-  favorite_foods: ["ice cream", "donuts"]
-```
-
-</YueDisplay>
-
-Newlines can be used to delimit values instead of a comma (or both):
-
-```yuescript
-values = {
-  1, 2, 3, 4
-  5, 6, 7, 8
-  name: "superman"
-  occupation: "crime fighting"
-}
-```
-<YueDisplay>
-
-```yue
-values = {
-  1, 2, 3, 4
-  5, 6, 7, 8
-  name: "superman"
-  occupation: "crime fighting"
-}
-```
-
-</YueDisplay>
-
-When creating a single line table literal, the curly braces can also be left off:
-
-```yuescript
-my_function dance: "Tango", partner: "none"
-
-y = type: "dog", legs: 4, tails: 1
-```
-<YueDisplay>
-
-```yue
-my_function dance: "Tango", partner: "none"
-
-y = type: "dog", legs: 4, tails: 1
-```
-
-</YueDisplay>
-
-The keys of a table literal can be language keywords without being escaped:
-
-```yuescript
-tbl = {
-  do: "something"
-  end: "hunger"
-}
-```
-<YueDisplay>
-
-```yue
-tbl = {
-  do: "something"
-  end: "hunger"
-}
-```
-
-</YueDisplay>
-
-If you are constructing a table out of variables and wish the keys to be the same as the variable names, then the **:** prefix operator can be used:
-
-```yuescript
-hair = "golden"
-height = 200
-person = { :hair, :height, shoe_size: 40 }
-
-print_table :hair, :height
-```
-<YueDisplay>
-
-```yue
-hair = "golden"
-height = 200
-person = { :hair, :height, shoe_size: 40 }
-
-print_table :hair, :height
-```
-
-</YueDisplay>
-
-If you want the key of a field in the table to to be result of an expression, then you can wrap it in **[ ]**, just like in Lua. You can also use a string literal directly as a key, leaving out the square brackets. This is useful if your key has any special characters.
-
-```yuescript
-t = {
-  [1 + 2]: "hello"
-  "hello world": true
-}
-```
-<YueDisplay>
-
-```yue
-t = {
-  [1 + 2]: "hello"
-  "hello world": true
-}
-```
-
-</YueDisplay>
-
-Lua tables have both an array part and a hash part, but sometimes you want to make a semantic distinction between array and hash usage when writing Lua tables. Then you can write Lua table with **[ ]** instead of **{ }** to represent an array table and writing any key value pair in a list table won't be allowed.
-
-```yuescript
-some_values = [1, 2, 3, 4]
-list_with_one_element = [1, ]
-```
-<YueDisplay>
-
-```yue
-some_values = [1, 2, 3, 4]
-list_with_one_element = [1, ]
-```
-
-</YueDisplay>
-
-## Comprehensions
-
-Comprehensions provide a convenient syntax for constructing a new table by iterating over some existing object and applying an expression to its values. There are two kinds of comprehensions: list comprehensions and table comprehensions. They both produce Lua tables; list comprehensions accumulate values into an array-like table, and table comprehensions let you set both the key and the value on each iteration.
-
-### List Comprehensions
-
-The following creates a copy of the items table but with all the values doubled.
-
-```yuescript
-items = [ 1, 2, 3, 4 ]
-doubled = [item * 2 for i, item in ipairs items]
-```
-<YueDisplay>
-
-```yue
-items = [ 1, 2, 3, 4 ]
-doubled = [item * 2 for i, item in ipairs items]
-```
-
-</YueDisplay>
-
-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
-slice = [item for i, item in ipairs items when i > 1 and i < 3]
-```
-
-</YueDisplay>
-
-Because it is common to iterate over the values of a numerically indexed table, an **\*** operator is introduced. The doubled example can be rewritten as:
-
-```yuescript
-doubled = [item * 2 for item in *items]
-```
-<YueDisplay>
-
-```yue
-doubled = [item * 2 for item in *items]
-```
-
-</YueDisplay>
-
-In list comprehensions, you can also use the spread operator `...` to flatten nested lists, achieving a flat map effect:
-
-```yuescript
-data =
-  a: [1, 2, 3]
-  b: [4, 5, 6]
-
-flat = [...v for k,v in pairs data]
--- flat is now [1, 2, 3, 4, 5, 6]
-```
-<YueDisplay>
-
-```yue
-data =
-  a: [1, 2, 3]
-  b: [4, 5, 6]
-
-flat = [...v for k,v in pairs data]
--- flat is now [1, 2, 3, 4, 5, 6]
-```
-
-</YueDisplay>
-
-The for and when clauses can be chained as much as desired. The only requirement is that a comprehension has at least one for clause.
-
-Using multiple for clauses is the same as using nested loops:
-
-```yuescript
-x_coords = [4, 5, 6, 7]
-y_coords = [9, 2, 3]
-
-points = [ [x, y] for x in *x_coords \
-for y in *y_coords]
-```
-<YueDisplay>
-
-```yue
-x_coords = [4, 5, 6, 7]
-y_coords = [9, 2, 3]
-
-points = [ [x, y] for x in *x_coords \
-for y in *y_coords]
-```
-
-</YueDisplay>
-
-Numeric for loops can also be used in comprehensions:
-
-```yuescript
-evens = [i for i = 1, 100 when i % 2 == 0]
-```
-<YueDisplay>
-
-```yue
-evens = [i for i = 1, 100 when i % 2 == 0]
-```
-
-</YueDisplay>
-
-### Table Comprehensions
-
-The syntax for table comprehensions is very similar, only differing by using **{** and **}** and taking two values from each iteration.
-
-This example makes a copy of the tablething:
-
-```yuescript
-thing = {
-  color: "red"
-  name: "fast"
-  width: 123
-}
-
-thing_copy = {k, v for k, v in pairs thing}
-```
-<YueDisplay>
-
-```yue
-thing = {
-  color: "red"
-  name: "fast"
-  width: 123
-}
-
-thing_copy = {k, v for k, v in pairs thing}
-```
-
-</YueDisplay>
-
-```yuescript
-no_color = {k, v for k, v in pairs thing when k != "color"}
-```
-<YueDisplay>
-
-```yue
-no_color = {k, v for k, v in pairs thing when k != "color"}
-```
-
-</YueDisplay>
-
-The **\*** operator is also supported. Here we create a square root look up table for a few numbers.
-
-```yuescript
-numbers = [1, 2, 3, 4]
-sqrts = {i, math.sqrt i for i in *numbers}
-```
-<YueDisplay>
-
-```yue
-numbers = [1, 2, 3, 4]
-sqrts = {i, math.sqrt i for i in *numbers}
-```
-
-</YueDisplay>
-
-The key-value tuple in a table comprehension can also come from a single expression, in which case the expression should return two values. The first is used as the key and the second is used as the value:
-
-In this example we convert an array of pairs to a table where the first item in the pair is the key and the second is the value.
-
-```yuescript
-tuples = [ ["hello", "world"], ["foo", "bar"]]
-tbl = {unpack tuple for tuple in *tuples}
-```
-<YueDisplay>
-
-```yue
-tuples = [ ["hello", "world"], ["foo", "bar"]]
-tbl = {unpack tuple for tuple in *tuples}
-```
-
-</YueDisplay>
-
-### Slicing
-
-A special syntax is provided to restrict the items that are iterated over when using the **\*** operator. This is equivalent to setting the iteration bounds and a step size in a for loop.
-
-Here we can set the minimum and maximum bounds, taking all items with indexes between 1 and 5 inclusive:
-
-```yuescript
-slice = [item for item in *items[1, 5]]
-```
-<YueDisplay>
-
-```yue
-slice = [item for item in *items[1, 5]]
-```
-
-</YueDisplay>
-
-Any of the slice arguments can be left off to use a sensible default. In this example, if the max index is left off it defaults to the length of the table. This will take everything but the first element:
-
-```yuescript
-slice = [item for item in *items[2,]]
-```
-<YueDisplay>
-
-```yue
-slice = [item for item in *items[2,]]
-```
-
-</YueDisplay>
-
-If the minimum bound is left out, it defaults to 1. Here we only provide a step size and leave the other bounds blank. This takes all odd indexed items: (1, 3, 5, …)
-
-```yuescript
-slice = [item for item in *items[,,2]]
-```
-<YueDisplay>
-
-```yue
-slice = [item for item in *items[,,2]]
-```
-
-</YueDisplay>
-
-Both the minimum and maximum bounds can be negative, which means that the bounds are counted from the end of the table.
-
-```yuescript
--- take the last 4 items
-slice = [item for item in *items[-4,-1]]
-```
-<YueDisplay>
-
-```yue
--- take the last 4 items
-slice = [item for item in *items[-4,-1]]
-```
-
-</YueDisplay>
-
-The step size can also be negative, which means that the items are taken in reverse order.
-
-```yuescript
-reverse_slice = [item for item in *items[-1,1,-1]]
-```
-<YueDisplay>
-
-```yue
-reverse_slice = [item for item in *items[-1,1,-1]]
-```
-
-</YueDisplay>
-
-#### Slicing Expression
-
-Slicing can also be used as an expression. This is useful for getting a sub-list of a table.
-
-```yuescript
--- take the 2nd and 4th items as a new list
-sub_list = items[2, 4]
-```
-<YueDisplay>
-
-```yue
--- take the 2nd and 4th items as a new list
-sub_list = items[2, 4]
-```
-
-</YueDisplay>
-
-## For Loop
-
-There are two for loop forms, just like in Lua. A numeric one and a generic one:
-
-```yuescript
-for i = 10, 20
-  print i
-
-for k = 1, 15, 2 -- an optional step provided
-  print k
-
-for key, value in pairs object
-  print key, value
-```
-<YueDisplay>
-
-```yue
-for i = 10, 20
-  print i
-
-for k = 1, 15, 2 -- an optional step provided
-  print k
-
-for key, value in pairs object
-  print key, value
-```
-
-</YueDisplay>
-
-The slicing and **\*** operators can be used, just like with comprehensions:
-
-```yuescript
-for item in *items[2, 4]
-  print item
-```
-<YueDisplay>
-
-```yue
-for item in *items[2, 4]
-  print item
-```
-
-</YueDisplay>
-
-A shorter syntax is also available for all variations when the body is only a single line:
-
-```yuescript
-for item in *items do print item
-
-for j = 1, 10, 3 do print j
-```
-<YueDisplay>
-
-```yue
-for item in *items do print item
-
-for j = 1, 10, 3 do print j
-```
-
-</YueDisplay>
-
-A for loop can also be used as an expression. The last statement in the body of the for loop is coerced into an expression and appended to an accumulating array table.
-
-Doubling every even number:
-
-```yuescript
-doubled_evens = for i = 1, 20
-  if i % 2 == 0
-    i * 2
-  else
-    i
-```
-<YueDisplay>
-
-```yue
-doubled_evens = for i = 1, 20
-  if i % 2 == 0
-    i * 2
-  else
-    i
-```
-
-</YueDisplay>
-
-In addition, for loops support break with a return value, allowing the loop itself to be used as an expression that exits early with a meaningful result.
-
-For example, to find the first number greater than 10:
-
-```yuescript
-first_large = for n in *numbers
-  break n if n > 10
-```
-<YueDisplay>
-
-```yue
-first_large = for n in *numbers
-  break n if n > 10
-```
-
-</YueDisplay>
-
-This break-with-value syntax enables concise and expressive search or early-exit patterns directly within loop expressions.
-
-You can also filter values by combining the for loop expression with the continue statement.
-
-For loops at the end of a function body are not accumulated into a table for a return value (Instead the function will return nil). Either an explicit return statement can be used, or the loop can be converted into a list comprehension.
-
-```yuescript
-func_a = -> for i = 1, 10 do print i
-func_b = -> return for i = 1, 10 do i
-
-print func_a! -- prints nil
-print func_b! -- prints table object
-```
-<YueDisplay>
-
-```yue
-func_a = -> for i = 1, 10 do print i
-func_b = -> return for i = 1, 10 do i
-
-print func_a! -- prints nil
-print func_b! -- prints table object
-```
-
-</YueDisplay>
-
-This is done to avoid the needless creation of tables for functions that don't need to return the results of the loop.
-
-## Repeat Loop
-
-The repeat loop comes from Lua:
-
-```yuescript
-i = 10
-repeat
-  print i
-  i -= 1
-until i == 0
-```
-<YueDisplay>
-
-```yue
-i = 10
-repeat
-  print i
-  i -= 1
-until i == 0
-```
-
-</YueDisplay>
-
-## While Loop
-
-The while loop also comes in four variations:
-
-```yuescript
-i = 10
-while i > 0
-  print i
-  i -= 1
-
-while running == true do my_function!
-```
-<YueDisplay>
-
-```yue
-i = 10
-while i > 0
-  print i
-  i -= 1
-
-while running == true do my_function!
-```
-
-</YueDisplay>
-
-```yuescript
-i = 10
-until i == 0
-  print i
-  i -= 1
-
-until running == false do my_function!
-```
-<YueDisplay>
-
-```yue
-i = 10
-until i == 0
-  print i
-  i -= 1
-until running == false do my_function!
-```
-
-</YueDisplay>
-
-Like for loops, the while loop can also be used an expression. Additionally, for a function to return the accumulated value of a while loop, the statement must be explicitly returned.
-
-## Continue
-
-A continue statement can be used to skip the current iteration in a loop.
-
-```yuescript
-i = 0
-while i < 10
-  i += 1
-  continue if i % 2 == 0
-  print i
-```
-<YueDisplay>
-
-```yue
-i = 0
-while i < 10
-  i += 1
-  continue if i % 2 == 0
-  print i
-```
-
-</YueDisplay>
-
-continue can also be used with loop expressions to prevent that iteration from accumulating into the result. This examples filters the array table into just even numbers:
-
-```yuescript
-my_numbers = [1, 2, 3, 4, 5, 6]
-odds = for x in *my_numbers
-  continue if x % 2 == 1
-  x
-```
-<YueDisplay>
-
-```yue
-my_numbers = [1, 2, 3, 4, 5, 6]
-odds = for x in *my_numbers
-  continue if x % 2 == 1
-  x
-```
-
-</YueDisplay>
-
-## Conditionals
-
-```yuescript
-have_coins = false
-if have_coins
-  print "Got coins"
-else
-  print "No coins"
-```
-<YueDisplay>
-
-```yue
-have_coins = false
-if have_coins
-  print "Got coins"
-else
-  print "No coins"
-```
-
-</YueDisplay>
-
-A short syntax for single statements can also be used:
-
-```yuescript
-have_coins = false
-if have_coins then print "Got coins" else print "No coins"
-```
-<YueDisplay>
-
-```yue
-have_coins = false
-if have_coins then print "Got coins" else print "No coins"
-```
-
-</YueDisplay>
-
-Because if statements can be used as expressions, this can also be written as:
-
-```yuescript
-have_coins = false
-print if have_coins then "Got coins" else "No coins"
-```
-<YueDisplay>
-
-```yue
-have_coins = false
-print if have_coins then "Got coins" else "No coins"
-```
-
-</YueDisplay>
-
-Conditionals can also be used in return statements and assignments:
-
-```yuescript
-is_tall = (name) ->
-  if name == "Rob"
-    true
-  else
-    false
-
-message = if is_tall "Rob"
-  "I am very tall"
-else
-  "I am not so tall"
-
-print message -- prints: I am very tall
-```
-<YueDisplay>
-
-```yue
-is_tall = (name) ->
-  if name == "Rob"
-    true
-  else
-    false
-
-message = if is_tall "Rob"
-  "I am very tall"
-else
-  "I am not so tall"
-
-print message -- prints: I am very tall
-```
-
-</YueDisplay>
-
-The opposite of if is unless:
-
-```yuescript
-unless os.date("%A") == "Monday"
-  print "it is not Monday!"
-```
-<YueDisplay>
-
-```yue
-unless os.date("%A") == "Monday"
-  print "it is not Monday!"
-```
-
-</YueDisplay>
-
-```yuescript
-print "You're lucky!" unless math.random! > 0.1
-```
-<YueDisplay>
-
-```yue
-print "You're lucky!" unless math.random! > 0.1
-```
-
-</YueDisplay>
-
-### In Expression
-
-You can write range checking code with an `in-expression`.
-
-```yuescript
-a = 5
-
-if a in [1, 3, 5, 7]
-  print "checking equality with discrete values"
-
-if a in list
-  print "checking if `a` is in a list"
-```
-<YueDisplay>
-
-```yue
-a = 5
-
-if a in [1, 3, 5, 7]
-  print "checking equality with discrete values"
-
-if a in list
-  print "checking if `a` is in a list"
-```
-
-</YueDisplay>
-
-```yuescript
-print "You're lucky!" unless math.random! > 0.1
-```
-<YueDisplay>
-
-```yue
-print "You're lucky!" unless math.random! > 0.1
-```
-
-</YueDisplay>
-
-## Line Decorators
-
-For convenience, the for loop and if statement can be applied to single statements at the end of the line:
-
-```yuescript
-print "hello world" if name == "Rob"
-```
-<YueDisplay>
-
-```yue
-print "hello world" if name == "Rob"
-```
-
-</YueDisplay>
-
-And with basic loops:
-
-```yuescript
-print "item: ", item for item in *items
-```
-<YueDisplay>
-
-```yue
-print "item: ", item for item in *items
-```
-
-</YueDisplay>
-
-And with while loops:
-
-```yuescript
-game\update! while game\isRunning!
-
-reader\parse_line! until reader\eof!
-```
-<YueDisplay>
-
-```yue
-game\update! while game\isRunning!
-
-reader\parse_line! until reader\eof!
-```
-
-</YueDisplay>
-
-## Switch
-
-The switch statement is shorthand for writing a series of if statements that check against the same value. Note that the value is only evaluated once. Like if statements, switches can have an else block to handle no matches. Comparison is done with the == operator. In switch statement, you can also use assignment expression to store temporary variable value.
-
-```yuescript
-switch name := "Dan"
-  when "Robert"
-    print "You are Robert"
-  when "Dan", "Daniel"
-    print "Your name, it's Dan"
-  else
-    print "I don't know about you with name #{name}"
-```
-<YueDisplay>
-
-```yue
-switch name := "Dan"
-  when "Robert"
-    print "You are Robert"
-  when "Dan", "Daniel"
-    print "Your name, it's Dan"
-  else
-    print "I don't know about you with name #{name}"
-```
-
-</YueDisplay>
-
-A switch when clause can match against multiple values by listing them out comma separated.
-
-Switches can be used as expressions as well, here we can assign the result of the switch to a variable:
-
-```yuescript
-b = 1
-next_number = switch b
-  when 1
-    2
-  when 2
-    3
-  else
-    error "can't count that high!"
-```
-<YueDisplay>
-
-```yue
-b = 1
-next_number = switch b
-  when 1
-    2
-  when 2
-    3
-  else
-    error "can't count that high!"
-```
-
-</YueDisplay>
-
-We can use the then keyword to write a switch's when block on a single line. No extra keyword is needed to write the else block on a single line.
-
-```yuescript
-msg = switch math.random(1, 5)
-  when 1 then "you are lucky"
-  when 2 then "you are almost lucky"
-  else "not so lucky"
-```
-<YueDisplay>
-
-```yue
-msg = switch math.random(1, 5)
-  when 1 then "you are lucky"
-  when 2 then "you are almost lucky"
-  else "not so lucky"
-```
-
-</YueDisplay>
-
-If you want to write code with one less indent when writing a switch statement, you can put the first when clause on the statement start line, and then all other clauses can be written with one less indent.
-
-```yuescript
-switch math.random(1, 5)
-  when 1
-    print "you are lucky" -- two indents
-  else
-    print "not so lucky"
-
-switch math.random(1, 5) when 1
-  print "you are lucky" -- one indent
-else
-  print "not so lucky"
-```
-<YueDisplay>
-
-```yue
-switch math.random(1, 5)
-  when 1
-    print "you are lucky" -- two indents
-  else
-    print "not so lucky"
-
-switch math.random(1, 5) when 1
-  print "you are lucky" -- one indent
-else
-  print "not so lucky"
-```
-
-</YueDisplay>
-
-It is worth noting the order of the case comparison expression. The case's expression is on the left hand side. This can be useful if the case's expression wants to overwrite how the comparison is done by defining an eq metamethod.
-
-### Table Matching
-
-You can do table matching in a switch when clause, if the table can be destructured by a specific structure and get non-nil values.
-
-```yuescript
-items =
-  * x: 100
-    y: 200
-  * width: 300
-    height: 400
-
-for item in *items
-  switch item
-    when :x, :y
-      print "Vec2 #{x}, #{y}"
-    when :width, :height
-      print "size #{width}, #{height}"
-```
-<YueDisplay>
-
-```yue
-items =
-  * x: 100
-    y: 200
-  * width: 300
-    height: 400
-
-for item in *items
-  switch item
-    when :x, :y
-      print "Vec2 #{x}, #{y}"
-    when :width, :height
-      print "size #{width}, #{height}"
-```
-
-</YueDisplay>
-
-You can use default values to optionally destructure the table for some fields.
-
-```yuescript
-item = {}
-
-{pos: {:x = 50, :y = 200}} = item -- get error: attempt to index a nil value (field 'pos')
-
-switch item
-  when {pos: {:x = 50, :y = 200}}
-    print "Vec2 #{x}, #{y}" -- table destructuring will still pass
-```
-<YueDisplay>
-
-```yue
-item = {}
-
-{pos: {:x = 50, :y = 200}} = item -- get error: attempt to index a nil value (field 'pos')
-
-switch item
-  when {pos: {:x = 50, :y = 200}}
-    print "Vec2 #{x}, #{y}" -- table destructuring will still pass
-```
-
-</YueDisplay>
-
-You can also match against array elements, table fields, and even nested structures with array or table literals.
-
-Match against array elements.
-
-```yuescript
-switch tb
-  when [1, 2, 3]
-    print "1, 2, 3"
-  when [1, b, 3]
-    print "1, #{b}, 3"
-  when [1, 2, b = 3] -- b has a default value
-    print "1, 2, #{b}"
-```
-<YueDisplay>
-
-```yue
-switch tb
-  when [1, 2, 3]
-    print "1, 2, 3"
-  when [1, b, 3]
-    print "1, #{b}, 3"
-  when [1, 2, b = 3] -- b has a default value
-    print "1, 2, #{b}"
-```
-
-</YueDisplay>
-
-Match against table fields with destructuring.
-
-```yuescript
-switch tb
-  when success: true, :result
-    print "success", result
-  when success: false
-    print "failed", result
-  else
-    print "invalid"
-```
-<YueDisplay>
-
-```yue
-switch tb
-  when success: true, :result
-    print "success", result
-  when success: false
-    print "failed", result
-  else
-    print "invalid"
-```
-
-</YueDisplay>
-
-Match against nested table structures.
-
-```yuescript
-switch tb
-  when data: {type: "success", :content}
-    print "success", content
-  when data: {type: "error", :content}
-    print "failed", content
-  else
-    print "invalid"
-```
-<YueDisplay>
-
-```yue
-switch tb
-  when data: {type: "success", :content}
-    print "success", content
-  when data: {type: "error", :content}
-    print "failed", content
-  else
-    print "invalid"
-```
-
-</YueDisplay>
-
-Match against array of tables.
-
-```yuescript
-switch tb
-  when [
-      {a: 1, b: 2}
-      {a: 3, b: 4}
-      {a: 5, b: 6}
-      fourth
-    ]
-    print "matched", fourth
-```
-<YueDisplay>
-
-```yue
-switch tb
-  when [
-      {a: 1, b: 2}
-      {a: 3, b: 4}
-      {a: 5, b: 6}
-      fourth
-    ]
-    print "matched", fourth
-```
-
-</YueDisplay>
-
-Match against a list and capture a range of elements.
-
-```yuescript
-segments = ["admin", "users", "logs", "view"]
-switch segments
-  when [...groups, resource, action]
-    print "Group:", groups -- prints: {"admin", "users"}
-    print "Resource:", resource -- prints: "logs"
-    print "Action:", action -- prints: "view"
-```
-<YueDisplay>
-
-```yue
-segments = ["admin", "users", "logs", "view"]
-switch segments
-  when [...groups, resource, action]
-    print "Group:", groups -- prints: {"admin", "users"}
-    print "Resource:", resource -- prints: "logs"
-    print "Action:", action -- prints: "view"
-```
-
-</YueDisplay>
-
-## Object Oriented Programming
-
-In these examples, the generated Lua code may appear overwhelming. It is best to focus on the meaning of the YueScript code at first, then look into the Lua code if you wish to know the implementation details.
-
-A simple class:
-
-```yuescript
-class Inventory
-  new: =>
-    @items = {}
-
-  add_item: (name) =>
-    if @items[name]
-      @items[name] += 1
-    else
-      @items[name] = 1
-```
-<YueDisplay>
-
-```yue
-class Inventory
-  new: =>
-    @items = {}
-
-  add_item: (name) =>
-    if @items[name]
-      @items[name] += 1
-    else
-      @items[name] = 1
-```
-
-</YueDisplay>
-
-A class is declared with a class statement followed by a table-like declaration where all of the methods and properties are listed.
-
-The new property is special in that it will become the constructor.
-
-Notice how all the methods in the class use the fat arrow function syntax. When calling methods on a instance, the instance itself is sent in as the first argument. The fat arrow handles the creation of a self argument.
-
-The @ prefix on a variable name is shorthand for self.. @items becomes self.items.
-
-Creating an instance of the class is done by calling the name of the class as a function.
-
-```yuescript
-inv = Inventory!
-inv\add_item "t-shirt"
-inv\add_item "pants"
-```
-<YueDisplay>
-
-```yue
-inv = Inventory!
-inv\add_item "t-shirt"
-inv\add_item "pants"
-```
-
-</YueDisplay>
-
-Because the instance of the class needs to be sent to the methods when they are called, the \ operator is used.
-
-All properties of a class are shared among the instances. This is fine for functions, but for other types of objects, undesired results may occur.
-
-Consider the example below, the clothes property is shared amongst all instances, so modifications to it in one instance will show up in another:
-
-```yuescript
-class Person
-  clothes: []
-  give_item: (name) =>
-    table.insert @clothes, name
-
-a = Person!
-b = Person!
-
-a\give_item "pants"
-b\give_item "shirt"
-
--- will print both pants and shirt
-print item for item in *a.clothes
-```
-<YueDisplay>
-
-```yue
-class Person
-  clothes: []
-  give_item: (name) =>
-    table.insert @clothes, name
-
-a = Person!
-b = Person!
-
-a\give_item "pants"
-b\give_item "shirt"
-
--- will print both pants and shirt
-print item for item in *a.clothes
-```
-
-</YueDisplay>
-
-The proper way to avoid this problem is to create the mutable state of the object in the constructor:
-
-```yuescript
-class Person
-  new: =>
-    @clothes = []
-```
-<YueDisplay>
-
-```yue
-class Person
-  new: =>
-    @clothes = []
-```
-
-</YueDisplay>
-
-### Inheritance
-
-The extends keyword can be used in a class declaration to inherit the properties and methods from another class.
-
-```yuescript
-class BackPack extends Inventory
-  size: 10
-  add_item: (name) =>
-    if #@items > size then error "backpack is full"
-    super name
-```
-<YueDisplay>
-
-```yue
-class BackPack extends Inventory
-  size: 10
-  add_item: (name) =>
-    if #@items > size then error "backpack is full"
-    super name
-```
-
-</YueDisplay>
-
-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.
-
-```yuescript
-class Shelf
-  @__inherited: (child) =>
-    print @__name, "was inherited by", child.__name
-
--- will print: Shelf was inherited by Cupboard
-class Cupboard extends Shelf
-```
-<YueDisplay>
-
-```yue
-class Shelf
-  @__inherited: (child) =>
-    print @__name, "was inherited by", child.__name
-
--- will print: Shelf was inherited by Cupboard
-class Cupboard extends Shelf
-```
-
-</YueDisplay>
-
-### Super
-
-**super** is a special keyword that can be used in two different ways: It can be treated as an object, or it can be called like a function. It only has special functionality when inside a class.
-
-When called as a function, it will call the function of the same name in the parent class. The current self will automatically be passed as the first argument. (As seen in the inheritance example above)
-
-When super is used as a normal value, it is a reference to the parent class object.
-
-It can be accessed like any of object in order to retrieve values in the parent class that might have been shadowed by the child class.
-
-When the \ calling operator is used with super, self is inserted as the first argument instead of the value of super itself. When using . to retrieve a function, the raw function is returned.
-
-A few examples of using super in different ways:
-
-```yuescript
-class MyClass extends ParentClass
-  a_method: =>
-    -- the following have the same effect:
-    super "hello", "world"
-    super\a_method "hello", "world"
-    super.a_method self, "hello", "world"
-
-    -- super as a value is equal to the parent class:
-    assert super == ParentClass
-```
-<YueDisplay>
-
-```yue
-class MyClass extends ParentClass
-  a_method: =>
-    -- the following have the same effect:
-    super "hello", "world"
-    super\a_method "hello", "world"
-    super.a_method self, "hello", "world"
-
-    -- super as a value is equal to the parent class:
-    assert super == ParentClass
-```
-
-</YueDisplay>
-
-**super** can also be used on left side of a Function Stub. The only major difference is that instead of the resulting function being bound to the value of super, it is bound to self.
-
-### 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.
-
-```yuescript
-b = BackPack!
-assert b.__class == BackPack
-
-print BackPack.size -- prints 10
-```
-<YueDisplay>
-
-```yue
-b = BackPack!
-assert b.__class == BackPack
-
-print BackPack.size -- prints 10
-```
-
-</YueDisplay>
-
-### Class Objects
-
-The class object is what we create when we use a class statement. The class object is stored in a variable of the same name of the class.
-
-The class object can be called like a function in order to create new instances. That's how we created instances of classes in the examples above.
-
-A class is made up of two tables. The class table itself, and the base table. The base is used as the metatable for all the instances. All properties listed in the class declaration are placed in the base.
-
-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.
-
-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.
-
-```yuescript
-print BackPack.__name -- prints Backpack
-```
-<YueDisplay>
-
-```yue
-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.
-
-If the class extends from anything, the parent class object is stored in __parent.
-
-### Class Variables
-
-We can create variables directly in the class object instead of in the base by using @ in the front of the property name in a class declaration.
-
-```yuescript
-class Things
-  @some_func: => print "Hello from", @__name
-
-Things\some_func!
-
--- class variables not visible in instances
-assert Things().some_func == nil
-```
-<YueDisplay>
-
-```yue
-class Things
-  @some_func: => print "Hello from", @__name
-
-Things\some_func!
-
--- class variables not visible in instances
-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.
-
-```yuescript
-class Counter
-  @count: 0
-
-  new: =>
-    @@count += 1
-
-Counter!
-Counter!
-
-print Counter.count -- prints 2
-```
-<YueDisplay>
-
-```yue
-class Counter
-  @count: 0
-
-  new: =>
-    @@count += 1
-
-Counter!
-Counter!
-
-print Counter.count -- prints 2
-```
-
-</YueDisplay>
-
-The calling semantics of @@ are similar to @. Calling a @@ name will pass the class in as the first argument using Lua's colon syntax.
-
-```yuescript
-@@hello 1,2,3,4
-```
-<YueDisplay>
-
-```yue
-@@hello 1,2,3,4
-```
-
-</YueDisplay>
-
-### Class Declaration Statements
-
-In the body of a class declaration, we can have normal expressions in addition to key/value pairs. In this context, self is equal to the class object.
-
-Here is an alternative way to create a class variable compared to what's described above:
-
-```yuescript
-class Things
-  @class_var = "hello world"
-```
-<YueDisplay>
-
-```yue
-class Things
-  @class_var = "hello world"
-```
-
-</YueDisplay>
-
-These expressions are executed after all the properties have been added to the base.
-
-All variables declared in the body of the class are local to the classes properties. This is convenient for placing private values or helper functions that only the class methods can access:
-
-```yuescript
-class MoreThings
-  secret = 123
-  log = (msg) -> print "LOG:", msg
-
-  some_method: =>
-    log "hello world: " .. secret
-```
-<YueDisplay>
-
-```yue
-class MoreThings
-  secret = 123
-  log = (msg) -> print "LOG:", msg
-
-  some_method: =>
-    log "hello world: " .. secret
-```
-
-</YueDisplay>
-
-### @ and @@ Values
-
-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.
-
-```yuescript
-assert @ == self
-assert @@ == self.__class
-```
-<YueDisplay>
-
-```yue
-assert @ == self
-assert @@ == self.__class
-```
-
-</YueDisplay>
-
-For example, a quick way to create a new instance of the same class from an instance method using @@:
-
-```yuescript
-some_instance_method = (...) => @@ ...
-```
-<YueDisplay>
-
-```yue
-some_instance_method = (...) => @@ ...
-```
-
-</YueDisplay>
-
-### Constructor Property Promotion
-
-To reduce the boilerplate code for definition of simple value objects. You can write a simple class like:
-
-```yuescript
-class Something
-  new: (@foo, @bar, @@biz, @@baz) =>
-
--- Which is short for
-
-class Something
-  new: (foo, bar, biz, baz) =>
-    @foo = foo
-    @bar = bar
-    @@biz = biz
-    @@baz = baz
-```
-<YueDisplay>
-
-```yue
-class Something
-  new: (@foo, @bar, @@biz, @@baz) =>
-
--- Which is short for
-
-class Something
-  new: (foo, bar, biz, baz) =>
-    @foo = foo
-    @bar = bar
-    @@biz = biz
-    @@baz = baz
-```
-
-</YueDisplay>
-
-You can also use this syntax for a common function to initialize a object's fields.
-
-```yuescript
-new = (@fieldA, @fieldB) => @
-obj = new {}, 123, "abc"
-print obj
-```
-<YueDisplay>
-
-```yue
-new = (@fieldA, @fieldB) => @
-obj = new {}, 123, "abc"
-print obj
-```
-
-</YueDisplay>
-
-### Class Expressions
-
-The class syntax can also be used as an expression which can be assigned to a variable or explicitly returned.
-
-```yuescript
-x = class Bucket
-  drops: 0
-  add_drop: => @drops += 1
-```
-<YueDisplay>
-
-```yue
-x = class Bucket
-  drops: 0
-  add_drop: => @drops += 1
-```
-
-</YueDisplay>
-
-### 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.
-
-```yuescript
-BigBucket = class extends Bucket
-  add_drop: => @drops += 10
-
-assert Bucket.__name == "BigBucket"
-```
-<YueDisplay>
-
-```yue
-BigBucket = class extends Bucket
-  add_drop: => @drops += 10
-
-assert Bucket.__name == "BigBucket"
-```
-
-</YueDisplay>
-
-You can even leave off the body, meaning you can write a blank anonymous class like this:
-
-```yuescript
-x = class
-```
-<YueDisplay>
-
-```yue
-x = class
-```
-
-</YueDisplay>
-
-### Class Mixing
-
-You can do mixing with keyword `using` to copy functions from either a plain table or a predefined class object into your new class. When doing mixing with a plain table, you can override the class indexing function (metamethod `__index`) to your customized implementation. When doing mixing with an existing class object, the class object's metamethods won't be copied.
-
-```yuescript
-MyIndex = __index: var: 1
-
-class X using MyIndex
-  func: =>
-    print 123
-
-x = X!
-print x.var
-
-class Y using X
-
-y = Y!
-y\func!
-
-assert y.__class.__parent ~= X -- X is not parent of Y
-```
-<YueDisplay>
-
-```yue
-MyIndex = __index: var: 1
-
-class X using MyIndex
-  func: =>
-    print 123
-
-x = X!
-print x.var
-
-class Y using X
-
-y = Y!
-y\func!
-
-assert y.__class.__parent ~= X -- X is not parent of Y
-```
-
-</YueDisplay>
-
-## 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.
-
-The with block helps to alleviate this. Within a with block we can use a special statements that begin with either . or \ which represent those operations applied to the object we are using with on.
-
-For example, we work with a newly created object:
-
-```yuescript
-with Person!
-  .name = "Oswald"
-  \add_relative my_dad
-  \save!
-  print .name
-```
-<YueDisplay>
-
-```yue
-with Person!
-  .name = "Oswald"
-  \add_relative my_dad
-  \save!
-  print .name
-```
-
-</YueDisplay>
-
-The with statement can also be used as an expression which returns the value it has been giving access to.
-
-```yuescript
-file = with File "favorite_foods.txt"
-  \set_encoding "utf8"
-```
-<YueDisplay>
-
-```yue
-file = with File "favorite_foods.txt"
-  \set_encoding "utf8"
-```
-
-</YueDisplay>
-
-Or…
-
-```yuescript
-create_person = (name,  relatives) ->
-  with Person!
-    .name = name
-    \add_relative relative for relative in *relatives
-
-me = create_person "Leaf", [dad, mother, sister]
-```
-<YueDisplay>
-
-```yue
-create_person = (name,  relatives) ->
-  with Person!
-    .name = name
-    \add_relative relative for relative in *relatives
-
-me = create_person "Leaf", [dad, mother, sister]
-```
-
-</YueDisplay>
-
-In this usage, with can be seen as a special form of the K combinator.
-
-The expression in the with statement can also be an assignment, if you want to give a name to the expression.
-
-```yuescript
-with str := "Hello"
-  print "original:", str
-  print "upper:", \upper!
-```
-<YueDisplay>
-
-```yue
-with str := "Hello"
-  print "original:", str
-  print "upper:", \upper!
-```
-
-</YueDisplay>
-
-You can access special keys with `[]` in a `with` statement.
-
-```yuescript
-with tb
-  [1] = 1
-  print [2]
-  with [abc]
-    [3] = [2]\func!
-    ["key-name"] = value
-  [] = "abc" -- appending to "tb"
-```
-<YueDisplay>
-
-```yue
-with tb
-  [1] = 1
-  print [2]
-  with [abc]
-    [3] = [2]\func!
-    ["key-name"] = value
-  [] = "abc" -- appending to "tb"
-```
-
-</YueDisplay>
-
-`with?` is an enhanced version of `with` syntax, which introduces an existential check to safely access objects that may be nil without explicit null checks.
-
-```yuescript
-with? obj
-  print obj.name
-```
-<YueDisplay>
-
-```yue
-with? obj
-  print obj.name
-```
-
-</YueDisplay>
-
-## Do
-
-When used as a statement, do works just like it does in Lua.
-
-```yuescript
-do
-  var = "hello"
-  print var
-print var -- nil here
-```
-<YueDisplay>
-
-```yue
-do
-  var = "hello"
-  print var
-print var -- nil here
-```
-
-</YueDisplay>
-
-YueScript's **do** can also be used an expression . Allowing you to combine multiple lines into one. The result of the do expression is the last statement in its body.
-
-```yuescript
-counter = do
-  i = 0
-  ->
-    i += 1
-    i
-
-print counter!
-print counter!
-```
-<YueDisplay>
-
-```yue
-counter = do
-  i = 0
-  ->
-    i += 1
-    i
-
-print counter!
-print counter!
-```
-
-</YueDisplay>
-
-```yuescript
-tbl = {
-  key: do
-    print "assigning key!"
-    1234
-}
-```
-<YueDisplay>
-
-```yue
-tbl = {
-  key: do
-    print "assigning key!"
-    1234
-}
-```
-
-</YueDisplay>
-
-## Function Stubs
-
-It is common to pass a function from an object around as a value, for example, passing an instance method into a function as a callback. If the function expects the object it is operating on as the first argument then you must somehow bundle that object with the function so it can be called properly.
-
-The function stub syntax is a shorthand for creating a new closure function that bundles both the object and function. This new function calls the wrapped function in the correct context of the object.
-
-Its syntax is the same as calling an instance method with the \ operator but with no argument list provided.
-
-```yuescript
-my_object = {
-  value: 1000
-  write: => print "the value:", @value
-}
-
-run_callback = (func) ->
-  print "running callback..."
-  func!
-
--- this will not work:
--- the function has to no reference to my_object
-run_callback my_object.write
-
--- function stub syntax
--- lets us bundle the object into a new function
-run_callback my_object\write
-```
-<YueDisplay>
-
-```yue
-my_object = {
-  value: 1000
-  write: => print "the value:", @value
-}
-
-run_callback = (func) ->
-  print "running callback..."
-  func!
-
--- this will not work:
--- the function has to no reference to my_object
-run_callback my_object.write
-
--- function stub syntax
--- lets us bundle the object into a new function
-run_callback my_object\write
-```
-
-</YueDisplay>
-
-## The Using Clause; Controlling Destructive Assignment
-
-While lexical scoping can be a great help in reducing the complexity of the code we write, things can get unwieldy as the code size increases. Consider the following snippet:
-
-```yuescript
-i = 100
-
--- many lines of code...
-
-my_func = ->
-  i = 10
-  while i > 0
-    print i
-    i -= 1
-
-my_func!
-
-print i -- will print 0
-```
-<YueDisplay>
-
-```yue
-i = 100
-
--- many lines of code...
-
-my_func = ->
-  i = 10
-  while i > 0
-    print i
-    i -= 1
-
-my_func!
-
-print i -- will print 0
-```
-
-</YueDisplay>
-
-In my_func, we've overwritten the value of i mistakenly. In this example it is quite obvious, but consider a large, or foreign code base where it isn't clear what names have already been declared.
-
-It would be helpful to say which variables from the enclosing scope we intend on change, in order to prevent us from changing others by accident.
-
-The using keyword lets us do that. using nil makes sure that no closed variables are overwritten in assignment. The using clause is placed after the argument list in a function, or in place of it if there are no arguments.
-
-```yuescript
-i = 100
-
-my_func = (using nil) ->
-  i = "hello" -- a new local variable is created here
-
-my_func!
-print i -- prints 100, i is unaffected
-```
-<YueDisplay>
-
-```yue
-i = 100
-
-my_func = (using nil) ->
-  i = "hello" -- a new local variable is created here
-
-my_func!
-print i -- prints 100, i is unaffected
-```
-
-</YueDisplay>
-
-Multiple names can be separated by commas. Closure values can still be accessed, they just cant be modified:
-
-```yuescript
-tmp = 1213
-i, k = 100, 50
-
-my_func = (add using k, i) ->
-  tmp = tmp + add -- a new local tmp is created
-  i += tmp
-  k += tmp
-
-my_func(22)
-print i, k -- these have been updated
-```
-<YueDisplay>
-
-```yue
-tmp = 1213
-i, k = 100, 50
-
-my_func = (add using k, i) ->
-  tmp = tmp + add -- a new local tmp is created
-  i += tmp
-  k += tmp
-
-my_func(22)
-print i, k -- these have been updated
-```
-
-</YueDisplay>
-
-## The YueScript Library
-
-Access it by `require("yue")`.
-
-### yue
-
-**Description:**
-
-The YueScript language library.
-
-#### version
-
-**Type:** Field.
-
-**Description:**
-
-The YueScript version.
-
-**Signature:**
-```lua
-version: string
-```
-
-#### dirsep
-
-**Type:** Field.
-
-**Description:**
-
-The file separator for the current platform.
-
-**Signature:**
-```lua
-dirsep: string
-```
-
-#### yue_compiled
-
-**Type:** Field.
-
-**Description:**
-
-The compiled module code cache.
-
-**Signature:**
-```lua
-yue_compiled: {string: string}
-```
-
-#### to_lua
-
-**Type:** Function.
-
-**Description:**
-
-The YueScript compiling function. It compiles the YueScript code to Lua code.
-
-**Signature:**
-```lua
-to_lua: function(code: string, config?: Config):
-    --[[codes]] string | nil,
-    --[[error]] string | nil,
-    --[[globals]] {{string, integer, integer}} | nil
-```
-
-**Parameters:**
-
-| 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. |
-| {{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
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| boolean | Whether the file exists. |
-
-#### read_file
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| string | The file content. |
-
-#### insert_loader
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| boolean | Whether the loader is inserted successfully. It will fail if the loader is already inserted. |
-
-#### remove_loader
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-#### loadstring
-
-**Type:** Function.
-
-**Description:**
-
-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...),
-    --[[error]] string | nil
-```
-
-**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. |
-
-**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. |
-
-#### loadstring
-
-**Type:** Function.
-
-**Description:**
-
-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...),
-    --[[error]] string | nil
-```
-
-**Parameters:**
-
-| 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. |
-
-#### loadstring
-
-**Type:** Function.
-
-**Description:**
-
-Loads YueScript code from a string into a function.
-
-**Signature:**
-```lua
-loadstring: function(input: string, config?: Config):
-    --[[loaded function]] nil | function(...: any): (any...),
-    --[[error]] string | nil
-```
-
-**Parameters:**
-
-| 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. |
-
-#### loadfile
-
-**Type:** Function.
-
-**Description:**
-
-Loads YueScript code from a file into a function.
-
-**Signature:**
-```lua
-loadfile: function(filename: string, env: table, config?: Config):
-    nil | function(...: any): (any...),
-    string | nil
-```
-
-**Parameters:**
-
-| 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. |
-
-#### loadfile
-
-**Type:** Function.
-
-**Description:**
-
-Loads YueScript code from a file into a function.
-
-**Signature:**
-```lua
-loadfile: function(filename: string, config?: Config):
-    nil | function(...: any): (any...),
-    string | nil
-```
-
-**Parameters:**
-
-| 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. |
-
-#### dofile
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| any... | The return values of the loaded function. |
-
-#### dofile
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| any... | The return values of the loaded function. |
-
-#### find_modulepath
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| string | The file path. |
-
-#### pcall
-
-**Type:** Function.
-
-**Description:**
-
-Calls a function in protected mode.
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| boolean, ... | Status code and function results or error object. |
-
-#### require
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-**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. |
-
-#### p
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-#### options
-
-**Type:** Field.
-
-**Description:**
-
-The current compiler options.
-
-**Signature:**
-```lua
-options: Config.Options
-```
-
-#### traceback
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| string | The rewritten traceback message. |
-
-#### is_ast
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| boolean | Whether the code matches the AST. |
-
-#### AST
-
-**Type:** Field.
-
-**Description:**
-
-The AST type definition with name, row, column and sub nodes.
-
-**Signature:**
-```lua
-type AST = {string, integer, integer, any}
-```
-
-#### to_ast
-
-**Type:** Function.
-
-**Description:**
-
-Converts the code to the AST.
-
-**Signature:**
-```lua
-to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
-    --[[AST]] AST | nil,
-    --[[error]] nil | string
-```
-
-**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. |
-
-**Returns:**
-
-| 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
-
-**Type:** Function.
-
-**Description:**
-
-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. |
-| reserveComment | boolean | [Optional] Whether to reserve the original comments. Default is true. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| string | The formatted code. |
-
-#### __call
-
-**Type:** Metamethod.
-
-**Description:**
-
-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. |
-
-**Returns:**
-
-| Return Type | Description |
-| --- | --- |
-| any | The module value. |
-
-### Config
-
-**Description:**
-
-The compiler compile options.
-
-#### lint_global
-
-**Type:** Field.
-
-**Description:**
-
-Whether the compiler should collect the global variables appearing in the code.
-
-**Signature:**
-```lua
-lint_global: boolean
-```
-
-#### implicit_return_root
-
-**Type:** Field.
-
-**Description:**
-
-Whether the compiler should do an implicit return for the root code block.
-
-**Signature:**
-```lua
-implicit_return_root: boolean
-```
-
-#### reserve_line_number
-
-**Type:** Field.
-
-**Description:**
-
-Whether the compiler should reserve the original line number in the compiled code.
-
-**Signature:**
-```lua
-reserve_line_number: boolean
-```
-
-#### reserve_comment
-
-**Type:** Field.
-
-**Description:**
-
-Whether the compiler should reserve the original comments in the compiled code.
-
-**Signature:**
-```lua
-reserve_comment: boolean
-```
-
-#### space_over_tab
-
-**Type:** Field.
-
-**Description:**
-
-Whether the compiler should use the space character instead of the tab character in the compiled code.
-
-**Signature:**
-```lua
-space_over_tab: boolean
-```
-
-#### same_module
-
-**Type:** Field.
-
-**Description:**
-
-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
-```
-
-#### line_offset
-
-**Type:** Field.
-
-**Description:**
-
-Whether the compiler error message should include the line number offset. For internal use only.
-
-**Signature:**
-```lua
-line_offset: integer
-```
-
-#### yue.Config.LuaTarget
-
-**Type:** Enumeration.
-
-**Description:**
-
-The target Lua version enumeration.
-
-**Signature:**
-```lua
-enum LuaTarget
-  "5.1"
-  "5.2"
-  "5.3"
-  "5.4"
-  "5.5"
-end
-```
-
-#### options
-
-**Type:** Field.
-
-**Description:**
-
-The extra options to be passed to the compilation function.
-
-**Signature:**
-```lua
-options: Options
-```
-
-### Options
-
-**Description:**
-
-The extra compiler options definition.
-
-#### target
-
-**Type:** Field.
-
-**Description:**
-
-The target Lua version for the compilation.
-
-**Signature:**
-```lua
-target: LuaTarget
-```
-
-#### path
-
-**Type:** Field.
-
-**Description:**
-
-The extra module search path.
-
-**Signature:**
-```lua
-path: string
-```
-
-#### dump_locals
-
-**Type:** Field.
-
-**Description:**
-
-Whether to dump the local variables in the traceback error message. Default is false.
-
-**Signature:**
-```lua
-dump_locals: boolean
-```
-
-#### simplified
-
-**Type:** Field.
-
-**Description:**
-
-Whether to simplify the error message. Default is true.
-
-**Signature:**
-```lua
-simplified: boolean
-```
-
-## Licence: MIT
-
-Copyright (c) 2017-2026 Li Jin \<dragon-fly@qq.com\>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-<CompilerModal />
+Welcome to the <b>YueScript</b> official documentation!<br/>
+Here you can find the language features, usage, reference examples and resources.<br/>
+Please select a chapter from the sidebar to start learning about YueScript.
diff --git a/doc/docs/doc/installation.md b/doc/docs/doc/installation.md
new file mode 100644
index 0000000..a93ddfd
--- /dev/null
+++ b/doc/docs/doc/installation.md
@@ -0,0 +1,43 @@
+# Installation
+
+## Lua Module
+
+Install [luarocks](https://luarocks.org), a package manager for Lua modules. Then install it as a Lua module and executable with:
+
+```shell
+luarocks install yuescript
+```
+
+Or you can build `yue.so` file with:
+
+```shell
+make shared LUAI=/usr/local/include/lua LUAL=/usr/local/lib/lua
+```
+
+Then get the binary file from path **bin/shared/yue.so**.
+
+## Build Binary Tool
+
+Clone this repo, then build and install executable with:
+
+```shell
+make install
+```
+
+Build YueScript tool without macro feature:
+
+```shell
+make install NO_MACRO=true
+```
+
+Build YueScript tool without built-in Lua binary:
+
+```shell
+make install NO_LUA=true
+```
+
+## Download Precompiled Binary
+
+You can download precompiled binary files, including binary executable files compatible with different Lua versions and library files.
+
+Download precompiled binary files from [here](https://github.com/IppClub/YueScript/releases).
diff --git a/doc/docs/doc/introduction.md b/doc/docs/doc/introduction.md
new file mode 100644
index 0000000..a9a9389
--- /dev/null
+++ b/doc/docs/doc/introduction.md
@@ -0,0 +1,105 @@
+# Introduction
+
+YueScript is a dynamic language that compiles to Lua. And it's a [MoonScript](https://github.com/leafo/moonscript) dialect. The codes written in YueScript are expressive and extremely concise. And it is suitable for writing some changing application logic with more maintainable codes and runs in a Lua embeded environment such as games or website servers.
+
+Yue (月) is the name of moon in Chinese and it's pronounced as [jyɛ].
+
+## An Overview of YueScript
+
+```yuescript
+-- import syntax
+import p, to_lua from "yue"
+
+-- object literals
+inventory =
+  equipment:
+    - "sword"
+    - "shield"
+  items:
+    - name: "potion"
+      count: 10
+    - name: "bread"
+      count: 3
+
+-- list comprehension
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
+-- pipe operator
+[1, 2, 3]
+  |> map (x) -> x * 2
+  |> filter (x) -> x > 4
+  |> reduce 0, (a, b) -> a + b
+  |> print
+
+-- metatable manipulation
+apple =
+  size: 15
+  <index>:
+    color: 0x00ffff
+
+with apple
+  p .size, .color, .<index> if .<>?
+
+-- js-like export syntax
+export 🌛 = "月之脚本"
+```
+
+<YueDisplay>
+
+```yue
+-- import syntax
+import p, to_lua from "yue"
+
+-- object literals
+inventory =
+  equipment:
+    - "sword"
+    - "shield"
+  items:
+    - name: "potion"
+      count: 10
+    - name: "bread"
+      count: 3
+
+-- list comprehension
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
+-- pipe operator
+[1, 2, 3]
+  |> map (x) -> x * 2
+  |> filter (x) -> x > 4
+  |> reduce 0, (a, b) -> a + b
+  |> print
+
+-- metatable manipulation
+apple =
+  size: 15
+  <index>:
+    color: 0x00ffff
+
+with apple
+  p .size, .color, .<index> if .<>?
+
+-- js-like export syntax
+export 🌛 = "月之脚本"
+```
+
+</YueDisplay>
+
+## 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
diff --git a/doc/docs/doc/licence-mit.md b/doc/docs/doc/licence-mit.md
new file mode 100644
index 0000000..253298f
--- /dev/null
+++ b/doc/docs/doc/licence-mit.md
@@ -0,0 +1,23 @@
+# Licence: MIT
+
+Copyright (c) 2017-2026 Li Jin \<dragon-fly@qq.com\>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+<CompilerModal />
diff --git a/doc/docs/doc/line-decorators.md b/doc/docs/doc/line-decorators.md
new file mode 100644
index 0000000..292bc77
--- /dev/null
+++ b/doc/docs/doc/line-decorators.md
@@ -0,0 +1,44 @@
+# Line Decorators
+
+For convenience, the for loop and if statement can be applied to single statements at the end of the line:
+
+```yuescript
+print "hello world" if name == "Rob"
+```
+<YueDisplay>
+
+```yue
+print "hello world" if name == "Rob"
+```
+
+</YueDisplay>
+
+And with basic loops:
+
+```yuescript
+print "item: ", item for item in *items
+```
+<YueDisplay>
+
+```yue
+print "item: ", item for item in *items
+```
+
+</YueDisplay>
+
+And with while loops:
+
+```yuescript
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+<YueDisplay>
+
+```yue
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/literals.md b/doc/docs/doc/literals.md
new file mode 100644
index 0000000..e097c62
--- /dev/null
+++ b/doc/docs/doc/literals.md
@@ -0,0 +1,110 @@
+# Literals
+
+All of the primitive literals in Lua can be used. This applies to numbers, strings, booleans, and **nil**.
+
+Unlike Lua, Line breaks are allowed inside of single and double quote strings without an escape sequence:
+
+```yuescript
+some_string = "Here is a string
+  that has a line break in it."
+
+-- You can mix expressions into string literals using #{} syntax.
+-- String interpolation is only available in double quoted strings.
+print "I am #{math.random! * 100}% sure."
+```
+<YueDisplay>
+
+```yue
+some_string = "Here is a string
+  that has a line break in it."
+
+-- You can mix expressions into string literals using #{} syntax.
+-- String interpolation is only available in double quoted strings.
+print "I am #{math.random! * 100}% sure."
+```
+
+</YueDisplay>
+
+## Number Literals
+
+You can use underscores in a number literal to increase readability.
+
+```yuescript
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+<YueDisplay>
+
+```yue
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+
+</YueDisplay>
+
+## YAML Multiline String
+
+The `|` prefix introduces a YAML-style multiline string literal:
+
+```yuescript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+<YueDisplay>
+
+```yue
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+</YueDisplay>
+
+This allows writing structured multiline text conveniently. All line breaks and indentation are preserved relative to the first non-empty line, and expressions inside `#{...}` are interpolated automatically as `tostring(expr)`.
+
+YAML Multiline String automatically detects the common leading whitespace prefix (minimum indentation across all non-empty lines) and removes it from all lines. This makes it easy to indent your code visually without affecting the resulting string content.
+
+```yuescript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+<YueDisplay>
+
+```yue
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+</YueDisplay>
+
+Internal indentation is preserved relative to the removed common prefix, allowing clean nested structures.
+
+All special characters like quotes (`"`) and backslashes (`\`) in the YAMLMultiline block are automatically escaped so that the generated Lua string is syntactically valid and behaves as expected.
+
+```yuescript
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+<YueDisplay>
+
+```yue
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/macro.md b/doc/docs/doc/macro.md
new file mode 100644
index 0000000..917c20e
--- /dev/null
+++ b/doc/docs/doc/macro.md
@@ -0,0 +1,274 @@
+# Macro
+
+## Common Usage
+
+Macro function is used for evaluating a string in the compile time and insert the generated codes into final compilation.
+
+```yuescript
+macro PI2 = -> math.pi * 2
+area = $PI2 * 5
+
+macro HELLO = -> "'hello world'"
+print $HELLO
+
+macro config = (debugging) ->
+  global debugMode = debugging == "true"
+  ""
+
+macro asserts = (cond) ->
+  debugMode and "assert #{cond}" or ""
+
+macro assert = (cond) ->
+  debugMode and "assert #{cond}" or "#{cond}"
+
+$config true
+$asserts item ~= nil
+
+$config false
+value = $assert item
+
+-- the passed expressions are treated as strings
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+<YueDisplay>
+
+```yue
+macro PI2 = -> math.pi * 2
+area = $PI2 * 5
+
+macro HELLO = -> "'hello world'"
+print $HELLO
+
+macro config = (debugging) ->
+  global debugMode = debugging == "true"
+  ""
+
+macro asserts = (cond) ->
+  debugMode and "assert #{cond}" or ""
+
+macro assert = (cond) ->
+  debugMode and "assert #{cond}" or "#{cond}"
+
+$config true
+$asserts item ~= nil
+
+$config false
+value = $assert item
+
+-- the passed expressions are treated as strings
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+
+</YueDisplay>
+
+## 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
+funcA = -> "fail to assign to the Yue macro defined variable"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "fail to assign to the Lua macro defined variable"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- the raw string leading and ending symbols are auto trimed
+$lua[==[
+-- raw Lua codes insertion
+if cond then
+  print("output")
+end
+]==]
+```
+<YueDisplay>
+
+```yue
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+funcA = -> "fail to assign to the Yue macro defined variable"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "fail to assign to the Lua macro defined variable"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- the raw string leading and ending symbols are auto trimed
+$lua[==[
+-- raw Lua codes insertion
+if cond then
+  print("output")
+end
+]==]
+```
+
+</YueDisplay>
+
+## 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}]"
+export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
+export macro foreach = (items, action) -> "for _ in *#{items}
+  #{action}"
+
+-- file main.yue
+import "utils" as {
+  $, -- symbol to import all macros
+  $foreach: $each -- rename macro $foreach to $each
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+```
+<YueDisplay>
+
+```yue
+-- file: utils.yue
+export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
+export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
+export macro foreach = (items, action) -> "for _ in *#{items}
+  #{action}"
+-- file main.yue
+-- import function is not available in browser, try it in a real environment
+--[[
+import "utils" as {
+  $, -- symbol to import all macros
+  $foreach: $each -- rename macro $foreach to $each
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+]]
+```
+
+</YueDisplay>
+
+## 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
+print $FILE -- get string of current module name
+print $LINE -- get number 2
+```
+
+</YueDisplay>
+
+## Generating Macros with Macros
+
+In YueScript, macro functions allow you to generate code at compile time. By nesting macro functions, you can create more complex generation patterns. This feature enables you to define a macro function that generates another macro function, allowing for more dynamic code generation.
+
+```yuescript
+macro Enum = (...) ->
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
+
+macro BodyType = $Enum(
+  Static
+  Dynamic
+  Kinematic
+)
+
+print "Valid enum type:", $BodyType Static
+-- print "Compilation error with enum type:", $BodyType Unknown
+```
+
+<YueDisplay>
+
+```yue
+macro Enum = (...) ->
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
+
+macro BodyType = $Enum(
+  Static
+  Dynamic
+  Kinematic
+)
+
+print "Valid enum type:", $BodyType Static
+-- print "Compilation error with enum type:", $BodyType Unknown
+```
+
+</YueDisplay>
+
+## Argument Validation
+
+You can declare the expected AST node types in the argument list, and check whether the incoming macro arguments meet the expectations at compile time.
+
+```yuescript
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hello"
+```
+<YueDisplay>
+
+```yue
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hello"
+```
+
+</YueDisplay>
+
+If you need more flexible argument checking, you can use the built-in `$is_ast` macro function to manually check at the appropriate place.
+
+```yuescript
+macro printNumAndStr = (num, str) ->
+  error "expected Num as first argument" unless $is_ast Num, num
+  error "expected String as second argument" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hello"
+```
+<YueDisplay>
+
+```yue
+macro printNumAndStr = (num, str) ->
+  error "expected Num as first argument" unless $is_ast Num, num
+  error "expected String as second argument" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hello"
+```
+
+</YueDisplay>
+
+For more details about available AST nodes, please refer to the uppercased definitions in [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp).
diff --git a/doc/docs/doc/module.md b/doc/docs/doc/module.md
new file mode 100644
index 0000000..c955092
--- /dev/null
+++ b/doc/docs/doc/module.md
@@ -0,0 +1,245 @@
+# Module
+
+## Import
+
+The import statement is a syntax sugar for requiring a module or help extracting items from an imported module. The imported items are const by default.
+
+```yuescript
+-- used as table destructuring
+do
+  import insert, concat from table
+  -- report error when assigning to insert, concat
+  import C, Ct, Cmt from require "lpeg"
+  -- shortcut for implicit requiring
+  import x, y, z from 'mymodule'
+  -- import with Python style
+  from 'module' import a, b, c
+
+-- shortcut for requring a module
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- requring module with aliasing or table destructuring
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+<YueDisplay>
+
+```yue
+-- used as table destructuring
+do
+  import insert, concat from table
+  -- report error when assigning to insert, concat
+  import C, Ct, Cmt from require "lpeg"
+  -- shortcut for implicit requiring
+  import x, y, z from 'mymodule'
+  -- import with Python style
+  from 'module' import a, b, c
+
+-- shortcut for requring a module
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- requring module with aliasing or table destructuring
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+</YueDisplay>
+
+## Import Global
+
+You can import specific globals into local variables with `import`. When importing a chain of global variable accessings, the last field will be assigned to the local variable.
+
+```yuescript
+do
+  import tostring
+  import table.concat
+  print concat ["a", tostring 1]
+```
+<YueDisplay>
+
+```yue
+do
+  import tostring
+  import table.concat
+  print concat ["a", tostring 1]
+```
+
+</YueDisplay>
+
+### Automatic Global Variable Import
+
+You can place `import global` at the top of a block to automatically import all names that have not been explicitly declared or assigned in the current scope as globals. These implicit imports are treated as local consts that reference the corresponding globals at the position of the statement.
+
+Names that are explicitly declared as globals in the same scope will not be imported, so you can still assign to them.
+
+```yuescript
+do
+  import global
+  print "hello"
+  math.random 3
+  -- print = nil -- error: imported globals are const
+
+do
+  -- explicit global variable will not be imported
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+<YueDisplay>
+
+```yue
+do
+  import global
+  print "hello"
+  math.random 3
+  -- print = nil -- error: imported globals are const
+
+do
+  -- explicit global variable will not be imported
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+
+</YueDisplay>
+
+## Export
+
+The export statement offers a concise way to define modules.
+
+### Named Export
+
+Named export will define a local variable as well as adding a field in the exported table.
+
+```yuescript
+export a, b, c = 1, 2, 3
+export cool = "cat"
+
+export What = if this
+  "abc"
+else
+  "def"
+
+export y = ->
+  hallo = 3434
+
+export class Something
+  umm: "cool"
+```
+<YueDisplay>
+
+```yue
+export a, b, c = 1, 2, 3
+export cool = "cat"
+
+export What = if this
+  "abc"
+else
+  "def"
+
+export y = ->
+  hallo = 3434
+
+export class Something
+  umm: "cool"
+```
+
+</YueDisplay>
+
+Doing named export with destructuring.
+
+```yuescript
+export :loadstring, to_lua: tolua = yue
+export {itemA: {:fieldA = 'default'}} = tb
+```
+<YueDisplay>
+
+```yue
+export :loadstring, to_lua: tolua = yue
+export {itemA: {:fieldA = 'default'}} = tb
+```
+
+</YueDisplay>
+
+Export named items from module without creating local variables.
+
+```yuescript
+export.itemA = tb
+export.<index> = items
+export["a-b-c"] = 123
+```
+<YueDisplay>
+
+```yue
+export.itemA = tb
+export.<index> = items
+export["a-b-c"] = 123
+```
+
+</YueDisplay>
+
+### Unnamed Export
+
+Unnamed export will add the target item into the array part of the exported table.
+
+```yuescript
+d, e, f = 3, 2, 1
+export d, e, f
+
+export if this
+  123
+else
+  456
+
+export with tmp
+  j = 2000
+```
+<YueDisplay>
+
+```yue
+d, e, f = 3, 2, 1
+export d, e, f
+
+export if this
+  123
+else
+  456
+
+export with tmp
+  j = 2000
+```
+
+</YueDisplay>
+
+### Default Export
+
+Using the **default** keyword in export statement to replace the exported table with any thing.
+
+```yuescript
+export default ->
+  print "hello"
+  123
+```
+<YueDisplay>
+
+```yue
+export default ->
+  print "hello"
+  123
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/object-oriented-programming.md b/doc/docs/doc/object-oriented-programming.md
new file mode 100644
index 0000000..6a8559e
--- /dev/null
+++ b/doc/docs/doc/object-oriented-programming.md
@@ -0,0 +1,555 @@
+# Object Oriented Programming
+
+In these examples, the generated Lua code may appear overwhelming. It is best to focus on the meaning of the YueScript code at first, then look into the Lua code if you wish to know the implementation details.
+
+A simple class:
+
+```yuescript
+class Inventory
+  new: =>
+    @items = {}
+
+  add_item: (name) =>
+    if @items[name]
+      @items[name] += 1
+    else
+      @items[name] = 1
+```
+<YueDisplay>
+
+```yue
+class Inventory
+  new: =>
+    @items = {}
+
+  add_item: (name) =>
+    if @items[name]
+      @items[name] += 1
+    else
+      @items[name] = 1
+```
+
+</YueDisplay>
+
+A class is declared with a class statement followed by a table-like declaration where all of the methods and properties are listed.
+
+The new property is special in that it will become the constructor.
+
+Notice how all the methods in the class use the fat arrow function syntax. When calling methods on a instance, the instance itself is sent in as the first argument. The fat arrow handles the creation of a self argument.
+
+The @ prefix on a variable name is shorthand for self.. @items becomes self.items.
+
+Creating an instance of the class is done by calling the name of the class as a function.
+
+```yuescript
+inv = Inventory!
+inv\add_item "t-shirt"
+inv\add_item "pants"
+```
+<YueDisplay>
+
+```yue
+inv = Inventory!
+inv\add_item "t-shirt"
+inv\add_item "pants"
+```
+
+</YueDisplay>
+
+Because the instance of the class needs to be sent to the methods when they are called, the \ operator is used.
+
+All properties of a class are shared among the instances. This is fine for functions, but for other types of objects, undesired results may occur.
+
+Consider the example below, the clothes property is shared amongst all instances, so modifications to it in one instance will show up in another:
+
+```yuescript
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- will print both pants and shirt
+print item for item in *a.clothes
+```
+<YueDisplay>
+
+```yue
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- will print both pants and shirt
+print item for item in *a.clothes
+```
+
+</YueDisplay>
+
+The proper way to avoid this problem is to create the mutable state of the object in the constructor:
+
+```yuescript
+class Person
+  new: =>
+    @clothes = []
+```
+<YueDisplay>
+
+```yue
+class Person
+  new: =>
+    @clothes = []
+```
+
+</YueDisplay>
+
+## Inheritance
+
+The extends keyword can be used in a class declaration to inherit the properties and methods from another class.
+
+```yuescript
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "backpack is full"
+    super name
+```
+<YueDisplay>
+
+```yue
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "backpack is full"
+    super name
+```
+
+</YueDisplay>
+
+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.
+
+```yuescript
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "was inherited by", child.__name
+
+-- will print: Shelf was inherited by Cupboard
+class Cupboard extends Shelf
+```
+<YueDisplay>
+
+```yue
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "was inherited by", child.__name
+
+-- will print: Shelf was inherited by Cupboard
+class Cupboard extends Shelf
+```
+
+</YueDisplay>
+
+## Super
+
+**super** is a special keyword that can be used in two different ways: It can be treated as an object, or it can be called like a function. It only has special functionality when inside a class.
+
+When called as a function, it will call the function of the same name in the parent class. The current self will automatically be passed as the first argument. (As seen in the inheritance example above)
+
+When super is used as a normal value, it is a reference to the parent class object.
+
+It can be accessed like any of object in order to retrieve values in the parent class that might have been shadowed by the child class.
+
+When the \ calling operator is used with super, self is inserted as the first argument instead of the value of super itself. When using . to retrieve a function, the raw function is returned.
+
+A few examples of using super in different ways:
+
+```yuescript
+class MyClass extends ParentClass
+  a_method: =>
+    -- the following have the same effect:
+    super "hello", "world"
+    super\a_method "hello", "world"
+    super.a_method self, "hello", "world"
+
+    -- super as a value is equal to the parent class:
+    assert super == ParentClass
+```
+<YueDisplay>
+
+```yue
+class MyClass extends ParentClass
+  a_method: =>
+    -- the following have the same effect:
+    super "hello", "world"
+    super\a_method "hello", "world"
+    super.a_method self, "hello", "world"
+
+    -- super as a value is equal to the parent class:
+    assert super == ParentClass
+```
+
+</YueDisplay>
+
+**super** can also be used on left side of a Function Stub. The only major difference is that instead of the resulting function being bound to the value of super, it is bound to self.
+
+## 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.
+
+```yuescript
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- prints 10
+```
+<YueDisplay>
+
+```yue
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- prints 10
+```
+
+</YueDisplay>
+
+## Class Objects
+
+The class object is what we create when we use a class statement. The class object is stored in a variable of the same name of the class.
+
+The class object can be called like a function in order to create new instances. That's how we created instances of classes in the examples above.
+
+A class is made up of two tables. The class table itself, and the base table. The base is used as the metatable for all the instances. All properties listed in the class declaration are placed in the base.
+
+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.
+
+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.
+
+```yuescript
+print BackPack.__name -- prints Backpack
+```
+<YueDisplay>
+
+```yue
+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.
+
+If the class extends from anything, the parent class object is stored in __parent.
+
+## Class Variables
+
+We can create variables directly in the class object instead of in the base by using @ in the front of the property name in a class declaration.
+
+```yuescript
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- class variables not visible in instances
+assert Things().some_func == nil
+```
+<YueDisplay>
+
+```yue
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- class variables not visible in instances
+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.
+
+```yuescript
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- prints 2
+```
+<YueDisplay>
+
+```yue
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- prints 2
+```
+
+</YueDisplay>
+
+The calling semantics of @@ are similar to @. Calling a @@ name will pass the class in as the first argument using Lua's colon syntax.
+
+```yuescript
+@@hello 1,2,3,4
+```
+<YueDisplay>
+
+```yue
+@@hello 1,2,3,4
+```
+
+</YueDisplay>
+
+## Class Declaration Statements
+
+In the body of a class declaration, we can have normal expressions in addition to key/value pairs. In this context, self is equal to the class object.
+
+Here is an alternative way to create a class variable compared to what's described above:
+
+```yuescript
+class Things
+  @class_var = "hello world"
+```
+<YueDisplay>
+
+```yue
+class Things
+  @class_var = "hello world"
+```
+
+</YueDisplay>
+
+These expressions are executed after all the properties have been added to the base.
+
+All variables declared in the body of the class are local to the classes properties. This is convenient for placing private values or helper functions that only the class methods can access:
+
+```yuescript
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "hello world: " .. secret
+```
+<YueDisplay>
+
+```yue
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "hello world: " .. secret
+```
+
+</YueDisplay>
+
+## @ and @@ Values
+
+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.
+
+```yuescript
+assert @ == self
+assert @@ == self.__class
+```
+<YueDisplay>
+
+```yue
+assert @ == self
+assert @@ == self.__class
+```
+
+</YueDisplay>
+
+For example, a quick way to create a new instance of the same class from an instance method using @@:
+
+```yuescript
+some_instance_method = (...) => @@ ...
+```
+<YueDisplay>
+
+```yue
+some_instance_method = (...) => @@ ...
+```
+
+</YueDisplay>
+
+## Constructor Property Promotion
+
+To reduce the boilerplate code for definition of simple value objects. You can write a simple class like:
+
+```yuescript
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- Which is short for
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+<YueDisplay>
+
+```yue
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- Which is short for
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+</YueDisplay>
+
+You can also use this syntax for a common function to initialize a object's fields.
+
+```yuescript
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+<YueDisplay>
+
+```yue
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+</YueDisplay>
+
+## Class Expressions
+
+The class syntax can also be used as an expression which can be assigned to a variable or explicitly returned.
+
+```yuescript
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+<YueDisplay>
+
+```yue
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+</YueDisplay>
+
+## 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.
+
+```yuescript
+BigBucket = class extends Bucket
+  add_drop: => @drops += 10
+
+assert Bucket.__name == "BigBucket"
+```
+<YueDisplay>
+
+```yue
+BigBucket = class extends Bucket
+  add_drop: => @drops += 10
+
+assert Bucket.__name == "BigBucket"
+```
+
+</YueDisplay>
+
+You can even leave off the body, meaning you can write a blank anonymous class like this:
+
+```yuescript
+x = class
+```
+<YueDisplay>
+
+```yue
+x = class
+```
+
+</YueDisplay>
+
+## Class Mixing
+
+You can do mixing with keyword `using` to copy functions from either a plain table or a predefined class object into your new class. When doing mixing with a plain table, you can override the class indexing function (metamethod `__index`) to your customized implementation. When doing mixing with an existing class object, the class object's metamethods won't be copied.
+
+```yuescript
+MyIndex = __index: var: 1
+
+class X using MyIndex
+  func: =>
+    print 123
+
+x = X!
+print x.var
+
+class Y using X
+
+y = Y!
+y\func!
+
+assert y.__class.__parent ~= X -- X is not parent of Y
+```
+<YueDisplay>
+
+```yue
+MyIndex = __index: var: 1
+
+class X using MyIndex
+  func: =>
+    print 123
+
+x = X!
+print x.var
+
+class Y using X
+
+y = Y!
+y\func!
+
+assert y.__class.__parent ~= X -- X is not parent of Y
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/operator.md b/doc/docs/doc/operator.md
new file mode 100644
index 0000000..9a2e89b
--- /dev/null
+++ b/doc/docs/doc/operator.md
@@ -0,0 +1,460 @@
+# Operator
+
+All of Lua's binary and unary operators are available. Additionally **!=** is as an alias for **~=**, and either **\\** or **::** can be used to write a chaining function call like `tb\func!` or `tb::func!`. And Yuescipt offers some other special operators to write more expressive codes.
+
+```yuescript
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+<YueDisplay>
+
+```yue
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+</YueDisplay>
+
+## Chaining Comparisons
+
+Comparisons can be arbitrarily chained:
+
+```yuescript
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- output: true
+
+a = 5
+print 1 <= a <= 10
+-- output: true
+```
+<YueDisplay>
+
+```yue
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- output: true
+
+a = 5
+print 1 <= a <= 10
+-- output: true
+```
+
+</YueDisplay>
+
+Note the evaluation behavior of chained comparisons:
+
+```yuescript
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  output:
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  output:
+  2
+  1
+  false
+]]
+```
+<YueDisplay>
+
+```yue
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  output:
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  output:
+  2
+  1
+  false
+]]
+```
+
+</YueDisplay>
+
+The middle expression is only evaluated once, rather than twice as it would be if the expression were written as `v(1) < v(2) and v(2) <= v(3)`. However, the order of evaluations in a chained comparison is undefined. It is strongly recommended not to use expressions with side effects (such as printing) in chained comparisons. If side effects are required, the short-circuit `and` operator should be used explicitly.
+
+## Table Appending
+
+The **[] =** operator is used to append values to tables.
+
+```yuescript
+tab = []
+tab[] = "Value"
+```
+<YueDisplay>
+
+```yue
+tab = []
+tab[] = "Value"
+```
+
+</YueDisplay>
+
+You can also use the spread operator `...` to append all elements from one list to another:
+
+```yuescript
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA is now [1, 2, 3, 4, 5, 6]
+```
+<YueDisplay>
+
+```yue
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA is now [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+## Table Spreading
+
+You can concatenate array tables or hash tables using spread operator `...` before expressions in table literals.
+
+```yuescript
+parts =
+  * "shoulders"
+  * "knees"
+lyrics =
+  * "head"
+  * ...parts
+  * "and"
+  * "toes"
+
+copy = {...other}
+
+a = {1, 2, 3, x: 1}
+b = {4, 5, y: 1}
+merge = {...a, ...b}
+```
+<YueDisplay>
+
+```yue
+parts =
+  * "shoulders"
+  * "knees"
+lyrics =
+  * "head"
+  * ...parts
+  * "and"
+  * "toes"
+
+copy = {...other}
+
+a = {1, 2, 3, x: 1}
+b = {4, 5, y: 1}
+merge = {...a, ...b}
+```
+
+</YueDisplay>
+
+## Table Reversed Indexing
+
+You can use the **#** operator to get the last elements of a table.
+
+```yuescript
+last = data.items[#]
+second_last = data.items[#-1]
+data.items[#] = 1
+```
+<YueDisplay>
+
+```yue
+last = data.items[#]
+second_last = data.items[#-1]
+data.items[#] = 1
+```
+
+</YueDisplay>
+
+## Metatable
+
+The **<>** operator can be used as a shortcut for metatable manipulation.
+
+### Metatable Creation
+
+Create normal table with empty bracekets **<>** or metamethod key which is surrounded by **<>**.
+
+```yuescript
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+ -- set field with variable of the same name
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "out of scope"
+```
+<YueDisplay>
+
+```yue
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+ -- set field with variable of the same name
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "out of scope"
+```
+
+</YueDisplay>
+
+### Metatable Accessing
+
+Accessing metatable with **<>** or metamethod name surrounded by **<>** or writing some expression in **<>**.
+
+```yuescript
+-- create with metatable containing field "value"
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+<YueDisplay>
+
+```yue
+-- create with metatable containing field "value"
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+
+</YueDisplay>
+
+### Metatable Destructure
+
+Destruct metatable with metamethod key surrounded by **<>**.
+
+```yuescript
+{item, :new, :<close>, <index>: getter} = tb
+print item, new, close, getter
+```
+<YueDisplay>
+
+```yue
+{item, :new, :<close>, <index>: getter} = tb
+print item, new, close, getter
+```
+
+</YueDisplay>
+
+## Existence
+
+The **?** operator can be used in a variety of contexts to check for existence.
+
+```yuescript
+func?!
+print abc?["hello world"]?.xyz
+
+x = tab?.value
+len = utf8?.len or string?.len or (o) -> #o
+
+if print and x?
+  print x
+
+with? io.open "test.txt", "w"
+  \write "hello"
+  \close!
+```
+<YueDisplay>
+
+```yue
+func?!
+print abc?["hello world"]?.xyz
+
+x = tab?.value
+len = utf8?.len or string?.len or (o) -> #o
+
+if print and x?
+  print x
+
+with? io.open "test.txt", "w"
+  \write "hello"
+  \close!
+```
+
+</YueDisplay>
+
+## Piping
+
+Instead of a series of nested function calls, you can pipe values with operator **|>**.
+
+```yuescript
+"hello" |> print
+1 |> print 2 -- insert pipe item as the first argument
+2 |> print 1, _, 3 -- pipe with a placeholder
+
+-- pipe expression in multiline
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+<YueDisplay>
+
+```yue
+"hello" |> print
+1 |> print 2 -- insert pipe item as the first argument
+2 |> print 1, _, 3 -- pipe with a placeholder
+-- pipe expression in multiline
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+</YueDisplay>
+
+## 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
+func a ?? {}
+
+a ??= false
+```
+<YueDisplay>
+
+```yue
+local a, b, c, d
+a = b ?? c ?? d
+func a ?? {}
+a ??= false
+```
+
+</YueDisplay>
+
+## Implicit Object
+
+You can write a list of implicit structures that starts with the symbol **\*** or **-** inside a table block. If you are creating implicit object, the fields of the object must be with the same indent.
+
+```yuescript
+-- assignment with implicit object
+list =
+  * 1
+  * 2
+  * 3
+
+-- function call with implicit object
+func
+  * 1
+  * 2
+  * 3
+
+-- return with implicit object
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- table with implicit object
+tb =
+  name: "abc"
+
+  values:
+    - "a"
+    - "b"
+    - "c"
+
+  objects:
+    - name: "a"
+      value: 1
+      func: => @value + 1
+      tb:
+        fieldA: 1
+
+    - name: "b"
+      value: 2
+      func: => @value + 2
+      tb: { }
+
+```
+<YueDisplay>
+
+```yue
+-- assignment with implicit object
+list =
+  * 1
+  * 2
+  * 3
+
+-- function call with implicit object
+func
+  * 1
+  * 2
+  * 3
+
+-- return with implicit object
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- table with implicit object
+tb =
+  name: "abc"
+
+  values:
+    - "a"
+    - "b"
+    - "c"
+
+  objects:
+    - name: "a"
+      value: 1
+      func: => @value + 1
+      tb:
+        fieldA: 1
+
+    - name: "b"
+      value: 2
+      func: => @value + 2
+      tb: { }
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/switch.md b/doc/docs/doc/switch.md
new file mode 100644
index 0000000..f503a80
--- /dev/null
+++ b/doc/docs/doc/switch.md
@@ -0,0 +1,296 @@
+# Switch
+
+The switch statement is shorthand for writing a series of if statements that check against the same value. Note that the value is only evaluated once. Like if statements, switches can have an else block to handle no matches. Comparison is done with the == operator. In switch statement, you can also use assignment expression to store temporary variable value.
+
+```yuescript
+switch name := "Dan"
+  when "Robert"
+    print "You are Robert"
+  when "Dan", "Daniel"
+    print "Your name, it's Dan"
+  else
+    print "I don't know about you with name #{name}"
+```
+<YueDisplay>
+
+```yue
+switch name := "Dan"
+  when "Robert"
+    print "You are Robert"
+  when "Dan", "Daniel"
+    print "Your name, it's Dan"
+  else
+    print "I don't know about you with name #{name}"
+```
+
+</YueDisplay>
+
+A switch when clause can match against multiple values by listing them out comma separated.
+
+Switches can be used as expressions as well, here we can assign the result of the switch to a variable:
+
+```yuescript
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "can't count that high!"
+```
+<YueDisplay>
+
+```yue
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "can't count that high!"
+```
+
+</YueDisplay>
+
+We can use the then keyword to write a switch's when block on a single line. No extra keyword is needed to write the else block on a single line.
+
+```yuescript
+msg = switch math.random(1, 5)
+  when 1 then "you are lucky"
+  when 2 then "you are almost lucky"
+  else "not so lucky"
+```
+<YueDisplay>
+
+```yue
+msg = switch math.random(1, 5)
+  when 1 then "you are lucky"
+  when 2 then "you are almost lucky"
+  else "not so lucky"
+```
+
+</YueDisplay>
+
+If you want to write code with one less indent when writing a switch statement, you can put the first when clause on the statement start line, and then all other clauses can be written with one less indent.
+
+```yuescript
+switch math.random(1, 5)
+  when 1
+    print "you are lucky" -- two indents
+  else
+    print "not so lucky"
+
+switch math.random(1, 5) when 1
+  print "you are lucky" -- one indent
+else
+  print "not so lucky"
+```
+<YueDisplay>
+
+```yue
+switch math.random(1, 5)
+  when 1
+    print "you are lucky" -- two indents
+  else
+    print "not so lucky"
+
+switch math.random(1, 5) when 1
+  print "you are lucky" -- one indent
+else
+  print "not so lucky"
+```
+
+</YueDisplay>
+
+It is worth noting the order of the case comparison expression. The case's expression is on the left hand side. This can be useful if the case's expression wants to overwrite how the comparison is done by defining an eq metamethod.
+
+## Table Matching
+
+You can do table matching in a switch when clause, if the table can be destructured by a specific structure and get non-nil values.
+
+```yuescript
+items =
+  * x: 100
+    y: 200
+  * width: 300
+    height: 400
+
+for item in *items
+  switch item
+    when :x, :y
+      print "Vec2 #{x}, #{y}"
+    when :width, :height
+      print "size #{width}, #{height}"
+```
+<YueDisplay>
+
+```yue
+items =
+  * x: 100
+    y: 200
+  * width: 300
+    height: 400
+
+for item in *items
+  switch item
+    when :x, :y
+      print "Vec2 #{x}, #{y}"
+    when :width, :height
+      print "size #{width}, #{height}"
+```
+
+</YueDisplay>
+
+You can use default values to optionally destructure the table for some fields.
+
+```yuescript
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- get error: attempt to index a nil value (field 'pos')
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- table destructuring will still pass
+```
+<YueDisplay>
+
+```yue
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- get error: attempt to index a nil value (field 'pos')
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- table destructuring will still pass
+```
+
+</YueDisplay>
+
+You can also match against array elements, table fields, and even nested structures with array or table literals.
+
+Match against array elements.
+
+```yuescript
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- b has a default value
+    print "1, 2, #{b}"
+```
+<YueDisplay>
+
+```yue
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- b has a default value
+    print "1, 2, #{b}"
+```
+
+</YueDisplay>
+
+Match against table fields with destructuring.
+
+```yuescript
+switch tb
+  when success: true, :result
+    print "success", result
+  when success: false
+    print "failed", result
+  else
+    print "invalid"
+```
+<YueDisplay>
+
+```yue
+switch tb
+  when success: true, :result
+    print "success", result
+  when success: false
+    print "failed", result
+  else
+    print "invalid"
+```
+
+</YueDisplay>
+
+Match against nested table structures.
+
+```yuescript
+switch tb
+  when data: {type: "success", :content}
+    print "success", content
+  when data: {type: "error", :content}
+    print "failed", content
+  else
+    print "invalid"
+```
+<YueDisplay>
+
+```yue
+switch tb
+  when data: {type: "success", :content}
+    print "success", content
+  when data: {type: "error", :content}
+    print "failed", content
+  else
+    print "invalid"
+```
+
+</YueDisplay>
+
+Match against array of tables.
+
+```yuescript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "matched", fourth
+```
+<YueDisplay>
+
+```yue
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "matched", fourth
+```
+
+</YueDisplay>
+
+Match against a list and capture a range of elements.
+
+```yuescript
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Group:", groups -- prints: {"admin", "users"}
+    print "Resource:", resource -- prints: "logs"
+    print "Action:", action -- prints: "view"
+```
+<YueDisplay>
+
+```yue
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Group:", groups -- prints: {"admin", "users"}
+    print "Resource:", resource -- prints: "logs"
+    print "Action:", action -- prints: "view"
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/table-literals.md b/doc/docs/doc/table-literals.md
new file mode 100644
index 0000000..c1adcab
--- /dev/null
+++ b/doc/docs/doc/table-literals.md
@@ -0,0 +1,168 @@
+# Table Literals
+
+Like in Lua, tables are delimited in curly braces.
+
+```yuescript
+some_values = [1, 2, 3, 4]
+```
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+```
+
+</YueDisplay>
+
+Unlike Lua, assigning a value to a key in a table is done with **:** (instead of **=**).
+
+```yuescript
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+<YueDisplay>
+
+```yue
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+</YueDisplay>
+
+The curly braces can be left off if a single table of key value pairs is being assigned.
+
+```yuescript
+profile =
+  height: "4 feet",
+  shoe_size: 13,
+  favorite_foods: ["ice cream", "donuts"]
+```
+<YueDisplay>
+
+```yue
+profile =
+  height: "4 feet",
+  shoe_size: 13,
+  favorite_foods: ["ice cream", "donuts"]
+```
+
+</YueDisplay>
+
+Newlines can be used to delimit values instead of a comma (or both):
+
+```yuescript
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "superman"
+  occupation: "crime fighting"
+}
+```
+<YueDisplay>
+
+```yue
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "superman"
+  occupation: "crime fighting"
+}
+```
+
+</YueDisplay>
+
+When creating a single line table literal, the curly braces can also be left off:
+
+```yuescript
+my_function dance: "Tango", partner: "none"
+
+y = type: "dog", legs: 4, tails: 1
+```
+<YueDisplay>
+
+```yue
+my_function dance: "Tango", partner: "none"
+
+y = type: "dog", legs: 4, tails: 1
+```
+
+</YueDisplay>
+
+The keys of a table literal can be language keywords without being escaped:
+
+```yuescript
+tbl = {
+  do: "something"
+  end: "hunger"
+}
+```
+<YueDisplay>
+
+```yue
+tbl = {
+  do: "something"
+  end: "hunger"
+}
+```
+
+</YueDisplay>
+
+If you are constructing a table out of variables and wish the keys to be the same as the variable names, then the **:** prefix operator can be used:
+
+```yuescript
+hair = "golden"
+height = 200
+person = { :hair, :height, shoe_size: 40 }
+
+print_table :hair, :height
+```
+<YueDisplay>
+
+```yue
+hair = "golden"
+height = 200
+person = { :hair, :height, shoe_size: 40 }
+
+print_table :hair, :height
+```
+
+</YueDisplay>
+
+If you want the key of a field in the table to to be result of an expression, then you can wrap it in **[ ]**, just like in Lua. You can also use a string literal directly as a key, leaving out the square brackets. This is useful if your key has any special characters.
+
+```yuescript
+t = {
+  [1 + 2]: "hello"
+  "hello world": true
+}
+```
+<YueDisplay>
+
+```yue
+t = {
+  [1 + 2]: "hello"
+  "hello world": true
+}
+```
+
+</YueDisplay>
+
+Lua tables have both an array part and a hash part, but sometimes you want to make a semantic distinction between array and hash usage when writing Lua tables. Then you can write Lua table with **[ ]** instead of **{ }** to represent an array table and writing any key value pair in a list table won't be allowed.
+
+```yuescript
+some_values = [1, 2, 3, 4]
+list_with_one_element = [1, ]
+```
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+list_with_one_element = [1, ]
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/the-using-clause-controlling-destructive-assignment.md b/doc/docs/doc/the-using-clause-controlling-destructive-assignment.md
new file mode 100644
index 0000000..fb9b740
--- /dev/null
+++ b/doc/docs/doc/the-using-clause-controlling-destructive-assignment.md
@@ -0,0 +1,98 @@
+# The Using Clause; Controlling Destructive Assignment
+
+While lexical scoping can be a great help in reducing the complexity of the code we write, things can get unwieldy as the code size increases. Consider the following snippet:
+
+```yuescript
+i = 100
+
+-- many lines of code...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- will print 0
+```
+<YueDisplay>
+
+```yue
+i = 100
+
+-- many lines of code...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- will print 0
+```
+
+</YueDisplay>
+
+In my_func, we've overwritten the value of i mistakenly. In this example it is quite obvious, but consider a large, or foreign code base where it isn't clear what names have already been declared.
+
+It would be helpful to say which variables from the enclosing scope we intend on change, in order to prevent us from changing others by accident.
+
+The using keyword lets us do that. using nil makes sure that no closed variables are overwritten in assignment. The using clause is placed after the argument list in a function, or in place of it if there are no arguments.
+
+```yuescript
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- a new local variable is created here
+
+my_func!
+print i -- prints 100, i is unaffected
+```
+<YueDisplay>
+
+```yue
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- a new local variable is created here
+
+my_func!
+print i -- prints 100, i is unaffected
+```
+
+</YueDisplay>
+
+Multiple names can be separated by commas. Closure values can still be accessed, they just cant be modified:
+
+```yuescript
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- a new local tmp is created
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- these have been updated
+```
+<YueDisplay>
+
+```yue
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- a new local tmp is created
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- these have been updated
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/the-yuescript-library.md b/doc/docs/doc/the-yuescript-library.md
new file mode 100644
index 0000000..3761755
--- /dev/null
+++ b/doc/docs/doc/the-yuescript-library.md
@@ -0,0 +1,821 @@
+# The YueScript Library
+
+Access it by `local yue = require("yue")` in Lua.
+
+## yue
+
+**Description:**
+
+The YueScript language library.
+
+### version
+
+**Type:** Field.
+
+**Description:**
+
+The YueScript version.
+
+**Signature:**
+```lua
+version: string
+```
+
+### dirsep
+
+**Type:** Field.
+
+**Description:**
+
+The file separator for the current platform.
+
+**Signature:**
+```lua
+dirsep: string
+```
+
+### yue_compiled
+
+**Type:** Field.
+
+**Description:**
+
+The compiled module code cache.
+
+**Signature:**
+```lua
+yue_compiled: {string: string}
+```
+
+### to_lua
+
+**Type:** Function.
+
+**Description:**
+
+The YueScript compiling function. It compiles the YueScript code to Lua code.
+
+**Signature:**
+```lua
+to_lua: function(code: string, config?: Config):
+    --[[codes]] string | nil,
+    --[[error]] string | nil,
+    --[[globals]] {{string, integer, integer}} | nil
+```
+
+**Parameters:**
+
+| 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. |
+| {{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
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| boolean | Whether the file exists. |
+
+### read_file
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| string | The file content. |
+
+### insert_loader
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| boolean | Whether the loader is inserted successfully. It will fail if the loader is already inserted. |
+
+### remove_loader
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+### loadstring
+
+**Type:** Function.
+
+**Description:**
+
+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...),
+    --[[error]] string | nil
+```
+
+**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. |
+
+**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. |
+
+### loadstring
+
+**Type:** Function.
+
+**Description:**
+
+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...),
+    --[[error]] string | nil
+```
+
+**Parameters:**
+
+| 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. |
+
+### loadstring
+
+**Type:** Function.
+
+**Description:**
+
+Loads YueScript code from a string into a function.
+
+**Signature:**
+```lua
+loadstring: function(input: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parameters:**
+
+| 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. |
+
+### loadfile
+
+**Type:** Function.
+
+**Description:**
+
+Loads YueScript code from a file into a function.
+
+**Signature:**
+```lua
+loadfile: function(filename: string, env: table, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**Parameters:**
+
+| 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. |
+
+### loadfile
+
+**Type:** Function.
+
+**Description:**
+
+Loads YueScript code from a file into a function.
+
+**Signature:**
+```lua
+loadfile: function(filename: string, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**Parameters:**
+
+| 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. |
+
+### dofile
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| any... | The return values of the loaded function. |
+
+### dofile
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| any... | The return values of the loaded function. |
+
+### find_modulepath
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| string | The file path. |
+
+### pcall
+
+**Type:** Function.
+
+**Description:**
+
+Calls a function in protected mode.
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| boolean, ... | Status code and function results or error object. |
+
+### require
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+**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. |
+
+### p
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+### options
+
+**Type:** Field.
+
+**Description:**
+
+The current compiler options.
+
+**Signature:**
+```lua
+options: Config.Options
+```
+
+### traceback
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| string | The rewritten traceback message. |
+
+### is_ast
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| boolean | Whether the code matches the AST. |
+
+### AST
+
+**Type:** Field.
+
+**Description:**
+
+The AST type definition with name, row, column and sub nodes.
+
+**Signature:**
+```lua
+type AST = {string, integer, integer, any}
+```
+
+### to_ast
+
+**Type:** Function.
+
+**Description:**
+
+Converts the code to the AST.
+
+**Signature:**
+```lua
+to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
+    --[[AST]] AST | nil,
+    --[[error]] nil | string
+```
+
+**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. |
+
+**Returns:**
+
+| 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
+
+**Type:** Function.
+
+**Description:**
+
+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. |
+| reserveComment | boolean | [Optional] Whether to reserve the original comments. Default is true. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| string | The formatted code. |
+
+### __call
+
+**Type:** Metamethod.
+
+**Description:**
+
+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. |
+
+**Returns:**
+
+| Return Type | Description |
+| --- | --- |
+| any | The module value. |
+
+## Config
+
+**Description:**
+
+The compiler compile options.
+
+### lint_global
+
+**Type:** Field.
+
+**Description:**
+
+Whether the compiler should collect the global variables appearing in the code.
+
+**Signature:**
+```lua
+lint_global: boolean
+```
+
+### implicit_return_root
+
+**Type:** Field.
+
+**Description:**
+
+Whether the compiler should do an implicit return for the root code block.
+
+**Signature:**
+```lua
+implicit_return_root: boolean
+```
+
+### reserve_line_number
+
+**Type:** Field.
+
+**Description:**
+
+Whether the compiler should reserve the original line number in the compiled code.
+
+**Signature:**
+```lua
+reserve_line_number: boolean
+```
+
+### reserve_comment
+
+**Type:** Field.
+
+**Description:**
+
+Whether the compiler should reserve the original comments in the compiled code.
+
+**Signature:**
+```lua
+reserve_comment: boolean
+```
+
+### space_over_tab
+
+**Type:** Field.
+
+**Description:**
+
+Whether the compiler should use the space character instead of the tab character in the compiled code.
+
+**Signature:**
+```lua
+space_over_tab: boolean
+```
+
+### same_module
+
+**Type:** Field.
+
+**Description:**
+
+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
+```
+
+### line_offset
+
+**Type:** Field.
+
+**Description:**
+
+Whether the compiler error message should include the line number offset. For internal use only.
+
+**Signature:**
+```lua
+line_offset: integer
+```
+
+### yue.Config.LuaTarget
+
+**Type:** Enumeration.
+
+**Description:**
+
+The target Lua version enumeration.
+
+**Signature:**
+```lua
+enum LuaTarget
+  "5.1"
+  "5.2"
+  "5.3"
+  "5.4"
+  "5.5"
+end
+```
+
+### options
+
+**Type:** Field.
+
+**Description:**
+
+The extra options to be passed to the compilation function.
+
+**Signature:**
+```lua
+options: Options
+```
+
+## Options
+
+**Description:**
+
+The extra compiler options definition.
+
+### target
+
+**Type:** Field.
+
+**Description:**
+
+The target Lua version for the compilation.
+
+**Signature:**
+```lua
+target: LuaTarget
+```
+
+### path
+
+**Type:** Field.
+
+**Description:**
+
+The extra module search path.
+
+**Signature:**
+```lua
+path: string
+```
+
+### dump_locals
+
+**Type:** Field.
+
+**Description:**
+
+Whether to dump the local variables in the traceback error message. Default is false.
+
+**Signature:**
+```lua
+dump_locals: boolean
+```
+
+### simplified
+
+**Type:** Field.
+
+**Description:**
+
+Whether to simplify the error message. Default is true.
+
+**Signature:**
+```lua
+simplified: boolean
+```
diff --git a/doc/docs/doc/try.md b/doc/docs/doc/try.md
new file mode 100644
index 0000000..23c7877
--- /dev/null
+++ b/doc/docs/doc/try.md
@@ -0,0 +1,105 @@
+# Try
+
+The syntax for Lua error handling in a common form.
+
+```yuescript
+try
+  func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try
+  func 1, 2, 3
+catch err
+  yue.traceback err
+
+try func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try func 1, 2, 3
+
+try
+  print "trying"
+  func 1, 2, 3
+
+-- working with if assignment pattern
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+<YueDisplay>
+
+```yue
+try
+  func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try
+  func 1, 2, 3
+catch err
+  yue.traceback err
+
+try func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try func 1, 2, 3
+
+try
+  print "trying"
+  func 1, 2, 3
+
+-- working with if assignment pattern
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+
+</YueDisplay>
+
+## Try?
+
+`try?` is a simplified use for error handling syntax that omit the boolean status from the `try` statement, and it will return the result from the try block when success, return nil instead of error object otherwise.
+
+```yuescript
+a, b, c = try? func!
+
+-- with nil coalescing operator
+a = (try? func!) ?? "default"
+
+-- as function argument
+f try? func!
+
+-- with catch block
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+<YueDisplay>
+
+```yue
+a, b, c = try? func!
+
+-- with nil coalescing operator
+a = (try? func!) ?? "default"
+
+-- as function argument
+f try? func!
+
+-- with catch block
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/usage.md b/doc/docs/doc/usage.md
new file mode 100644
index 0000000..45161c6
--- /dev/null
+++ b/doc/docs/doc/usage.md
@@ -0,0 +1,111 @@
+# Usage
+
+## Lua Module
+
+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"
+          }
+        })
+        ```
+
+## YueScript Tool
+
+Use YueScript tool with:
+
+```shell
+> yue -h
+Usage: yue
+       [options] [<file/directory>] ...
+       yue -e <code_or_file> [args...]
+       yue -w [<directory>] [options]
+       yue -
+
+Notes:
+   - '-' / '--' must be the first and only argument.
+   - '-o/--output' can not be used with multiple input files.
+   - '-w/--watch' can not be used with file input (directory only).
+   - with '-e/--execute', remaining tokens are treated as script args.
+
+Options:
+   -h, --help                 Show this help message and exit.
+   -e <str>, --execute <str>  Execute a file or raw codes
+   -m, --minify               Generate minified codes
+   -r, --rewrite              Rewrite output to match original line numbers
+   -t <output_to>, --output-to <output_to>
+                              Specify where to place compiled files
+   -o <file>, --output <file> Write output to file
+   -p, --print                Write output to standard out
+   -b, --benchmark            Dump compile time (doesn't write output)
+   -g, --globals              Dump global variables used in NAME LINE COLUMN
+   -s, --spaces               Use spaces in generated codes instead of tabs
+   -l, --line-numbers         Write line numbers from source codes
+   -j, --no-implicit-return   Disable implicit return at end of file
+   -c, --reserve-comments     Reserve comments before statement from source codes
+   -w [<dir>], --watch [<dir>]
+                              Watch changes and compile every file under directory
+   -v, --version              Print version
+   -                          Read from standard in, print to standard out
+                              (Must be first and only argument)
+   --                         Same as '-' (kept for backward compatibility)
+
+   --target <version>         Specify the Lua version that codes will be generated to
+                              (version can only be 5.1 to 5.5)
+   --path <path_str>          Append an extra Lua search path string to package.path
+   --<key>=<value>            Pass compiler option in key=value form (existing behavior)
+
+   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 .**
+
+Compile and save results to a target path:  **yue -t /target/path/ .**
+
+Compile and reserve debug info:  **yue -l .**
+
+Compile and generate minified codes:  **yue -m .**
+
+Execute raw codes:  **yue -e 'print 123'**
+
+Execute a YueScript file:  **yue -e main.yue**
diff --git a/doc/docs/doc/varargs-assignment.md b/doc/docs/doc/varargs-assignment.md
new file mode 100644
index 0000000..1d66680
--- /dev/null
+++ b/doc/docs/doc/varargs-assignment.md
@@ -0,0 +1,24 @@
+# Varargs Assignment
+
+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]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+<YueDisplay>
+
+```yue
+list = [1, 2, 3, 4, 5]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/while-loop.md b/doc/docs/doc/while-loop.md
new file mode 100644
index 0000000..502935e
--- /dev/null
+++ b/doc/docs/doc/while-loop.md
@@ -0,0 +1,69 @@
+# While Loop
+
+The while loop also comes in four variations:
+
+```yuescript
+i = 10
+while i > 0
+  print i
+  i -= 1
+
+while running == true do my_function!
+```
+<YueDisplay>
+
+```yue
+i = 10
+while i > 0
+  print i
+  i -= 1
+
+while running == true do my_function!
+```
+
+</YueDisplay>
+
+```yuescript
+i = 10
+until i == 0
+  print i
+  i -= 1
+
+until running == false do my_function!
+```
+<YueDisplay>
+
+```yue
+i = 10
+until i == 0
+  print i
+  i -= 1
+until running == false do my_function!
+```
+
+</YueDisplay>
+
+Like for loops, the while loop can also be used an expression. Additionally, for a function to return the accumulated value of a while loop, the statement must be explicitly returned.
+
+## Repeat Loop
+
+The repeat loop comes from Lua:
+
+```yuescript
+i = 10
+repeat
+  print i
+  i -= 1
+until i == 0
+```
+<YueDisplay>
+
+```yue
+i = 10
+repeat
+  print i
+  i -= 1
+until i == 0
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/whitespace.md b/doc/docs/doc/whitespace.md
new file mode 100644
index 0000000..d742a2b
--- /dev/null
+++ b/doc/docs/doc/whitespace.md
@@ -0,0 +1,43 @@
+# Whitespace
+
+YueScript is a whitespace significant language. You have to write some code block in the same indent with space **' '** or tab **'\t'** like function body, value list and some control blocks. And expressions containing different whitespaces might mean different things. Tab is treated like 4 space, but it's better not mix the use of spaces and tabs.
+
+## Statement Separator
+
+A statement normally ends at a line break. You can also use a semicolon `;` to explicitly terminate a statement, which allows writing multiple statements on the same line:
+
+```yuescript
+a = 1; b = 2; print a + b
+```
+<YueDisplay>
+
+```yue
+a = 1; b = 2; print a + b
+```
+
+</YueDisplay>
+
+## Multiline Chaining
+
+You can write multi-line chaining function calls with a same indent.
+
+```yuescript
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x) -> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value) -> value .. '!'
+  \subscribe print
+```
+<YueDisplay>
+
+```yue
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x) -> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value) -> value .. '!'
+  \subscribe print
+```
+
+</YueDisplay>
diff --git a/doc/docs/doc/with-statement.md b/doc/docs/doc/with-statement.md
new file mode 100644
index 0000000..7786803
--- /dev/null
+++ b/doc/docs/doc/with-statement.md
@@ -0,0 +1,126 @@
+# 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.
+
+The with block helps to alleviate this. Within a with block we can use a special statements that begin with either . or \ which represent those operations applied to the object we are using with on.
+
+For example, we work with a newly created object:
+
+```yuescript
+with Person!
+  .name = "Oswald"
+  \add_relative my_dad
+  \save!
+  print .name
+```
+<YueDisplay>
+
+```yue
+with Person!
+  .name = "Oswald"
+  \add_relative my_dad
+  \save!
+  print .name
+```
+
+</YueDisplay>
+
+The with statement can also be used as an expression which returns the value it has been giving access to.
+
+```yuescript
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+<YueDisplay>
+
+```yue
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+</YueDisplay>
+
+Or…
+
+```yuescript
+create_person = (name,  relatives) ->
+  with Person!
+    .name = name
+    \add_relative relative for relative in *relatives
+
+me = create_person "Leaf", [dad, mother, sister]
+```
+<YueDisplay>
+
+```yue
+create_person = (name,  relatives) ->
+  with Person!
+    .name = name
+    \add_relative relative for relative in *relatives
+
+me = create_person "Leaf", [dad, mother, sister]
+```
+
+</YueDisplay>
+
+In this usage, with can be seen as a special form of the K combinator.
+
+The expression in the with statement can also be an assignment, if you want to give a name to the expression.
+
+```yuescript
+with str := "Hello"
+  print "original:", str
+  print "upper:", \upper!
+```
+<YueDisplay>
+
+```yue
+with str := "Hello"
+  print "original:", str
+  print "upper:", \upper!
+```
+
+</YueDisplay>
+
+You can access special keys with `[]` in a `with` statement.
+
+```yuescript
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- appending to "tb"
+```
+<YueDisplay>
+
+```yue
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- appending to "tb"
+```
+
+</YueDisplay>
+
+`with?` is an enhanced version of `with` syntax, which introduces an existential check to safely access objects that may be nil without explicit null checks.
+
+```yuescript
+with? obj
+  print obj.name
+```
+<YueDisplay>
+
+```yue
+with? obj
+  print obj.name
+```
+
+</YueDisplay>
diff --git a/doc/docs/index.md b/doc/docs/index.md
index 0ce1284..03a33dd 100644
--- a/doc/docs/index.md
+++ b/doc/docs/index.md
@@ -17,9 +17,8 @@ features:
     details: Pipe, pattern matching, slicing, and destructuring without giving up Lua interop.
   - title: Rapid Iteration
     details: Any feedback is welcome to help accelerate the language development and evolution!
-footer: MIT Licensed | Copyright © 2017-2026 Li Jin
 ---
 
-## License & Copyright
+### License & Copyright
 
 MIT License. Copyright © 2017-2026 Li Jin. All rights reserved.
diff --git a/doc/docs/zh/doc/assignment.md b/doc/docs/zh/doc/assignment.md
new file mode 100644
index 0000000..49561fb
--- /dev/null
+++ b/doc/docs/zh/doc/assignment.md
@@ -0,0 +1,142 @@
+# 赋值
+
+&emsp;&emsp;月之脚本中定义的变量是动态类型的，并默认为局部变量。但你可以通过 **local** 和 **global** 声明来改变声明变量的作用范围。
+
+```yuescript
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- 访问现有的变量
+```
+<YueDisplay>
+
+```yue
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- 访问现有的变量
+```
+
+</YueDisplay>
+
+## 执行更新
+
+&emsp;&emsp;你可以使用各式二进制运算符执行更新赋值。
+
+```yuescript
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- 如果执行更新的局部变量不存在，将新建一个局部变量
+arg or= "默认值"
+```
+<YueDisplay>
+
+```yue
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- 如果执行更新的局部变量不存在，将新建一个局部变量
+arg or= "默认值"
+```
+
+</YueDisplay>
+
+## 链式赋值
+
+&emsp;&emsp;你可以进行链式赋值，将多个项目赋予相同的值。
+
+```yuescript
+a = b = c = d = e = 0
+x = y = z = f!
+```
+<YueDisplay>
+
+```yue
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+</YueDisplay>
+
+## 显式声明局部变量
+
+```yuescript
+do
+  local a = 1
+  local *
+  print "预先声明后续所有变量为局部变量"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "只预先声明后续大写的变量为局部变量"
+  a = 1
+  B = 2
+```
+<YueDisplay>
+
+```yue
+do
+  local a = 1
+  local *
+  print "预先声明后续所有变量为局部变量"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "只预先声明后续大写的变量为局部变量"
+  a = 1
+  B = 2
+```
+
+</YueDisplay>
+
+## 显式声明全局变量
+
+```yuescript
+do
+  global a = 1
+  global *
+  print "预先声明所有变量为全局变量"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global x = 1
+  global ^
+  print "只预先声明大写的变量为全局变量"
+  a = 1
+  B = 2
+  local Temp = "一个局部值"
+```
+<YueDisplay>
+
+```yue
+do
+  global a = 1
+  global *
+  print "预先声明所有变量为全局变量"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global x = 1
+  global ^
+  print "只预先声明大写的变量为全局变量"
+  a = 1
+  B = 2
+  local Temp = "一个局部值"
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/attributes.md b/doc/docs/zh/doc/attributes.md
new file mode 100644
index 0000000..3dc3b0b
--- /dev/null
+++ b/doc/docs/zh/doc/attributes.md
@@ -0,0 +1,46 @@
+# 属性
+
+&emsp;&emsp;月之脚本现在提供了 Lua 5.4 新增的叫做属性的语法支持。在月之脚本编译到的 Lua 目标版本低于 5.4 时，你仍然可以同时使用`const` 和 `close` 的属性声明语法，并获得常量检查和作用域回调的功能。
+
+```yuescript
+const a = 123
+close _ = <close>: -> print "超出范围。"
+```
+<YueDisplay>
+
+```yue
+const a = 123
+close _ = <close>: -> print "超出范围。"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你可以对进行解构得到的变量标记为常量。
+
+```yuescript
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+<YueDisplay>
+
+```yue
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你也可以声明全局变量为常量。
+
+```yuescript
+global const Constant = 123
+-- Constant = 1
+```
+<YueDisplay>
+
+```yue
+global const Constant = 123
+-- Constant = 1
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/backcalls.md b/doc/docs/zh/doc/backcalls.md
new file mode 100644
index 0000000..4c32fac
--- /dev/null
+++ b/doc/docs/zh/doc/backcalls.md
@@ -0,0 +1,69 @@
+# 反向回调
+
+&emsp;&emsp;反向回调用于减少函数回调的嵌套。它们使用指向左侧的箭头，并且默认会被定义为传入后续函数调用的最后一个参数。它的语法大部分与常规箭头函数相同，只是它指向另一方向，并且后续的函数体不需要进行缩进。
+
+```yuescript
+x <- f
+print "hello" .. x
+```
+<YueDisplay>
+
+```yue
+x <- f
+print "hello" .. x
+```
+
+</YueDisplay>
+
+&emsp;&emsp;月之脚本也提供了粗箭头反向回调函数。
+
+```yuescript
+<= f
+print @value
+```
+<YueDisplay>
+
+```yue
+<= f
+print @value
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你可以通过一个占位符指定回调函数的传参位置。
+
+```yuescript
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+<YueDisplay>
+
+```yue
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果你希望在反向回调处理后继续编写更多其它的代码，可以使用 do 语句将不属于反向回调的代码分隔开。对于非粗箭头函数的反向回调，回调返回值的括号也是可以省略的。
+
+```yuescript
+result, msg = do
+  data <- readAsync "文件名.txt"
+  print data
+  info <- processAsync data
+  check info
+print result, msg
+```
+<YueDisplay>
+
+```yue
+result, msg = do
+  data <- readAsync "文件名.txt"
+  print data
+  info <- processAsync data
+  check info
+print result, msg
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/comment.md b/doc/docs/zh/doc/comment.md
new file mode 100644
index 0000000..f6a7b4e
--- /dev/null
+++ b/doc/docs/zh/doc/comment.md
@@ -0,0 +1,30 @@
+# 注释
+
+```yuescript
+-- 我是一个注释
+
+str = --[[
+这是一个多行注释。
+没问题。
+]] strA \ -- 注释 1
+  .. strB \ -- 注释 2
+  .. strC
+
+func --[[端口]] 3000, --[[ip]] "192.168.1.1"
+```
+<YueDisplay>
+
+```yue
+-- 我是一个注释
+
+str = --[[
+这是一个多行注释。
+没问题。
+]] strA \ -- 注释 1
+  .. strB \ -- 注释 2
+  .. strC
+
+func --[[端口]] 3000, --[[ip]] "192.168.1.1"
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/comprehensions.md b/doc/docs/zh/doc/comprehensions.md
new file mode 100644
index 0000000..fd25b22
--- /dev/null
+++ b/doc/docs/zh/doc/comprehensions.md
@@ -0,0 +1,272 @@
+# 推导式
+
+&emsp;&emsp;推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生 Lua 表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
+
+## 列表推导式
+
+&emsp;&emsp;以下操作创建了一个 items 表的副本，但所有包含的值都翻倍了。
+
+```yuescript
+items = [1, 2, 3, 4]
+doubled = [item * 2 for i, item in ipairs items]
+```
+<YueDisplay>
+
+```yue
+items = [1, 2, 3, 4]
+doubled = [item * 2 for i, item in ipairs items]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;可以使用 `when` 子句筛选新表中包含的项目：
+
+```yuescript
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+<YueDisplay>
+
+```yue
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;因为我们常常需要迭代数值索引表的值，所以引入了 **\*** 操作符来做语法简化。doubled 示例可以重写为：
+
+```yuescript
+doubled = [item * 2 for item in *items]
+```
+<YueDisplay>
+
+```yue
+doubled = [item * 2 for item in *items]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在列表推导式中，你还可以使用展开操作符 `...` 来实现对列表嵌套层级进行扁平化的处理：
+
+```yuescript
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat 现在为 [1, 2, 3, 4, 5, 6]
+```
+<YueDisplay>
+
+```yue
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat 现在为 [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;for 和 when 子句可以根据需要进行链式操作。唯一的要求是推导式中至少要有一个 for 子句。
+
+&emsp;&emsp;使用多个 for 子句与使用多重循环的效果相同：
+
+```yuescript
+x_coords = [4, 5, 6, 7]
+y_coords = [9, 2, 3]
+
+points = [ [x, y] for x in *x_coords \
+for y in *y_coords]
+```
+<YueDisplay>
+
+```yue
+x_coords = [4, 5, 6, 7]
+y_coords = [9, 2, 3]
+
+points = [ [x, y] for x in *x_coords \
+for y in *y_coords]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在推导式中也可以使用简单的数值 for 循环：
+
+```yuescript
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+<YueDisplay>
+
+```yue
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+</YueDisplay>
+
+## 表格推导式
+
+&emsp;&emsp;表格推导式和列表推导式的语法非常相似，只是要使用 **{** 和 **}** 并从每次迭代中取两个值。
+
+&emsp;&emsp;以下示例生成了表格 thing 的副本：
+
+```yuescript
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+<YueDisplay>
+
+```yue
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+</YueDisplay>
+
+```yuescript
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+<YueDisplay>
+
+```yue
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;**\*** 操作符在表格推导式中能使用。在下面的例子里，我们为几个数字创建了一个平方根查找表。
+
+```yuescript
+numbers = [1, 2, 3, 4]
+sqrts = {i, math.sqrt i for i in *numbers}
+```
+<YueDisplay>
+
+```yue
+numbers = [1, 2, 3, 4]
+sqrts = {i, math.sqrt i for i in *numbers}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;表格推导式中的键值元组也可以来自单个表达式，在这种情况下，表达式在计算后应返回两个值。第一个用作键，第二个用作值：
+
+&emsp;&emsp;在下面的示例中，我们将一些数组转换为一个表，其中每个数组里的第一项是键，第二项是值。
+
+```yuescript
+tuples = [ ["hello", "world"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+<YueDisplay>
+
+```yue
+tuples = [ ["hello", "world"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+
+</YueDisplay>
+
+## 切片
+
+&emsp;&emsp;当使用 **\*** 操作符时，月之脚本还提供了一种特殊的语法来限制要遍历的列表范围。这个语法也相当于在 for 循环中设置迭代边界和步长。
+
+&emsp;&emsp;下面的案例中，我们在切片中设置最小和最大边界，取索引在 1 到 5 之间（包括 1 和 5）的所有项目：
+
+```yuescript
+slice = [item for item in *items[1, 5]]
+```
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[1, 5]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;切片的任意参数都可以省略，并会使用默认值。在如下示例中，如果省略了最大索引边界，它默认为表的长度。使下面的代码取除第一个元素之外的所有元素：
+
+```yuescript
+slice = [item for item in *items[2,]]
+```
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[2,]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果省略了最小边界，便默认会设置为 1。这里我们只提供一个步长，并留下其他边界为空。这样会使得代码取出所有奇数索引的项目：(1, 3, 5, …)
+
+```yuescript
+slice = [item for item in *items[,,2]]
+```
+<YueDisplay>
+
+
+```yue
+slice = [item for item in *items[,,2]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;最小和最大边界都可以是负数，使用负数意味着边界是从表的末尾开始计算的。
+
+```yuescript
+-- 取最后4个元素
+slice = [item for item in *items[-4,-1]]
+```
+<YueDisplay>
+
+```yue
+-- 取最后4个元素
+slice = [item for item in *items[-4,-1]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;切片的步长也可以是负数，这意味着元素会以相反的顺序被取出。
+
+```yuescript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+<YueDisplay>
+
+```yue
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+</YueDisplay>
+
+### 切片表达式
+
+&emsp;&emsp;切片也可以作为表达式来使用。可以用于获取一个表包含的子列表。
+
+```yuescript
+-- 取第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+
+-- 取最后4个元素作为新的列表
+last_four_items = items[-4, -1]
+```
+<YueDisplay>
+
+```yue
+-- 取第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+
+-- 取最后4个元素作为新的列表
+last_four_items = items[-4, -1]
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/conditionals.md b/doc/docs/zh/doc/conditionals.md
new file mode 100644
index 0000000..e4b217a
--- /dev/null
+++ b/doc/docs/zh/doc/conditionals.md
@@ -0,0 +1,150 @@
+# 条件语句
+
+```yuescript
+have_coins = false
+if have_coins
+  print "有硬币"
+else
+  print "没有硬币"
+```
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins
+  print "有硬币"
+else
+  print "没有硬币"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;对于简单的语句，也可以使用简短的语法：
+
+```yuescript
+have_coins = false
+if have_coins then print "有硬币" else print "没有硬币"
+```
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins then print "有硬币" else print "没有硬币"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;因为 if 语句可以用作表达式，所以也可以这样写：
+
+```yuescript
+have_coins = false
+print if have_coins then "有硬币" else "没有硬币"
+```
+<YueDisplay>
+
+```yue
+have_coins = false
+print if have_coins then "有硬币" else "没有硬币"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;条件语句也可以作为表达式用在返回语句和赋值语句中：
+
+```yuescript
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "我很高"
+else
+  "我不是很高"
+
+print message -- 打印: 我很高
+```
+<YueDisplay>
+
+```yue
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "我很高"
+else
+  "我不是很高"
+
+print message -- 打印: 我很高
+```
+
+</YueDisplay>
+
+&emsp;&emsp;if 的反义词是 unless（相当于 if not，正如“如果”对应“除非”）：
+
+```yuescript
+unless os.date("%A") == "Monday"
+  print "今天不是星期一！"
+```
+<YueDisplay>
+
+
+```yue
+unless os.date("%A") == "Monday"
+  print "今天不是星期一！"
+```
+
+</YueDisplay>
+
+```yuescript
+print "你真幸运！" unless math.random! > 0.1
+```
+<YueDisplay>
+
+```yue
+print "你真幸运！" unless math.random! > 0.1
+```
+
+</YueDisplay>
+
+## 范围表达式
+
+&emsp;&emsp;你可以使用范围表达式来编写进行范围检查的代码。
+
+```yuescript
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "检查离散值的相等性"
+
+if a in list
+  print "检查`a`是否在列表中"
+```
+<YueDisplay>
+
+```yue
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "检查离散值的相等性"
+
+if a in list
+  print "检查`a`是否在列表中"
+```
+
+</YueDisplay>
+
+```yuescript
+print "你很幸运!" unless math.random! > 0.1
+```
+<YueDisplay>
+
+```yue
+print "你很幸运!" unless math.random! > 0.1
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/continue.md b/doc/docs/zh/doc/continue.md
new file mode 100644
index 0000000..9fab8a3
--- /dev/null
+++ b/doc/docs/zh/doc/continue.md
@@ -0,0 +1,41 @@
+# continue 语句
+
+&emsp;&emsp;继续语句可以用来跳出当前的循环迭代。
+
+```yuescript
+i = 0
+while i < 10
+  i += 1
+  continue if i % 2 == 0
+  print i
+```
+<YueDisplay>
+
+```yue
+i = 0
+while i < 10
+  i += 1
+  continue if i % 2 == 0
+  print i
+```
+
+</YueDisplay>
+
+&emsp;&emsp;继续语句也可以与各种循环表达式一起使用，以防止当前的循环迭代结果累积到结果列表中。以下示例将数组表过滤为仅包含偶数的数组：
+
+```yuescript
+my_numbers = [1, 2, 3, 4, 5, 6]
+odds = for x in *my_numbers
+  continue if x % 2 == 1
+  x
+```
+<YueDisplay>
+
+```yue
+my_numbers = [1, 2, 3, 4, 5, 6]
+odds = for x in *my_numbers
+  continue if x % 2 == 1
+  x
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/destructuring-assignment.md b/doc/docs/zh/doc/destructuring-assignment.md
new file mode 100644
index 0000000..205a1ff
--- /dev/null
+++ b/doc/docs/zh/doc/destructuring-assignment.md
@@ -0,0 +1,241 @@
+# 解构赋值
+
+&emsp;&emsp;解构赋值是一种快速从 Lua 表中按名称或基于数组中的位置提取值的方法。
+
+&emsp;&emsp;通常当你看到一个字面量的 Lua 表，比如 `{1,2,3}`，它位于赋值的右侧，因为它是一个值。解构赋值语句的写法就是交换了字面量 Lua 表的角色，并将其放在赋值语句的左侧。
+
+&emsp;&emsp;最好是通过示例来解释。以下是如何从表格中解包前两个值的方法：
+
+```yuescript
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+<YueDisplay>
+
+
+```yue
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在解构表格字面量中，键代表从右侧读取的键，值代表读取的值将被赋予的名称。
+
+```yuescript
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- 可以不带大括号进行简单的解构
+```
+<YueDisplay>
+
+```yue
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- 可以不带大括号进行简单的解构
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这也适用于嵌套的数据结构：
+
+```yuescript
+obj2 = {
+  numbers: [1,2,3,4]
+  properties: {
+    color: "green"
+    height: 13.5
+  }
+}
+
+{numbers: [first, second], properties: {color: color}} = obj2
+print first, second, color
+```
+<YueDisplay>
+
+```yue
+obj2 = {
+  numbers: [1,2,3,4]
+  properties: {
+    color: "green"
+    height: 13.5
+  }
+}
+
+{numbers: [first, second]} = obj2
+print first, second, color
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果解构语句很复杂，也可以任意将其分散在几行中。稍微复杂一些的示例：
+
+```yuescript
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+<YueDisplay>
+
+```yue
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+</YueDisplay>
+
+&emsp;&emsp;有时候我们会需要从 Lua 表中提取值并将它们赋给与键同名的局部变量。为了避免编写重复代码，我们可以使用 **:** 前缀操作符：
+
+```yuescript
+{:concat, :insert} = table
+```
+<YueDisplay>
+
+```yue
+{:concat, :insert} = table
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这样的用法与导入语法有些相似。但我们可以通过混合语法重命名我们想要提取的字段：
+
+```yuescript
+{:mix, :max, random: rand} = math
+```
+<YueDisplay>
+
+```yue
+{:mix, :max, random: rand} = math
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在进行解构时，你可以指定默认值，如：
+
+```yuescript
+{:name = "nameless", :job = "jobless"} = person
+```
+<YueDisplay>
+
+```yue
+{:name = "nameless", :job = "jobless"} = person
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在进行列表解构时，你可以使用`_`作为占位符：
+
+```yuescript
+[_, two, _, four] = items
+```
+<YueDisplay>
+
+```yue
+[_, two, _, four] = items
+```
+
+</YueDisplay>
+
+## 范围解构
+
+&emsp;&emsp;你可以使用展开运算符 `...` 在列表解构中来捕获一个范围的值到子列表中。这在当你想要从列表的开头和结尾提取特定元素，同时收集中间的元素时非常有用。
+
+```yuescript
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- 打印: first
+print bulk   -- 打印: {"second", "third", "fourth"}
+print last   -- 打印: last
+```
+<YueDisplay>
+
+```yue
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- 打印: first
+print bulk   -- 打印: {"second", "third", "fourth"}
+print last   -- 打印: last
+```
+
+</YueDisplay>
+
+&emsp;&emsp;展开运算符可以用在不同的位置来捕获不同的范围，并且你可以使用 `_` 作为占位符来表示你想跳过对应范围的捕获：
+
+```yuescript
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+```
+<YueDisplay>
+
+```yue
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+```
+
+</YueDisplay>
+
+## 在其它地方的解构赋值
+
+&emsp;&emsp;解构赋值也可以出现在其它隐式进行赋值的地方。一个例子是用在 for 循环中：
+
+```yuescript
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+<YueDisplay>
+
+```yue
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+</YueDisplay>
+
+&emsp;&emsp;我们知道数组表中的每个元素都是一个两项的元组，所以我们可以直接在 for 语句的名称子句中使用解构来解包它。
diff --git a/doc/docs/zh/doc/do.md b/doc/docs/zh/doc/do.md
new file mode 100644
index 0000000..52dca26
--- /dev/null
+++ b/doc/docs/zh/doc/do.md
@@ -0,0 +1,66 @@
+# do 语句
+
+&emsp;&emsp;当用作语句时，do 语句的作用就像在 Lua 中差不多。
+
+```yuescript
+do
+  var = "hello"
+  print var
+print var -- 这里是nil
+```
+<YueDisplay>
+
+```yue
+do
+  var = "hello"
+  print var
+print var -- 这里是nil
+```
+
+</YueDisplay>
+
+&emsp;&emsp;月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将 do 语句代码块的最后一个语句作为表达式返回的结果。
+
+```yuescript
+counter = do
+  i = 0
+  ->
+    i += 1
+    i
+
+print counter!
+print counter!
+```
+<YueDisplay>
+
+```yue
+counter = do
+  i = 0
+  ->
+    i += 1
+    i
+
+print counter!
+print counter!
+```
+
+</YueDisplay>
+
+```yuescript
+tbl = {
+  key: do
+    print "分配键值!"
+    1234
+}
+```
+<YueDisplay>
+
+```yue
+tbl = {
+  key: do
+    print "分配键值!"
+    1234
+}
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/for-loop.md b/doc/docs/zh/doc/for-loop.md
new file mode 100644
index 0000000..212ff81
--- /dev/null
+++ b/doc/docs/zh/doc/for-loop.md
@@ -0,0 +1,125 @@
+# for 循环
+
+&emsp;&emsp;Lua 中有两种 for 循环形式，数字型和通用型：
+
+```yuescript
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- 提供了一个遍历的步长
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+<YueDisplay>
+
+```yue
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- 提供了一个遍历的步长
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+
+</YueDisplay>
+
+&emsp;&emsp;可以使用切片和 **\*** 操作符，就像在列表推导中一样：
+
+```yuescript
+for item in *items[2, 4]
+  print item
+```
+<YueDisplay>
+
+```yue
+for item in *items[2, 4]
+  print item
+```
+
+</YueDisplay>
+
+&emsp;&emsp;当代码语句只有一行时，循环语句也都可以写作更短的语法：
+
+```yuescript
+for item in *items do print item
+
+for j = 1, 10, 3 do print j
+```
+<YueDisplay>
+
+```yue
+for item in *items do print item
+
+for j = 1, 10, 3 do print j
+```
+
+</YueDisplay>
+
+&emsp;&emsp;for 循环也可以用作表达式。for 循环主体中的最后一条语句会被强制转换为一个返回值的表达式，并会将表达式计算结果的值追加到一个作为结果的数组表中。
+
+&emsp;&emsp;将每个偶数加倍：
+
+```yuescript
+doubled_evens = for i = 1, 20
+  if i % 2 == 0
+    i * 2
+  else
+    i
+```
+<YueDisplay>
+
+```yue
+doubled_evens = for i = 1, 20
+  if i % 2 == 0
+    i * 2
+  else
+    i
+```
+
+</YueDisplay>
+
+&emsp;&emsp;此外，for 循环还支持带返回值的 break 语句，这样循环本身就可以作为一个表达式，在满足条件时提前退出并返回有意义的结果。
+
+&emsp;&emsp;例如，查找第一个大于 10 的数字：
+
+```yuescript
+first_large = for n in *numbers
+  break n if n > 10
+```
+<YueDisplay>
+
+```yue
+first_large = for n in *numbers
+  break n if n > 10
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你还可以结合 for 循环表达式与 continue 语句来过滤值。
+
+&emsp;&emsp;注意出现在函数体末尾的 for 循环，不会被当作是一个表达式并将循环结果累积到一个列表中作为返回值（相反，函数将返回 nil）。如果要函数末尾的循环转换为列表表达式，可以显式地使用返回语句加 for 循环表达式。
+
+```yuescript
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- 打印 nil
+print func_b! -- 打印 table 对象
+```
+<YueDisplay>
+
+```yue
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- 打印 nil
+print func_b! -- 打印 table 对象
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这样做是为了避免在不需要返回循环结果的函数，创建无效的返回值表格。
diff --git a/doc/docs/zh/doc/function-literals.md b/doc/docs/zh/doc/function-literals.md
new file mode 100644
index 0000000..efe920b
--- /dev/null
+++ b/doc/docs/zh/doc/function-literals.md
@@ -0,0 +1,494 @@
+# 函数字面量
+
+&emsp;&emsp;所有函数都是使用月之脚本的函数表达式创建的。一个简单的函数可以用箭头表示为：**->**。
+
+```yuescript
+my_function = ->
+my_function() -- 调用空函数
+```
+<YueDisplay>
+
+```yue
+my_function = ->
+my_function() -- 调用空函数
+```
+
+</YueDisplay>
+
+&emsp;&emsp;函数体可以是紧跟在箭头后的一个语句，或者是在后面的行上使用同样缩进的一系列语句：
+
+```yuescript
+func_a = -> print "你好，世界"
+
+func_b = ->
+  value = 100
+  print "这个值是：", value
+```
+<YueDisplay>
+
+```yue
+func_a = -> print "你好，世界"
+
+func_b = ->
+  value = 100
+  print "这个值是：", value
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果一个函数没有参数，可以使用 **\!** 操作符调用它，而不是空括号。使用 **\!** 调用没有参数的函数是推荐的写法。
+
+```yuescript
+func_a!
+func_b()
+```
+<YueDisplay>
+
+```yue
+func_a!
+func_b()
+```
+
+</YueDisplay>
+
+&emsp;&emsp;带有参数的函数可以通过在箭头前加上括号中的参数名列表来进行创建：
+
+```yuescript
+sum = (x, y) -> print "数字的和", x + y
+```
+<YueDisplay>
+
+```yue
+sum = (x, y) -> print "数字的和", x + y
+```
+
+</YueDisplay>
+
+&emsp;&emsp;函数可以通过在函数名后列出参数来调用。当对函数做嵌套的调用时，后面列出的参数会应用于左侧最近的函数。
+
+```yuescript
+sum 10, 20
+print sum 10, 20
+
+a b c "a", "b", "c"
+```
+<YueDisplay>
+
+```yue
+sum 10, 20
+print sum 10, 20
+
+a b c "a", "b", "c"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;为了避免在调用函数时产生歧义，也可以使用括号将参数括起来。比如在以下的例子中是必需的，这样才能确保参数被传入到正确的函数。
+
+```yuescript
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+<YueDisplay>
+
+```yue
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+</YueDisplay>
+
+&emsp;&emsp;注意：函数名与开始括号之间不能有任何空格。
+
+&emsp;&emsp;函数会将函数体中的最后一个语句强制转换为返回语句，这被称作隐式返回：
+
+```yuescript
+sum = (x, y) -> x + y
+print "数字的和是", sum 10, 20
+```
+<YueDisplay>
+
+```yue
+sum = (x, y) -> x + y
+print "数字的和是", sum 10, 20
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果你需要做显式返回，可以使用 return 关键字：
+
+```yuescript
+sum = (x, y) -> return x + y
+```
+<YueDisplay>
+
+```yue
+sum = (x, y) -> return x + y
+```
+
+</YueDisplay>
+
+&emsp;&emsp;就像在Lua中一样，函数可以返回多个值。最后一个语句必须是由逗号分隔的值列表：
+
+```yuescript
+mystery = (x, y) -> x + y, x - y
+a, b = mystery 10, 20
+```
+<YueDisplay>
+
+```yue
+mystery = (x, y) -> x + y, x - y
+a, b = mystery 10, 20
+```
+
+</YueDisplay>
+
+## 粗箭头
+
+&emsp;&emsp;因为在 Lua 中调用方法时，经常习惯将对象作为第一个参数传入，所以月之脚本提供了一种特殊的语法来创建自动包含 self 参数的函数。
+
+```yuescript
+func = (num) => @value + num
+```
+<YueDisplay>
+
+```yue
+func = (num) => @value + num
+```
+
+</YueDisplay>
+
+## 参数默认值
+
+&emsp;&emsp;可以为函数的参数提供默认值。如果参数的值为 nil，则确定该参数为空。任何具有默认值的 nil 参数在函数体运行之前都会被替换。
+
+```yuescript
+my_function = (name = "某物", height = 100) ->
+  print "你好，我是", name
+  print "我的高度是", height
+```
+<YueDisplay>
+
+```yue
+my_function = (name = "某物", height = 100) ->
+  print "你好，我是", name
+  print "我的高度是", height
+```
+
+</YueDisplay>
+
+&emsp;&emsp;函数参数的默认值表达式在函数体中会按参数声明的顺序进行计算。因此，在默认值的表达式中可以访问先前声明的参数。
+
+```yuescript
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+<YueDisplay>
+
+```yue
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+</YueDisplay>
+
+## 注意事项
+
+&emsp;&emsp;由于月之脚本支持无需括号的表达式式函数调用，因此为了避免因空白字符造成的解析歧义，需要进行一些限制。
+
+&emsp;&emsp;减号（-）在表达式中既可以作为一元取反操作符，也可以作为二元减法操作符。请注意下面这些示例的编译方式：
+
+```yuescript
+a = x - 10
+b = x-10
+c = x -y
+d = x- z
+```
+<YueDisplay>
+
+```yue
+a = x - 10
+b = x-10
+c = x -y
+d = x- z
+```
+
+</YueDisplay>
+
+&emsp;&emsp;当函数调用的第一个参数是字符串字面量时，可以通过空白控制其优先级。在 Lua 中，常见的写法是调用仅有一个字符串或表字面量参数的函数时省略括号。
+
+&emsp;&emsp;当变量名和字符串字面量之间没有空格时，函数的调用优先级高于后续表达式，因此此时无法再传入其他参数。
+
+&emsp;&emsp;当变量名和字符串字面量之间有空格时，字符串字面量会作为后续表达式（如果存在）的参数，这样可以传递参数列表。
+
+```yuescript
+x = func"hello" + 100
+y = func "hello" + 100
+```
+<YueDisplay>
+
+```yue
+x = func"hello" + 100
+y = func "hello" + 100
+```
+
+</YueDisplay>
+
+## 多行参数
+
+&emsp;&emsp;当调用接收大量参数的函数时，将参数列表分成多行是很方便的。由于月之脚本语言对空白字符的敏感性，做参数列表的分割时务必要小心。
+
+&emsp;&emsp;如果要将参数列表写到下一行，那么当前行必须以逗号结束。并且下一行的缩进必须比当前的缩进多。一旦做了参数的缩进，所有其他参数列表的行必须保持相同的缩进级别，以成为参数列表的一部分。
+
+```yuescript
+my_func 5, 4, 3,
+  8, 9, 10
+
+cool_func 1, 2,
+  3, 4,
+  5, 6,
+  7, 8
+```
+<YueDisplay>
+
+```yue
+my_func 5, 4, 3,
+  8, 9, 10
+
+cool_func 1, 2,
+  3, 4,
+  5, 6,
+  7, 8
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这种调用方式可以做嵌套。并通过缩进级别来确定参数属于哪一个函数。
+
+```yuescript
+my_func 5, 6, 7,
+  6, another_func 6, 7, 8,
+    9, 1, 2,
+  5, 4
+```
+<YueDisplay>
+
+```yue
+my_func 5, 6, 7,
+  6, another_func 6, 7, 8,
+    9, 1, 2,
+  5, 4
+```
+
+</YueDisplay>
+
+&emsp;&emsp;因为 Lua 表也使用逗号作为分隔符，这种缩进语法有助于让值成为参数列表的一部分，而不是 Lua 表的一部分。
+
+```yuescript
+x = [
+  1, 2, 3, 4, a_func 4, 5,
+    5, 6,
+  8, 9, 10
+]
+```
+<YueDisplay>
+
+```yue
+x = [
+  1, 2, 3, 4, a_func 4, 5,
+    5, 6,
+  8, 9, 10
+]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;有个不常见的写法可以注意一下，如果我们将在后面使用较低的缩进，我们可以为函数参数提供更深的缩进来区分列表的归属。
+
+```yuescript
+y = [ my_func 1, 2, 3,
+   4, 5,
+  5, 6, 7
+]
+```
+<YueDisplay>
+
+```yue
+y = [ my_func 1, 2, 3,
+   4, 5,
+  5, 6, 7
+]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;对于其它有代码块跟随的语句，比如条件语句，也可以通过小心安排缩进来做类似的事。比如我们可以通过调整缩进级别来控制一些值归属于哪个语句：
+
+```yuescript
+if func 1, 2, 3,
+  "你好",
+  "世界"
+    print "你好"
+    print "我在if内部"
+
+if func 1, 2, 3,
+    "你好",
+    "世界"
+  print "hello"
+  print "我在if内部"
+```
+<YueDisplay>
+
+```yue
+if func 1, 2, 3,
+  "你好",
+  "世界"
+    print "你好"
+    print "我在if内部"
+
+if func 1, 2, 3,
+    "你好",
+    "世界"
+  print "你好"
+  print "我在if内部"
+```
+
+</YueDisplay>
+
+## 参数解构
+
+&emsp;&emsp;月之脚本支持在函数形参位置对传入对象进行解构。适用两类解构表子面量：
+
+- 使用 {} 包裹的字面量/对象形参，支持提供获得空字段时的默认值（例如 {:a, :b}、{a: a1 = 123}）。
+
+- 无 {} 包裹、以键值/简写键序列开头，直至遇到其它表达式终止（例如 :a, b: b1, :c），表示从同一个对象中解构多个字段。
+
+```yuescript
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+```
+<YueDisplay>
+
+```yue
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+```
+
+</YueDisplay>
+
+## 前置返回表达式
+
+&emsp;&emsp;在深度嵌套的函数体中，为了提升返回值的可读性及编写便利性，我们新增了 “前置返回表达式” 语法。其形式如下：
+
+```yuescript
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+```
+<YueDisplay>
+
+```yue
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这个写法等价于：
+
+```yuescript
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+```
+<YueDisplay>
+
+```yue
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+```
+
+</YueDisplay>
+
+&emsp;&emsp;唯一的区别在于：你可以将函数的返回值表达式提前写在 `->` 或 `=>` 前，用以指示该函数应隐式返回该表达式的值。这样即使在多层循环或条件判断的场景下，也无需编写尾行悬挂的返回表达式，逻辑结构会更加直观清晰。
+
+## 命名变长参数
+
+&emsp;&emsp;你可以使用 `(...t) ->` 语法来将变长参数自动存储到一个命名表中。这个表会包含所有传入的参数（包括 `nil` 值），并且会在表的 `n` 字段中存储实际传入的参数个数（包括 `nil` 值在内的个数）。
+
+```yuescript
+f = (...t) ->
+  print "参数个数:", t.n
+  print "表长度:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- 处理包含 nil 的情况
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+<YueDisplay>
+
+```yue
+f = (...t) ->
+  print "参数个数:", t.n
+  print "表长度:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- 处理包含 nil 的情况
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/function-stubs.md b/doc/docs/zh/doc/function-stubs.md
new file mode 100644
index 0000000..af08feb
--- /dev/null
+++ b/doc/docs/zh/doc/function-stubs.md
@@ -0,0 +1,48 @@
+# 函数存根
+
+&emsp;&emsp;在编程中，将对象的方法作为函数类型的值进行传递是一种常见做法，尤其是在将实例方法作为回调函数传递给其他函数的情形中。当目标函数需要将该对象作为其第一个参数时，我们需要找到一种方式将对象和函数绑定在一起，以便能够正确地调用该函数。
+
+&emsp;&emsp;函数存根（stub）语法提供了一种便捷的方法来创建一个新的闭包函数，这个函数将对象和原函数绑定在一起。这样，当调用这个新创建的函数时，它会在正确的对象上下文中执行原有的函数。
+
+&emsp;&emsp;这种语法类似于使用 \ 操作符调用实例方法的方式，区别在于，这里不需要在 \ 操作符后面附加参数列表。
+
+```yuescript
+my_object = {
+  value: 1000
+  write: => print "值为:", @value
+}
+
+run_callback = (func) ->
+  print "运行回调..."
+  func!
+
+-- 这样写不起作用：
+-- 函数没有引用my_object
+run_callback my_object.write
+
+-- 函数存根语法
+-- 让我们把对象捆绑到一个新函数中
+run_callback my_object\write
+```
+<YueDisplay>
+
+```yue
+my_object = {
+  value: 1000
+  write: => print "值为:", @value
+}
+
+run_callback = (func) ->
+  print "运行回调..."
+  func!
+
+-- 这样写不起作用：
+-- 函数没有引用my_object
+run_callback my_object.write
+
+-- 函数存根语法
+-- 让我们把对象捆绑到一个新函数中
+run_callback my_object\write
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/if-assignment.md b/doc/docs/zh/doc/if-assignment.md
new file mode 100644
index 0000000..e4077e1
--- /dev/null
+++ b/doc/docs/zh/doc/if-assignment.md
@@ -0,0 +1,73 @@
+# If 赋值
+
+&emsp;&emsp;`if` 和 `elseif` 代码块可以在条件表达式的位置进行赋值。在代码执行到要计算条件时，会首先进行赋值计算，并使用赋与的值作为分支判断的条件。赋值的变量仅在条件分支的代码块内有效，这意味着如果值不是真值，那么它就不会被用到。注意，你必须使用“海象运算符” `:=` 而不是 `=` 来做赋值。
+
+```yuescript
+if user := database.find_user "moon"
+  print user.name
+```
+<YueDisplay>
+
+```yue
+if user := database.find_user "moon"
+  print user.name
+```
+
+</YueDisplay>
+
+```yuescript
+if hello := os.getenv "hello"
+  print "你有 hello", hello
+elseif world := os.getenv "world"
+  print "你有 world", world
+else
+  print "什么都没有 :("
+```
+<YueDisplay>
+
+```yue
+if hello := os.getenv "hello"
+  print "你有 hello", hello
+elseif world := os.getenv "world"
+  print "你有 world", world
+else
+  print "什么都没有 :("
+```
+
+</YueDisplay>
+
+&emsp;&emsp;使用多个返回值的 If 赋值。只有第一个值会被检查，其他值都有同样的作用域。
+
+```yuescript
+if success, result := pcall -> "无报错地获取结果"
+  print result -- 变量 result 是有作用域的
+print "好的"
+```
+<YueDisplay>
+
+```yue
+if success, result := pcall -> "无报错地获取结果"
+  print result -- 变量 result 是有作用域的
+print "好的"
+```
+
+</YueDisplay>
+
+## While 赋值
+
+&emsp;&emsp;你可以在 while 循环中同样使用赋值来获取循环条件的值。
+
+```yuescript
+while byte := stream\read_one!
+  -- 对 byte 做一些操作
+  print byte
+```
+<YueDisplay>
+
+```yue
+while byte := stream\read_one!
+  -- 对 byte 做一些操作
+  print byte
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/index.md b/doc/docs/zh/doc/index.md
index 5250325..7611fc6 100755
--- a/doc/docs/zh/doc/index.md
+++ b/doc/docs/zh/doc/index.md
@@ -1,5453 +1,11 @@
 ---
-sidebar: auto
 title: 参考手册
 ---
 
-# 月之脚本
+# 月之脚本文档
 
-<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em;"/>
+<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em;padding-bottom: 2em;"/>
 
-## 介绍
-
-月之脚本（YueScript）是一种动态语言，可以编译为 Lua。它是 [MoonScript](https://github.com/leafo/moonscript) 的方言。用月之脚本编写的代码既有表现力又非常简洁。它适合编写一些更易于维护的代码，并在嵌入 Lua 的环境中运行，如游戏或网站服务器。
-
-Yue（月）是中文中“月亮”的名称。
-
-### 月之脚本概览
-```yuescript
--- 导入语法
-import p, to_lua from "yue"
-
--- 隐式对象
-inventory =
-  equipment:
-    - "sword"
-    - "shield"
-  items:
-    - name: "potion"
-      count: 10
-    - name: "bread"
-      count: 3
-
--- 列表推导
-map = (arr, action) ->
-  [action item for item in *arr]
-
-filter = (arr, cond) ->
-  [item for item in *arr when cond item]
-
-reduce = (arr, init, action): init ->
-  init = action init, item for item in *arr
-
--- 管道操作符
-[1, 2, 3]
-  |> map (x) -> x * 2
-  |> filter (x) -> x > 4
-  |> reduce 0, (a, b) -> a + b
-  |> print
-
--- 元表操作
-apple =
-  size: 15
-  <index>:
-    color: 0x00ffff
-
-with apple
-  p .size, .color, .<index> if .<>?
-
--- 类似js的导出语法
-export 🌛 = "月之脚本"
-```
-<YueDisplay>
-
-```yue
--- 导入语法
-import p, to_lua from "yue"
-
--- 隐式对象
-inventory =
-  equipment:
-    - "sword"
-    - "shield"
-  items:
-    - name: "potion"
-      count: 10
-    - name: "bread"
-      count: 3
-
--- 列表推导
-map = (arr, action) ->
-  [action item for item in *arr]
-
-filter = (arr, cond) ->
-  [item for item in *arr when cond item]
-
-reduce = (arr, init, action): init ->
-  init = action init, item for item in *arr
-
--- 管道操作符
-[1, 2, 3]
-  |> map (x) -> x * 2
-  |> filter (x) -> x > 4
-  |> reduce 0, (a, b) -> a + b
-  |> print
-
--- 元表操作
-apple =
-  size: 15
-  <index>:
-    color: 0x00ffff
-
-with apple
-  p .size, .color, .<index> if .<>?
-
--- 类似js的导出语法
-export 🌛 = "月之脚本"
-```
-
-</YueDisplay>
-
-## 安装
-
-* **Lua 模块**
-
-&emsp;安装 [luarocks](https://luarocks.org)，一个 Lua 模块的包管理器。然后作为 Lua 模块和可执行文件安装它：
-
-```
-> luarocks install yuescript
-```
-
-&emsp;或者你可以自己构建 `yue.so` 文件：
-
-```
-> make shared LUAI=/usr/local/include/lua LUAL=/usr/local/lib/lua
-```
-
-&emsp;然后从路径 **bin/shared/yue.so** 获取二进制文件。
-
-* **构建二进制工具**
-
-&emsp;克隆项目仓库，然后构建并安装可执行文件：
-```
-> make install
-```
-
-&emsp;构建不带宏功能的月之脚本编译工具：
-```
-> make install NO_MACRO=true
-```
-
-&emsp;构建不带内置Lua二进制文件的月之脚本编译工具：
-```
-> make install NO_LUA=true
-```
-
-* **下载预编译的二进制程序**
-
-&emsp;你可以下载预编译的二进制程序，包括兼容不同 Lua 版本的二进制可执行文件和库文件。
-
-&emsp;在[这里](https://github.com/IppClub/YueScript/releases)下载预编译的二进制程序。
-
-## 使用方法
-
-### Lua 模块
-
-在 Lua 中使用月之脚本模块：
-
-* **用法 1**
-在 Lua 中引入 "你的脚本入口文件.yue"。
-```Lua
-require("yue")("你的脚本入口文件")
-```
-当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import** 进行脚本引用即可。错误消息中的代码行号也会被正确处理。
-
-* **用法 2**
-手动引入月之脚本模块并重写错误消息来帮助调试。
-```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**
-在 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"
-  }
-})
-```
-
-### 月之脚本编译工具
-
-使用月之脚本编译工具：
-```sh
-命令行用法: yue
-         [选项] [<文件/目录>] ...
-         yue -e <代码或文件> [参数...]
-         yue -w [<目录>] [选项]
-         yue -
-
-说明:
-   - '-' 或 '--' 必须作为唯一且第一个参数，用于读取标准输入。
-   - '-o/--output' 不能与多个输入文件一起使用。
-   - '-w/--watch' 仅能用于目录，不能用于单个文件。
-   - 使用 '-e/--execute' 时，后续的参数将作为脚本参数传递。
-
-选项:
-   -h, --help                 显示帮助信息并退出
-   -e <字符串>, --execute <字符串>  执行文件或原始代码
-   -m, --minify               生成压缩（最小化）代码
-   -r, --rewrite              重写输出以匹配原始代码行号
-   -t <目标路径>, --output-to <目标路径>
-                              指定编译后文件的输出路径
-   -o <文件>, --output <文件>  将输出写入文件
-   -p, --print                输出到标准输出
-   -b, --benchmark            输出编译耗时（不写入文件）
-   -g, --globals              显示用到的全局变量及其所在的名称、行号、列号
-   -s, --spaces               用空格代替制表符(tab)输出代码
-   -l, --line-numbers         输出源代码的行号
-   -j, --no-implicit-return   禁用文件末尾的隐式返回
-   -c, --reserve-comments     保留源代码中的注释
-   -w [<目录>], --watch [<目录>]
-                              监视目录变化并自动编译
-   -v, --version              显示版本信息
-   -                          从标准输入读取，输出到标准输出（仅能作为唯一参数）
-   --                         等同于 '-'，为兼容旧版本保留
-
-   --target <版本>            指定生成代码的 Lua 版本 (只能为 5.1 ~ 5.5)
-   --path <路径字符串>         附加一个 Lua 搜索路径到 package.path
-   --<键>=<值>                以 key=value 形式传递编译器选项（保持已有用法）
-
-   不带选项直接运行可进入交互模式（REPL），在交互模式里输入单独的符号 '$'
-   可用于开始或结束多行模式。
-```
-&emsp;&emsp;使用案例：
-&emsp;&emsp;递归编译当前路径下扩展名为 **.yue** 的每个月之脚本文件： **yue .**
-&emsp;&emsp;编译并将结果保存到目标路径： **yue -t /target/path/ .**
-&emsp;&emsp;编译并保留调试信息： **yue -l .**
-&emsp;&emsp;编译并生成压缩代码： **yue -m .**
-&emsp;&emsp;直接执行代码： **yue -e 'print 123'**
-&emsp;&emsp;执行一个月之脚本文件： **yue -e main.yue**
-
-## 宏
-
-### 常见用法
-
-宏函数用于在编译时执行一段代码来生成新的代码，并将生成的代码插入到最终编译结果中。
-
-```yuescript
-macro PI2 = -> math.pi * 2
-area = $PI2 * 5
-
-macro HELLO = -> "'你好 世界'"
-print $HELLO
-
-macro config = (debugging) ->
-  global debugMode = debugging == "true"
-  ""
-
-macro asserts = (cond) ->
-  debugMode and "assert #{cond}" or ""
-
-macro assert = (cond) ->
-  debugMode and "assert #{cond}" or "#{cond}"
-
-$config true
-$asserts item ~= nil
-
-$config false
-value = $assert item
-
--- 宏函数参数传递的表达式会被转换为字符串
-macro and = (...) -> "#{ table.concat {...}, ' and ' }"
-if $and f1!, f2!, f3!
-  print "OK"
-```
-<YueDisplay>
-
-```yue
-macro PI2 = -> math.pi * 2
-area = $PI2 * 5
-
-macro HELLO = -> "'你好 世界'"
-print $HELLO
-
-macro config = (debugging) ->
-  global debugMode = debugging == "true"
-  ""
-
-macro asserts = (cond) ->
-  debugMode and "assert #{cond}" or ""
-
-macro assert = (cond) ->
-  debugMode and "assert #{cond}" or "#{cond}"
-
-$config true
-$asserts item ~= nil
-
-$config false
-value = $assert item
-
--- 宏函数参数传递的表达式会被转换为字符串
-macro and = (...) -> "#{ table.concat {...}, ' and ' }"
-if $and f1!, f2!, f3!
-  print "OK"
-```
-
-</YueDisplay>
-
-### 直接插入代码
-
-宏函数可以返回一个包含月之脚本代码的字符串，或是一个包含 Lua 代码字符串的配置表。
-```yuescript
-macro yueFunc = (var) -> "local #{var} = ->"
-$yueFunc funcA
-funcA = -> "无法访问宏生成月之脚本里定义的变量"
-
-macro luaFunc = (var) -> {
-  code: "local function #{var}() end"
-  type: "lua"
-}
-$luaFunc funcB
-funcB = -> "无法访问宏生成 Lua 代码里定义的变量"
-
-macro lua = (code) -> {
-  :code
-  type: "lua"
-}
-
--- raw字符串的开始和结束符号会自动被去除了再传入宏函数
-$lua[==[
--- 插入原始Lua代码
-if cond then
-  print("输出")
-end
-]==]
-```
-<YueDisplay>
-
-```yue
-macro yueFunc = (var) -> "local #{var} = ->"
-$yueFunc funcA
-funcA = -> "无法访问宏生成月之脚本里定义的变量"
-
-macro luaFunc = (var) -> {
-  code: "local function #{var}() end"
-  type: "lua"
-}
-$luaFunc funcB
-funcB = -> "无法访问宏生成 Lua 代码里定义的变量"
-
-macro lua = (code) -> {
-  :code
-  type: "lua"
-}
-
--- raw字符串的开始和结束符号会自动被去除了再传入宏函数
-$lua[==[
--- 插入原始Lua代码
-if cond then
-  print("输出")
-end
-]==]
-```
-
-</YueDisplay>
-
-### 导出宏
-
-宏函数可以从一个模块中导出，并在另一个模块中导入。你必须将导出的宏函数放在一个单独的文件中使用，而且只有宏定义、宏导入和宏展开可以放入这个宏导出模块中。
-```yuescript
--- 文件: utils.yue
-export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
-export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
-export macro foreach = (items, action) -> "for _ in *#{items}
-  #{action}"
-
--- 文件 main.yue
-import "utils" as {
-  $, -- 表示导入所有宏的符号
-  $foreach: $each -- 重命名宏 $foreach 为 $each
-}
-[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
-```
-<YueDisplay>
-
-```yue
--- 文件: utils.yue
-export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
-export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
-export macro foreach = (items, action) -> "for _ in *#{items}
-  #{action}"
--- 文件 main.yue
--- 在浏览器中不支持import函数，请在真实环境中尝试
---[[
-import "utils" as {
-  $, -- 表示导入所有宏的符号
-  $foreach: $each -- 重命名宏 $foreach 为 $each
-}
-[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
-]]
-```
-
-</YueDisplay>
-
-### 内置宏
-
-月之脚本中有一些内置可以直接使用的宏，但你可以通过声明相同名称的宏来覆盖它们。
-```yuescript
-print $FILE -- 获取当前模块名称的字符串
-print $LINE -- 获取当前代码行数：2
-```
-<YueDisplay>
-
-```yue
-print $FILE -- 获取当前模块名称的字符串
-print $LINE -- 获取当前代码行数：2
-```
-
-</YueDisplay>
-
-### 用宏生成宏
-
-在月之脚本中，宏函数允许你在编译时生成代码。通过嵌套的宏函数，你可以创建更复杂的生成模式。这个特性允许你定义一个宏函数，用它来生成另一个宏函数，从而实现更加动态的代码生成。
-
-```yuescript
-macro Enum = (...) ->
-  items = {...}
-  itemSet = {item, true for item in *items}
-  (item) ->
-    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
-    "\"#{item}\""
-
-macro BodyType = $Enum(
-  Static
-  Dynamic
-  Kinematic
-)
-
-print "有效的枚举类型:", $BodyType Static
--- print "编译报错的枚举类型:", $BodyType Unknown
-```
-<YueDisplay>
-
-```yue
-macro Enum = (...) ->
-  items = {...}
-  itemSet = {item, true for item in *items}
-  (item) ->
-    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
-    "\"#{item}\""
-
-macro BodyType = $Enum(
-  Static
-  Dynamic
-  Kinematic
-)
-
-print "有效的枚举类型:", $BodyType Static
--- print "编译报错的枚举类型:", $BodyType Unknown
-```
-
-</YueDisplay>
-
-### 宏参数检查
-
-可以直接在参数列表中声明期望的 AST 节点类型，并在编译时检查传入的宏参数是否符合预期。
-
-```yuescript
-macro printNumAndStr = (num `Num, str `String) -> |
-  print(
-    #{num}
-    #{str}
-  )
-
-$printNumAndStr 123, "hello"
-```
-<YueDisplay>
-
-```yue
-macro printNumAndStr = (num `Num, str `String) -> |
-  print(
-    #{num}
-    #{str}
-  )
-
-$printNumAndStr 123, "hello"
-```
-
-</YueDisplay>
-
-如果需要做更加灵活的参数检查操作，可以使用内置的 `$is_ast` 宏函数在合适的位置进行手动检查。
-
-```yuescript
-macro printNumAndStr = (num, str) ->
-  error "expected Num as first argument" unless $is_ast Num, num
-  error "expected String as second argument" unless $is_ast String, str
-  "print(#{num}, #{str})"
-
-$printNumAndStr 123, "hello"
-```
-<YueDisplay>
-
-```yue
-macro printNumAndStr = (num, str) ->
-  error "expected Num as first argument" unless $is_ast Num, num
-  error "expected String as second argument" unless $is_ast String, str
-  "print(#{num}, #{str})"
-
-$printNumAndStr 123, "hello"
-```
-
-</YueDisplay>
-
-更多关于可用 AST 节点的详细信息，请参考 [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp) 中大写的规则定义。
-
-## 操作符
-
-Lua 的所有二元和一元操作符在月之脚本中都是可用的。此外，**!=** 符号是 **~=** 的别名，而 **\\** 或 **::** 均可用于编写链式函数调用，如写作 `tb\func!` 或 `tb::func!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
-
-```yuescript
-tb\func! if tb ~= nil
-tb::func! if tb != nil
-```
-<YueDisplay>
-
-```yue
-tb\func! if tb ~= nil
-tb::func! if tb != nil
-```
-
-</YueDisplay>
-
-### 链式比较
-
-你可以在月之脚本中进行比较表达式的链式书写：
-
-```yuescript
-print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
--- 输出：true
-
-a = 5
-print 1 <= a <= 10
--- 输出：true
-```
-<YueDisplay>
-
-```yue
-print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
--- 输出：true
-
-a = 5
-print 1 <= a <= 10
--- 输出：true
-```
-
-</YueDisplay>
-
-可以注意一下链式比较表达式的求值行为：
-
-```yuescript
-v = (x) ->
-  print x
-  x
-
-print v(1) < v(2) <= v(3)
---[[
-  输出：
-  2
-  1
-  3
-  true
-]]
-
-print v(1) > v(2) <= v(3)
---[[
-  输出：
-  2
-  1
-  false
-]]
-```
-<YueDisplay>
-
-```yue
-v = (x) ->
-  print x
-  x
-
-print v(1) < v(2) <= v(3)
---[[
-  输出：
-  2
-  1
-  3
-  true
-]]
-
-print v(1) > v(2) <= v(3)
---[[
-  输出：
-  2
-  1
-  false
-]]
-```
-
-</YueDisplay>
-
-在上面的例子里，中间的表达式 `v(2)` 仅被计算一次，如果把表达式写成 `v(1) < v(2) and v(2) <= v(3)` 的方式，中间的 `v(2)` 才会被计算两次。在链式比较中，求值的顺序往往是未定义的。所以强烈建议不要在链式比较中使用具有副作用（比如做打印操作）的表达式。如果需要使用有副作用的函数，应明确使用短路 `and` 运算符来做连接。
-
-### 表追加
-
-**[] =** 操作符用于向 Lua 表的最后插入值。
-
-```yuescript
-tab = []
-tab[] = "Value"
-```
-<YueDisplay>
-
-```yue
-tab = []
-tab[] = "Value"
-```
-
-</YueDisplay>
-
-你还可以使用展开操作符 `...` 来将一个列表中的所有元素追加到另一个列表中：
-
-```yuescript
-tbA = [1, 2, 3]
-tbB = [4, 5, 6]
-tbA[] = ...tbB
--- tbA 现在为 [1, 2, 3, 4, 5, 6]
-```
-<YueDisplay>
-
-```yue
-tbA = [1, 2, 3]
-tbB = [4, 5, 6]
-tbA[] = ...tbB
--- tbA 现在为 [1, 2, 3, 4, 5, 6]
-```
-
-</YueDisplay>
-
-### 表扩展
-
-你可以使用前置 `...` 操作符在 Lua 表中插入数组表或哈希表。
-
-```yuescript
-parts =
-  * "shoulders"
-  * "knees"
-lyrics =
-  * "head"
-  * ...parts
-  * "and"
-  * "toes"
-
-copy = {...other}
-
-a = {1, 2, 3, x: 1}
-b = {4, 5, y: 1}
-merge = {...a, ...b}
-```
-<YueDisplay>
-
-```yue
-parts =
-  * "shoulders"
-  * "knees"
-lyrics =
-  * "head"
-  * ...parts
-  * "and"
-  * "toes"
-
-copy = {...other}
-
-a = {1, 2, 3, x: 1}
-b = {4, 5, y: 1}
-merge = {...a, ...b}
-```
-
-</YueDisplay>
-
-### 表反向索引
-
-你可以使用 **#** 操作符来反向索引表中的元素。
-
-```yuescript
-last = data.items[#]
-second_last = data.items[#-1]
-data.items[#] = 1
-```
-<YueDisplay>
-
-```yue
-last = data.items[#]
-second_last = data.items[#-1]
-data.items[#] = 1
-```
-
-</YueDisplay>
-
-### 元表
-
-**<>** 操作符可提供元表操作的快捷方式。
-
-* **元表创建**
-使用空括号 **<>** 或被 **<>** 包围的元方法键创建普通的 Lua 表。
-
-```yuescript
-mt = {}
-add = (right) => <>: mt, value: @value + right.value
-mt.__add = add
-
-a = <>: mt, value: 1
--- 使用与临时变量名相同的字段名，将临时变量赋值给元表
-b = :<add>, value: 2
-c = <add>: mt.__add, value: 3
-
-d = a + b + c
-print d.value
-
-close _ = <close>: -> print "超出范围"
-```
-<YueDisplay>
-
-```yue
-mt = {}
-add = (right) => <>: mt, value: @value + right.value
-mt.__add = add
-
-a = <>: mt, value: 1
--- 使用与临时变量名相同的字段名，将临时变量赋值给元表
-b = :<add>, value: 2
-c = <add>: mt.__add, value: 3
-
-d = a + b + c
-print d.value
-
-close _ = <close>: -> print "超出范围"
-```
-
-</YueDisplay>
-
-* **元表访问**
-使用 **<>** 或被 **<>** 包围的元方法名或在 **<>** 中编写某些表达式来访问元表。
-
-```yuescript
--- 使用包含字段 "value" 的元表创建
-tb = <"value">: 123
-tb.<index> = tb.<>
-print tb.value
-
-tb.<> = __index: {item: "hello"}
-print tb.item
-```
-<YueDisplay>
-
-
-```yue
--- 使用包含字段 "value" 的元表创建
-tb = <"value">: 123
-tb.<index> = tb.<>
-print tb.value
-tb.<> = __index: {item: "hello"}
-print tb.item
-```
-
-</YueDisplay>
-
-* **元表解构**
-使用被 **<>** 包围的元方法键解构元表。
-
-```yuescript
-{item, :new, :<close>, <index>: getter} = tb
-print item, new, close, getter
-```
-<YueDisplay>
-
-```yue
-{item, :new, :<close>, <index>: getter} = tb
-print item, new, close, getter
-```
-
-</YueDisplay>
-
-### 存在性
-
-**?** 运算符可以在多种上下文中用来检查存在性。
-
-```yuescript
-func?!
-print abc?["你好 世界"]?.xyz
-
-x = tab?.value
-len = utf8?.len or string?.len or (o) -> #o
-
-if print and x?
-  print x
-
-with? io.open "test.txt", "w"
-  \write "你好"
-  \close!
-```
-<YueDisplay>
-
-```yue
-func?!
-print abc?["你好 世界"]?.xyz
-
-x = tab?.value
-len = utf8?.len or string?.len or (o) -> #o
-
-if print and x?
-  print x
-
-with? io.open "test.txt", "w"
-  \write "你好"
-  \close!
-```
-
-</YueDisplay>
-
-### 管道
-
-与其使用一系列嵌套的函数调用，你还可以考虑使用运算符 **|>** 来传递值。
-
-```yuescript
-"你好" |> print
-1 |> print 2 -- 将管道项作为第一个参数插入
-2 |> print 1, _, 3 -- 带有占位符的管道
-
--- 多行的管道表达式
-readFile "example.txt"
-  |> extract language, {}
-  |> parse language
-  |> emit
-  |> render
-  |> print
-```
-<YueDisplay>
-
-```yue
-"你好" |> print
-1 |> print 2 -- 将管道项作为第一个参数插入
-2 |> print 1, _, 3 -- 带有占位符的管道
--- 多行的管道表达式
-readFile "example.txt"
-  |> extract language, {}
-  |> parse language
-  |> emit
-  |> render
-  |> print
-```
-
-</YueDisplay>
-
-### 空值合并
-
-如果其左操作数不是 **nil**，则nil合并运算符 **??** 返回其左操作数的值；否则，它将计算右操作数并返回其结果。如果左操作数计算结果为非 nil 的值，**??** 运算符将不再计算其右操作数。
-```yuescript
-local a, b, c, d
-a = b ?? c ?? d
-func a ?? {}
-
-a ??= false
-```
-<YueDisplay>
-
-```yue
-local a, b, c, d
-a = b ?? c ?? d
-func a ?? {}
-a ??= false
-```
-
-</YueDisplay>
-
-### 隐式对象
-
-你可以在表格块内使用符号 **\*** 或是 **-** 开始编写一系列隐式结构。如果你正在创建隐式对象，对象的字段必须具有相同的缩进。
-
-```yuescript
--- 赋值时使用隐式对象
-list =
-  * 1
-  * 2
-  * 3
-
--- 函数调用时使用隐式对象
-func
-  * 1
-  * 2
-  * 3
-
--- 返回时使用隐式对象
-f = ->
-  return
-    * 1
-    * 2
-    * 3
-
--- 表格时使用隐式对象
-tb =
-  name: "abc"
-
-  values:
-    - "a"
-    - "b"
-    - "c"
-
-  objects:
-    - name: "a"
-      value: 1
-      func: => @value + 1
-      tb:
-        fieldA: 1
-
-    - name: "b"
-      value: 2
-      func: => @value + 2
-      tb: { }
-```
-<YueDisplay>
-
-```yue
--- 赋值时使用隐式对象
-list =
-  * 1
-  * 2
-  * 3
-
--- 函数调用时使用隐式对象
-func
-  * 1
-  * 2
-  * 3
-
--- 返回时使用隐式对象
-f = ->
-  return
-    * 1
-    * 2
-    * 3
-
--- 表格时使用隐式对象
-tb =
-  name: "abc"
-
-  values:
-    - "a"
-    - "b"
-    - "c"
-
-  objects:
-    - name: "a"
-      value: 1
-      func: => @value + 1
-      tb:
-        fieldA: 1
-
-    - name: "b"
-      value: 2
-      func: => @value + 2
-      tb: { }
-```
-
-</YueDisplay>
-
-## 模块
-
-### 导入
-
-导入语句是一个语法糖，用于需要引入一个模块或者从已导入的模块中提取子项目。从模块导入的变量默认为不可修改的常量。
-
-```yuescript
--- 用作表解构
-do
-  import insert, concat from table
-  -- 当给 insert, concat 变量赋值时，编译器会报告错误
-  import C, Ct, Cmt from require "lpeg"
-  -- 快捷写法引入模块的子项
-  import x, y, z from 'mymodule'
-  -- 使用Python风格的导入
-  from 'module' import a, b, c
-
--- 快捷地导入一个模块
-do
-  import 'module'
-  import 'module_x'
-  import "d-a-s-h-e-s"
-  import "module.part"
-
--- 导入模块后起一个别名使用，或是进行导入模块表的解构
-do
-  import "player" as PlayerModule
-  import "lpeg" as :C, :Ct, :Cmt
-  import "export" as {one, two, Something:{umm:{ch}}}
-```
-<YueDisplay>
-
-```yue
--- 用作表解构
-do
-  import insert, concat from table
-  -- 当给 insert, concat 变量赋值时，编译器会报告错误
-  import C, Ct, Cmt from require "lpeg"
-  -- 快捷写法引入模块的子项
-  import x, y, z from 'mymodule'
-  -- 使用Python风格的导入
-  from 'module' import a, b, c
-
--- 快捷地导入一个模块
-do
-  import 'module'
-  import 'module_x'
-  import "d-a-s-h-e-s"
-  import "module.part"
-
--- 导入模块后起一个别名使用，或是进行导入模块表的解构
-do
-  import "player" as PlayerModule
-  import "lpeg" as :C, :Ct, :Cmt
-  import "export" as {one, two, Something:{umm:{ch}}}
-```
-
-</YueDisplay>
-
-### 导入全局变量
-
-你可以使用 `import` 将指定的全局变量导入到本地变量中。当导入一系列对全局变量的链式访问时，最后一个访问的字段将被赋值给本地变量。
-
-```yuescript
-do
-  import tostring
-  import table.concat
-  print concat ["a", tostring 1]
-```
-<YueDisplay>
-
-```yue
-do
-  import tostring
-  import table.concat
-  print concat ["a", tostring 1]
-```
-
-</YueDisplay>
-
-#### 自动导入
-
-在一个代码块的顶部写 `import global`，会将当前作用域中尚未显式声明或赋值过的变量名，自动导入为本地常量，并在该语句的位置绑定到同名的全局变量。
-
-但是在同一作用域中被显式声明为全局的变量不会被自动导入，因此可以继续进行赋值操作。
-
-```yuescript
-do
-  import global
-  print "hello"
-  math.random 3
-  -- print = nil -- 报错：自动导入的全局变量为常量
-
-do
-  -- 被显式声明为全局的变量不会被自动导入
-  import global
-  global FLAG
-  print FLAG
-  FLAG = 123
-```
-<YueDisplay>
-
-```yue
-do
-  import global
-  print "hello"
-  math.random 3
-  -- print = nil -- 报错：自动导入的全局变量是常量
-
-do
-  -- 被显式声明为全局的变量不会被自动导入
-  import global
-  global FLAG
-  print FLAG
-  FLAG = 123
-```
-
-</YueDisplay>
-
-### 导出
-
-导出语句提供了一种简洁的方式来定义当前的模块。
-
-* **命名导出**
-带命名的导出将定义一个局部变量，并在导出的表中添加一个同名的字段。
-
-```yuescript
-export a, b, c = 1, 2, 3
-export cool = "cat"
-
-export What = if this
-  "abc"
-else
-  "def"
-
-export y = ->
-  hallo = 3434
-
-export class Something
-  umm: "cool"
-```
-<YueDisplay>
-
-```yue
-export a, b, c = 1, 2, 3
-export cool = "cat"
-
-export What = if this
-  "abc"
-else
-  "def"
-
-export y = ->
-  hallo = 3434
-
-export class Something
-  umm: "cool"
-```
-
-</YueDisplay>
-
-使用解构进行命名导出。
-
-```yuescript
-export :loadstring, to_lua: tolua = yue
-export {itemA: {:fieldA = '默认值'}} = tb
-```
-<YueDisplay>
-
-```yue
-export :loadstring, to_lua: tolua = yue
-export {itemA: {:fieldA = '默认值'}} = tb
-```
-
-</YueDisplay>
-
-从模块导出命名项目时，可以不用创建局部变量。
-
-```yuescript
-export.itemA = tb
-export.<index> = items
-export["a-b-c"] = 123
-```
-<YueDisplay>
-
-```yue
-export.itemA = tb
-export.<index> = items
-export["a-b-c"] = 123
-```
-
-</YueDisplay>
-
-* **未命名导出**
-未命名导出会将要导出的目标项目添加到导出表的数组部分。
-
-```yuescript
-d, e, f = 3, 2, 1
-export d, e, f
-
-export if this
-  123
-else
-  456
-
-export with tmp
-  j = 2000
-```
-<YueDisplay>
-
-```yue
-d, e, f = 3, 2, 1
-export d, e, f
-
-export if this
-  123
-else
-  456
-
-export with tmp
-  j = 2000
-```
-
-</YueDisplay>
-
-* **默认导出**
-在导出语句中使用 **default** 关键字，来替换导出的表为一个目标的对象。
-
-```yuescript
-export default ->
-  print "你好"
-  123
-```
-<YueDisplay>
-
-```yue
-export default ->
-  print "你好"
-  123
-```
-
-</YueDisplay>
-
-## 赋值
-
-月之脚本中定义的变量是动态类型的，并默认为局部变量。但你可以通过 **local** 和 **global** 声明来改变声明变量的作用范围。
-
-```yuescript
-hello = "world"
-a, b, c = 1, 2, 3
-hello = 123 -- 访问现有的变量
-```
-<YueDisplay>
-
-```yue
-hello = "world"
-a, b, c = 1, 2, 3
-hello = 123 -- 访问现有的变量
-```
-
-</YueDisplay>
-
-### 执行更新
-
-你可以使用各式二进制运算符执行更新赋值。
-```yuescript
-x = 1
-x += 1
-x -= 1
-x *= 10
-x /= 10
-x %= 10
-s ..= "world" -- 如果执行更新的局部变量不存在，将新建一个局部变量
-arg or= "默认值"
-```
-<YueDisplay>
-
-```yue
-x = 1
-x += 1
-x -= 1
-x *= 10
-x /= 10
-x %= 10
-s ..= "world" -- 如果执行更新的局部变量不存在，将新建一个局部变量
-arg or= "默认值"
-```
-
-</YueDisplay>
-
-### 链式赋值
-
-你可以进行链式赋值，将多个项目赋予相同的值。
-```yuescript
-a = b = c = d = e = 0
-x = y = z = f!
-```
-<YueDisplay>
-
-```yue
-a = b = c = d = e = 0
-x = y = z = f!
-```
-
-</YueDisplay>
-
-### 显式声明局部变量
-```yuescript
-do
-  local a = 1
-  local *
-  print "预先声明后续所有变量为局部变量"
-  x = -> 1 + y + z
-  y, z = 2, 3
-  global instance = Item\new!
-
-do
-  local X = 1
-  local ^
-  print "只预先声明后续大写的变量为局部变量"
-  a = 1
-  B = 2
-```
-<YueDisplay>
-
-```yue
-do
-  local a = 1
-  local *
-  print "预先声明后续所有变量为局部变量"
-  x = -> 1 + y + z
-  y, z = 2, 3
-  global instance = Item\new!
-
-do
-  local X = 1
-  local ^
-  print "只预先声明后续大写的变量为局部变量"
-  a = 1
-  B = 2
-```
-
-</YueDisplay>
-
-### 显式声明全局变量
-```yuescript
-do
-  global a = 1
-  global *
-  print "预先声明所有变量为全局变量"
-  x = -> 1 + y + z
-  y, z = 2, 3
-
-do
-  global x = 1
-  global ^
-  print "只预先声明大写的变量为全局变量"
-  a = 1
-  B = 2
-  local Temp = "一个局部值"
-```
-<YueDisplay>
-
-```yue
-do
-  global a = 1
-  global *
-  print "预先声明所有变量为全局变量"
-  x = -> 1 + y + z
-  y, z = 2, 3
-
-do
-  global x = 1
-  global ^
-  print "只预先声明大写的变量为全局变量"
-  a = 1
-  B = 2
-  local Temp = "一个局部值"
-```
-
-</YueDisplay>
-
-## 解构赋值
-
-解构赋值是一种快速从 Lua 表中按名称或基于数组中的位置提取值的方法。
-
-通常当你看到一个字面量的 Lua 表，比如 `{1,2,3}`，它位于赋值的右侧，因为它是一个值。解构赋值语句的写法就是交换了字面量 Lua 表的角色，并将其放在赋值语句的左侧。
-
-最好是通过示例来解释。以下是如何从表格中解包前两个值的方法：
-
-```yuescript
-thing = [1, 2]
-
-[a, b] = thing
-print a, b
-```
-<YueDisplay>
-
-
-```yue
-thing = [1, 2]
-
-[a, b] = thing
-print a, b
-```
-
-</YueDisplay>
-
-在解构表格字面量中，键代表从右侧读取的键，值代表读取的值将被赋予的名称。
-
-```yuescript
-obj = {
-  hello: "world"
-  day: "tuesday"
-  length: 20
-}
-
-{hello: hello, day: the_day} = obj
-print hello, the_day
-
-:day = obj -- 可以不带大括号进行简单的解构
-```
-<YueDisplay>
-
-```yue
-obj = {
-  hello: "world"
-  day: "tuesday"
-  length: 20
-}
-
-{hello: hello, day: the_day} = obj
-print hello, the_day
-
-:day = obj -- 可以不带大括号进行简单的解构
-```
-
-</YueDisplay>
-
-这也适用于嵌套的数据结构：
-
-```yuescript
-obj2 = {
-  numbers: [1,2,3,4]
-  properties: {
-    color: "green"
-    height: 13.5
-  }
-}
-
-{numbers: [first, second], properties: {color: color}} = obj2
-print first, second, color
-```
-<YueDisplay>
-
-```yue
-obj2 = {
-  numbers: [1,2,3,4]
-  properties: {
-    color: "green"
-    height: 13.5
-  }
-}
-
-{numbers: [first, second]} = obj2
-print first, second, color
-```
-
-</YueDisplay>
-
-如果解构语句很复杂，也可以任意将其分散在几行中。稍微复杂一些的示例：
-
-```yuescript
-{
-  numbers: [first, second]
-  properties: {
-    color: color
-  }
-} = obj2
-```
-<YueDisplay>
-
-```yue
-{
-  numbers: [first, second]
-  properties: {
-    color: color
-  }
-} = obj2
-```
-
-</YueDisplay>
-
-有时候我们会需要从 Lua 表中提取值并将它们赋给与键同名的局部变量。为了避免编写重复代码，我们可以使用 **:** 前缀操作符：
-
-```yuescript
-{:concat, :insert} = table
-```
-<YueDisplay>
-
-```yue
-{:concat, :insert} = table
-```
-
-</YueDisplay>
-
-这样的用法与导入语法有些相似。但我们可以通过混合语法重命名我们想要提取的字段：
-
-```yuescript
-{:mix, :max, random: rand} = math
-```
-<YueDisplay>
-
-```yue
-{:mix, :max, random: rand} = math
-```
-
-</YueDisplay>
-
-在进行解构时，你可以指定默认值，如：
-
-```yuescript
-{:name = "nameless", :job = "jobless"} = person
-```
-<YueDisplay>
-
-```yue
-{:name = "nameless", :job = "jobless"} = person
-```
-
-</YueDisplay>
-
-在进行列表解构时，你可以使用`_`作为占位符：
-
-```yuescript
-[_, two, _, four] = items
-```
-<YueDisplay>
-
-```yue
-[_, two, _, four] = items
-```
-
-</YueDisplay>
-
-### 范围解构
-
-你可以使用展开运算符 `...` 在列表解构中来捕获一个范围的值到子列表中。这在当你想要从列表的开头和结尾提取特定元素，同时收集中间的元素时非常有用。
-
-```yuescript
-orders = ["first", "second", "third", "fourth", "last"]
-[first, ...bulk, last] = orders
-print first  -- 打印: first
-print bulk   -- 打印: {"second", "third", "fourth"}
-print last   -- 打印: last
-```
-<YueDisplay>
-
-```yue
-orders = ["first", "second", "third", "fourth", "last"]
-[first, ...bulk, last] = orders
-print first  -- 打印: first
-print bulk   -- 打印: {"second", "third", "fourth"}
-print last   -- 打印: last
-```
-
-</YueDisplay>
-
-展开运算符可以用在不同的位置来捕获不同的范围，并且你可以使用 `_` 作为占位符来表示你想跳过对应范围的捕获：
-
-```yuescript
--- 捕获第一个元素之后的所有元素
-[first, ...rest] = orders
-
--- 捕获最后一个元素之前的所有元素
-[...start, last] = orders
-
--- 跳过中间的元素，只捕获第一个和最后一个元素
-[first, ..._, last] = orders
-```
-<YueDisplay>
-
-```yue
--- 捕获第一个元素之后的所有元素
-[first, ...rest] = orders
-
--- 捕获最后一个元素之前的所有元素
-[...start, last] = orders
-
--- 跳过中间的元素，只捕获第一个和最后一个元素
-[first, ..._, last] = orders
-```
-
-</YueDisplay>
-
-### 在其它地方的解构赋值
-
-解构赋值也可以出现在其它隐式进行赋值的地方。一个例子是用在 for 循环中：
-
-```yuescript
-tuples = [
-  ["hello", "world"]
-  ["egg", "head"]
-]
-
-for [left, right] in *tuples
-  print left, right
-```
-<YueDisplay>
-
-```yue
-tuples = [
-  ["hello", "world"]
-  ["egg", "head"]
-]
-
-for [left, right] in *tuples
-  print left, right
-```
-
-</YueDisplay>
-
-我们知道数组表中的每个元素都是一个两项的元组，所以我们可以直接在 for 语句的名称子句中使用解构来解包它。
-
-## If 赋值
-
-`if` 和 `elseif` 代码块可以在条件表达式的位置进行赋值。在代码执行到要计算条件时，会首先进行赋值计算，并使用赋与的值作为分支判断的条件。赋值的变量仅在条件分支的代码块内有效，这意味着如果值不是真值，那么它就不会被用到。注意，你必须使用“海象运算符” `:=` 而不是 `=` 来做赋值。
-
-```yuescript
-if user := database.find_user "moon"
-  print user.name
-```
-<YueDisplay>
-
-```yue
-if user := database.find_user "moon"
-  print user.name
-```
-
-</YueDisplay>
-
-```yuescript
-if hello := os.getenv "hello"
-  print "你有 hello", hello
-elseif world := os.getenv "world"
-  print "你有 world", world
-else
-  print "什么都没有 :("
-```
-<YueDisplay>
-
-```yue
-if hello := os.getenv "hello"
-  print "你有 hello", hello
-elseif world := os.getenv "world"
-  print "你有 world", world
-else
-  print "什么都没有 :("
-```
-
-</YueDisplay>
-
-使用多个返回值的 If 赋值。只有第一个值会被检查，其他值都有同样的作用域。
-```yuescript
-if success, result := pcall -> "无报错地获取结果"
-  print result -- 变量 result 是有作用域的
-print "好的"
-```
-<YueDisplay>
-
-```yue
-if success, result := pcall -> "无报错地获取结果"
-  print result -- 变量 result 是有作用域的
-print "好的"
-```
-
-</YueDisplay>
-
-### While 赋值
-
-你可以在 while 循环中同样使用赋值来获取循环条件的值。
-```yuescript
-while byte := stream\read_one!
-  -- 对 byte 做一些操作
-  print byte
-```
-<YueDisplay>
-
-```yue
-while byte := stream\read_one!
-  -- 对 byte 做一些操作
-  print byte
-```
-
-</YueDisplay>
-
-## 可变参数赋值
-
-你可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用 Lua 的方式访问其内容。
-```yuescript
-list = [1, 2, 3, 4, 5]
-fn = (ok) -> ok, table.unpack list
-ok, ... = fn true
-count = select '#', ...
-first = select 1, ...
-print ok, count, first
-```
-<YueDisplay>
-
-```yue
-list = [1, 2, 3, 4, 5]
-fn = (ok) -> ok, table.unpack list
-ok, ... = fn true
-count = select '#', ...
-first = select 1, ...
-print ok, count, first
-```
-
-</YueDisplay>
-
-## 空白
-
-月之脚本是一个对空白敏感的语言。你必须在相同的缩进中使用空格 **' '** 或制表符 **'\t'** 来编写一些代码块，如函数体、值列表和一些控制块。包含不同空白的表达式可能意味着不同的事情。制表符被视为4个空格，但最好不要混合使用空格和制表符。
-
-### 语句分隔符
-
-一条语句通常以换行结束。你也可以使用分号 `;` 显式结束一条语句，从而在同一行中编写多条语句：
-
-```yuescript
-a = 1; b = 2; print a + b
-```
-<YueDisplay>
-
-```yue
-a = 1; b = 2; print a + b
-```
-
-</YueDisplay>
-
-### 多行链式调用
-
-你可以使用相同的缩进来编写多行链式函数调用。
-```yuescript
-Rx.Observable
-  .fromRange 1, 8
-  \filter (x) -> x % 2 == 0
-  \concat Rx.Observable.of 'who do we appreciate'
-  \map (value) -> value .. '!'
-  \subscribe print
-```
-<YueDisplay>
-
-```yue
-Rx.Observable
-  .fromRange 1, 8
-  \filter (x) -> x % 2 == 0
-  \concat Rx.Observable.of 'who do we appreciate'
-  \map (value) -> value .. '!'
-  \subscribe print
-```
-
-</YueDisplay>
-
-## 注释
-
-```yuescript
--- 我是一个注释
-
-str = --[[
-这是一个多行注释。
-没问题。
-]] strA \ -- 注释 1
-  .. strB \ -- 注释 2
-  .. strC
-
-func --[[端口]] 3000, --[[ip]] "192.168.1.1"
-```
-<YueDisplay>
-
-```yue
--- 我是一个注释
-
-str = --[[
-这是一个多行注释。
-没问题。
-]] strA \ -- 注释 1
-  .. strB \ -- 注释 2
-  .. strC
-
-func --[[端口]] 3000, --[[ip]] "192.168.1.1"
-```
-
-</YueDisplay>
-
-## 错误处理
-
-用于统一进行 Lua 错误处理的便捷语法。
-
-```yuescript
-try
-  func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try
-  func 1, 2, 3
-catch err
-  yue.traceback err
-
-try func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try func 1, 2, 3
-
-try
-  print "尝试中"
-  func 1, 2, 3
-
--- 使用if赋值模式
-if success, result := try func 1, 2, 3
-catch err
-    print yue.traceback err
-  print result
-```
-<YueDisplay>
-
-```yue
-try
-  func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try
-  func 1, 2, 3
-catch err
-  yue.traceback err
-
-try func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try func 1, 2, 3
-
-try
-  print "尝试中"
-  func 1, 2, 3
-
--- 使用if赋值模式
-if success, result := try func 1, 2, 3
-catch err
-    print yue.traceback err
-  print result
-```
-
-</YueDisplay>
-
-### 错误处理简化
-
-`try?` 是 `try` 的功能简化语法，它不再返回 `try` 语句的布尔状态，并在成功时直接返回 `try` 代码块的结果，失败时返回 `nil` 值而非错误对象。
-
-```yuescript
-a, b, c = try? func!
-
--- 与空值合并运算符一起使用
-a = (try? func!) ?? "default"
-
--- 作为函数参数
-f try? func!
-
--- 带 catch 块的 try!
-f try?
-  print 123
-  func!
-catch e
-  print e
-  e
-```
-<YueDisplay>
-
-```yue
-a, b, c = try? func!
-
--- 与空值合并运算符一起使用
-a = (try? func!) ?? "default"
-
--- 作为函数参数
-f try? func!
-
--- 带 catch 块的 try!
-f try?
-  print 123
-  func!
-catch e
-  print e
-  e
-```
-
-</YueDisplay>
-
-## 属性
-
-月之脚本现在提供了 Lua 5.4 新增的叫做属性的语法支持。在月之脚本编译到的 Lua 目标版本低于 5.4 时，你仍然可以同时使用`const` 和 `close` 的属性声明语法，并获得常量检查和作用域回调的功能。
-
-```yuescript
-const a = 123
-close _ = <close>: -> print "超出范围。"
-```
-<YueDisplay>
-
-```yue
-const a = 123
-close _ = <close>: -> print "超出范围。"
-```
-
-</YueDisplay>
-
-你可以对进行解构得到的变量标记为常量。
-
-```yuescript
-const {:a, :b, c, d} = tb
--- a = 1
-```
-<YueDisplay>
-
-```yue
-const {:a, :b, c, d} = tb
--- a = 1
-```
-
-</YueDisplay>
-
-你也可以声明全局变量为常量。
-
-```yuescript
-global const Constant = 123
--- Constant = 1
-```
-<YueDisplay>
-
-```yue
-global const Constant = 123
--- Constant = 1
-```
-
-</YueDisplay>
-
-## 字面量
-
-Lua 中的所有基本字面量都可以在月之脚本中使用。包括数字、字符串、布尔值和 **nil**。
-
-但与 Lua 不同的是，单引号和双引号字符串内部允许有换行：
-
-```yuescript
-some_string = "这是一个字符串
-  并包括一个换行。"
-
--- 使用#{}语法可以将表达式插入到字符串字面量中。
--- 字符串插值只在双引号字符串中可用。
-print "我有#{math.random! * 100}%的把握。"
-```
-<YueDisplay>
-
-```yue
-some_string = "这是一个字符串
-  并包括一个换行。"
-
--- 使用#{}语法可以将表达式插入到字符串字面量中。
--- 字符串插值只在双引号字符串中可用。
-print "我有#{math.random! * 100}%的把握。"
-```
-
-</YueDisplay>
-
-### 数字字面量
-
-你可以在数字字面量中使用下划线来增加可读性。
-
-```yuescript
-integer = 1_000_000
-hex = 0xEF_BB_BF
-binary = 0B10011
-```
-<YueDisplay>
-
-
-```yue
-integer = 1_000_000
-hex = 0xEF_BB_BF
-binary = 0B10011
-```
-
-</YueDisplay>
-
-### YAML 风格字符串
-
-使用 `|` 前缀标记一个多行 YAML 风格字符串：
-
-```yuescript
-str = |
-  key: value
-  list:
-    - item1
-    - #{expr}
-```
-<YueDisplay>
-
-```yue
-str = |
-  key: value
-  list:
-    - item1
-    - #{expr}
-```
-
-</YueDisplay>
-
-其效果类似于原生 Lua 的多行拼接，所有文本（含换行）将被保留下来，并支持 `#{...}` 语法，通过 `tostring(expr)` 插入表达式结果。
-
-YAML 风格的多行字符串会自动检测首行后最小的公共缩进，并从所有行中删除该前缀空白字符。这让你可以在代码中对齐文本，但输出字符串不会带多余缩进。
-
-```yuescript
-fn = ->
-  str = |
-    foo:
-      bar: baz
-  return str
-```
-<YueDisplay>
-
-```yue
-fn = ->
-  str = |
-    foo:
-      bar: baz
-  return str
-```
-
-</YueDisplay>
-
-输出字符串中的 foo: 对齐到行首，不会带有函数缩进空格。保留内部缩进的相对结构，适合书写结构化嵌套样式的内容。
-
-支持自动处理字符中的引号、反斜杠等特殊符号，无需手动转义：
-
-```yuescript
-str = |
-  path: "C:\Program Files\App"
-  note: 'He said: "#{Hello}!"'
-```
-<YueDisplay>
-
-```yue
-str = |
-  path: "C:\Program Files\App"
-  note: 'He said: "#{Hello}!"'
-```
-
-</YueDisplay>
-
-## 函数字面量
-
-所有函数都是使用月之脚本的函数表达式创建的。一个简单的函数可以用箭头表示为：**->**。
-
-```yuescript
-my_function = ->
-my_function() -- 调用空函数
-```
-<YueDisplay>
-
-```yue
-my_function = ->
-my_function() -- 调用空函数
-```
-
-</YueDisplay>
-
-函数体可以是紧跟在箭头后的一个语句，或者是在后面的行上使用同样缩进的一系列语句：
-
-```yuescript
-func_a = -> print "你好，世界"
-
-func_b = ->
-  value = 100
-  print "这个值是：", value
-```
-<YueDisplay>
-
-```yue
-func_a = -> print "你好，世界"
-
-func_b = ->
-  value = 100
-  print "这个值是：", value
-```
-
-</YueDisplay>
-
-如果一个函数没有参数，可以使用 **\!** 操作符调用它，而不是空括号。使用 **\!** 调用没有参数的函数是推荐的写法。
-
-```yuescript
-func_a!
-func_b()
-```
-<YueDisplay>
-
-```yue
-func_a!
-func_b()
-```
-
-</YueDisplay>
-
-带有参数的函数可以通过在箭头前加上括号中的参数名列表来进行创建：
-
-```yuescript
-sum = (x, y) -> print "数字的和", x + y
-```
-<YueDisplay>
-
-```yue
-sum = (x, y) -> print "数字的和", x + y
-```
-
-</YueDisplay>
-
-函数可以通过在函数名后列出参数来调用。当对函数做嵌套的调用时，后面列出的参数会应用于左侧最近的函数。
-
-```yuescript
-sum 10, 20
-print sum 10, 20
-
-a b c "a", "b", "c"
-```
-<YueDisplay>
-
-```yue
-sum 10, 20
-print sum 10, 20
-
-a b c "a", "b", "c"
-```
-
-</YueDisplay>
-
-为了避免在调用函数时产生歧义，也可以使用括号将参数括起来。比如在以下的例子中是必需的，这样才能确保参数被传入到正确的函数。
-
-```yuescript
-print "x:", sum(10, 20), "y:", sum(30, 40)
-```
-<YueDisplay>
-
-```yue
-print "x:", sum(10, 20), "y:", sum(30, 40)
-```
-
-</YueDisplay>
-
-注意：函数名与开始括号之间不能有任何空格。
-
-函数会将函数体中的最后一个语句强制转换为返回语句，这被称作隐式返回：
-
-```yuescript
-sum = (x, y) -> x + y
-print "数字的和是", sum 10, 20
-```
-<YueDisplay>
-
-```yue
-sum = (x, y) -> x + y
-print "数字的和是", sum 10, 20
-```
-
-</YueDisplay>
-
-如果你需要做显式返回，可以使用 return 关键字：
-
-```yuescript
-sum = (x, y) -> return x + y
-```
-<YueDisplay>
-
-```yue
-sum = (x, y) -> return x + y
-```
-
-</YueDisplay>
-
-就像在Lua中一样，函数可以返回多个值。最后一个语句必须是由逗号分隔的值列表：
-
-```yuescript
-mystery = (x, y) -> x + y, x - y
-a, b = mystery 10, 20
-```
-<YueDisplay>
-
-```yue
-mystery = (x, y) -> x + y, x - y
-a, b = mystery 10, 20
-```
-
-</YueDisplay>
-
-### 粗箭头
-
-因为在 Lua 中调用方法时，经常习惯将对象作为第一个参数传入，所以月之脚本提供了一种特殊的语法来创建自动包含 self 参数的函数。
-
-```yuescript
-func = (num) => @value + num
-```
-<YueDisplay>
-
-```yue
-func = (num) => @value + num
-```
-
-</YueDisplay>
-
-### 参数默认值
-
-可以为函数的参数提供默认值。如果参数的值为 nil，则确定该参数为空。任何具有默认值的 nil 参数在函数体运行之前都会被替换。
-
-```yuescript
-my_function = (name = "某物", height = 100) ->
-  print "你好，我是", name
-  print "我的高度是", height
-```
-<YueDisplay>
-
-```yue
-my_function = (name = "某物", height = 100) ->
-  print "你好，我是", name
-  print "我的高度是", height
-```
-
-</YueDisplay>
-
-函数参数的默认值表达式在函数体中会按参数声明的顺序进行计算。因此，在默认值的表达式中可以访问先前声明的参数。
-
-```yuescript
-some_args = (x = 100, y = x + 1000) ->
-  print x + y
-```
-<YueDisplay>
-
-```yue
-some_args = (x = 100, y = x + 1000) ->
-  print x + y
-```
-
-</YueDisplay>
-
-### 多行参数
-
-当调用接收大量参数的函数时，将参数列表分成多行是很方便的。由于月之脚本语言对空白字符的敏感性，做参数列表的分割时务必要小心。
-
-如果要将参数列表写到下一行，那么当前行必须以逗号结束。并且下一行的缩进必须比当前的缩进多。一旦做了参数的缩进，所有其他参数列表的行必须保持相同的缩进级别，以成为参数列表的一部分。
-
-```yuescript
-my_func 5, 4, 3,
-  8, 9, 10
-
-cool_func 1, 2,
-  3, 4,
-  5, 6,
-  7, 8
-```
-<YueDisplay>
-
-```yue
-my_func 5, 4, 3,
-  8, 9, 10
-
-cool_func 1, 2,
-  3, 4,
-  5, 6,
-  7, 8
-```
-
-</YueDisplay>
-
-这种调用方式可以做嵌套。并通过缩进级别来确定参数属于哪一个函数。
-
-```yuescript
-my_func 5, 6, 7,
-  6, another_func 6, 7, 8,
-    9, 1, 2,
-  5, 4
-```
-<YueDisplay>
-
-```yue
-my_func 5, 6, 7,
-  6, another_func 6, 7, 8,
-    9, 1, 2,
-  5, 4
-```
-
-</YueDisplay>
-
-因为 Lua 表也使用逗号作为分隔符，这种缩进语法有助于让值成为参数列表的一部分，而不是 Lua 表的一部分。
-
-```yuescript
-x = [
-  1, 2, 3, 4, a_func 4, 5,
-    5, 6,
-  8, 9, 10
-]
-```
-<YueDisplay>
-
-```yue
-x = [
-  1, 2, 3, 4, a_func 4, 5,
-    5, 6,
-  8, 9, 10
-]
-```
-
-</YueDisplay>
-
-有个不常见的写法可以注意一下，如果我们将在后面使用较低的缩进，我们可以为函数参数提供更深的缩进来区分列表的归属。
-
-```yuescript
-y = [ my_func 1, 2, 3,
-   4, 5,
-  5, 6, 7
-]
-```
-<YueDisplay>
-
-```yue
-y = [ my_func 1, 2, 3,
-   4, 5,
-  5, 6, 7
-]
-```
-
-</YueDisplay>
-
-对于其它有代码块跟随的语句，比如条件语句，也可以通过小心安排缩进来做类似的事。比如我们可以通过调整缩进级别来控制一些值归属于哪个语句：
-
-```yuescript
-if func 1, 2, 3,
-  "你好",
-  "世界"
-    print "你好"
-    print "我在if内部"
-
-if func 1, 2, 3,
-    "你好",
-    "世界"
-  print "hello"
-  print "我在if内部"
-```
-<YueDisplay>
-
-```yue
-if func 1, 2, 3,
-  "你好",
-  "世界"
-    print "你好"
-    print "我在if内部"
-
-if func 1, 2, 3,
-    "你好",
-    "世界"
-  print "你好"
-  print "我在if内部"
-```
-
-</YueDisplay>
-
-### 参数解构
-
-月之脚本支持在函数形参位置对传入对象进行解构。适用两类解构表子面量：
-
-- 使用 {} 包裹的字面量/对象形参，支持提供获得空字段时的默认值（例如 {:a, :b}、{a: a1 = 123}）。
-
-- 无 {} 包裹、以键值/简写键序列开头，直至遇到其它表达式终止（例如 :a, b: b1, :c），表示从同一个对象中解构多个字段。
-
-```yuescript
-f1 = (:a, :b, :c) ->
-  print a, b, c
-
-f1 a: 1, b: "2", c: {}
-
-f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
-  print a1, b, c
-
-arg1 = {a: 0}
-f2 arg1, arg2
-```
-<YueDisplay>
-
-```yue
-f1 = (:a, :b, :c) ->
-  print a, b, c
-
-f1 a: 1, b: "2", c: {}
-
-f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
-  print a1, b, c
-
-arg1 = {a: 0}
-f2 arg1, arg2
-```
-
-</YueDisplay>
-
-### 前置返回表达式
-
-在深度嵌套的函数体中，为了提升返回值的可读性及编写便利性，我们新增了 “前置返回表达式” 语法。其形式如下：
-
-```yuescript
-findFirstEven = (list): nil ->
-  for item in *list
-    if type(item) == "table"
-      for sub in *item
-        if sub % 2 == 0
-          return sub
-```
-<YueDisplay>
-
-```yue
-findFirstEven = (list): nil ->
-  for item in *list
-    if type(item) == "table"
-      for sub in *item
-        if sub % 2 == 0
-          return sub
-```
-
-</YueDisplay>
-
-这个写法等价于：
-
-```yuescript
-findFirstEven = (list) ->
-  for item in *list
-    if type(item) == "table"
-      for sub in *item
-        if sub % 2 == 0
-          return sub
-  nil
-```
-<YueDisplay>
-
-```yue
-findFirstEven = (list) ->
-  for item in *list
-    if type(item) == "table"
-      for sub in *item
-        if sub % 2 == 0
-          return sub
-  nil
-```
-
-</YueDisplay>
-
-唯一的区别在于：你可以将函数的返回值表达式提前写在 `->` 或 `=>` 前，用以指示该函数应隐式返回该表达式的值。这样即使在多层循环或条件判断的场景下，也无需编写尾行悬挂的返回表达式，逻辑结构会更加直观清晰。
-
-### 命名变长参数
-
-你可以使用 `(...t) ->` 语法来将变长参数自动存储到一个命名表中。这个表会包含所有传入的参数（包括 `nil` 值），并且会在表的 `n` 字段中存储实际传入的参数个数（包括 `nil` 值在内的个数）。
-
-```yuescript
-f = (...t) ->
-  print "参数个数:", t.n
-  print "表长度:", #t
-  for i = 1, t.n
-    print t[i]
-
-f 1, 2, 3
-f "a", "b", "c", "d"
-f!
-
--- 处理包含 nil 的情况
-process = (...args) ->
-  sum = 0
-  for i = 1, args.n
-    if args[i] != nil and type(args[i]) == "number"
-      sum += args[i]
-  sum
-
-process 1, nil, 3, nil, 5
-```
-<YueDisplay>
-
-```yue
-f = (...t) ->
-  print "参数个数:", t.n
-  print "表长度:", #t
-  for i = 1, t.n
-    print t[i]
-
-f 1, 2, 3
-f "a", "b", "c", "d"
-f!
-
--- 处理包含 nil 的情况
-process = (...args) ->
-  sum = 0
-  for i = 1, args.n
-    if args[i] != nil and type(args[i]) == "number"
-      sum += args[i]
-  sum
-
-process 1, nil, 3, nil, 5
-```
-
-</YueDisplay>
-
-## 反向回调
-
-反向回调用于减少函数回调的嵌套。它们使用指向左侧的箭头，并且默认会被定义为传入后续函数调用的最后一个参数。它的语法大部分与常规箭头函数相同，只是它指向另一方向，并且后续的函数体不需要进行缩进。
-
-```yuescript
-<- f
-print "hello"
-```
-<YueDisplay>
-
-```yue
-<- f
-print "hello"
-```
-
-</YueDisplay>
-
-月之脚本也提供了粗箭头反向回调函数。
-
-```yuescript
-<= f
-print @value
-```
-<YueDisplay>
-
-```yue
-<= f
-print @value
-```
-
-</YueDisplay>
-
-你可以通过一个占位符指定回调函数的传参位置。
-
-```yuescript
-(x) <- map _, [1, 2, 3]
-x * 2
-```
-<YueDisplay>
-
-```yue
-(x) <- map _, [1, 2, 3]
-x * 2
-```
-
-</YueDisplay>
-
-如果你希望在反向回调处理后继续编写更多其它的代码，可以使用 do 语句将不属于反向回调的代码分隔开。对于非粗箭头函数的反向回调，回调返回值的括号也是可以省略的。
-
-```yuescript
-result, msg = do
-  data <- readAsync "文件名.txt"
-  print data
-  info <- processAsync data
-  check info
-print result, msg
-```
-<YueDisplay>
-
-```yue
-result, msg = do
-  data <- readAsync "文件名.txt"
-  print data
-  info <- processAsync data
-  check info
-print result, msg
-```
-
-</YueDisplay>
-
-## 表格字面量
-
-和 Lua 一样，表格可以通过花括号进行定义。
-
-```yuescript
-some_values = [1, 2, 3, 4]
-```
-<YueDisplay>
-
-```yue
-some_values = [1, 2, 3, 4]
-```
-
-</YueDisplay>
-
-但与Lua不同的是，给表格中的键赋值是用 **:**（而不是 **=**）。
-
-```yuescript
-some_values = {
-  name: "Bill",
-  age: 200,
-  ["favorite food"]: "rice"
-}
-```
-<YueDisplay>
-
-```yue
-some_values = {
-  name: "Bill",
-  age: 200,
-  ["favorite food"]: "rice"
-}
-```
-
-</YueDisplay>
-
-如果只分配一个键值对的表格，可以省略花括号。
-
-```yuescript
-profile =
-  height: "4英尺",
-  shoe_size: 13,
-  favorite_foods: ["冰淇淋", "甜甜圈"]
-```
-<YueDisplay>
-
-```yue
-profile =
-  height: "4英尺",
-  shoe_size: 13,
-  favorite_foods: ["冰淇淋", "甜甜圈"]
-```
-
-</YueDisplay>
-
-可以使用换行符而不使用逗号（或两者都用）来分隔表格中的值：
-
-```yuescript
-values = {
-  1, 2, 3, 4
-  5, 6, 7, 8
-  name: "超人"
-  occupation: "打击犯罪"
-}
-```
-<YueDisplay>
-
-```yue
-values = {
-  1, 2, 3, 4
-  5, 6, 7, 8
-  name: "超人"
-  occupation: "打击犯罪"
-}
-```
-
-</YueDisplay>
-
-创建单行表格字面量时，也可以省略花括号：
-
-```yuescript
-my_function dance: "探戈", partner: "无"
-
-y = type: "狗", legs: 4, tails: 1
-```
-<YueDisplay>
-
-```yue
-my_function dance: "探戈", partner: "无"
-
-y = type: "狗", legs: 4, tails: 1
-```
-
-</YueDisplay>
-
-表格字面量的键可以使用 Lua 语言的关键字，而无需转义：
-
-```yuescript
-tbl = {
-  do: "某事"
-  end: "饥饿"
-}
-```
-<YueDisplay>
-
-```yue
-tbl = {
-  do: "某事"
-  end: "饥饿"
-}
-```
-
-</YueDisplay>
-
-如果你要构造一个由变量组成的表，并希望键与变量名相同，那么可以使用 **:** 前缀操作符：
-
-```yuescript
-hair = "金色"
-height = 200
-person = { :hair, :height, shoe_size: 40 }
-
-print_table :hair, :height
-```
-<YueDisplay>
-
-```yue
-hair = "金色"
-height = 200
-person = { :hair, :height, shoe_size: 40 }
-
-print_table :hair, :height
-```
-
-</YueDisplay>
-
-如果你希望表中字段的键是某个表达式的结果，那么可以用 **[ ]** 包裹它，就像在 Lua 中一样。如果键中有任何特殊字符，也可以直接使用字符串字面量作为键，省略方括号。
-
-```yuescript
-t = {
-  [1 + 2]: "你好"
-  "你好 世界": true
-}
-```
-<YueDisplay>
-
-```yue
-t = {
-  [1 + 2]: "你好"
-  "你好 世界": true
-}
-```
-
-</YueDisplay>
-
-Lua 的表同时具有数组部分和哈希部分，但有时候你会希望在书写 Lua 表时，对 Lua 表做数组和哈希不同用法的语义区分。然后你可以用 **[ ]** 而不是 **{ }** 来编写表示数组的 Lua 表，并且不允许在数组 Lua 表中写入任何键值对。
-
-```yuescript
-some_values = [ 1, 2, 3, 4 ]
-list_with_one_element = [ 1, ]
-```
-<YueDisplay>
-
-```yue
-some_values = [ 1, 2, 3, 4 ]
-list_with_one_element = [ 1, ]
-```
-
-</YueDisplay>
-
-## 推导式
-
-推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生 Lua 表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
-
-### 列表推导式
-
-以下操作创建了一个 items 表的副本，但所有包含的值都翻倍了。
-
-```yuescript
-items = [1, 2, 3, 4]
-doubled = [item * 2 for i, item in ipairs items]
-```
-<YueDisplay>
-
-```yue
-items = [1, 2, 3, 4]
-doubled = [item * 2 for i, item in ipairs items]
-```
-
-</YueDisplay>
-
-可以使用 `when` 子句筛选新表中包含的项目：
-
-```yuescript
-slice = [item for i, item in ipairs items when i > 1 and i < 3]
-```
-<YueDisplay>
-
-```yue
-slice = [item for i, item in ipairs items when i > 1 and i < 3]
-```
-
-</YueDisplay>
-
-因为我们常常需要迭代数值索引表的值，所以引入了 **\*** 操作符来做语法简化。doubled 示例可以重写为：
-
-```yuescript
-doubled = [item * 2 for item in *items]
-```
-<YueDisplay>
-
-```yue
-doubled = [item * 2 for item in *items]
-```
-
-</YueDisplay>
-
-在列表推导式中，你还可以使用展开操作符 `...` 来实现对列表嵌套层级进行扁平化的处理：
-
-```yuescript
-data =
-  a: [1, 2, 3]
-  b: [4, 5, 6]
-
-flat = [...v for k,v in pairs data]
--- flat 现在为 [1, 2, 3, 4, 5, 6]
-```
-<YueDisplay>
-
-```yue
-data =
-  a: [1, 2, 3]
-  b: [4, 5, 6]
-
-flat = [...v for k,v in pairs data]
--- flat 现在为 [1, 2, 3, 4, 5, 6]
-```
-
-</YueDisplay>
-
-for 和 when 子句可以根据需要进行链式操作。唯一的要求是推导式中至少要有一个 for 子句。
-
-使用多个 for 子句与使用多重循环的效果相同：
-
-```yuescript
-x_coords = [4, 5, 6, 7]
-y_coords = [9, 2, 3]
-
-points = [ [x, y] for x in *x_coords \
-for y in *y_coords]
-```
-<YueDisplay>
-
-```yue
-x_coords = [4, 5, 6, 7]
-y_coords = [9, 2, 3]
-
-points = [ [x, y] for x in *x_coords \
-for y in *y_coords]
-```
-
-</YueDisplay>
-
-在推导式中也可以使用简单的数值 for 循环：
-
-```yuescript
-evens = [i for i = 1, 100 when i % 2 == 0]
-```
-<YueDisplay>
-
-```yue
-evens = [i for i = 1, 100 when i % 2 == 0]
-```
-
-</YueDisplay>
-
-### 表格推导式
-
-表格推导式和列表推导式的语法非常相似，只是要使用 **{** 和 **}** 并从每次迭代中取两个值。
-
-以下示例生成了表格 thing 的副本：
-
-```yuescript
-thing = {
-  color: "red"
-  name: "fast"
-  width: 123
-}
-
-thing_copy = {k, v for k, v in pairs thing}
-```
-<YueDisplay>
-
-```yue
-thing = {
-  color: "red"
-  name: "fast"
-  width: 123
-}
-
-thing_copy = {k, v for k, v in pairs thing}
-```
-
-</YueDisplay>
-
-```yuescript
-no_color = {k, v for k, v in pairs thing when k != "color"}
-```
-<YueDisplay>
-
-```yue
-no_color = {k, v for k, v in pairs thing when k != "color"}
-```
-
-</YueDisplay>
-
-**\*** 操作符在表格推导式中能使用。在下面的例子里，我们为几个数字创建了一个平方根查找表。
-
-```yuescript
-numbers = [1, 2, 3, 4]
-sqrts = {i, math.sqrt i for i in *numbers}
-```
-<YueDisplay>
-
-```yue
-numbers = [1, 2, 3, 4]
-sqrts = {i, math.sqrt i for i in *numbers}
-```
-
-</YueDisplay>
-
-表格推导式中的键值元组也可以来自单个表达式，在这种情况下，表达式在计算后应返回两个值。第一个用作键，第二个用作值：
-
-在下面的示例中，我们将一些数组转换为一个表，其中每个数组里的第一项是键，第二项是值。
-
-```yuescript
-tuples = [ ["hello", "world"], ["foo", "bar"]]
-tbl = {unpack tuple for tuple in *tuples}
-```
-<YueDisplay>
-
-```yue
-tuples = [ ["hello", "world"], ["foo", "bar"]]
-tbl = {unpack tuple for tuple in *tuples}
-```
-
-</YueDisplay>
-
-### 切片
-
-当使用 **\*** 操作符时，月之脚本还提供了一种特殊的语法来限制要遍历的列表范围。这个语法也相当于在 for 循环中设置迭代边界和步长。
-
-下面的案例中，我们在切片中设置最小和最大边界，取索引在 1 到 5 之间（包括 1 和 5）的所有项目：
-
-```yuescript
-slice = [item for item in *items[1, 5]]
-```
-<YueDisplay>
-
-```yue
-slice = [item for item in *items[1, 5]]
-```
-
-</YueDisplay>
-
-切片的任意参数都可以省略，并会使用默认值。在如下示例中，如果省略了最大索引边界，它默认为表的长度。使下面的代码取除第一个元素之外的所有元素：
-
-```yuescript
-slice = [item for item in *items[2,]]
-```
-<YueDisplay>
-
-```yue
-slice = [item for item in *items[2,]]
-```
-
-</YueDisplay>
-
-如果省略了最小边界，便默认会设置为 1。这里我们只提供一个步长，并留下其他边界为空。这样会使得代码取出所有奇数索引的项目：(1, 3, 5, …)
-
-```yuescript
-slice = [item for item in *items[,,2]]
-```
-<YueDisplay>
-
-
-```yue
-slice = [item for item in *items[,,2]]
-```
-
-</YueDisplay>
-
-最小和最大边界都可以是负数，使用负数意味着边界是从表的末尾开始计算的。
-
-```yuescript
--- 取最后4个元素
-slice = [item for item in *items[-4,-1]]
-```
-<YueDisplay>
-
-```yue
--- 取最后4个元素
-slice = [item for item in *items[-4,-1]]
-```
-
-</YueDisplay>
-
-切片的步长也可以是负数，这意味着元素会以相反的顺序被取出。
-
-```yuescript
-reverse_slice = [item for item in *items[-1,1,-1]]
-```
-<YueDisplay>
-
-```yue
-reverse_slice = [item for item in *items[-1,1,-1]]
-```
-
-</YueDisplay>
-
-#### 切片表达式
-
-切片也可以作为表达式来使用。可以用于获取一个表包含的子列表。
-
-```yuescript
--- 取第2和第4个元素作为新的列表
-sub_list = items[2, 4]
-```
-<YueDisplay>
-
-```yue
--- 取第2和第4个元素作为新的列表
-sub_list = items[2, 4]
-```
-
-</YueDisplay>
-
-## for 循环
-
-Lua 中有两种 for 循环形式，数字型和通用型：
-
-```yuescript
-for i = 10, 20
-  print i
-
-for k = 1, 15, 2 -- 提供了一个遍历的步长
-  print k
-
-for key, value in pairs object
-  print key, value
-```
-<YueDisplay>
-
-```yue
-for i = 10, 20
-  print i
-
-for k = 1, 15, 2 -- 提供了一个遍历的步长
-  print k
-
-for key, value in pairs object
-  print key, value
-```
-
-</YueDisplay>
-
-可以使用切片和 **\*** 操作符，就像在列表推导中一样：
-
-```yuescript
-for item in *items[2, 4]
-  print item
-```
-<YueDisplay>
-
-```yue
-for item in *items[2, 4]
-  print item
-```
-
-</YueDisplay>
-
-当代码语句只有一行时，循环语句也都可以写作更短的语法：
-
-```yuescript
-for item in *items do print item
-
-for j = 1, 10, 3 do print j
-```
-<YueDisplay>
-
-```yue
-for item in *items do print item
-
-for j = 1, 10, 3 do print j
-```
-
-</YueDisplay>
-
-for 循环也可以用作表达式。for 循环主体中的最后一条语句会被强制转换为一个返回值的表达式，并会将表达式计算结果的值追加到一个作为结果的数组表中。
-
-将每个偶数加倍：
-
-```yuescript
-doubled_evens = for i = 1, 20
-  if i % 2 == 0
-    i * 2
-  else
-    i
-```
-<YueDisplay>
-
-```yue
-doubled_evens = for i = 1, 20
-  if i % 2 == 0
-    i * 2
-  else
-    i
-```
-
-</YueDisplay>
-
-此外，for 循环还支持带返回值的 break 语句，这样循环本身就可以作为一个表达式，在满足条件时提前退出并返回有意义的结果。
-
-例如，查找第一个大于 10 的数字：
-
-```yuescript
-first_large = for n in *numbers
-  break n if n > 10
-```
-<YueDisplay>
-
-```yue
-first_large = for n in *numbers
-  break n if n > 10
-```
-
-</YueDisplay>
-
-你还可以结合 for 循环表达式与 continue 语句来过滤值。
-
-注意出现在函数体末尾的 for 循环，不会被当作是一个表达式并将循环结果累积到一个列表中作为返回值（相反，函数将返回 nil）。如果要函数末尾的循环转换为列表表达式，可以显式地使用返回语句加 for 循环表达式。
-
-```yuescript
-func_a = -> for i = 1, 10 do print i
-func_b = -> return for i = 1, 10 do i
-
-print func_a! -- 打印 nil
-print func_b! -- 打印 table 对象
-```
-<YueDisplay>
-
-```yue
-func_a = -> for i = 1, 10 do print i
-func_b = -> return for i = 1, 10 do i
-
-print func_a! -- 打印 nil
-print func_b! -- 打印 table 对象
-```
-
-</YueDisplay>
-
-这样做是为了避免在不需要返回循环结果的函数，创建无效的返回值表格。
-
-## repeat 循环
-
-repeat 循环是从 Lua 语言中搬过来的相似语法：
-
-```yuescript
-i = 10
-repeat
-  print i
-  i -= 1
-until i == 0
-```
-<YueDisplay>
-
-```yue
-i = 10
-repeat
-  print i
-  i -= 1
-until i == 0
-```
-
-</YueDisplay>
-
-## while 循环
-
-在月之脚本中的 while 循环有四种写法：
-
-```yuescript
-i = 10
-while i > 0
-  print i
-  i -= 1
-
-while running == true do my_function!
-```
-<YueDisplay>
-
-```yue
-i = 10
-while i > 0
-  print i
-  i -= 1
-
-while running == true do my_function!
-```
-
-</YueDisplay>
-
-```yuescript
-i = 10
-until i == 0
-  print i
-  i -= 1
-
-until running == false do my_function!
-```
-<YueDisplay>
-
-```yue
-i = 10
-until i == 0
-  print i
-  i -= 1
-until running == false do my_function!
-```
-
-</YueDisplay>
-
-像 for 循环的语法一样，while 循环也可以作为一个表达式使用。为了使函数返回 while 循环的累积列表值，必须明确使用返回语句返回 while 循环表达式。
-
-## 继续
-
-继续语句可以用来跳出当前的循环迭代。
-
-```yuescript
-i = 0
-while i < 10
-  i += 1
-  continue if i % 2 == 0
-  print i
-```
-<YueDisplay>
-
-```yue
-i = 0
-while i < 10
-  i += 1
-  continue if i % 2 == 0
-  print i
-```
-
-</YueDisplay>
-
-继续语句也可以与各种循环表达式一起使用，以防止当前的循环迭代结果累积到结果列表中。以下示例将数组表过滤为仅包含偶数的数组：
-
-```yuescript
-my_numbers = [1, 2, 3, 4, 5, 6]
-odds = for x in *my_numbers
-  continue if x % 2 == 1
-  x
-```
-<YueDisplay>
-
-```yue
-my_numbers = [1, 2, 3, 4, 5, 6]
-odds = for x in *my_numbers
-  continue if x % 2 == 1
-  x
-```
-
-</YueDisplay>
-
-## 条件语句
-
-```yuescript
-have_coins = false
-if have_coins
-  print "有硬币"
-else
-  print "没有硬币"
-```
-<YueDisplay>
-
-```yue
-have_coins = false
-if have_coins
-  print "有硬币"
-else
-  print "没有硬币"
-```
-
-</YueDisplay>
-
-对于简单的语句，也可以使用简短的语法：
-
-```yuescript
-have_coins = false
-if have_coins then print "有硬币" else print "没有硬币"
-```
-<YueDisplay>
-
-```yue
-have_coins = false
-if have_coins then print "有硬币" else print "没有硬币"
-```
-
-</YueDisplay>
-
-因为if语句可以用作表达式，所以也可以这样写：
-
-```yuescript
-have_coins = false
-print if have_coins then "有硬币" else "没有硬币"
-```
-<YueDisplay>
-
-```yue
-have_coins = false
-print if have_coins then "有硬币" else "没有硬币"
-```
-
-</YueDisplay>
-
-条件语句也可以作为表达式用在返回语句和赋值语句中：
-
-```yuescript
-is_tall = (name) ->
-  if name == "Rob"
-    true
-  else
-    false
-
-message = if is_tall "Rob"
-  "我很高"
-else
-  "我不是很高"
-
-print message -- 打印: 我很高
-```
-<YueDisplay>
-
-```yue
-is_tall = (name) ->
-  if name == "Rob"
-    true
-  else
-    false
-
-message = if is_tall "Rob"
-  "我很高"
-else
-  "我不是很高"
-
-print message -- 打印: 我很高
-```
-
-</YueDisplay>
-
-if 的反义词是 unless（相当于 if not，正如“如果”对应“除非”）：
-
-```yuescript
-unless os.date("%A") == "Monday"
-  print "今天不是星期一！"
-```
-<YueDisplay>
-
-
-```yue
-unless os.date("%A") == "Monday"
-  print "今天不是星期一！"
-```
-
-</YueDisplay>
-
-```yuescript
-print "你真幸运！" unless math.random! > 0.1
-```
-<YueDisplay>
-
-```yue
-print "你真幸运！" unless math.random! > 0.1
-```
-
-</YueDisplay>
-
-### 范围表达式
-
-你可以使用范围表达式来编写进行范围检查的代码。
-
-```yuescript
-a = 5
-
-if a in [1, 3, 5, 7]
-  print "检查离散值的相等性"
-
-if a in list
-  print "检查`a`是否在列表中"
-```
-<YueDisplay>
-
-```yue
-a = 5
-
-if a in [1, 3, 5, 7]
-  print "检查离散值的相等性"
-
-if a in list
-  print "检查`a`是否在列表中"
-```
-
-</YueDisplay>
-
-```yuescript
-print "你很幸运!" unless math.random! > 0.1
-```
-<YueDisplay>
-
-```yue
-print "你很幸运!" unless math.random! > 0.1
-```
-
-</YueDisplay>
-
-## 代码行修饰符
-
-为了方便编写代码，循环语句和 if 语句可以应用于单行代码语句的末尾：
-
-```yuescript
-print "你好，世界" if name == "Rob"
-```
-<YueDisplay>
-
-```yue
-print "你好，世界" if name == "Rob"
-```
-
-</YueDisplay>
-
-修饰 for 循环的示例：
-
-```yuescript
-print "项目: ", item for item in *items
-```
-<YueDisplay>
-
-```yue
-print "项目: ", item for item in *items
-```
-
-</YueDisplay>
-
-修饰 while 循环的示例：
-
-```yuescript
-game\update! while game\isRunning!
-
-reader\parse_line! until reader\eof!
-```
-<YueDisplay>
-
-```yue
-game\update! while game\isRunning!
-
-reader\parse_line! until reader\eof!
-```
-
-</YueDisplay>
-
-## switch 语句
-
-switch 语句是为了简化检查一系列相同值的if语句而提供的简写语法。要注意用于比较检查的目标值只会计算一次。和 if 语句一样，switch 语句在最后可以接一个 else 代码块来处理没有匹配的情况。在生成的 Lua 代码中，进行比较是使用 == 操作符完成的。switch 语句中也可以使用赋值表达式来储存临时变量值。
-
-```yuescript
-switch name := "Dan"
-  when "Robert"
-    print "你是Robert"
-  when "Dan", "Daniel"
-    print "你的名字是Dan"
-  else
-    print "我不认识你，你的名字是#{name}"
-```
-<YueDisplay>
-
-```yue
-switch name := "Dan"
-  when "Robert"
-    print "你是Robert"
-  when "Dan", "Daniel"
-    print "你的名字是Dan"
-  else
-    print "我不认识你，你的名字是#{name}"
-```
-
-</YueDisplay>
-
-switch 语句的 when 子句中可以通过使用逗号分隔的列表来匹配多个值。
-
-switch 语句也可以作为表达式使用，下面我们可以将 switch 语句返回的结果分配给一个变量：
-
-```yuescript
-b = 1
-next_number = switch b
-  when 1
-    2
-  when 2
-    3
-  else
-    error "数字数得太大了！"
-```
-<YueDisplay>
-
-```yue
-b = 1
-next_number = switch b
-  when 1
-    2
-  when 2
-    3
-  else
-    error "数字数得太大了！"
-```
-
-</YueDisplay>
-
-我们可以使用 then 关键字在 when 子句的同一行上编写处理代码。else 代码块的后续代码中要写在同一行上不需要额外的关键字。
-
-```yuescript
-msg = switch math.random(1, 5)
-  when 1 then "你很幸运"
-  when 2 then "你差点很幸运"
-  else "不太幸运"
-```
-<YueDisplay>
-
-```yue
-msg = switch math.random(1, 5)
-  when 1 then "你很幸运"
-  when 2 then "你差点很幸运"
-  else "不太幸运"
-```
-
-</YueDisplay>
-
-如果在编写 switch 语句时希望少写一个缩进，那么你可以把第一个 when 子句放在 switch 开始语句的第一行，然后后续的子语句就都可以都少写一个缩进。
-
-```yuescript
-switch math.random(1, 5)
-  when 1
-    print "你很幸运" -- 两个缩进级别
-  else
-    print "不太幸运"
-
-switch math.random(1, 5) when 1
-  print "你很幸运" -- 一个缩进级别
-else
-  print "不太幸运"
-```
-<YueDisplay>
-
-```yue
-switch math.random(1, 5)
-  when 1
-    print "你很幸运" -- 两个缩进级别
-  else
-    print "不太幸运"
-
-switch math.random(1, 5) when 1
-  print "你很幸运" -- 一个缩进级别
-else
-  print "不太幸运"
-```
-
-</YueDisplay>
-
-值得注意的是，在生成 Lua 代码时，我们要做检查的目标变量会放在 == 表达式的右侧。当你希望给 when 子句的比较对象定义一个 \_\_eq 元方法来重载判断逻辑时，可能会有用。
-
-### 表格匹配
-
-在 switch 的 when 子句中，如果期待检查目标是一个表格，且可以通过特定的结构进行解构并获得非 nil 值，那么你可以尝试使用表格匹配的语法。
-
-```yuescript
-items =
-  * x: 100
-    y: 200
-  * width: 300
-    height: 400
-
-for item in *items
-  switch item
-    when :x, :y
-      print "Vec2 #{x}, #{y}"
-    when :width, :height
-      print "尺寸 #{width}, #{height}"
-```
-<YueDisplay>
-
-```yue
-items =
-  * x: 100
-    y: 200
-  * width: 300
-    height: 400
-
-for item in *items
-  switch item
-    when :x, :y
-      print "Vec2 #{x}, #{y}"
-    when :width, :height
-      print "尺寸 #{width}, #{height}"
-```
-
-</YueDisplay>
-
-你可以使用默认值来选择性地解构表格的某些字段。
-
-```yuescript
-item = {}
-
-{pos: {:x = 50, :y = 200}} = item -- 获取错误：尝试索引nil值（字段'pos'）
-
-switch item
-  when {pos: {:x = 50, :y = 200}}
-    print "Vec2 #{x}, #{y}" -- 表格解构仍然会通过
-```
-<YueDisplay>
-
-```yue
-item = {}
-
-{pos: {:x = 50, :y = 200}} = item -- 获取错误：尝试索引nil值（字段'pos'）
-
-switch item
-  when {pos: {:x = 50, :y = 200}}
-    print "Vec2 #{x}, #{y}" -- 表格解构仍然会通过
-```
-
-</YueDisplay>
-
-你也可以匹配数组元素、表格字段，甚至使用数组或表格字面量来匹配嵌套的结构。
-
-匹配数组元素。
-
-```yuescript
-switch tb
-  when [1, 2, 3]
-    print "1, 2, 3"
-  when [1, b, 3]
-    print "1, #{b}, 3"
-  when [1, 2, b = 3] -- 变量b有默认值
-    print "1, 2, #{b}"
-```
-<YueDisplay>
-
-```yue
-switch tb
-  when [1, 2, 3]
-    print "1, 2, 3"
-  when [1, b, 3]
-    print "1, #{b}, 3"
-  when [1, 2, b = 3] -- 变量b有默认值
-    print "1, 2, #{b}"
-```
-
-</YueDisplay>
-
-匹配表格字段。
-
-```yuescript
-switch tb
-  when success: true, :result
-    print "成功", result
-  when success: false
-    print "失败", result
-  else
-    print "无效值"
-```
-<YueDisplay>
-
-```yue
-switch tb
-  when success: true, :result
-    print "成功", result
-  when success: false
-    print "失败", result
-  else
-    print "无效值"
-```
-
-</YueDisplay>
-
-匹配嵌套的表格结构。
-
-```yuescript
-switch tb
-  when data: {type: "success", :content}
-    print "成功", content
-  when data: {type: "error", :content}
-    print "失败", content
-  else
-    print "无效值"
-```
-<YueDisplay>
-
-```yue
-switch tb
-  when data: {type: "success", :content}
-    print "成功", content
-  when data: {type: "error", :content}
-    print "失败", content
-  else
-    print "无效值"
-```
-
-</YueDisplay>
-
-匹配表格数组。
-
-```yuescript
-switch tb
-  when [
-      {a: 1, b: 2}
-      {a: 3, b: 4}
-      {a: 5, b: 6}
-      fourth
-    ]
-    print "匹配成功", fourth
-```
-<YueDisplay>
-
-```yue
-switch tb
-  when [
-      {a: 1, b: 2}
-      {a: 3, b: 4}
-      {a: 5, b: 6}
-      fourth
-    ]
-    print "匹配成功", fourth
-```
-
-</YueDisplay>
-
-匹配一个列表并捕获特定范围内的元素。
-
-```yuescript
-segments = ["admin", "users", "logs", "view"]
-switch segments
-  when [...groups, resource, action]
-    print "Group:", groups -- 打印: {"admin", "users"}
-    print "Resource:", resource -- 打印: "logs"
-    print "Action:", action -- 打印: "view"
-```
-<YueDisplay>
-
-```yue
-segments = ["admin", "users", "logs", "view"]
-switch segments
-  when [...groups, resource, action]
-    print "Group:", groups -- 打印: {"admin", "users"}
-    print "Resource:", resource -- 打印: "logs"
-    print "Action:", action -- 打印: "view"
-```
-
-</YueDisplay>
-
-## 面向对象编程
-
-在以下的示例中，月之脚本生成的 Lua 代码可能看起来会很复杂。所以最好主要关注月之脚本代码层面的意义，然后如果你想知道关于面向对象功能的实现细节，再查看 Lua 代码。
-
-一个简单的类：
-
-```yuescript
-class Inventory
-  new: =>
-    @items = {}
-
-  add_item: (name) =>
-    if @items[name]
-      @items[name] += 1
-    else
-      @items[name] = 1
-```
-<YueDisplay>
-
-```yue
-class Inventory
-  new: =>
-    @items = {}
-
-  add_item: (name) =>
-    if @items[name]
-      @items[name] += 1
-    else
-      @items[name] = 1
-```
-
-</YueDisplay>
-
-在月之脚本中采用面向对象的编程方式时，通常会使用类声明语句结合 Lua 表格字面量来做类定义。这个类的定义包含了它的所有方法和属性。在这种结构中，键名为 “new” 的成员扮演了一个重要的角色，是作为构造函数来使用。
-
-值得注意的是，类中的方法都采用了粗箭头函数语法。当在类的实例上调用方法时，该实例会自动作为第一个参数被传入，因此粗箭头函数用于生成一个名为 “self” 的参数。
-
-此外，“@” 前缀在变量名上起到了简化作用，代表 “self”。例如，`@items` 就等同于 `self.items`。
-
-为了创建类的一个新实例，可以将类名当作一个函数来调用，这样就可以生成并返回一个新的实例。
-
-```yuescript
-inv = Inventory!
-inv\add_item "t-shirt"
-inv\add_item "pants"
-```
-<YueDisplay>
-
-
-```yue
-inv = Inventory!
-inv\add_item "t-shirt"
-inv\add_item "pants"
-```
-
-</YueDisplay>
-
-在月之脚本的类中，由于需要将类的实例作为参数传入到调用的方法中，因此使用了 **\\** 操作符做类的成员函数调用。
-
-需要特别注意的是，类的所有属性在其实例之间是共享的。这对于函数类型的成员属性通常不会造成问题，但对于其他类型的属性，可能会导致意外的结果。
-
-例如，在下面的示例中，clothes 属性在所有实例之间共享。因此，对这个属性在一个实例中的修改，将会影响到其他所有实例。
-
-```yuescript
-class Person
-  clothes: []
-  give_item: (name) =>
-    table.insert @clothes, name
-
-a = Person!
-b = Person!
-
-a\give_item "pants"
-b\give_item "shirt"
-
--- 会同时打印出裤子和衬衫
-print item for item in *a.clothes
-```
-<YueDisplay>
-
-```yue
-class Person
-  clothes: []
-  give_item: (name) =>
-    table.insert @clothes, name
-
-a = Person!
-b = Person!
-
-a\give_item "pants"
-b\give_item "shirt"
-
--- 会同时打印出裤子和衬衫
-print item for item in *a.clothes
-```
-
-</YueDisplay>
-
-避免这个问题的正确方法是在构造函数中创建对象的可变状态：
-
-```yuescript
-class Person
-  new: =>
-    @clothes = []
-```
-<YueDisplay>
-
-```yue
-class Person
-  new: =>
-    @clothes = []
-```
-
-</YueDisplay>
-
-### 继承
-
-`extends` 关键字可以在类声明中使用，以继承另一个类的属性和方法。
-
-```yuescript
-class BackPack extends Inventory
-  size: 10
-  add_item: (name) =>
-    if #@items > size then error "背包已满"
-    super name
-```
-<YueDisplay>
-
-```yue
-class BackPack extends Inventory
-  size: 10
-  add_item: (name) =>
-    if #@items > size then error "背包已满"
-    super name
-```
-
-</YueDisplay>
-
-
-在这一部分，我们对月之脚本中的 `Inventory` 类进行了扩展，加入了对可以携带物品数量的限制。
-
-在这个特定的例子中，子类并没有定义自己的构造函数。因此，当创建一个新的实例时，系统会默认调用父类的构造函数。但如果我们在子类中定义了构造函数，我们可以利用 `super` 方法来调用并执行父类的构造函数。
-
-此外，当一个类继承自另一个类时，它会尝试调用父类上的 `__inherited` 方法（如果这个方法存在的话），以此来向父类发送通知。这个 `__inherited` 函数接受两个参数：被继承的父类和继承的子类。
-
-```yuescript
-class Shelf
-  @__inherited: (child) =>
-    print @__name, "被", child.__name, "继承"
-
--- 将打印: Shelf 被 Cupboard 继承
-class Cupboard extends Shelf
-```
-<YueDisplay>
-
-```yue
-class Shelf
-  @__inherited: (child) =>
-    print @__name, "被", child.__name, "继承"
-
--- 将打印: Shelf 被 Cupboard 继承
-class Cupboard extends Shelf
-```
-
-</YueDisplay>
-
-### super 关键字
-
-`super` 是一个特别的关键字，它有两种不同的使用方式：既可以当作一个对象来看待，也可以像调用函数那样使用。它仅在类的内部使用时具有特殊的功能。
-
-当 `super` 被作为一个函数调用时，它将调用父类中与之同名的函数。此时，当前的 `self` 会自动作为第一个参数传递，正如上面提到的继承示例所展示的那样。
-
-在将 `super` 当作普通值使用时，它实际上是对父类对象的引用。通过这种方式，我们可以访问父类中可能被子类覆盖的值，就像访问任何普通对象一样。
-
-此外，当使用 `\` 操作符与 `super` 一起使用时，`self`将被插入为第一个参数，而不是使用 `super` 本身的值。而在使用`.`操作符来检索函数时，则会返回父类中的原始函数。
-
-下面是一些使用 `super` 的不同方法的示例：
-
-```yuescript
-class MyClass extends ParentClass
-  a_method: =>
-    -- 以下效果相同：
-    super "你好", "世界"
-    super\a_method "你好", "世界"
-    super.a_method self, "你好", "世界"
-
-    -- super 作为值等于父类：
-    assert super == ParentClass
-```
-<YueDisplay>
-
-```yue
-class MyClass extends ParentClass
-  a_method: =>
-    -- 以下效果相同：
-    super "你好", "世界"
-    super\a_method "你好", "世界"
-    super.a_method self, "你好", "世界"
-
-    -- super 作为值等于父类：
-    assert super == ParentClass
-```
-
-</YueDisplay>
-
-**super** 也可以用在函数存根的左侧。唯一的主要区别是，生成的函数不是绑定到 super 的值，而是绑定到 self。
-
-### 类型
-
-每个类的实例都带有它的类型。这存储在特殊的 \_\_class 属性中。此属性会保存类对象。类对象是我们用来构建新实例的对象。我们还可以索引类对象以检索类方法和属性。
-
-```yuescript
-b = BackPack!
-assert b.__class == BackPack
-
-print BackPack.size -- 打印 10
-```
-<YueDisplay>
-
-```yue
-b = BackPack!
-assert b.__class == BackPack
-
-print BackPack.size -- 打印 10
-```
-
-</YueDisplay>
-
-### 类对象
-
-
-在月之脚本中，当我们编写类的定义语句时，实际上是在创建一个类对象。这个类对象被保存在一个与该类同名的变量中。
-
-类对象具有函数的特性，可以被调用来创建新的实例。这正是我们在之前示例中所展示的创建类实例的方式。
-
-一个类由两个表构成：类表本身和一个基表。基表作为所有实例的元表。在类声明中列出的所有属性都存放在基表中。
-
-如果在类对象的元表中找不到某个属性，系统会从基表中检索该属性。这就意味着我们可以直接从类本身访问到其方法和属性。
-
-需要特别注意的是，对类对象的赋值并不会影响到基表，因此这不是向实例添加新方法的正确方式。相反，需要直接修改基表。关于这点，可以参考下面的 “__base” 字段。
-
-此外，类对象包含几个特殊的属性：当类被声明时，类的名称会作为一个字符串存储在类对象的 “__name” 字段中。
-
-```yuescript
-print BackPack.__name -- 打印 Backpack
-```
-<YueDisplay>
-
-```yue
-print BackPack.__name -- 打印 Backpack
-```
-
-</YueDisplay>
-
-基础对象被保存在一个名为 `__base` 的特殊表中。我们可以编辑这个表，以便为那些已经创建出来的实例和还未创建的实例增加新的功能。
-
-另外，如果一个类是从另一个类派生而来的，那么其父类对象则会被存储在名为 `__parent` 的地方。这种机制允许在类之间实现继承和功能扩展。
-
-### 类变量
-
-我们可以直接在类对象中创建变量，而不是在类的基对象中，通过在类声明中的属性名前使用 @。
-
-```yuescript
-class Things
-  @some_func: => print "Hello from", @__name
-
-Things\some_func!
-
--- 类变量在实例中不可见
-assert Things().some_func == nil
-```
-<YueDisplay>
-
-```yue
-class Things
-  @some_func: => print "Hello from", @__name
-
-Things\some_func!
-
--- 类变量在实例中不可见
-assert Things().some_func == nil
-```
-
-</YueDisplay>
-
-在表达式中，我们可以使用 @@ 来访问存储在 `self.__class` 中的值。因此，`@@hello` 是 `self.__class.hello` 的简写。
-
-```yuescript
-class Counter
-  @count: 0
-
-  new: =>
-    @@count += 1
-
-Counter!
-Counter!
-
-print Counter.count -- 输出 2
-```
-<YueDisplay>
-
-```yue
-class Counter
-  @count: 0
-
-  new: =>
-    @@count += 1
-
-Counter!
-Counter!
-
-print Counter.count -- 输出 2
-```
-
-</YueDisplay>
-
-@@ 的调用语义与 @ 类似。调用 @@ 时，会使用 Lua 的冒号语法将类作为第一个参数传入。
-
-```yuescript
-@@hello 1,2,3,4
-```
-<YueDisplay>
-
-```yue
-@@hello 1,2,3,4
-```
-
-</YueDisplay>
-
-### 类声明语句
-
-在类声明的主体中，除了键/值对外，我们还可以编写普通的表达式。在这种类声明体中的普通代码的上下文中，self 等于类对象，而不是实例对象。
-
-以下是创建类变量的另一种方法：
-
-```yuescript
-class Things
-  @class_var = "hello world"
-```
-<YueDisplay>
-
-```yue
-class Things
-  @class_var = "hello world"
-```
-
-</YueDisplay>
-
-这些表达式会在所有属性被添加到类的基对象后执行。
-
-在类的主体中声明的所有变量都会限制作用域只在类声明的范围。这对于放置只有类方法可以访问的私有值或辅助函数很方便：
-
-```yuescript
-class MoreThings
-  secret = 123
-  log = (msg) -> print "LOG:", msg
-
-  some_method: =>
-    log "hello world: " .. secret
-```
-<YueDisplay>
-
-```yue
-class MoreThings
-  secret = 123
-  log = (msg) -> print "LOG:", msg
-
-  some_method: =>
-    log "hello world: " .. secret
-```
-
-</YueDisplay>
-
-### @ 和 @@ 值
-
-当 @ 和 @@ 前缀在一个名字前时，它们分别代表在 self 和 self.\_\_class 中访问的那个名字。
-
-如果它们单独使用，它们是 self 和 self.\_\_class 的别名。
-
-```yuescript
-assert @ == self
-assert @@ == self.__class
-```
-<YueDisplay>
-
-```yue
-assert @ == self
-assert @@ == self.__class
-```
-
-</YueDisplay>
-
-例如，使用 @@ 从实例方法快速创建同一类的新实例的方法：
-
-```yuescript
-some_instance_method = (...) => @@ ...
-```
-<YueDisplay>
-
-```yue
-some_instance_method = (...) => @@ ...
-```
-
-</YueDisplay>
-
-### 构造属性提升
-
-为了减少编写简单值对象定义的代码。你可以这样简单写一个类：
-
-```yuescript
-class Something
-  new: (@foo, @bar, @@biz, @@baz) =>
-
--- 这是以下声明的简写形式
-
-class Something
-  new: (foo, bar, biz, baz) =>
-    @foo = foo
-    @bar = bar
-    @@biz = biz
-    @@baz = baz
-```
-<YueDisplay>
-
-```yue
-class Something
-  new: (@foo, @bar, @@biz, @@baz) =>
-
--- 这是以下声明的简写形式
-
-class Something
-  new: (foo, bar, biz, baz) =>
-    @foo = foo
-    @bar = bar
-    @@biz = biz
-    @@baz = baz
-```
-
-</YueDisplay>
-
-你也可以使用这种语法为一个函数初始化传入对象的字段。
-
-```yuescript
-new = (@fieldA, @fieldB) => @
-obj = new {}, 123, "abc"
-print obj
-```
-<YueDisplay>
-
-```yue
-new = (@fieldA, @fieldB) => @
-obj = new {}, 123, "abc"
-print obj
-```
-
-</YueDisplay>
-
-### 类表达式
-
-类声明的语法也可以作为一个表达式使用，可以赋值给一个变量或者被返回语句返回。
-
-```yuescript
-x = class Bucket
-  drops: 0
-  add_drop: => @drops += 1
-```
-<YueDisplay>
-
-```yue
-x = class Bucket
-  drops: 0
-  add_drop: => @drops += 1
-```
-
-</YueDisplay>
-
-### 匿名类
-
-声明类时可以省略名称。如果类的表达式不在赋值语句中，\_\_name 属性将为 nil。如果出现在赋值语句中，赋值操作左侧的名称将代替 nil。
-
-```yuescript
-BigBucket = class extends Bucket
-  add_drop: => @drops += 10
-
-assert Bucket.__name == "BigBucket"
-```
-<YueDisplay>
-
-```yue
-BigBucket = class extends Bucket
-  add_drop: => @drops += 10
-
-assert Bucket.__name == "BigBucket"
-```
-
-</YueDisplay>
-
-你甚至可以省略掉主体，这意味着你可以这样写一个空白的匿名类：
-
-```yuescript
-x = class
-```
-<YueDisplay>
-
-```yue
-x = class
-```
-
-</YueDisplay>
-
-### 类混合
-
-你可以通过使用 `using` 关键字来实现类混合。这意味着你可以从一个普通 Lua 表格或已定义的类对象中，复制函数到你创建的新类中。当你使用普通 Lua 表格进行类混合时，你有机会用自己的实现来重写类的索引方法（例如元方法 `__index`）。然而，当你从一个类对象做混合时，需要注意的是该类对象的元方法将不会被复制到新类。
-
-```yuescript
-MyIndex = __index: var: 1
-
-class X using MyIndex
-  func: =>
-    print 123
-
-x = X!
-print x.var
-
-class Y using X
-
-y = Y!
-y\func!
-
-assert y.__class.__parent ~= X -- X 不是 Y 的父类
-```
-<YueDisplay>
-
-```yue
-MyIndex = __index: var: 1
-
-class X using MyIndex
-  func: =>
-    print 123
-
-x = X!
-print x.var
-
-class Y using X
-
-y = Y!
-y\func!
-
-assert y.__class.__parent ~= X -- X 不是 Y 的父类
-```
-
-</YueDisplay>
-
-## with 语句
-
-在编写 Lua 代码时，我们在创建对象后的常见操作是立即调用这个对象一系列操作函数并设置一系列属性。
-
-这导致在代码中多次重复引用对象的名称，增加了不必要的文本噪音。一个常见的解决方案是在创建对象时，在构造函数传入一个表，该表包含要覆盖设置的键和值的集合。这样做的缺点是该对象的构造函数必须支持这种初始化形式。
-
-with 块有助于简化编写这样的代码。在 with 块内，我们可以使用以 . 或 \ 开头的特殊语句，这些语句代表我们正在使用的对象的操作。
-
-例如，我们可以这样处理一个新创建的对象：
-
-```yuescript
-with Person!
-  .name = "Oswald"
-  \add_relative my_dad
-  \save!
-  print .name
-```
-<YueDisplay>
-
-```yue
-with Person!
-  .name = "Oswald"
-  \add_relative my_dad
-  \save!
-  print .name
-```
-
-</YueDisplay>
-
-with 语句也可以用作一个表达式，并返回它的代码块正在处理的对象。
-
-```yuescript
-file = with File "favorite_foods.txt"
-  \set_encoding "utf8"
-```
-<YueDisplay>
-
-```yue
-file = with File "favorite_foods.txt"
-  \set_encoding "utf8"
-```
-
-</YueDisplay>
-
-或者…
-
-```yuescript
-create_person = (name,  relatives) ->
-  with Person!
-    .name = name
-    \add_relative relative for relative in *relatives
-
-me = create_person "Leaf", [dad, mother, sister]
-```
-<YueDisplay>
-
-```yue
-create_person = (name,  relatives) ->
-  with Person!
-    .name = name
-    \add_relative relative for relative in *relatives
-
-me = create_person "Leaf", [dad, mother, sister]
-```
-
-</YueDisplay>
-
-在此用法中，with 可以被视为K组合子（k-combinator）的一种特殊形式。
-
-如果你想给表达式另外起一个名称的话，with 语句中的表达式也可以是一个赋值语句。
-
-```yuescript
-with str := "你好"
-  print "原始:", str
-  print "大写:", \upper!
-```
-<YueDisplay>
-
-```yue
-with str := "你好"
-  print "原始:", str
-  print "大写:", \upper!
-```
-
-</YueDisplay>
-
-你可以在 `with` 语句中使用 `[]` 访问特殊键。
-
-```yuescript
-with tb
-  [1] = 1
-  print [2]
-  with [abc]
-    [3] = [2]\func!
-    ["key-name"] = value
-  [] = "abc" -- 追加到 "tb"
-```
-<YueDisplay>
-
-```yue
-with tb
-  [1] = 1
-  print [2]
-  with [abc]
-    [3] = [2]\func!
-    ["key-name"] = value
-  [] = "abc" -- 追加到 "tb"
-```
-
-</YueDisplay>
-
-`with?` 是 `with` 语法的一个增强版本，引入了存在性检查，用于在不显式判空的情况下安全访问可能为 nil 的对象。
-
-```yuescript
-with? obj
-  print obj.name
-```
-<YueDisplay>
-
-```yue
-with? obj
-  print obj.name
-```
-
-</YueDisplay>
-
-## do 语句
-
-当用作语句时，do 语句的作用就像在 Lua 中差不多。
-
-```yuescript
-do
-  var = "hello"
-  print var
-print var -- 这里是nil
-```
-<YueDisplay>
-
-```yue
-do
-  var = "hello"
-  print var
-print var -- 这里是nil
-```
-
-</YueDisplay>
-
-月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将 do 语句代码块的最后一个语句作为表达式返回的结果。
-
-```yuescript
-counter = do
-  i = 0
-  ->
-    i += 1
-    i
-
-print counter!
-print counter!
-```
-<YueDisplay>
-
-```yue
-counter = do
-  i = 0
-  ->
-    i += 1
-    i
-
-print counter!
-print counter!
-```
-
-</YueDisplay>
-
-```yuescript
-tbl = {
-  key: do
-    print "分配键值!"
-    1234
-}
-```
-<YueDisplay>
-
-```yue
-tbl = {
-  key: do
-    print "分配键值!"
-    1234
-}
-```
-
-</YueDisplay>
-
-## 函数存根
-
-在编程中，将对象的方法作为函数类型的值进行传递是一种常见做法，尤其是在将实例方法作为回调函数传递给其他函数的情形中。当目标函数需要将该对象作为其第一个参数时，我们需要找到一种方式将对象和函数绑定在一起，以便能够正确地调用该函数。
-
-函数存根（stub）语法提供了一种便捷的方法来创建一个新的闭包函数，这个函数将对象和原函数绑定在一起。这样，当调用这个新创建的函数时，它会在正确的对象上下文中执行原有的函数。
-
-这种语法类似于使用 \ 操作符调用实例方法的方式，区别在于，这里不需要在 \ 操作符后面附加参数列表。
-
-```yuescript
-my_object = {
-  value: 1000
-  write: => print "值为:", @value
-}
-
-run_callback = (func) ->
-  print "运行回调..."
-  func!
-
--- 这样写不起作用：
--- 函数没有引用my_object
-run_callback my_object.write
-
--- 函数存根语法
--- 让我们把对象捆绑到一个新函数中
-run_callback my_object\write
-```
-<YueDisplay>
-
-```yue
-my_object = {
-  value: 1000
-  write: => print "值为:", @value
-}
-
-run_callback = (func) ->
-  print "运行回调..."
-  func!
-
--- 这样写不起作用：
--- 函数没有引用my_object
-run_callback my_object.write
-
--- 函数存根语法
--- 让我们把对象捆绑到一个新函数中
-run_callback my_object\write
-```
-
-</YueDisplay>
-
-## 使用 using 语句：防止破坏性赋值
-
-Lua 的变量作用域是降低代码复杂度的重要工具。然而，随着代码量的增加，维护这些变量可能变得更加困难。比如，看看下面的代码片段：
-
-```yuescript
-i = 100
-
--- 许多代码行...
-
-my_func = ->
-  i = 10
-  while i > 0
-    print i
-    i -= 1
-
-my_func!
-
-print i -- 将打印 0
-```
-<YueDisplay>
-
-```yue
-i = 100
-
--- 许多代码行...
-
-my_func = ->
-  i = 10
-  while i > 0
-    print i
-    i -= 1
-
-my_func!
-
-print i -- 将打印 0
-```
-
-</YueDisplay>
-
-在 `my_func` 中，我们不小心覆盖了变量 `i` 的值。虽然在这个例子中这个问题很明显，但在一个庞大的或者是由多人共同维护的代码库中，很难追踪每个变量的声明情况。
-
-如果我们可以明确指出哪些变量是我们想在当前作用域内修改的，并且防止我们不小心更改了其他作用域中同名的变量，那将大有裨益。
-
-`using` 语句就是为此而生。`using nil` 确保函数内部的赋值不会意外地影响到外部作用域的变量。我们只需将 `using` 子句放在函数的参数列表之后；若函数没有参数，则直接放在括号内即可。
-
-```yuescript
-i = 100
-
-my_func = (using nil) ->
-  i = "hello" -- 这里创建了一个新的局部变量
-
-my_func!
-print i -- 打印 100，i 没有受到影响
-```
-<YueDisplay>
-
-```yue
-i = 100
-
-my_func = (using nil) ->
-  i = "hello" -- 这里创建了一个新的局部变量
-
-my_func!
-print i -- 打印 100，i 没有受到影响
-```
-
-</YueDisplay>
-
-using子句中可以填写多个用逗号分隔名称。指定可以访问和修改的外部变量的名称：
-
-```yuescript
-tmp = 1213
-i, k = 100, 50
-
-my_func = (add using k, i) ->
-  tmp = tmp + add -- 创建了一个新的局部tmp
-  i += tmp
-  k += tmp
-
-my_func(22)
-print i, k -- 这些已经被更新
-```
-<YueDisplay>
-
-```yue
-tmp = 1213
-i, k = 100, 50
-
-my_func = (add using k, i) ->
-  tmp = tmp + add -- 创建了一个新的局部tmp
-  i += tmp
-  k += tmp
-
-my_func(22)
-print i, k -- 这些已经被更新
-```
-
-</YueDisplay>
-
-## 月之脚本语言库
-
-使用 `require("yue")` 来访问。
-
-### yue
-
-**描述：**
-
-月之脚本语言库。
-
-#### version
-
-**类型：** 成员变量。
-
-**描述：**
-
-月之脚本版本。
-
-**签名：**
-```lua
-version: string
-```
-
-#### dirsep
-
-**类型：** 成员变量。
-
-**描述：**
-
-当前平台的文件分隔符。
-
-**签名：**
-```lua
-dirsep: string
-```
-
-#### yue_compiled
-
-**类型：** 成员变量。
-
-**描述：**
-
-编译模块代码缓存。
-
-**签名：**
-```lua
-yue_compiled: {string: string}
-```
-
-#### to_lua
-
-**类型：** 函数。
-
-**描述：**
-
-月之脚本的编译函数。它将 YueScript 代码编译为 Lua 代码。
-
-**签名：**
-```lua
-to_lua: function(code: string, config?: Config):
-    --[[codes]] string | nil,
-    --[[error]] string | nil,
-    --[[globals]] {{string, integer, integer}} | nil
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| code | string | YueScript 代码。 |
-| config | Config | [可选] 编译器选项。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| string \| nil | 编译后的 Lua 代码，如果编译失败则为 nil。 |
-| string \| nil | 错误消息，如果编译成功则为 nil。 |
-| {{string, integer, integer}} \| nil | 代码中出现的全局变量（带有名称、行和列），如果编译器选项 `lint_global` 为 false 则为 nil。 |
-
-#### file_exist
-
-**类型：** 函数。
-
-**描述：**
-
-检查源文件是否存在的函数。可以覆盖该函数以自定义行为。
-
-**签名：**
-```lua
-file_exist: function(filename: string): boolean
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| boolean | 文件是否存在。 |
-
-#### read_file
-
-**类型：** 函数。
-
-**描述：**
-
-读取源文件的函数。可以覆盖该函数以自定义行为。
-
-**签名：**
-```lua
-read_file: function(filename: string): string
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| string | 文件内容。 |
-
-#### insert_loader
-
-**类型：** 函数。
-
-**描述：**
-
-将 YueScript 加载器插入到 Lua 包加载器（搜索器）中。
-
-**签名：**
-```lua
-insert_loader: function(pos?: integer): boolean
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| pos | integer | [可选] 要插入加载器的位置。默认为 3。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| boolean | 是否成功插入加载器。如果加载器已经插入，则返回失败。 |
-
-#### remove_loader
-
-**类型：** 函数。
-
-**描述：**
-
-从 Lua 包加载器（搜索器）中移除 YueScript 加载器。
-
-**签名：**
-```lua
-remove_loader: function(): boolean
-```
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| boolean | 是否成功移除加载器。如果加载器未插入，则返回失败。 |
-
-#### loadstring
-
-**类型：** 函数。
-
-**描述：**
-
-将 YueScript 代码字符串加载为一个函数。
-
-**签名：**
-```lua
-loadstring: function(input: string, chunkname: string, env: table, config?: Config):
-    --[[loaded function]] nil | function(...: any): (any...),
-    --[[error]] string | nil
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| input | string | YueScript 代码。 |
-| chunkname | string | 代码块的名称。 |
-| env | table | 环境表。 |
-| config | Config | [可选] 编译器选项。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
-
-#### loadstring
-
-**类型：** 函数。
-
-**描述：**
-
-将 YueScript 代码字符串加载为一个函数。
-
-**签名：**
-```lua
-loadstring: function(input: string, chunkname: string, config?: Config):
-    --[[loaded function]] nil | function(...: any): (any...),
-    --[[error]] string | nil
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| input | string | YueScript 代码。 |
-| chunkname | string | 代码块的名称。 |
-| config | Config | [可选] 编译器选项。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
-
-#### loadstring
-
-**类型：** 函数。
-
-**描述：**
-
-将 YueScript 代码字符串加载为一个函数。
-
-**签名：**
-```lua
-loadstring: function(input: string, config?: Config):
-    --[[loaded function]] nil | function(...: any): (any...),
-    --[[error]] string | nil
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| input | string | YueScript 代码。 |
-| config | Config | [可选] 编译器选项。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
-
-#### loadfile
-
-**类型：** 函数。
-
-**描述：**
-
-将 YueScript 代码文件加载为一个函数。
-
-**签名：**
-```lua
-loadfile: function(filename: string, env: table, config?: Config):
-    nil | function(...: any): (any...),
-    string | nil
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-| env | table | 环境表。 |
-| config | Config | [可选] 编译器选项。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
-
-#### loadfile
-
-**类型：** 函数。
-
-**描述：**
-
-将 YueScript 代码文件加载为一个函数。
-
-**签名：**
-```lua
-loadfile: function(filename: string, config?: Config):
-    nil | function(...: any): (any...),
-    string | nil
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-| config | Config | [可选] 编译器选项。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| function \| nil | 加载的函数，如果加载失败则为 nil。 |
-| string \| nil | 错误消息，如果加载成功则为 nil。 |
-
-#### dofile
-
-**类型：** 函数。
-
-**描述：**
-
-将 YueScript 代码文件加载为一个函数并执行。
-
-**签名：**
-```lua
-dofile: function(filename: string, env: table, config?: Config): any...
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-| env | table | 环境表。 |
-| config | Config | [可选] 编译器选项。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| any... | 加载的函数执行后的返回值。 |
-
-#### dofile
-
-**类型：** 函数。
-
-**描述：**
-
-将 YueScript 代码文件加载为一个函数并执行。
-
-**签名：**
-```lua
-dofile: function(filename: string, config?: Config): any...
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| filename | string | 文件名。 |
-| config | Config | [可选] 编译器选项。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| any... | 加载的函数执行后的返回值。 |
-
-#### find_modulepath
-
-**类型：** 函数。
-
-**描述：**
-
-将 YueScript 模块名解析为文件路径。
-
-**签名：**
-```lua
-find_modulepath: function(name: string): string
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| name | string | 模块名。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| string | 文件路径。 |
-
-#### pcall
-
-**类型：** 函数。
-
-**描述：**
-
-在保护模式下调用一个函数。
-会捕获任何错误，执行成功则返回成功状态和结果，否则为失败状态和错误信息。
-当发生错误时，将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
-
-**签名：**
-```lua
-pcall: function(f: function, ...: any): boolean, any...
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| f | function | 要调用的函数。 |
-| ... | any | 要传递给函数的参数。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| boolean, ... | 状态码和函数结果或错误信息。 |
-
-#### require
-
-**类型：** 函数。
-
-**描述：**
-
-加载给定的模块。可以是 Lua 模块或 YueScript 模块。
-如果模块是 YueScript 模块且加载失败，则将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
-
-**签名：**
-```lua
-require: function(name: string): any...
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| modname | string | 要加载的模块名。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| any | 如果模块已经加载，则返回 package.loaded[modname] 中存储的值。否则，尝试查找加载器并返回 package.loaded[modname] 的最终值和加载器数据作为第二个结果。 |
-
-#### p
-
-**类型：** 函数。
-
-**描述：**
-
-检查传递的值的内部结构，并打印值出它的字符串表示。
-
-**签名：**
-```lua
-p: function(...: any)
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| ... | any | 要检查的值。 |
-
-#### options
-
-**类型：** 成员变量。
-
-**描述：**
-
-当前编译器选项。
-
-**签名：**
-```lua
-options: Config.Options
-```
-
-#### traceback
-
-**类型：** 函数。
-
-**描述：**
-
-重写堆栈跟踪中的行号为 YueScript 代码中的原始行号的 traceback 函数。
-
-**签名：**
-```lua
-traceback: function(message: string): string
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| message | string | 堆栈跟踪消息。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| string | 重写后的堆栈跟踪消息。 |
-
-#### is_ast
-
-**类型：** 函数。
-
-**描述：**
-
-检查代码是否匹配指定的 AST。
-
-**签名：**
-```lua
-is_ast: function(astName: string, code: string): boolean
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| astName | string | AST 名称。 |
-| code | string | 代码。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| boolean | 代码是否匹配 AST。 |
-
-#### AST
-
-**类型：** 成员变量。
-
-**描述：**
-
-AST 类型定义，带有名称、行、列和子节点。
-
-**签名：**
-```lua
-type AST = {string, integer, integer, any}
-```
-
-#### to_ast
-
-**类型：** 函数。
-
-**描述：**
-
-将代码转换为 AST。
-
-**签名：**
-```lua
-to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
-    --[[AST]] AST | nil,
-    --[[error]] nil | string
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| code | string | 代码。 |
-| flattenLevel | integer | [可选] 扁平化级别。级别越高，会消除更多的 AST 结构的嵌套。默认为 0。最大为 2。 |
-| astName | string | [可选] AST 名称。默认为 "File"。 |
-| reserveComment | boolean | [可选] 是否保留原始注释。默认为 false。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| AST \| nil | AST，如果转换失败则为 nil。 |
-| string \| nil | 错误消息，如果转换成功则为 nil。 |
-
-#### format
-
-**类型：** 函数。
-
-**描述：**
-
-格式化 YueScript 代码。
-
-**签名：**
-```lua
-format: function(code: string, tabSize?: number, reserveComment?: boolean): string
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| code | string | 代码。 |
-| tabSize | integer | [可选] 制表符大小。默认为 4。 |
-| reserveComment | boolean | [可选] 是否保留原始注释。默认为 true。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| string | 格式化后的代码。 |
-
-#### __call
-
-**类型：** 元方法。
-
-**描述：**
-
-导入 YueScript 模块。
-如果发生加载失败，则将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
-
-**签名：**
-```lua
-metamethod __call: function(self: yue, module: string): any...
-```
-
-**参数：**
-
-| 参数名 | 类型 | 描述 |
-| --- | --- | --- |
-| module | string | 模块名。 |
-
-**返回值：**
-
-| 返回类型 | 描述 |
-| --- | --- |
-| any | 模块值。 |
-
-### Config
-
-**描述：**
-
-编译器编译选项。
-
-#### lint_global
-
-**类型：** 成员变量。
-
-**描述：**
-
-编译器是否应该收集代码中出现的全局变量。
-
-**签名：**
-```lua
-lint_global: boolean
-```
-
-#### implicit_return_root
-
-**类型：** 成员变量。
-
-**描述：**
-
-编译器是否应该对根层级的代码块进行隐式的表达式返回。
-
-**签名：**
-```lua
-implicit_return_root: boolean
-```
-
-#### reserve_line_number
-
-**类型：** 成员变量。
-
-**描述：**
-
-编译器是否应该在编译后的代码中保留原始行号。
-
-**签名：**
-```lua
-reserve_line_number: boolean
-```
-
-#### reserve_comment
-
-**类型：** 成员变量。
-
-**描述：**
-
-编译器是否应该在编译后的代码中保留原始注释。
-
-**签名：**
-```lua
-reserve_comment: boolean
-```
-
-#### space_over_tab
-
-**类型：** 成员变量。
-
-**描述：**
-
-编译器是否应该在编译后的代码中使用空格字符而不是制表符字符。
-
-**签名：**
-```lua
-space_over_tab: boolean
-```
-
-#### same_module
-
-**类型：** 成员变量。
-
-**描述：**
-
-编译器是否应该将要编译的代码视为当前正在编译的模块。仅供编译器内部使用。
-
-**签名：**
-```lua
-same_module: boolean
-```
-
-#### line_offset
-
-**类型：** 成员变量。
-
-**描述：**
-
-编译器错误消息是否应该包含行号偏移量。仅供编译器内部使用。
-
-**签名：**
-```lua
-line_offset: integer
-```
-
-#### yue.Config.LuaTarget
-
-**类型：** 枚举。
-
-**描述：**
-
-目标 Lua 版本枚举。
-
-**签名：**
-```lua
-enum LuaTarget
-  "5.1"
-  "5.2"
-  "5.3"
-  "5.4"
-  "5.5"
-end
-```
-
-#### options
-
-**类型：** 成员变量。
-
-**描述：**
-
-要传递给编译函数的额外选项。
-
-**签名：**
-```lua
-options: Options
-```
-
-### Options
-
-**描述：**
-
-额外编译器选项定义。
-
-#### target
-
-**类型：** 成员变量。
-
-**描述：**
-
-编译目标 Lua 版本。
-
-**签名：**
-```lua
-target: LuaTarget
-```
-
-#### path
-
-**类型：** 成员变量。
-
-**描述：**
-
-额外模块搜索路径。
-
-**签名：**
-```lua
-path: string
-```
-
-#### dump_locals
-
-**类型：** 成员变量。
-
-**描述：**
-
-是否在回溯错误消息中输出代码块的局部变量。默认为 false。
-
-**签名：**
-```lua
-dump_locals: boolean
-```
-
-#### simplified
-
-**类型：** 成员变量。
-
-**描述：**
-
-是否简化输出的错误消息。默认为 true。
-
-**签名：**
-```lua
-simplified: boolean
-```
-
-## MIT 许可证
-
-版权 (c) 2017-2025 李瑾  \<dragon-fly@qq.com\>
-
-特此免费授予任何获得本软件副本和相关文档文件（下称“软件”）的人不受限制地处置该软件的权利，包括不受限制地使用、复制、修改、合并、发布、分发、转授许可和/或出售该软件副本，以及再授权被配发了本软件的人如上的权利，须在下列条件下：
-上述版权声明和本许可声明应包含在该软件的所有副本或实质成分中。
-本软件是“如此”提供的，没有任何形式的明示或暗示的保证，包括但不限于对适销性、特定用途的适用性和不侵权的保证。在任何情况下，作者或版权持有人都不对任何索赔、损害或其他责任负责，无论这些追责来自合同、侵权或其它行为中，还是产生于、源于或有关于本软件以及本软件的使用或其它处置。
-
-<CompilerModal />
+欢迎来到 <b>月之脚本（YueScript）</b> 官方文档！<br/>
+这里收录了语言特性、用法、参考示例和资源。<br/>
+请选择左侧的章节索引或目录，开启你的月之脚本之旅 ☽
diff --git a/doc/docs/zh/doc/installation.md b/doc/docs/zh/doc/installation.md
new file mode 100644
index 0000000..618da2a
--- /dev/null
+++ b/doc/docs/zh/doc/installation.md
@@ -0,0 +1,43 @@
+# 安装
+
+## Lua 模块
+
+&emsp;安装 [luarocks](https://luarocks.org)，一个 Lua 模块的包管理器。然后作为 Lua 模块和可执行文件安装它：
+
+```shell
+luarocks install yuescript
+```
+
+&emsp;或者你可以自己构建 `yue.so` 文件：
+
+```shell
+make shared LUAI=/usr/local/include/lua LUAL=/usr/local/lib/lua
+```
+
+&emsp;然后从路径 **bin/shared/yue.so** 获取二进制文件。
+
+## 构建二进制工具
+
+&emsp;克隆项目仓库，然后构建并安装可执行文件：
+
+```shell
+make install
+```
+
+&emsp;构建不带宏功能的月之脚本编译工具：
+
+```shell
+make install NO_MACRO=true
+```
+
+&emsp;构建不带内置Lua二进制文件的月之脚本编译工具：
+
+```shell
+make install NO_LUA=true
+```
+
+## 下载预编译的二进制程序
+
+&emsp;你可以下载预编译的二进制程序，包括兼容不同 Lua 版本的二进制可执行文件和库文件。
+
+&emsp;在[这里](https://github.com/IppClub/YueScript/releases)下载预编译的二进制程序。
diff --git a/doc/docs/zh/doc/introduction.md b/doc/docs/zh/doc/introduction.md
new file mode 100644
index 0000000..827d163
--- /dev/null
+++ b/doc/docs/zh/doc/introduction.md
@@ -0,0 +1,103 @@
+# 介绍
+
+月之脚本（YueScript）是一种动态语言，可以编译为 Lua。它是 [MoonScript](https://github.com/leafo/moonscript) 的方言。用月之脚本编写的代码既有表现力又非常简洁。它适合编写一些更易于维护的代码，并在嵌入 Lua 的环境中运行，如游戏或网站服务器。
+
+Yue（月）是中文中“月亮”的名称。
+
+## 月之脚本概览
+```yuescript
+-- 导入语法
+import p, to_lua from "yue"
+
+-- 隐式对象
+inventory =
+  equipment:
+    - "sword"
+    - "shield"
+  items:
+    - name: "potion"
+      count: 10
+    - name: "bread"
+      count: 3
+
+-- 列表推导
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
+-- 管道操作符
+[1, 2, 3]
+  |> map (x) -> x * 2
+  |> filter (x) -> x > 4
+  |> reduce 0, (a, b) -> a + b
+  |> print
+
+-- 元表操作
+apple =
+  size: 15
+  <index>:
+    color: 0x00ffff
+
+with apple
+  p .size, .color, .<index> if .<>?
+
+-- 类似js的导出语法
+export 🌛 = "月之脚本"
+```
+<YueDisplay>
+
+```yue
+-- 导入语法
+import p, to_lua from "yue"
+
+-- 隐式对象
+inventory =
+  equipment:
+    - "sword"
+    - "shield"
+  items:
+    - name: "potion"
+      count: 10
+    - name: "bread"
+      count: 3
+
+-- 列表推导
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
+-- 管道操作符
+[1, 2, 3]
+  |> map (x) -> x * 2
+  |> filter (x) -> x > 4
+  |> reduce 0, (a, b) -> a + b
+  |> print
+
+-- 元表操作
+apple =
+  size: 15
+  <index>:
+    color: 0x00ffff
+
+with apple
+  p .size, .color, .<index> if .<>?
+
+-- 类似js的导出语法
+export 🌛 = "月之脚本"
+```
+
+</YueDisplay>
+
+## 关于 Dora SSR
+
+月之脚本是与开源游戏引擎 [Dora SSR](https://github.com/Dora-SSR/Dora-SSR) 一起开发和维护的。它已被用于创建引擎工具、游戏原型和演示，在实际的游戏项目中验证其能力，同时它也帮助增强了 Dora SSR 游戏引擎的开发体验。
diff --git a/doc/docs/zh/doc/licence-mit.md b/doc/docs/zh/doc/licence-mit.md
new file mode 100644
index 0000000..1a07518
--- /dev/null
+++ b/doc/docs/zh/doc/licence-mit.md
@@ -0,0 +1,9 @@
+# MIT 许可证
+
+版权 (c) 2017-2026 李瑾  \<dragon-fly@qq.com\>
+
+特此免费授予任何获得本软件副本和相关文档文件（下称“软件”）的人不受限制地处置该软件的权利，包括不受限制地使用、复制、修改、合并、发布、分发、转授许可和/或出售该软件副本，以及再授权被配发了本软件的人如上的权利，须在下列条件下：
+上述版权声明和本许可声明应包含在该软件的所有副本或实质成分中。
+本软件是“如此”提供的，没有任何形式的明示或暗示的保证，包括但不限于对适销性、特定用途的适用性和不侵权的保证。在任何情况下，作者或版权持有人都不对任何索赔、损害或其他责任负责，无论这些追责来自合同、侵权或其它行为中，还是产生于、源于或有关于本软件以及本软件的使用或其它处置。
+
+<CompilerModal />
diff --git a/doc/docs/zh/doc/line-decorators.md b/doc/docs/zh/doc/line-decorators.md
new file mode 100644
index 0000000..86a1bd9
--- /dev/null
+++ b/doc/docs/zh/doc/line-decorators.md
@@ -0,0 +1,44 @@
+# 代码行修饰
+
+&emsp;&emsp;为了方便编写代码，循环语句和 if 语句可以应用于单行代码语句的末尾：
+
+```yuescript
+print "你好，世界" if name == "Rob"
+```
+<YueDisplay>
+
+```yue
+print "你好，世界" if name == "Rob"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;修饰 for 循环的示例：
+
+```yuescript
+print "项目: ", item for item in *items
+```
+<YueDisplay>
+
+```yue
+print "项目: ", item for item in *items
+```
+
+</YueDisplay>
+
+&emsp;&emsp;修饰 while 循环的示例：
+
+```yuescript
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+<YueDisplay>
+
+```yue
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/literals.md b/doc/docs/zh/doc/literals.md
new file mode 100644
index 0000000..1592bae
--- /dev/null
+++ b/doc/docs/zh/doc/literals.md
@@ -0,0 +1,111 @@
+# 字面量
+
+&emsp;&emsp;Lua 中的所有基本字面量都可以在月之脚本中使用。包括数字、字符串、布尔值和 **nil**。
+
+&emsp;&emsp;但与 Lua 不同的是，单引号和双引号字符串内部允许有换行：
+
+```yuescript
+some_string = "这是一个字符串
+  并包括一个换行。"
+
+-- 使用#{}语法可以将表达式插入到字符串字面量中。
+-- 字符串插值只在双引号字符串中可用。
+print "我有#{math.random! * 100}%的把握。"
+```
+<YueDisplay>
+
+```yue
+some_string = "这是一个字符串
+  并包括一个换行。"
+
+-- 使用#{}语法可以将表达式插入到字符串字面量中。
+-- 字符串插值只在双引号字符串中可用。
+print "我有#{math.random! * 100}%的把握。"
+```
+
+</YueDisplay>
+
+## 数字字面量
+
+&emsp;&emsp;你可以在数字字面量中使用下划线来增加可读性。
+
+```yuescript
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+<YueDisplay>
+
+
+```yue
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+
+</YueDisplay>
+
+## YAML 风格字符串
+
+&emsp;&emsp;使用 `|` 前缀标记一个多行 YAML 风格字符串：
+
+```yuescript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+<YueDisplay>
+
+```yue
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;其效果类似于原生 Lua 的多行拼接，所有文本（含换行）将被保留下来，并支持 `#{...}` 语法，通过 `tostring(expr)` 插入表达式结果。
+
+&emsp;&emsp;YAML 风格的多行字符串会自动检测首行后最小的公共缩进，并从所有行中删除该前缀空白字符。这让你可以在代码中对齐文本，但输出字符串不会带多余缩进。
+
+```yuescript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+<YueDisplay>
+
+```yue
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+</YueDisplay>
+
+&emsp;&emsp;输出字符串中的 foo: 对齐到行首，不会带有函数缩进空格。保留内部缩进的相对结构，适合书写结构化嵌套样式的内容。
+
+&emsp;&emsp;支持自动处理字符中的引号、反斜杠等特殊符号，无需手动转义：
+
+```yuescript
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+<YueDisplay>
+
+```yue
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/macro.md b/doc/docs/zh/doc/macro.md
new file mode 100644
index 0000000..924b3ab
--- /dev/null
+++ b/doc/docs/zh/doc/macro.md
@@ -0,0 +1,276 @@
+# 宏
+
+## 常见用法
+
+&emsp;&emsp;宏函数用于在编译时执行一段代码来生成新的代码，并将生成的代码插入到最终编译结果中。
+
+```yuescript
+macro PI2 = -> math.pi * 2
+area = $PI2 * 5
+
+macro HELLO = -> "'你好 世界'"
+print $HELLO
+
+macro config = (debugging) ->
+  global debugMode = debugging == "true"
+  ""
+
+macro asserts = (cond) ->
+  debugMode and "assert #{cond}" or ""
+
+macro assert = (cond) ->
+  debugMode and "assert #{cond}" or "#{cond}"
+
+$config true
+$asserts item ~= nil
+
+$config false
+value = $assert item
+
+-- 宏函数参数传递的表达式会被转换为字符串
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+<YueDisplay>
+
+```yue
+macro PI2 = -> math.pi * 2
+area = $PI2 * 5
+
+macro HELLO = -> "'你好 世界'"
+print $HELLO
+
+macro config = (debugging) ->
+  global debugMode = debugging == "true"
+  ""
+
+macro asserts = (cond) ->
+  debugMode and "assert #{cond}" or ""
+
+macro assert = (cond) ->
+  debugMode and "assert #{cond}" or "#{cond}"
+
+$config true
+$asserts item ~= nil
+
+$config false
+value = $assert item
+
+-- 宏函数参数传递的表达式会被转换为字符串
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+
+</YueDisplay>
+
+## 直接插入代码
+
+&emsp;&emsp;宏函数可以返回一个包含月之脚本代码的字符串，或是一个包含 Lua 代码字符串的配置表。
+
+```yuescript
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+funcA = -> "无法访问宏生成月之脚本里定义的变量"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "无法访问宏生成 Lua 代码里定义的变量"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- raw字符串的开始和结束符号会自动被去除了再传入宏函数
+$lua[==[
+-- 插入原始Lua代码
+if cond then
+  print("输出")
+end
+]==]
+```
+<YueDisplay>
+
+```yue
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+funcA = -> "无法访问宏生成月之脚本里定义的变量"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "无法访问宏生成 Lua 代码里定义的变量"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- raw字符串的开始和结束符号会自动被去除了再传入宏函数
+$lua[==[
+-- 插入原始Lua代码
+if cond then
+  print("输出")
+end
+]==]
+```
+
+</YueDisplay>
+
+## 导出宏
+
+&emsp;&emsp;宏函数可以从一个模块中导出，并在另一个模块中导入。你必须将导出的宏函数放在一个单独的文件中使用，而且只有宏定义、宏导入和宏展开可以放入这个宏导出模块中。
+
+```yuescript
+-- 文件: utils.yue
+export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
+export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
+export macro foreach = (items, action) -> "for _ in *#{items}
+  #{action}"
+
+-- 文件 main.yue
+import "utils" as {
+  $, -- 表示导入所有宏的符号
+  $foreach: $each -- 重命名宏 $foreach 为 $each
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+```
+<YueDisplay>
+
+```yue
+-- 文件: utils.yue
+export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
+export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
+export macro foreach = (items, action) -> "for _ in *#{items}
+  #{action}"
+-- 文件 main.yue
+-- 在浏览器中不支持import函数，请在真实环境中尝试
+--[[
+import "utils" as {
+  $, -- 表示导入所有宏的符号
+  $foreach: $each -- 重命名宏 $foreach 为 $each
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+]]
+```
+
+</YueDisplay>
+
+## 内置宏
+
+&emsp;&emsp;月之脚本中有一些内置可以直接使用的宏，但你可以通过声明相同名称的宏来覆盖它们。
+
+```yuescript
+print $FILE -- 获取当前模块名称的字符串
+print $LINE -- 获取当前代码行数：2
+```
+<YueDisplay>
+
+```yue
+print $FILE -- 获取当前模块名称的字符串
+print $LINE -- 获取当前代码行数：2
+```
+
+</YueDisplay>
+
+## 用宏生成宏
+
+&emsp;&emsp;在月之脚本中，宏函数允许你在编译时生成代码。通过嵌套的宏函数，你可以创建更复杂的生成模式。这个特性允许你定义一个宏函数，用它来生成另一个宏函数，从而实现更加动态的代码生成。
+
+```yuescript
+macro Enum = (...) ->
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
+
+macro BodyType = $Enum(
+  Static
+  Dynamic
+  Kinematic
+)
+
+print "有效的枚举类型:", $BodyType Static
+-- print "编译报错的枚举类型:", $BodyType Unknown
+```
+<YueDisplay>
+
+```yue
+macro Enum = (...) ->
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
+
+macro BodyType = $Enum(
+  Static
+  Dynamic
+  Kinematic
+)
+
+print "有效的枚举类型:", $BodyType Static
+-- print "编译报错的枚举类型:", $BodyType Unknown
+```
+
+</YueDisplay>
+
+## 宏参数检查
+
+&emsp;&emsp;可以直接在参数列表中声明期望的 AST 节点类型，并在编译时检查传入的宏参数是否符合预期。
+
+```yuescript
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hello"
+```
+<YueDisplay>
+
+```yue
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hello"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果需要做更加灵活的参数检查操作，可以使用内置的 `$is_ast` 宏函数在合适的位置进行手动检查。
+
+```yuescript
+macro printNumAndStr = (num, str) ->
+  error "expected Num as first argument" unless $is_ast Num, num
+  error "expected String as second argument" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hello"
+```
+<YueDisplay>
+
+```yue
+macro printNumAndStr = (num, str) ->
+  error "expected Num as first argument" unless $is_ast Num, num
+  error "expected String as second argument" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hello"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;更多关于可用 AST 节点的详细信息，请参考 [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp) 中大写的规则定义。
diff --git a/doc/docs/zh/doc/module.md b/doc/docs/zh/doc/module.md
new file mode 100644
index 0000000..bae6618
--- /dev/null
+++ b/doc/docs/zh/doc/module.md
@@ -0,0 +1,245 @@
+# 模块
+
+## 导入
+
+&emsp;&emsp;导入语句是一个语法糖，用于需要引入一个模块或者从已导入的模块中提取子项目。从模块导入的变量默认为不可修改的常量。
+
+```yuescript
+-- 用作表解构
+do
+  import insert, concat from table
+  -- 当给 insert, concat 变量赋值时，编译器会报告错误
+  import C, Ct, Cmt from require "lpeg"
+  -- 快捷写法引入模块的子项
+  import x, y, z from 'mymodule'
+  -- 使用Python风格的导入
+  from 'module' import a, b, c
+
+-- 快捷地导入一个模块
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- 导入模块后起一个别名使用，或是进行导入模块表的解构
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+<YueDisplay>
+
+```yue
+-- 用作表解构
+do
+  import insert, concat from table
+  -- 当给 insert, concat 变量赋值时，编译器会报告错误
+  import C, Ct, Cmt from require "lpeg"
+  -- 快捷写法引入模块的子项
+  import x, y, z from 'mymodule'
+  -- 使用Python风格的导入
+  from 'module' import a, b, c
+
+-- 快捷地导入一个模块
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- 导入模块后起一个别名使用，或是进行导入模块表的解构
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+</YueDisplay>
+
+## 导入全局变量
+
+&emsp;&emsp;你可以使用 `import` 将指定的全局变量导入到本地变量中。当导入一系列对全局变量的链式访问时，最后一个访问的字段将被赋值给本地变量。
+
+```yuescript
+do
+  import tostring
+  import table.concat
+  print concat ["a", tostring 1]
+```
+<YueDisplay>
+
+```yue
+do
+  import tostring
+  import table.concat
+  print concat ["a", tostring 1]
+```
+
+</YueDisplay>
+
+### 自动全局变量导入
+
+&emsp;&emsp;在一个代码块的顶部写 `import global`，会将当前作用域中尚未显式声明或赋值过的变量名，自动导入为本地常量，并在该语句的位置绑定到同名的全局变量。
+
+&emsp;&emsp;但是在同一作用域中被显式声明为全局的变量不会被自动导入，因此可以继续进行赋值操作。
+
+```yuescript
+do
+  import global
+  print "hello"
+  math.random 3
+  -- print = nil -- 报错：自动导入的全局变量为常量
+
+do
+  -- 被显式声明为全局的变量不会被自动导入
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+<YueDisplay>
+
+```yue
+do
+  import global
+  print "hello"
+  math.random 3
+  -- print = nil -- 报错：自动导入的全局变量是常量
+
+do
+  -- 被显式声明为全局的变量不会被自动导入
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+
+</YueDisplay>
+
+## 导出
+
+&emsp;&emsp;导出语句提供了一种简洁的方式来定义当前的模块。
+
+### 命名导出
+
+&emsp;&emsp;带命名的导出将定义一个局部变量，并在导出的表中添加一个同名的字段。
+
+```yuescript
+export a, b, c = 1, 2, 3
+export cool = "cat"
+
+export What = if this
+  "abc"
+else
+  "def"
+
+export y = ->
+  hallo = 3434
+
+export class Something
+  umm: "cool"
+```
+<YueDisplay>
+
+```yue
+export a, b, c = 1, 2, 3
+export cool = "cat"
+
+export What = if this
+  "abc"
+else
+  "def"
+
+export y = ->
+  hallo = 3434
+
+export class Something
+  umm: "cool"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;使用解构进行命名导出。
+
+```yuescript
+export :loadstring, to_lua: tolua = yue
+export {itemA: {:fieldA = '默认值'}} = tb
+```
+<YueDisplay>
+
+```yue
+export :loadstring, to_lua: tolua = yue
+export {itemA: {:fieldA = '默认值'}} = tb
+```
+
+</YueDisplay>
+
+&emsp;&emsp;从模块导出命名项目时，可以不用创建局部变量。
+
+```yuescript
+export.itemA = tb
+export.<index> = items
+export["a-b-c"] = 123
+```
+<YueDisplay>
+
+```yue
+export.itemA = tb
+export.<index> = items
+export["a-b-c"] = 123
+```
+
+</YueDisplay>
+
+### 未命名导出
+
+&emsp;&emsp;未命名导出会将要导出的目标项目添加到导出表的数组部分。
+
+```yuescript
+d, e, f = 3, 2, 1
+export d, e, f
+
+export if this
+  123
+else
+  456
+
+export with tmp
+  j = 2000
+```
+<YueDisplay>
+
+```yue
+d, e, f = 3, 2, 1
+export d, e, f
+
+export if this
+  123
+else
+  456
+
+export with tmp
+  j = 2000
+```
+
+</YueDisplay>
+
+### 默认导出
+
+&emsp;&emsp;在导出语句中使用 **default** 关键字，来替换导出的表为一个目标的对象。
+
+```yuescript
+export default ->
+  print "你好"
+  123
+```
+<YueDisplay>
+
+```yue
+export default ->
+  print "你好"
+  123
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/object-oriented-programming.md b/doc/docs/zh/doc/object-oriented-programming.md
new file mode 100644
index 0000000..9eb94d8
--- /dev/null
+++ b/doc/docs/zh/doc/object-oriented-programming.md
@@ -0,0 +1,550 @@
+# 面向对象编程
+
+&emsp;&emsp;在以下的示例中，月之脚本生成的 Lua 代码可能看起来会很复杂。所以最好主要关注月之脚本代码层面的意义，然后如果你想知道关于面向对象功能的实现细节，再查看 Lua 代码。
+
+&emsp;&emsp;一个简单的类：
+
+```yuescript
+class Inventory
+  new: =>
+    @items = {}
+
+  add_item: (name) =>
+    if @items[name]
+      @items[name] += 1
+    else
+      @items[name] = 1
+```
+<YueDisplay>
+
+```yue
+class Inventory
+  new: =>
+    @items = {}
+
+  add_item: (name) =>
+    if @items[name]
+      @items[name] += 1
+    else
+      @items[name] = 1
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在月之脚本中采用面向对象的编程方式时，通常会使用类声明语句结合 Lua 表格字面量来做类定义。这个类的定义包含了它的所有方法和属性。在这种结构中，键名为 “new” 的成员扮演了一个重要的角色，是作为构造函数来使用。
+
+&emsp;&emsp;值得注意的是，类中的方法都采用了粗箭头函数语法。当在类的实例上调用方法时，该实例会自动作为第一个参数被传入，因此粗箭头函数用于生成一个名为 “self” 的参数。
+
+&emsp;&emsp;此外，“@” 前缀在变量名上起到了简化作用，代表 “self”。例如，`@items` 就等同于 `self.items`。
+
+&emsp;&emsp;为了创建类的一个新实例，可以将类名当作一个函数来调用，这样就可以生成并返回一个新的实例。
+
+```yuescript
+inv = Inventory!
+inv\add_item "t-shirt"
+inv\add_item "pants"
+```
+<YueDisplay>
+
+
+```yue
+inv = Inventory!
+inv\add_item "t-shirt"
+inv\add_item "pants"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在月之脚本的类中，由于需要将类的实例作为参数传入到调用的方法中，因此使用了 **\\** 操作符做类的成员函数调用。
+
+&emsp;&emsp;需要特别注意的是，类的所有属性在其实例之间是共享的。这对于函数类型的成员属性通常不会造成问题，但对于其他类型的属性，可能会导致意外的结果。
+
+&emsp;&emsp;例如，在下面的示例中，clothes 属性在所有实例之间共享。因此，对这个属性在一个实例中的修改，将会影响到其他所有实例。
+
+```yuescript
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- 会同时打印出裤子和衬衫
+print item for item in *a.clothes
+```
+<YueDisplay>
+
+```yue
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- 会同时打印出裤子和衬衫
+print item for item in *a.clothes
+```
+
+</YueDisplay>
+
+&emsp;&emsp;避免这个问题的正确方法是在构造函数中创建对象的可变状态：
+
+```yuescript
+class Person
+  new: =>
+    @clothes = []
+```
+<YueDisplay>
+
+```yue
+class Person
+  new: =>
+    @clothes = []
+```
+
+</YueDisplay>
+
+## 继承
+
+&emsp;&emsp;`extends` 关键字可以在类声明中使用，以继承另一个类的属性和方法。
+
+```yuescript
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "背包已满"
+    super name
+```
+<YueDisplay>
+
+```yue
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "背包已满"
+    super name
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在这一部分，我们对月之脚本中的 `Inventory` 类进行了扩展，加入了对可以携带物品数量的限制。
+
+&emsp;&emsp;在这个特定的例子中，子类并没有定义自己的构造函数。因此，当创建一个新的实例时，系统会默认调用父类的构造函数。但如果我们在子类中定义了构造函数，我们可以利用 `super` 方法来调用并执行父类的构造函数。
+
+&emsp;&emsp;此外，当一个类继承自另一个类时，它会尝试调用父类上的 `__inherited` 方法（如果这个方法存在的话），以此来向父类发送通知。这个 `__inherited` 函数接受两个参数：被继承的父类和继承的子类。
+
+```yuescript
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "被", child.__name, "继承"
+
+-- 将打印: Shelf 被 Cupboard 继承
+class Cupboard extends Shelf
+```
+<YueDisplay>
+
+```yue
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "被", child.__name, "继承"
+
+-- 将打印: Shelf 被 Cupboard 继承
+class Cupboard extends Shelf
+```
+
+</YueDisplay>
+
+## super 关键字
+
+&emsp;&emsp;`super` 是一个特别的关键字，它有两种不同的使用方式：既可以当作一个对象来看待，也可以像调用函数那样使用。它仅在类的内部使用时具有特殊的功能。
+
+&emsp;&emsp;当 `super` 被作为一个函数调用时，它将调用父类中与之同名的函数。此时，当前的 `self` 会自动作为第一个参数传递，正如上面提到的继承示例所展示的那样。
+
+&emsp;&emsp;在将 `super` 当作普通值使用时，它实际上是对父类对象的引用。通过这种方式，我们可以访问父类中可能被子类覆盖的值，就像访问任何普通对象一样。
+
+&emsp;&emsp;此外，当使用 `\` 操作符与 `super` 一起使用时，`self`将被插入为第一个参数，而不是使用 `super` 本身的值。而在使用`.`操作符来检索函数时，则会返回父类中的原始函数。
+
+&emsp;&emsp;下面是一些使用 `super` 的不同方法的示例：
+
+```yuescript
+class MyClass extends ParentClass
+  a_method: =>
+    -- 以下效果相同：
+    super "你好", "世界"
+    super\a_method "你好", "世界"
+    super.a_method self, "你好", "世界"
+
+    -- super 作为值等于父类：
+    assert super == ParentClass
+```
+<YueDisplay>
+
+```yue
+class MyClass extends ParentClass
+  a_method: =>
+    -- 以下效果相同：
+    super "你好", "世界"
+    super\a_method "你好", "世界"
+    super.a_method self, "你好", "世界"
+
+    -- super 作为值等于父类：
+    assert super == ParentClass
+```
+
+</YueDisplay>
+
+&emsp;&emsp;**super** 也可以用在函数存根的左侧。唯一的主要区别是，生成的函数不是绑定到 super 的值，而是绑定到 self。
+
+## 类型
+
+&emsp;&emsp;每个类的实例都带有它的类型。这存储在特殊的 \_\_class 属性中。此属性会保存类对象。类对象是我们用来构建新实例的对象。我们还可以索引类对象以检索类方法和属性。
+
+```yuescript
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- 打印 10
+```
+<YueDisplay>
+
+```yue
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- 打印 10
+```
+
+</YueDisplay>
+
+## 类对象
+
+&emsp;&emsp;在月之脚本中，当我们编写类的定义语句时，实际上是在创建一个类对象。这个类对象被保存在一个与该类同名的变量中。
+
+&emsp;&emsp;类对象具有函数的特性，可以被调用来创建新的实例。这正是我们在之前示例中所展示的创建类实例的方式。
+
+&emsp;&emsp;一个类由两个表构成：类表本身和一个基表。基表作为所有实例的元表。在类声明中列出的所有属性都存放在基表中。
+
+&emsp;&emsp;如果在类对象的元表中找不到某个属性，系统会从基表中检索该属性。这就意味着我们可以直接从类本身访问到其方法和属性。
+
+&emsp;&emsp;需要特别注意的是，对类对象的赋值并不会影响到基表，因此这不是向实例添加新方法的正确方式。相反，需要直接修改基表。关于这点，可以参考下面的 “__base” 字段。
+
+&emsp;&emsp;此外，类对象包含几个特殊的属性：当类被声明时，类的名称会作为一个字符串存储在类对象的 “__name” 字段中。
+
+```yuescript
+print BackPack.__name -- 打印 Backpack
+```
+<YueDisplay>
+
+```yue
+print BackPack.__name -- 打印 Backpack
+```
+
+</YueDisplay>
+
+&emsp;&emsp;基础对象被保存在一个名为 `__base` 的特殊表中。我们可以编辑这个表，以便为那些已经创建出来的实例和还未创建的实例增加新的功能。
+
+&emsp;&emsp;另外，如果一个类是从另一个类派生而来的，那么其父类对象则会被存储在名为 `__parent` 的地方。这种机制允许在类之间实现继承和功能扩展。
+
+## 类变量
+
+&emsp;&emsp;我们可以直接在类对象中创建变量，而不是在类的基对象中，通过在类声明中的属性名前使用 @。
+
+```yuescript
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- 类变量在实例中不可见
+assert Things().some_func == nil
+```
+<YueDisplay>
+
+```yue
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- 类变量在实例中不可见
+assert Things().some_func == nil
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在表达式中，我们可以使用 @@ 来访问存储在 `self.__class` 中的值。因此，`@@hello` 是 `self.__class.hello` 的简写。
+
+```yuescript
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- 输出 2
+```
+<YueDisplay>
+
+```yue
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- 输出 2
+```
+
+</YueDisplay>
+
+&emsp;&emsp;@@ 的调用语义与 @ 类似。调用 @@ 时，会使用 Lua 的冒号语法将类作为第一个参数传入。
+
+```yuescript
+@@hello 1,2,3,4
+```
+<YueDisplay>
+
+```yue
+@@hello 1,2,3,4
+```
+
+</YueDisplay>
+
+## 类声明语句
+
+&emsp;&emsp;在类声明的主体中，除了键/值对外，我们还可以编写普通的表达式。在这种类声明体中的普通代码的上下文中，self 等于类对象，而不是实例对象。
+
+&emsp;&emsp;以下是创建类变量的另一种方法：
+
+```yuescript
+class Things
+  @class_var = "hello world"
+```
+<YueDisplay>
+
+```yue
+class Things
+  @class_var = "hello world"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这些表达式会在所有属性被添加到类的基对象后执行。
+
+&emsp;&emsp;在类的主体中声明的所有变量都会限制作用域只在类声明的范围。这对于放置只有类方法可以访问的私有值或辅助函数很方便：
+
+```yuescript
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "hello world: " .. secret
+```
+<YueDisplay>
+
+```yue
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "hello world: " .. secret
+```
+
+</YueDisplay>
+
+## @ 和 @@ 值
+
+&emsp;&emsp;当 @ 和 @@ 前缀在一个名字前时，它们分别代表在 self 和 self.\_\_class 中访问的那个名字。
+
+&emsp;&emsp;如果它们单独使用，它们是 self 和 self.\_\_class 的别名。
+
+```yuescript
+assert @ == self
+assert @@ == self.__class
+```
+<YueDisplay>
+
+```yue
+assert @ == self
+assert @@ == self.__class
+```
+
+</YueDisplay>
+
+&emsp;&emsp;例如，使用 @@ 从实例方法快速创建同一类的新实例的方法：
+
+```yuescript
+some_instance_method = (...) => @@ ...
+```
+<YueDisplay>
+
+```yue
+some_instance_method = (...) => @@ ...
+```
+
+</YueDisplay>
+
+## 构造属性提升
+
+&emsp;&emsp;为了减少编写简单值对象定义的代码。你可以这样简单写一个类：
+
+```yuescript
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- 这是以下声明的简写形式
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+<YueDisplay>
+
+```yue
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- 这是以下声明的简写形式
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你也可以使用这种语法为一个函数初始化传入对象的字段。
+
+```yuescript
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+<YueDisplay>
+
+```yue
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+</YueDisplay>
+
+## 类表达式
+
+&emsp;&emsp;类声明的语法也可以作为一个表达式使用，可以赋值给一个变量或者被返回语句返回。
+
+```yuescript
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+<YueDisplay>
+
+```yue
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+</YueDisplay>
+
+## 匿名类
+
+&emsp;&emsp;声明类时可以省略名称。如果类的表达式不在赋值语句中，\_\_name 属性将为 nil。如果出现在赋值语句中，赋值操作左侧的名称将代替 nil。
+
+```yuescript
+BigBucket = class extends Bucket
+  add_drop: => @drops += 10
+
+assert Bucket.__name == "BigBucket"
+```
+<YueDisplay>
+
+```yue
+BigBucket = class extends Bucket
+  add_drop: => @drops += 10
+
+assert Bucket.__name == "BigBucket"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你甚至可以省略掉主体，这意味着你可以这样写一个空白的匿名类：
+
+```yuescript
+x = class
+```
+<YueDisplay>
+
+```yue
+x = class
+```
+
+</YueDisplay>
+
+## 类混合
+
+&emsp;&emsp;你可以通过使用 `using` 关键字来实现类混合。这意味着你可以从一个普通 Lua 表格或已定义的类对象中，复制函数到你创建的新类中。当你使用普通 Lua 表格进行类混合时，你有机会用自己的实现来重写类的索引方法（例如元方法 `__index`）。然而，当你从一个类对象做混合时，需要注意的是该类对象的元方法将不会被复制到新类。
+
+```yuescript
+MyIndex = __index: var: 1
+
+class X using MyIndex
+  func: =>
+    print 123
+
+x = X!
+print x.var
+
+class Y using X
+
+y = Y!
+y\func!
+
+assert y.__class.__parent ~= X -- X 不是 Y 的父类
+```
+<YueDisplay>
+
+```yue
+MyIndex = __index: var: 1
+
+class X using MyIndex
+  func: =>
+    print 123
+
+x = X!
+print x.var
+
+class Y using X
+
+y = Y!
+y\func!
+
+assert y.__class.__parent ~= X -- X 不是 Y 的父类
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/operator.md b/doc/docs/zh/doc/operator.md
new file mode 100644
index 0000000..6c9fc5b
--- /dev/null
+++ b/doc/docs/zh/doc/operator.md
@@ -0,0 +1,461 @@
+# 操作符
+
+&emsp;&emsp;Lua 的所有二元和一元操作符在月之脚本中都是可用的。此外，**!=** 符号是 **~=** 的别名，而 **\\** 或 **::** 均可用于编写链式函数调用，如写作 `tb\func!` 或 `tb::func!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
+
+```yuescript
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+<YueDisplay>
+
+```yue
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+</YueDisplay>
+
+## 链式比较
+
+&emsp;&emsp;你可以在月之脚本中进行比较表达式的链式书写：
+
+```yuescript
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- 输出：true
+
+a = 5
+print 1 <= a <= 10
+-- 输出：true
+```
+<YueDisplay>
+
+```yue
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- 输出：true
+
+a = 5
+print 1 <= a <= 10
+-- 输出：true
+```
+
+</YueDisplay>
+
+&emsp;&emsp;可以注意一下链式比较表达式的求值行为：
+
+```yuescript
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  输出：
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  输出：
+  2
+  1
+  false
+]]
+```
+<YueDisplay>
+
+```yue
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  输出：
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  输出：
+  2
+  1
+  false
+]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在上面的例子里，中间的表达式 `v(2)` 仅被计算一次，如果把表达式写成 `v(1) < v(2) and v(2) <= v(3)` 的方式，中间的 `v(2)` 才会被计算两次。在链式比较中，求值的顺序往往是未定义的。所以强烈建议不要在链式比较中使用具有副作用（比如做打印操作）的表达式。如果需要使用有副作用的函数，应明确使用短路 `and` 运算符来做连接。
+
+## 表追加
+
+&emsp;&emsp;**[] =** 操作符用于向 Lua 表的最后插入值。
+
+```yuescript
+tab = []
+tab[] = "Value"
+```
+<YueDisplay>
+
+```yue
+tab = []
+tab[] = "Value"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你还可以使用展开操作符 `...` 来将一个列表中的所有元素追加到另一个列表中：
+
+```yuescript
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA 现在为 [1, 2, 3, 4, 5, 6]
+```
+<YueDisplay>
+
+```yue
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA 现在为 [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+## 表扩展
+
+&emsp;&emsp;你可以使用前置 `...` 操作符在 Lua 表中插入数组表或哈希表。
+
+```yuescript
+parts =
+  * "shoulders"
+  * "knees"
+lyrics =
+  * "head"
+  * ...parts
+  * "and"
+  * "toes"
+
+copy = {...other}
+
+a = {1, 2, 3, x: 1}
+b = {4, 5, y: 1}
+merge = {...a, ...b}
+```
+<YueDisplay>
+
+```yue
+parts =
+  * "shoulders"
+  * "knees"
+lyrics =
+  * "head"
+  * ...parts
+  * "and"
+  * "toes"
+
+copy = {...other}
+
+a = {1, 2, 3, x: 1}
+b = {4, 5, y: 1}
+merge = {...a, ...b}
+```
+
+</YueDisplay>
+
+## 表反向索引
+
+&emsp;&emsp;你可以使用 **#** 操作符来反向索引表中的元素。
+
+```yuescript
+last = data.items[#]
+second_last = data.items[#-1]
+data.items[#] = 1
+```
+<YueDisplay>
+
+```yue
+last = data.items[#]
+second_last = data.items[#-1]
+data.items[#] = 1
+```
+
+</YueDisplay>
+
+## 元表
+
+&emsp;&emsp;**<>** 操作符可提供元表操作的快捷方式。
+
+### 元表创建
+
+&emsp;&emsp;使用空括号 **<>** 或被 **<>** 包围的元方法键创建普通的 Lua 表。
+
+```yuescript
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+-- 使用与临时变量名相同的字段名，将临时变量赋值给元表
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "超出范围"
+```
+<YueDisplay>
+
+```yue
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+-- 使用与临时变量名相同的字段名，将临时变量赋值给元表
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "超出范围"
+```
+
+</YueDisplay>
+
+### 元表访问
+
+&emsp;&emsp;使用 **<>** 或被 **<>** 包围的元方法名或在 **<>** 中编写某些表达式来访问元表。
+
+```yuescript
+-- 使用包含字段 "value" 的元表创建
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+<YueDisplay>
+
+
+```yue
+-- 使用包含字段 "value" 的元表创建
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+
+</YueDisplay>
+
+### 元表解构
+
+&emsp;&emsp;使用被 **<>** 包围的元方法键解构元表。
+
+```yuescript
+{item, :new, :<close>, <index>: getter} = tb
+print item, new, close, getter
+```
+<YueDisplay>
+
+```yue
+{item, :new, :<close>, <index>: getter} = tb
+print item, new, close, getter
+```
+
+</YueDisplay>
+
+## 存在性
+
+&emsp;&emsp;**?** 运算符可以在多种上下文中用来检查存在性。
+
+```yuescript
+func?!
+print abc?["你好 世界"]?.xyz
+
+x = tab?.value
+len = utf8?.len or string?.len or (o) -> #o
+
+if print and x?
+  print x
+
+with? io.open "test.txt", "w"
+  \write "你好"
+  \close!
+```
+<YueDisplay>
+
+```yue
+func?!
+print abc?["你好 世界"]?.xyz
+
+x = tab?.value
+len = utf8?.len or string?.len or (o) -> #o
+
+if print and x?
+  print x
+
+with? io.open "test.txt", "w"
+  \write "你好"
+  \close!
+```
+
+</YueDisplay>
+
+## 管道
+
+&emsp;&emsp;与其使用一系列嵌套的函数调用，你还可以考虑使用运算符 **|>** 来传递值。
+
+```yuescript
+"你好" |> print
+1 |> print 2 -- 将管道项作为第一个参数插入
+2 |> print 1, _, 3 -- 带有占位符的管道
+
+-- 多行的管道表达式
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+<YueDisplay>
+
+```yue
+"你好" |> print
+1 |> print 2 -- 将管道项作为第一个参数插入
+2 |> print 1, _, 3 -- 带有占位符的管道
+-- 多行的管道表达式
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+</YueDisplay>
+
+## 空值合并
+
+&emsp;&emsp;如果其左操作数不是 **nil**，则nil合并运算符 **??** 返回其左操作数的值；否则，它将计算右操作数并返回其结果。如果左操作数计算结果为非 nil 的值，**??** 运算符将不再计算其右操作数。
+
+```yuescript
+local a, b, c, d
+a = b ?? c ?? d
+func a ?? {}
+
+a ??= false
+```
+<YueDisplay>
+
+```yue
+local a, b, c, d
+a = b ?? c ?? d
+func a ?? {}
+a ??= false
+```
+
+</YueDisplay>
+
+## 隐式对象
+
+&emsp;&emsp;你可以在表格块内使用符号 **\*** 或是 **-** 开始编写一系列隐式结构。如果你正在创建隐式对象，对象的字段必须具有相同的缩进。
+
+```yuescript
+-- 赋值时使用隐式对象
+list =
+  * 1
+  * 2
+  * 3
+
+-- 函数调用时使用隐式对象
+func
+  * 1
+  * 2
+  * 3
+
+-- 返回时使用隐式对象
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- 表格时使用隐式对象
+tb =
+  name: "abc"
+
+  values:
+    - "a"
+    - "b"
+    - "c"
+
+  objects:
+    - name: "a"
+      value: 1
+      func: => @value + 1
+      tb:
+        fieldA: 1
+
+    - name: "b"
+      value: 2
+      func: => @value + 2
+      tb: { }
+```
+<YueDisplay>
+
+```yue
+-- 赋值时使用隐式对象
+list =
+  * 1
+  * 2
+  * 3
+
+-- 函数调用时使用隐式对象
+func
+  * 1
+  * 2
+  * 3
+
+-- 返回时使用隐式对象
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- 表格时使用隐式对象
+tb =
+  name: "abc"
+
+  values:
+    - "a"
+    - "b"
+    - "c"
+
+  objects:
+    - name: "a"
+      value: 1
+      func: => @value + 1
+      tb:
+        fieldA: 1
+
+    - name: "b"
+      value: 2
+      func: => @value + 2
+      tb: { }
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/switch.md b/doc/docs/zh/doc/switch.md
new file mode 100644
index 0000000..700bc2a
--- /dev/null
+++ b/doc/docs/zh/doc/switch.md
@@ -0,0 +1,296 @@
+# switch 语句
+
+&emsp;&emsp;switch 语句是为了简化检查一系列相同值的if语句而提供的简写语法。要注意用于比较检查的目标值只会计算一次。和 if 语句一样，switch 语句在最后可以接一个 else 代码块来处理没有匹配的情况。在生成的 Lua 代码中，进行比较是使用 == 操作符完成的。switch 语句中也可以使用赋值表达式来储存临时变量值。
+
+```yuescript
+switch name := "Dan"
+  when "Robert"
+    print "你是Robert"
+  when "Dan", "Daniel"
+    print "你的名字是Dan"
+  else
+    print "我不认识你，你的名字是#{name}"
+```
+<YueDisplay>
+
+```yue
+switch name := "Dan"
+  when "Robert"
+    print "你是Robert"
+  when "Dan", "Daniel"
+    print "你的名字是Dan"
+  else
+    print "我不认识你，你的名字是#{name}"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;switch 语句的 when 子句中可以通过使用逗号分隔的列表来匹配多个值。
+
+&emsp;&emsp;switch 语句也可以作为表达式使用，下面我们可以将 switch 语句返回的结果分配给一个变量：
+
+```yuescript
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "数字数得太大了！"
+```
+<YueDisplay>
+
+```yue
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "数字数得太大了！"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;我们可以使用 then 关键字在 when 子句的同一行上编写处理代码。else 代码块的后续代码中要写在同一行上不需要额外的关键字。
+
+```yuescript
+msg = switch math.random(1, 5)
+  when 1 then "你很幸运"
+  when 2 then "你差点很幸运"
+  else "不太幸运"
+```
+<YueDisplay>
+
+```yue
+msg = switch math.random(1, 5)
+  when 1 then "你很幸运"
+  when 2 then "你差点很幸运"
+  else "不太幸运"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果在编写 switch 语句时希望少写一个缩进，那么你可以把第一个 when 子句放在 switch 开始语句的第一行，然后后续的子语句就都可以都少写一个缩进。
+
+```yuescript
+switch math.random(1, 5)
+  when 1
+    print "你很幸运" -- 两个缩进级别
+  else
+    print "不太幸运"
+
+switch math.random(1, 5) when 1
+  print "你很幸运" -- 一个缩进级别
+else
+  print "不太幸运"
+```
+<YueDisplay>
+
+```yue
+switch math.random(1, 5)
+  when 1
+    print "你很幸运" -- 两个缩进级别
+  else
+    print "不太幸运"
+
+switch math.random(1, 5) when 1
+  print "你很幸运" -- 一个缩进级别
+else
+  print "不太幸运"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;值得注意的是，在生成 Lua 代码时，我们要做检查的目标变量会放在 == 表达式的右侧。当你希望给 when 子句的比较对象定义一个 \_\_eq 元方法来重载判断逻辑时，可能会有用。
+
+## 表格匹配
+
+&emsp;&emsp;在 switch 的 when 子句中，如果期待检查目标是一个表格，且可以通过特定的结构进行解构并获得非 nil 值，那么你可以尝试使用表格匹配的语法。
+
+```yuescript
+items =
+  * x: 100
+    y: 200
+  * width: 300
+    height: 400
+
+for item in *items
+  switch item
+    when :x, :y
+      print "Vec2 #{x}, #{y}"
+    when :width, :height
+      print "尺寸 #{width}, #{height}"
+```
+<YueDisplay>
+
+```yue
+items =
+  * x: 100
+    y: 200
+  * width: 300
+    height: 400
+
+for item in *items
+  switch item
+    when :x, :y
+      print "Vec2 #{x}, #{y}"
+    when :width, :height
+      print "尺寸 #{width}, #{height}"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你可以使用默认值来选择性地解构表格的某些字段。
+
+```yuescript
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- 获取错误：尝试索引nil值（字段'pos'）
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- 表格解构仍然会通过
+```
+<YueDisplay>
+
+```yue
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- 获取错误：尝试索引nil值（字段'pos'）
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- 表格解构仍然会通过
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你也可以匹配数组元素、表格字段，甚至使用数组或表格字面量来匹配嵌套的结构。
+
+&emsp;&emsp;匹配数组元素。
+
+```yuescript
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- 变量b有默认值
+    print "1, 2, #{b}"
+```
+<YueDisplay>
+
+```yue
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- 变量b有默认值
+    print "1, 2, #{b}"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;匹配表格字段。
+
+```yuescript
+switch tb
+  when success: true, :result
+    print "成功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+```
+<YueDisplay>
+
+```yue
+switch tb
+  when success: true, :result
+    print "成功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;匹配嵌套的表格结构。
+
+```yuescript
+switch tb
+  when data: {type: "success", :content}
+    print "成功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+```
+<YueDisplay>
+
+```yue
+switch tb
+  when data: {type: "success", :content}
+    print "成功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;匹配表格数组。
+
+```yuescript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹配成功", fourth
+```
+<YueDisplay>
+
+```yue
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹配成功", fourth
+```
+
+</YueDisplay>
+
+&emsp;&emsp;匹配一个列表并捕获特定范围内的元素。
+
+```yuescript
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Group:", groups -- 打印: {"admin", "users"}
+    print "Resource:", resource -- 打印: "logs"
+    print "Action:", action -- 打印: "view"
+```
+<YueDisplay>
+
+```yue
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Group:", groups -- 打印: {"admin", "users"}
+    print "Resource:", resource -- 打印: "logs"
+    print "Action:", action -- 打印: "view"
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/table-literals.md b/doc/docs/zh/doc/table-literals.md
new file mode 100644
index 0000000..a111950
--- /dev/null
+++ b/doc/docs/zh/doc/table-literals.md
@@ -0,0 +1,168 @@
+# 表格字面量
+
+&emsp;&emsp;和 Lua 一样，表格可以通过花括号进行定义。
+
+```yuescript
+some_values = [1, 2, 3, 4]
+```
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;但与Lua不同的是，给表格中的键赋值是用 **:**（而不是 **=**）。
+
+```yuescript
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+<YueDisplay>
+
+```yue
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果只分配一个键值对的表格，可以省略花括号。
+
+```yuescript
+profile =
+  height: "4英尺",
+  shoe_size: 13,
+  favorite_foods: ["冰淇淋", "甜甜圈"]
+```
+<YueDisplay>
+
+```yue
+profile =
+  height: "4英尺",
+  shoe_size: 13,
+  favorite_foods: ["冰淇淋", "甜甜圈"]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;可以使用换行符而不使用逗号（或两者都用）来分隔表格中的值：
+
+```yuescript
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "超人"
+  occupation: "打击犯罪"
+}
+```
+<YueDisplay>
+
+```yue
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "超人"
+  occupation: "打击犯罪"
+}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;创建单行表格字面量时，也可以省略花括号：
+
+```yuescript
+my_function dance: "探戈", partner: "无"
+
+y = type: "狗", legs: 4, tails: 1
+```
+<YueDisplay>
+
+```yue
+my_function dance: "探戈", partner: "无"
+
+y = type: "狗", legs: 4, tails: 1
+```
+
+</YueDisplay>
+
+&emsp;&emsp;表格字面量的键可以使用 Lua 语言的关键字，而无需转义：
+
+```yuescript
+tbl = {
+  do: "某事"
+  end: "饥饿"
+}
+```
+<YueDisplay>
+
+```yue
+tbl = {
+  do: "某事"
+  end: "饥饿"
+}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果你要构造一个由变量组成的表，并希望键与变量名相同，那么可以使用 **:** 前缀操作符：
+
+```yuescript
+hair = "金色"
+height = 200
+person = { :hair, :height, shoe_size: 40 }
+
+print_table :hair, :height
+```
+<YueDisplay>
+
+```yue
+hair = "金色"
+height = 200
+person = { :hair, :height, shoe_size: 40 }
+
+print_table :hair, :height
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果你希望表中字段的键是某个表达式的结果，那么可以用 **[ ]** 包裹它，就像在 Lua 中一样。如果键中有任何特殊字符，也可以直接使用字符串字面量作为键，省略方括号。
+
+```yuescript
+t = {
+  [1 + 2]: "你好"
+  "你好 世界": true
+}
+```
+<YueDisplay>
+
+```yue
+t = {
+  [1 + 2]: "你好"
+  "你好 世界": true
+}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;Lua 的表同时具有数组部分和哈希部分，但有时候你会希望在书写 Lua 表时，对 Lua 表做数组和哈希不同用法的语义区分。然后你可以用 **[ ]** 而不是 **{ }** 来编写表示数组的 Lua 表，并且不允许在数组 Lua 表中写入任何键值对。
+
+```yuescript
+some_values = [ 1, 2, 3, 4 ]
+list_with_one_element = [ 1, ]
+```
+<YueDisplay>
+
+```yue
+some_values = [ 1, 2, 3, 4 ]
+list_with_one_element = [ 1, ]
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/the-using-clause-controlling-destructive-assignment.md b/doc/docs/zh/doc/the-using-clause-controlling-destructive-assignment.md
new file mode 100644
index 0000000..722de6f
--- /dev/null
+++ b/doc/docs/zh/doc/the-using-clause-controlling-destructive-assignment.md
@@ -0,0 +1,98 @@
+# 使用 using 语句：防止破坏性赋值
+
+&emsp;&emsp;Lua 的变量作用域是降低代码复杂度的重要工具。然而，随着代码量的增加，维护这些变量可能变得更加困难。比如，看看下面的代码片段：
+
+```yuescript
+i = 100
+
+-- 许多代码行...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- 将打印 0
+```
+<YueDisplay>
+
+```yue
+i = 100
+
+-- 许多代码行...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- 将打印 0
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在 `my_func` 中，我们不小心覆盖了变量 `i` 的值。虽然在这个例子中这个问题很明显，但在一个庞大的或者是由多人共同维护的代码库中，很难追踪每个变量的声明情况。
+
+&emsp;&emsp;如果我们可以明确指出哪些变量是我们想在当前作用域内修改的，并且防止我们不小心更改了其他作用域中同名的变量，那将大有裨益。
+
+&emsp;&emsp;`using` 语句就是为此而生。`using nil` 确保函数内部的赋值不会意外地影响到外部作用域的变量。我们只需将 `using` 子句放在函数的参数列表之后；若函数没有参数，则直接放在括号内即可。
+
+```yuescript
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- 这里创建了一个新的局部变量
+
+my_func!
+print i -- 打印 100，i 没有受到影响
+```
+<YueDisplay>
+
+```yue
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- 这里创建了一个新的局部变量
+
+my_func!
+print i -- 打印 100，i 没有受到影响
+```
+
+</YueDisplay>
+
+&emsp;&emsp;using子句中可以填写多个用逗号分隔名称。指定可以访问和修改的外部变量的名称：
+
+```yuescript
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- 创建了一个新的局部tmp
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- 这些已经被更新
+```
+<YueDisplay>
+
+```yue
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- 创建了一个新的局部tmp
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- 这些已经被更新
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/the-yuescript-library.md b/doc/docs/zh/doc/the-yuescript-library.md
new file mode 100644
index 0000000..54e26f7
--- /dev/null
+++ b/doc/docs/zh/doc/the-yuescript-library.md
@@ -0,0 +1,821 @@
+# 月之脚本语言库
+
+在 Lua 中使用 `local yue = require("yue")` 来访问。
+
+## yue
+
+**描述：**
+
+月之脚本语言库。
+
+### version
+
+**类型：** 成员变量。
+
+**描述：**
+
+月之脚本版本。
+
+**签名：**
+```lua
+version: string
+```
+
+### dirsep
+
+**类型：** 成员变量。
+
+**描述：**
+
+当前平台的文件分隔符。
+
+**签名：**
+```lua
+dirsep: string
+```
+
+### yue_compiled
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译模块代码缓存。
+
+**签名：**
+```lua
+yue_compiled: {string: string}
+```
+
+### to_lua
+
+**类型：** 函数。
+
+**描述：**
+
+月之脚本的编译函数。它将 YueScript 代码编译为 Lua 代码。
+
+**签名：**
+```lua
+to_lua: function(code: string, config?: Config):
+    --[[codes]] string | nil,
+    --[[error]] string | nil,
+    --[[globals]] {{string, integer, integer}} | nil
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| code | string | YueScript 代码。 |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| string \| nil | 编译后的 Lua 代码，如果编译失败则为 nil。 |
+| string \| nil | 错误消息，如果编译成功则为 nil。 |
+| {{string, integer, integer}} \| nil | 代码中出现的全局变量（带有名称、行和列），如果编译器选项 `lint_global` 为 false 则为 nil。 |
+
+### file_exist
+
+**类型：** 函数。
+
+**描述：**
+
+检查源文件是否存在的函数。可以覆盖该函数以自定义行为。
+
+**签名：**
+```lua
+file_exist: function(filename: string): boolean
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| filename | string | 文件名。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| boolean | 文件是否存在。 |
+
+### read_file
+
+**类型：** 函数。
+
+**描述：**
+
+读取源文件的函数。可以覆盖该函数以自定义行为。
+
+**签名：**
+```lua
+read_file: function(filename: string): string
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| filename | string | 文件名。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| string | 文件内容。 |
+
+### insert_loader
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 加载器插入到 Lua 包加载器（搜索器）中。
+
+**签名：**
+```lua
+insert_loader: function(pos?: integer): boolean
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| pos | integer | [可选] 要插入加载器的位置。默认为 3。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| boolean | 是否成功插入加载器。如果加载器已经插入，则返回失败。 |
+
+### remove_loader
+
+**类型：** 函数。
+
+**描述：**
+
+从 Lua 包加载器（搜索器）中移除 YueScript 加载器。
+
+**签名：**
+```lua
+remove_loader: function(): boolean
+```
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| boolean | 是否成功移除加载器。如果加载器未插入，则返回失败。 |
+
+### loadstring
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码字符串加载为一个函数。
+
+**签名：**
+```lua
+loadstring: function(input: string, chunkname: string, env: table, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| input | string | YueScript 代码。 |
+| chunkname | string | 代码块的名称。 |
+| env | table | 环境表。 |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil | 错误消息，如果加载成功则为 nil。 |
+
+### loadstring
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码字符串加载为一个函数。
+
+**签名：**
+```lua
+loadstring: function(input: string, chunkname: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| input | string | YueScript 代码。 |
+| chunkname | string | 代码块的名称。 |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil | 错误消息，如果加载成功则为 nil。 |
+
+### loadstring
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码字符串加载为一个函数。
+
+**签名：**
+```lua
+loadstring: function(input: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| input | string | YueScript 代码。 |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil | 错误消息，如果加载成功则为 nil。 |
+
+### loadfile
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码文件加载为一个函数。
+
+**签名：**
+```lua
+loadfile: function(filename: string, env: table, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| filename | string | 文件名。 |
+| env | table | 环境表。 |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil | 错误消息，如果加载成功则为 nil。 |
+
+### loadfile
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码文件加载为一个函数。
+
+**签名：**
+```lua
+loadfile: function(filename: string, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| filename | string | 文件名。 |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil | 错误消息，如果加载成功则为 nil。 |
+
+### dofile
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码文件加载为一个函数并执行。
+
+**签名：**
+```lua
+dofile: function(filename: string, env: table, config?: Config): any...
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| filename | string | 文件名。 |
+| env | table | 环境表。 |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| any... | 加载的函数执行后的返回值。 |
+
+### dofile
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码文件加载为一个函数并执行。
+
+**签名：**
+```lua
+dofile: function(filename: string, config?: Config): any...
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| filename | string | 文件名。 |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| any... | 加载的函数执行后的返回值。 |
+
+### find_modulepath
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 模块名解析为文件路径。
+
+**签名：**
+```lua
+find_modulepath: function(name: string): string
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| name | string | 模块名。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| string | 文件路径。 |
+
+### pcall
+
+**类型：** 函数。
+
+**描述：**
+
+在保护模式下调用一个函数。
+会捕获任何错误，执行成功则返回成功状态和结果，否则为失败状态和错误信息。
+当发生错误时，将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
+
+**签名：**
+```lua
+pcall: function(f: function, ...: any): boolean, any...
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| f | function | 要调用的函数。 |
+| ... | any | 要传递给函数的参数。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| boolean, ... | 状态码和函数结果或错误信息。 |
+
+### require
+
+**类型：** 函数。
+
+**描述：**
+
+加载给定的模块。可以是 Lua 模块或 YueScript 模块。
+如果模块是 YueScript 模块且加载失败，则将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
+
+**签名：**
+```lua
+require: function(name: string): any...
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| modname | string | 要加载的模块名。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| any | 如果模块已经加载，则返回 package.loaded[modname] 中存储的值。否则，尝试查找加载器并返回 package.loaded[modname] 的最终值和加载器数据作为第二个结果。 |
+
+### p
+
+**类型：** 函数。
+
+**描述：**
+
+检查传递的值的内部结构，并打印值出它的字符串表示。
+
+**签名：**
+```lua
+p: function(...: any)
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| ... | any | 要检查的值。 |
+
+### options
+
+**类型：** 成员变量。
+
+**描述：**
+
+当前编译器选项。
+
+**签名：**
+```lua
+options: Config.Options
+```
+
+### traceback
+
+**类型：** 函数。
+
+**描述：**
+
+重写堆栈跟踪中的行号为 YueScript 代码中的原始行号的 traceback 函数。
+
+**签名：**
+```lua
+traceback: function(message: string): string
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| message | string | 堆栈跟踪消息。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| string | 重写后的堆栈跟踪消息。 |
+
+### is_ast
+
+**类型：** 函数。
+
+**描述：**
+
+检查代码是否匹配指定的 AST。
+
+**签名：**
+```lua
+is_ast: function(astName: string, code: string): boolean
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| astName | string | AST 名称。 |
+| code | string | 代码。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| boolean | 代码是否匹配 AST。 |
+
+### AST
+
+**类型：** 成员变量。
+
+**描述：**
+
+AST 类型定义，带有名称、行、列和子节点。
+
+**签名：**
+```lua
+type AST = {string, integer, integer, any}
+```
+
+### to_ast
+
+**类型：** 函数。
+
+**描述：**
+
+将代码转换为 AST。
+
+**签名：**
+```lua
+to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
+    --[[AST]] AST | nil,
+    --[[error]] nil | string
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| code | string | 代码。 |
+| flattenLevel | integer | [可选] 扁平化级别。级别越高，会消除更多的 AST 结构的嵌套。默认为 0。最大为 2。 |
+| astName | string | [可选] AST 名称。默认为 "File"。 |
+| reserveComment | boolean | [可选] 是否保留原始注释。默认为 false。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| AST \| nil | AST，如果转换失败则为 nil。 |
+| string \| nil | 错误消息，如果转换成功则为 nil。 |
+
+### format
+
+**类型：** 函数。
+
+**描述：**
+
+格式化 YueScript 代码。
+
+**签名：**
+```lua
+format: function(code: string, tabSize?: number, reserveComment?: boolean): string
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| code | string | 代码。 |
+| tabSize | integer | [可选] 制表符大小。默认为 4。 |
+| reserveComment | boolean | [可选] 是否保留原始注释。默认为 true。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| string | 格式化后的代码。 |
+
+### __call
+
+**类型：** 元方法。
+
+**描述：**
+
+导入 YueScript 模块。
+如果发生加载失败，则将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
+
+**签名：**
+```lua
+metamethod __call: function(self: yue, module: string): any...
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| module | string | 模块名。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| any | 模块值。 |
+
+## Config
+
+**描述：**
+
+编译器编译选项。
+
+### lint_global
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该收集代码中出现的全局变量。
+
+**签名：**
+```lua
+lint_global: boolean
+```
+
+### implicit_return_root
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该对根层级的代码块进行隐式的表达式返回。
+
+**签名：**
+```lua
+implicit_return_root: boolean
+```
+
+### reserve_line_number
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该在编译后的代码中保留原始行号。
+
+**签名：**
+```lua
+reserve_line_number: boolean
+```
+
+### reserve_comment
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该在编译后的代码中保留原始注释。
+
+**签名：**
+```lua
+reserve_comment: boolean
+```
+
+### space_over_tab
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该在编译后的代码中使用空格字符而不是制表符字符。
+
+**签名：**
+```lua
+space_over_tab: boolean
+```
+
+### same_module
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该将要编译的代码视为当前正在编译的模块。仅供编译器内部使用。
+
+**签名：**
+```lua
+same_module: boolean
+```
+
+### line_offset
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器错误消息是否应该包含行号偏移量。仅供编译器内部使用。
+
+**签名：**
+```lua
+line_offset: integer
+```
+
+### yue.Config.LuaTarget
+
+**类型：** 枚举。
+
+**描述：**
+
+目标 Lua 版本枚举。
+
+**签名：**
+```lua
+enum LuaTarget
+  "5.1"
+  "5.2"
+  "5.3"
+  "5.4"
+  "5.5"
+end
+```
+
+### options
+
+**类型：** 成员变量。
+
+**描述：**
+
+要传递给编译函数的额外选项。
+
+**签名：**
+```lua
+options: Options
+```
+
+## Options
+
+**描述：**
+
+额外编译器选项定义。
+
+### target
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译目标 Lua 版本。
+
+**签名：**
+```lua
+target: LuaTarget
+```
+
+### path
+
+**类型：** 成员变量。
+
+**描述：**
+
+额外模块搜索路径。
+
+**签名：**
+```lua
+path: string
+```
+
+### dump_locals
+
+**类型：** 成员变量。
+
+**描述：**
+
+是否在回溯错误消息中输出代码块的局部变量。默认为 false。
+
+**签名：**
+```lua
+dump_locals: boolean
+```
+
+### simplified
+
+**类型：** 成员变量。
+
+**描述：**
+
+是否简化输出的错误消息。默认为 true。
+
+**签名：**
+```lua
+simplified: boolean
+```
diff --git a/doc/docs/zh/doc/try.md b/doc/docs/zh/doc/try.md
new file mode 100644
index 0000000..b4de24d
--- /dev/null
+++ b/doc/docs/zh/doc/try.md
@@ -0,0 +1,105 @@
+# 错误处理
+
+&emsp;&emsp;用于统一进行 Lua 错误处理的便捷语法。
+
+```yuescript
+try
+  func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try
+  func 1, 2, 3
+catch err
+  yue.traceback err
+
+try func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try func 1, 2, 3
+
+try
+  print "尝试中"
+  func 1, 2, 3
+
+-- 使用if赋值模式
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+<YueDisplay>
+
+```yue
+try
+  func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try
+  func 1, 2, 3
+catch err
+  yue.traceback err
+
+try func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try func 1, 2, 3
+
+try
+  print "尝试中"
+  func 1, 2, 3
+
+-- 使用if赋值模式
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+
+</YueDisplay>
+
+## 错误处理简化
+
+&emsp;&emsp;`try?` 是 `try` 的功能简化语法，它不再返回 `try` 语句的布尔状态，并在成功时直接返回 `try` 代码块的结果，失败时返回 `nil` 值而非错误对象。
+
+```yuescript
+a, b, c = try? func!
+
+-- 与空值合并运算符一起使用
+a = (try? func!) ?? "default"
+
+-- 作为函数参数
+f try? func!
+
+-- 带 catch 块的 try!
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+<YueDisplay>
+
+```yue
+a, b, c = try? func!
+
+-- 与空值合并运算符一起使用
+a = (try? func!) ?? "default"
+
+-- 作为函数参数
+f try? func!
+
+-- 带 catch 块的 try!
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/usage.md b/doc/docs/zh/doc/usage.md
new file mode 100644
index 0000000..b9d84d4
--- /dev/null
+++ b/doc/docs/zh/doc/usage.md
@@ -0,0 +1,110 @@
+# 使用方法
+
+## Lua 模块
+
+&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"
+          }
+        })
+        ```
+
+## 月之脚本编译工具
+
+&emsp;&emsp;使用月之脚本编译工具：
+
+```shell
+> yue -h
+命令行用法: yue
+         [选项] [<文件/目录>] ...
+         yue -e <代码或文件> [参数...]
+         yue -w [<目录>] [选项]
+         yue -
+
+说明:
+   - '-' 或 '--' 必须作为唯一且第一个参数，用于读取标准输入。
+   - '-o/--output' 不能与多个输入文件一起使用。
+   - '-w/--watch' 仅能用于目录，不能用于单个文件。
+   - 使用 '-e/--execute' 时，后续的参数将作为脚本参数传递。
+
+选项:
+   -h, --help                 显示帮助信息并退出
+   -e <字符串>, --execute <字符串>  执行文件或原始代码
+   -m, --minify               生成压缩（最小化）代码
+   -r, --rewrite              重写输出以匹配原始代码行号
+   -t <目标路径>, --output-to <目标路径>
+                              指定编译后文件的输出路径
+   -o <文件>, --output <文件>  将输出写入文件
+   -p, --print                输出到标准输出
+   -b, --benchmark            输出编译耗时（不写入文件）
+   -g, --globals              显示用到的全局变量及其所在的名称、行号、列号
+   -s, --spaces               用空格代替制表符(tab)输出代码
+   -l, --line-numbers         输出源代码的行号
+   -j, --no-implicit-return   禁用文件末尾的隐式返回
+   -c, --reserve-comments     保留源代码中的注释
+   -w [<目录>], --watch [<目录>]
+                              监视目录变化并自动编译
+   -v, --version              显示版本信息
+   -                          从标准输入读取，输出到标准输出（仅能作为唯一参数）
+   --                         等同于 '-'，为兼容旧版本保留
+
+   --target <版本>            指定生成代码的 Lua 版本 (只能为 5.1 ~ 5.5)
+   --path <路径字符串>         附加一个 Lua 搜索路径到 package.path
+   --<键>=<值>                以 key=value 形式传递编译器选项（保持已有用法）
+
+   不带选项直接运行可进入交互模式（REPL），在交互模式里输入单独的符号 '$'
+   可用于开始或结束多行模式。
+```
+
+&emsp;&emsp;使用案例：
+
+&emsp;&emsp;递归编译当前路径下扩展名为 **.yue** 的每个月之脚本文件： **yue .**
+
+&emsp;&emsp;编译并将结果保存到目标路径： **yue -t /target/path/ .**
+
+&emsp;&emsp;编译并保留调试信息： **yue -l .**
+
+&emsp;&emsp;编译并生成压缩代码： **yue -m .**
+
+&emsp;&emsp;直接执行代码： **yue -e 'print 123'**
+
+&emsp;&emsp;执行一个月之脚本文件： **yue -e main.yue**
diff --git a/doc/docs/zh/doc/varargs-assignment.md b/doc/docs/zh/doc/varargs-assignment.md
new file mode 100644
index 0000000..6cc4278
--- /dev/null
+++ b/doc/docs/zh/doc/varargs-assignment.md
@@ -0,0 +1,24 @@
+# 可变参数赋值
+
+&emsp;&emsp;你可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用 Lua 的方式访问其内容。
+
+```yuescript
+list = [1, 2, 3, 4, 5]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+<YueDisplay>
+
+```yue
+list = [1, 2, 3, 4, 5]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/while-loop.md b/doc/docs/zh/doc/while-loop.md
new file mode 100644
index 0000000..5995890
--- /dev/null
+++ b/doc/docs/zh/doc/while-loop.md
@@ -0,0 +1,69 @@
+# while 循环
+
+&emsp;&emsp;在月之脚本中的 while 循环支持几种不同的写法：
+
+```yuescript
+i = 10
+while i > 0
+  print i
+  i -= 1
+
+while running == true do my_function!
+```
+<YueDisplay>
+
+```yue
+i = 10
+while i > 0
+  print i
+  i -= 1
+
+while running == true do my_function!
+```
+
+</YueDisplay>
+
+```yuescript
+i = 10
+until i == 0
+  print i
+  i -= 1
+
+until running == false do my_function!
+```
+<YueDisplay>
+
+```yue
+i = 10
+until i == 0
+  print i
+  i -= 1
+until running == false do my_function!
+```
+
+</YueDisplay>
+
+&emsp;&emsp;像 for 循环的语法一样，while 循环也可以作为一个表达式使用。为了使函数返回 while 循环的累积列表值，必须明确使用返回语句返回 while 循环表达式。
+
+## repeat 循环
+
+&emsp;&emsp;repeat 循环是从 Lua 语言中搬过来的相似语法：
+
+```yuescript
+i = 10
+repeat
+  print i
+  i -= 1
+until i == 0
+```
+<YueDisplay>
+
+```yue
+i = 10
+repeat
+  print i
+  i -= 1
+until i == 0
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/whitespace.md b/doc/docs/zh/doc/whitespace.md
new file mode 100644
index 0000000..1886e23
--- /dev/null
+++ b/doc/docs/zh/doc/whitespace.md
@@ -0,0 +1,43 @@
+# 空白
+
+&emsp;&emsp;月之脚本是一个对空白敏感的语言。你必须在相同的缩进中使用空格 **' '** 或制表符 **'\t'** 来编写一些代码块，如函数体、值列表和一些控制块。包含不同空白的表达式可能意味着不同的事情。制表符被视为4个空格，但最好不要混合使用空格和制表符。
+
+## 语句分隔符
+
+&emsp;&emsp;一条语句通常以换行结束。你也可以使用分号 `;` 显式结束一条语句，从而在同一行中编写多条语句：
+
+```yuescript
+a = 1; b = 2; print a + b
+```
+<YueDisplay>
+
+```yue
+a = 1; b = 2; print a + b
+```
+
+</YueDisplay>
+
+## 多行链式调用
+
+&emsp;&emsp;你可以使用相同的缩进来编写多行链式函数调用。
+
+```yuescript
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x) -> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value) -> value .. '!'
+  \subscribe print
+```
+<YueDisplay>
+
+```yue
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x) -> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value) -> value .. '!'
+  \subscribe print
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/doc/with-statement.md b/doc/docs/zh/doc/with-statement.md
new file mode 100644
index 0000000..fbd3633
--- /dev/null
+++ b/doc/docs/zh/doc/with-statement.md
@@ -0,0 +1,126 @@
+# with 语句
+
+
+在编写 Lua 代码时，我们在创建对象后的常见操作是立即调用这个对象一系列操作函数并设置一系列属性。
+
+这导致在代码中多次重复引用对象的名称，增加了不必要的文本噪音。一个常见的解决方案是在创建对象时，在构造函数传入一个表，该表包含要覆盖设置的键和值的集合。这样做的缺点是该对象的构造函数必须支持这种初始化形式。
+
+with 块有助于简化编写这样的代码。在 with 块内，我们可以使用以 . 或 \ 开头的特殊语句，这些语句代表我们正在使用的对象的操作。
+
+例如，我们可以这样处理一个新创建的对象：
+
+```yuescript
+with Person!
+  .name = "Oswald"
+  \add_relative my_dad
+  \save!
+  print .name
+```
+<YueDisplay>
+
+```yue
+with Person!
+  .name = "Oswald"
+  \add_relative my_dad
+  \save!
+  print .name
+```
+
+</YueDisplay>
+
+with 语句也可以用作一个表达式，并返回它的代码块正在处理的对象。
+
+```yuescript
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+<YueDisplay>
+
+```yue
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+</YueDisplay>
+
+或者…
+
+```yuescript
+create_person = (name,  relatives) ->
+  with Person!
+    .name = name
+    \add_relative relative for relative in *relatives
+
+me = create_person "Leaf", [dad, mother, sister]
+```
+<YueDisplay>
+
+```yue
+create_person = (name,  relatives) ->
+  with Person!
+    .name = name
+    \add_relative relative for relative in *relatives
+
+me = create_person "Leaf", [dad, mother, sister]
+```
+
+</YueDisplay>
+
+在此用法中，with 可以被视为K组合子（k-combinator）的一种特殊形式。
+
+如果你想给表达式另外起一个名称的话，with 语句中的表达式也可以是一个赋值语句。
+
+```yuescript
+with str := "你好"
+  print "原始:", str
+  print "大写:", \upper!
+```
+<YueDisplay>
+
+```yue
+with str := "你好"
+  print "原始:", str
+  print "大写:", \upper!
+```
+
+</YueDisplay>
+
+你可以在 `with` 语句中使用 `[]` 访问特殊键。
+
+```yuescript
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- 追加到 "tb"
+```
+<YueDisplay>
+
+```yue
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- 追加到 "tb"
+```
+
+</YueDisplay>
+
+`with?` 是 `with` 语法的一个增强版本，引入了存在性检查，用于在不显式判空的情况下安全访问可能为 nil 的对象。
+
+```yuescript
+with? obj
+  print obj.name
+```
+<YueDisplay>
+
+```yue
+with? obj
+  print obj.name
+```
+
+</YueDisplay>
diff --git a/doc/docs/zh/index.md b/doc/docs/zh/index.md
index 9068956..ea42085 100644
--- a/doc/docs/zh/index.md
+++ b/doc/docs/zh/index.md
@@ -17,7 +17,6 @@ features:
     details: 管道、模式匹配、切片与解构，同时保留 Lua 互操作性。
   - title: 快速迭代
     details: 虚心接受用户反馈，以帮助改进和加速语言的开发和演进！
-footer: MIT Licensed | Copyright © 2017-2026 Li Jin
 ---
 
 ### 版权和协议