63 files changed, 7374 insertions, 756 deletions

diff --git a/doc/docs/.vuepress/components/YueCompiler.vue b/doc/docs/.vuepress/components/YueCompiler.vue
index 6b6042c..3a22d1c 100755
--- a/doc/docs/.vuepress/components/YueCompiler.vue
+++ b/doc/docs/.vuepress/components/YueCompiler.vue
@@ -1,21 +1,21 @@
 <template>
                 <div style="width: 100%; height: auto;">
                         <div class="parent" style="background-color: #f5f7ff;">
-                                <div class="childL" style="height: 2.5em;">
+                                <div class="editor-section">
                                         <div class="childTitle">YueScript {{ info }}</div>
+                                        <div class="editor-container" ref='yueEditor'>
+                                                <ClientOnly>
+                                                        <prism-editor class="my-editor" v-model="code" :highlight="highlighterYue" @input="codeChanged($event)" line-numbers :readonly="readonly"></prism-editor>
+                                                </ClientOnly>
+                                        </div>
                                 </div>
-                                <div class="childR" style="height: 2.5em;">
+                                <div class="editor-section">
                                         <div class="childTitle">Lua</div>
-                                </div>
-                                <div class="childL" ref='yueEditor' style="height: 30em;">
-                                        <ClientOnly>
-                                                <prism-editor class="my-editor" v-model="code" :highlight="highlighterYue" @input="codeChanged($event)" line-numbers :readonly="readonly"></prism-editor>
-                                        </ClientOnly>
-                                </div>
-                                <div class="childR" style="height: 30em;">
-                                        <ClientOnly>
-                                                <prism-editor class="my-editor" v-model="compiled" :highlight="highlighterLua" @input="codeChanged($event)" readonly></prism-editor>
-                                        </ClientOnly>
+                                        <div class="editor-container">
+                                                <ClientOnly>
+                                                        <prism-editor class="my-editor" v-model="compiled" :highlight="highlighterLua" @input="codeChanged($event)" :line-numbers="isMobileLayout" readonly></prism-editor>
+                                                </ClientOnly>
+                                        </div>
                                 </div>
                         </div>
                         <div v-if="!compileronly">
@@ -57,9 +57,18 @@
                                 code: '',
                                 compiled: '',
                                 result: '',
+                                windowWidth: 0,
                         };
                 },
+                computed: {
+                        isMobileLayout() {
+                                return this.windowWidth <= 768;
+                        },
+                },
                 mounted () {
+                        this.windowWidth = window.innerWidth;
+                        window.addEventListener('resize', this.handleResize);
+
                         if (this.text !== '') {
                                 this.$data.code = this.text;
                                 this.codeChanged(this.text);
@@ -86,7 +95,13 @@
                         })(this);
                         check();
                 },
