60 files changed, 6732 insertions, 731 deletions
diff --git a/doc/docs/doc/README.md b/doc/docs/doc/README.md
index c4518bf..f0d67a5 100755
--- a/doc/docs/doc/README.md
+++ b/doc/docs/doc/README.md
@@ -16,19 +16,29 @@ Yue (月) is the name of moon in Chinese and it's pronounced as [jyɛ].
 ### An Overview of YueScript
 ```moonscript
 -- import syntax
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 -- object literals
 inventory =
  equipment:
-    * "sword"
+    - "sword"
-    * "shield"
+    - "shield"
  items:
-    * name: "potion"
+    - name: "potion"
      count: 10
-    * name: "bread"
+    - 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
@@ -51,19 +61,29 @@ export 🌛 = "月之脚本"
 <YueDisplay>
 <pre>
 -- import syntax
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 -- object literals
 inventory =
  equipment:
-    * "sword"
+    - "sword"
-    * "shield"
+    - "shield"
  items:
-    * name: "potion"
+    - name: "potion"
      count: 10
-    * name: "bread"
+    - 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
@@ -132,14 +152,14 @@ export 🌛 = "月之脚本"
 &emsp;Use YueScript module in Lua:
-* **Case 1**  
+* **Case 1**
 Require "your_yuescript_entry.yue" in Lua.
 ```Lua
 require("yue")("your_yuescript_entry")
 ```
 &emsp;And this code still works when you compile "your_yuescript_entry.yue"  to "your_yuescript_entry.lua" in the same path. In the rest YueScript files just use the normal **require** or **import**. The code line numbers in error messages will also be handled correctly.
-* **Case 2**  
+* **Case 2**
 Require YueScript module and rewite message by hand.
 ```lua
 local yue = require("yue")
@@ -151,7 +171,7 @@ end, function(err)
 end)
 ```
-* **Case 3**  
+* **Case 3**
 Use the YueScript compiler function in Lua.
 ```lua
 local yue = require("yue")
@@ -203,12 +223,12 @@ Usage: yue [options|files|directories] ...
   Execute without options to enter REPL, type symbol '$'
   in a single line to start/stop multi-line mode
 ```
-&emsp;&emsp;Use cases:  
+&emsp;&emsp;Use cases:
-&emsp;&emsp;Recursively compile every YueScript file with extension **.yue** under current path:  **yue .**  
+&emsp;&emsp;Recursively compile every YueScript file with extension **.yue** under current path:  **yue .**
-&emsp;&emsp;Compile and save results to a target path:  **yue -t /target/path/ .**  
+&emsp;&emsp;Compile and save results to a target path:  **yue -t /target/path/ .**
-&emsp;&emsp;Compile and reserve debug info:  **yue -l .**  
+&emsp;&emsp;Compile and reserve debug info:  **yue -l .**
-&emsp;&emsp;Compile and generate minified codes:  **yue -m .**  
+&emsp;&emsp;Compile and generate minified codes:  **yue -m .**
-&emsp;&emsp;Execute raw codes:  **yue -e 'print 123'**  
+&emsp;&emsp;Execute raw codes:  **yue -e 'print 123'**
 &emsp;&emsp;Execute a YueScript file:  **yue -e main.yue**
 ## Macro
@@ -424,6 +444,54 @@ print "Valid enum type:", $BodyType Static
 </pre>
 </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.
+```moonscript
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+$printNumAndStr 123, "hello"
+```
+<YueDisplay>
+<pre>
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+$printNumAndStr 123, "hello"
+</pre>
+</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.
+```moonscript
+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>
+<pre>
+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"
+</pre>
+</YueDisplay>
+For more details about available AST nodes, please refer to the uppercased definitions in [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp).
 ## Operator
 All of Lua's binary and unary operators are available. Additionally **!=** is as an alias for **~=**, and either **\\** or **::** can be used to write a chaining function call like `tb\func!` or `tb::func!`. And Yuescipt offers some other special operators to write more expressive codes.
@@ -566,11 +634,26 @@ merge = {...a, ...b}
 </pre>
 </YueDisplay>
+### Table Reversed Indexing
+You can use the **#** operator to get the last elements of a table.
+```moonscript
+last = data.items[#]
+second_last = data.items[#-1]
+```
+<YueDisplay>
+<pre>
+last = data.items[#]
+second_last = data.items[#-1]
+</pre>
+</YueDisplay>
 ### Metatable
 The **<>** operator can be used as a shortcut for metatable manipulation.
-* **Metatable Creation**  
+* **Metatable Creation**
 Create normal table with empty bracekets **<>** or metamethod key which is surrounded by **<>**.
 ```moonscript
@@ -606,7 +689,7 @@ close _ = &lt;close&gt;: -> print "out of scope"
 </pre>
 </YueDisplay>
-* **Metatable Accessing**  
+* **Metatable Accessing**
 Accessing metatable with **<>** or metamethod name surrounded by **<>** or writing some expression in **<>**.
 ```moonscript
@@ -630,7 +713,7 @@ print tb.item
 </pre>
 </YueDisplay>
-* **Metatable Destructure**  
+* **Metatable Destructure**
 Destruct metatable with metamethod key surrounded by **<>**.
 ```moonscript
@@ -732,34 +815,45 @@ a ??= false
 ### Implicit Object
-You can write a list of implicit structures that starts with the symbol **\*** inside a table block. If you are creating implicit object, the fields of the object must be with the same indent.
+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.
 ```moonscript
+-- 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"
+    - "a"
-    * "b"
+    - "b"
-    * "c"
+    - "c"
  objects:
-    * name: "a"
+    - name: "a"
      value: 1
      func: => @value + 1
      tb:
        fieldA: 1
-    * name: "b"
+    - name: "b"
      value: 2
      func: => @value + 2
      tb: { }
@@ -767,32 +861,42 @@ tb =
 ```
 <YueDisplay>
 <pre>
+-- 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"
+    - "a"
-    * "b"
+    - "b"
-    * "c"
+    - "c"
  objects:
-    * name: "a"
+    - name: "a"
      value: 1
      func: => @value + 1
      tb:
        fieldA: 1
-    * name: "b"
+    - name: "b"
      value: 2
      func: => @value + 2
      tb: { }
@@ -860,7 +964,7 @@ do
 The export statement offers a concise way to define modules.
-* **Named Export**  
+* **Named Export**
 Named export will define a local variable as well as adding a field in the exported table.
 ```moonscript
@@ -924,7 +1028,7 @@ export["a-b-c"] = 123
 </pre>
 </YueDisplay>
-* **Unnamed Export**  
+* **Unnamed Export**
 Unnamed export will add the target item into the array part of the exported table.
 ```moonscript
@@ -954,7 +1058,7 @@ export with tmp
 </pre>
 </YueDisplay>
-* **Default Export**  
+* **Default Export**
 Using the **default** keyword in export statement to replace the exported table with any thing.
 ```moonscript
@@ -1202,7 +1306,7 @@ If the destructuring statement is complicated, feel free to spread it out over a
 </pre>
 </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:
+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:
 ```moonscript
 {:concat, :insert} = table
@@ -1246,6 +1350,52 @@ You can use `_` as placeholder when doing a list destructuring:
 </pre>
 </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.
+```moonscript
+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>
+<pre>
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- prints: first
+print bulk   -- prints: {"second", "third", "fourth"}
+print last   -- prints: last
+</pre>
+</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:
+```moonscript
+-- 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>
+<pre>
+-- 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
+</pre>
+</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:
@@ -1475,6 +1625,47 @@ catch err
 </pre>
 </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.
+```moonscript
+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>
+<pre>
+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
+</pre>
+</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.
@@ -1503,6 +1694,19 @@ const {:a, :b, c, d} = tb
 </pre>
 </YueDisplay>
+You can also declare a global variable to be `const`.
+```moonscript
+global const Constant = 123
+-- Constant = 1
+```
+<YueDisplay>
+<pre>
+global const Constant = 123
+-- Constant = 1
+</pre>
+</YueDisplay>
 ## Literals
 All of the primitive literals in Lua can be used. This applies to numbers, strings, booleans, and **nil**.
@@ -1535,12 +1739,73 @@ You can use underscores in a number literal to increase readability.
 ```moonscript
 integer = 1_000_000
 hex = 0xEF_BB_BF
+binary = 0B10011
 ```
 <YueDisplay>
 <pre>
 integer = 1_000_000
 hex = 0xEF_BB_BF
+binary = 0B10011
+</pre>
+</YueDisplay>
+### YAML Multiline String
+The `|` prefix introduces a YAML-style multiline string literal:
+```moonscript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+<YueDisplay>
+<pre>
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+</pre>
+</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.
+```moonscript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+<YueDisplay>
+<pre>
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+</pre>
+</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.
+```moonscript
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+<YueDisplay>
+<pre>
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
 </pre>
 </YueDisplay>
@@ -1902,22 +2167,22 @@ x * 2
 </pre>
 </YueDisplay>
-If you wish to have further code after your backcalls, you can set them aside with a do statement.
+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.
 ```moonscript
 result, msg = do
-  (data) <- readAsync "filename.txt"
+  data <- readAsync "filename.txt"
  print data
-  (info) <- processAsync data
+  info <- processAsync data
  check info
 print result, msg
 ```
 <YueDisplay>
 <pre>
 result, msg = do
-  (data) <- readAsync "filename.txt"
+  data <- readAsync "filename.txt"
  print data
-  (info) <- processAsync data
+  info <- processAsync data
  check info
 print result, msg
 </pre>
@@ -2248,6 +2513,45 @@ slice = [item for item in *items[,,2]]
 </pre>
 </YueDisplay>
+Both the minimum and maximum bounds can be negative, which means that the bounds are counted from the end of the table.
+```moonscript
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+```
+<YueDisplay>
+<pre>
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+</pre>
+</YueDisplay>
+The step size can also be negative, which means that the items are taken in reverse order.
+```moonscript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+<YueDisplay>
+<pre>
+reverse_slice = [item for item in *items[-1,1,-1]]
+</pre>
+</YueDisplay>
+#### Slicing Expression
+Slicing can also be used as an expression. This is useful for getting a sub-list of a table.
+```moonscript
+-- take the 2nd and 4th items as a new list
+sub_list = items[2, 4]
+```
+<YueDisplay>
+<pre>
+-- take the 2nd and 4th items as a new list
+sub_list = items[2, 4]
+</pre>
+</YueDisplay>
 ## For Loop
 There are two for loop forms, just like in Lua. A numeric one and a generic one:
@@ -2324,6 +2628,23 @@ doubled_evens = for i = 1, 20
 </pre>
 </YueDisplay>
+In addition, for loops support break with a return value, allowing the loop itself to be used as an expression that exits early with a meaningful result.
+For example, to find the first number greater than 10:
+```moonscript
+first_large = for n in *numbers
+  break n if n > 10
+```
+<YueDisplay>
+<pre>
+first_large = for n in *numbers
+  break n if n > 10
+</pre>
+</YueDisplay>
+This break-with-value syntax enables concise and expressive search or early-exit patterns directly within loop expressions.
 You can also filter values by combining the for loop expression with the continue statement.
 For loops at the end of a function body are not accumulated into a table for a return value (Instead the function will return nil). Either an explicit return statement can be used, or the loop can be converted into a list comprehension.
@@ -2345,7 +2666,7 @@ print func_b! -- prints table object
 </pre>
 </YueDisplay>
-This is done to avoid the needless creation of tables for functions that don’t need to return the results of the loop.
+This is done to avoid the needless creation of tables for functions that don't need to return the results of the loop.
 ## Repeat Loop
@@ -2624,28 +2945,26 @@ reader\parse_line! until reader\eof!
 ## 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.
+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.
 ```moonscript
-name = "Dan"
+switch name := "Dan"
-switch name
  when "Robert"
    print "You are Robert"
  when "Dan", "Daniel"
    print "Your name, it's Dan"
  else
-    print "I don't know about your name"
+    print "I don't know about you with name #{name}"
 ```
 <YueDisplay>
 <pre>
-name = "Dan"
+switch name := "Dan"
-switch name
  when "Robert"
    print "You are Robert"
  when "Dan", "Daniel"
    print "Your name, it's Dan"
  else
-    print "I don't know about your name"
+    print "I don't know about you with name #{name}"
 </pre>
 </YueDisplay>
@@ -2676,7 +2995,7 @@ next_number = switch b
 </pre>
 </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.
+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.
 ```moonscript
 msg = switch math.random(1, 5)
@@ -2722,7 +3041,7 @@ else
 </pre>
 </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.
+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
@@ -2782,6 +3101,123 @@ switch item
 </pre>
 </YueDisplay>
+You can also match against array elements, table fields, and even nested structures with array or table literals.
+Match against array elements.
+```moonscript
+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>
+<pre>
+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}"
+</pre>
+</YueDisplay>
+Match against table fields with destructuring.
+```moonscript
+switch tb
+  when success: true, :result
+    print "success", result
+  when success: false
+    print "failed", result
+  else
+    print "invalid"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when success: true, :result
+    print "success", result
+  when success: false
+    print "failed", result
+  else
+    print "invalid"
+</pre>
+</YueDisplay>
+Match against nested table structures.
+```moonscript
+switch tb
+  when data: {type: "success", :content}
+    print "success", content
+  when data: {type: "error", :content}
+    print "failed", content
+  else
+    print "invalid"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when data: {type: "success", :content}
+    print "success", content
+  when data: {type: "error", :content}
+    print "failed", content
+  else
+    print "invalid"
+</pre>
+</YueDisplay>
+Match against array of tables.
+```moonscript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "matched", fourth
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "matched", fourth
+</pre>
+</YueDisplay>
+Match against a list and capture a range of elements.
+```moonscript
+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>
+<pre>
+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"
+</pre>
+</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.
@@ -2913,7 +3349,7 @@ class BackPack extends Inventory
 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.
+In this example, we don't define a constructor on the subclass, so the parent class' constructor is called when we make a new instance. If we did define a constructor then we can use the super method to call the parent constructor.
 Whenever a class inherits from another, it sends a message to the parent class by calling the method __inherited on the parent class if it exists. The function receives two arguments, the class that is being inherited and the child class.
@@ -3000,13 +3436,13 @@ print BackPack.size -- prints 10
 The class object is what we create when we use a class statement. The class object is stored in a variable of the same name of the class.
-The class object can be called like a function in order to create new instances. That’s how we created instances of classes in the examples above.
+The class object can be called like a function in order to create new instances. That's how we created instances of classes in the examples above.
 A class is made up of two tables. The class table itself, and the base table. The base is used as the metatable for all the instances. All properties listed in the class declaration are placed in the base.
-The class object’s metatable reads properties from the base if they don’t exist in the class object. This means we can access functions and properties directly from the class.
+The class object's metatable reads properties from the base if they don't exist in the class object. This means we can access functions and properties directly from the class.
-It is important to note that assigning to the class object does not assign into the base, so it’s not a valid way to add new methods to instances. Instead the base must explicitly be changed. See the __base field below.
+It is important to note that assigning to the class object does not assign into the base, so it's not a valid way to add new methods to instances. Instead the base must explicitly be changed. See the __base field below.
 The class object has a couple special properties:
@@ -3079,7 +3515,7 @@ print Counter.count -- prints 2
 </pre>
 </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.
+The calling semantics of @@ are similar to @. Calling a @@ name will pass the class in as the first argument using Lua's colon syntax.
 ```moonscript
 @@hello 1,2,3,4
@@ -3094,7 +3530,7 @@ The calling semantics of @@ are similar to @. Calling a @@ name will pass the cl
 In the body of a class declaration, we can have normal expressions in addition to key/value pairs. In this context, self is equal to the class object.
-Here is an alternative way to create a class variable compared to what’s described above:
+Here is an alternative way to create a class variable compared to what's described above:
 ```moonscript
 class Things
@@ -3360,19 +3796,19 @@ 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.
 ```moonscript
-with str = "Hello"
+with str := "Hello"
  print "original:", str
  print "upper:", \upper!
 ```
 <YueDisplay>
 <pre>
-with str = "Hello"
+with str := "Hello"
  print "original:", str
  print "upper:", \upper!
 </pre>
 </YueDisplay>
-Accessing special keys with `[]` in a `with` statement.
+You can access special keys with `[]` in a `with` statement.
 ```moonscript
 with tb
@@ -3395,6 +3831,18 @@ with tb
 </pre>
 </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.
+```moonscript
+with? obj
+  print obj.name
+```
+<YueDisplay>
+<pre>
+with? obj
+  print obj.name
+</pre>
+</YueDisplay>
 ## Do
@@ -3415,7 +3863,7 @@ print var -- nil here
 </pre>
 </YueDisplay>
-YueScript’s **do** can also be used an expression . Allowing you to combine multiple lines into one. The result of the do expression is the last statement in its body.
+YueScript'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.
 ```moonscript
 counter = do
@@ -3541,7 +3989,7 @@ print i -- will print 0
 </pre>
 </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.
+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.
diff --git a/doc/docs/zh/doc/README.md b/doc/docs/zh/doc/README.md
index 754566c..15f4768 100755
--- a/doc/docs/zh/doc/README.md
+++ b/doc/docs/zh/doc/README.md
@@ -16,19 +16,29 @@ Yue（月）是中文中“月亮”的名称。
 ### 月之脚本概览
 ```moonscript
 -- 导入语法
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 -- 隐式对象
 inventory =
  equipment:
-    * "sword"
+    - "sword"
-    * "shield"
+    - "shield"
  items:
-    * name: "potion"
+    - name: "potion"
      count: 10
-    * name: "bread"
+    - 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
@@ -51,19 +61,29 @@ export 🌛 = "月之脚本"
 <YueDisplay>
 <pre>
 -- 导入语法
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 -- 隐式对象
 inventory =
  equipment:
-    * "sword"
+    - "sword"
-    * "shield"
+    - "shield"
  items:
-    * name: "potion"
+    - name: "potion"
      count: 10
-    * name: "bread"
+    - 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
@@ -122,7 +142,7 @@ export 🌛 = "月之脚本"
 * **下载预编译的二进制程序**
-&emsp;您可以下载预编译的二进制程序，包括兼容不同 Lua 版本的二进制可执行文件和库文件。
+&emsp;你可以下载预编译的二进制程序，包括兼容不同 Lua 版本的二进制可执行文件和库文件。
 &emsp;在[这里](https://github.com/IppClub/YueScript/releases)下载预编译的二进制程序。
@@ -132,14 +152,14 @@ export 🌛 = "月之脚本"
 在Lua中使用月之脚本模块：
-* **用法 1**  
+* **用法 1**
 在Lua中引入 "你的脚本入口文件.yue"。
 ```Lua
 require("yue")("你的脚本入口文件")
 ```
 当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import**进行脚本引用即可。错误消息中的代码行号也会被正确处理。
-* **用法 2**  
+* **用法 2**
 手动引入月之脚本模块并重写错误消息来帮助调试。
 ```lua
 local yue = require("yue")
@@ -151,7 +171,7 @@ end, function(err)
 end)
 ```
-* **用法 3**  
+* **用法 3**
 在Lua中使用月之脚本编译器功能。
 ```lua
 local yue = require("yue")
@@ -202,12 +222,12 @@ f!
   不添加任何选项执行命令可以进入REPL模式，
   在单行输入符号 '$' 并换行后，可以开始或是停止多行输入模式
 ```
-&emsp;&emsp;使用案例：  
+&emsp;&emsp;使用案例：
-&emsp;&emsp;递归编译当前路径下扩展名为 **.yue** 的每个月之脚本文件： **yue .**  
+&emsp;&emsp;递归编译当前路径下扩展名为 **.yue** 的每个月之脚本文件： **yue .**
-&emsp;&emsp;编译并将结果保存到目标路径： **yue -t /target/path/ .**  
+&emsp;&emsp;编译并将结果保存到目标路径： **yue -t /target/path/ .**
-&emsp;&emsp;编译并保留调试信息： **yue -l .**  
+&emsp;&emsp;编译并保留调试信息： **yue -l .**
-&emsp;&emsp;编译并生成压缩代码： **yue -m .**  
+&emsp;&emsp;编译并生成压缩代码： **yue -m .**
-&emsp;&emsp;直接执行代码： **yue -e 'print 123'**  
+&emsp;&emsp;直接执行代码： **yue -e 'print 123'**
 &emsp;&emsp;执行一个月之脚本文件： **yue -e main.yue**
 ## 宏
@@ -333,7 +353,7 @@ end
 ### 导出宏
-宏函数可以从一个模块中导出，并在另一个模块中导入。您必须将导出的宏函数放在一个单独的文件中使用，而且只有宏定义、宏导入和宏展开可以放入这个宏导出模块中。
+宏函数可以从一个模块中导出，并在另一个模块中导入。你必须将导出的宏函数放在一个单独的文件中使用，而且只有宏定义、宏导入和宏展开可以放入这个宏导出模块中。
 ```moonscript
 -- 文件: utils.yue
 export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
@@ -422,6 +442,54 @@ print "有效的枚举类型:", $BodyType Static
 </pre>
 </YueDisplay>
+### 宏参数检查
+可以直接在参数列表中声明期望的 AST 节点类型，并在编译时检查传入的宏参数是否符合预期。
+```moonscript
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+$printNumAndStr 123, "hello"
+```
+<YueDisplay>
+<pre>
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+$printNumAndStr 123, "hello"
+</pre>
+</YueDisplay>
+如果需要做更加灵活的参数检查操作，可以使用内置的 `$is_ast` 宏函数在合适的位置进行手动检查。
+```moonscript
+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>
+<pre>
+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"
+</pre>
+</YueDisplay>
+更多关于可用 AST 节点的详细信息，请参考 [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp) 中大写的规则定义。
 ## 操作符
 Lua的所有二元和一元操作符在月之脚本中都是可用的。此外，**!=** 符号是 **~=** 的别名，而 **\\** 或 **::** 均可用于编写链式函数调用，如写作 `tb\func!` 或 `tb::func!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
@@ -439,7 +507,7 @@ tb::func! if tb != nil
 ### 链式比较
-您可以在月之脚本中进行比较表达式的链式书写：
+你可以在月之脚本中进行比较表达式的链式书写：
 ```moonscript
 print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
@@ -528,7 +596,7 @@ tab[] = "Value"
 ### 表扩展
-您可以使用前置 `...` 操作符在Lua表中插入数组表或哈希表。
+你可以使用前置 `...` 操作符在Lua表中插入数组表或哈希表。
 ```moonscript
 parts =
@@ -565,11 +633,26 @@ merge = {...a, ...b}
 </pre>
 </YueDisplay>
+### 表反向索引
+你可以使用 **#** 操作符来反向索引表中的元素。
+```moonscript
+last = data.items[#]
+second_last = data.items[#-1]
+```
+<YueDisplay>
+<pre>
+last = data.items[#]
+second_last = data.items[#-1]
+</pre>
+</YueDisplay>
 ### 元表
 **<>** 操作符可提供元表操作的快捷方式。
-* **元表创建**  
+* **元表创建**
 使用空括号 **<>** 或被 **<>** 包围的元方法键创建普通的Lua表。
 ```moonscript
@@ -605,7 +688,7 @@ close _ = &lt;close&gt;: -> print "超出范围"
 </pre>
 </YueDisplay>
-* **元表访问**  
+* **元表访问**
 使用 **<>** 或被 **<>** 包围的元方法名或在 **<>** 中编写某些表达式来访问元表。
 ```moonscript
@@ -629,7 +712,7 @@ print tb.item
 </pre>
 </YueDisplay>
-* **元表解构**  
+* **元表解构**
 使用被 **<>** 包围的元方法键解构元表。
 ```moonscript
@@ -680,7 +763,7 @@ with? io.open "test.txt", "w"
 ### 管道
-与其使用一系列嵌套的函数调用，您还可以考虑使用运算符 **|>** 来传递值。
+与其使用一系列嵌套的函数调用，你还可以考虑使用运算符 **|>** 来传递值。
 ```moonscript
 "你好" |> print
@@ -731,67 +814,87 @@ a ??= false
 ### 隐式对象
-您可以在表格块内使用符号 **\*** 开始编写一系列隐式结构。如果您正在创建隐式对象，对象的字段必须具有相同的缩进。
+你可以在表格块内使用符号 **\*** 或是 **-** 开始编写一系列隐式结构。如果你正在创建隐式对象，对象的字段必须具有相同的缩进。
 ```moonscript
+-- 赋值时使用隐式对象
 list =
  * 1
  * 2
  * 3
+-- 函数调用时使用隐式对象
 func
  * 1
  * 2
  * 3
+-- 返回时使用隐式对象
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+-- 表格时使用隐式对象
 tb =
  name: "abc"
  values:
-    * "a"
+    - "a"
-    * "b"
+    - "b"
-    * "c"
+    - "c"
  objects:
-    * name: "a"
+    - name: "a"
      value: 1
      func: => @value + 1
      tb:
        fieldA: 1
-    * name: "b"
+    - name: "b"
      value: 2
      func: => @value + 2
      tb: { }
 ```
 <YueDisplay>
 <pre>
+-- 赋值时使用隐式对象
 list =
  * 1
  * 2
  * 3
+-- 函数调用时使用隐式对象
 func
  * 1
  * 2
  * 3
+-- 返回时使用隐式对象
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+-- 表格时使用隐式对象
 tb =
  name: "abc"
  values:
-    * "a"
+    - "a"
-    * "b"
+    - "b"
-    * "c"
+    - "c"
  objects:
-    * name: "a"
+    - name: "a"
      value: 1
      func: => @value + 1
      tb:
        fieldA: 1
-    * name: "b"
+    - name: "b"
      value: 2
      func: => @value + 2
      tb: { }
@@ -859,7 +962,7 @@ do
 导出语句提供了一种简洁的方式来定义当前的模块。
-* **命名导出**  
+* **命名导出**
 带命名的导出将定义一个局部变量，并在导出的表中添加一个同名的字段。
 ```moonscript
@@ -923,7 +1026,7 @@ export["a-b-c"] = 123
 </pre>
 </YueDisplay>
-* **未命名导出**  
+* **未命名导出**
 未命名导出会将要导出的目标项目添加到导出表的数组部分。
 ```moonscript
@@ -953,7 +1056,7 @@ export with tmp
 </pre>
 </YueDisplay>
-* **默认导出**  
+* **默认导出**
 在导出语句中使用 **default** 关键字，来替换导出的表为一个目标的对象。
 ```moonscript
@@ -1223,7 +1326,7 @@ print first, second, color
 </pre>
 </YueDisplay>
-在进行解构时，您可以指定默认值，如：
+在进行解构时，你可以指定默认值，如：
 ```moonscript
 {:name = "nameless", :job = "jobless"} = person
@@ -1234,7 +1337,7 @@ print first, second, color
 </pre>
 </YueDisplay>
-在进行列表解构时，您可以使用`_`作为占位符：
+在进行列表解构时，你可以使用`_`作为占位符：
 ```moonscript
 [_, two, _, four] = items
@@ -1245,9 +1348,55 @@ print first, second, color
 </pre>
 </YueDisplay>
-### 在其它地方的解构
+### 范围解构
+你可以使用展开运算符 `...` 在列表解构中来捕获一个范围的值到子列表中。这在当你想要从列表的开头和结尾提取特定元素，同时收集中间的元素时非常有用。
+```moonscript
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- 打印: first
+print bulk   -- 打印: {"second", "third", "fourth"}
+print last   -- 打印: last
+```
+<YueDisplay>
+<pre>
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- 打印: first
+print bulk   -- 打印: {"second", "third", "fourth"}
+print last   -- 打印: last
+</pre>
+</YueDisplay>
+展开运算符可以用在不同的位置来捕获不同的范围，并且你可以使用 `_` 作为占位符来表示你想跳过对应范围的捕获：
+```moonscript
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+```
+<YueDisplay>
+<pre>
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+</pre>
+</YueDisplay>
+### 在其它地方的解构赋值
-解构也可以出现在其它隐式进行赋值的地方。一个例子是用在for循环：
+解构赋值也可以出现在其它隐式进行赋值的地方。一个例子是用在for循环中：
 ```moonscript
 tuples = [
@@ -1322,7 +1471,7 @@ print "好的"
 ### While 赋值
-您可以在 while 循环中同样使用赋值来获取循环条件的值。
+你可以在 while 循环中同样使用赋值来获取循环条件的值。
 ```moonscript
 while byte := stream\read_one!
  -- 对 byte 做一些操作
@@ -1338,7 +1487,7 @@ while byte := stream\read_one!
 ## 可变参数赋值
-您可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用Lua的方式访问其内容。
+你可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用Lua的方式访问其内容。
 ```moonscript
 list = [1, 2, 3, 4, 5]
 fn = (ok) -> ok, table.unpack list
@@ -1360,7 +1509,7 @@ print ok, count, first
 ## 空白
-月之脚本是一个对空白敏感的语言。您必须在相同的缩进中使用空格 **' '** 或制表符 **'\t'** 来编写一些代码块，如函数体、值列表和一些控制块。包含不同空白的表达式可能意味着不同的事情。制表符被视为4个空格，但最好不要混合使用空格和制表符。
+月之脚本是一个对空白敏感的语言。你必须在相同的缩进中使用空格 **' '** 或制表符 **'\t'** 来编写一些代码块，如函数体、值列表和一些控制块。包含不同空白的表达式可能意味着不同的事情。制表符被视为4个空格，但最好不要混合使用空格和制表符。
 ### 多行链式调用
@@ -1474,6 +1623,47 @@ catch err
 </pre>
 </YueDisplay>
+### 错误处理简化
+`try?` 是 `try` 的功能简化语法，它不再返回 `try` 语句的布尔状态，并在成功时直接返回 `try` 代码块的结果，失败时返回 `nil` 值而非错误对象。
+```moonscript
+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>
+<pre>
+a, b, c = try? func!
+-- 与空值合并运算符一起使用
+a = (try? func!) ?? "default"
+-- 作为函数参数
+f try? func!
+-- 带 catch 块的 try!
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+</pre>
+</YueDisplay>
 ## 属性
 月之脚本现在提供了Lua 5.4新增的叫做属性的语法支持。在月之脚本编译到的Lua目标版本低于5.4时，你仍然可以同时使用`const`和`close`的属性声明语法，并获得常量检查和作用域回调的功能。
@@ -1502,6 +1692,19 @@ const {:a, :b, c, d} = tb
 </pre>
 </YueDisplay>
+你也可以声明全局变量为常量。
+```moonscript
+global const Constant = 123
+-- Constant = 1
+```
+<YueDisplay>
+<pre>
+global const Constant = 123
+-- Constant = 1
+</pre>
+</YueDisplay>
 ## 字面量
 Lua中的所有基本字面量都可以在月之脚本中使用。包括数字、字符串、布尔值和**nil**。
@@ -1529,17 +1732,78 @@ print "我有#{math.random! * 100}%的把握。"
 ### 数字字面量
-您可以在数字字面量中使用下划线来增加可读性。
+你可以在数字字面量中使用下划线来增加可读性。
 ```moonscript
 integer = 1_000_000
 hex = 0xEF_BB_BF
+binary = 0B10011
 ```
 <YueDisplay>
 <pre>
 integer = 1_000_000
 hex = 0xEF_BB_BF
+binary = 0B10011
+</pre>
+</YueDisplay>
+### YAML 风格字符串
+使用 `|` 前缀标记一个多行 YAML 风格字符串：
+```moonscript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+<YueDisplay>
+<pre>
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+</pre>
+</YueDisplay>
+其效果类似于原生 Lua 的多行拼接，所有文本（含换行）将被保留下来，并支持 `#{...}` 语法，通过 `tostring(expr)` 插入表达式结果。
+YAML 风格的多行字符串会自动检测首行后最小的公共缩进，并从所有行中删除该前缀空白字符。这让你可以在代码中对齐文本，但输出字符串不会带多余缩进。
+```moonscript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+<YueDisplay>
+<pre>
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+</pre>
+</YueDisplay>
+输出字符串中的 foo: 对齐到行首，不会带有函数缩进空格。保留内部缩进的相对结构，适合书写结构化嵌套样式的内容。
+支持自动处理字符中的引号、反斜杠等特殊符号，无需手动转义：
+```moonscript
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+<YueDisplay>
+<pre>
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
 </pre>
 </YueDisplay>
@@ -1644,7 +1908,7 @@ print "数字的和是", sum 10, 20
 </pre>
 </YueDisplay>
-如果您需要做显式返回，可以使用return关键字：
+如果你需要做显式返回，可以使用return关键字：
 ```moonscript
 sum = (x, y) -> return x + y
@@ -1850,7 +2114,7 @@ print @value
 </pre>
 </YueDisplay>
-您可以通过一个占位符指定回调函数的传参位置。
+你可以通过一个占位符指定回调函数的传参位置。
 ```moonscript
 (x) <- map _, [1, 2, 3]
@@ -1863,22 +2127,22 @@ x * 2
 </pre>
 </YueDisplay>
-如果您希望在反向回调处理后继续编写更多其它的代码，您可以使用do语句将不归属反向回调的代码分开。
+如果你希望在反向回调处理后继续编写更多其它的代码，可以使用 do 语句将不属于反向回调的代码分隔开。对于非粗箭头函数的反向回调，回调返回值的括号也是可以省略的。
 ```moonscript
 result, msg = do
-  (data) <- readAsync "文件名.txt"
+  data <- readAsync "文件名.txt"
  print data
-  (info) <- processAsync data
+  info <- processAsync data
  check info
 print result, msg
 ```
 <YueDisplay>
 <pre>
 result, msg = do
-  (data) <- readAsync "文件名.txt"
+  data <- readAsync "文件名.txt"
  print data
-  (info) <- processAsync data
+  info <- processAsync data
  check info
 print result, msg
 </pre>
@@ -2037,7 +2301,7 @@ list_with_one_element = [ 1, ]
 ## 推导式
-推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生Lua表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许您在每次遍历时设置新表格的键和值。
+推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生Lua表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
 ### 列表推导式
@@ -2210,6 +2474,45 @@ slice = [item for item in *items[,,2]]
 </pre>
 </YueDisplay>
+最小和最大边界都可以是负数，使用负数意味着边界是从表的末尾开始计算的。
+```moonscript
+-- 取最后4个元素
+slice = [item for item in *items[-4,-1]]
+```
+<YueDisplay>
+<pre>
+-- 取最后4个元素
+slice = [item for item in *items[-4,-1]]
+</pre>
+</YueDisplay>
+切片的步长也可以是负数，这意味着元素会以相反的顺序被取出。
+```moonscript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+<YueDisplay>
+<pre>
+reverse_slice = [item for item in *items[-1,1,-1]]
+</pre>
+</YueDisplay>
+#### 切片表达式
+切片也可以作为表达式来使用。可以用于获取一个表包含的子列表。
+```moonscript
+-- 取第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+```
+<YueDisplay>
+<pre>
+-- 取第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+</pre>
+</YueDisplay>
 ## for 循环
 Lua中有两种for循环形式，数字型和通用型：
@@ -2286,9 +2589,24 @@ doubled_evens = for i = 1, 20
 </pre>
 </YueDisplay>
-您还可以结合for循环表达式与continue语句来过滤值。
+此外，for循环还支持带返回值的break语句，这样循环本身就可以作为一个表达式，在满足条件时提前退出并返回有意义的结果。
-注意出现在函数体末尾的for循环，不会被当作是一个表达式，并将循环结果累积到一个列表中作为返回值（相反，函数将返回nil）。如果要函数末尾的循环转换为列表表达式，可以使用返回语句加for循环表达式。
+例如，查找第一个大于10的数字：
+```moonscript
+first_large = for n in *numbers
+  break n if n > 10
+```
+<YueDisplay>
+<pre>
+first_large = for n in *numbers
+  break n if n > 10
+</pre>
+</YueDisplay>
+你还可以结合for循环表达式与continue语句来过滤值。
+注意出现在函数体末尾的for循环，不会被当作是一个表达式并将循环结果累积到一个列表中作为返回值（相反，函数将返回nil）。如果要函数末尾的循环转换为列表表达式，可以显式地使用返回语句加for循环表达式。
 ```moonscript
 func_a = -> for i = 1, 10 do print i
@@ -2513,7 +2831,7 @@ print "你真幸运！" unless math.random! > 0.1
 ### 范围表达式
-您可以使用范围表达式来编写进行范围检查的代码。
+你可以使用范围表达式来编写进行范围检查的代码。
 ```moonscript
 a = 5
@@ -2586,28 +2904,26 @@ reader\parse_line! until reader\eof!
 ## switch 语句
-switch语句是为了简化检查一系列相同值的if语句而提供的简写语法。要注意用于比较检查的目标值只会计算一次。和if语句一样，switch语句在最后可以接一个else代码块来处理没有匹配的情况。在生成的Lua代码中，进行比较是使用==操作符完成的。
+switch语句是为了简化检查一系列相同值的if语句而提供的简写语法。要注意用于比较检查的目标值只会计算一次。和if语句一样，switch语句在最后可以接一个else代码块来处理没有匹配的情况。在生成的Lua代码中，进行比较是使用==操作符完成的。switch语句中也可以使用赋值表达式来储存临时变量值。
 ```moonscript
-name = "Dan"
+switch name := "Dan"
-switch name
  when "Robert"
    print "你是Robert"
  when "Dan", "Daniel"
    print "你的名字是Dan"
  else
-    print "我不知道你的名字"
+    print "我不认识你，你的名字是#{name}"
 ```
 <YueDisplay>
 <pre>
-name = "Dan"
+switch name := "Dan"
-switch name
  when "Robert"
    print "你是Robert"
  when "Dan", "Daniel"
    print "你的名字是Dan"
  else
-    print "我不知道你的名字"
+    print "我不认识你，你的名字是#{name}"
 </pre>
 </YueDisplay>
@@ -2684,7 +3000,7 @@ else
 </pre>
 </YueDisplay>
-值得注意的是，在生成Lua代码时，我们要做检查的目标变量会放在==表达式的右侧。当您希望给when子句的比较对象定义一个\_\_eq元方法来重载判断逻辑时，可能会有用。
+值得注意的是，在生成Lua代码时，我们要做检查的目标变量会放在==表达式的右侧。当你希望给when子句的比较对象定义一个\_\_eq元方法来重载判断逻辑时，可能会有用。
 ### 表格匹配
@@ -2744,9 +3060,126 @@ switch item
 </pre>
 </YueDisplay>
+你也可以匹配数组元素、表格字段，甚至使用数组或表格字面量来匹配嵌套的结构。
+匹配数组元素。
+```moonscript
+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>
+<pre>
+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}"
+</pre>
+</YueDisplay>
+匹配表格字段。
+```moonscript
+switch tb
+  when success: true, :result
+    print "成功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when success: true, :result
+    print "成功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+</pre>
+</YueDisplay>
+匹配嵌套的表格结构。
+```moonscript
+switch tb
+  when data: {type: "success", :content}
+    print "成功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when data: {type: "success", :content}
+    print "成功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+</pre>
+</YueDisplay>
+匹配表格数组。
+```moonscript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹配成功", fourth
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹配成功", fourth
+</pre>
+</YueDisplay>
+匹配一个列表并捕获特定范围内的元素。
+```moonscript
+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>
+<pre>
+segments = ["admin", "users", "logs", "view"]
+switch segments
+        when [...groups, resource, action]
+                print "Group:", groups -- 打印: {"admin", "users"}
+                print "Resource:", resource -- 打印: "logs"
+                print "Action:", action -- 打印: "view"
+</pre>
+</YueDisplay>
 ## 面向对象编程
-在以下的示例中，月之脚本生成的Lua代码可能看起来会很复杂。所以最好主要关注月之脚本代码层面的意义，然后如果您想知道关于面向对象功能的实现细节，再查看Lua代码。
+在以下的示例中，月之脚本生成的Lua代码可能看起来会很复杂。所以最好主要关注月之脚本代码层面的意义，然后如果你想知道关于面向对象功能的实现细节，再查看Lua代码。
 一个简单的类：
@@ -3214,7 +3647,7 @@ x = class
 ### 类混合
-您可以通过使用 `using` 关键字来实现类混合。这意味着您可以从一个普通 Lua 表格或已定义的类对象中，复制函数到您创建的新类中。当您使用普通 Lua 表格进行类混合时，您有机会用自己的实现来重写类的索引方法（例如元方法 `__index`）。然而，当您从一个类对象做混合时，需要注意的是该类对象的元方法将不会被复制到新类。
+你可以通过使用 `using` 关键字来实现类混合。这意味着你可以从一个普通 Lua 表格或已定义的类对象中，复制函数到你创建的新类中。当你使用普通 Lua 表格进行类混合时，你有机会用自己的实现来重写类的索引方法（例如元方法 `__index`）。然而，当你从一个类对象做混合时，需要注意的是该类对象的元方法将不会被复制到新类。
 ```moonscript
 MyIndex = __index: var: 1
@@ -3316,22 +3749,22 @@ me = create_person "Leaf", [dad, mother, sister]
 在此用法中，with可以被视为K组合子（k-combinator）的一种特殊形式。
-如果������给表达式另外起一个名称的话，with语句中的表达式也可以是一个赋值语句。
+如果你想给表达式另外起一个名称的话，with语句中的表达式也可以是一个赋值语句。
 ```moonscript
-with str = "你好"
+with str := "你好"
  print "原始:", str
  print "大写:", \upper!
 ```
 <YueDisplay>
 <pre>
-with str = "你好"
+with str := "你好"
  print "原始:", str
  print "大写:", \upper!
 </pre>
 </YueDisplay>
-在with语句中可������用`[]`访问特殊键。
+你���以��� `with` 语句中使用 `[]` 访问特殊键。
 ```moonscript
 with tb
@@ -3354,6 +3787,19 @@ with tb
 </pre>
 </YueDisplay>
+`with?` 是 `with` 语法的一个增强版本，引入了存在性检查，用于在不显式判空的情况下安全访问可能为 nil 的对象。
+```moonscript
+with? obj
+  print obj.name
+```
+<YueDisplay>
+<pre>
+with? obj
+  print obj.name
+</pre>
+</YueDisplay>
 ## do 语句
 当用作语句时，do语句的作用就像在Lua中差不多。
@@ -3373,7 +3819,7 @@ print var -- 这里是nil
 </pre>
 </YueDisplay>
-月之脚本的 **do** 也可以用作表达式。允许您将多行代码的处理合并为一个表达式，并将do语句代码块的最后一个语句作为表达式返回的结果。
+月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将do语句代码块的最后一个语句作为表达式返回的结果。
 ```moonscript
 counter = do
@@ -4332,8 +4778,8 @@ simplified: boolean
 版权 (c) 2017-2025 李瑾  \<dragon-fly@qq.com\>
-特此免费授予任何获得本软件副本和相关文档文件（下称“软件”）的人不受限制地处置该软件的权利，包括不受限制地使用、复制、修改、合并、发布、分发、转授许可和/或出售该软件副本，以及再授权被配发了本软件的人如上的权利，须在下列条件下：  
+特此免费授予任何获得本软件副本和相关文档文件（下称“软件”）的人不受限制地处置该软件的权利，包括不受限制地使用、复制、修改、合并、发布、分发、转授许可和/或出售该软件副本，以及再授权被配发了本软件的人如上的权利，须在下列条件下：
-上述版权声明和本许可声明应包含在该软件的所有副本或实质成分中。  
+上述版权声明和本许可声明应包含在该软件的所有副本或实质成分中。
 本软件是“如此”提供的，没有任何形式的明示或暗示的保证，包括但不限于对适销性、特定用途的适用性和不侵权的保证。在任何情况下，作者或版权持有人都不对任何索赔、损害或其他责任负责，无论这些追责来自合同、侵权或其它行为中，还是产生于、源于或有关于本软件以及本软件的使用或其它处置。
 <CompilerModal />
diff --git a/makefile b/makefile
index d1b074a..d7e85d3 100644
--- a/makefile
+++ b/makefile
@@ -391,7 +391,6 @@ test: debug
        @./$(BIN_NAME) $(TEST_INPUT)/try_catch.yue -o $(TEST_OUTPUT)/5.1/try_catch.lua --target=5.1
        @./$(BIN_NAME) $(TEST_INPUT)/attrib.yue -o $(TEST_OUTPUT)/5.1/attrib.lua --target=5.1
        @./$(BIN_NAME) $(TEST_INPUT)/test/loops_spec.yue -o $(TEST_OUTPUT)/5.1/test/loops_spec.lua --target=5.1
-        @./$(BIN_NAME) $(TEST_INPUT)/literals.yue -o $(TEST_OUTPUT)/5.1/literals.lua --target=5.1
        @./$(BIN_NAME) -e spec/inputs/compile_doc.yue $(TEST_OUTPUT)
        @echo -en "Compile time: "
        @$(END_TIME)
@@ -410,7 +409,6 @@ gen: release
        @./$(BIN_NAME) $(TEST_INPUT)/loops.yue -o $(GEN_OUTPUT)/5.1/loops.lua --target=5.1
        @./$(BIN_NAME) $(TEST_INPUT)/try_catch.yue -o $(GEN_OUTPUT)/5.1/try_catch.lua --target=5.1
        @./$(BIN_NAME) $(TEST_INPUT)/attrib.yue -o $(GEN_OUTPUT)/5.1/attrib.lua --target=5.1
-        @./$(BIN_NAME) $(TEST_INPUT)/literals.yue -o $(GEN_OUTPUT)/5.1/literals.lua --target=5.1
        @./$(BIN_NAME) $(TEST_INPUT)/test/loops_spec.yue -o $(GEN_OUTPUT)/5.1/test/loops_spec.lua --target=5.1
        @./$(BIN_NAME) -e spec/inputs/compile_doc.yue $(GEN_OUTPUT)
        @echo -en "Compile time: "
diff --git a/spec/inputs/backcall.yue b/spec/inputs/backcall.yue
index 8aadc71..e6b8c21 100644
--- a/spec/inputs/backcall.yue
+++ b/spec/inputs/backcall.yue
@@ -13,9 +13,9 @@ do
        x > 2
 do
-        (data) <- http?.get "ajaxtest"
+        data <- http?.get "ajaxtest"
        body[".result"]\html data
-        (processed) <- http.post "ajaxprocess", data
+        processed <- http.post "ajaxprocess", data
        body[".result"]\append processed
        <- setTimeout 1000
        print "done"
diff --git a/spec/inputs/destructure.yue b/spec/inputs/destructure.yue
index 674dfe4..b6250d0 100644
--- a/spec/inputs/destructure.yue
+++ b/spec/inputs/destructure.yue
@@ -94,7 +94,7 @@ do
 --
 do
-        with {a,b} = thing
+        with {a,b} := thing
                print a, b
@@ -240,5 +240,43 @@ do
        switch tb
                when {c: {<"abc">: meta_field = "def"}, <[[any string]]>: {d: abc = 123}, <'str'>: {e: def = {}}}
                        print meta_field, abc, def
+do
+        clients = ["VIP_Alice", "User_Bob", "User_Clara", "VIP_Eva"]
+        [vipStart, ...regulars, vipEnd] = clients
+        print vipStart -- "VIP_Alice"
+        print regulars -- {"User_Bob", "User_Clara"}
+        print vipEnd   -- "VIP_Eva"
+do
+        setupMeeting = (participants) ->
+                [chair, ..._, secretary] = participants
+                print chair, secretary
+        setupMeeting ["Alice", "Bob", "Charlie", "David"]
+        -- Output: Alice David
+do
+        getTransactions = ->
+                {
+                        {id: "T1", amount: 100}
+                        {id: "T2", amount: 200}
+                        {id: "T3", amount: 300}
+                }
+        :id, :amount = getTransactions![#]
+        assert id == "T3"
+        assert amount == 300
+do
+        [
+                _
+                ...middle
+                _
+        ] = tb
+do
+        {a, :abc, b, :def, ...sub, d, e} = tb
 nil
diff --git a/spec/inputs/global.yue b/spec/inputs/global.yue
index ce1cc15..4e3b8aa 100644
--- a/spec/inputs/global.yue
+++ b/spec/inputs/global.yue
@@ -82,3 +82,9 @@ do
        FooBar = "pascal case"
        FOOBAR = "all uppercase"
+do
+        global const class A
+        global const Flag = 1
+        global const const, x, y = "const", 1, 2
+        global const math, table
diff --git a/spec/inputs/import.yue b/spec/inputs/import.yue
index b8ffc24..8982e6c 100644
--- a/spec/inputs/import.yue
+++ b/spec/inputs/import.yue
@@ -139,3 +139,13 @@ do
        import "m" as {c: d}
        import "m" as {g, {<close>: i}}
+do
+        import require
+        import string as stringlib
+        import string.format
+        import io.read as io_read
+        type = ->
+        import type as tp
+        import 月 as yue
diff --git a/spec/inputs/lists.yue b/spec/inputs/lists.yue
index 921cae0..c493b68 100644
--- a/spec/inputs/lists.yue
+++ b/spec/inputs/lists.yue
@@ -87,4 +87,51 @@ do
        [a, b] = hello
        [name = "nameless", job = "jobless"] = person
+do
+        transactions = ["T001", "T002", "T003", "T004", "T005"]
+        middleTransactions = transactions[2, -2]
+        print middleTransactions -- => {"T002", "T003", "T004"}
+do
+        logs =
+                - start: 0, end: 100
+                - start: 100, end: 200
+                - start: 200, end: 123
+        print logs[#].end -- => 123
+do
+        pendingOrders = ["O001", "O002", "O003", "O004"]
+        print pendingOrders[# - 1] -- => "O003" 
+do
+        getOrders = ->
+                {
+                        { id: "O1001", status: "pending" }
+                        { id: "O1002", status: "processing" }
+                        { id: "O1003", status: "done" }
+                }
+        lastStatus = getOrders()[#].status
+        assert lastStatus == "done"
+do
+        cloneList1 = (list) -> list[,]
+        cloneList2 = (list) -> [...list,]
+        cloneTable = (tb) -> {...tb}
+do
+        print(
+                globalTB[#]
+                a.b.c[# - 2]
+                x?\y?!.z?[# - 3]
+        )
+do
+        f = ->
+                print(
+                        globalTB[#]\end 123
+                        a.b.c[5,-5][# - 2]
+                        x?\y?!.z?[# - 3]?[, -3]
+                )
 nil
diff --git a/spec/inputs/loops.yue b/spec/inputs/loops.yue
index c5b28b3..5df10ca 100644
--- a/spec/inputs/loops.yue
+++ b/spec/inputs/loops.yue
@@ -213,3 +213,55 @@ do
 do
        until x := func 'a', b do
                print "false expected"
+do
+        index = for i = 1, #tb
+                break i if tb[i]
+        f for i = 1, #tb
+                break i if tb[i]
+        f for i = 1, #tb
+                i if tb[i]
+        i = 1
+        ids = while tb[i]
+                i += 1
+                i - 1
+        i = 1
+        idx = while tb[i]
+                i += 1
+                break i - 1
+        f1 = ->
+                i = 1
+                f while tb[i]
+                        i += 1
+                        i - 1
+        i = 1
+        f while tb[i]
+                i += 1
+                break i - 1
+        list = for item in *items
+                switch item
+                        when type: "A", :value
+                                if value > 5
+                                        item
+do
+        repeat print 1 until true
+        x = repeat
+                a = func!
+                break a.x
+        until a.v
+        items = repeat
+                item = getItem!
+                break unless item
+                item if item.value > 0
+        until false
diff --git a/spec/inputs/macro.yue b/spec/inputs/macro.yue
index 5d5f1a9..191f09f 100644
--- a/spec/inputs/macro.yue
+++ b/spec/inputs/macro.yue
@@ -60,6 +60,11 @@ macro NumAndStr = (num, str) ->
 print $NumAndStr 123, 'xyz'
+macro NumAndStr2 = (num`Num, str`SingleString) -> |
+        [#{num}, #{str}]
+print $NumAndStr2 456, 'abc'
 $asserts item == nil
 $myconfig false
@@ -100,13 +105,14 @@ macro filter = (items, action)->
        $showMacro "filter", "[_ for _ in *#{items} when #{action}]"
 macro reduce = (items, def, action)->
-        $showMacro "reduce", "if ##{items} == 0
+        $showMacro "reduce", |
-        #{def}
+                if ##{items} == 0
-else
+                        #{def}
-        _1 = #{def}
+                else
-        for _2 in *#{items}
+                        _1 = #{def}
-                _1 = #{action}
+                        for _2 in *#{items}
-        _1"
+                                _1 = #{action}
+                        _1
 macro foreach = (items, action)->
        $showMacro "foreach", "for _ in *#{items}
@@ -154,13 +160,15 @@ macro curry = (...)->
 f = $curry x,y,z,do
        print x,y,z
-macro get_inner = (var)-> "do
+macro get_inner = (var)-> |
-        a = 1
+        do
-        a + 1"
+                a = 1
+                a + 1
-macro get_inner_hygienic = (var)-> "(->
+macro get_inner_hygienic = (var)-> |
-        local a = 1
+        (->
-        a + 1)!"
+                local a = 1
+                a + 1)!
 do
        a = 8
@@ -196,6 +204,18 @@ end
 print x
+import "yue"
+macro lua = (code`YAMLMultiline) -> {
+        code: yue.loadstring(code)!
+        type: "lua"
+}
+$lua |
+        local function f2(a)
+                return a + 1
+        end
+        x = x + f2(3)
 macro def = (fname, ...)->
        args = {...}
        last = table.remove args
@@ -317,7 +337,13 @@ $chainC(
        Destroy!
 )
-macro tb = -> "{'abc', a:123, <call>:=> 998}"
+macro tb = -> |
+        {
+                'abc'
+                a: 123
+                <call>: => 998
+        }
 print $tb[1], $tb.a, ($tb)!, $tb!
 print "current line: #{ $LINE }"
diff --git a/spec/inputs/macro_export.yue b/spec/inputs/macro_export.yue
index cc7d459..22905b5 100644
--- a/spec/inputs/macro_export.yue
+++ b/spec/inputs/macro_export.yue
@@ -8,13 +8,12 @@ export macro config = (debugging = true)->
        ""
 export macro showMacro = (name, res)->
-        if debugMacro then "
+        if debugMacro then |
-do
+                do
-        txt = #{res}
+                        txt = #{res}
-        print '[macro ' .. #{name} .. ']'
+                        print '[macro #{name}]'
-        print txt
+                        print txt
-        txt
+                        txt
-"
        else
                res
@@ -35,14 +34,16 @@ export macro copy = (src, dst, ...)->
                src != "_src_" and src != "_dst_" and dst != "_src_" and dst != "_dst_"
                "copy targets can not be _src_ or _dst_"
        )
-        "
+        copyFields = table.concat(
-do
+                ["_dst_.#{field} = _src_.#{field}" for field in *{...}]
-        local _src_, _dst_
+                "\n\t\t\t"
-        with _dst_ = #{dst}
+        )
-                with _src_ = #{src}
+        |
-#{table.concat for field in *{...} do "
+                do
-                        _dst_.#{field} = _src_.#{field}
+                        local _src_, _dst_
-"}"
+                        with _dst_ := #{dst}
+                                with _src_ := #{src}
+                                        #{copyFields}
 export macro enum = (...) ->
        items = {...}
diff --git a/spec/inputs/macro_teal.yue b/spec/inputs/macro_teal.yue
index 0cfd862..e51bcd7 100644
--- a/spec/inputs/macro_teal.yue
+++ b/spec/inputs/macro_teal.yue
@@ -4,11 +4,16 @@ $ ->
                options.target_extension = "tl"
        package.path ..= ";./spec/lib/?.lua"
-macro to_lua = (code)->
+macro to_lua = (code)-> |
-        "require('yue').to_lua(#{code}, reserve_line_number:false, same_module:true)"
+        require('yue').to_lua #{code},
+                reserve_line_number: false
+                same_module: true
-macro trim = (name)->
+macro trim = (name)-> |
-        "if result := #{name}\\match '[\\'\"](.*)[\\'\"]' then result else #{name}"
+        if result := #{name}\match '[\'"](.*)[\'"]'
+                result
+        else
+                #{name}
 export macro local = (decl, value = nil)->
        import "yue" as {options:{:tl_enabled}}
diff --git a/spec/inputs/macro_todo.yue b/spec/inputs/macro_todo.yue
index 752c9cb..c9c8f77 100644
--- a/spec/inputs/macro_todo.yue
+++ b/spec/inputs/macro_todo.yue
@@ -5,9 +5,6 @@ export macro todoInner = (module, line, msg)->
                type: "lua"
        }
-export macro todo = (msg)->
+export macro todo = (msg)-> |
-        if msg
+        $todoInner $FILE, $LINE#{msg and ", #{msg}" or ""}
-                "$todoInner $FILE, $LINE, #{msg}"
-        else
-                "$todoInner $FILE, $LINE"
diff --git a/spec/inputs/props.yue b/spec/inputs/props.yue
new file mode 100644
index 0000000..bbb7aae
--- /dev/null
+++ b/spec/inputs/props.yue
@@ -0,0 +1,61 @@
+class Props
+        __index: (name): nil =>
+                cls = @.<>
+                if item := cls.__getter?[name] -- access properties
+                        return item @
+                elseif item := rawget cls, name -- access member functions
+                        return item
+                else
+                        c = cls
+                        while c := c.<> -- recursive to access base classes
+                                if item := c.__getter?[name]
+                                        cls.__getter ??= {}
+                                        cls.__getter[name] = item -- cache base properties to class
+                                        return item @
+                                elseif item := rawget c, name
+                                        rawset cls, name, item -- cache base member to class
+                                        return item
+        __newindex: (name, value) =>
+                cls = @.<>
+                if item := cls.__setter?[name] -- access properties
+                        item @, value
+                else
+                        c = cls
+                        while c := c.<> -- recursive to access base classes
+                                if item := c.__setter?[name]
+                                        cls.__setter ??= {}
+                                        cls.__setter[name] = item -- cache base property to class
+                                        item @, value
+                                        return
+                        rawset @, name, value -- assign field to self
+        assignReadOnly = -> error "assigning a readonly property"
+        prop: (name, props) =>
+                {
+                        :get
+                        :set = assignReadOnly
+                } = props
+                if getter := rawget @__base, "__getter"
+                        getter[name] = get
+                else
+                        rawset @__base, "__getter", [name]: get
+                if setter := rawget @__base, "__setter"
+                        setter[name] = set
+                else
+                        rawset @__base, "__setter", [name]: set
+class A extends Props
+        @prop 'x'
+                get: => @_x + 1000
+                set: (v) => @_x = v
+        new: =>
+                @_x = 0
+                
+class B extends A
+        @prop 'abc', get: => "hello"
+b = B!
+b.x = 999
+print b.x, b.abc
diff --git a/spec/inputs/string.yue b/spec/inputs/string.yue
index f91383e..1f0fba8 100644
--- a/spec/inputs/string.yue
+++ b/spec/inputs/string.yue
@@ -74,3 +74,76 @@ _ = "hello"
 something"hello"\world!
 something "hello"\world!
+do
+        str = |
+                key: value
+        str = |
+                config:
+                        enabled: true
+                        level: 5
+        str = |
+                header: start
+                footer: end
+        str = |
+                name: #{username}
+        str = |
+                count: #{total} items
+        str = |
+                user: #{name}
+                id: #{id}
+        str = |
+                path: "C:\\Program Files\\App"
+                desc: 'single "quote" test'
+        str = |
+                key: value   
+                next: 123   
+        str = |
+                list:
+                  - "one"
+                  - "two"
+        str = |
+                -- comment
+                content text
+                -- comment
+        str = |
+                #{1 + 2}
+                #{2 + 3}
+                #{"a" .. "b"}
+        obj =
+                settings: |
+                        mode: #{mode}
+                        flags:
+                                - #{flag1}
+                                - default
+        fn = -> |
+                Hello
+                name: #{userName}
+        str = |
+                result:
+                        status: #{if ok then "pass" else "fail"}
+                        code: #{code}
+        summary = |
+                date: #{os.date()}
+                values:
+                        -
+                                a: #{aVal}
+                                b: #{bVal or defaultB}
+        msg = send |
+                Hello, #{user}!
+                Today is #{os.date("%A")}.
+        desc = do
+                prefix = "Result"
+                |
+                        #{prefix}:
+                        value: #{compute!}
+        (|
+                1
+                2
+                3
+        ) |> print
+export yaml = |
+        version: #{ver}
+        ok: true
diff --git a/spec/inputs/switch.yue b/spec/inputs/switch.yue
index 49d47f3..2b0669c 100644
--- a/spec/inputs/switch.yue
+++ b/spec/inputs/switch.yue
@@ -165,5 +165,128 @@ do
                        print item
                when [a = 1, b = "abc"]
                        print a, b
-nil
+do
+        switch tb
+                when [1, 2, 3]
+                        print "1, 2, 3"
+                when [1, b, 3]
+                        print "1, #{b}, 3"
+                when [1, 2, b = 3]
+                        print "1, 2, #{b}"
+do
+        switch tb
+                when success: true, :result
+                        print "success", result
+                when success: false
+                        print "failed", result
+                else
+                        print "invalid"
+do
+        switch tb
+                when {type: "success", :content}
+                        print "success", content
+                when {type: "error", :content}
+                        print "failed", content
+                else
+                        print "invalid"
+do
+        switch tb
+                when [
+                                {a: 1, b: 2}
+                                {a: 3, b: 4}
+                                {a: 5, b: 6}
+                                fourth
+                        ]
+                        print "matched", fourth
+        switch tb
+                when [
+                                {c: 1, d: 2}
+                                {c: 3, d: 4}
+                                {c: 5, d: 6}
+                        ]
+                        print "OK"
+                when [
+                                _
+                                _
+                                {a: 1, b: 2}
+                                {a: 3, b: 4}
+                                {a: 5, b: 6}
+                                sixth
+                        ]
+                        print "matched", sixth
+do
+        switch v := "hello"
+                when "hello"
+                        print "matched hello"
+                else
+                        print "not matched"
+        -- output: matched hello
+do
+        f = -> "ok"
+        switch val := f!
+                when "ok"
+                        print "it's ok"
+        -- output: it's ok
+do
+        g = -> 42
+        switch result := g!
+                when 1, 2
+                        print "small"
+                when 42
+                        print "life universe everything"
+                else
+                        print "other #{result}"
+        -- output: life universe everything
+do
+        check = ->
+                if true
+                        "yes"
+                else
+                        "no"
+        switch x := check!
+                when "yes"
+                        print "affirmative"
+                else
+                        print "negative"
+        -- output: affirmative
+do
+        t = (): tb ->
+                tb = {a: 1}
+                tb.a = 2
+        switch data := t!
+                when {a: 2}
+                        print "matched"
+                else
+                        print "not matched"
+do
+        clientData = ["Meta", "CUST_1001", "CHK123"]
+        switch clientData
+                when [...metadata, customerId, checksum]
+                        print metadata -- {"Meta"}
+                        print customerId -- "CUST_1001"
+                        print checksum -- "CHK123"
+do
+        handlePath = (segments) ->
+                switch segments
+                        when [..._, resource, action]
+                                print "Resource:", resource
+                                print "Action:", action
+        handlePath ["admin", "logs", "view"]
+nil
diff --git a/spec/inputs/tables.yue b/spec/inputs/tables.yue
index 0de8a8c..702e04a 100644
--- a/spec/inputs/tables.yue
+++ b/spec/inputs/tables.yue
@@ -245,6 +245,24 @@ menus =
                                click: ->
                        }
+_ =
+        boolean:
+                - true
+                - false
+        float:
+                - 3.14
+                - -6.8523015e+5
+        int:
+                - 123
+                - -0b1010_0111_0100_1010_1110
+        null:
+                nodeName: 'node'
+                parent: nil
+        string:
+                - 'Hello world'
+                - "newline
+newline2"
 tb = {...other}
 tbMix = {
diff --git a/spec/inputs/try_catch.yue b/spec/inputs/try_catch.yue
index 4e05bc6..6c29a52 100644
--- a/spec/inputs/try_catch.yue
+++ b/spec/inputs/try_catch.yue
@@ -62,6 +62,126 @@ f = ->
        do
                <- x
                local tb, a, b, c
-                f = -> try tb.f a, b, c
+                f1 = -> try tb.f a, b, c
+        do
+                f1 = -> do
+                        ok, ... = try func!
+                        ...
+        do
+                local func
+                a, b, c = try? func!
+        
+        do
+                a, b, c = try? func!
+        do
+                a = (try? func!) ?? "default"
+        do
+                f try? func!
+        
+        do
+                f try?
+                        print 123
+                        func!
+                catch e
+                        print e
+                        e
        nil
+do
+        try
+                func 1, 2, 3
+        catch err
+                print err
+        try func 1, 2, 3
+        catch err
+                print err
+        try
+                print "trying"
+                func 1, 2, 3
+        do
+                success, result = try
+                        func 1, 2, 3
+                catch err
+                        print err
+                success, result = try func 1, 2, 3
+        tb = {}
+        try tb.func
+        try tb.func!
+        try tb.func()
+        try (tb.func!)
+        try (tb\func(1, 2, 3))
+        try tb.func 1
+        try tb.func(1)
+        if (try func 1
+        catch err
+                print err)
+                print "OK"
+        if try (func 1)
+        catch err
+                        print err
+                print "OK"
+        do
+                if success, result := try func "abc", 123
+                        print result
+                success, result = try func "abc", 123
+                catch err
+                        print err
+                print result if success, result := try func "abc", 123
+                catch err
+                        print err
+        do
+                try
+                        func 1, 2, 3
+                try func 1, 2, 3
+        do
+                <- x
+                local tb, a, b, c
+                f1 = -> try tb.f a, b, c
+        do
+                f1 = -> do
+                        ok, ... = try func!
+                        ...
+        do
+                local func
+                a, b, c = try? func!
+        
+        do
+                a, b, c = try? func!
+        do
+                a = (try? func!) ?? "default"
+        do
+                f try? func!
+        
+        do
+                f try?
+                        print 123
+                        func!
+                catch e
+                        print e
+                        e
+nil
diff --git a/spec/inputs/unicode/destructure.yue b/spec/inputs/unicode/destructure.yue
index 3c3a369..a5ffd5d 100644
--- a/spec/inputs/unicode/destructure.yue
+++ b/spec/inputs/unicode/destructure.yue
@@ -84,7 +84,7 @@ do
 --
 do
-        with {元素a,元素b} = 东西
+        with {元素a,元素b} := 东西
                打印 元素a, 元素b
diff --git a/spec/inputs/unicode/macro_export.yue b/spec/inputs/unicode/macro_export.yue
index 3c9a942..56571cd 100644
--- a/spec/inputs/unicode/macro_export.yue
+++ b/spec/inputs/unicode/macro_export.yue
@@ -37,8 +37,8 @@ export macro 复制 = (源, 目标, ...)->
        "
 do
        local _源_, _目标_
-        with _目标_ = #{目标}
+        with _目标_ := #{目标}
-                with _源_ = #{源}
+                with _源_ := #{源}
 #{table.concat for 字段 in *{...} do "
                        _目标_.#{字段} = _源_.#{字段}
 "}"
diff --git a/spec/inputs/unicode/with.yue b/spec/inputs/unicode/with.yue
index ecbfdab..3c15add 100644
--- a/spec/inputs/unicode/with.yue
+++ b/spec/inputs/unicode/with.yue
@@ -45,19 +45,19 @@ do
        with 变量a
                打印 .世界
-        模块 = with _模块 = {}
+        模块 = with _模块 := {}
                .事物 = "你好"
-        with 变量a, 变量b = 东西, 布
+        with 变量a, 变量b := 东西, 布
                打印 .世界
-        变量x = with 变量a, 变量b = 1, 2
+        变量x = with 变量a, 变量b := 1, 2
                打印 变量a + 变量b
-        打印 with 变量a, 变量b = 1, 2
+        打印 with 变量a, 变量b := 1, 2
                打印 变量a + 变量b
-        p = with 你好!.字段x, 世界!.字段y = 1, 2
+        p = with 你好!.字段x, 世界!.字段y := 1, 2
                打印 变量a + 变量b
 --
@@ -68,16 +68,16 @@ do
                变量x\大写!
 do
-        with 变量k = "乔"
+        with 变量k := "乔"
                打印 \大写!
 do
-        with 变量a,变量b,变量c = "", "", ""
+        with 变量a,变量b,变量c := "", "", ""
                打印 \大写!
 do
        变量a = "床铺"
-        with 变量a,变量b,变量c = "", "", ""
+        with 变量a,变量b,变量c := "", "", ""
                打印 \大写!
 do
@@ -85,7 +85,7 @@ do
                打印 \大写!
 do
-        with 变量k.变量j = "乔"
+        with 变量k.变量j := "乔"
                打印 \大写!
 do
@@ -96,7 +96,7 @@ do
 do
        with 变量a
-                with .b = 2
+                with .b := 2
                        打印 .c
 do
@@ -131,12 +131,12 @@ do
 do
        global 掩码
-        with? 掩码 = 实心矩形 宽: w, 高: h, 颜色: 0x66000000
+        with? 掩码 := 实心矩形 宽: w, 高: h, 颜色: 0x66000000
                .触摸启用 = true
                .吞噬触摸 = true
 do
-        with? 掩码 = 实心矩形 宽: w, 高: h, 颜色: 0x66000000
+        with? 掩码 := 实心矩形 宽: w, 高: h, 颜色: 0x66000000
                .触摸启用 = true
                .吞噬触摸 = true
diff --git a/spec/inputs/with.yue b/spec/inputs/with.yue
index 19b7be1..2256833 100644
--- a/spec/inputs/with.yue
+++ b/spec/inputs/with.yue
@@ -48,21 +48,21 @@ do
        with a -- only one value allowed
                print .world
-        mod = with _M = {}
+        mod = with _M := {}
                .Thing = "hi"
        -- operate on a only
-        with a, b = something, pooh
+        with a, b := something, pooh
                print .world
-        x = with a, b = 1, 2
+        x = with a, b := 1, 2
                print a + b
-        print with a, b = 1, 2
+        print with a, b := 1, 2
                print a + b
        -- assignment lhs must be evaluated in the order they appear
-        p = with hello!.x, world!.y = 1, 2
+        p = with hello!.x, world!.y := 1, 2
                print a + b
 --
@@ -73,16 +73,16 @@ do
                x\upper!
 do
-        with k = "jo"
+        with k := "jo"
                print \upper!
 do
-        with a,b,c = "", "", ""
+        with a,b,c := "", "", ""
                print \upper!
 do
        a = "bunk"
-        with a,b,c = "", "", ""
+        with a,b,c := "", "", ""
                print \upper!
 do
@@ -90,7 +90,7 @@ do
                print \upper!
 do
-        with k.j = "jo"
+        with k.j := "jo"
                print \upper!
 do
@@ -103,7 +103,7 @@ do
 do
        with a
                -- nested `with`s with assignments should change the scope correctly
-                with .b = 2
+                with .b := 2
                        print .c
 do
@@ -138,12 +138,12 @@ do
 do
        global mask
-        with? mask = SolidRect width: w, height: h, color: 0x66000000
+        with? mask := SolidRect width: w, height: h, color: 0x66000000
                .touchEnabled = true
                .swallowTouches = true
 do
-        with? mask = SolidRect width: w, height: h, color: 0x66000000
+        with? mask := SolidRect width: w, height: h, color: 0x66000000
                .touchEnabled = true
                .swallowTouches = true
@@ -152,4 +152,22 @@ do
                return with {}
                        return [123]
+do
+        f with item
+                if .id > 0
+                        break .content
+        a = with tb
+                if .v
+                        break .a
+        a = while true
+                break with? tb
+                        break 1
+do
+        a = for i = 1, 100
+          with? x := tb[i]
+                 break x if .id := 1
 nil
diff --git a/spec/outputs/5.1/literals.lua b/spec/outputs/5.1/literals.lua
deleted file mode 100644
index 36c705a..0000000
--- a/spec/outputs/5.1/literals.lua
+++ /dev/null
@@ -1,44 +0,0 @@
-local _ = {
-        121,
-        121.2323,
-        121.2323e-1,
-        121.2323e13434,
-        2323E34,
-        0x12323,
-        0xfF2323,
-        0xabcdef,
-        0xABCDEF,
-        0XFBC400,
-        2.7365508487142853e-35,
-        0xABCP321,
-        2.4074124304840448e-35,
-        6.4326233113470805e-94,
-        0.1171875,
-        162.1875,
-        3.1415926535897931,
-        1,
-        8,
-        15,
-        201,
-        .2323,
-        .2323e-1,
-        .2323e13434,
-        1LL,
-        1ULL,
-        9332LL,
-        9332,
-        0x2aLL,
-        0x2aULL,
-        1000000.0000001,
-        1234e5678,
-        1234E-5678,
-        0xDEADBEEF,
-        [[ hello world ]],
-        [=[ hello world ]=],
-        [====[ hello world ]====],
-        "another world",
-        'what world',
-        "\n     hello world\n   ",
-        'yeah\n what is going on\n      here is something cool'
-}
-return nil
diff --git a/spec/outputs/5.1/loops.lua b/spec/outputs/5.1/loops.lua
index 57b19be..e4f2871 100644
--- a/spec/outputs/5.1/loops.lua
+++ b/spec/outputs/5.1/loops.lua
@@ -60,8 +60,8 @@ do
                local y = hello[_index_0]
                if y % 2 == 0 then
                        _accum_0[_len_0] = y
+                        _len_0 = _len_0 + 1
                end
-                _len_0 = _len_0 + 1
        end
        x = _accum_0
 end
@@ -132,13 +132,11 @@ do
 end
 do
        local _accum_0 = { }
-        local _len_0 = 1
        local _list_2 = 3
        for _index_0 = 1, #_list_2 do
                local thing = _list_2[_index_0]
                y = "hello"
                break
-                _len_0 = _len_0 + 1
        end
        x = _accum_0
 end
@@ -489,3 +487,131 @@ do
                end
        until false
 end
+local _anon_func_0 = function(i, tb)
+        local _accum_0 = { }
+        local _len_0 = 1
+        while tb[i] do
+                i = i + 1
+                _accum_0[_len_0] = i - 1
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+do
+        local index
+        do
+                local _accum_0
+                for i = 1, #tb do
+                        if tb[i] then
+                                _accum_0 = i
+                                break
+                        end
+                end
+                index = _accum_0
+        end
+        f((function()
+                local _accum_0
+                for i = 1, #tb do
+                        if tb[i] then
+                                _accum_0 = i
+                                break
+                        end
+                end
+                return _accum_0
+        end)())
+        f((function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                for i = 1, #tb do
+                        if tb[i] then
+                                _accum_0[_len_0] = i
+                                _len_0 = _len_0 + 1
+                        end
+                end
+                return _accum_0
+        end)())
+        i = 1
+        local ids
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                while tb[i] do
+                        i = i + 1
+                        _accum_0[_len_0] = i - 1
+                        _len_0 = _len_0 + 1
+                end
+                ids = _accum_0
+        end
+        i = 1
+        local idx
+        do
+                local _accum_0
+                while tb[i] do
+                        i = i + 1
+                        _accum_0 = i - 1
+                        break
+                end
+                idx = _accum_0
+        end
+        local f1
+        f1 = function()
+                i = 1
+                return f(_anon_func_0(i, tb))
+        end
+        i = 1
+        f((function()
+                local _accum_0
+                while tb[i] do
+                        i = i + 1
+                        _accum_0 = i - 1
+                        break
+                end
+                return _accum_0
+        end)())
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _list_3 = items
+        for _index_0 = 1, #_list_3 do
+                local item = _list_3[_index_0]
+                local _type_0 = type(item)
+                local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                if _tab_0 then
+                        local value = item.value
+                        if "A" == item.type and value ~= nil then
+                                if value > 5 then
+                                        _accum_0[_len_0] = item
+                                        _len_0 = _len_0 + 1
+                                end
+                        end
+                end
+        end
+        list = _accum_0
+end
+do
+        repeat
+                print(1)
+        until true
+        do
+                local _accum_0
+                repeat
+                        a = func()
+                        _accum_0 = a.x
+                        break
+                until a.v
+                x = _accum_0
+        end
+        local items
+        local _accum_0 = { }
+        local _len_0 = 1
+        repeat
+                local item = getItem()
+                if not item then
+                        break
+                end
+                if item.value > 0 then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        until false
+        items = _accum_0
+end
diff --git a/spec/outputs/5.1/try_catch.lua b/spec/outputs/5.1/try_catch.lua
index efd92c6..d2b58bc 100644
--- a/spec/outputs/5.1/try_catch.lua
+++ b/spec/outputs/5.1/try_catch.lua
@@ -22,6 +22,43 @@ end
 local _anon_func_7 = function(a, b, c, tb)
        return tb.f(a, b, c)
 end
+local _anon_func_8 = function(_arg_0, ...)
+        local ok = _arg_0
+        return ...
+end
+local _anon_func_10 = function(_arg_0, ...)
+        local _ok_0 = _arg_0
+        if _ok_0 then
+                return ...
+        end
+end
+local _anon_func_9 = function(func, pcall)
+        return _anon_func_10(pcall(func))
+end
+local _anon_func_12 = function(_arg_0, ...)
+        local _ok_0 = _arg_0
+        if _ok_0 then
+                return ...
+        end
+end
+local _anon_func_11 = function(func, pcall)
+        return _anon_func_12(pcall(func))
+end
+local _anon_func_14 = function(_arg_0, ...)
+        local _ok_0 = _arg_0
+        if _ok_0 then
+                return ...
+        end
+end
+local _anon_func_13 = function(func, print, xpcall)
+        return _anon_func_14(xpcall(function()
+                print(123)
+                return func()
+        end, function(e)
+                print(e)
+                return e
+        end))
+end
 local f
 f = function()
        xpcall(function()
@@ -104,10 +141,236 @@ f = function()
        do
                x(function()
                        local tb, a, b, c
-                        f = function()
+                        local f1
+                        f1 = function()
                                return pcall(_anon_func_7, a, b, c, tb)
                        end
                end)
        end
+        do
+                local f1
+                f1 = function()
+                        do
+                                return _anon_func_8(pcall(function()
+                                        return func()
+                                end))
+                        end
+                end
+        end
+        do
+                local func
+                local a, b, c
+                local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(func)
+                if _ok_0 then
+                        a, b, c = _ret_0, _ret_1, _ret_2
+                end
+        end
+        do
+                local a, b, c
+                local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                        return func()
+                end)
+                if _ok_0 then
+                        a, b, c = _ret_0, _ret_1, _ret_2
+                end
+        end
+        do
+                local a
+                local _exp_0 = (_anon_func_9(func, pcall))
+                if _exp_0 ~= nil then
+                        a = _exp_0
+                else
+                        a = "default"
+                end
+        end
+        do
+                f(_anon_func_11(func, pcall))
+        end
+        do
+                f(_anon_func_13(func, print, xpcall))
+        end
        return nil
 end
+local _anon_func_15 = function(a, b, c, tb)
+        return tb.f(a, b, c)
+end
+local _anon_func_16 = function(_arg_0, ...)
+        local ok = _arg_0
+        return ...
+end
+do
+        xpcall(function()
+                return func(1, 2, 3)
+        end, function(err)
+                return print(err)
+        end)
+        xpcall(function()
+                return func(1, 2, 3)
+        end, function(err)
+                return print(err)
+        end)
+        pcall(function()
+                print("trying")
+                return func(1, 2, 3)
+        end)
+        do
+                local success, result = xpcall(function()
+                        return func(1, 2, 3)
+                end, function(err)
+                        return print(err)
+                end)
+                success, result = pcall(function()
+                        return func(1, 2, 3)
+                end)
+        end
+        local tb = { }
+        pcall(function()
+                return tb.func
+        end)
+        pcall(function()
+                return tb.func()
+        end)
+        pcall(function()
+                return tb.func()
+        end)
+        pcall(function()
+                return (tb.func())
+        end)
+        pcall(function()
+                return (tb:func(1, 2, 3))
+        end)
+        pcall(function()
+                return tb.func(1)
+        end)
+        pcall(function()
+                return tb.func(1)
+        end)
+        if (xpcall(function()
+                return func(1)
+        end, function(err)
+                return print(err)
+        end)) then
+                print("OK")
+        end
+        if xpcall(function()
+                return (func(1))
+        end, function(err)
+                return print(err)
+        end) then
+                print("OK")
+        end
+        do
+                do
+                        local success, result = pcall(function()
+                                return func("abc", 123)
+                        end)
+                        if success then
+                                print(result)
+                        end
+                end
+                local success, result = xpcall(function()
+                        return func("abc", 123)
+                end, function(err)
+                        return print(err)
+                end)
+                success, result = xpcall(function()
+                        return func("abc", 123)
+                end, function(err)
+                        return print(err)
+                end)
+                if success then
+                        print(result)
+                end
+        end
+        do
+                pcall(function()
+                        return func(1, 2, 3)
+                end)
+                pcall(function()
+                        return func(1, 2, 3)
+                end)
+        end
+        do
+                x(function()
+                        local tb, a, b, c
+                        local f1
+                        f1 = function()
+                                return pcall(_anon_func_15, a, b, c, tb)
+                        end
+                end)
+        end
+        do
+                local f1
+                f1 = function()
+                        do
+                                return _anon_func_16(pcall(function()
+                                        return func()
+                                end))
+                        end
+                end
+        end
+        do
+                local func
+                local a, b, c
+                local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(func)
+                if _ok_0 then
+                        a, b, c = _ret_0, _ret_1, _ret_2
+                end
+        end
+        do
+                local a, b, c
+                local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                        return func()
+                end)
+                if _ok_0 then
+                        a, b, c = _ret_0, _ret_1, _ret_2
+                end
+        end
+        do
+                local a
+                local _exp_0 = ((function()
+                        return (function(_arg_0, ...)
+                                local _ok_0 = _arg_0
+                                if _ok_0 then
+                                        return ...
+                                end
+                        end)(pcall(function()
+                                return func()
+                        end))
+                end)())
+                if _exp_0 ~= nil then
+                        a = _exp_0
+                else
+                        a = "default"
+                end
+        end
+        do
+                f((function()
+                        return (function(_arg_0, ...)
+                                local _ok_0 = _arg_0
+                                if _ok_0 then
+                                        return ...
+                                end
+                        end)(pcall(function()
+                                return func()
+                        end))
+                end)())
+        end
+        do
+                f((function()
+                        return (function(_arg_0, ...)
+                                local _ok_0 = _arg_0
+                                if _ok_0 then
+                                        return ...
+                                end
+                        end)(xpcall(function()
+                                print(123)
+                                return func()
+                        end, function(e)
+                                print(e)
+                                return e
+                        end))
+                end)())
+        end
+end
+return nil
diff --git a/spec/outputs/assign.lua b/spec/outputs/assign.lua
index 162c5a8..89c5f8a 100644
--- a/spec/outputs/assign.lua
+++ b/spec/outputs/assign.lua
@@ -43,10 +43,8 @@ do
        end
 end
 local _anon_func_0 = function(print)
-        do
+        print(123)
-                print(123)
+        return { }
-                return { }
-        end
 end
 return _(function()
        setmetatable(a, _anon_func_0(print))
diff --git a/spec/outputs/codes_from_doc.lua b/spec/outputs/codes_from_doc.lua
index f6d5d61..b7d1236 100644
--- a/spec/outputs/codes_from_doc.lua
+++ b/spec/outputs/codes_from_doc.lua
@@ -20,6 +20,38 @@ local inventory = {
                }
        }
 }
+local map
+map = function(arr, action)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                _accum_0[_len_0] = action(item)
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+local filter
+filter = function(arr, cond)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                if cond(item) then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        end
+        return _accum_0
+end
+local reduce
+reduce = function(arr, init, action)
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                init = action(init, item)
+        end
+        return init
+end
 print(reduce(filter(map({
        1,
        2,
@@ -77,6 +109,12 @@ end
 print("yuescript")
 print(3)
 print("Valid enum type:", "Static")
+do
+        print(123, "hello")
+end
+do
+        print(123, "hello")
+end
 if tb ~= nil then
        tb:func()
 end
@@ -177,6 +215,16 @@ for _key_0, _value_0 in pairs(b) do
        end
 end
 merge = _tab_0
+local last
+do
+        local _item_0 = data.items
+        last = _item_0[#_item_0]
+end
+local second_last
+do
+        local _item_0 = data.items
+        second_last = _item_0[#_item_0 - 1]
+end
 local mt = { }
 local add
 add = function(self, right)
@@ -307,6 +355,14 @@ func({
        2,
        3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
        name = "abc",
        values = {
@@ -547,6 +603,59 @@ end
 local two, four
 local _obj_0 = items
 two, four = _obj_0[2], _obj_0[4]
+local orders = {
+        "first",
+        "second",
+        "third",
+        "fourth",
+        "last"
+}
+local first, bulk, last = orders[1], (function()
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _max_0 = #orders + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = orders[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end)(), orders[#orders]
+print(first)
+print(bulk)
+print(last)
+local first, rest
+do
+        local _obj_0 = orders
+        first, rest = _obj_0[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)()
+end
+local start, last
+do
+        local _obj_0 = orders
+        start, last = (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -2 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0]
+end
+local _obj_0 = orders
+first, last = _obj_0[1], _obj_0[#_obj_0]
 local tuples = {
        {
                "hello",
@@ -648,6 +757,56 @@ end)
 if success then
        print(result)
 end
+local a, b, c
+do
+        local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                return func()
+        end)
+        if _ok_0 then
+                a, b, c = _ret_0, _ret_1, _ret_2
+        end
+end
+do
+        local _exp_0 = ((function()
+                return (function(_arg_0, ...)
+                        local _ok_0 = _arg_0
+                        if _ok_0 then
+                                return ...
+                        end
+                end)(pcall(function()
+                        return func()
+                end))
+        end)())
+        if _exp_0 ~= nil then
+                a = _exp_0
+        else
+                a = "default"
+        end
+end
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(pcall(function()
+                return func()
+        end))
+end)())
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(xpcall(function()
+                print(123)
+                return func()
+        end, function(e)
+                print(e)
+                return e
+        end))
+end)())
 local a <const> = 123
 local _ <close> = setmetatable({ }, {
        __close = function()
@@ -657,10 +816,19 @@ local _ <close> = setmetatable({ }, {
 local a, b, c, d
 local _obj_0 = tb
 a, b, c, d = _obj_0.a, _obj_0.b, _obj_0[1], _obj_0[2]
+Constant = 123
 local some_string = "Here is a string\n  that has a line break in it."
 print("I am " .. tostring(math.random() * 100) .. "% sure.")
 local integer = 1000000
 local hex = 0xEFBBBF
+local binary = 19
+local str = "key: value\nlist:\n  - item1\n  - " .. tostring(expr)
+local fn
+fn = function()
+        local str = "foo:\n  bar: baz"
+        return str
+end
+local str = "path: \"C:\\Program Files\\App\"\nnote: 'He said: \"" .. tostring(Hello) .. "!\"'"
 local my_function
 my_function = function() end
 my_function()
@@ -970,8 +1138,7 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-local _max_0 = 5
+for _index_0 = 1, 5 do
-for _index_0 = 1, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
@@ -981,7 +1148,8 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 2, #_list_0 do
+local _max_0 = #_list_0
+for _index_0 = 2, _max_0 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
@@ -991,12 +1159,46 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 1, #_list_0, 2 do
+local _max_0 = #_list_0
+for _index_0 = 1, _max_0, 2 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
 end
 slice = _accum_0
+local slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -4 + 1
+local _max_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, _max_0 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+slice = _accum_0
+local reverse_slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, 1, -1 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+reverse_slice = _accum_0
+local sub_list
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+for _index_0 = 2, 4 do
+        local _item_0 = _list_0[_index_0]
+        _accum_0[_len_0] = _item_0
+        _len_0 = _len_0 + 1
+end
+sub_list = _accum_0
 for i = 10, 20 do
        print(i)
 end
@@ -1007,8 +1209,7 @@ for key, value in pairs(object) do
        print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
+for _index_0 = 2, 4 do
-for _index_0 = 2, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
        local item = _list_0[_index_0]
        print(item)
 end
@@ -1026,12 +1227,24 @@ local _len_0 = 1
 for i = 1, 20 do
        if i % 2 == 0 then
                _accum_0[_len_0] = i * 2
+                _len_0 = _len_0 + 1
        else
                _accum_0[_len_0] = i
+                _len_0 = _len_0 + 1
        end
-        _len_0 = _len_0 + 1
 end
 doubled_evens = _accum_0
+local first_large
+local _accum_0
+local _list_0 = numbers
+for _index_0 = 1, #_list_0 do
+        local n = _list_0[_index_0]
+        if n > 10 then
+                _accum_0 = n
+                break
+        end
+end
+first_large = _accum_0
 local func_a
 func_a = function()
        for i = 1, 10 do
@@ -1180,7 +1393,7 @@ if "Robert" == name then
 elseif "Dan" == name or "Daniel" == name then
        print("Your name, it's Dan")
 else
-        print("I don't know about your name")
+        print("I don't know about you with name " .. tostring(name))
 end
 local b = 1
 local next_number
@@ -1280,6 +1493,192 @@ if _tab_0 then
        end
        print("Vec2 " .. tostring(x) .. ", " .. tostring(y))
 end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        if 1 == _exp_0[1] and 2 == _exp_0[2] and 3 == _exp_0[3] then
+                _match_0 = true
+                print("1, 2, 3")
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local b = _exp_0[2]
+                if 1 == _exp_0[1] and b ~= nil and 3 == _exp_0[3] then
+                        _match_1 = true
+                        print("1, " .. tostring(b) .. ", 3")
+                end
+        end
+        if not _match_1 then
+                if _tab_0 then
+                        local b = _exp_0[3]
+                        if b == nil then
+                                b = 3
+                        end
+                        if 1 == _exp_0[1] and 2 == _exp_0[2] then
+                                print("1, 2, " .. tostring(b))
+                        end
+                end
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local result = _exp_0.result
+        if true == _exp_0.success and result ~= nil then
+                _match_0 = true
+                print("success", result)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                if false == _exp_0.success then
+                        _match_1 = true
+                        print("failed", result)
+                end
+        end
+        if not _match_1 then
+                print("invalid")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local content
+        do
+                local _obj_0 = _exp_0.data
+                local _type_1 = type(_obj_0)
+                if "table" == _type_1 or "userdata" == _type_1 then
+                        content = _obj_0.content
+                end
+        end
+        local _val_0
+        do
+                local _obj_0 = _exp_0.data
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.type
+                end
+        end
+        if "success" == _val_0 and content ~= nil then
+                _match_0 = true
+                print("success", content)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local content
+                do
+                        local _obj_0 = _exp_0.data
+                        local _type_1 = type(_obj_0)
+                        if "table" == _type_1 or "userdata" == _type_1 then
+                                content = _obj_0.content
+                        end
+                end
+                local _val_0
+                do
+                        local _obj_0 = _exp_0.data
+                        if _obj_0 ~= nil then
+                                _val_0 = _obj_0.type
+                        end
+                end
+                if "error" == _val_0 and content ~= nil then
+                        _match_1 = true
+                        print("failed", content)
+                end
+        end
+        if not _match_1 then
+                print("invalid")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local fourth = _exp_0[4]
+        local _val_0
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.a
+                end
+        end
+        local _val_1
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_1 = _obj_0.b
+                end
+        end
+        local _val_2
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_2 = _obj_0.a
+                end
+        end
+        local _val_3
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_3 = _obj_0.b
+                end
+        end
+        local _val_4
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_4 = _obj_0.a
+                end
+        end
+        local _val_5
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_5 = _obj_0.b
+                end
+        end
+        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                print("matched", fourth)
+        end
+end
+local segments = {
+        "admin",
+        "users",
+        "logs",
+        "view"
+}
+local _type_0 = type(segments)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local groups
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #segments + -3 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = segments[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                groups = _accum_0
+        end
+        local resource = segments[#segments - 1]
+        local action = segments[#segments]
+        if resource ~= nil and action ~= nil then
+                print("Group:", groups)
+                print("Resource:", resource)
+                print("Action:", action)
+        end
+end
 local Inventory
 local _class_0
 local _base_0 = {
@@ -1936,6 +2335,10 @@ do
        _with_1["key-name"] = value
 end
 _with_0[#_with_0 + 1] = "abc"
+local _with_0 = obj
+if _with_0 ~= nil then
+        print(obj.name)
+end
 do
        local var = "hello"
        print(var)
@@ -2026,6 +2429,38 @@ local inventory = {
                }
        }
 }
+local map
+map = function(arr, action)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                _accum_0[_len_0] = action(item)
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+local filter
+filter = function(arr, cond)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                if cond(item) then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        end
+        return _accum_0
+end
+local reduce
+reduce = function(arr, init, action)
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                init = action(init, item)
+        end
+        return init
+end
 print(reduce(filter(map({
        1,
        2,
@@ -2083,6 +2518,12 @@ end
 print("yuescript")
 print(3)
 print("Valid enum type:", "Static")
+do
+        print(123, "hello")
+end
+do
+        print(123, "hello")
+end
 if tb ~= nil then
        tb:func()
 end
@@ -2183,6 +2624,16 @@ for _key_0, _value_0 in pairs(b) do
        end
 end
 merge = _tab_0
+local last
+do
+        local _item_0 = data.items
+        last = _item_0[#_item_0]
+end
+local second_last
+do
+        local _item_0 = data.items
+        second_last = _item_0[#_item_0 - 1]
+end
 local mt = { }
 local add
 add = function(self, right)
@@ -2313,6 +2764,14 @@ func({
        2,
        3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
        name = "abc",
        values = {
@@ -2553,6 +3012,59 @@ end
 local two, four
 local _obj_0 = items
 two, four = _obj_0[2], _obj_0[4]
+local orders = {
+        "first",
+        "second",
+        "third",
+        "fourth",
+        "last"
+}
+local first, bulk, last = orders[1], (function()
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _max_0 = #orders + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = orders[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end)(), orders[#orders]
+print(first)
+print(bulk)
+print(last)
+local first, rest
+do
+        local _obj_0 = orders
+        first, rest = _obj_0[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)()
+end
+local start, last
+do
+        local _obj_0 = orders
+        start, last = (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -2 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0]
+end
+local _obj_0 = orders
+first, last = _obj_0[1], _obj_0[#_obj_0]
 local tuples = {
        {
                "hello",
@@ -2654,6 +3166,56 @@ end)
 if success then
        print(result)
 end
+local a, b, c
+do
+        local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                return func()
+        end)
+        if _ok_0 then
+                a, b, c = _ret_0, _ret_1, _ret_2
+        end
+end
+do
+        local _exp_0 = ((function()
+                return (function(_arg_0, ...)
+                        local _ok_0 = _arg_0
+                        if _ok_0 then
+                                return ...
+                        end
+                end)(pcall(function()
+                        return func()
+                end))
+        end)())
+        if _exp_0 ~= nil then
+                a = _exp_0
+        else
+                a = "default"
+        end
+end
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(pcall(function()
+                return func()
+        end))
+end)())
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(xpcall(function()
+                print(123)
+                return func()
+        end, function(e)
+                print(e)
+                return e
+        end))
+end)())
 local a <const> = 123
 local _ <close> = setmetatable({ }, {
        __close = function()
@@ -2663,10 +3225,19 @@ local _ <close> = setmetatable({ }, {
 local a, b, c, d
 local _obj_0 = tb
 a, b, c, d = _obj_0.a, _obj_0.b, _obj_0[1], _obj_0[2]
+Constant = 123
 local some_string = "Here is a string\n  that has a line break in it."
 print("I am " .. tostring(math.random() * 100) .. "% sure.")
 local integer = 1000000
 local hex = 0xEFBBBF
+local binary = 19
+local str = "key: value\nlist:\n  - item1\n  - " .. tostring(expr)
+local fn
+fn = function()
+        local str = "foo:\n  bar: baz"
+        return str
+end
+local str = "path: \"C:\\Program Files\\App\"\nnote: 'He said: \"" .. tostring(Hello) .. "!\"'"
 local my_function
 my_function = function() end
 my_function()
@@ -2976,8 +3547,7 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-local _max_0 = 5
+for _index_0 = 1, 5 do
-for _index_0 = 1, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
@@ -2987,7 +3557,8 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 2, #_list_0 do
+local _max_0 = #_list_0
+for _index_0 = 2, _max_0 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
@@ -2997,12 +3568,46 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 1, #_list_0, 2 do
+local _max_0 = #_list_0
+for _index_0 = 1, _max_0, 2 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
 end
 slice = _accum_0
+local slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -4 + 1
+local _max_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, _max_0 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+slice = _accum_0
+local reverse_slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, 1, -1 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+reverse_slice = _accum_0
+local sub_list
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+for _index_0 = 2, 4 do
+        local _item_0 = _list_0[_index_0]
+        _accum_0[_len_0] = _item_0
+        _len_0 = _len_0 + 1
+end
+sub_list = _accum_0
 for i = 10, 20 do
        print(i)
 end
@@ -3013,8 +3618,7 @@ for key, value in pairs(object) do
        print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
+for _index_0 = 2, 4 do
-for _index_0 = 2, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
        local item = _list_0[_index_0]
        print(item)
 end
@@ -3032,12 +3636,24 @@ local _len_0 = 1
 for i = 1, 20 do
        if i % 2 == 0 then
                _accum_0[_len_0] = i * 2
+                _len_0 = _len_0 + 1
        else
                _accum_0[_len_0] = i
+                _len_0 = _len_0 + 1
        end
-        _len_0 = _len_0 + 1
 end
 doubled_evens = _accum_0
+local first_large
+local _accum_0
+local _list_0 = numbers
+for _index_0 = 1, #_list_0 do
+        local n = _list_0[_index_0]
+        if n > 10 then
+                _accum_0 = n
+                break
+        end
+end
+first_large = _accum_0
 local func_a
 func_a = function()
        for i = 1, 10 do
@@ -3186,7 +3802,7 @@ if "Robert" == name then
 elseif "Dan" == name or "Daniel" == name then
        print("Your name, it's Dan")
 else
-        print("I don't know about your name")
+        print("I don't know about you with name " .. tostring(name))
 end
 local b = 1
 local next_number
@@ -3286,6 +3902,192 @@ if _tab_0 then
        end
        print("Vec2 " .. tostring(x) .. ", " .. tostring(y))
 end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        if 1 == _exp_0[1] and 2 == _exp_0[2] and 3 == _exp_0[3] then
+                _match_0 = true
+                print("1, 2, 3")
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local b = _exp_0[2]
+                if 1 == _exp_0[1] and b ~= nil and 3 == _exp_0[3] then
+                        _match_1 = true
+                        print("1, " .. tostring(b) .. ", 3")
+                end
+        end
+        if not _match_1 then
+                if _tab_0 then
+                        local b = _exp_0[3]
+                        if b == nil then
+                                b = 3
+                        end
+                        if 1 == _exp_0[1] and 2 == _exp_0[2] then
+                                print("1, 2, " .. tostring(b))
+                        end
+                end
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local result = _exp_0.result
+        if true == _exp_0.success and result ~= nil then
+                _match_0 = true
+                print("success", result)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                if false == _exp_0.success then
+                        _match_1 = true
+                        print("failed", result)
+                end
+        end
+        if not _match_1 then
+                print("invalid")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local content
+        do
+                local _obj_0 = _exp_0.data
+                local _type_1 = type(_obj_0)
+                if "table" == _type_1 or "userdata" == _type_1 then
+                        content = _obj_0.content
+                end
+        end
+        local _val_0
+        do
+                local _obj_0 = _exp_0.data
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.type
+                end
+        end
+        if "success" == _val_0 and content ~= nil then
+                _match_0 = true
+                print("success", content)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local content
+                do
+                        local _obj_0 = _exp_0.data
+                        local _type_1 = type(_obj_0)
+                        if "table" == _type_1 or "userdata" == _type_1 then
+                                content = _obj_0.content
+                        end
+                end
+                local _val_0
+                do
+                        local _obj_0 = _exp_0.data
+                        if _obj_0 ~= nil then
+                                _val_0 = _obj_0.type
+                        end
+                end
+                if "error" == _val_0 and content ~= nil then
+                        _match_1 = true
+                        print("failed", content)
+                end
+        end
+        if not _match_1 then
+                print("invalid")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local fourth = _exp_0[4]
+        local _val_0
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.a
+                end
+        end
+        local _val_1
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_1 = _obj_0.b
+                end
+        end
+        local _val_2
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_2 = _obj_0.a
+                end
+        end
+        local _val_3
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_3 = _obj_0.b
+                end
+        end
+        local _val_4
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_4 = _obj_0.a
+                end
+        end
+        local _val_5
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_5 = _obj_0.b
+                end
+        end
+        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                print("matched", fourth)
+        end
+end
+local segments = {
+        "admin",
+        "users",
+        "logs",
+        "view"
+}
+local _type_0 = type(segments)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local groups
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #segments + -3 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = segments[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                groups = _accum_0
+        end
+        local resource = segments[#segments - 1]
+        local action = segments[#segments]
+        if resource ~= nil and action ~= nil then
+                print("Group:", groups)
+                print("Resource:", resource)
+                print("Action:", action)
+        end
+end
 local Inventory
 local _class_0
 local _base_0 = {
@@ -3942,6 +4744,10 @@ do
        _with_1["key-name"] = value
 end
 _with_0[#_with_0 + 1] = "abc"
+local _with_0 = obj
+if _with_0 ~= nil then
+        print(obj.name)
+end
 do
        local var = "hello"
        print(var)
diff --git a/spec/outputs/codes_from_doc_zh.lua b/spec/outputs/codes_from_doc_zh.lua
index acd41a0..b54d6d7 100644
--- a/spec/outputs/codes_from_doc_zh.lua
+++ b/spec/outputs/codes_from_doc_zh.lua
@@ -20,6 +20,38 @@ local inventory = {
                }
        }
 }
+local map
+map = function(arr, action)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                _accum_0[_len_0] = action(item)
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+local filter
+filter = function(arr, cond)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                if cond(item) then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        end
+        return _accum_0
+end
+local reduce
+reduce = function(arr, init, action)
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                init = action(init, item)
+        end
+        return init
+end
 print(reduce(filter(map({
        1,
        2,
@@ -77,6 +109,12 @@ end
 print("yuescript")
 print(3)
 print("有效的枚举类型:", "Static")
+do
+        print(123, "hello")
+end
+do
+        print(123, "hello")
+end
 if tb ~= nil then
        tb:func()
 end
@@ -177,6 +215,16 @@ for _key_0, _value_0 in pairs(b) do
        end
 end
 merge = _tab_0
+local last
+do
+        local _item_0 = data.items
+        last = _item_0[#_item_0]
+end
+local second_last
+do
+        local _item_0 = data.items
+        second_last = _item_0[#_item_0 - 1]
+end
 local mt = { }
 local add
 add = function(self, right)
@@ -307,6 +355,14 @@ func({
        2,
        3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
        name = "abc",
        values = {
@@ -547,6 +603,59 @@ end
 local two, four
 local _obj_0 = items
 two, four = _obj_0[2], _obj_0[4]
+local orders = {
+        "first",
+        "second",
+        "third",
+        "fourth",
+        "last"
+}
+local first, bulk, last = orders[1], (function()
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _max_0 = #orders + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = orders[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end)(), orders[#orders]
+print(first)
+print(bulk)
+print(last)
+local first, rest
+do
+        local _obj_0 = orders
+        first, rest = _obj_0[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)()
+end
+local start, last
+do
+        local _obj_0 = orders
+        start, last = (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -2 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0]
+end
+local _obj_0 = orders
+first, last = _obj_0[1], _obj_0[#_obj_0]
 local tuples = {
        {
                "hello",
@@ -648,6 +757,56 @@ end)
 if success then
        print(result)
 end
+local a, b, c
+do
+        local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                return func()
+        end)
+        if _ok_0 then
+                a, b, c = _ret_0, _ret_1, _ret_2
+        end
+end
+do
+        local _exp_0 = ((function()
+                return (function(_arg_0, ...)
+                        local _ok_0 = _arg_0
+                        if _ok_0 then
+                                return ...
+                        end
+                end)(pcall(function()
+                        return func()
+                end))
+        end)())
+        if _exp_0 ~= nil then
+                a = _exp_0
+        else
+                a = "default"
+        end
+end
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(pcall(function()
+                return func()
+        end))
+end)())
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(xpcall(function()
+                print(123)
+                return func()
+        end, function(e)
+                print(e)
+                return e
+        end))
+end)())
 local a <const> = 123
 local _ <close> = setmetatable({ }, {
        __close = function()
@@ -657,10 +816,19 @@ local _ <close> = setmetatable({ }, {
 local a, b, c, d
 local _obj_0 = tb
 a, b, c, d = _obj_0.a, _obj_0.b, _obj_0[1], _obj_0[2]
+Constant = 123
 local some_string = "这是一个字符串\n  并包括一个换行。"
 print("我有" .. tostring(math.random() * 100) .. "%的把握。")
 local integer = 1000000
 local hex = 0xEFBBBF
+local binary = 19
+local str = "key: value\nlist:\n  - item1\n  - " .. tostring(expr)
+local fn
+fn = function()
+        local str = "foo:\n  bar: baz"
+        return str
+end
+local str = "path: \"C:\\Program Files\\App\"\nnote: 'He said: \"" .. tostring(Hello) .. "!\"'"
 local my_function
 my_function = function() end
 my_function()
@@ -964,8 +1132,7 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-local _max_0 = 5
+for _index_0 = 1, 5 do
-for _index_0 = 1, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
@@ -975,7 +1142,8 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 2, #_list_0 do
+local _max_0 = #_list_0
+for _index_0 = 2, _max_0 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
@@ -985,12 +1153,46 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 1, #_list_0, 2 do
+local _max_0 = #_list_0
+for _index_0 = 1, _max_0, 2 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
 end
 slice = _accum_0
+local slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -4 + 1
+local _max_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, _max_0 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+slice = _accum_0
+local reverse_slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, 1, -1 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+reverse_slice = _accum_0
+local sub_list
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+for _index_0 = 2, 4 do
+        local _item_0 = _list_0[_index_0]
+        _accum_0[_len_0] = _item_0
+        _len_0 = _len_0 + 1
+end
+sub_list = _accum_0
 for i = 10, 20 do
        print(i)
 end
@@ -1001,8 +1203,7 @@ for key, value in pairs(object) do
        print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
+for _index_0 = 2, 4 do
-for _index_0 = 2, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
        local item = _list_0[_index_0]
        print(item)
 end
@@ -1020,12 +1221,24 @@ local _len_0 = 1
 for i = 1, 20 do
        if i % 2 == 0 then
                _accum_0[_len_0] = i * 2
+                _len_0 = _len_0 + 1
        else
                _accum_0[_len_0] = i
+                _len_0 = _len_0 + 1
        end
-        _len_0 = _len_0 + 1
 end
 doubled_evens = _accum_0
+local first_large
+local _accum_0
+local _list_0 = numbers
+for _index_0 = 1, #_list_0 do
+        local n = _list_0[_index_0]
+        if n > 10 then
+                _accum_0 = n
+                break
+        end
+end
+first_large = _accum_0
 local func_a
 func_a = function()
        for i = 1, 10 do
@@ -1174,7 +1387,7 @@ if "Robert" == name then
 elseif "Dan" == name or "Daniel" == name then
        print("你的名字是Dan")
 else
-        print("我不知道你的名字")
+        print("我不认识你，你的名字是" .. tostring(name))
 end
 local b = 1
 local next_number
@@ -1274,6 +1487,192 @@ if _tab_0 then
        end
        print("Vec2 " .. tostring(x) .. ", " .. tostring(y))
 end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        if 1 == _exp_0[1] and 2 == _exp_0[2] and 3 == _exp_0[3] then
+                _match_0 = true
+                print("1, 2, 3")
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local b = _exp_0[2]
+                if 1 == _exp_0[1] and b ~= nil and 3 == _exp_0[3] then
+                        _match_1 = true
+                        print("1, " .. tostring(b) .. ", 3")
+                end
+        end
+        if not _match_1 then
+                if _tab_0 then
+                        local b = _exp_0[3]
+                        if b == nil then
+                                b = 3
+                        end
+                        if 1 == _exp_0[1] and 2 == _exp_0[2] then
+                                print("1, 2, " .. tostring(b))
+                        end
+                end
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local result = _exp_0.result
+        if true == _exp_0.success and result ~= nil then
+                _match_0 = true
+                print("成功", result)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                if false == _exp_0.success then
+                        _match_1 = true
+                        print("失败", result)
+                end
+        end
+        if not _match_1 then
+                print("无效值")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local content
+        do
+                local _obj_0 = _exp_0.data
+                local _type_1 = type(_obj_0)
+                if "table" == _type_1 or "userdata" == _type_1 then
+                        content = _obj_0.content
+                end
+        end
+        local _val_0
+        do
+                local _obj_0 = _exp_0.data
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.type
+                end
+        end
+        if "success" == _val_0 and content ~= nil then
+                _match_0 = true
+                print("成功", content)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local content
+                do
+                        local _obj_0 = _exp_0.data
+                        local _type_1 = type(_obj_0)
+                        if "table" == _type_1 or "userdata" == _type_1 then
+                                content = _obj_0.content
+                        end
+                end
+                local _val_0
+                do
+                        local _obj_0 = _exp_0.data
+                        if _obj_0 ~= nil then
+                                _val_0 = _obj_0.type
+                        end
+                end
+                if "error" == _val_0 and content ~= nil then
+                        _match_1 = true
+                        print("失败", content)
+                end
+        end
+        if not _match_1 then
+                print("无效值")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local fourth = _exp_0[4]
+        local _val_0
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.a
+                end
+        end
+        local _val_1
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_1 = _obj_0.b
+                end
+        end
+        local _val_2
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_2 = _obj_0.a
+                end
+        end
+        local _val_3
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_3 = _obj_0.b
+                end
+        end
+        local _val_4
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_4 = _obj_0.a
+                end
+        end
+        local _val_5
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_5 = _obj_0.b
+                end
+        end
+        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                print("匹配成功", fourth)
+        end
+end
+local segments = {
+        "admin",
+        "users",
+        "logs",
+        "view"
+}
+local _type_0 = type(segments)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local groups
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #segments + -3 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = segments[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                groups = _accum_0
+        end
+        local resource = segments[#segments - 1]
+        local action = segments[#segments]
+        if resource ~= nil and action ~= nil then
+                print("Group:", groups)
+                print("Resource:", resource)
+                print("Action:", action)
+        end
+end
 local Inventory
 local _class_0
 local _base_0 = {
@@ -1930,6 +2329,10 @@ do
        _with_1["key-name"] = value
 end
 _with_0[#_with_0 + 1] = "abc"
+local _with_0 = obj
+if _with_0 ~= nil then
+        print(obj.name)
+end
 do
        local var = "hello"
        print(var)
@@ -2020,6 +2423,38 @@ local inventory = {
                }
        }
 }
+local map
+map = function(arr, action)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                _accum_0[_len_0] = action(item)
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+local filter
+filter = function(arr, cond)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                if cond(item) then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        end
+        return _accum_0
+end
+local reduce
+reduce = function(arr, init, action)
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                init = action(init, item)
+        end
+        return init
+end
 print(reduce(filter(map({
        1,
        2,
@@ -2077,6 +2512,12 @@ end
 print("yuescript")
 print(3)
 print("有效的枚举类型:", "Static")
+do
+        print(123, "hello")
+end
+do
+        print(123, "hello")
+end
 if tb ~= nil then
        tb:func()
 end
@@ -2177,6 +2618,16 @@ for _key_0, _value_0 in pairs(b) do
        end
 end
 merge = _tab_0
+local last
+do
+        local _item_0 = data.items
+        last = _item_0[#_item_0]
+end
+local second_last
+do
+        local _item_0 = data.items
+        second_last = _item_0[#_item_0 - 1]
+end
 local mt = { }
 local add
 add = function(self, right)
@@ -2307,6 +2758,14 @@ func({
        2,
        3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
        name = "abc",
        values = {
@@ -2547,6 +3006,59 @@ end
 local two, four
 local _obj_0 = items
 two, four = _obj_0[2], _obj_0[4]
+local orders = {
+        "first",
+        "second",
+        "third",
+        "fourth",
+        "last"
+}
+local first, bulk, last = orders[1], (function()
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _max_0 = #orders + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = orders[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end)(), orders[#orders]
+print(first)
+print(bulk)
+print(last)
+local first, rest
+do
+        local _obj_0 = orders
+        first, rest = _obj_0[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)()
+end
+local start, last
+do
+        local _obj_0 = orders
+        start, last = (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -2 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0]
+end
+local _obj_0 = orders
+first, last = _obj_0[1], _obj_0[#_obj_0]
 local tuples = {
        {
                "hello",
@@ -2648,6 +3160,56 @@ end)
 if success then
        print(result)
 end
+local a, b, c
+do
+        local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                return func()
+        end)
+        if _ok_0 then
+                a, b, c = _ret_0, _ret_1, _ret_2
+        end
+end
+do
+        local _exp_0 = ((function()
+                return (function(_arg_0, ...)
+                        local _ok_0 = _arg_0
+                        if _ok_0 then
+                                return ...
+                        end
+                end)(pcall(function()
+                        return func()
+                end))
+        end)())
+        if _exp_0 ~= nil then
+                a = _exp_0
+        else
+                a = "default"
+        end
+end
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(pcall(function()
+                return func()
+        end))
+end)())
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(xpcall(function()
+                print(123)
+                return func()
+        end, function(e)
+                print(e)
+                return e
+        end))
+end)())
 local a <const> = 123
 local _ <close> = setmetatable({ }, {
        __close = function()
@@ -2657,10 +3219,19 @@ local _ <close> = setmetatable({ }, {
 local a, b, c, d
 local _obj_0 = tb
 a, b, c, d = _obj_0.a, _obj_0.b, _obj_0[1], _obj_0[2]
+Constant = 123
 local some_string = "这是一个字符串\n  并包括一个换行。"
 print("我有" .. tostring(math.random() * 100) .. "%的把握。")
 local integer = 1000000
 local hex = 0xEFBBBF
+local binary = 19
+local str = "key: value\nlist:\n  - item1\n  - " .. tostring(expr)
+local fn
+fn = function()
+        local str = "foo:\n  bar: baz"
+        return str
+end
+local str = "path: \"C:\\Program Files\\App\"\nnote: 'He said: \"" .. tostring(Hello) .. "!\"'"
 local my_function
 my_function = function() end
 my_function()
@@ -2964,8 +3535,7 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-local _max_0 = 5
+for _index_0 = 1, 5 do
-for _index_0 = 1, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
@@ -2975,7 +3545,8 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 2, #_list_0 do
+local _max_0 = #_list_0
+for _index_0 = 2, _max_0 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
@@ -2985,12 +3556,46 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 1, #_list_0, 2 do
+local _max_0 = #_list_0
+for _index_0 = 1, _max_0, 2 do
        local item = _list_0[_index_0]
        _accum_0[_len_0] = item
        _len_0 = _len_0 + 1
 end
 slice = _accum_0
+local slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -4 + 1
+local _max_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, _max_0 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+slice = _accum_0
+local reverse_slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, 1, -1 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+reverse_slice = _accum_0
+local sub_list
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+for _index_0 = 2, 4 do
+        local _item_0 = _list_0[_index_0]
+        _accum_0[_len_0] = _item_0
+        _len_0 = _len_0 + 1
+end
+sub_list = _accum_0
 for i = 10, 20 do
        print(i)
 end
@@ -3001,8 +3606,7 @@ for key, value in pairs(object) do
        print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
+for _index_0 = 2, 4 do
-for _index_0 = 2, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
        local item = _list_0[_index_0]
        print(item)
 end
@@ -3020,12 +3624,24 @@ local _len_0 = 1
 for i = 1, 20 do
        if i % 2 == 0 then
                _accum_0[_len_0] = i * 2
+                _len_0 = _len_0 + 1
        else
                _accum_0[_len_0] = i
+                _len_0 = _len_0 + 1
        end
-        _len_0 = _len_0 + 1
 end
 doubled_evens = _accum_0
+local first_large
+local _accum_0
+local _list_0 = numbers
+for _index_0 = 1, #_list_0 do
+        local n = _list_0[_index_0]
+        if n > 10 then
+                _accum_0 = n
+                break
+        end
+end
+first_large = _accum_0
 local func_a
 func_a = function()
        for i = 1, 10 do
@@ -3174,7 +3790,7 @@ if "Robert" == name then
 elseif "Dan" == name or "Daniel" == name then
        print("你的名字是Dan")
 else
-        print("我不知道你的名字")
+        print("我不认识你，你的名字是" .. tostring(name))
 end
 local b = 1
 local next_number
@@ -3274,6 +3890,192 @@ if _tab_0 then
        end
        print("Vec2 " .. tostring(x) .. ", " .. tostring(y))
 end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        if 1 == _exp_0[1] and 2 == _exp_0[2] and 3 == _exp_0[3] then
+                _match_0 = true
+                print("1, 2, 3")
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local b = _exp_0[2]
+                if 1 == _exp_0[1] and b ~= nil and 3 == _exp_0[3] then
+                        _match_1 = true
+                        print("1, " .. tostring(b) .. ", 3")
+                end
+        end
+        if not _match_1 then
+                if _tab_0 then
+                        local b = _exp_0[3]
+                        if b == nil then
+                                b = 3
+                        end
+                        if 1 == _exp_0[1] and 2 == _exp_0[2] then
+                                print("1, 2, " .. tostring(b))
+                        end
+                end
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local result = _exp_0.result
+        if true == _exp_0.success and result ~= nil then
+                _match_0 = true
+                print("成功", result)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                if false == _exp_0.success then
+                        _match_1 = true
+                        print("失败", result)
+                end
+        end
+        if not _match_1 then
+                print("无效值")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local content
+        do
+                local _obj_0 = _exp_0.data
+                local _type_1 = type(_obj_0)
+                if "table" == _type_1 or "userdata" == _type_1 then
+                        content = _obj_0.content
+                end
+        end
+        local _val_0
+        do
+                local _obj_0 = _exp_0.data
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.type
+                end
+        end
+        if "success" == _val_0 and content ~= nil then
+                _match_0 = true
+                print("成功", content)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local content
+                do
+                        local _obj_0 = _exp_0.data
+                        local _type_1 = type(_obj_0)
+                        if "table" == _type_1 or "userdata" == _type_1 then
+                                content = _obj_0.content
+                        end
+                end
+                local _val_0
+                do
+                        local _obj_0 = _exp_0.data
+                        if _obj_0 ~= nil then
+                                _val_0 = _obj_0.type
+                        end
+                end
+                if "error" == _val_0 and content ~= nil then
+                        _match_1 = true
+                        print("失败", content)
+                end
+        end
+        if not _match_1 then
+                print("无效值")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local fourth = _exp_0[4]
+        local _val_0
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.a
+                end
+        end
+        local _val_1
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_1 = _obj_0.b
+                end
+        end
+        local _val_2
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_2 = _obj_0.a
+                end
+        end
+        local _val_3
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_3 = _obj_0.b
+                end
+        end
+        local _val_4
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_4 = _obj_0.a
+                end
+        end
+        local _val_5
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_5 = _obj_0.b
+                end
+        end
+        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                print("匹配成功", fourth)
+        end
+end
+local segments = {
+        "admin",
+        "users",
+        "logs",
+        "view"
+}
+local _type_0 = type(segments)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local groups
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #segments + -3 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = segments[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                groups = _accum_0
+        end
+        local resource = segments[#segments - 1]
+        local action = segments[#segments]
+        if resource ~= nil and action ~= nil then
+                print("Group:", groups)
+                print("Resource:", resource)
+                print("Action:", action)
+        end
+end
 local Inventory
 local _class_0
 local _base_0 = {
@@ -3930,6 +4732,10 @@ do
        _with_1["key-name"] = value
 end
 _with_0[#_with_0 + 1] = "abc"
+local _with_0 = obj
+if _with_0 ~= nil then
+        print(obj.name)
+end
 do
        local var = "hello"
        print(var)
diff --git a/spec/outputs/comprehension.lua b/spec/outputs/comprehension.lua
index 9a7c478..663bd44 100644
--- a/spec/outputs/comprehension.lua
+++ b/spec/outputs/comprehension.lua
@@ -243,8 +243,11 @@ end
 do
        local _accum_0 = { }
        local _len_0 = 1
+        local _min_0 = 1 + 2
        local _max_0 = 3 + 4
-        for _index_0 = 1 + 2, _max_0 < 0 and #items + _max_0 or _max_0 do
+        _min_0 = _min_0 < 0 and #items + _min_0 + 1 or _min_0
+        _max_0 = _max_0 < 0 and #items + _max_0 + 1 or _max_0
+        for _index_0 = _min_0, _max_0 do
                local item = items[_index_0]
                _accum_0[_len_0] = item
                _len_0 = _len_0 + 1
@@ -254,8 +257,11 @@ end
 do
        local _accum_0 = { }
        local _len_0 = 1
+        local _min_0 = hello() * 4
        local _max_0 = 2 - thing[4]
-        for _index_0 = hello() * 4, _max_0 < 0 and #items + _max_0 or _max_0 do
+        _min_0 = _min_0 < 0 and #items + _min_0 + 1 or _min_0
+        _max_0 = _max_0 < 0 and #items + _max_0 + 1 or _max_0
+        for _index_0 = _min_0, _max_0 do
                local item = items[_index_0]
                _accum_0[_len_0] = item
                _len_0 = _len_0 + 1
diff --git a/spec/outputs/destructure.lua b/spec/outputs/destructure.lua
index 44da58b..ba216b5 100644
--- a/spec/outputs/destructure.lua
+++ b/spec/outputs/destructure.lua
@@ -621,4 +621,94 @@ do
                print(meta_field, abc, def)
        end
 end
+do
+        local clients = {
+                "VIP_Alice",
+                "User_Bob",
+                "User_Clara",
+                "VIP_Eva"
+        }
+        local vipStart, regulars, vipEnd = clients[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #clients + -2 + 1
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = clients[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), clients[#clients]
+        print(vipStart)
+        print(regulars)
+        print(vipEnd)
+end
+do
+        local setupMeeting
+        setupMeeting = function(participants)
+                local chair, secretary = participants[1], participants[#participants]
+                return print(chair, secretary)
+        end
+        setupMeeting({
+                "Alice",
+                "Bob",
+                "Charlie",
+                "David"
+        })
+end
+do
+        local getTransactions
+        getTransactions = function()
+                return {
+                        {
+                                id = "T1",
+                                amount = 100
+                        },
+                        {
+                                id = "T2",
+                                amount = 200
+                        },
+                        {
+                                id = "T3",
+                                amount = 300
+                        }
+                }
+        end
+        local id, amount
+        do
+                local _item_0 = getTransactions()
+                local _obj_0 = _item_0[#_item_0]
+                id, amount = _obj_0.id, _obj_0.amount
+        end
+        assert(id == "T3")
+        assert(amount == 300)
+end
+do
+        local middle
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _list_0 = tb
+        local _max_0 = #_list_0 + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = _list_0[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        middle = _accum_0
+end
+do
+        local a, abc, b, def, sub, d, e
+        local _obj_0 = tb
+        a, abc, b, def, sub, d, e = _obj_0[1], _obj_0.abc, _obj_0[2], _obj_0.def, (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -3 + 1
+                for _index_0 = 3, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0 - 1], _obj_0[#_obj_0]
+end
 return nil
diff --git a/spec/outputs/global.lua b/spec/outputs/global.lua
index 54a21a9..3918f85 100644
--- a/spec/outputs/global.lua
+++ b/spec/outputs/global.lua
@@ -93,3 +93,28 @@ do
        FooBar = "pascal case"
        FOOBAR = "all uppercase"
 end
+do
+        do
+                local _class_0
+                local _base_0 = { }
+                if _base_0.__index == nil then
+                        _base_0.__index = _base_0
+                end
+                _class_0 = setmetatable({
+                        __init = function() end,
+                        __base = _base_0,
+                        __name = "A"
+                }, {
+                        __index = _base_0,
+                        __call = function(cls, ...)
+                                local _self_0 = setmetatable({ }, _base_0)
+                                cls.__init(_self_0, ...)
+                                return _self_0
+                        end
+                })
+                _base_0.__class = _class_0
+                A = _class_0
+        end
+        Flag = 1
+        const, x, y = "const", 1, 2
+end
diff --git a/spec/outputs/import.lua b/spec/outputs/import.lua
index 83c99e2..7aa130f 100644
--- a/spec/outputs/import.lua
+++ b/spec/outputs/import.lua
@@ -166,3 +166,13 @@ do
        local _obj_1 = require("m")
        g, i = _obj_1[1], getmetatable(_obj_1[2]).__close
 end
+do
+        local require <const> = require
+        local stringlib <const> = string
+        local format <const> = string.format
+        local io_read <const> = io.read
+        local type
+        type = function() end
+        local tp <const> = _G.type
+        local yue <const> = _G["月"]
+end
diff --git a/spec/outputs/lists.lua b/spec/outputs/lists.lua
index 48ec9c8..2ed7b95 100644
--- a/spec/outputs/lists.lua
+++ b/spec/outputs/lists.lua
@@ -230,31 +230,36 @@ x = {
        6,
        7
 }
-local _max_0 = -5
+local _max_0 = #x + -5 + 1
-for _index_0 = 2, _max_0 < 0 and #x + _max_0 or _max_0, 2 do
+for _index_0 = 2, _max_0, 2 do
        local y = x[_index_0]
        print(y)
 end
-local _max_1 = 3
+for _index_0 = 1, 3 do
-for _index_0 = 1, _max_1 < 0 and #x + _max_1 or _max_1 do
        local y = x[_index_0]
        print(y)
 end
-for _index_0 = 2, #x do
+local _max_1 = #x
+for _index_0 = 2, _max_1 do
        local y = x[_index_0]
        print(y)
 end
-for _index_0 = 1, #x, 2 do
+local _max_2 = #x
+for _index_0 = 1, _max_2, 2 do
        local y = x[_index_0]
        print(y)
 end
-for _index_0 = 2, #x, 2 do
+local _max_3 = #x
+for _index_0 = 2, _max_3, 2 do
        local y = x[_index_0]
        print(y)
 end
 local a, b, c = 1, 5, 2
-local _max_2 = b
+local _min_0 = a
-for _index_0 = a, _max_2 < 0 and #x + _max_2 or _max_2, c do
+local _max_4 = b
+_min_0 = _min_0 < 0 and #x + _min_0 + 1 or _min_0
+_max_4 = _max_4 < 0 and #x + _max_4 + 1 or _max_4
+for _index_0 = _min_0, _max_4, c do
        local y = x[_index_0]
        print(y)
 end
@@ -287,7 +292,10 @@ do
                a
        })
        local _list_0 = f
-        for _index_0 = a, #_list_0 do
+        local _min_1 = a
+        local _max_5 = #_list_0
+        _min_1 = _min_1 < 0 and #_list_0 + _min_1 + 1 or _min_1
+        for _index_0 = _min_1, _max_5 do
                local v = _list_0[_index_0]
                print(v)
        end
@@ -327,4 +335,191 @@ do
                job = "jobless"
        end
 end
+do
+        local transactions = {
+                "T001",
+                "T002",
+                "T003",
+                "T004",
+                "T005"
+        }
+        local middleTransactions
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_5 = #transactions + -2 + 1
+                for _index_0 = 2, _max_5 do
+                        local _item_0 = transactions[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                middleTransactions = _accum_0
+        end
+        print(middleTransactions)
+end
+do
+        local logs = {
+                {
+                        start = 0,
+                        ["end"] = 100
+                },
+                {
+                        start = 100,
+                        ["end"] = 200
+                },
+                {
+                        start = 200,
+                        ["end"] = 123
+                }
+        }
+        print(logs[#logs]["end"])
+end
+do
+        local pendingOrders = {
+                "O001",
+                "O002",
+                "O003",
+                "O004"
+        }
+        print(pendingOrders[#pendingOrders - 1])
+end
+do
+        local getOrders
+        getOrders = function()
+                return {
+                        {
+                                id = "O1001",
+                                status = "pending"
+                        },
+                        {
+                                id = "O1002",
+                                status = "processing"
+                        },
+                        {
+                                id = "O1003",
+                                status = "done"
+                        }
+                }
+        end
+        local lastStatus
+        do
+                local _item_0 = getOrders()
+                lastStatus = _item_0[#_item_0].status
+        end
+        assert(lastStatus == "done")
+end
+do
+        local cloneList1
+        cloneList1 = function(list)
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_5 = #list
+                for _index_0 = 1, _max_5 do
+                        local _item_0 = list[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end
+        local cloneList2
+        cloneList2 = function(list)
+                local _tab_0 = { }
+                local _idx_0 = #_tab_0 + 1
+                for _index_0 = 1, #list do
+                        local _value_0 = list[_index_0]
+                        _tab_0[_idx_0] = _value_0
+                        _idx_0 = _idx_0 + 1
+                end
+                return _tab_0
+        end
+        local cloneTable
+        cloneTable = function(tb)
+                local _tab_0 = { }
+                local _idx_0 = 1
+                for _key_0, _value_0 in pairs(tb) do
+                        if _idx_0 == _key_0 then
+                                _tab_0[#_tab_0 + 1] = _value_0
+                                _idx_0 = _idx_0 + 1
+                        else
+                                _tab_0[_key_0] = _value_0
+                        end
+                end
+                return _tab_0
+        end
+end
+do
+        print((function()
+                local _item_0 = globalTB
+                return _item_0[#_item_0]
+        end)(), (function()
+                local _item_0 = a.b.c
+                return _item_0[#_item_0 - 2]
+        end)(), (function()
+                if x ~= nil then
+                        local _obj_0 = x.y
+                        if _obj_0 ~= nil then
+                                local _obj_1 = _obj_0(x).z
+                                if _obj_1 ~= nil then
+                                        return _obj_1[#_obj_1 - 3]
+                                end
+                                return nil
+                        end
+                        return nil
+                end
+                return nil
+        end)())
+end
+local _anon_func_0 = function(globalTB)
+        local _item_0 = globalTB
+        local _call_0 = _item_0[#_item_0]
+        return _call_0["end"](_call_0, 123)
+end
+local _anon_func_1 = function(a)
+        local _item_0
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _list_0 = a.b.c
+                local _max_5 = #_list_0 + -5 + 1
+                for _index_0 = 5, _max_5 do
+                        local _item_1 = _list_0[_index_0]
+                        _accum_0[_len_0] = _item_1
+                        _len_0 = _len_0 + 1
+                end
+                _item_0 = _accum_0
+        end
+        return _item_0[#_item_0 - 2]
+end
+local _anon_func_2 = function(x)
+        if x ~= nil then
+                local _obj_0 = x.y
+                if _obj_0 ~= nil then
+                        local _obj_1 = _obj_0(x).z
+                        if _obj_1 ~= nil then
+                                local _obj_2 = _obj_1[#_obj_1 - 3]
+                                if _obj_2 ~= nil then
+                                        local _accum_0 = { }
+                                        local _len_0 = 1
+                                        local _max_5 = #_obj_2 + -3 + 1
+                                        for _index_0 = 1, _max_5 do
+                                                local _item_0 = _obj_2[_index_0]
+                                                _accum_0[_len_0] = _item_0
+                                                _len_0 = _len_0 + 1
+                                        end
+                                        return _accum_0
+                                end
+                                return nil
+                        end
+                        return nil
+                end
+                return nil
+        end
+        return nil
+end
+do
+        local f
+        f = function()
+                return print(_anon_func_0(globalTB), _anon_func_1(a), _anon_func_2(x))
+        end
+end
 return nil
diff --git a/spec/outputs/loops.lua b/spec/outputs/loops.lua
index 8624d49..6ab4bbb 100644
--- a/spec/outputs/loops.lua
+++ b/spec/outputs/loops.lua
@@ -60,8 +60,8 @@ do
                local y = hello[_index_0]
                if y % 2 == 0 then
                        _accum_0[_len_0] = y
+                        _len_0 = _len_0 + 1
                end
-                _len_0 = _len_0 + 1
        end
        x = _accum_0
 end
@@ -132,13 +132,11 @@ do
 end
 do
        local _accum_0 = { }
-        local _len_0 = 1
        local _list_2 = 3
        for _index_0 = 1, #_list_2 do
                local thing = _list_2[_index_0]
                y = "hello"
                break
-                _len_0 = _len_0 + 1
        end
        x = _accum_0
 end
@@ -370,3 +368,131 @@ do
                end
        until false
 end
+local _anon_func_0 = function(i, tb)
+        local _accum_0 = { }
+        local _len_0 = 1
+        while tb[i] do
+                i = i + 1
+                _accum_0[_len_0] = i - 1
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+do
+        local index
+        do
+                local _accum_0
+                for i = 1, #tb do
+                        if tb[i] then
+                                _accum_0 = i
+                                break
+                        end
+                end
+                index = _accum_0
+        end
+        f((function()
+                local _accum_0
+                for i = 1, #tb do
+                        if tb[i] then
+                                _accum_0 = i
+                                break
+                        end
+                end
+                return _accum_0
+        end)())
+        f((function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                for i = 1, #tb do
+                        if tb[i] then
+                                _accum_0[_len_0] = i
+                                _len_0 = _len_0 + 1
+                        end
+                end
+                return _accum_0
+        end)())
+        i = 1
+        local ids
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                while tb[i] do
+                        i = i + 1
+                        _accum_0[_len_0] = i - 1
+                        _len_0 = _len_0 + 1
+                end
+                ids = _accum_0
+        end
+        i = 1
+        local idx
+        do
+                local _accum_0
+                while tb[i] do
+                        i = i + 1
+                        _accum_0 = i - 1
+                        break
+                end
+                idx = _accum_0
+        end
+        local f1
+        f1 = function()
+                i = 1
+                return f(_anon_func_0(i, tb))
+        end
+        i = 1
+        f((function()
+                local _accum_0
+                while tb[i] do
+                        i = i + 1
+                        _accum_0 = i - 1
+                        break
+                end
+                return _accum_0
+        end)())
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _list_3 = items
+        for _index_0 = 1, #_list_3 do
+                local item = _list_3[_index_0]
+                local _type_0 = type(item)
+                local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                if _tab_0 then
+                        local value = item.value
+                        if "A" == item.type and value ~= nil then
+                                if value > 5 then
+                                        _accum_0[_len_0] = item
+                                        _len_0 = _len_0 + 1
+                                end
+                        end
+                end
+        end
+        list = _accum_0
+end
+do
+        repeat
+                print(1)
+        until true
+        do
+                local _accum_0
+                repeat
+                        a = func()
+                        _accum_0 = a.x
+                        break
+                until a.v
+                x = _accum_0
+        end
+        local items
+        local _accum_0 = { }
+        local _len_0 = 1
+        repeat
+                local item = getItem()
+                if not item then
+                        break
+                end
+                if item.value > 0 then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        until false
+        items = _accum_0
+end
diff --git a/spec/outputs/macro.lua b/spec/outputs/macro.lua
index 4d31574..89c6e63 100644
--- a/spec/outputs/macro.lua
+++ b/spec/outputs/macro.lua
@@ -26,6 +26,10 @@ print({
        123,
        'xyz'
 })
+print({
+        456,
+        'abc'
+})
 do
        assert(item == nil)
 end
@@ -213,6 +217,13 @@ function tb:func()
 end
 end
 print(x)
+local yue = require("yue")
+do
+local function f2(a)
+        return a + 1
+end
+x = x + f2(3)
+end
 local sel
 sel = function(a, b, c)
        if a then
@@ -317,7 +328,7 @@ print((setmetatable({
                return 998
        end
 }))
-print("current line: " .. tostring(323))
+print("current line: " .. tostring(349))
 do
        do
 -- TODO
@@ -330,10 +341,8 @@ local _1
 _1 = function()
        print(1)
        local _accum_0 = { }
-        local _len_0 = 1
        while false do
                break
-                _len_0 = _len_0 + 1
        end
        return _accum_0
 end
diff --git a/spec/outputs/props.lua b/spec/outputs/props.lua
new file mode 100644
index 0000000..2c282e0
--- /dev/null
+++ b/spec/outputs/props.lua
@@ -0,0 +1,240 @@
+local Props
+do
+        local _class_0
+        local assignReadOnly
+        local _base_0 = {
+                __index = function(self, name)
+                        local cls = getmetatable(self)
+                        do
+                                local item
+                                do
+                                        local _obj_0 = cls.__getter
+                                        if _obj_0 ~= nil then
+                                                item = _obj_0[name]
+                                        end
+                                end
+                                if item then
+                                        return item(self)
+                                else
+                                        item = rawget(cls, name)
+                                        if item then
+                                                return item
+                                        else
+                                                local c = cls
+                                                repeat
+                                                        c = getmetatable(c)
+                                                        if c then
+                                                                local _obj_0 = c.__getter
+                                                                if _obj_0 ~= nil then
+                                                                        item = _obj_0[name]
+                                                                end
+                                                                if item then
+                                                                        if cls.__getter == nil then
+                                                                                cls.__getter = { }
+                                                                        end
+                                                                        cls.__getter[name] = item
+                                                                        return item(self)
+                                                                else
+                                                                        item = rawget(c, name)
+                                                                        if item then
+                                                                                rawset(cls, name, item)
+                                                                                return item
+                                                                        end
+                                                                end
+                                                        else
+                                                                break
+                                                        end
+                                                until false
+                                        end
+                                end
+                        end
+                        return nil
+                end,
+                __newindex = function(self, name, value)
+                        local cls = getmetatable(self)
+                        local item
+                        local _obj_0 = cls.__setter
+                        if _obj_0 ~= nil then
+                                item = _obj_0[name]
+                        end
+                        if item then
+                                return item(self, value)
+                        else
+                                local c = cls
+                                repeat
+                                        c = getmetatable(c)
+                                        if c then
+                                                local _obj_1 = c.__setter
+                                                if _obj_1 ~= nil then
+                                                        item = _obj_1[name]
+                                                end
+                                                if item then
+                                                        if cls.__setter == nil then
+                                                                cls.__setter = { }
+                                                        end
+                                                        cls.__setter[name] = item
+                                                        item(self, value)
+                                                        return
+                                                end
+                                        else
+                                                break
+                                        end
+                                until false
+                                return rawset(self, name, value)
+                        end
+                end,
+                prop = function(self, name, props)
+                        local get, set = props.get, props.set
+                        if set == nil then
+                                set = assignReadOnly
+                        end
+                        do
+                                local getter = rawget(self.__base, "__getter")
+                                if getter then
+                                        getter[name] = get
+                                else
+                                        rawset(self.__base, "__getter", {
+                                                [name] = get
+                                        })
+                                end
+                        end
+                        local setter = rawget(self.__base, "__setter")
+                        if setter then
+                                setter[name] = set
+                        else
+                                return rawset(self.__base, "__setter", {
+                                        [name] = set
+                                })
+                        end
+                end
+        }
+        if _base_0.__index == nil then
+                _base_0.__index = _base_0
+        end
+        _class_0 = setmetatable({
+                __init = function() end,
+                __base = _base_0,
+                __name = "Props"
+        }, {
+                __index = _base_0,
+                __call = function(cls, ...)
+                        local _self_0 = setmetatable({ }, _base_0)
+                        cls.__init(_self_0, ...)
+                        return _self_0
+                end
+        })
+        _base_0.__class = _class_0
+        local self = _class_0;
+        assignReadOnly = function()
+                return error("assigning a readonly property")
+        end
+        Props = _class_0
+end
+local A
+do
+        local _class_0
+        local _parent_0 = Props
+        local _base_0 = { }
+        for _key_0, _val_0 in pairs(_parent_0.__base) do
+                if _base_0[_key_0] == nil and _key_0:match("^__") and not (_key_0 == "__index" and _val_0 == _parent_0.__base) then
+                        _base_0[_key_0] = _val_0
+                end
+        end
+        if _base_0.__index == nil then
+                _base_0.__index = _base_0
+        end
+        setmetatable(_base_0, _parent_0.__base)
+        _class_0 = setmetatable({
+                __init = function(self)
+                        self._x = 0
+                end,
+                __base = _base_0,
+                __name = "A",
+                __parent = _parent_0
+        }, {
+                __index = function(cls, name)
+                        local val = rawget(_base_0, name)
+                        if val == nil then
+                                local parent = rawget(cls, "__parent")
+                                if parent then
+                                        return parent[name]
+                                end
+                        else
+                                return val
+                        end
+                end,
+                __call = function(cls, ...)
+                        local _self_0 = setmetatable({ }, _base_0)
+                        cls.__init(_self_0, ...)
+                        return _self_0
+                end
+        })
+        _base_0.__class = _class_0
+        local self = _class_0;
+        self:prop('x', {
+                get = function(self)
+                        return self._x + 1000
+                end,
+                set = function(self, v)
+                        self._x = v
+                end
+        })
+        if _parent_0.__inherited then
+                _parent_0.__inherited(_parent_0, _class_0)
+        end
+        A = _class_0
+end
+local B
+do
+        local _class_0
+        local _parent_0 = A
+        local _base_0 = { }
+        for _key_0, _val_0 in pairs(_parent_0.__base) do
+                if _base_0[_key_0] == nil and _key_0:match("^__") and not (_key_0 == "__index" and _val_0 == _parent_0.__base) then
+                        _base_0[_key_0] = _val_0
+                end
+        end
+        if _base_0.__index == nil then
+                _base_0.__index = _base_0
+        end
+        setmetatable(_base_0, _parent_0.__base)
+        _class_0 = setmetatable({
+                __init = function(self, ...)
+                        return _class_0.__parent.__init(self, ...)
+                end,
+                __base = _base_0,
+                __name = "B",
+                __parent = _parent_0
+        }, {
+                __index = function(cls, name)
+                        local val = rawget(_base_0, name)
+                        if val == nil then
+                                local parent = rawget(cls, "__parent")
+                                if parent then
+                                        return parent[name]
+                                end
+                        else
+                                return val
+                        end
+                end,
+                __call = function(cls, ...)
+                        local _self_0 = setmetatable({ }, _base_0)
+                        cls.__init(_self_0, ...)
+                        return _self_0
+                end
+        })
+        _base_0.__class = _class_0
+        local self = _class_0;
+        self:prop('abc', {
+                get = function(self)
+                        return "hello"
+                end
+        })
+        if _parent_0.__inherited then
+                _parent_0.__inherited(_parent_0, _class_0)
+        end
+        B = _class_0
+end
+local b = B()
+b.x = 999
+return print(b.x, b.abc)
diff --git a/spec/outputs/string.lua b/spec/outputs/string.lua
index febea62..b536e6d 100644
--- a/spec/outputs/string.lua
+++ b/spec/outputs/string.lua
@@ -1,3 +1,4 @@
+local _module_0 = { }
 local hi = "hello"
 local hello = "what the heckyes"
 print(hi)
@@ -41,4 +42,42 @@ local _ = "hello";
 ("hello"):format().hello(1, 2, 3);
 ("hello"):format(1, 2, 3)
 something("hello"):world()
-return something(("hello"):world())
+something(("hello"):world())
+do
+        local str = "key: value"
+        str = "config:\n\tenabled: true\n\tlevel: 5"
+        str = "header: start\nfooter: end"
+        str = "name: " .. tostring(username)
+        str = "count: " .. tostring(total) .. " items"
+        str = "user: " .. tostring(name) .. "\nid: " .. tostring(id)
+        str = "path: \"C:\\\\Program Files\\\\App\"\ndesc: 'single \"quote\" test'"
+        str = "key: value   \nnext: 123   "
+        str = "list:\n  - \"one\"\n  - \"two\""
+        str = "-- comment\ncontent text\n-- comment"
+        str = tostring(1 + 2) .. '\n' .. tostring(2 + 3) .. '\n' .. tostring("a" .. "b")
+        local obj = {
+                settings = "mode: " .. tostring(mode) .. "\nflags:\n\t- " .. tostring(flag1) .. "\n\t- default"
+        }
+        local fn
+        fn = function()
+                return "Hello\nname: " .. tostring(userName)
+        end
+        str = "result:\n\tstatus: " .. tostring((function()
+                if ok then
+                        return "pass"
+                else
+                        return "fail"
+                end
+        end)()) .. "\n\tcode: " .. tostring(code)
+        local summary = "date: " .. tostring(os.date()) .. "\nvalues:\n\t-\n\t\ta: " .. tostring(aVal) .. "\n\t\tb: " .. tostring(bVal or defaultB)
+        local msg = send("Hello, " .. tostring(user) .. "!\nToday is " .. tostring(os.date("%A")) .. ".")
+        local desc
+        do
+                local prefix = "Result"
+                desc = tostring(prefix) .. ":\nvalue: " .. tostring(compute())
+        end
+        print(("1\n2\n3"))
+end
+local yaml = "version: " .. tostring(ver) .. "\nok: true"
+_module_0["yaml"] = yaml
+return _module_0
diff --git a/spec/outputs/switch.lua b/spec/outputs/switch.lua
index e4dedc9..7c1004b 100644
--- a/spec/outputs/switch.lua
+++ b/spec/outputs/switch.lua
@@ -415,4 +415,366 @@ do
                end
        end
 end
+do
+        local _exp_0 = tb
+        local _type_0 = type(_exp_0)
+        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+        local _match_0 = false
+        if _tab_0 then
+                if 1 == _exp_0[1] and 2 == _exp_0[2] and 3 == _exp_0[3] then
+                        _match_0 = true
+                        print("1, 2, 3")
+                end
+        end
+        if not _match_0 then
+                local _match_1 = false
+                if _tab_0 then
+                        local b = _exp_0[2]
+                        if 1 == _exp_0[1] and b ~= nil and 3 == _exp_0[3] then
+                                _match_1 = true
+                                print("1, " .. tostring(b) .. ", 3")
+                        end
+                end
+                if not _match_1 then
+                        if _tab_0 then
+                                local b = _exp_0[3]
+                                if b == nil then
+                                        b = 3
+                                end
+                                if 1 == _exp_0[1] and 2 == _exp_0[2] then
+                                        print("1, 2, " .. tostring(b))
+                                end
+                        end
+                end
+        end
+end
+do
+        local _exp_0 = tb
+        local _type_0 = type(_exp_0)
+        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+        local _match_0 = false
+        if _tab_0 then
+                local result = _exp_0.result
+                if true == _exp_0.success and result ~= nil then
+                        _match_0 = true
+                        print("success", result)
+                end
+        end
+        if not _match_0 then
+                local _match_1 = false
+                if _tab_0 then
+                        if false == _exp_0.success then
+                                _match_1 = true
+                                print("failed", result)
+                        end
+                end
+                if not _match_1 then
+                        print("invalid")
+                end
+        end
+end
+do
+        local _exp_0 = tb
+        local _type_0 = type(_exp_0)
+        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+        local _match_0 = false
+        if _tab_0 then
+                local content = _exp_0.content
+                if "success" == _exp_0.type and content ~= nil then
+                        _match_0 = true
+                        print("success", content)
+                end
+        end
+        if not _match_0 then
+                local _match_1 = false
+                if _tab_0 then
+                        local content = _exp_0.content
+                        if "error" == _exp_0.type and content ~= nil then
+                                _match_1 = true
+                                print("failed", content)
+                        end
+                end
+                if not _match_1 then
+                        print("invalid")
+                end
+        end
+end
+do
+        do
+                local _exp_0 = tb
+                local _type_0 = type(_exp_0)
+                local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                if _tab_0 then
+                        local fourth = _exp_0[4]
+                        local _val_0
+                        do
+                                local _obj_0 = _exp_0[1]
+                                if _obj_0 ~= nil then
+                                        _val_0 = _obj_0.a
+                                end
+                        end
+                        local _val_1
+                        do
+                                local _obj_0 = _exp_0[1]
+                                if _obj_0 ~= nil then
+                                        _val_1 = _obj_0.b
+                                end
+                        end
+                        local _val_2
+                        do
+                                local _obj_0 = _exp_0[2]
+                                if _obj_0 ~= nil then
+                                        _val_2 = _obj_0.a
+                                end
+                        end
+                        local _val_3
+                        do
+                                local _obj_0 = _exp_0[2]
+                                if _obj_0 ~= nil then
+                                        _val_3 = _obj_0.b
+                                end
+                        end
+                        local _val_4
+                        do
+                                local _obj_0 = _exp_0[3]
+                                if _obj_0 ~= nil then
+                                        _val_4 = _obj_0.a
+                                end
+                        end
+                        local _val_5
+                        do
+                                local _obj_0 = _exp_0[3]
+                                if _obj_0 ~= nil then
+                                        _val_5 = _obj_0.b
+                                end
+                        end
+                        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                                print("matched", fourth)
+                        end
+                end
+        end
+        local _exp_0 = tb
+        local _type_0 = type(_exp_0)
+        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+        local _match_0 = false
+        if _tab_0 then
+                local _val_0
+                do
+                        local _obj_0 = _exp_0[1]
+                        if _obj_0 ~= nil then
+                                _val_0 = _obj_0.c
+                        end
+                end
+                local _val_1
+                do
+                        local _obj_0 = _exp_0[1]
+                        if _obj_0 ~= nil then
+                                _val_1 = _obj_0.d
+                        end
+                end
+                local _val_2
+                do
+                        local _obj_0 = _exp_0[2]
+                        if _obj_0 ~= nil then
+                                _val_2 = _obj_0.c
+                        end
+                end
+                local _val_3
+                do
+                        local _obj_0 = _exp_0[2]
+                        if _obj_0 ~= nil then
+                                _val_3 = _obj_0.d
+                        end
+                end
+                local _val_4
+                do
+                        local _obj_0 = _exp_0[3]
+                        if _obj_0 ~= nil then
+                                _val_4 = _obj_0.c
+                        end
+                end
+                local _val_5
+                do
+                        local _obj_0 = _exp_0[3]
+                        if _obj_0 ~= nil then
+                                _val_5 = _obj_0.d
+                        end
+                end
+                if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 then
+                        _match_0 = true
+                        print("OK")
+                end
+        end
+        if not _match_0 then
+                if _tab_0 then
+                        local sixth = _exp_0[6]
+                        local _val_0
+                        do
+                                local _obj_0 = _exp_0[3]
+                                if _obj_0 ~= nil then
+                                        _val_0 = _obj_0.a
+                                end
+                        end
+                        local _val_1
+                        do
+                                local _obj_0 = _exp_0[3]
+                                if _obj_0 ~= nil then
+                                        _val_1 = _obj_0.b
+                                end
+                        end
+                        local _val_2
+                        do
+                                local _obj_0 = _exp_0[4]
+                                if _obj_0 ~= nil then
+                                        _val_2 = _obj_0.a
+                                end
+                        end
+                        local _val_3
+                        do
+                                local _obj_0 = _exp_0[4]
+                                if _obj_0 ~= nil then
+                                        _val_3 = _obj_0.b
+                                end
+                        end
+                        local _val_4
+                        do
+                                local _obj_0 = _exp_0[5]
+                                if _obj_0 ~= nil then
+                                        _val_4 = _obj_0.a
+                                end
+                        end
+                        local _val_5
+                        do
+                                local _obj_0 = _exp_0[5]
+                                if _obj_0 ~= nil then
+                                        _val_5 = _obj_0.b
+                                end
+                        end
+                        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and sixth ~= nil then
+                                print("matched", sixth)
+                        end
+                end
+        end
+end
+do
+        local v = "hello"
+        if "hello" == v then
+                print("matched hello")
+        else
+                print("not matched")
+        end
+end
+do
+        local f
+        f = function()
+                return "ok"
+        end
+        local val = f()
+        if "ok" == val then
+                print("it's ok")
+        end
+end
+do
+        local g
+        g = function()
+                return 42
+        end
+        local result = g()
+        if 1 == result or 2 == result then
+                print("small")
+        elseif 42 == result then
+                print("life universe everything")
+        else
+                print("other " .. tostring(result))
+        end
+end
+do
+        local check
+        check = function()
+                if true then
+                        return "yes"
+                else
+                        return "no"
+                end
+        end
+        local x = check()
+        if "yes" == x then
+                print("affirmative")
+        else
+                print("negative")
+        end
+end
+do
+        local t
+        t = function()
+                local tb = {
+                        a = 1
+                }
+                tb.a = 2
+                return tb
+        end
+        local data = t()
+        local _type_0 = type(data)
+        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+        local _match_0 = false
+        if _tab_0 then
+                if 2 == data.a then
+                        _match_0 = true
+                        print("matched")
+                end
+        end
+        if not _match_0 then
+                print("not matched")
+        end
+end
+do
+        local clientData = {
+                "Meta",
+                "CUST_1001",
+                "CHK123"
+        }
+        local _type_0 = type(clientData)
+        local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+        if _tab_0 then
+                local metadata
+                do
+                        local _accum_0 = { }
+                        local _len_0 = 1
+                        local _max_0 = #clientData + -3 + 1
+                        for _index_0 = 1, _max_0 do
+                                local _item_0 = clientData[_index_0]
+                                _accum_0[_len_0] = _item_0
+                                _len_0 = _len_0 + 1
+                        end
+                        metadata = _accum_0
+                end
+                local customerId = clientData[#clientData - 1]
+                local checksum = clientData[#clientData]
+                if customerId ~= nil and checksum ~= nil then
+                        print(metadata)
+                        print(customerId)
+                        print(checksum)
+                end
+        end
+end
+do
+        local handlePath
+        handlePath = function(segments)
+                local _type_0 = type(segments)
+                local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+                if _tab_0 then
+                        local resource = segments[#segments - 1]
+                        local action = segments[#segments]
+                        if resource ~= nil and action ~= nil then
+                                print("Resource:", resource)
+                                return print("Action:", action)
+                        end
+                end
+        end
+        handlePath({
+                "admin",
+                "logs",
+                "view"
+        })
+end
 return nil
diff --git a/spec/outputs/tables.lua b/spec/outputs/tables.lua
index f358811..3f851de 100644
--- a/spec/outputs/tables.lua
+++ b/spec/outputs/tables.lua
@@ -366,6 +366,28 @@ local menus = {
                }
        }
 }
+_ = {
+        boolean = {
+                true,
+                false
+        },
+        float = {
+                3.14,
+                -6.8523015e+5
+        },
+        int = {
+                123,
+                -685230
+        },
+        null = {
+                nodeName = 'node',
+                parent = nil
+        },
+        string = {
+                'Hello world',
+                "newline\nnewline2"
+        }
+}
 local tb
 do
        local _tab_0 = { }
diff --git a/spec/outputs/try_catch.lua b/spec/outputs/try_catch.lua
index efd92c6..edb2341 100644
--- a/spec/outputs/try_catch.lua
+++ b/spec/outputs/try_catch.lua
@@ -22,6 +22,44 @@ end
 local _anon_func_7 = function(a, b, c, tb)
        return tb.f(a, b, c)
 end
+local _anon_func_8 = function(_arg_0, ...)
+        local ok = _arg_0
+        return ...
+end
+local _anon_func_10 = function(_arg_0, ...)
+        local _ok_0 = _arg_0
+        if _ok_0 then
+                return ...
+        end
+end
+local _anon_func_9 = function(func, pcall)
+        return _anon_func_10(pcall(func))
+end
+local _anon_func_12 = function(_arg_0, ...)
+        local _ok_0 = _arg_0
+        if _ok_0 then
+                return ...
+        end
+end
+local _anon_func_11 = function(func, pcall)
+        return _anon_func_12(pcall(func))
+end
+local _anon_func_14 = function(_arg_0, ...)
+        local _ok_0 = _arg_0
+        if _ok_0 then
+                return ...
+        end
+end
+local _anon_func_15 = function(func, print)
+        print(123)
+        return func()
+end
+local _anon_func_13 = function(func, print, xpcall)
+        return _anon_func_14(xpcall(_anon_func_15, function(e)
+                print(e)
+                return e
+        end, func, print))
+end
 local f
 f = function()
        xpcall(function()
@@ -104,10 +142,236 @@ f = function()
        do
                x(function()
                        local tb, a, b, c
-                        f = function()
+                        local f1
+                        f1 = function()
                                return pcall(_anon_func_7, a, b, c, tb)
                        end
                end)
        end
+        do
+                local f1
+                f1 = function()
+                        do
+                                return _anon_func_8(pcall(function()
+                                        return func()
+                                end))
+                        end
+                end
+        end
+        do
+                local func
+                local a, b, c
+                local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(func)
+                if _ok_0 then
+                        a, b, c = _ret_0, _ret_1, _ret_2
+                end
+        end
+        do
+                local a, b, c
+                local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                        return func()
+                end)
+                if _ok_0 then
+                        a, b, c = _ret_0, _ret_1, _ret_2
+                end
+        end
+        do
+                local a
+                local _exp_0 = (_anon_func_9(func, pcall))
+                if _exp_0 ~= nil then
+                        a = _exp_0
+                else
+                        a = "default"
+                end
+        end
+        do
+                f(_anon_func_11(func, pcall))
+        end
+        do
+                f(_anon_func_13(func, print, xpcall))
+        end
        return nil
 end
+local _anon_func_16 = function(a, b, c, tb)
+        return tb.f(a, b, c)
+end
+local _anon_func_17 = function(_arg_0, ...)
+        local ok = _arg_0
+        return ...
+end
+do
+        xpcall(function()
+                return func(1, 2, 3)
+        end, function(err)
+                return print(err)
+        end)
+        xpcall(function()
+                return func(1, 2, 3)
+        end, function(err)
+                return print(err)
+        end)
+        pcall(function()
+                print("trying")
+                return func(1, 2, 3)
+        end)
+        do
+                local success, result = xpcall(function()
+                        return func(1, 2, 3)
+                end, function(err)
+                        return print(err)
+                end)
+                success, result = pcall(function()
+                        return func(1, 2, 3)
+                end)
+        end
+        local tb = { }
+        pcall(function()
+                return tb.func
+        end)
+        pcall(function()
+                return tb.func()
+        end)
+        pcall(function()
+                return tb.func()
+        end)
+        pcall(function()
+                return (tb.func())
+        end)
+        pcall(function()
+                return (tb:func(1, 2, 3))
+        end)
+        pcall(function()
+                return tb.func(1)
+        end)
+        pcall(function()
+                return tb.func(1)
+        end)
+        if (xpcall(function()
+                return func(1)
+        end, function(err)
+                return print(err)
+        end)) then
+                print("OK")
+        end
+        if xpcall(function()
+                return (func(1))
+        end, function(err)
+                return print(err)
+        end) then
+                print("OK")
+        end
+        do
+                do
+                        local success, result = pcall(function()
+                                return func("abc", 123)
+                        end)
+                        if success then
+                                print(result)
+                        end
+                end
+                local success, result = xpcall(function()
+                        return func("abc", 123)
+                end, function(err)
+                        return print(err)
+                end)
+                success, result = xpcall(function()
+                        return func("abc", 123)
+                end, function(err)
+                        return print(err)
+                end)
+                if success then
+                        print(result)
+                end
+        end
+        do
+                pcall(function()
+                        return func(1, 2, 3)
+                end)
+                pcall(function()
+                        return func(1, 2, 3)
+                end)
+        end
+        do
+                x(function()
+                        local tb, a, b, c
+                        local f1
+                        f1 = function()
+                                return pcall(_anon_func_16, a, b, c, tb)
+                        end
+                end)
+        end
+        do
+                local f1
+                f1 = function()
+                        do
+                                return _anon_func_17(pcall(function()
+                                        return func()
+                                end))
+                        end
+                end
+        end
+        do
+                local func
+                local a, b, c
+                local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(func)
+                if _ok_0 then
+                        a, b, c = _ret_0, _ret_1, _ret_2
+                end
+        end
+        do
+                local a, b, c
+                local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                        return func()
+                end)
+                if _ok_0 then
+                        a, b, c = _ret_0, _ret_1, _ret_2
+                end
+        end
+        do
+                local a
+                local _exp_0 = ((function()
+                        return (function(_arg_0, ...)
+                                local _ok_0 = _arg_0
+                                if _ok_0 then
+                                        return ...
+                                end
+                        end)(pcall(function()
+                                return func()
+                        end))
+                end)())
+                if _exp_0 ~= nil then
+                        a = _exp_0
+                else
+                        a = "default"
+                end
+        end
+        do
+                f((function()
+                        return (function(_arg_0, ...)
+                                local _ok_0 = _arg_0
+                                if _ok_0 then
+                                        return ...
+                                end
+                        end)(pcall(function()
+                                return func()
+                        end))
+                end)())
+        end
+        do
+                f((function()
+                        return (function(_arg_0, ...)
+                                local _ok_0 = _arg_0
+                                if _ok_0 then
+                                        return ...
+                                end
+                        end)(xpcall(function()
+                                print(123)
+                                return func()
+                        end, function(e)
+                                print(e)
+                                return e
+                        end))
+                end)())
+        end
+end
+return nil
diff --git a/spec/outputs/unicode/assign.lua b/spec/outputs/unicode/assign.lua
index d4ad56a..e00d016 100644
--- a/spec/outputs/unicode/assign.lua
+++ b/spec/outputs/unicode/assign.lua
@@ -43,10 +43,8 @@ do
        end
 end
 local _anon_func_0 = function(_u6253_u5370)
-        do
+        _u6253_u5370(123)
-                _u6253_u5370(123)
+        return { }
-                return { }
-        end
 end
 return __u65e0_u6548_u53d8_u91cf(function()
        setmetatable(a_u53d8_u91cf, _anon_func_0(_u6253_u5370))
diff --git a/spec/outputs/unicode/comprehension.lua b/spec/outputs/unicode/comprehension.lua
index 60e490f..92bce69 100644
--- a/spec/outputs/unicode/comprehension.lua
+++ b/spec/outputs/unicode/comprehension.lua
@@ -243,8 +243,11 @@ end
 do
        local _accum_0 = { }
        local _len_0 = 1
+        local _min_0 = 1 + 2
        local _max_0 = 3 + 4
-        for _index_0 = 1 + 2, _max_0 < 0 and #_u5217_u8868 + _max_0 or _max_0 do
+        _min_0 = _min_0 < 0 and #_u5217_u8868 + _min_0 + 1 or _min_0
+        _max_0 = _max_0 < 0 and #_u5217_u8868 + _max_0 + 1 or _max_0
+        for _index_0 = _min_0, _max_0 do
                local _u9879_u76ee = _u5217_u8868[_index_0]
                _accum_0[_len_0] = _u9879_u76ee
                _len_0 = _len_0 + 1
@@ -254,8 +257,11 @@ end
 do
        local _accum_0 = { }
        local _len_0 = 1
+        local _min_0 = _u4f60_u597d() * 4
        local _max_0 = 2 - _u4e1c_u897f[4]
-        for _index_0 = _u4f60_u597d() * 4, _max_0 < 0 and #_u5217_u8868 + _max_0 or _max_0 do
+        _min_0 = _min_0 < 0 and #_u5217_u8868 + _min_0 + 1 or _min_0
+        _max_0 = _max_0 < 0 and #_u5217_u8868 + _max_0 + 1 or _max_0
+        for _index_0 = _min_0, _max_0 do
                local _u9879_u76ee = _u5217_u8868[_index_0]
                _accum_0[_len_0] = _u9879_u76ee
                _len_0 = _len_0 + 1
diff --git a/spec/outputs/unicode/lists.lua b/spec/outputs/unicode/lists.lua
index aafd516..3bf6f50 100644
--- a/spec/outputs/unicode/lists.lua
+++ b/spec/outputs/unicode/lists.lua
@@ -229,31 +229,36 @@ _u53d8_u91cfx = {
        6,
        7
 }
-local _max_0 = -5
+local _max_0 = #_u53d8_u91cfx + -5 + 1
-for _index_0 = 2, _max_0 < 0 and #_u53d8_u91cfx + _max_0 or _max_0, 2 do
+for _index_0 = 2, _max_0, 2 do
        local _u53d8_u91cfy = _u53d8_u91cfx[_index_0]
        _u6253_u5370(_u53d8_u91cfy)
 end
-local _max_1 = 3
+for _index_0 = 1, 3 do
-for _index_0 = 1, _max_1 < 0 and #_u53d8_u91cfx + _max_1 or _max_1 do
        local _u53d8_u91cfy = _u53d8_u91cfx[_index_0]
        _u6253_u5370(_u53d8_u91cfy)
 end
-for _index_0 = 2, #_u53d8_u91cfx do
+local _max_1 = #_u53d8_u91cfx
+for _index_0 = 2, _max_1 do
        local _u53d8_u91cfy = _u53d8_u91cfx[_index_0]
        _u6253_u5370(_u53d8_u91cfy)
 end
-for _index_0 = 1, #_u53d8_u91cfx, 2 do
+local _max_2 = #_u53d8_u91cfx
+for _index_0 = 1, _max_2, 2 do
        local _u53d8_u91cfy = _u53d8_u91cfx[_index_0]
        _u6253_u5370(_u53d8_u91cfy)
 end
-for _index_0 = 2, #_u53d8_u91cfx, 2 do
+local _max_3 = #_u53d8_u91cfx
+for _index_0 = 2, _max_3, 2 do
        local _u53d8_u91cfy = _u53d8_u91cfx[_index_0]
        _u6253_u5370(_u53d8_u91cfy)
 end
 local _u53d8_u91cfa, _u53d8_u91cfb, _u53d8_u91cfc = 1, 5, 2
-local _max_2 = _u53d8_u91cfb
+local _min_0 = _u53d8_u91cfa
-for _index_0 = _u53d8_u91cfa, _max_2 < 0 and #_u53d8_u91cfx + _max_2 or _max_2, _u53d8_u91cfc do
+local _max_4 = _u53d8_u91cfb
+_min_0 = _min_0 < 0 and #_u53d8_u91cfx + _min_0 + 1 or _min_0
+_max_4 = _max_4 < 0 and #_u53d8_u91cfx + _max_4 + 1 or _max_4
+for _index_0 = _min_0, _max_4, _u53d8_u91cfc do
        local _u53d8_u91cfy = _u53d8_u91cfx[_index_0]
        _u6253_u5370(_u53d8_u91cfy)
 end
diff --git a/spec/outputs/unicode/loops.lua b/spec/outputs/unicode/loops.lua
index 8379993..27bbe2e 100644
--- a/spec/outputs/unicode/loops.lua
+++ b/spec/outputs/unicode/loops.lua
@@ -60,8 +60,8 @@ do
                local _u53d8_u91cfy = _u4f60_u597d[_index_0]
                if _u53d8_u91cfy % 2 == 0 then
                        _accum_0[_len_0] = _u53d8_u91cfy
+                        _len_0 = _len_0 + 1
                end
-                _len_0 = _len_0 + 1
        end
        _u53d8_u91cfx = _accum_0
 end
@@ -132,13 +132,11 @@ do
 end
 do
        local _accum_0 = { }
-        local _len_0 = 1
        local _list_2 = 3
        for _index_0 = 1, #_list_2 do
                local _u4e1c_u897f = _list_2[_index_0]
                _u53d8_u91cfy = "你好"
                break
-                _len_0 = _len_0 + 1
        end
        _u53d8_u91cfx = _accum_0
 end
diff --git a/spec/outputs/unicode/macro.lua b/spec/outputs/unicode/macro.lua
index b14f571..b4e78cd 100644
--- a/spec/outputs/unicode/macro.lua
+++ b/spec/outputs/unicode/macro.lua
@@ -216,17 +216,15 @@ do
 end
 local _ = require('下划线')
 local _anon_func_0 = function(_)
-        do
+        local _call_0 = (_({
-                local _call_0 = (_({
+                1,
-                        1,
+                2,
-                        2,
+                3,
-                        3,
+                4,
-                        4,
+                -2,
-                        -2,
+                3
-                        3
+        }))
-                }))
+        return _call_0["链"](_call_0)
-                return _call_0["链"](_call_0)
-        end
 end
 local _call_0 = ((function()
        local _call_0 = ((function()
@@ -241,17 +239,15 @@ local _call_0 = ((function()
 end)())
 local _u7ed3_u679ca = _call_0["取值"](_call_0)
 local _anon_func_1 = function(_)
-        do
+        local _call_1 = (_({
-                local _call_1 = (_({
+                1,
-                        1,
+                2,
-                        2,
+                3,
-                        3,
+                4,
-                        4,
+                -2,
-                        -2,
+                3
-                        3
+        }))
-                }))
+        return _call_1["链"](_call_1)
-                return _call_1["链"](_call_1)
-        end
 end
 do
        local _call_1 = ((function()
@@ -270,10 +266,8 @@ do
        end)
 end
 local _anon_func_2 = function(_u539f_u70b9)
-        do
+        local _call_1 = _u539f_u70b9["变换"]["根节点"]["游戏对象"]
-                local _call_1 = _u539f_u70b9["变换"]["根节点"]["游戏对象"]
+        return _call_1["父节点"](_call_1)
-                return _call_1["父节点"](_call_1)
-        end
 end
 local _call_1 = ((function()
        local _call_1 = ((function()
@@ -365,10 +359,8 @@ local _1
 _1 = function()
        _u6253_u5370(1)
        local _accum_0 = { }
-        local _len_0 = 1
        while false do
                break
-                _len_0 = _len_0 + 1
        end
        return _accum_0
 end
diff --git a/spec/outputs/unicode/multiline_chain.lua b/spec/outputs/unicode/multiline_chain.lua
index c1da13f..61e7057 100644
--- a/spec/outputs/unicode/multiline_chain.lua
+++ b/spec/outputs/unicode/multiline_chain.lua
@@ -59,10 +59,8 @@ _u51fd_u6570 = function()
        return _accum_0
 end
 local _anon_func_0 = function(_u53d8_u91cfa)
-        do
+        local _call_1 = _u53d8_u91cfa
-                local _call_1 = _u53d8_u91cfa
+        return (_call_1["变量b"](_call_1, 123))["变量c"]("abc")
-                return (_call_1["变量b"](_call_1, 123))["变量c"]("abc")
-        end
 end
 local _u51fd_u65701
 _u51fd_u65701 = function()
diff --git a/spec/outputs/unicode/syntax.lua b/spec/outputs/unicode/syntax.lua
index 1984f40..a13302b 100644
--- a/spec/outputs/unicode/syntax.lua
+++ b/spec/outputs/unicode/syntax.lua
@@ -286,10 +286,8 @@ _ = 5 - _u4ec0_u4e48(_u65e0_u804a)
 _u4ec0_u4e48(_u65e0_u804a - 5)
 _u53d8_u91cfx = _u4f60_u597d - _u4e16_u754c - _u67d0_u7269
 local _anon_func_0 = function(_u4ec0_u4e48)
-        do
+        local _call_8 = _u4ec0_u4e48
-                local _call_8 = _u4ec0_u4e48
+        return _call_8["酷"](_call_8, 100)
-                return _call_8["酷"](_call_8, 100)
-        end
 end
 (function(_u67d0_u7269)
        if _u67d0_u7269 == nil then
diff --git a/spec/outputs/unicode/vararg.lua b/spec/outputs/unicode/vararg.lua
index b837006..fc894ff 100644
--- a/spec/outputs/unicode/vararg.lua
+++ b/spec/outputs/unicode/vararg.lua
@@ -125,14 +125,10 @@ local _anon_func_11 = function(_u9879_u76ee, ...)
        return _tbl_0
 end
 local _anon_func_12 = function(_u51fd_u6570)
-        do
+        return _u51fd_u6570()
-                return _u51fd_u6570()
-        end
 end
 local _anon_func_13 = function(_u51fd_u6570, ...)
-        do
+        return _u51fd_u6570(...)
-                return _u51fd_u6570(...)
-        end
 end
 local _anon_func_14 = function(_u51fd_u6570)
        local _accum_0 = { }
@@ -195,15 +191,11 @@ local _anon_func_23 = function(_u51fd_u6570, ...)
        return nil
 end
 local _anon_func_24 = function(_u6253_u5370, select, ...)
-        do
+        _u6253_u5370(select("#", ...))
-                _u6253_u5370(select("#", ...))
+        return _u6253_u5370(...)
-                return _u6253_u5370(...)
-        end
 end
 local _anon_func_25 = function(_u6253_u5370, ...)
-        do
+        return _u6253_u5370(...)
-                return _u6253_u5370(...)
-        end
 end
 local _anon_func_26 = function(_u53d8_u91cfx, _u8868, _u88682)
        if 1 == _u53d8_u91cfx then
@@ -214,9 +206,7 @@ local _anon_func_26 = function(_u53d8_u91cfx, _u8868, _u88682)
        end
 end
 local _anon_func_27 = function(_u6253_u5370, ...)
-        do
+        return _u6253_u5370(...)
-                return _u6253_u5370(...)
-        end
 end
 local _anon_func_28 = function(_u6761_u4ef6)
        if _u6761_u4ef6 then
@@ -224,10 +214,8 @@ local _anon_func_28 = function(_u6761_u4ef6)
        end
 end
 local _anon_func_29 = function(_u6253_u5370, _arg_0, ...)
-        do
+        local _u8868 = _arg_0
-                local _u8868 = _arg_0
+        return _u6253_u5370(...)
-                return _u6253_u5370(...)
-        end
 end
 local _u8fde_u63a5
 _u8fde_u63a5 = function(...)
diff --git a/spec/outputs/upvalue_func.lua b/spec/outputs/upvalue_func.lua
index 3181adf..3e088be 100644
--- a/spec/outputs/upvalue_func.lua
+++ b/spec/outputs/upvalue_func.lua
@@ -214,10 +214,8 @@ local _anon_func_1 = function(valueB)
        end
 end
 local _anon_func_2 = function(print, select, _arg_0, ...)
-        do
+        local ok = _arg_0
-                local ok = _arg_0
+        return print(select(3, ...))
-                return print(select(3, ...))
-        end
 end
 local _anon_func_3 = function(tb)
        if tb ~= nil then
@@ -242,11 +240,9 @@ local _anon_func_5 = function(getmetatable, tb)
        return _obj_0[1 + 1](_obj_0, "abc")
 end
 local _anon_func_6 = function(tb)
-        do
+        local _call_0 = tb
-                local _call_0 = tb
+        local _call_1 = _call_0["end"](_call_0)
-                local _call_1 = _call_0["end"](_call_0)
+        return _call_1["🤣"](_call_1, 123)
-                return _call_1["🤣"](_call_1, 123)
-        end
 end
 local _anon_func_7 = function(itemA, listA)
        for _index_0 = 1, #listA do
@@ -354,17 +350,13 @@ local _anon_func_16 = function(pairs, tb, tostring)
        return _tbl_0
 end
 local _anon_func_17 = function(print)
-        do
+        print(123)
-                print(123)
+        return "abc"
-                return "abc"
-        end
 end
 local _anon_func_18 = function(print, select, _arg_0, ...)
-        do
+        local success = _arg_0
-                local success = _arg_0
+        if success then
-                if success then
+                return print(select('#', ...))
-                        return print(select('#', ...))
-                end
        end
 end
 local _anon_func_19 = function(cond, i)
@@ -459,11 +451,9 @@ local _anon_func_25 = function(itemA, listA)
        return false
 end
 local _anon_func_24 = function(itemA, listA, tb)
-        do
+        local _call_0 = tb
-                local _call_0 = tb
+        local _call_1 = _call_0["end"](_call_0)
-                local _call_1 = _call_0["end"](_call_0)
+        return _call_1["🤣"](_call_1, 123 and (#listA > 0 and _anon_func_25(itemA, listA)))
-                return _call_1["🤣"](_call_1, 123 and (#listA > 0 and _anon_func_25(itemA, listA)))
-        end
 end
 GameEngine:onEvent("SomeEvent", function()
        return func(value + (_anon_func_21(cond)) + (_anon_func_22(valueB)) > _anon_func_23(tb) + _anon_func_24(itemA, listA, tb))
@@ -503,13 +493,11 @@ local _anon_func_27 = function(char)
        return nil
 end
 local _anon_func_28 = function(os, _arg_0, ...)
-        do
+        local ok = _arg_0
-                local ok = _arg_0
+        if ok then
-                if ok then
+                return ...
-                        return ...
+        else
-                else
+                return os.exit(1)
-                        return os.exit(1)
-                end
        end
 end
 local _anon_func_29 = function(debug_env_after, debug_env_before, env, func)
diff --git a/spec/outputs/vararg.lua b/spec/outputs/vararg.lua
index dabba44..254aa6a 100644
--- a/spec/outputs/vararg.lua
+++ b/spec/outputs/vararg.lua
@@ -125,14 +125,10 @@ local _anon_func_11 = function(items, ...)
        return _tbl_0
 end
 local _anon_func_12 = function(func)
-        do
+        return func()
-                return func()
-        end
 end
 local _anon_func_13 = function(func, ...)
-        do
+        return func(...)
-                return func(...)
-        end
 end
 local _anon_func_14 = function(func)
        local _accum_0 = { }
@@ -195,15 +191,11 @@ local _anon_func_23 = function(func, ...)
        return nil
 end
 local _anon_func_24 = function(print, select, ...)
-        do
+        print(select("#", ...))
-                print(select("#", ...))
+        return print(...)
-                return print(...)
-        end
 end
 local _anon_func_25 = function(print, ...)
-        do
+        return print(...)
-                return print(...)
-        end
 end
 local _anon_func_26 = function(tb, tb2, x)
        if 1 == x then
@@ -214,9 +206,7 @@ local _anon_func_26 = function(tb, tb2, x)
        end
 end
 local _anon_func_27 = function(print, ...)
-        do
+        return print(...)
-                return print(...)
-        end
 end
 local _anon_func_28 = function(cond)
        if cond then
@@ -224,10 +214,8 @@ local _anon_func_28 = function(cond)
        end
 end
 local _anon_func_29 = function(print, _arg_0, ...)
-        do
+        local tb = _arg_0
-                local tb = _arg_0
+        return print(...)
-                return print(...)
-        end
 end
 local join
 join = function(...)
diff --git a/spec/outputs/with.lua b/spec/outputs/with.lua
index 1a795c1..530915e 100644
--- a/spec/outputs/with.lua
+++ b/spec/outputs/with.lua
@@ -187,4 +187,66 @@ do
                return _with_0[123]
        end
 end
+do
+        f((function()
+                local _with_0 = item
+                do
+                        local _accum_0
+                        repeat
+                                if _with_0.id > 0 then
+                                        _accum_0 = _with_0.content
+                                        break
+                                end
+                        until true
+                        _with_0 = _accum_0
+                end
+                return _with_0
+        end)())
+        local a
+        do
+                local _with_0 = tb
+                do
+                        local _accum_0
+                        repeat
+                                if _with_0.v then
+                                        _accum_0 = _with_0.a
+                                        break
+                                end
+                        until true
+                        _with_0 = _accum_0
+                end
+                a = _with_0
+        end
+        local _accum_0
+        while true do
+                local _with_0 = tb
+                local _accum_1
+                repeat
+                        if _with_0 ~= nil then
+                                _accum_1 = 1
+                                break
+                        end
+                until true
+                _with_0 = _accum_1
+                _accum_0 = _with_0
+                break
+        end
+        a = _accum_0
+end
+do
+        local a
+        local _accum_0
+        for i = 1, 100 do
+                local x = tb[i]
+                if x ~= nil then
+                        local _des_0 = 1
+                        if _des_0 then
+                                x.id = _des_0
+                                _accum_0 = x
+                                break
+                        end
+                end
+        end
+        a = _accum_0
+end
 return nil
diff --git a/src/3rdParty/efsw/FileWatcherGeneric.cpp b/src/3rdParty/efsw/FileWatcherGeneric.cpp
index 3f3c52e..468d27c 100644
--- a/src/3rdParty/efsw/FileWatcherGeneric.cpp
+++ b/src/3rdParty/efsw/FileWatcherGeneric.cpp
@@ -25,7 +25,7 @@ FileWatcherGeneric::~FileWatcherGeneric() {
 }
 WatchID FileWatcherGeneric::addWatch( const std::string& directory, FileWatchListener* watcher,
-                                                                          bool recursive, const std::vector<WatcherOption>& options ) {
+                                                                          bool recursive, const std::vector<WatcherOption>& /*options*/ ) {
        std::string dir( directory );
        FileSystem::dirAddSlashAtEnd( dir );
diff --git a/src/yuescript/yue_ast.cpp b/src/yuescript/yue_ast.cpp
index fe6e726..945e1d7 100644
--- a/src/yuescript/yue_ast.cpp
+++ b/src/yuescript/yue_ast.cpp
@@ -167,12 +167,11 @@ std::string ExistentialOp_t::to_string(void*) const {
 std::string TableAppendingOp_t::to_string(void*) const {
        return "[]"s;
 }
-std::string PlainItem_t::to_string(void *) const {
+std::string PlainItem_t::to_string(void*) const {
        return {};
 }
-std::string GlobalOp_t::to_string(void* ud) const {
+std::string GlobalOp_t::to_string(void*) const {
-        auto info = reinterpret_cast<YueFormat*>(ud);
+        return "*"s;
-        return info->convert(this);
 }
 std::string ExportDefault_t::to_string(void*) const {
        return "default"s;
@@ -188,9 +187,17 @@ std::string ConstValue_t::to_string(void* ud) const {
 std::string NotIn_t::to_string(void*) const {
        return {};
 }
+std::string Break_t::to_string(void*) const {
+        return "break"s;
+}
+std::string Continue_t::to_string(void*) const {
+        return "continue"s;
+}
 std::string BreakLoop_t::to_string(void* ud) const {
-        auto info = reinterpret_cast<YueFormat*>(ud);
+        if (value) {
-        return info->convert(this);
+                return type->to_string(ud) + ' ' + value->to_string(ud);
+        }
+        return type->to_string(ud);
 }
 std::string YueLineComment_t::to_string(void* ud) const {
        auto info = reinterpret_cast<YueFormat*>(ud);
@@ -297,6 +304,17 @@ std::string ImportAs_t::to_string(void* ud) const {
        }
        return join(temp, " "s);
 }
+std::string ImportGlobal_t::to_string(void* ud) const {
+        str_list temp;
+        for (auto seg : segs.objects()) {
+                temp.emplace_back(seg->to_string(ud));
+        }
+        auto item = join(temp, "."s);
+        if (target) {
+                return item + " as "s + target->to_string(ud);
+        }
+        return item;
+}
 std::string Import_t::to_string(void* ud) const {
        if (ast_is<FromImport_t>(content)) {
                return content->to_string(ud);
@@ -324,6 +342,12 @@ std::string Backcall_t::to_string(void* ud) const {
        temp.emplace_back(value->to_string(ud));
        return join(temp, " "sv);
 }
+std::string SubBackcall_t::to_string(void* ud) const {
+        str_list temp;
+        temp.emplace_back(arrow->to_string(ud));
+        temp.emplace_back(value->to_string(ud));
+        return join(temp, " "sv);
+}
 std::string PipeBody_t::to_string(void* ud) const {
        auto info = reinterpret_cast<YueFormat*>(ud);
        str_list temp;
@@ -359,8 +383,8 @@ std::string With_t::to_string(void* ud) const {
        str_list temp{
                eop ? "with?"s : "with"s,
                valueList->to_string(ud)};
-        if (assigns) {
+        if (assign) {
-                temp.push_back(assigns->to_string(ud));
+                temp.push_back(':' + assign->to_string(ud));
        }
        if (body.is<Statement_t>()) {
                return join(temp, " "sv) + " do "s + body->to_string(ud);
@@ -406,6 +430,9 @@ std::string SwitchCase_t::to_string(void* ud) const {
 std::string Switch_t::to_string(void* ud) const {
        auto info = reinterpret_cast<YueFormat*>(ud);
        str_list temp{"switch "s + target->to_string(ud)};
+        if (assignment) {
+                temp.back().append(assignment->to_string(ud));
+        }
        info->pushScope();
        for (auto branch : branches.objects()) {
                temp.emplace_back(info->ind() + branch->to_string(ud));
@@ -449,41 +476,75 @@ std::string If_t::to_string(void* ud) const {
                temp.back() += " then"s;
        }
        ++it;
-        bool condition = true;
+        enum class NType {
+                Cond,
+                Stat,
+                Block
+        };
+        NType lastType = NType::Cond;
        for (; it != nodes.objects().end(); ++it) {
                auto node = *it;
                switch (node->get_id()) {
                        case id<IfCond_t>():
                                temp.emplace_back(info->ind() + "elseif "s + node->to_string(ud));
-                                condition = true;
+                                lastType = NType::Cond;
                                break;
                        case id<Statement_t>(): {
-                                if (condition) {
+                                switch (lastType) {
-                                        temp.back() += " then "s + node->to_string(ud);
+                                        case NType::Cond:
-                                } else {
+                                                temp.back() += " then "s + node->to_string(ud);
-                                        temp.emplace_back(info->ind() + "else "s + node->to_string(ud));
+                                                break;
+                                        case NType::Stat:
+                                                if (temp.back().back() == '\n') {
+                                                        temp.emplace_back(info->ind() + "else "s + node->to_string(ud));
+                                                } else {
+                                                        temp.back() += " else "s + node->to_string(ud);
+                                                }
+                                                break;
+                                        case NType::Block:
+                                                temp.emplace_back(info->ind() + "else "s + node->to_string(ud));
+                                                break;
                                }
-                                condition = false;
+                                lastType = NType::Stat;
                                break;
                        }
                        case id<Block_t>(): {
-                                if (condition) {
+                                switch (lastType) {
-                                        info->pushScope();
+                                        case NType::Cond: {
-                                        temp.emplace_back(node->to_string(ud));
+                                                info->pushScope();
-                                        if (temp.back().empty()) {
+                                                temp.emplace_back(node->to_string(ud));
-                                                temp.back() = info->ind() + "--"s;
+                                                if (temp.back().empty()) {
+                                                        temp.back() = info->ind() + "--"s;
+                                                }
+                                                info->popScope();
+                                                break;
+                                        }
+                                        case NType::Stat: {
+                                                if (temp.back().back() == '\n') {
+                                                        temp.emplace_back(info->ind() + "else"s);
+                                                } else {
+                                                        temp.back() += " else"s;
+                                                }
+                                                info->pushScope();
+                                                temp.emplace_back(node->to_string(ud));
+                                                if (temp.back().empty()) {
+                                                        temp.back() = info->ind() + "--"s;
+                                                }
+                                                info->popScope();
+                                                break;
                                        }
-                                        info->popScope();
+                                        case NType::Block: {
-                                } else {
+                                                temp.emplace_back(info->ind() + "else"s);
-                                        temp.emplace_back(info->ind() + "else"s);
+                                                info->pushScope();
-                                        info->pushScope();
+                                                temp.emplace_back(node->to_string(ud));
-                                        temp.emplace_back(node->to_string(ud));
+                                                if (temp.back().empty()) {
-                                        if (temp.back().empty()) {
+                                                        temp.back() = info->ind() + "--"s;
-                                                temp.back() = info->ind() + "--"s;
+                                                }
+                                                info->popScope();
+                                                break;
                                        }
-                                        info->popScope();
                                }
-                                condition = false;
+                                lastType = NType::Block;
                                break;
                        }
                }
@@ -511,10 +572,10 @@ std::string While_t::to_string(void* ud) const {
 }
 std::string Repeat_t::to_string(void* ud) const {
        auto info = reinterpret_cast<YueFormat*>(ud);
-        str_list temp;
+        if (body.is<Statement_t>()) {
-        if (body->content.is<Statement_t>()) {
+                return "repeat "s + body->to_string(ud) + " until "s + condition->to_string(ud);
-                temp.emplace_back("repeat "s + body->to_string(ud));
        } else {
+                str_list temp;
                temp.emplace_back("repeat"s);
                info->pushScope();
                temp.emplace_back(body->to_string(ud));
@@ -522,9 +583,9 @@ std::string Repeat_t::to_string(void* ud) const {
                        temp.back() = info->ind() + "--"s;
                }
                info->popScope();
+                temp.emplace_back(info->ind() + "until "s + condition->to_string(ud));
+                return join(temp, "\n"sv);
        }
-        temp.emplace_back(info->ind() + "until "s + condition->to_string(ud));
-        return join(temp, "\n"sv);
 }
 std::string ForStepValue_t::to_string(void* ud) const {
        return value->to_string(ud);
@@ -596,10 +657,13 @@ std::string CatchBlock_t::to_string(void* ud) const {
 std::string Try_t::to_string(void* ud) const {
        auto info = reinterpret_cast<YueFormat*>(ud);
        str_list temp;
+        temp.emplace_back("try"s);
+        if (eop) {
+                temp.back() += eop->to_string(ud);
+        }
        if (func.is<Exp_t>()) {
-                temp.emplace_back("try "s + func->to_string(ud));
+                temp.back() += (" "s + func->to_string(ud));
        } else {
-                temp.emplace_back("try"s);
                info->pushScope();
                temp.emplace_back(func->to_string(ud));
                if (temp.back().empty()) {
@@ -851,6 +915,12 @@ std::string Exp_t::to_string(void* ud) const {
        }
        return join(temp, " "sv);
 }
+std::string ReversedIndex_t::to_string(void* ud) const {
+        if (modifier) {
+                return "[# - "s + modifier->to_string(ud) + ']';
+        }
+        return "[#]"s;
+}
 std::string Callable_t::to_string(void* ud) const {
        return item->to_string(ud);
 }
@@ -937,6 +1007,51 @@ std::string DoubleString_t::to_string(void* ud) const {
        }
        return '"' + join(temp) + '"';
 }
+std::string YAMLIndent_t::to_string(void* ud) const {
+        auto info = reinterpret_cast<YueFormat*>(ud);
+        return info->convert(this);
+}
+std::string YAMLLineInner_t::to_string(void* ud) const {
+        auto info = reinterpret_cast<YueFormat*>(ud);
+        return info->convert(this);
+}
+std::string YAMLLineContent_t::to_string(void* ud) const {
+        if (content.is<Exp_t>()) {
+                return "#{"s + content->to_string(ud) + '}';
+        }
+        return content->to_string(ud);
+}
+std::string YAMLLine_t::to_string(void* ud) const {
+        str_list temp;
+        for (auto seg : segments.objects()) {
+                temp.emplace_back(seg->to_string(ud));
+        }
+        return join(temp);
+}
+std::string YAMLMultiline_t::to_string(void* ud) const {
+        auto info = reinterpret_cast<YueFormat*>(ud);
+        int currentIndent = info->indent;
+        str_list temp;
+        int lastIndent = -1;
+        for (auto line_ : lines.objects()) {
+                auto line = static_cast<YAMLLine_t*>(line_);
+                auto indent = line->indent->to_string(ud);
+                int ind = 0;
+                for (auto c : indent) {
+                        if (c == ' ') ind++;
+                        if (c == '\t') ind += 4;
+                }
+                if (lastIndent < ind) {
+                        info->pushScope();
+                } else if (lastIndent > ind) {
+                        info->popScope();
+                }
+                lastIndent = ind;
+                temp.emplace_back(indent + line->to_string(ud));
+        }
+        info->indent = currentIndent;
+        return "|\n" + join(temp, "\n"sv) + '\n';
+}
 std::string String_t::to_string(void* ud) const {
        return str->to_string(ud);
 }
@@ -1125,7 +1240,7 @@ std::string ClassDecl_t::to_string(void* ud) const {
        return line;
 }
 std::string GlobalValues_t::to_string(void* ud) const {
-        auto line = nameList->to_string(ud);
+        std::string line = nameList->to_string(ud);
        if (valueList) {
                if (valueList.is<TableBlock_t>()) {
                        line += " =\n"s + valueList->to_string(ud);
@@ -1136,7 +1251,7 @@ std::string GlobalValues_t::to_string(void* ud) const {
        return line;
 }
 std::string Global_t::to_string(void* ud) const {
-        return "global "s + item->to_string(ud);
+        return "global "s + (constAttrib ? "const "s : ""s) + item->to_string(ud);
 }
 std::string Export_t::to_string(void* ud) const {
        auto line = "export"s;
@@ -1235,6 +1350,9 @@ std::string FnArgDef_t::to_string(void* ud) const {
        if (op) {
                line += op->to_string(ud);
        }
+        if (label) {
+                line += '`' + label->to_string(ud);
+        }
        if (defaultValue) {
                line += " = "s + defaultValue->to_string(ud);
        }
@@ -1257,6 +1375,9 @@ std::string FnArgDefList_t::to_string(void* ud) const {
                }
                if (varArg) {
                        temp.emplace_back(info->ind() + varArg->to_string(ud));
+                        if (label) {
+                                temp.back().append('`' + label->to_string(ud));
+                        }
                }
                return join(temp, "\n"sv);
        } else {
@@ -1265,6 +1386,9 @@ std::string FnArgDefList_t::to_string(void* ud) const {
                }
                if (varArg) {
                        temp.emplace_back(varArg->to_string(ud));
+                        if (label) {
+                                temp.back().append('`' + label->to_string(ud));
+                        }
                }
                return join(temp, ", "sv);
        }
@@ -1546,3 +1670,4 @@ std::string File_t::to_string(void* ud) const {
 } // namespace yue
 } // namespace parserlib
diff --git a/src/yuescript/yue_ast.h b/src/yuescript/yue_ast.h
index 5e70645..1937eb8 100644
--- a/src/yuescript/yue_ast.h
+++ b/src/yuescript/yue_ast.h
@@ -233,8 +233,15 @@ AST_NODE(ImportAs)
        AST_MEMBER(ImportAs, &literal, &target)
 AST_END(ImportAs)
+AST_NODE(ImportGlobal)
+        ast_ptr<true, Seperator_t> sep;
+        ast_list<true, UnicodeName_t> segs;
+        ast_ptr<false, Variable_t> target;
+        AST_MEMBER(ImportGlobal, &sep, &segs, &target)
+AST_END(ImportGlobal)
 AST_NODE(Import)
-        ast_sel<true, ImportAs_t, ImportFrom_t, FromImport_t> content;
+        ast_sel<true, ImportAs_t, ImportFrom_t, FromImport_t, ImportGlobal_t> content;
        AST_MEMBER(Import, &content)
 AST_END(Import)
@@ -273,6 +280,8 @@ AST_NODE(ExpList)
        ast_ptr<true, Seperator_t> sep;
        ast_list<true, Exp_t> exprs;
        AST_MEMBER(ExpList, &sep, &exprs)
+        bool followStmtProcessed = false;
+        Statement_t* followStmt = nullptr;
 AST_END(ExpList)
 AST_NODE(Return)
@@ -285,9 +294,9 @@ AST_END(Return)
 AST_NODE(With)
        ast_ptr<false, ExistentialOp_t> eop;
        ast_ptr<true, ExpList_t> valueList;
-        ast_ptr<false, Assign_t> assigns;
+        ast_ptr<false, Assign_t> assign;
        ast_sel<true, Block_t, Statement_t> body;
-        AST_MEMBER(With, &eop, &valueList, &assigns, &body)
+        AST_MEMBER(With, &eop, &valueList, &assign, &body)
 AST_END(With)
 AST_NODE(SwitchList)
@@ -302,20 +311,21 @@ AST_NODE(SwitchCase)
        AST_MEMBER(SwitchCase, &condition, &body)
 AST_END(SwitchCase)
+AST_NODE(Assignment)
+        ast_ptr<false, ExpList_t> expList;
+        ast_ptr<true, Assign_t> assign;
+        AST_MEMBER(Assignment, &expList, &assign)
+AST_END(Assignment)
 AST_NODE(Switch)
        ast_ptr<true, Exp_t> target;
+        ast_ptr<false, Assignment_t> assignment;
        ast_ptr<true, Seperator_t> sep;
        ast_list<true, SwitchCase_t> branches;
        ast_sel<false, Block_t, Statement_t> lastBranch;
-        AST_MEMBER(Switch, &target, &sep, &branches, &lastBranch)
+        AST_MEMBER(Switch, &target, &assignment, &sep, &branches, &lastBranch)
 AST_END(Switch)
-AST_NODE(Assignment)
-        ast_ptr<false, ExpList_t> expList;
-        ast_ptr<true, Assign_t> assign;
-        AST_MEMBER(Assignment, &expList, &assign)
-AST_END(Assignment)
 AST_NODE(IfCond)
        ast_ptr<true, Exp_t> condition;
        ast_ptr<false, Assignment_t> assignment;
@@ -343,7 +353,7 @@ AST_NODE(While)
 AST_END(While)
 AST_NODE(Repeat)
-        ast_ptr<true, Body_t> body;
+        ast_sel<true, Block_t, Statement_t> body;
        ast_ptr<true, Exp_t> condition;
        AST_MEMBER(Repeat, &body, &condition)
 AST_END(Repeat)
@@ -381,9 +391,10 @@ AST_NODE(CatchBlock)
 AST_END(CatchBlock)
 AST_NODE(Try)
+        ast_ptr<false, ExistentialOp_t> eop;
        ast_sel<true, Block_t, Exp_t> func;
        ast_ptr<false, CatchBlock_t> catchBlock;
-        AST_MEMBER(Try, &func, &catchBlock)
+        AST_MEMBER(Try, &eop, &func, &catchBlock)
 AST_END(Try)
 AST_NODE(Comprehension)
@@ -547,8 +558,8 @@ AST_NODE(SimpleValue)
        ast_sel<true,
                TableLit_t, ConstValue_t,
                If_t, Switch_t, With_t, ClassDecl_t,
-                ForEach_t, For_t, While_t, Do_t, Try_t,
+                ForEach_t, For_t, While_t, Repeat_t,
-                UnaryValue_t,
+                Do_t, Try_t, UnaryValue_t,
                TblComprehension_t, Comprehension_t,
                FunLit_t, Num_t, VarArg_t> value;
        AST_MEMBER(SimpleValue, &value)
@@ -587,8 +598,31 @@ AST_NODE(DoubleString)
        AST_MEMBER(DoubleString, &sep, &segments)
 AST_END(DoubleString)
+AST_LEAF(YAMLIndent)
+AST_END(YAMLIndent)
+AST_LEAF(YAMLLineInner)
+AST_END(YAMLLineInner)
+AST_NODE(YAMLLineContent)
+        ast_sel<true, YAMLLineInner_t, Exp_t> content;
+        AST_MEMBER(YAMLLineContent, &content)
+AST_END(YAMLLineContent)
+AST_NODE(YAMLLine)
+        ast_ptr<true, YAMLIndent_t> indent;
+        ast_list<true, YAMLLineContent_t> segments;
+        AST_MEMBER(YAMLLine, &indent, &segments)
+AST_END(YAMLLine)
+AST_NODE(YAMLMultiline)
+        ast_ptr<true, Seperator_t> sep;
+        ast_list<true, YAMLLine_t> lines;
+        AST_MEMBER(YAMLMultiline, &sep, &lines)
+AST_END(YAMLMultiline)
 AST_NODE(String)
-        ast_sel<true, DoubleString_t, SingleString_t, LuaString_t> str;
+        ast_sel<true, DoubleString_t, SingleString_t, LuaString_t, YAMLMultiline_t> str;
        AST_MEMBER(String, &str)
 AST_END(String)
@@ -639,9 +673,14 @@ AST_END(TableAppendingOp)
 AST_LEAF(PlainItem)
 AST_END(PlainItem)
+AST_NODE(ReversedIndex)
+        ast_ptr<false, Exp_t> modifier;
+        AST_MEMBER(ReversedIndex, &modifier)
+AST_END(ReversedIndex)
 AST_NODE(ChainValue)
        ast_ptr<true, Seperator_t> sep;
-        ast_sel_list<true, Callable_t, Invoke_t, DotChainItem_t, ColonChainItem_t, Slice_t, Exp_t, String_t, InvokeArgs_t, ExistentialOp_t, TableAppendingOp_t,
+        ast_sel_list<true, Callable_t, Invoke_t, DotChainItem_t, ColonChainItem_t, Slice_t, Exp_t, String_t, InvokeArgs_t, ExistentialOp_t, TableAppendingOp_t, ReversedIndex_t,
                /*non-syntax-rule*/ PlainItem_t> items;
        AST_MEMBER(ChainValue, &sep, &items)
 AST_END(ChainValue)
@@ -725,8 +764,9 @@ AST_LEAF(GlobalOp)
 AST_END(GlobalOp)
 AST_NODE(Global)
+        ast_ptr<false, ConstAttrib_t> constAttrib;
        ast_sel<true, ClassDecl_t, GlobalOp_t, GlobalValues_t> item;
-        AST_MEMBER(Global, &item)
+        AST_MEMBER(Global, &constAttrib, &item)
 AST_END(Global)
 AST_LEAF(ExportDefault)
@@ -742,15 +782,17 @@ AST_END(Export)
 AST_NODE(FnArgDef)
        ast_sel<true, Variable_t, SelfItem_t> name;
        ast_ptr<false, ExistentialOp_t> op;
+        ast_ptr<false, Name_t> label;
        ast_ptr<false, Exp_t> defaultValue;
-        AST_MEMBER(FnArgDef, &name, &op, &defaultValue)
+        AST_MEMBER(FnArgDef, &name, &op, &label, &defaultValue)
 AST_END(FnArgDef)
 AST_NODE(FnArgDefList)
        ast_ptr<true, Seperator_t> sep;
        ast_list<false, FnArgDef_t> definitions;
        ast_ptr<false, VarArg_t> varArg;
-        AST_MEMBER(FnArgDefList, &sep, &definitions, &varArg)
+        ast_ptr<false, Name_t> label;
+        AST_MEMBER(FnArgDefList, &sep, &definitions, &varArg, &label)
 AST_END(FnArgDefList)
 AST_NODE(OuterVarShadow)
@@ -838,9 +880,15 @@ AST_NODE(UnaryExp)
        AST_MEMBER(UnaryExp, &ops, &expos, &inExp)
 AST_END(UnaryExp)
+AST_NODE(SubBackcall)
+        ast_ptr<true, FnArrowBack_t> arrow;
+        ast_ptr<true, ChainValue_t> value;
+        AST_MEMBER(SubBackcall, &arrow, &value)
+AST_END(SubBackcall)
 AST_NODE(ExpListAssign)
        ast_ptr<true, ExpList_t> expList;
-        ast_sel<false, Update_t, Assign_t> action;
+        ast_sel<false, Update_t, Assign_t, SubBackcall_t> action;
        AST_MEMBER(ExpListAssign, &expList, &action)
 AST_END(ExpListAssign)
@@ -856,7 +904,17 @@ AST_NODE(WhileLine)
        AST_MEMBER(WhileLine, &type, &condition)
 AST_END(WhileLine)
-AST_LEAF(BreakLoop)
+AST_LEAF(Break)
+AST_END(Break)
+AST_LEAF(Continue)
+AST_END(Continue)
+AST_NODE(BreakLoop)
+        ast_sel<true, Break_t, Continue_t> type;
+        ast_ptr<false, Exp_t> value;
+        AST_MEMBER(BreakLoop, &type, &value)
+        std::string varBWV;
 AST_END(BreakLoop)
 AST_NODE(PipeBody)
diff --git a/src/yuescript/yue_compiler.cpp b/src/yuescript/yue_compiler.cpp
index 590c502..d676750 100644
--- a/src/yuescript/yue_compiler.cpp
+++ b/src/yuescript/yue_compiler.cpp
@@ -78,7 +78,7 @@ static std::unordered_set<std::string> Metamethods = {
        "close"s // Lua 5.4
 };
-const std::string_view version = "0.27.5"sv;
+const std::string_view version = "0.29.3"sv;
 const std::string_view extension = "yue"sv;
 class CompileError : public std::logic_error {
@@ -165,12 +165,12 @@ public:
                double compileTime = 0.0;
                if (config.profiling) {
                        auto start = std::chrono::high_resolution_clock::now();
-                        _info = _parser.parse<File_t>(codes);
+                        _info = _parser.parse<File_t>(codes, config.lax);
                        auto stop = std::chrono::high_resolution_clock::now();
                        std::chrono::duration<double> diff = stop - start;
                        parseTime = diff.count();
                } else {
-                        _info = _parser.parse<File_t>(codes);
+                        _info = _parser.parse<File_t>(codes, config.lax);
                }
                std::unique_ptr<GlobalVars> globals;
                std::unique_ptr<Options> options;
@@ -429,8 +429,9 @@ private:
        };
        enum class VarType {
                Local = 0,
-                Const = 1,
+                LocalConst = 1,
-                Global = 2
+                Global = 2,
+                GlobalConst = 3
        };
        struct Scope {
                GlobalMode mode = GlobalMode::None;
@@ -558,7 +559,7 @@ private:
                for (auto it = _scopes.rbegin(); it != _scopes.rend(); ++it) {
                        auto vars = it->vars.get();
                        auto vit = vars->find(name);
-                        if (vit != vars->end() && vit->second != VarType::Global) {
+                        if (vit != vars->end() && (vit->second == VarType::Local || vit->second == VarType::LocalConst)) {
                                local = true;
                                break;
                        }
@@ -571,7 +572,7 @@ private:
                for (auto it = _scopes.rbegin(); it != _scopes.rend(); ++it) {
                        auto vars = it->vars.get();
                        auto vit = vars->find(name);
-                        if (vit != vars->end() && vit->second == VarType::Global) {
+                        if (vit != vars->end() && (vit->second == VarType::Global || vit->second == VarType::GlobalConst)) {
                                global = true;
                                break;
                        }
@@ -593,7 +594,7 @@ private:
                        auto vars = it->vars.get();
                        auto vit = vars->find(name);
                        if (vit != vars->end()) {
-                                isConst = (vit->second == VarType::Const);
+                                isConst = (vit->second == VarType::LocalConst || vit->second == VarType::GlobalConst);
                                break;
                        }
                        if (checkShadowScopeOnly && it->allows) break;
@@ -874,9 +875,9 @@ private:
                return false;
        }
-        void markVarConst(const std::string& name) {
+        void markVarLocalConst(const std::string& name) {
                auto& scope = _scopes.back();
-                scope.vars->insert_or_assign(name, VarType::Const);
+                scope.vars->insert_or_assign(name, VarType::LocalConst);
        }
        void markVarShadowed() {
@@ -895,6 +896,11 @@ private:
                scope.vars->insert_or_assign(name, VarType::Global);
        }
+        void markVarGlobalConst(const std::string& name) {
+                auto& scope = _scopes.back();
+                scope.vars->insert_or_assign(name, VarType::GlobalConst);
+        }
        void addToAllowList(const std::string& name) {
                auto& scope = _scopes.back();
                scope.allows->insert(name);
@@ -1252,7 +1258,7 @@ private:
        template <class T>
        ast_ptr<false, T> toAst(std::string_view codes, ast_node* parent) {
-                auto res = _parser.parse<T>(std::string(codes));
+                auto res = _parser.parse<T>(std::string(codes), false);
                if (res.error) {
                        throw CompileError(res.error.value().msg, parent);
                }
@@ -1275,6 +1281,8 @@ private:
                Common,
                EndWithColon,
                EndWithEOP,
+                EndWithSlice,
+                HasRIndex,
                HasEOP,
                HasKeyword,
                HasUnicode,
@@ -1293,6 +1301,9 @@ private:
                if (ast_is<ExistentialOp_t>(chainValue->items.back())) {
                        return ChainType::EndWithEOP;
                }
+                if (ast_is<Slice_t>(chainValue->items.back())) {
+                        return ChainType::EndWithSlice;
+                }
                if (auto dot = ast_cast<DotChainItem_t>(chainValue->items.back())) {
                        if (dot->name.is<Metatable_t>()) {
                                return ChainType::Metatable;
@@ -1318,6 +1329,8 @@ private:
                                }
                        } else if (ast_is<ExistentialOp_t>(item)) {
                                return ChainType::HasEOP;
+                        } else if (ast_is<ReversedIndex_t>(item)) {
+                                return ChainType::HasRIndex;
                        }
                }
                return type;
@@ -1840,6 +1853,7 @@ private:
                                                                case id<ForEach_t>(): transformForEach(static_cast<ForEach_t*>(value), out); break;
                                                                case id<For_t>(): transformFor(static_cast<For_t*>(value), out); break;
                                                                case id<While_t>(): transformWhile(static_cast<While_t*>(value), out); break;
+                                                                case id<Repeat_t>(): transformRepeat(static_cast<Repeat_t*>(value), out); break;
                                                                case id<Do_t>(): transformDo(static_cast<Do_t*>(value), out, ExpUsage::Common); break;
                                                                case id<Try_t>(): transformTry(static_cast<Try_t*>(value), out, ExpUsage::Common); break;
                                                                case id<Comprehension_t>(): {
@@ -2051,13 +2065,16 @@ private:
                                        if (item.targetVar.empty()) {
                                                throw CompileError("can only declare variable as const"sv, item.target);
                                        }
-                                        markVarConst(item.targetVar);
+                                        markVarLocalConst(item.targetVar);
                                }
                        }
                }
        }
        bool transformAssignment(ExpListAssign_t* assignment, str_list& out, bool optionalDestruct = false) {
+                if (assignment->action.is<SubBackcall_t>()) {
+                        YUEE("AST node mismatch", assignment->action);
+                }
                checkAssignable(assignment->expList);
                BLOCK_START
                auto assign = ast_cast<Assign_t>(assignment->action);
@@ -2320,6 +2337,17 @@ private:
                                out.back().insert(0, preDefine);
                                return false;
                        }
+                        case id<Try_t>(): {
+                                auto tryNode = static_cast<Try_t*>(value);
+                                if (tryNode->eop) {
+                                        auto assignList = assignment->expList.get();
+                                        std::string preDefine = getPreDefineLine(assignment);
+                                        transformTry(tryNode, out, ExpUsage::Assignment, assignList);
+                                        out.back().insert(0, preDefine);
+                                        return false;
+                                }
+                                break;
+                        }
                        case id<Switch_t>(): {
                                auto switchNode = static_cast<Switch_t*>(value);
                                auto assignList = assignment->expList.get();
@@ -2391,6 +2419,13 @@ private:
                                out.back().insert(0, preDefine);
                                return false;
                        }
+                        case id<Repeat_t>(): {
+                                auto expList = assignment->expList.get();
+                                std::string preDefine = getPreDefineLine(assignment);
+                                transformRepeatInPlace(static_cast<Repeat_t*>(value), out, expList);
+                                out.back().insert(0, preDefine);
+                                return false;
+                        }
                        case id<TableLit_t>(): {
                                auto tableLit = static_cast<TableLit_t*>(value);
                                if (hasSpreadExp(tableLit->values.objects())) {
@@ -2443,12 +2478,14 @@ private:
                        switch (type) {
                                case ChainType::HasEOP:
                                case ChainType::EndWithColon:
+                                case ChainType::EndWithSlice:
                                case ChainType::MetaFieldInvocation: {
                                        std::string preDefine = getPreDefineLine(assignment);
                                        transformChainValue(chainValue, out, ExpUsage::Assignment, expList, false, optionalDestruct);
                                        out.back().insert(0, preDefine);
                                        return false;
                                }
+                                case ChainType::HasRIndex:
                                case ChainType::HasKeyword:
                                case ChainType::HasUnicode:
                                case ChainType::Macro:
@@ -2464,6 +2501,10 @@ private:
                auto info = extractDestructureInfo(assignment, false, optionalDestruct);
                if (info.destructures.empty()) {
                        transformAssignmentCommon(assignment, out);
+                        if (assignment->expList->followStmt) {
+                                transformStatement(assignment->expList->followStmt, out);
+                                assignment->expList->followStmtProcessed = true;
+                        }
                        return true;
                } else {
                        auto x = assignment;
@@ -2729,8 +2770,12 @@ private:
                                temp.push_back(indent() + "end"s + nlr(x));
                        }
                        out.push_back(join(temp));
+                        if (assignment->expList->followStmt) {
+                                transformStatement(assignment->expList->followStmt, out);
+                                assignment->expList->followStmtProcessed = true;
+                        }
+                        return false;
                }
-                return false;
        }
        void transformAssignItem(ast_node* value, str_list& out) {
@@ -2796,20 +2841,46 @@ private:
                if (!tableItems) throw CompileError("invalid destructure value"sv, node);
                std::list<DestructItem> pairs;
                int index = 0;
+                int count = 0;
+                bool hasSpread = false;
                auto subMetaDestruct = node->new_ptr<TableLit_t>();
                for (auto pair : *tableItems) {
                        switch (pair->get_id()) {
                                case id<Exp_t>():
                                case id<NormalDef_t>(): {
+                                        ++index;
                                        Exp_t* defVal = nullptr;
                                        if (auto nd = ast_cast<NormalDef_t>(pair)) {
                                                pair = nd->item.get();
                                                defVal = nd->defVal.get();
                                        }
-                                        ++index;
+                                        bool assignable = false;
-                                        if (!varDefOnly && !isAssignable(static_cast<Exp_t*>(pair))) {
+                                        try {
+                                                assignable = isAssignable(static_cast<Exp_t*>(pair));
+                                        } catch (const CompileError& e) {
+                                                if (!varDefOnly) throw e;
+                                        }
+                                        if (!assignable && !varDefOnly) {
+                                                if (optional) break;
                                                throw CompileError("can't destructure value"sv, pair);
                                        }
+                                        ast_ptr<true, ast_node> indexItem;
+                                        if (hasSpread) {
+                                                int rIndex = count - index;
+                                                indexItem.set(toAst<ReversedIndex_t>('#' + (rIndex == 0 ? Empty : "-"s + std::to_string(rIndex)), pair));
+                                        } else {
+                                                indexItem.set(toAst<Exp_t>(std::to_string(index), pair));
+                                        }
+                                        if (optional && varDefOnly && !assignable) {
+                                                if (defVal) {
+                                                        throw CompileError("default value is not supported here"sv, defVal);
+                                                }
+                                                auto exp = static_cast<Exp_t*>(pair);
+                                                auto chain = exp->new_ptr<ChainValue_t>();
+                                                chain->items.push_back(indexItem);
+                                                pairs.push_back({exp, Empty, chain, nullptr});
+                                                break;
+                                        }
                                        auto value = singleValueFrom(pair);
                                        auto item = value->item.get();
                                        ast_node* subExp = ast_cast<SimpleTable_t>(item);
@@ -2820,7 +2891,6 @@ private:
                                                                throw CompileError("default value is not supported here"sv, defVal);
                                                        }
                                                }
-                                                auto indexItem = toAst<Exp_t>(std::to_string(index), value);
                                                for (auto& p : subPairs) {
                                                        if (sep) p.structure->items.push_front(sep);
                                                        p.structure->items.push_front(indexItem);
@@ -2831,7 +2901,6 @@ private:
                                                auto varName = singleVariableFrom(exp, AccessType::None);
                                                if (varName == "_"sv) break;
                                                auto chain = exp->new_ptr<ChainValue_t>();
-                                                auto indexItem = toAst<Exp_t>(std::to_string(index), exp);
                                                chain->items.push_back(indexItem);
                                                pairs.push_back({exp,
                                                        varName,
@@ -2889,7 +2958,25 @@ private:
                                                }
                                        }
                                        if (auto exp = np->value.as<Exp_t>()) {
-                                                if (!varDefOnly && !isAssignable(exp)) throw CompileError("can't do destructure value"sv, exp);
+                                                bool assignable = false;
+                                                try {
+                                                        assignable = isAssignable(exp);
+                                                } catch (const CompileError& e) {
+                                                        if (!varDefOnly) throw e;
+                                                }
+                                                if (!assignable && !varDefOnly) {
+                                                        if (optional) break;
+                                                        throw CompileError("can't destructure value"sv, pair);
+                                                }
+                                                if (optional && varDefOnly && !assignable) {
+                                                        if (defVal) {
+                                                                throw CompileError("default value is not supported here"sv, defVal);
+                                                        }
+                                                        auto chain = exp->new_ptr<ChainValue_t>();
+                                                        if (keyIndex) chain->items.push_back(keyIndex);
+                                                        pairs.push_back({exp, Empty, chain, nullptr});
+                                                        break;
+                                                }
                                                auto item = singleValueFrom(exp)->item.get();
                                                ast_node* subExp = ast_cast<SimpleTable_t>(item);
                                                if (subExp || (subExp = item->get_by_path<TableLit_t>()) || (subExp = item->get_by_path<Comprehension_t>())) {
@@ -2938,7 +3025,13 @@ private:
                                        auto tb = static_cast<TableBlockIndent_t*>(pair);
                                        ++index;
                                        auto subPairs = destructFromExp(tb, varDefOnly, optional);
-                                        auto indexItem = toAst<Exp_t>(std::to_string(index), tb);
+                                        ast_ptr<true, ast_node> indexItem;
+                                        if (hasSpread) {
+                                                int rIndex = count - index;
+                                                indexItem.set(toAst<ReversedIndex_t>('#' + (rIndex == 0 ? Empty : "-"s + std::to_string(rIndex)), tb));
+                                        } else {
+                                                indexItem.set(toAst<Exp_t>(std::to_string(index), tb));
+                                        }
                                        for (auto& p : subPairs) {
                                                if (sep) p.structure->items.push_front(sep);
                                                p.structure->items.push_front(indexItem);
@@ -2995,6 +3088,42 @@ private:
                                        subMetaDestruct->values.push_back(newPairDef);
                                        break;
                                }
+                                case id<SpreadListExp_t>():
+                                case id<SpreadExp_t>(): {
+                                        ++index;
+                                        if (hasSpread) {
+                                                throw CompileError("duplicated spread expression"sv, pair);
+                                        }
+                                        hasSpread = true;
+                                        for (auto item : *tableItems) {
+                                                if (ast_is<
+                                                                SpreadListExp_t, SpreadExp_t,
+                                                                TableBlockIndent_t,
+                                                                Exp_t, NormalDef_t>(item)) {
+                                                        count++;
+                                                }
+                                        }
+                                        Exp_t* exp = nullptr;
+                                        if (auto se = ast_cast<SpreadExp_t>(pair)) {
+                                                exp = se->exp.get();
+                                        } else {
+                                                exp = ast_to<SpreadListExp_t>(pair)->exp.get();
+                                        }
+                                        auto varName = singleVariableFrom(exp, AccessType::None);
+                                        if (varName == "_"sv) break;
+                                        int start = index;
+                                        int stop = index - count - 1;
+                                        auto chain = exp->new_ptr<ChainValue_t>();
+                                        auto slice = toAst<Slice_t>(
+                                                '[' + (start == 1 ? Empty : std::to_string(start)) + ',' + (stop == -1 ? Empty : std::to_string(stop)) + ']', exp);
+                                        chain->items.push_back(slice);
+                                        auto nil = toAst<Exp_t>("nil"sv, slice);
+                                        pairs.push_back({exp,
+                                                varName,
+                                                chain,
+                                                nil.get()});
+                                        break;
+                                }
                                default: YUEE("AST node mismatch", pair); break;
                        }
                }
@@ -3111,7 +3240,11 @@ private:
                                                break;
                                        default: YUEE("AST node mismatch", destructNode); break;
                                }
-                                if (dlist->empty()) throw CompileError("expect items to be destructured"sv, destructNode);
+                                if (dlist->empty()) {
+                                        if (!optional) {
+                                                throw CompileError("expect items to be destructured"sv, destructNode);
+                                        }
+                                }
                                for (auto item : *dlist) {
                                        switch (item->get_id()) {
                                                case id<MetaVariablePairDef_t>(): {
@@ -3247,7 +3380,9 @@ private:
                                                simpleValue->value.set(tab);
                                                auto pairs = destructFromExp(newExp(simpleValue, expr), varDefOnly, optional);
                                                if (pairs.empty()) {
-                                                        throw CompileError("expect items to be destructured"sv, tab);
+                                                        if (!optional) {
+                                                                throw CompileError("expect items to be destructured"sv, tab);
+                                                        }
                                                }
                                                destruct.items = std::move(pairs);
                                                if (!varDefOnly) {
@@ -3286,7 +3421,7 @@ private:
                                                                destruct.valueVar.clear();
                                                        }
                                                }
-                                                destructs.push_back(destruct);
+                                                destructs.push_back(std::move(destruct));
                                        }
                                }
                        } else {
@@ -4205,12 +4340,22 @@ private:
        std::optional<std::pair<std::string, str_list>> upValueFuncFromExp(Exp_t* exp, str_list* ensureArgListInTheEnd, bool blockRewrite) {
                if (checkUpValueFuncAvailable(exp)) {
+                        auto block = exp->new_ptr<Block_t>();
+                        if (auto sVal = simpleSingleValueFrom(exp)) {
+                                if (auto doNode = sVal->value.as<Do_t>()) {
+                                        if (auto blk = doNode->body->content.as<Block_t>()) {
+                                                block->statements.dup(blk->statements);
+                                        } else {
+                                                block->statements.push_back(doNode->body->content.to<Statement_t>());
+                                        }
+                                        return getUpValueFuncFromBlock(block, ensureArgListInTheEnd, false, blockRewrite);
+                                }
+                        }
                        auto returnNode = exp->new_ptr<Return_t>();
                        returnNode->explicitReturn = false;
                        auto returnList = exp->new_ptr<ExpListLow_t>();
                        returnList->exprs.push_back(exp);
                        returnNode->valueList.set(returnList);
-                        auto block = exp->new_ptr<Block_t>();
                        auto stmt = exp->new_ptr<Statement_t>();
                        stmt->content.set(returnNode);
                        block->statements.push_back(stmt);
@@ -4287,7 +4432,9 @@ private:
                        return false;
                };
                switch (usage) {
-                        case ExpUsage::Common: YUEE("AST node mismatch", x); return;
+                        case ExpUsage::Common:
+                                YUEE("AST node mismatch", x);
+                                return;
                        case ExpUsage::Return:
                        case ExpUsage::Closure: {
                                prepareValue();
@@ -4410,6 +4557,7 @@ private:
                        case id<ForEach_t>(): transformForEachClosure(static_cast<ForEach_t*>(value), out); break;
                        case id<For_t>(): transformForClosure(static_cast<For_t*>(value), out); break;
                        case id<While_t>(): transformWhileClosure(static_cast<While_t*>(value), out); break;
+                        case id<Repeat_t>(): transformRepeatClosure(static_cast<Repeat_t*>(value), out); break;
                        case id<Do_t>(): transformDo(static_cast<Do_t*>(value), out, ExpUsage::Closure); break;
                        case id<Try_t>(): transformTry(static_cast<Try_t*>(value), out, ExpUsage::Closure); break;
                        case id<UnaryValue_t>(): transformUnaryValue(static_cast<UnaryValue_t*>(value), out); break;
@@ -4729,11 +4877,7 @@ private:
                                auto newBody = x->new_ptr<Body_t>();
                                newBody->content.set(followingBlock);
                                {
-                                        auto doNode = x->new_ptr<Do_t>();
+                                        if (auto result = upValueFuncFromBlock(followingBlock.get(), &argNames, false, true)) {
-                                        doNode->body.set(newBody);
-                                        auto simpleValue = x->new_ptr<SimpleValue_t>();
-                                        simpleValue->value.set(doNode);
-                                        if (auto result = upValueFuncFromExp(newExp(simpleValue, x), &argNames, true)) {
                                                auto [funcName, args] = std::move(*result);
                                                str_list finalArgs;
                                                for (const auto& arg : args) {
@@ -4741,9 +4885,13 @@ private:
                                                                finalArgs.push_back(arg);
                                                        }
                                                }
-                                                newBlock->statements.push_back(toAst<Statement_t>(funcName + ' ' + join(finalArgs, ","sv), x));
+                                                newBlock->statements.push_back(toAst<Statement_t>(funcName + ' ' + (finalArgs.empty() ? "nil"s : join(finalArgs, ","sv)), x));
                                                auto sVal = singleValueFrom(static_cast<Statement_t*>(newBlock->statements.back())->content.to<ExpListAssign_t>()->expList);
-                                                ast_to<InvokeArgs_t>(sVal->item.to<ChainValue_t>()->items.back())->args.dup(newInvoke->args);
+                                                auto invokArgs = ast_to<InvokeArgs_t>(sVal->item.to<ChainValue_t>()->items.back());
+                                                if (finalArgs.empty()) {
+                                                        invokArgs->args.clear();
+                                                }
+                                                invokArgs->args.dup(newInvoke->args);
                                                transformBlock(newBlock, out, usage, assignList, isRoot);
                                                return;
                                        }
@@ -4820,6 +4968,38 @@ private:
                                newBlock->statements.push_back(toAst<Statement_t>("if "s + okVar + " then return ... else error ..."s, x));
                                transformBlock(newBlock, out, usage, assignList, isRoot);
                                return;
+                        } else if (auto expListAssign = stmt->content.as<ExpListAssign_t>();
+                                expListAssign && expListAssign->action && expListAssign->action.is<SubBackcall_t>()) {
+                                auto x = *nodes.begin();
+                                auto newBlock = x->new_ptr<Block_t>();
+                                if (it != nodes.begin()) {
+                                        for (auto i = nodes.begin(); i != it; ++i) {
+                                                newBlock->statements.push_back(*i);
+                                        }
+                                }
+                                auto doBackcall = static_cast<SubBackcall_t*>(expListAssign->action.get());
+                                auto backcall = expListAssign->new_ptr<Backcall_t>();
+                                auto argsDef = backcall->new_ptr<FnArgsDef_t>();
+                                try {
+                                        auto defList = toAst<FnArgDefList_t>(YueFormat{}.toString(expListAssign->expList), expListAssign->expList);
+                                        argsDef->defList.set(defList);
+                                } catch (const std::exception&) {
+                                        throw CompileError("backcall syntax error", backcall);
+                                }
+                                backcall->argsDef.set(argsDef);
+                                backcall->arrow.set(doBackcall->arrow);
+                                backcall->value.set(doBackcall->value);
+                                auto newStmt = backcall->new_ptr<Statement_t>();
+                                newStmt->content.set(backcall);
+                                newStmt->comments.dup(stmt->comments);
+                                newStmt->appendix.set(stmt->appendix);
+                                newBlock->statements.push_back(newStmt);
+                                auto ait = it;
+                                for (auto i = ++ait; i != nodes.end(); ++i) {
+                                        newBlock->statements.push_back(*i);
+                                }
+                                transformBlock(newBlock, out, usage, assignList, isRoot);
+                                return;
                        }
                        if (auto local = stmt->content.as<Local_t>()) {
                                if (!local->collected) {
@@ -4991,36 +5171,45 @@ private:
                if (!nodes.empty()) {
                        str_list temp;
                        for (auto node : nodes) {
-                                currentScope().lastStatement = (node == nodes.back()) && currentScope().mode == GlobalMode::None;
+                                auto transformNode = [&]() {
-                                transformStatement(static_cast<Statement_t*>(node), temp);
+                                        currentScope().lastStatement = (node == nodes.back()) && currentScope().mode == GlobalMode::None;
-                                if (isRoot && !_rootDefs.empty()) {
+                                        transformStatement(static_cast<Statement_t*>(node), temp);
-                                        auto last = std::move(temp.back());
+                                        if (isRoot && !_rootDefs.empty()) {
-                                        temp.pop_back();
+                                                auto last = std::move(temp.back());
-                                        temp.insert(temp.end(), _rootDefs.begin(), _rootDefs.end());
+                                                temp.pop_back();
-                                        _rootDefs.clear();
+                                                temp.insert(temp.end(), _rootDefs.begin(), _rootDefs.end());
-                                        temp.push_back(std::move(last));
+                                                _rootDefs.clear();
-                                }
+                                                temp.push_back(std::move(last));
-                                if (!temp.empty() && _parser.startWith<StatementSep_t>(temp.back())) {
+                                        }
-                                        auto rit = ++temp.rbegin();
+                                        if (!temp.empty() && _parser.startWith<StatementSep_t>(temp.back())) {
-                                        if (rit != temp.rend() && !rit->empty()) {
+                                                auto rit = ++temp.rbegin();
-                                                auto index = std::string::npos;
+                                                if (rit != temp.rend() && !rit->empty()) {
-                                                if (_config.reserveLineNumber) {
+                                                        auto index = std::string::npos;
-                                                        index = rit->rfind(" -- "sv);
+                                                        if (_config.reserveLineNumber) {
-                                                } else {
+                                                                index = rit->rfind(" -- "sv);
-                                                        index = rit->find_last_not_of('\n');
+                                                        } else {
-                                                        if (index != std::string::npos) index++;
+                                                                index = rit->find_last_not_of('\n');
-                                                }
+                                                                if (index != std::string::npos) index++;
-                                                if (index != std::string::npos) {
-                                                        auto ending = rit->substr(0, index);
-                                                        auto ind = ending.find_last_of(" \t\n"sv);
-                                                        if (ind != std::string::npos) {
-                                                                ending = ending.substr(ind + 1);
                                                        }
-                                                        if (LuaKeywords.find(ending) == LuaKeywords.end()) {
+                                                        if (index != std::string::npos) {
-                                                                rit->insert(index, ";"sv);
+                                                                auto ending = rit->substr(0, index);
+                                                                auto ind = ending.find_last_of(" \t\n"sv);
+                                                                if (ind != std::string::npos) {
+                                                                        ending = ending.substr(ind + 1);
+                                                                }
+                                                                if (LuaKeywords.find(ending) == LuaKeywords.end()) {
+                                                                        rit->insert(index, ";"sv);
+                                                                }
                                                        }
                                                }
                                        }
+                                };
+                                if (_config.lax) {
+                                        try {
+                                                transformNode();
+                                        } catch (const CompileError&) { }
+                                } else {
+                                        transformNode();
                                }
                        }
                        out.push_back(join(temp));
@@ -5229,18 +5418,29 @@ private:
                auto macroLit = macro->decl.to<MacroLit_t>();
                auto argsDef = macroLit->argsDef.get();
                str_list newArgs;
+                str_list argChecks;
+                bool hasCheck = false;
                if (argsDef) {
                        for (auto def_ : argsDef->definitions.objects()) {
                                auto def = static_cast<FnArgDef_t*>(def_);
                                if (def->name.is<SelfItem_t>()) {
                                        throw CompileError("self name is not supported for macro function argument"sv, def->name);
                                } else {
+                                        if (def->op) throw CompileError("invalid existence checking"sv, def->op);
+                                        if (def->label) {
+                                                hasCheck = true;
+                                                const auto& astName = argChecks.emplace_back(_parser.toString(def->label));
+                                                if (!_parser.hasAST(astName)) {
+                                                        throw CompileError("invalid AST name"sv, def->label);
+                                                }
+                                        } else {
+                                                argChecks.emplace_back();
+                                        }
                                        std::string defVal;
                                        if (def->defaultValue) {
                                                defVal = _parser.toString(def->defaultValue);
                                                Utils::trim(defVal);
-                                                defVal.insert(0, "=[==========["sv);
+                                                defVal = '=' + Utils::toLuaDoubleString(defVal);
-                                                defVal.append("]==========]"sv);
                                        }
                                        newArgs.emplace_back(_parser.toString(def->name) + defVal);
                                }
@@ -5248,6 +5448,14 @@ private:
                        if (argsDef->varArg) {
                                newArgs.emplace_back(_parser.toString(argsDef->varArg));
                        }
+                        if (argsDef->label) {
+                                hasCheck = true;
+                                const auto& astName = _parser.toString(argsDef->label);
+                                if (!_parser.hasAST(astName)) {
+                                        throw CompileError("invalid AST name"sv, argsDef->label);
+                                }
+                                argChecks.emplace_back("..."s + astName);
+                        }
                }
                std::string macroCodes = "_ENV=require('yue').macro_env\n("s + join(newArgs, ","sv) + ")->"s + _parser.toString(macroLit->body);
                auto chunkName = "=(macro "s + macroName + ')';
@@ -5278,6 +5486,24 @@ private:
                        throw CompileError("failed to generate macro function\n"s + err, macroLit);
                } // cur true macro
                lua_remove(L, -2); // cur macro
+                if (hasCheck) {
+                        lua_createtable(L, 0, 0); // cur macro checks
+                        int i = 1;
+                        for (const auto& check : argChecks) {
+                                if (check.empty()) {
+                                        lua_pushboolean(L, 0);
+                                        lua_rawseti(L, -2, i);
+                                } else {
+                                        lua_pushlstring(L, check.c_str(), check.size());
+                                        lua_rawseti(L, -2, i);
+                                }
+                                i++;
+                        }
+                        lua_createtable(L, 2, 0); // cur macro checks macrotab
+                        lua_insert(L, -3); // cur macrotab macro checks
+                        lua_rawseti(L, -3, 1); // macrotab[1] = checks, cur macrotab macro
+                        lua_rawseti(L, -2, 2); // macrotab[2] = macro, cur macrotab
+                } // cur macro
                if (exporting && _config.exporting && !_config.module.empty()) {
                        pushModuleTable(_config.module); // cur macro module
                        lua_pushlstring(L, macroName.c_str(), macroName.size()); // cur macro module name
@@ -5352,6 +5578,9 @@ private:
                                                case id<While_t>():
                                                        transformWhileInPlace(static_cast<While_t*>(value), out);
                                                        return;
+                                                case id<Repeat_t>():
+                                                        transformRepeatInPlace(static_cast<Repeat_t*>(value), out);
+                                                        return;
                                                case id<For_t>():
                                                        transformForInPlace(static_cast<For_t*>(value), out);
                                                        return;
@@ -5432,7 +5661,11 @@ private:
                        auto def = static_cast<FnArgDef_t*>(_def);
                        auto& arg = argItems.emplace_back();
                        switch (def->name->get_id()) {
-                                case id<Variable_t>(): arg.name = variableToString(static_cast<Variable_t*>(def->name.get())); break;
+                                case id<Variable_t>(): {
+                                        if (def->op) throw CompileError("invalid existence checking"sv, def->op);
+                                        arg.name = variableToString(static_cast<Variable_t*>(def->name.get()));
+                                        break;
+                                }
                                case id<SelfItem_t>(): {
                                        assignSelf = true;
                                        if (def->op) {
@@ -5571,6 +5804,45 @@ private:
                }
        }
+        bool transformChainEndWithSlice(const node_container& chainList, str_list& out, ExpUsage usage, ExpList_t* assignList) {
+                auto x = chainList.front();
+                if (ast_is<Slice_t>(chainList.back())) {
+                        auto comp = x->new_ptr<Comprehension_t>();
+                        {
+                                auto chainValue = x->new_ptr<ChainValue_t>();
+                                for (auto item : chainList) {
+                                        chainValue->items.push_back(item);
+                                }
+                                auto itemVar = getUnusedName("_item_"sv);
+                                auto expCode = YueFormat{}.toString(chainValue);
+                                auto compCode = '[' + itemVar + " for "s + itemVar + " in *"s + expCode + ']';
+                                comp.set(toAst<Comprehension_t>(compCode, x));
+                        }
+                        switch (usage) {
+                                case ExpUsage::Assignment: {
+                                        auto simpleValue = x->new_ptr<SimpleValue_t>();
+                                        simpleValue->value.set(comp);
+                                        auto exp = newExp(simpleValue, x);
+                                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                                        assignment->expList.set(assignList);
+                                        auto assign = x->new_ptr<Assign_t>();
+                                        assign->values.push_back(exp);
+                                        assignment->action.set(assign);
+                                        transformAssignment(assignment, out);
+                                        break;
+                                }
+                                case ExpUsage::Return:
+                                        transformComprehension(comp, out, ExpUsage::Return);
+                                        break;
+                                default:
+                                        transformComprehension(comp, out, ExpUsage::Closure);
+                                        break;
+                        }
+                        return true;
+                }
+                return false;
+        }
        bool transformChainEndWithEOP(const node_container& chainList, str_list& out, ExpUsage usage, ExpList_t* assignList) {
                auto x = chainList.front();
                if (ast_is<ExistentialOp_t>(chainList.back())) {
@@ -6088,7 +6360,7 @@ private:
                        case id<ColonChainItem_t>():
                        case id<Exp_t>():
                                if (_withVars.empty()) {
-                                        throw CompileError("short dot/colon and indexing syntax must be called within a with block"sv, x);
+                                        throw CompileError("short dot/colon/indexing syntax must be called within a with block"sv, x);
                                } else {
                                        temp.push_back(_withVars.top());
                                }
@@ -6234,6 +6506,93 @@ private:
                                                }
                                                return;
                                        }
+                                        break;
+                                }
+                                case id<ReversedIndex_t>(): {
+                                        auto rIndex = static_cast<ReversedIndex_t*>(*it);
+                                        auto current = it;
+                                        auto prevChain = x->new_ptr<ChainValue_t>();
+                                        for (auto i = chainList.begin(); i != current; ++i) {
+                                                prevChain->items.push_back(*i);
+                                        }
+                                        auto var = singleVariableFrom(prevChain, AccessType::None);
+                                        if (!var.empty() && isLocal(var)) {
+                                                auto indexNode = toAst<Exp_t>('#' + var, rIndex);
+                                                if (rIndex->modifier) {
+                                                        auto opValue = rIndex->new_ptr<ExpOpValue_t>();
+                                                        opValue->op.set(toAst<BinaryOperator_t>("-"sv, rIndex));
+                                                        opValue->pipeExprs.dup(rIndex->modifier->pipeExprs);
+                                                        indexNode->opValues.push_back(opValue);
+                                                        indexNode->opValues.dup(rIndex->modifier->opValues);
+                                                        indexNode->nilCoalesed.set(rIndex->modifier->nilCoalesed);
+                                                }
+                                                prevChain->items.push_back(indexNode);
+                                                auto next = current;
+                                                ++next;
+                                                for (auto i = next; i != chainList.end(); ++i) {
+                                                        prevChain->items.push_back(*i);
+                                                }
+                                                if (usage == ExpUsage::Assignment) {
+                                                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                                                        assignment->expList.set(assignList);
+                                                        auto assign = x->new_ptr<Assign_t>();
+                                                        assign->values.push_back(newExp(prevChain, x));
+                                                        assignment->action.set(assign);
+                                                        transformAssignment(assignment, out);
+                                                        return;
+                                                }
+                                                transformChainValue(prevChain, out, usage, assignList);
+                                                return;
+                                        } else {
+                                                auto itemVar = getUnusedName("_item_"sv);
+                                                auto asmt = assignmentFrom(toAst<Exp_t>(itemVar, x), newExp(prevChain, x), x);
+                                                auto stmt1 = x->new_ptr<Statement_t>();
+                                                stmt1->content.set(asmt);
+                                                auto newChain = x->new_ptr<ChainValue_t>();
+                                                newChain->items.push_back(toAst<Callable_t>(itemVar, x));
+                                                auto indexNode = toAst<Exp_t>('#' + itemVar, rIndex);
+                                                if (rIndex->modifier) {
+                                                        auto opValue = rIndex->new_ptr<ExpOpValue_t>();
+                                                        opValue->op.set(toAst<BinaryOperator_t>("-"sv, rIndex));
+                                                        opValue->pipeExprs.dup(rIndex->modifier->pipeExprs);
+                                                        indexNode->opValues.push_back(opValue);
+                                                        indexNode->opValues.dup(rIndex->modifier->opValues);
+                                                        indexNode->nilCoalesed.set(rIndex->modifier->nilCoalesed);
+                                                }
+                                                newChain->items.push_back(indexNode);
+                                                auto next = current;
+                                                ++next;
+                                                for (auto i = next; i != chainList.end(); ++i) {
+                                                        newChain->items.push_back(*i);
+                                                }
+                                                auto expList = x->new_ptr<ExpList_t>();
+                                                expList->exprs.push_back(newExp(newChain, x));
+                                                auto expListAssign = x->new_ptr<ExpListAssign_t>();
+                                                expListAssign->expList.set(expList);
+                                                auto stmt2 = x->new_ptr<Statement_t>();
+                                                stmt2->content.set(expListAssign);
+                                                auto block = x->new_ptr<Block_t>();
+                                                block->statements.push_back(stmt1);
+                                                block->statements.push_back(stmt2);
+                                                auto body = x->new_ptr<Body_t>();
+                                                body->content.set(block);
+                                                auto doNode = x->new_ptr<Do_t>();
+                                                doNode->body.set(body);
+                                                if (usage == ExpUsage::Assignment) {
+                                                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                                                        assignment->expList.set(assignList);
+                                                        auto assign = x->new_ptr<Assign_t>();
+                                                        auto sVal = x->new_ptr<SimpleValue_t>();
+                                                        sVal->value.set(doNode);
+                                                        assign->values.push_back(newExp(sVal, x));
+                                                        assignment->action.set(assign);
+                                                        transformAssignment(assignment, out);
+                                                        return;
+                                                }
+                                                transformDo(doNode, out, usage);
+                                                return;
+                                        }
+                                        break;
                                }
                        }
                }
@@ -6418,7 +6777,7 @@ private:
                                }
                        }
                }
-                int len = lua_objlen(L, -1);
+                int len = static_cast<int>(lua_objlen(L, -1));
                lua_pushnil(L); // cur nil
                for (int i = len; i >= 1; i--) {
                        lua_pop(L, 1); // cur
@@ -6430,7 +6789,25 @@ private:
                                break;
                        }
                }
-                if (!lua_isfunction(L, -1)) {
+                str_list checks;
+                if (lua_istable(L, -1)) {
+                        lua_rawgeti(L, -1, 1); // cur macrotab checks
+                        int len = static_cast<int>(lua_objlen(L, -1));
+                        for (int i = 1; i <= len; i++) {
+                                lua_rawgeti(L, -1, i);
+                                if (lua_toboolean(L, -1) == 0) {
+                                        checks.emplace_back();
+                                } else {
+                                        size_t str_len = 0;
+                                        auto str = lua_tolstring(L, -1, &str_len);
+                                        checks.emplace_back(std::string{str, str_len});
+                                }
+                                lua_pop(L, 1);
+                        }
+                        lua_pop(L, 1);
+                        lua_rawgeti(L, -1, 2); // cur macrotab macroFunc
+                        lua_remove(L, -2); // cur macroFunc
+                } else if (!lua_isfunction(L, -1)) {
                        auto code = expandBuiltinMacro(macroName, x);
                        if (!code.empty()) return code;
                        if (macroName == "is_ast"sv) {
@@ -6475,11 +6852,34 @@ private:
                } // cur macroFunc
                pushYue("pcall"sv); // cur macroFunc pcall
                lua_insert(L, -2); // cur pcall macroFunc
-                if (!lua_checkstack(L, argStrs.size())) {
+                if (!lua_checkstack(L, static_cast<int>(argStrs.size()))) {
                        throw CompileError("too much macro params"s, x);
                }
+                auto checkIt = checks.begin();
+                node_container::const_iterator argIt;
+                if (args) {
+                        argIt = args->begin();
+                }
                for (const auto& arg : argStrs) {
+                        if (checkIt != checks.end()) {
+                                if (checkIt->empty()) {
+                                        ++checkIt;
+                                } else {
+                                        if ((*checkIt)[0] == '.') {
+                                                auto astName = checkIt->substr(3);
+                                                if (!_parser.match(astName, arg)) {
+                                                        throw CompileError("expecting \""s + astName + "\", AST mismatch"s, *argIt);
+                                                }
+                                        } else {
+                                                if (!_parser.match(*checkIt, arg)) {
+                                                        throw CompileError("expecting \""s + *checkIt + "\", AST mismatch"s, *argIt);
+                                                }
+                                                ++checkIt;
+                                        }
+                                }
+                        }
                        lua_pushlstring(L, arg.c_str(), arg.size());
+                        ++argIt;
                } // cur pcall macroFunc args...
                bool success = lua_pcall(L, static_cast<int>(argStrs.size()), 1, 0) == 0;
                if (!success) { // cur err
@@ -6609,14 +7009,14 @@ private:
                } else {
                        if (!codes.empty()) {
                                if (isBlock) {
-                                        info = _parser.parse<BlockEnd_t>(codes);
+                                        info = _parser.parse<BlockEnd_t>(codes, false);
                                        if (info.error) {
                                                throw CompileError("failed to expand macro as block: "s + info.error.value().msg, x);
                                        }
                                } else {
-                                        info = _parser.parse<Exp_t>(codes);
+                                        info = _parser.parse<Exp_t>(codes, false);
                                        if (!info.node && allowBlockMacroReturn) {
-                                                info = _parser.parse<BlockEnd_t>(codes);
+                                                info = _parser.parse<BlockEnd_t>(codes, false);
                                                if (info.error) {
                                                        throw CompileError("failed to expand macro as expr or block: "s + info.error.value().msg, x);
                                                }
@@ -6752,6 +7152,9 @@ private:
                if (transformChainEndWithColonItem(chainList, out, usage, assignList)) {
                        return;
                }
+                if (transformChainEndWithSlice(chainList, out, usage, assignList)) {
+                        return;
+                }
                transformChainList(chainList, out, usage, assignList);
        }
@@ -7153,7 +7556,7 @@ private:
                                try {
                                        unsigned long long value = std::stoull(binaryPart, nullptr, 2);
                                        numStr = std::to_string(value);
-                                } catch (const std::exception& e) {
+                                } catch (const std::exception&) {
                                        throw CompileError("invalid binary literal"sv, num);
                                }
                        } else if (getLuaTarget(num) < 502) {
@@ -7859,6 +8262,11 @@ private:
        }
        bool transformForEachHead(AssignableNameList_t* nameList, ast_node* loopTarget, str_list& out, bool inClosure) {
+                enum class NumState {
+                        Unknown,
+                        Positive,
+                        Negtive
+                };
                auto x = nameList;
                str_list temp;
                str_list vars;
@@ -7925,15 +8333,35 @@ private:
                                for (auto item : chainList) {
                                        chain->items.push_back(item);
                                }
-                                std::string startValue("1"sv);
+                                std::string startValue;
+                                NumState startStatus = NumState::Unknown;
                                if (auto exp = slice->startValue.as<Exp_t>()) {
                                        transformExp(exp, temp, ExpUsage::Closure);
+                                        if (temp.back().at(0) == '-') {
+                                                if (_parser.match<Num_t>(temp.back().substr(1))) {
+                                                        startStatus = NumState::Negtive;
+                                                }
+                                        } else {
+                                                if (_parser.match<Num_t>(temp.back())) {
+                                                        startStatus = NumState::Positive;
+                                                }
+                                        }
                                        startValue = std::move(temp.back());
                                        temp.pop_back();
                                }
                                std::string stopValue;
+                                NumState stopStatus = NumState::Unknown;
                                if (auto exp = slice->stopValue.as<Exp_t>()) {
                                        transformExp(exp, temp, ExpUsage::Closure);
+                                        if (temp.back().at(0) == '-') {
+                                                if (_parser.match<Num_t>(temp.back().substr(1))) {
+                                                        stopStatus = NumState::Negtive;
+                                                }
+                                        } else {
+                                                if (_parser.match<Num_t>(temp.back())) {
+                                                        stopStatus = NumState::Positive;
+                                                }
+                                        }
                                        stopValue = std::move(temp.back());
                                        temp.pop_back();
                                }
@@ -7955,8 +8383,33 @@ private:
                                        transformChainValue(chain, temp, ExpUsage::Closure);
                                        _buf << prefix << indent() << "local "sv << listVar << " = "sv << temp.back() << nll(nameList);
                                }
+                                if (startValue.empty()) {
+                                        startValue = "1"s;
+                                        startStatus = NumState::Positive;
+                                }
+                                std::string minVar;
+                                if (startStatus != NumState::Positive) {
+                                        std::string prefix;
+                                        if (!extraScope && !inClosure && needScope) {
+                                                extraScope = true;
+                                                prefix = indent() + "do"s + nll(x);
+                                                pushScope();
+                                        }
+                                        minVar = getUnusedName("_min_"sv);
+                                        varBefore.push_back(minVar);
+                                        if (startStatus == NumState::Negtive) {
+                                                _buf << prefix << indent() << "local "sv << minVar << " = "sv << "#"sv << listVar << " + "sv << startValue << " + 1"sv << nll(nameList);
+                                        } else {
+                                                _buf << prefix << indent() << "local "sv << minVar << " = "sv << startValue << nll(nameList);
+                                        }
+                                }
+                                bool defaultStop = false;
+                                if (stopValue.empty()) {
+                                        stopValue = "#"s + listVar;
+                                        defaultStop = true;
+                                }
                                std::string maxVar;
-                                if (!stopValue.empty()) {
+                                if (stopStatus != NumState::Positive) {
                                        std::string prefix;
                                        if (!extraScope && !inClosure && needScope) {
                                                extraScope = true;
@@ -7965,14 +8418,45 @@ private:
                                        }
                                        maxVar = getUnusedName("_max_"sv);
                                        varBefore.push_back(maxVar);
-                                        _buf << prefix << indent() << "local "sv << maxVar << " = "sv << stopValue << nll(nameList);
+                                        if (stopStatus == NumState::Negtive) {
+                                                _buf << indent() << "local "sv << maxVar << " = "sv << "#"sv << listVar << " + "sv << stopValue << " + 1"sv << nll(nameList);
+                                        } else {
+                                                _buf << prefix << indent() << "local "sv << maxVar << " = "sv << stopValue << nll(nameList);
+                                        }
+                                }
+                                if (startStatus == NumState::Unknown) {
+                                        _buf << indent() << minVar << " = "sv << minVar << " < 0 and #"sv << listVar << " + "sv << minVar << " + 1 or "sv << minVar << nll(nameList);
+                                }
+                                if (!defaultStop && stopStatus == NumState::Unknown) {
+                                        _buf << indent() << maxVar << " = "sv << maxVar << " < 0 and #"sv << listVar << " + "sv << maxVar << " + 1 or "sv << maxVar << nll(nameList);
                                }
                                _buf << indent() << "for "sv << indexVar << " = "sv;
-                                _buf << startValue << ", "sv;
+                                if (startValue.empty()) {
+                                        _buf << "1"sv;
+                                } else {
+                                        switch (startStatus) {
+                                                case NumState::Unknown:
+                                                case NumState::Negtive:
+                                                        _buf << minVar;
+                                                        break;
+                                                case NumState::Positive:
+                                                        _buf << startValue;
+                                                        break;
+                                        }
+                                }
+                                _buf << ", "sv;
                                if (stopValue.empty()) {
                                        _buf << "#"sv << listVar;
                                } else {
-                                        _buf << maxVar << " < 0 and #"sv << listVar << " + "sv << maxVar << " or "sv << maxVar;
+                                        switch (stopStatus) {
+                                                case NumState::Unknown:
+                                                case NumState::Negtive:
+                                                        _buf << maxVar;
+                                                        break;
+                                                case NumState::Positive:
+                                                        _buf << stopValue;
+                                                        break;
+                                        }
                                }
                                if (!stepValue.empty()) {
                                        _buf << ", "sv << stepValue;
@@ -8012,7 +8496,7 @@ private:
                pushScope();
                for (const auto& var : vars) forceAddToScope(var);
                for (const auto& var : varAfter) addToScope(var);
-                if (!varConstAfter.empty()) markVarConst(varConstAfter);
+                if (!varConstAfter.empty()) markVarLocalConst(varConstAfter);
                if (!destructPairs.empty()) {
                        temp.clear();
                        for (auto& pair : destructPairs) {
@@ -8097,7 +8581,7 @@ private:
                _buf << indent() << "for "sv << varName << " = "sv << start << ", "sv << stop << (step.empty() ? Empty : ", "s + step) << " do"sv << nll(var);
                pushScope();
                forceAddToScope(varName);
-                markVarConst(varName);
+                markVarLocalConst(varName);
                out.push_back(clearBuf());
        }
@@ -8105,26 +8589,59 @@ private:
                transformForHead(forNode->varName, forNode->startValue, forNode->stopValue, forNode->stepValue, out);
        }
-        void transform_plain_body(ast_node* body, str_list& out, ExpUsage usage, ExpList_t* assignList = nullptr) {
+        void transform_plain_body(ast_node* bodyOrStmt, str_list& out, ExpUsage usage, ExpList_t* assignList = nullptr) {
-                switch (body->get_id()) {
+                switch (bodyOrStmt->get_id()) {
                        case id<Block_t>():
-                                transformBlock(static_cast<Block_t*>(body), out, usage, assignList);
+                                transformBlock(static_cast<Block_t*>(bodyOrStmt), out, usage, assignList);
                                break;
                        case id<Statement_t>(): {
-                                auto newBlock = body->new_ptr<Block_t>();
+                                auto newBlock = bodyOrStmt->new_ptr<Block_t>();
-                                newBlock->statements.push_back(body);
+                                newBlock->statements.push_back(bodyOrStmt);
                                transformBlock(newBlock, out, usage, assignList);
                                break;
                        }
-                        default: YUEE("AST node mismatch", body); break;
+                        default: YUEE("AST node mismatch", bodyOrStmt); break;
                }
        }
-        bool hasContinueStatement(ast_node* body) {
+        enum class BreakLoopType {
-                return traversal::Stop == body->traverse([&](ast_node* node) {
+                None = 0,
+                Break = 1,
+                BreakWithValue = 1 << 1,
+                Continue = 1 << 2
+        };
+        bool hasBreak(uint32_t breakLoopType) const {
+                return (breakLoopType & int(BreakLoopType::Break)) != 0;
+        }
+        bool hasBreakWithValue(uint32_t breakLoopType) const {
+                return (breakLoopType & int(BreakLoopType::BreakWithValue)) != 0;
+        }
+        bool hasContinue(uint32_t breakLoopType) const {
+                return (breakLoopType & int(BreakLoopType::Continue)) != 0;
+        }
+        uint32_t getBreakLoopType(ast_node* body, const std::string& varBWV) {
+                uint32_t type = 0;
+                body->traverse([&](ast_node* node) {
                        if (auto stmt = ast_cast<Statement_t>(node)) {
-                                if (stmt->content.is<BreakLoop_t>()) {
+                                if (auto breakLoop = stmt->content.as<BreakLoop_t>()) {
-                                        return _parser.toString(stmt->content) == "continue"sv ? traversal::Stop : traversal::Return;
+                                        if (breakLoop->type.is<Continue_t>()) {
+                                                type |= int(BreakLoopType::Continue);
+                                                return traversal::Return;
+                                        } else {
+                                                if (breakLoop->value) {
+                                                        if (varBWV.empty()) {
+                                                                throw CompileError("break with a value is not allowed here"sv, breakLoop->value);
+                                                        }
+                                                        type |= int(BreakLoopType::BreakWithValue);
+                                                        breakLoop->varBWV = varBWV;
+                                                } else {
+                                                        type |= int(BreakLoopType::Break);
+                                                }
+                                        }
                                } else if (auto expList = expListFrom(stmt)) {
                                        BLOCK_START
                                        auto value = singleValueFrom(expList);
@@ -8135,40 +8652,30 @@ private:
                                        switch (sVal->get_id()) {
                                                case id<With_t>(): {
                                                        auto withNode = static_cast<With_t*>(sVal);
-                                                        if (hasContinueStatement(withNode->body)) {
+                                                        type |= getBreakLoopType(withNode->body, varBWV);
-                                                                return traversal::Stop;
+                                                        return traversal::Return;
-                                                        }
-                                                        break;
                                                }
                                                case id<Do_t>(): {
                                                        auto doNode = static_cast<Do_t*>(sVal);
-                                                        if (hasContinueStatement(doNode->body)) {
+                                                        type |= getBreakLoopType(doNode->body, varBWV);
-                                                                return traversal::Stop;
+                                                        return traversal::Return;
-                                                        }
-                                                        break;
                                                }
                                                case id<If_t>(): {
                                                        auto ifNode = static_cast<If_t*>(sVal);
                                                        for (auto n : ifNode->nodes.objects()) {
-                                                                if (hasContinueStatement(n)) {
+                                                                type |= getBreakLoopType(n, varBWV);
-                                                                        return traversal::Stop;
-                                                                }
                                                        }
-                                                        break;
+                                                        return traversal::Return;
                                                }
                                                case id<Switch_t>(): {
                                                        auto switchNode = static_cast<Switch_t*>(sVal);
                                                        for (auto branch : switchNode->branches.objects()) {
-                                                                if (hasContinueStatement(static_cast<SwitchCase_t*>(branch)->body)) {
+                                                                type |= getBreakLoopType(static_cast<SwitchCase_t*>(branch)->body, varBWV);
-                                                                        return traversal::Stop;
-                                                                }
                                                        }
                                                        if (switchNode->lastBranch) {
-                                                                if (hasContinueStatement(switchNode->lastBranch)) {
+                                                                type |= getBreakLoopType(switchNode->lastBranch, varBWV);
-                                                                        return traversal::Stop;
-                                                                }
                                                        }
-                                                        break;
+                                                        return traversal::Return;
                                                }
                                        }
                                        BLOCK_END
@@ -8182,6 +8689,7 @@ private:
                        }
                        return traversal::Return;
                });
+                return type;
        }
        void addDoToLastLineReturn(ast_node* body) {
@@ -8205,10 +8713,10 @@ private:
                }
        }
-        void transformLoopBody(ast_node* body, str_list& out, const std::string& appendContent, ExpUsage usage, ExpList_t* assignList = nullptr) {
+        void transformLoopBody(ast_node* body, str_list& out, uint32_t breakLoopType, ExpUsage usage, ExpList_t* assignList = nullptr) {
                str_list temp;
                bool extraDo = false;
-                bool withContinue = hasContinueStatement(body);
+                bool withContinue = hasContinue(breakLoopType);
                int target = getLuaTarget(body);
                std::string extraLabel;
                if (withContinue) {
@@ -8217,7 +8725,7 @@ private:
                                        if (!block->statements.empty()) {
                                                auto stmt = static_cast<Statement_t*>(block->statements.back());
                                                if (auto breakLoop = ast_cast<BreakLoop_t>(stmt->content)) {
-                                                        extraDo = _parser.toString(breakLoop) == "break"sv;
+                                                        extraDo = breakLoop->type.is<Break_t>();
                                                }
                                        }
                                }
@@ -8250,9 +8758,6 @@ private:
                                        popScope();
                                        _buf << indent() << "end"sv << nll(body);
                                }
-                                if (!appendContent.empty()) {
-                                        _buf << indent() << appendContent;
-                                }
                                _buf << indent() << _continueVars.top().var << " = true"sv << nll(body);
                                popScope();
                                _buf << indent() << "until true"sv << nlr(body);
@@ -8262,14 +8767,9 @@ private:
                                temp.push_back(clearBuf());
                                _continueVars.pop();
                        } else {
-                                if (!appendContent.empty()) {
-                                        temp.push_back(indent() + appendContent);
-                                }
                                temp.push_back(extraLabel);
                                _continueVars.pop();
                        }
-                } else if (!appendContent.empty()) {
-                        temp.back().append(indent() + appendContent);
                }
                out.push_back(join(temp));
        }
@@ -8277,8 +8777,9 @@ private:
        std::string transformRepeatBody(Repeat_t* repeatNode, str_list& out) {
                str_list temp;
                bool extraDo = false;
-                auto body = repeatNode->body->content.get();
+                auto body = repeatNode->body.get();
-                bool withContinue = hasContinueStatement(body);
+                auto breakLoopType = getBreakLoopType(body, Empty);
+                bool withContinue = hasContinue(breakLoopType);
                std::string conditionVar;
                std::string extraLabel;
                ast_ptr<false, ExpListAssign_t> condAssign;
@@ -8289,7 +8790,7 @@ private:
                                        if (!block->statements.empty()) {
                                                auto stmt = static_cast<Statement_t*>(block->statements.back());
                                                if (auto breakLoop = ast_cast<BreakLoop_t>(stmt->content)) {
-                                                        extraDo = _parser.toString(breakLoop) == "break"sv;
+                                                        extraDo = breakLoop->type.is<Break_t>();
                                                }
                                        }
                                }
@@ -8352,7 +8853,8 @@ private:
        void transformFor(For_t* forNode, str_list& out) {
                str_list temp;
                transformForHead(forNode, temp);
-                transformLoopBody(forNode->body, temp, Empty, ExpUsage::Common);
+                auto breakLoopType = getBreakLoopType(forNode->body, Empty);
+                transformLoopBody(forNode->body, temp, breakLoopType, ExpUsage::Common);
                popScope();
                out.push_back(join(temp) + indent() + "end"s + nlr(forNode));
        }
@@ -8363,13 +8865,24 @@ private:
                addToScope(accum);
                std::string len = getUnusedName("_len_"sv);
                addToScope(len);
-                _buf << indent() << "local "sv << accum << " = { }"sv << nll(forNode);
+                auto breakLoopType = getBreakLoopType(forNode->body, accum);
+                _buf << indent() << "local "sv << accum << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(forNode);
+                out.emplace_back(clearBuf());
                _buf << indent() << "local "sv << len << " = 1"sv << nll(forNode);
-                out.push_back(clearBuf());
+                auto& lenAssign = out.emplace_back(clearBuf());
                transformForHead(forNode, out);
-                auto expList = toAst<ExpList_t>(accum + '[' + len + ']', x);
+                if (hasBreakWithValue(breakLoopType)) {
-                auto lenLine = len + " = "s + len + " + 1"s + nlr(forNode->body);
+                        lenAssign.clear();
-                transformLoopBody(forNode->body, out, lenLine, ExpUsage::Assignment, expList);
+                        transformLoopBody(forNode->body, out, breakLoopType, ExpUsage::Common);
+                } else {
+                        auto expList = toAst<ExpList_t>(accum + '[' + len + ']', x);
+                        auto followStmt = toAst<Statement_t>(len + "+=1"s, forNode->body);
+                        expList->followStmt = followStmt.get();
+                        transformLoopBody(forNode->body, out, breakLoopType, ExpUsage::Assignment, expList);
+                        if (!expList->followStmtProcessed) {
+                                lenAssign.clear();
+                        }
+                }
                popScope();
                out.push_back(indent() + "end"s + nlr(forNode));
                return accum;
@@ -8448,7 +8961,8 @@ private:
        void transformForEach(ForEach_t* forEach, str_list& out) {
                str_list temp;
                bool extraScoped = transformForEachHead(forEach->nameList, forEach->loopValue, temp, false);
-                transformLoopBody(forEach->body, temp, Empty, ExpUsage::Common);
+                auto breakLoopType = getBreakLoopType(forEach->body, Empty);
+                transformLoopBody(forEach->body, temp, breakLoopType, ExpUsage::Common);
                popScope();
                out.push_back(temp.front() + temp.back() + indent() + "end"s + nlr(forEach));
                if (extraScoped) {
@@ -8463,13 +8977,24 @@ private:
                addToScope(accum);
                std::string len = getUnusedName("_len_"sv);
                addToScope(len);
-                _buf << indent() << "local "sv << accum << " = { }"sv << nll(forEach);
+                auto breakLoopType = getBreakLoopType(forEach->body, accum);
+                _buf << indent() << "local "sv << accum << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(forEach);
+                out.emplace_back(clearBuf());
                _buf << indent() << "local "sv << len << " = 1"sv << nll(forEach);
-                out.push_back(clearBuf());
+                auto& lenAssign = out.emplace_back(clearBuf());
                transformForEachHead(forEach->nameList, forEach->loopValue, out, true);
-                auto expList = toAst<ExpList_t>(accum + '[' + len + ']', x);
+                if (hasBreakWithValue(breakLoopType)) {
-                auto lenLine = len + " = "s + len + " + 1"s + nlr(forEach->body);
+                        lenAssign.clear();
-                transformLoopBody(forEach->body, out, lenLine, ExpUsage::Assignment, expList);
+                        transformLoopBody(forEach->body, out, breakLoopType, ExpUsage::Common);
+                } else {
+                        auto expList = toAst<ExpList_t>(accum + '[' + len + ']', x);
+                        auto followStmt = toAst<Statement_t>(len + "+=1"s, forEach->body);
+                        expList->followStmt = followStmt.get();
+                        transformLoopBody(forEach->body, out, breakLoopType, ExpUsage::Assignment, expList);
+                        if (!expList->followStmtProcessed) {
+                                lenAssign.clear();
+                        }
+                }
                popScope();
                out.push_back(indent() + "end"s + nlr(forEach));
                return accum;
@@ -8653,12 +9178,64 @@ private:
                out.push_back(temp.empty() ? "\"\""s : join(temp, " .. "sv));
        }
+        void transformYAMLMultiline(YAMLMultiline_t* multiline, str_list& out) {
+                std::optional<std::string> indent;
+                str_list temp;
+                for (auto line_ : multiline->lines.objects()) {
+                        auto line = static_cast<YAMLLine_t*>(line_);
+                        auto indentStr = _parser.toString(line->indent);
+                        if (!indent) {
+                                indent = indentStr;
+                        }
+                        if (std::string_view{indentStr.c_str(), indent.value().size()} != indent.value()) {
+                                throw CompileError("inconsistent indent"sv, line);
+                        }
+                        indentStr = indentStr.substr(indent.value().size());
+                        str_list segs;
+                        bool firstSeg = true;
+                        for (auto seg_ : line->segments.objects()) {
+                                auto content = static_cast<YAMLLineContent_t*>(seg_)->content.get();
+                                switch (content->get_id()) {
+                                        case id<YAMLLineInner_t>(): {
+                                                auto seqStr = _parser.toString(content);
+                                                Utils::replace(seqStr, "\\#"sv, "#"sv);
+                                                if (firstSeg) {
+                                                        firstSeg = false;
+                                                        seqStr.insert(0, indentStr);
+                                                }
+                                                segs.push_back(Utils::toLuaDoubleString(seqStr));
+                                                break;
+                                        }
+                                        case id<Exp_t>(): {
+                                                if (firstSeg) {
+                                                        firstSeg = false;
+                                                        if (!indentStr.empty()) {
+                                                                segs.push_back(Utils::toLuaDoubleString(indentStr));
+                                                        }
+                                                }
+                                                transformExp(static_cast<Exp_t*>(content), segs, ExpUsage::Closure);
+                                                segs.back() = globalVar("tostring"sv, content, AccessType::Read) + '(' + segs.back() + ')';
+                                                break;
+                                        }
+                                        default: YUEE("AST node mismatch", content); break;
+                                }
+                        }
+                        temp.push_back(join(segs, " .. "sv));
+                }
+                auto str = join(temp, " .. '\\n' .. "sv);
+                Utils::replace(str, "\" .. '\\n' .. \""sv, "\\n"sv);
+                Utils::replace(str, "\" .. '\\n'"sv, "\\n\""sv);
+                Utils::replace(str, "'\\n' .. \""sv, "\"\\n"sv);
+                out.push_back(str);
+        }
        void transformString(String_t* string, str_list& out) {
                auto str = string->str.get();
                switch (str->get_id()) {
                        case id<SingleString_t>(): transformSingleString(static_cast<SingleString_t*>(str), out); break;
                        case id<DoubleString_t>(): transformDoubleString(static_cast<DoubleString_t*>(str), out); break;
                        case id<LuaString_t>(): transformLuaString(static_cast<LuaString_t*>(str), out); break;
+                        case id<YAMLMultiline_t>(): transformYAMLMultiline(static_cast<YAMLMultiline_t*>(str), out); break;
                        default: YUEE("AST node mismatch", str); break;
                }
        }
@@ -8840,7 +9417,7 @@ private:
                                                auto names = transformAssignDefs(assignment->expList.get(), DefOp::Get);
                                                for (const auto& name : names) {
                                                        forceAddToScope(name.first);
-                                                        markVarConst(name.first);
+                                                        markVarLocalConst(name.first);
                                                        varDefs.push_back(name.first);
                                                        classConstVars.push_back(name.first);
                                                }
@@ -8854,7 +9431,7 @@ private:
                                                                for (const auto& item : destruct.items) {
                                                                        if (!item.targetVar.empty()) {
                                                                                forceAddToScope(item.targetVar);
-                                                                                markVarConst(item.targetVar);
+                                                                                markVarLocalConst(item.targetVar);
                                                                                varDefs.push_back(item.targetVar);
                                                                                classConstVars.push_back(item.targetVar);
                                                                        }
@@ -9236,11 +9813,11 @@ private:
                std::string withVar;
                bool needScope = !currentScope().lastStatement && !returnValue;
                bool extraScope = false;
-                if (with->assigns) {
+                if (with->assign) {
                        auto vars = getAssignVars(with);
                        if (vars.front().empty() || isDeclaredAsGlobal(vars.front())) {
-                                if (with->assigns->values.objects().size() == 1) {
+                                if (with->assign->values.objects().size() == 1) {
-                                        auto var = singleVariableFrom(with->assigns->values.objects().front(), AccessType::Read);
+                                        auto var = singleVariableFrom(with->assign->values.objects().front(), AccessType::Read);
                                        if (!var.empty() && isLocal(var)) {
                                                withVar = var;
                                        }
@@ -9250,7 +9827,7 @@ private:
                                        auto assignment = x->new_ptr<ExpListAssign_t>();
                                        assignment->expList.set(toAst<ExpList_t>(withVar, x));
                                        auto assign = x->new_ptr<Assign_t>();
-                                        assign->values.push_back(with->assigns->values.objects().front());
+                                        assign->values.push_back(with->assign->values.objects().front());
                                        assignment->action.set(assign);
                                        if (needScope) {
                                                extraScope = true;
@@ -9264,7 +9841,7 @@ private:
                                auto assign = x->new_ptr<Assign_t>();
                                assign->values.push_back(toAst<Exp_t>(withVar, x));
                                bool skipFirst = true;
-                                for (auto value : with->assigns->values.objects()) {
+                                for (auto value : with->assign->values.objects()) {
                                        if (skipFirst) {
                                                skipFirst = false;
                                                continue;
@@ -9277,7 +9854,7 @@ private:
                                withVar = vars.front();
                                auto assignment = x->new_ptr<ExpListAssign_t>();
                                assignment->expList.set(with->valueList);
-                                assignment->action.set(with->assigns);
+                                assignment->action.set(with->assign);
                                if (needScope) {
                                        extraScope = true;
                                        temp.push_back(indent() + "do"s + nll(with));
@@ -9355,15 +9932,57 @@ private:
                        }
                }
                _withVars.push(withVar);
+                std::string breakWithVar;
+                if (assignList || returnValue) {
+                        auto breakLoopType = getBreakLoopType(with->body, withVar);
+                        if (hasBreakWithValue(breakLoopType)) {
+                                breakWithVar = withVar;
+                        }
+                }
                if (with->eop) {
                        auto ifNode = x->new_ptr<If_t>();
                        ifNode->type.set(toAst<IfType_t>("if"sv, x));
                        ifNode->nodes.push_back(toAst<IfCond_t>(withVar + "~=nil"s, x));
                        ifNode->nodes.push_back(with->body);
-                        transformIf(ifNode, temp, ExpUsage::Common);
+                        if (breakWithVar.empty()) {
+                                transformIf(ifNode, temp, ExpUsage::Common);
+                        } else {
+                                auto simpleValue = x->new_ptr<SimpleValue_t>();
+                                simpleValue->value.set(ifNode);
+                                auto exp = newExp(simpleValue, x);
+                                auto expList = x->new_ptr<ExpList_t>();
+                                expList->exprs.push_back(exp);
+                                auto expListAssign = x->new_ptr<ExpListAssign_t>();
+                                expListAssign->expList.set(expList);
+                                auto stmt = x->new_ptr<Statement_t>();
+                                stmt->content.set(expListAssign);
+                                auto repeatNode = toAst<Repeat_t>("repeat\n\t--\nuntil true"s, x);
+                                auto block = x->new_ptr<Block_t>();
+                                block->statements.push_back(stmt);
+                                repeatNode->body.set(block);
+                                auto sVal = x->new_ptr<SimpleValue_t>();
+                                sVal->value.set(repeatNode);
+                                auto asmt = assignmentFrom(toAst<Exp_t>(breakWithVar, x), newExp(sVal, x), x);
+                                transformAssignment(asmt, temp);
+                        }
                } else {
                        bool transformed = false;
-                        if (!extraScope && assignList) {
+                        if (!breakWithVar.empty()) {
+                                auto repeatNode = toAst<Repeat_t>("repeat\n\t--\nuntil true"s, x);
+                                auto block = x->new_ptr<Block_t>();
+                                if (auto blk = with->body.as<Block_t>()) {
+                                        block->statements.dup(blk->statements);
+                                } else {
+                                        auto stmt = with->body.to<Statement_t>();
+                                        block->statements.push_back(stmt);
+                                }
+                                repeatNode->body.set(block);
+                                auto sVal = x->new_ptr<SimpleValue_t>();
+                                sVal->value.set(repeatNode);
+                                auto asmt = assignmentFrom(toAst<Exp_t>(breakWithVar, x), newExp(sVal, x), x);
+                                transformAssignment(asmt, temp);
+                                transformed = true;
+                        } else if (!extraScope && assignList) {
                                if (auto block = with->body.as<Block_t>()) {
                                        if (!block->statements.empty()) {
                                                Statement_t* stmt = static_cast<Statement_t*>(block->statements.back());
@@ -9428,12 +10047,18 @@ private:
                switch (item->get_id()) {
                        case id<ClassDecl_t>(): {
                                auto classDecl = static_cast<ClassDecl_t*>(item);
+                                std::string varName;
                                if (classDecl->name) {
                                        if (auto var = classDecl->name->item.as<Variable_t>()) {
-                                                addGlobalVar(variableToString(var), classDecl->name->item);
+                                                varName = variableToString(var);
+                                                addGlobalVar(varName, var);
                                        }
                                }
+                                if (varName.empty()) {
+                                        throw CompileError("missing name for class", classDecl);
+                                }
                                transformClassDecl(classDecl, out, ExpUsage::Common);
+                                markVarGlobalConst(varName);
                                break;
                        }
                        case id<GlobalOp_t>():
@@ -9447,9 +10072,11 @@ private:
                                auto values = global->item.to<GlobalValues_t>();
                                if (values->valueList) {
                                        auto expList = x->new_ptr<ExpList_t>();
+                                        str_list varNames;
                                        for (auto name : values->nameList->names.objects()) {
                                                auto var = static_cast<Variable_t*>(name);
-                                                addGlobalVar(variableToString(var), var);
+                                                varNames.emplace_back(variableToString(var));
+                                                addGlobalVar(varNames.back(), var);
                                                auto callable = x->new_ptr<Callable_t>();
                                                callable->item.set(name);
                                                auto chainValue = x->new_ptr<ChainValue_t>();
@@ -9468,10 +10095,17 @@ private:
                                        }
                                        assignment->action.set(assign);
                                        transformAssignment(assignment, out);
+                                        for (const auto& name : varNames) {
+                                                markVarGlobalConst(name);
+                                        }
                                } else {
                                        for (auto name : values->nameList->names.objects()) {
                                                auto var = static_cast<Variable_t*>(name);
-                                                addGlobalVar(variableToString(var), var);
+                                                auto varName = variableToString(var);
+                                                addGlobalVar(varName, var);
+                                                if (global->constAttrib) {
+                                                        markVarGlobalConst(varName);
+                                                }
                                        }
                                }
                                break;
@@ -9820,8 +10454,47 @@ private:
                out.push_back(join(temp));
        }
-        void transformTry(Try_t* tryNode, str_list& out, ExpUsage usage) {
+        void transformTry(Try_t* tryNode, str_list& out, ExpUsage usage, ExpList_t* assignList = nullptr) {
                auto x = tryNode;
+                if (tryNode->eop && usage == ExpUsage::Assignment) {
+                        str_list rets;
+                        pushScope();
+                        auto okVar = getUnusedName("_ok_"sv);
+                        for (size_t i = 0; i < assignList->exprs.size(); i++) {
+                                auto retVar = getUnusedName("_ret_"sv);
+                                rets.emplace_back(retVar);
+                                addToScope(retVar);
+                        }
+                        popScope();
+                        auto varList = join(rets, ","sv);
+                        auto ifNode = toAst<If_t>("if "s + okVar + ',' + varList + ":=try nil then "s + varList, x);
+                        auto exp = ast_to<IfCond_t>(ifNode->nodes.front())->assignment->assign->values.front();
+                        auto sVal = simpleSingleValueFrom(exp);
+                        auto newTry = sVal->value.to<Try_t>();
+                        newTry->func.set(tryNode->func);
+                        newTry->catchBlock.set(tryNode->catchBlock);
+                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                        assignment->expList.set(assignList);
+                        auto assign = x->new_ptr<Assign_t>();
+                        assign->values.push_back(ifNode);
+                        assignment->action.set(assign);
+                        transformAssignment(assignment, out);
+                        return;
+                }
+                if (tryNode->eop && usage != ExpUsage::Common) {
+                        auto okVar = getUnusedName("_ok_"sv);
+                        auto code = "do\n\t"s + okVar + ", ... = try nil\n\t... if "s + okVar;
+                        auto doNode = toAst<Do_t>(code, x);
+                        auto block = doNode->body->content.to<Block_t>();
+                        auto asmt = static_cast<Statement_t*>(block->statements.front())->content.to<ExpListAssign_t>();
+                        auto assign = asmt->action.to<Assign_t>();
+                        auto sVal = simpleSingleValueFrom(assign->values.back());
+                        auto newTry = sVal->value.to<Try_t>();
+                        newTry->func.set(tryNode->func);
+                        newTry->catchBlock.set(tryNode->catchBlock);
+                        transformDo(doNode, out, usage);
+                        return;
+                }
                ast_ptr<true, Exp_t> errHandler;
                if (tryNode->catchBlock) {
                        auto catchBlock = tryNode->catchBlock.get();
@@ -10133,7 +10806,7 @@ private:
                out.push_back(join(temp));
                auto vars = getAssignVars(assignment);
                for (const auto& var : vars) {
-                        markVarConst(var);
+                        markVarLocalConst(var);
                }
        }
@@ -10361,12 +11034,36 @@ private:
                transformAssignment(assignment, out);
                if (auto var = ast_cast<Variable_t>(target)) {
                        auto moduleName = variableToString(var);
-                        markVarConst(moduleName);
+                        markVarLocalConst(moduleName);
                } else {
                        markDestructureConst(assignment);
                }
        }
+        void transformImportGlobal(ImportGlobal_t* importNode, str_list& out) {
+                auto uname = static_cast<UnicodeName_t*>(importNode->segs.front());
+                auto var = _parser.toString(uname);
+                auto isNormal = _parser.match<Name_t>(var) && _parser.match<Variable_t>(var);
+                auto varName = unicodeVariableFrom(uname);
+                str_list temp;
+                auto it = ++importNode->segs.objects().begin();
+                for (; it != importNode->segs.objects().end(); ++it) {
+                        temp.emplace_back(_parser.toString(*it));
+                }
+                temp.emplace_front(var);
+                if (isLocal(varName) || !isNormal) {
+                        temp.emplace_front("_G"s);
+                }
+                std::string stmt;
+                if (importNode->target) {
+                        stmt = "const "s + _parser.toString(importNode->target) + '=' + join(temp, "."sv);
+                } else {
+                        stmt = "const "s + temp.back() + '=' + join(temp, "."sv);
+                }
+                auto localAttrib = toAst<LocalAttrib_t>(stmt, importNode);
+                transformLocalAttrib(localAttrib, out);
+        }
        void transformImport(Import_t* import, str_list& out) {
                auto content = import->content.get();
                switch (content->get_id()) {
@@ -10379,6 +11076,9 @@ private:
                        case id<FromImport_t>():
                                transformFromImport(static_cast<FromImport_t*>(content), out);
                                break;
+                        case id<ImportGlobal_t>():
+                                transformImportGlobal(static_cast<ImportGlobal_t*>(content), out);
+                                break;
                        default: YUEE("AST node mismatch", content); break;
                }
        }
@@ -10398,15 +11098,27 @@ private:
                addToScope(accumVar);
                auto lenVar = getUnusedName("_len_"sv);
                addToScope(lenVar);
-                temp.push_back(indent() + "local "s + accumVar + " = { }"s + nll(whileNode));
+                auto breakLoopType = getBreakLoopType(whileNode->body, accumVar);
-                temp.push_back(indent() + "local "s + lenVar + " = 1"s + nll(whileNode));
+                _buf << indent() << "local "sv << accumVar << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(whileNode);
+                temp.emplace_back(clearBuf());
+                _buf << indent() << "local "s << lenVar << " = 1"s << nll(whileNode);
+                auto& lenAssign = temp.emplace_back(clearBuf());
                bool isUntil = _parser.toString(whileNode->type) == "until"sv;
                auto condStr = transformCondExp(whileNode->condition, isUntil);
                temp.push_back(indent() + "while "s + condStr + " do"s + nll(whileNode));
                pushScope();
-                auto assignLeft = toAst<ExpList_t>(accumVar + '[' + lenVar + ']', x);
+                if (hasBreakWithValue(breakLoopType)) {
-                auto lenLine = lenVar + " = "s + lenVar + " + 1"s + nlr(whileNode);
+                        lenAssign.clear();
-                transformLoopBody(whileNode->body, temp, lenLine, ExpUsage::Assignment, assignLeft);
+                        transformLoopBody(whileNode->body, temp, breakLoopType, ExpUsage::Common);
+                } else {
+                        auto assignLeft = toAst<ExpList_t>(accumVar + '[' + lenVar + ']', x);
+                        auto followStmt = toAst<Statement_t>(lenVar + "+=1"s, whileNode);
+                        assignLeft->followStmt = followStmt.get();
+                        transformLoopBody(whileNode->body, temp, breakLoopType, ExpUsage::Assignment, assignLeft);
+                        if (!assignLeft->followStmtProcessed) {
+                                lenAssign.clear();
+                        }
+                }
                popScope();
                temp.push_back(indent() + "end"s + nlr(whileNode));
                if (expList) {
@@ -10442,15 +11154,26 @@ private:
                addToScope(accumVar);
                auto lenVar = getUnusedName("_len_"sv);
                addToScope(lenVar);
-                temp.push_back(indent() + "local "s + accumVar + " = { }"s + nll(whileNode));
+                auto breakLoopType = getBreakLoopType(whileNode->body, accumVar);
-                temp.push_back(indent() + "local "s + lenVar + " = 1"s + nll(whileNode));
+                _buf << indent() << "local "sv << accumVar << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(whileNode);
+                temp.emplace_back(clearBuf());
+                auto& lenAssign = temp.emplace_back(indent() + "local "s + lenVar + " = 1"s + nll(whileNode));
                bool isUntil = _parser.toString(whileNode->type) == "until"sv;
                auto condStr = transformCondExp(whileNode->condition, isUntil);
                temp.push_back(indent() + "while "s + condStr + " do"s + nll(whileNode));
                pushScope();
-                auto assignLeft = toAst<ExpList_t>(accumVar + '[' + lenVar + ']', x);
+                if (hasBreakWithValue(breakLoopType)) {
-                auto lenLine = lenVar + " = "s + lenVar + " + 1"s + nlr(whileNode);
+                        lenAssign.clear();
-                transformLoopBody(whileNode->body, temp, lenLine, ExpUsage::Assignment, assignLeft);
+                        transformLoopBody(whileNode->body, temp, breakLoopType, ExpUsage::Common);
+                } else {
+                        auto assignLeft = toAst<ExpList_t>(accumVar + '[' + lenVar + ']', x);
+                        auto followStmt = toAst<Statement_t>(lenVar + "+=1"s, whileNode);
+                        assignLeft->followStmt = followStmt.get();
+                        transformLoopBody(whileNode->body, temp, breakLoopType, ExpUsage::Assignment, assignLeft);
+                        if (!assignLeft->followStmtProcessed) {
+                                lenAssign.clear();
+                        }
+                }
                popScope();
                temp.push_back(indent() + "end"s + nlr(whileNode));
                temp.push_back(indent() + "return "s + accumVar + nlr(whileNode));
@@ -10485,9 +11208,7 @@ private:
                        expListAssign->expList.set(expList);
                        auto stmt = x->new_ptr<Statement_t>();
                        stmt->content.set(expListAssign);
-                        auto body = x->new_ptr<Body_t>();
+                        repeat->body.set(stmt);
-                        body->content.set(stmt);
-                        repeat->body.set(body);
                        transformRepeat(repeat, out);
                        return;
                }
@@ -10495,7 +11216,8 @@ private:
                pushScope();
                bool isUntil = _parser.toString(whileNode->type) == "until"sv;
                auto condStr = transformCondExp(whileNode->condition, isUntil);
-                transformLoopBody(whileNode->body, temp, Empty, ExpUsage::Common);
+                auto breakLoopType = getBreakLoopType(whileNode->body, Empty);
+                transformLoopBody(whileNode->body, temp, breakLoopType, ExpUsage::Common);
                popScope();
                _buf << indent() << "while "sv << condStr << " do"sv << nll(whileNode);
                _buf << temp.back();
@@ -10503,6 +11225,106 @@ private:
                out.push_back(clearBuf());
        }
+        void transformRepeatInPlace(Repeat_t* repeatNode, str_list& out, ExpList_t* expList = nullptr) {
+                auto x = repeatNode;
+                str_list temp;
+                bool extraScope = false;
+                if (expList) {
+                        if (!currentScope().lastStatement) {
+                                extraScope = true;
+                                temp.push_back(indent() + "do"s + nll(repeatNode));
+                                pushScope();
+                        }
+                }
+                auto accumVar = getUnusedName("_accum_"sv);
+                addToScope(accumVar);
+                auto lenVar = getUnusedName("_len_"sv);
+                addToScope(lenVar);
+                auto breakLoopType = getBreakLoopType(repeatNode->body, accumVar);
+                _buf << indent() << "local "sv << accumVar << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(repeatNode);
+                temp.emplace_back(clearBuf());
+                _buf << indent() << "local "s << lenVar << " = 1"s << nll(repeatNode);
+                auto& lenAssign = temp.emplace_back(clearBuf());
+                auto condStr = transformCondExp(repeatNode->condition, false);
+                temp.push_back(indent() + "repeat"s + nll(repeatNode));
+                pushScope();
+                if (hasBreakWithValue(breakLoopType)) {
+                        lenAssign.clear();
+                        transformLoopBody(repeatNode->body, temp, breakLoopType, ExpUsage::Common);
+                } else {
+                        auto assignLeft = toAst<ExpList_t>(accumVar + '[' + lenVar + ']', x);
+                        auto followStmt = toAst<Statement_t>(lenVar + "+=1"s, repeatNode);
+                        assignLeft->followStmt = followStmt.get();
+                        transformLoopBody(repeatNode->body, temp, breakLoopType, ExpUsage::Assignment, assignLeft);
+                        if (!assignLeft->followStmtProcessed) {
+                                lenAssign.clear();
+                        }
+                }
+                popScope();
+                temp.push_back(indent() + "until "s + condStr + nlr(repeatNode));
+                if (expList) {
+                        auto assign = x->new_ptr<Assign_t>();
+                        assign->values.push_back(toAst<Exp_t>(accumVar, x));
+                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                        assignment->expList.set(expList);
+                        assignment->action.set(assign);
+                        transformAssignment(assignment, temp);
+                        if (extraScope) popScope();
+                } else {
+                        temp.push_back(indent() + "return "s + accumVar + nlr(repeatNode));
+                }
+                if (expList && extraScope) {
+                        temp.push_back(indent() + "end"s + nlr(repeatNode));
+                }
+                out.push_back(join(temp));
+        }
+        void transformRepeatClosure(Repeat_t* repeatNode, str_list& out) {
+                auto x = repeatNode;
+                auto simpleValue = x->new_ptr<SimpleValue_t>();
+                simpleValue->value.set(repeatNode);
+                if (transformAsUpValueFunc(newExp(simpleValue, x), out)) {
+                        return;
+                }
+                str_list temp;
+                pushAnonFunctionScope();
+                pushAnonVarArg();
+                std::string& funcStart = temp.emplace_back();
+                pushScope();
+                auto accumVar = getUnusedName("_accum_"sv);
+                addToScope(accumVar);
+                auto lenVar = getUnusedName("_len_"sv);
+                addToScope(lenVar);
+                auto breakLoopType = getBreakLoopType(repeatNode->body, accumVar);
+                _buf << indent() << "local "sv << accumVar << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(repeatNode);
+                temp.emplace_back(clearBuf());
+                auto& lenAssign = temp.emplace_back(indent() + "local "s + lenVar + " = 1"s + nll(repeatNode));
+                auto condStr = transformCondExp(repeatNode->condition, false);
+                temp.push_back(indent() + "repeat"s + nll(repeatNode));
+                pushScope();
+                if (hasBreakWithValue(breakLoopType)) {
+                        lenAssign.clear();
+                        transformLoopBody(repeatNode->body, temp, breakLoopType, ExpUsage::Common);
+                } else {
+                        auto assignLeft = toAst<ExpList_t>(accumVar + '[' + lenVar + ']', x);
+                        auto followStmt = toAst<Statement_t>(lenVar + "+=1"s, repeatNode);
+                        assignLeft->followStmt = followStmt.get();
+                        transformLoopBody(repeatNode->body, temp, breakLoopType, ExpUsage::Assignment, assignLeft);
+                        if (!assignLeft->followStmtProcessed) {
+                                lenAssign.clear();
+                        }
+                }
+                popScope();
+                temp.push_back(indent() + "until "s + condStr + nlr(repeatNode));
+                temp.push_back(indent() + "return "s + accumVar + nlr(repeatNode));
+                popScope();
+                funcStart = anonFuncStart() + nll(repeatNode);
+                temp.push_back(indent() + anonFuncEnd());
+                popAnonVarArg();
+                popFunctionScope();
+                out.push_back(join(temp));
+        }
        void transformRepeat(Repeat_t* repeat, str_list& out) {
                str_list temp;
                pushScope();
@@ -10536,10 +11358,26 @@ private:
                        pushScope();
                }
                bool extraScope = false;
+                if (switchNode->assignment) {
+                        if (needScope) {
+                                extraScope = true;
+                                temp.push_back(indent() + "do"s + nll(x));
+                                pushScope();
+                        }
+                        auto asmt = x->new_ptr<ExpListAssign_t>();
+                        auto expList = x->new_ptr<ExpList_t>();
+                        expList->exprs.push_back(switchNode->target);
+                        if (switchNode->assignment->expList) {
+                                expList->exprs.dup(switchNode->assignment->expList->exprs);
+                        }
+                        asmt->expList.set(expList);
+                        asmt->action.set(switchNode->assignment->assign);
+                        transformAssignment(asmt, temp);
+                }
                auto objVar = singleVariableFrom(switchNode->target, AccessType::Read);
                if (objVar.empty() || !isLocal(objVar)) {
                        if (usage == ExpUsage::Common || usage == ExpUsage::Assignment) {
-                                if (needScope) {
+                                if (needScope && !extraScope) {
                                        extraScope = true;
                                        temp.push_back(indent() + "do"s + nll(x));
                                        pushScope();
@@ -10597,8 +11435,9 @@ private:
                                }
                                temp.back().append(indent() + "if "s + tabCheckVar + " then"s + nll(branch));
                                pushScope();
-                                auto assignment = assignmentFrom(static_cast<Exp_t*>(valueList->exprs.front()), toAst<Exp_t>(objVar, branch), branch);
+                                auto chainValue = toAst<ChainValue_t>(objVar, branch);
-                                auto info = extractDestructureInfo(assignment, true, false);
+                                auto assignment = assignmentFrom(static_cast<Exp_t*>(valueList->exprs.front()), newExp(chainValue, branch), branch);
+                                auto info = extractDestructureInfo(assignment, true, true);
                                transformAssignment(assignment, temp, true);
                                str_list conds;
                                for (const auto& des : info.destructures) {
@@ -10608,8 +11447,31 @@ private:
                                        const auto& destruct = std::get<Destructure>(des);
                                        for (const auto& item : destruct.items) {
                                                if (!item.defVal) {
-                                                        transformExp(item.target, conds, ExpUsage::Closure);
+                                                        if (!isAssignable(item.target)) {
-                                                        conds.back().append(" ~= nil"s);
+                                                                auto callable = chainValue->items.front();
+                                                                auto chain = callable->new_ptr<ChainValue_t>();
+                                                                chain->items.push_back(callable);
+                                                                chain->items.dup(item.structure->items);
+                                                                if (specialChainValue(chain) == ChainType::Common) {
+                                                                        transformChainValue(chain, conds, ExpUsage::Closure);
+                                                                        auto vStr = conds.back();
+                                                                        conds.pop_back();
+                                                                        transformExp(item.target, conds, ExpUsage::Closure);
+                                                                        conds.back().append(" == "s);
+                                                                        conds.back().append(vStr);
+                                                                } else {
+                                                                        auto varName = getUnusedName("_val_"sv);
+                                                                        auto vExp = toAst<Exp_t>(varName, chain);
+                                                                        auto asmt = assignmentFrom(vExp, newExp(chain, chain), chain);
+                                                                        transformAssignment(asmt, temp);
+                                                                        transformExp(item.target, conds, ExpUsage::Closure);
+                                                                        conds.back().append(" == "s);
+                                                                        conds.back().append(varName);
+                                                                }
+                                                        } else {
+                                                                transformExp(item.target, conds, ExpUsage::Closure);
+                                                                conds.back().append(" ~= nil"s);
+                                                        }
                                                }
                                        }
                                }
@@ -10907,7 +11769,7 @@ private:
                        }
                        transformAssignment(assignment, temp);
                        for (const auto& name : vars) {
-                                markVarConst(name);
+                                markVarLocalConst(name);
                        }
                        if (localAttrib->attrib.is<CloseAttrib_t>()) {
                                str_list leftVars, rightVars;
@@ -10979,7 +11841,7 @@ private:
                                temp.push_back(indent() + "local "s + join(leftVars, ", "sv) + " = "s + join(items, ", "sv) + nll(x));
                        }
                        for (const auto& var : vars) {
-                                markVarConst(var);
+                                markVarLocalConst(var);
                        }
                }
                if (!listB->exprs.empty()) {
@@ -11004,18 +11866,24 @@ private:
                        temp.push_back(indent() + "local "s + join(vars, ", "sv) + nll(x));
                        transformAssignment(assignment, temp);
                        for (const auto& name : vars) {
-                                markVarConst(name);
+                                markVarLocalConst(name);
                        }
                }
                out.push_back(join(temp));
        }
        void transformBreakLoop(BreakLoop_t* breakLoop, str_list& out) {
-                auto keyword = _parser.toString(breakLoop);
+                auto isBreak = breakLoop->type.is<Break_t>();
+                auto keyword = isBreak ? "break"s : "continue"s;
                if (_enableBreakLoop.empty() || !_enableBreakLoop.top()) {
                        throw CompileError(keyword + " is not inside a loop"s, breakLoop);
                }
-                if (keyword == "break"sv) {
+                if (isBreak) {
+                        if (breakLoop->value) {
+                                auto exp = toAst<Exp_t>(breakLoop->varBWV, breakLoop->value);
+                                auto assignment = assignmentFrom(exp, breakLoop->value, breakLoop);
+                                transformAssignment(assignment, out);
+                        }
                        out.push_back(indent() + keyword + nll(breakLoop));
                        return;
                }
diff --git a/src/yuescript/yue_compiler.h b/src/yuescript/yue_compiler.h
index d352636..aff5978 100644
--- a/src/yuescript/yue_compiler.h
+++ b/src/yuescript/yue_compiler.h
@@ -31,6 +31,7 @@ struct YueConfig {
        bool reserveLineNumber = true;
        bool useSpaceOverTab = false;
        bool reserveComment = false;
+        bool lax = false;
        // internal options
        bool exporting = false;
        bool profiling = false;
diff --git a/src/yuescript/yue_parser.cpp b/src/yuescript/yue_parser.cpp
index 77c5901..1942e23 100644
--- a/src/yuescript/yue_parser.cpp
+++ b/src/yuescript/yue_parser.cpp
@@ -118,8 +118,8 @@ YueParser::YueParser() {
                return false;
        });
-        if_assignment_syntax_error = pl::user(true_(), [](const item_t& item) {
+        assignment_expression_syntax_error = pl::user(true_(), [](const item_t& item) {
-                throw ParserError("use := for if-assignment expression"sv, item.begin);
+                throw ParserError("use := for assignment expression"sv, item.begin);
                return false;
        });
@@ -162,6 +162,13 @@ YueParser::YueParser() {
                ) \
        )
+        #define disable_until_rule(patt) ( \
+                disable_until >> ( \
+                        (patt) >> enable_until | \
+                        enable_until >> cut \
+                ) \
+        )
        #define body_with(str) ( \
                key(str) >> space >> (in_block | Statement) | \
                in_block | \
@@ -325,7 +332,7 @@ YueParser::YueParser() {
                Exp;
        import_tab_list = import_tab_item >> *(space >> ',' >> space >> import_tab_item);
        import_tab_line = (
-                push_indent_match >> (space >> import_tab_list >> pop_indent | pop_indent)
+                push_indent_match >> ensure(space >> import_tab_list, pop_indent)
        ) | space;
        import_tab_lines = space_break >> import_tab_line >> *(-(space >> ',') >> space_break >> import_tab_line) >> -(space >> ',');
        import_tab_key_value = key_value | ':' >> MacroName | MacroNamePair | ImportAllMacro;
@@ -342,7 +349,9 @@ YueParser::YueParser() {
        ImportAs = ImportLiteral >> -(space >> key("as") >> space >> (ImportTabLit | Variable | ImportAllMacro));
-        Import = key("import") >> space >> (ImportAs | ImportFrom) | FromImport;
+        ImportGlobal = Seperator >> UnicodeName >> *('.' >> UnicodeName) >> -(space >> key("as") >> space >> Variable);
+        Import = key("import") >> space >> (ImportAs | ImportFrom | ImportGlobal) | FromImport;
        Label = "::" >> LabelName >> "::";
@@ -350,11 +359,13 @@ YueParser::YueParser() {
        ShortTabAppending = "[]" >> space >> Assign;
-        BreakLoop = (expr("break") | "continue") >> not_alpha_num;
+        Break = key("break");
+        Continue = key("continue");
+        BreakLoop = (Break >> -(space >> Exp) | Continue) >> not_alpha_num;
        Return = key("return") >> -(space >> (TableBlock | ExpListLow));
-        with_exp = ExpList >> -(space >> Assign);
+        with_exp = ExpList >> -(space >> (':' >> Assign | and_('=') >> assignment_expression_syntax_error));
        With = key("with") >> -ExistentialOp >> space >> disable_do_chain_arg_table_block_rule(with_exp) >> space >> body_with("do");
        SwitchCase = key("when") >> space >> disable_chain_rule(disable_arg_table_block_rule(SwitchList)) >> space >> body_with("then");
@@ -370,7 +381,8 @@ YueParser::YueParser() {
                and_(SimpleTable | TableLit) >> Exp |
                exp_not_tab >> *(space >> ',' >> space >> exp_not_tab)
        );
-        Switch = key("switch") >> space >> Exp >>
+        Switch = key("switch") >> space >>
+                Exp >> -(space >> Assignment) >>
                space >> Seperator >> (
                        SwitchCase >> space >> (
                                switch_block |
@@ -379,20 +391,26 @@ YueParser::YueParser() {
                        +space_break >> advance_match >> space >> SwitchCase >> switch_block >> pop_indent
                );
-        Assignment = -(',' >> space >> ExpList >> space) >> (':' >> Assign | and_('=') >> if_assignment_syntax_error);
+        Assignment = -(',' >> space >> ExpList >> space) >> (':' >> Assign | and_('=') >> assignment_expression_syntax_error);
        IfCond = disable_chain_rule(disable_arg_table_block_rule(Exp >> -(space >> Assignment)));
        if_else_if = -(line_break >> *space_break >> check_indent_match) >> space >> key("elseif") >> space >> IfCond >> space >> body_with("then");
        if_else = -(line_break >> *space_break >> check_indent_match) >> space >> key("else") >> space >> body;
        IfType = (expr("if") | "unless") >> not_alpha_num;
        If = IfType >> space >> IfCond >> space >> opt_body_with("then") >> *if_else_if >> -if_else;
-        WhileType = (expr("while") | "until") >> not_alpha_num;
+        WhileType = (expr("while") | pl::user("until", [](const item_t& item) {
-        While = WhileType >> space >> disable_do_chain_arg_table_block_rule(Exp >> -(space >> Assignment)) >> space >> opt_body_with("do");
+                State* st = reinterpret_cast<State*>(item.user_data);
-        Repeat = key("repeat") >> space >> Body >> line_break >> *space_break >> check_indent_match >> space >> key("until") >> space >> Exp;
+                return st->noUntilStack.empty() || !st->noUntilStack.back();
+        })) >> not_alpha_num;
+        While = key(WhileType) >> space >> disable_do_chain_arg_table_block_rule(Exp >> -(space >> Assignment)) >> space >> opt_body_with("do");
+        Repeat = key("repeat") >> space >> (
+                in_block >> line_break >> *space_break >> check_indent_match |
+                disable_until_rule(Statement)
+        ) >> space >> key("until") >> space >> Exp;
        for_key = pl::user(key("for"), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                return st->noForStack.empty() || !st->noForStack.top();
+                return st->noForStack.empty() || !st->noForStack.back();
        });
        ForStepValue = ',' >> space >> Exp;
        for_args = Variable >> space >> '=' >> space >> Exp >> space >> ',' >> space >> Exp >> space >> -ForStepValue;
@@ -406,18 +424,18 @@ YueParser::YueParser() {
        Do = pl::user(key("do"), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                return st->noDoStack.empty() || !st->noDoStack.top();
+                return st->noDoStack.empty() || !st->noDoStack.back();
        }) >> space >> Body;
        disable_do = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noDoStack.push(true);
+                st->noDoStack.push_back(true);
                return true;
        });
        enable_do = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noDoStack.pop();
+                st->noDoStack.pop_back();
                return true;
        });
@@ -435,46 +453,58 @@ YueParser::YueParser() {
        disable_do_chain_arg_table_block = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noDoStack.push(true);
+                st->noDoStack.push_back(true);
-                st->noChainBlockStack.push(true);
+                st->noChainBlockStack.push_back(true);
-                st->noTableBlockStack.push(true);
+                st->noTableBlockStack.push_back(true);
                return true;
        });
        enable_do_chain_arg_table_block = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noDoStack.pop();
+                st->noDoStack.pop_back();
-                st->noChainBlockStack.pop();
+                st->noChainBlockStack.pop_back();
-                st->noTableBlockStack.pop();
+                st->noTableBlockStack.pop_back();
                return true;
        });
        disable_arg_table_block = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noTableBlockStack.push(true);
+                st->noTableBlockStack.push_back(true);
                return true;
        });
        enable_arg_table_block = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noTableBlockStack.pop();
+                st->noTableBlockStack.pop_back();
                return true;
        });
        disable_for = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noForStack.push(true);
+                st->noForStack.push_back(true);
                return true;
        });
        enable_for = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noForStack.pop();
+                st->noForStack.pop_back();
+                return true;
+        });
+        disable_until = pl::user(true_(), [](const item_t& item) {
+                State* st = reinterpret_cast<State*>(item.user_data);
+                st->noUntilStack.push_back(true);
+                return true;
+        });
+        enable_until = pl::user(true_(), [](const item_t& item) {
+                State* st = reinterpret_cast<State*>(item.user_data);
+                st->noUntilStack.pop_back();
                return true;
        });
        CatchBlock = line_break >> *space_break >> check_indent_match >> space >> key("catch") >> space >> Variable >> space >> in_block;
-        Try = key("try") >> space >> (in_block | Exp) >> -CatchBlock;
+        Try = key("try") >> -ExistentialOp >> space >> (in_block | Exp) >> -CatchBlock;
        list_value =
                and_(
@@ -561,20 +591,20 @@ YueParser::YueParser() {
        disable_chain = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noChainBlockStack.push(true);
+                st->noChainBlockStack.push_back(true);
                return true;
        });
        enable_chain = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                st->noChainBlockStack.pop();
+                st->noChainBlockStack.pop_back();
                return true;
        });
        chain_line = check_indent_match >> space >> (chain_dot_chain | colon_chain) >> -InvokeArgs;
        chain_block = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                return st->noChainBlockStack.empty() || !st->noChainBlockStack.top();
+                return st->noChainBlockStack.empty() || !st->noChainBlockStack.back();
        }) >> +space_break >> advance_match >> ensure(
                chain_line >> *(+space_break >> chain_line), pop_indent);
        ChainValue =
@@ -611,7 +641,15 @@ YueParser::YueParser() {
        DoubleStringInner = +(not_("#{") >> double_string_plain);
        DoubleStringContent = DoubleStringInner | interp;
        DoubleString = '"' >> Seperator >> *DoubleStringContent >> '"';
-        String = DoubleString | SingleString | LuaString;
+        YAMLIndent = +set(" \t");
+        YAMLLineInner = +('\\' >> set("\"\\#") | not_("#{" | stop) >> any_char);
+        YAMLLineContent = YAMLLineInner | interp;
+        YAMLLine = check_indent_match >> YAMLIndent >> +(YAMLLineContent) |
+                advance_match >> YAMLIndent >> ensure(+YAMLLineContent, pop_indent);
+        YAMLMultiline = '|' >> space >> Seperator >> +(*set(" \t") >> line_break) >> advance_match >> ensure(YAMLLine >> *(+(*set(" \t") >> line_break) >> YAMLLine), pop_indent);
+        String = DoubleString | SingleString | LuaString | YAMLMultiline;
        lua_string_open = '[' >> *expr('=') >> '[';
        lua_string_close = ']' >> *expr('=') >> ']';
@@ -639,7 +677,7 @@ YueParser::YueParser() {
        fn_args_value_list = Exp >> *(space >> ',' >> space >> Exp);
        fn_args_lit_line = (
-                push_indent_match >> (space >> fn_args_value_list >> pop_indent | pop_indent)
+                push_indent_match >> ensure(space >> fn_args_value_list, pop_indent)
        ) | (
                space
        );
@@ -681,7 +719,8 @@ YueParser::YueParser() {
        chain_with_colon = +chain_item >> -colon_chain;
        chain_items = chain_with_colon | colon_chain;
-        index = '[' >> not_('[') >> space >> Exp >> space >> ']';
+        index = '[' >> not_('[') >> space >> (ReversedIndex >> and_(space >> ']') | Exp) >> space >> ']';
+        ReversedIndex = '#' >> space >> -('-' >> space >> Exp);
        chain_item =
                Invoke >> -ExistentialOp |
                DotChainItem >> -ExistentialOp |
@@ -738,7 +777,7 @@ YueParser::YueParser() {
        table_block_inner = Seperator >> key_value_line >> *(+space_break >> key_value_line);
        TableBlock = +space_break >> advance_match >> ensure(table_block_inner, pop_indent);
-        TableBlockIndent = '*' >> Seperator >> disable_arg_table_block_rule(
+        TableBlockIndent = ('*' | '-' >> space_one) >> Seperator >> disable_arg_table_block_rule(
                space >> key_value_list >> -(space >> ',') >>
                -(+space_break >> advance_match >> space >> ensure(key_value_list >> -(space >> ',') >> *(+space_break >> key_value_line), pop_indent)));
@@ -759,7 +798,7 @@ YueParser::YueParser() {
        GlobalValues = NameList >> -(space >> '=' >> space >> (TableBlock | ExpListLow));
        GlobalOp = expr('*') | '^';
-        Global = key("global") >> space >> (ClassDecl | GlobalOp | GlobalValues);
+        Global = key("global") >> space >> (-(ConstAttrib >> space) >> ClassDecl | GlobalOp | -(ConstAttrib >> space) >> GlobalValues);
        ExportDefault = key("default");
@@ -841,24 +880,24 @@ YueParser::YueParser() {
        key_value_line = check_indent_match >> space >> (
                key_value_list >> -(space >> ',') |
                TableBlockIndent |
-                '*' >> space >> (SpreadExp | Exp | TableBlock)
+                ('*' | '-' >> space_one) >> space >> (SpreadExp | Exp | TableBlock)
        );
        fn_arg_def_list = FnArgDef >> *(space >> ',' >> space >> FnArgDef);
        fn_arg_def_lit_line = (
-                push_indent_match >> (space >> fn_arg_def_list >> pop_indent | pop_indent)
+                push_indent_match >> ensure(space >> fn_arg_def_list, pop_indent)
        ) | (
                space
        );
        fn_arg_def_lit_lines = fn_arg_def_lit_line >> *(-(space >> ',') >> space_break >> fn_arg_def_lit_line);
-        FnArgDef = (Variable | SelfItem >> -ExistentialOp) >> -(space >> '=' >> space >> Exp);
+        FnArgDef = (Variable | SelfItem >> -ExistentialOp) >> -(space >> '`' >> space >> Name) >> -(space >> '=' >> space >> Exp);
        FnArgDefList = Seperator >> (
-                fn_arg_def_lit_lines >> -(-(space >> ',') >> white >> VarArg) |
+                fn_arg_def_lit_lines >> -(-(space >> ',') >> white >> VarArg >> -(space >> '`' >> space >> Name)) |
-                white >> VarArg
+                white >> VarArg >> -(space >> '`' >> space >> Name)
        );
        OuterVarShadow = key("using") >> space >> (NameList | key("nil"));
@@ -887,6 +926,7 @@ YueParser::YueParser() {
        FnArrowBack = '<' >> set("-=");
        Backcall = -(FnArgsDef >> space) >> FnArrowBack >> space >> ChainValue;
+        SubBackcall = FnArrowBack >> space >> ChainValue;
        PipeBody = Seperator >>
                pipe_operator >> space >> UnaryExp >>
@@ -900,7 +940,7 @@ YueParser::YueParser() {
        arg_table_block = pl::user(true_(), [](const item_t& item) {
                State* st = reinterpret_cast<State*>(item.user_data);
-                return st->noTableBlockStack.empty() || !st->noTableBlockStack.top();
+                return st->noTableBlockStack.empty() || !st->noTableBlockStack.back();
        }) >> TableBlock;
        invoke_args_with_table =
@@ -940,11 +980,11 @@ YueParser::YueParser() {
        SimpleValue =
                TableLit | ConstValue | If | Switch | Try | With |
-                ClassDecl | ForEach | For | While | Do |
+                ClassDecl | ForEach | For | While | Repeat | Do |
                UnaryValue | TblComprehension | Comprehension |
                FunLit | Num | VarArg;
-        ExpListAssign = ExpList >> -(space >> (Update | Assign)) >> not_(space >> '=');
+        ExpListAssign = ExpList >> -(space >> (Update | Assign | SubBackcall)) >> not_(space >> '=');
        IfLine = IfType >> space >> IfCond;
        WhileLine = WhileType >> space >> Exp;
@@ -1001,11 +1041,16 @@ YueParser::YueParser() {
                empty_line_break |
                advance_match >> ensure(space >> (indentation_error | Statement), pop_indent)
        );
-        Block = Seperator >> line >> *(+line_break >> line);
+        Block = Seperator >> (pl::user(true_(), [](const item_t& item) {
+                State* st = reinterpret_cast<State*>(item.user_data);
+                return st->lax;
+        }) >> lax_line >> *(+line_break >> lax_line) | line >> *(+line_break >> line));
        shebang = "#!" >> *(not_(stop) >> any_char);
        BlockEnd = Block >> white >> stop;
        File = -shebang >> -Block >> white >> stop;
+        lax_line = advance_match >> ensure(*(not_(stop) >> any()), pop_indent) | line >> and_(stop) | check_indent_match >> *(not_(stop) >> any());
 }
 // clang-format on
@@ -1035,7 +1080,7 @@ bool YueParser::startWith(std::string_view codes, rule& r) {
        return true;
 }
-ParseInfo YueParser::parse(std::string_view codes, rule& r) {
+ParseInfo YueParser::parse(std::string_view codes, rule& r, bool lax) {
        ParseInfo res;
        if (codes.substr(0, 3) == "\xEF\xBB\xBF"sv) {
                codes = codes.substr(3);
@@ -1053,6 +1098,7 @@ ParseInfo YueParser::parse(std::string_view codes, rule& r) {
        error_list errors;
        try {
                State state;
+                state.lax = lax;
                res.node.set(::yue::parse(*(res.codes), r, errors, &state));
                if (state.exportCount > 0) {
                        int index = 0;
@@ -1090,19 +1136,21 @@ ParseInfo YueParser::parse(std::string_view codes, rule& r) {
        return res;
 }
-ParseInfo YueParser::parse(std::string_view astName, std::string_view codes) {
+ParseInfo YueParser::parse(std::string_view astName, std::string_view codes, bool lax) {
        auto it = _rules.find(astName);
        if (it != _rules.end()) {
-                return parse(codes, *it->second);
+                return parse(codes, *it->second, lax);
        }
-        return {};
+        ParseInfo info{};
+        info.error = ParseInfo::Error{"invalid rule: "s + std::string{astName}, 1, 1};
+        return info;
 }
 bool YueParser::match(std::string_view astName, std::string_view codes) {
        auto it = _rules.find(astName);
        if (it != _rules.end()) {
                auto rEnd = rule(*it->second >> eof());
-                return parse(codes, rEnd).node;
+                return parse(codes, rEnd, false).node;
        }
        return false;
 }
@@ -1138,6 +1186,24 @@ void trim(std::string& str) {
        str.erase(0, str.find_first_not_of(" \t\r\n"));
        str.erase(str.find_last_not_of(" \t\r\n") + 1);
 }
+std::string toLuaDoubleString(const std::string& input) {
+        std::string luaStr = "\"";
+        for (char c : input) {
+                switch (c) {
+                        case '\"': luaStr += "\\\""; break;
+                        case '\\': luaStr += "\\\\"; break;
+                        case '\n': luaStr += "\\n"; break;
+                        case '\r': luaStr += "\\r"; break;
+                        case '\t': luaStr += "\\t"; break;
+                        default:
+                                luaStr += c;
+                                break;
+                }
+        }
+        luaStr += "\"";
+        return luaStr;
+}
 } // namespace Utils
 std::string ParseInfo::errorMessage(std::string_view msg, int errLine, int errCol, int lineOffset) const {
diff --git a/src/yuescript/yue_parser.h b/src/yuescript/yue_parser.h
index 7281ec3..c91e530 100644
--- a/src/yuescript/yue_parser.h
+++ b/src/yuescript/yue_parser.h
@@ -74,16 +74,16 @@ extern std::unordered_set<std::string> Keywords;
 class YueParser {
 public:
        template <class AST>
-        ParseInfo parse(std::string_view codes) {
+        ParseInfo parse(std::string_view codes, bool lax) {
-                return parse(codes, getRule<AST>());
+                return parse(codes, getRule<AST>(), lax);
        }
-        ParseInfo parse(std::string_view astName, std::string_view codes);
+        ParseInfo parse(std::string_view astName, std::string_view codes, bool lax);
        template <class AST>
        bool match(std::string_view codes) {
                auto rEnd = rule(getRule<AST>() >> eof());
-                return parse(codes, rEnd).node;
+                return parse(codes, rEnd, false).node;
        }
        bool match(std::string_view astName, std::string_view codes);
@@ -102,13 +102,14 @@ public:
 protected:
        YueParser();
-        ParseInfo parse(std::string_view codes, rule& r);
+        ParseInfo parse(std::string_view codes, rule& r, bool lax);
        bool startWith(std::string_view codes, rule& r);
        struct State {
                State() {
                        indents.push(0);
                }
+                bool lax = false;
                bool exportDefault = false;
                bool exportMacro = false;
                bool exportMetatable = false;
@@ -119,10 +120,11 @@ protected:
                size_t stringOpen = 0;
                std::string buffer;
                std::stack<int> indents;
-                std::stack<bool> noDoStack;
+                std::vector<bool> noDoStack;
-                std::stack<bool> noChainBlockStack;
+                std::vector<bool> noChainBlockStack;
-                std::stack<bool> noTableBlockStack;
+                std::vector<bool> noTableBlockStack;
-                std::stack<bool> noForStack;
+                std::vector<bool> noForStack;
+                std::vector<bool> noUntilStack;
                std::unordered_set<std::string> usedNames;
        };
@@ -156,7 +158,7 @@ private:
        NONE_AST_RULE(invalid_interpolation_error);
        NONE_AST_RULE(confusing_unary_not_error);
        NONE_AST_RULE(table_key_pair_error);
-        NONE_AST_RULE(if_assignment_syntax_error);
+        NONE_AST_RULE(assignment_expression_syntax_error);
        NONE_AST_RULE(inc_exp_level);
        NONE_AST_RULE(dec_exp_level);
@@ -217,6 +219,8 @@ private:
        NONE_AST_RULE(enable_for);
        NONE_AST_RULE(enable_fun_lit);
        NONE_AST_RULE(disable_fun_lit);
+        NONE_AST_RULE(disable_until);
+        NONE_AST_RULE(enable_until);
        NONE_AST_RULE(switch_else);
        NONE_AST_RULE(switch_block);
        NONE_AST_RULE(if_else_if);
@@ -284,6 +288,7 @@ private:
        NONE_AST_RULE(yue_line_comment);
        NONE_AST_RULE(line);
        NONE_AST_RULE(shebang);
+        NONE_AST_RULE(lax_line);
        AST_RULE(Num);
        AST_RULE(Name);
@@ -315,12 +320,14 @@ private:
        AST_RULE(ImportAllMacro);
        AST_RULE(ImportTabLit);
        AST_RULE(ImportAs);
+        AST_RULE(ImportGlobal);
        AST_RULE(Import);
        AST_RULE(Label);
        AST_RULE(Goto);
        AST_RULE(ShortTabAppending);
        AST_RULE(FnArrowBack);
        AST_RULE(Backcall);
+        AST_RULE(SubBackcall);
        AST_RULE(PipeBody);
        AST_RULE(ExpListLow);
        AST_RULE(ExpList);
@@ -359,6 +366,7 @@ private:
        AST_RULE(ExpOpValue);
        AST_RULE(Exp);
        AST_RULE(Callable);
+        AST_RULE(ReversedIndex);
        AST_RULE(ChainValue);
        AST_RULE(SimpleTable);
        AST_RULE(SimpleValue);
@@ -371,6 +379,11 @@ private:
        AST_RULE(DoubleStringInner);
        AST_RULE(DoubleStringContent);
        AST_RULE(DoubleString);
+        AST_RULE(YAMLIndent);
+        AST_RULE(YAMLLineInner);
+        AST_RULE(YAMLLineContent);
+        AST_RULE(YAMLLine);
+        AST_RULE(YAMLMultiline);
        AST_RULE(String);
        AST_RULE(Parens);
        AST_RULE(DotChainItem);
@@ -427,6 +440,8 @@ private:
        AST_RULE(ExpListAssign);
        AST_RULE(IfLine);
        AST_RULE(WhileLine);
+        AST_RULE(Break);
+        AST_RULE(Continue);
        AST_RULE(BreakLoop);
        AST_RULE(StatementAppendix);
        AST_RULE(Statement);
@@ -444,6 +459,7 @@ private:
 namespace Utils {
 void replace(std::string& str, std::string_view from, std::string_view to);
 void trim(std::string& str);
+std::string toLuaDoubleString(const std::string& input);
 } // namespace Utils
 } // namespace yue
diff --git a/src/yuescript/yuescript.cpp b/src/yuescript/yuescript.cpp
index 7e8e8b7..61e3949 100644
--- a/src/yuescript/yuescript.cpp
+++ b/src/yuescript/yuescript.cpp
@@ -93,6 +93,12 @@ static void get_config(lua_State* L, yue::YueConfig& config) {
                config.useSpaceOverTab = lua_toboolean(L, -1) != 0;
        }
        lua_pop(L, 1);
+        lua_pushliteral(L, "lax");
+        lua_gettable(L, -2);
+        if (lua_isboolean(L, -1) != 0) {
+                config.lax = lua_toboolean(L, -1) != 0;
+        }
+        lua_pop(L, 1);
        lua_pushliteral(L, "options");
        lua_gettable(L, -2);
        if (lua_istable(L, -1) != 0) {
@@ -180,7 +186,7 @@ static int yueformat(lua_State* L) {
                tabSize = static_cast<int>(luaL_checkinteger(L, 2));
        }
        std::string_view codes(input, len);
-        auto info = yue::YueParser::shared().parse<yue::File_t>(codes);
+        auto info = yue::YueParser::shared().parse<yue::File_t>(codes, false);
        if (info.error) {
                const auto& error = info.error.value();
                if (!info.codes) {
@@ -201,6 +207,7 @@ static int yueformat(lua_State* L) {
                formatter.spaceOverTab = false;
        }
        auto result = formatter.toString(info.node.get());
+        yue::Utils::replace(result, "\n\n", "\n");
        lua_pushlstring(L, result.c_str(), result.size());
        return 1;
 }
@@ -282,8 +289,13 @@ static int yuetoast(lua_State* L) {
                        ruleName = {name, nameSize};
                }
        }
+        bool lax = false;
+        if (!lua_isnoneornil(L, 4)) {
+                luaL_checktype(L, 4, LUA_TBOOLEAN);
+                lax = lua_toboolean(L, 4) != 0;
+        }
        auto& yueParser = yue::YueParser::shared();
-        auto info = ruleName.empty() ? yueParser.parse<yue::File_t>({input, size}) : yueParser.parse(ruleName, {input, size});
+        auto info = ruleName.empty() ? yueParser.parse<yue::File_t>({input, size}, lax) : yueParser.parse(ruleName, {input, size}, lax);
        if (!info.error) {
                lua_createtable(L, 0, 0);
                int tableIndex = lua_gettop(L);
diff --git a/win-build/Yuescript/Yuescript.vcxproj b/win-build/Yuescript/Yuescript.vcxproj
index d073e70..87e13ce 100644
--- a/win-build/Yuescript/Yuescript.vcxproj
+++ b/win-build/Yuescript/Yuescript.vcxproj
@@ -215,6 +215,7 @@
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalOptions>/STACK:2097152 %(AdditionalOptions)</AdditionalOptions>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug53|x64'">
@@ -230,6 +231,7 @@
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalOptions>/STACK:2097152 %(AdditionalOptions)</AdditionalOptions>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -287,6 +289,7 @@
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalOptions>/STACK:2097152 %(AdditionalOptions)</AdditionalOptions>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release53|x64'">
@@ -306,6 +309,7 @@
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalOptions>/STACK:2097152 %(AdditionalOptions)</AdditionalOptions>
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>