7 files changed, 15 insertions, 12475 deletions
diff --git a/doc/yue-de.md b/doc/yue-de.md
index 1a13a47..94bfd4b 100644
--- a/doc/yue-de.md
+++ b/doc/yue-de.md
@@ -1,11 +1,5 @@
---
-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.
@@ -21,17 +15,6 @@ do
 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
@@ -42,18 +25,6 @@ status, value = do
  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
@@ -65,21 +36,6 @@ print counter!
 print counter!
 ```
-<YueDisplay>
-```yue
-counter = do
-  i = 0
-  ->
-    i += 1
-    i
-print counter!
-print counter!
-```
-</YueDisplay>
 ```yuescript
 tbl = {
  key: do
@@ -88,18 +44,6 @@ tbl = {
 }
 ```
-<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:
@@ -108,28 +52,12 @@ Zur Vereinfachung können `for`-Schleifen und `if`-Anweisungen auf einzelne Anwe
 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
@@ -138,16 +66,6 @@ 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
@@ -183,39 +101,6 @@ 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.
@@ -246,36 +131,6 @@ 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.
@@ -295,28 +150,6 @@ import "utils" as {
 [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.
@@ -326,15 +159,6 @@ 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.
@@ -357,28 +181,6 @@ 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.
@@ -393,20 +195,6 @@ macro printNumAndStr = (num `Num, str `String) -> |
 $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
@@ -418,19 +206,6 @@ macro printNumAndStr = (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
@@ -465,38 +240,6 @@ catch 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.
@@ -519,44 +262,14 @@ catch 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]
+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
@@ -567,18 +280,6 @@ some_values = {
 }
 ```
-<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
@@ -588,17 +289,6 @@ profile =
  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
@@ -610,19 +300,6 @@ values = {
 }
 ```
-<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
@@ -631,16 +308,6 @@ 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
@@ -650,17 +317,6 @@ tbl = {
 }
 ```
-<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
@@ -671,18 +327,6 @@ 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
@@ -692,33 +336,13 @@ t = {
 }
 ```
-<YueDisplay>
+Lua-Tabellen haben sowohl einen Array-Teil als auch einen Hash-Teil, aber manchmal ist es nützlich, hier eine semantische Unterscheidung zu treffen. Du kannst **[ ]** anstelle von **{ }** verwenden, um eine Tabelle explizit als Array zu deklarieren; dadurch wird verhindert, dass Schlüssel-Wert-Paare hineingeschrieben werden.
-```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.
@@ -732,43 +356,18 @@ 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
@@ -780,19 +379,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:
@@ -805,32 +391,12 @@ 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.
@@ -847,32 +413,10 @@ thing = {
 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
@@ -880,15 +424,6 @@ 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.
@@ -898,15 +433,6 @@ 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.
@@ -917,42 +443,18 @@ Hier setzen wir die minimalen und maximalen Grenzen und nehmen alle Elemente mit
 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
@@ -960,29 +462,12 @@ Sowohl die Mindest- als auch die Maximalgrenze können negativ sein; dann werden
 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.
@@ -995,18 +480,6 @@ sub_list = items[2, 4]
 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.
@@ -1025,22 +498,6 @@ class Inventory
      @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.
@@ -1057,16 +514,6 @@ 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.
@@ -1089,26 +536,6 @@ b\give_item "Hemd"
 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
@@ -1117,16 +544,6 @@ class Person
    @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.
@@ -1139,18 +556,6 @@ class BackPack extends Inventory
    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.
@@ -1166,19 +571,6 @@ class Shelf
 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.
@@ -1205,22 +597,6 @@ class MyClass extends ParentClass
    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
@@ -1234,17 +610,6 @@ 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.
@@ -1265,14 +630,6 @@ Der Name der Klasse, wie sie deklariert wurde, wird im Feld `__name` gespeichert
 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.
@@ -1291,20 +648,6 @@ Things\some_func!
 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
@@ -1320,37 +663,12 @@ 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.
@@ -1362,15 +680,6 @@ 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:
@@ -1384,19 +693,6 @@ class MoreThings
    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`.
@@ -1408,29 +704,12 @@ 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:
@@ -1449,24 +728,6 @@ class Something
    @@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
@@ -1475,16 +736,6 @@ 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.
@@ -1495,16 +746,6 @@ x = class Bucket
  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.
@@ -1516,31 +757,12 @@ BigBucket = class extends Bucket
 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.
@@ -1563,28 +785,6 @@ 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.
@@ -1603,18 +803,6 @@ with Person!
  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
@@ -1622,15 +810,6 @@ 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
@@ -1638,15 +817,6 @@ 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
@@ -1659,20 +829,6 @@ b = with obj
 -- 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 …
@@ -1686,19 +842,6 @@ create_person = (name,  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.
@@ -1709,16 +852,6 @@ with str := "Hallo"
  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
@@ -1731,20 +864,6 @@ with tb
  [] = "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
@@ -1752,15 +871,6 @@ 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.
@@ -1771,16 +881,6 @@ 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.
@@ -1796,21 +896,6 @@ 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.
@@ -1820,15 +905,6 @@ 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
@@ -1848,27 +924,6 @@ do
  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
@@ -1888,27 +943,6 @@ do
  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.
@@ -1922,19 +956,6 @@ 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.
@@ -1944,15 +965,6 @@ 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
@@ -1962,19 +974,6 @@ 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
@@ -1983,16 +982,6 @@ if success, result := pcall -> "Ergebnis ohne Probleme erhalten"
 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.
@@ -2003,16 +992,6 @@ while byte := stream\read_one!
  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.
@@ -2028,17 +1007,6 @@ thing = [1, 2]
 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
@@ -2054,23 +1022,6 @@ 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
@@ -2086,23 +1037,6 @@ 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
@@ -2114,75 +1048,30 @@ Wenn die Destructuring-Anweisung kompliziert ist, kannst du sie gerne auf mehrer
 } = 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.
@@ -2195,18 +1084,6 @@ 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
@@ -2220,21 +1097,6 @@ Der Spread-Operator kann an unterschiedlichen Positionen verwendet werden, um un
 [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:
@@ -2249,20 +1111,6 @@ 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
@@ -2285,26 +1133,6 @@ 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.
@@ -2321,20 +1149,6 @@ 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
@@ -2350,23 +1164,6 @@ 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
@@ -2536,55 +1333,6 @@ with apple
 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.
@@ -2643,18 +1391,6 @@ 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
@@ -2662,15 +1398,6 @@ 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
@@ -2678,15 +1405,6 @@ 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
@@ -2704,25 +1422,6 @@ else
 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
@@ -2730,27 +1429,10 @@ 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.
@@ -2765,20 +1447,6 @@ 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>
 Der `in`-Operator kann auch mit Tabellen verwendet werden und unterstützt die Variante `not in` für Verneinungen:
 ```yuescript
@@ -2792,21 +1460,6 @@ not_exist = item not in list
 check = -> value not in table
 ```
-<YueDisplay>
-```yue
-has = "foo" in {"bar", "foo"}
-if a in {1, 2, 3}
-  print "a ist in der Tabelle"
-not_exist = item not in list
-check = -> value not in table
-```
-</YueDisplay>
 Eine Ein-Element-Liste oder Tabelle prüft auf Gleichheit mit diesem Element:
 ```yuescript
@@ -2821,22 +1474,6 @@ with tb
  c = a in [1]
 ```
-<YueDisplay>
-```yue
-- [1,] prüft, ob wert == 1
-c = a in [1,]
-- {1} prüft auch, ob wert == 1
-c = a in {1}
-- Ohne Komma ist [1] ein Indexzugriff (tb[1])
-with tb
-  c = a in [1]
-```
-</YueDisplay>
 # For-Schleife
 Es gibt zwei Formen der `for`-Schleife, genau wie in Lua: eine numerische und eine generische.
@@ -2852,21 +1489,6 @@ 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
@@ -2874,15 +1496,6 @@ 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
@@ -2891,16 +1504,6 @@ 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:
@@ -2913,18 +1516,6 @@ doubled_evens = for i = 1, 20
    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:
@@ -2934,15 +1525,6 @@ 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
@@ -2950,15 +1532,6 @@ 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.
@@ -2971,18 +1544,6 @@ 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
@@ -2997,18 +1558,6 @@ while i < 10
  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
@@ -3018,17 +1567,6 @@ odds = for x in *my_numbers
  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.
@@ -3043,20 +1581,6 @@ switch name := "Dan"
    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:
@@ -3072,21 +1596,6 @@ next_number = switch b
    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
@@ -3096,17 +1605,6 @@ msg = switch math.random(1, 5)
  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
@@ -3122,23 +1620,6 @@ 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
@@ -3160,25 +1641,6 @@ for item in *items
      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
@@ -3191,20 +1653,6 @@ switch item
    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.
@@ -3219,20 +1667,6 @@ switch tb
    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
@@ -3245,20 +1679,6 @@ switch tb
    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
@@ -3271,20 +1691,6 @@ switch tb
    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
@@ -3298,21 +1704,6 @@ switch tb
    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
@@ -3324,19 +1715,6 @@ switch segments
    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:
@@ -3350,19 +1728,6 @@ while i > 0
 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
@@ -3372,18 +1737,6 @@ until i == 0
 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
@@ -3392,16 +1745,6 @@ value, doubled = while true
  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
@@ -3416,18 +1759,6 @@ repeat
 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
@@ -3438,18 +1769,6 @@ value, scaled = repeat
 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.
@@ -3477,29 +1796,6 @@ run_callback my_object.write
 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.
@@ -3509,15 +1805,6 @@ x <- f
 print "hallo" .. x
 ```
-<YueDisplay>
-```yue
-x <- f
-print "hallo" .. x
-```
-</YueDisplay>
 Fat-Arrow-Funktionen sind ebenfalls verfügbar.
 ```yuescript
@@ -3525,15 +1812,6 @@ Fat-Arrow-Funktionen sind ebenfalls verfügbar.
 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
@@ -3541,15 +1819,6 @@ Du kannst einen Platzhalter angeben, an welcher Stelle die Backcall-Funktion als
 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
@@ -3561,19 +1830,6 @@ result, msg = do
 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.
@@ -3583,15 +1839,6 @@ 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
@@ -3602,18 +1849,6 @@ func_b = ->
  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
@@ -3621,29 +1856,12 @@ 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
@@ -3653,31 +1871,12 @@ 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:
@@ -3687,29 +1886,12 @@ 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
@@ -3717,15 +1899,6 @@ 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.
@@ -3734,14 +1907,6 @@ Da es in Lua üblich ist, beim Methodenaufruf ein Objekt als erstes Argument zu
 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.
@@ -3752,16 +1917,6 @@ my_function = (name = "etwas", height = 100) ->
  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
@@ -3769,15 +1924,6 @@ 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.
@@ -3791,17 +1937,6 @@ 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.
@@ -3813,15 +1948,6 @@ 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.
@@ -3838,20 +1964,6 @@ cool_func 1, 2,
  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
@@ -3861,17 +1973,6 @@ my_func 5, 6, 7,
  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
@@ -3882,18 +1983,6 @@ x = [
 ]
 ```
-<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
@@ -3903,17 +1992,6 @@ y = [ my_func 1, 2, 3,
 ]
 ```
-<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
@@ -3930,24 +2008,6 @@ if func 1, 2, 3,
  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:
@@ -3968,23 +2028,6 @@ 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:
@@ -3998,19 +2041,6 @@ findFirstEven = (list): nil ->
          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
@@ -4023,20 +2053,6 @@ findFirstEven = (list) ->
  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
@@ -4065,32 +2081,6 @@ process = (...args) ->
 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.
@@ -4103,14 +2093,6 @@ Eine Anweisung endet normalerweise an einem Zeilenumbruch. Du kannst auch ein Se
 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.
@@ -4124,19 +2106,6 @@ Rx.Observable
  \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
@@ -4152,23 +2121,6 @@ Alles okay.
 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.
@@ -4178,15 +2130,6 @@ 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
@@ -4194,15 +2137,6 @@ 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
@@ -4210,15 +2144,6 @@ 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.
@@ -4228,15 +2153,6 @@ 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:
@@ -4250,19 +2166,6 @@ 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
@@ -4288,33 +2191,6 @@ print v(1) > v(2) <= v(3)
 ]]
 ```
-<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
@@ -4326,15 +2202,6 @@ 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
@@ -4344,17 +2211,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.
@@ -4376,27 +2232,6 @@ 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.
@@ -4407,16 +2242,6 @@ 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.
@@ -4441,26 +2266,6 @@ 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.
@@ -4475,19 +2280,6 @@ 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.
@@ -4497,15 +2289,6 @@ Destrukturiere Metatable mit Metamethoden-Schlüssel, der von **<>** umschlossen
 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.
@@ -4525,25 +2308,6 @@ with? io.open "test.txt", "w"
  \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.
@@ -4562,24 +2326,6 @@ readFile "example.txt"
  |> 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.
@@ -4592,17 +2338,6 @@ 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.
@@ -4650,52 +2385,6 @@ 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**.
@@ -4711,19 +2400,6 @@ some_string = "Hier ist ein String
 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.
@@ -4734,16 +2410,6 @@ 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:
@@ -4756,18 +2422,6 @@ str = |
    - #{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.
@@ -4780,18 +2434,6 @@ fn = ->
  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.
@@ -4802,16 +2444,6 @@ str = |
  note: 'He said: "#{Hello}!"'
 ```
-<YueDisplay>
-```yue
-str = |
-  path: "C:\Program Files\App"
-  note: 'He said: "#{Hello}!"'
-```
-</YueDisplay>
 # Module
 ## Import
@@ -4843,35 +2475,6 @@ do
  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.
@@ -4883,17 +2486,6 @@ do
  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.
@@ -4915,25 +2507,6 @@ do
  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.
@@ -4958,26 +2531,6 @@ 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
@@ -4985,15 +2538,6 @@ 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
@@ -5002,16 +2546,6 @@ 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.
@@ -5029,23 +2563,6 @@ 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.
@@ -5056,16 +2573,6 @@ export default ->
  123
 ```
-<YueDisplay>
-```yue
-export default ->
-  print "hallo"
-  123
-```
-</YueDisplay>
 # Lizenz: MIT
 Hinweis: Die MIT-Lizenz ist unten im englischen Originaltext wiedergegeben.
diff --git a/doc/yue-en.md b/doc/yue-en.md
index 3f8546a..764bc1a 100644
--- a/doc/yue-en.md
+++ b/doc/yue-en.md
@@ -1,11 +1,5 @@
---
-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.
@@ -21,17 +15,6 @@ do
 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:
@@ -44,18 +27,6 @@ status, value = do
  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
@@ -67,21 +38,6 @@ print counter!
 print counter!
 ```
-<YueDisplay>
-```yue
-counter = do
-  i = 0
-  ->
-    i += 1
-    i
-print counter!
-print counter!
-```
-</YueDisplay>
 ```yuescript
 tbl = {
  key: do
@@ -90,18 +46,6 @@ tbl = {
 }
 ```
-<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:
@@ -110,28 +54,12 @@ For convenience, the for loop and if statement can be applied to single statemen
 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
@@ -140,16 +68,6 @@ 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
@@ -185,39 +103,6 @@ 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.
@@ -248,36 +133,6 @@ 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.
@@ -297,28 +152,6 @@ import "utils" as {
 [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.
@@ -328,15 +161,6 @@ 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.
@@ -359,28 +183,6 @@ 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.
@@ -395,20 +197,6 @@ macro printNumAndStr = (num `Num, str `String) -> |
 $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
@@ -420,19 +208,6 @@ macro printNumAndStr = (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
@@ -467,38 +242,6 @@ catch 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.
@@ -521,44 +264,14 @@ catch 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]
+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
@@ -569,18 +282,6 @@ some_values = {
 }
 ```
-<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
@@ -590,17 +291,6 @@ profile =
  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
@@ -612,19 +302,6 @@ values = {
 }
 ```
-<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
@@ -633,16 +310,6 @@ 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
@@ -652,17 +319,6 @@ tbl = {
 }
 ```
-<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
@@ -673,18 +329,6 @@ 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
@@ -694,33 +338,13 @@ t = {
 }
 ```
-<YueDisplay>
+Lua tables have both an array part and a hash part, but sometimes it's useful to make a semantic distinction between the two. You can use **[ ]** instead of **{ }** to explicitly declare a table as an array, doing so will prevent any key-value pairs from being written inside it.
-```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.
@@ -734,43 +358,18 @@ 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
@@ -782,19 +381,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:
@@ -807,32 +393,12 @@ 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.
@@ -849,32 +415,10 @@ thing = {
 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
@@ -882,15 +426,6 @@ 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.
@@ -900,15 +435,6 @@ 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.
@@ -919,42 +445,18 @@ Here we can set the minimum and maximum bounds, taking all items with indexes be
 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
@@ -962,29 +464,12 @@ Both the minimum and maximum bounds can be negative, which means that the bounds
 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.
@@ -997,18 +482,6 @@ sub_list = items[2, 4]
 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.
@@ -1027,22 +500,6 @@ class Inventory
      @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.
@@ -1059,16 +516,6 @@ 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.
@@ -1091,26 +538,6 @@ 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"
-- 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
@@ -1119,16 +546,6 @@ class Person
    @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.
@@ -1141,18 +558,6 @@ class BackPack extends Inventory
    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.
@@ -1168,19 +573,6 @@ class Shelf
 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.
@@ -1207,22 +599,6 @@ class MyClass extends ParentClass
    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
@@ -1236,17 +612,6 @@ 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.
@@ -1267,14 +632,6 @@ The name of the class as when it was declared is stored as a string in the \_\_n
 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.
@@ -1293,20 +650,6 @@ Things\some_func!
 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
@@ -1322,37 +665,12 @@ 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.
@@ -1364,15 +682,6 @@ 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:
@@ -1386,19 +695,6 @@ class MoreThings
    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.
@@ -1410,29 +706,12 @@ 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:
@@ -1451,24 +730,6 @@ class Something
    @@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
@@ -1477,16 +738,6 @@ 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.
@@ -1497,16 +748,6 @@ x = class Bucket
  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.
@@ -1518,31 +759,12 @@ BigBucket = class extends Bucket
 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.
@@ -1565,28 +787,6 @@ 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.
@@ -1605,18 +805,6 @@ with Person!
  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
@@ -1624,15 +812,6 @@ 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
@@ -1640,15 +819,6 @@ 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
@@ -1661,20 +831,6 @@ b = with obj
 -- 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…
@@ -1688,19 +844,6 @@ create_person = (name,  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.
@@ -1711,16 +854,6 @@ with str := "Hello"
  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
@@ -1733,20 +866,6 @@ with tb
  [] = "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
@@ -1754,15 +873,6 @@ 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.
@@ -1773,16 +883,6 @@ 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.
@@ -1798,21 +898,6 @@ 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.
@@ -1822,15 +907,6 @@ 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
@@ -1850,27 +926,6 @@ do
  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
@@ -1890,27 +945,6 @@ do
  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.
@@ -1924,19 +958,6 @@ 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.
@@ -1946,15 +967,6 @@ 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
@@ -1964,19 +976,6 @@ 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
@@ -1985,16 +984,6 @@ if success, result := pcall -> "get result without problems"
 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.
@@ -2005,16 +994,6 @@ while byte := stream\read_one!
  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.
@@ -2030,17 +1009,6 @@ thing = [1, 2]
 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
@@ -2056,23 +1024,6 @@ 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
@@ -2088,23 +1039,6 @@ 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
@@ -2116,75 +1050,30 @@ If the destructuring statement is complicated, feel free to spread it out over a
 } = 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.
@@ -2197,18 +1086,6 @@ 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
@@ -2222,21 +1099,6 @@ The spread operator can be used in different positions to capture different rang
 [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:
@@ -2251,20 +1113,6 @@ 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
@@ -2287,26 +1135,6 @@ 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.
@@ -2323,20 +1151,6 @@ 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
@@ -2352,23 +1166,6 @@ 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
@@ -2537,55 +1334,6 @@ with apple
 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.
@@ -2644,18 +1392,6 @@ 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
@@ -2663,15 +1399,6 @@ 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
@@ -2679,15 +1406,6 @@ 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
@@ -2705,25 +1423,6 @@ else
 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
@@ -2731,27 +1430,10 @@ 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`.
@@ -2766,20 +1448,6 @@ 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>
 The `in` operator can also be used with tables and supports the `not in` variant for negation:
 ```yuescript
@@ -2793,21 +1461,6 @@ not_exist = item not in list
 check = -> value not in table
 ```
-<YueDisplay>
-```yue
-has = "foo" in {"bar", "foo"}
-if a in {1, 2, 3}
-  print "a is in the table"
-not_exist = item not in list
-check = -> value not in table
-```
-</YueDisplay>
 A single-element list or table checks for equality with that element:
 ```yuescript
@@ -2822,22 +1475,6 @@ with tb
  c = a in [1]
 ```
-<YueDisplay>
-```yue
-- [1,] checks if value == 1
-c = a in [1,]
-- {1} also checks if value == 1
-c = a in {1}
-- Without comma, [1] is indexing (tb[1])
-with tb
-  c = a in [1]
-```
-</YueDisplay>
 # For Loop
 There are two for loop forms, just like in Lua. A numeric one and a generic one:
@@ -2853,21 +1490,6 @@ 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
@@ -2875,15 +1497,6 @@ 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
@@ -2892,16 +1505,6 @@ 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:
@@ -2914,18 +1517,6 @@ doubled_evens = for i = 1, 20
    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:
@@ -2935,15 +1526,6 @@ 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:
@@ -2953,15 +1535,6 @@ 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.
@@ -2974,18 +1547,6 @@ 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
@@ -3000,18 +1561,6 @@ while i < 10
  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
@@ -3021,17 +1570,6 @@ odds = for x in *my_numbers
  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.
@@ -3046,20 +1584,6 @@ switch name := "Dan"
    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:
@@ -3075,21 +1599,6 @@ next_number = switch b
    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
@@ -3099,17 +1608,6 @@ msg = switch math.random(1, 5)
  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
@@ -3125,23 +1623,6 @@ 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
@@ -3163,25 +1644,6 @@ for item in *items
      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
@@ -3194,20 +1656,6 @@ switch item
    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.
@@ -3222,20 +1670,6 @@ switch tb
    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
@@ -3248,20 +1682,6 @@ switch tb
    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
@@ -3274,20 +1694,6 @@ switch tb
    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
@@ -3301,21 +1707,6 @@ switch tb
    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
@@ -3327,19 +1718,6 @@ switch segments
    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:
@@ -3353,19 +1731,6 @@ while i > 0
 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
@@ -3375,18 +1740,6 @@ until i == 0
 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
@@ -3395,16 +1748,6 @@ value, doubled = while true
  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
@@ -3419,18 +1762,6 @@ repeat
 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
@@ -3441,18 +1772,6 @@ value, scaled = repeat
 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.
@@ -3480,29 +1799,6 @@ run_callback my_object.write
 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.
@@ -3512,15 +1808,6 @@ x <- f
 print "hello" .. x
 ```
-<YueDisplay>
-```yue
-x <- f
-print "hello" .. x
-```
-</YueDisplay>
 Fat arrow functions are also available.
 ```yuescript
@@ -3528,15 +1815,6 @@ Fat arrow functions are also available.
 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
@@ -3544,15 +1822,6 @@ You can specify a placeholder for where you want the backcall function to go as
 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
@@ -3564,19 +1833,6 @@ result, msg = do
 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: **->**.
@@ -3586,15 +1842,6 @@ 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
@@ -3605,18 +1852,6 @@ func_b = ->
  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
@@ -3624,29 +1859,12 @@ 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
@@ -3656,31 +1874,12 @@ 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:
@@ -3690,29 +1889,12 @@ 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
@@ -3720,15 +1902,6 @@ 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.
@@ -3737,14 +1910,6 @@ Because it is an idiom in Lua to send an object as the first argument when calli
 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.
@@ -3755,16 +1920,6 @@ my_function = (name = "something", height = 100) ->
  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
@@ -3772,15 +1927,6 @@ 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.
@@ -3794,17 +1940,6 @@ 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.
@@ -3816,15 +1951,6 @@ 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.
@@ -3841,20 +1967,6 @@ cool_func 1, 2,
  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
@@ -3864,17 +1976,6 @@ my_func 5, 6, 7,
  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
@@ -3885,18 +1986,6 @@ x = [
 ]
 ```
-<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
@@ -3906,17 +1995,6 @@ y = [ my_func 1, 2, 3,
 ]
 ```
-<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
@@ -3933,24 +2011,6 @@ if func 1, 2, 3,
  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:
@@ -3972,23 +2032,6 @@ 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:
@@ -4002,19 +2045,6 @@ findFirstEven = (list): nil ->
          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
@@ -4027,20 +2057,6 @@ findFirstEven = (list) ->
  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
@@ -4069,32 +2085,6 @@ process = (...args) ->
 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.
@@ -4107,14 +2097,6 @@ A statement normally ends at a line break. You can also use a semicolon `;` to e
 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.
@@ -4128,19 +2110,6 @@ Rx.Observable
  \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
@@ -4156,23 +2125,6 @@ It's OK.
 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.
@@ -4182,15 +2134,6 @@ 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
@@ -4198,15 +2141,6 @@ 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
@@ -4214,15 +2148,6 @@ 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.
@@ -4232,15 +2157,6 @@ 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:
@@ -4254,19 +2170,6 @@ 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
@@ -4292,33 +2195,6 @@ print v(1) > v(2) <= v(3)
 ]]
 ```
-<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
@@ -4330,15 +2206,6 @@ 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
@@ -4348,17 +2215,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.
@@ -4380,27 +2236,6 @@ 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.
@@ -4411,16 +2246,6 @@ 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.
@@ -4445,26 +2270,6 @@ 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 **<>**.
@@ -4479,19 +2284,6 @@ 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 **<>**.
@@ -4501,15 +2293,6 @@ Destruct metatable with metamethod key surrounded by **<>**.
 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.
@@ -4529,25 +2312,6 @@ with? io.open "test.txt", "w"
  \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 **|>**.
@@ -4566,24 +2330,6 @@ readFile "example.txt"
  |> 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.
@@ -4596,17 +2342,6 @@ 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.
@@ -4654,52 +2389,6 @@ 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**.
@@ -4715,19 +2404,6 @@ some_string = "Here is a string
 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.
@@ -4738,16 +2414,6 @@ 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:
@@ -4760,18 +2426,6 @@ str = |
    - #{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.
@@ -4784,18 +2438,6 @@ fn = ->
  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.
@@ -4806,16 +2448,6 @@ str = |
  note: 'He said: "#{Hello}!"'
 ```
-<YueDisplay>
-```yue
-str = |
-  path: "C:\Program Files\App"
-  note: 'He said: "#{Hello}!"'
-```
-</YueDisplay>
 # Module
 ## Import
@@ -4847,35 +2479,6 @@ do
  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.
@@ -4887,17 +2490,6 @@ do
  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.
@@ -4919,25 +2511,6 @@ do
  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.
@@ -4962,26 +2535,6 @@ 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
@@ -4989,15 +2542,6 @@ 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
@@ -5006,16 +2550,6 @@ 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.
@@ -5033,23 +2567,6 @@ 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.
@@ -5060,16 +2577,6 @@ export default ->
  123
 ```
-<YueDisplay>
-```yue
-export default ->
-  print "hello"
-  123
-```
-</YueDisplay>
 # License: MIT
 Copyright (c) 2017-2026 Li Jin \<dragon-fly@qq.com\>
diff --git a/doc/yue-id-id.md b/doc/yue-id-id.md
index ca90d85..200438e 100644
--- a/doc/yue-id-id.md
+++ b/doc/yue-id-id.md
@@ -1,11 +1,5 @@
---
-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.
@@ -21,17 +15,6 @@ do
 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
@@ -42,18 +25,6 @@ status, value = do
  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
@@ -65,21 +36,6 @@ print counter!
 print counter!
 ```
-<YueDisplay>
-```yue
-counter = do
-  i = 0
-  ->
-    i += 1
-    i
-print counter!
-print counter!
-```
-</YueDisplay>
 ```yuescript
 tbl = {
  key: do
@@ -88,18 +44,6 @@ tbl = {
 }
 ```
-<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:
@@ -108,28 +52,12 @@ Untuk kemudahan, loop for dan pernyataan if dapat diterapkan pada pernyataan tun
 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
@@ -138,16 +66,6 @@ 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
@@ -183,39 +101,6 @@ 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.
@@ -246,36 +131,6 @@ 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.
@@ -295,28 +150,6 @@ import "utils" as {
 [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.
@@ -326,15 +159,6 @@ 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.
@@ -357,28 +181,6 @@ 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.
@@ -393,20 +195,6 @@ macro printNumAndStr = (num `Num, str `String) -> |
 $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
@@ -418,19 +206,6 @@ macro printNumAndStr = (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
@@ -465,38 +240,6 @@ catch 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.
@@ -519,44 +262,14 @@ catch 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]
+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
@@ -567,18 +280,6 @@ some_values = {
 }
 ```
-<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
@@ -588,17 +289,6 @@ profile =
  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
@@ -610,19 +300,6 @@ values = {
 }
 ```
-<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
@@ -631,16 +308,6 @@ 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
@@ -650,17 +317,6 @@ tbl = {
 }
 ```
-<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
@@ -671,18 +327,6 @@ 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
@@ -692,33 +336,13 @@ t = {
 }
 ```
-<YueDisplay>
+Tabel Lua memiliki bagian array dan bagian hash, tetapi kadang-kadang berguna untuk membuat perbedaan semantik di antara keduanya. Anda dapat menggunakan **[ ]** sebagai ganti **{ }** untuk mendeklarasikan tabel secara eksplisit sebagai array, dengan begitu akan mencegah pasangan key-value dituliskan di dalamnya.
-```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.
@@ -732,43 +356,18 @@ 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
@@ -780,19 +379,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:
@@ -805,32 +391,12 @@ 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.
@@ -847,32 +413,10 @@ thing = {
 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
@@ -880,15 +424,6 @@ 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.
@@ -898,15 +433,6 @@ 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.
@@ -917,42 +443,18 @@ Di sini kita bisa menetapkan batas minimum dan maksimum, mengambil semua item de
 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
@@ -960,29 +462,12 @@ Batas minimum dan maksimum bisa bernilai negatif, yang berarti batas dihitung da
 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.
@@ -995,18 +480,6 @@ sub_list = items[2, 4]
 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.
@@ -1025,22 +498,6 @@ class Inventory
      @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.
@@ -1057,16 +514,6 @@ 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.
@@ -1089,26 +536,6 @@ 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"
-- 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
@@ -1117,16 +544,6 @@ class Person
    @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.
@@ -1139,18 +556,6 @@ class BackPack extends Inventory
    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.
@@ -1166,19 +571,6 @@ class Shelf
 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.
@@ -1205,22 +597,6 @@ class MyClass extends ParentClass
    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
@@ -1234,17 +610,6 @@ 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.
@@ -1265,14 +630,6 @@ Nama kelas saat dideklarasikan disimpan sebagai string di field `__name` pada ob
 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`.
@@ -1291,20 +648,6 @@ Things\some_func!
 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
@@ -1320,37 +663,12 @@ 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.
@@ -1362,15 +680,6 @@ 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:
@@ -1384,19 +693,6 @@ class MoreThings
    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`.
@@ -1408,29 +704,12 @@ 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:
@@ -1449,24 +728,6 @@ class Something
    @@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
@@ -1475,16 +736,6 @@ 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.
@@ -1495,16 +746,6 @@ x = class Bucket
  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.
@@ -1516,31 +757,12 @@ BigBucket = class extends Bucket
 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.
@@ -1563,28 +785,6 @@ 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.
@@ -1603,18 +803,6 @@ with Person!
  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
@@ -1622,15 +810,6 @@ 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
@@ -1638,15 +817,6 @@ 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
@@ -1659,20 +829,6 @@ b = with obj
 -- 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…
@@ -1686,19 +842,6 @@ create_person = (name,  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.
@@ -1709,16 +852,6 @@ with str := "Hello"
  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
@@ -1731,20 +864,6 @@ with tb
  [] = "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
@@ -1752,15 +871,6 @@ 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**.
@@ -1771,16 +881,6 @@ 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.
@@ -1796,21 +896,6 @@ 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.
@@ -1820,15 +905,6 @@ 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
@@ -1848,27 +924,6 @@ do
  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
@@ -1888,27 +943,6 @@ do
  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.
@@ -1922,19 +956,6 @@ 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.
@@ -1944,15 +965,6 @@ 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
@@ -1962,19 +974,6 @@ 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
@@ -1983,16 +982,6 @@ if success, result := pcall -> "get result without problems"
 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.
@@ -2003,16 +992,6 @@ while byte := stream\read_one!
  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.
@@ -2028,17 +1007,6 @@ thing = [1, 2]
 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
@@ -2054,23 +1022,6 @@ 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
@@ -2086,23 +1037,6 @@ 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
@@ -2114,75 +1048,30 @@ Jika pernyataan destrukturisasi kompleks, Anda bisa memecahnya ke beberapa baris
 } = 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.
@@ -2195,18 +1084,6 @@ 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
@@ -2220,21 +1097,6 @@ Operator spread dapat digunakan pada posisi berbeda untuk menangkap rentang yang
 [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:
@@ -2249,20 +1111,6 @@ 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
@@ -2285,26 +1133,6 @@ 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.
@@ -2321,20 +1149,6 @@ 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
@@ -2350,23 +1164,6 @@ 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
@@ -2535,55 +1332,6 @@ with apple
 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.
@@ -2642,18 +1390,6 @@ 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
@@ -2661,15 +1397,6 @@ 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
@@ -2677,15 +1404,6 @@ 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
@@ -2703,25 +1421,6 @@ else
 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
@@ -2729,27 +1428,10 @@ 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`.
@@ -2764,20 +1446,6 @@ 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>
 Operator `in` juga dapat digunakan dengan tabel dan mendukung varian `not in` untuk negasi:
 ```yuescript
@@ -2791,21 +1459,6 @@ not_exist = item not in list
 check = -> value not in table
 ```
-<YueDisplay>
-```yue
-has = "foo" in {"bar", "foo"}
-if a in {1, 2, 3}
-  print "a ada di dalam tabel"
-not_exist = item not in list
-check = -> value not in table
-```
-</YueDisplay>
 Daftar atau tabel dengan satu elemen memeriksa kesamaan dengan elemen tersebut:
 ```yuescript
@@ -2820,22 +1473,6 @@ with tb
  c = a in [1]
 ```
-<YueDisplay>
-```yue
-- [1,] memeriksa apakah nilai == 1
-c = a in [1,]
-- {1} juga memeriksa apakah nilai == 1
-c = a in {1}
-- Tanpa koma, [1] adalah akses indeks (tb[1])
-with tb
-  c = a in [1]
-```
-</YueDisplay>
 # Perulangan For
 Ada dua bentuk perulangan for, seperti di Lua. Satu numerik dan satu generik:
@@ -2851,21 +1488,6 @@ 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
@@ -2873,15 +1495,6 @@ 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
@@ -2890,16 +1503,6 @@ 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:
@@ -2912,18 +1515,6 @@ doubled_evens = for i = 1, 20
    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:
@@ -2933,15 +1524,6 @@ 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
@@ -2949,15 +1531,6 @@ 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.
@@ -2970,18 +1543,6 @@ 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.
@@ -2994,18 +1555,6 @@ while i < 10
  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
@@ -3015,17 +1564,6 @@ odds = for x in *my_numbers
  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.
@@ -3040,20 +1578,6 @@ switch name := "Dan"
    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:
@@ -3069,21 +1593,6 @@ next_number = switch b
    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
@@ -3093,17 +1602,6 @@ msg = switch math.random(1, 5)
  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
@@ -3119,23 +1617,6 @@ 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
@@ -3157,25 +1638,6 @@ for item in *items
      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
@@ -3188,20 +1650,6 @@ switch item
    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.
@@ -3216,20 +1664,6 @@ switch tb
    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
@@ -3242,20 +1676,6 @@ switch tb
    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
@@ -3268,20 +1688,6 @@ switch tb
    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
@@ -3295,21 +1701,6 @@ switch tb
    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
@@ -3321,19 +1712,6 @@ switch segments
    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:
@@ -3347,19 +1725,6 @@ while i > 0
 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
@@ -3369,18 +1734,6 @@ until i == 0
 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
@@ -3389,16 +1742,6 @@ value, doubled = while true
  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
@@ -3413,18 +1756,6 @@ repeat
 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
@@ -3435,18 +1766,6 @@ value, scaled = repeat
 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.
@@ -3474,29 +1793,6 @@ run_callback my_object.write
 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.
@@ -3506,15 +1802,6 @@ x <- f
 print "hello" .. x
 ```
-<YueDisplay>
-```yue
-x <- f
-print "hello" .. x
-```
-</YueDisplay>
 Fungsi panah tebal juga tersedia.
 ```yuescript
@@ -3522,15 +1809,6 @@ Fungsi panah tebal juga tersedia.
 print @value
 ```
-<YueDisplay>
-```yue
-<= f
-print @value
-```
-</YueDisplay>
 Anda dapat menentukan placeholder untuk posisi fungsi backcall sebagai parameter.
 ```yuescript
@@ -3538,15 +1816,6 @@ Anda dapat menentukan placeholder untuk posisi fungsi backcall sebagai parameter
 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
@@ -3558,19 +1827,6 @@ result, msg = do
 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: **->**.
@@ -3580,15 +1836,6 @@ 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
@@ -3599,18 +1846,6 @@ func_b = ->
  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
@@ -3618,29 +1853,12 @@ 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
@@ -3650,31 +1868,12 @@ 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:
@@ -3684,29 +1883,12 @@ 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
@@ -3714,15 +1896,6 @@ 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`.
@@ -3731,14 +1904,6 @@ Karena sudah menjadi idiom di Lua untuk mengirim objek sebagai argumen pertama s
 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.
@@ -3749,16 +1914,6 @@ my_function = (name = "something", height = 100) ->
  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
@@ -3766,15 +1921,6 @@ 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.
@@ -3788,17 +1934,6 @@ 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.
@@ -3810,15 +1945,6 @@ 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.
@@ -3835,20 +1961,6 @@ cool_func 1, 2,
  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
@@ -3858,17 +1970,6 @@ my_func 5, 6, 7,
  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
@@ -3879,18 +1980,6 @@ x = [
 ]
 ```
-<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
@@ -3900,17 +1989,6 @@ y = [ my_func 1, 2, 3,
 ]
 ```
-<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
@@ -3927,24 +2005,6 @@ if func 1, 2, 3,
  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:
@@ -3966,23 +2026,6 @@ 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:
@@ -3996,19 +2039,6 @@ findFirstEven = (list): nil ->
          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
@@ -4021,20 +2051,6 @@ findFirstEven = (list) ->
  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
@@ -4063,32 +2079,6 @@ process = (...args) ->
 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.
@@ -4101,14 +2091,6 @@ Sebuah pernyataan biasanya berakhir pada pergantian baris. Anda juga bisa memaka
 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.
@@ -4122,19 +2104,6 @@ Rx.Observable
  \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
@@ -4150,23 +2119,6 @@ Tidak masalah.
 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.
@@ -4176,15 +2128,6 @@ 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
@@ -4192,15 +2135,6 @@ 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
@@ -4208,15 +2142,6 @@ 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.
@@ -4226,15 +2151,6 @@ 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:
@@ -4248,19 +2164,6 @@ 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
@@ -4286,33 +2189,6 @@ print v(1) > v(2) <= v(3)
 ]]
 ```
-<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
@@ -4324,15 +2200,6 @@ 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
@@ -4342,17 +2209,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.
@@ -4374,27 +2230,6 @@ 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.
@@ -4405,16 +2240,6 @@ 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.
@@ -4439,26 +2264,6 @@ 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 **<>**.
@@ -4473,19 +2278,6 @@ 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 **<>**.
@@ -4495,15 +2287,6 @@ Destrukturisasi metatable dengan kunci metamethod yang dikelilingi **<>**.
 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.
@@ -4523,25 +2306,6 @@ with? io.open "test.txt", "w"
  \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 **|>**.
@@ -4560,24 +2324,6 @@ readFile "example.txt"
  |> 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.
@@ -4590,17 +2336,6 @@ 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.
@@ -4648,52 +2383,6 @@ 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**.
@@ -4709,19 +2398,6 @@ some_string = "Here is a string
 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.
@@ -4732,16 +2408,6 @@ 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:
@@ -4754,18 +2420,6 @@ str = |
    - #{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.
@@ -4778,18 +2432,6 @@ fn = ->
  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.
@@ -4800,16 +2442,6 @@ str = |
  note: 'He said: "#{Hello}!"'
 ```
-<YueDisplay>
-```yue
-str = |
-  path: "C:\Program Files\App"
-  note: 'He said: "#{Hello}!"'
-```
-</YueDisplay>
 # Modul
 ## Import
@@ -4841,35 +2473,6 @@ do
  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.
@@ -4881,17 +2484,6 @@ do
  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.
@@ -4913,25 +2505,6 @@ do
  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.
@@ -4956,26 +2529,6 @@ 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
@@ -4983,15 +2536,6 @@ 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
@@ -5000,16 +2544,6 @@ 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.
@@ -5027,23 +2561,6 @@ 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.
@@ -5054,16 +2571,6 @@ export default ->
  123
 ```
-<YueDisplay>
-```yue
-export default ->
-  print "hello"
-  123
-```
-</YueDisplay>
 # Lisensi: MIT
 Copyright (c) 2017-2026 Li Jin <dragon-fly@qq.com>
diff --git a/doc/yue-pt-br.md b/doc/yue-pt-br.md
index 7bab231..dac3aad 100644
--- a/doc/yue-pt-br.md
+++ b/doc/yue-pt-br.md
@@ -1,11 +1,5 @@
---
-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.
@@ -21,17 +15,6 @@ do
 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
@@ -42,18 +25,6 @@ status, value = do
  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
@@ -65,21 +36,6 @@ print counter!
 print counter!
 ```
-<YueDisplay>
-```yue
-counter = do
-  i = 0
-  ->
-    i += 1
-    i
-print counter!
-print counter!
-```
-</YueDisplay>
 ```yuescript
 tbl = {
  key: do
@@ -88,18 +44,6 @@ tbl = {
 }
 ```
-<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:
@@ -108,28 +52,12 @@ Por conveniência, o loop for e a instrução if podem ser aplicados a instruç�
 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
@@ -138,16 +66,6 @@ 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
@@ -183,39 +101,6 @@ 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.
@@ -246,36 +131,6 @@ 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.
@@ -295,27 +150,6 @@ import "utils" as {
 [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.
@@ -325,15 +159,6 @@ 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.
@@ -356,28 +181,6 @@ 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.
@@ -392,20 +195,6 @@ macro printNumAndStr = (num `Num, str `String) -> |
 $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
@@ -417,19 +206,6 @@ macro printNumAndStr = (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
@@ -464,38 +240,6 @@ catch 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.
@@ -518,44 +262,14 @@ catch 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]
+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
@@ -566,18 +280,6 @@ some_values = {
 }
 ```
-<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
@@ -587,17 +289,6 @@ profile =
  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
@@ -609,19 +300,6 @@ values = {
 }
 ```
-<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
@@ -630,16 +308,6 @@ 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
@@ -649,17 +317,6 @@ tbl = {
 }
 ```
-<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
@@ -670,18 +327,6 @@ 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
@@ -691,33 +336,13 @@ t = {
 }
 ```
-<YueDisplay>
+As tabelas Lua têm tanto uma parte array quanto uma parte hash, mas às vezes é útil fazer uma distinção semântica entre as duas. Você pode usar **[ ]** em vez de **{ }** para declarar explicitamente uma tabela como um array, fazer isso impedirá que quaisquer pares chave-valor sejam escritos dentro dela.
-```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.
@@ -731,43 +356,18 @@ 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
@@ -779,19 +379,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:
@@ -804,32 +391,12 @@ 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.
@@ -846,32 +413,10 @@ thing = {
 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
@@ -879,15 +424,6 @@ 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.
@@ -897,15 +433,6 @@ 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.
@@ -916,42 +443,18 @@ Aqui podemos definir os limites mínimo e máximo, pegando todos os itens com í
 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
@@ -959,29 +462,12 @@ Tanto o limite mínimo quanto o máximo podem ser negativos, o que significa que
 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.
@@ -994,18 +480,6 @@ sub_list = items[2, 4]
 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.
@@ -1024,22 +498,6 @@ class Inventory
      @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.
@@ -1056,16 +514,6 @@ 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.
@@ -1088,26 +536,6 @@ 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"
-- 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
@@ -1116,16 +544,6 @@ class Person
    @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.
@@ -1138,18 +556,6 @@ class BackPack extends Inventory
    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.
@@ -1165,19 +571,6 @@ class Shelf
 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.
@@ -1204,22 +597,6 @@ class MyClass extends ParentClass
    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
@@ -1233,17 +610,6 @@ 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.
@@ -1264,14 +630,6 @@ O nome da classe quando foi declarada é armazenado como string no campo \_\_nam
 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.
@@ -1290,20 +648,6 @@ Things\some_func!
 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
@@ -1319,37 +663,12 @@ 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.
@@ -1361,15 +680,6 @@ 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:
@@ -1383,19 +693,6 @@ class MoreThings
    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.
@@ -1407,29 +704,12 @@ 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:
@@ -1448,24 +728,6 @@ class Something
    @@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
@@ -1474,16 +736,6 @@ 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.
@@ -1494,16 +746,6 @@ x = class Bucket
  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.
@@ -1515,31 +757,12 @@ BigBucket = class extends Bucket
 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.
@@ -1562,28 +785,6 @@ 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.
@@ -1602,18 +803,6 @@ with Person!
  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
@@ -1621,15 +810,6 @@ 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
@@ -1637,15 +817,6 @@ 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
@@ -1658,20 +829,6 @@ b = with obj
 -- 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…
@@ -1685,19 +842,6 @@ create_person = (name,  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.
@@ -1708,16 +852,6 @@ with str := "Hello"
  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
@@ -1730,20 +864,6 @@ with tb
  [] = "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
@@ -1751,15 +871,6 @@ 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**.
@@ -1770,16 +881,6 @@ 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.
@@ -1795,21 +896,6 @@ 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.
@@ -1819,15 +905,6 @@ 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
@@ -1847,27 +924,6 @@ do
  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
@@ -1887,27 +943,6 @@ do
  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.
@@ -1921,19 +956,6 @@ 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.
@@ -1943,15 +965,6 @@ 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
@@ -1961,19 +974,6 @@ 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
@@ -1982,16 +982,6 @@ if success, result := pcall -> "obter resultado sem problemas"
 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.
@@ -2002,16 +992,6 @@ while byte := stream\read_one!
  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.
@@ -2027,17 +1007,6 @@ thing = [1, 2]
 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
@@ -2053,23 +1022,6 @@ 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
@@ -2085,23 +1037,6 @@ 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
@@ -2113,75 +1048,30 @@ Se a instrução de desestruturação for complicada, sinta-se à vontade para e
 } = 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.
@@ -2194,18 +1084,6 @@ 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
@@ -2219,21 +1097,6 @@ O operador spread pode ser usado em diferentes posições para capturar diferent
 [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:
@@ -2248,20 +1111,6 @@ 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
@@ -2284,26 +1133,6 @@ 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.
@@ -2320,20 +1149,6 @@ 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
@@ -2349,23 +1164,6 @@ 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
@@ -2534,55 +1332,6 @@ with apple
 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.
@@ -2641,18 +1390,6 @@ 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
@@ -2660,15 +1397,6 @@ 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
@@ -2676,15 +1404,6 @@ 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
@@ -2702,25 +1421,6 @@ else
 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
@@ -2728,27 +1428,10 @@ 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`.
@@ -2763,20 +1446,6 @@ 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>
 O operador `in` também pode ser usado com tabelas e suporta a variante `not in` para negação:
 ```yuescript
@@ -2790,21 +1459,6 @@ not_exist = item not in list
 check = -> value not in table
 ```
-<YueDisplay>
-```yue
-has = "foo" in {"bar", "foo"}
-if a in {1, 2, 3}
-  print "a está na tabela"
-not_exist = item not in list
-check = -> value not in table
-```
-</YueDisplay>
 Uma lista ou tabela de único elemento verifica igualdade com esse elemento:
 ```yuescript
@@ -2819,22 +1473,6 @@ with tb
  c = a in [1]
 ```
-<YueDisplay>
-```yue
-- [1,] verifica se valor == 1
-c = a in [1,]
-- {1} também verifica se valor == 1
-c = a in {1}
-- Sem vírgula, [1] é acesso por índice (tb[1])
-with tb
-  c = a in [1]
-```
-</YueDisplay>
 # Loop For
 Existem duas formas de loop for, assim como no Lua. Uma numérica e uma genérica:
@@ -2850,21 +1488,6 @@ 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
@@ -2872,15 +1495,6 @@ 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
@@ -2889,16 +1503,6 @@ 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:
@@ -2911,18 +1515,6 @@ doubled_evens = for i = 1, 20
    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:
@@ -2932,15 +1524,6 @@ 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
@@ -2948,15 +1531,6 @@ 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.
@@ -2969,18 +1543,6 @@ 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
@@ -2995,18 +1557,6 @@ while i < 10
  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
@@ -3016,17 +1566,6 @@ odds = for x in *my_numbers
  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.
@@ -3041,20 +1580,6 @@ switch name := "Dan"
    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:
@@ -3070,21 +1595,6 @@ next_number = switch b
    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
@@ -3094,17 +1604,6 @@ msg = switch math.random(1, 5)
  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
@@ -3120,23 +1619,6 @@ 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
@@ -3158,25 +1640,6 @@ for item in *items
      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
@@ -3189,20 +1652,6 @@ switch item
    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.
@@ -3217,20 +1666,6 @@ switch tb
    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
@@ -3243,20 +1678,6 @@ switch tb
    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
@@ -3269,20 +1690,6 @@ switch tb
    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
@@ -3296,21 +1703,6 @@ switch tb
    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
@@ -3322,19 +1714,6 @@ switch segments
    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:
@@ -3348,19 +1727,6 @@ while i > 0
 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
@@ -3370,18 +1736,6 @@ until i == 0
 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
@@ -3390,16 +1744,6 @@ value, doubled = while true
  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
@@ -3414,18 +1758,6 @@ repeat
 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
@@ -3436,18 +1768,6 @@ value, scaled = repeat
 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.
@@ -3475,29 +1795,6 @@ run_callback my_object.write
 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.
@@ -3507,15 +1804,6 @@ x <- f
 print "hello" .. x
 ```
-<YueDisplay>
-```yue
-x <- f
-print "hello" .. x
-```
-</YueDisplay>
 Funções seta "fat" também estão disponíveis.
 ```yuescript
@@ -3523,15 +1811,6 @@ Funções seta "fat" também estão disponíveis.
 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
@@ -3539,15 +1818,6 @@ Você pode especificar um placeholder para onde deseja que a função backcall v
 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
@@ -3559,19 +1829,6 @@ result, msg = do
 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: **->**.
@@ -3581,15 +1838,6 @@ 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
@@ -3600,18 +1848,6 @@ func_b = ->
  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
@@ -3619,29 +1855,12 @@ 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
@@ -3651,31 +1870,12 @@ 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:
@@ -3685,29 +1885,12 @@ 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
@@ -3715,15 +1898,6 @@ 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.
@@ -3732,14 +1906,6 @@ Como é um idioma em Lua enviar um objeto como primeiro argumento ao chamar um m
 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.
@@ -3750,16 +1916,6 @@ my_function = (name = "something", height = 100) ->
  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
@@ -3767,15 +1923,6 @@ 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.
@@ -3789,17 +1936,6 @@ 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.
@@ -3811,15 +1947,6 @@ 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.
@@ -3836,20 +1963,6 @@ cool_func 1, 2,
  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
@@ -3859,17 +1972,6 @@ my_func 5, 6, 7,
  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
@@ -3880,18 +1982,6 @@ x = [
 ]
 ```
-<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
@@ -3901,17 +1991,6 @@ y = [ my_func 1, 2, 3,
 ]
 ```
-<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
@@ -3928,24 +2007,6 @@ if func 1, 2, 3,
  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:
@@ -3967,23 +2028,6 @@ 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:
@@ -3997,19 +2041,6 @@ findFirstEven = (list): nil ->
          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
@@ -4022,20 +2053,6 @@ findFirstEven = (list) ->
  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
@@ -4064,32 +2081,6 @@ process = (...args) ->
 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.
@@ -4102,14 +2093,6 @@ Uma instrução normalmente termina em uma quebra de linha. Você também pode u
 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.
@@ -4123,19 +2106,6 @@ Rx.Observable
  \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
@@ -4151,23 +2121,6 @@ Está OK.
 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.
@@ -4177,15 +2130,6 @@ 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
@@ -4193,15 +2137,6 @@ 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
@@ -4209,15 +2144,6 @@ 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.
@@ -4227,15 +2153,6 @@ 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:
@@ -4249,19 +2166,6 @@ 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
@@ -4287,33 +2191,6 @@ print v(1) > v(2) <= v(3)
 ]]
 ```
-<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
@@ -4325,15 +2202,6 @@ 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
@@ -4343,17 +2211,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.
@@ -4375,27 +2232,6 @@ 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.
@@ -4406,16 +2242,6 @@ 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.
@@ -4440,26 +2266,6 @@ 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 **<>**.
@@ -4474,19 +2280,6 @@ 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 **<>**.
@@ -4496,15 +2289,6 @@ Desestruture a metatable com chave de metamétodo cercada por **<>**.
 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.
@@ -4524,25 +2308,6 @@ with? io.open "test.txt", "w"
  \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 **|>**.
@@ -4561,24 +2326,6 @@ readFile "example.txt"
  |> 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.
@@ -4591,17 +2338,6 @@ 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.
@@ -4649,52 +2385,6 @@ 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**.
@@ -4710,19 +2400,6 @@ some_string = "Aqui está uma string
 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.
@@ -4733,16 +2410,6 @@ 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:
@@ -4755,18 +2422,6 @@ str = |
    - #{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.
@@ -4779,18 +2434,6 @@ fn = ->
  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.
@@ -4801,16 +2444,6 @@ str = |
  note: 'Ele disse: "#{Hello}!"'
 ```
-<YueDisplay>
-```yue
-str = |
-  path: "C:\Program Files\App"
-  note: 'Ele disse: "#{Hello}!"'
-```
-</YueDisplay>
 # Módulo
 ## Import
@@ -4842,35 +2475,6 @@ do
  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.
@@ -4882,17 +2486,6 @@ do
  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.
@@ -4914,25 +2507,6 @@ do
  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.
@@ -4957,26 +2531,6 @@ 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
@@ -4984,15 +2538,6 @@ 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
@@ -5001,16 +2546,6 @@ 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.
@@ -5028,23 +2563,6 @@ 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.
@@ -5055,16 +2573,6 @@ export default ->
  123
 ```
-<YueDisplay>
-```yue
-export default ->
-  print "hello"
-  123
-```
-</YueDisplay>
 # Licença: MIT
 Copyright (c) 2017-2026 Li Jin \<dragon-fly@qq.com\>
diff --git a/doc/yue-zh.md b/doc/yue-zh.md
index 93e21d8..d8b5346 100644
--- a/doc/yue-zh.md
+++ b/doc/yue-zh.md
@@ -1,11 +1,5 @@
---
-title: 参考手册
---
 # 月之脚本文档
-<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em;padding-bottom: 2em;"/>
 欢迎来到 <b>月之脚本（YueScript）</b> 官方文档！<br/>
 这里收录了语言特性、用法、参考示例和资源。<br/>
 请选择左侧的章节索引或目录，开启你的月之脚本之旅 ☽
@@ -21,17 +15,6 @@ do
 print var -- 这里是nil
 ```
-<YueDisplay>
-```yue
-do
-  var = "hello"
-  print var
-print var -- 这里是nil
-```
-</YueDisplay>
 &emsp;&emsp;月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将 do 语句代码块的最后一个语句作为表达式返回的结果。`do` 表达式支持通过 `break` 打断执行流并提前返回多个值。
 ```yuescript
@@ -42,18 +25,6 @@ status, value = do
  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
@@ -65,21 +36,6 @@ print counter!
 print counter!
 ```
-<YueDisplay>
-```yue
-counter = do
-  i = 0
-  ->
-    i += 1
-    i
-print counter!
-print counter!
-```
-</YueDisplay>
 ```yuescript
 tbl = {
  key: do
@@ -88,18 +44,6 @@ tbl = {
 }
 ```
-<YueDisplay>
-```yue
-tbl = {
-  key: do
-    print "分配键值!"
-    1234
-}
-```
-</YueDisplay>
 # 代码行修饰
 &emsp;&emsp;为了方便编写代码，循环语句和 if 语句可以应用于单行代码语句的末尾：
@@ -108,28 +52,12 @@ tbl = {
 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
@@ -138,16 +66,6 @@ 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>
 # 宏
 ## 常见用法
@@ -183,39 +101,6 @@ 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 代码字符串的配置表。
@@ -246,36 +131,6 @@ 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;宏函数可以从一个模块中导出，并在另一个模块中导入。你必须将导出的宏函数放在一个单独的文件中使用，而且只有宏定义、宏导入和宏展开可以放入这个宏导出模块中。
@@ -295,28 +150,6 @@ import "utils" as {
 [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;月之脚本中有一些内置可以直接使用的宏，但你可以通过声明相同名称的宏来覆盖它们。
@@ -326,15 +159,6 @@ print $FILE -- 获取当前模块名称的字符串
 print $LINE -- 获取当前代码行数：2
 ```
-<YueDisplay>
-```yue
-print $FILE -- 获取当前模块名称的字符串
-print $LINE -- 获取当前代码行数：2
-```
-</YueDisplay>
 ## 用宏生成宏
 &emsp;&emsp;在月之脚本中，宏函数允许你在编译时生成代码。通过嵌套的宏函数，你可以创建更复杂的生成模式。这个特性允许你定义一个宏函数，用它来生成另一个宏函数，从而实现更加动态的代码生成。
@@ -357,28 +181,6 @@ 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 节点类型，并在编译时检查传入的宏参数是否符合预期。
@@ -393,20 +195,6 @@ macro printNumAndStr = (num `Num, str `String) -> |
 $printNumAndStr 123, "hello"
 ```
-<YueDisplay>
-```yue
-macro printNumAndStr = (num `Num, str `String) -> |
-  print(
-    #{num}
-    #{str}
-  )
-$printNumAndStr 123, "hello"
-```
-</YueDisplay>
 &emsp;&emsp;如果需要做更加灵活的参数检查操作，可以使用内置的 `$is_ast` 宏函数在合适的位置进行手动检查。
 ```yuescript
@@ -418,19 +206,6 @@ macro printNumAndStr = (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) 中大写的规则定义。
 # 错误处理
@@ -465,38 +240,6 @@ catch 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` 值而非错误对象。
@@ -519,44 +262,14 @@ catch 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]
+some_values = {1, 2, 3, 4}
-```
-<YueDisplay>
-```yue
-some_values = [1, 2, 3, 4]
 ```
-</YueDisplay>
 &emsp;&emsp;但与Lua不同的是，给表格中的键赋值是用 **:**（而不是 **=**）。
 ```yuescript
@@ -567,18 +280,6 @@ some_values = {
 }
 ```
-<YueDisplay>
-```yue
-some_values = {
-  name: "Bill",
-  age: 200,
-  ["favorite food"]: "rice"
-}
-```
-</YueDisplay>
 &emsp;&emsp;如果只分配一个键值对的表格，可以省略花括号。
 ```yuescript
@@ -588,17 +289,6 @@ profile =
  favorite_foods: ["冰淇淋", "甜甜圈"]
 ```
-<YueDisplay>
-```yue
-profile =
-  height: "4英尺",
-  shoe_size: 13,
-  favorite_foods: ["冰淇淋", "甜甜圈"]
-```
-</YueDisplay>
 &emsp;&emsp;可以使用换行符而不使用逗号（或两者都用）来分隔表格中的值：
 ```yuescript
@@ -610,19 +300,6 @@ values = {
 }
 ```
-<YueDisplay>
-```yue
-values = {
-  1, 2, 3, 4
-  5, 6, 7, 8
-  name: "超人"
-  occupation: "打击犯罪"
-}
-```
-</YueDisplay>
 &emsp;&emsp;创建单行表格字面量时，也可以省略花括号：
 ```yuescript
@@ -631,16 +308,6 @@ 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
@@ -650,17 +317,6 @@ tbl = {
 }
 ```
-<YueDisplay>
-```yue
-tbl = {
-  do: "某事"
-  end: "饥饿"
-}
-```
-</YueDisplay>
 &emsp;&emsp;如果你要构造一个由变量组成的表，并希望键与变量名相同，那么可以使用 **:** 前缀操作符：
 ```yuescript
@@ -671,18 +327,6 @@ 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
@@ -692,17 +336,6 @@ t = {
 }
 ```
-<YueDisplay>
-```yue
-t = {
-  [1 + 2]: "你好"
-  "你好 世界": true
-}
-```
-</YueDisplay>
 &emsp;&emsp;Lua 的表同时具有数组部分和哈希部分，但有时候你会希望在书写 Lua 表时，对 Lua 表做数组和哈希不同用法的语义区分。然后你可以用 **[ ]** 而不是 **{ }** 来编写表示数组的 Lua 表，并且不允许在数组 Lua 表中写入任何键值对。
 ```yuescript
@@ -710,15 +343,6 @@ 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 表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
@@ -732,43 +356,18 @@ 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
@@ -780,19 +379,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 子句与使用多重循环的效果相同：
@@ -805,32 +391,12 @@ 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;表格推导式和列表推导式的语法非常相似，只是要使用 **{** 和 **}** 并从每次迭代中取两个值。
@@ -847,32 +413,10 @@ thing = {
 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
@@ -880,15 +424,6 @@ 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;在下面的示例中，我们将一些数组转换为一个表，其中每个数组里的第一项是键，第二项是值。
@@ -898,15 +433,6 @@ 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 循环中设置迭代边界和步长。
@@ -917,42 +443,18 @@ tbl = {unpack tuple for tuple in *tuples}
 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
@@ -960,29 +462,12 @@ slice = [item for item in *items[,,2]]
 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;切片也可以作为表达式来使用。可以用于获取一个表包含的子列表。
@@ -995,18 +480,6 @@ sub_list = items[2, 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 代码。
@@ -1025,22 +498,6 @@ class Inventory
      @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” 的参数。
@@ -1055,16 +512,6 @@ 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;需要特别注意的是，类的所有属性在其实例之间是共享的。这对于函数类型的成员属性通常不会造成问题，但对于其他类型的属性，可能会导致意外的结果。
@@ -1087,26 +534,6 @@ 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
@@ -1115,16 +542,6 @@ class Person
    @clothes = []
 ```
-<YueDisplay>
-```yue
-class Person
-  new: =>
-    @clothes = []
-```
-</YueDisplay>
 ## 继承
 &emsp;&emsp;`extends` 关键字可以在类声明中使用，以继承另一个类的属性和方法。
@@ -1137,18 +554,6 @@ class BackPack extends Inventory
    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` 方法来调用并执行父类的构造函数。
@@ -1164,19 +569,6 @@ class Shelf
 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` 是一个特别的关键字，它有两种不同的使用方式：既可以当作一个对象来看待，也可以像调用函数那样使用。它仅在类的内部使用时具有特殊的功能。
@@ -1201,22 +593,6 @@ class MyClass extends ParentClass
    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。
 ## 类型
@@ -1230,17 +606,6 @@ assert b.__class == BackPack
 print BackPack.size -- 打印 10
 ```
-<YueDisplay>
-```yue
-b = BackPack!
-assert b.__class == BackPack
-print BackPack.size -- 打印 10
-```
-</YueDisplay>
 ## 类对象
 &emsp;&emsp;在月之脚本中，当我们编写类的定义语句时，实际上是在创建一个类对象。这个类对象被保存在一个与该类同名的变量中。
@@ -1259,14 +624,6 @@ print BackPack.size -- 打印 10
 print BackPack.__name -- 打印 Backpack
 ```
-<YueDisplay>
-```yue
-print BackPack.__name -- 打印 Backpack
-```
-</YueDisplay>
 &emsp;&emsp;基础对象被保存在一个名为 `__base` 的特殊表中。我们可以编辑这个表，以便为那些已经创建出来的实例和还未创建的实例增加新的功能。
 &emsp;&emsp;另外，如果一个类是从另一个类派生而来的，那么其父类对象则会被存储在名为 `__parent` 的地方。这种机制允许在类之间实现继承和功能扩展。
@@ -1285,20 +642,6 @@ 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
@@ -1314,37 +657,12 @@ 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 等于类对象，而不是实例对象。
@@ -1356,15 +674,6 @@ class Things
  @class_var = "hello world"
 ```
-<YueDisplay>
-```yue
-class Things
-  @class_var = "hello world"
-```
-</YueDisplay>
 &emsp;&emsp;这些表达式会在所有属性被添加到类的基对象后执行。
 &emsp;&emsp;在类的主体中声明的所有变量都会限制作用域只在类声明的范围。这对于放置只有类方法可以访问的私有值或辅助函数很方便：
@@ -1378,19 +687,6 @@ class MoreThings
    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 中访问的那个名字。
@@ -1402,29 +698,12 @@ 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;为了减少编写简单值对象定义的代码。你可以这样简单写一个类：
@@ -1443,24 +722,6 @@ class Something
    @@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
@@ -1469,16 +730,6 @@ obj = new {}, 123, "abc"
 print obj
 ```
-<YueDisplay>
-```yue
-new = (@fieldA, @fieldB) => @
-obj = new {}, 123, "abc"
-print obj
-```
-</YueDisplay>
 ## 类表达式
 &emsp;&emsp;类声明的语法也可以作为一个表达式使用，可以赋值给一个变量或者被返回语句返回。
@@ -1489,16 +740,6 @@ x = class Bucket
  add_drop: => @drops += 1
 ```
-<YueDisplay>
-```yue
-x = class Bucket
-  drops: 0
-  add_drop: => @drops += 1
-```
-</YueDisplay>
 ## 匿名类
 &emsp;&emsp;声明类时可以省略名称。如果类的表达式不在赋值语句中，\_\_name 属性将为 nil。如果出现在赋值语句中，赋值操作左侧的名称将代替 nil。
@@ -1510,31 +751,12 @@ BigBucket = class extends Bucket
 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`）。然而，当你从一个类对象做混合时，需要注意的是该类对象的元方法将不会被复制到新类。
@@ -1557,28 +779,6 @@ 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 代码时，我们在创建对象后的常见操作是立即调用这个对象一系列操作函数并设置一系列属性。
@@ -1597,18 +797,6 @@ with Person!
  print .name
 ```
-<YueDisplay>
-```yue
-with Person!
-  .name = "Oswald"
-  \add_relative my_dad
-  \save!
-  print .name
-```
-</YueDisplay>
 with 语句也可以用作一个表达式，并返回它的代码块正在处理的对象。
 ```yuescript
@@ -1616,15 +804,6 @@ file = with File "favorite_foods.txt"
  \set_encoding "utf8"
 ```
-<YueDisplay>
-```yue
-file = with File "favorite_foods.txt"
-  \set_encoding "utf8"
-```
-</YueDisplay>
 `with` 表达式支持 `break` 返回一个值：
 ```yuescript
@@ -1632,15 +811,6 @@ result = with obj
  break .value
 ```
-<YueDisplay>
-```yue
-result = with obj
-  break .value
-```
-</YueDisplay>
 在 `with` 中使用 `break value` 后，`with` 表达式将不再返回其目标对象，而是返回 `break` 给出的值。
 ```yuescript
@@ -1653,20 +823,6 @@ b = with obj
 -- 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 返回值。
 或者…
@@ -1680,19 +836,6 @@ create_person = (name,  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 语句中的表达式也可以是一个赋值语句。
@@ -1703,16 +846,6 @@ with str := "你好"
  print "大写:", \upper!
 ```
-<YueDisplay>
-```yue
-with str := "你好"
-  print "原始:", str
-  print "大写:", \upper!
-```
-</YueDisplay>
 你可以在 `with` 语句中使用 `[]` 访问特殊键。
 ```yuescript
@@ -1725,20 +858,6 @@ with tb
  [] = "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
@@ -1746,15 +865,6 @@ with? obj
  print obj.name
 ```
-<YueDisplay>
-```yue
-with? obj
-  print obj.name
-```
-</YueDisplay>
 # 赋值
 &emsp;&emsp;月之脚本中定义的变量是动态类型的，并默认为局部变量。但你可以通过 **local** 和 **global** 声明来改变声明变量的作用范围。
@@ -1765,16 +875,6 @@ a, b, c = 1, 2, 3
 hello = 123 -- 访问现有的变量
 ```
-<YueDisplay>
-```yue
-hello = "world"
-a, b, c = 1, 2, 3
-hello = 123 -- 访问现有的变量
-```
-</YueDisplay>
 ## 执行更新
 &emsp;&emsp;你可以使用各式二进制运算符执行更新赋值。
@@ -1790,21 +890,6 @@ 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;你可以进行链式赋值，将多个项目赋予相同的值。
@@ -1814,15 +899,6 @@ a = b = c = d = e = 0
 x = y = z = f!
 ```
-<YueDisplay>
-```yue
-a = b = c = d = e = 0
-x = y = z = f!
-```
-</YueDisplay>
 ## 显式声明局部变量
 ```yuescript
@@ -1842,27 +918,6 @@ do
  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
@@ -1882,27 +937,6 @@ do
  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 的方式访问其内容。
@@ -1916,19 +950,6 @@ 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` 代码块可以在条件表达式的位置进行赋值。在代码执行到要计算条件时，会首先进行赋值计算，并使用赋与的值作为分支判断的条件。赋值的变量仅在条件分支的代码块内有效，这意味着如果值不是真值，那么它就不会被用到。注意，你必须使用“海象运算符” `:=` 而不是 `=` 来做赋值。
@@ -1938,15 +959,6 @@ 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
@@ -1956,19 +968,6 @@ 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
@@ -1977,16 +976,6 @@ if success, result := pcall -> "无报错地获取结果"
 print "好的"
 ```
-<YueDisplay>
-```yue
-if success, result := pcall -> "无报错地获取结果"
-  print result -- 变量 result 是有作用域的
-print "好的"
-```
-</YueDisplay>
 ## While 赋值
 &emsp;&emsp;你可以在 while 循环中同样使用赋值来获取循环条件的值。
@@ -1997,16 +986,6 @@ while byte := stream\read_one!
  print byte
 ```
-<YueDisplay>
-```yue
-while byte := stream\read_one!
-  -- 对 byte 做一些操作
-  print byte
-```
-</YueDisplay>
 # 解构赋值
 &emsp;&emsp;解构赋值是一种快速从 Lua 表中按名称或基于数组中的位置提取值的方法。
@@ -2022,17 +1001,6 @@ thing = [1, 2]
 print a, b
 ```
-<YueDisplay>
-```yue
-thing = [1, 2]
-[a, b] = thing
-print a, b
-```
-</YueDisplay>
 &emsp;&emsp;在解构表格字面量中，键代表从右侧读取的键，值代表读取的值将被赋予的名称。
 ```yuescript
@@ -2048,23 +1016,6 @@ 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
@@ -2080,23 +1031,6 @@ 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
@@ -2108,75 +1042,30 @@ print first, second, 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;你可以使用展开运算符 `...` 在列表解构中来捕获一个范围的值到子列表中。这在当你想要从列表的开头和结尾提取特定元素，同时收集中间的元素时非常有用。
@@ -2189,18 +1078,6 @@ 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
@@ -2214,21 +1091,6 @@ print last   -- 打印: last
 [first, ..._, last] = orders
 ```
-<YueDisplay>
-```yue
-- 捕获第一个元素之后的所有元素
-[first, ...rest] = orders
-- 捕获最后一个元素之前的所有元素
-[...start, last] = orders
-- 跳过中间的元素，只捕获第一个和最后一个元素
-[first, ..._, last] = orders
-```
-</YueDisplay>
 ## 在其它地方的解构赋值
 &emsp;&emsp;解构赋值也可以出现在其它隐式进行赋值的地方。一个例子是用在 for 循环中：
@@ -2243,20 +1105,6 @@ 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 语句：防止破坏性赋值
@@ -2279,26 +1127,6 @@ 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;如果我们可以明确指出哪些变量是我们想在当前作用域内修改的，并且防止我们不小心更改了其他作用域中同名的变量，那将大有裨益。
@@ -2315,20 +1143,6 @@ 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
@@ -2344,23 +1158,6 @@ 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 模块
@@ -2527,55 +1324,6 @@ with apple
 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 游戏引擎的开发体验。
@@ -2634,18 +1382,6 @@ else
  print "没有硬币"
 ```
-<YueDisplay>
-```yue
-have_coins = false
-if have_coins
-  print "有硬币"
-else
-  print "没有硬币"
-```
-</YueDisplay>
 &emsp;&emsp;对于简单的语句，也可以使用简短的语法：
 ```yuescript
@@ -2653,15 +1389,6 @@ 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
@@ -2669,15 +1396,6 @@ have_coins = false
 print if have_coins then "有硬币" else "没有硬币"
 ```
-<YueDisplay>
-```yue
-have_coins = false
-print if have_coins then "有硬币" else "没有硬币"
-```
-</YueDisplay>
 &emsp;&emsp;条件语句也可以作为表达式用在返回语句和赋值语句中：
 ```yuescript
@@ -2695,25 +1413,6 @@ 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
@@ -2721,27 +1420,10 @@ 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;你可以使用范围表达式来编写进行范围检查的代码。
@@ -2756,20 +1438,6 @@ 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>
 `in` 运算符也可以用于表，并支持 `not in` 变体来进行否定检查：
 ```yuescript
@@ -2783,21 +1451,6 @@ not_exist = item not in list
 check = -> value not in table
 ```
-<YueDisplay>
-```yue
-has = "foo" in {"bar", "foo"}
-if a in {1, 2, 3}
-  print "a 在表中"
-not_exist = item not in list
-check = -> value not in table
-```
-</YueDisplay>
 单元素列表或表会检查与该元素的相等性：
 ```yuescript
@@ -2812,22 +1465,6 @@ with tb
  c = a in [1]
 ```
-<YueDisplay>
-```yue
-- [1,] 检查 value == 1
-c = a in [1,]
-- {1} 也是检查 value == 1
-c = a in {1}
-- 没有逗号，[1] 是索引访问（tb[1]）
-with tb
-  c = a in [1]
-```
-</YueDisplay>
 # for 循环
 &emsp;&emsp;Lua 中有两种 for 循环形式，数字型和通用型：
@@ -2843,21 +1480,6 @@ 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
@@ -2865,15 +1487,6 @@ for item in *items[2, 4]
  print item
 ```
-<YueDisplay>
-```yue
-for item in *items[2, 4]
-  print item
-```
-</YueDisplay>
 &emsp;&emsp;当代码语句只有一行时，循环语句也都可以写作更短的语法：
 ```yuescript
@@ -2882,16 +1495,6 @@ 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;将每个偶数加倍：
@@ -2904,18 +1507,6 @@ doubled_evens = for i = 1, 20
    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 的数字：
@@ -2925,29 +1516,11 @@ 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 循环表达式。
@@ -2960,18 +1533,6 @@ 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 语句
@@ -2986,18 +1547,6 @@ while i < 10
  print i
 ```
-<YueDisplay>
-```yue
-i = 0
-while i < 10
-  i += 1
-  continue if i % 2 == 0
-  print i
-```
-</YueDisplay>
 &emsp;&emsp;继续语句也可以与各种循环表达式一起使用，以防止当前的循环迭代结果累积到结果列表中。以下示例将数组表过滤为仅包含偶数的数组：
 ```yuescript
@@ -3007,17 +1556,6 @@ odds = for x in *my_numbers
  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 语句中也可以使用赋值表达式来储存临时变量值。
@@ -3032,20 +1570,6 @@ switch name := "Dan"
    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 语句返回的结果分配给一个变量：
@@ -3061,21 +1585,6 @@ next_number = switch b
    error "数字数得太大了！"
 ```
-<YueDisplay>
-```yue
-b = 1
-next_number = switch b
-  when 1
-    2
-  when 2
-    3
-  else
-    error "数字数得太大了！"
-```
-</YueDisplay>
 &emsp;&emsp;我们可以使用 then 关键字在 when 子句的同一行上编写处理代码。else 代码块的后续代码中要写在同一行上不需要额外的关键字。
 ```yuescript
@@ -3085,17 +1594,6 @@ msg = switch math.random(1, 5)
  else "不太幸运"
 ```
-<YueDisplay>
-```yue
-msg = switch math.random(1, 5)
-  when 1 then "你很幸运"
-  when 2 then "你差点很幸运"
-  else "不太幸运"
-```
-</YueDisplay>
 &emsp;&emsp;如果在编写 switch 语句时希望少写一个缩进，那么你可以把第一个 when 子句放在 switch 开始语句的第一行，然后后续的子语句就都可以都少写一个缩进。
 ```yuescript
@@ -3111,23 +1609,6 @@ 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 元方法来重载判断逻辑时，可能会有用。
 ## 表格匹配
@@ -3149,25 +1630,6 @@ for item in *items
      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
@@ -3180,20 +1642,6 @@ switch item
    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;匹配数组元素。
@@ -3208,20 +1656,6 @@ switch tb
    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
@@ -3234,20 +1668,6 @@ switch tb
    print "无效值"
 ```
-<YueDisplay>
-```yue
-switch tb
-  when success: true, :result
-    print "成功", result
-  when success: false
-    print "失败", result
-  else
-    print "无效值"
-```
-</YueDisplay>
 &emsp;&emsp;匹配嵌套的表格结构。
 ```yuescript
@@ -3260,20 +1680,6 @@ switch tb
    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
@@ -3287,21 +1693,6 @@ switch tb
    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
@@ -3313,19 +1704,6 @@ switch segments
    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 循环支持几种不同的写法：
@@ -3339,19 +1717,6 @@ while i > 0
 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
@@ -3361,18 +1726,6 @@ until i == 0
 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
@@ -3381,16 +1734,6 @@ value, doubled = while true
  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 循环
@@ -3405,18 +1748,6 @@ repeat
 until i == 0
 ```
-<YueDisplay>
-```yue
-i = 10
-repeat
-  print i
-  i -= 1
-until i == 0
-```
-</YueDisplay>
 &emsp;&emsp;repeat 循环表达式同样支持 `break` 返回多个值：
 ```yuescript
@@ -3427,18 +1758,6 @@ value, scaled = repeat
 until false
 ```
-<YueDisplay>
-```yue
-i = 1
-value, scaled = repeat
-  break i, i * 100 if i > 3
-  i += 1
-until false
-```
-</YueDisplay>
 # 函数存根
 &emsp;&emsp;在编程中，将对象的方法作为函数类型的值进行传递是一种常见做法，尤其是在将实例方法作为回调函数传递给其他函数的情形中。当目标函数需要将该对象作为其第一个参数时，我们需要找到一种方式将对象和函数绑定在一起，以便能够正确地调用该函数。
@@ -3466,29 +1785,6 @@ 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;反向回调用于减少函数回调的嵌套。它们使用指向左侧的箭头，并且默认会被定义为传入后续函数调用的最后一个参数。它的语法大部分与常规箭头函数相同，只是它指向另一方向，并且后续的函数体不需要进行缩进。
@@ -3498,15 +1794,6 @@ x <- f
 print "hello" .. x
 ```
-<YueDisplay>
-```yue
-x <- f
-print "hello" .. x
-```
-</YueDisplay>
 &emsp;&emsp;月之脚本也提供了粗箭头反向回调函数。
 ```yuescript
@@ -3514,15 +1801,6 @@ print "hello" .. x
 print @value
 ```
-<YueDisplay>
-```yue
-<= f
-print @value
-```
-</YueDisplay>
 &emsp;&emsp;你可以通过一个占位符指定回调函数的传参位置。
 ```yuescript
@@ -3530,15 +1808,6 @@ print @value
 x * 2
 ```
-<YueDisplay>
-```yue
-(x) <- map _, [1, 2, 3]
-x * 2
-```
-</YueDisplay>
 &emsp;&emsp;如果你希望在反向回调处理后继续编写更多其它的代码，可以使用 do 语句将不属于反向回调的代码分隔开。对于非粗箭头函数的反向回调，回调返回值的括号也是可以省略的。
 ```yuescript
@@ -3550,19 +1819,6 @@ result, msg = do
 print result, msg
 ```
-<YueDisplay>
-```yue
-result, msg = do
-  data <- readAsync "文件名.txt"
-  print data
-  info <- processAsync data
-  check info
-print result, msg
-```
-</YueDisplay>
 # 函数字面量
 &emsp;&emsp;所有函数都是使用月之脚本的函数表达式创建的。一个简单的函数可以用箭头表示为：**->**。
@@ -3572,15 +1828,6 @@ my_function = ->
 my_function() -- 调用空函数
 ```
-<YueDisplay>
-```yue
-my_function = ->
-my_function() -- 调用空函数
-```
-</YueDisplay>
 &emsp;&emsp;函数体可以是紧跟在箭头后的一个语句，或者是在后面的行上使用同样缩进的一系列语句：
 ```yuescript
@@ -3591,18 +1838,6 @@ func_b = ->
  print "这个值是：", value
 ```
-<YueDisplay>
-```yue
-func_a = -> print "你好，世界"
-func_b = ->
-  value = 100
-  print "这个值是：", value
-```
-</YueDisplay>
 &emsp;&emsp;如果一个函数没有参数，可以使用 **\!** 操作符调用它，而不是空括号。使用 **\!** 调用没有参数的函数是推荐的写法。
 ```yuescript
@@ -3610,29 +1845,12 @@ 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
@@ -3642,31 +1860,12 @@ 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;函数会将函数体中的最后一个语句强制转换为返回语句，这被称作隐式返回：
@@ -3676,29 +1875,12 @@ 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
@@ -3706,15 +1888,6 @@ 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 参数的函数。
@@ -3723,14 +1896,6 @@ a, b = mystery 10, 20
 func = (num) => @value + num
 ```
-<YueDisplay>
-```yue
-func = (num) => @value + num
-```
-</YueDisplay>
 ## 参数默认值
 &emsp;&emsp;可以为函数的参数提供默认值。如果参数的值为 nil，则确定该参数为空。任何具有默认值的 nil 参数在函数体运行之前都会被替换。
@@ -3741,16 +1906,6 @@ my_function = (name = "某物", height = 100) ->
  print "我的高度是", height
 ```
-<YueDisplay>
-```yue
-my_function = (name = "某物", height = 100) ->
-  print "你好，我是", name
-  print "我的高度是", height
-```
-</YueDisplay>
 &emsp;&emsp;函数参数的默认值表达式在函数体中会按参数声明的顺序进行计算。因此，在默认值的表达式中可以访问先前声明的参数。
 ```yuescript
@@ -3758,15 +1913,6 @@ 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;由于月之脚本支持无需括号的表达式式函数调用，因此为了避免因空白字符造成的解析歧义，需要进行一些限制。
@@ -3780,17 +1926,6 @@ 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;当变量名和字符串字面量之间没有空格时，函数的调用优先级高于后续表达式，因此此时无法再传入其他参数。
@@ -3802,15 +1937,6 @@ x = func"hello" + 100
 y = func "hello" + 100
 ```
-<YueDisplay>
-```yue
-x = func"hello" + 100
-y = func "hello" + 100
-```
-</YueDisplay>
 ## 多行参数
 &emsp;&emsp;当调用接收大量参数的函数时，将参数列表分成多行是很方便的。由于月之脚本语言对空白字符的敏感性，做参数列表的分割时务必要小心。
@@ -3827,20 +1953,6 @@ cool_func 1, 2,
  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
@@ -3850,17 +1962,6 @@ my_func 5, 6, 7,
  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
@@ -3871,18 +1972,6 @@ x = [
 ]
 ```
-<YueDisplay>
-```yue
-x = [
-  1, 2, 3, 4, a_func 4, 5,
-    5, 6,
-  8, 9, 10
-]
-```
-</YueDisplay>
 &emsp;&emsp;有个不常见的写法可以注意一下，如果我们将在后面使用较低的缩进，我们可以为函数参数提供更深的缩进来区分列表的归属。
 ```yuescript
@@ -3892,17 +1981,6 @@ y = [ my_func 1, 2, 3,
 ]
 ```
-<YueDisplay>
-```yue
-y = [ my_func 1, 2, 3,
-   4, 5,
-  5, 6, 7
-]
-```
-</YueDisplay>
 &emsp;&emsp;对于其它有代码块跟随的语句，比如条件语句，也可以通过小心安排缩进来做类似的事。比如我们可以通过调整缩进级别来控制一些值归属于哪个语句：
 ```yuescript
@@ -3919,24 +1997,6 @@ if func 1, 2, 3,
  print "我在if内部"
 ```
-<YueDisplay>
-```yue
-if func 1, 2, 3,
-  "你好",
-  "世界"
-    print "你好"
-    print "我在if内部"
-if func 1, 2, 3,
-    "你好",
-    "世界"
-  print "你好"
-  print "我在if内部"
-```
-</YueDisplay>
 ## 参数解构
 &emsp;&emsp;月之脚本支持在函数形参位置对传入对象进行解构。适用两类解构表子面量：
@@ -3958,23 +2018,6 @@ 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;在深度嵌套的函数体中，为了提升返回值的可读性及编写便利性，我们新增了 “前置返回表达式” 语法。其形式如下：
@@ -3988,19 +2031,6 @@ findFirstEven = (list): nil ->
          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
@@ -4013,20 +2043,6 @@ findFirstEven = (list) ->
  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;唯一的区别在于：你可以将函数的返回值表达式提前写在 `->` 或 `=>` 前，用以指示该函数应隐式返回该表达式的值。这样即使在多层循环或条件判断的场景下，也无需编写尾行悬挂的返回表达式，逻辑结构会更加直观清晰。
 ## 命名变长参数
@@ -4055,32 +2071,6 @@ process = (...args) ->
 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个空格，但最好不要混合使用空格和制表符。
@@ -4093,14 +2083,6 @@ process 1, nil, 3, nil, 5
 a = 1; b = 2; print a + b
 ```
-<YueDisplay>
-```yue
-a = 1; b = 2; print a + b
-```
-</YueDisplay>
 ## 多行链式调用
 &emsp;&emsp;你可以使用相同的缩进来编写多行链式函数调用。
@@ -4114,19 +2096,6 @@ Rx.Observable
  \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
@@ -4142,23 +2111,6 @@ str = --[[
 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` 的属性声明语法，并获得常量检查和作用域回调的功能。
@@ -4168,15 +2120,6 @@ const a = 123
 close _ = <close>: -> print "超出范围。"
 ```
-<YueDisplay>
-```yue
-const a = 123
-close _ = <close>: -> print "超出范围。"
-```
-</YueDisplay>
 &emsp;&emsp;你可以对进行解构得到的变量标记为常量。
 ```yuescript
@@ -4184,15 +2127,6 @@ const {:a, :b, c, d} = tb
 -- a = 1
 ```
-<YueDisplay>
-```yue
-const {:a, :b, c, d} = tb
-- a = 1
-```
-</YueDisplay>
 &emsp;&emsp;你也可以声明全局变量为常量。
 ```yuescript
@@ -4200,15 +2134,6 @@ global const Constant = 123
 -- Constant = 1
 ```
-<YueDisplay>
-```yue
-global const Constant = 123
-- Constant = 1
-```
-</YueDisplay>
 # 操作符
 &emsp;&emsp;Lua 的所有二元和一元操作符在月之脚本中都是可用的。此外，**!=** 符号是 **~=** 的别名，而 **\\** 或 **::** 均可用于编写链式函数调用，如写作 `tb\func!` 或 `tb::func!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
@@ -4218,15 +2143,6 @@ 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;你可以在月之脚本中进行比较表达式的链式书写：
@@ -4240,19 +2156,6 @@ 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
@@ -4278,33 +2181,6 @@ print v(1) > v(2) <= v(3)
 ]]
 ```
-<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` 运算符来做连接。
 ## 表追加
@@ -4316,15 +2192,6 @@ tab = []
 tab[] = "Value"
 ```
-<YueDisplay>
-```yue
-tab = []
-tab[] = "Value"
-```
-</YueDisplay>
 &emsp;&emsp;你还可以使用展开操作符 `...` 来将一个列表中的所有元素追加到另一个列表中：
 ```yuescript
@@ -4334,17 +2201,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 表中插入数组表或哈希表。
@@ -4366,27 +2222,6 @@ 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;你可以使用 **#** 操作符来反向索引表中的元素。
@@ -4397,16 +2232,6 @@ second_last = data.items[#-1]
 data.items[#] = 1
 ```
-<YueDisplay>
-```yue
-last = data.items[#]
-second_last = data.items[#-1]
-data.items[#] = 1
-```
-</YueDisplay>
 ## 元表
 &emsp;&emsp;**<>** 操作符可提供元表操作的快捷方式。
@@ -4431,26 +2256,6 @@ 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;使用 **<>** 或被 **<>** 包围的元方法名或在 **<>** 中编写某些表达式来访问元表。
@@ -4465,19 +2270,6 @@ 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;使用被 **<>** 包围的元方法键解构元表。
@@ -4487,15 +2279,6 @@ print tb.item
 print item, new, close, getter
 ```
-<YueDisplay>
-```yue
-{item, :new, :<close>, <index>: getter} = tb
-print item, new, close, getter
-```
-</YueDisplay>
 ## 存在性
 &emsp;&emsp;**?** 运算符可以在多种上下文中用来检查存在性。
@@ -4515,25 +2298,6 @@ with? io.open "test.txt", "w"
  \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;与其使用一系列嵌套的函数调用，你还可以考虑使用运算符 **|>** 来传递值。
@@ -4552,24 +2316,6 @@ readFile "example.txt"
  |> 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 的值，**??** 运算符将不再计算其右操作数。
@@ -4582,17 +2328,6 @@ func a ?? {}
 a ??= false
 ```
-<YueDisplay>
-```yue
-local a, b, c, d
-a = b ?? c ?? d
-func a ?? {}
-a ??= false
-```
-</YueDisplay>
 ## 隐式对象
 &emsp;&emsp;你可以在表格块内使用符号 **\*** 或是 **-** 开始编写一系列隐式结构。如果你正在创建隐式对象，对象的字段必须具有相同的缩进。
@@ -4639,52 +2374,6 @@ tb =
      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**。
@@ -4700,19 +2389,6 @@ some_string = "这是一个字符串
 print "我有#{math.random! * 100}%的把握。"
 ```
-<YueDisplay>
-```yue
-some_string = "这是一个字符串
-  并包括一个换行。"
-- 使用#{}语法可以将表达式插入到字符串字面量中。
-- 字符串插值只在双引号字符串中可用。
-print "我有#{math.random! * 100}%的把握。"
-```
-</YueDisplay>
 ## 数字字面量
 &emsp;&emsp;你可以在数字字面量中使用下划线来增加可读性。
@@ -4723,16 +2399,6 @@ hex = 0xEF_BB_BF
 binary = 0B10011
 ```
-<YueDisplay>
-```yue
-integer = 1_000_000
-hex = 0xEF_BB_BF
-binary = 0B10011
-```
-</YueDisplay>
 ## YAML 风格字符串
 &emsp;&emsp;使用 `|` 前缀标记一个多行 YAML 风格字符串：
@@ -4745,18 +2411,6 @@ str = |
    - #{expr}
 ```
-<YueDisplay>
-```yue
-str = |
-  key: value
-  list:
-    - item1
-    - #{expr}
-```
-</YueDisplay>
 &emsp;&emsp;其效果类似于原生 Lua 的多行拼接，所有文本（含换行）将被保留下来，并支持 `#{...}` 语法，通过 `tostring(expr)` 插入表达式结果。
 &emsp;&emsp;YAML 风格的多行字符串会自动检测首行后最小的公共缩进，并从所有行中删除该前缀空白字符。这让你可以在代码中对齐文本，但输出字符串不会带多余缩进。
@@ -4769,18 +2423,6 @@ fn = ->
  return str
 ```
-<YueDisplay>
-```yue
-fn = ->
-  str = |
-    foo:
-      bar: baz
-  return str
-```
-</YueDisplay>
 &emsp;&emsp;输出字符串中的 foo: 对齐到行首，不会带有函数缩进空格。保留内部缩进的相对结构，适合书写结构化嵌套样式的内容。
 &emsp;&emsp;支持自动处理字符中的引号、反斜杠等特殊符号，无需手动转义：
@@ -4791,16 +2433,6 @@ str = |
  note: 'He said: "#{Hello}!"'
 ```
-<YueDisplay>
-```yue
-str = |
-  path: "C:\Program Files\App"
-  note: 'He said: "#{Hello}!"'
-```
-</YueDisplay>
 # 模块
 ## 导入
@@ -4832,35 +2464,6 @@ do
  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` 将指定的全局变量导入到本地变量中。当导入一系列对全局变量的链式访问时，最后一个访问的字段将被赋值给本地变量。
@@ -4872,17 +2475,6 @@ do
  print concat ["a", tostring 1]
 ```
-<YueDisplay>
-```yue
-do
-  import tostring
-  import table.concat
-  print concat ["a", tostring 1]
-```
-</YueDisplay>
 ### 自动全局变量导入
 &emsp;&emsp;在一个代码块的顶部写 `import global`，会将当前作用域中尚未显式声明或赋值过的变量名，自动导入为本地常量，并在该语句的位置绑定到同名的全局变量。
@@ -4904,25 +2496,6 @@ do
  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;导出语句提供了一种简洁的方式来定义当前的模块。
@@ -4947,26 +2520,6 @@ 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
@@ -4974,15 +2527,6 @@ 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
@@ -4991,16 +2535,6 @@ export.<index> = items
 export["a-b-c"] = 123
 ```
-<YueDisplay>
-```yue
-export.itemA = tb
-export.<index> = items
-export["a-b-c"] = 123
-```
-</YueDisplay>
 ### 未命名导出
 &emsp;&emsp;未命名导出会将要导出的目标项目添加到导出表的数组部分。
@@ -5018,23 +2552,6 @@ 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** 关键字，来替换导出的表为一个目标的对象。
@@ -5045,16 +2562,6 @@ export default ->
  123
 ```
-<YueDisplay>
-```yue
-export default ->
-  print "你好"
-  123
-```
-</YueDisplay>
 # MIT 许可证
 版权 (c) 2017-2026 李瑾 \<dragon-fly@qq.com\>
diff --git a/spec/inputs/compile_doc.yue b/spec/inputs/compile_doc.yue
index 161c077..c26fced 100644
--- a/spec/inputs/compile_doc.yue
+++ b/spec/inputs/compile_doc.yue
@@ -61,5 +61,9 @@ for [compiledFile, docFile, docFiles] in *docs
        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"
+                \write (table
+                        .concat docTexts, "\n"
+                        \gsub "<img .-/>\n\n", ""
+                        \gsub "%-%-%-.-%-%-%-\n\n", ""
+                        \gsub "<YueDisplay>.-</YueDisplay>\n\n", "")
diff --git a/spec/outputs/compile_doc.lua b/spec/outputs/compile_doc.lua
index ad1b065..e8fd719 100644
--- a/spec/outputs/compile_doc.lua
+++ b/spec/outputs/compile_doc.lua
@@ -120,7 +120,7 @@ for _index_0 = 1, #docs do
        local _close_0 <close> = output
        local output2
        local _with_0 = io.open(tostring(docFolder) .. "/" .. tostring(docFile), "w+")
-        _with_0:write(table.concat(docTexts, "\n"))
+        _with_0:write((table.concat(docTexts, "\n"):gsub("<img .-/>\n\n", ""):gsub("%-%-%-.-%-%-%-\n\n", ""):gsub("<YueDisplay>.-</YueDisplay>\n\n", "")))
        output2 = _with_0
        local _close_1 <close> = output2
 end