13 files changed, 29573 insertions, 10 deletions

diff --git a/doc/yue-de.md b/doc/yue-de.md
new file mode 100644
index 0000000..36d96cd
--- /dev/null
+++ b/doc/yue-de.md
@@ -0,0 +1,5881 @@
+---
+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.
+
+# Do
+
+Als Statement verhält sich `do` wie in Lua.
+
+```yuescript
+do
+  var = "hallo"
+  print var
+print var -- nil hier
+```
+
+<YueDisplay>
+
+```yue
+do
+  var = "hallo"
+  print var
+print var -- nil hier
+```
+
+</YueDisplay>
+
+YueScripts **do** kann auch als Ausdruck verwendet werden. So kannst du mehrere Zeilen in einem Ausdruck kombinieren. Das Ergebnis des `do`-Ausdrucks ist die letzte Anweisung im Block. `do`-Ausdrücke unterstützen die Verwendung von `break`, um den Kontrollfluss zu unterbrechen und mehrere Rückgabewerte vorzeitig zurückzugeben.
+
+```yuescript
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+<YueDisplay>
+
+```yue
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+</YueDisplay>
+
+```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 "Schlüssel wird zugewiesen!"
+    1234
+}
+```
+
+<YueDisplay>
+
+```yue
+tbl = {
+  key: do
+    print "Schlüssel wird zugewiesen!"
+    1234
+}
+```
+
+</YueDisplay>
+
+# Line-Decorators
+
+Zur Vereinfachung können `for`-Schleifen und `if`-Anweisungen auf einzelne Anweisungen am Zeilenende angewendet werden:
+
+```yuescript
+print "Hallo Welt" if name == "Rob"
+```
+
+<YueDisplay>
+
+```yue
+print "Hallo Welt" if name == "Rob"
+```
+
+</YueDisplay>
+
+Und mit einfachen Schleifen:
+
+```yuescript
+print "Element: ", item for item in *items
+```
+
+<YueDisplay>
+
+```yue
+print "Element: ", item for item in *items
+```
+
+</YueDisplay>
+
+Und mit `while`-Schleifen:
+
+```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>
+
+# Makros
+
+## Häufige Verwendung
+
+Makrofunktionen werden verwendet, um zur Compile-Zeit einen String auszuwerten und den generierten Code in die finale Kompilierung einzufügen.
+
+```yuescript
+macro PI2 = -> math.pi * 2
+area = $PI2 * 5
+
+macro HELLO = -> "'Hallo Welt'"
+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
+
+-- übergebene Ausdrücke werden als Strings behandelt
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+
+<YueDisplay>
+
+```yue
+macro PI2 = -> math.pi * 2
+area = $PI2 * 5
+
+macro HELLO = -> "'Hallo Welt'"
+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
+
+-- übergebene Ausdrücke werden als Strings behandelt
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+
+</YueDisplay>
+
+## Rohcode einfügen
+
+Eine Makrofunktion kann entweder einen YueScript-String oder eine Konfigurationstabelle mit Lua-Code zurückgeben.
+
+```yuescript
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+funcA = -> "Zuweisung an die vom Yue-Makro definierte Variable schlägt fehl"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "Zuweisung an die vom Lua-Makro definierte Variable schlägt fehl"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- führende und abschließende Symbole des Raw-Strings werden automatisch getrimmt
+$lua[==[
+-- Einfügen von rohem Lua-Code
+if cond then
+  print("Ausgabe")
+end
+]==]
+```
+
+<YueDisplay>
+
+```yue
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+funcA = -> "Zuweisung an die vom Yue-Makro definierte Variable schlägt fehl"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "Zuweisung an die vom Lua-Makro definierte Variable schlägt fehl"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- führende und abschließende Symbole des Raw-Strings werden automatisch getrimmt
+$lua[==[
+-- Einfügen von rohem Lua-Code
+if cond then
+  print("Ausgabe")
+end
+]==]
+```
+
+</YueDisplay>
+
+## Makros exportieren
+
+Makrofunktionen können aus einem Modul exportiert und in ein anderes Modul importiert werden. Exportierte Makros müssen in einer einzelnen Datei liegen, und im Export-Modul dürfen nur Makrodefinitionen, Makro-Imports und Makro-Expansionen stehen.
+
+```yuescript
+-- Datei: 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}"
+
+-- Datei main.yue
+import "utils" as {
+  $, -- Symbol zum Importieren aller Makros
+  $foreach: $each -- Makro $foreach in $each umbenennen
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+```
+
+<YueDisplay>
+
+```yue
+-- Datei: 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}"
+
+-- Datei main.yue
+-- Import-Funktion im Browser nicht verfügbar, in echter Umgebung testen
+--[[
+import "utils" as {
+  $, -- Symbol zum Importieren aller Makros
+  $foreach: $each -- Makro $foreach in $each umbenennen
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+]]
+```
+
+</YueDisplay>
+
+## Eingebaute Makros
+
+Es gibt einige eingebaute Makros, aber du kannst sie überschreiben, indem du Makros mit denselben Namen deklarierst.
+
+```yuescript
+print $FILE -- String des aktuellen Modulnamens
+print $LINE -- gibt 2 aus
+```
+
+<YueDisplay>
+
+```yue
+print $FILE -- String des aktuellen Modulnamens
+print $LINE -- gibt 2 aus
+```
+
+</YueDisplay>
+
+## Makros mit Makros erzeugen
+
+In YueScript erlauben Makrofunktionen Codegenerierung zur Compile-Zeit. Durch das Verschachteln von Makrofunktionen kannst du komplexere Generierungsmuster erzeugen. Damit kannst du eine Makrofunktion definieren, die eine andere Makrofunktion erzeugt.
+
+```yuescript
+macro Enum = (...) ->
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "erhalten: \"#{item}\", erwartet eines von #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
+
+macro BodyType = $Enum(
+  Static
+  Dynamic
+  Kinematic
+)
+
+print "Gültiger Enum-Typ:", $BodyType Static
+-- print "Kompilierungsfehler bei Enum-Typ:", $BodyType Unknown
+```
+
+<YueDisplay>
+
+```yue
+macro Enum = (...) ->
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "erhalten: \"#{item}\", erwartet eines von #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
+
+macro BodyType = $Enum(
+  Static
+  Dynamic
+  Kinematic
+)
+
+print "Gültiger Enum-Typ:", $BodyType Static
+-- print "Kompilierungsfehler bei Enum-Typ:", $BodyType Unknown
+```
+
+</YueDisplay>
+
+## Argument-Validierung
+
+Du kannst erwartete AST-Knotentypen in der Argumentliste deklarieren und zur Compile-Zeit prüfen, ob die übergebenen Makroargumente den Erwartungen entsprechen.
+
+```yuescript
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hallo"
+```
+
+<YueDisplay>
+
+```yue
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hallo"
+```
+
+</YueDisplay>
+
+Wenn du flexiblere Argumentprüfungen brauchst, kannst du das eingebaute Makro `$is_ast` verwenden, um manuell an der passenden Stelle zu prüfen.
+
+```yuescript
+macro printNumAndStr = (num, str) ->
+  error "als erstes Argument Num erwartet" unless $is_ast Num, num
+  error "als zweites Argument String erwartet" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hallo"
+```
+
+<YueDisplay>
+
+```yue
+macro printNumAndStr = (num, str) ->
+  error "als erstes Argument Num erwartet" unless $is_ast Num, num
+  error "als zweites Argument String erwartet" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hallo"
+```
+
+</YueDisplay>
+
+Weitere Details zu verfügbaren AST-Knoten findest du in den großgeschriebenen Definitionen in `yue_parser.cpp`.
+
+# Try
+
+Die Syntax für Fehlerbehandlung in Lua in einer gängigen 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 "Versuche"
+  func 1, 2, 3
+
+-- Verwendung mit if-Zuweisungsmuster
+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 "Versuche"
+  func 1, 2, 3
+
+-- Verwendung mit if-Zuweisungsmuster
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+
+</YueDisplay>
+
+## Try?
+
+`try?` ist eine vereinfachte Fehlerbehandlungs-Syntax, die den booleschen Status aus dem `try`-Statement weglässt. Bei Erfolg gibt sie das Ergebnis des `try`-Blocks zurück, ansonsten `nil` statt eines Fehlerobjekts.
+
+```yuescript
+a, b, c = try? func!
+
+-- mit Nil-Verschmelzungs-Operator
+a = (try? func!) ?? "Standardwert"
+
+-- als Funktionsargument
+f try? func!
+
+-- mit catch-Block
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+<YueDisplay>
+
+```yue
+a, b, c = try? func!
+
+-- mit Nil-Verschmelzungs-Operator
+a = (try? func!) ?? "Standardwert"
+
+-- als Funktionsargument
+f try? func!
+
+-- mit catch-Block
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+</YueDisplay>
+
+# Tabellenliterale
+
+Wie in Lua werden Tabellen mit geschweiften Klammern definiert.
+
+```yuescript
+some_values = [1, 2, 3, 4]
+```
+
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+```
+
+</YueDisplay>
+
+Anders als in Lua weist man einem Schlüssel in einer Tabelle mit **:** (statt **=**) einen Wert zu.
+
+```yuescript
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["Lieblingsessen"]: "Reis"
+}
+```
+
+<YueDisplay>
+
+```yue
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["Lieblingsessen"]: "Reis"
+}
+```
+
+</YueDisplay>
+
+Die geschweiften Klammern können weggelassen werden, wenn eine einzelne Tabelle aus Schlüssel-Wert-Paaren zugewiesen wird.
+
+```yuescript
+profile =
+  height: "4 Fuß",
+  shoe_size: 13,
+  favorite_foods: ["Eis", "Donuts"]
+```
+
+<YueDisplay>
+
+```yue
+profile =
+  height: "4 Fuß",
+  shoe_size: 13,
+  favorite_foods: ["Eis", "Donuts"]
+```
+
+</YueDisplay>
+
+Zeilenumbrüche können Werte statt eines Kommas trennen (oder zusätzlich):
+
+```yuescript
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "Superman"
+  occupation: "Verbrechensbekämpfung"
+}
+```
+
+<YueDisplay>
+
+```yue
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "Superman"
+  occupation: "Verbrechensbekämpfung"
+}
+```
+
+</YueDisplay>
+
+Beim Erstellen eines einzeiligen Tabellenliterals können die geschweiften Klammern ebenfalls weggelassen werden:
+
+```yuescript
+my_function dance: "Tango", partner: "keiner"
+
+y = type: "Hund", legs: 4, tails: 1
+```
+
+<YueDisplay>
+
+```yue
+my_function dance: "Tango", partner: "keiner"
+
+y = type: "Hund", legs: 4, tails: 1
+```
+
+</YueDisplay>
+
+Die Schlüssel eines Tabellenliterals können Sprach-Schlüsselwörter sein, ohne sie zu escapen:
+
+```yuescript
+tbl = {
+  do: "etwas"
+  end: "Hunger"
+}
+```
+
+<YueDisplay>
+
+```yue
+tbl = {
+  do: "etwas"
+  end: "Hunger"
+}
+```
+
+</YueDisplay>
+
+Wenn du eine Tabelle aus Variablen konstruierst und die Schlüssel den Variablennamen entsprechen sollen, kannst du den Präfix-Operator **:** verwenden:
+
+```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>
+
+Wenn der Schlüssel eines Feldes das Ergebnis eines Ausdrucks sein soll, kannst du ihn wie in Lua in **[ ]** setzen. Du kannst auch ein String-Literal direkt als Schlüssel verwenden und die eckigen Klammern weglassen. Das ist nützlich, wenn dein Schlüssel Sonderzeichen enthält.
+
+```yuescript
+t = {
+  [1 + 2]: "hallo"
+  "Hallo Welt": true
+}
+```
+
+<YueDisplay>
+
+```yue
+t = {
+  [1 + 2]: "hallo"
+  "Hallo Welt": true
+}
+```
+
+</YueDisplay>
+
+Lua-Tabellen haben einen Array-Teil und einen Hash-Teil, aber manchmal möchte man beim Schreiben von Lua-Tabellen eine semantische Unterscheidung zwischen Array- und Hash-Nutzung machen. Dann kannst du eine Lua-Tabelle mit **[ ]** statt **{ }** schreiben, um eine Array-Tabelle darzustellen, und das Schreiben von Schlüssel-Wert-Paaren in einer Listentabelle ist nicht erlaubt.
+
+```yuescript
+some_values = [1, 2, 3, 4]
+list_with_one_element = [1, ]
+```
+
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+list_with_one_element = [1, ]
+```
+
+</YueDisplay>
+
+# Comprehensions
+
+Comprehensions bieten eine bequeme Syntax, um eine neue Tabelle zu erzeugen, indem man über ein bestehendes Objekt iteriert und einen Ausdruck auf seine Werte anwendet. Es gibt zwei Arten: Listen-Comprehensions und Tabellen-Comprehensions. Beide erzeugen Lua-Tabellen; Listen-Comprehensions sammeln Werte in einer array-ähnlichen Tabelle, und Tabellen-Comprehensions erlauben es, Schlüssel und Wert pro Iteration zu setzen.
+
+## Listen-Comprehensions
+
+Das folgende Beispiel erstellt eine Kopie der `items`-Tabelle, aber mit verdoppelten Werten.
+
+```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>
+
+Die Elemente in der neuen Tabelle können mit einer `when`-Klausel eingeschränkt werden:
+
+```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>
+
+Da es üblich ist, über die Werte einer numerisch indizierten Tabelle zu iterieren, gibt es den **\***-Operator. Das Verdopplungsbeispiel kann so umgeschrieben werden:
+
+```yuescript
+doubled = [item * 2 for item in *items]
+```
+
+<YueDisplay>
+
+```yue
+doubled = [item * 2 for item in *items]
+```
+
+</YueDisplay>
+
+In Listen-Comprehensions kannst du außerdem den Spread-Operator `...` verwenden, um verschachtelte Listen zu flatten und einen Flat-Map-Effekt zu erzielen:
+
+```yuescript
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat ist jetzt [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 ist jetzt [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+Die `for`- und `when`-Klauseln können beliebig oft verkettet werden. Die einzige Anforderung ist, dass eine Comprehension mindestens eine `for`-Klausel enthält.
+
+Mehrere `for`-Klauseln entsprechen verschachtelten Schleifen:
+
+```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>
+
+Numerische `for`-Schleifen können ebenfalls in Comprehensions verwendet werden:
+
+```yuescript
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+<YueDisplay>
+
+```yue
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+</YueDisplay>
+
+## Tabellen-Comprehensions
+
+Die Syntax für Tabellen-Comprehensions ist sehr ähnlich, unterscheidet sich jedoch dadurch, dass **{** und **}** verwendet werden und pro Iteration zwei Werte erzeugt werden.
+
+Dieses Beispiel erstellt eine Kopie von `thing`:
+
+```yuescript
+thing = {
+  color: "rot"
+  name: "schnell"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+<YueDisplay>
+
+```yue
+thing = {
+  color: "rot"
+  name: "schnell"
+  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>
+
+Der **\***-Operator wird ebenfalls unterstützt. Hier erstellen wir eine Nachschlagetabelle für Quadratwurzeln einiger Zahlen.
+
+```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>
+
+Das Schlüssel-Wert-Tupel in einer Tabellen-Comprehension kann auch aus einem einzelnen Ausdruck stammen; der Ausdruck muss dann zwei Werte zurückgeben. Der erste wird als Schlüssel und der zweite als Wert verwendet:
+
+In diesem Beispiel konvertieren wir ein Array von Paaren in eine Tabelle, wobei das erste Element des Paars der Schlüssel und das zweite der Wert ist.
+
+```yuescript
+tuples = [ ["hallo", "Welt"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+
+<YueDisplay>
+
+```yue
+tuples = [ ["hallo", "Welt"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+
+</YueDisplay>
+
+## Slicing
+
+Eine spezielle Syntax erlaubt es, die iterierten Elemente bei Verwendung des **\***-Operators einzuschränken. Das ist äquivalent zum Setzen von Iterationsgrenzen und Schrittweite in einer `for`-Schleife.
+
+Hier setzen wir die minimalen und maximalen Grenzen und nehmen alle Elemente mit Indizes zwischen 1 und 5 (inklusive):
+
+```yuescript
+slice = [item for item in *items[1, 5]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[1, 5]]
+```
+
+</YueDisplay>
+
+Jedes der Slice-Argumente kann weggelassen werden, um einen sinnvollen Standard zu verwenden. Wenn der maximale Index weggelassen wird, entspricht er der Länge der Tabelle. Dieses Beispiel nimmt alles außer dem ersten Element:
+
+```yuescript
+slice = [item for item in *items[2,]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[2,]]
+```
+
+</YueDisplay>
+
+Wenn die Mindestgrenze weggelassen wird, ist sie standardmäßig 1. Hier geben wir nur die Schrittweite an und lassen die anderen Grenzen leer. Das nimmt alle ungerad indizierten Elemente (1, 3, 5, …):
+
+```yuescript
+slice = [item for item in *items[,,2]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[,,2]]
+```
+
+</YueDisplay>
+
+Sowohl die Mindest- als auch die Maximalgrenze können negativ sein; dann werden die Grenzen vom Ende der Tabelle gezählt.
+
+```yuescript
+-- die letzten 4 Elemente nehmen
+slice = [item for item in *items[-4,-1]]
+```
+
+<YueDisplay>
+
+```yue
+-- die letzten 4 Elemente nehmen
+slice = [item for item in *items[-4,-1]]
+```
+
+</YueDisplay>
+
+Die Schrittweite kann ebenfalls negativ sein, wodurch die Elemente in umgekehrter Reihenfolge genommen werden.
+
+```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-Ausdruck
+
+Slicing kann auch als Ausdruck verwendet werden. Das ist nützlich, um eine Teilliste einer Tabelle zu erhalten.
+
+```yuescript
+-- das 2. und 4. Element als neue Liste nehmen
+sub_list = items[2, 4]
+
+-- die letzten 4 Elemente nehmen
+last_four_items = items[-4, -1]
+```
+
+<YueDisplay>
+
+```yue
+-- das 2. und 4. Element als neue Liste nehmen
+sub_list = items[2, 4]
+
+-- die letzten 4 Elemente nehmen
+last_four_items = items[-4, -1]
+```
+
+</YueDisplay>
+
+# Objektorientierte Programmierung
+
+In diesen Beispielen kann der generierte Lua-Code überwältigend wirken. Am besten konzentrierst du dich zunächst auf die Bedeutung des YueScript-Codes und schaust dir den Lua-Code nur an, wenn du die Implementierungsdetails wissen möchtest.
+
+Eine einfache Klasse:
+
+```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>
+
+Eine Klasse wird mit einem `class`-Statement deklariert, gefolgt von einer tabellenähnlichen Deklaration mit allen Methoden und Eigenschaften.
+
+Die Eigenschaft `new` ist besonders, da sie zum Konstruktor wird.
+
+Beachte, dass alle Methoden in der Klasse die Fat-Arrow-Syntax verwenden. Beim Aufruf von Methoden auf einer Instanz wird die Instanz selbst als erstes Argument übergeben. Der Fat-Arrow übernimmt die Erstellung des `self`-Arguments.
+
+Das `@`-Präfix ist Kurzform für `self.`. `@items` wird zu `self.items`.
+
+Eine Instanz der Klasse wird erstellt, indem man den Klassennamen wie eine Funktion aufruft.
+
+```yuescript
+inv = Inventory!
+inv\add_item "T-Shirt"
+inv\add_item "Hose"
+```
+
+<YueDisplay>
+
+```yue
+inv = Inventory!
+inv\add_item "T-Shirt"
+inv\add_item "Hose"
+```
+
+</YueDisplay>
+
+Da die Instanz bei Methodenaufrufen an die Methoden übergeben werden muss, wird der `\`-Operator verwendet.
+
+Alle Eigenschaften einer Klasse werden von allen Instanzen gemeinsam genutzt. Für Funktionen ist das ok, aber bei anderen Objekten kann das zu unerwünschten Ergebnissen führen.
+
+Im folgenden Beispiel wird die Eigenschaft `clothes` von allen Instanzen geteilt, sodass Änderungen in einer Instanz in einer anderen sichtbar werden:
+
+```yuescript
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "Hose"
+b\give_item "Hemd"
+
+-- gibt sowohl Hose als auch Hemd aus
+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 "Hose"
+b\give_item "Hemd"
+
+-- gibt sowohl Hose als auch Hemd aus
+print item for item in *a.clothes
+```
+
+</YueDisplay>
+
+Der richtige Weg, das zu vermeiden, ist, den veränderlichen Zustand im Konstruktor zu erstellen:
+
+```yuescript
+class Person
+  new: =>
+    @clothes = []
+```
+
+<YueDisplay>
+
+```yue
+class Person
+  new: =>
+    @clothes = []
+```
+
+</YueDisplay>
+
+## Vererbung
+
+Das Schlüsselwort `extends` kann in einer Klassendeklaration verwendet werden, um Eigenschaften und Methoden von einer anderen Klasse zu erben.
+
+```yuescript
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "Rucksack ist voll"
+    super name
+```
+
+<YueDisplay>
+
+```yue
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "Rucksack ist voll"
+    super name
+```
+
+</YueDisplay>
+
+Hier erweitern wir unsere `Inventory`-Klasse und begrenzen die Anzahl der Elemente.
+
+In diesem Beispiel definieren wir keinen Konstruktor in der Subklasse, daher wird der Konstruktor der Elternklasse beim Erstellen einer neuen Instanz aufgerufen. Definieren wir einen Konstruktor, können wir mit `super` den Elternkonstruktor aufrufen.
+
+Wenn eine Klasse von einer anderen erbt, sendet sie eine Nachricht an die Elternklasse, indem die Methode `__inherited` der Elternklasse aufgerufen wird, falls vorhanden. Die Funktion erhält zwei Argumente: die Klasse, die vererbt wird, und die Kindklasse.
+
+```yuescript
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "wurde vererbt von", child.__name
+
+-- gibt aus: Shelf wurde von Cupboard geerbt
+class Cupboard extends Shelf
+```
+
+<YueDisplay>
+
+```yue
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "wurde vererbt von", child.__name
+
+-- gibt aus: Shelf wurde von Cupboard geerbt
+class Cupboard extends Shelf
+```
+
+</YueDisplay>
+
+## Super
+
+**super** ist ein spezielles Schlüsselwort, das auf zwei Arten verwendet werden kann: als Objekt oder als Funktionsaufruf. Es hat besondere Funktionalität nur innerhalb einer Klasse.
+
+Wenn es als Funktion aufgerufen wird, ruft es die gleichnamige Funktion in der Elternklasse auf. `self` wird automatisch als erstes Argument übergeben (wie im Vererbungsbeispiel oben).
+
+Wenn `super` als normaler Wert verwendet wird, ist es eine Referenz auf das Objekt der Elternklasse.
+
+Du kannst es wie jedes andere Objekt verwenden, um Werte der Elternklasse zu lesen, die von der Kindklasse überschattet wurden.
+
+Wenn der `\`-Aufrufoperator mit `super` verwendet wird, wird `self` als erstes Argument eingefügt statt des Wertes von `super`. Wenn man `.` zum Abrufen einer Funktion verwendet, wird die rohe Funktion zurückgegeben.
+
+Ein paar Beispiele für `super` in unterschiedlichen Formen:
+
+```yuescript
+class MyClass extends ParentClass
+  a_method: =>
+    -- Folgendes hat dieselbe Wirkung:
+    super "hallo", "Welt"
+    super\a_method "hallo", "Welt"
+    super.a_method self, "hallo", "Welt"
+
+    -- super als Wert entspricht der Elternklasse:
+    assert super == ParentClass
+```
+
+<YueDisplay>
+
+```yue
+class MyClass extends ParentClass
+  a_method: =>
+    -- Folgendes hat dieselbe Wirkung:
+    super "hallo", "Welt"
+    super\a_method "hallo", "Welt"
+    super.a_method self, "hallo", "Welt"
+
+    -- super als Wert entspricht der Elternklasse:
+    assert super == ParentClass
+```
+
+</YueDisplay>
+
+**super** kann auch links einer Funktions-Stub verwendet werden. Der einzige große Unterschied ist, dass die resultierende Funktion statt an `super` an `self` gebunden wird.
+
+## Typen
+
+Jede Instanz einer Klasse trägt ihren Typ in sich. Dieser wird in der speziellen Eigenschaft `__class` gespeichert. Diese Eigenschaft enthält das Klassenobjekt. Das Klassenobjekt wird aufgerufen, um eine neue Instanz zu erstellen. Wir können das Klassenobjekt auch indizieren, um Klassenmethoden und Eigenschaften abzurufen.
+
+```yuescript
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- gibt 10 aus
+```
+
+<YueDisplay>
+
+```yue
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- gibt 10 aus
+```
+
+</YueDisplay>
+
+## Klassenobjekte
+
+Das Klassenobjekt entsteht, wenn wir ein `class`-Statement verwenden. Es wird in einer Variablen mit dem Klassennamen gespeichert.
+
+Das Klassenobjekt kann wie eine Funktion aufgerufen werden, um neue Instanzen zu erstellen. So haben wir die Instanzen in den Beispielen oben erstellt.
+
+Eine Klasse besteht aus zwei Tabellen: der Klassentabelle selbst und der Basistabelle. Die Basis wird als Metatable für alle Instanzen verwendet. Alle in der Klassendeklaration aufgeführten Eigenschaften werden in der Basis platziert.
+
+Das Metatable des Klassenobjekts liest Eigenschaften aus der Basis, wenn sie im Klassenobjekt nicht existieren. Das bedeutet, dass wir Funktionen und Eigenschaften direkt von der Klasse aus aufrufen können.
+
+Wichtig: Zuweisungen an das Klassenobjekt schreiben nicht in die Basis. Das ist keine gültige Methode, um neue Methoden zu Instanzen hinzuzufügen. Stattdessen muss die Basis explizit geändert werden. Siehe das Feld `__base` unten.
+
+Das Klassenobjekt hat einige spezielle Eigenschaften:
+
+Der Name der Klasse, wie sie deklariert wurde, wird im Feld `__name` gespeichert.
+
+```yuescript
+print BackPack.__name -- gibt Backpack aus
+```
+
+<YueDisplay>
+
+```yue
+print BackPack.__name -- gibt Backpack aus
+```
+
+</YueDisplay>
+
+Die Basistabelle ist in `__base` gespeichert. Du kannst diese Tabelle ändern, um Instanzen Funktionalität hinzuzufügen, die bereits existieren oder noch erstellt werden.
+
+Wenn die Klasse von etwas erbt, ist das Elternklassenobjekt in `__parent` gespeichert.
+
+## Klassenvariablen
+
+Du kannst Variablen direkt im Klassenobjekt statt in der Basis erstellen, indem du in der Klassendeklaration `@` vor den Eigenschaftsnamen setzt.
+
+```yuescript
+class Things
+  @some_func: => print "Hallo von", @__name
+
+Things\some_func!
+
+-- Klassenvariablen in Instanzen nicht sichtbar
+assert Things().some_func == nil
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @some_func: => print "Hallo von", @__name
+
+Things\some_func!
+
+-- Klassenvariablen in Instanzen nicht sichtbar
+assert Things().some_func == nil
+```
+
+</YueDisplay>
+
+In Ausdrücken können wir `@@` verwenden, um auf einen Wert zuzugreifen, der in `self.__class` gespeichert ist. `@@hello` ist also eine Kurzform für `self.__class.hello`.
+
+```yuescript
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- gibt 2 aus
+```
+
+<YueDisplay>
+
+```yue
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- gibt 2 aus
+```
+
+</YueDisplay>
+
+Die Aufrufsemantik von `@@` ist ähnlich wie bei `@`. Wenn du einen `@@`-Namen aufrufst, wird die Klasse als erstes Argument übergeben (Lua-`:`-Syntax).
+
+```yuescript
+@@hello 1,2,3,4
+```
+
+<YueDisplay>
+
+```yue
+@@hello 1,2,3,4
+```
+
+</YueDisplay>
+
+## Klassendeklarations-Statements
+
+Im Rumpf einer Klassendeklaration können wir normale Ausdrücke zusätzlich zu Schlüssel/Wert-Paaren haben. In diesem Kontext ist `self` gleich dem Klassenobjekt.
+
+Hier ist eine alternative Möglichkeit, eine Klassenvariable zu erstellen:
+
+```yuescript
+class Things
+  @class_var = "Hallo Welt"
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @class_var = "Hallo Welt"
+```
+
+</YueDisplay>
+
+Diese Ausdrücke werden ausgeführt, nachdem alle Eigenschaften zur Basis hinzugefügt wurden.
+
+Alle Variablen, die im Klassenkörper deklariert werden, sind lokal zu den Klasseneigenschaften. Das ist praktisch, um private Werte oder Hilfsfunktionen zu platzieren, auf die nur die Klassenmethoden zugreifen können:
+
+```yuescript
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "Hallo Welt: " .. secret
+```
+
+<YueDisplay>
+
+```yue
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "Hallo Welt: " .. secret
+```
+
+</YueDisplay>
+
+## @- und @@-Werte
+
+Wenn `@` und `@@` vor einem Namen stehen, repräsentieren sie den Namen in `self` bzw. `self.__class`.
+
+Wenn sie alleine verwendet werden, sind sie Aliase für `self` und `self.__class`.
+
+```yuescript
+assert @ == self
+assert @@ == self.__class
+```
+
+<YueDisplay>
+
+```yue
+assert @ == self
+assert @@ == self.__class
+```
+
+</YueDisplay>
+
+Zum Beispiel kannst du mit `@@` in einer Instanzmethode schnell eine neue Instanz derselben Klasse erzeugen:
+
+```yuescript
+some_instance_method = (...) => @@ ...
+```
+
+<YueDisplay>
+
+```yue
+some_instance_method = (...) => @@ ...
+```
+
+</YueDisplay>
+
+## Konstruktor-Property-Promotion
+
+Um Boilerplate beim Definieren einfacher Value-Objekte zu reduzieren, kannst du eine Klasse so schreiben:
+
+```yuescript
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- Kurzform für
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+<YueDisplay>
+
+```yue
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- Kurzform für
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+</YueDisplay>
+
+Du kannst diese Syntax auch für eine gemeinsame Funktion verwenden, um Objektfelder zu initialisieren.
+
+```yuescript
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+<YueDisplay>
+
+```yue
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+</YueDisplay>
+
+## Klassenausdrücke
+
+Die `class`-Syntax kann auch als Ausdruck verwendet werden, der einer Variable zugewiesen oder explizit zurückgegeben wird.
+
+```yuescript
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+<YueDisplay>
+
+```yue
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+</YueDisplay>
+
+## Anonyme Klassen
+
+Der Name kann beim Deklarieren einer Klasse weggelassen werden. Das `__name`-Attribut ist dann `nil`, es sei denn, der Klassenausdruck steht in einer Zuweisung. In diesem Fall wird der Name auf der linken Seite statt `nil` verwendet.
+
+```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>
+
+Du kannst sogar den Körper weglassen und eine leere anonyme Klasse schreiben:
+
+```yuescript
+x = class
+```
+
+<YueDisplay>
+
+```yue
+x = class
+```
+
+</YueDisplay>
+
+## Class Mixing
+
+Du kannst mit dem Schlüsselwort `using` mischen, um Funktionen aus einer einfachen Tabelle oder einem vordefinierten Klassenobjekt in deine neue Klasse zu kopieren. Beim Mischen mit einer einfachen Tabelle kannst du die Klassen-Indexing-Funktion (Metamethod `__index`) überschreiben. Beim Mischen mit einem bestehenden Klassenobjekt werden dessen Metamethoden nicht kopiert.
+
+```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 ist nicht die Elternklasse von 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 ist nicht die Elternklasse von Y
+```
+
+</YueDisplay>
+
+# With-Statement
+
+Ein häufiges Muster bei der Erstellung eines Objekts ist, unmittelbar danach eine Reihe von Funktionen aufzurufen und Eigenschaften zu setzen.
+
+Das führt dazu, dass der Objektname mehrfach wiederholt wird und unnötiges Rauschen entsteht. Eine gängige Lösung ist, eine Tabelle als Argument zu übergeben, die eine Sammlung von Schlüsseln und Werten enthält, die überschrieben werden sollen. Der Nachteil ist, dass der Konstruktor dieses Objekts diese Form unterstützen muss.
+
+Der `with`-Block hilft, das zu vermeiden. Innerhalb eines `with`-Blocks können wir spezielle Anweisungen verwenden, die mit `.` oder `\` beginnen und die Operationen auf das Objekt anwenden, mit dem wir gerade arbeiten.
+
+Zum Beispiel arbeiten wir mit einem neu erstellten Objekt:
+
+```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>
+
+Das `with`-Statement kann auch als Ausdruck verwendet werden und gibt den Wert zurück, auf den es Zugriff gewährt.
+
+```yuescript
+file = with File "Lieblingsessen.txt"
+  \set_encoding "utf8"
+```
+
+<YueDisplay>
+
+```yue
+file = with File "Lieblingsessen.txt"
+  \set_encoding "utf8"
+```
+
+</YueDisplay>
+
+`with`-Ausdrücke unterstützen `break` mit genau einem Wert:
+
+```yuescript
+result = with obj
+  break .value
+```
+
+<YueDisplay>
+
+```yue
+result = with obj
+  break .value
+```
+
+</YueDisplay>
+
+Sobald `break value` in `with` verwendet wird, gibt der `with`-Ausdruck nicht mehr sein Zielobjekt zurück, sondern den von `break` gelieferten Wert.
+
+```yuescript
+a = with obj
+  .x = 1
+-- a ist obj
+
+b = with obj
+  break .x
+-- b ist .x, nicht obj
+```
+
+<YueDisplay>
+
+```yue
+a = with obj
+  .x = 1
+-- a ist obj
+
+b = with obj
+  break .x
+-- b ist .x, nicht obj
+```
+
+</YueDisplay>
+
+Im Unterschied zu `for` / `while` / `repeat` / `do` unterstützt `with` nur einen `break`-Wert.
+
+Oder …
+
+```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 dieser Verwendung kann `with` als spezielle Form des K-Kombinators gesehen werden.
+
+Der Ausdruck im `with`-Statement kann auch eine Zuweisung sein, wenn du dem Ausdruck einen Namen geben willst.
+
+```yuescript
+with str := "Hallo"
+  print "Original:", str
+  print "Großbuchstaben:", \upper!
+```
+
+<YueDisplay>
+
+```yue
+with str := "Hallo"
+  print "Original:", str
+  print "Großbuchstaben:", \upper!
+```
+
+</YueDisplay>
+
+Du kannst in einem `with`-Statement über `[]` auf spezielle Schlüssel zugreifen.
+
+```yuescript
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- an "tb" anhängen
+```
+
+<YueDisplay>
+
+```yue
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- an "tb" anhängen
+```
+
+</YueDisplay>
+
+`with?` ist eine erweiterte Version der `with`-Syntax, die einen Existenz-Check einführt, um Objekte, die `nil` sein könnten, sicher zuzugreifen, ohne explizite Nullprüfungen.
+
+```yuescript
+with? obj
+  print obj.name
+```
+
+<YueDisplay>
+
+```yue
+with? obj
+  print obj.name
+```
+
+</YueDisplay>
+
+# Zuweisung
+
+Variablen sind dynamisch typisiert und standardmäßig `local`. Du kannst den Geltungsbereich mit den Statements **local** und **global** ändern.
+
+```yuescript
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- nutzt die bestehende Variable
+```
+
+<YueDisplay>
+
+```yue
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- nutzt die bestehende Variable
+```
+
+</YueDisplay>
+
+## Update-Zuweisung
+
+Du kannst Update-Zuweisungen mit vielen binären Operatoren durchführen.
+
+```yuescript
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- legt eine neue lokale Variable an, wenn sie nicht existiert
+arg or= "default value"
+```
+
+<YueDisplay>
+
+```yue
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- legt eine neue lokale Variable an, wenn sie nicht existiert
+arg or= "default value"
+```
+
+</YueDisplay>
+
+## Verkettete Zuweisung
+
+Mit verketteten Zuweisungen kannst du mehrere Variablen auf denselben Wert setzen.
+
+```yuescript
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+<YueDisplay>
+
+```yue
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+</YueDisplay>
+
+## Explizite 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>
+
+## Explizite 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>
+
+# Varargs-Zuweisung
+
+Du kannst Rückgabewerte einer Funktion dem Varargs-Symbol `...` zuweisen und dann den Inhalt auf die Lua-Weise auslesen.
+
+```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>
+
+# If-Zuweisung
+
+`if`- und `elseif`-Blöcke können eine Zuweisung anstelle eines Bedingungsausdrucks enthalten. Beim Auswerten der Bedingung findet die Zuweisung statt, und der zugewiesene Wert wird als Bedingung verwendet. Die zugewiesene Variable ist nur im Geltungsbereich des Bedingungsblocks verfügbar, d. h. sie ist nicht verfügbar, wenn der Wert nicht truthy ist. Für die Zuweisung musst du den "Walrus-Operator" `:=` statt `=` verwenden.
+
+```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 "Du hast hello", hello
+elseif world := os.getenv "world"
+  print "Du hast world", world
+else
+  print "nichts :("
+```
+
+<YueDisplay>
+
+```yue
+if hello := os.getenv "hello"
+  print "Du hast hello", hello
+elseif world := os.getenv "world"
+  print "Du hast world", world
+else
+  print "nichts :("
+```
+
+</YueDisplay>
+
+If-Zuweisung mit mehreren Rückgabewerten. Nur der erste Wert wird geprüft, andere Werte bleiben im Scope.
+
+```yuescript
+if success, result := pcall -> "Ergebnis ohne Probleme erhalten"
+  print result -- Variable result ist im Scope
+print "OK"
+```
+
+<YueDisplay>
+
+```yue
+if success, result := pcall -> "Ergebnis ohne Probleme erhalten"
+  print result -- Variable result ist im Scope
+print "OK"
+```
+
+</YueDisplay>
+
+## While-Zuweisung
+
+Du kannst if-Zuweisung auch in einer while-Schleife verwenden, um den Wert als Schleifenbedingung zu nutzen.
+
+```yuescript
+while byte := stream\read_one!
+  -- mit dem Byte etwas anfangen
+  print byte
+```
+
+<YueDisplay>
+
+```yue
+while byte := stream\read_one!
+  -- mit dem Byte etwas anfangen
+  print byte
+```
+
+</YueDisplay>
+
+# Destructuring-Zuweisung
+
+Destructuring-Zuweisung ist eine Möglichkeit, schnell Werte aus einer Tabelle nach Name oder Position in array-basierten Tabellen zu extrahieren.
+
+Normalerweise steht ein Tabellenliteral wie `{1,2,3}` auf der rechten Seite einer Zuweisung, weil es ein Wert ist. Destructuring-Zuweisung tauscht die Rolle des Tabellenliterals und setzt es auf die linke Seite der Zuweisung.
+
+Am besten lässt sich das mit Beispielen erklären. So entpackst du die ersten zwei Werte einer Tabelle:
+
+```yuescript
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+<YueDisplay>
+
+```yue
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+</YueDisplay>
+
+Im Destructuring-Tabellenliteral repräsentiert der Schlüssel den zu lesenden Schlüssel der rechten Seite, und der Wert ist der Name, dem der gelesene Wert zugewiesen wird.
+
+```yuescript
+obj = {
+  hello: "Welt"
+  day: "Dienstag"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- einfache Destructuring-Zuweisung ohne Klammern ist ok
+```
+
+<YueDisplay>
+
+```yue
+obj = {
+  hello: "Welt"
+  day: "Dienstag"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- einfache Destructuring-Zuweisung ohne Klammern ist ok
+```
+
+</YueDisplay>
+
+Das funktioniert auch mit verschachtelten Datenstrukturen:
+
+```yuescript
+obj2 = {
+  numbers: [1, 2, 3, 4]
+  properties: {
+    color: "grün"
+    height: 13.5
+  }
+}
+
+{numbers: [first, second], properties: {color: color}} = obj2
+print first, second, color
+```
+
+<YueDisplay>
+
+```yue
+obj2 = {
+  numbers: [1, 2, 3, 4]
+  properties: {
+    color: "grün"
+    height: 13.5
+  }
+}
+
+{numbers: [first, second], properties: {color: color}} = obj2
+print first, second, color
+```
+
+</YueDisplay>
+
+Wenn die Destructuring-Anweisung kompliziert ist, kannst du sie gerne auf mehrere Zeilen verteilen. Ein etwas komplexeres Beispiel:
+
+```yuescript
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+<YueDisplay>
+
+```yue
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+</YueDisplay>
+
+Es ist üblich, Werte aus einer Tabelle zu extrahieren und ihnen lokale Variablen mit demselben Namen wie der Schlüssel zuzuweisen. Um Wiederholungen zu vermeiden, kannst du den Präfix-Operator **:** verwenden:
+
+```yuescript
+{:concat, :insert} = table
+```
+
+<YueDisplay>
+
+```yue
+{:concat, :insert} = table
+```
+
+</YueDisplay>
+
+Das ist effektiv dasselbe wie `import`, aber du kannst Felder umbenennen, indem du die Syntax mischst:
+
+```yuescript
+{:mix, :max, random: rand} = math
+```
+
+<YueDisplay>
+
+```yue
+{:mix, :max, random: rand} = math
+```
+
+</YueDisplay>
+
+Du kannst Standardwerte beim Destructuring angeben, z. B.:
+
+```yuescript
+{:name = "namenlos", :job = "arbeitlos"} = person
+```
+
+<YueDisplay>
+
+```yue
+{:name = "namenlos", :job = "arbeitlos"} = person
+```
+
+</YueDisplay>
+
+Du kannst `_` als Platzhalter verwenden, wenn du eine Listen-Destructuring-Zuweisung machst:
+
+```yuescript
+[_, two, _, four] = items
+```
+
+<YueDisplay>
+
+```yue
+[_, two, _, four] = items
+```
+
+</YueDisplay>
+
+## Bereichs-Destructuring
+
+Du kannst den Spread-Operator `...` in Listen-Destructuring verwenden, um einen Wertebereich zu erfassen. Das ist nützlich, wenn du bestimmte Elemente am Anfang und Ende einer Liste extrahieren und den Rest dazwischen sammeln willst.
+
+```yuescript
+orders = ["erster", "zweiter", "dritter", "vierter", "letzter"]
+[first, ...bulk, last] = orders
+print first  -- gibt aus: erster
+print bulk   -- gibt aus: {"zweiter", "dritter", "vierter"}
+print last   -- gibt aus: letzter
+```
+
+<YueDisplay>
+
+```yue
+orders = ["erster", "zweiter", "dritter", "vierter", "letzter"]
+[first, ...bulk, last] = orders
+print first  -- gibt aus: erster
+print bulk   -- gibt aus: {"zweiter", "dritter", "vierter"}
+print last   -- gibt aus: letzter
+```
+
+</YueDisplay>
+
+Der Spread-Operator kann an unterschiedlichen Positionen verwendet werden, um unterschiedliche Bereiche zu erfassen, und du kannst `_` als Platzhalter für Werte verwenden, die du nicht erfassen willst:
+
+```yuescript
+-- Alles nach dem ersten Element erfassen
+[first, ...rest] = orders
+
+-- Alles vor dem letzten Element erfassen
+[...start, last] = orders
+
+-- Alles außer den mittleren Elementen erfassen
+[first, ..._, last] = orders
+```
+
+<YueDisplay>
+
+```yue
+-- Alles nach dem ersten Element erfassen
+[first, ...rest] = orders
+
+-- Alles vor dem letzten Element erfassen
+[...start, last] = orders
+
+-- Alles außer den mittleren Elementen erfassen
+[first, ..._, last] = orders
+```
+
+</YueDisplay>
+
+## Destructuring an anderen Stellen
+
+Destructuring kann auch an Stellen vorkommen, an denen eine Zuweisung implizit erfolgt. Ein Beispiel ist eine `for`-Schleife:
+
+```yuescript
+tuples = [
+  ["hallo", "Welt"]
+  ["Ei", "Kopf"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+<YueDisplay>
+
+```yue
+tuples = [
+  ["hallo", "Welt"]
+  ["Ei", "Kopf"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+</YueDisplay>
+
+Wir wissen, dass jedes Element der Array-Tabelle ein 2er-Tupel ist, daher können wir es direkt in der Namensliste der `for`-Anweisung mittels Destructuring entpacken.
+
+# Die Using-Klausel: Destruktive Zuweisung kontrollieren
+
+Lexikalisches Scoping kann die Komplexität des Codes stark reduzieren, aber mit wachsendem Codeumfang kann es unübersichtlich werden. Betrachte folgendes Beispiel:
+
+```yuescript
+i = 100
+
+-- viele Zeilen Code...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- wird 0 ausgeben
+```
+
+<YueDisplay>
+
+```yue
+i = 100
+
+-- viele Zeilen Code...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- wird 0 ausgeben
+```
+
+</YueDisplay>
+
+In `my_func` haben wir den Wert von `i` versehentlich überschrieben. In diesem Beispiel ist es offensichtlich, aber in einer großen oder fremden Codebasis ist oft nicht klar, welche Namen bereits deklariert wurden.
+
+Es wäre hilfreich, anzugeben, welche Variablen aus dem umschließenden Scope wir verändern wollen, um versehentliche Änderungen zu vermeiden.
+
+Das Schlüsselwort `using` ermöglicht das. `using nil` stellt sicher, dass keine geschlossenen Variablen bei Zuweisungen überschrieben werden. Die `using`-Klausel steht nach der Argumentliste einer Funktion oder ersetzt sie, wenn es keine Argumente gibt.
+
+```yuescript
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- hier wird eine neue lokale Variable erstellt
+
+my_func!
+print i -- gibt 100 aus, i bleibt unverändert
+```
+
+<YueDisplay>
+
+```yue
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- hier wird eine neue lokale Variable erstellt
+
+my_func!
+print i -- gibt 100 aus, i bleibt unverändert
+```
+
+</YueDisplay>
+
+Mehrere Namen können durch Kommas getrennt werden. Closure-Werte können weiterhin gelesen, aber nicht verändert werden:
+
+```yuescript
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- ein neues lokales tmp wird erstellt
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- diese wurden aktualisiert
+```
+
+<YueDisplay>
+
+```yue
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- ein neues lokales tmp wird erstellt
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- diese wurden aktualisiert
+```
+
+</YueDisplay>
+
+# Verwendung
+
+## Lua-Modul
+
+YueScript-Modul in Lua verwenden:
+
+- **Fall 1**
+
+  "your_yuescript_entry.yue" in Lua require'n.
+
+  ```Lua
+  require("yue")("your_yuescript_entry")
+  ```
+
+  Dieser Code funktioniert weiterhin, wenn du "your_yuescript_entry.yue" im gleichen Pfad zu "your_yuescript_entry.lua" kompilierst. In den restlichen YueScript-Dateien verwendest du einfach normales **require** oder **import**. Die Zeilennummern in Fehlermeldungen werden korrekt behandelt.
+
+- **Fall 2**
+
+  YueScript-Modul require'n und das Fehlermapping manuell umschreiben.
+
+  ```lua
+  local yue = require("yue")
+  yue.insert_loader()
+  local success, result = xpcall(function()
+    return require("yuescript_module_name")
+  end, function(err)
+    return yue.traceback(err)
+  end)
+  ```
+
+- **Fall 3**
+
+  Die YueScript-Compilerfunktion in Lua verwenden.
+
+  ```lua
+  local yue = require("yue")
+  local codes, err, globals = yue.to_lua([[
+    f = ->
+      print "Hallo Welt"
+    f!
+  ]],{
+    implicit_return_root = true,
+    reserve_line_number = true,
+    lint_global = true,
+    space_over_tab = false,
+    options = {
+      target = "5.4",
+      path = "/script"
+    }
+  })
+  ```
+
+## YueScript-Tool
+
+YueScript-Tool verwenden mit:
+
+```shell
+> yue -h
+Verwendung: yue
+          [Optionen] [<Datei/Verzeichnis>] ...
+          yue -e <code_oder_datei> [argumente...]
+          yue -w [<verzeichnis>] [optionen]
+          yue -
+
+Hinweise:
+   - '-' / '--' muss das erste und einzige Argument sein.
+   - '-o/--output' kann nicht mit mehreren Eingabedateien verwendet werden.
+   - '-w/--watch' kann nicht mit Dateieingabe verwendet werden (nur Verzeichnisse).
+   - Mit '-e/--execute' werden verbleibende Tokens als Skriptargumente behandelt.
+
+Optionen:
+   -h, --help                 Zeigt diese Hilfemeldung an und beendet das Programm.
+   -e <str>, --execute <str>  Datei oder Quellcode ausführen
+   -m, --minify               Minimierten Code erzeugen
+   -r, --rewrite              Ausgabe so umschreiben, dass die Zeilennummern dem Original entsprechen
+   -t <ziel>, --output-to <ziel>
+                              Ziel für kompilierte Dateien angeben
+   -o <datei>, --output <datei>
+                              Schreibe die Ausgabe in eine Datei
+   -p, --print                Schreibe die Ausgabe auf die Standardausgabe
+   -b, --benchmark            Gibt die Kompilierungszeit aus (keine Ausgabe schreiben)
+   -g, --globals              Gibt verwendete globale Variablen im Format NAME ZEILE SPALTE aus
+   -s, --spaces               Verwende Leerzeichen anstelle von Tabs im generierten Code
+   -l, --line-numbers         Schreibe Zeilennummern aus dem Quellcode
+   -j, --no-implicit-return   Deaktiviert implizites Rückgabe am Datei-Ende
+   -c, --reserve-comments     Kommentare aus dem Quellcode vor Anweisungen beibehalten
+   -w [<verz>], --watch [<verz>]
+                              Änderungen beobachten und alle Dateien im Verzeichnis kompilieren
+   -v, --version              Version ausgeben
+   -                          Lese von Standardinput, schreibe auf Standardausgabe
+                              (muss das erste und einzige Argument sein)
+   --                         Wie '-', bleibt zur Abwärtskompatibilität bestehen
+
+   --target <version>         Gib an, welche Lua-Version erzeugt werden soll
+                              (Version nur von 5.1 bis 5.5 möglich)
+   --path <pfad_str>          Füge einen zusätzlichen Lua-Suchpfad zu package.path hinzu
+   --<schlüssel>=<wert>       Übertrage Compileroption im Schlüssel=Wert-Format (bestehendes Verhalten)
+
+   Ohne Optionen wird die REPL gestartet, gebe das Symbol '$'
+   in eine einzelne Zeile ein, um den Multi-Line-Modus zu starten/beenden
+```
+
+Anwendungsfälle:
+
+Rekursiv jede YueScript-Datei mit der Endung **.yue** unter dem aktuellen Pfad kompilieren: **yue .**
+
+Kompilieren und Ergebnisse in einen Zielpfad schreiben: **yue -t /target/path/ .**
+
+Kompilieren und Debug-Infos beibehalten: **yue -l .**
+
+Kompilieren und minifizierten Code erzeugen: **yue -m .**
+
+Rohcode ausführen: **yue -e 'print 123'**
+
+Eine YueScript-Datei ausführen: **yue -e main.yue**
+
+# Einführung
+
+YueScript ist eine dynamische Sprache, die zu Lua kompiliert. Sie ist ein Dialekt von [MoonScript](https://github.com/leafo/moonscript). Code, der in YueScript geschrieben wird, ist ausdrucksstark und sehr kompakt. YueScript eignet sich zum Schreiben von veränderlicher Anwendungslogik mit besser wartbarem Code und läuft in eingebetteten Lua-Umgebungen wie Spielen oder Webservern.
+
+Yue (月) ist das chinesische Wort für Mond und wird als [jyɛ] ausgesprochen.
+
+## Ein Überblick über YueScript
+
+```yuescript
+-- Import-Syntax
+import p, to_lua from "yue"
+
+-- Objekt-Literale
+inventory =
+  equipment:
+    - "Schwert"
+    - "Schild"
+  items:
+    - name: "Trank"
+      count: 10
+    - name: "Brot"
+      count: 3
+
+-- Listen-Abstraktion
+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 .<>?
+
+-- export-Syntax (ähnlich wie in JavaScript)
+export 🌛 = "Skript des Mondes"
+```
+
+<YueDisplay>
+
+```yue
+-- Import-Syntax
+import p, to_lua from "yue"
+
+-- Objekt-Literale
+inventory =
+  equipment:
+    - "Schwert"
+    - "Schild"
+  items:
+    - name: "Trank"
+      count: 10
+    - name: "Brot"
+      count: 3
+
+-- Listen-Abstraktion
+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 .<>?
+
+-- export-Syntax (ähnlich wie in JavaScript)
+export 🌛 = "Skript des Mondes"
+```
+
+</YueDisplay>
+
+## Über Dora SSR
+
+YueScript wird zusammen mit der Open-Source-Spiel-Engine [Dora SSR](https://github.com/Dora-SSR/Dora-SSR) entwickelt und gepflegt. Es wird zum Erstellen von Engine-Tools, Spiel-Demos und Prototypen eingesetzt und hat seine Leistungsfähigkeit in realen Szenarien unter Beweis gestellt, während es gleichzeitig die Dora-SSR-Entwicklungserfahrung verbessert.
+
+# Installation
+
+## Lua-Modul
+
+Installiere [luarocks](https://luarocks.org), einen Paketmanager für Lua-Module. Installiere YueScript dann als Lua-Modul und ausführbare Datei mit:
+
+```shell
+luarocks install yuescript
+```
+
+Oder du kannst die Datei `yue.so` bauen mit:
+
+```shell
+make shared LUAI=/usr/local/include/lua LUAL=/usr/local/lib/lua
+```
+
+Anschließend findest du die Binärdatei unter **bin/shared/yue.so**.
+
+## Binär-Tool bauen
+
+Klone dieses Repo und baue/installiere die ausführbare Datei mit:
+
+```shell
+make install
+```
+
+YueScript-Tool ohne Makro-Feature bauen:
+
+```shell
+make install NO_MACRO=true
+```
+
+YueScript-Tool ohne eingebautes Lua-Binary bauen:
+
+```shell
+make install NO_LUA=true
+```
+
+## Vorgefertigtes Binary herunterladen
+
+Du kannst vorkompilierte Binärdateien herunterladen, inklusive ausführbarer Dateien für unterschiedliche Lua-Versionen und Bibliotheksdateien.
+
+Lade vorkompilierte Binärdateien von [hier](https://github.com/IppClub/YueScript/releases) herunter.
+
+# Bedingungen
+
+```yuescript
+have_coins = false
+if have_coins
+  print "Münzen erhalten"
+else
+  print "Keine Münzen"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins
+  print "Münzen erhalten"
+else
+  print "Keine Münzen"
+```
+
+</YueDisplay>
+
+Eine Kurzsyntax für einzelne Anweisungen kann ebenfalls verwendet werden:
+
+```yuescript
+have_coins = false
+if have_coins then print "Münzen erhalten" else print "Keine Münzen"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins then print "Münzen erhalten" else print "Keine Münzen"
+```
+
+</YueDisplay>
+
+Da `if`-Anweisungen als Ausdrücke verwendet werden können, kann man das auch so schreiben:
+
+```yuescript
+have_coins = false
+print if have_coins then "Münzen erhalten" else "Keine Münzen"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+print if have_coins then "Münzen erhalten" else "Keine Münzen"
+```
+
+</YueDisplay>
+
+Bedingungen können auch in `return`-Anweisungen und Zuweisungen verwendet werden:
+
+```yuescript
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "Ich bin sehr groß"
+else
+  "Ich bin nicht so groß"
+
+print message -- gibt aus: Ich bin sehr groß
+```
+
+<YueDisplay>
+
+```yue
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "Ich bin sehr groß"
+else
+  "Ich bin nicht so groß"
+
+print message -- gibt aus: Ich bin sehr groß
+```
+
+</YueDisplay>
+
+Das Gegenteil von `if` ist `unless`:
+
+```yuescript
+unless os.date("%A") == "Monday"
+  print "Es ist nicht Montag!"
+```
+
+<YueDisplay>
+
+```yue
+unless os.date("%A") == "Monday"
+  print "Es ist nicht Montag!"
+```
+
+</YueDisplay>
+
+```yuescript
+print "You're lucky!" unless math.random! > 0.1
+```
+
+<YueDisplay>
+
+```yue
+print "You're lucky!" unless math.random! > 0.1
+```
+
+</YueDisplay>
+
+## In-Ausdruck
+
+Mit einem `in`-Ausdruck kannst du Bereichsprüfungen schreiben.
+
+```yuescript
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "Gleichheitsprüfung mit diskreten Werten"
+
+if a in list
+  print "Prüfen, ob `a` in einer Liste ist"
+```
+
+<YueDisplay>
+
+```yue
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "Gleichheitsprüfung mit diskreten Werten"
+
+if a in list
+  print "Prüfen, ob `a` in einer Liste ist"
+```
+
+</YueDisplay>
+
+# For-Schleife
+
+Es gibt zwei Formen der `for`-Schleife, genau wie in Lua: eine numerische und eine generische.
+
+```yuescript
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- ein optionaler Schritt
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+
+<YueDisplay>
+
+```yue
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- ein optionaler Schritt
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+
+</YueDisplay>
+
+Die Slicing- und **\***-Operatoren können verwendet werden, genau wie bei Comprehensions:
+
+```yuescript
+for item in *items[2, 4]
+  print item
+```
+
+<YueDisplay>
+
+```yue
+for item in *items[2, 4]
+  print item
+```
+
+</YueDisplay>
+
+Eine kürzere Syntax ist für alle Varianten verfügbar, wenn der Rumpf nur eine Zeile hat:
+
+```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>
+
+Eine `for`-Schleife kann auch als Ausdruck verwendet werden. Die letzte Anweisung im Schleifenrumpf wird in einen Ausdruck umgewandelt und an eine wachsende Array-Tabelle angehängt.
+
+Alle geraden Zahlen verdoppeln:
+
+```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>
+
+Zusätzlich unterstützen `for`-Schleifen `break` mit Rückgabewerten, sodass die Schleife selbst als Ausdruck verwendet werden kann, der früh mit einem sinnvollen Ergebnis endet. `for`-Ausdrücke unterstützen mehrere `break`-Werte.
+
+Beispiel: die erste Zahl größer als 10 finden:
+
+```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>
+
+Diese `break`-mit-Wert-Syntax ermöglicht knappe und ausdrucksstarke Such- bzw. Early-Exit-Muster direkt in Schleifenausdrücken.
+
+```yuescript
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+<YueDisplay>
+
+```yue
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+</YueDisplay>
+
+Du kannst Werte auch filtern, indem du den `for`-Ausdruck mit `continue` kombinierst.
+
+`for`-Schleifen am Ende eines Funktionsrumpfs werden nicht in eine Tabelle für einen Rückgabewert gesammelt (stattdessen gibt die Funktion `nil` zurück). Du kannst entweder explizit `return` verwenden oder die Schleife in eine Listen-Comprehension umwandeln.
+
+```yuescript
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- gibt nil aus
+print func_b! -- gibt Tabellenobjekt aus
+```
+
+<YueDisplay>
+
+```yue
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- gibt nil aus
+print func_b! -- gibt Tabellenobjekt aus
+```
+
+</YueDisplay>
+
+Das verhindert die unnötige Erstellung von Tabellen in Funktionen, die die Ergebnisse der Schleife nicht zurückgeben müssen.
+
+# Continue
+
+Eine `continue`-Anweisung überspringt die aktuelle Iteration einer Schleife.
+
+```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` kann auch mit Schleifenausdrücken verwendet werden, um zu verhindern, dass diese Iteration in das Ergebnis akkumuliert wird. Dieses Beispiel filtert die Array-Tabelle auf gerade Zahlen:
+
+```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>
+
+# Switch
+
+Die `switch`-Anweisung ist eine Kurzform für eine Reihe von `if`-Anweisungen, die gegen denselben Wert prüfen. Der Wert wird nur einmal ausgewertet. Wie bei `if` kann `switch` einen `else`-Block haben, wenn keine Übereinstimmung gefunden wird. Verglichen wird mit dem Operator `==`. In einer `switch`-Anweisung kannst du auch eine Zuweisung verwenden, um den temporären Wert zu speichern.
+
+```yuescript
+switch name := "Dan"
+  when "Robert"
+    print "Du bist Robert"
+  when "Dan", "Daniel"
+    print "Dein Name ist Dan"
+  else
+    print "Ich kenne dich nicht mit dem Namen #{name}"
+```
+
+<YueDisplay>
+
+```yue
+switch name := "Dan"
+  when "Robert"
+    print "Du bist Robert"
+  when "Dan", "Daniel"
+    print "Dein Name ist Dan"
+  else
+    print "Ich kenne dich nicht mit dem Namen #{name}"
+```
+
+</YueDisplay>
+
+Eine `when`-Klausel kann mehrere Werte prüfen, indem sie kommasepariert aufgelistet werden.
+
+`switch` kann auch als Ausdruck verwendet werden. Hier wird das Ergebnis der `switch`-Anweisung einer Variable zugewiesen:
+
+```yuescript
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "so hoch kann ich nicht zählen!"
+```
+
+<YueDisplay>
+
+```yue
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "so hoch kann ich nicht zählen!"
+```
+
+</YueDisplay>
+
+Du kannst das Schlüsselwort `then` verwenden, um einen `when`-Block in einer Zeile zu schreiben. Für den `else`-Block braucht es kein zusätzliches Schlüsselwort.
+
+```yuescript
+msg = switch math.random(1, 5)
+  when 1 then "Du hast Glück"
+  when 2 then "Du hast fast Glück"
+  else "nicht so viel Glück"
+```
+
+<YueDisplay>
+
+```yue
+msg = switch math.random(1, 5)
+  when 1 then "Du hast Glück"
+  when 2 then "Du hast fast Glück"
+  else "nicht so viel Glück"
+```
+
+</YueDisplay>
+
+Wenn du eine Einrückung weniger möchtest, kannst du die erste `when`-Klausel in die Startzeile der Anweisung setzen und alle weiteren Klauseln mit einer Einrückung weniger schreiben.
+
+```yuescript
+switch math.random(1, 5)
+  when 1
+    print "Du hast Glück" -- zwei Einrückungen
+  else
+    print "nicht so viel Glück"
+
+switch math.random(1, 5) when 1
+  print "Du hast Glück" -- eine Einrückung
+else
+  print "nicht so viel Glück"
+```
+
+<YueDisplay>
+
+```yue
+switch math.random(1, 5)
+  when 1
+    print "Du hast Glück" -- zwei Einrückungen
+  else
+    print "nicht so viel Glück"
+
+switch math.random(1, 5) when 1
+  print "Du hast Glück" -- eine Einrückung
+else
+  print "nicht so viel Glück"
+```
+
+</YueDisplay>
+
+Beachte die Reihenfolge des Case-Vergleichsausdrucks. Der Case-Ausdruck steht auf der linken Seite. Das kann nützlich sein, wenn der Case-Ausdruck die Vergleichslogik über eine `__eq`-Metamethod selbst definiert.
+
+## Tabellen-Matching
+
+Du kannst in einer `switch`-`when`-Klausel Tabellen-Matching verwenden, wenn die Tabelle durch eine bestimmte Struktur destrukturiert werden kann und dabei nicht-`nil`-Werte liefert.
+
+```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 "Größe #{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 "Größe #{width}, #{height}"
+```
+
+</YueDisplay>
+
+Du kannst Standardwerte verwenden, um bestimmte Felder optional zu destrukturieren.
+
+```yuescript
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- Fehler: Versuch, einen nil-Wert zu indexieren (Feld 'pos')
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- Tabellen-Destrukturierung greift trotzdem
+```
+
+<YueDisplay>
+
+```yue
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- Fehler: Versuch, einen nil-Wert zu indexieren (Feld 'pos')
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- Tabellen-Destrukturierung greift trotzdem
+```
+
+</YueDisplay>
+
+Du kannst auch gegen Array-Elemente, Tabellenfelder und sogar verschachtelte Strukturen mit Array- oder Tabellenliteralen matchen.
+
+Matchen gegen Array-Elemente.
+
+```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 hat einen Standardwert
+    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 hat einen Standardwert
+    print "1, 2, #{b}"
+```
+
+</YueDisplay>
+
+Matchen gegen Tabellenfelder mit Destructuring.
+
+```yuescript
+switch tb
+  when success: true, :result
+    print "Erfolg", result
+  when success: false
+    print "fehlgeschlagen", result
+  else
+    print "ungültig"
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when success: true, :result
+    print "Erfolg", result
+  when success: false
+    print "fehlgeschlagen", result
+  else
+    print "ungültig"
+```
+
+</YueDisplay>
+
+Matchen gegen verschachtelte Tabellenstrukturen.
+
+```yuescript
+switch tb
+  when data: {type: "success", :content}
+    print "Erfolg", content
+  when data: {type: "error", :content}
+    print "fehlgeschlagen", content
+  else
+    print "ungültig"
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when data: {type: "success", :content}
+    print "Erfolg", content
+  when data: {type: "error", :content}
+    print "fehlgeschlagen", content
+  else
+    print "ungültig"
+```
+
+</YueDisplay>
+
+Matchen gegen Array von Tabellen.
+
+```yuescript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "getroffen", fourth
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "getroffen", fourth
+```
+
+</YueDisplay>
+
+Matchen gegen eine Liste und einen Bereich von Elementen erfassen.
+
+```yuescript
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Gruppe:", groups -- gibt aus: {"admin", "users"}
+    print "Ressource:", resource -- gibt aus: "logs"
+    print "Aktion:", action -- gibt aus: "view"
+```
+
+<YueDisplay>
+
+```yue
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Gruppe:", groups -- gibt aus: {"admin", "users"}
+    print "Ressource:", resource -- gibt aus: "logs"
+    print "Aktion:", action -- gibt aus: "view"
+```
+
+</YueDisplay>
+
+# While-Schleife
+
+Die `while`-Schleife gibt es ebenfalls in vier Variationen:
+
+```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>
+
+Wie bei `for`-Schleifen kann die `while`-Schleife auch als Ausdruck verwendet werden. `while`- und `until`-Ausdrücke unterstützen `break` mit mehreren Rückgabewerten.
+
+```yuescript
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+<YueDisplay>
+
+```yue
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+</YueDisplay>
+
+Damit eine Funktion den akkumulierten Wert einer `while`-Schleife zurückgibt, muss die Anweisung explizit mit `return` zurückgegeben werden.
+
+## Repeat-Schleife
+
+Die `repeat`-Schleife stammt aus 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>
+
+`repeat`-Ausdrücke unterstützen ebenfalls `break` mit mehreren Rückgabewerten:
+
+```yuescript
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+<YueDisplay>
+
+```yue
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+</YueDisplay>
+
+# Funktions-Stubs
+
+Es ist üblich, eine Funktion eines Objekts als Wert weiterzureichen, z. B. eine Instanzmethode als Callback. Wenn die Funktion das Objekt, auf dem sie arbeitet, als erstes Argument erwartet, musst du dieses Objekt irgendwie mit der Funktion bündeln, damit sie korrekt aufgerufen werden kann.
+
+Die Funktions-Stub-Syntax ist eine Kurzform, um eine neue Closure-Funktion zu erstellen, die sowohl Objekt als auch Funktion bündelt. Diese neue Funktion ruft die umschlossene Funktion im richtigen Kontext des Objekts auf.
+
+Die Syntax entspricht dem Aufruf einer Instanzmethode mit dem `\`-Operator, jedoch ohne Argumentliste.
+
+```yuescript
+my_object = {
+  value: 1000
+  write: => print "der Wert:", @value
+}
+
+run_callback = (func) ->
+  print "Callback wird ausgeführt..."
+  func!
+
+-- das funktioniert nicht:
+-- die Funktion darf keine Referenz auf my_object haben
+run_callback my_object.write
+
+-- Funktions-Stub-Syntax
+-- bindet das Objekt in eine neue Funktion ein
+run_callback my_object\write
+```
+
+<YueDisplay>
+
+```yue
+my_object = {
+  value: 1000
+  write: => print "der Wert:", @value
+}
+
+run_callback = (func) ->
+  print "Callback wird ausgeführt..."
+  func!
+
+-- das funktioniert nicht:
+-- die Funktion darf keine Referenz auf my_object haben
+run_callback my_object.write
+
+-- Funktions-Stub-Syntax
+-- bindet das Objekt in eine neue Funktion ein
+run_callback my_object\write
+```
+
+</YueDisplay>
+
+# Backcalls
+
+Backcalls werden verwendet, um Callbacks zu entkoppeln (unnesting). Sie werden mit Pfeilen nach links definiert und füllen standardmäßig als letzter Parameter einen Funktionsaufruf. Die Syntax ist weitgehend wie bei normalen Pfeilfunktionen, nur dass der Pfeil in die andere Richtung zeigt und der Funktionskörper keine Einrückung benötigt.
+
+```yuescript
+x <- f
+print "hallo" .. x
+```
+
+<YueDisplay>
+
+```yue
+x <- f
+print "hallo" .. x
+```
+
+</YueDisplay>
+
+Fat-Arrow-Funktionen sind ebenfalls verfügbar.
+
+```yuescript
+<= f
+print @value
+```
+
+<YueDisplay>
+
+```yue
+<= f
+print @value
+```
+
+</YueDisplay>
+
+Du kannst einen Platzhalter angeben, an welcher Stelle die Backcall-Funktion als Parameter eingesetzt werden soll.
+
+```yuescript
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+<YueDisplay>
+
+```yue
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+</YueDisplay>
+
+Wenn du nach deinen Backcalls weiteren Code haben willst, kannst du sie mit einem `do`-Statement absetzen. Bei Nicht-Fat-Arrow-Funktionen können die Klammern weggelassen werden.
+
+```yuescript
+result, msg = do
+  data <- readAsync "dateiname.txt"
+  print data
+  info <- processAsync data
+  check info
+print result, msg
+```
+
+<YueDisplay>
+
+```yue
+result, msg = do
+  data <- readAsync "dateiname.txt"
+  print data
+  info <- processAsync data
+  check info
+print result, msg
+```
+
+</YueDisplay>
+
+# Funktionsliterale
+
+Alle Funktionen werden mit einem Funktionsausdruck erstellt. Eine einfache Funktion wird mit dem Pfeil **->** notiert.
+
+```yuescript
+my_function = ->
+my_function() -- leere Funktion aufrufen
+```
+
+<YueDisplay>
+
+```yue
+my_function = ->
+my_function() -- leere Funktion aufrufen
+```
+
+</YueDisplay>
+
+Der Funktionskörper kann entweder eine einzelne Anweisung direkt nach dem Pfeil sein oder aus mehreren Anweisungen bestehen, die in den folgenden Zeilen eingerückt werden:
+
+```yuescript
+func_a = -> print "Hallo Welt"
+
+func_b = ->
+  value = 100
+  print "Der Wert:", value
+```
+
+<YueDisplay>
+
+```yue
+func_a = -> print "Hallo Welt"
+
+func_b = ->
+  value = 100
+  print "Der Wert:", value
+```
+
+</YueDisplay>
+
+Wenn eine Funktion keine Argumente hat, kann sie mit dem `!`-Operator statt leerer Klammern aufgerufen werden. Der `!`-Aufruf ist die bevorzugte Art, Funktionen ohne Argumente aufzurufen.
+
+```yuescript
+func_a!
+func_b()
+```
+
+<YueDisplay>
+
+```yue
+func_a!
+func_b()
+```
+
+</YueDisplay>
+
+Funktionen mit Argumenten werden erstellt, indem der Pfeil von einer Argumentliste in Klammern eingeleitet wird:
+
+```yuescript
+sum = (x, y) -> print "Summe", x + y
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> print "Summe", x + y
+```
+
+</YueDisplay>
+
+Funktionen können aufgerufen werden, indem die Argumente hinter dem Namen eines Ausdrucks stehen, der zu einer Funktion evaluiert. Beim Verketten mehrerer Funktionsaufrufe werden die Argumente der nächstliegenden Funktion links zugeordnet.
+
+```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>
+
+Um Mehrdeutigkeiten beim Aufruf zu vermeiden, können die Argumente auch in Klammern gesetzt werden. Das ist hier nötig, damit die richtigen Argumente an die richtigen Funktionen gehen.
+
+```yuescript
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+<YueDisplay>
+
+```yue
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+</YueDisplay>
+
+Zwischen öffnender Klammer und Funktionsname darf kein Leerzeichen stehen.
+
+Funktionen wandeln die letzte Anweisung im Funktionskörper in ein `return` um. Das nennt sich implizites Return:
+
+```yuescript
+sum = (x, y) -> x + y
+print "Die Summe ist ", sum 10, 20
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> x + y
+print "Die Summe ist ", sum 10, 20
+```
+
+</YueDisplay>
+
+Wenn du explizit zurückgeben willst, verwende `return`:
+
+```yuescript
+sum = (x, y) -> return x + y
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> return x + y
+```
+
+</YueDisplay>
+
+Wie in Lua können Funktionen mehrere Werte zurückgeben. Die letzte Anweisung muss eine Liste von Werten sein, getrennt durch Kommas:
+
+```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
+
+Da es in Lua üblich ist, beim Methodenaufruf ein Objekt als erstes Argument zu übergeben, gibt es eine spezielle Syntax zum Erstellen von Funktionen, die automatisch ein `self`-Argument enthalten.
+
+```yuescript
+func = (num) => @value + num
+```
+
+<YueDisplay>
+
+```yue
+func = (num) => @value + num
+```
+
+</YueDisplay>
+
+## Standardwerte für Argumente
+
+Es ist möglich, Standardwerte für Funktionsargumente anzugeben. Ein Argument gilt als leer, wenn sein Wert `nil` ist. Alle `nil`-Argumente mit Standardwert werden vor Ausführung des Funktionskörpers ersetzt.
+
+```yuescript
+my_function = (name = "etwas", height = 100) ->
+  print "Hallo, ich bin", name
+  print "Meine Größe ist", height
+```
+
+<YueDisplay>
+
+```yue
+my_function = (name = "etwas", height = 100) ->
+  print "Hallo, ich bin", name
+  print "Meine Größe ist", height
+```
+
+</YueDisplay>
+
+Der Ausdruck für den Standardwert wird im Funktionskörper in der Reihenfolge der Argumentdeklarationen ausgewertet. Daher können Standardwerte auf zuvor deklarierte Argumente zugreifen.
+
+```yuescript
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+<YueDisplay>
+
+```yue
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+</YueDisplay>
+
+## Hinweise
+
+Aufgrund der ausdrucksstarken, klammerlosen Funktionsaufrufe müssen einige Einschränkungen gelten, um Parsing-Mehrdeutigkeiten mit Leerraum zu vermeiden.
+
+Das Minuszeichen hat zwei Rollen: unäre Negation und binäre Subtraktion. Sieh dir an, wie die folgenden Beispiele kompiliert werden:
+
+```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>
+
+Die Präzedenz des ersten Arguments eines Funktionsaufrufs kann mit Leerraum gesteuert werden, wenn das Argument ein String-Literal ist. In Lua lässt man bei Aufrufen mit einem einzelnen String- oder Tabellenliteral häufig die Klammern weg.
+
+Wenn kein Leerzeichen zwischen Variable und String-Literal steht, hat der Funktionsaufruf Vorrang vor nachfolgenden Ausdrücken. In dieser Form können keine weiteren Argumente übergeben werden.
+
+Steht ein Leerzeichen zwischen Variable und String-Literal, verhält sich der Aufruf wie oben gezeigt. Das String-Literal gehört dann zu nachfolgenden Ausdrücken (falls vorhanden) und dient als Argumentliste.
+
+```yuescript
+x = func"hallo" + 100
+y = func "hallo" + 100
+```
+
+<YueDisplay>
+
+```yue
+x = func"hallo" + 100
+y = func "hallo" + 100
+```
+
+</YueDisplay>
+
+## Mehrzeilige Argumente
+
+Wenn Funktionsaufrufe viele Argumente haben, ist es praktisch, die Argumentliste auf mehrere Zeilen zu verteilen. Wegen der whitespace-sensitiven Natur der Sprache muss man dabei sorgfältig sein.
+
+Wenn eine Argumentliste in der nächsten Zeile fortgesetzt wird, muss die aktuelle Zeile mit einem Komma enden. Die folgende Zeile muss stärker eingerückt sein als die aktuelle. Sobald eingerückt, müssen alle weiteren Argumentzeilen auf derselben Einrückungsebene liegen, um Teil der Argumentliste zu sein.
+
+```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>
+
+Diese Art des Aufrufs kann verschachtelt werden. Die Einrückungsebene bestimmt, zu welcher Funktion die Argumente gehören.
+
+```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>
+
+Da Tabellen ebenfalls das Komma als Trennzeichen verwenden, hilft diese Einrückungssyntax dabei, Werte zur Argumentliste gehören zu lassen, statt zur Tabelle.
+
+```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>
+
+Obwohl es selten ist: Du kannst Funktionsargumente tiefer einrücken, wenn du weißt, dass du später eine geringere Einrückungsebene verwenden wirst.
+
+```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>
+
+Dasselbe lässt sich mit anderen Block-Statements wie Bedingungen machen. Wir können die Einrückungsebene verwenden, um zu bestimmen, zu welcher Anweisung ein Wert gehört:
+
+```yuescript
+if func 1, 2, 3,
+  "hallo",
+  "Welt"
+    print "hallo"
+    print "Ich bin innerhalb der if-Bedingung"
+
+if func 1, 2, 3,
+    "hallo",
+    "Welt"
+  print "hallo"
+  print "Ich bin innerhalb der if-Bedingung"
+```
+
+<YueDisplay>
+
+```yue
+if func 1, 2, 3,
+  "hallo",
+  "Welt"
+    print "hallo"
+    print "Ich bin innerhalb der if-Bedingung"
+
+if func 1, 2, 3,
+    "hallo",
+    "Welt"
+  print "hallo"
+  print "Ich bin innerhalb der if-Bedingung"
+```
+
+</YueDisplay>
+
+## Parameter-Destructuring
+
+YueScript unterstützt jetzt Destructuring von Funktionsparametern, wenn das Argument ein Objekt ist. Es gibt zwei Formen von Destructuring-Tabellenliteralen:
+
+- **Geschweifte Klammern/Objektparameter**, die optionale Standardwerte erlauben, wenn Felder fehlen (z. B. `{:a, :b}`, `{a: a1 = 123}`).
+- **Unverpackte einfache Tabellensyntax**, die mit einer Sequenz aus Key-Value- oder Shorthand-Bindings beginnt und so lange läuft, bis ein anderer Ausdruck sie beendet (z. B. `:a, b: b1, :c`). Diese Form extrahiert mehrere Felder aus demselben Objekt.
+
+```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>
+
+## Präfixiertes Return-Expression
+
+Wenn du mit tief verschachtelten Funktionskörpern arbeitest, kann es mühsam sein, die Lesbarkeit und Konsistenz des Rückgabewerts zu erhalten. Dafür führt YueScript die Syntax der **präfixierten Return-Expression** ein. Sie hat folgende Form:
+
+```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>
+
+Das ist äquivalent zu:
+
+```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>
+
+Der einzige Unterschied ist, dass du den finalen Rückgabeausdruck vor das `->`- oder `=>`-Token ziehen kannst, um den impliziten Rückgabewert der Funktion als letzte Anweisung zu kennzeichnen. So musst du selbst bei Funktionen mit mehreren verschachtelten Schleifen oder bedingten Zweigen kein abschließendes `return` am Ende des Funktionskörpers mehr schreiben, was die Logikstruktur klarer und leichter nachvollziehbar macht.
+
+## Benannte Varargs
+
+Mit der Syntax `(...t) ->` kannst du Varargs automatisch in einer benannten Tabelle speichern. Diese Tabelle enthält alle übergebenen Argumente (einschließlich `nil`-Werten), und das Feld `n` der Tabelle speichert die tatsächliche Anzahl übergebener Argumente (einschließlich `nil`-Werten).
+
+```yuescript
+f = (...t) ->
+  print "Anzahl der Argumente:", t.n
+  print "Tabellenlänge:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- Fälle mit nil-Werten behandeln
+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 "Anzahl der Argumente:", t.n
+  print "Tabellenlänge:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- Fälle mit nil-Werten behandeln
+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>
+
+# Leerraum
+
+YueScript ist eine whitespace-sensible Sprache. Du musst bestimmte Code-Blöcke mit derselben Einrückung (Leerzeichen **' '** oder Tab **'\t'**) schreiben, z. B. Funktionskörper, Wertelisten und Kontrollblöcke. Ausdrücke mit unterschiedlichem Leerraum können unterschiedliche Bedeutungen haben. Ein Tab wird wie 4 Leerzeichen behandelt, aber es ist besser, Leerzeichen und Tabs nicht zu mischen.
+
+## Anweisungs-Trenner
+
+Eine Anweisung endet normalerweise an einem Zeilenumbruch. Du kannst auch ein Semikolon `;` verwenden, um eine Anweisung explizit zu beenden, wodurch mehrere Anweisungen in einer Zeile möglich sind:
+
+```yuescript
+a = 1; b = 2; print a + b
+```
+
+<YueDisplay>
+
+```yue
+a = 1; b = 2; print a + b
+```
+
+</YueDisplay>
+
+## Mehrzeiliges Chaining
+
+Du kannst mehrzeilige, verkettete Funktionsaufrufe mit derselben Einrückung schreiben.
+
+```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>
+
+# Kommentare
+
+```yuescript
+-- Ich bin ein Kommentar
+
+str = --[[
+Dies ist ein mehrzeiliger Kommentar.
+Alles okay.
+]] strA \ -- Kommentar 1
+  .. strB \ -- Kommentar 2
+  .. strC
+
+func --[[Port]] 3000, --[[IP]] "192.168.1.1"
+```
+
+<YueDisplay>
+
+```yue
+-- Ich bin ein Kommentar
+
+str = --[[
+Dies ist ein mehrzeiliger Kommentar.
+Alles okay.
+]] strA \ -- Kommentar 1
+  .. strB \ -- Kommentar 2
+  .. strC
+
+func --[[Port]] 3000, --[[IP]] "192.168.1.1"
+```
+
+</YueDisplay>
+
+# Attribute
+
+Syntax-Unterstützung für Lua-5.4-Attribute. Du kannst weiterhin die Deklarationen `const` und `close` verwenden und erhältst Konstantenprüfung sowie Scoped-Callbacks, wenn du auf Lua-Versionen unter 5.4 zielst.
+
+```yuescript
+const a = 123
+close _ = <close>: -> print "Außerhalb des Gültigkeitsbereichs."
+```
+
+<YueDisplay>
+
+```yue
+const a = 123
+close _ = <close>: -> print "Außerhalb des Gültigkeitsbereichs."
+```
+
+</YueDisplay>
+
+Du kannst Destructuring mit als konstant markierten Variablen verwenden.
+
+```yuescript
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+<YueDisplay>
+
+```yue
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+</YueDisplay>
+
+Du kannst auch eine globale Variable als `const` deklarieren.
+
+```yuescript
+global const Constant = 123
+-- Constant = 1
+```
+
+<YueDisplay>
+
+```yue
+global const Constant = 123
+-- Constant = 1
+```
+
+</YueDisplay>
+
+# Operatoren
+
+Alle binären und unären Operatoren von Lua sind verfügbar. Zusätzlich ist **!=** ein Alias für **~=**, und entweder **\*\* oder **::\*\* kann für verkettete Funktionsaufrufe wie `tb\func!` oder `tb::func!` verwendet werden. Außerdem bietet YueScript einige spezielle Operatoren für ausdrucksstärkeren Code.
+
+```yuescript
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+<YueDisplay>
+
+```yue
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+</YueDisplay>
+
+## Verkettete Vergleiche
+
+Vergleiche können beliebig verkettet werden:
+
+```yuescript
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- Ausgabe: true
+
+a = 5
+print 1 <= a <= 10
+-- Ausgabe: true
+```
+
+<YueDisplay>
+
+```yue
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- Ausgabe: true
+
+a = 5
+print 1 <= a <= 10
+-- Ausgabe: true
+```
+
+</YueDisplay>
+
+Beachte das Auswertungsverhalten verketteter Vergleiche:
+
+```yuescript
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  Ausgabe:
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  Ausgabe:
+  2
+  1
+  false
+]]
+```
+
+<YueDisplay>
+
+```yue
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  Ausgabe:
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  Ausgabe:
+  2
+  1
+  false
+]]
+```
+
+</YueDisplay>
+
+Der mittlere Ausdruck wird nur einmal ausgewertet, nicht zweimal wie bei `v(1) < v(2) and v(2) <= v(3)`. Die Auswertungsreihenfolge in verketteten Vergleichen ist jedoch undefiniert. Es wird dringend empfohlen, in verketteten Vergleichen keine Ausdrücke mit Seiteneffekten (z. B. `print`) zu verwenden. Wenn Seiteneffekte nötig sind, sollte der Short-Circuit-Operator `and` explizit verwendet werden.
+
+## Tabellenerweiterung
+
+Der Operator **[] =** wird verwendet, um Werte an Tabellen anzuhängen.
+
+```yuescript
+tab = []
+tab[] = "Wert"
+```
+
+<YueDisplay>
+
+```yue
+tab = []
+tab[] = "Wert"
+```
+
+</YueDisplay>
+
+Du kannst auch den Spread-Operator `...` verwenden, um alle Elemente einer Liste an eine andere anzuhängen:
+
+```yuescript
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA ist jetzt [1, 2, 3, 4, 5, 6]
+```
+
+<YueDisplay>
+
+```yue
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA ist jetzt [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+## Tabellen-Spread
+
+Du kannst Array-Tabellen oder Hash-Tabellen mit dem Spread-Operator `...` vor Ausdrücken in Tabellenliteralen zusammenführen.
+
+```yuescript
+parts =
+  * "Schultern"
+  * "Knie"
+lyrics =
+  * "Kopf"
+  * ...parts
+  * "und"
+  * "Zehen"
+
+copy = {...other}
+
+a = {1, 2, 3, x: 1}
+b = {4, 5, y: 1}
+merge = {...a, ...b}
+```
+
+<YueDisplay>
+
+```yue
+parts =
+  * "Schultern"
+  * "Knie"
+lyrics =
+  * "Kopf"
+  * ...parts
+  * "und"
+  * "Zehen"
+
+copy = {...other}
+
+a = {1, 2, 3, x: 1}
+b = {4, 5, y: 1}
+merge = {...a, ...b}
+```
+
+</YueDisplay>
+
+## Umgekehrter Tabellenindex
+
+Mit dem Operator **#** kannst du auf die letzten Elemente einer Tabelle zugreifen.
+
+```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
+
+Der Operator **<>** kann als Abkürzung für Metatable-Manipulation verwendet werden.
+
+### Metatable erstellen
+
+Erzeuge eine normale Tabelle mit leeren Klammern **<>** oder einem Metamethod-Schlüssel, der von **<>** umschlossen ist.
+
+```yuescript
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+ -- Feld mit gleichnamiger Variable setzen
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "Außerhalb des Gültigkeitsbereichs"
+```
+
+<YueDisplay>
+
+```yue
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+ -- Feld mit gleichnamiger Variable setzen
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "Außerhalb des Gültigkeitsbereichs"
+```
+
+</YueDisplay>
+
+### Metatable-Zugriff
+
+Metatable mit **<>** oder einem von **<>** umschlossenen Metamethod-Namen aufrufen oder einen Ausdruck in **<>** schreiben.
+
+```yuescript
+-- erstellen mit Metatable, das das Feld "value" enthält
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+
+tb.<> = __index: {item: "hallo"}
+print tb.item
+```
+
+<YueDisplay>
+
+```yue
+-- erstellen mit Metatable, das das Feld "value" enthält
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+tb.<> = __index: {item: "hallo"}
+print tb.item
+```
+
+</YueDisplay>
+
+### Metatable-Destrukturierung
+
+Destrukturiere Metatable mit Metamethoden-Schlüssel, der von **<>** umschlossen ist.
+
+```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>
+
+## Existenz
+
+Der Operator **?** kann in verschiedenen Kontexten verwendet werden, um die Existenz zu prüfen.
+
+```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
+
+Anstelle einer Reihe verschachtelter Funktionsaufrufe kannst du Werte mit dem Operator **|>** weiterleiten.
+
+```yuescript
+"hello" |> print
+1 |> print 2 -- Pipe-Element als erstes Argument einfügen
+2 |> print 1, _, 3 -- Pipe mit Platzhalter
+
+-- Pipe-Ausdruck über mehrere Zeilen
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+<YueDisplay>
+
+```yue
+"hello" |> print
+1 |> print 2 -- Pipe-Element als erstes Argument einfügen
+2 |> print 1, _, 3 -- Pipe mit Platzhalter
+-- Pipe-Ausdruck über mehrere Zeilen
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+</YueDisplay>
+
+## Nil-Coalescing
+
+Der Nil-Coalescing-Operator **??** gibt den Wert des linken Operanden zurück, wenn er nicht **nil** ist; andernfalls wird der rechte Operand ausgewertet und sein Ergebnis zurückgegeben. Der **??**-Operator wertet seinen rechten Operanden nicht aus, wenn der linke Operand nicht nil ergibt.
+
+```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>
+
+## Implizites Objekt
+
+Du kannst innerhalb eines Tabellenblocks eine Liste impliziter Strukturen schreiben, die mit dem Symbol **\*** oder **-** beginnt. Beim Erstellen eines impliziten Objekts müssen die Felder des Objekts dieselbe Einrückung haben.
+
+```yuescript
+-- Zuweisung mit implizitem Objekt
+list =
+  * 1
+  * 2
+  * 3
+
+-- Funktionsaufruf mit implizitem Objekt
+func
+  * 1
+  * 2
+  * 3
+
+-- Rückgabe mit implizitem Objekt
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- Tabelle mit implizitem Objekt
+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
+-- Zuweisung mit implizitem Objekt
+list =
+  * 1
+  * 2
+  * 3
+
+-- Funktionsaufruf mit implizitem Objekt
+func
+  * 1
+  * 2
+  * 3
+
+-- Rückgabe mit implizitem Objekt
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- Tabelle mit implizitem Objekt
+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>
+
+# Literale
+
+Alle primitiven Literale in Lua können verwendet werden. Das gilt für Zahlen, Strings, Booleans und **nil**.
+
+Anders als in Lua sind Zeilenumbrüche innerhalb einfacher und doppelter Anführungszeichen ohne Escape-Sequenz erlaubt:
+
+```yuescript
+some_string = "Hier ist ein String
+  mit einem Zeilenumbruch."
+
+-- Mit der #{}-Syntax kannst du Ausdrücke in String-Literale einbinden.
+-- String-Interpolation gibt es nur in doppelt angeführten Strings.
+print "Ich bin mir zu #{math.random! * 100}% sicher."
+```
+
+<YueDisplay>
+
+```yue
+some_string = "Hier ist ein String
+  mit einem Zeilenumbruch."
+
+-- Mit der #{}-Syntax kannst du Ausdrücke in String-Literale einbinden.
+-- String-Interpolation gibt es nur in doppelt angeführten Strings.
+print "Ich bin mir zu #{math.random! * 100}% sicher."
+```
+
+</YueDisplay>
+
+## Zahlenliterale
+
+Du kannst Unterstriche in Zahlenliteralen verwenden, um die Lesbarkeit zu erhöhen.
+
+```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-Mehrzeilen-String
+
+Das Präfix `|` führt ein mehrzeiliges String-Literal im YAML-Stil ein:
+
+```yuescript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+<YueDisplay>
+
+```yue
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+</YueDisplay>
+
+Damit lässt sich strukturierter, mehrzeiliger Text bequem schreiben. Alle Zeilenumbrüche und Einrückungen bleiben relativ zur ersten nicht-leeren Zeile erhalten, und Ausdrücke innerhalb von `#{...}` werden automatisch als `tostring(expr)` interpoliert.
+
+Der YAML-Mehrzeilen-String erkennt automatisch das gemeinsame führende Leerraumpräfix (minimale Einrückung über alle nicht-leeren Zeilen) und entfernt es aus allen Zeilen. So kannst du deinen Code optisch einrücken, ohne den resultierenden String zu verändern.
+
+```yuescript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+<YueDisplay>
+
+```yue
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+</YueDisplay>
+
+Die interne Einrückung bleibt relativ zum entfernten gemeinsamen Präfix erhalten, wodurch saubere, verschachtelte Strukturen möglich sind.
+
+Alle Sonderzeichen wie Anführungszeichen (`"`) und Backslashes (`\`) im YAML-Mehrzeilen-Block werden automatisch escaped, sodass der erzeugte Lua-String syntaktisch korrekt ist und wie erwartet funktioniert.
+
+```yuescript
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+
+<YueDisplay>
+
+```yue
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+
+</YueDisplay>
+
+# Module
+
+## Import
+
+Die `import`-Anweisung ist syntaktischer Zucker für `require` und hilft beim Extrahieren von Einträgen aus importierten Modulen. Importierte Elemente sind standardmäßig `const`.
+
+```yuescript
+-- als Tabellen-Destrukturierung
+do
+  import insert, concat from table
+  -- Fehler beim Zuweisen zu insert, concat
+  import C, Ct, Cmt from require "lpeg"
+  -- Kurzform für implizites Require
+  import x, y, z from 'mymodule'
+  -- Import im Python-Stil
+  from 'module' import a, b, c
+
+-- Kurzform zum Laden eines Moduls
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- Modul mit Alias oder Tabellen-Destrukturierung laden
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+<YueDisplay>
+
+```yue
+-- als Tabellen-Destrukturierung
+do
+  import insert, concat from table
+  -- Fehler beim Zuweisen zu insert, concat
+  import C, Ct, Cmt from require "lpeg"
+  -- Kurzform für implizites Require
+  import x, y, z from 'mymodule'
+  -- Import im Python-Stil
+  from 'module' import a, b, c
+
+-- Kurzform zum Laden eines Moduls
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- Modul mit Alias oder Tabellen-Destrukturierung laden
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+</YueDisplay>
+
+## Import von Globals
+
+Du kannst mit `import` bestimmte Globals in lokale Variablen importieren. Wenn du eine Kette von Globalzugriffen importierst, wird das letzte Feld der lokalen Variable zugewiesen.
+
+```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>
+
+### Automatischer Global-Import
+
+Du kannst `import global` am Anfang eines Blocks platzieren, um automatisch alle Namen zu importieren, die im aktuellen Scope nicht explizit deklariert oder zugewiesen sind. Diese impliziten Importe werden als lokale `const` behandelt, die an die entsprechenden Globals zum Zeitpunkt der Anweisung gebunden sind.
+
+Namen, die im selben Scope explizit als `global` deklariert werden, werden nicht importiert, sodass du sie weiterhin zuweisen kannst.
+
+```yuescript
+do
+  import global
+  print "hallo"
+  math.random 3
+  -- print = nil -- Fehler: importierte Globals sind const
+
+do
+  -- explizite globale Variable wird nicht importiert
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+
+<YueDisplay>
+
+```yue
+do
+  import global
+  print "hallo"
+  math.random 3
+  -- print = nil -- Fehler: importierte Globals sind const
+
+do
+  -- explizite globale Variable wird nicht importiert
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+
+</YueDisplay>
+
+## Export
+
+Die `export`-Anweisung bietet eine knappe Möglichkeit, Module zu definieren.
+
+### Benannter Export
+
+Benannter Export definiert eine lokale Variable und fügt ein Feld in die exportierte Tabelle ein.
+
+```yuescript
+export a, b, c = 1, 2, 3
+export cool = "Katze"
+
+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 = "Katze"
+
+export What = if this
+  "abc"
+else
+  "def"
+
+export y = ->
+  hallo = 3434
+
+export class Something
+  umm: "cool"
+```
+
+</YueDisplay>
+
+Benannter Export mit 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>
+
+Benannte Elemente aus dem Modul exportieren, ohne lokale Variablen zu erstellen.
+
+```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>
+
+### Unbenannter Export
+
+Unbenannter Export fügt das Ziel-Element in den Array-Teil der exportierten Tabelle ein.
+
+```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
+
+Mit dem Schlüsselwort **default** in einer `export`-Anweisung wird die exportierte Tabelle durch ein beliebiges Objekt ersetzt.
+
+```yuescript
+export default ->
+  print "hallo"
+  123
+```
+
+<YueDisplay>
+
+```yue
+export default ->
+  print "hallo"
+  123
+```
+
+</YueDisplay>
+
+# Lizenz: MIT
+
+Hinweis: Die MIT-Lizenz ist unten im englischen Originaltext wiedergegeben.
+
+Urheberrecht (c) 2017-2026 Li Jin <dragon-fly@qq.com>
+
+Hiermit wird unentgeltlich jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die "Software") erhält, die Erlaubnis erteilt, uneingeschränkt mit der Software zu verfahren, einschließlich und ohne Beschränkung der Rechte, die Software zu benutzen, zu kopieren, zu verändern, zusammenzuführen, zu veröffentlichen, zu verbreiten, zu unterlizenzieren und/oder zu verkaufen, sowie Personen, denen die Software zur Verfügung gestellt wird, dies ebenfalls zu gestatten, unter den folgenden Bedingungen:
+
+Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.
+
+DIE SOFTWARE WIRD OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GARANTIE ZUR VERFÜGUNG GESTELLT, EINSCHLIESSLICH DER GARANTIEN DER MARKTGÄNGIGKEIT, DER EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND DER NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR ANSPRÜCHE, SCHÄDEN ODER SONSTIGE HAFTUNGEN VERANTWORTLICH, SEI ES AUS EINEM VERTRAG, EINER UNERLAUBTEN HANDLUNG ODER ANDERWEITIG, DIE SICH AUS DER SOFTWARE ODER DER BENUTZUNG DER SOFTWARE ODER ANDEREN GESCHÄFTEN MIT DER SOFTWARE ERGEBEN ODER DAMIT IN ZUSAMMENHANG STEHEN.
+
+# Die YueScript-Bibliothek
+
+Zugriff in Lua über `local yue = require("yue")`.
+
+## yue
+
+**Beschreibung:**
+
+Die YueScript-Sprachbibliothek.
+
+### version
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Die YueScript-Version.
+
+**Signatur:**
+
+```lua
+version: string
+```
+
+### dirsep
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Der Dateitrennzeichen-String der aktuellen Plattform.
+
+**Signatur:**
+
+```lua
+dirsep: string
+```
+
+### yue_compiled
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Der Cache für kompilierten Modulcode.
+
+**Signatur:**
+
+```lua
+yue_compiled: {string: string}
+```
+
+### to_lua
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Die YueScript-Compilerfunktion. Sie kompiliert YueScript-Code zu Lua-Code.
+
+**Signatur:**
+
+```lua
+to_lua: function(code: string, config?: Config):
+    --[[codes]] string | nil,
+    --[[error]] string | nil,
+    --[[globals]] {{string, integer, integer}} | nil
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| code      | string | Der YueScript-Code.               |
+| config    | Config | [Optional] Die Compiler-Optionen. |
+
+**Rückgabe:**
+
+| Rückgabetyp                         | Beschreibung                                                                                                              |
+| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| string \| nil                       | Der kompilierte Lua-Code oder `nil`, falls die Kompilierung fehlgeschlagen ist.                                           |
+| string \| nil                       | Die Fehlermeldung oder `nil`, falls die Kompilierung erfolgreich war.                                                     |
+| {{string, integer, integer}} \| nil | Die globalen Variablen im Code (mit Name, Zeile und Spalte) oder `nil`, wenn die Compiler-Option `lint_global` false ist. |
+
+### file_exist
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Prüft, ob eine Quelldatei existiert. Kann überschrieben werden, um das Verhalten anzupassen.
+
+**Signatur:**
+
+```lua
+file_exist: function(filename: string): boolean
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung   |
+| --------- | ------ | -------------- |
+| filename  | string | Der Dateiname. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung            |
+| ----------- | ----------------------- |
+| boolean     | Ob die Datei existiert. |
+
+### read_file
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Liest eine Quelldatei. Kann überschrieben werden, um das Verhalten anzupassen.
+
+**Signatur:**
+
+```lua
+read_file: function(filename: string): string
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung   |
+| --------- | ------ | -------------- |
+| filename  | string | Der Dateiname. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung     |
+| ----------- | ---------------- |
+| string      | Der Dateiinhalt. |
+
+### insert_loader
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Fügt den YueScript-Loader in die Package-Loader (Searcher) ein.
+
+**Signatur:**
+
+```lua
+insert_loader: function(pos?: integer): boolean
+```
+
+**Parameter:**
+
+| Parameter | Typ     | Beschreibung                                                           |
+| --------- | ------- | ---------------------------------------------------------------------- |
+| pos       | integer | [Optional] Position, an der der Loader eingefügt wird. Standard ist 3. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung                                                                         |
+| ----------- | ------------------------------------------------------------------------------------ |
+| boolean     | Ob der Loader erfolgreich eingefügt wurde. Scheitert, wenn er bereits eingefügt ist. |
+
+### remove_loader
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Entfernt den YueScript-Loader aus den Package-Loadern (Searchern).
+
+**Signatur:**
+
+```lua
+remove_loader: function(): boolean
+```
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung                                                                      |
+| ----------- | --------------------------------------------------------------------------------- |
+| boolean     | Ob der Loader erfolgreich entfernt wurde. Scheitert, wenn er nicht eingefügt ist. |
+
+### loadstring
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Lädt YueScript-Code aus einem String in eine Funktion.
+
+**Signatur:**
+
+```lua
+loadstring: function(input: string, chunkname: string, env: table, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| input     | string | Der YueScript-Code.               |
+| chunkname | string | Der Name des Code-Chunks.         |
+| env       | table  | Die Environment-Tabelle.          |
+| config    | Config | [Optional] Die Compiler-Optionen. |
+
+**Rückgabe:**
+
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
+| function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
+
+### loadstring
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Lädt YueScript-Code aus einem String in eine Funktion.
+
+**Signatur:**
+
+```lua
+loadstring: function(input: string, chunkname: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| input     | string | Der YueScript-Code.               |
+| chunkname | string | Der Name des Code-Chunks.         |
+| config    | Config | [Optional] Die Compiler-Optionen. |
+
+**Rückgabe:**
+
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
+| function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
+
+### loadstring
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Lädt YueScript-Code aus einem String in eine Funktion.
+
+**Signatur:**
+
+```lua
+loadstring: function(input: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| input     | string | Der YueScript-Code.               |
+| config    | Config | [Optional] Die Compiler-Optionen. |
+
+**Rückgabe:**
+
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
+| function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
+
+### loadfile
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Lädt YueScript-Code aus einer Datei in eine Funktion.
+
+**Signatur:**
+
+```lua
+loadfile: function(filename: string, env: table, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| filename  | string | Der Dateiname.                    |
+| env       | table  | Die Environment-Tabelle.          |
+| config    | Config | [Optional] Die Compiler-Optionen. |
+
+**Rückgabe:**
+
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
+| function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
+
+### loadfile
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Lädt YueScript-Code aus einer Datei in eine Funktion.
+
+**Signatur:**
+
+```lua
+loadfile: function(filename: string, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| filename  | string | Der Dateiname.                    |
+| config    | Config | [Optional] Die Compiler-Optionen. |
+
+**Rückgabe:**
+
+| Rückgabetyp     | Beschreibung                                                          |
+| --------------- | --------------------------------------------------------------------- |
+| function \| nil | Die geladene Funktion oder `nil`, falls das Laden fehlgeschlagen ist. |
+| string \| nil   | Die Fehlermeldung oder `nil`, falls das Laden erfolgreich war.        |
+
+### dofile
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Lädt YueScript-Code aus einer Datei in eine Funktion und führt sie aus.
+
+**Signatur:**
+
+```lua
+dofile: function(filename: string, env: table, config?: Config): any...
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| filename  | string | Der Dateiname.                    |
+| env       | table  | Die Environment-Tabelle.          |
+| config    | Config | [Optional] Die Compiler-Optionen. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung                              |
+| ----------- | ----------------------------------------- |
+| any...      | Die Rückgabewerte der geladenen Funktion. |
+
+### dofile
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Lädt YueScript-Code aus einer Datei in eine Funktion und führt sie aus.
+
+**Signatur:**
+
+```lua
+dofile: function(filename: string, config?: Config): any...
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung                      |
+| --------- | ------ | --------------------------------- |
+| filename  | string | Der Dateiname.                    |
+| config    | Config | [Optional] Die Compiler-Optionen. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung                              |
+| ----------- | ----------------------------------------- |
+| any...      | Die Rückgabewerte der geladenen Funktion. |
+
+### find_modulepath
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Löst den YueScript-Modulnamen in einen Dateipfad auf.
+
+**Signatur:**
+
+```lua
+find_modulepath: function(name: string): string
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung   |
+| --------- | ------ | -------------- |
+| name      | string | Der Modulname. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung   |
+| ----------- | -------------- |
+| string      | Der Dateipfad. |
+
+### pcall
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Ruft eine Funktion im geschützten Modus auf.
+Fängt Fehler ab und gibt einen Statuscode sowie Ergebnisse oder ein Fehlerobjekt zurück.
+Schreibt die Fehlerzeilennummer bei Fehlern auf die ursprüngliche Zeilennummer im YueScript-Code um.
+
+**Signatur:**
+
+```lua
+pcall: function(f: function, ...: any): boolean, any...
+```
+
+**Parameter:**
+
+| Parameter | Typ      | Beschreibung                |
+| --------- | -------- | --------------------------- |
+| f         | function | Die aufzurufende Funktion.  |
+| ...       | any      | Argumente für die Funktion. |
+
+**Rückgabe:**
+
+| Rückgabetyp  | Beschreibung                                         |
+| ------------ | ---------------------------------------------------- |
+| boolean, ... | Statuscode und Funktionsresultate oder Fehlerobjekt. |
+
+### require
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Lädt ein Modul (Lua oder YueScript).
+Schreibt die Fehlerzeilennummer auf die ursprüngliche Zeilennummer im YueScript-Code um, wenn das Modul ein YueScript-Modul ist und das Laden fehlschlägt.
+
+**Signatur:**
+
+```lua
+require: function(name: string): any...
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung                     |
+| --------- | ------ | -------------------------------- |
+| modname   | string | Der Name des zu ladenden Moduls. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung                                                                                                                                                                                                             |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| any         | Der Wert in `package.loaded[modname]`, falls das Modul bereits geladen ist. Andernfalls wird ein Loader gesucht und der finale Wert von `package.loaded[modname]` sowie Loader-Daten als zweites Ergebnis zurückgegeben. |
+
+### p
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Inspiziert die Struktur der übergebenen Werte und gibt String-Repräsentationen aus.
+
+**Signatur:**
+
+```lua
+p: function(...: any)
+```
+
+**Parameter:**
+
+| Parameter | Typ | Beschreibung                 |
+| --------- | --- | ---------------------------- |
+| ...       | any | Die zu inspizierenden Werte. |
+
+### options
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Die aktuellen Compiler-Optionen.
+
+**Signatur:**
+
+```lua
+options: Config.Options
+```
+
+### traceback
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Die Traceback-Funktion, die Stacktrace-Zeilennummern auf die ursprünglichen Zeilennummern im YueScript-Code umschreibt.
+
+**Signatur:**
+
+```lua
+traceback: function(message: string): string
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung             |
+| --------- | ------ | ------------------------ |
+| message   | string | Die Traceback-Nachricht. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung                            |
+| ----------- | --------------------------------------- |
+| string      | Die umgeschriebene Traceback-Nachricht. |
+
+### is_ast
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Prüft, ob der Code dem angegebenen AST entspricht.
+
+**Signatur:**
+
+```lua
+is_ast: function(astName: string, code: string): boolean
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung  |
+| --------- | ------ | ------------- |
+| astName   | string | Der AST-Name. |
+| code      | string | Der Code.     |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung                    |
+| ----------- | ------------------------------- |
+| boolean     | Ob der Code dem AST entspricht. |
+
+### AST
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Die AST-Typdefinition mit Name, Zeile, Spalte und Unterknoten.
+
+**Signatur:**
+
+```lua
+type AST = {string, integer, integer, any}
+```
+
+### to_ast
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Konvertiert Code in AST.
+
+**Signatur:**
+
+```lua
+to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
+    --[[AST]] AST | nil,
+    --[[error]] nil | string
+```
+
+**Parameter:**
+
+| Parameter      | Typ     | Beschreibung                                                                                 |
+| -------------- | ------- | -------------------------------------------------------------------------------------------- |
+| code           | string  | Der Code.                                                                                    |
+| flattenLevel   | integer | [Optional] Der Flatten-Level. Höher bedeutet mehr Flattening. Standard ist 0. Maximum ist 2. |
+| astName        | string  | [Optional] Der AST-Name. Standard ist "File".                                                |
+| reserveComment | boolean | [Optional] Ob die ursprünglichen Kommentare beibehalten werden. Standard ist false.          |
+
+**Rückgabe:**
+
+| Rückgabetyp   | Beschreibung                                                           |
+| ------------- | ---------------------------------------------------------------------- |
+| AST \| nil    | Der AST oder `nil`, falls die Konvertierung fehlgeschlagen ist.        |
+| string \| nil | Die Fehlermeldung oder `nil`, falls die Konvertierung erfolgreich war. |
+
+### format
+
+**Typ:** Funktion.
+
+**Beschreibung:**
+
+Formatiert den YueScript-Code.
+
+**Signatur:**
+
+```lua
+format: function(code: string, tabSize?: number, reserveComment?: boolean): string
+```
+
+**Parameter:**
+
+| Parameter      | Typ     | Beschreibung                                                                       |
+| -------------- | ------- | ---------------------------------------------------------------------------------- |
+| code           | string  | Der Code.                                                                          |
+| tabSize        | integer | [Optional] Die Tab-Größe. Standard ist 4.                                          |
+| reserveComment | boolean | [Optional] Ob die ursprünglichen Kommentare beibehalten werden. Standard ist true. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung          |
+| ----------- | --------------------- |
+| string      | Der formatierte Code. |
+
+### \_\_call
+
+**Typ:** Metamethod.
+
+**Beschreibung:**
+
+Required das YueScript-Modul.
+Schreibt die Fehlerzeilennummer bei Ladefehlern auf die ursprüngliche Zeilennummer im YueScript-Code um.
+
+**Signatur:**
+
+```lua
+metamethod __call: function(self: yue, module: string): any...
+```
+
+**Parameter:**
+
+| Parameter | Typ    | Beschreibung   |
+| --------- | ------ | -------------- |
+| module    | string | Der Modulname. |
+
+**Rückgabe:**
+
+| Rückgabetyp | Beschreibung   |
+| ----------- | -------------- |
+| any         | Der Modulwert. |
+
+## Config
+
+**Beschreibung:**
+
+Die Compiler-Optionen.
+
+### lint_global
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Ob der Compiler die globalen Variablen im Code sammeln soll.
+
+**Signatur:**
+
+```lua
+lint_global: boolean
+```
+
+### implicit_return_root
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Ob der Compiler für den Root-Codeblock ein implizites Return verwenden soll.
+
+**Signatur:**
+
+```lua
+implicit_return_root: boolean
+```
+
+### reserve_line_number
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Ob der Compiler die ursprüngliche Zeilennummer im kompilierten Code beibehalten soll.
+
+**Signatur:**
+
+```lua
+reserve_line_number: boolean
+```
+
+### reserve_comment
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Ob der Compiler die ursprünglichen Kommentare im kompilierten Code beibehalten soll.
+
+**Signatur:**
+
+```lua
+reserve_comment: boolean
+```
+
+### space_over_tab
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Ob der Compiler statt Tabzeichen Leerzeichen verwenden soll.
+
+**Signatur:**
+
+```lua
+space_over_tab: boolean
+```
+
+### same_module
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Ob der Compiler den zu kompilierenden Code als dasselbe aktuell kompilierte Modul behandeln soll. Nur für internen Gebrauch.
+
+**Signatur:**
+
+```lua
+same_module: boolean
+```
+
+### line_offset
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Ob die Compiler-Fehlermeldung einen Zeilennummern-Offset enthalten soll. Nur für internen Gebrauch.
+
+**Signatur:**
+
+```lua
+line_offset: integer
+```
+
+### yue.Config.LuaTarget
+
+**Typ:** Enumeration.
+
+**Beschreibung:**
+
+Die Ziel-Lua-Version.
+
+**Signatur:**
+
+```lua
+enum LuaTarget
+  "5.1"
+  "5.2"
+  "5.3"
+  "5.4"
+  "5.5"
+end
+```
+
+### options
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Zusätzliche Optionen für die Kompilierung.
+
+**Signatur:**
+
+```lua
+options: Options
+```
+
+## Options
+
+**Beschreibung:**
+
+Zusätzliche Compiler-Optionen.
+
+### target
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Die Ziel-Lua-Version für die Kompilierung.
+
+**Signatur:**
+
+```lua
+target: LuaTarget
+```
+
+### path
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Zusätzlicher Modul-Suchpfad.
+
+**Signatur:**
+
+```lua
+path: string
+```
+
+### dump_locals
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Ob lokale Variablen in Traceback-Fehlermeldungen ausgegeben werden sollen. Standard ist false.
+
+**Signatur:**
+
+```lua
+dump_locals: boolean
+```
+
+### simplified
+
+**Typ:** Feld.
+
+**Beschreibung:**
+
+Ob Fehlermeldungen vereinfacht werden sollen. Standard ist true.
+
+**Signatur:**
+
+```lua
+simplified: boolean
+```
diff --git a/doc/yue-en.md b/doc/yue-en.md
new file mode 100644
index 0000000..a16060c
--- /dev/null
+++ b/doc/yue-en.md
@@ -0,0 +1,5895 @@
+---
+title: Reference
+---
+
+# YueScript Documentation
+
+<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em; padding-bottom: 2em;"/>
+
+Welcome to the <b>YueScript</b> official documentation!<br/>
+Here you can find the language features, usage, reference examples and resources.<br/>
+Please select a chapter from the sidebar to start learning about YueScript.
+
+# 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.
+
+`do` expressions also support using `break` to interrupt control flow and return multiple values early:
+
+```yuescript
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+<YueDisplay>
+
+```yue
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+</YueDisplay>
+
+```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>
+
+# 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>
+
+# 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).
+
+# 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>
+
+# Table Literals
+
+Like in Lua, tables are delimited in curly braces.
+
+```yuescript
+some_values = [1, 2, 3, 4]
+```
+
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+```
+
+</YueDisplay>
+
+Unlike Lua, assigning a value to a key in a table is done with **:** (instead of **=**).
+
+```yuescript
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+<YueDisplay>
+
+```yue
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+</YueDisplay>
+
+The curly braces can be left off if a single table of key value pairs is being assigned.
+
+```yuescript
+profile =
+  height: "4 feet",
+  shoe_size: 13,
+  favorite_foods: ["ice cream", "donuts"]
+```
+
+<YueDisplay>
+
+```yue
+profile =
+  height: "4 feet",
+  shoe_size: 13,
+  favorite_foods: ["ice cream", "donuts"]
+```
+
+</YueDisplay>
+
+Newlines can be used to delimit values instead of a comma (or both):
+
+```yuescript
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "superman"
+  occupation: "crime fighting"
+}
+```
+
+<YueDisplay>
+
+```yue
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "superman"
+  occupation: "crime fighting"
+}
+```
+
+</YueDisplay>
+
+When creating a single line table literal, the curly braces can also be left off:
+
+```yuescript
+my_function dance: "Tango", partner: "none"
+
+y = type: "dog", legs: 4, tails: 1
+```
+
+<YueDisplay>
+
+```yue
+my_function dance: "Tango", partner: "none"
+
+y = type: "dog", legs: 4, tails: 1
+```
+
+</YueDisplay>
+
+The keys of a table literal can be language keywords without being escaped:
+
+```yuescript
+tbl = {
+  do: "something"
+  end: "hunger"
+}
+```
+
+<YueDisplay>
+
+```yue
+tbl = {
+  do: "something"
+  end: "hunger"
+}
+```
+
+</YueDisplay>
+
+If you are constructing a table out of variables and wish the keys to be the same as the variable names, then the **:** prefix operator can be used:
+
+```yuescript
+hair = "golden"
+height = 200
+person = { :hair, :height, shoe_size: 40 }
+
+print_table :hair, :height
+```
+
+<YueDisplay>
+
+```yue
+hair = "golden"
+height = 200
+person = { :hair, :height, shoe_size: 40 }
+
+print_table :hair, :height
+```
+
+</YueDisplay>
+
+If you want the key of a field in the table to to be result of an expression, then you can wrap it in **[ ]**, just like in Lua. You can also use a string literal directly as a key, leaving out the square brackets. This is useful if your key has any special characters.
+
+```yuescript
+t = {
+  [1 + 2]: "hello"
+  "hello world": true
+}
+```
+
+<YueDisplay>
+
+```yue
+t = {
+  [1 + 2]: "hello"
+  "hello world": true
+}
+```
+
+</YueDisplay>
+
+Lua tables have both an array part and a hash part, but sometimes you want to make a semantic distinction between array and hash usage when writing Lua tables. Then you can write Lua table with **[ ]** instead of **{ }** to represent an array table and writing any key value pair in a list table won't be allowed.
+
+```yuescript
+some_values = [1, 2, 3, 4]
+list_with_one_element = [1, ]
+```
+
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+list_with_one_element = [1, ]
+```
+
+</YueDisplay>
+
+# Comprehensions
+
+Comprehensions provide a convenient syntax for constructing a new table by iterating over some existing object and applying an expression to its values. There are two kinds of comprehensions: list comprehensions and table comprehensions. They both produce Lua tables; list comprehensions accumulate values into an array-like table, and table comprehensions let you set both the key and the value on each iteration.
+
+## List Comprehensions
+
+The following creates a copy of the items table but with all the values doubled.
+
+```yuescript
+items = [ 1, 2, 3, 4 ]
+doubled = [item * 2 for i, item in ipairs items]
+```
+
+<YueDisplay>
+
+```yue
+items = [ 1, 2, 3, 4 ]
+doubled = [item * 2 for i, item in ipairs items]
+```
+
+</YueDisplay>
+
+The items included in the new table can be restricted with a when clause:
+
+```yuescript
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+</YueDisplay>
+
+Because it is common to iterate over the values of a numerically indexed table, an **\*** operator is introduced. The doubled example can be rewritten as:
+
+```yuescript
+doubled = [item * 2 for item in *items]
+```
+
+<YueDisplay>
+
+```yue
+doubled = [item * 2 for item in *items]
+```
+
+</YueDisplay>
+
+In list comprehensions, you can also use the spread operator `...` to flatten nested lists, achieving a flat map effect:
+
+```yuescript
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat is now [1, 2, 3, 4, 5, 6]
+```
+
+<YueDisplay>
+
+```yue
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat is now [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+The for and when clauses can be chained as much as desired. The only requirement is that a comprehension has at least one for clause.
+
+Using multiple for clauses is the same as using nested loops:
+
+```yuescript
+x_coords = [4, 5, 6, 7]
+y_coords = [9, 2, 3]
+
+points = [ [x, y] for x in *x_coords \
+for y in *y_coords]
+```
+
+<YueDisplay>
+
+```yue
+x_coords = [4, 5, 6, 7]
+y_coords = [9, 2, 3]
+
+points = [ [x, y] for x in *x_coords \
+for y in *y_coords]
+```
+
+</YueDisplay>
+
+Numeric for loops can also be used in comprehensions:
+
+```yuescript
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+<YueDisplay>
+
+```yue
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+</YueDisplay>
+
+## Table Comprehensions
+
+The syntax for table comprehensions is very similar, only differing by using **{** and **}** and taking two values from each iteration.
+
+This example makes a copy of the tablething:
+
+```yuescript
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+<YueDisplay>
+
+```yue
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+</YueDisplay>
+
+```yuescript
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+<YueDisplay>
+
+```yue
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+</YueDisplay>
+
+The **\*** operator is also supported. Here we create a square root look up table for a few numbers.
+
+```yuescript
+numbers = [1, 2, 3, 4]
+sqrts = {i, math.sqrt i for i in *numbers}
+```
+
+<YueDisplay>
+
+```yue
+numbers = [1, 2, 3, 4]
+sqrts = {i, math.sqrt i for i in *numbers}
+```
+
+</YueDisplay>
+
+The key-value tuple in a table comprehension can also come from a single expression, in which case the expression should return two values. The first is used as the key and the second is used as the value:
+
+In this example we convert an array of pairs to a table where the first item in the pair is the key and the second is the value.
+
+```yuescript
+tuples = [ ["hello", "world"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+
+<YueDisplay>
+
+```yue
+tuples = [ ["hello", "world"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+
+</YueDisplay>
+
+## Slicing
+
+A special syntax is provided to restrict the items that are iterated over when using the **\*** operator. This is equivalent to setting the iteration bounds and a step size in a for loop.
+
+Here we can set the minimum and maximum bounds, taking all items with indexes between 1 and 5 inclusive:
+
+```yuescript
+slice = [item for item in *items[1, 5]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[1, 5]]
+```
+
+</YueDisplay>
+
+Any of the slice arguments can be left off to use a sensible default. In this example, if the max index is left off it defaults to the length of the table. This will take everything but the first element:
+
+```yuescript
+slice = [item for item in *items[2,]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[2,]]
+```
+
+</YueDisplay>
+
+If the minimum bound is left out, it defaults to 1. Here we only provide a step size and leave the other bounds blank. This takes all odd indexed items: (1, 3, 5, …)
+
+```yuescript
+slice = [item for item in *items[,,2]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[,,2]]
+```
+
+</YueDisplay>
+
+Both the minimum and maximum bounds can be negative, which means that the bounds are counted from the end of the table.
+
+```yuescript
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+```
+
+<YueDisplay>
+
+```yue
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+```
+
+</YueDisplay>
+
+The step size can also be negative, which means that the items are taken in reverse order.
+
+```yuescript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+<YueDisplay>
+
+```yue
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+</YueDisplay>
+
+### Slicing Expression
+
+Slicing can also be used as an expression. This is useful for getting a sub-list of a table.
+
+```yuescript
+-- take the 2nd and 4th items as a new list
+sub_list = items[2, 4]
+
+-- 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>
+
+# Object Oriented Programming
+
+In these examples, the generated Lua code may appear overwhelming. It is best to focus on the meaning of the YueScript code at first, then look into the Lua code if you wish to know the implementation details.
+
+A simple class:
+
+```yuescript
+class Inventory
+  new: =>
+    @items = {}
+
+  add_item: (name) =>
+    if @items[name]
+      @items[name] += 1
+    else
+      @items[name] = 1
+```
+
+<YueDisplay>
+
+```yue
+class Inventory
+  new: =>
+    @items = {}
+
+  add_item: (name) =>
+    if @items[name]
+      @items[name] += 1
+    else
+      @items[name] = 1
+```
+
+</YueDisplay>
+
+A class is declared with a class statement followed by a table-like declaration where all of the methods and properties are listed.
+
+The new property is special in that it will become the constructor.
+
+Notice how all the methods in the class use the fat arrow function syntax. When calling methods on a instance, the instance itself is sent in as the first argument. The fat arrow handles the creation of a self argument.
+
+The @ prefix on a variable name is shorthand for self.. @items becomes self.items.
+
+Creating an instance of the class is done by calling the name of the class as a function.
+
+```yuescript
+inv = Inventory!
+inv\add_item "t-shirt"
+inv\add_item "pants"
+```
+
+<YueDisplay>
+
+```yue
+inv = Inventory!
+inv\add_item "t-shirt"
+inv\add_item "pants"
+```
+
+</YueDisplay>
+
+Because the instance of the class needs to be sent to the methods when they are called, the \ operator is used.
+
+All properties of a class are shared among the instances. This is fine for functions, but for other types of objects, undesired results may occur.
+
+Consider the example below, the clothes property is shared amongst all instances, so modifications to it in one instance will show up in another:
+
+```yuescript
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- will print both pants and shirt
+print item for item in *a.clothes
+```
+
+<YueDisplay>
+
+```yue
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- will print both pants and shirt
+print item for item in *a.clothes
+```
+
+</YueDisplay>
+
+The proper way to avoid this problem is to create the mutable state of the object in the constructor:
+
+```yuescript
+class Person
+  new: =>
+    @clothes = []
+```
+
+<YueDisplay>
+
+```yue
+class Person
+  new: =>
+    @clothes = []
+```
+
+</YueDisplay>
+
+## Inheritance
+
+The extends keyword can be used in a class declaration to inherit the properties and methods from another class.
+
+```yuescript
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "backpack is full"
+    super name
+```
+
+<YueDisplay>
+
+```yue
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "backpack is full"
+    super name
+```
+
+</YueDisplay>
+
+Here we extend our Inventory class, and limit the amount of items it can carry.
+
+In this example, we don't define a constructor on the subclass, so the parent class' constructor is called when we make a new instance. If we did define a constructor then we can use the super method to call the parent constructor.
+
+Whenever a class inherits from another, it sends a message to the parent class by calling the method \_\_inherited on the parent class if it exists. The function receives two arguments, the class that is being inherited and the child class.
+
+```yuescript
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "was inherited by", child.__name
+
+-- will print: Shelf was inherited by Cupboard
+class Cupboard extends Shelf
+```
+
+<YueDisplay>
+
+```yue
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "was inherited by", child.__name
+
+-- will print: Shelf was inherited by Cupboard
+class Cupboard extends Shelf
+```
+
+</YueDisplay>
+
+## Super
+
+**super** is a special keyword that can be used in two different ways: It can be treated as an object, or it can be called like a function. It only has special functionality when inside a class.
+
+When called as a function, it will call the function of the same name in the parent class. The current self will automatically be passed as the first argument. (As seen in the inheritance example above)
+
+When super is used as a normal value, it is a reference to the parent class object.
+
+It can be accessed like any of object in order to retrieve values in the parent class that might have been shadowed by the child class.
+
+When the \ calling operator is used with super, self is inserted as the first argument instead of the value of super itself. When using . to retrieve a function, the raw function is returned.
+
+A few examples of using super in different ways:
+
+```yuescript
+class MyClass extends ParentClass
+  a_method: =>
+    -- the following have the same effect:
+    super "hello", "world"
+    super\a_method "hello", "world"
+    super.a_method self, "hello", "world"
+
+    -- super as a value is equal to the parent class:
+    assert super == ParentClass
+```
+
+<YueDisplay>
+
+```yue
+class MyClass extends ParentClass
+  a_method: =>
+    -- the following have the same effect:
+    super "hello", "world"
+    super\a_method "hello", "world"
+    super.a_method self, "hello", "world"
+
+    -- super as a value is equal to the parent class:
+    assert super == ParentClass
+```
+
+</YueDisplay>
+
+**super** can also be used on left side of a Function Stub. The only major difference is that instead of the resulting function being bound to the value of super, it is bound to self.
+
+## Types
+
+Every instance of a class carries its type with it. This is stored in the special \_\_class property. This property holds the class object. The class object is what we call to build a new instance. We can also index the class object to retrieve class methods and properties.
+
+```yuescript
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- prints 10
+```
+
+<YueDisplay>
+
+```yue
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- prints 10
+```
+
+</YueDisplay>
+
+## Class Objects
+
+The class object is what we create when we use a class statement. The class object is stored in a variable of the same name of the class.
+
+The class object can be called like a function in order to create new instances. That's how we created instances of classes in the examples above.
+
+A class is made up of two tables. The class table itself, and the base table. The base is used as the metatable for all the instances. All properties listed in the class declaration are placed in the base.
+
+The class object's metatable reads properties from the base if they don't exist in the class object. This means we can access functions and properties directly from the class.
+
+It is important to note that assigning to the class object does not assign into the base, so it's not a valid way to add new methods to instances. Instead the base must explicitly be changed. See the \_\_base field below.
+
+The class object has a couple special properties:
+
+The name of the class as when it was declared is stored as a string in the \_\_name field of the class object.
+
+```yuescript
+print BackPack.__name -- prints Backpack
+```
+
+<YueDisplay>
+
+```yue
+print BackPack.__name -- prints Backpack
+```
+
+</YueDisplay>
+
+The base object is stored in \_\_base. We can modify this table to add functionality to instances that have already been created and ones that are yet to be created.
+
+If the class extends from anything, the parent class object is stored in \_\_parent.
+
+## Class Variables
+
+We can create variables directly in the class object instead of in the base by using @ in the front of the property name in a class declaration.
+
+```yuescript
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- class variables not visible in instances
+assert Things().some_func == nil
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- class variables not visible in instances
+assert Things().some_func == nil
+```
+
+</YueDisplay>
+
+In expressions, we can use @@ to access a value that is stored in the **class of self. Thus, @@hello is shorthand for self.**class.hello.
+
+```yuescript
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- prints 2
+```
+
+<YueDisplay>
+
+```yue
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- prints 2
+```
+
+</YueDisplay>
+
+The calling semantics of @@ are similar to @. Calling a @@ name will pass the class in as the first argument using Lua's colon syntax.
+
+```yuescript
+@@hello 1,2,3,4
+```
+
+<YueDisplay>
+
+```yue
+@@hello 1,2,3,4
+```
+
+</YueDisplay>
+
+## Class Declaration Statements
+
+In the body of a class declaration, we can have normal expressions in addition to key/value pairs. In this context, self is equal to the class object.
+
+Here is an alternative way to create a class variable compared to what's described above:
+
+```yuescript
+class Things
+  @class_var = "hello world"
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @class_var = "hello world"
+```
+
+</YueDisplay>
+
+These expressions are executed after all the properties have been added to the base.
+
+All variables declared in the body of the class are local to the classes properties. This is convenient for placing private values or helper functions that only the class methods can access:
+
+```yuescript
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "hello world: " .. secret
+```
+
+<YueDisplay>
+
+```yue
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "hello world: " .. secret
+```
+
+</YueDisplay>
+
+## @ and @@ Values
+
+When @ and @@ are prefixed in front of a name they represent, respectively, that name accessed in self and self.\_\_class.
+
+If they are used all by themselves, they are aliases for self and self.\_\_class.
+
+```yuescript
+assert @ == self
+assert @@ == self.__class
+```
+
+<YueDisplay>
+
+```yue
+assert @ == self
+assert @@ == self.__class
+```
+
+</YueDisplay>
+
+For example, a quick way to create a new instance of the same class from an instance method using @@:
+
+```yuescript
+some_instance_method = (...) => @@ ...
+```
+
+<YueDisplay>
+
+```yue
+some_instance_method = (...) => @@ ...
+```
+
+</YueDisplay>
+
+## Constructor Property Promotion
+
+To reduce the boilerplate code for definition of simple value objects. You can write a simple class like:
+
+```yuescript
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- Which is short for
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+<YueDisplay>
+
+```yue
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- Which is short for
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+</YueDisplay>
+
+You can also use this syntax for a common function to initialize a object's fields.
+
+```yuescript
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+<YueDisplay>
+
+```yue
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+</YueDisplay>
+
+## Class Expressions
+
+The class syntax can also be used as an expression which can be assigned to a variable or explicitly returned.
+
+```yuescript
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+<YueDisplay>
+
+```yue
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+</YueDisplay>
+
+## Anonymous classes
+
+The name can be left out when declaring a class. The \_\_name attribute will be nil, unless the class expression is in an assignment. The name on the left hand side of the assignment is used instead of nil.
+
+```yuescript
+BigBucket = class extends Bucket
+  add_drop: => @drops += 10
+
+assert Bucket.__name == "BigBucket"
+```
+
+<YueDisplay>
+
+```yue
+BigBucket = class extends Bucket
+  add_drop: => @drops += 10
+
+assert Bucket.__name == "BigBucket"
+```
+
+</YueDisplay>
+
+You can even leave off the body, meaning you can write a blank anonymous class like this:
+
+```yuescript
+x = class
+```
+
+<YueDisplay>
+
+```yue
+x = class
+```
+
+</YueDisplay>
+
+## Class Mixing
+
+You can do mixing with keyword `using` to copy functions from either a plain table or a predefined class object into your new class. When doing mixing with a plain table, you can override the class indexing function (metamethod `__index`) to your customized implementation. When doing mixing with an existing class object, the class object's metamethods won't be copied.
+
+```yuescript
+MyIndex = __index: var: 1
+
+class X using MyIndex
+  func: =>
+    print 123
+
+x = X!
+print x.var
+
+class Y using X
+
+y = Y!
+y\func!
+
+assert y.__class.__parent ~= X -- X is not parent of Y
+```
+
+<YueDisplay>
+
+```yue
+MyIndex = __index: var: 1
+
+class X using MyIndex
+  func: =>
+    print 123
+
+x = X!
+print x.var
+
+class Y using X
+
+y = Y!
+y\func!
+
+assert y.__class.__parent ~= X -- X is not parent of Y
+```
+
+</YueDisplay>
+
+# With Statement
+
+A common pattern involving the creation of an object is calling a series of functions and setting a series of properties immediately after creating it.
+
+This results in repeating the name of the object multiple times in code, adding unnecessary noise. A common solution to this is to pass a table in as an argument which contains a collection of keys and values to overwrite. The downside to this is that the constructor of this object must support this form.
+
+The with block helps to alleviate this. Within a with block we can use a special statements that begin with either . or \ which represent those operations applied to the object we are using with on.
+
+For example, we work with a newly created object:
+
+```yuescript
+with Person!
+  .name = "Oswald"
+  \add_relative my_dad
+  \save!
+  print .name
+```
+
+<YueDisplay>
+
+```yue
+with Person!
+  .name = "Oswald"
+  \add_relative my_dad
+  \save!
+  print .name
+```
+
+</YueDisplay>
+
+The with statement can also be used as an expression which returns the value it has been giving access to.
+
+```yuescript
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+<YueDisplay>
+
+```yue
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+</YueDisplay>
+
+`with` expressions support `break` with one value:
+
+```yuescript
+result = with obj
+  break .value
+```
+
+<YueDisplay>
+
+```yue
+result = with obj
+  break .value
+```
+
+</YueDisplay>
+
+After `break value` is used inside `with`, the `with` expression no longer returns its target object. Instead, it returns the value from `break`.
+
+```yuescript
+a = with obj
+  .x = 1
+-- a is obj
+
+b = with obj
+  break .x
+-- b is .x, not obj
+```
+
+<YueDisplay>
+
+```yue
+a = with obj
+  .x = 1
+-- a is obj
+
+b = with obj
+  break .x
+-- b is .x, not obj
+```
+
+</YueDisplay>
+
+Unlike `for` / `while` / `repeat` / `do`, `with` only supports one break value.
+
+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>
+
+# 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>
+
+# 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>
+
+# 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>
+
+# 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.
+
+# 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>
+
+# 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**
+
+# 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 🌛 = "Script of Moon"
+```
+
+<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 🌛 = "Script of Moon"
+```
+
+</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.
+
+# 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).
+
+# 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>
+
+# 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 return values, allowing the loop itself to be used as an expression that exits early with meaningful results.
+
+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.
+
+For loop expressions can break with multiple values:
+
+```yuescript
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+<YueDisplay>
+
+```yue
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+</YueDisplay>
+
+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.
+
+# 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>
+
+# 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>
+
+# 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 as an expression. While and until loop expressions support `break` with multiple return values.
+
+```yuescript
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+<YueDisplay>
+
+```yue
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+</YueDisplay>
+
+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>
+
+Repeat loop expressions also support `break` with multiple return values:
+
+```yuescript
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+<YueDisplay>
+
+```yue
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+</YueDisplay>
+
+# Function Stubs
+
+It is common to pass a function from an object around as a value, for example, passing an instance method into a function as a callback. If the function expects the object it is operating on as the first argument then you must somehow bundle that object with the function so it can be called properly.
+
+The function stub syntax is a shorthand for creating a new closure function that bundles both the object and function. This new function calls the wrapped function in the correct context of the object.
+
+Its syntax is the same as calling an instance method with the \ operator but with no argument list provided.
+
+```yuescript
+my_object = {
+  value: 1000
+  write: => print "the value:", @value
+}
+
+run_callback = (func) ->
+  print "running callback..."
+  func!
+
+-- this will not work:
+-- the function has to no reference to my_object
+run_callback my_object.write
+
+-- function stub syntax
+-- lets us bundle the object into a new function
+run_callback my_object\write
+```
+
+<YueDisplay>
+
+```yue
+my_object = {
+  value: 1000
+  write: => print "the value:", @value
+}
+
+run_callback = (func) ->
+  print "running callback..."
+  func!
+
+-- this will not work:
+-- the function has to no reference to my_object
+run_callback my_object.write
+
+-- function stub syntax
+-- lets us bundle the object into a new function
+run_callback my_object\write
+```
+
+</YueDisplay>
+
+# 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>
+
+# 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>
+
+# Whitespace
+
+YueScript is a whitespace significant language. You have to write some code block in the same indent with space **' '** or tab **'\t'** like function body, value list and some control blocks. And expressions containing different whitespaces might mean different things. Tab is treated like 4 space, but it's better not mix the use of spaces and tabs.
+
+## Statement Separator
+
+A statement normally ends at a line break. You can also use a semicolon `;` to explicitly terminate a statement, which allows writing multiple statements on the same line:
+
+```yuescript
+a = 1; b = 2; print a + b
+```
+
+<YueDisplay>
+
+```yue
+a = 1; b = 2; print a + b
+```
+
+</YueDisplay>
+
+## Multiline Chaining
+
+You can write multi-line chaining function calls with a same indent.
+
+```yuescript
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x) -> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value) -> value .. '!'
+  \subscribe print
+```
+
+<YueDisplay>
+
+```yue
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x) -> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value) -> value .. '!'
+  \subscribe print
+```
+
+</YueDisplay>
+
+# Comment
+
+```yuescript
+-- I am a comment
+
+str = --[[
+This is a multi-line comment.
+It's OK.
+]] strA \ -- comment 1
+  .. strB \ -- comment 2
+  .. strC
+
+func --[[port]] 3000, --[[ip]] "192.168.1.1"
+```
+
+<YueDisplay>
+
+```yue
+-- I am a comment
+
+str = --[[
+This is a multi-line comment.
+It's OK.
+]] strA \ -- comment 1
+  .. strB \ -- comment 2
+  .. strC
+
+func --[[port]] 3000, --[[ip]] "192.168.1.1"
+```
+
+</YueDisplay>
+
+# 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>
+
+# 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>
+
+# 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>
+
+# 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>
+
+# 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.
+
+# 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/yue-id-id.md b/doc/yue-id-id.md
new file mode 100644
index 0000000..704ebe4
--- /dev/null
+++ b/doc/yue-id-id.md
@@ -0,0 +1,5890 @@
+---
+title: Referensi
+---
+
+# Dokumentasi YueScript
+
+<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em; padding-bottom: 2em;"/>
+
+Selamat datang di dokumentasi resmi <b>YueScript</b>!<br/>
+Di sini Anda dapat menemukan fitur bahasa, penggunaan, contoh referensi, dan sumber daya.<br/>
+Silakan pilih bab dari sidebar untuk mulai mempelajari YueScript.
+
+# Do
+
+Saat digunakan sebagai pernyataan, `do` bekerja seperti di Lua.
+
+```yuescript
+do
+  var = "hello"
+  print var
+print var -- nil di sini
+```
+
+<YueDisplay>
+
+```yue
+do
+  var = "hello"
+  print var
+print var -- nil di sini
+```
+
+</YueDisplay>
+
+`do` di YueScript juga bisa digunakan sebagai ekspresi, memungkinkan Anda menggabungkan beberapa baris menjadi satu. Hasil ekspresi `do` adalah pernyataan terakhir di badannya. Ekspresi `do` mendukung penggunaan `break` untuk memutus alur eksekusi dan mengembalikan banyak nilai lebih awal.
+
+```yuescript
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+<YueDisplay>
+
+```yue
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+</YueDisplay>
+
+```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>
+
+# Dekorator Baris
+
+Untuk kemudahan, loop for dan pernyataan if dapat diterapkan pada pernyataan tunggal di akhir baris:
+
+```yuescript
+print "hello world" if name == "Rob"
+```
+
+<YueDisplay>
+
+```yue
+print "hello world" if name == "Rob"
+```
+
+</YueDisplay>
+
+Dan dengan loop dasar:
+
+```yuescript
+print "item: ", item for item in *items
+```
+
+<YueDisplay>
+
+```yue
+print "item: ", item for item in *items
+```
+
+</YueDisplay>
+
+Dan dengan loop while:
+
+```yuescript
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+
+<YueDisplay>
+
+```yue
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+
+</YueDisplay>
+
+# Makro
+
+## Penggunaan Umum
+
+Fungsi macro digunakan untuk mengevaluasi string pada waktu kompilasi dan menyisipkan kode yang dihasilkan ke kompilasi akhir.
+
+```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
+
+-- ekspresi yang dikirim diperlakukan sebagai string
+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
+
+-- ekspresi yang dikirim diperlakukan sebagai string
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+
+</YueDisplay>
+
+## Menyisipkan Kode Mentah
+
+Fungsi macro bisa mengembalikan string YueScript atau tabel konfigurasi yang berisi kode Lua.
+
+```yuescript
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+funcA = -> "gagal meng-assign ke variabel yang didefinisikan oleh macro Yue"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "gagal meng-assign ke variabel yang didefinisikan oleh macro Lua"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- simbol awal dan akhir string mentah otomatis di-trim
+$lua[==[
+-- penyisipan kode Lua mentah
+if cond then
+  print("output")
+end
+]==]
+```
+
+<YueDisplay>
+
+```yue
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+funcA = -> "gagal meng-assign ke variabel yang didefinisikan oleh macro Yue"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "gagal meng-assign ke variabel yang didefinisikan oleh macro Lua"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- simbol awal dan akhir string mentah otomatis di-trim
+$lua[==[
+-- penyisipan kode Lua mentah
+if cond then
+  print("output")
+end
+]==]
+```
+
+</YueDisplay>
+
+## Export Macro
+
+Fungsi macro dapat diekspor dari modul dan diimpor di modul lain. Anda harus menaruh fungsi macro export dalam satu file agar dapat digunakan, dan hanya definisi macro, impor macro, dan ekspansi macro yang boleh ada di modul export macro.
+
+```yuescript
+-- file: utils.yue
+export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
+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 {
+  $, -- simbol untuk mengimpor semua macro
+  $foreach: $each -- ganti nama macro $foreach menjadi $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
+-- fungsi import tidak tersedia di browser, coba di lingkungan nyata
+--[[
+import "utils" as {
+  $, -- simbol untuk mengimpor semua macro
+  $foreach: $each -- ganti nama macro $foreach menjadi $each
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+]]
+```
+
+</YueDisplay>
+
+## Macro Bawaan
+
+Ada beberapa macro bawaan tetapi Anda bisa menimpanya dengan mendeklarasikan macro dengan nama yang sama.
+
+```yuescript
+print $FILE -- mendapatkan string nama modul saat ini
+print $LINE -- mendapatkan angka 2
+```
+
+<YueDisplay>
+
+```yue
+print $FILE -- mendapatkan string nama modul saat ini
+print $LINE -- mendapatkan angka 2
+```
+
+</YueDisplay>
+
+## Menghasilkan Macro dengan Macro
+
+Di YueScript, fungsi macro memungkinkan Anda menghasilkan kode pada waktu kompilasi. Dengan menumpuk fungsi macro, Anda dapat membuat pola generasi yang lebih kompleks. Fitur ini memungkinkan Anda mendefinisikan fungsi macro yang menghasilkan fungsi macro lain, sehingga menghasilkan kode yang lebih dinamis.
+
+```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>
+
+## Validasi Argumen
+
+Anda dapat mendeklarasikan tipe node AST yang diharapkan dalam daftar argumen, dan memeriksa apakah argumen macro yang masuk memenuhi harapan pada waktu kompilasi.
+
+```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>
+
+Jika Anda membutuhkan pengecekan argumen yang lebih fleksibel, Anda dapat menggunakan fungsi macro bawaan `$is_ast` untuk memeriksa secara manual pada tempat yang tepat.
+
+```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>
+
+Untuk detail lebih lanjut tentang node AST yang tersedia, silakan lihat definisi huruf besar di [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp).
+
+# Try
+
+Sintaks untuk penanganan error Lua dalam bentuk umum.
+
+```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
+
+-- bekerja dengan pola if assignment
+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
+
+-- bekerja dengan pola if assignment
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+
+</YueDisplay>
+
+## Try?
+
+`try?` adalah bentuk sederhana untuk penanganan error yang menghilangkan status boolean dari pernyataan `try`, dan akan mengembalikan hasil dari blok try ketika berhasil, atau mengembalikan nil alih-alih objek error bila gagal.
+
+```yuescript
+a, b, c = try? func!
+
+-- dengan operator nil coalescing
+a = (try? func!) ?? "default"
+
+-- sebagai argumen fungsi
+f try? func!
+
+-- dengan blok catch
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+<YueDisplay>
+
+```yue
+a, b, c = try? func!
+
+-- dengan operator nil coalescing
+a = (try? func!) ?? "default"
+
+-- sebagai argumen fungsi
+f try? func!
+
+-- dengan blok catch
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+</YueDisplay>
+
+# Literal Tabel
+
+Seperti di Lua, tabel dibatasi dengan kurung kurawal.
+
+```yuescript
+some_values = [1, 2, 3, 4]
+```
+
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+```
+
+</YueDisplay>
+
+Berbeda dengan Lua, assignment nilai ke sebuah kunci di tabel dilakukan dengan **:** (bukan **=**).
+
+```yuescript
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+<YueDisplay>
+
+```yue
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+</YueDisplay>
+
+Kurung kurawal dapat dihilangkan jika hanya satu tabel pasangan key-value yang di-assign.
+
+```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>
+
+Baris baru dapat digunakan untuk memisahkan nilai sebagai ganti koma (atau keduanya):
+
+```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>
+
+Saat membuat literal tabel satu baris, kurung kurawal juga bisa dihilangkan:
+
+```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>
+
+Kunci literal tabel dapat berupa kata kunci bahasa tanpa perlu di-escape:
+
+```yuescript
+tbl = {
+  do: "something"
+  end: "hunger"
+}
+```
+
+<YueDisplay>
+
+```yue
+tbl = {
+  do: "something"
+  end: "hunger"
+}
+```
+
+</YueDisplay>
+
+Jika Anda membangun tabel dari variabel dan ingin kunci sama dengan nama variabel, maka operator prefiks **:** dapat digunakan:
+
+```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>
+
+Jika Anda ingin kunci field dalam tabel menjadi hasil suatu ekspresi, Anda dapat membungkusnya dengan **[ ]**, seperti di Lua. Anda juga bisa menggunakan literal string langsung sebagai kunci tanpa tanda kurung siku. Ini berguna jika kunci memiliki karakter khusus.
+
+```yuescript
+t = {
+  [1 + 2]: "hello"
+  "hello world": true
+}
+```
+
+<YueDisplay>
+
+```yue
+t = {
+  [1 + 2]: "hello"
+  "hello world": true
+}
+```
+
+</YueDisplay>
+
+Tabel Lua memiliki bagian array dan bagian hash, tetapi terkadang Anda ingin membedakan penggunaan array dan hash secara semantik saat menulis tabel Lua. Maka Anda bisa menulis tabel Lua dengan **[ ]** alih-alih **{ }** untuk merepresentasikan tabel array, dan menuliskan pasangan key-value di tabel list tidak akan diizinkan.
+
+```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>
+
+# Komprehensi
+
+Komprehensi menyediakan sintaks yang nyaman untuk membangun tabel baru dengan mengiterasi objek yang ada dan menerapkan ekspresi pada nilainya. Ada dua jenis komprehensi: komprehensi list dan komprehensi tabel. Keduanya menghasilkan tabel Lua; komprehensi list mengakumulasi nilai ke tabel mirip array, dan komprehensi tabel memungkinkan Anda menetapkan kunci dan nilai pada setiap iterasi.
+
+## Komprehensi List
+
+Berikut membuat salinan tabel `items` tetapi semua nilainya digandakan.
+
+```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>
+
+Item yang disertakan dalam tabel baru bisa dibatasi dengan klausa `when`:
+
+```yuescript
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+</YueDisplay>
+
+Karena umum untuk mengiterasi nilai dari tabel berindeks numerik, operator **\*** diperkenalkan. Contoh `doubled` bisa ditulis ulang sebagai:
+
+```yuescript
+doubled = [item * 2 for item in *items]
+```
+
+<YueDisplay>
+
+```yue
+doubled = [item * 2 for item in *items]
+```
+
+</YueDisplay>
+
+Dalam komprehensi list, Anda juga bisa menggunakan operator spread `...` untuk meratakan list bertingkat, menghasilkan efek flat map:
+
+```yuescript
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat sekarang [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 sekarang [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+Klausa `for` dan `when` dapat dirantai sebanyak yang diinginkan. Satu-satunya syarat adalah komprehensi memiliki setidaknya satu klausa `for`.
+
+Menggunakan beberapa klausa `for` sama seperti menggunakan loop bertingkat:
+
+```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>
+
+Perulangan for numerik juga bisa digunakan dalam komprehensi:
+
+```yuescript
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+<YueDisplay>
+
+```yue
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+</YueDisplay>
+
+## Komprehensi Tabel
+
+Sintaks untuk komprehensi tabel sangat mirip, hanya berbeda dengan penggunaan **{** dan **}** serta mengambil dua nilai dari setiap iterasi.
+
+Contoh ini membuat salinan tabel `thing`:
+
+```yuescript
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+<YueDisplay>
+
+```yue
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+</YueDisplay>
+
+```yuescript
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+<YueDisplay>
+
+```yue
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+</YueDisplay>
+
+Operator **\*** juga didukung. Di sini kita membuat tabel lookup akar kuadrat untuk beberapa angka.
+
+```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>
+
+Tuple key-value dalam komprehensi tabel juga bisa berasal dari satu ekspresi, yang berarti ekspresi tersebut harus mengembalikan dua nilai. Nilai pertama digunakan sebagai kunci dan nilai kedua digunakan sebagai nilai:
+
+Dalam contoh ini kita mengonversi array pasangan menjadi tabel di mana item pertama dalam pasangan menjadi kunci dan item kedua menjadi nilai.
+
+```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
+
+Sintaks khusus disediakan untuk membatasi item yang diiterasi saat menggunakan operator **\***. Ini setara dengan mengatur batas iterasi dan ukuran langkah pada loop for.
+
+Di sini kita bisa menetapkan batas minimum dan maksimum, mengambil semua item dengan indeks antara 1 dan 5 (inklusif):
+
+```yuescript
+slice = [item for item in *items[1, 5]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[1, 5]]
+```
+
+</YueDisplay>
+
+Salah satu argumen slice boleh dikosongkan untuk menggunakan default yang masuk akal. Pada contoh ini, jika indeks maksimum dikosongkan, defaultnya adalah panjang tabel. Ini akan mengambil semua item kecuali elemen pertama:
+
+```yuescript
+slice = [item for item in *items[2,]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[2,]]
+```
+
+</YueDisplay>
+
+Jika batas minimum dikosongkan, defaultnya adalah 1. Di sini kita hanya memberikan ukuran langkah dan membiarkan batas lainnya kosong. Ini akan mengambil semua item berindeks ganjil: (1, 3, 5, …)
+
+```yuescript
+slice = [item for item in *items[,,2]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[,,2]]
+```
+
+</YueDisplay>
+
+Batas minimum dan maksimum bisa bernilai negatif, yang berarti batas dihitung dari akhir tabel.
+
+```yuescript
+-- ambil 4 item terakhir
+slice = [item for item in *items[-4,-1]]
+```
+
+<YueDisplay>
+
+```yue
+-- ambil 4 item terakhir
+slice = [item for item in *items[-4,-1]]
+```
+
+</YueDisplay>
+
+Ukuran langkah juga bisa negatif, yang berarti item diambil dalam urutan terbalik.
+
+```yuescript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+<YueDisplay>
+
+```yue
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+</YueDisplay>
+
+### Ekspresi Slicing
+
+Slicing juga bisa digunakan sebagai ekspresi. Ini berguna untuk mendapatkan sub-list dari sebuah tabel.
+
+```yuescript
+-- ambil item ke-2 dan ke-4 sebagai list baru
+sub_list = items[2, 4]
+
+-- ambil 4 item terakhir
+last_four_items = items[-4, -1]
+```
+
+<YueDisplay>
+
+```yue
+-- ambil item ke-2 dan ke-4 sebagai list baru
+sub_list = items[2, 4]
+
+-- ambil 4 item terakhir
+last_four_items = items[-4, -1]
+```
+
+</YueDisplay>
+
+# Pemrograman Berorientasi Objek
+
+Dalam contoh-contoh ini, kode Lua yang dihasilkan mungkin tampak berat. Sebaiknya fokus dulu pada makna kode YueScript, lalu lihat kode Lua jika Anda ingin mengetahui detail implementasinya.
+
+Kelas sederhana:
+
+```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>
+
+Kelas dideklarasikan dengan pernyataan `class` diikuti deklarasi mirip tabel di mana semua method dan properti dicantumkan.
+
+Properti `new` bersifat khusus karena akan menjadi konstruktor.
+
+Perhatikan bahwa semua method di kelas menggunakan sintaks fungsi panah tebal. Saat memanggil method pada instance, instance itu sendiri dikirim sebagai argumen pertama. Panah tebal menangani pembuatan argumen `self`.
+
+Prefiks `@` pada nama variabel adalah singkatan untuk `self.`. `@items` menjadi `self.items`.
+
+Membuat instance kelas dilakukan dengan memanggil nama kelas sebagai fungsi.
+
+```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>
+
+Karena instance kelas perlu dikirim ke method saat dipanggil, operator `\` digunakan.
+
+Semua properti kelas dibagikan di antara instance. Ini baik untuk fungsi, tetapi untuk jenis objek lain dapat menimbulkan hasil yang tidak diinginkan.
+
+Pertimbangkan contoh di bawah ini, properti `clothes` dibagikan di antara semua instance, sehingga perubahan di satu instance akan terlihat di instance lainnya:
+
+```yuescript
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- akan mencetak pants dan 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"
+
+-- akan mencetak pants dan shirt
+print item for item in *a.clothes
+```
+
+</YueDisplay>
+
+Cara yang benar untuk menghindari masalah ini adalah membuat state yang dapat berubah di konstruktor:
+
+```yuescript
+class Person
+  new: =>
+    @clothes = []
+```
+
+<YueDisplay>
+
+```yue
+class Person
+  new: =>
+    @clothes = []
+```
+
+</YueDisplay>
+
+## Pewarisan
+
+Kata kunci `extends` dapat digunakan dalam deklarasi kelas untuk mewarisi properti dan method dari kelas lain.
+
+```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>
+
+Di sini kita memperluas kelas Inventory, dan membatasi jumlah item yang bisa dibawa.
+
+Dalam contoh ini, kita tidak mendefinisikan konstruktor pada subclass, sehingga konstruktor kelas induk dipanggil ketika membuat instance baru. Jika kita mendefinisikan konstruktor, kita bisa menggunakan method `super` untuk memanggil konstruktor induk.
+
+Setiap kali sebuah kelas mewarisi dari kelas lain, ia mengirim pesan ke kelas induk dengan memanggil method `__inherited` pada kelas induk jika ada. Fungsi menerima dua argumen, kelas yang diwarisi dan kelas anak.
+
+```yuescript
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "was inherited by", child.__name
+
+-- akan mencetak: Shelf was inherited by Cupboard
+class Cupboard extends Shelf
+```
+
+<YueDisplay>
+
+```yue
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "was inherited by", child.__name
+
+-- akan mencetak: Shelf was inherited by Cupboard
+class Cupboard extends Shelf
+```
+
+</YueDisplay>
+
+## Super
+
+**super** adalah kata kunci khusus yang dapat digunakan dengan dua cara: sebagai objek, atau dipanggil seperti fungsi. Ia hanya memiliki fungsi khusus ketika berada di dalam kelas.
+
+Ketika dipanggil sebagai fungsi, ia akan memanggil fungsi dengan nama yang sama di kelas induk. `self` saat ini akan otomatis dikirim sebagai argumen pertama. (Seperti pada contoh pewarisan di atas)
+
+Ketika `super` digunakan sebagai nilai normal, ia merupakan referensi ke objek kelas induk.
+
+Ia dapat diakses seperti objek biasa untuk mengambil nilai di kelas induk yang mungkin tertutup oleh kelas anak.
+
+Ketika operator pemanggilan `\` digunakan dengan `super`, `self` disisipkan sebagai argumen pertama alih-alih nilai `super` itu sendiri. Saat menggunakan `.` untuk mengambil fungsi, fungsi mentah dikembalikan.
+
+Beberapa contoh penggunaan `super` dengan cara berbeda:
+
+```yuescript
+class MyClass extends ParentClass
+  a_method: =>
+    -- berikut memiliki efek yang sama:
+    super "hello", "world"
+    super\a_method "hello", "world"
+    super.a_method self, "hello", "world"
+
+    -- super sebagai nilai sama dengan kelas induk:
+    assert super == ParentClass
+```
+
+<YueDisplay>
+
+```yue
+class MyClass extends ParentClass
+  a_method: =>
+    -- berikut memiliki efek yang sama:
+    super "hello", "world"
+    super\a_method "hello", "world"
+    super.a_method self, "hello", "world"
+
+    -- super sebagai nilai sama dengan kelas induk:
+    assert super == ParentClass
+```
+
+</YueDisplay>
+
+**super** juga dapat digunakan di sisi kiri Function Stub. Perbedaan utamanya adalah, alih-alih fungsi hasil terikat pada nilai `super`, fungsi terikat pada `self`.
+
+## Tipe
+
+Setiap instance kelas membawa tipenya sendiri. Ini disimpan di properti khusus `__class`. Properti ini memuat objek kelas. Objek kelas adalah yang kita panggil untuk membuat instance baru. Kita juga dapat mengindeks objek kelas untuk mengambil method dan properti kelas.
+
+```yuescript
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- mencetak 10
+```
+
+<YueDisplay>
+
+```yue
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- mencetak 10
+```
+
+</YueDisplay>
+
+## Objek Kelas
+
+Objek kelas adalah yang kita buat saat menggunakan pernyataan `class`. Objek kelas disimpan dalam variabel dengan nama yang sama dengan kelas.
+
+Objek kelas dapat dipanggil seperti fungsi untuk membuat instance baru. Begitulah cara kita membuat instance kelas pada contoh di atas.
+
+Sebuah kelas terdiri dari dua tabel: tabel kelas itu sendiri dan tabel base. Base digunakan sebagai metatable untuk semua instance. Semua properti yang dicantumkan dalam deklarasi kelas ditempatkan di base.
+
+Metatable objek kelas membaca properti dari base jika tidak ada di objek kelas. Ini berarti kita dapat mengakses fungsi dan properti langsung dari kelas.
+
+Penting untuk dicatat bahwa assignment ke objek kelas tidak meng-assign ke base, sehingga itu bukan cara yang valid untuk menambahkan method baru ke instance. Sebagai gantinya, base harus diubah secara eksplisit. Lihat field `__base` di bawah.
+
+Objek kelas memiliki beberapa properti khusus:
+
+Nama kelas saat dideklarasikan disimpan sebagai string di field `__name` pada objek kelas.
+
+```yuescript
+print BackPack.__name -- mencetak Backpack
+```
+
+<YueDisplay>
+
+```yue
+print BackPack.__name -- mencetak Backpack
+```
+
+</YueDisplay>
+
+Objek base disimpan di `__base`. Kita dapat memodifikasi tabel ini untuk menambahkan fungsionalitas ke instance yang sudah dibuat maupun yang akan dibuat.
+
+Jika kelas memperluas kelas lain, objek kelas induk disimpan di `__parent`.
+
+## Variabel Kelas
+
+Kita dapat membuat variabel langsung di objek kelas alih-alih di base dengan menggunakan `@` di depan nama properti pada deklarasi kelas.
+
+```yuescript
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- variabel kelas tidak terlihat pada instance
+assert Things().some_func == nil
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- variabel kelas tidak terlihat pada instance
+assert Things().some_func == nil
+```
+
+</YueDisplay>
+
+Dalam ekspresi, kita dapat menggunakan `@@` untuk mengakses nilai yang disimpan di `__class` milik `self`. Jadi, `@@hello` adalah singkatan dari `self.__class.hello`.
+
+```yuescript
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- mencetak 2
+```
+
+<YueDisplay>
+
+```yue
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- mencetak 2
+```
+
+</YueDisplay>
+
+Semantik pemanggilan `@@` mirip dengan `@`. Memanggil nama `@@` akan meneruskan kelas sebagai argumen pertama menggunakan sintaks kolon Lua.
+
+```yuescript
+@@hello 1,2,3,4
+```
+
+<YueDisplay>
+
+```yue
+@@hello 1,2,3,4
+```
+
+</YueDisplay>
+
+## Pernyataan Deklarasi Kelas
+
+Di dalam badan deklarasi kelas, kita bisa memiliki ekspresi normal selain pasangan key/value. Dalam konteks ini, `self` sama dengan objek kelas.
+
+Berikut cara alternatif untuk membuat variabel kelas dibandingkan yang dijelaskan di atas:
+
+```yuescript
+class Things
+  @class_var = "hello world"
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @class_var = "hello world"
+```
+
+</YueDisplay>
+
+Ekspresi ini dieksekusi setelah semua properti ditambahkan ke base.
+
+Semua variabel yang dideklarasikan di badan kelas bersifat lokal terhadap properti kelas. Ini berguna untuk menempatkan nilai privat atau fungsi pembantu yang hanya dapat diakses oleh method kelas:
+
+```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>
+
+## Nilai @ dan @@
+
+Ketika `@` dan `@@` diprefiks di depan sebuah nama, masing-masing merepresentasikan nama tersebut yang diakses di `self` dan `self.__class`.
+
+Jika digunakan sendirian, keduanya adalah alias untuk `self` dan `self.__class`.
+
+```yuescript
+assert @ == self
+assert @@ == self.__class
+```
+
+<YueDisplay>
+
+```yue
+assert @ == self
+assert @@ == self.__class
+```
+
+</YueDisplay>
+
+Contohnya, cara cepat untuk membuat instance baru dari kelas yang sama dari method instance menggunakan `@@`:
+
+```yuescript
+some_instance_method = (...) => @@ ...
+```
+
+<YueDisplay>
+
+```yue
+some_instance_method = (...) => @@ ...
+```
+
+</YueDisplay>
+
+## Promosi Properti Konstruktor
+
+Untuk mengurangi boilerplate saat mendefinisikan objek nilai sederhana, Anda dapat menulis kelas sederhana seperti:
+
+```yuescript
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- Yang merupakan singkatan dari
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+<YueDisplay>
+
+```yue
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- Yang merupakan singkatan dari
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+</YueDisplay>
+
+Anda juga bisa menggunakan sintaks ini untuk fungsi umum guna menginisialisasi field objek.
+
+```yuescript
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+<YueDisplay>
+
+```yue
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+</YueDisplay>
+
+## Ekspresi Kelas
+
+Sintaks kelas juga bisa digunakan sebagai ekspresi yang dapat di-assign ke variabel atau di-return secara eksplisit.
+
+```yuescript
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+<YueDisplay>
+
+```yue
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+</YueDisplay>
+
+## Kelas Anonim
+
+Nama bisa dihilangkan saat mendeklarasikan kelas. Atribut `__name` akan bernilai nil, kecuali ekspresi kelas berada dalam assignment. Nama di sisi kiri assignment digunakan sebagai ganti 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>
+
+Anda bahkan bisa menghilangkan badan kelas, artinya Anda bisa menulis kelas anonim kosong seperti ini:
+
+```yuescript
+x = class
+```
+
+<YueDisplay>
+
+```yue
+x = class
+```
+
+</YueDisplay>
+
+## Pencampuran Kelas
+
+Anda bisa melakukan mixing dengan kata kunci `using` untuk menyalin fungsi dari tabel biasa atau objek kelas yang sudah didefinisikan ke kelas baru Anda. Saat mixing dengan tabel biasa, Anda dapat mengganti fungsi pengindeksan kelas (metamethod `__index`) dengan implementasi kustom. Saat mixing dengan objek kelas yang sudah ada, metamethod objek kelas tidak akan disalin.
+
+```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 bukan parent dari 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 bukan parent dari Y
+```
+
+</YueDisplay>
+
+# Pernyataan With
+
+Pola umum saat membuat objek adalah memanggil serangkaian fungsi dan mengatur serangkaian properti segera setelah objek dibuat.
+
+Hal ini menyebabkan nama objek diulang berkali-kali di kode, menambah noise yang tidak perlu. Solusi umum untuk ini adalah meneruskan tabel sebagai argumen yang berisi kumpulan kunci dan nilai untuk ditimpa. Kekurangannya adalah konstruktor objek harus mendukung bentuk ini.
+
+Blok `with` membantu mengatasi hal ini. Di dalam blok `with`, kita bisa menggunakan pernyataan khusus yang diawali dengan `.` atau `\` yang merepresentasikan operasi tersebut diterapkan pada objek yang sedang dipakai.
+
+Sebagai contoh, kita bekerja dengan objek yang baru dibuat:
+
+```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>
+
+Pernyataan `with` juga bisa digunakan sebagai ekspresi yang mengembalikan nilai yang diberi akses.
+
+```yuescript
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+<YueDisplay>
+
+```yue
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+</YueDisplay>
+
+Ekspresi `with` mendukung `break` dengan satu nilai:
+
+```yuescript
+result = with obj
+  break .value
+```
+
+<YueDisplay>
+
+```yue
+result = with obj
+  break .value
+```
+
+</YueDisplay>
+
+Setelah `break value` digunakan di dalam `with`, ekspresi `with` tidak lagi mengembalikan objek targetnya, melainkan mengembalikan nilai dari `break`.
+
+```yuescript
+a = with obj
+  .x = 1
+-- a adalah obj
+
+b = with obj
+  break .x
+-- b adalah .x, bukan obj
+```
+
+<YueDisplay>
+
+```yue
+a = with obj
+  .x = 1
+-- a adalah obj
+
+b = with obj
+  break .x
+-- b adalah .x, bukan obj
+```
+
+</YueDisplay>
+
+Berbeda dari `for` / `while` / `repeat` / `do`, `with` hanya mendukung satu nilai `break`.
+
+Atau…
+
+```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>
+
+Dalam penggunaan ini, `with` dapat dilihat sebagai bentuk khusus dari kombinator K.
+
+Ekspresi pada pernyataan `with` juga bisa berupa assignment jika Anda ingin memberi nama pada ekspresi tersebut.
+
+```yuescript
+with str := "Hello"
+  print "original:", str
+  print "upper:", \upper!
+```
+
+<YueDisplay>
+
+```yue
+with str := "Hello"
+  print "original:", str
+  print "upper:", \upper!
+```
+
+</YueDisplay>
+
+Anda bisa mengakses kunci khusus dengan `[]` di dalam pernyataan `with`.
+
+```yuescript
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- menambahkan ke "tb"
+```
+
+<YueDisplay>
+
+```yue
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- menambahkan ke "tb"
+```
+
+</YueDisplay>
+
+`with?` adalah versi yang ditingkatkan dari sintaks `with`, yang memperkenalkan pengecekan keberadaan untuk mengakses objek yang mungkin nil secara aman tanpa pemeriksaan null eksplisit.
+
+```yuescript
+with? obj
+  print obj.name
+```
+
+<YueDisplay>
+
+```yue
+with? obj
+  print obj.name
+```
+
+</YueDisplay>
+
+# Penugasan
+
+Variabel bersifat bertipe dinamis dan secara default dideklarasikan sebagai local. Namun Anda dapat mengubah cakupan deklarasi dengan pernyataan **local** dan **global**.
+
+```yuescript
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- menggunakan variabel yang sudah ada
+```
+
+<YueDisplay>
+
+```yue
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- menggunakan variabel yang sudah ada
+```
+
+</YueDisplay>
+
+## Pembaruan Nilai
+
+Anda dapat melakukan assignment pembaruan dengan banyak operator biner.
+
+```yuescript
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- akan menambah local baru jika variabel local belum ada
+arg or= "default value"
+```
+
+<YueDisplay>
+
+```yue
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- akan menambah local baru jika variabel local belum ada
+arg or= "default value"
+```
+
+</YueDisplay>
+
+## Assignment Berantai
+
+Anda bisa melakukan assignment berantai untuk menetapkan beberapa item ke nilai yang sama.
+
+```yuescript
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+<YueDisplay>
+
+```yue
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+</YueDisplay>
+
+## Local Eksplisit
+
+```yuescript
+do
+  local a = 1
+  local *
+  print "deklarasikan semua variabel sebagai local di awal"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "hanya deklarasikan variabel huruf besar sebagai local di awal"
+  a = 1
+  B = 2
+```
+
+<YueDisplay>
+
+```yue
+do
+  local a = 1
+  local *
+  print "deklarasikan semua variabel sebagai local di awal"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "hanya deklarasikan variabel huruf besar sebagai local di awal"
+  a = 1
+  B = 2
+```
+
+</YueDisplay>
+
+## Global Eksplisit
+
+```yuescript
+do
+  global a = 1
+  global *
+  print "deklarasikan semua variabel sebagai global"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global X = 1
+  global ^
+  print "hanya deklarasikan variabel huruf besar sebagai global"
+  a = 1
+  B = 2
+  local Temp = "a local value"
+```
+
+<YueDisplay>
+
+```yue
+do
+  global a = 1
+  global *
+  print "deklarasikan semua variabel sebagai global"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global X = 1
+  global ^
+  print "hanya deklarasikan variabel huruf besar sebagai global"
+  a = 1
+  B = 2
+  local Temp = "a local value"
+```
+
+</YueDisplay>
+
+# Penugasan Varargs
+
+Anda dapat meng-assign hasil yang dikembalikan dari sebuah fungsi ke simbol varargs `...`. Lalu akses isinya menggunakan cara Lua.
+
+```yuescript
+list = [1, 2, 3, 4, 5]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+
+<YueDisplay>
+
+```yue
+list = [1, 2, 3, 4, 5]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+
+</YueDisplay>
+
+# Penugasan pada If
+
+Blok `if` dan `elseif` dapat menerima assignment sebagai ganti ekspresi kondisional. Saat kondisi dievaluasi, assignment akan dilakukan dan nilai yang di-assign akan digunakan sebagai ekspresi kondisional. Variabel yang di-assign hanya berada dalam scope badan kondisional, artinya tidak pernah tersedia jika nilai tidak truthy. Dan Anda harus menggunakan "walrus operator" `:=` sebagai ganti `=` untuk melakukan 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>
+
+Assignment if dengan beberapa nilai return. Hanya nilai pertama yang dicek, nilai lainnya tetap berada dalam scope.
+
+```yuescript
+if success, result := pcall -> "get result without problems"
+  print result -- variabel result berada dalam scope
+print "OK"
+```
+
+<YueDisplay>
+
+```yue
+if success, result := pcall -> "get result without problems"
+  print result -- variabel result berada dalam scope
+print "OK"
+```
+
+</YueDisplay>
+
+## Assignment pada While
+
+Anda juga bisa menggunakan assignment if di loop while untuk mendapatkan nilai sebagai kondisi loop.
+
+```yuescript
+while byte := stream\read_one!
+  -- lakukan sesuatu dengan byte
+  print byte
+```
+
+<YueDisplay>
+
+```yue
+while byte := stream\read_one!
+  -- lakukan sesuatu dengan byte
+  print byte
+```
+
+</YueDisplay>
+
+# Penugasan Destrukturisasi
+
+Assignment destrukturisasi adalah cara cepat untuk mengekstrak nilai dari sebuah tabel berdasarkan nama kunci atau posisinya pada tabel berbasis array.
+
+Biasanya ketika Anda melihat literal tabel, `{1,2,3}`, ia berada di sisi kanan assignment karena merupakan nilai. Assignment destrukturisasi menukar peran literal tabel dan menaruhnya di sisi kiri pernyataan assignment.
+
+Ini paling mudah dijelaskan dengan contoh. Berikut cara membongkar dua nilai pertama dari sebuah tabel:
+
+```yuescript
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+<YueDisplay>
+
+```yue
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+</YueDisplay>
+
+Di literal tabel destrukturisasi, kunci mewakili kunci yang dibaca dari sisi kanan, dan nilai mewakili nama yang akan menerima nilai tersebut.
+
+```yuescript
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- OK untuk destrukturisasi sederhana tanpa kurung
+```
+
+<YueDisplay>
+
+```yue
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- OK untuk destrukturisasi sederhana tanpa kurung
+```
+
+</YueDisplay>
+
+Ini juga bekerja pada struktur data bertingkat:
+
+```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>
+
+Jika pernyataan destrukturisasi kompleks, Anda bisa memecahnya ke beberapa baris. Contoh yang sedikit lebih rumit:
+
+```yuescript
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+<YueDisplay>
+
+```yue
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+</YueDisplay>
+
+Umumnya mengekstrak nilai dari tabel lalu menugaskannya ke variabel local dengan nama yang sama dengan kuncinya. Untuk menghindari pengulangan, kita bisa menggunakan operator prefiks **:**:
+
+```yuescript
+{:concat, :insert} = table
+```
+
+<YueDisplay>
+
+```yue
+{:concat, :insert} = table
+```
+
+</YueDisplay>
+
+Ini secara efektif sama seperti import, tetapi kita dapat mengganti nama field yang ingin diekstrak dengan menggabungkan sintaks:
+
+```yuescript
+{:mix, :max, random: rand} = math
+```
+
+<YueDisplay>
+
+```yue
+{:mix, :max, random: rand} = math
+```
+
+</YueDisplay>
+
+Anda bisa menulis nilai default saat destrukturisasi seperti:
+
+```yuescript
+{:name = "nameless", :job = "jobless"} = person
+```
+
+<YueDisplay>
+
+```yue
+{:name = "nameless", :job = "jobless"} = person
+```
+
+</YueDisplay>
+
+Anda dapat menggunakan `_` sebagai placeholder saat destrukturisasi list:
+
+```yuescript
+[_, two, _, four] = items
+```
+
+<YueDisplay>
+
+```yue
+[_, two, _, four] = items
+```
+
+</YueDisplay>
+
+## Destrukturisasi Rentang
+
+Anda dapat menggunakan operator spread `...` pada destrukturisasi list untuk menangkap rentang nilai. Ini berguna ketika Anda ingin mengekstrak elemen tertentu dari awal dan akhir list sambil mengumpulkan sisanya di tengah.
+
+```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>
+
+Operator spread dapat digunakan pada posisi berbeda untuk menangkap rentang yang berbeda, dan Anda bisa memakai `_` sebagai placeholder untuk nilai yang tidak ingin ditangkap:
+
+```yuescript
+-- Tangkap semuanya setelah elemen pertama
+[first, ...rest] = orders
+
+-- Tangkap semuanya sebelum elemen terakhir
+[...start, last] = orders
+
+-- Tangkap semuanya kecuali elemen tengah
+[first, ..._, last] = orders
+```
+
+<YueDisplay>
+
+```yue
+-- Tangkap semuanya setelah elemen pertama
+[first, ...rest] = orders
+
+-- Tangkap semuanya sebelum elemen terakhir
+[...start, last] = orders
+
+-- Tangkap semuanya kecuali elemen tengah
+[first, ..._, last] = orders
+```
+
+</YueDisplay>
+
+## Destrukturisasi di Tempat Lain
+
+Destrukturisasi juga dapat muncul di tempat-tempat di mana assignment terjadi secara implisit. Contohnya adalah perulangan for:
+
+```yuescript
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+<YueDisplay>
+
+```yue
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+</YueDisplay>
+
+Kita tahu setiap elemen pada tabel array adalah tuple dua item, sehingga kita dapat membongkarnya langsung di klausa nama pada pernyataan for menggunakan destrukturisasi.
+
+# Klausa Using; Mengendalikan Penugasan Destruktif
+
+Meskipun scope leksikal sangat membantu mengurangi kompleksitas kode yang kita tulis, hal ini bisa menjadi sulit ketika ukuran kode membesar. Pertimbangkan cuplikan berikut:
+
+```yuescript
+i = 100
+
+-- banyak baris kode...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- akan mencetak 0
+```
+
+<YueDisplay>
+
+```yue
+i = 100
+
+-- banyak baris kode...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- akan mencetak 0
+```
+
+</YueDisplay>
+
+Di `my_func`, kita tanpa sengaja menimpa nilai `i`. Dalam contoh ini halnya cukup jelas, tetapi bayangkan kode besar atau basis kode asing di mana tidak jelas nama apa saja yang sudah dideklarasikan.
+
+Akan sangat membantu jika kita dapat menyatakan variabel mana dari scope luar yang memang ingin kita ubah, agar mencegah mengubah yang lain secara tidak sengaja.
+
+Kata kunci `using` memungkinkan kita melakukan itu. `using nil` memastikan bahwa tidak ada variabel tertutup yang ditimpa dalam assignment. Klausa `using` ditempatkan setelah daftar argumen pada fungsi, atau menggantikannya jika tidak ada argumen.
+
+```yuescript
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- variabel local baru dibuat di sini
+
+my_func!
+print i -- mencetak 100, i tidak terpengaruh
+```
+
+<YueDisplay>
+
+```yue
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- variabel local baru dibuat di sini
+
+my_func!
+print i -- mencetak 100, i tidak terpengaruh
+```
+
+</YueDisplay>
+
+Beberapa nama dapat dipisahkan dengan koma. Nilai closure tetap bisa diakses, hanya saja tidak dapat dimodifikasi:
+
+```yuescript
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- tmp local baru dibuat
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- ini telah diperbarui
+```
+
+<YueDisplay>
+
+```yue
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- tmp local baru dibuat
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- ini telah diperbarui
+```
+
+</YueDisplay>
+
+# Penggunaan
+
+## Modul Lua
+
+Gunakan modul YueScript di Lua:
+
+- **Kasus 1**
+
+  Require "your_yuescript_entry.yue" di Lua.
+
+  ```Lua
+  require("yue")("your_yuescript_entry")
+  ```
+
+  Dan kode ini tetap bekerja ketika Anda mengompilasi "your_yuescript_entry.yue" menjadi "your_yuescript_entry.lua" di path yang sama. Pada file YueScript lainnya cukup gunakan **require** atau **import** biasa. Nomor baris pada pesan error juga akan ditangani dengan benar.
+
+- **Kasus 2**
+
+  Require modul YueScript dan tulis ulang pesan secara manual.
+
+  ```lua
+  local yue = require("yue")
+  yue.insert_loader()
+  local success, result = xpcall(function()
+    return require("yuescript_module_name")
+  end, function(err)
+    return yue.traceback(err)
+  end)
+  ```
+
+- **Kasus 3**
+
+  Gunakan fungsi kompiler YueScript di Lua.
+
+  ```lua
+  local yue = require("yue")
+  local codes, err, globals = yue.to_lua([[
+    f = ->
+      print "hello world"
+    f!
+  ]],{
+    implicit_return_root = true,
+    reserve_line_number = true,
+    lint_global = true,
+    space_over_tab = false,
+    options = {
+      target = "5.4",
+      path = "/script"
+    }
+  })
+  ```
+
+## Tool YueScript
+
+Gunakan tool YueScript dengan:
+
+```shell
+> yue -h
+Penggunaan: yue
+           [opsi] [<file/direktori>] ...
+           yue -e <kode_atau_file> [argumen...]
+           yue -w [<direktori>] [opsi]
+           yue -
+
+Catatan:
+   - '-' / '--' harus menjadi argumen pertama dan satu-satunya.
+   - '-o/--output' tidak dapat digunakan dengan beberapa file input.
+   - '-w/--watch' tidak dapat digunakan dengan file input (khusus direktori).
+   - dengan '-e/--execute', token sisanya dianggap sebagai argumen skrip.
+
+Opsi:
+   -h, --help                 Tampilkan pesan bantuan ini dan keluar.
+   -e <str>, --execute <str>  Eksekusi file atau kode mentah
+   -m, --minify               Menghasilkan kode yang sudah diminimasi
+   -r, --rewrite              Tulis ulang output agar sesuai dengan nomor baris asal
+   -t <output_to>, --output-to <output_to>
+                              Tentukan lokasi untuk menaruh file hasil kompilasi
+   -o <file>, --output <file> Tulis output ke file
+   -p, --print                Tulis output ke standar output
+   -b, --benchmark            Tampilkan waktu kompilasi (tanpa menulis output)
+   -g, --globals              Tampilkan variabel global yang digunakan dalam FORMAT NAMA BARIS KOLOM
+   -s, --spaces               Pakai spasi di kode hasil kompilasi (bukan tab)
+   -l, --line-numbers         Tulis nomor baris dari kode sumber
+   -j, --no-implicit-return   Nonaktifkan return implisit di akhir file
+   -c, --reserve-comments     Pertahankan komentar sebelum pernyataan dari kode sumber
+   -w [<dir>], --watch [<dir>]
+                              Pantau perubahan dan kompilasi setiap file di bawah direktori
+   -v, --version              Tampilkan versi
+   -                          Baca dari standar input, tulis ke standar output
+                              (harus menjadi argumen pertama dan satu-satunya)
+   --                         Sama dengan '-', dipertahankan untuk kompatibilitas lama
+
+   --target <versi>           Tentukan versi Lua yang akan dihasilkan kodenya
+                              (versi hanya bisa dari 5.1 sampai 5.5)
+   --path <path_str>          Tambahkan path pencarian Lua tambahan ke package.path
+   --<key>=<value>            Kirim opsi kompilasi dalam bentuk key=value (perilaku standar)
+
+   Jalankan tanpa opsi untuk masuk ke REPL, ketik simbol '$'
+   dalam satu baris untuk memulai/mengakhiri mode multi-baris
+```
+
+Gunakan kasus:
+
+Kompilasi semua file YueScript dengan ekstensi **.yue** secara rekursif di bawah path saat ini: **yue .**
+
+Kompilasi dan simpan hasil ke path target: **yue -t /target/path/ .**
+
+Kompilasi dan pertahankan info debug: **yue -l .**
+
+Kompilasi dan hasilkan kode yang diminisasi: **yue -m .**
+
+Eksekusi kode mentah: **yue -e 'print 123'**
+
+Eksekusi file YueScript: **yue -e main.yue**
+
+# Pendahuluan
+
+YueScript adalah bahasa dinamis yang dikompilasi ke Lua, dan merupakan dialek [MoonScript](https://github.com/leafo/moonscript). Kode yang ditulis dengan YueScript ekspresif dan sangat ringkas. YueScript cocok untuk menulis logika aplikasi yang sering berubah dengan kode yang lebih mudah dipelihara, serta berjalan di lingkungan embed Lua seperti game atau server situs web.
+
+Yue (月) adalah kata untuk bulan dalam bahasa Tionghoa dan diucapkan sebagai [jyɛ].
+
+## Ikhtisar 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 🌛 = "Skrip Bulan"
+```
+
+<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 🌛 = "Skrip Bulan"
+```
+
+</YueDisplay>
+
+## Tentang Dora SSR
+
+YueScript dikembangkan dan dipelihara bersama mesin game open-source [Dora SSR](https://github.com/Dora-SSR/Dora-SSR). YueScript telah digunakan untuk membuat alat mesin, demo game, dan prototipe, membuktikan kemampuannya dalam skenario dunia nyata sekaligus meningkatkan pengalaman pengembangan Dora SSR.
+
+# Instalasi
+
+## Modul Lua
+
+Instal [luarocks](https://luarocks.org), manajer paket untuk modul Lua. Lalu instal sebagai modul Lua dan executable dengan:
+
+```shell
+luarocks install yuescript
+```
+
+Atau Anda dapat membangun file `yue.so` dengan:
+
+```shell
+make shared LUAI=/usr/local/include/lua LUAL=/usr/local/lib/lua
+```
+
+Lalu ambil file biner dari path **bin/shared/yue.so**.
+
+## Membangun Tool Biner
+
+Klon repo ini, lalu bangun dan instal executable dengan:
+
+```shell
+make install
+```
+
+Bangun tool YueScript tanpa fitur macro:
+
+```shell
+make install NO_MACRO=true
+```
+
+Bangun tool YueScript tanpa biner Lua bawaan:
+
+```shell
+make install NO_LUA=true
+```
+
+## Unduh Biner Pra-kompilasi
+
+Anda dapat mengunduh file biner pra-kompilasi, termasuk file executable biner yang kompatibel dengan berbagai versi Lua dan file library.
+
+Unduh file biner pra-kompilasi dari [sini](https://github.com/IppClub/YueScript/releases).
+
+# Kondisional
+
+```yuescript
+have_coins = false
+if have_coins
+  print "Dapat koin"
+else
+  print "Tidak ada koin"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins
+  print "Dapat koin"
+else
+  print "Tidak ada koin"
+```
+
+</YueDisplay>
+
+Sintaks pendek untuk pernyataan tunggal juga bisa digunakan:
+
+```yuescript
+have_coins = false
+if have_coins then print "Dapat koin" else print "Tidak ada koin"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins then print "Dapat koin" else print "Tidak ada koin"
+```
+
+</YueDisplay>
+
+Karena pernyataan if dapat digunakan sebagai ekspresi, ini juga bisa ditulis sebagai:
+
+```yuescript
+have_coins = false
+print if have_coins then "Dapat koin" else "Tidak ada koin"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+print if have_coins then "Dapat koin" else "Tidak ada koin"
+```
+
+</YueDisplay>
+
+Kondisional juga bisa digunakan di pernyataan return dan assignment:
+
+```yuescript
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "Saya sangat tinggi"
+else
+  "Saya tidak terlalu tinggi"
+
+print message -- prints: Saya sangat tinggi
+```
+
+<YueDisplay>
+
+```yue
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "Saya sangat tinggi"
+else
+  "Saya tidak terlalu tinggi"
+
+print message -- prints: Saya sangat tinggi
+```
+
+</YueDisplay>
+
+Kebalikan dari if adalah unless:
+
+```yuescript
+unless os.date("%A") == "Monday"
+  print "hari ini bukan Senin!"
+```
+
+<YueDisplay>
+
+```yue
+unless os.date("%A") == "Monday"
+  print "hari ini bukan Senin!"
+```
+
+</YueDisplay>
+
+```yuescript
+print "Kamu beruntung!" unless math.random! > 0.1
+```
+
+<YueDisplay>
+
+```yue
+print "Kamu beruntung!" unless math.random! > 0.1
+```
+
+</YueDisplay>
+
+## Ekspresi In
+
+Anda dapat menulis kode pengecekan rentang dengan `ekspresi in`.
+
+```yuescript
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "memeriksa kesamaan dengan nilai-nilai diskrit"
+
+if a in list
+  print "memeriksa apakah `a` ada di dalam daftar"
+```
+
+<YueDisplay>
+
+```yue
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "memeriksa kesamaan dengan nilai-nilai diskrit"
+
+if a in list
+  print "memeriksa apakah `a` ada di dalam daftar"
+```
+
+</YueDisplay>
+
+# Perulangan For
+
+Ada dua bentuk perulangan for, seperti di Lua. Satu numerik dan satu generik:
+
+```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>
+
+Operator slicing dan **\*** dapat digunakan, seperti pada comprehension:
+
+```yuescript
+for item in *items[2, 4]
+  print item
+```
+
+<YueDisplay>
+
+```yue
+for item in *items[2, 4]
+  print item
+```
+
+</YueDisplay>
+
+Sintaks yang lebih singkat juga tersedia untuk semua variasi ketika badan hanya satu baris:
+
+```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>
+
+Perulangan for juga bisa digunakan sebagai ekspresi. Pernyataan terakhir di badan for dipaksa menjadi ekspresi dan ditambahkan ke tabel array yang terakumulasi.
+
+Menggandakan setiap bilangan genap:
+
+```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>
+
+Selain itu, loop for mendukung break dengan nilai kembalian, sehingga loop itu sendiri bisa dipakai sebagai ekspresi yang keluar lebih awal dengan hasil bermakna. Ekspresi `for` mendukung `break` dengan banyak nilai.
+
+Contohnya, untuk menemukan angka pertama yang lebih besar dari 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>
+
+Sintaks break-dengan-nilai ini memungkinkan pola pencarian atau keluar-lebih-awal yang ringkas langsung di dalam ekspresi loop.
+
+```yuescript
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+<YueDisplay>
+
+```yue
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+</YueDisplay>
+
+Anda juga bisa memfilter nilai dengan menggabungkan ekspresi for dengan pernyataan continue.
+
+Loop for di akhir badan fungsi tidak diakumulasikan menjadi tabel untuk nilai kembalian (sebaliknya fungsi akan mengembalikan nil). Gunakan pernyataan return eksplisit, atau ubah loop menjadi 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>
+
+# Pernyataan Continue
+
+Pernyataan continue dapat digunakan untuk melewati iterasi saat ini di dalam 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 juga bisa digunakan bersama ekspresi loop untuk mencegah iterasi tersebut diakumulasikan ke hasil. Contoh ini memfilter tabel array menjadi hanya angka genap:
+
+```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>
+
+# Pernyataan Switch
+
+Pernyataan switch adalah bentuk singkat untuk menulis serangkaian if yang membandingkan nilai yang sama. Perhatikan bahwa nilainya hanya dievaluasi sekali. Seperti if, switch bisa memiliki blok else untuk menangani tidak ada yang cocok. Perbandingan dilakukan dengan operator `==`. Di dalam switch, Anda juga bisa memakai ekspresi assignment untuk menyimpan nilai variabel sementara.
+
+```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>
+
+Klausa when pada switch bisa mencocokkan beberapa nilai dengan menuliskannya dipisah koma.
+
+Switch juga bisa dipakai sebagai ekspresi; di sini kita dapat menetapkan hasil switch ke sebuah variabel:
+
+```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>
+
+Kita bisa memakai kata kunci `then` untuk menulis blok when switch pada satu baris. Tidak ada kata kunci tambahan yang dibutuhkan untuk menulis blok else pada satu baris.
+
+```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>
+
+Jika Anda ingin menulis kode dengan satu indentasi lebih sedikit saat menulis switch, Anda bisa menaruh klausa when pertama pada baris awal pernyataan, lalu semua klausa lain dapat ditulis dengan satu indentasi lebih sedikit.
+
+```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>
+
+Perlu dicatat urutan ekspresi perbandingan kasus. Ekspresi kasus berada di sisi kiri. Ini bisa berguna jika ekspresi kasus ingin mengganti cara perbandingan dengan mendefinisikan metamethod `eq`.
+
+## Pencocokan Tabel
+
+Anda bisa melakukan pencocokan tabel dalam klausa when switch, jika tabel dapat didestrukturisasi oleh struktur tertentu dan mendapatkan nilai non-nil.
+
+```yuescript
+items =
+  * x: 100
+    y: 200
+  * width: 300
+    height: 400
+
+for item in *items
+  switch item
+    when :x, :y
+      print "Vec2 #{x}, #{y}"
+    when :width, :height
+      print "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>
+
+Anda dapat menggunakan nilai default untuk mendestrukturisasi tabel secara opsional pada beberapa field.
+
+```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>
+
+Anda juga bisa mencocokkan elemen array, field tabel, dan bahkan struktur bertingkat dengan literal array atau tabel.
+
+Cocokkan terhadap elemen array.
+
+```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>
+
+Cocokkan terhadap field tabel dengan destrukturisasi.
+
+```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>
+
+Cocokkan terhadap struktur tabel bertingkat.
+
+```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>
+
+Cocokkan terhadap array dari tabel.
+
+```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>
+
+Cocokkan terhadap daftar dan tangkap rentang elemen.
+
+```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>
+
+# Perulangan While
+
+Perulangan while juga memiliki empat variasi:
+
+```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>
+
+Seperti loop for, loop while juga bisa digunakan sebagai ekspresi. Ekspresi `while` dan `until` mendukung `break` dengan banyak nilai.
+
+```yuescript
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+<YueDisplay>
+
+```yue
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+</YueDisplay>
+
+Selain itu, agar sebuah fungsi mengembalikan nilai akumulasi dari loop while, pernyataannya harus di-return secara eksplisit.
+
+## Repeat Loop
+
+Loop repeat berasal dari 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>
+
+Ekspresi `repeat` juga mendukung `break` dengan banyak nilai:
+
+```yuescript
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+<YueDisplay>
+
+```yue
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+</YueDisplay>
+
+# Stub Fungsi
+
+Sering kali fungsi dari sebuah objek diteruskan sebagai nilai, misalnya meneruskan method instance ke fungsi lain sebagai callback. Jika fungsi mengharapkan objek yang dioperasikan sebagai argumen pertama, maka Anda harus menggabungkan objek tersebut dengan fungsi agar dapat dipanggil dengan benar.
+
+Sintaks stub fungsi adalah singkatan untuk membuat fungsi closure baru yang menggabungkan objek dan fungsi. Fungsi baru ini memanggil fungsi yang dibungkus dalam konteks objek yang benar.
+
+Sintaksnya sama seperti memanggil method instance dengan operator `\`, tetapi tanpa menyediakan daftar argumen.
+
+```yuescript
+my_object = {
+  value: 1000
+  write: => print "the value:", @value
+}
+
+run_callback = (func) ->
+  print "running callback..."
+  func!
+
+-- ini tidak akan berfungsi:
+-- fungsi tidak memiliki referensi ke my_object
+run_callback my_object.write
+
+-- sintaks stub fungsi
+-- memungkinkan kita membundel objek ke fungsi baru
+run_callback my_object\write
+```
+
+<YueDisplay>
+
+```yue
+my_object = {
+  value: 1000
+  write: => print "the value:", @value
+}
+
+run_callback = (func) ->
+  print "running callback..."
+  func!
+
+-- ini tidak akan berfungsi:
+-- fungsi tidak memiliki referensi ke my_object
+run_callback my_object.write
+
+-- sintaks stub fungsi
+-- memungkinkan kita membundel objek ke fungsi baru
+run_callback my_object\write
+```
+
+</YueDisplay>
+
+# Backcall
+
+Backcall digunakan untuk meratakan callback yang bersarang. Backcall didefinisikan menggunakan panah yang mengarah ke kiri sebagai parameter terakhir secara default yang akan mengisi pemanggilan fungsi. Semua sintaks pada dasarnya sama seperti fungsi panah biasa, kecuali arahnya berlawanan dan badan fungsi tidak memerlukan indentasi.
+
+```yuescript
+x <- f
+print "hello" .. x
+```
+
+<YueDisplay>
+
+```yue
+x <- f
+print "hello" .. x
+```
+
+</YueDisplay>
+
+Fungsi panah tebal juga tersedia.
+
+```yuescript
+<= f
+print @value
+```
+
+<YueDisplay>
+
+```yue
+<= f
+print @value
+```
+
+</YueDisplay>
+
+Anda dapat menentukan placeholder untuk posisi fungsi backcall sebagai parameter.
+
+```yuescript
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+<YueDisplay>
+
+```yue
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+</YueDisplay>
+
+Jika Anda ingin menulis kode lanjutan setelah backcall, Anda dapat memisahkannya dengan pernyataan `do`. Tanda kurung dapat dihilangkan untuk fungsi panah non-tebal.
+
+```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>
+
+# Literal Fungsi
+
+Semua fungsi dibuat menggunakan ekspresi fungsi. Fungsi sederhana ditandai dengan panah: **->**.
+
+```yuescript
+my_function = ->
+my_function() -- memanggil fungsi kosong
+```
+
+<YueDisplay>
+
+```yue
+my_function = ->
+my_function() -- memanggil fungsi kosong
+```
+
+</YueDisplay>
+
+Badan fungsi bisa berupa satu pernyataan yang ditulis langsung setelah panah, atau berupa serangkaian pernyataan yang diindentasi di baris berikutnya:
+
+```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>
+
+Jika fungsi tidak memiliki argumen, ia dapat dipanggil menggunakan operator `!`, sebagai ganti tanda kurung kosong. Pemanggilan `!` adalah cara yang disarankan untuk memanggil fungsi tanpa argumen.
+
+```yuescript
+func_a!
+func_b()
+```
+
+<YueDisplay>
+
+```yue
+func_a!
+func_b()
+```
+
+</YueDisplay>
+
+Fungsi dengan argumen dapat dibuat dengan menaruh daftar nama argumen dalam tanda kurung sebelum panah:
+
+```yuescript
+sum = (x, y) -> print "sum", x + y
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> print "sum", x + y
+```
+
+</YueDisplay>
+
+Fungsi dapat dipanggil dengan menuliskan argumen setelah nama ekspresi yang mengevaluasi ke fungsi. Saat merangkai pemanggilan fungsi, argumen diterapkan ke fungsi terdekat di sebelah kiri.
+
+```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>
+
+Untuk menghindari ambiguitas saat memanggil fungsi, tanda kurung juga bisa digunakan untuk mengelilingi argumen. Ini diperlukan di sini agar argumen yang tepat dikirim ke fungsi yang tepat.
+
+```yuescript
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+<YueDisplay>
+
+```yue
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+</YueDisplay>
+
+Tidak boleh ada spasi antara tanda kurung buka dan nama fungsi.
+
+Fungsi akan memaksa pernyataan terakhir di badannya menjadi pernyataan return, ini disebut return implisit:
+
+```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>
+
+Dan jika Anda perlu return secara eksplisit, Anda bisa menggunakan kata kunci `return`:
+
+```yuescript
+sum = (x, y) -> return x + y
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> return x + y
+```
+
+</YueDisplay>
+
+Seperti di Lua, fungsi dapat mengembalikan beberapa nilai. Pernyataan terakhir harus berupa daftar nilai yang dipisahkan koma:
+
+```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>
+
+## Panah Tebal
+
+Karena sudah menjadi idiom di Lua untuk mengirim objek sebagai argumen pertama saat memanggil method, disediakan sintaks khusus untuk membuat fungsi yang otomatis menyertakan argumen `self`.
+
+```yuescript
+func = (num) => @value + num
+```
+
+<YueDisplay>
+
+```yue
+func = (num) => @value + num
+```
+
+</YueDisplay>
+
+## Nilai Default Argumen
+
+Dimungkinkan untuk menyediakan nilai default bagi argumen fungsi. Argumen dianggap kosong jika nilainya nil. Argumen nil yang memiliki nilai default akan diganti sebelum badan fungsi dijalankan.
+
+```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>
+
+Ekspresi nilai default argumen dievaluasi di dalam badan fungsi sesuai urutan deklarasi argumen. Karena itu, nilai default dapat mengakses argumen yang dideklarasikan sebelumnya.
+
+```yuescript
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+<YueDisplay>
+
+```yue
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+</YueDisplay>
+
+## Pertimbangan
+
+Karena cara pemanggilan fungsi tanpa tanda kurung yang ekspresif, beberapa pembatasan harus diterapkan untuk menghindari ambiguitas parsing yang melibatkan spasi.
+
+Tanda minus memiliki dua peran, operator negasi unari dan operator pengurangan biner. Perhatikan bagaimana contoh berikut dikompilasi:
+
+```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>
+
+Prioritas argumen pertama pada pemanggilan fungsi dapat dikendalikan menggunakan spasi jika argumennya adalah literal string. Di Lua, sudah umum untuk menghilangkan tanda kurung saat memanggil fungsi dengan satu literal string atau tabel.
+
+Ketika tidak ada spasi antara variabel dan literal string, pemanggilan fungsi akan memiliki prioritas atas ekspresi yang mengikuti. Tidak ada argumen lain yang dapat diberikan pada fungsi ketika dipanggil dengan cara ini.
+
+Ketika ada spasi setelah variabel dan literal string, pemanggilan fungsi bertindak seperti yang dijelaskan di atas. Literal string menjadi milik ekspresi berikutnya (jika ada), yang berfungsi sebagai daftar argumen.
+
+```yuescript
+x = func"hello" + 100
+y = func "hello" + 100
+```
+
+<YueDisplay>
+
+```yue
+x = func"hello" + 100
+y = func "hello" + 100
+```
+
+</YueDisplay>
+
+## Argumen Multi-baris
+
+Saat memanggil fungsi yang menerima banyak argumen, akan lebih nyaman untuk memecah daftar argumen menjadi beberapa baris. Karena sifat bahasa yang peka terhadap spasi, perlu hati-hati saat memecah daftar argumen.
+
+Jika daftar argumen akan dilanjutkan ke baris berikutnya, baris saat ini harus diakhiri dengan koma. Dan baris berikutnya harus lebih terindentasi daripada indentasi saat ini. Setelah diindentasi, semua baris argumen lainnya harus berada pada tingkat indentasi yang sama agar menjadi bagian dari daftar argumen.
+
+```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>
+
+Jenis pemanggilan ini dapat dinest. Tingkat indentasi digunakan untuk menentukan argumen milik fungsi yang mana.
+
+```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>
+
+Karena tabel juga menggunakan koma sebagai pemisah, sintaks indentasi ini membantu agar nilai menjadi bagian dari daftar argumen, bukan bagian dari tabel.
+
+```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>
+
+Meskipun jarang, perhatikan bahwa kita bisa memberikan indentasi yang lebih dalam untuk argumen fungsi jika kita tahu akan menggunakan indentasi yang lebih dangkal di bagian selanjutnya.
+
+```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>
+
+Hal yang sama juga dapat dilakukan pada pernyataan tingkat blok lainnya seperti kondisional. Kita bisa menggunakan tingkat indentasi untuk menentukan nilai milik pernyataan apa:
+
+```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>
+
+## Destrukturisasi Parameter
+
+YueScript kini mendukung destrukturisasi parameter fungsi ketika argumen berupa objek. Dua bentuk destrukturisasi literal tabel tersedia:
+
+- **Literal berkurung kurawal/parameter objek**, memungkinkan nilai default opsional ketika field hilang (misalnya, `{:a, :b}`, `{a: a1 = 123}`).
+
+- **Sintaks tabel sederhana tanpa pembungkus**, dimulai dengan urutan key-value atau binding singkat dan berlanjut sampai ekspresi lain menghentikannya (misalnya, `:a, b: b1, :c`). Bentuk ini mengekstrak beberapa field dari objek yang sama.
+
+```yuescript
+f1 = (:a, :b, :c) ->
+  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>
+
+## Ekspresi Return Berawalan
+
+Saat bekerja dengan badan fungsi yang sangat bertingkat, menjaga keterbacaan dan konsistensi nilai return bisa terasa melelahkan. Untuk mengatasinya, YueScript memperkenalkan sintaks **Ekspresi Return Berawalan**. Bentuknya sebagai berikut:
+
+```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>
+
+Ini setara dengan:
+
+```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>
+
+Satu-satunya perbedaan adalah Anda dapat memindahkan ekspresi return terakhir sebelum token `->` atau `=>` untuk menunjukkan nilai return implisit fungsi sebagai pernyataan terakhir. Dengan cara ini, bahkan pada fungsi dengan banyak loop bertingkat atau cabang kondisional, Anda tidak lagi perlu menulis ekspresi return di akhir badan fungsi, sehingga struktur logika menjadi lebih lurus dan mudah diikuti.
+
+## Varargs Bernama
+
+Anda dapat menggunakan sintaks `(...t) ->` untuk otomatis menyimpan varargs ke tabel bernama. Tabel ini berisi semua argumen yang diteruskan (termasuk nilai `nil`), dan field `n` pada tabel menyimpan jumlah argumen yang benar-benar diteruskan (termasuk nilai `nil`).
+
+```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!
+
+-- Menangani kasus dengan nilai nil
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+
+<YueDisplay>
+
+```yue
+f = (...t) ->
+  print "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!
+
+-- Menangani kasus dengan nilai nil
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+
+</YueDisplay>
+
+# Spasi Kosong
+
+YueScript adalah bahasa yang peka terhadap spasi. Anda harus menulis beberapa blok kode dengan indentasi yang sama menggunakan spasi **' '** atau tab **'\t'** seperti badan fungsi, daftar nilai, dan beberapa blok kontrol. Ekspresi yang mengandung spasi berbeda dapat bermakna berbeda. Tab diperlakukan seperti 4 spasi, tetapi sebaiknya jangan mencampur penggunaan spasi dan tab.
+
+## Pemisah Pernyataan
+
+Sebuah pernyataan biasanya berakhir pada pergantian baris. Anda juga bisa memakai titik koma `;` untuk mengakhiri pernyataan secara eksplisit, yang memungkinkan menulis beberapa pernyataan pada satu baris:
+
+```yuescript
+a = 1; b = 2; print a + b
+```
+
+<YueDisplay>
+
+```yue
+a = 1; b = 2; print a + b
+```
+
+</YueDisplay>
+
+## Rantai Multibaris
+
+Anda bisa menulis pemanggilan fungsi berantai multi-baris dengan indentasi yang sama.
+
+```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>
+
+# Komentar
+
+```yuescript
+-- Saya adalah komentar
+
+str = --[[
+Ini komentar multi-baris.
+Tidak masalah.
+]] strA \ -- komentar 1
+  .. strB \ -- komentar 2
+  .. strC
+
+func --[[port]] 3000, --[[ip]] "192.168.1.1"
+```
+
+<YueDisplay>
+
+```yue
+-- Saya adalah komentar
+
+str = --[[
+Ini komentar multi-baris.
+Tidak masalah.
+]] strA \ -- komentar 1
+  .. strB \ -- komentar 2
+  .. strC
+
+func --[[port]] 3000, --[[ip]] "192.168.1.1"
+```
+
+</YueDisplay>
+
+# Atribut
+
+Dukungan sintaks untuk atribut Lua 5.4. Anda juga masih bisa menggunakan deklarasi `const` dan `close` dan mendapatkan pemeriksaan konstanta serta callback berbatas-scope ketika menargetkan versi Lua di bawah 5.4.
+
+```yuescript
+const a = 123
+close _ = <close>: -> print "Out of scope."
+```
+
+<YueDisplay>
+
+```yue
+const a = 123
+close _ = <close>: -> print "Out of scope."
+```
+
+</YueDisplay>
+
+Anda dapat melakukan destrukturisasi dengan variabel yang diberi atribut sebagai konstanta.
+
+```yuescript
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+<YueDisplay>
+
+```yue
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+</YueDisplay>
+
+Anda juga bisa mendeklarasikan variabel global sebagai `const`.
+
+```yuescript
+global const Constant = 123
+-- Constant = 1
+```
+
+<YueDisplay>
+
+```yue
+global const Constant = 123
+-- Constant = 1
+```
+
+</YueDisplay>
+
+# Operator
+
+Semua operator biner dan unari Lua tersedia. Selain itu **!=** adalah alias untuk **~=**, dan **\\** atau **::** bisa digunakan untuk menulis pemanggilan fungsi berantai seperti `tb\func!` atau `tb::func!`. YueScript juga menawarkan beberapa operator khusus lain untuk menulis kode yang lebih ekspresif.
+
+```yuescript
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+<YueDisplay>
+
+```yue
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+</YueDisplay>
+
+## Perbandingan Berantai
+
+Perbandingan bisa dirantai secara bebas:
+
+```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>
+
+Perhatikan perilaku evaluasi perbandingan berantai:
+
+```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>
+
+Ekspresi tengah hanya dievaluasi sekali, bukan dua kali seperti jika ekspresi ditulis sebagai `v(1) < v(2) and v(2) <= v(3)`. Namun, urutan evaluasi pada perbandingan berantai tidak didefinisikan. Sangat disarankan untuk tidak menggunakan ekspresi dengan efek samping (seperti `print`) di perbandingan berantai. Jika efek samping diperlukan, operator short-circuit `and` sebaiknya digunakan secara eksplisit.
+
+## Menambahkan ke Tabel
+
+Operator **[] =** digunakan untuk menambahkan nilai ke tabel.
+
+```yuescript
+tab = []
+tab[] = "Value"
+```
+
+<YueDisplay>
+
+```yue
+tab = []
+tab[] = "Value"
+```
+
+</YueDisplay>
+
+Anda juga bisa memakai operator spread `...` untuk menambahkan semua elemen dari satu list ke list lain:
+
+```yuescript
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA sekarang [1, 2, 3, 4, 5, 6]
+```
+
+<YueDisplay>
+
+```yue
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA sekarang [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+## Penyebaran Tabel
+
+Anda bisa menggabungkan tabel array atau tabel hash menggunakan operator spread `...` sebelum ekspresi di literal tabel.
+
+```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>
+
+## Indeks Balik Tabel
+
+Anda dapat menggunakan operator **#** untuk mendapatkan elemen terakhir dari tabel.
+
+```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
+
+Operator **<>** dapat digunakan sebagai pintasan untuk manipulasi metatable.
+
+### Pembuatan Metatable
+
+Buat tabel normal dengan tanda kurung siku kosong **<>** atau kunci metamethod yang dikelilingi oleh **<>**.
+
+```yuescript
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+ -- set field dengan variabel bernama sama
+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 dengan variabel bernama sama
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "out of scope"
+```
+
+</YueDisplay>
+
+### Mengakses Metatable
+
+Akses metatable dengan **<>**, nama metamethod yang dikelilingi **<>**, atau menulis ekspresi di dalam **<>**.
+
+```yuescript
+-- dibuat dengan metatable yang berisi field "value"
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+
+<YueDisplay>
+
+```yue
+-- dibuat dengan metatable yang berisi field "value"
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+
+</YueDisplay>
+
+### Destrukturisasi Metatable
+
+Destrukturisasi metatable dengan kunci metamethod yang dikelilingi **<>**.
+
+```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>
+
+## Keberadaan
+
+Operator **?** dapat digunakan dalam berbagai konteks untuk memeriksa keberadaan.
+
+```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
+
+Sebagai ganti serangkaian pemanggilan fungsi bersarang, Anda bisa mengalirkan nilai dengan operator **|>**.
+
+```yuescript
+"hello" |> print
+1 |> print 2 -- sisipkan nilai pipe sebagai argumen pertama
+2 |> print 1, _, 3 -- pipe dengan placeholder
+
+-- ekspresi pipe multi-baris
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+<YueDisplay>
+
+```yue
+"hello" |> print
+1 |> print 2 -- sisipkan nilai pipe sebagai argumen pertama
+2 |> print 1, _, 3 -- pipe dengan placeholder
+-- ekspresi pipe multi-baris
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+</YueDisplay>
+
+## Nil Coalescing
+
+Operator nil-coalescing **??** mengembalikan nilai dari operan kiri jika bukan **nil**; jika tidak, operator mengevaluasi operan kanan dan mengembalikan hasilnya. Operator **??** tidak mengevaluasi operan kanan jika operan kiri bernilai non-nil.
+
+```yuescript
+local a, b, c, d
+a = b ?? c ?? d
+func a ?? {}
+
+a ??= false
+```
+
+<YueDisplay>
+
+```yue
+local a, b, c, d
+a = b ?? c ?? d
+func a ?? {}
+a ??= false
+```
+
+</YueDisplay>
+
+## Objek Implisit
+
+Anda dapat menulis daftar struktur implisit yang diawali simbol **\*** atau **-** di dalam blok tabel. Jika Anda membuat objek implisit, field objek harus berada pada indentasi yang sama.
+
+```yuescript
+-- assignment dengan objek implisit
+list =
+  * 1
+  * 2
+  * 3
+
+-- pemanggilan fungsi dengan objek implisit
+func
+  * 1
+  * 2
+  * 3
+
+-- return dengan objek implisit
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- tabel dengan objek implisit
+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 dengan objek implisit
+list =
+  * 1
+  * 2
+  * 3
+
+-- pemanggilan fungsi dengan objek implisit
+func
+  * 1
+  * 2
+  * 3
+
+-- return dengan objek implisit
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- tabel dengan objek implisit
+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>
+
+# Literal
+
+Semua literal primitif di Lua dapat digunakan. Ini berlaku untuk angka, string, boolean, dan **nil**.
+
+Berbeda dengan Lua, pemisah baris diizinkan di dalam string bertanda kutip tunggal maupun ganda tanpa urutan escape:
+
+```yuescript
+some_string = "Here is a string
+  that has a line break in it."
+
+-- Anda dapat mencampur ekspresi ke dalam literal string dengan sintaks #{}.
+-- Interpolasi string hanya tersedia pada string dengan tanda kutip ganda.
+print "I am #{math.random! * 100}% sure."
+```
+
+<YueDisplay>
+
+```yue
+some_string = "Here is a string
+  that has a line break in it."
+
+-- Anda dapat mencampur ekspresi ke dalam literal string dengan sintaks #{}.
+-- Interpolasi string hanya tersedia pada string dengan tanda kutip ganda.
+print "I am #{math.random! * 100}% sure."
+```
+
+</YueDisplay>
+
+## Literal Angka
+
+Anda bisa menggunakan garis bawah pada literal angka untuk meningkatkan keterbacaan.
+
+```yuescript
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+
+<YueDisplay>
+
+```yue
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+
+</YueDisplay>
+
+## String Multibaris YAML
+
+Prefiks `|` memperkenalkan literal string multibaris bergaya YAML:
+
+```yuescript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+<YueDisplay>
+
+```yue
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+</YueDisplay>
+
+Ini memungkinkan penulisan teks multibaris terstruktur dengan mudah. Semua pemisah baris dan indentasi dipertahankan relatif terhadap baris non-kosong pertama, dan ekspresi di dalam `#{...}` diinterpolasi otomatis sebagai `tostring(expr)`.
+
+String Multibaris YAML secara otomatis mendeteksi prefiks spasi awal yang sama (indentasi minimum di seluruh baris non-kosong) dan menghapusnya dari semua baris. Ini memudahkan untuk mengindentasi kode secara visual tanpa memengaruhi isi string yang dihasilkan.
+
+```yuescript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+<YueDisplay>
+
+```yue
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+</YueDisplay>
+
+Indentasi internal dipertahankan relatif terhadap prefiks umum yang dihapus, sehingga struktur bertingkat tetap rapi.
+
+Semua karakter khusus seperti tanda kutip (`"`) dan backslash (`\`) di dalam blok YAMLMultiline di-escape secara otomatis agar string Lua yang dihasilkan valid secara sintaks dan berperilaku sebagaimana mestinya.
+
+```yuescript
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+
+<YueDisplay>
+
+```yue
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+
+</YueDisplay>
+
+# Modul
+
+## Import
+
+Pernyataan `import` adalah sintaks sugar untuk me-require modul atau membantu mengekstrak item dari modul yang diimpor. Item yang diimpor bersifat `const` secara default.
+
+```yuescript
+-- digunakan sebagai destrukturisasi tabel
+do
+  import insert, concat from table
+  -- akan error saat meng-assign ke insert, concat
+  import C, Ct, Cmt from require "lpeg"
+  -- shortcut untuk require implisit
+  import x, y, z from 'mymodule'
+  -- import gaya Python
+  from 'module' import a, b, c
+
+-- shortcut untuk require modul
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- require modul dengan aliasing atau destrukturisasi tabel
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+<YueDisplay>
+
+```yue
+-- digunakan sebagai destrukturisasi tabel
+do
+  import insert, concat from table
+  -- akan error saat meng-assign ke insert, concat
+  import C, Ct, Cmt from require "lpeg"
+  -- shortcut untuk require implisit
+  import x, y, z from 'mymodule'
+  -- import gaya Python
+  from 'module' import a, b, c
+
+-- shortcut untuk require modul
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- require modul dengan aliasing atau destrukturisasi tabel
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+</YueDisplay>
+
+## Import Global
+
+Anda dapat mengimpor global tertentu ke variabel local dengan `import`. Saat mengimpor rangkaian akses variabel global, field terakhir akan di-assign ke variabel local.
+
+```yuescript
+do
+  import tostring
+  import table.concat
+  print concat ["a", tostring 1]
+```
+
+<YueDisplay>
+
+```yue
+do
+  import tostring
+  import table.concat
+  print concat ["a", tostring 1]
+```
+
+</YueDisplay>
+
+### Import Variabel Global Otomatis
+
+Anda dapat menempatkan `import global` di awal blok untuk mengimpor secara otomatis semua nama yang belum dideklarasikan atau di-assign secara eksplisit di scope saat ini sebagai global. Import implisit ini diperlakukan sebagai local const yang mereferensikan global terkait pada posisi pernyataan tersebut.
+
+Nama yang secara eksplisit dideklarasikan sebagai global di scope yang sama tidak akan diimpor, sehingga Anda masih bisa meng-assign ke mereka.
+
+```yuescript
+do
+  import global
+  print "hello"
+  math.random 3
+  -- print = nil -- error: imported globals are const
+
+do
+  -- variabel global eksplisit tidak akan diimpor
+  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
+  -- variabel global eksplisit tidak akan diimpor
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+
+</YueDisplay>
+
+## Export
+
+Pernyataan `export` menawarkan cara ringkas untuk mendefinisikan modul.
+
+### Export Bernama
+
+Export bernama akan mendefinisikan variabel local sekaligus menambahkan field di tabel export.
+
+```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>
+
+Melakukan export bernama dengan destrukturisasi.
+
+```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 item bernama dari modul tanpa membuat variabel local.
+
+```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>
+
+### Export Tanpa Nama
+
+Export tanpa nama akan menambahkan item target ke bagian array dari tabel export.
+
+```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>
+
+### Export Default
+
+Gunakan kata kunci **default** dalam pernyataan export untuk mengganti tabel export dengan apa pun.
+
+```yuescript
+export default ->
+  print "hello"
+  123
+```
+
+<YueDisplay>
+
+```yue
+export default ->
+  print "hello"
+  123
+```
+
+</YueDisplay>
+
+# Lisensi: MIT
+
+Copyright (c) 2017-2026 Li Jin <dragon-fly@qq.com>
+
+Izin dengan ini diberikan, tanpa biaya, kepada siapa pun yang memperoleh salinan
+perangkat lunak ini beserta file dokumentasi terkait ("Perangkat Lunak"), untuk
+berurusan dengan Perangkat Lunak tanpa pembatasan, termasuk tanpa batasan hak
+untuk menggunakan, menyalin, memodifikasi, menggabungkan, menerbitkan,
+mendistribusikan, mensublisensikan, dan/atau menjual salinan Perangkat Lunak,
+dan untuk mengizinkan orang yang menerima Perangkat Lunak untuk melakukannya,
+dengan syarat-syarat berikut:
+
+Pemberitahuan hak cipta di atas dan pemberitahuan izin ini harus disertakan dalam
+semua salinan atau bagian substansial dari Perangkat Lunak.
+
+PERANGKAT LUNAK DISEDIAKAN "APA ADANYA", TANPA JAMINAN APA PUN, BAIK TERSURAT
+MAUPUN TERSIRAT, TERMASUK NAMUN TIDAK TERBATAS PADA JAMINAN KELAYAKAN
+DIPERDAGANGKAN, KESESUAIAN UNTUK TUJUAN TERTENTU, DAN TIDAK MELANGGAR HAK.
+DALAM KEADAAN APA PUN, PENULIS ATAU PEMEGANG HAK CIPTA TIDAK BERTANGGUNG JAWAB
+ATAS KLAIM, KERUSAKAN, ATAU KEWAJIBAN LAINNYA, BAIK DALAM TINDAKAN KONTRAK,
+PERBUATAN MELAWAN HUKUM, ATAU LAINNYA, YANG TIMBUL DARI, DI LUAR, ATAU TERKAIT
+DENGAN PERANGKAT LUNAK ATAU PENGGUNAAN ATAU URUSAN LAIN DALAM PERANGKAT LUNAK.
+
+# Pustaka YueScript
+
+Akses dengan `local yue = require("yue")` di Lua.
+
+## yue
+
+**Deskripsi:**
+
+Pustaka bahasa YueScript.
+
+### version
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Versi YueScript.
+
+**Signature:**
+
+```lua
+version: string
+```
+
+### dirsep
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Pemisah file untuk platform saat ini.
+
+**Signature:**
+
+```lua
+dirsep: string
+```
+
+### yue_compiled
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Cache kode modul yang telah dikompilasi.
+
+**Signature:**
+
+```lua
+yue_compiled: {string: string}
+```
+
+### to_lua
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Fungsi kompilasi YueScript. Mengompilasi kode YueScript menjadi kode Lua.
+
+**Signature:**
+
+```lua
+to_lua: function(code: string, config?: Config):
+    --[[codes]] string | nil,
+    --[[error]] string | nil,
+    --[[globals]] {{string, integer, integer}} | nil
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| code      | string | Kode YueScript.           |
+| config    | Config | [Opsional] Opsi kompiler. |
+
+**Return:**
+
+| Tipe Return                         | Deskripsi                                                                                                                         |
+| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| string \| nil                       | Kode Lua hasil kompilasi, atau nil jika kompilasi gagal.                                                                          |
+| string \| nil                       | Pesan error, atau nil jika kompilasi berhasil.                                                                                    |
+| {{string, integer, integer}} \| nil | Variabel global yang muncul dalam kode (dengan nama, baris, dan kolom), atau nil jika opsi kompiler `lint_global` bernilai false. |
+
+### file_exist
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Fungsi untuk memeriksa keberadaan file sumber. Dapat ditimpa untuk menyesuaikan perilaku.
+
+**Signature:**
+
+```lua
+file_exist: function(filename: string): boolean
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi  |
+| --------- | ------ | ---------- |
+| filename  | string | Nama file. |
+
+**Return:**
+
+| Tipe Return | Deskripsi        |
+| ----------- | ---------------- |
+| boolean     | Apakah file ada. |
+
+### read_file
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Fungsi untuk membaca file sumber. Dapat ditimpa untuk menyesuaikan perilaku.
+
+**Signature:**
+
+```lua
+read_file: function(filename: string): string
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi  |
+| --------- | ------ | ---------- |
+| filename  | string | Nama file. |
+
+**Return:**
+
+| Tipe Return | Deskripsi |
+| ----------- | --------- |
+| string      | Isi file. |
+
+### insert_loader
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Menyisipkan loader YueScript ke package loaders (searchers).
+
+**Signature:**
+
+```lua
+insert_loader: function(pos?: integer): boolean
+```
+
+**Parameter:**
+
+| Parameter | Tipe    | Deskripsi                                                     |
+| --------- | ------- | ------------------------------------------------------------- |
+| pos       | integer | [Opsional] Posisi untuk menyisipkan loader. Default adalah 3. |
+
+**Return:**
+
+| Tipe Return | Deskripsi                                                                   |
+| ----------- | --------------------------------------------------------------------------- |
+| boolean     | Apakah loader berhasil disisipkan. Akan gagal jika loader sudah disisipkan. |
+
+### remove_loader
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Menghapus loader YueScript dari package loaders (searchers).
+
+**Signature:**
+
+```lua
+remove_loader: function(): boolean
+```
+
+**Return:**
+
+| Tipe Return | Deskripsi                                                                |
+| ----------- | ------------------------------------------------------------------------ |
+| boolean     | Apakah loader berhasil dihapus. Akan gagal jika loader belum disisipkan. |
+
+### loadstring
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memuat kode YueScript dari string menjadi fungsi.
+
+**Signature:**
+
+```lua
+loadstring: function(input: string, chunkname: string, env: table, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| input     | string | Kode YueScript.           |
+| chunkname | string | Nama chunk kode.          |
+| env       | table  | Tabel environment.        |
+| config    | Config | [Opsional] Opsi kompiler. |
+
+**Return:**
+
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
+| function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
+
+### loadstring
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memuat kode YueScript dari string menjadi fungsi.
+
+**Signature:**
+
+```lua
+loadstring: function(input: string, chunkname: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| input     | string | Kode YueScript.           |
+| chunkname | string | Nama chunk kode.          |
+| config    | Config | [Opsional] Opsi kompiler. |
+
+**Return:**
+
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
+| function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
+
+### loadstring
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memuat kode YueScript dari string menjadi fungsi.
+
+**Signature:**
+
+```lua
+loadstring: function(input: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| input     | string | Kode YueScript.           |
+| config    | Config | [Opsional] Opsi kompiler. |
+
+**Return:**
+
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
+| function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
+
+### loadfile
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memuat kode YueScript dari file menjadi fungsi.
+
+**Signature:**
+
+```lua
+loadfile: function(filename: string, env: table, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| filename  | string | Nama file.                |
+| env       | table  | Tabel environment.        |
+| config    | Config | [Opsional] Opsi kompiler. |
+
+**Return:**
+
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
+| function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
+
+### loadfile
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memuat kode YueScript dari file menjadi fungsi.
+
+**Signature:**
+
+```lua
+loadfile: function(filename: string, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| filename  | string | Nama file.                |
+| config    | Config | [Opsional] Opsi kompiler. |
+
+**Return:**
+
+| Tipe Return     | Deskripsi                                         |
+| --------------- | ------------------------------------------------- |
+| function \| nil | Fungsi yang dimuat, atau nil jika pemuatan gagal. |
+| string \| nil   | Pesan error, atau nil jika pemuatan berhasil.     |
+
+### dofile
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memuat kode YueScript dari file menjadi fungsi dan mengeksekusinya.
+
+**Signature:**
+
+```lua
+dofile: function(filename: string, env: table, config?: Config): any...
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| filename  | string | Nama file.                |
+| env       | table  | Tabel environment.        |
+| config    | Config | [Opsional] Opsi kompiler. |
+
+**Return:**
+
+| Tipe Return | Deskripsi                             |
+| ----------- | ------------------------------------- |
+| any...      | Nilai return dari fungsi yang dimuat. |
+
+### dofile
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memuat kode YueScript dari file menjadi fungsi dan mengeksekusinya.
+
+**Signature:**
+
+```lua
+dofile: function(filename: string, config?: Config): any...
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi                 |
+| --------- | ------ | ------------------------- |
+| filename  | string | Nama file.                |
+| config    | Config | [Opsional] Opsi kompiler. |
+
+**Return:**
+
+| Tipe Return | Deskripsi                             |
+| ----------- | ------------------------------------- |
+| any...      | Nilai return dari fungsi yang dimuat. |
+
+### find_modulepath
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Menguraikan nama modul YueScript menjadi path file.
+
+**Signature:**
+
+```lua
+find_modulepath: function(name: string): string
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi   |
+| --------- | ------ | ----------- |
+| name      | string | Nama modul. |
+
+**Return:**
+
+| Tipe Return | Deskripsi  |
+| ----------- | ---------- |
+| string      | Path file. |
+
+### pcall
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memanggil fungsi dalam mode terlindungi.
+Menangkap error apa pun dan mengembalikan kode status beserta hasil atau objek error.
+Menulis ulang nomor baris error ke nomor baris asli di kode YueScript saat error terjadi.
+
+**Signature:**
+
+```lua
+pcall: function(f: function, ...: any): boolean, any...
+```
+
+**Parameter:**
+
+| Parameter | Tipe     | Deskripsi                          |
+| --------- | -------- | ---------------------------------- |
+| f         | function | Fungsi yang akan dipanggil.        |
+| ...       | any      | Argumen yang diteruskan ke fungsi. |
+
+**Return:**
+
+| Tipe Return  | Deskripsi                                      |
+| ------------ | ---------------------------------------------- |
+| boolean, ... | Kode status dan hasil fungsi atau objek error. |
+
+### require
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memuat modul tertentu. Bisa berupa modul Lua atau modul YueScript.
+Menulis ulang nomor baris error ke nomor baris asli di kode YueScript jika modul adalah modul YueScript dan pemuatan gagal.
+
+**Signature:**
+
+```lua
+require: function(name: string): any...
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi                    |
+| --------- | ------ | ---------------------------- |
+| modname   | string | Nama modul yang akan dimuat. |
+
+**Return:**
+
+| Tipe Return | Deskripsi                                                                                                                                                                                               |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| any         | Nilai yang disimpan di package.loaded[modname] jika modul sudah dimuat. Jika belum, mencoba mencari loader dan mengembalikan nilai akhir package.loaded[modname] serta data loader sebagai hasil kedua. |
+
+### p
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memeriksa struktur nilai yang diteruskan dan mencetak representasi string.
+
+**Signature:**
+
+```lua
+p: function(...: any)
+```
+
+**Parameter:**
+
+| Parameter | Tipe | Deskripsi                  |
+| --------- | ---- | -------------------------- |
+| ...       | any  | Nilai yang akan diperiksa. |
+
+### options
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Opsi kompiler saat ini.
+
+**Signature:**
+
+```lua
+options: Config.Options
+```
+
+### traceback
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Fungsi traceback yang menulis ulang nomor baris stack trace ke nomor baris asli di kode YueScript.
+
+**Signature:**
+
+```lua
+traceback: function(message: string): string
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi        |
+| --------- | ------ | ---------------- |
+| message   | string | Pesan traceback. |
+
+**Return:**
+
+| Tipe Return | Deskripsi                                 |
+| ----------- | ----------------------------------------- |
+| string      | Pesan traceback yang telah ditulis ulang. |
+
+### is_ast
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memeriksa apakah kode cocok dengan AST yang ditentukan.
+
+**Signature:**
+
+```lua
+is_ast: function(astName: string, code: string): boolean
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi |
+| --------- | ------ | --------- |
+| astName   | string | Nama AST. |
+| code      | string | Kode.     |
+
+**Return:**
+
+| Tipe Return | Deskripsi                     |
+| ----------- | ----------------------------- |
+| boolean     | Apakah kode cocok dengan AST. |
+
+### AST
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Definisi tipe AST dengan nama, baris, kolom, dan sub-node.
+
+**Signature:**
+
+```lua
+type AST = {string, integer, integer, any}
+```
+
+### to_ast
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Mengonversi kode menjadi AST.
+
+**Signature:**
+
+```lua
+to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
+    --[[AST]] AST | nil,
+    --[[error]] nil | string
+```
+
+**Parameter:**
+
+| Parameter      | Tipe    | Deskripsi                                                                                |
+| -------------- | ------- | ---------------------------------------------------------------------------------------- |
+| code           | string  | Kode.                                                                                    |
+| flattenLevel   | integer | [Opsional] Tingkat perataan. Semakin tinggi berarti semakin rata. Default 0. Maksimum 2. |
+| astName        | string  | [Opsional] Nama AST. Default "File".                                                     |
+| reserveComment | boolean | [Opsional] Apakah akan mempertahankan komentar asli. Default false.                      |
+
+**Return:**
+
+| Tipe Return   | Deskripsi                                     |
+| ------------- | --------------------------------------------- |
+| AST \| nil    | AST, atau nil jika konversi gagal.            |
+| string \| nil | Pesan error, atau nil jika konversi berhasil. |
+
+### format
+
+**Tipe:** Function.
+
+**Deskripsi:**
+
+Memformat kode YueScript.
+
+**Signature:**
+
+```lua
+format: function(code: string, tabSize?: number, reserveComment?: boolean): string
+```
+
+**Parameter:**
+
+| Parameter      | Tipe    | Deskripsi                                                     |
+| -------------- | ------- | ------------------------------------------------------------- |
+| code           | string  | Kode.                                                         |
+| tabSize        | integer | [Opsional] Ukuran tab. Default 4.                             |
+| reserveComment | boolean | [Opsional] Apakah mempertahankan komentar asli. Default true. |
+
+**Return:**
+
+| Tipe Return | Deskripsi                 |
+| ----------- | ------------------------- |
+| string      | Kode yang telah diformat. |
+
+### \_\_call
+
+**Tipe:** Metamethod.
+
+**Deskripsi:**
+
+Me-require modul YueScript.
+Menulis ulang nomor baris error ke nomor baris asli di kode YueScript saat pemuatan gagal.
+
+**Signature:**
+
+```lua
+metamethod __call: function(self: yue, module: string): any...
+```
+
+**Parameter:**
+
+| Parameter | Tipe   | Deskripsi   |
+| --------- | ------ | ----------- |
+| module    | string | Nama modul. |
+
+**Return:**
+
+| Tipe Return | Deskripsi    |
+| ----------- | ------------ |
+| any         | Nilai modul. |
+
+## Config
+
+**Deskripsi:**
+
+Opsi kompilasi kompiler.
+
+### lint_global
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Apakah kompiler harus mengumpulkan variabel global yang muncul dalam kode.
+
+**Signature:**
+
+```lua
+lint_global: boolean
+```
+
+### implicit_return_root
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Apakah kompiler harus melakukan return implisit untuk blok kode root.
+
+**Signature:**
+
+```lua
+implicit_return_root: boolean
+```
+
+### reserve_line_number
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Apakah kompiler harus mempertahankan nomor baris asli di kode hasil kompilasi.
+
+**Signature:**
+
+```lua
+reserve_line_number: boolean
+```
+
+### reserve_comment
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Apakah kompiler harus mempertahankan komentar asli di kode hasil kompilasi.
+
+**Signature:**
+
+```lua
+reserve_comment: boolean
+```
+
+### space_over_tab
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Apakah kompiler harus menggunakan karakter spasi alih-alih tab di kode hasil kompilasi.
+
+**Signature:**
+
+```lua
+space_over_tab: boolean
+```
+
+### same_module
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Apakah kompiler harus memperlakukan kode yang akan dikompilasi sebagai modul yang sama dengan modul yang sedang dikompilasi. Untuk penggunaan internal saja.
+
+**Signature:**
+
+```lua
+same_module: boolean
+```
+
+### line_offset
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Apakah pesan error kompiler harus menyertakan offset nomor baris. Untuk penggunaan internal saja.
+
+**Signature:**
+
+```lua
+line_offset: integer
+```
+
+### yue.Config.LuaTarget
+
+**Tipe:** Enumeration.
+
+**Deskripsi:**
+
+Enumerasi versi Lua target.
+
+**Signature:**
+
+```lua
+enum LuaTarget
+  "5.1"
+  "5.2"
+  "5.3"
+  "5.4"
+  "5.5"
+end
+```
+
+### options
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Opsi tambahan untuk diteruskan ke fungsi kompilasi.
+
+**Signature:**
+
+```lua
+options: Options
+```
+
+## Options
+
+**Deskripsi:**
+
+Definisi opsi kompiler tambahan.
+
+### target
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Versi Lua target untuk kompilasi.
+
+**Signature:**
+
+```lua
+target: LuaTarget
+```
+
+### path
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Path pencarian modul tambahan.
+
+**Signature:**
+
+```lua
+path: string
+```
+
+### dump_locals
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Apakah akan menampilkan variabel local dalam pesan error traceback. Default false.
+
+**Signature:**
+
+```lua
+dump_locals: boolean
+```
+
+### simplified
+
+**Tipe:** Field.
+
+**Deskripsi:**
+
+Apakah akan menyederhanakan pesan error. Default true.
+
+**Signature:**
+
+```lua
+simplified: boolean
+```
diff --git a/doc/yue-pt-br.md b/doc/yue-pt-br.md
new file mode 100644
index 0000000..fccbdf6
--- /dev/null
+++ b/doc/yue-pt-br.md
@@ -0,0 +1,5890 @@
+---
+title: Referência
+---
+
+# Documentação do YueScript
+
+<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em; padding-bottom: 2em;"/>
+
+Bem-vindo à documentação oficial do <b>YueScript</b>!<br/>
+Aqui você encontra recursos da linguagem, uso, exemplos de referência e materiais úteis.<br/>
+Selecione um capítulo na barra lateral para começar a aprender YueScript.
+
+# Do
+
+Quando usado como instrução, do funciona exatamente como no Lua.
+
+```yuescript
+do
+  var = "hello"
+  print var
+print var -- nil aqui
+```
+
+<YueDisplay>
+
+```yue
+do
+  var = "hello"
+  print var
+print var -- nil aqui
+```
+
+</YueDisplay>
+
+O **do** do YueScript também pode ser usado como expressão. Permitindo combinar múltiplas linhas em uma. O resultado da expressão do é a última instrução em seu corpo. Expressões `do` suportam usar `break` para interromper o fluxo de execução e retornar múltiplos valores antecipadamente.
+
+```yuescript
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+<YueDisplay>
+
+```yue
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+</YueDisplay>
+
+```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>
+
+# Decoradores de linha
+
+Por conveniência, o loop for e a instrução if podem ser aplicados a instruções únicas no final da linha:
+
+```yuescript
+print "hello world" if name == "Rob"
+```
+
+<YueDisplay>
+
+```yue
+print "hello world" if name == "Rob"
+```
+
+</YueDisplay>
+
+E com loops básicos:
+
+```yuescript
+print "item: ", item for item in *items
+```
+
+<YueDisplay>
+
+```yue
+print "item: ", item for item in *items
+```
+
+</YueDisplay>
+
+E com loops while:
+
+```yuescript
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+
+<YueDisplay>
+
+```yue
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+
+</YueDisplay>
+
+# Macro
+
+## Uso comum
+
+A função macro é usada para avaliar uma string em tempo de compilação e inserir os códigos gerados na compilação final.
+
+```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
+
+-- as expressões passadas são tratadas como 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
+
+-- as expressões passadas são tratadas como strings
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+
+</YueDisplay>
+
+## Inserir códigos brutos
+
+Uma função macro pode retornar uma string YueScript ou uma tabela de configuração contendo códigos Lua.
+
+```yuescript
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+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"
+}
+
+-- os símbolos inicial e final da string bruta são aparados automaticamente
+$lua[==[
+-- inserção de códigos Lua brutos
+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"
+}
+
+-- os símbolos inicial e final da string bruta são aparados automaticamente
+$lua[==[
+-- inserção de códigos Lua brutos
+if cond then
+  print("output")
+end
+]==]
+```
+
+</YueDisplay>
+
+## Exportar macro
+
+Funções macro podem ser exportadas de um módulo e importadas em outro módulo. Você deve colocar funções export macro em um único arquivo para uso, e apenas definição de macro, importação de macro e expansão de macro inline podem ser colocadas no módulo exportador de macro.
+
+```yuescript
+-- arquivo: utils.yue
+export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
+export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
+export macro foreach = (items, action) -> "for _ in *#{items}
+  #{action}"
+
+-- arquivo main.yue
+import "utils" as {
+  $, -- símbolo para importar todas as macros
+  $foreach: $each -- renomear macro $foreach para $each
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+```
+
+<YueDisplay>
+
+```yue
+-- arquivo: 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}"
+
+-- arquivo main.yue
+--[[
+import "utils" as {
+  $, -- símbolo para importar todas as macros
+  $foreach: $each -- renomear macro $foreach para $each
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+]]
+```
+
+</YueDisplay>
+
+## Macro embutida
+
+Existem algumas macros embutidas, mas você pode sobrescrevê-las declarando macros com os mesmos nomes.
+
+```yuescript
+print $FILE -- obtém string do nome do módulo atual
+print $LINE -- obtém número 2
+```
+
+<YueDisplay>
+
+```yue
+print $FILE -- obtém string do nome do módulo atual
+print $LINE -- obtém número 2
+```
+
+</YueDisplay>
+
+## Gerando macros com macros
+
+No YueScript, as funções macro permitem que você gere código em tempo de compilação. Aninhando funções macro, você pode criar padrões de geração mais complexos. Este recurso permite que você defina uma função macro que gera outra função macro, permitindo geração de código mais dinâmica.
+
+```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>
+
+## Validação de argumentos
+
+Você pode declarar os tipos de nós AST esperados na lista de argumentos e verificar se os argumentos da macro recebidos atendem às expectativas em tempo de compilação.
+
+```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>
+
+Se você precisar de verificação de argumentos mais flexível, pode usar a função macro embutida `$is_ast` para verificar manualmente no lugar apropriado.
+
+```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>
+
+Para mais detalhes sobre os nós AST disponíveis, consulte as definições em maiúsculas em [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp).
+
+# Try
+
+A sintaxe para tratamento de erros do Lua em uma forma comum.
+
+```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
+
+-- funcionando com padrão de atribuição em if
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+
+<YueDisplay>
+
+```yue
+try
+  func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try
+  func 1, 2, 3
+catch err
+  yue.traceback err
+
+try func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try func 1, 2, 3
+
+try
+  print "trying"
+  func 1, 2, 3
+
+-- funcionando com padrão de atribuição em if
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+
+</YueDisplay>
+
+## Try?
+
+`try?` é um uso simplificado para sintaxe de tratamento de erros que omite o status booleano da instrução `try`, e retornará o resultado do bloco try quando tiver sucesso, retornando nil em vez do objeto de erro caso contrário.
+
+```yuescript
+a, b, c = try? func!
+
+-- com operador de coalescência de nil
+a = (try? func!) ?? "default"
+
+-- como argumento de função
+f try? func!
+
+-- com bloco catch
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+<YueDisplay>
+
+```yue
+a, b, c = try? func!
+
+-- com operador de coalescência de nil
+a = (try? func!) ?? "default"
+
+-- como argumento de função
+f try? func!
+
+-- com bloco catch
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+</YueDisplay>
+
+# Literais de tabela
+
+Como no Lua, as tabelas são delimitadas por chaves.
+
+```yuescript
+some_values = [1, 2, 3, 4]
+```
+
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+```
+
+</YueDisplay>
+
+Diferente do Lua, atribuir um valor a uma chave em uma tabela é feito com **:** (em vez de **=**).
+
+```yuescript
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+<YueDisplay>
+
+```yue
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+</YueDisplay>
+
+As chaves podem ser omitidas se uma única tabela de pares chave-valor está sendo atribuída.
+
+```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>
+
+Quebras de linha podem ser usadas para delimitar valores em vez de vírgula (ou ambos):
+
+```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>
+
+Ao criar um literal de tabela em uma única linha, as chaves também podem ser omitidas:
+
+```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>
+
+As chaves de um literal de tabela podem ser palavras-chave da linguagem sem precisar escapar:
+
+```yuescript
+tbl = {
+  do: "something"
+  end: "hunger"
+}
+```
+
+<YueDisplay>
+
+```yue
+tbl = {
+  do: "something"
+  end: "hunger"
+}
+```
+
+</YueDisplay>
+
+Se você está construindo uma tabela a partir de variáveis e deseja que as chaves sejam iguais aos nomes das variáveis, então o operador de prefixo **:** pode ser usado:
+
+```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>
+
+Se você quiser que a chave de um campo na tabela seja o resultado de uma expressão, então pode envolvê-la em **[ ]**, assim como no Lua. Você também pode usar um literal de string diretamente como chave, omitindo os colchetes. Isso é útil se sua chave tiver caracteres especiais.
+
+```yuescript
+t = {
+  [1 + 2]: "hello"
+  "hello world": true
+}
+```
+
+<YueDisplay>
+
+```yue
+t = {
+  [1 + 2]: "hello"
+  "hello world": true
+}
+```
+
+</YueDisplay>
+
+As tabelas Lua têm tanto uma parte array quanto uma parte hash, mas às vezes você quer fazer uma distinção semântica entre uso de array e hash ao escrever tabelas Lua. Então você pode escrever tabela Lua com **[ ]** em vez de **{ }** para representar uma tabela array, e escrever qualquer par chave-valor em uma tabela lista não será permitido.
+
+```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>
+
+# Compreensões
+
+As compreensões fornecem uma sintaxe conveniente para construir uma nova tabela iterando sobre algum objeto existente e aplicando uma expressão a seus valores. Existem dois tipos de compreensões: compreensões de lista e compreensões de tabela. Ambas produzem tabelas Lua; as compreensões de lista acumulam valores em uma tabela semelhante a array, e as compreensões de tabela permitem definir tanto a chave quanto o valor em cada iteração.
+
+## Compreensões de lista
+
+O seguinte cria uma cópia da tabela items mas com todos os valores dobrados.
+
+```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>
+
+Os itens incluídos na nova tabela podem ser restringidos com uma cláusula when:
+
+```yuescript
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+</YueDisplay>
+
+Como é comum iterar sobre os valores de uma tabela indexada numericamente, um operador **\*** é introduzido. O exemplo doubled pode ser reescrito como:
+
+```yuescript
+doubled = [item * 2 for item in *items]
+```
+
+<YueDisplay>
+
+```yue
+doubled = [item * 2 for item in *items]
+```
+
+</YueDisplay>
+
+Nas compreensões de lista, você também pode usar o operador spread `...` para achatar listas aninhadas, alcançando um efeito de flat map:
+
+```yuescript
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat agora é [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 agora é [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+As cláusulas for e when podem ser encadeadas tanto quanto desejado. O único requisito é que uma compreensão tenha pelo menos uma cláusula for.
+
+Usar múltiplas cláusulas for é o mesmo que usar loops aninhados:
+
+```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>
+
+Loops for numéricos também podem ser usados em compreensões:
+
+```yuescript
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+<YueDisplay>
+
+```yue
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+</YueDisplay>
+
+## Compreensões de tabela
+
+A sintaxe para compreensões de tabela é muito semelhante, diferindo apenas por usar **{** e **}** e receber dois valores de cada iteração.
+
+Este exemplo faz uma cópia da tabela thing:
+
+```yuescript
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+<YueDisplay>
+
+```yue
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+</YueDisplay>
+
+```yuescript
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+<YueDisplay>
+
+```yue
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+</YueDisplay>
+
+O operador **\*** também é suportado. Aqui criamos uma tabela de consulta de raiz quadrada para alguns números.
+
+```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>
+
+A tupla chave-valor em uma compreensão de tabela também pode vir de uma única expressão, caso em que a expressão deve retornar dois valores. O primeiro é usado como chave e o segundo é usado como valor:
+
+Neste exemplo convertemos um array de pares em uma tabela onde o primeiro item do par é a chave e o segundo é o valor.
+
+```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
+
+Uma sintaxe especial é fornecida para restringir os itens sobre os quais se itera ao usar o operador **\***. Isso é equivalente a definir os limites de iteração e um tamanho de passo em um loop for.
+
+Aqui podemos definir os limites mínimo e máximo, pegando todos os itens com índices entre 1 e 5 inclusive:
+
+```yuescript
+slice = [item for item in *items[1, 5]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[1, 5]]
+```
+
+</YueDisplay>
+
+Qualquer um dos argumentos do slice pode ser omitido para usar um padrão sensato. Neste exemplo, se o índice máximo for omitido, ele usa como padrão o comprimento da tabela. Isso pegará tudo exceto o primeiro elemento:
+
+```yuescript
+slice = [item for item in *items[2,]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[2,]]
+```
+
+</YueDisplay>
+
+Se o limite mínimo for omitido, ele usa como padrão 1. Aqui fornecemos apenas um tamanho de passo e deixamos os outros limites em branco. Isso pega todos os itens com índice ímpar: (1, 3, 5, …)
+
+```yuescript
+slice = [item for item in *items[,,2]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[,,2]]
+```
+
+</YueDisplay>
+
+Tanto o limite mínimo quanto o máximo podem ser negativos, o que significa que os limites são contados a partir do fim da tabela.
+
+```yuescript
+-- pegar os últimos 4 itens
+slice = [item for item in *items[-4,-1]]
+```
+
+<YueDisplay>
+
+```yue
+-- pegar os últimos 4 itens
+slice = [item for item in *items[-4,-1]]
+```
+
+</YueDisplay>
+
+O tamanho do passo também pode ser negativo, o que significa que os itens são tomados em ordem reversa.
+
+```yuescript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+<YueDisplay>
+
+```yue
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+</YueDisplay>
+
+### Expressão de slicing
+
+O slicing também pode ser usado como expressão. Isso é útil para obter uma sublista de uma tabela.
+
+```yuescript
+-- pegar o 2º e 4º itens como nova lista
+sub_list = items[2, 4]
+
+-- pegar os últimos 4 itens
+last_four_items = items[-4, -1]
+```
+
+<YueDisplay>
+
+```yue
+-- pegar o 2º e 4º itens como nova lista
+sub_list = items[2, 4]
+
+-- pegar os últimos 4 itens
+last_four_items = items[-4, -1]
+```
+
+</YueDisplay>
+
+# Programação orientada a objetos
+
+Nestes exemplos, o código Lua gerado pode parecer avassalador. É melhor focar primeiro no significado do código YueScript e depois olhar o código Lua se desejar conhecer os detalhes da implementação.
+
+Uma classe simples:
+
+```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>
+
+Uma classe é declarada com uma instrução class seguida de uma declaração semelhante a tabela onde todos os métodos e propriedades são listados.
+
+A propriedade new é especial pois se tornará o construtor.
+
+Observe como todos os métodos da classe usam a sintaxe de função seta fat. Ao chamar métodos em uma instância, a própria instância é enviada como primeiro argumento. A seta fat cuida da criação do argumento self.
+
+O prefixo @ em um nome de variável é abreviação para self.. @items torna-se self.items.
+
+Criar uma instância da classe é feito chamando o nome da classe como uma função.
+
+```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>
+
+Como a instância da classe precisa ser enviada aos métodos quando são chamados, o operador \ é usado.
+
+Todas as propriedades de uma classe são compartilhadas entre as instâncias. Isso é bom para funções, mas para outros tipos de objetos, resultados indesejados podem ocorrer.
+
+Considere o exemplo abaixo, a propriedade clothes é compartilhada entre todas as instâncias, então modificações nela em uma instância aparecerão em outra:
+
+```yuescript
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- vai imprimir tanto pants quanto 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"
+
+-- vai imprimir tanto pants quanto shirt
+print item for item in *a.clothes
+```
+
+</YueDisplay>
+
+A forma correta de evitar esse problema é criar o estado mutável do objeto no construtor:
+
+```yuescript
+class Person
+  new: =>
+    @clothes = []
+```
+
+<YueDisplay>
+
+```yue
+class Person
+  new: =>
+    @clothes = []
+```
+
+</YueDisplay>
+
+## Herança
+
+A palavra-chave extends pode ser usada em uma declaração de classe para herdar as propriedades e métodos de outra classe.
+
+```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>
+
+Aqui estendemos nossa classe Inventory e limitamos a quantidade de itens que ela pode carregar.
+
+Neste exemplo, não definimos um construtor na subclasse, então o construtor da classe pai é chamado quando criamos uma nova instância. Se definirmos um construtor, podemos usar o método super para chamar o construtor pai.
+
+Sempre que uma classe herda de outra, ela envia uma mensagem à classe pai chamando o método \_\_inherited na classe pai se ele existir. A função recebe dois argumentos: a classe que está sendo herdada e a classe filha.
+
+```yuescript
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "was inherited by", child.__name
+
+-- vai imprimir: Shelf was inherited by Cupboard
+class Cupboard extends Shelf
+```
+
+<YueDisplay>
+
+```yue
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "was inherited by", child.__name
+
+-- vai imprimir: Shelf was inherited by Cupboard
+class Cupboard extends Shelf
+```
+
+</YueDisplay>
+
+## Super
+
+**super** é uma palavra-chave especial que pode ser usada de duas formas diferentes: pode ser tratado como um objeto, ou pode ser chamado como uma função. Só tem funcionalidade especial quando está dentro de uma classe.
+
+Quando chamado como função, chamará a função de mesmo nome na classe pai. O self atual será automaticamente passado como primeiro argumento. (Como visto no exemplo de herança acima)
+
+Quando super é usado como valor normal, é uma referência ao objeto da classe pai.
+
+Pode ser acessado como qualquer objeto para recuperar valores na classe pai que possam ter sido sombreados pela classe filha.
+
+Quando o operador de chamada \ é usado com super, self é inserido como primeiro argumento em vez do valor do próprio super. Ao usar . para recuperar uma função, a função bruta é retornada.
+
+Alguns exemplos de uso de super de diferentes formas:
+
+```yuescript
+class MyClass extends ParentClass
+  a_method: =>
+    -- os seguintes têm o mesmo efeito:
+    super "hello", "world"
+    super\a_method "hello", "world"
+    super.a_method self, "hello", "world"
+
+    -- super como valor é igual à classe pai:
+    assert super == ParentClass
+```
+
+<YueDisplay>
+
+```yue
+class MyClass extends ParentClass
+  a_method: =>
+    -- os seguintes têm o mesmo efeito:
+    super "hello", "world"
+    super\a_method "hello", "world"
+    super.a_method self, "hello", "world"
+
+    -- super como valor é igual à classe pai:
+    assert super == ParentClass
+```
+
+</YueDisplay>
+
+**super** também pode ser usado no lado esquerdo de um Function Stub. A única diferença principal é que, em vez da função resultante estar vinculada ao valor de super, ela está vinculada a self.
+
+## Tipos
+
+Cada instância de uma classe carrega seu tipo consigo. Isso é armazenado na propriedade especial \_\_class. Esta propriedade contém o objeto da classe. O objeto da classe é o que chamamos para construir uma nova instância. Também podemos indexar o objeto da classe para recuperar métodos e propriedades da classe.
+
+```yuescript
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- imprime 10
+```
+
+<YueDisplay>
+
+```yue
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- imprime 10
+```
+
+</YueDisplay>
+
+## Objetos de classe
+
+O objeto da classe é o que criamos quando usamos uma instrução class. O objeto da classe é armazenado em uma variável com o mesmo nome da classe.
+
+O objeto da classe pode ser chamado como uma função para criar novas instâncias. É assim que criamos instâncias de classes nos exemplos acima.
+
+Uma classe é composta por duas tabelas. A própria tabela da classe e a tabela base. A base é usada como metatable para todas as instâncias. Todas as propriedades listadas na declaração da classe são colocadas na base.
+
+A metatable do objeto da classe lê propriedades da base se não existirem no objeto da classe. Isso significa que podemos acessar funções e propriedades diretamente da classe.
+
+É importante notar que atribuir ao objeto da classe não atribui à base, então não é uma forma válida de adicionar novos métodos às instâncias. Em vez disso, a base deve ser alterada explicitamente. Veja o campo \_\_base abaixo.
+
+O objeto da classe tem algumas propriedades especiais:
+
+O nome da classe quando foi declarada é armazenado como string no campo \_\_name do objeto da classe.
+
+```yuescript
+print BackPack.__name -- imprime Backpack
+```
+
+<YueDisplay>
+
+```yue
+print BackPack.__name -- imprime Backpack
+```
+
+</YueDisplay>
+
+O objeto base é armazenado em \_\_base. Podemos modificar esta tabela para adicionar funcionalidade a instâncias que já foram criadas e às que ainda serão criadas.
+
+Se a classe estende de algo, o objeto da classe pai é armazenado em \_\_parent.
+
+## Variáveis de classe
+
+Podemos criar variáveis diretamente no objeto da classe em vez da base usando @ na frente do nome da propriedade em uma declaração de classe.
+
+```yuescript
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- variáveis de classe não visíveis em instâncias
+assert Things().some_func == nil
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- variáveis de classe não visíveis em instâncias
+assert Things().some_func == nil
+```
+
+</YueDisplay>
+
+Em expressões, podemos usar @@ para acessar um valor armazenado no **class de self. Assim, @@hello é abreviação para self.**class.hello.
+
+```yuescript
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- imprime 2
+```
+
+<YueDisplay>
+
+```yue
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- imprime 2
+```
+
+</YueDisplay>
+
+A semântica de chamada de @@ é semelhante a @. Chamar um nome @@ passará a classe como primeiro argumento usando a sintaxe de dois pontos do Lua.
+
+```yuescript
+@@hello 1,2,3,4
+```
+
+<YueDisplay>
+
+```yue
+@@hello 1,2,3,4
+```
+
+</YueDisplay>
+
+## Instruções de declaração de classe
+
+No corpo de uma declaração de classe, podemos ter expressões normais além de pares chave/valor. Neste contexto, self é igual ao objeto da classe.
+
+Aqui está uma forma alternativa de criar variável de classe comparada ao descrito acima:
+
+```yuescript
+class Things
+  @class_var = "hello world"
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @class_var = "hello world"
+```
+
+</YueDisplay>
+
+Estas expressões são executadas após todas as propriedades terem sido adicionadas à base.
+
+Todas as variáveis declaradas no corpo da classe são locais às propriedades da classe. Isso é conveniente para colocar valores privados ou funções auxiliares que apenas os métodos da classe podem acessar:
+
+```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>
+
+## Valores @ e @@
+
+Quando @ e @@ são prefixados na frente de um nome, eles representam, respectivamente, esse nome acessado em self e self.\_\_class.
+
+Se forem usados sozinhos, são aliases para self e self.\_\_class.
+
+```yuescript
+assert @ == self
+assert @@ == self.__class
+```
+
+<YueDisplay>
+
+```yue
+assert @ == self
+assert @@ == self.__class
+```
+
+</YueDisplay>
+
+Por exemplo, uma forma rápida de criar uma nova instância da mesma classe a partir de um método de instância usando @@:
+
+```yuescript
+some_instance_method = (...) => @@ ...
+```
+
+<YueDisplay>
+
+```yue
+some_instance_method = (...) => @@ ...
+```
+
+</YueDisplay>
+
+## Promoção de propriedade no construtor
+
+Para reduzir o código repetitivo na definição de objetos de valor simples. Você pode escrever uma classe simples como:
+
+```yuescript
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- O que é abreviação para
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+<YueDisplay>
+
+```yue
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- O que é abreviação para
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+</YueDisplay>
+
+Você também pode usar esta sintaxe para uma função comum para inicializar os campos de um objeto.
+
+```yuescript
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+<YueDisplay>
+
+```yue
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+</YueDisplay>
+
+## Expressões de classe
+
+A sintaxe de classe também pode ser usada como expressão que pode ser atribuída a uma variável ou retornada explicitamente.
+
+```yuescript
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+<YueDisplay>
+
+```yue
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+</YueDisplay>
+
+## Classes anônimas
+
+O nome pode ser omitido ao declarar uma classe. O atributo \_\_name será nil, a menos que a expressão da classe esteja em uma atribuição. O nome no lado esquerdo da atribuição é usado em vez de nil.
+
+```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>
+
+Você pode até omitir o corpo, significando que pode escrever uma classe anônima em branco assim:
+
+```yuescript
+x = class
+```
+
+<YueDisplay>
+
+```yue
+x = class
+```
+
+</YueDisplay>
+
+## Mistura de classes
+
+Você pode fazer mistura com a palavra-chave `using` para copiar funções de uma tabela simples ou de um objeto de classe predefinido para sua nova classe. Ao fazer mistura com uma tabela simples, você pode sobrescrever a função de indexação da classe (metamétodo `__index`) para sua implementação personalizada. Ao fazer mistura com um objeto de classe existente, os metamétodos do objeto da classe não serão copiados.
+
+```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 não é pai de 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 não é pai de Y
+```
+
+</YueDisplay>
+
+# Instrução With
+
+Um padrão comum envolvendo a criação de um objeto é chamar uma série de funções e definir uma série de propriedades imediatamente após criá-lo.
+
+Isso resulta em repetir o nome do objeto várias vezes no código, adicionando ruído desnecessário. Uma solução comum para isso é passar uma tabela como argumento que contém uma coleção de chaves e valores para sobrescrever. O inconveniente é que o construtor desse objeto deve suportar essa forma.
+
+O bloco with ajuda a aliviar isso. Dentro de um bloco with podemos usar instruções especiais que começam com . ou \ que representam essas operações aplicadas ao objeto com o qual estamos usando with.
+
+Por exemplo, trabalhamos com um objeto recém-criado:
+
+```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>
+
+A instrução with também pode ser usada como expressão que retorna o valor ao qual foi dado acesso.
+
+```yuescript
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+<YueDisplay>
+
+```yue
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+</YueDisplay>
+
+Expressões `with` suportam `break` com um valor:
+
+```yuescript
+result = with obj
+  break .value
+```
+
+<YueDisplay>
+
+```yue
+result = with obj
+  break .value
+```
+
+</YueDisplay>
+
+Depois que `break value` é usado dentro de `with`, a expressão `with` deixa de retornar seu objeto-alvo e passa a retornar o valor de `break`.
+
+```yuescript
+a = with obj
+  .x = 1
+-- a é obj
+
+b = with obj
+  break .x
+-- b é .x, não obj
+```
+
+<YueDisplay>
+
+```yue
+a = with obj
+  .x = 1
+-- a é obj
+
+b = with obj
+  break .x
+-- b é .x, não obj
+```
+
+</YueDisplay>
+
+Diferente de `for` / `while` / `repeat` / `do`, `with` suporta apenas um valor de `break`.
+
+Ou…
+
+```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>
+
+Neste uso, with pode ser visto como uma forma especial do combinador K.
+
+A expressão na instrução with também pode ser uma atribuição, se você quiser dar um nome à expressão.
+
+```yuescript
+with str := "Hello"
+  print "original:", str
+  print "upper:", \upper!
+```
+
+<YueDisplay>
+
+```yue
+with str := "Hello"
+  print "original:", str
+  print "upper:", \upper!
+```
+
+</YueDisplay>
+
+Você pode acessar chaves especiais com `[]` em uma instrução `with`.
+
+```yuescript
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- anexando a "tb"
+```
+
+<YueDisplay>
+
+```yue
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- anexando a "tb"
+```
+
+</YueDisplay>
+
+`with?` é uma versão aprimorada da sintaxe `with`, que introduz uma verificação existencial para acessar com segurança objetos que podem ser nil sem verificações explícitas de null.
+
+```yuescript
+with? obj
+  print obj.name
+```
+
+<YueDisplay>
+
+```yue
+with? obj
+  print obj.name
+```
+
+</YueDisplay>
+
+# Atribuição
+
+A variável é tipada dinamicamente e é definida como local por padrão. Mas você pode alterar o escopo da declaração pelas instruções **local** e **global**.
+
+```yuescript
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- usa a variável existente
+```
+
+<YueDisplay>
+
+```yue
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- usa a variável existente
+```
+
+</YueDisplay>
+
+## Atualização
+
+Você pode realizar atribuição de atualização com muitos operadores binários.
+
+```yuescript
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- adiciona um novo local se a variável local não existir
+arg or= "valor padrão"
+```
+
+<YueDisplay>
+
+```yue
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- adiciona um novo local se a variável local não existir
+arg or= "valor padrão"
+```
+
+</YueDisplay>
+
+## Atribuição encadeada
+
+Você pode fazer atribuição encadeada para atribuir múltiplos itens ao mesmo valor.
+
+```yuescript
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+<YueDisplay>
+
+```yue
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+</YueDisplay>
+
+## Locais explícitos
+
+```yuescript
+do
+  local a = 1
+  local *
+  print "declarar antecipadamente todas as variáveis como locais"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "declarar antecipadamente apenas variáveis em maiúsculas"
+  a = 1
+  B = 2
+```
+
+<YueDisplay>
+
+```yue
+do
+  local a = 1
+  local *
+  print "declarar antecipadamente todas as variáveis como locais"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "declarar antecipadamente apenas variáveis em maiúsculas"
+  a = 1
+  B = 2
+```
+
+</YueDisplay>
+
+## Globais explícitos
+
+```yuescript
+do
+  global a = 1
+  global *
+  print "declarar todas as variáveis como globais"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global X = 1
+  global ^
+  print "declarar apenas variáveis em maiúsculas como globais"
+  a = 1
+  B = 2
+  local Temp = "um valor local"
+```
+
+<YueDisplay>
+
+```yue
+do
+  global a = 1
+  global *
+  print "declarar todas as variáveis como globais"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global X = 1
+  global ^
+  print "declarar apenas variáveis em maiúsculas como globais"
+  a = 1
+  B = 2
+  local Temp = "um valor local"
+```
+
+</YueDisplay>
+
+# Atribuição de varargs
+
+Você pode atribuir os resultados retornados de uma função a um símbolo varargs `...`. E então acessar seu conteúdo da forma Lua.
+
+```yuescript
+list = [1, 2, 3, 4, 5]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+
+<YueDisplay>
+
+```yue
+list = [1, 2, 3, 4, 5]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+
+</YueDisplay>
+
+# Atribuição em if
+
+Os blocos `if` e `elseif` podem receber uma atribuição no lugar de uma expressão condicional. Ao avaliar o condicional, a atribuição será realizada e o valor que foi atribuído será usado como expressão condicional. A variável atribuída está no escopo apenas para o corpo do condicional, ou seja, nunca está disponível se o valor não for truthy. E você precisa usar o "operador walrus" `:=` em vez de `=` para fazer a atribuição.
+
+```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 "Você tem hello", hello
+elseif world := os.getenv "world"
+  print "você tem world", world
+else
+  print "nada :("
+```
+
+<YueDisplay>
+
+```yue
+if hello := os.getenv "hello"
+  print "Você tem hello", hello
+elseif world := os.getenv "world"
+  print "você tem world", world
+else
+  print "nada :("
+```
+
+</YueDisplay>
+
+Atribuição em if com múltiplos valores de retorno. Apenas o primeiro valor é verificado, os outros valores estão no escopo.
+
+```yuescript
+if success, result := pcall -> "obter resultado sem problemas"
+  print result -- variável result está no escopo
+print "OK"
+```
+
+<YueDisplay>
+
+```yue
+if success, result := pcall -> "obter resultado sem problemas"
+  print result -- variável result está no escopo
+print "OK"
+```
+
+</YueDisplay>
+
+## Atribuição em while
+
+Você também pode usar atribuição em if em um loop while para obter o valor como condição do loop.
+
+```yuescript
+while byte := stream\read_one!
+  -- fazer algo com o byte
+  print byte
+```
+
+<YueDisplay>
+
+```yue
+while byte := stream\read_one!
+  -- fazer algo com o byte
+  print byte
+```
+
+</YueDisplay>
+
+# Atribuição por desestruturação
+
+A atribuição por desestruturação é uma forma de extrair rapidamente valores de uma tabela por seu nome ou posição em tabelas baseadas em array.
+
+Tipicamente, quando você vê um literal de tabela, {1,2,3}, ele está no lado direito de uma atribuição porque é um valor. A atribuição por desestruturação troca o papel do literal de tabela e o coloca no lado esquerdo de uma instrução de atribuição.
+
+Isso é melhor explicado com exemplos. Assim você extrairia os dois primeiros valores de uma tabela:
+
+```yuescript
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+<YueDisplay>
+
+```yue
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+</YueDisplay>
+
+No literal de tabela de desestruturação, a chave representa a chave para ler do lado direito, e o valor representa o nome ao qual o valor lido será atribuído.
+
+```yuescript
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- OK fazer desestruturação simples sem chaves
+```
+
+<YueDisplay>
+
+```yue
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- OK fazer desestruturação simples sem chaves
+```
+
+</YueDisplay>
+
+Isso também funciona com estruturas de dados aninhadas:
+
+```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>
+
+Se a instrução de desestruturação for complicada, sinta-se à vontade para espalhá-la em várias linhas. Um exemplo um pouco mais complicado:
+
+```yuescript
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+<YueDisplay>
+
+```yue
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+</YueDisplay>
+
+É comum extrair valores de uma tabela e atribuí-los a variáveis locais que têm o mesmo nome da chave. Para evitar repetição, podemos usar o operador de prefixo **:**:
+
+```yuescript
+{:concat, :insert} = table
+```
+
+<YueDisplay>
+
+```yue
+{:concat, :insert} = table
+```
+
+</YueDisplay>
+
+Isso é efetivamente o mesmo que import, mas podemos renomear campos que queremos extrair misturando a sintaxe:
+
+```yuescript
+{:mix, :max, random: rand} = math
+```
+
+<YueDisplay>
+
+```yue
+{:mix, :max, random: rand} = math
+```
+
+</YueDisplay>
+
+Você pode escrever valores padrão ao fazer desestruturação:
+
+```yuescript
+{:name = "sem nome", :job = "sem emprego"} = person
+```
+
+<YueDisplay>
+
+```yue
+{:name = "sem nome", :job = "sem emprego"} = person
+```
+
+</YueDisplay>
+
+Você pode usar `_` como placeholder ao fazer desestruturação de lista:
+
+```yuescript
+[_, two, _, four] = items
+```
+
+<YueDisplay>
+
+```yue
+[_, two, _, four] = items
+```
+
+</YueDisplay>
+
+## Desestruturação por intervalo
+
+Você pode usar o operador spread `...` na desestruturação de lista para capturar um intervalo de valores. Isso é útil quando você quer extrair elementos específicos do início e do fim de uma lista enquanto coleta o restante entre eles.
+
+```yuescript
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- imprime: first
+print bulk   -- imprime: {"second", "third", "fourth"}
+print last   -- imprime: last
+```
+
+<YueDisplay>
+
+```yue
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- imprime: first
+print bulk   -- imprime: {"second", "third", "fourth"}
+print last   -- imprime: last
+```
+
+</YueDisplay>
+
+O operador spread pode ser usado em diferentes posições para capturar diferentes intervalos, e você pode usar `_` como placeholder para os valores que não quer capturar:
+
+```yuescript
+-- Capturar tudo após o primeiro elemento
+[first, ...rest] = orders
+
+-- Capturar tudo antes do último elemento
+[...start, last] = orders
+
+-- Capturar tudo exceto os elementos do meio
+[first, ..._, last] = orders
+```
+
+<YueDisplay>
+
+```yue
+-- Capturar tudo após o primeiro elemento
+[first, ...rest] = orders
+
+-- Capturar tudo antes do último elemento
+[...start, last] = orders
+
+-- Capturar tudo exceto os elementos do meio
+[first, ..._, last] = orders
+```
+
+</YueDisplay>
+
+## Desestruturação em outros lugares
+
+A desestruturação também pode aparecer em lugares onde uma atribuição ocorre implicitamente. Um exemplo disso é um loop for:
+
+```yuescript
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+<YueDisplay>
+
+```yue
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+</YueDisplay>
+
+Sabemos que cada elemento na tabela array é uma tupla de dois itens, então podemos desempacotá-lo diretamente na cláusula de nomes da instrução for usando desestruturação.
+
+# A cláusula Using; controlando atribuição destrutiva
+
+Embora o escopo léxico possa ser uma grande ajuda na redução da complexidade do código que escrevemos, as coisas podem ficar difíceis de gerenciar conforme o tamanho do código aumenta. Considere o seguinte trecho:
+
+```yuescript
+i = 100
+
+-- muitas linhas de código...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- vai imprimir 0
+```
+
+<YueDisplay>
+
+```yue
+i = 100
+
+-- muitas linhas de código...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- vai imprimir 0
+```
+
+</YueDisplay>
+
+Em my_func, sobrescrevemos o valor de i por engano. Neste exemplo é bem óbvio, mas considere uma base de código grande ou estrangeira onde não está claro quais nomes já foram declarados.
+
+Seria útil dizer quais variáveis do escopo envolvente pretendemos alterar, para evitar que alteremos outras por acidente.
+
+A palavra-chave using nos permite fazer isso. using nil garante que nenhuma variável fechada seja sobrescrita na atribuição. A cláusula using é colocada após a lista de argumentos em uma função, ou no lugar dela se não houver argumentos.
+
+```yuescript
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- uma nova variável local é criada aqui
+
+my_func!
+print i -- imprime 100, i não é afetado
+```
+
+<YueDisplay>
+
+```yue
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- uma nova variável local é criada aqui
+
+my_func!
+print i -- imprime 100, i não é afetado
+```
+
+</YueDisplay>
+
+Múltiplos nomes podem ser separados por vírgulas. Os valores do closure ainda podem ser acessados, apenas não podem ser modificados:
+
+```yuescript
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- uma nova variável local tmp é criada
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- estes foram atualizados
+```
+
+<YueDisplay>
+
+```yue
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- uma nova variável local tmp é criada
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- estes foram atualizados
+```
+
+</YueDisplay>
+
+# Uso
+
+## Módulo Lua
+
+Use o módulo YueScript em Lua:
+
+- **Caso 1**
+
+  Use require em "your_yuescript_entry.yue" no Lua.
+
+  ```Lua
+  require("yue")("your_yuescript_entry")
+  ```
+
+  E esse código continua funcionando quando você compila "your_yuescript_entry.yue" para "your_yuescript_entry.lua" no mesmo caminho. Nos demais arquivos YueScript, use normalmente o **require** ou **import**. Os números de linha nas mensagens de erro também serão tratados corretamente.
+
+- **Caso 2**
+
+  Requerer o módulo YueScript e reescrever a mensagem manualmente.
+
+  ```lua
+  local yue = require("yue")
+  yue.insert_loader()
+  local success, result = xpcall(function()
+    return require("yuescript_module_name")
+  end, function(err)
+    return yue.traceback(err)
+  end)
+  ```
+
+- **Caso 3**
+
+  Usar a função compiladora do YueScript em Lua.
+
+  ```lua
+  local yue = require("yue")
+  local codes, err, globals = yue.to_lua([[
+    f = ->
+      print "hello world"
+    f!
+  ]],{
+    implicit_return_root = true,
+    reserve_line_number = true,
+    lint_global = true,
+    space_over_tab = false,
+    options = {
+      target = "5.4",
+      path = "/script"
+    }
+  })
+  ```
+
+## Ferramenta YueScript
+
+Use a ferramenta YueScript com:
+
+```shell
+> yue -h
+Usage: yue
+       [options] [<file/directory>] ...
+       yue -e <code_or_file> [args...]
+       yue -w [<directory>] [options]
+       yue -
+
+Notas:
+   - '-' / '--' deve ser o primeiro e único argumento.
+   - '-o/--output' não pode ser usado com múltiplos arquivos de entrada.
+   - '-w/--watch' não pode ser usado com entrada de arquivo (apenas diretório).
+   - com '-e/--execute', os tokens restantes são tratados como argumentos do script.
+
+Opções:
+   -h, --help                 Mostrar esta mensagem de ajuda e sair.
+   -e <str>, --execute <str>  Executar um arquivo ou código bruto
+   -m, --minify               Gerar código minificado
+   -r, --rewrite              Reescrever saída para corresponder aos números de linha originais
+   -t <output_to>, --output-to <output_to>
+                              Especificar onde colocar os arquivos compilados
+   -o <file>, --output <file> Escrever saída em arquivo
+   -p, --print                Escrever saída na saída padrão
+   -b, --benchmark            Mostrar tempo de compilação (não grava saída)
+   -g, --globals              Listar variáveis globais usadas em NOME LINHA COLUNA
+   -s, --spaces               Usar espaços no código gerado em vez de tabulações
+   -l, --line-numbers         Escrever números de linha do código fonte
+   -j, --no-implicit-return   Desabilitar retorno implícito no final do arquivo
+   -c, --reserve-comments     Preservar comentários antes de instruções do código fonte
+   -w [<dir>], --watch [<dir>]
+                              Observar alterações e compilar cada arquivo no diretório
+   -v, --version              Imprimir versão
+   -                          Ler da entrada padrão, imprimir na saída padrão
+                              (Deve ser o primeiro e único argumento)
+   --                         Igual a '-' (mantido para compatibilidade retroativa)
+
+   --target <version>         Especificar a versão do Lua para a qual o código será gerado
+                              (a versão pode ser apenas 5.1 a 5.5)
+   --path <path_str>          Adicionar um caminho de busca Lua extra ao package.path
+   --<key>=<value>            Passar opção do compilador no formato key=value (comportamento existente)
+
+   Execute sem opções para entrar no REPL, digite o símbolo '$'
+   em uma única linha para iniciar/parar o modo multilinha
+```
+
+Casos de uso:
+
+Compilar recursivamente todos os arquivos YueScript com extensão **.yue** no caminho atual: **yue .**
+
+Compilar e salvar resultados em um caminho de destino: **yue -t /target/path/ .**
+
+Compilar e preservar informações de debug: **yue -l .**
+
+Compilar e gerar código minificado: **yue -m .**
+
+Executar código bruto: **yue -e 'print 123'**
+
+Executar um arquivo YueScript: **yue -e main.yue**
+
+# Introdução
+
+YueScript é uma linguagem dinâmica que compila para Lua. É um dialeto do [MoonScript](https://github.com/leafo/moonscript). O código escrito em YueScript é expressivo e extremamente conciso. É adequado para escrever lógica de aplicação variável com código mais manutenível e roda em ambientes Lua embutidos, como jogos ou servidores web.
+
+Yue (月) é o nome da lua em chinês e é pronunciado como [jyɛ].
+
+## Uma visão geral do YueScript
+
+```yuescript
+-- sintaxe de importação
+import p, to_lua from "yue"
+
+-- literais de objeto
+inventory =
+  equipment:
+    - "sword"
+    - "shield"
+  items:
+    - name: "potion"
+      count: 10
+    - name: "bread"
+      count: 3
+
+-- compreensão de lista
+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
+
+-- operador pipe
+[1, 2, 3]
+  |> map (x) -> x * 2
+  |> filter (x) -> x > 4
+  |> reduce 0, (a, b) -> a + b
+  |> print
+
+-- manipulação de metatable
+apple =
+  size: 15
+  <index>:
+    color: 0x00ffff
+
+with apple
+  p .size, .color, .<index> if .<>?
+
+-- sintaxe de exportação estilo js
+export 🌛 = "Script da Lua"
+```
+
+<YueDisplay>
+
+```yue
+-- sintaxe de importação
+import p, to_lua from "yue"
+
+-- literais de objeto
+inventory =
+  equipment:
+    - "sword"
+    - "shield"
+  items:
+    - name: "potion"
+      count: 10
+    - name: "bread"
+      count: 3
+
+-- compreensão de lista
+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
+
+-- operador pipe
+[1, 2, 3]
+  |> map (x) -> x * 2
+  |> filter (x) -> x > 4
+  |> reduce 0, (a, b) -> a + b
+  |> print
+
+-- manipulação de metatable
+apple =
+  size: 15
+  <index>:
+    color: 0x00ffff
+
+with apple
+  p .size, .color, .<index> if .<>?
+
+-- sintaxe de exportação estilo js
+export 🌛 = "Script da Lua"
+```
+
+</YueDisplay>
+
+## Sobre o Dora SSR
+
+O YueScript está sendo desenvolvido e mantido em conjunto com o motor de jogo open-source [Dora SSR](https://github.com/Dora-SSR/Dora-SSR). Tem sido usado para criar ferramentas do motor, demonstrações de jogos e protótipos, validando suas capacidades em cenários do mundo real e aprimorando a experiência de desenvolvimento do Dora SSR.
+
+# Instalação
+
+## Módulo Lua
+
+Instale o [luarocks](https://luarocks.org), um gerenciador de pacotes para módulos Lua. Em seguida, instale-o como módulo Lua e executável com:
+
+```shell
+luarocks install yuescript
+```
+
+Ou você pode compilar o arquivo `yue.so` com:
+
+```shell
+make shared LUAI=/usr/local/include/lua LUAL=/usr/local/lib/lua
+```
+
+Depois, obtenha o arquivo binário no caminho **bin/shared/yue.so**.
+
+## Compilar ferramenta binária
+
+Clone este repositório e compile e instale o executável com:
+
+```shell
+make install
+```
+
+Compilar a ferramenta YueScript sem o recurso de macro:
+
+```shell
+make install NO_MACRO=true
+```
+
+Compilar a ferramenta YueScript sem o binário Lua embutido:
+
+```shell
+make install NO_LUA=true
+```
+
+## Baixar binário pré-compilado
+
+Você pode baixar arquivos binários pré-compilados, incluindo executáveis compatíveis com diferentes versões do Lua e arquivos de biblioteca.
+
+Baixe os arquivos binários pré-compilados [aqui](https://github.com/IppClub/YueScript/releases).
+
+# Condicionais
+
+```yuescript
+have_coins = false
+if have_coins
+  print "Tem moedas"
+else
+  print "Sem moedas"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins
+  print "Tem moedas"
+else
+  print "Sem moedas"
+```
+
+</YueDisplay>
+
+Uma sintaxe curta para instruções únicas também pode ser usada:
+
+```yuescript
+have_coins = false
+if have_coins then print "Tem moedas" else print "Sem moedas"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins then print "Tem moedas" else print "Sem moedas"
+```
+
+</YueDisplay>
+
+Como instruções if podem ser usadas como expressões, isso também pode ser escrito como:
+
+```yuescript
+have_coins = false
+print if have_coins then "Tem moedas" else "Sem moedas"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+print if have_coins then "Tem moedas" else "Sem moedas"
+```
+
+</YueDisplay>
+
+Condicionais também podem ser usados em instruções de retorno e atribuições:
+
+```yuescript
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "Sou muito alto"
+else
+  "Não sou tão alto"
+
+print message -- imprime: Sou muito alto
+```
+
+<YueDisplay>
+
+```yue
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "Sou muito alto"
+else
+  "Não sou tão alto"
+
+print message -- imprime: Sou muito alto
+```
+
+</YueDisplay>
+
+O oposto de if é unless:
+
+```yuescript
+unless os.date("%A") == "Monday"
+  print "não é segunda-feira!"
+```
+
+<YueDisplay>
+
+```yue
+unless os.date("%A") == "Monday"
+  print "não é segunda-feira!"
+```
+
+</YueDisplay>
+
+```yuescript
+print "Você tem sorte!" unless math.random! > 0.1
+```
+
+<YueDisplay>
+
+```yue
+print "Você tem sorte!" unless math.random! > 0.1
+```
+
+</YueDisplay>
+
+## Em expressão
+
+Você pode escrever código de verificação de intervalo com uma `in-expression`.
+
+```yuescript
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "verificando igualdade com valores discretos"
+
+if a in list
+  print "verificando se `a` está na lista"
+```
+
+<YueDisplay>
+
+```yue
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "verificando igualdade com valores discretos"
+
+if a in list
+  print "verificando se `a` está na lista"
+```
+
+</YueDisplay>
+
+# Loop For
+
+Existem duas formas de loop for, assim como no Lua. Uma numérica e uma genérica:
+
+```yuescript
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- um passo opcional fornecido
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+
+<YueDisplay>
+
+```yue
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- um passo opcional fornecido
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+
+</YueDisplay>
+
+Os operadores de slicing e **\*** podem ser usados, assim como com compreensões:
+
+```yuescript
+for item in *items[2, 4]
+  print item
+```
+
+<YueDisplay>
+
+```yue
+for item in *items[2, 4]
+  print item
+```
+
+</YueDisplay>
+
+Uma sintaxe mais curta também está disponível para todas as variações quando o corpo é apenas uma linha:
+
+```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>
+
+Um loop for também pode ser usado como expressão. A última instrução no corpo do loop for é convertida em expressão e anexada a uma tabela array acumuladora.
+
+Dobrando cada número par:
+
+```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>
+
+Além disso, os loops for suportam break com valores de retorno, permitindo que o próprio loop seja usado como expressão que sai antecipadamente com um resultado significativo. Expressões `for` suportam `break` com múltiplos valores.
+
+Por exemplo, para encontrar o primeiro número maior que 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>
+
+Esta sintaxe de break-com-valor permite padrões concisos e expressivos de busca ou saída antecipada diretamente em expressões de loop.
+
+```yuescript
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+<YueDisplay>
+
+```yue
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+</YueDisplay>
+
+Você também pode filtrar valores combinando a expressão do loop for com a instrução continue.
+
+Loops for no final do corpo de uma função não são acumulados em uma tabela para valor de retorno (em vez disso, a função retornará nil). Uma instrução return explícita pode ser usada, ou o loop pode ser convertido em compreensão de lista.
+
+```yuescript
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- imprime nil
+print func_b! -- imprime objeto table
+```
+
+<YueDisplay>
+
+```yue
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- imprime nil
+print func_b! -- imprime objeto table
+```
+
+</YueDisplay>
+
+Isso é feito para evitar a criação desnecessária de tabelas para funções que não precisam retornar os resultados do loop.
+
+# Continue
+
+Uma instrução continue pode ser usada para pular a iteração atual em um 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 também pode ser usado com expressões de loop para impedir que essa iteração seja acumulada no resultado. Este exemplo filtra a tabela array para apenas números pares:
+
+```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>
+
+# Switch
+
+A instrução switch é uma forma abreviada de escrever uma série de instruções if que verificam o mesmo valor. Observe que o valor é avaliado apenas uma vez. Como as instruções if, os switches podem ter um bloco else para tratar ausência de correspondências. A comparação é feita com o operador ==. Na instrução switch, você também pode usar expressão de atribuição para armazenar valor de variável temporária.
+
+```yuescript
+switch name := "Dan"
+  when "Robert"
+    print "Você é Robert"
+  when "Dan", "Daniel"
+    print "Seu nome é Dan"
+  else
+    print "Não sei quem você é com o nome #{name}"
+```
+
+<YueDisplay>
+
+```yue
+switch name := "Dan"
+  when "Robert"
+    print "Você é Robert"
+  when "Dan", "Daniel"
+    print "Seu nome é Dan"
+  else
+    print "Não sei quem você é com o nome #{name}"
+```
+
+</YueDisplay>
+
+Uma cláusula when de um switch pode corresponder a múltiplos valores listando-os separados por vírgula.
+
+Os switches também podem ser usados como expressões; aqui podemos atribuir o resultado do switch a uma variável:
+
+```yuescript
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "não consigo contar tão alto!"
+```
+
+<YueDisplay>
+
+```yue
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "não consigo contar tão alto!"
+```
+
+</YueDisplay>
+
+Podemos usar a palavra-chave then para escrever o bloco when de um switch em uma única linha. Nenhuma palavra-chave extra é necessária para escrever o bloco else em uma única linha.
+
+```yuescript
+msg = switch math.random(1, 5)
+  when 1 then "você tem sorte"
+  when 2 then "você quase tem sorte"
+  else "não tão sortudo"
+```
+
+<YueDisplay>
+
+```yue
+msg = switch math.random(1, 5)
+  when 1 then "você tem sorte"
+  when 2 then "você quase tem sorte"
+  else "não tão sortudo"
+```
+
+</YueDisplay>
+
+Se você quiser escrever código com uma indentação a menos ao escrever uma instrução switch, pode colocar a primeira cláusula when na linha de início da instrução, e então todas as outras cláusulas podem ser escritas com uma indentação a menos.
+
+```yuescript
+switch math.random(1, 5)
+  when 1
+    print "você tem sorte" -- duas indentações
+  else
+    print "não tão sortudo"
+
+switch math.random(1, 5) when 1
+  print "você tem sorte" -- uma indentação
+else
+  print "não tão sortudo"
+```
+
+<YueDisplay>
+
+```yue
+switch math.random(1, 5)
+  when 1
+    print "você tem sorte" -- duas indentações
+  else
+    print "não tão sortudo"
+
+switch math.random(1, 5) when 1
+  print "você tem sorte" -- uma indentação
+else
+  print "não tão sortudo"
+```
+
+</YueDisplay>
+
+Vale notar a ordem da expressão de comparação do case. A expressão do case está no lado esquerdo. Isso pode ser útil se a expressão do case quiser sobrescrever como a comparação é feita definindo um metamétodo eq.
+
+## Correspondência de tabela
+
+Você pode fazer correspondência de tabela em uma cláusula when de switch, se a tabela puder ser desestruturada por uma estrutura específica e obter valores não-nil.
+
+```yuescript
+items =
+  * x: 100
+    y: 200
+  * width: 300
+    height: 400
+
+for item in *items
+  switch item
+    when :x, :y
+      print "Vec2 #{x}, #{y}"
+    when :width, :height
+      print "tamanho #{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 "tamanho #{width}, #{height}"
+```
+
+</YueDisplay>
+
+Você pode usar valores padrão para opcionalmente desestruturar a tabela para alguns campos.
+
+```yuescript
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- obtém erro: attempt to index a nil value (field 'pos')
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- a desestruturação de tabela ainda passará
+```
+
+<YueDisplay>
+
+```yue
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- obtém erro: attempt to index a nil value (field 'pos')
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- a desestruturação de tabela ainda passará
+```
+
+</YueDisplay>
+
+Você também pode corresponder contra elementos de array, campos de tabela, e até estruturas aninhadas com literais de array ou tabela.
+
+Corresponder contra elementos de array.
+
+```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 tem valor padrão
+    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 tem valor padrão
+    print "1, 2, #{b}"
+```
+
+</YueDisplay>
+
+Corresponder contra campos de tabela com desestruturação.
+
+```yuescript
+switch tb
+  when success: true, :result
+    print "sucesso", result
+  when success: false
+    print "falhou", result
+  else
+    print "inválido"
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when success: true, :result
+    print "sucesso", result
+  when success: false
+    print "falhou", result
+  else
+    print "inválido"
+```
+
+</YueDisplay>
+
+Corresponder contra estruturas de tabela aninhadas.
+
+```yuescript
+switch tb
+  when data: {type: "success", :content}
+    print "sucesso", content
+  when data: {type: "error", :content}
+    print "erro", content
+  else
+    print "inválido"
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when data: {type: "success", :content}
+    print "sucesso", content
+  when data: {type: "error", :content}
+    print "erro", content
+  else
+    print "inválido"
+```
+
+</YueDisplay>
+
+Corresponder contra array de tabelas.
+
+```yuescript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "correspondido", fourth
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "correspondido", fourth
+```
+
+</YueDisplay>
+
+Corresponder contra uma lista e capturar um intervalo de elementos.
+
+```yuescript
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Grupo:", groups -- imprime: {"admin", "users"}
+    print "Recurso:", resource -- imprime: "logs"
+    print "Ação:", action -- imprime: "view"
+```
+
+<YueDisplay>
+
+```yue
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Grupo:", groups -- imprime: {"admin", "users"}
+    print "Recurso:", resource -- imprime: "logs"
+    print "Ação:", action -- imprime: "view"
+```
+
+</YueDisplay>
+
+# Loop While
+
+O loop while também vem em quatro variações:
+
+```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>
+
+Como os loops for, o loop while também pode ser usado como expressão. Expressões `while` e `until` suportam `break` com múltiplos valores.
+
+```yuescript
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+<YueDisplay>
+
+```yue
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+</YueDisplay>
+
+Além disso, para uma função retornar o valor acumulado de um loop while, a instrução deve ser explicitamente retornada.
+
+## Loop Repeat
+
+O loop repeat vem do 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>
+
+Expressões `repeat` também suportam `break` com múltiplos valores:
+
+```yuescript
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+<YueDisplay>
+
+```yue
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+</YueDisplay>
+
+# Stubs de função
+
+É comum passar uma função de um objeto como valor, por exemplo, passando um método de instância para uma função como callback. Se a função espera o objeto em que está operando como primeiro argumento, então você deve de alguma forma empacotar esse objeto com a função para que ela possa ser chamada corretamente.
+
+A sintaxe de function stub é uma forma abreviada de criar uma nova função closure que empacota tanto o objeto quanto a função. Esta nova função chama a função empacotada no contexto correto do objeto.
+
+Sua sintaxe é a mesma que chamar um método de instância com o operador \, mas sem lista de argumentos fornecida.
+
+```yuescript
+my_object = {
+  value: 1000
+  write: => print "the value:", @value
+}
+
+run_callback = (func) ->
+  print "running callback..."
+  func!
+
+-- isso não funcionará:
+-- a função não tem referência a my_object
+run_callback my_object.write
+
+-- sintaxe de function stub
+-- nos permite empacotar o objeto em uma nova função
+run_callback my_object\write
+```
+
+<YueDisplay>
+
+```yue
+my_object = {
+  value: 1000
+  write: => print "the value:", @value
+}
+
+run_callback = (func) ->
+  print "running callback..."
+  func!
+
+-- isso não funcionará:
+-- a função não tem referência a my_object
+run_callback my_object.write
+
+-- sintaxe de function stub
+-- nos permite empacotar o objeto em uma nova função
+run_callback my_object\write
+```
+
+</YueDisplay>
+
+# Backcalls
+
+Backcalls são usados para desaninhar callbacks. Eles são definidos usando setas apontando para a esquerda como o último parâmetro, preenchendo por padrão uma chamada de função. Toda a sintaxe é basicamente a mesma das funções seta regulares, exceto que apenas aponta para o outro lado e o corpo da função não requer indentação.
+
+```yuescript
+x <- f
+print "hello" .. x
+```
+
+<YueDisplay>
+
+```yue
+x <- f
+print "hello" .. x
+```
+
+</YueDisplay>
+
+Funções seta "fat" também estão disponíveis.
+
+```yuescript
+<= f
+print @value
+```
+
+<YueDisplay>
+
+```yue
+<= f
+print @value
+```
+
+</YueDisplay>
+
+Você pode especificar um placeholder para onde deseja que a função backcall vá como parâmetro.
+
+```yuescript
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+<YueDisplay>
+
+```yue
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+</YueDisplay>
+
+Se você desejar ter mais código após seus backcalls, pode colocá-los em uma instrução do. E os parênteses podem ser omitidos com funções seta não-fat.
+
+```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>
+
+# Literais de função
+
+Todas as funções são criadas usando uma expressão de função. Uma função simples é denotada usando a seta: **->**.
+
+```yuescript
+my_function = ->
+my_function() -- chama a função vazia
+```
+
+<YueDisplay>
+
+```yue
+my_function = ->
+my_function() -- chama a função vazia
+```
+
+</YueDisplay>
+
+O corpo da função pode ser uma instrução colocada diretamente após a seta, ou pode ser uma série de instruções indentadas nas linhas seguintes:
+
+```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>
+
+Se uma função não tem argumentos, ela pode ser chamada usando o operador !, em vez de parênteses vazios. A invocação ! é a forma preferida de chamar funções sem argumentos.
+
+```yuescript
+func_a!
+func_b()
+```
+
+<YueDisplay>
+
+```yue
+func_a!
+func_b()
+```
+
+</YueDisplay>
+
+Funções com argumentos podem ser criadas precedendo a seta com uma lista de nomes de argumentos entre parênteses:
+
+```yuescript
+sum = (x, y) -> print "sum", x + y
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> print "sum", x + y
+```
+
+</YueDisplay>
+
+Funções podem ser chamadas listando os argumentos após o nome de uma expressão que avalia para uma função. Ao encadear chamadas de função, os argumentos são aplicados à função mais próxima à esquerda.
+
+```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>
+
+Para evitar ambiguidade ao chamar funções, parênteses também podem ser usados para envolver os argumentos. Isso é necessário aqui para garantir que os argumentos certos sejam enviados às funções certas.
+
+```yuescript
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+<YueDisplay>
+
+```yue
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+</YueDisplay>
+
+Não deve haver espaço entre o parêntese de abertura e a função.
+
+As funções convertem a última instrução em seu corpo em uma instrução de retorno, isso é chamado de retorno implícito:
+
+```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>
+
+E se você precisar retornar explicitamente, pode usar a palavra-chave return:
+
+```yuescript
+sum = (x, y) -> return x + y
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> return x + y
+```
+
+</YueDisplay>
+
+Assim como no Lua, as funções podem retornar múltiplos valores. A última instrução deve ser uma lista de valores separados por vírgulas:
+
+```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>
+
+## Setas fat
+
+Como é um idioma em Lua enviar um objeto como primeiro argumento ao chamar um método, uma sintaxe especial é fornecida para criar funções que incluem automaticamente um argumento self.
+
+```yuescript
+func = (num) => @value + num
+```
+
+<YueDisplay>
+
+```yue
+func = (num) => @value + num
+```
+
+</YueDisplay>
+
+## Valores padrão de argumentos
+
+É possível fornecer valores padrão para os argumentos de uma função. Um argumento é determinado como vazio se seu valor for nil. Qualquer argumento nil que tenha valor padrão será substituído antes da execução do corpo da função.
+
+```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>
+
+Uma expressão de valor padrão de argumento é avaliada no corpo da função na ordem das declarações de argumentos. Por esse motivo, os valores padrão têm acesso aos argumentos declarados anteriormente.
+
+```yuescript
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+<YueDisplay>
+
+```yue
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+</YueDisplay>
+
+## Considerações
+
+Devido à forma expressiva de chamar funções sem parênteses, algumas restrições devem ser colocadas para evitar ambiguidade de análise envolvendo espaço em branco.
+
+O sinal de menos desempenha dois papéis: um operador de negação unário e um operador de subtração binário. Considere como os seguintes exemplos compilam:
+
+```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>
+
+A precedência do primeiro argumento de uma chamada de função pode ser controlada usando espaço em branco se o argumento for um literal de string. Em Lua, é comum omitir parênteses ao chamar uma função com uma única string ou literal de tabela.
+
+Quando não há espaço entre uma variável e um literal de string, a chamada de função tem precedência sobre quaisquer expressões seguintes. Nenhum outro argumento pode ser passado para a função quando ela é chamada dessa forma.
+
+Quando há um espaço após uma variável e um literal de string, a chamada de função age como mostrado acima. O literal de string pertence a quaisquer expressões seguintes (se existirem), que servem como lista de argumentos.
+
+```yuescript
+x = func"hello" + 100
+y = func "hello" + 100
+```
+
+<YueDisplay>
+
+```yue
+x = func"hello" + 100
+y = func "hello" + 100
+```
+
+</YueDisplay>
+
+## Argumentos multilinha
+
+Ao chamar funções que recebem um grande número de argumentos, é conveniente dividir a lista de argumentos em várias linhas. Devido à natureza sensível a espaço em branco da linguagem, deve-se ter cuidado ao dividir a lista de argumentos.
+
+Se uma lista de argumentos for continuada na próxima linha, a linha atual deve terminar em vírgula. E a linha seguinte deve estar mais indentada que a indentação atual. Uma vez indentada, todas as outras linhas de argumentos devem estar no mesmo nível de indentação para fazer parte da lista de argumentos.
+
+```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>
+
+Este tipo de invocação pode ser aninhado. O nível de indentação é usado para determinar a qual função os argumentos pertencem.
+
+```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>
+
+Como as tabelas também usam vírgula como delimitador, esta sintaxe de indentação ajuda a deixar os valores fazerem parte da lista de argumentos em vez de fazerem parte da tabela.
+
+```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>
+
+Embora incomum, observe como podemos dar uma indentação mais profunda para argumentos de função se soubermos que usaremos uma indentação menor mais adiante.
+
+```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>
+
+A mesma coisa pode ser feita com outras instruções em nível de bloco como condicionais. Podemos usar o nível de indentação para determinar a qual instrução um valor pertence:
+
+```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>
+
+## Desestruturação de parâmetros
+
+YueScript agora suporta desestruturação de parâmetros de função quando o argumento é um objeto. Duas formas de literais de tabela de desestruturação estão disponíveis:
+
+- **Literais/parâmetros de objeto envolvidos em chaves**, permitindo valores padrão opcionais quando os campos estão ausentes (ex.: `{:a, :b}`, `{a: a1 = 123}`).
+
+- **Sintaxe de tabela simples não envolvida**, começando com uma sequência de ligações chave-valor ou abreviadas e continuando até outra expressão terminá-la (ex.: `:a, b: b1, :c`). Esta forma extrai múltiplos campos do mesmo objeto.
+
+```yuescript
+f1 = (:a, :b, :c) ->
+  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>
+
+## Expressão de retorno prefixada
+
+Ao trabalhar com corpos de função profundamente aninhados, pode ser tedioso manter a legibilidade e consistência do valor de retorno. Para resolver isso, YueScript introduz a sintaxe **Expressão de Retorno Prefixada**. Sua forma é a seguinte:
+
+```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>
+
+Isso é equivalente a:
+
+```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>
+
+A única diferença é que você pode mover a expressão de retorno final antes do token `->` ou `=>` para indicar o valor de retorno implícito da função como última instrução. Dessa forma, mesmo em funções com múltiplos loops aninhados ou ramificações condicionais, você não precisa mais escrever uma expressão de retorno no final do corpo da função, tornando a estrutura lógica mais direta e fácil de seguir.
+
+## Varargs nomeados
+
+Você pode usar a sintaxe `(...t) ->` para armazenar automaticamente varargs em uma tabela nomeada. Esta tabela conterá todos os argumentos passados (incluindo valores `nil`), e o campo `n` da tabela armazenará o número real de argumentos passados (incluindo valores `nil`).
+
+```yuescript
+f = (...t) ->
+  print "contagem de argumentos:", t.n
+  print "comprimento da tabela:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- Tratando casos com valores nil
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+
+<YueDisplay>
+
+```yue
+f = (...t) ->
+  print "contagem de argumentos:", t.n
+  print "comprimento da tabela:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- Tratando casos com valores nil
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+
+</YueDisplay>
+
+# Espaço em branco
+
+YueScript é uma linguagem sensível a espaço em branco. Você precisa escrever blocos de código na mesma indentação com espaço **' '** ou tabulação **'\t'**, como corpo de função, lista de valores e alguns blocos de controle. E expressões contendo diferentes espaços em branco podem significar coisas diferentes. Tabulação é tratada como 4 espaços, mas é melhor não misturar o uso de espaços e tabulações.
+
+## Separador de instrução
+
+Uma instrução normalmente termina em uma quebra de linha. Você também pode usar ponto e vírgula `;` para terminar explicitamente uma instrução, o que permite escrever múltiplas instruções na mesma linha:
+
+```yuescript
+a = 1; b = 2; print a + b
+```
+
+<YueDisplay>
+
+```yue
+a = 1; b = 2; print a + b
+```
+
+</YueDisplay>
+
+## Encadeamento multilinha
+
+Você pode escrever chamadas de função encadeadas em múltiplas linhas com a mesma indentação.
+
+```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>
+
+# Comentário
+
+```yuescript
+-- Eu sou um comentário
+
+str = --[[
+Este é um comentário multilinha.
+Está OK.
+]] strA \ -- comentário 1
+  .. strB \ -- comentário 2
+  .. strC
+
+func --[[port]] 3000, --[[ip]] "192.168.1.1"
+```
+
+<YueDisplay>
+
+```yue
+-- Eu sou um comentário
+
+str = --[[
+Este é um comentário multilinha.
+Está OK.
+]] strA \ -- comentário 1
+  .. strB \ -- comentário 2
+  .. strC
+
+func --[[port]] 3000, --[[ip]] "192.168.1.1"
+```
+
+</YueDisplay>
+
+# Atributos
+
+Suporte de sintaxe para atributos do Lua 5.4. E você ainda pode usar tanto a declaração `const` quanto `close` e obter verificação de constante e callback com escopo funcionando ao direcionar para versões do Lua abaixo da 5.4.
+
+```yuescript
+const a = 123
+close _ = <close>: -> print "Fora do escopo."
+```
+
+<YueDisplay>
+
+```yue
+const a = 123
+close _ = <close>: -> print "Fora do escopo."
+```
+
+</YueDisplay>
+
+Você pode fazer desestruturação com variáveis atribuídas como constante.
+
+```yuescript
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+<YueDisplay>
+
+```yue
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+</YueDisplay>
+
+Você também pode declarar uma variável global como `const`.
+
+```yuescript
+global const Constant = 123
+-- Constant = 1
+```
+
+<YueDisplay>
+
+```yue
+global const Constant = 123
+-- Constant = 1
+```
+
+</YueDisplay>
+
+# Operador
+
+Todos os operadores binários e unários do Lua estão disponíveis. Além disso, **!=** é um alias para **~=**, e **\\** ou **::** podem ser usados para escrever uma chamada de função encadeada como `tb\func!` ou `tb::func!`. E o YueScript oferece alguns outros operadores especiais para escrever códigos mais expressivos.
+
+```yuescript
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+<YueDisplay>
+
+```yue
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+</YueDisplay>
+
+## Comparações encadeadas
+
+Comparações podem ser encadeadas arbitrariamente:
+
+```yuescript
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- saída: true
+
+a = 5
+print 1 <= a <= 10
+-- saída: true
+```
+
+<YueDisplay>
+
+```yue
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- saída: true
+
+a = 5
+print 1 <= a <= 10
+-- saída: true
+```
+
+</YueDisplay>
+
+Observe o comportamento de avaliação das comparações encadeadas:
+
+```yuescript
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  saída:
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  saída:
+  2
+  1
+  false
+]]
+```
+
+<YueDisplay>
+
+```yue
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  saída:
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  saída:
+  2
+  1
+  false
+]]
+```
+
+</YueDisplay>
+
+A expressão do meio é avaliada apenas uma vez, em vez de duas vezes como seria se a expressão fosse escrita como `v(1) < v(2) and v(2) <= v(3)`. No entanto, a ordem das avaliações em uma comparação encadeada é indefinida. É fortemente recomendado não usar expressões com efeitos colaterais (como impressão) em comparações encadeadas. Se efeitos colaterais forem necessários, o operador de curto-circuito `and` deve ser usado explicitamente.
+
+## Anexar à tabela
+
+O operador **[] =** é usado para anexar valores a tabelas.
+
+```yuescript
+tab = []
+tab[] = "Value"
+```
+
+<YueDisplay>
+
+```yue
+tab = []
+tab[] = "Value"
+```
+
+</YueDisplay>
+
+Você também pode usar o operador spread `...` para anexar todos os elementos de uma lista a outra:
+
+```yuescript
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA agora é [1, 2, 3, 4, 5, 6]
+```
+
+<YueDisplay>
+
+```yue
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA agora é [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+## Spread de tabela
+
+Você pode concatenar tabelas de array ou tabelas hash usando o operador spread `...` antes de expressões em literais de tabela.
+
+```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>
+
+## Indexação reversa de tabela
+
+Você pode usar o operador **#** para obter os últimos elementos de uma tabela.
+
+```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
+
+O operador **<>** pode ser usado como atalho para manipulação de metatable.
+
+### Criação de metatable
+
+Crie tabela normal com chaves vazias **<>** ou chave de metamétodo cercada por **<>**.
+
+```yuescript
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+ -- definir campo com variável de mesmo nome
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "fora do escopo"
+```
+
+<YueDisplay>
+
+```yue
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+ -- definir campo com variável de mesmo nome
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "fora do escopo"
+```
+
+</YueDisplay>
+
+### Acesso à metatable
+
+Acesse a metatable com **<>** ou nome do metamétodo cercado por **<>** ou escrevendo alguma expressão em **<>**.
+
+```yuescript
+-- criar com metatable contendo campo "value"
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+
+<YueDisplay>
+
+```yue
+-- criar com metatable contendo campo "value"
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+
+</YueDisplay>
+
+### Desestruturação de metatable
+
+Desestruture a metatable com chave de metamétodo cercada por **<>**.
+
+```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>
+
+## Existência
+
+O operador **?** pode ser usado em diversos contextos para verificar existência.
+
+```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>
+
+## Pipe
+
+Em vez de uma série de chamadas de função aninhadas, você pode encaminhar valores com o operador **|>**.
+
+```yuescript
+"hello" |> print
+1 |> print 2 -- insere o item do pipe como primeiro argumento
+2 |> print 1, _, 3 -- pipe com um placeholder
+
+-- expressão pipe em multilinha
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+<YueDisplay>
+
+```yue
+"hello" |> print
+1 |> print 2 -- insere o item do pipe como primeiro argumento
+2 |> print 1, _, 3 -- pipe com um placeholder
+-- expressão pipe em multilinha
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+</YueDisplay>
+
+## Coalescência de nil
+
+O operador de coalescência de nil **??** retorna o valor do operando esquerdo se não for **nil**; caso contrário, avalia o operando direito e retorna seu resultado. O operador **??** não avalia seu operando direito se o operando esquerdo avaliar para não-nil.
+
+```yuescript
+local a, b, c, d
+a = b ?? c ?? d
+func a ?? {}
+
+a ??= false
+```
+
+<YueDisplay>
+
+```yue
+local a, b, c, d
+a = b ?? c ?? d
+func a ?? {}
+a ??= false
+```
+
+</YueDisplay>
+
+## Objeto implícito
+
+Você pode escrever uma lista de estruturas implícitas que começa com o símbolo **\*** ou **-** dentro de um bloco de tabela. Se você está criando objeto implícito, os campos do objeto devem estar com a mesma indentação.
+
+```yuescript
+-- atribuição com objeto implícito
+list =
+  * 1
+  * 2
+  * 3
+
+-- chamada de função com objeto implícito
+func
+  * 1
+  * 2
+  * 3
+
+-- retorno com objeto implícito
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- tabela com objeto implícito
+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
+-- atribuição com objeto implícito
+list =
+  * 1
+  * 2
+  * 3
+
+-- chamada de função com objeto implícito
+func
+  * 1
+  * 2
+  * 3
+
+-- retorno com objeto implícito
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- tabela com objeto implícito
+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>
+
+# Literais
+
+Todos os literais primitivos do Lua podem ser usados. Isso se aplica a números, strings, booleanos e **nil**.
+
+Diferente do Lua, quebras de linha são permitidas dentro de strings com aspas simples e duplas sem sequência de escape:
+
+```yuescript
+some_string = "Aqui está uma string
+  que tem uma quebra de linha."
+
+-- Você pode misturar expressões em literais de string usando a sintaxe #{}.
+-- Interpolação de string está disponível apenas em strings com aspas duplas.
+print "Tenho #{math.random! * 100}% de certeza."
+```
+
+<YueDisplay>
+
+```yue
+some_string = "Aqui está uma string
+  que tem uma quebra de linha."
+
+-- Você pode misturar expressões em literais de string usando a sintaxe #{}.
+-- Interpolação de string está disponível apenas em strings com aspas duplas.
+print "Tenho #{math.random! * 100}% de certeza."
+```
+
+</YueDisplay>
+
+## Literais numéricos
+
+Você pode usar underscores em um literal numérico para aumentar a legibilidade.
+
+```yuescript
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+
+<YueDisplay>
+
+```yue
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+
+</YueDisplay>
+
+## String multilinha estilo YAML
+
+O prefixo `|` introduz um literal de string multilinha no estilo YAML:
+
+```yuescript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+<YueDisplay>
+
+```yue
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+</YueDisplay>
+
+Isso permite escrever texto estruturado multilinha convenientemente. Todas as quebras de linha e indentação são preservadas em relação à primeira linha não vazia, e expressões dentro de `#{...}` são interpoladas automaticamente como `tostring(expr)`.
+
+A string multilinha YAML detecta automaticamente o prefixo comum de espaço em branco à esquerda (indentação mínima em todas as linhas não vazias) e remove-o de todas as linhas. Isso facilita a indentação visual do seu código sem afetar o conteúdo da string resultante.
+
+```yuescript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+<YueDisplay>
+
+```yue
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+</YueDisplay>
+
+A indentação interna é preservada em relação ao prefixo comum removido, permitindo estruturas aninhadas limpas.
+
+Todos os caracteres especiais como aspas (`"`) e barras invertidas (`\`) no bloco YAML Multiline são escapados automaticamente para que a string Lua gerada seja sintaticamente válida e se comporte como esperado.
+
+```yuescript
+str = |
+  path: "C:\Program Files\App"
+  note: 'Ele disse: "#{Hello}!"'
+```
+
+<YueDisplay>
+
+```yue
+str = |
+  path: "C:\Program Files\App"
+  note: 'Ele disse: "#{Hello}!"'
+```
+
+</YueDisplay>
+
+# Módulo
+
+## Import
+
+A instrução import é um açúcar sintático para requerer um módulo ou ajudar a extrair itens de um módulo importado. Os itens importados são const por padrão.
+
+```yuescript
+-- usado como desestruturação de tabela
+do
+  import insert, concat from table
+  -- reporta erro ao atribuir a insert, concat
+  import C, Ct, Cmt from require "lpeg"
+  -- atalho para require implícito
+  import x, y, z from 'mymodule'
+  -- import com estilo Python
+  from 'module' import a, b, c
+
+-- atalho para requerer um módulo
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- requerer módulo com aliasing ou desestruturação de tabela
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+<YueDisplay>
+
+```yue
+-- usado como desestruturação de tabela
+do
+  import insert, concat from table
+  -- reporta erro ao atribuir a insert, concat
+  import C, Ct, Cmt from require "lpeg"
+  -- atalho para require implícito
+  import x, y, z from 'mymodule'
+  -- import com estilo Python
+  from 'module' import a, b, c
+
+-- atalho para requerer um módulo
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- requerer módulo com aliasing ou desestruturação de tabela
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+</YueDisplay>
+
+## Import Global
+
+Você pode importar globais específicos para variáveis locais com `import`. Ao importar uma cadeia de acessos a variáveis globais, o último campo será atribuído à variável local.
+
+```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>
+
+### Importação automática de variável global
+
+Você pode colocar `import global` no topo de um bloco para importar automaticamente todos os nomes que não foram explicitamente declarados ou atribuídos no escopo atual como globais. Essas importações implícitas são tratadas como consts locais que referenciam os globais correspondentes na posição da instrução.
+
+Nomes que foram explicitamente declarados como globais no mesmo escopo não serão importados, então você ainda pode atribuir a eles.
+
+```yuescript
+do
+  import global
+  print "hello"
+  math.random 3
+  -- print = nil -- erro: globais importados são const
+
+do
+  -- variável global explícita não será importada
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+
+<YueDisplay>
+
+```yue
+do
+  import global
+  print "hello"
+  math.random 3
+  -- print = nil -- erro: globais importados são const
+
+do
+  -- variável global explícita não será importada
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+
+</YueDisplay>
+
+## Export
+
+A instrução export oferece uma forma concisa de definir módulos.
+
+### Export nomeado
+
+Export nomeado definirá uma variável local e também adicionará um campo na tabela exportada.
+
+```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>
+
+Fazendo export nomeado com desestruturação.
+
+```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>
+
+Exportar itens nomeados do módulo sem criar variáveis locais.
+
+```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>
+
+### Export sem nome
+
+Export sem nome adicionará o item alvo na parte array da tabela exportada.
+
+```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>
+
+### Export padrão
+
+Usar a palavra-chave **default** na instrução export para substituir a tabela exportada por qualquer coisa.
+
+```yuescript
+export default ->
+  print "hello"
+  123
+```
+
+<YueDisplay>
+
+```yue
+export default ->
+  print "hello"
+  123
+```
+
+</YueDisplay>
+
+# Licença: MIT
+
+Copyright (c) 2017-2026 Li Jin \<dragon-fly@qq.com\>
+
+A permissão é concedida, gratuitamente, a qualquer pessoa que obtenha uma cópia
+deste software e dos arquivos de documentação associados (o "Software"), para negociar
+o Software sem restrições, incluindo, sem limitação, os direitos de usar, copiar,
+modificar, mesclar, publicar, distribuir, sublicenciar e/ou vender
+cópias do Software, e permitir que pessoas a quem o Software seja fornecido o façam,
+sujeito às seguintes condições:
+
+O aviso de direitos autorais acima e este aviso de permissão devem ser incluídos em todas as
+cópias ou partes substanciais do Software.
+
+O SOFTWARE É FORNECIDO "NO ESTADO EM QUE SE ENCONTRA", SEM GARANTIA DE QUALQUER TIPO,
+EXPRESSA OU IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO ÀS GARANTIAS DE COMERCIALIZAÇÃO,
+ADEQUAÇÃO A UM DETERMINADO FIM E NÃO VIOLAÇÃO. EM NENHUMA HIPÓTESE OS AUTORES OU
+DETENTORES DOS DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUAISQUER REIVINDICAÇÕES,
+DANOS OU OUTRAS RESPONSABILIDADES, SEJA EM UMA AÇÃO DE CONTRATO, ATO ILÍCITO OU OUTRA,
+DECORRENTES DE, FORA DE OU RELACIONADAS COM O SOFTWARE OU O USO OU OUTRAS NEGOCIAÇÕES
+NO SOFTWARE.
+
+# A biblioteca YueScript
+
+Acesse com `local yue = require("yue")` no Lua.
+
+## yue
+
+**Descrição:**
+
+A biblioteca da linguagem YueScript.
+
+### version
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+A versão do YueScript.
+
+**Assinatura:**
+
+```lua
+version: string
+```
+
+### dirsep
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+O separador de arquivos da plataforma atual.
+
+**Assinatura:**
+
+```lua
+dirsep: string
+```
+
+### yue_compiled
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+O cache de código de módulo compilado.
+
+**Assinatura:**
+
+```lua
+yue_compiled: {string: string}
+```
+
+### to_lua
+
+**Tipo:** Função.
+
+**Descrição:**
+
+A função de compilação do YueScript. Compila o código YueScript para código Lua.
+
+**Assinatura:**
+
+```lua
+to_lua: function(code: string, config?: Config):
+    --[[codes]] string | nil,
+    --[[error]] string | nil,
+    --[[globals]] {{string, integer, integer}} | nil
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| code      | string | O código YueScript.                 |
+| config    | Config | [Opcional] As opções do compilador. |
+
+**Retorna:**
+
+| Tipo de Retorno                     | Descrição                                                                                                                        |
+| ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| string \| nil                       | O código Lua compilado, ou nil se a compilação falhou.                                                                           |
+| string \| nil                       | A mensagem de erro, ou nil se a compilação foi bem-sucedida.                                                                     |
+| {{string, integer, integer}} \| nil | As variáveis globais que aparecem no código (com nome, linha e coluna), ou nil se a opção do compilador `lint_global` for false. |
+
+### file_exist
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Função de verificação de existência do arquivo fonte. Pode ser sobrescrita para personalizar o comportamento.
+
+**Assinatura:**
+
+```lua
+file_exist: function(filename: string): boolean
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição          |
+| --------- | ------ | ------------------ |
+| filename  | string | O nome do arquivo. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição            |
+| --------------- | -------------------- |
+| boolean         | Se o arquivo existe. |
+
+### read_file
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Função de leitura do arquivo fonte. Pode ser sobrescrita para personalizar o comportamento.
+
+**Assinatura:**
+
+```lua
+read_file: function(filename: string): string
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição          |
+| --------- | ------ | ------------------ |
+| filename  | string | O nome do arquivo. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição              |
+| --------------- | ---------------------- |
+| string          | O conteúdo do arquivo. |
+
+### insert_loader
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Insere o carregador YueScript nos carregadores de pacote (searchers).
+
+**Assinatura:**
+
+```lua
+insert_loader: function(pos?: integer): boolean
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo    | Descrição                                                   |
+| --------- | ------- | ----------------------------------------------------------- |
+| pos       | integer | [Opcional] A posição para inserir o carregador. Padrão é 3. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                                              |
+| --------------- | -------------------------------------------------------------------------------------- |
+| boolean         | Se o carregador foi inserido com sucesso. Falhará se o carregador já estiver inserido. |
+
+### remove_loader
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Remove o carregador YueScript dos carregadores de pacote (searchers).
+
+**Assinatura:**
+
+```lua
+remove_loader: function(): boolean
+```
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                                               |
+| --------------- | --------------------------------------------------------------------------------------- |
+| boolean         | Se o carregador foi removido com sucesso. Falhará se o carregador não estiver inserido. |
+
+### loadstring
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Carrega código YueScript de uma string em uma função.
+
+**Assinatura:**
+
+```lua
+loadstring: function(input: string, chunkname: string, env: table, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| input     | string | O código YueScript.                 |
+| chunkname | string | O nome do chunk de código.          |
+| env       | table  | A tabela de ambiente.               |
+| config    | Config | [Opcional] As opções do compilador. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+
+### loadstring
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Carrega código YueScript de uma string em uma função.
+
+**Assinatura:**
+
+```lua
+loadstring: function(input: string, chunkname: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| input     | string | O código YueScript.                 |
+| chunkname | string | O nome do chunk de código.          |
+| config    | Config | [Opcional] As opções do compilador. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+
+### loadstring
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Carrega código YueScript de uma string em uma função.
+
+**Assinatura:**
+
+```lua
+loadstring: function(input: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| input     | string | O código YueScript.                 |
+| config    | Config | [Opcional] As opções do compilador. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+
+### loadfile
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Carrega código YueScript de um arquivo em uma função.
+
+**Assinatura:**
+
+```lua
+loadfile: function(filename: string, env: table, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| filename  | string | O nome do arquivo.                  |
+| env       | table  | A tabela de ambiente.               |
+| config    | Config | [Opcional] As opções do compilador. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+
+### loadfile
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Carrega código YueScript de um arquivo em uma função.
+
+**Assinatura:**
+
+```lua
+loadfile: function(filename: string, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| filename  | string | O nome do arquivo.                  |
+| config    | Config | [Opcional] As opções do compilador. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                      |
+| --------------- | -------------------------------------------------------------- |
+| function \| nil | A função carregada, ou nil se o carregamento falhou.           |
+| string \| nil   | A mensagem de erro, ou nil se o carregamento foi bem-sucedido. |
+
+### dofile
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Carrega código YueScript de um arquivo em uma função e o executa.
+
+**Assinatura:**
+
+```lua
+dofile: function(filename: string, env: table, config?: Config): any...
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| filename  | string | O nome do arquivo.                  |
+| env       | table  | A tabela de ambiente.               |
+| config    | Config | [Opcional] As opções do compilador. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                  |
+| --------------- | ------------------------------------------ |
+| any...          | Os valores de retorno da função carregada. |
+
+### dofile
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Carrega código YueScript de um arquivo em uma função e o executa.
+
+**Assinatura:**
+
+```lua
+dofile: function(filename: string, config?: Config): any...
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                           |
+| --------- | ------ | ----------------------------------- |
+| filename  | string | O nome do arquivo.                  |
+| config    | Config | [Opcional] As opções do compilador. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                  |
+| --------------- | ------------------------------------------ |
+| any...          | Os valores de retorno da função carregada. |
+
+### find_modulepath
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Resolve o nome do módulo YueScript para o caminho do arquivo.
+
+**Assinatura:**
+
+```lua
+find_modulepath: function(name: string): string
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição         |
+| --------- | ------ | ----------------- |
+| name      | string | O nome do módulo. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição             |
+| --------------- | --------------------- |
+| string          | O caminho do arquivo. |
+
+### pcall
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Chama uma função em modo protegido.
+Captura quaisquer erros e retorna um código de status e resultados ou objeto de erro.
+Reescreve o número da linha do erro para o número da linha original no código YueScript quando ocorrem erros.
+
+**Assinatura:**
+
+```lua
+pcall: function(f: function, ...: any): boolean, any...
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo     | Descrição                          |
+| --------- | -------- | ---------------------------------- |
+| f         | function | A função a chamar.                 |
+| ...       | any      | Argumentos a passar para a função. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                  |
+| --------------- | ---------------------------------------------------------- |
+| boolean, ...    | Código de status e resultados da função ou objeto de erro. |
+
+### require
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Carrega um módulo dado. Pode ser um módulo Lua ou um módulo YueScript.
+Reescreve o número da linha do erro para o número da linha original no código YueScript se o módulo for um módulo YueScript e o carregamento falhar.
+
+**Assinatura:**
+
+```lua
+require: function(name: string): any...
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                    |
+| --------- | ------ | ---------------------------- |
+| modname   | string | O nome do módulo a carregar. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                                                                                                                                                                                         |
+| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| any             | O valor armazenado em package.loaded[modname] se o módulo já estiver carregado. Caso contrário, tenta encontrar um carregador e retorna o valor final de package.loaded[modname] e os dados do carregador como segundo resultado. |
+
+### p
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Inspeciona as estruturas dos valores passados e imprime representações em string.
+
+**Assinatura:**
+
+```lua
+p: function(...: any)
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo | Descrição                 |
+| --------- | ---- | ------------------------- |
+| ...       | any  | Os valores a inspecionar. |
+
+### options
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+As opções atuais do compilador.
+
+**Assinatura:**
+
+```lua
+options: Config.Options
+```
+
+### traceback
+
+**Tipo:** Função.
+
+**Descrição:**
+
+A função traceback que reescreve os números das linhas do stack trace para os números das linhas originais no código YueScript.
+
+**Assinatura:**
+
+```lua
+traceback: function(message: string): string
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição                |
+| --------- | ------ | ------------------------ |
+| message   | string | A mensagem de traceback. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                          |
+| --------------- | ---------------------------------- |
+| string          | A mensagem de traceback reescrita. |
+
+### is_ast
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Verifica se o código corresponde ao AST especificado.
+
+**Assinatura:**
+
+```lua
+is_ast: function(astName: string, code: string): boolean
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição      |
+| --------- | ------ | -------------- |
+| astName   | string | O nome do AST. |
+| code      | string | O código.      |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                       |
+| --------------- | ------------------------------- |
+| boolean         | Se o código corresponde ao AST. |
+
+### AST
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+A definição do tipo AST com nome, linha, coluna e subnós.
+
+**Assinatura:**
+
+```lua
+type AST = {string, integer, integer, any}
+```
+
+### to_ast
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Converte o código para o AST.
+
+**Assinatura:**
+
+```lua
+to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
+    --[[AST]] AST | nil,
+    --[[error]] nil | string
+```
+
+**Parâmetros:**
+
+| Parâmetro      | Tipo    | Descrição                                                                                              |
+| -------------- | ------- | ------------------------------------------------------------------------------------------------------ |
+| code           | string  | O código.                                                                                              |
+| flattenLevel   | integer | [Opcional] O nível de achatamento. Nível mais alto significa mais achatamento. Padrão é 0. Máximo é 2. |
+| astName        | string  | [Opcional] O nome do AST. Padrão é "File".                                                             |
+| reserveComment | boolean | [Opcional] Se deve preservar os comentários originais. Padrão é false.                                 |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição                                                   |
+| --------------- | ----------------------------------------------------------- |
+| AST \| nil      | O AST, ou nil se a conversão falhou.                        |
+| string \| nil   | A mensagem de erro, ou nil se a conversão foi bem-sucedida. |
+
+### format
+
+**Tipo:** Função.
+
+**Descrição:**
+
+Formata o código YueScript.
+
+**Assinatura:**
+
+```lua
+format: function(code: string, tabSize?: number, reserveComment?: boolean): string
+```
+
+**Parâmetros:**
+
+| Parâmetro      | Tipo    | Descrição                                                             |
+| -------------- | ------- | --------------------------------------------------------------------- |
+| code           | string  | O código.                                                             |
+| tabSize        | integer | [Opcional] O tamanho da tabulação. Padrão é 4.                        |
+| reserveComment | boolean | [Opcional] Se deve preservar os comentários originais. Padrão é true. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição           |
+| --------------- | ------------------- |
+| string          | O código formatado. |
+
+### \_\_call
+
+**Tipo:** Metamétodo.
+
+**Descrição:**
+
+Requer o módulo YueScript.
+Reescreve o número da linha do erro para o número da linha original no código YueScript quando o carregamento falha.
+
+**Assinatura:**
+
+```lua
+metamethod __call: function(self: yue, module: string): any...
+```
+
+**Parâmetros:**
+
+| Parâmetro | Tipo   | Descrição         |
+| --------- | ------ | ----------------- |
+| module    | string | O nome do módulo. |
+
+**Retorna:**
+
+| Tipo de Retorno | Descrição          |
+| --------------- | ------------------ |
+| any             | O valor do módulo. |
+
+## Config
+
+**Descrição:**
+
+As opções de compilação do compilador.
+
+### lint_global
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+Se o compilador deve coletar as variáveis globais que aparecem no código.
+
+**Assinatura:**
+
+```lua
+lint_global: boolean
+```
+
+### implicit_return_root
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+Se o compilador deve fazer retorno implícito para o bloco de código raiz.
+
+**Assinatura:**
+
+```lua
+implicit_return_root: boolean
+```
+
+### reserve_line_number
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+Se o compilador deve preservar o número da linha original no código compilado.
+
+**Assinatura:**
+
+```lua
+reserve_line_number: boolean
+```
+
+### reserve_comment
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+Se o compilador deve preservar os comentários originais no código compilado.
+
+**Assinatura:**
+
+```lua
+reserve_comment: boolean
+```
+
+### space_over_tab
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+Se o compilador deve usar o caractere de espaço em vez do caractere de tabulação no código compilado.
+
+**Assinatura:**
+
+```lua
+space_over_tab: boolean
+```
+
+### same_module
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+Se o compilador deve tratar o código a ser compilado como o mesmo módulo que está sendo compilado atualmente. Apenas para uso interno.
+
+**Assinatura:**
+
+```lua
+same_module: boolean
+```
+
+### line_offset
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+Se a mensagem de erro do compilador deve incluir o deslocamento do número da linha. Apenas para uso interno.
+
+**Assinatura:**
+
+```lua
+line_offset: integer
+```
+
+### yue.Config.LuaTarget
+
+**Tipo:** Enumeração.
+
+**Descrição:**
+
+A enumeração da versão alvo do Lua.
+
+**Assinatura:**
+
+```lua
+enum LuaTarget
+  "5.1"
+  "5.2"
+  "5.3"
+  "5.4"
+  "5.5"
+end
+```
+
+### options
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+As opções extras a serem passadas para a função de compilação.
+
+**Assinatura:**
+
+```lua
+options: Options
+```
+
+## Options
+
+**Descrição:**
+
+A definição das opções extras do compilador.
+
+### target
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+A versão alvo do Lua para a compilação.
+
+**Assinatura:**
+
+```lua
+target: LuaTarget
+```
+
+### path
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+O caminho de busca de módulo extra.
+
+**Assinatura:**
+
+```lua
+path: string
+```
+
+### dump_locals
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+Se deve incluir as variáveis locais na mensagem de erro do traceback. Padrão é false.
+
+**Assinatura:**
+
+```lua
+dump_locals: boolean
+```
+
+### simplified
+
+**Tipo:** Campo.
+
+**Descrição:**
+
+Se deve simplificar a mensagem de erro. Padrão é true.
+
+**Assinatura:**
+
+```lua
+simplified: boolean
+```
diff --git a/doc/yue-zh.md b/doc/yue-zh.md
new file mode 100644
index 0000000..7454eab
--- /dev/null
+++ b/doc/yue-zh.md
@@ -0,0 +1,5866 @@
+---
+title: 参考手册
+---
+
+# 月之脚本文档
+
+<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em;padding-bottom: 2em;"/>
+
+欢迎来到 <b>月之脚本（YueScript）</b> 官方文档！<br/>
+这里收录了语言特性、用法、参考示例和资源。<br/>
+请选择左侧的章节索引或目录，开启你的月之脚本之旅 ☽
+
+# do 语句
+
+&emsp;&emsp;当用作语句时，do 语句的作用就像在 Lua 中差不多。
+
+```yuescript
+do
+  var = "hello"
+  print var
+print var -- 这里是nil
+```
+
+<YueDisplay>
+
+```yue
+do
+  var = "hello"
+  print var
+print var -- 这里是nil
+```
+
+</YueDisplay>
+
+&emsp;&emsp;月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将 do 语句代码块的最后一个语句作为表达式返回的结果。`do` 表达式支持通过 `break` 打断执行流并提前返回多个值。
+
+```yuescript
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+<YueDisplay>
+
+```yue
+status, value = do
+  n = 12
+  if n > 10
+    break "large", n
+  break "small", n
+```
+
+</YueDisplay>
+
+```yuescript
+counter = do
+  i = 0
+  ->
+    i += 1
+    i
+
+print counter!
+print counter!
+```
+
+<YueDisplay>
+
+```yue
+counter = do
+  i = 0
+  ->
+    i += 1
+    i
+
+print counter!
+print counter!
+```
+
+</YueDisplay>
+
+```yuescript
+tbl = {
+  key: do
+    print "分配键值!"
+    1234
+}
+```
+
+<YueDisplay>
+
+```yue
+tbl = {
+  key: do
+    print "分配键值!"
+    1234
+}
+```
+
+</YueDisplay>
+
+# 代码行修饰
+
+&emsp;&emsp;为了方便编写代码，循环语句和 if 语句可以应用于单行代码语句的末尾：
+
+```yuescript
+print "你好，世界" if name == "Rob"
+```
+
+<YueDisplay>
+
+```yue
+print "你好，世界" if name == "Rob"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;修饰 for 循环的示例：
+
+```yuescript
+print "项目: ", item for item in *items
+```
+
+<YueDisplay>
+
+```yue
+print "项目: ", item for item in *items
+```
+
+</YueDisplay>
+
+&emsp;&emsp;修饰 while 循环的示例：
+
+```yuescript
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+
+<YueDisplay>
+
+```yue
+game\update! while game\isRunning!
+
+reader\parse_line! until reader\eof!
+```
+
+</YueDisplay>
+
+# 宏
+
+## 常见用法
+
+&emsp;&emsp;宏函数用于在编译时执行一段代码来生成新的代码，并将生成的代码插入到最终编译结果中。
+
+```yuescript
+macro PI2 = -> math.pi * 2
+area = $PI2 * 5
+
+macro HELLO = -> "'你好 世界'"
+print $HELLO
+
+macro config = (debugging) ->
+  global debugMode = debugging == "true"
+  ""
+
+macro asserts = (cond) ->
+  debugMode and "assert #{cond}" or ""
+
+macro assert = (cond) ->
+  debugMode and "assert #{cond}" or "#{cond}"
+
+$config true
+$asserts item ~= nil
+
+$config false
+value = $assert item
+
+-- 宏函数参数传递的表达式会被转换为字符串
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+
+<YueDisplay>
+
+```yue
+macro PI2 = -> math.pi * 2
+area = $PI2 * 5
+
+macro HELLO = -> "'你好 世界'"
+print $HELLO
+
+macro config = (debugging) ->
+  global debugMode = debugging == "true"
+  ""
+
+macro asserts = (cond) ->
+  debugMode and "assert #{cond}" or ""
+
+macro assert = (cond) ->
+  debugMode and "assert #{cond}" or "#{cond}"
+
+$config true
+$asserts item ~= nil
+
+$config false
+value = $assert item
+
+-- 宏函数参数传递的表达式会被转换为字符串
+macro and = (...) -> "#{ table.concat {...}, ' and ' }"
+if $and f1!, f2!, f3!
+  print "OK"
+```
+
+</YueDisplay>
+
+## 直接插入代码
+
+&emsp;&emsp;宏函数可以返回一个包含月之脚本代码的字符串，或是一个包含 Lua 代码字符串的配置表。
+
+```yuescript
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+funcA = -> "无法访问宏生成月之脚本里定义的变量"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "无法访问宏生成 Lua 代码里定义的变量"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- raw字符串的开始和结束符号会自动被去除了再传入宏函数
+$lua[==[
+-- 插入原始Lua代码
+if cond then
+  print("输出")
+end
+]==]
+```
+
+<YueDisplay>
+
+```yue
+macro yueFunc = (var) -> "local #{var} = ->"
+$yueFunc funcA
+funcA = -> "无法访问宏生成月之脚本里定义的变量"
+
+macro luaFunc = (var) -> {
+  code: "local function #{var}() end"
+  type: "lua"
+}
+$luaFunc funcB
+funcB = -> "无法访问宏生成 Lua 代码里定义的变量"
+
+macro lua = (code) -> {
+  :code
+  type: "lua"
+}
+
+-- raw字符串的开始和结束符号会自动被去除了再传入宏函数
+$lua[==[
+-- 插入原始Lua代码
+if cond then
+  print("输出")
+end
+]==]
+```
+
+</YueDisplay>
+
+## 导出宏
+
+&emsp;&emsp;宏函数可以从一个模块中导出，并在另一个模块中导入。你必须将导出的宏函数放在一个单独的文件中使用，而且只有宏定义、宏导入和宏展开可以放入这个宏导出模块中。
+
+```yuescript
+-- 文件: utils.yue
+export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
+export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
+export macro foreach = (items, action) -> "for _ in *#{items}
+  #{action}"
+
+-- 文件 main.yue
+import "utils" as {
+  $, -- 表示导入所有宏的符号
+  $foreach: $each -- 重命名宏 $foreach 为 $each
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+```
+
+<YueDisplay>
+
+```yue
+-- 文件: utils.yue
+export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
+export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
+export macro foreach = (items, action) -> "for _ in *#{items}
+  #{action}"
+
+-- 文件 main.yue
+-- 在浏览器中不支持import函数，请在真实环境中尝试
+--[[
+import "utils" as {
+  $, -- 表示导入所有宏的符号
+  $foreach: $each -- 重命名宏 $foreach 为 $each
+}
+[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
+]]
+```
+
+</YueDisplay>
+
+## 内置宏
+
+&emsp;&emsp;月之脚本中有一些内置可以直接使用的宏，但你可以通过声明相同名称的宏来覆盖它们。
+
+```yuescript
+print $FILE -- 获取当前模块名称的字符串
+print $LINE -- 获取当前代码行数：2
+```
+
+<YueDisplay>
+
+```yue
+print $FILE -- 获取当前模块名称的字符串
+print $LINE -- 获取当前代码行数：2
+```
+
+</YueDisplay>
+
+## 用宏生成宏
+
+&emsp;&emsp;在月之脚本中，宏函数允许你在编译时生成代码。通过嵌套的宏函数，你可以创建更复杂的生成模式。这个特性允许你定义一个宏函数，用它来生成另一个宏函数，从而实现更加动态的代码生成。
+
+```yuescript
+macro Enum = (...) ->
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
+
+macro BodyType = $Enum(
+  Static
+  Dynamic
+  Kinematic
+)
+
+print "有效的枚举类型:", $BodyType Static
+-- print "编译报错的枚举类型:", $BodyType Unknown
+```
+
+<YueDisplay>
+
+```yue
+macro Enum = (...) ->
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
+
+macro BodyType = $Enum(
+  Static
+  Dynamic
+  Kinematic
+)
+
+print "有效的枚举类型:", $BodyType Static
+-- print "编译报错的枚举类型:", $BodyType Unknown
+```
+
+</YueDisplay>
+
+## 宏参数检查
+
+&emsp;&emsp;可以直接在参数列表中声明期望的 AST 节点类型，并在编译时检查传入的宏参数是否符合预期。
+
+```yuescript
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hello"
+```
+
+<YueDisplay>
+
+```yue
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hello"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果需要做更加灵活的参数检查操作，可以使用内置的 `$is_ast` 宏函数在合适的位置进行手动检查。
+
+```yuescript
+macro printNumAndStr = (num, str) ->
+  error "expected Num as first argument" unless $is_ast Num, num
+  error "expected String as second argument" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hello"
+```
+
+<YueDisplay>
+
+```yue
+macro printNumAndStr = (num, str) ->
+  error "expected Num as first argument" unless $is_ast Num, num
+  error "expected String as second argument" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hello"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;更多关于可用 AST 节点的详细信息，请参考 [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp) 中大写的规则定义。
+
+# 错误处理
+
+&emsp;&emsp;用于统一进行 Lua 错误处理的便捷语法。
+
+```yuescript
+try
+  func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try
+  func 1, 2, 3
+catch err
+  yue.traceback err
+
+try func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try func 1, 2, 3
+
+try
+  print "尝试中"
+  func 1, 2, 3
+
+-- 使用if赋值模式
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+
+<YueDisplay>
+
+```yue
+try
+  func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try
+  func 1, 2, 3
+catch err
+  yue.traceback err
+
+try func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try func 1, 2, 3
+
+try
+  print "尝试中"
+  func 1, 2, 3
+
+-- 使用if赋值模式
+if success, result := try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+
+</YueDisplay>
+
+## 错误处理简化
+
+&emsp;&emsp;`try?` 是 `try` 的功能简化语法，它不再返回 `try` 语句的布尔状态，并在成功时直接返回 `try` 代码块的结果，失败时返回 `nil` 值而非错误对象。
+
+```yuescript
+a, b, c = try? func!
+
+-- 与空值合并运算符一起使用
+a = (try? func!) ?? "default"
+
+-- 作为函数参数
+f try? func!
+
+-- 带 catch 块的 try!
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+<YueDisplay>
+
+```yue
+a, b, c = try? func!
+
+-- 与空值合并运算符一起使用
+a = (try? func!) ?? "default"
+
+-- 作为函数参数
+f try? func!
+
+-- 带 catch 块的 try!
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+
+</YueDisplay>
+
+# 表格字面量
+
+&emsp;&emsp;和 Lua 一样，表格可以通过花括号进行定义。
+
+```yuescript
+some_values = [1, 2, 3, 4]
+```
+
+<YueDisplay>
+
+```yue
+some_values = [1, 2, 3, 4]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;但与Lua不同的是，给表格中的键赋值是用 **:**（而不是 **=**）。
+
+```yuescript
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+<YueDisplay>
+
+```yue
+some_values = {
+  name: "Bill",
+  age: 200,
+  ["favorite food"]: "rice"
+}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果只分配一个键值对的表格，可以省略花括号。
+
+```yuescript
+profile =
+  height: "4英尺",
+  shoe_size: 13,
+  favorite_foods: ["冰淇淋", "甜甜圈"]
+```
+
+<YueDisplay>
+
+```yue
+profile =
+  height: "4英尺",
+  shoe_size: 13,
+  favorite_foods: ["冰淇淋", "甜甜圈"]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;可以使用换行符而不使用逗号（或两者都用）来分隔表格中的值：
+
+```yuescript
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "超人"
+  occupation: "打击犯罪"
+}
+```
+
+<YueDisplay>
+
+```yue
+values = {
+  1, 2, 3, 4
+  5, 6, 7, 8
+  name: "超人"
+  occupation: "打击犯罪"
+}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;创建单行表格字面量时，也可以省略花括号：
+
+```yuescript
+my_function dance: "探戈", partner: "无"
+
+y = type: "狗", legs: 4, tails: 1
+```
+
+<YueDisplay>
+
+```yue
+my_function dance: "探戈", partner: "无"
+
+y = type: "狗", legs: 4, tails: 1
+```
+
+</YueDisplay>
+
+&emsp;&emsp;表格字面量的键可以使用 Lua 语言的关键字，而无需转义：
+
+```yuescript
+tbl = {
+  do: "某事"
+  end: "饥饿"
+}
+```
+
+<YueDisplay>
+
+```yue
+tbl = {
+  do: "某事"
+  end: "饥饿"
+}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果你要构造一个由变量组成的表，并希望键与变量名相同，那么可以使用 **:** 前缀操作符：
+
+```yuescript
+hair = "金色"
+height = 200
+person = { :hair, :height, shoe_size: 40 }
+
+print_table :hair, :height
+```
+
+<YueDisplay>
+
+```yue
+hair = "金色"
+height = 200
+person = { :hair, :height, shoe_size: 40 }
+
+print_table :hair, :height
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果你希望表中字段的键是某个表达式的结果，那么可以用 **[ ]** 包裹它，就像在 Lua 中一样。如果键中有任何特殊字符，也可以直接使用字符串字面量作为键，省略方括号。
+
+```yuescript
+t = {
+  [1 + 2]: "你好"
+  "你好 世界": true
+}
+```
+
+<YueDisplay>
+
+```yue
+t = {
+  [1 + 2]: "你好"
+  "你好 世界": true
+}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;Lua 的表同时具有数组部分和哈希部分，但有时候你会希望在书写 Lua 表时，对 Lua 表做数组和哈希不同用法的语义区分。然后你可以用 **[ ]** 而不是 **{ }** 来编写表示数组的 Lua 表，并且不允许在数组 Lua 表中写入任何键值对。
+
+```yuescript
+some_values = [ 1, 2, 3, 4 ]
+list_with_one_element = [ 1, ]
+```
+
+<YueDisplay>
+
+```yue
+some_values = [ 1, 2, 3, 4 ]
+list_with_one_element = [ 1, ]
+```
+
+</YueDisplay>
+
+# 推导式
+
+&emsp;&emsp;推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生 Lua 表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
+
+## 列表推导式
+
+&emsp;&emsp;以下操作创建了一个 items 表的副本，但所有包含的值都翻倍了。
+
+```yuescript
+items = [1, 2, 3, 4]
+doubled = [item * 2 for i, item in ipairs items]
+```
+
+<YueDisplay>
+
+```yue
+items = [1, 2, 3, 4]
+doubled = [item * 2 for i, item in ipairs items]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;可以使用 `when` 子句筛选新表中包含的项目：
+
+```yuescript
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;因为我们常常需要迭代数值索引表的值，所以引入了 **\*** 操作符来做语法简化。doubled 示例可以重写为：
+
+```yuescript
+doubled = [item * 2 for item in *items]
+```
+
+<YueDisplay>
+
+```yue
+doubled = [item * 2 for item in *items]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在列表推导式中，你还可以使用展开操作符 `...` 来实现对列表嵌套层级进行扁平化的处理：
+
+```yuescript
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat 现在为 [1, 2, 3, 4, 5, 6]
+```
+
+<YueDisplay>
+
+```yue
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat 现在为 [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;for 和 when 子句可以根据需要进行链式操作。唯一的要求是推导式中至少要有一个 for 子句。
+
+&emsp;&emsp;使用多个 for 子句与使用多重循环的效果相同：
+
+```yuescript
+x_coords = [4, 5, 6, 7]
+y_coords = [9, 2, 3]
+
+points = [ [x, y] for x in *x_coords \
+for y in *y_coords]
+```
+
+<YueDisplay>
+
+```yue
+x_coords = [4, 5, 6, 7]
+y_coords = [9, 2, 3]
+
+points = [ [x, y] for x in *x_coords \
+for y in *y_coords]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在推导式中也可以使用简单的数值 for 循环：
+
+```yuescript
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+<YueDisplay>
+
+```yue
+evens = [i for i = 1, 100 when i % 2 == 0]
+```
+
+</YueDisplay>
+
+## 表格推导式
+
+&emsp;&emsp;表格推导式和列表推导式的语法非常相似，只是要使用 **{** 和 **}** 并从每次迭代中取两个值。
+
+&emsp;&emsp;以下示例生成了表格 thing 的副本：
+
+```yuescript
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+<YueDisplay>
+
+```yue
+thing = {
+  color: "red"
+  name: "fast"
+  width: 123
+}
+
+thing_copy = {k, v for k, v in pairs thing}
+```
+
+</YueDisplay>
+
+```yuescript
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+<YueDisplay>
+
+```yue
+no_color = {k, v for k, v in pairs thing when k != "color"}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;**\*** 操作符在表格推导式中能使用。在下面的例子里，我们为几个数字创建了一个平方根查找表。
+
+```yuescript
+numbers = [1, 2, 3, 4]
+sqrts = {i, math.sqrt i for i in *numbers}
+```
+
+<YueDisplay>
+
+```yue
+numbers = [1, 2, 3, 4]
+sqrts = {i, math.sqrt i for i in *numbers}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;表格推导式中的键值元组也可以来自单个表达式，在这种情况下，表达式在计算后应返回两个值。第一个用作键，第二个用作值：
+
+&emsp;&emsp;在下面的示例中，我们将一些数组转换为一个表，其中每个数组里的第一项是键，第二项是值。
+
+```yuescript
+tuples = [ ["hello", "world"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+
+<YueDisplay>
+
+```yue
+tuples = [ ["hello", "world"], ["foo", "bar"]]
+tbl = {unpack tuple for tuple in *tuples}
+```
+
+</YueDisplay>
+
+## 切片
+
+&emsp;&emsp;当使用 **\*** 操作符时，月之脚本还提供了一种特殊的语法来限制要遍历的列表范围。这个语法也相当于在 for 循环中设置迭代边界和步长。
+
+&emsp;&emsp;下面的案例中，我们在切片中设置最小和最大边界，取索引在 1 到 5 之间（包括 1 和 5）的所有项目：
+
+```yuescript
+slice = [item for item in *items[1, 5]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[1, 5]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;切片的任意参数都可以省略，并会使用默认值。在如下示例中，如果省略了最大索引边界，它默认为表的长度。使下面的代码取除第一个元素之外的所有元素：
+
+```yuescript
+slice = [item for item in *items[2,]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[2,]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果省略了最小边界，便默认会设置为 1。这里我们只提供一个步长，并留下其他边界为空。这样会使得代码取出所有奇数索引的项目：(1, 3, 5, …)
+
+```yuescript
+slice = [item for item in *items[,,2]]
+```
+
+<YueDisplay>
+
+```yue
+slice = [item for item in *items[,,2]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;最小和最大边界都可以是负数，使用负数意味着边界是从表的末尾开始计算的。
+
+```yuescript
+-- 取最后4个元素
+slice = [item for item in *items[-4,-1]]
+```
+
+<YueDisplay>
+
+```yue
+-- 取最后4个元素
+slice = [item for item in *items[-4,-1]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;切片的步长也可以是负数，这意味着元素会以相反的顺序被取出。
+
+```yuescript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+<YueDisplay>
+
+```yue
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+
+</YueDisplay>
+
+### 切片表达式
+
+&emsp;&emsp;切片也可以作为表达式来使用。可以用于获取一个表包含的子列表。
+
+```yuescript
+-- 取第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+
+-- 取最后4个元素作为新的列表
+last_four_items = items[-4, -1]
+```
+
+<YueDisplay>
+
+```yue
+-- 取第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+
+-- 取最后4个元素作为新的列表
+last_four_items = items[-4, -1]
+```
+
+</YueDisplay>
+
+# 面向对象编程
+
+&emsp;&emsp;在以下的示例中，月之脚本生成的 Lua 代码可能看起来会很复杂。所以最好主要关注月之脚本代码层面的意义，然后如果你想知道关于面向对象功能的实现细节，再查看 Lua 代码。
+
+&emsp;&emsp;一个简单的类：
+
+```yuescript
+class Inventory
+  new: =>
+    @items = {}
+
+  add_item: (name) =>
+    if @items[name]
+      @items[name] += 1
+    else
+      @items[name] = 1
+```
+
+<YueDisplay>
+
+```yue
+class Inventory
+  new: =>
+    @items = {}
+
+  add_item: (name) =>
+    if @items[name]
+      @items[name] += 1
+    else
+      @items[name] = 1
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在月之脚本中采用面向对象的编程方式时，通常会使用类声明语句结合 Lua 表格字面量来做类定义。这个类的定义包含了它的所有方法和属性。在这种结构中，键名为 “new” 的成员扮演了一个重要的角色，是作为构造函数来使用。
+
+&emsp;&emsp;值得注意的是，类中的方法都采用了粗箭头函数语法。当在类的实例上调用方法时，该实例会自动作为第一个参数被传入，因此粗箭头函数用于生成一个名为 “self” 的参数。
+
+&emsp;&emsp;此外，“@” 前缀在变量名上起到了简化作用，代表 “self”。例如，`@items` 就等同于 `self.items`。
+
+&emsp;&emsp;为了创建类的一个新实例，可以将类名当作一个函数来调用，这样就可以生成并返回一个新的实例。
+
+```yuescript
+inv = Inventory!
+inv\add_item "t-shirt"
+inv\add_item "pants"
+```
+
+<YueDisplay>
+
+```yue
+inv = Inventory!
+inv\add_item "t-shirt"
+inv\add_item "pants"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在月之脚本的类中，由于需要将类的实例作为参数传入到调用的方法中，因此使用了 **\\** 操作符做类的成员函数调用。
+
+&emsp;&emsp;需要特别注意的是，类的所有属性在其实例之间是共享的。这对于函数类型的成员属性通常不会造成问题，但对于其他类型的属性，可能会导致意外的结果。
+
+&emsp;&emsp;例如，在下面的示例中，clothes 属性在所有实例之间共享。因此，对这个属性在一个实例中的修改，将会影响到其他所有实例。
+
+```yuescript
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- 会同时打印出裤子和衬衫
+print item for item in *a.clothes
+```
+
+<YueDisplay>
+
+```yue
+class Person
+  clothes: []
+  give_item: (name) =>
+    table.insert @clothes, name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- 会同时打印出裤子和衬衫
+print item for item in *a.clothes
+```
+
+</YueDisplay>
+
+&emsp;&emsp;避免这个问题的正确方法是在构造函数中创建对象的可变状态：
+
+```yuescript
+class Person
+  new: =>
+    @clothes = []
+```
+
+<YueDisplay>
+
+```yue
+class Person
+  new: =>
+    @clothes = []
+```
+
+</YueDisplay>
+
+## 继承
+
+&emsp;&emsp;`extends` 关键字可以在类声明中使用，以继承另一个类的属性和方法。
+
+```yuescript
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "背包已满"
+    super name
+```
+
+<YueDisplay>
+
+```yue
+class BackPack extends Inventory
+  size: 10
+  add_item: (name) =>
+    if #@items > size then error "背包已满"
+    super name
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在这一部分，我们对月之脚本中的 `Inventory` 类进行了扩展，加入了对可以携带物品数量的限制。
+
+&emsp;&emsp;在这个特定的例子中，子类并没有定义自己的构造函数。因此，当创建一个新的实例时，系统会默认调用父类的构造函数。但如果我们在子类中定义了构造函数，我们可以利用 `super` 方法来调用并执行父类的构造函数。
+
+&emsp;&emsp;此外，当一个类继承自另一个类时，它会尝试调用父类上的 `__inherited` 方法（如果这个方法存在的话），以此来向父类发送通知。这个 `__inherited` 函数接受两个参数：被继承的父类和继承的子类。
+
+```yuescript
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "被", child.__name, "继承"
+
+-- 将打印: Shelf 被 Cupboard 继承
+class Cupboard extends Shelf
+```
+
+<YueDisplay>
+
+```yue
+class Shelf
+  @__inherited: (child) =>
+    print @__name, "被", child.__name, "继承"
+
+-- 将打印: Shelf 被 Cupboard 继承
+class Cupboard extends Shelf
+```
+
+</YueDisplay>
+
+## super 关键字
+
+&emsp;&emsp;`super` 是一个特别的关键字，它有两种不同的使用方式：既可以当作一个对象来看待，也可以像调用函数那样使用。它仅在类的内部使用时具有特殊的功能。
+
+&emsp;&emsp;当 `super` 被作为一个函数调用时，它将调用父类中与之同名的函数。此时，当前的 `self` 会自动作为第一个参数传递，正如上面提到的继承示例所展示的那样。
+
+&emsp;&emsp;在将 `super` 当作普通值使用时，它实际上是对父类对象的引用。通过这种方式，我们可以访问父类中可能被子类覆盖的值，就像访问任何普通对象一样。
+
+&emsp;&emsp;此外，当使用 `\` 操作符与 `super` 一起使用时，`self`将被插入为第一个参数，而不是使用 `super` 本身的值。而在使用`.`操作符来检索函数时，则会返回父类中的原始函数。
+
+&emsp;&emsp;下面是一些使用 `super` 的不同方法的示例：
+
+```yuescript
+class MyClass extends ParentClass
+  a_method: =>
+    -- 以下效果相同：
+    super "你好", "世界"
+    super\a_method "你好", "世界"
+    super.a_method self, "你好", "世界"
+
+    -- super 作为值等于父类：
+    assert super == ParentClass
+```
+
+<YueDisplay>
+
+```yue
+class MyClass extends ParentClass
+  a_method: =>
+    -- 以下效果相同：
+    super "你好", "世界"
+    super\a_method "你好", "世界"
+    super.a_method self, "你好", "世界"
+
+    -- super 作为值等于父类：
+    assert super == ParentClass
+```
+
+</YueDisplay>
+
+&emsp;&emsp;**super** 也可以用在函数存根的左侧。唯一的主要区别是，生成的函数不是绑定到 super 的值，而是绑定到 self。
+
+## 类型
+
+&emsp;&emsp;每个类的实例都带有它的类型。这存储在特殊的 \_\_class 属性中。此属性会保存类对象。类对象是我们用来构建新实例的对象。我们还可以索引类对象以检索类方法和属性。
+
+```yuescript
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- 打印 10
+```
+
+<YueDisplay>
+
+```yue
+b = BackPack!
+assert b.__class == BackPack
+
+print BackPack.size -- 打印 10
+```
+
+</YueDisplay>
+
+## 类对象
+
+&emsp;&emsp;在月之脚本中，当我们编写类的定义语句时，实际上是在创建一个类对象。这个类对象被保存在一个与该类同名的变量中。
+
+&emsp;&emsp;类对象具有函数的特性，可以被调用来创建新的实例。这正是我们在之前示例中所展示的创建类实例的方式。
+
+&emsp;&emsp;一个类由两个表构成：类表本身和一个基表。基表作为所有实例的元表。在类声明中列出的所有属性都存放在基表中。
+
+&emsp;&emsp;如果在类对象的元表中找不到某个属性，系统会从基表中检索该属性。这就意味着我们可以直接从类本身访问到其方法和属性。
+
+&emsp;&emsp;需要特别注意的是，对类对象的赋值并不会影响到基表，因此这不是向实例添加新方法的正确方式。相反，需要直接修改基表。关于这点，可以参考下面的 “\_\_base” 字段。
+
+&emsp;&emsp;此外，类对象包含几个特殊的属性：当类被声明时，类的名称会作为一个字符串存储在类对象的 “\_\_name” 字段中。
+
+```yuescript
+print BackPack.__name -- 打印 Backpack
+```
+
+<YueDisplay>
+
+```yue
+print BackPack.__name -- 打印 Backpack
+```
+
+</YueDisplay>
+
+&emsp;&emsp;基础对象被保存在一个名为 `__base` 的特殊表中。我们可以编辑这个表，以便为那些已经创建出来的实例和还未创建的实例增加新的功能。
+
+&emsp;&emsp;另外，如果一个类是从另一个类派生而来的，那么其父类对象则会被存储在名为 `__parent` 的地方。这种机制允许在类之间实现继承和功能扩展。
+
+## 类变量
+
+&emsp;&emsp;我们可以直接在类对象中创建变量，而不是在类的基对象中，通过在类声明中的属性名前使用 @。
+
+```yuescript
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- 类变量在实例中不可见
+assert Things().some_func == nil
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @some_func: => print "Hello from", @__name
+
+Things\some_func!
+
+-- 类变量在实例中不可见
+assert Things().some_func == nil
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在表达式中，我们可以使用 @@ 来访问存储在 `self.__class` 中的值。因此，`@@hello` 是 `self.__class.hello` 的简写。
+
+```yuescript
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- 输出 2
+```
+
+<YueDisplay>
+
+```yue
+class Counter
+  @count: 0
+
+  new: =>
+    @@count += 1
+
+Counter!
+Counter!
+
+print Counter.count -- 输出 2
+```
+
+</YueDisplay>
+
+&emsp;&emsp;@@ 的调用语义与 @ 类似。调用 @@ 时，会使用 Lua 的冒号语法将类作为第一个参数传入。
+
+```yuescript
+@@hello 1,2,3,4
+```
+
+<YueDisplay>
+
+```yue
+@@hello 1,2,3,4
+```
+
+</YueDisplay>
+
+## 类声明语句
+
+&emsp;&emsp;在类声明的主体中，除了键/值对外，我们还可以编写普通的表达式。在这种类声明体中的普通代码的上下文中，self 等于类对象，而不是实例对象。
+
+&emsp;&emsp;以下是创建类变量的另一种方法：
+
+```yuescript
+class Things
+  @class_var = "hello world"
+```
+
+<YueDisplay>
+
+```yue
+class Things
+  @class_var = "hello world"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这些表达式会在所有属性被添加到类的基对象后执行。
+
+&emsp;&emsp;在类的主体中声明的所有变量都会限制作用域只在类声明的范围。这对于放置只有类方法可以访问的私有值或辅助函数很方便：
+
+```yuescript
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "hello world: " .. secret
+```
+
+<YueDisplay>
+
+```yue
+class MoreThings
+  secret = 123
+  log = (msg) -> print "LOG:", msg
+
+  some_method: =>
+    log "hello world: " .. secret
+```
+
+</YueDisplay>
+
+## @ 和 @@ 值
+
+&emsp;&emsp;当 @ 和 @@ 前缀在一个名字前时，它们分别代表在 self 和 self.\_\_class 中访问的那个名字。
+
+&emsp;&emsp;如果它们单独使用，它们是 self 和 self.\_\_class 的别名。
+
+```yuescript
+assert @ == self
+assert @@ == self.__class
+```
+
+<YueDisplay>
+
+```yue
+assert @ == self
+assert @@ == self.__class
+```
+
+</YueDisplay>
+
+&emsp;&emsp;例如，使用 @@ 从实例方法快速创建同一类的新实例的方法：
+
+```yuescript
+some_instance_method = (...) => @@ ...
+```
+
+<YueDisplay>
+
+```yue
+some_instance_method = (...) => @@ ...
+```
+
+</YueDisplay>
+
+## 构造属性提升
+
+&emsp;&emsp;为了减少编写简单值对象定义的代码。你可以这样简单写一个类：
+
+```yuescript
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- 这是以下声明的简写形式
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+<YueDisplay>
+
+```yue
+class Something
+  new: (@foo, @bar, @@biz, @@baz) =>
+
+-- 这是以下声明的简写形式
+
+class Something
+  new: (foo, bar, biz, baz) =>
+    @foo = foo
+    @bar = bar
+    @@biz = biz
+    @@baz = baz
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你也可以使用这种语法为一个函数初始化传入对象的字段。
+
+```yuescript
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+<YueDisplay>
+
+```yue
+new = (@fieldA, @fieldB) => @
+obj = new {}, 123, "abc"
+print obj
+```
+
+</YueDisplay>
+
+## 类表达式
+
+&emsp;&emsp;类声明的语法也可以作为一个表达式使用，可以赋值给一个变量或者被返回语句返回。
+
+```yuescript
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+<YueDisplay>
+
+```yue
+x = class Bucket
+  drops: 0
+  add_drop: => @drops += 1
+```
+
+</YueDisplay>
+
+## 匿名类
+
+&emsp;&emsp;声明类时可以省略名称。如果类的表达式不在赋值语句中，\_\_name 属性将为 nil。如果出现在赋值语句中，赋值操作左侧的名称将代替 nil。
+
+```yuescript
+BigBucket = class extends Bucket
+  add_drop: => @drops += 10
+
+assert Bucket.__name == "BigBucket"
+```
+
+<YueDisplay>
+
+```yue
+BigBucket = class extends Bucket
+  add_drop: => @drops += 10
+
+assert Bucket.__name == "BigBucket"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你甚至可以省略掉主体，这意味着你可以这样写一个空白的匿名类：
+
+```yuescript
+x = class
+```
+
+<YueDisplay>
+
+```yue
+x = class
+```
+
+</YueDisplay>
+
+## 类混合
+
+&emsp;&emsp;你可以通过使用 `using` 关键字来实现类混合。这意味着你可以从一个普通 Lua 表格或已定义的类对象中，复制函数到你创建的新类中。当你使用普通 Lua 表格进行类混合时，你有机会用自己的实现来重写类的索引方法（例如元方法 `__index`）。然而，当你从一个类对象做混合时，需要注意的是该类对象的元方法将不会被复制到新类。
+
+```yuescript
+MyIndex = __index: var: 1
+
+class X using MyIndex
+  func: =>
+    print 123
+
+x = X!
+print x.var
+
+class Y using X
+
+y = Y!
+y\func!
+
+assert y.__class.__parent ~= X -- X 不是 Y 的父类
+```
+
+<YueDisplay>
+
+```yue
+MyIndex = __index: var: 1
+
+class X using MyIndex
+  func: =>
+    print 123
+
+x = X!
+print x.var
+
+class Y using X
+
+y = Y!
+y\func!
+
+assert y.__class.__parent ~= X -- X 不是 Y 的父类
+```
+
+</YueDisplay>
+
+# with 语句
+
+在编写 Lua 代码时，我们在创建对象后的常见操作是立即调用这个对象一系列操作函数并设置一系列属性。
+
+这导致在代码中多次重复引用对象的名称，增加了不必要的文本噪音。一个常见的解决方案是在创建对象时，在构造函数传入一个表，该表包含要覆盖设置的键和值的集合。这样做的缺点是该对象的构造函数必须支持这种初始化形式。
+
+with 块有助于简化编写这样的代码。在 with 块内，我们可以使用以 . 或 \ 开头的特殊语句，这些语句代表我们正在使用的对象的操作。
+
+例如，我们可以这样处理一个新创建的对象：
+
+```yuescript
+with Person!
+  .name = "Oswald"
+  \add_relative my_dad
+  \save!
+  print .name
+```
+
+<YueDisplay>
+
+```yue
+with Person!
+  .name = "Oswald"
+  \add_relative my_dad
+  \save!
+  print .name
+```
+
+</YueDisplay>
+
+with 语句也可以用作一个表达式，并返回它的代码块正在处理的对象。
+
+```yuescript
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+<YueDisplay>
+
+```yue
+file = with File "favorite_foods.txt"
+  \set_encoding "utf8"
+```
+
+</YueDisplay>
+
+`with` 表达式支持 `break` 返回一个值：
+
+```yuescript
+result = with obj
+  break .value
+```
+
+<YueDisplay>
+
+```yue
+result = with obj
+  break .value
+```
+
+</YueDisplay>
+
+在 `with` 中使用 `break value` 后，`with` 表达式将不再返回其目标对象，而是返回 `break` 给出的值。
+
+```yuescript
+a = with obj
+  .x = 1
+-- a 是 obj
+
+b = with obj
+  break .x
+-- b 是 .x，不是 obj
+```
+
+<YueDisplay>
+
+```yue
+a = with obj
+  .x = 1
+-- a 是 obj
+
+b = with obj
+  break .x
+-- b 是 .x，不是 obj
+```
+
+</YueDisplay>
+
+与 `for` / `while` / `repeat` / `do` 不同，`with` 只支持一个 break 返回值。
+
+或者…
+
+```yuescript
+create_person = (name,  relatives) ->
+  with Person!
+    .name = name
+    \add_relative relative for relative in *relatives
+
+me = create_person "Leaf", [dad, mother, sister]
+```
+
+<YueDisplay>
+
+```yue
+create_person = (name,  relatives) ->
+  with Person!
+    .name = name
+    \add_relative relative for relative in *relatives
+
+me = create_person "Leaf", [dad, mother, sister]
+```
+
+</YueDisplay>
+
+在此用法中，with 可以被视为K组合子（k-combinator）的一种特殊形式。
+
+如果你想给表达式另外起一个名称的话，with 语句中的表达式也可以是一个赋值语句。
+
+```yuescript
+with str := "你好"
+  print "原始:", str
+  print "大写:", \upper!
+```
+
+<YueDisplay>
+
+```yue
+with str := "你好"
+  print "原始:", str
+  print "大写:", \upper!
+```
+
+</YueDisplay>
+
+你可以在 `with` 语句中使用 `[]` 访问特殊键。
+
+```yuescript
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- 追加到 "tb"
+```
+
+<YueDisplay>
+
+```yue
+with tb
+  [1] = 1
+  print [2]
+  with [abc]
+    [3] = [2]\func!
+    ["key-name"] = value
+  [] = "abc" -- 追加到 "tb"
+```
+
+</YueDisplay>
+
+`with?` 是 `with` 语法的一个增强版本，引入了存在性检查，用于在不显式判空的情况下安全访问可能为 nil 的对象。
+
+```yuescript
+with? obj
+  print obj.name
+```
+
+<YueDisplay>
+
+```yue
+with? obj
+  print obj.name
+```
+
+</YueDisplay>
+
+# 赋值
+
+&emsp;&emsp;月之脚本中定义的变量是动态类型的，并默认为局部变量。但你可以通过 **local** 和 **global** 声明来改变声明变量的作用范围。
+
+```yuescript
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- 访问现有的变量
+```
+
+<YueDisplay>
+
+```yue
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- 访问现有的变量
+```
+
+</YueDisplay>
+
+## 执行更新
+
+&emsp;&emsp;你可以使用各式二进制运算符执行更新赋值。
+
+```yuescript
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- 如果执行更新的局部变量不存在，将新建一个局部变量
+arg or= "默认值"
+```
+
+<YueDisplay>
+
+```yue
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- 如果执行更新的局部变量不存在，将新建一个局部变量
+arg or= "默认值"
+```
+
+</YueDisplay>
+
+## 链式赋值
+
+&emsp;&emsp;你可以进行链式赋值，将多个项目赋予相同的值。
+
+```yuescript
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+<YueDisplay>
+
+```yue
+a = b = c = d = e = 0
+x = y = z = f!
+```
+
+</YueDisplay>
+
+## 显式声明局部变量
+
+```yuescript
+do
+  local a = 1
+  local *
+  print "预先声明后续所有变量为局部变量"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "只预先声明后续大写的变量为局部变量"
+  a = 1
+  B = 2
+```
+
+<YueDisplay>
+
+```yue
+do
+  local a = 1
+  local *
+  print "预先声明后续所有变量为局部变量"
+  x = -> 1 + y + z
+  y, z = 2, 3
+  global instance = Item\new!
+
+do
+  local X = 1
+  local ^
+  print "只预先声明后续大写的变量为局部变量"
+  a = 1
+  B = 2
+```
+
+</YueDisplay>
+
+## 显式声明全局变量
+
+```yuescript
+do
+  global a = 1
+  global *
+  print "预先声明所有变量为全局变量"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global x = 1
+  global ^
+  print "只预先声明大写的变量为全局变量"
+  a = 1
+  B = 2
+  local Temp = "一个局部值"
+```
+
+<YueDisplay>
+
+```yue
+do
+  global a = 1
+  global *
+  print "预先声明所有变量为全局变量"
+  x = -> 1 + y + z
+  y, z = 2, 3
+
+do
+  global x = 1
+  global ^
+  print "只预先声明大写的变量为全局变量"
+  a = 1
+  B = 2
+  local Temp = "一个局部值"
+```
+
+</YueDisplay>
+
+# 可变参数赋值
+
+&emsp;&emsp;你可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用 Lua 的方式访问其内容。
+
+```yuescript
+list = [1, 2, 3, 4, 5]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+
+<YueDisplay>
+
+```yue
+list = [1, 2, 3, 4, 5]
+fn = (ok) -> ok, table.unpack list
+ok, ... = fn true
+count = select '#', ...
+first = select 1, ...
+print ok, count, first
+```
+
+</YueDisplay>
+
+# If 赋值
+
+&emsp;&emsp;`if` 和 `elseif` 代码块可以在条件表达式的位置进行赋值。在代码执行到要计算条件时，会首先进行赋值计算，并使用赋与的值作为分支判断的条件。赋值的变量仅在条件分支的代码块内有效，这意味着如果值不是真值，那么它就不会被用到。注意，你必须使用“海象运算符” `:=` 而不是 `=` 来做赋值。
+
+```yuescript
+if user := database.find_user "moon"
+  print user.name
+```
+
+<YueDisplay>
+
+```yue
+if user := database.find_user "moon"
+  print user.name
+```
+
+</YueDisplay>
+
+```yuescript
+if hello := os.getenv "hello"
+  print "你有 hello", hello
+elseif world := os.getenv "world"
+  print "你有 world", world
+else
+  print "什么都没有 :("
+```
+
+<YueDisplay>
+
+```yue
+if hello := os.getenv "hello"
+  print "你有 hello", hello
+elseif world := os.getenv "world"
+  print "你有 world", world
+else
+  print "什么都没有 :("
+```
+
+</YueDisplay>
+
+&emsp;&emsp;使用多个返回值的 If 赋值。只有第一个值会被检查，其他值都有同样的作用域。
+
+```yuescript
+if success, result := pcall -> "无报错地获取结果"
+  print result -- 变量 result 是有作用域的
+print "好的"
+```
+
+<YueDisplay>
+
+```yue
+if success, result := pcall -> "无报错地获取结果"
+  print result -- 变量 result 是有作用域的
+print "好的"
+```
+
+</YueDisplay>
+
+## While 赋值
+
+&emsp;&emsp;你可以在 while 循环中同样使用赋值来获取循环条件的值。
+
+```yuescript
+while byte := stream\read_one!
+  -- 对 byte 做一些操作
+  print byte
+```
+
+<YueDisplay>
+
+```yue
+while byte := stream\read_one!
+  -- 对 byte 做一些操作
+  print byte
+```
+
+</YueDisplay>
+
+# 解构赋值
+
+&emsp;&emsp;解构赋值是一种快速从 Lua 表中按名称或基于数组中的位置提取值的方法。
+
+&emsp;&emsp;通常当你看到一个字面量的 Lua 表，比如 `{1,2,3}`，它位于赋值的右侧，因为它是一个值。解构赋值语句的写法就是交换了字面量 Lua 表的角色，并将其放在赋值语句的左侧。
+
+&emsp;&emsp;最好是通过示例来解释。以下是如何从表格中解包前两个值的方法：
+
+```yuescript
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+<YueDisplay>
+
+```yue
+thing = [1, 2]
+
+[a, b] = thing
+print a, b
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在解构表格字面量中，键代表从右侧读取的键，值代表读取的值将被赋予的名称。
+
+```yuescript
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- 可以不带大括号进行简单的解构
+```
+
+<YueDisplay>
+
+```yue
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- 可以不带大括号进行简单的解构
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这也适用于嵌套的数据结构：
+
+```yuescript
+obj2 = {
+  numbers: [1,2,3,4]
+  properties: {
+    color: "green"
+    height: 13.5
+  }
+}
+
+{numbers: [first, second], properties: {color: color}} = obj2
+print first, second, color
+```
+
+<YueDisplay>
+
+```yue
+obj2 = {
+  numbers: [1,2,3,4]
+  properties: {
+    color: "green"
+    height: 13.5
+  }
+}
+
+{numbers: [first, second], properties: {color: color}} = obj2
+print first, second, color
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果解构语句很复杂，也可以任意将其分散在几行中。稍微复杂一些的示例：
+
+```yuescript
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+<YueDisplay>
+
+```yue
+{
+  numbers: [first, second]
+  properties: {
+    color: color
+  }
+} = obj2
+```
+
+</YueDisplay>
+
+&emsp;&emsp;有时候我们会需要从 Lua 表中提取值并将它们赋给与键同名的局部变量。为了避免编写重复代码，我们可以使用 **:** 前缀操作符：
+
+```yuescript
+{:concat, :insert} = table
+```
+
+<YueDisplay>
+
+```yue
+{:concat, :insert} = table
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这样的用法与导入语法有些相似。但我们可以通过混合语法重命名我们想要提取的字段：
+
+```yuescript
+{:mix, :max, random: rand} = math
+```
+
+<YueDisplay>
+
+```yue
+{:mix, :max, random: rand} = math
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在进行解构时，你可以指定默认值，如：
+
+```yuescript
+{:name = "nameless", :job = "jobless"} = person
+```
+
+<YueDisplay>
+
+```yue
+{:name = "nameless", :job = "jobless"} = person
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在进行列表解构时，你可以使用`_`作为占位符：
+
+```yuescript
+[_, two, _, four] = items
+```
+
+<YueDisplay>
+
+```yue
+[_, two, _, four] = items
+```
+
+</YueDisplay>
+
+## 范围解构
+
+&emsp;&emsp;你可以使用展开运算符 `...` 在列表解构中来捕获一个范围的值到子列表中。这在当你想要从列表的开头和结尾提取特定元素，同时收集中间的元素时非常有用。
+
+```yuescript
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- 打印: first
+print bulk   -- 打印: {"second", "third", "fourth"}
+print last   -- 打印: last
+```
+
+<YueDisplay>
+
+```yue
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- 打印: first
+print bulk   -- 打印: {"second", "third", "fourth"}
+print last   -- 打印: last
+```
+
+</YueDisplay>
+
+&emsp;&emsp;展开运算符可以用在不同的位置来捕获不同的范围，并且你可以使用 `_` 作为占位符来表示你想跳过对应范围的捕获：
+
+```yuescript
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+```
+
+<YueDisplay>
+
+```yue
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+```
+
+</YueDisplay>
+
+## 在其它地方的解构赋值
+
+&emsp;&emsp;解构赋值也可以出现在其它隐式进行赋值的地方。一个例子是用在 for 循环中：
+
+```yuescript
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+<YueDisplay>
+
+```yue
+tuples = [
+  ["hello", "world"]
+  ["egg", "head"]
+]
+
+for [left, right] in *tuples
+  print left, right
+```
+
+</YueDisplay>
+
+&emsp;&emsp;我们知道数组表中的每个元素都是一个两项的元组，所以我们可以直接在 for 语句的名称子句中使用解构来解包它。
+
+# 使用 using 语句：防止破坏性赋值
+
+&emsp;&emsp;Lua 的变量作用域是降低代码复杂度的重要工具。然而，随着代码量的增加，维护这些变量可能变得更加困难。比如，看看下面的代码片段：
+
+```yuescript
+i = 100
+
+-- 许多代码行...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- 将打印 0
+```
+
+<YueDisplay>
+
+```yue
+i = 100
+
+-- 许多代码行...
+
+my_func = ->
+  i = 10
+  while i > 0
+    print i
+    i -= 1
+
+my_func!
+
+print i -- 将打印 0
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在 `my_func` 中，我们不小心覆盖了变量 `i` 的值。虽然在这个例子中这个问题很明显，但在一个庞大的或者是由多人共同维护的代码库中，很难追踪每个变量的声明情况。
+
+&emsp;&emsp;如果我们可以明确指出哪些变量是我们想在当前作用域内修改的，并且防止我们不小心更改了其他作用域中同名的变量，那将大有裨益。
+
+&emsp;&emsp;`using` 语句就是为此而生。`using nil` 确保函数内部的赋值不会意外地影响到外部作用域的变量。我们只需将 `using` 子句放在函数的参数列表之后；若函数没有参数，则直接放在括号内即可。
+
+```yuescript
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- 这里创建了一个新的局部变量
+
+my_func!
+print i -- 打印 100，i 没有受到影响
+```
+
+<YueDisplay>
+
+```yue
+i = 100
+
+my_func = (using nil) ->
+  i = "hello" -- 这里创建了一个新的局部变量
+
+my_func!
+print i -- 打印 100，i 没有受到影响
+```
+
+</YueDisplay>
+
+&emsp;&emsp;using子句中可以填写多个用逗号分隔名称。指定可以访问和修改的外部变量的名称：
+
+```yuescript
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- 创建了一个新的局部tmp
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- 这些已经被更新
+```
+
+<YueDisplay>
+
+```yue
+tmp = 1213
+i, k = 100, 50
+
+my_func = (add using k, i) ->
+  tmp = tmp + add -- 创建了一个新的局部tmp
+  i += tmp
+  k += tmp
+
+my_func(22)
+print i, k -- 这些已经被更新
+```
+
+</YueDisplay>
+
+# 使用方法
+
+## Lua 模块
+
+&emsp;&emsp;在 Lua 中使用月之脚本模块：
+
+- **用法 1**
+
+  &emsp;&emsp;在 Lua 中引入 "你的脚本入口文件.yue"。
+
+  ```Lua
+  require("yue")("你的脚本入口文件")
+  ```
+
+  &emsp;&emsp;当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import** 进行脚本引用即可。错误消息中的代码行号也会被正确处理。
+
+- **用法 2**
+
+  &emsp;&emsp;手动引入月之脚本模块并重写错误消息来帮助调试。
+
+  ```lua
+  local yue = require("yue")
+  yue.insert_loaders()
+  local success, result = xpcall(function()
+    return require("yuescript_module_name")
+  end, function(err)
+    return yue.traceback(err)
+  end)
+  ```
+
+- **用法 3**
+
+  &emsp;&emsp;在 Lua 中使用月之脚本编译器功能。
+
+  ```lua
+  local yue = require("yue")
+  local codes, err, globals = yue.to_lua([[
+  f = ->
+    print "hello world"
+  f!
+  ]],{
+    implicit_return_root = true,
+    reserve_line_number = true,
+    lint_global = true,
+    space_over_tab = false,
+    options = {
+      target = "5.4",
+      path = "/script"
+    }
+  })
+  ```
+
+## 月之脚本编译工具
+
+&emsp;&emsp;使用月之脚本编译工具：
+
+```shell
+> yue -h
+命令行用法: yue
+         [选项] [<文件/目录>] ...
+         yue -e <代码或文件> [参数...]
+         yue -w [<目录>] [选项]
+         yue -
+
+说明:
+   - '-' 或 '--' 必须作为唯一且第一个参数，用于读取标准输入。
+   - '-o/--output' 不能与多个输入文件一起使用。
+   - '-w/--watch' 仅能用于目录，不能用于单个文件。
+   - 使用 '-e/--execute' 时，后续的参数将作为脚本参数传递。
+
+选项:
+   -h, --help                 显示帮助信息并退出
+   -e <字符串>, --execute <字符串>  执行文件或原始代码
+   -m, --minify               生成压缩（最小化）代码
+   -r, --rewrite              重写输出以匹配原始代码行号
+   -t <目标路径>, --output-to <目标路径>
+                              指定编译后文件的输出路径
+   -o <文件>, --output <文件>  将输出写入文件
+   -p, --print                输出到标准输出
+   -b, --benchmark            输出编译耗时（不写入文件）
+   -g, --globals              显示用到的全局变量及其所在的名称、行号、列号
+   -s, --spaces               用空格代替制表符(tab)输出代码
+   -l, --line-numbers         输出源代码的行号
+   -j, --no-implicit-return   禁用文件末尾的隐式返回
+   -c, --reserve-comments     保留源代码中的注释
+   -w [<目录>], --watch [<目录>]
+                              监视目录变化并自动编译
+   -v, --version              显示版本信息
+   -                          从标准输入读取，输出到标准输出（仅能作为唯一参数）
+   --                         等同于 '-'，为兼容旧版本保留
+
+   --target <版本>            指定生成代码的 Lua 版本 (只能为 5.1 ~ 5.5)
+   --path <路径字符串>         附加一个 Lua 搜索路径到 package.path
+   --<键>=<值>                以 key=value 形式传递编译器选项（保持已有用法）
+
+   不带选项直接运行可进入交互模式（REPL），在交互模式里输入单独的符号 '$'
+   可用于开始或结束多行模式。
+```
+
+&emsp;&emsp;使用案例：
+
+&emsp;&emsp;递归编译当前路径下扩展名为 **.yue** 的每个月之脚本文件： **yue .**
+
+&emsp;&emsp;编译并将结果保存到目标路径： **yue -t /target/path/ .**
+
+&emsp;&emsp;编译并保留调试信息： **yue -l .**
+
+&emsp;&emsp;编译并生成压缩代码： **yue -m .**
+
+&emsp;&emsp;直接执行代码： **yue -e 'print 123'**
+
+&emsp;&emsp;执行一个月之脚本文件： **yue -e main.yue**
+
+# 介绍
+
+月之脚本（YueScript）是一种动态语言，可以编译为 Lua。它是 [MoonScript](https://github.com/leafo/moonscript) 的方言。用月之脚本编写的代码既有表现力又非常简洁。它适合编写一些更易于维护的代码，并在嵌入 Lua 的环境中运行，如游戏或网站服务器。
+
+Yue（月）是中文中“月亮”的名称。
+
+## 月之脚本概览
+
+```yuescript
+-- 导入语法
+import p, to_lua from "yue"
+
+-- 隐式对象
+inventory =
+  equipment:
+    - "sword"
+    - "shield"
+  items:
+    - name: "potion"
+      count: 10
+    - name: "bread"
+      count: 3
+
+-- 列表推导
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
+-- 管道操作符
+[1, 2, 3]
+  |> map (x) -> x * 2
+  |> filter (x) -> x > 4
+  |> reduce 0, (a, b) -> a + b
+  |> print
+
+-- 元表操作
+apple =
+  size: 15
+  <index>:
+    color: 0x00ffff
+
+with apple
+  p .size, .color, .<index> if .<>?
+
+-- 类似js的导出语法
+export 🌛 = "月之脚本"
+```
+
+<YueDisplay>
+
+```yue
+-- 导入语法
+import p, to_lua from "yue"
+
+-- 隐式对象
+inventory =
+  equipment:
+    - "sword"
+    - "shield"
+  items:
+    - name: "potion"
+      count: 10
+    - name: "bread"
+      count: 3
+
+-- 列表推导
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
+-- 管道操作符
+[1, 2, 3]
+  |> map (x) -> x * 2
+  |> filter (x) -> x > 4
+  |> reduce 0, (a, b) -> a + b
+  |> print
+
+-- 元表操作
+apple =
+  size: 15
+  <index>:
+    color: 0x00ffff
+
+with apple
+  p .size, .color, .<index> if .<>?
+
+-- 类似js的导出语法
+export 🌛 = "月之脚本"
+```
+
+</YueDisplay>
+
+## 关于 Dora SSR
+
+月之脚本是与开源游戏引擎 [Dora SSR](https://github.com/Dora-SSR/Dora-SSR) 一起开发和维护的。它已被用于创建引擎工具、游戏原型和演示，在实际的游戏项目中验证其能力，同时它也帮助增强了 Dora SSR 游戏引擎的开发体验。
+
+# 安装
+
+## Lua 模块
+
+&emsp;安装 [luarocks](https://luarocks.org)，一个 Lua 模块的包管理器。然后作为 Lua 模块和可执行文件安装它：
+
+```shell
+luarocks install yuescript
+```
+
+&emsp;或者你可以自己构建 `yue.so` 文件：
+
+```shell
+make shared LUAI=/usr/local/include/lua LUAL=/usr/local/lib/lua
+```
+
+&emsp;然后从路径 **bin/shared/yue.so** 获取二进制文件。
+
+## 构建二进制工具
+
+&emsp;克隆项目仓库，然后构建并安装可执行文件：
+
+```shell
+make install
+```
+
+&emsp;构建不带宏功能的月之脚本编译工具：
+
+```shell
+make install NO_MACRO=true
+```
+
+&emsp;构建不带内置Lua二进制文件的月之脚本编译工具：
+
+```shell
+make install NO_LUA=true
+```
+
+## 下载预编译的二进制程序
+
+&emsp;你可以下载预编译的二进制程序，包括兼容不同 Lua 版本的二进制可执行文件和库文件。
+
+&emsp;在[这里](https://github.com/IppClub/YueScript/releases)下载预编译的二进制程序。
+
+# 条件语句
+
+```yuescript
+have_coins = false
+if have_coins
+  print "有硬币"
+else
+  print "没有硬币"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins
+  print "有硬币"
+else
+  print "没有硬币"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;对于简单的语句，也可以使用简短的语法：
+
+```yuescript
+have_coins = false
+if have_coins then print "有硬币" else print "没有硬币"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+if have_coins then print "有硬币" else print "没有硬币"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;因为 if 语句可以用作表达式，所以也可以这样写：
+
+```yuescript
+have_coins = false
+print if have_coins then "有硬币" else "没有硬币"
+```
+
+<YueDisplay>
+
+```yue
+have_coins = false
+print if have_coins then "有硬币" else "没有硬币"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;条件语句也可以作为表达式用在返回语句和赋值语句中：
+
+```yuescript
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "我很高"
+else
+  "我不是很高"
+
+print message -- 打印: 我很高
+```
+
+<YueDisplay>
+
+```yue
+is_tall = (name) ->
+  if name == "Rob"
+    true
+  else
+    false
+
+message = if is_tall "Rob"
+  "我很高"
+else
+  "我不是很高"
+
+print message -- 打印: 我很高
+```
+
+</YueDisplay>
+
+&emsp;&emsp;if 的反义词是 unless（相当于 if not，正如“如果”对应“除非”）：
+
+```yuescript
+unless os.date("%A") == "Monday"
+  print "今天不是星期一！"
+```
+
+<YueDisplay>
+
+```yue
+unless os.date("%A") == "Monday"
+  print "今天不是星期一！"
+```
+
+</YueDisplay>
+
+```yuescript
+print "你真幸运！" unless math.random! > 0.1
+```
+
+<YueDisplay>
+
+```yue
+print "你真幸运！" unless math.random! > 0.1
+```
+
+</YueDisplay>
+
+## 范围表达式
+
+&emsp;&emsp;你可以使用范围表达式来编写进行范围检查的代码。
+
+```yuescript
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "检查离散值的相等性"
+
+if a in list
+  print "检查`a`是否在列表中"
+```
+
+<YueDisplay>
+
+```yue
+a = 5
+
+if a in [1, 3, 5, 7]
+  print "检查离散值的相等性"
+
+if a in list
+  print "检查`a`是否在列表中"
+```
+
+</YueDisplay>
+
+# for 循环
+
+&emsp;&emsp;Lua 中有两种 for 循环形式，数字型和通用型：
+
+```yuescript
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- 提供了一个遍历的步长
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+
+<YueDisplay>
+
+```yue
+for i = 10, 20
+  print i
+
+for k = 1, 15, 2 -- 提供了一个遍历的步长
+  print k
+
+for key, value in pairs object
+  print key, value
+```
+
+</YueDisplay>
+
+&emsp;&emsp;可以使用切片和 **\*** 操作符，就像在列表推导中一样：
+
+```yuescript
+for item in *items[2, 4]
+  print item
+```
+
+<YueDisplay>
+
+```yue
+for item in *items[2, 4]
+  print item
+```
+
+</YueDisplay>
+
+&emsp;&emsp;当代码语句只有一行时，循环语句也都可以写作更短的语法：
+
+```yuescript
+for item in *items do print item
+
+for j = 1, 10, 3 do print j
+```
+
+<YueDisplay>
+
+```yue
+for item in *items do print item
+
+for j = 1, 10, 3 do print j
+```
+
+</YueDisplay>
+
+&emsp;&emsp;for 循环也可以用作表达式。for 循环主体中的最后一条语句会被强制转换为一个返回值的表达式，并会将表达式计算结果的值追加到一个作为结果的数组表中。
+
+&emsp;&emsp;将每个偶数加倍：
+
+```yuescript
+doubled_evens = for i = 1, 20
+  if i % 2 == 0
+    i * 2
+  else
+    i
+```
+
+<YueDisplay>
+
+```yue
+doubled_evens = for i = 1, 20
+  if i % 2 == 0
+    i * 2
+  else
+    i
+```
+
+</YueDisplay>
+
+&emsp;&emsp;此外，for 循环还支持带返回值的 break 语句，这样循环本身就可以作为一个表达式，在满足条件时提前退出并返回有意义的结果。for 循环表达式支持 `break` 返回多个值。
+
+&emsp;&emsp;例如，查找第一个大于 10 的数字：
+
+```yuescript
+first_large = for n in *numbers
+  break n if n > 10
+```
+
+<YueDisplay>
+
+```yue
+first_large = for n in *numbers
+  break n if n > 10
+```
+
+</YueDisplay>
+
+```yuescript
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+<YueDisplay>
+
+```yue
+key, score = for k, v in pairs data
+  break k, v * 10 if k == "target"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你还可以结合 for 循环表达式与 continue 语句来过滤值。
+
+&emsp;&emsp;注意出现在函数体末尾的 for 循环，不会被当作是一个表达式并将循环结果累积到一个列表中作为返回值（相反，函数将返回 nil）。如果要函数末尾的循环转换为列表表达式，可以显式地使用返回语句加 for 循环表达式。
+
+```yuescript
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- 打印 nil
+print func_b! -- 打印 table 对象
+```
+
+<YueDisplay>
+
+```yue
+func_a = -> for i = 1, 10 do print i
+func_b = -> return for i = 1, 10 do i
+
+print func_a! -- 打印 nil
+print func_b! -- 打印 table 对象
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这样做是为了避免在不需要返回循环结果的函数，创建无效的返回值表格。
+
+# continue 语句
+
+&emsp;&emsp;继续语句可以用来跳出当前的循环迭代。
+
+```yuescript
+i = 0
+while i < 10
+  i += 1
+  continue if i % 2 == 0
+  print i
+```
+
+<YueDisplay>
+
+```yue
+i = 0
+while i < 10
+  i += 1
+  continue if i % 2 == 0
+  print i
+```
+
+</YueDisplay>
+
+&emsp;&emsp;继续语句也可以与各种循环表达式一起使用，以防止当前的循环迭代结果累积到结果列表中。以下示例将数组表过滤为仅包含偶数的数组：
+
+```yuescript
+my_numbers = [1, 2, 3, 4, 5, 6]
+odds = for x in *my_numbers
+  continue if x % 2 == 1
+  x
+```
+
+<YueDisplay>
+
+```yue
+my_numbers = [1, 2, 3, 4, 5, 6]
+odds = for x in *my_numbers
+  continue if x % 2 == 1
+  x
+```
+
+</YueDisplay>
+
+# switch 语句
+
+&emsp;&emsp;switch 语句是为了简化检查一系列相同值的if语句而提供的简写语法。要注意用于比较检查的目标值只会计算一次。和 if 语句一样，switch 语句在最后可以接一个 else 代码块来处理没有匹配的情况。在生成的 Lua 代码中，进行比较是使用 == 操作符完成的。switch 语句中也可以使用赋值表达式来储存临时变量值。
+
+```yuescript
+switch name := "Dan"
+  when "Robert"
+    print "你是Robert"
+  when "Dan", "Daniel"
+    print "你的名字是Dan"
+  else
+    print "我不认识你，你的名字是#{name}"
+```
+
+<YueDisplay>
+
+```yue
+switch name := "Dan"
+  when "Robert"
+    print "你是Robert"
+  when "Dan", "Daniel"
+    print "你的名字是Dan"
+  else
+    print "我不认识你，你的名字是#{name}"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;switch 语句的 when 子句中可以通过使用逗号分隔的列表来匹配多个值。
+
+&emsp;&emsp;switch 语句也可以作为表达式使用，下面我们可以将 switch 语句返回的结果分配给一个变量：
+
+```yuescript
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "数字数得太大了！"
+```
+
+<YueDisplay>
+
+```yue
+b = 1
+next_number = switch b
+  when 1
+    2
+  when 2
+    3
+  else
+    error "数字数得太大了！"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;我们可以使用 then 关键字在 when 子句的同一行上编写处理代码。else 代码块的后续代码中要写在同一行上不需要额外的关键字。
+
+```yuescript
+msg = switch math.random(1, 5)
+  when 1 then "你很幸运"
+  when 2 then "你差点很幸运"
+  else "不太幸运"
+```
+
+<YueDisplay>
+
+```yue
+msg = switch math.random(1, 5)
+  when 1 then "你很幸运"
+  when 2 then "你差点很幸运"
+  else "不太幸运"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果在编写 switch 语句时希望少写一个缩进，那么你可以把第一个 when 子句放在 switch 开始语句的第一行，然后后续的子语句就都可以都少写一个缩进。
+
+```yuescript
+switch math.random(1, 5)
+  when 1
+    print "你很幸运" -- 两个缩进级别
+  else
+    print "不太幸运"
+
+switch math.random(1, 5) when 1
+  print "你很幸运" -- 一个缩进级别
+else
+  print "不太幸运"
+```
+
+<YueDisplay>
+
+```yue
+switch math.random(1, 5)
+  when 1
+    print "你很幸运" -- 两个缩进级别
+  else
+    print "不太幸运"
+
+switch math.random(1, 5) when 1
+  print "你很幸运" -- 一个缩进级别
+else
+  print "不太幸运"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;值得注意的是，在生成 Lua 代码时，我们要做检查的目标变量会放在 == 表达式的右侧。当你希望给 when 子句的比较对象定义一个 \_\_eq 元方法来重载判断逻辑时，可能会有用。
+
+## 表格匹配
+
+&emsp;&emsp;在 switch 的 when 子句中，如果期待检查目标是一个表格，且可以通过特定的结构进行解构并获得非 nil 值，那么你可以尝试使用表格匹配的语法。
+
+```yuescript
+items =
+  * x: 100
+    y: 200
+  * width: 300
+    height: 400
+
+for item in *items
+  switch item
+    when :x, :y
+      print "Vec2 #{x}, #{y}"
+    when :width, :height
+      print "尺寸 #{width}, #{height}"
+```
+
+<YueDisplay>
+
+```yue
+items =
+  * x: 100
+    y: 200
+  * width: 300
+    height: 400
+
+for item in *items
+  switch item
+    when :x, :y
+      print "Vec2 #{x}, #{y}"
+    when :width, :height
+      print "尺寸 #{width}, #{height}"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你可以使用默认值来选择性地解构表格的某些字段。
+
+```yuescript
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- 获取错误：尝试索引nil值（字段'pos'）
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- 表格解构仍然会通过
+```
+
+<YueDisplay>
+
+```yue
+item = {}
+
+{pos: {:x = 50, :y = 200}} = item -- 获取错误：尝试索引nil值（字段'pos'）
+
+switch item
+  when {pos: {:x = 50, :y = 200}}
+    print "Vec2 #{x}, #{y}" -- 表格解构仍然会通过
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你也可以匹配数组元素、表格字段，甚至使用数组或表格字面量来匹配嵌套的结构。
+
+&emsp;&emsp;匹配数组元素。
+
+```yuescript
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- 变量b有默认值
+    print "1, 2, #{b}"
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- 变量b有默认值
+    print "1, 2, #{b}"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;匹配表格字段。
+
+```yuescript
+switch tb
+  when success: true, :result
+    print "成功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when success: true, :result
+    print "成功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;匹配嵌套的表格结构。
+
+```yuescript
+switch tb
+  when data: {type: "success", :content}
+    print "成功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when data: {type: "success", :content}
+    print "成功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;匹配表格数组。
+
+```yuescript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹配成功", fourth
+```
+
+<YueDisplay>
+
+```yue
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹配成功", fourth
+```
+
+</YueDisplay>
+
+&emsp;&emsp;匹配一个列表并捕获特定范围内的元素。
+
+```yuescript
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Group:", groups -- 打印: {"admin", "users"}
+    print "Resource:", resource -- 打印: "logs"
+    print "Action:", action -- 打印: "view"
+```
+
+<YueDisplay>
+
+```yue
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Group:", groups -- 打印: {"admin", "users"}
+    print "Resource:", resource -- 打印: "logs"
+    print "Action:", action -- 打印: "view"
+```
+
+</YueDisplay>
+
+# while 循环
+
+&emsp;&emsp;在月之脚本中的 while 循环支持几种不同的写法：
+
+```yuescript
+i = 10
+while i > 0
+  print i
+  i -= 1
+
+while running == true do my_function!
+```
+
+<YueDisplay>
+
+```yue
+i = 10
+while i > 0
+  print i
+  i -= 1
+
+while running == true do my_function!
+```
+
+</YueDisplay>
+
+```yuescript
+i = 10
+until i == 0
+  print i
+  i -= 1
+
+until running == false do my_function!
+```
+
+<YueDisplay>
+
+```yue
+i = 10
+until i == 0
+  print i
+  i -= 1
+until running == false do my_function!
+```
+
+</YueDisplay>
+
+&emsp;&emsp;像 for 循环的语法一样，while 循环也可以作为一个表达式使用。while / until 循环表达式支持 `break` 返回多个值。
+
+```yuescript
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+<YueDisplay>
+
+```yue
+value, doubled = while true
+  n = get_next!
+  break n, n * 2 if n > 10
+```
+
+</YueDisplay>
+
+&emsp;&emsp;为了使函数返回 while 循环的累积列表值，必须明确使用返回语句返回 while 循环表达式。
+
+## repeat 循环
+
+&emsp;&emsp;repeat 循环是从 Lua 语言中搬过来的相似语法：
+
+```yuescript
+i = 10
+repeat
+  print i
+  i -= 1
+until i == 0
+```
+
+<YueDisplay>
+
+```yue
+i = 10
+repeat
+  print i
+  i -= 1
+until i == 0
+```
+
+</YueDisplay>
+
+&emsp;&emsp;repeat 循环表达式同样支持 `break` 返回多个值：
+
+```yuescript
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+<YueDisplay>
+
+```yue
+i = 1
+value, scaled = repeat
+  break i, i * 100 if i > 3
+  i += 1
+until false
+```
+
+</YueDisplay>
+
+# 函数存根
+
+&emsp;&emsp;在编程中，将对象的方法作为函数类型的值进行传递是一种常见做法，尤其是在将实例方法作为回调函数传递给其他函数的情形中。当目标函数需要将该对象作为其第一个参数时，我们需要找到一种方式将对象和函数绑定在一起，以便能够正确地调用该函数。
+
+&emsp;&emsp;函数存根（stub）语法提供了一种便捷的方法来创建一个新的闭包函数，这个函数将对象和原函数绑定在一起。这样，当调用这个新创建的函数时，它会在正确的对象上下文中执行原有的函数。
+
+&emsp;&emsp;这种语法类似于使用 \ 操作符调用实例方法的方式，区别在于，这里不需要在 \ 操作符后面附加参数列表。
+
+```yuescript
+my_object = {
+  value: 1000
+  write: => print "值为:", @value
+}
+
+run_callback = (func) ->
+  print "运行回调..."
+  func!
+
+-- 这样写不起作用：
+-- 函数没有引用my_object
+run_callback my_object.write
+
+-- 函数存根语法
+-- 让我们把对象捆绑到一个新函数中
+run_callback my_object\write
+```
+
+<YueDisplay>
+
+```yue
+my_object = {
+  value: 1000
+  write: => print "值为:", @value
+}
+
+run_callback = (func) ->
+  print "运行回调..."
+  func!
+
+-- 这样写不起作用：
+-- 函数没有引用my_object
+run_callback my_object.write
+
+-- 函数存根语法
+-- 让我们把对象捆绑到一个新函数中
+run_callback my_object\write
+```
+
+</YueDisplay>
+
+# 反向回调
+
+&emsp;&emsp;反向回调用于减少函数回调的嵌套。它们使用指向左侧的箭头，并且默认会被定义为传入后续函数调用的最后一个参数。它的语法大部分与常规箭头函数相同，只是它指向另一方向，并且后续的函数体不需要进行缩进。
+
+```yuescript
+x <- f
+print "hello" .. x
+```
+
+<YueDisplay>
+
+```yue
+x <- f
+print "hello" .. x
+```
+
+</YueDisplay>
+
+&emsp;&emsp;月之脚本也提供了粗箭头反向回调函数。
+
+```yuescript
+<= f
+print @value
+```
+
+<YueDisplay>
+
+```yue
+<= f
+print @value
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你可以通过一个占位符指定回调函数的传参位置。
+
+```yuescript
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+<YueDisplay>
+
+```yue
+(x) <- map _, [1, 2, 3]
+x * 2
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果你希望在反向回调处理后继续编写更多其它的代码，可以使用 do 语句将不属于反向回调的代码分隔开。对于非粗箭头函数的反向回调，回调返回值的括号也是可以省略的。
+
+```yuescript
+result, msg = do
+  data <- readAsync "文件名.txt"
+  print data
+  info <- processAsync data
+  check info
+print result, msg
+```
+
+<YueDisplay>
+
+```yue
+result, msg = do
+  data <- readAsync "文件名.txt"
+  print data
+  info <- processAsync data
+  check info
+print result, msg
+```
+
+</YueDisplay>
+
+# 函数字面量
+
+&emsp;&emsp;所有函数都是使用月之脚本的函数表达式创建的。一个简单的函数可以用箭头表示为：**->**。
+
+```yuescript
+my_function = ->
+my_function() -- 调用空函数
+```
+
+<YueDisplay>
+
+```yue
+my_function = ->
+my_function() -- 调用空函数
+```
+
+</YueDisplay>
+
+&emsp;&emsp;函数体可以是紧跟在箭头后的一个语句，或者是在后面的行上使用同样缩进的一系列语句：
+
+```yuescript
+func_a = -> print "你好，世界"
+
+func_b = ->
+  value = 100
+  print "这个值是：", value
+```
+
+<YueDisplay>
+
+```yue
+func_a = -> print "你好，世界"
+
+func_b = ->
+  value = 100
+  print "这个值是：", value
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果一个函数没有参数，可以使用 **\!** 操作符调用它，而不是空括号。使用 **\!** 调用没有参数的函数是推荐的写法。
+
+```yuescript
+func_a!
+func_b()
+```
+
+<YueDisplay>
+
+```yue
+func_a!
+func_b()
+```
+
+</YueDisplay>
+
+&emsp;&emsp;带有参数的函数可以通过在箭头前加上括号中的参数名列表来进行创建：
+
+```yuescript
+sum = (x, y) -> print "数字的和", x + y
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> print "数字的和", x + y
+```
+
+</YueDisplay>
+
+&emsp;&emsp;函数可以通过在函数名后列出参数来调用。当对函数做嵌套的调用时，后面列出的参数会应用于左侧最近的函数。
+
+```yuescript
+sum 10, 20
+print sum 10, 20
+
+a b c "a", "b", "c"
+```
+
+<YueDisplay>
+
+```yue
+sum 10, 20
+print sum 10, 20
+
+a b c "a", "b", "c"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;为了避免在调用函数时产生歧义，也可以使用括号将参数括起来。比如在以下的例子中是必需的，这样才能确保参数被传入到正确的函数。
+
+```yuescript
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+<YueDisplay>
+
+```yue
+print "x:", sum(10, 20), "y:", sum(30, 40)
+```
+
+</YueDisplay>
+
+&emsp;&emsp;注意：函数名与开始括号之间不能有任何空格。
+
+&emsp;&emsp;函数会将函数体中的最后一个语句强制转换为返回语句，这被称作隐式返回：
+
+```yuescript
+sum = (x, y) -> x + y
+print "数字的和是", sum 10, 20
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> x + y
+print "数字的和是", sum 10, 20
+```
+
+</YueDisplay>
+
+&emsp;&emsp;如果你需要做显式返回，可以使用 return 关键字：
+
+```yuescript
+sum = (x, y) -> return x + y
+```
+
+<YueDisplay>
+
+```yue
+sum = (x, y) -> return x + y
+```
+
+</YueDisplay>
+
+&emsp;&emsp;就像在Lua中一样，函数可以返回多个值。最后一个语句必须是由逗号分隔的值列表：
+
+```yuescript
+mystery = (x, y) -> x + y, x - y
+a, b = mystery 10, 20
+```
+
+<YueDisplay>
+
+```yue
+mystery = (x, y) -> x + y, x - y
+a, b = mystery 10, 20
+```
+
+</YueDisplay>
+
+## 粗箭头
+
+&emsp;&emsp;因为在 Lua 中调用方法时，经常习惯将对象作为第一个参数传入，所以月之脚本提供了一种特殊的语法来创建自动包含 self 参数的函数。
+
+```yuescript
+func = (num) => @value + num
+```
+
+<YueDisplay>
+
+```yue
+func = (num) => @value + num
+```
+
+</YueDisplay>
+
+## 参数默认值
+
+&emsp;&emsp;可以为函数的参数提供默认值。如果参数的值为 nil，则确定该参数为空。任何具有默认值的 nil 参数在函数体运行之前都会被替换。
+
+```yuescript
+my_function = (name = "某物", height = 100) ->
+  print "你好，我是", name
+  print "我的高度是", height
+```
+
+<YueDisplay>
+
+```yue
+my_function = (name = "某物", height = 100) ->
+  print "你好，我是", name
+  print "我的高度是", height
+```
+
+</YueDisplay>
+
+&emsp;&emsp;函数参数的默认值表达式在函数体中会按参数声明的顺序进行计算。因此，在默认值的表达式中可以访问先前声明的参数。
+
+```yuescript
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+<YueDisplay>
+
+```yue
+some_args = (x = 100, y = x + 1000) ->
+  print x + y
+```
+
+</YueDisplay>
+
+## 注意事项
+
+&emsp;&emsp;由于月之脚本支持无需括号的表达式式函数调用，因此为了避免因空白字符造成的解析歧义，需要进行一些限制。
+
+&emsp;&emsp;减号（-）在表达式中既可以作为一元取反操作符，也可以作为二元减法操作符。请注意下面这些示例的编译方式：
+
+```yuescript
+a = x - 10
+b = x-10
+c = x -y
+d = x- z
+```
+
+<YueDisplay>
+
+```yue
+a = x - 10
+b = x-10
+c = x -y
+d = x- z
+```
+
+</YueDisplay>
+
+&emsp;&emsp;当函数调用的第一个参数是字符串字面量时，可以通过空白控制其优先级。在 Lua 中，常见的写法是调用仅有一个字符串或表字面量参数的函数时省略括号。
+
+&emsp;&emsp;当变量名和字符串字面量之间没有空格时，函数的调用优先级高于后续表达式，因此此时无法再传入其他参数。
+
+&emsp;&emsp;当变量名和字符串字面量之间有空格时，字符串字面量会作为后续表达式（如果存在）的参数，这样可以传递参数列表。
+
+```yuescript
+x = func"hello" + 100
+y = func "hello" + 100
+```
+
+<YueDisplay>
+
+```yue
+x = func"hello" + 100
+y = func "hello" + 100
+```
+
+</YueDisplay>
+
+## 多行参数
+
+&emsp;&emsp;当调用接收大量参数的函数时，将参数列表分成多行是很方便的。由于月之脚本语言对空白字符的敏感性，做参数列表的分割时务必要小心。
+
+&emsp;&emsp;如果要将参数列表写到下一行，那么当前行必须以逗号结束。并且下一行的缩进必须比当前的缩进多。一旦做了参数的缩进，所有其他参数列表的行必须保持相同的缩进级别，以成为参数列表的一部分。
+
+```yuescript
+my_func 5, 4, 3,
+  8, 9, 10
+
+cool_func 1, 2,
+  3, 4,
+  5, 6,
+  7, 8
+```
+
+<YueDisplay>
+
+```yue
+my_func 5, 4, 3,
+  8, 9, 10
+
+cool_func 1, 2,
+  3, 4,
+  5, 6,
+  7, 8
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这种调用方式可以做嵌套。并通过缩进级别来确定参数属于哪一个函数。
+
+```yuescript
+my_func 5, 6, 7,
+  6, another_func 6, 7, 8,
+    9, 1, 2,
+  5, 4
+```
+
+<YueDisplay>
+
+```yue
+my_func 5, 6, 7,
+  6, another_func 6, 7, 8,
+    9, 1, 2,
+  5, 4
+```
+
+</YueDisplay>
+
+&emsp;&emsp;因为 Lua 表也使用逗号作为分隔符，这种缩进语法有助于让值成为参数列表的一部分，而不是 Lua 表的一部分。
+
+```yuescript
+x = [
+  1, 2, 3, 4, a_func 4, 5,
+    5, 6,
+  8, 9, 10
+]
+```
+
+<YueDisplay>
+
+```yue
+x = [
+  1, 2, 3, 4, a_func 4, 5,
+    5, 6,
+  8, 9, 10
+]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;有个不常见的写法可以注意一下，如果我们将在后面使用较低的缩进，我们可以为函数参数提供更深的缩进来区分列表的归属。
+
+```yuescript
+y = [ my_func 1, 2, 3,
+   4, 5,
+  5, 6, 7
+]
+```
+
+<YueDisplay>
+
+```yue
+y = [ my_func 1, 2, 3,
+   4, 5,
+  5, 6, 7
+]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;对于其它有代码块跟随的语句，比如条件语句，也可以通过小心安排缩进来做类似的事。比如我们可以通过调整缩进级别来控制一些值归属于哪个语句：
+
+```yuescript
+if func 1, 2, 3,
+  "你好",
+  "世界"
+    print "你好"
+    print "我在if内部"
+
+if func 1, 2, 3,
+    "你好",
+    "世界"
+  print "hello"
+  print "我在if内部"
+```
+
+<YueDisplay>
+
+```yue
+if func 1, 2, 3,
+  "你好",
+  "世界"
+    print "你好"
+    print "我在if内部"
+
+if func 1, 2, 3,
+    "你好",
+    "世界"
+  print "你好"
+  print "我在if内部"
+```
+
+</YueDisplay>
+
+## 参数解构
+
+&emsp;&emsp;月之脚本支持在函数形参位置对传入对象进行解构。适用两类解构表子面量：
+
+- 使用 {} 包裹的字面量/对象形参，支持提供获得空字段时的默认值（例如 {:a, :b}、{a: a1 = 123}）。
+
+- 无 {} 包裹、以键值/简写键序列开头，直至遇到其它表达式终止（例如 :a, b: b1, :c），表示从同一个对象中解构多个字段。
+
+```yuescript
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+```
+
+<YueDisplay>
+
+```yue
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+```
+
+</YueDisplay>
+
+## 前置返回表达式
+
+&emsp;&emsp;在深度嵌套的函数体中，为了提升返回值的可读性及编写便利性，我们新增了 “前置返回表达式” 语法。其形式如下：
+
+```yuescript
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+```
+
+<YueDisplay>
+
+```yue
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+```
+
+</YueDisplay>
+
+&emsp;&emsp;这个写法等价于：
+
+```yuescript
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+```
+
+<YueDisplay>
+
+```yue
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+```
+
+</YueDisplay>
+
+&emsp;&emsp;唯一的区别在于：你可以将函数的返回值表达式提前写在 `->` 或 `=>` 前，用以指示该函数应隐式返回该表达式的值。这样即使在多层循环或条件判断的场景下，也无需编写尾行悬挂的返回表达式，逻辑结构会更加直观清晰。
+
+## 命名变长参数
+
+&emsp;&emsp;你可以使用 `(...t) ->` 语法来将变长参数自动存储到一个命名表中。这个表会包含所有传入的参数（包括 `nil` 值），并且会在表的 `n` 字段中存储实际传入的参数个数（包括 `nil` 值在内的个数）。
+
+```yuescript
+f = (...t) ->
+  print "参数个数:", t.n
+  print "表长度:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- 处理包含 nil 的情况
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+
+<YueDisplay>
+
+```yue
+f = (...t) ->
+  print "参数个数:", t.n
+  print "表长度:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- 处理包含 nil 的情况
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+
+</YueDisplay>
+
+# 空白
+
+&emsp;&emsp;月之脚本是一个对空白敏感的语言。你必须在相同的缩进中使用空格 **' '** 或制表符 **'\t'** 来编写一些代码块，如函数体、值列表和一些控制块。包含不同空白的表达式可能意味着不同的事情。制表符被视为4个空格，但最好不要混合使用空格和制表符。
+
+## 语句分隔符
+
+&emsp;&emsp;一条语句通常以换行结束。你也可以使用分号 `;` 显式结束一条语句，从而在同一行中编写多条语句：
+
+```yuescript
+a = 1; b = 2; print a + b
+```
+
+<YueDisplay>
+
+```yue
+a = 1; b = 2; print a + b
+```
+
+</YueDisplay>
+
+## 多行链式调用
+
+&emsp;&emsp;你可以使用相同的缩进来编写多行链式函数调用。
+
+```yuescript
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x) -> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value) -> value .. '!'
+  \subscribe print
+```
+
+<YueDisplay>
+
+```yue
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x) -> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value) -> value .. '!'
+  \subscribe print
+```
+
+</YueDisplay>
+
+# 注释
+
+```yuescript
+-- 我是一个注释
+
+str = --[[
+这是一个多行注释。
+没问题。
+]] strA \ -- 注释 1
+  .. strB \ -- 注释 2
+  .. strC
+
+func --[[端口]] 3000, --[[ip]] "192.168.1.1"
+```
+
+<YueDisplay>
+
+```yue
+-- 我是一个注释
+
+str = --[[
+这是一个多行注释。
+没问题。
+]] strA \ -- 注释 1
+  .. strB \ -- 注释 2
+  .. strC
+
+func --[[端口]] 3000, --[[ip]] "192.168.1.1"
+```
+
+</YueDisplay>
+
+# 属性
+
+&emsp;&emsp;月之脚本现在提供了 Lua 5.4 新增的叫做属性的语法支持。在月之脚本编译到的 Lua 目标版本低于 5.4 时，你仍然可以同时使用`const` 和 `close` 的属性声明语法，并获得常量检查和作用域回调的功能。
+
+```yuescript
+const a = 123
+close _ = <close>: -> print "超出范围。"
+```
+
+<YueDisplay>
+
+```yue
+const a = 123
+close _ = <close>: -> print "超出范围。"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你可以对进行解构得到的变量标记为常量。
+
+```yuescript
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+<YueDisplay>
+
+```yue
+const {:a, :b, c, d} = tb
+-- a = 1
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你也可以声明全局变量为常量。
+
+```yuescript
+global const Constant = 123
+-- Constant = 1
+```
+
+<YueDisplay>
+
+```yue
+global const Constant = 123
+-- Constant = 1
+```
+
+</YueDisplay>
+
+# 操作符
+
+&emsp;&emsp;Lua 的所有二元和一元操作符在月之脚本中都是可用的。此外，**!=** 符号是 **~=** 的别名，而 **\\** 或 **::** 均可用于编写链式函数调用，如写作 `tb\func!` 或 `tb::func!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
+
+```yuescript
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+<YueDisplay>
+
+```yue
+tb\func! if tb ~= nil
+tb::func! if tb != nil
+```
+
+</YueDisplay>
+
+## 链式比较
+
+&emsp;&emsp;你可以在月之脚本中进行比较表达式的链式书写：
+
+```yuescript
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- 输出：true
+
+a = 5
+print 1 <= a <= 10
+-- 输出：true
+```
+
+<YueDisplay>
+
+```yue
+print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
+-- 输出：true
+
+a = 5
+print 1 <= a <= 10
+-- 输出：true
+```
+
+</YueDisplay>
+
+&emsp;&emsp;可以注意一下链式比较表达式的求值行为：
+
+```yuescript
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  输出：
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  输出：
+  2
+  1
+  false
+]]
+```
+
+<YueDisplay>
+
+```yue
+v = (x) ->
+  print x
+  x
+
+print v(1) < v(2) <= v(3)
+--[[
+  输出：
+  2
+  1
+  3
+  true
+]]
+
+print v(1) > v(2) <= v(3)
+--[[
+  输出：
+  2
+  1
+  false
+]]
+```
+
+</YueDisplay>
+
+&emsp;&emsp;在上面的例子里，中间的表达式 `v(2)` 仅被计算一次，如果把表达式写成 `v(1) < v(2) and v(2) <= v(3)` 的方式，中间的 `v(2)` 才会被计算两次。在链式比较中，求值的顺序往往是未定义的。所以强烈建议不要在链式比较中使用具有副作用（比如做打印操作）的表达式。如果需要使用有副作用的函数，应明确使用短路 `and` 运算符来做连接。
+
+## 表追加
+
+&emsp;&emsp;**[] =** 操作符用于向 Lua 表的最后插入值。
+
+```yuescript
+tab = []
+tab[] = "Value"
+```
+
+<YueDisplay>
+
+```yue
+tab = []
+tab[] = "Value"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;你还可以使用展开操作符 `...` 来将一个列表中的所有元素追加到另一个列表中：
+
+```yuescript
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA 现在为 [1, 2, 3, 4, 5, 6]
+```
+
+<YueDisplay>
+
+```yue
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA 现在为 [1, 2, 3, 4, 5, 6]
+```
+
+</YueDisplay>
+
+## 表扩展
+
+&emsp;&emsp;你可以使用前置 `...` 操作符在 Lua 表中插入数组表或哈希表。
+
+```yuescript
+parts =
+  * "shoulders"
+  * "knees"
+lyrics =
+  * "head"
+  * ...parts
+  * "and"
+  * "toes"
+
+copy = {...other}
+
+a = {1, 2, 3, x: 1}
+b = {4, 5, y: 1}
+merge = {...a, ...b}
+```
+
+<YueDisplay>
+
+```yue
+parts =
+  * "shoulders"
+  * "knees"
+lyrics =
+  * "head"
+  * ...parts
+  * "and"
+  * "toes"
+
+copy = {...other}
+
+a = {1, 2, 3, x: 1}
+b = {4, 5, y: 1}
+merge = {...a, ...b}
+```
+
+</YueDisplay>
+
+## 表反向索引
+
+&emsp;&emsp;你可以使用 **#** 操作符来反向索引表中的元素。
+
+```yuescript
+last = data.items[#]
+second_last = data.items[#-1]
+data.items[#] = 1
+```
+
+<YueDisplay>
+
+```yue
+last = data.items[#]
+second_last = data.items[#-1]
+data.items[#] = 1
+```
+
+</YueDisplay>
+
+## 元表
+
+&emsp;&emsp;**<>** 操作符可提供元表操作的快捷方式。
+
+### 元表创建
+
+&emsp;&emsp;使用空括号 **<>** 或被 **<>** 包围的元方法键创建普通的 Lua 表。
+
+```yuescript
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+-- 使用与临时变量名相同的字段名，将临时变量赋值给元表
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "超出范围"
+```
+
+<YueDisplay>
+
+```yue
+mt = {}
+add = (right) => <>: mt, value: @value + right.value
+mt.__add = add
+
+a = <>: mt, value: 1
+-- 使用与临时变量名相同的字段名，将临时变量赋值给元表
+b = :<add>, value: 2
+c = <add>: mt.__add, value: 3
+
+d = a + b + c
+print d.value
+
+close _ = <close>: -> print "超出范围"
+```
+
+</YueDisplay>
+
+### 元表访问
+
+&emsp;&emsp;使用 **<>** 或被 **<>** 包围的元方法名或在 **<>** 中编写某些表达式来访问元表。
+
+```yuescript
+-- 使用包含字段 "value" 的元表创建
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+
+<YueDisplay>
+
+```yue
+-- 使用包含字段 "value" 的元表创建
+tb = <"value">: 123
+tb.<index> = tb.<>
+print tb.value
+tb.<> = __index: {item: "hello"}
+print tb.item
+```
+
+</YueDisplay>
+
+### 元表解构
+
+&emsp;&emsp;使用被 **<>** 包围的元方法键解构元表。
+
+```yuescript
+{item, :new, :<close>, <index>: getter} = tb
+print item, new, close, getter
+```
+
+<YueDisplay>
+
+```yue
+{item, :new, :<close>, <index>: getter} = tb
+print item, new, close, getter
+```
+
+</YueDisplay>
+
+## 存在性
+
+&emsp;&emsp;**?** 运算符可以在多种上下文中用来检查存在性。
+
+```yuescript
+func?!
+print abc?["你好 世界"]?.xyz
+
+x = tab?.value
+len = utf8?.len or string?.len or (o) -> #o
+
+if print and x?
+  print x
+
+with? io.open "test.txt", "w"
+  \write "你好"
+  \close!
+```
+
+<YueDisplay>
+
+```yue
+func?!
+print abc?["你好 世界"]?.xyz
+
+x = tab?.value
+len = utf8?.len or string?.len or (o) -> #o
+
+if print and x?
+  print x
+
+with? io.open "test.txt", "w"
+  \write "你好"
+  \close!
+```
+
+</YueDisplay>
+
+## 管道
+
+&emsp;&emsp;与其使用一系列嵌套的函数调用，你还可以考虑使用运算符 **|>** 来传递值。
+
+```yuescript
+"你好" |> print
+1 |> print 2 -- 将管道项作为第一个参数插入
+2 |> print 1, _, 3 -- 带有占位符的管道
+
+-- 多行的管道表达式
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+<YueDisplay>
+
+```yue
+"你好" |> print
+1 |> print 2 -- 将管道项作为第一个参数插入
+2 |> print 1, _, 3 -- 带有占位符的管道
+-- 多行的管道表达式
+readFile "example.txt"
+  |> extract language, {}
+  |> parse language
+  |> emit
+  |> render
+  |> print
+```
+
+</YueDisplay>
+
+## 空值合并
+
+&emsp;&emsp;如果其左操作数不是 **nil**，则nil合并运算符 **??** 返回其左操作数的值；否则，它将计算右操作数并返回其结果。如果左操作数计算结果为非 nil 的值，**??** 运算符将不再计算其右操作数。
+
+```yuescript
+local a, b, c, d
+a = b ?? c ?? d
+func a ?? {}
+
+a ??= false
+```
+
+<YueDisplay>
+
+```yue
+local a, b, c, d
+a = b ?? c ?? d
+func a ?? {}
+a ??= false
+```
+
+</YueDisplay>
+
+## 隐式对象
+
+&emsp;&emsp;你可以在表格块内使用符号 **\*** 或是 **-** 开始编写一系列隐式结构。如果你正在创建隐式对象，对象的字段必须具有相同的缩进。
+
+```yuescript
+-- 赋值时使用隐式对象
+list =
+  * 1
+  * 2
+  * 3
+
+-- 函数调用时使用隐式对象
+func
+  * 1
+  * 2
+  * 3
+
+-- 返回时使用隐式对象
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- 表格时使用隐式对象
+tb =
+  name: "abc"
+
+  values:
+    - "a"
+    - "b"
+    - "c"
+
+  objects:
+    - name: "a"
+      value: 1
+      func: => @value + 1
+      tb:
+        fieldA: 1
+
+    - name: "b"
+      value: 2
+      func: => @value + 2
+      tb: { }
+```
+
+<YueDisplay>
+
+```yue
+-- 赋值时使用隐式对象
+list =
+  * 1
+  * 2
+  * 3
+
+-- 函数调用时使用隐式对象
+func
+  * 1
+  * 2
+  * 3
+
+-- 返回时使用隐式对象
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- 表格时使用隐式对象
+tb =
+  name: "abc"
+
+  values:
+    - "a"
+    - "b"
+    - "c"
+
+  objects:
+    - name: "a"
+      value: 1
+      func: => @value + 1
+      tb:
+        fieldA: 1
+
+    - name: "b"
+      value: 2
+      func: => @value + 2
+      tb: { }
+```
+
+</YueDisplay>
+
+# 字面量
+
+&emsp;&emsp;Lua 中的所有基本字面量都可以在月之脚本中使用。包括数字、字符串、布尔值和 **nil**。
+
+&emsp;&emsp;但与 Lua 不同的是，单引号和双引号字符串内部允许有换行：
+
+```yuescript
+some_string = "这是一个字符串
+  并包括一个换行。"
+
+-- 使用#{}语法可以将表达式插入到字符串字面量中。
+-- 字符串插值只在双引号字符串中可用。
+print "我有#{math.random! * 100}%的把握。"
+```
+
+<YueDisplay>
+
+```yue
+some_string = "这是一个字符串
+  并包括一个换行。"
+
+-- 使用#{}语法可以将表达式插入到字符串字面量中。
+-- 字符串插值只在双引号字符串中可用。
+print "我有#{math.random! * 100}%的把握。"
+```
+
+</YueDisplay>
+
+## 数字字面量
+
+&emsp;&emsp;你可以在数字字面量中使用下划线来增加可读性。
+
+```yuescript
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+
+<YueDisplay>
+
+```yue
+integer = 1_000_000
+hex = 0xEF_BB_BF
+binary = 0B10011
+```
+
+</YueDisplay>
+
+## YAML 风格字符串
+
+&emsp;&emsp;使用 `|` 前缀标记一个多行 YAML 风格字符串：
+
+```yuescript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+<YueDisplay>
+
+```yue
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+
+</YueDisplay>
+
+&emsp;&emsp;其效果类似于原生 Lua 的多行拼接，所有文本（含换行）将被保留下来，并支持 `#{...}` 语法，通过 `tostring(expr)` 插入表达式结果。
+
+&emsp;&emsp;YAML 风格的多行字符串会自动检测首行后最小的公共缩进，并从所有行中删除该前缀空白字符。这让你可以在代码中对齐文本，但输出字符串不会带多余缩进。
+
+```yuescript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+<YueDisplay>
+
+```yue
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+
+</YueDisplay>
+
+&emsp;&emsp;输出字符串中的 foo: 对齐到行首，不会带有函数缩进空格。保留内部缩进的相对结构，适合书写结构化嵌套样式的内容。
+
+&emsp;&emsp;支持自动处理字符中的引号、反斜杠等特殊符号，无需手动转义：
+
+```yuescript
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+
+<YueDisplay>
+
+```yue
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+
+</YueDisplay>
+
+# 模块
+
+## 导入
+
+&emsp;&emsp;导入语句是一个语法糖，用于需要引入一个模块或者从已导入的模块中提取子项目。从模块导入的变量默认为不可修改的常量。
+
+```yuescript
+-- 用作表解构
+do
+  import insert, concat from table
+  -- 当给 insert, concat 变量赋值时，编译器会报告错误
+  import C, Ct, Cmt from require "lpeg"
+  -- 快捷写法引入模块的子项
+  import x, y, z from 'mymodule'
+  -- 使用Python风格的导入
+  from 'module' import a, b, c
+
+-- 快捷地导入一个模块
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- 导入模块后起一个别名使用，或是进行导入模块表的解构
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+<YueDisplay>
+
+```yue
+-- 用作表解构
+do
+  import insert, concat from table
+  -- 当给 insert, concat 变量赋值时，编译器会报告错误
+  import C, Ct, Cmt from require "lpeg"
+  -- 快捷写法引入模块的子项
+  import x, y, z from 'mymodule'
+  -- 使用Python风格的导入
+  from 'module' import a, b, c
+
+-- 快捷地导入一个模块
+do
+  import 'module'
+  import 'module_x'
+  import "d-a-s-h-e-s"
+  import "module.part"
+
+-- 导入模块后起一个别名使用，或是进行导入模块表的解构
+do
+  import "player" as PlayerModule
+  import "lpeg" as :C, :Ct, :Cmt
+  import "export" as {one, two, Something:{umm:{ch}}}
+```
+
+</YueDisplay>
+
+## 导入全局变量
+
+&emsp;&emsp;你可以使用 `import` 将指定的全局变量导入到本地变量中。当导入一系列对全局变量的链式访问时，最后一个访问的字段将被赋值给本地变量。
+
+```yuescript
+do
+  import tostring
+  import table.concat
+  print concat ["a", tostring 1]
+```
+
+<YueDisplay>
+
+```yue
+do
+  import tostring
+  import table.concat
+  print concat ["a", tostring 1]
+```
+
+</YueDisplay>
+
+### 自动全局变量导入
+
+&emsp;&emsp;在一个代码块的顶部写 `import global`，会将当前作用域中尚未显式声明或赋值过的变量名，自动导入为本地常量，并在该语句的位置绑定到同名的全局变量。
+
+&emsp;&emsp;但是在同一作用域中被显式声明为全局的变量不会被自动导入，因此可以继续进行赋值操作。
+
+```yuescript
+do
+  import global
+  print "hello"
+  math.random 3
+  -- print = nil -- 报错：自动导入的全局变量为常量
+
+do
+  -- 被显式声明为全局的变量不会被自动导入
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+
+<YueDisplay>
+
+```yue
+do
+  import global
+  print "hello"
+  math.random 3
+  -- print = nil -- 报错：自动导入的全局变量是常量
+
+do
+  -- 被显式声明为全局的变量不会被自动导入
+  import global
+  global FLAG
+  print FLAG
+  FLAG = 123
+```
+
+</YueDisplay>
+
+## 导出
+
+&emsp;&emsp;导出语句提供了一种简洁的方式来定义当前的模块。
+
+### 命名导出
+
+&emsp;&emsp;带命名的导出将定义一个局部变量，并在导出的表中添加一个同名的字段。
+
+```yuescript
+export a, b, c = 1, 2, 3
+export cool = "cat"
+
+export What = if this
+  "abc"
+else
+  "def"
+
+export y = ->
+  hallo = 3434
+
+export class Something
+  umm: "cool"
+```
+
+<YueDisplay>
+
+```yue
+export a, b, c = 1, 2, 3
+export cool = "cat"
+
+export What = if this
+  "abc"
+else
+  "def"
+
+export y = ->
+  hallo = 3434
+
+export class Something
+  umm: "cool"
+```
+
+</YueDisplay>
+
+&emsp;&emsp;使用解构进行命名导出。
+
+```yuescript
+export :loadstring, to_lua: tolua = yue
+export {itemA: {:fieldA = '默认值'}} = tb
+```
+
+<YueDisplay>
+
+```yue
+export :loadstring, to_lua: tolua = yue
+export {itemA: {:fieldA = '默认值'}} = tb
+```
+
+</YueDisplay>
+
+&emsp;&emsp;从模块导出命名项目时，可以不用创建局部变量。
+
+```yuescript
+export.itemA = tb
+export.<index> = items
+export["a-b-c"] = 123
+```
+
+<YueDisplay>
+
+```yue
+export.itemA = tb
+export.<index> = items
+export["a-b-c"] = 123
+```
+
+</YueDisplay>
+
+### 未命名导出
+
+&emsp;&emsp;未命名导出会将要导出的目标项目添加到导出表的数组部分。
+
+```yuescript
+d, e, f = 3, 2, 1
+export d, e, f
+
+export if this
+  123
+else
+  456
+
+export with tmp
+  j = 2000
+```
+
+<YueDisplay>
+
+```yue
+d, e, f = 3, 2, 1
+export d, e, f
+
+export if this
+  123
+else
+  456
+
+export with tmp
+  j = 2000
+```
+
+</YueDisplay>
+
+### 默认导出
+
+&emsp;&emsp;在导出语句中使用 **default** 关键字，来替换导出的表为一个目标的对象。
+
+```yuescript
+export default ->
+  print "你好"
+  123
+```
+
+<YueDisplay>
+
+```yue
+export default ->
+  print "你好"
+  123
+```
+
+</YueDisplay>
+
+# MIT 许可证
+
+版权 (c) 2017-2026 李瑾 \<dragon-fly@qq.com\>
+
+特此免费授予任何获得本软件副本和相关文档文件（下称“软件”）的人不受限制地处置该软件的权利，包括不受限制地使用、复制、修改、合并、发布、分发、转授许可和/或出售该软件副本，以及再授权被配发了本软件的人如上的权利，须在下列条件下：
+上述版权声明和本许可声明应包含在该软件的所有副本或实质成分中。
+本软件是“如此”提供的，没有任何形式的明示或暗示的保证，包括但不限于对适销性、特定用途的适用性和不侵权的保证。在任何情况下，作者或版权持有人都不对任何索赔、损害或其他责任负责，无论这些追责来自合同、侵权或其它行为中，还是产生于、源于或有关于本软件以及本软件的使用或其它处置。
+
+# 月之脚本语言库
+
+在 Lua 中使用 `local yue = require("yue")` 来访问。
+
+## yue
+
+**描述：**
+
+月之脚本语言库。
+
+### version
+
+**类型：** 成员变量。
+
+**描述：**
+
+月之脚本版本。
+
+**签名：**
+
+```lua
+version: string
+```
+
+### dirsep
+
+**类型：** 成员变量。
+
+**描述：**
+
+当前平台的文件分隔符。
+
+**签名：**
+
+```lua
+dirsep: string
+```
+
+### yue_compiled
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译模块代码缓存。
+
+**签名：**
+
+```lua
+yue_compiled: {string: string}
+```
+
+### to_lua
+
+**类型：** 函数。
+
+**描述：**
+
+月之脚本的编译函数。它将 YueScript 代码编译为 Lua 代码。
+
+**签名：**
+
+```lua
+to_lua: function(code: string, config?: Config):
+    --[[codes]] string | nil,
+    --[[error]] string | nil,
+    --[[globals]] {{string, integer, integer}} | nil
+```
+
+**参数：**
+
+| 参数名 | 类型   | 描述                |
+| ------ | ------ | ------------------- |
+| code   | string | YueScript 代码。    |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型                            | 描述                                                                                       |
+| ----------------------------------- | ------------------------------------------------------------------------------------------ |
+| string \| nil                       | 编译后的 Lua 代码，如果编译失败则为 nil。                                                  |
+| string \| nil                       | 错误消息，如果编译成功则为 nil。                                                           |
+| {{string, integer, integer}} \| nil | 代码中出现的全局变量（带有名称、行和列），如果编译器选项 `lint_global` 为 false 则为 nil。 |
+
+### file_exist
+
+**类型：** 函数。
+
+**描述：**
+
+检查源文件是否存在的函数。可以覆盖该函数以自定义行为。
+
+**签名：**
+
+```lua
+file_exist: function(filename: string): boolean
+```
+
+**参数：**
+
+| 参数名   | 类型   | 描述     |
+| -------- | ------ | -------- |
+| filename | string | 文件名。 |
+
+**返回值：**
+
+| 返回类型 | 描述           |
+| -------- | -------------- |
+| boolean  | 文件是否存在。 |
+
+### read_file
+
+**类型：** 函数。
+
+**描述：**
+
+读取源文件的函数。可以覆盖该函数以自定义行为。
+
+**签名：**
+
+```lua
+read_file: function(filename: string): string
+```
+
+**参数：**
+
+| 参数名   | 类型   | 描述     |
+| -------- | ------ | -------- |
+| filename | string | 文件名。 |
+
+**返回值：**
+
+| 返回类型 | 描述       |
+| -------- | ---------- |
+| string   | 文件内容。 |
+
+### insert_loader
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 加载器插入到 Lua 包加载器（搜索器）中。
+
+**签名：**
+
+```lua
+insert_loader: function(pos?: integer): boolean
+```
+
+**参数：**
+
+| 参数名 | 类型    | 描述                                  |
+| ------ | ------- | ------------------------------------- |
+| pos    | integer | [可选] 要插入加载器的位置。默认为 3。 |
+
+**返回值：**
+
+| 返回类型 | 描述                                                 |
+| -------- | ---------------------------------------------------- |
+| boolean  | 是否成功插入加载器。如果加载器已经插入，则返回失败。 |
+
+### remove_loader
+
+**类型：** 函数。
+
+**描述：**
+
+从 Lua 包加载器（搜索器）中移除 YueScript 加载器。
+
+**签名：**
+
+```lua
+remove_loader: function(): boolean
+```
+
+**返回值：**
+
+| 返回类型 | 描述                                               |
+| -------- | -------------------------------------------------- |
+| boolean  | 是否成功移除加载器。如果加载器未插入，则返回失败。 |
+
+### loadstring
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码字符串加载为一个函数。
+
+**签名：**
+
+```lua
+loadstring: function(input: string, chunkname: string, env: table, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**参数：**
+
+| 参数名    | 类型   | 描述                |
+| --------- | ------ | ------------------- |
+| input     | string | YueScript 代码。    |
+| chunkname | string | 代码块的名称。      |
+| env       | table  | 环境表。            |
+| config    | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
+
+### loadstring
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码字符串加载为一个函数。
+
+**签名：**
+
+```lua
+loadstring: function(input: string, chunkname: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**参数：**
+
+| 参数名    | 类型   | 描述                |
+| --------- | ------ | ------------------- |
+| input     | string | YueScript 代码。    |
+| chunkname | string | 代码块的名称。      |
+| config    | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
+
+### loadstring
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码字符串加载为一个函数。
+
+**签名：**
+
+```lua
+loadstring: function(input: string, config?: Config):
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
+```
+
+**参数：**
+
+| 参数名 | 类型   | 描述                |
+| ------ | ------ | ------------------- |
+| input  | string | YueScript 代码。    |
+| config | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
+
+### loadfile
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码文件加载为一个函数。
+
+**签名：**
+
+```lua
+loadfile: function(filename: string, env: table, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**参数：**
+
+| 参数名   | 类型   | 描述                |
+| -------- | ------ | ------------------- |
+| filename | string | 文件名。            |
+| env      | table  | 环境表。            |
+| config   | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
+
+### loadfile
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码文件加载为一个函数。
+
+**签名：**
+
+```lua
+loadfile: function(filename: string, config?: Config):
+    nil | function(...: any): (any...),
+    string | nil
+```
+
+**参数：**
+
+| 参数名   | 类型   | 描述                |
+| -------- | ------ | ------------------- |
+| filename | string | 文件名。            |
+| config   | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型        | 描述                               |
+| --------------- | ---------------------------------- |
+| function \| nil | 加载的函数，如果加载失败则为 nil。 |
+| string \| nil   | 错误消息，如果加载成功则为 nil。   |
+
+### dofile
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码文件加载为一个函数并执行。
+
+**签名：**
+
+```lua
+dofile: function(filename: string, env: table, config?: Config): any...
+```
+
+**参数：**
+
+| 参数名   | 类型   | 描述                |
+| -------- | ------ | ------------------- |
+| filename | string | 文件名。            |
+| env      | table  | 环境表。            |
+| config   | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述                       |
+| -------- | -------------------------- |
+| any...   | 加载的函数执行后的返回值。 |
+
+### dofile
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 代码文件加载为一个函数并执行。
+
+**签名：**
+
+```lua
+dofile: function(filename: string, config?: Config): any...
+```
+
+**参数：**
+
+| 参数名   | 类型   | 描述                |
+| -------- | ------ | ------------------- |
+| filename | string | 文件名。            |
+| config   | Config | [可选] 编译器选项。 |
+
+**返回值：**
+
+| 返回类型 | 描述                       |
+| -------- | -------------------------- |
+| any...   | 加载的函数执行后的返回值。 |
+
+### find_modulepath
+
+**类型：** 函数。
+
+**描述：**
+
+将 YueScript 模块名解析为文件路径。
+
+**签名：**
+
+```lua
+find_modulepath: function(name: string): string
+```
+
+**参数：**
+
+| 参数名 | 类型   | 描述     |
+| ------ | ------ | -------- |
+| name   | string | 模块名。 |
+
+**返回值：**
+
+| 返回类型 | 描述       |
+| -------- | ---------- |
+| string   | 文件路径。 |
+
+### pcall
+
+**类型：** 函数。
+
+**描述：**
+
+在保护模式下调用一个函数。
+会捕获任何错误，执行成功则返回成功状态和结果，否则为失败状态和错误信息。
+当发生错误时，将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
+
+**签名：**
+
+```lua
+pcall: function(f: function, ...: any): boolean, any...
+```
+
+**参数：**
+
+| 参数名 | 类型     | 描述                 |
+| ------ | -------- | -------------------- |
+| f      | function | 要调用的函数。       |
+| ...    | any      | 要传递给函数的参数。 |
+
+**返回值：**
+
+| 返回类型     | 描述                         |
+| ------------ | ---------------------------- |
+| boolean, ... | 状态码和函数结果或错误信息。 |
+
+### require
+
+**类型：** 函数。
+
+**描述：**
+
+加载给定的模块。可以是 Lua 模块或 YueScript 模块。
+如果模块是 YueScript 模块且加载失败，则将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
+
+**签名：**
+
+```lua
+require: function(name: string): any...
+```
+
+**参数：**
+
+| 参数名  | 类型   | 描述             |
+| ------- | ------ | ---------------- |
+| modname | string | 要加载的模块名。 |
+
+**返回值：**
+
+| 返回类型 | 描述                                                                                                                                                 |
+| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| any      | 如果模块已经加载，则返回 package.loaded[modname] 中存储的值。否则，尝试查找加载器并返回 package.loaded[modname] 的最终值和加载器数据作为第二个结果。 |
+
+### p
+
+**类型：** 函数。
+
+**描述：**
+
+检查传递的值的内部结构，并打印值出它的字符串表示。
+
+**签名：**
+
+```lua
+p: function(...: any)
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述         |
+| ------ | ---- | ------------ |
+| ...    | any  | 要检查的值。 |
+
+### options
+
+**类型：** 成员变量。
+
+**描述：**
+
+当前编译器选项。
+
+**签名：**
+
+```lua
+options: Config.Options
+```
+
+### traceback
+
+**类型：** 函数。
+
+**描述：**
+
+重写堆栈跟踪中的行号为 YueScript 代码中的原始行号的 traceback 函数。
+
+**签名：**
+
+```lua
+traceback: function(message: string): string
+```
+
+**参数：**
+
+| 参数名  | 类型   | 描述           |
+| ------- | ------ | -------------- |
+| message | string | 堆栈跟踪消息。 |
+
+**返回值：**
+
+| 返回类型 | 描述                   |
+| -------- | ---------------------- |
+| string   | 重写后的堆栈跟踪消息。 |
+
+### is_ast
+
+**类型：** 函数。
+
+**描述：**
+
+检查代码是否匹配指定的 AST。
+
+**签名：**
+
+```lua
+is_ast: function(astName: string, code: string): boolean
+```
+
+**参数：**
+
+| 参数名  | 类型   | 描述       |
+| ------- | ------ | ---------- |
+| astName | string | AST 名称。 |
+| code    | string | 代码。     |
+
+**返回值：**
+
+| 返回类型 | 描述               |
+| -------- | ------------------ |
+| boolean  | 代码是否匹配 AST。 |
+
+### AST
+
+**类型：** 成员变量。
+
+**描述：**
+
+AST 类型定义，带有名称、行、列和子节点。
+
+**签名：**
+
+```lua
+type AST = {string, integer, integer, any}
+```
+
+### to_ast
+
+**类型：** 函数。
+
+**描述：**
+
+将代码转换为 AST。
+
+**签名：**
+
+```lua
+to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
+    --[[AST]] AST | nil,
+    --[[error]] nil | string
+```
+
+**参数：**
+
+| 参数名         | 类型    | 描述                                                                           |
+| -------------- | ------- | ------------------------------------------------------------------------------ |
+| code           | string  | 代码。                                                                         |
+| flattenLevel   | integer | [可选] 扁平化级别。级别越高，会消除更多的 AST 结构的嵌套。默认为 0。最大为 2。 |
+| astName        | string  | [可选] AST 名称。默认为 "File"。                                               |
+| reserveComment | boolean | [可选] 是否保留原始注释。默认为 false。                                        |
+
+**返回值：**
+
+| 返回类型      | 描述                             |
+| ------------- | -------------------------------- |
+| AST \| nil    | AST，如果转换失败则为 nil。      |
+| string \| nil | 错误消息，如果转换成功则为 nil。 |
+
+### format
+
+**类型：** 函数。
+
+**描述：**
+
+格式化 YueScript 代码。
+
+**签名：**
+
+```lua
+format: function(code: string, tabSize?: number, reserveComment?: boolean): string
+```
+
+**参数：**
+
+| 参数名         | 类型    | 描述                                   |
+| -------------- | ------- | -------------------------------------- |
+| code           | string  | 代码。                                 |
+| tabSize        | integer | [可选] 制表符大小。默认为 4。          |
+| reserveComment | boolean | [可选] 是否保留原始注释。默认为 true。 |
+
+**返回值：**
+
+| 返回类型 | 描述             |
+| -------- | ---------------- |
+| string   | 格式化后的代码。 |
+
+### \_\_call
+
+**类型：** 元方法。
+
+**描述：**
+
+导入 YueScript 模块。
+如果发生加载失败，则将错误信息中的代码行号重写为 YueScript 代码中的原始行号。
+
+**签名：**
+
+```lua
+metamethod __call: function(self: yue, module: string): any...
+```
+
+**参数：**
+
+| 参数名 | 类型   | 描述     |
+| ------ | ------ | -------- |
+| module | string | 模块名。 |
+
+**返回值：**
+
+| 返回类型 | 描述     |
+| -------- | -------- |
+| any      | 模块值。 |
+
+## Config
+
+**描述：**
+
+编译器编译选项。
+
+### lint_global
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该收集代码中出现的全局变量。
+
+**签名：**
+
+```lua
+lint_global: boolean
+```
+
+### implicit_return_root
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该对根层级的代码块进行隐式的表达式返回。
+
+**签名：**
+
+```lua
+implicit_return_root: boolean
+```
+
+### reserve_line_number
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该在编译后的代码中保留原始行号。
+
+**签名：**
+
+```lua
+reserve_line_number: boolean
+```
+
+### reserve_comment
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该在编译后的代码中保留原始注释。
+
+**签名：**
+
+```lua
+reserve_comment: boolean
+```
+
+### space_over_tab
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该在编译后的代码中使用空格字符而不是制表符字符。
+
+**签名：**
+
+```lua
+space_over_tab: boolean
+```
+
+### same_module
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该将要编译的代码视为当前正在编译的模块。仅供编译器内部使用。
+
+**签名：**
+
+```lua
+same_module: boolean
+```
+
+### line_offset
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器错误消息是否应该包含行号偏移量。仅供编译器内部使用。
+
+**签名：**
+
+```lua
+line_offset: integer
+```
+
+### yue.Config.LuaTarget
+
+**类型：** 枚举。
+
+**描述：**
+
+目标 Lua 版本枚举。
+
+**签名：**
+
+```lua
+enum LuaTarget
+  "5.1"
+  "5.2"
+  "5.3"
+  "5.4"
+  "5.5"
+end
+```
+
+### options
+
+**类型：** 成员变量。
+
+**描述：**
+
+要传递给编译函数的额外选项。
+
+**签名：**
+
+```lua
+options: Options
+```
+
+## Options
+
+**描述：**
+
+额外编译器选项定义。
+
+### target
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译目标 Lua 版本。
+
+**签名：**
+
+```lua
+target: LuaTarget
+```
+
+### path
+
+**类型：** 成员变量。
+
+**描述：**
+
+额外模块搜索路径。
+
+**签名：**
+
+```lua
+path: string
+```
+
+### dump_locals
+
+**类型：** 成员变量。
+
+**描述：**
+
+是否在回溯错误消息中输出代码块的局部变量。默认为 false。
+
+**签名：**
+
+```lua
+dump_locals: boolean
+```
+
+### simplified
+
+**类型：** 成员变量。
+
+**描述：**
+
+是否简化输出的错误消息。默认为 true。
+
+**签名：**
+
+```lua
+simplified: boolean
+```
diff --git a/makefile b/makefile
index 99028e4..8cf9854 100644
--- a/makefile
+++ b/makefile
@@ -33,6 +33,7 @@ INSTALL_PREFIX = usr/local
 TEST_INPUT = ./spec/inputs
 TEST_OUTPUT = ./spec/generated
 GEN_OUTPUT = ./spec/outputs
+DOC_OUTPUT = ./doc
 
 PLAT = macos
 
@@ -439,7 +440,7 @@ test: debug
         @./$(BIN_NAME) $(TEST_INPUT)/import_global.yue -o $(TEST_OUTPUT)/5.1/import_global.lua --target 5.1
         @./$(BIN_NAME) $(TEST_INPUT)/test/loops_spec.yue -o $(TEST_OUTPUT)/5.1/test/loops_spec.lua --target 5.1
         @./$(BIN_NAME) $(TEST_INPUT)/test/try_catch_spec.yue -o $(TEST_OUTPUT)/5.1/test/try_catch_spec.lua --target 5.1
-        @./$(BIN_NAME) -e spec/inputs/compile_doc.yue $(TEST_OUTPUT)
+        @./$(BIN_NAME) -e spec/inputs/compile_doc.yue $(TEST_OUTPUT) $(DOC_OUTPUT)
         @echo -en "Compile time: "
         @$(END_TIME)
         @./$(BIN_NAME) -e "$$(printf "r = io.popen('git diff --no-index $(TEST_OUTPUT) $(GEN_OUTPUT) | head -5')\\\\read '*a'\nif r ~= ''\n print r\n os.exit 1")"
@@ -466,7 +467,7 @@ gen: release
         @./$(BIN_NAME) $(TEST_INPUT)/import_global.yue -o $(GEN_OUTPUT)/5.1/import_global.lua --target 5.1
         @./$(BIN_NAME) $(TEST_INPUT)/test/loops_spec.yue -o $(GEN_OUTPUT)/5.1/test/loops_spec.lua --target 5.1
         @./$(BIN_NAME) $(TEST_INPUT)/test/try_catch_spec.yue -o $(GEN_OUTPUT)/5.1/test/try_catch_spec.lua --target 5.1
-        @./$(BIN_NAME) -e spec/inputs/compile_doc.yue $(GEN_OUTPUT)
+        @./$(BIN_NAME) -e spec/inputs/compile_doc.yue $(GEN_OUTPUT) $(DOC_OUTPUT)
         @echo -en "Compile time: "
         @$(END_TIME)
 
diff --git a/spec/inputs/compile_doc.yue b/spec/inputs/compile_doc.yue
index ab621f8..f6a8d49 100644
--- a/spec/inputs/compile_doc.yue
+++ b/spec/inputs/compile_doc.yue
@@ -1,4 +1,4 @@
-outputFolder = ...
+[outputFolder, docFolder] = {...}
 
 getFiles = (locale) ->
         locale = if locale == "en" then "" else "#{locale}/"
@@ -37,13 +37,15 @@ getFiles = (locale) ->
                 "doc/docs/#{locale}doc/reference/license-mit.md"
                 "doc/docs/#{locale}doc/reference/the-yuescript-library.md"
         ]
-docs = [ ["codes_from_doc_#{locale}.lua", getFiles locale] for locale in *["en", "zh", "pt-br", "de", "id-id"]]
-for [compiledFile, docFiles] in *docs
+docs = [ ["codes_from_doc_#{locale}.lua", "yue-#{locale}.md", getFiles locale] for locale in *["en", "zh", "pt-br", "de", "id-id"]]
+for [compiledFile, docFile, docFiles] in *docs
         codes = []
+        docTexts = []
         for docFile in *docFiles
                 close input = with? io.open docFile
                         import "yue" as :to_lua
                         text = \read "*a"
+                        docTexts[] = text
                         for code in text\gmatch "```yuescript[\r\n]+(.-)```[^%w]"
                                 if result, err := to_lua code, implicit_return_root: false, reserve_line_number: false
                                         codes[] = result
@@ -58,4 +60,6 @@ for [compiledFile, docFiles] in *docs
                                         os.exit 1
         close output = with io.open "#{outputFolder}/#{compiledFile}", "w+"
                 \write table.concat codes
+        close output2 = with io.open "#{docFolder}/#{docFile}", "w+"
+                \write table.concat docTexts, "\n"
 
diff --git a/spec/outputs/codes_from_doc_de.lua b/spec/outputs/codes_from_doc_de.lua
index 428f788..4c9ba1d 100644
--- a/spec/outputs/codes_from_doc_de.lua
+++ b/spec/outputs/codes_from_doc_de.lua
@@ -2163,6 +2163,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
@@ -2209,6 +2221,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
diff --git a/spec/outputs/codes_from_doc_en.lua b/spec/outputs/codes_from_doc_en.lua
index 4006605..6d822e1 100644
--- a/spec/outputs/codes_from_doc_en.lua
+++ b/spec/outputs/codes_from_doc_en.lua
@@ -2163,6 +2163,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
@@ -2209,6 +2221,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
diff --git a/spec/outputs/codes_from_doc_id-id.lua b/spec/outputs/codes_from_doc_id-id.lua
index 7d95eaa..4026240 100644
--- a/spec/outputs/codes_from_doc_id-id.lua
+++ b/spec/outputs/codes_from_doc_id-id.lua
@@ -2163,6 +2163,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
@@ -2209,6 +2221,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
diff --git a/spec/outputs/codes_from_doc_pt-br.lua b/spec/outputs/codes_from_doc_pt-br.lua
index caa15d6..0d0c76f 100644
--- a/spec/outputs/codes_from_doc_pt-br.lua
+++ b/spec/outputs/codes_from_doc_pt-br.lua
@@ -2163,6 +2163,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
@@ -2209,6 +2221,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
diff --git a/spec/outputs/codes_from_doc_zh.lua b/spec/outputs/codes_from_doc_zh.lua
index 4ff3866..c847841 100644
--- a/spec/outputs/codes_from_doc_zh.lua
+++ b/spec/outputs/codes_from_doc_zh.lua
@@ -2163,6 +2163,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
@@ -2209,6 +2221,18 @@ repeat
         result = _with_0.value
         break
 until true
+local a
+do
+        local _with_0 = obj
+        _with_0.x = 1
+        a = _with_0
+end
+local b
+local _with_0 = obj
+repeat
+        b = _with_0.x
+        break
+until true
 local create_person
 create_person = function(name, relatives)
         local _with_0 = Person()
diff --git a/spec/outputs/compile_doc.lua b/spec/outputs/compile_doc.lua
index 8d5c11a..f661bbd 100644
--- a/spec/outputs/compile_doc.lua
+++ b/spec/outputs/compile_doc.lua
@@ -1,4 +1,10 @@
-local outputFolder = ...
+local outputFolder, docFolder
+do
+        local _obj_0 = {
+                ...
+        }
+        outputFolder, docFolder = _obj_0[1], _obj_0[2]
+end
 local getFiles
 getFiles = function(locale)
         if locale == "en" then
@@ -57,6 +63,7 @@ do
                 local locale = _list_0[_index_0]
                 _accum_0[_len_0] = {
                         "codes_from_doc_" .. tostring(locale) .. ".lua",
+                        "yue-" .. tostring(locale) .. ".md",
                         getFiles(locale)
                 }
                 _len_0 = _len_0 + 1
@@ -65,8 +72,9 @@ do
 end
 for _index_0 = 1, #docs do
         local _des_0 = docs[_index_0]
-        local compiledFile, docFiles = _des_0[1], _des_0[2]
+        local compiledFile, docFile, docFiles = _des_0[1], _des_0[2], _des_0[3]
         local codes = { }
+        local docTexts = { }
         for _index_1 = 1, #docFiles do
                 local docFile = docFiles[_index_1]
                 local input
@@ -74,6 +82,7 @@ for _index_0 = 1, #docs do
                 if _with_0 ~= nil then
                         local to_lua = require("yue").to_lua
                         local text = _with_0:read("*a")
+                        docTexts[#docTexts + 1] = text
                         for code in text:gmatch("```yuescript[\r\n]+(.-)```[^%w]") do
                                 local result, err = to_lua(code, {
                                         implicit_return_root = false,
@@ -103,8 +112,15 @@ for _index_0 = 1, #docs do
                 local _close_0 <close> = input
         end
         local output
-        local _with_0 = io.open(tostring(outputFolder) .. "/" .. tostring(compiledFile), "w+")
-        _with_0:write(table.concat(codes))
-        output = _with_0
+        do
+                local _with_0 = io.open(tostring(outputFolder) .. "/" .. tostring(compiledFile), "w+")
+                _with_0:write(table.concat(codes))
+                output = _with_0
+        end
         local _close_0 <close> = output
+        local output2
+        local _with_0 = io.open(tostring(docFolder) .. "/" .. tostring(docFile), "w+")
+        _with_0:write(table.concat(docTexts, "\n"))
+        output2 = _with_0
+        local _close_1 <close> = output2
 end