+                beforeDestroy() {
+                        window.removeEventListener('resize', this.handleResize);
+                },
                 methods: {
+                        handleResize() {
+                                this.windowWidth = window.innerWidth;
+                        },
                         runCode() {
                                 if (window.yue && this.$data.compiled !== '') {
                                         let res = '';
@@ -136,27 +151,35 @@
                 resize: none;
                 margin-top: 5px;
         }
-        .childL {
-                float: left;
-                width: 50%;
-                box-sizing: border-box;
-                background-clip: content-box;
-                background: #f5f7ff;
+
+        .parent {
+                display: flex;
+                flex-wrap: wrap;
+                width: 100%;
         }
-        .childR {
-                float: left;
+
+        .editor-section {
                 width: 50%;
                 box-sizing: border-box;
-                background-clip: content-box;
                 background: #f5f7ff;
         }
+
+        .editor-container {
+                height: 55vh;
+        }
+
         .childTitle {
                 width: 100%;
                 font-size: 1.2em;
                 color: #b7ae8f;
                 text-align: center;
                 padding: 0.2em;
+                height: 2.5em;
+                display: flex;
+                align-items: center;
+                justify-content: center;
         }
+
         .button {
                 float: right;
                 border: none;
@@ -173,9 +196,11 @@
                 margin-top: 10px;
                 margin-right: 5px;
         }
+
         .button:hover {
                 background-color: #beb69a;
         }
+
         .button:focus,
         .button:active:focus,
         .button.active:focus,
@@ -207,5 +232,19 @@
         .my-editor >>> .prism-editor__textarea:focus {
                 outline: none;
         }
-</style>
 
+        /* 移动端�应�布局 */
+        @media screen and (max-width: 768px) {
+                .parent {
+                        flex-direction: column;
+                }
+
+                .editor-section {
+                        width: 100%;
+                }
+
+                .editor-container {
+                        height: 30vh;
+                }
+        }
+</style>
diff --git a/doc/docs/doc/README.md b/doc/docs/doc/README.md
index c4518bf..57f27c8 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"
-    * "shield"
+    - "sword"
+    - "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"
-    * "shield"
+    - "sword"
+    - "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;Recursively compile every YueScript file with extension **.yue** under current path:  **yue .**  
-&emsp;&emsp;Compile and save results to a target path:  **yue -t /target/path/ .**  
-&emsp;&emsp;Compile and reserve debug info:  **yue -l .**  
-&emsp;&emsp;Compile and generate minified codes:  **yue -m .**  
-&emsp;&emsp;Execute raw codes:  **yue -e 'print 123'**  
+&emsp;&emsp;Use cases:
+&emsp;&emsp;Recursively compile every YueScript file with extension **.yue** under current path:  **yue .**
+&emsp;&emsp;Compile and save results to a target path:  **yue -t /target/path/ .**
+&emsp;&emsp;Compile and reserve debug info:  **yue -l .**
+&emsp;&emsp;Compile and generate minified codes:  **yue -m .**
+&emsp;&emsp;Execute raw codes:  **yue -e 'print 123'**
 &emsp;&emsp;Execute a YueScript file:  **yue -e main.yue**
 
 ## Macro
@@ -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"
-    * "b"
-    * "c"
+    - "a"
+    - "b"
+    - "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"
-    * "b"
-    * "c"
+    - "a"
+    - "b"
+    - "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>
 
@@ -1861,6 +2126,89 @@ if func 1, 2, 3,
 </pre>
 </YueDisplay>
 
+### Parameter Destructuring
+
+YueScript now supports destructuring function parameters when the argument is an object. Two forms of destructuring table literals are available:
+
+* **Curly-brace wrapped literals/object parameters**, allowing optional default values when fields are missing (e.g., `{:a, :b}`, `{a: a1 = 123}`).
+
+* **Unwrapped simple table syntax**, starting with a sequence of key-value or shorthand bindings and continuing until another expression terminates it (e.g., `:a, b: b1, :c`). This form extracts multiple fields from the same object.
+
+```moonscript
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+```
+<YueDisplay>
+<pre>
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+</pre>
+</YueDisplay>
+
+### Prefixed Return Expression
+
+When working with deeply nested function bodies, it can be tedious to maintain readability and consistency of the return value. To address this, YueScript introduces the **Prefixed Return Expression** syntax. Its form is as follows:
+
+```moon
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+```
+<YueDisplay>
+<pre>
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+</pre>
+</YueDisplay>
+
+This is equivalent to:
+
+```moon
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+```
+<YueDisplay>
+<pre>
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+</pre>
+</YueDisplay>
+
+The only difference is that you can move the final return expression before the `->` or `=>` token to indicate the function’s implicit return value as the last statement. This way, even in functions with multiple nested loops or conditional branches, you no longer need to write a trailing return expression at the end of the function body, making the logic structure more straightforward and easier to follow.
+
 ## Backcalls
 
 Backcalls are used for unnesting callbacks. They are defined using arrows pointed to the left as the last parameter by default filling in a function call. All the syntax is mostly the same as regular arrow functions except that it is just pointing the other way and the function body does not require indent.
@@ -1902,22 +2250,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 +2596,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 +2711,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 +2749,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 +3028,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
+switch name := "Dan"
   when "Robert"
     print "You are Robert"
   when "Dan", "Daniel"
     print "Your name, it's Dan"
   else
-    print "I don't know about your name"
+    print "I don't know about you with name #{name}"
 ```
 <YueDisplay>
 <pre>
-name = "Dan"
-switch name
+switch name := "Dan"
   when "Robert"
     print "You are Robert"
   when "Dan", "Daniel"
     print "Your name, it's Dan"
   else
-    print "I don't know about your name"
+    print "I don't know about you with name #{name}"
 </pre>
 </YueDisplay>
 
@@ -2676,7 +3078,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 +3124,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 +3184,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 +3432,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 +3519,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 +3598,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 +3613,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 +3879,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 +3914,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 +3946,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 +4072,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..5cfe4e6 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"
-    * "shield"
+    - "sword"
+    - "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"
-    * "shield"
+    - "sword"
+    - "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;递归编译当�路径下扩展�为 **.yue** 的�个月之脚本文件： **yue .**  
-&emsp;&emsp;编译并将结果�存到目标路径： **yue -t /target/path/ .**  
-&emsp;&emsp;编译并�留调试信�： **yue -l .**  
-&emsp;&emsp;编译并生�压缩代�： **yue -m .**  
-&emsp;&emsp;直接执行代�： **yue -e 'print 123'**  
+&emsp;&emsp;使用案例：
+&emsp;&emsp;递归编译当�路径下扩展�为 **.yue** 的�个月之脚本文件： **yue .**
+&emsp;&emsp;编译并将结果�存到目标路径： **yue -t /target/path/ .**
+&emsp;&emsp;编译并�留调试信�： **yue -l .**
+&emsp;&emsp;编译并生�压缩代�： **yue -m .**
+&emsp;&emsp;直接执行代�： **yue -e 'print 123'**
 &emsp;&emsp;执行一个月之脚本文件： **yue -e main.yue**
 
 ## �
@@ -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"
-    * "b"
-    * "c"
+    - "a"
+    - "b"
+    - "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"
-    * "b"
-    * "c"
+    - "a"
+    - "b"
+    - "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
@@ -1822,6 +2086,89 @@ if func 1, 2, 3,
 </pre>
 </YueDisplay>
 
+### �数解构
+
+月之脚本支�在函数形��置对传入对象进行解构。适用两类解构表���：
+
+- 使用 {} 包裹的字��/对象形�，支��供获得空字段时的默认值（例如 {:a, :b}�{a: a1 = 123}）。
+
+- 无 {} 包裹�以键值/简写键�列开头，直至�到其它表达�终止（例如 :a, b: b1, :c），表示从�一个对象中解构多个字段。
+
+```moonscript
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+```
+<YueDisplay>
+<pre>
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+</pre>
+</YueDisplay>
+
+### �置返回表达�
+
+在深度嵌套的函数体中，为了��返回值的�读性�编写便利性，我们新增了 “�置返回表达�� 语法。其形�如下：
+
+```moon
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+```
+<YueDisplay>
+<pre>
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+</pre>
+</YueDisplay>
+
+这个写法等价于：
+
+```moon
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+```
+<YueDisplay>
+<pre>
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+</pre>
+</YueDisplay>
+
+唯一的区别在于：你�以将函数的返回值表达���写在 `->` 或 `=>` �，用以指示该函数应��返回该表达�的值。这样�使在多层循环或�件判断的场景下，也无需编写尾行悬挂的返回表达�，逻辑结构会更加直观清晰。
+
 ## ��回调
 
 ��回调用于�少函数回调的嵌套。它们使用指�左侧的箭头，并且默认会被定义为传入�续函数调用的最�一个�数。它的语法大部分与常规箭头函数相�，�是它指��一方�，并且�续的函数体�需�进行缩进。
@@ -1850,7 +2197,7 @@ print @value
 </pre>
 </YueDisplay>
 
-您�以通过一个��符指定回调函数的传��置。
+你�以通过一个��符指定回调函数的传��置。
 
 ```moonscript
 (x) <- map _, [1, 2, 3]
@@ -1863,22 +2210,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 +2384,7 @@ list_with_one_element = [ 1, ]
 
 ## 推导�
 
-推导�为我们�供了一�便�的语法，通过�历现有对象并对其值应用表达��构造出新的表格。月之脚本有两�推导�：列表推导�和表格推导�。它们最终都是产生Lua表格；列表推导�将值累积到类似数组的表格中，而表格推导��许您在�次�历时设置新表格的键和值。
+推导�为我们�供了一�便�的语法，通过�历现有对象并对其值应用表达��构造出新的表格。月之脚本有两�推导�：列表推导�和表格推导�。它们最终都是产生Lua表格；列表推导�将值累积到类似数组的表格中，而表格推导��许你在�次�历时设置新表格的键和值。
 
 ### 列表推导�
 
@@ -2210,6 +2557,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 +2672,24 @@ doubled_evens = for i = 1, 20
 </pre>
 </YueDisplay>
 
-您还�以结�for循环表达�与continue语��过滤值。
+此外，for循环还支�带返回值的break语�，这样循环本身就�以作为一个表达�，在满足�件时��退出并返回有�义的结果。
+
+例如，查找第一个大于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循环表达�。
+注�出现在函数体末尾的for循环，�会被当作是一个表达�并将循环结果累积到一个列表中作为返回值（相�，函数将返回nil）。如果�函数末尾的循环转�为列表表达�，�以显�地使用返回语�加for循环表达�。
 
 ```moonscript
 func_a = -> for i = 1, 10 do print i
@@ -2513,7 +2914,7 @@ print "你真幸��" unless math.random! > 0.1
 
 ### 范围表达�
 
-您�以使用范围表达��编写进行范围检查的代�。
+你�以使用范围表达��编写进行范围检查的代�。
 
 ```moonscript
 a = 5
@@ -2586,28 +2987,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
+switch name := "Dan"
   when "Robert"
     print "你是Robert"
   when "Dan", "Daniel"
     print "你的�字是Dan"
   else
-    print "我�知�你的�字"
+    print "我�认识你，你的�字是#{name}"
 ```
 <YueDisplay>
 <pre>
-name = "Dan"
-switch name
+switch name := "Dan"
   when "Robert"
     print "你是Robert"
   when "Dan", "Daniel"
     print "你的�字是Dan"
   else
-    print "我�知�你的�字"
+    print "我�认识你，你的�字是#{name}"
 </pre>
 </YueDisplay>
 
@@ -2684,7 +3083,7 @@ else
 </pre>
 </YueDisplay>
 
-值得注�的是，在生�Lua代�时，我们��检查的目标��会放在==表达�的�侧。当您希望给when��的比较对象定义一个\_\_eq元方法��载判断逻辑时，�能会有用。
+值得注�的是，在生�Lua代�时，我们��检查的目标��会放在==表达�的�侧。当你希望给when��的比较对象定义一个\_\_eq元方法��载判断逻辑时，�能会有用。
 
 ### 表格匹�
 
@@ -2744,9 +3143,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 +3730,7 @@ x = class
 
 ### 类混�
 
-您�以通过使用 `using` 关键字�实现类混�。这�味�您�以从一个普通 Lua 表格或已定义的类对象中，�制函数到您创建的新类中。当您使用普通 Lua 表格进行类混�时，您有机会用自己的实现��写类的索引方法（例如元方法 `__index`）。然而，当您从一个类对象�混�时，需�注�的是该类对象的元方法将�会被�制到新类。
+你�以通过使用 `using` 关键字�实现类混�。这�味�你�以从一个普通 Lua 表格或已定义的类对象中，�制函数到你创建的新类中。当你使用普通 Lua 表格进行类混�时，你有机会用自己的实现��写类的索引方法（例如元方法 `__index`）。然而，当你从一个类对象�混�时，需�注�的是该类对象的元方法将�会被�制到新类。
 
 ```moonscript
 MyIndex = __index: var: 1
@@ -3316,22 +3832,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 +3870,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 +3902,7 @@ print var -- 这里是nil
 </pre>
 </YueDisplay>
 
-月之脚本的 **do** 也�以用作表达�。�许您将多行代�的处��并为一个表达�，并将do语�代��的最�一个语�作为表达�返回的结果。
+月之脚本的 **do** 也�以用作表达�。�许你将多行代�的处��并为一个表达�，并将do语�代��的最�一个语�作为表达�返回的结果。
 
 ```moonscript
 counter = do
@@ -4332,8 +4861,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/funcs.yue b/spec/inputs/funcs.yue
index e647edc..6b1669b 100644
--- a/spec/inputs/funcs.yue
+++ b/spec/inputs/funcs.yue
@@ -193,4 +193,35 @@ do
         func = (): -> check 123
         print func! -- get nil
 
+do
+        f = ({:a, :b, :c}) -> print a, b, c
+        f = (:a, :b, :c) -> print a, b, c
+        g = (x, :y) -> print x, y
+        i = ({a: ax = 0, b: by = 0}) -> print ax, by
+        j = (name, {id: uid = "n/a", :role = "guest"}) -> print name, uid, role
+        m = ({user: {:name, :age}, meta: {:ver = 1}}) -> print name, age, ver
+        m1 = ({user: {:name, :age}, :meta = {}}) -> print name, age, meta and meta.ver or "nil"
+        new = ({:name = "anon", :age = 0}) =>
+                @name = name
+                @age  = age
+        set = ({:name = @name, :age = @age}) =>
+                @name = name
+                @age = age
+        logKV = ({:k, :v}, ...) ->
+                print "kv:", k, v
+                print "rest count:", select "#", ...
+        macro gen = (fname) -> |
+          #{fname} = ({:a, :b = 0}) -> print a, b
+        $gen foo
+        t1 = (:a, x) -> print a, x
+        t2 = (:a) -> print a
+        w = (
+                id
+                {:x = 0, :y = 0}
+                :flag
+        ) ->
+                print id, x, y, flag
+        g1 = ({:a, a: ax}) -> print a, ax
+        g4 = ({:a, :b, ...rest}) -> print a, b
+
 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
-        #{def}
-else
-        _1 = #{def}
-        for _2 in *#{items}
-                _1 = #{action}
-        _1"
+        $showMacro "reduce", |
+                if ##{items} == 0
+                        #{def}
+                else
+                        _1 = #{def}
+                        for _2 in *#{items}
+                                _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
-        a = 1
-        a + 1"
+macro get_inner = (var)-> |
+        do
+                a = 1
+                a + 1
 
-macro get_inner_hygienic = (var)-> "(->
-        local a = 1
-        a + 1)!"
+macro get_inner_hygienic = (var)-> |
+        (->
+                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 "
-do
-        txt = #{res}
-        print '[macro ' .. #{name} .. ']'
-        print txt
-        txt
-"
+        if debugMacro then |
+                do
+                        txt = #{res}
+                        print '[macro #{name}]'
+                        print 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_"
         )
-        "
-do
-        local _src_, _dst_
-        with _dst_ = #{dst}
-                with _src_ = #{src}
-#{table.concat for field in *{...} do "
-                        _dst_.#{field} = _src_.#{field}
-"}"
+        copyFields = table.concat(
+                ["_dst_.#{field} = _src_.#{field}" for field in *{...}]
+                "\n\t\t\t"
+        )
+        |
+                do
+                        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)->
-        "require('yue').to_lua(#{code}, reserve_line_number:false, same_module:true)"
+macro to_lua = (code)-> |
+        require('yue').to_lua #{code},
+                reserve_line_number: false
+                same_module: true
 
-macro trim = (name)->
-        "if result := #{name}\\match '[\\'\"](.*)[\\'\"]' then result else #{name}"
+macro trim = (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)->
-        if msg
-                "$todoInner $FILE, $LINE, #{msg}"
-        else
-                "$todoInner $FILE, $LINE"
+export macro todo = (msg)-> |
+        $todoInner $FILE, $LINE#{msg and ", #{msg}" or ""}
 
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)
-                return { }
-        end
+        print(123)
+        return { }
 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..055e79b 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()
@@ -755,6 +923,36 @@ if func(1, 2, 3, "hello", "world") then
         print("hello")
         print("I am inside if")
 end
+local f1
+f1 = function(_arg_0)
+        local a, b, c
+        a, b, c = _arg_0.a, _arg_0.b, _arg_0.c
+        return print(a, b, c)
+end
+f1({
+        a = 1,
+        b = "2",
+        c = { }
+})
+local f2
+f2 = function(_arg_0, c)
+        local a1, b
+        a1, b = _arg_0.a, _arg_0.b
+        if a1 == nil then
+                a1 = 123
+        end
+        if b == nil then
+                b = 'abc'
+        end
+        if c == nil then
+                c = { }
+        end
+        return print(a1, b, c)
+end
+local arg1 = {
+        a = 0
+}
+f2(arg1, arg2)
 f(function()
         return print("hello")
 end)
@@ -970,8 +1168,7 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-local _max_0 = 5
-for _index_0 = 1, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
+for _index_0 = 1, 5 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
@@ -981,7 +1178,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 +1189,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 +1239,7 @@ for key, value in pairs(object) do
         print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
-for _index_0 = 2, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
+for _index_0 = 2, 4 do
         local item = _list_0[_index_0]
         print(item)
 end
@@ -1026,12 +1257,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 +1423,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 +1523,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 +2365,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 +2459,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 +2548,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 +2654,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 +2794,14 @@ func({
         2,
         3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
         name = "abc",
         values = {
@@ -2553,6 +3042,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 +3196,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 +3255,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()
@@ -2761,6 +3362,66 @@ if func(1, 2, 3, "hello", "world") then
         print("hello")
         print("I am inside if")
 end
+local f1
+f1 = function(_arg_0)
+        local a, b, c
+        a, b, c = _arg_0.a, _arg_0.b, _arg_0.c
+        return print(a, b, c)
+end
+f1({
+        a = 1,
+        b = "2",
+        c = { }
+})
+local f2
+f2 = function(_arg_0, c)
+        local a1, b
+        a1, b = _arg_0.a, _arg_0.b
+        if a1 == nil then
+                a1 = 123
+        end
+        if b == nil then
+                b = 'abc'
+        end
+        if c == nil then
+                c = { }
+        end
+end
+print(a1, b, c)
+local arg1 = {
+        a = 0
+}
+f2(arg1, arg2)
+local findFirstEven
+findFirstEven = function(list)
+        for _index_0 = 1, #list do
+                local item = list[_index_0]
+                if type(item) == "table" then
+                        for _index_1 = 1, #item do
+                                local sub = item[_index_1]
+                                if sub % 2 == 0 then
+                                        return sub
+                                end
+                        end
+                end
+        end
+        return nil
+end
+local findFirstEven
+findFirstEven = function(list)
+        for _index_0 = 1, #list do
+                local item = list[_index_0]
+                if type(item) == "table" then
+                        for _index_1 = 1, #item do
+                                local sub = item[_index_1]
+                                if sub % 2 == 0 then
+                                        return sub
+                                end
+                        end
+                end
+        end
+        return nil
+end
 f(function()
         return print("hello")
 end)
@@ -2976,8 +3637,7 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-local _max_0 = 5
-for _index_0 = 1, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
+for _index_0 = 1, 5 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
@@ -2987,7 +3647,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 +3658,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 +3708,7 @@ for key, value in pairs(object) do
         print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
-for _index_0 = 2, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
+for _index_0 = 2, 4 do
         local item = _list_0[_index_0]
         print(item)
 end
@@ -3032,12 +3726,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 +3892,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 +3992,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 +4834,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..de76829 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()
@@ -749,6 +917,36 @@ if func(1, 2, 3, "你好", "世界") then
         print("hello")
         print("我在if内部")
 end
+local f1
+f1 = function(_arg_0)
+        local a, b, c
+        a, b, c = _arg_0.a, _arg_0.b, _arg_0.c
+        return print(a, b, c)
+end
+f1({
+        a = 1,
+        b = "2",
+        c = { }
+})
+local f2
+f2 = function(_arg_0, c)
+        local a1, b
+        a1, b = _arg_0.a, _arg_0.b
+        if a1 == nil then
+                a1 = 123
+        end
+        if b == nil then
+                b = 'abc'
+        end
+        if c == nil then
+                c = { }
+        end
+        return print(a1, b, c)
+end
+local arg1 = {
+        a = 0
+}
+f2(arg1, arg2)
 f(function()
         return print("hello")
 end)
@@ -964,8 +1162,7 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-local _max_0 = 5
-for _index_0 = 1, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
+for _index_0 = 1, 5 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
@@ -975,7 +1172,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 +1183,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 +1233,7 @@ for key, value in pairs(object) do
         print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
-for _index_0 = 2, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
+for _index_0 = 2, 4 do
         local item = _list_0[_index_0]
         print(item)
 end
@@ -1020,12 +1251,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 +1417,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 +1517,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 +2359,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 +2453,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 +2542,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 +2648,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 +2788,14 @@ func({
         2,
         3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
         name = "abc",
         values = {
@@ -2547,6 +3036,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 +3190,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 +3249,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()
@@ -2749,6 +3350,66 @@ if func(1, 2, 3, "你好", "世界") then
         print("你好")
         print("我在if内部")
 end
+local f1
+f1 = function(_arg_0)
+        local a, b, c
+        a, b, c = _arg_0.a, _arg_0.b, _arg_0.c
+        return print(a, b, c)
+end
+f1({
+        a = 1,
+        b = "2",
+        c = { }
+})
+local f2
+f2 = function(_arg_0, c)
+        local a1, b
+        a1, b = _arg_0.a, _arg_0.b
+        if a1 == nil then
+                a1 = 123
+        end
+        if b == nil then
+                b = 'abc'
+        end
+        if c == nil then
+                c = { }
+        end
+        return print(a1, b, c)
+end
+local arg1 = {
+        a = 0
+}
+f2(arg1, arg2)
+local findFirstEven
+findFirstEven = function(list)
+        for _index_0 = 1, #list do
+                local item = list[_index_0]
+                if type(item) == "table" then
+                        for _index_1 = 1, #item do
+                                local sub = item[_index_1]
+                                if sub % 2 == 0 then
+                                        return sub
+                                end
+                        end
+                end
+        end
+        return nil
+end
+local findFirstEven
+findFirstEven = function(list)
+        for _index_0 = 1, #list do
+                local item = list[_index_0]
+                if type(item) == "table" then
+                        for _index_1 = 1, #item do
+                                local sub = item[_index_1]
+                                if sub % 2 == 0 then
+                                        return sub
+                                end
+                        end
+                end
+        end
+        return nil
+end
 f(function()
         return print("hello")
 end)
@@ -2964,8 +3625,7 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-local _max_0 = 5
-for _index_0 = 1, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
+for _index_0 = 1, 5 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
@@ -2975,7 +3635,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 +3646,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 +3696,7 @@ for key, value in pairs(object) do
         print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
-for _index_0 = 2, _max_0 < 0 and #_list_0 + _max_0 or _max_0 do
+for _index_0 = 2, 4 do
         local item = _list_0[_index_0]
         print(item)
 end
@@ -3020,12 +3714,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 +3880,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 +3980,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 +4822,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/funcs.lua b/spec/outputs/funcs.lua
index c1735c4..db7ed67 100644
--- a/spec/outputs/funcs.lua
+++ b/spec/outputs/funcs.lua
@@ -283,4 +283,157 @@ do
         end
         print(func())
 end
+local _anon_func_0 = function(_arg_0)
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _max_0 = #_arg_0
+        for _index_0 = 1, _max_0 do
+                local _item_0 = _arg_0[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+do
+        local f
+        f = function(_arg_0)
+                local a, b, c
+                a, b, c = _arg_0.a, _arg_0.b, _arg_0.c
+                return print(a, b, c)
+        end
+        f = function(_arg_0)
+                local a, b, c
+                a, b, c = _arg_0.a, _arg_0.b, _arg_0.c
+                return print(a, b, c)
+        end
+        local g
+        g = function(x, _arg_0)
+                local y
+                y = _arg_0.y
+                return print(x, y)
+        end
+        local i
+        i = function(_arg_0)
+                local ax, by
+                ax, by = _arg_0.a, _arg_0.b
+                if ax == nil then
+                        ax = 0
+                end
+                if by == nil then
+                        by = 0
+                end
+                return print(ax, by)
+        end
+        j = function(name, _arg_0)
+                local uid, role
+                uid, role = _arg_0.id, _arg_0.role
+                if uid == nil then
+                        uid = "n/a"
+                end
+                if role == nil then
+                        role = "guest"
+                end
+                return print(name, uid, role)
+        end
+        local m
+        m = function(_arg_0)
+                local name, age, ver
+                name, age, ver = _arg_0.user.name, _arg_0.user.age, _arg_0.meta.ver
+                if ver == nil then
+                        ver = 1
+                end
+                return print(name, age, ver)
+        end
+        local m1
+        m1 = function(_arg_0)
+                local name, age, meta
+                name, age, meta = _arg_0.user.name, _arg_0.user.age, _arg_0.meta
+                if meta == nil then
+                        meta = { }
+                end
+                return print(name, age, meta and meta.ver or "nil")
+        end
+        local new
+        new = function(self, _arg_0)
+                local name, age
+                name, age = _arg_0.name, _arg_0.age
+                if name == nil then
+                        name = "anon"
+                end
+                if age == nil then
+                        age = 0
+                end
+                self.name = name
+                self.age = age
+        end
+        local set
+        set = function(self, _arg_0)
+                local name, age
+                name, age = _arg_0.name, _arg_0.age
+                if name == nil then
+                        name = self.name
+                end
+                if age == nil then
+                        age = self.age
+                end
+                self.name = name
+                self.age = age
+        end
+        local logKV
+        logKV = function(_arg_0, ...)
+                local k, v
+                k, v = _arg_0.k, _arg_0.v
+                print("kv:", k, v)
+                return print("rest count:", select("#", ...))
+        end
+        do
+                local foo
+                foo = function(_arg_0)
+                        local a, b
+                        a, b = _arg_0.a, _arg_0.b
+                        if b == nil then
+                                b = 0
+                        end
+                        return print(a, b)
+                end
+        end
+        local t1
+        t1 = function(_arg_0, x)
+                local a
+                a = _arg_0.a
+                return print(a, x)
+        end
+        local t2
+        t2 = function(_arg_0)
+                local a
+                a = _arg_0.a
+                return print(a)
+        end
+        local w
+        w = function(id, _arg_0, _arg_1)
+                local x, y
+                x, y = _arg_0.x, _arg_0.y
+                if x == nil then
+                        x = 0
+                end
+                if y == nil then
+                        y = 0
+                end
+                local flag
+                flag = _arg_1.flag
+                return print(id, x, y, flag)
+        end
+        local g1
+        g1 = function(_arg_0)
+                local a, ax
+                a, ax = _arg_0.a, _arg_0.a
+                return print(a, ax)
+        end
+        local g4
+        g4 = function(_arg_0)
+                local a, b, rest
+                a, b, rest = _arg_0.a, _arg_0.b, _anon_func_0(_arg_0)
+                return print(a, b)
+        end
+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
-for _index_0 = 2, _max_0 < 0 and #x + _max_0 or _max_0, 2 do
+local _max_0 = #x + -5 + 1
+for _index_0 = 2, _max_0, 2 do
         local y = x[_index_0]
         print(y)
 end
-local _max_1 = 3
-for _index_0 = 1, _max_1 < 0 and #x + _max_1 or _max_1 do
+for _index_0 = 1, 3 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
-for _index_0 = a, _max_2 < 0 and #x + _max_2 or _max_2, c do
+local _min_0 = a
+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)
-                return { }
-        end
+        _u6253_u5370(123)
+        return { }
 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
-for _index_0 = 2, _max_0 < 0 and #_u53d8_u91cfx + _max_0 or _max_0, 2 do
+local _max_0 = #_u53d8_u91cfx + -5 + 1
+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, _max_1 < 0 and #_u53d8_u91cfx + _max_1 or _max_1 do
+for _index_0 = 1, 3 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
-for _index_0 = _u53d8_u91cfa, _max_2 < 0 and #_u53d8_u91cfx + _max_2 or _max_2, _u53d8_u91cfc do
+local _min_0 = _u53d8_u91cfa
+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 = (_({
-                        1,
-                        2,
-                        3,
-                        4,
-                        -2,
-                        3
-                }))
-                return _call_0["链"](_call_0)
-        end
+        local _call_0 = (_({
+                1,
+                2,
+                3,
+                4,
+                -2,
+                3
+        }))
+        return _call_0["链"](_call_0)
 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 = (_({
-                        1,
-                        2,
-                        3,
-                        4,
-                        -2,
-                        3
-                }))
-                return _call_1["链"](_call_1)
-        end
+        local _call_1 = (_({
+                1,
+                2,
+                3,
+                4,
+                -2,
+                3
+        }))
+        return _call_1["链"](_call_1)
 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["��"]["根节点"]["游�对象"]
-                return _call_1["父节点"](_call_1)
-        end
+        local _call_1 = _u539f_u70b9["��"]["根节点"]["游�对象"]
+        return _call_1["父节点"](_call_1)
 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
-                return (_call_1["��b"](_call_1, 123))["��c"]("abc")
-        end
+        local _call_1 = _u53d8_u91cfa
+        return (_call_1["��b"](_call_1, 123))["��c"]("abc")
 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
-                return _call_8["é…·"](_call_8, 100)
-        end
+        local _call_8 = _u4ec0_u4e48
+        return _call_8["é…·"](_call_8, 100)
 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()
-        end
+        return _u51fd_u6570()
 end
 local _anon_func_13 = function(_u51fd_u6570, ...)
-        do
-                return _u51fd_u6570(...)
-        end
+        return _u51fd_u6570(...)
 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("#", ...))
-                return _u6253_u5370(...)
-        end
+        _u6253_u5370(select("#", ...))
+        return _u6253_u5370(...)
 end
 local _anon_func_25 = function(_u6253_u5370, ...)
-        do
-                return _u6253_u5370(...)
-        end
+        return _u6253_u5370(...)
 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(...)
-        end
+        return _u6253_u5370(...)
 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
-                return _u6253_u5370(...)
-        end
+        local _u8868 = _arg_0
+        return _u6253_u5370(...)
 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
-                return print(select(3, ...))
-        end
+        local ok = _arg_0
+        return print(select(3, ...))
 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_1 = _call_0["end"](_call_0)
-                return _call_1["🤣"](_call_1, 123)
-        end
+        local _call_0 = tb
+        local _call_1 = _call_0["end"](_call_0)
+        return _call_1["🤣"](_call_1, 123)
 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)
-                return "abc"
-        end
+        print(123)
+        return "abc"
 end
 local _anon_func_18 = function(print, select, _arg_0, ...)
-        do
-                local success = _arg_0
-                if success then
-                        return print(select('#', ...))
-                end
+        local success = _arg_0
+        if success then
+                return print(select('#', ...))
         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_1 = _call_0["end"](_call_0)
-                return _call_1["🤣"](_call_1, 123 and (#listA > 0 and _anon_func_25(itemA, listA)))
-        end
+        local _call_0 = tb
+        local _call_1 = _call_0["end"](_call_0)
+        return _call_1["🤣"](_call_1, 123 and (#listA > 0 and _anon_func_25(itemA, listA)))
 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
-                if ok then
-                        return ...
-                else
-                        return os.exit(1)
-                end
+        local ok = _arg_0
+        if ok then
+                return ...
+        else
+                return os.exit(1)
         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()
-        end
+        return func()
 end
 local _anon_func_13 = function(func, ...)
-        do
-                return func(...)
-        end
+        return func(...)
 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("#", ...))
-                return print(...)
-        end
+        print(select("#", ...))
+        return print(...)
 end
 local _anon_func_25 = function(print, ...)
-        do
-                return print(...)
-        end
+        return print(...)
 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(...)
-        end
+        return print(...)
 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
-                return print(...)
-        end
+        local tb = _arg_0
+        return print(...)
 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 {
-        auto info = reinterpret_cast<YueFormat*>(ud);
-        return info->convert(this);
+std::string GlobalOp_t::to_string(void*) const {
+        return "*"s;
 }
 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);
-        return info->convert(this);
+        if (value) {
+                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) {
-                temp.push_back(assigns->to_string(ud));
+        if (assign) {
+                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) {
-                                        temp.back() += " then "s + node->to_string(ud);
-                                } else {
-                                        temp.emplace_back(info->ind() + "else "s + node->to_string(ud));
+                                switch (lastType) {
+                                        case NType::Cond:
+                                                temp.back() += " then "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) {
-                                        info->pushScope();
-                                        temp.emplace_back(node->to_string(ud));
-                                        if (temp.back().empty()) {
-                                                temp.back() = info->ind() + "--"s;
+                                switch (lastType) {
+                                        case NType::Cond: {
+                                                info->pushScope();
+                                                temp.emplace_back(node->to_string(ud));
+                                                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();
-                                } else {
-                                        temp.emplace_back(info->ind() + "else"s);
-                                        info->pushScope();
-                                        temp.emplace_back(node->to_string(ud));
-                                        if (temp.back().empty()) {
-                                                temp.back() = info->ind() + "--"s;
+                                        case NType::Block: {
+                                                temp.emplace_back(info->ind() + "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();
                                 }
-                                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->content.is<Statement_t>()) {
-                temp.emplace_back("repeat "s + body->to_string(ud));
+        if (body.is<Statement_t>()) {
+                return "repeat "s + body->to_string(ud) + " until "s + condition->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..6e1bb88 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,
-                UnaryValue_t,
+                ForEach_t, For_t, While_t, Repeat_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)
@@ -740,17 +780,19 @@ AST_NODE(Export)
 AST_END(Export)
 
 AST_NODE(FnArgDef)
-        ast_sel<true, Variable_t, SelfItem_t> name;
+        ast_sel<true, Variable_t, SelfItem_t, SimpleTable_t, TableLit_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..33161a7 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.4"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,
-                Global = 2
+                LocalConst = 1,
+                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>(): {
@@ -1968,7 +1982,7 @@ private:
                 return indent() + "local "s + join(defs, ", "sv);
         }
 
-        std::string getDestrucureDefine(ExpListAssign_t* assignment) {
+        std::string getDestructureDefine(ExpListAssign_t* assignment) {
                 auto info = extractDestructureInfo(assignment, true, false);
                 if (!info.destructures.empty()) {
                         str_list defs;
@@ -1999,8 +2013,31 @@ private:
                 return clearBuf();
         }
 
+        str_list getArgDestructureList(ExpListAssign_t* assignment) {
+                str_list defs;
+                auto info = extractDestructureInfo(assignment, true, false);
+                if (!info.destructures.empty()) {
+                        for (const auto& des : info.destructures) {
+                                if (std::holds_alternative<Destructure>(des)) {
+                                        const auto& destruct = std::get<Destructure>(des);
+                                        for (const auto& item : destruct.items) {
+                                                if (item.targetVar.empty()) {
+                                                        throw CompileError("can only destruct argument to variable"sv, item.target);
+                                                } else {
+                                                        defs.push_back(item.targetVar);
+                                                }
+                                        }
+                                } else {
+                                        const auto& assignment = std::get<AssignmentPtr>(des);
+                                        YUEE("AST node mismatch", assignment.ptr);
+                                }
+                        }
+                }
+                return defs;
+        }
+
         std::string getPreDefine(ExpListAssign_t* assignment) {
-                auto preDefine = getDestrucureDefine(assignment);
+                auto preDefine = getDestructureDefine(assignment);
                 if (preDefine.empty()) {
                         preDefine = toLocalDecl(transformAssignDefs(assignment->expList, DefOp::Mark));
                 }
@@ -2051,13 +2088,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 +2360,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 +2442,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 +2501,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 +2524,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 +2793,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 +2864,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;
-                                        if (!varDefOnly && !isAssignable(static_cast<Exp_t*>(pair))) {
+                                        bool assignable = false;
+                                        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 +2914,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 +2924,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 +2981,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 +3048,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 +3111,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 +3263,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 +3403,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 +3444,7 @@ private:
                                                                 destruct.valueVar.clear();
                                                         }
                                                 }
-                                                destructs.push_back(destruct);
+                                                destructs.push_back(std::move(destruct));
                                         }
                                 }
                         } else {
@@ -4205,12 +4363,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 +4455,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 +4580,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 +4900,7 @@ private:
                                 auto newBody = x->new_ptr<Body_t>();
                                 newBody->content.set(followingBlock);
                                 {
-                                        auto doNode = x->new_ptr<Do_t>();
-                                        doNode->body.set(newBody);
-                                        auto simpleValue = x->new_ptr<SimpleValue_t>();
-                                        simpleValue->value.set(doNode);
-                                        if (auto result = upValueFuncFromExp(newExp(simpleValue, x), &argNames, true)) {
+                                        if (auto result = upValueFuncFromBlock(followingBlock.get(), &argNames, false, true)) {
                                                 auto [funcName, args] = std::move(*result);
                                                 str_list finalArgs;
                                                 for (const auto& arg : args) {
@@ -4741,9 +4908,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 +4991,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 +5194,45 @@ private:
                 if (!nodes.empty()) {
                         str_list temp;
                         for (auto node : nodes) {
-                                currentScope().lastStatement = (node == nodes.back()) && currentScope().mode == GlobalMode::None;
-                                transformStatement(static_cast<Statement_t*>(node), temp);
-                                if (isRoot && !_rootDefs.empty()) {
-                                        auto last = std::move(temp.back());
-                                        temp.pop_back();
-                                        temp.insert(temp.end(), _rootDefs.begin(), _rootDefs.end());
-                                        _rootDefs.clear();
-                                        temp.push_back(std::move(last));
-                                }
-                                if (!temp.empty() && _parser.startWith<StatementSep_t>(temp.back())) {
-                                        auto rit = ++temp.rbegin();
-                                        if (rit != temp.rend() && !rit->empty()) {
-                                                auto index = std::string::npos;
-                                                if (_config.reserveLineNumber) {
-                                                        index = rit->rfind(" -- "sv);
-                                                } else {
-                                                        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);
+                                auto transformNode = [&]() {
+                                        currentScope().lastStatement = (node == nodes.back()) && currentScope().mode == GlobalMode::None;
+                                        transformStatement(static_cast<Statement_t*>(node), temp);
+                                        if (isRoot && !_rootDefs.empty()) {
+                                                auto last = std::move(temp.back());
+                                                temp.pop_back();
+                                                temp.insert(temp.end(), _rootDefs.begin(), _rootDefs.end());
+                                                _rootDefs.clear();
+                                                temp.push_back(std::move(last));
+                                        }
+                                        if (!temp.empty() && _parser.startWith<StatementSep_t>(temp.back())) {
+                                                auto rit = ++temp.rbegin();
+                                                if (rit != temp.rend() && !rit->empty()) {
+                                                        auto index = std::string::npos;
+                                                        if (_config.reserveLineNumber) {
+                                                                index = rit->rfind(" -- "sv);
+                                                        } else {
+                                                                index = rit->find_last_not_of('\n');
+                                                                if (index != std::string::npos) index++;
                                                         }
-                                                        if (LuaKeywords.find(ending) == LuaKeywords.end()) {
-                                                                rit->insert(index, ";"sv);
+                                                        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()) {
+                                                                        rit->insert(index, ";"sv);
+                                                                }
                                                         }
                                                 }
                                         }
+                                };
+                                if (_config.lax) {
+                                        try {
+                                                transformNode();
+                                        } catch (const CompileError&) { }
+                                } else {
+                                        transformNode();
                                 }
                         }
                         out.push_back(join(temp));
@@ -5229,18 +5441,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.append("]==========]"sv);
+                                                defVal = '=' + Utils::toLuaDoubleString(defVal);
                                         }
                                         newArgs.emplace_back(_parser.toString(def->name) + defVal);
                                 }
@@ -5248,6 +5471,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 +5509,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 +5601,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;
@@ -5423,6 +5675,7 @@ private:
                         bool checkExistence = false;
                         std::string name;
                         std::string assignSelf;
+                        ast_ptr<false, ExpListAssign_t> assignment;
                 };
                 std::list<ArgItem> argItems;
                 str_list temp;
@@ -5432,7 +5685,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) {
@@ -5473,6 +5730,22 @@ private:
                                         }
                                         break;
                                 }
+                                case id<TableLit_t>(): {
+                                        arg.name = getUnusedName("_arg_"sv);
+                                        auto simpleValue = def->new_ptr<SimpleValue_t>();
+                                        simpleValue->value.set(def->name);
+                                        auto asmt = assignmentFrom(newExp(simpleValue, def), toAst<Exp_t>(arg.name, def), def);
+                                        arg.assignment = asmt;
+                                        break;
+                                }
+                                case id<SimpleTable_t>(): {
+                                        arg.name = getUnusedName("_arg_"sv);
+                                        auto value = def->new_ptr<Value_t>();
+                                        value->item.set(def->name);
+                                        auto asmt = assignmentFrom(newExp(value, def), toAst<Exp_t>(arg.name, def), def);
+                                        arg.assignment = asmt;
+                                        break;
+                                }
                                 default: YUEE("AST node mismatch", def->name.get()); break;
                         }
                         forceAddToScope(arg.name);
@@ -5491,6 +5764,14 @@ private:
                                 _buf << indent() << "end"sv << nll(def);
                                 temp.back() = clearBuf();
                         }
+                        if (arg.assignment) {
+                                auto names = getArgDestructureList(arg.assignment);
+                                for (const auto& name : names) {
+                                        forceAddToScope(name);
+                                }
+                                temp.emplace_back(indent() + "local "s + join(names, ", "sv) + nll(def));
+                                transformAssignment(arg.assignment, temp);
+                        }
                         if (varNames.empty())
                                 varNames = arg.name;
                         else
@@ -5571,6 +5852,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 +6408,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 +6554,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 +6825,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 +6837,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 +6900,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 +7057,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 +7200,9 @@ private:
                 if (transformChainEndWithColonItem(chainList, out, usage, assignList)) {
                         return;
                 }
+                if (transformChainEndWithSlice(chainList, out, usage, assignList)) {
+                        return;
+                }
                 transformChainList(chainList, out, usage, assignList);
         }
 
@@ -7153,7 +7604,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 +8310,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 +8381,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 +8431,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 +8466,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 +8544,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 +8629,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 +8637,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) {
-                switch (body->get_id()) {
+        void transform_plain_body(ast_node* bodyOrStmt, str_list& out, ExpUsage usage, ExpList_t* assignList = nullptr) {
+                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>();
-                                newBlock->statements.push_back(body);
+                                auto newBlock = bodyOrStmt->new_ptr<Block_t>();
+                                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) {
-                return traversal::Stop == body->traverse([&](ast_node* node) {
+        enum class BreakLoopType {
+                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>()) {
-                                        return _parser.toString(stmt->content) == "continue"sv ? traversal::Stop : traversal::Return;
+                                if (auto breakLoop = stmt->content.as<BreakLoop_t>()) {
+                                        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 +8700,30 @@ private:
                                         switch (sVal->get_id()) {
                                                 case id<With_t>(): {
                                                         auto withNode = static_cast<With_t*>(sVal);
-                                                        if (hasContinueStatement(withNode->body)) {
-                                                                return traversal::Stop;
-                                                        }
-                                                        break;
+                                                        type |= getBreakLoopType(withNode->body, varBWV);
+                                                        return traversal::Return;
                                                 }
                                                 case id<Do_t>(): {
                                                         auto doNode = static_cast<Do_t*>(sVal);
-                                                        if (hasContinueStatement(doNode->body)) {
-                                                                return traversal::Stop;
-                                                        }
-                                                        break;
+                                                        type |= getBreakLoopType(doNode->body, varBWV);
+                                                        return traversal::Return;
                                                 }
                                                 case id<If_t>(): {
                                                         auto ifNode = static_cast<If_t*>(sVal);
                                                         for (auto n : ifNode->nodes.objects()) {
-                                                                if (hasContinueStatement(n)) {
-                                                                        return traversal::Stop;
-                                                                }
+                                                                type |= getBreakLoopType(n, varBWV);
                                                         }
-                                                        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)) {
-                                                                        return traversal::Stop;
-                                                                }
+                                                                type |= getBreakLoopType(static_cast<SwitchCase_t*>(branch)->body, varBWV);
                                                         }
                                                         if (switchNode->lastBranch) {
-                                                                if (hasContinueStatement(switchNode->lastBranch)) {
-                                                                        return traversal::Stop;
-                                                                }
+                                                                type |= getBreakLoopType(switchNode->lastBranch, varBWV);
                                                         }
-                                                        break;
+                                                        return traversal::Return;
                                                 }
                                         }
                                         BLOCK_END
@@ -8182,6 +8737,7 @@ private:
                         }
                         return traversal::Return;
                 });
+                return type;
         }
 
         void addDoToLastLineReturn(ast_node* body) {
@@ -8205,10 +8761,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 +8773,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 +8806,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 +8815,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 +8825,9 @@ private:
         std::string transformRepeatBody(Repeat_t* repeatNode, str_list& out) {
                 str_list temp;
                 bool extraDo = false;
-                auto body = repeatNode->body->content.get();
-                bool withContinue = hasContinueStatement(body);
+                auto body = repeatNode->body.get();
+                auto breakLoopType = getBreakLoopType(body, Empty);
+                bool withContinue = hasContinue(breakLoopType);
                 std::string conditionVar;
                 std::string extraLabel;
                 ast_ptr<false, ExpListAssign_t> condAssign;
@@ -8289,7 +8838,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 +8901,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 +8913,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);
-                auto lenLine = len + " = "s + len + " + 1"s + nlr(forNode->body);
-                transformLoopBody(forNode->body, out, lenLine, ExpUsage::Assignment, expList);
+                if (hasBreakWithValue(breakLoopType)) {
+                        lenAssign.clear();
+                        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 +9009,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 +9025,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);
-                auto lenLine = len + " = "s + len + " + 1"s + nlr(forEach->body);
-                transformLoopBody(forEach->body, out, lenLine, ExpUsage::Assignment, expList);
+                if (hasBreakWithValue(breakLoopType)) {
+                        lenAssign.clear();
+                        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 +9226,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 +9465,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 +9479,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 +9861,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) {
-                                        auto var = singleVariableFrom(with->assigns->values.objects().front(), AccessType::Read);
+                                if (with->assign->values.objects().size() == 1) {
+                                        auto var = singleVariableFrom(with->assign->values.objects().front(), AccessType::Read);
                                         if (!var.empty() && isLocal(var)) {
                                                 withVar = var;
                                         }
@@ -9250,7 +9875,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 +9889,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 +9902,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 +9980,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 +10095,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 +10120,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 +10143,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 +10502,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 +10854,7 @@ private:
                 out.push_back(join(temp));
                 auto vars = getAssignVars(assignment);
                 for (const auto& var : vars) {
-                        markVarConst(var);
+                        markVarLocalConst(var);
                 }
         }
 
@@ -10361,12 +11082,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 +11124,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 +11146,27 @@ private:
                 addToScope(accumVar);
                 auto lenVar = getUnusedName("_len_"sv);
                 addToScope(lenVar);
-                temp.push_back(indent() + "local "s + accumVar + " = { }"s + nll(whileNode));
-                temp.push_back(indent() + "local "s + lenVar + " = 1"s + nll(whileNode));
+                auto breakLoopType = getBreakLoopType(whileNode->body, accumVar);
+                _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);
-                auto lenLine = lenVar + " = "s + lenVar + " + 1"s + nlr(whileNode);
-                transformLoopBody(whileNode->body, temp, lenLine, ExpUsage::Assignment, assignLeft);
+                if (hasBreakWithValue(breakLoopType)) {
+                        lenAssign.clear();
+                        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 +11202,26 @@ private:
                 addToScope(accumVar);
                 auto lenVar = getUnusedName("_len_"sv);
                 addToScope(lenVar);
-                temp.push_back(indent() + "local "s + accumVar + " = { }"s + nll(whileNode));
-                temp.push_back(indent() + "local "s + lenVar + " = 1"s + nll(whileNode));
+                auto breakLoopType = getBreakLoopType(whileNode->body, accumVar);
+                _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);
-                auto lenLine = lenVar + " = "s + lenVar + " + 1"s + nlr(whileNode);
-                transformLoopBody(whileNode->body, temp, lenLine, ExpUsage::Assignment, assignLeft);
+                if (hasBreakWithValue(breakLoopType)) {
+                        lenAssign.clear();
+                        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 +11256,7 @@ private:
                         expListAssign->expList.set(expList);
                         auto stmt = x->new_ptr<Statement_t>();
                         stmt->content.set(expListAssign);
-                        auto body = x->new_ptr<Body_t>();
-                        body->content.set(stmt);
-                        repeat->body.set(body);
+                        repeat->body.set(stmt);
                         transformRepeat(repeat, out);
                         return;
                 }
@@ -10495,7 +11264,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 +11273,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 +11406,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 +11483,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 info = extractDestructureInfo(assignment, true, false);
+                                auto chainValue = toAst<ChainValue_t>(objVar, branch);
+                                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 +11495,31 @@ private:
                                         const auto& destruct = std::get<Destructure>(des);
                                         for (const auto& item : destruct.items) {
                                                 if (!item.defVal) {
-                                                        transformExp(item.target, conds, ExpUsage::Closure);
-                                                        conds.back().append(" ~= nil"s);
+                                                        if (!isAssignable(item.target)) {
+                                                                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 +11817,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 +11889,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 +11914,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..01ca083 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) {
-                throw ParserError("use := for if-assignment expression"sv, item.begin);
+        assignment_expression_syntax_error = pl::user(true_(), [](const item_t& item) {
+                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;
-        While = WhileType >> space >> disable_do_chain_arg_table_block_rule(Exp >> -(space >> Assignment)) >> space >> opt_body_with("do");
-        Repeat = key("repeat") >> space >> Body >> line_break >> *space_break >> check_indent_match >> space >> key("until") >> space >> Exp;
+        WhileType = (expr("while") | pl::user("until", [](const item_t& item) {
+                State* st = reinterpret_cast<State*>(item.user_data);
+                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->noChainBlockStack.push(true);
-                st->noTableBlockStack.push(true);
+                st->noDoStack.push_back(true);
+                st->noChainBlockStack.push_back(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->noChainBlockStack.pop();
-                st->noTableBlockStack.pop();
+                st->noDoStack.pop_back();
+                st->noChainBlockStack.pop_back();
+                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) | TableLit | SimpleTable;
 
         FnArgDefList = Seperator >> (
-                fn_arg_def_lit_lines >> -(-(space >> ',') >> white >> VarArg) |
-                white >> VarArg
+                fn_arg_def_lit_lines >> -(-(space >> ',') >> white >> VarArg >> -(space >> '`' >> space >> Name)) |
+                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) {
-                return parse(codes, getRule<AST>());
+        ParseInfo parse(std::string_view codes, bool lax) {
+                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::stack<bool> noChainBlockStack;
-                std::stack<bool> noTableBlockStack;
-                std::stack<bool> noForStack;
+                std::vector<bool> noDoStack;
+                std::vector<bool> noChainBlockStack;
+                std::vector<bool> noTableBlockStack;
+                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>