docs: add German and Portuguese (Brazil) localescodex/add-portuguese-and-german-language-support

35 files changed, 5553 insertions, 0 deletions

diff --git a/doc/docs/de/doc/assignment.md b/doc/docs/de/doc/assignment.md
new file mode 100644
index 0000000..4dac6f4
--- /dev/null
+++ b/doc/docs/de/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/de/doc/attributes.md b/doc/docs/de/doc/attributes.md
new file mode 100644
index 0000000..e6fd5a7
--- /dev/null
+++ b/doc/docs/de/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/de/doc/backcalls.md b/doc/docs/de/doc/backcalls.md
new file mode 100644
index 0000000..e34331e
--- /dev/null
+++ b/doc/docs/de/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/de/doc/comment.md b/doc/docs/de/doc/comment.md
new file mode 100644
index 0000000..b67c97d
--- /dev/null
+++ b/doc/docs/de/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/de/doc/comprehensions.md b/doc/docs/de/doc/comprehensions.md
new file mode 100644
index 0000000..3a92167
--- /dev/null
+++ b/doc/docs/de/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/de/doc/conditionals.md b/doc/docs/de/doc/conditionals.md
new file mode 100644
index 0000000..5ba81cf
--- /dev/null
+++ b/doc/docs/de/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/de/doc/continue.md b/doc/docs/de/doc/continue.md
new file mode 100644
index 0000000..b000765
--- /dev/null
+++ b/doc/docs/de/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/de/doc/destructuring-assignment.md b/doc/docs/de/doc/destructuring-assignment.md
new file mode 100644
index 0000000..e7b8046
--- /dev/null
+++ b/doc/docs/de/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], properties: {color: color}} = 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/de/doc/do.md b/doc/docs/de/doc/do.md
new file mode 100644
index 0000000..4990d6f
--- /dev/null
+++ b/doc/docs/de/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/de/doc/for-loop.md b/doc/docs/de/doc/for-loop.md
new file mode 100644
index 0000000..cabcde5
--- /dev/null
+++ b/doc/docs/de/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/de/doc/function-literals.md b/doc/docs/de/doc/function-literals.md
new file mode 100644
index 0000000..316e07c
--- /dev/null
+++ b/doc/docs/de/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/de/doc/function-stubs.md b/doc/docs/de/doc/function-stubs.md
new file mode 100644
index 0000000..57a8b0c
--- /dev/null
+++ b/doc/docs/de/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/de/doc/if-assignment.md b/doc/docs/de/doc/if-assignment.md
new file mode 100644
index 0000000..02984e8
--- /dev/null
+++ b/doc/docs/de/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/de/doc/index.md b/doc/docs/de/doc/index.md
new file mode 100755
index 0000000..3c4857f
--- /dev/null
+++ b/doc/docs/de/doc/index.md
@@ -0,0 +1,11 @@
+---
+title: Referenz
+---
+
+# YueScript-Dokumentation
+
+<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em; padding-bottom: 2em;"/>
+
+Willkommen in der offiziellen <b>YueScript</b>-Dokumentation!<br/>
+Hier findest du Sprachfeatures, Nutzung, Referenzbeispiele und Ressourcen.<br/>
+Bitte wähle ein Kapitel in der Seitenleiste, um mit YueScript zu beginnen.
diff --git a/doc/docs/de/doc/installation.md b/doc/docs/de/doc/installation.md
new file mode 100644
index 0000000..a93ddfd
--- /dev/null
+++ b/doc/docs/de/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/de/doc/introduction.md b/doc/docs/de/doc/introduction.md
new file mode 100644
index 0000000..a9a9389
--- /dev/null
+++ b/doc/docs/de/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/de/doc/licence-mit.md b/doc/docs/de/doc/licence-mit.md
new file mode 100644
index 0000000..f1d5d60
--- /dev/null
+++ b/doc/docs/de/doc/licence-mit.md
@@ -0,0 +1,23 @@
+# License: 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/de/doc/line-decorators.md b/doc/docs/de/doc/line-decorators.md
new file mode 100644
index 0000000..292bc77
--- /dev/null
+++ b/doc/docs/de/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/de/doc/literals.md b/doc/docs/de/doc/literals.md
new file mode 100644
index 0000000..e097c62
--- /dev/null
+++ b/doc/docs/de/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/de/doc/macro.md b/doc/docs/de/doc/macro.md
new file mode 100644
index 0000000..6d194c3
--- /dev/null
+++ b/doc/docs/de/doc/macro.md
@@ -0,0 +1,275 @@
+# 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/de/doc/module.md b/doc/docs/de/doc/module.md
new file mode 100644
index 0000000..c955092
--- /dev/null
+++ b/doc/docs/de/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/de/doc/object-oriented-programming.md b/doc/docs/de/doc/object-oriented-programming.md
new file mode 100644
index 0000000..6a8559e
--- /dev/null
+++ b/doc/docs/de/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/de/doc/operator.md b/doc/docs/de/doc/operator.md
new file mode 100644
index 0000000..9a2e89b
--- /dev/null
+++ b/doc/docs/de/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/de/doc/switch.md b/doc/docs/de/doc/switch.md
new file mode 100644
index 0000000..f503a80
--- /dev/null
+++ b/doc/docs/de/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/de/doc/table-literals.md b/doc/docs/de/doc/table-literals.md
new file mode 100644
index 0000000..c1adcab
--- /dev/null
+++ b/doc/docs/de/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/de/doc/the-using-clause-controlling-destructive-assignment.md b/doc/docs/de/doc/the-using-clause-controlling-destructive-assignment.md
new file mode 100644
index 0000000..fb9b740
--- /dev/null
+++ b/doc/docs/de/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/de/doc/the-yuescript-library.md b/doc/docs/de/doc/the-yuescript-library.md
new file mode 100644
index 0000000..3761755
--- /dev/null
+++ b/doc/docs/de/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/de/doc/try.md b/doc/docs/de/doc/try.md
new file mode 100644
index 0000000..23c7877
--- /dev/null
+++ b/doc/docs/de/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/de/doc/usage.md b/doc/docs/de/doc/usage.md
new file mode 100644
index 0000000..45161c6
--- /dev/null
+++ b/doc/docs/de/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/de/doc/varargs-assignment.md b/doc/docs/de/doc/varargs-assignment.md
new file mode 100644
index 0000000..1d66680
--- /dev/null
+++ b/doc/docs/de/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/de/doc/while-loop.md b/doc/docs/de/doc/while-loop.md
new file mode 100644
index 0000000..502935e
--- /dev/null
+++ b/doc/docs/de/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/de/doc/whitespace.md b/doc/docs/de/doc/whitespace.md
new file mode 100644
index 0000000..d742a2b
--- /dev/null
+++ b/doc/docs/de/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/de/doc/with-statement.md b/doc/docs/de/doc/with-statement.md
new file mode 100644
index 0000000..7786803
--- /dev/null
+++ b/doc/docs/de/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/de/index.md b/doc/docs/de/index.md
new file mode 100644
index 0000000..1a923b2
--- /dev/null
+++ b/doc/docs/de/index.md
@@ -0,0 +1,24 @@
+---
+layout: home
+hero:
+  name: YueScript
+  tagline: Eine Sprache, die zu Lua kompiliert
+  image:
+    src: /image/yuescript.svg
+    alt: YueScript
+  actions:
+    - theme: brand
+      text: Schnellstart →
+      link: /de/doc/
+features:
+  - title: Vertrauter Lua-Workflow
+    details: Schreibe kompakte Syntax, die in gut lesbares Lua mit vorhersehbarer Ausgabe kompiliert wird.
+  - title: Moderne Sprachfeatures
+    details: Pipe, Pattern Matching, Slicing und Destructuring – ohne auf Lua-Interop zu verzichten.
+  - title: Schnelle Iteration
+    details: Jedes Feedback ist willkommen, um die Entwicklung und Weiterentwicklung der Sprache zu beschleunigen!
+footer:
+  message: MIT-Lizenz.
+  copyright: Copyright © 2017-2026 Li Jin. Alle Rechte vorbehalten.
+---
+---
diff --git a/doc/docs/de/try/index.md b/doc/docs/de/try/index.md
new file mode 100755
index 0000000..f8c3193
--- /dev/null
+++ b/doc/docs/de/try/index.md
@@ -0,0 +1,6 @@
+# YueScript Online-Compiler
+---
+
+Probiere YueScript im Browser mit WASM aus.
+
+<YueCompiler />