140 files changed, 9871 insertions, 3383 deletions

diff --git a/doc/docs/doc/README.md b/doc/docs/doc/README.md
index 89bd643..f0d67a5 100755
--- a/doc/docs/doc/README.md
+++ b/doc/docs/doc/README.md
@@ -16,19 +16,29 @@ Yue (月) is the name of moon in Chinese and it's pronounced as [jyɛ].
 ### An Overview of YueScript
 ```moonscript
 -- import syntax
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 
 -- object literals
 inventory =
   equipment:
-    * "sword"
-    * "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>
 
@@ -1902,22 +2167,22 @@ x * 2
 </pre>
 </YueDisplay>
 
-If you wish to have further code after your backcalls, you can set them aside with a do statement.
+If you wish to have further code after your backcalls, you can set them aside with a do statement. And the parentheses can be omitted with non-fat arrow functions.
 
 ```moonscript
 result, msg = do
-  (data) <- readAsync "filename.txt"
+  data <- readAsync "filename.txt"
   print data
-  (info) <- processAsync data
+  info <- processAsync data
   check info
 print result, msg
 ```
 <YueDisplay>
 <pre>
 result, msg = do
-  (data) <- readAsync "filename.txt"
+  data <- readAsync "filename.txt"
   print data
-  (info) <- processAsync data
+  info <- processAsync data
   check info
 print result, msg
 </pre>
@@ -2096,13 +2361,11 @@ doubled = [item * 2 for i, item in ipairs items]
 The items included in the new table can be restricted with a when clause:
 
 ```moonscript
-iter = ipairs items
-slice = [item for i, item in iter when i > 1 and i < 3]
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
 ```
 <YueDisplay>
 <pre>
-iter = ipairs items
-slice = [item for i, item in iter when i > 1 and i < 3]
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
 </pre>
 </YueDisplay>
 
@@ -2250,6 +2513,45 @@ slice = [item for item in *items[,,2]]
 </pre>
 </YueDisplay>
 
+Both the minimum and maximum bounds can be negative, which means that the bounds are counted from the end of the table.
+
+```moonscript
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+```
+<YueDisplay>
+<pre>
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+</pre>
+</YueDisplay>
+
+The step size can also be negative, which means that the items are taken in reverse order.
+
+```moonscript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+<YueDisplay>
+<pre>
+reverse_slice = [item for item in *items[-1,1,-1]]
+</pre>
+</YueDisplay>
+
+#### Slicing Expression
+
+Slicing can also be used as an expression. This is useful for getting a sub-list of a table.
+
+```moonscript
+-- take the 2nd and 4th items as a new list
+sub_list = items[2, 4]
+```
+<YueDisplay>
+<pre>
+-- take the 2nd and 4th items as a new list
+sub_list = items[2, 4]
+</pre>
+</YueDisplay>
+
 ## For Loop
 
 There are two for loop forms, just like in Lua. A numeric one and a generic one:
@@ -2326,6 +2628,23 @@ doubled_evens = for i = 1, 20
 </pre>
 </YueDisplay>
 
+In addition, for loops support break with a return value, allowing the loop itself to be used as an expression that exits early with a meaningful result.
+
+For example, to find the first number greater than 10:
+
+```moonscript
+first_large = for n in *numbers
+  break n if n > 10
+```
+<YueDisplay>
+<pre>
+first_large = for n in *numbers
+  break n if n > 10
+</pre>
+</YueDisplay>
+
+This break-with-value syntax enables concise and expressive search or early-exit patterns directly within loop expressions.
+
 You can also filter values by combining the for loop expression with the continue statement.
 
 For loops at the end of a function body are not accumulated into a table for a return value (Instead the function will return nil). Either an explicit return statement can be used, or the loop can be converted into a list comprehension.
@@ -2347,7 +2666,7 @@ print func_b! -- prints table object
 </pre>
 </YueDisplay>
 
-This is done to avoid the needless creation of tables for functions that don’t need to return the results of the loop.
+This is done to avoid the needless creation of tables for functions that don't need to return the results of the loop.
 
 ## Repeat Loop
 
@@ -2626,28 +2945,26 @@ reader\parse_line! until reader\eof!
 
 ## Switch
 
-The switch statement is shorthand for writing a series of if statements that check against the same value. Note that the value is only evaluated once. Like if statements, switches can have an else block to handle no matches. Comparison is done with the == operator.
+The switch statement is shorthand for writing a series of if statements that check against the same value. Note that the value is only evaluated once. Like if statements, switches can have an else block to handle no matches. Comparison is done with the == operator. In switch statement, you can also use assignment expression to store temporary variable value.
 
 ```moonscript
-name = "Dan"
-switch name
+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>
 
@@ -2678,7 +2995,7 @@ next_number = switch b
 </pre>
 </YueDisplay>
 
-We can use the then keyword to write a switch’s when block on a single line. No extra keyword is needed to write the else block on a single line.
+We can use the then keyword to write a switch's when block on a single line. No extra keyword is needed to write the else block on a single line.
 
 ```moonscript
 msg = switch math.random(1, 5)
@@ -2724,7 +3041,7 @@ else
 </pre>
 </YueDisplay>
 
-It is worth noting the order of the case comparison expression. The case’s expression is on the left hand side. This can be useful if the case’s expression wants to overwrite how the comparison is done by defining an eq metamethod.
+It is worth noting the order of the case comparison expression. The case's expression is on the left hand side. This can be useful if the case's expression wants to overwrite how the comparison is done by defining an eq metamethod.
 
 ### Table Matching
 
@@ -2784,6 +3101,123 @@ switch item
 </pre>
 </YueDisplay>
 
+You can also match against array elements, table fields, and even nested structures with array or table literals.
+
+Match against array elements.
+
+```moonscript
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- b has a default value
+    print "1, 2, #{b}"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- b has a default value
+    print "1, 2, #{b}"
+</pre>
+</YueDisplay>
+
+Match against table fields with destructuring.
+
+```moonscript
+switch tb
+  when success: true, :result
+    print "success", result
+  when success: false
+    print "failed", result
+  else
+    print "invalid"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when success: true, :result
+    print "success", result
+  when success: false
+    print "failed", result
+  else
+    print "invalid"
+</pre>
+</YueDisplay>
+
+Match against nested table structures.
+
+```moonscript
+switch tb
+  when data: {type: "success", :content}
+    print "success", content
+  when data: {type: "error", :content}
+    print "failed", content
+  else
+    print "invalid"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when data: {type: "success", :content}
+    print "success", content
+  when data: {type: "error", :content}
+    print "failed", content
+  else
+    print "invalid"
+</pre>
+</YueDisplay>
+
+Match against array of tables.
+
+```moonscript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "matched", fourth
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "matched", fourth
+</pre>
+</YueDisplay>
+
+Match against a list and capture a range of elements.
+
+```moonscript
+segments = ["admin", "users", "logs", "view"]
+switch segments
+        when [...groups, resource, action]
+                print "Group:", groups -- prints: {"admin", "users"}
+                print "Resource:", resource -- prints: "logs"
+                print "Action:", action -- prints: "view"
+```
+<YueDisplay>
+<pre>
+segments = ["admin", "users", "logs", "view"]
+switch segments
+        when [...groups, resource, action]
+                print "Group:", groups -- prints: {"admin", "users"}
+                print "Resource:", resource -- prints: "logs"
+                print "Action:", action -- prints: "view"
+</pre>
+</YueDisplay>
+
 ## Object Oriented Programming
 
 In these examples, the generated Lua code may appear overwhelming. It is best to focus on the meaning of the YueScript code at first, then look into the Lua code if you wish to know the implementation details.
@@ -2915,7 +3349,7 @@ class BackPack extends Inventory
 
 Here we extend our Inventory class, and limit the amount of items it can carry.
 
-In this example, we don’t define a constructor on the subclass, so the parent class' constructor is called when we make a new instance. If we did define a constructor then we can use the super method to call the parent constructor.
+In this example, we don't define a constructor on the subclass, so the parent class' constructor is called when we make a new instance. If we did define a constructor then we can use the super method to call the parent constructor.
 
 Whenever a class inherits from another, it sends a message to the parent class by calling the method __inherited on the parent class if it exists. The function receives two arguments, the class that is being inherited and the child class.
 
@@ -3002,13 +3436,13 @@ print BackPack.size -- prints 10
 
 The class object is what we create when we use a class statement. The class object is stored in a variable of the same name of the class.
 
-The class object can be called like a function in order to create new instances. That’s how we created instances of classes in the examples above.
+The class object can be called like a function in order to create new instances. That's how we created instances of classes in the examples above.
 
 A class is made up of two tables. The class table itself, and the base table. The base is used as the metatable for all the instances. All properties listed in the class declaration are placed in the base.
 
-The class object’s metatable reads properties from the base if they don’t exist in the class object. This means we can access functions and properties directly from the class.
+The class object's metatable reads properties from the base if they don't exist in the class object. This means we can access functions and properties directly from the class.
 
-It is important to note that assigning to the class object does not assign into the base, so it’s not a valid way to add new methods to instances. Instead the base must explicitly be changed. See the __base field below.
+It is important to note that assigning to the class object does not assign into the base, so it's not a valid way to add new methods to instances. Instead the base must explicitly be changed. See the __base field below.
 
 The class object has a couple special properties:
 
@@ -3081,7 +3515,7 @@ print Counter.count -- prints 2
 </pre>
 </YueDisplay>
 
-The calling semantics of @@ are similar to @. Calling a @@ name will pass the class in as the first argument using Lua’s colon syntax.
+The calling semantics of @@ are similar to @. Calling a @@ name will pass the class in as the first argument using Lua's colon syntax.
 
 ```moonscript
 @@hello 1,2,3,4
@@ -3096,7 +3530,7 @@ The calling semantics of @@ are similar to @. Calling a @@ name will pass the cl
 
 In the body of a class declaration, we can have normal expressions in addition to key/value pairs. In this context, self is equal to the class object.
 
-Here is an alternative way to create a class variable compared to what’s described above:
+Here is an alternative way to create a class variable compared to what's described above:
 
 ```moonscript
 class Things
@@ -3362,19 +3796,19 @@ In this usage, with can be seen as a special form of the K combinator.
 The expression in the with statement can also be an assignment, if you want to give a name to the expression.
 
 ```moonscript
-with str = "Hello"
+with str := "Hello"
   print "original:", str
   print "upper:", \upper!
 ```
 <YueDisplay>
 <pre>
-with str = "Hello"
+with str := "Hello"
   print "original:", str
   print "upper:", \upper!
 </pre>
 </YueDisplay>
 
-Accessing special keys with `[]` in a `with` statement.
+You can access special keys with `[]` in a `with` statement.
 
 ```moonscript
 with tb
@@ -3397,6 +3831,18 @@ with tb
 </pre>
 </YueDisplay>
 
+`with?` is an enhanced version of `with` syntax, which introduces an existential check to safely access objects that may be nil without explicit null checks.
+
+```moonscript
+with? obj
+  print obj.name
+```
+<YueDisplay>
+<pre>
+with? obj
+  print obj.name
+</pre>
+</YueDisplay>
 
 ## Do
 
@@ -3417,7 +3863,7 @@ print var -- nil here
 </pre>
 </YueDisplay>
 
-YueScript’s **do** can also be used an expression . Allowing you to combine multiple lines into one. The result of the do expression is the last statement in its body.
+YueScript's **do** can also be used an expression . Allowing you to combine multiple lines into one. The result of the do expression is the last statement in its body.
 
 ```moonscript
 counter = do
@@ -3543,7 +3989,7 @@ print i -- will print 0
 </pre>
 </YueDisplay>
 
-In my_func, we've overwritten the value of i mistakenly. In this example it is quite obvious, but consider a large, or foreign code base where it isn’t clear what names have already been declared.
+In my_func, we've overwritten the value of i mistakenly. In this example it is quite obvious, but consider a large, or foreign code base where it isn't clear what names have already been declared.
 
 It would be helpful to say which variables from the enclosing scope we intend on change, in order to prevent us from changing others by accident.
 
diff --git a/doc/docs/zh/doc/README.md b/doc/docs/zh/doc/README.md
index 1a2da96..15f4768 100755
--- a/doc/docs/zh/doc/README.md
+++ b/doc/docs/zh/doc/README.md
@@ -16,19 +16,29 @@ Yue（月）是中文中“月亮�的�称。
 ### 月之脚本概览
 ```moonscript
 -- 导入语法
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 
 -- ��对象
 inventory =
   equipment:
-    * "sword"
-    * "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
@@ -1850,7 +2114,7 @@ print @value
 </pre>
 </YueDisplay>
 
-您�以通过一个��符指定回调函数的传��置。
+你�以通过一个��符指定回调函数的传��置。
 
 ```moonscript
 (x) <- map _, [1, 2, 3]
@@ -1863,22 +2127,22 @@ x * 2
 </pre>
 </YueDisplay>
 
-如果您希望在��回调处��继续编写更多其它的代�，您�以使用do语�将�归属��回调的代�分开。
+如果你希望在��回调处��继续编写更多其它的代�，�以使用 do 语�将�属于��回调的代�分隔开。对于�粗箭头函数的��回调，回调返回值的括�也是�以�略的。
 
 ```moonscript
 result, msg = do
-  (data) <- readAsync "文件�.txt"
+  data <- readAsync "文件�.txt"
   print data
-  (info) <- processAsync data
+  info <- processAsync data
   check info
 print result, msg
 ```
 <YueDisplay>
 <pre>
 result, msg = do
-  (data) <- readAsync "文件�.txt"
+  data <- readAsync "文件�.txt"
   print data
-  (info) <- processAsync data
+  info <- processAsync data
   check info
 print result, msg
 </pre>
@@ -2037,7 +2301,7 @@ list_with_one_element = [ 1, ]
 
 ## 推导�
 
-推导�为我们�供了一�便�的语法，通过�历现有对象并对其值应用表达��构造出新的表格。月之脚本有两�推导�：列表推导�和表格推导�。它们最终都是产生Lua表格；列表推导�将值累积到类似数组的表格中，而表格推导��许您在�次�历时设置新表格的键和值。
+推导�为我们�供了一�便�的语法，通过�历现有对象并对其值应用表达��构造出新的表格。月之脚本有两�推导�：列表推导�和表格推导�。它们最终都是产生Lua表格；列表推导�将值累积到类似数组的表格中，而表格推导��许你在�次�历时设置新表格的键和值。
 
 ### 列表推导�
 
@@ -2057,13 +2321,11 @@ doubled = [item * 2 for i, item in ipairs items]
 �以使用when��筛选新表中包�的项目：
 
 ```moonscript
-iter = ipairs items
-slice = [item for i, item in iter when i > 1 and i < 3]
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
 ```
 <YueDisplay>
 <pre>
-iter = ipairs items
-slice = [item for i, item in iter when i > 1 and i < 3]
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
 </pre>
 </YueDisplay>
 
@@ -2212,6 +2474,45 @@ slice = [item for item in *items[,,2]]
 </pre>
 </YueDisplay>
 
+最�和最大边界都�以是负数，使用负数�味�边界是从表的末尾开始计算的。
+
+```moonscript
+-- �最�4个元素
+slice = [item for item in *items[-4,-1]]
+```
+<YueDisplay>
+<pre>
+-- �最�4个元素
+slice = [item for item in *items[-4,-1]]
+</pre>
+</YueDisplay>
+
+切片的步长也�以是负数，这�味�元素会以相�的顺�被�出。
+
+```moonscript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+<YueDisplay>
+<pre>
+reverse_slice = [item for item in *items[-1,1,-1]]
+</pre>
+</YueDisplay>
+
+#### 切片表达�
+
+切片也�以作为表达��使用。�以用于获�一个表包�的�列表。
+
+```moonscript
+-- �第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+```
+<YueDisplay>
+<pre>
+-- �第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+</pre>
+</YueDisplay>
+
 ## for 循环
 
 Lua中有两�for循环形�，数字型和通用型：
@@ -2288,9 +2589,24 @@ doubled_evens = for i = 1, 20
 </pre>
 </YueDisplay>
 
-您还�以结�for循环表达�与continue语��过滤值。
+此外，for循环还支�带返回值的break语�，这样循环本身就�以作为一个表达�，在满足�件时��退出并返回有�义的结果。
 
-注�出现在函数体末尾的for循环，�会被当作是一个表达�，并将循环结果累积到一个列表中作为返回值（相�，函数将返回nil）。如果�函数末尾的循环转�为列表表达�，�以使用返回语�加for循环表达�。
+例如，查找第一个大于10的数字：
+
+```moonscript
+first_large = for n in *numbers
+  break n if n > 10
+```
+<YueDisplay>
+<pre>
+first_large = for n in *numbers
+  break n if n > 10
+</pre>
+</YueDisplay>
+
+你还�以结�for循环表达�与continue语��过滤值。
+
+注�出现在函数体末尾的for循环，�会被当作是一个表达�并将循环结果累积到一个列表中作为返回值（相�，函数将返回nil）。如果�函数末尾的循环转�为列表表达�，�以显�地使用返回语�加for循环表达�。
 
 ```moonscript
 func_a = -> for i = 1, 10 do print i
@@ -2515,7 +2831,7 @@ print "你真幸��" unless math.random! > 0.1
 
 ### 范围表达�
 
-您�以使用范围表达��编写进行范围检查的代�。
+你�以使用范围表达��编写进行范围检查的代�。
 
 ```moonscript
 a = 5
@@ -2588,28 +2904,26 @@ reader\parse_line! until reader\eof!
 
 ## switch 语�
 
-switch语�是为了简化检查一系列相�值的if语�而�供的简写语法。�注�用于比较检查的目标值�会计算一次。和if语�一样，switch语�在最��以接一个else代���处�没有匹�的情况。在生�的Lua代�中，进行比较是使用==�作符完�的。
+switch语�是为了简化检查一系列相�值的if语�而�供的简写语法。�注�用于比较检查的目标值�会计算一次。和if语�一样，switch语�在最��以接一个else代���处�没有匹�的情况。在生�的Lua代�中，进行比较是使用==�作符完�的。switch语�中也�以使用赋值表达��储存临时��值。
 
 ```moonscript
-name = "Dan"
-switch name
+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>
 
@@ -2686,7 +3000,7 @@ else
 </pre>
 </YueDisplay>
 
-值得注�的是，在生�Lua代�时，我们��检查的目标��会放在==表达�的�侧。当您希望给when��的比较对象定义一个\_\_eq元方法��载判断逻辑时，�能会有用。
+值得注�的是，在生�Lua代�时，我们��检查的目标��会放在==表达�的�侧。当你希望给when��的比较对象定义一个\_\_eq元方法��载判断逻辑时，�能会有用。
 
 ### 表格匹�
 
@@ -2746,9 +3060,126 @@ switch item
 </pre>
 </YueDisplay>
 
+你也�以匹�数组元素�表格字段，甚至使用数组或表格字���匹�嵌套的结构。
+
+匹�数组元素。
+
+```moonscript
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- ��b有默认值
+    print "1, 2, #{b}"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- ��b有默认值
+    print "1, 2, #{b}"
+</pre>
+</YueDisplay>
+
+匹�表格字段。
+
+```moonscript
+switch tb
+  when success: true, :result
+    print "�功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when success: true, :result
+    print "�功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+</pre>
+</YueDisplay>
+
+匹�嵌套的表格结构。
+
+```moonscript
+switch tb
+  when data: {type: "success", :content}
+    print "�功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when data: {type: "success", :content}
+    print "�功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+</pre>
+</YueDisplay>
+
+匹�表格数组。
+
+```moonscript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹��功", fourth
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹��功", fourth
+</pre>
+</YueDisplay>
+
+匹�一个列表并�获特定范围内的元素。
+
+```moonscript
+segments = ["admin", "users", "logs", "view"]
+switch segments
+        when [...groups, resource, action]
+                print "Group:", groups -- 打�: {"admin", "users"}
+                print "Resource:", resource -- 打�: "logs"
+                print "Action:", action -- 打�: "view"
+```
+<YueDisplay>
+<pre>
+segments = ["admin", "users", "logs", "view"]
+switch segments
+        when [...groups, resource, action]
+                print "Group:", groups -- 打�: {"admin", "users"}
+                print "Resource:", resource -- 打�: "logs"
+                print "Action:", action -- 打�: "view"
+</pre>
+</YueDisplay>
+
 ## ��对象编程
 
-在以下的示例中，月之脚本生�的Lua代��能看起�会很��。所以最好主�关注月之脚本代�层�的�义，然�如果您想知�关于��对象功能的实现细节，�查看Lua代�。
+在以下的示例中，月之脚本生�的Lua代��能看起�会很��。所以最好主�关注月之脚本代�层�的�义，然�如果你想知�关于��对象功能的实现细节，�查看Lua代�。
 
 一个简�的类：
 
@@ -3216,7 +3647,7 @@ x = class
 
 ### 类混�
 
-您�以通过使用 `using` 关键字�实现类混�。这�味�您�以从一个普通 Lua 表格或已定义的类对象中，�制函数到您创建的新类中。当您使用普通 Lua 表格进行类混�时，您有机会用自己的实现��写类的索引方法（例如元方法 `__index`）。然而，当您从一个类对象�混�时，需�注�的是该类对象的元方法将�会被�制到新类。
+你�以通过使用 `using` 关键字�实现类混�。这�味�你�以从一个普通 Lua 表格或已定义的类对象中，�制函数到你创建的新类中。当你使用普通 Lua 表格进行类混�时，你有机会用自己的实现��写类的索引方法（例如元方法 `__index`）。然而，当你从一个类对象�混�时，需�注�的是该类对象的元方法将�会被�制到新类。
 
 ```moonscript
 MyIndex = __index: var: 1
@@ -3318,22 +3749,22 @@ me = create_person "Leaf", [dad, mother, sister]
 
 在此用法中，with�以被视为K组��（k-combinator）的一�特殊形�。
 
-如果您想给表达��外起一个�称的�，with语�中的表达�也�以是一个赋值语�。
+如果你想给表达��外起一个�称的�，with语�中的表达�也�以是一个赋值语�。
 
 ```moonscript
-with str = "你好"
+with str := "你好"
   print "原始:", str
   print "大写:", \upper!
 ```
 <YueDisplay>
 <pre>
-with str = "你好"
+with str := "你好"
   print "原始:", str
   print "大写:", \upper!
 </pre>
 </YueDisplay>
 
-在with语�中�以使用`[]`访问特殊键。
+你�以在 `with` 语�中使用 `[]` 访问特殊键。
 
 ```moonscript
 with tb
@@ -3356,6 +3787,19 @@ with tb
 </pre>
 </YueDisplay>
 
+`with?` 是 `with` 语法的一个增强版本，引入了存在性检查，用于在�显�判空的情况下安全访问�能为 nil 的对象。
+
+```moonscript
+with? obj
+  print obj.name
+```
+<YueDisplay>
+<pre>
+with? obj
+  print obj.name
+</pre>
+</YueDisplay>
+
 ## do 语�
 
 当用作语�时，do语�的作用就�在Lua中差�多。
@@ -3375,7 +3819,7 @@ print var -- 这里是nil
 </pre>
 </YueDisplay>
 
-月之脚本的 **do** 也�以用作表达�。�许您将多行代�的处��并为一个表达�，并将do语�代��的最�一个语�作为表达�返回的结果。
+月之脚本的 **do** 也�以用作表达�。�许你将多行代�的处��并为一个表达�，并将do语�代��的最�一个语�作为表达�返回的结果。
 
 ```moonscript
 counter = do
@@ -4334,8 +4778,8 @@ simplified: boolean
 
 版� (c) 2017-2025 �瑾  \<dragon-fly@qq.com\>
 
-特此�费授予任何获得本软件副本和相关文档文件（下称“软件�）的人���制地处置该软件的�利，包括���制地使用��制�修改��并��布�分��转授许�和/或出售该软件副本，以��授�被��了本软件的人如上的�利，须在下列�件下：  
-上述版�声明和本许�声明应包�在该软件的所有副本或实质�分中。  
+特此�费授予任何获得本软件副本和相关文档文件（下称“软件�）的人���制地处置该软件的�利，包括���制地使用��制�修改��并��布�分��转授许�和/或出售该软件副本，以��授�被��了本软件的人如上的�利，须在下列�件下：
+上述版�声明和本许�声明应包�在该软件的所有副本或实质�分中。
 本软件是“如此��供的，没有任何形�的明示或暗示的��，包括但��于对适销性�特定用途的适用性和�侵�的��。在任何情况下，作者或版��有人都�对任何索赔��害或其他责任负责，无论这些追责�自���侵�或其它行为中，还是产生于��于或有关于本软件以�本软件的使用或其它处置。
 
 <CompilerModal />
diff --git a/spec/inputs/backcall.yue b/spec/inputs/backcall.yue
index 8aadc71..e6b8c21 100644
--- a/spec/inputs/backcall.yue
+++ b/spec/inputs/backcall.yue
@@ -13,9 +13,9 @@ do
         x > 2
 
 do
-        (data) <- http?.get "ajaxtest"
+        data <- http?.get "ajaxtest"
         body[".result"]\html data
-        (processed) <- http.post "ajaxprocess", data
+        processed <- http.post "ajaxprocess", data
         body[".result"]\append processed
         <- setTimeout 1000
         print "done"
diff --git a/spec/inputs/destructure.yue b/spec/inputs/destructure.yue
index 674dfe4..b6250d0 100644
--- a/spec/inputs/destructure.yue
+++ b/spec/inputs/destructure.yue
@@ -94,7 +94,7 @@ do
 --
 
 do
-        with {a,b} = thing
+        with {a,b} := thing
                 print a, b
 
 
@@ -240,5 +240,43 @@ do
         switch tb
                 when {c: {<"abc">: meta_field = "def"}, <[[any string]]>: {d: abc = 123}, <'str'>: {e: def = {}}}
                         print meta_field, abc, def
+
+do
+        clients = ["VIP_Alice", "User_Bob", "User_Clara", "VIP_Eva"]
+        [vipStart, ...regulars, vipEnd] = clients
+        print vipStart -- "VIP_Alice"
+        print regulars -- {"User_Bob", "User_Clara"}
+        print vipEnd   -- "VIP_Eva"
+
+do
+        setupMeeting = (participants) ->
+                [chair, ..._, secretary] = participants
+                print chair, secretary
+
+        setupMeeting ["Alice", "Bob", "Charlie", "David"]
+        -- Output: Alice David
+
+do
+        getTransactions = ->
+                {
+                        {id: "T1", amount: 100}
+                        {id: "T2", amount: 200}
+                        {id: "T3", amount: 300}
+                }
+
+        :id, :amount = getTransactions![#]
+        assert id == "T3"
+        assert amount == 300
+
+do
+        [
+                _
+                ...middle
+                _
+        ] = tb
+
+do
+        {a, :abc, b, :def, ...sub, d, e} = tb
+
 nil
 
diff --git a/spec/inputs/global.yue b/spec/inputs/global.yue
index ce1cc15..4e3b8aa 100644
--- a/spec/inputs/global.yue
+++ b/spec/inputs/global.yue
@@ -82,3 +82,9 @@ do
         FooBar = "pascal case"
         FOOBAR = "all uppercase"
 
+do
+        global const class A
+        global const Flag = 1
+        global const const, x, y = "const", 1, 2
+        global const math, table
+
diff --git a/spec/inputs/import.yue b/spec/inputs/import.yue
index b8ffc24..8982e6c 100644
--- a/spec/inputs/import.yue
+++ b/spec/inputs/import.yue
@@ -139,3 +139,13 @@ do
         import "m" as {c: d}
         import "m" as {g, {<close>: i}}
 
+do
+        import require
+        import string as stringlib
+        import string.format
+        import io.read as io_read
+
+        type = ->
+        import type as tp
+        import 月 as yue
+
diff --git a/spec/inputs/lists.yue b/spec/inputs/lists.yue
index 921cae0..c493b68 100644
--- a/spec/inputs/lists.yue
+++ b/spec/inputs/lists.yue
@@ -87,4 +87,51 @@ do
         [a, b] = hello
         [name = "nameless", job = "jobless"] = person
 
+do
+        transactions = ["T001", "T002", "T003", "T004", "T005"]
+        middleTransactions = transactions[2, -2]
+        print middleTransactions -- => {"T002", "T003", "T004"}
+
+do
+        logs =
+                - start: 0, end: 100
+                - start: 100, end: 200
+                - start: 200, end: 123
+        print logs[#].end -- => 123
+
+do
+        pendingOrders = ["O001", "O002", "O003", "O004"]
+        print pendingOrders[# - 1] -- => "O003" 
+
+do
+        getOrders = ->
+                {
+                        { id: "O1001", status: "pending" }
+                        { id: "O1002", status: "processing" }
+                        { id: "O1003", status: "done" }
+                }
+
+        lastStatus = getOrders()[#].status
+        assert lastStatus == "done"
+
+do
+        cloneList1 = (list) -> list[,]
+        cloneList2 = (list) -> [...list,]
+        cloneTable = (tb) -> {...tb}
+
+do
+        print(
+                globalTB[#]
+                a.b.c[# - 2]
+                x?\y?!.z?[# - 3]
+        )
+
+do
+        f = ->
+                print(
+                        globalTB[#]\end 123
+                        a.b.c[5,-5][# - 2]
+                        x?\y?!.z?[# - 3]?[, -3]
+                )
+
 nil
diff --git a/spec/inputs/literals.yue b/spec/inputs/literals.yue
index 6b666f0..32cf7e7 100644
--- a/spec/inputs/literals.yue
+++ b/spec/inputs/literals.yue
@@ -10,10 +10,19 @@ _ = {
         0xfF2323
         0xabcdef
         0xABCDEF
+        0XFB_C4_00
         0x123p-123
         0xABCP+321
         0x.1p-111
         0xA_B_CP-3_2_1
+        0x0.1E
+        0xA23p-4
+        0X1.921FB54442D18P+1
+
+        0b01
+        0b00_00_10_00
+        0B1111
+        0B00_11_00_10_01
 
         .2323
         .2323e-1
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/attrib.lua b/spec/outputs/5.1/attrib.lua
index a156e84..bda24bc 100644
--- a/spec/outputs/5.1/attrib.lua
+++ b/spec/outputs/5.1/attrib.lua
@@ -136,9 +136,11 @@ do
         end
         local b
         if not false then
-                if x then
-                        b = 1
-                end
+                b = ((function()
+                        if x then
+                                return 1
+                        end
+                end)())
         end
         local _close_0
         if (function()
@@ -164,10 +166,12 @@ do
         end)(pcall(function()
                 local c
                 if true then
-                        local _exp_0 = x
-                        if "abc" == _exp_0 then
-                                c = 998
-                        end
+                        c = ((function()
+                                local _exp_0 = x
+                                if "abc" == _exp_0 then
+                                        return 998
+                                end
+                        end)())
                 end
                 local d
                 if (function()
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 d4c80c1..d2b58bc 100644
--- a/spec/outputs/5.1/try_catch.lua
+++ b/spec/outputs/5.1/try_catch.lua
@@ -8,10 +8,10 @@ local _anon_func_2 = function(tb)
         return tb.func()
 end
 local _anon_func_3 = function(tb)
-        return tb.func()
+        return (tb.func())
 end
 local _anon_func_4 = function(tb)
-        return tb:func(1, 2, 3)
+        return (tb:func(1, 2, 3))
 end
 local _anon_func_5 = function(tb)
         return tb.func(1)
@@ -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()
@@ -64,7 +101,7 @@ f = function()
                 print("OK")
         end
         if xpcall(function()
-                return func(1)
+                return (func(1))
         end, function(err)
                 return print(err)
         end) then
@@ -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 f889865..89c5f8a 100644
--- a/spec/outputs/assign.lua
+++ b/spec/outputs/assign.lua
@@ -36,17 +36,15 @@ local x
 do
         local f = getHandler()
         if f then
-                do
+                x = ((function()
                         f()
-                        x = 123
-                end
+                        return 123
+                end)())
         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/attrib.lua b/spec/outputs/attrib.lua
index e48963c..bb9916c 100644
--- a/spec/outputs/attrib.lua
+++ b/spec/outputs/attrib.lua
@@ -56,17 +56,21 @@ do
         end
         local b
         if not false then
-                if x then
-                        b = 1
-                end
+                b = ((function()
+                        if x then
+                                return 1
+                        end
+                end)())
         end
         local _close_0 <close> = b
         local c
         if true then
-                local _exp_0 = x
-                if "abc" == _exp_0 then
-                        c = 998
-                end
+                c = ((function()
+                        local _exp_0 = x
+                        if "abc" == _exp_0 then
+                                return 998
+                        end
+                end)())
         end
         local d
         if (function()
diff --git a/spec/outputs/codes_from_doc.lua b/spec/outputs/codes_from_doc.lua
index 27f8de5..b7d1236 100644
--- a/spec/outputs/codes_from_doc.lua
+++ b/spec/outputs/codes_from_doc.lua
@@ -20,6 +20,38 @@ local inventory = {
                 }
         }
 }
+local map
+map = function(arr, action)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                _accum_0[_len_0] = action(item)
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+local filter
+filter = function(arr, cond)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                if cond(item) then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        end
+        return _accum_0
+end
+local reduce
+reduce = function(arr, init, action)
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                init = action(init, item)
+        end
+        return init
+end
 print(reduce(filter(map({
         1,
         2,
@@ -77,6 +109,12 @@ end
 print("yuescript")
 print(3)
 print("Valid enum type:", "Static")
+do
+        print(123, "hello")
+end
+do
+        print(123, "hello")
+end
 if tb ~= nil then
         tb:func()
 end
@@ -177,6 +215,16 @@ for _key_0, _value_0 in pairs(b) do
         end
 end
 merge = _tab_0
+local last
+do
+        local _item_0 = data.items
+        last = _item_0[#_item_0]
+end
+local second_last
+do
+        local _item_0 = data.items
+        second_last = _item_0[#_item_0 - 1]
+end
 local mt = { }
 local add
 add = function(self, right)
@@ -307,6 +355,14 @@ func({
         2,
         3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
         name = "abc",
         values = {
@@ -547,6 +603,59 @@ end
 local two, four
 local _obj_0 = items
 two, four = _obj_0[2], _obj_0[4]
+local orders = {
+        "first",
+        "second",
+        "third",
+        "fourth",
+        "last"
+}
+local first, bulk, last = orders[1], (function()
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _max_0 = #orders + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = orders[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end)(), orders[#orders]
+print(first)
+print(bulk)
+print(last)
+local first, rest
+do
+        local _obj_0 = orders
+        first, rest = _obj_0[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)()
+end
+local start, last
+do
+        local _obj_0 = orders
+        start, last = (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -2 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0]
+end
+local _obj_0 = orders
+first, last = _obj_0[1], _obj_0[#_obj_0]
 local tuples = {
         {
                 "hello",
@@ -648,6 +757,56 @@ end)
 if success then
         print(result)
 end
+local a, b, c
+do
+        local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                return func()
+        end)
+        if _ok_0 then
+                a, b, c = _ret_0, _ret_1, _ret_2
+        end
+end
+do
+        local _exp_0 = ((function()
+                return (function(_arg_0, ...)
+                        local _ok_0 = _arg_0
+                        if _ok_0 then
+                                return ...
+                        end
+                end)(pcall(function()
+                        return func()
+                end))
+        end)())
+        if _exp_0 ~= nil then
+                a = _exp_0
+        else
+                a = "default"
+        end
+end
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(pcall(function()
+                return func()
+        end))
+end)())
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(xpcall(function()
+                print(123)
+                return func()
+        end, function(e)
+                print(e)
+                return e
+        end))
+end)())
 local a <const> = 123
 local _ <close> = setmetatable({ }, {
         __close = function()
@@ -657,10 +816,19 @@ local _ <close> = setmetatable({ }, {
 local a, b, c, d
 local _obj_0 = tb
 a, b, c, d = _obj_0.a, _obj_0.b, _obj_0[1], _obj_0[2]
+Constant = 123
 local some_string = "Here is a string\n  that has a line break in it."
 print("I am " .. tostring(math.random() * 100) .. "% sure.")
 local integer = 1000000
 local hex = 0xEFBBBF
+local binary = 19
+local str = "key: value\nlist:\n  - item1\n  - " .. tostring(expr)
+local fn
+fn = function()
+        local str = "foo:\n  bar: baz"
+        return str
+end
+local str = "path: \"C:\\Program Files\\App\"\nnote: 'He said: \"" .. tostring(Hello) .. "!\"'"
 local my_function
 my_function = function() end
 my_function()
@@ -860,11 +1028,10 @@ for i, item in ipairs(items) do
         _len_0 = _len_0 + 1
 end
 doubled = _accum_0
-local iter = ipairs(items)
 local slice
 local _accum_0 = { }
 local _len_0 = 1
-for i, item in iter do
+for i, item in ipairs(items) do
         if i > 1 and i < 3 then
                 _accum_0[_len_0] = item
                 _len_0 = _len_0 + 1
@@ -971,8 +1138,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
@@ -982,7 +1148,8 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 2, #_list_0 do
+local _max_0 = #_list_0
+for _index_0 = 2, _max_0 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
@@ -992,12 +1159,46 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 1, #_list_0, 2 do
+local _max_0 = #_list_0
+for _index_0 = 1, _max_0, 2 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
 end
 slice = _accum_0
+local slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -4 + 1
+local _max_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, _max_0 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+slice = _accum_0
+local reverse_slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, 1, -1 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+reverse_slice = _accum_0
+local sub_list
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+for _index_0 = 2, 4 do
+        local _item_0 = _list_0[_index_0]
+        _accum_0[_len_0] = _item_0
+        _len_0 = _len_0 + 1
+end
+sub_list = _accum_0
 for i = 10, 20 do
         print(i)
 end
@@ -1008,8 +1209,7 @@ for key, value in pairs(object) do
         print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
-for _index_0 = 2, _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
@@ -1027,12 +1227,24 @@ local _len_0 = 1
 for i = 1, 20 do
         if i % 2 == 0 then
                 _accum_0[_len_0] = i * 2
+                _len_0 = _len_0 + 1
         else
                 _accum_0[_len_0] = i
+                _len_0 = _len_0 + 1
         end
-        _len_0 = _len_0 + 1
 end
 doubled_evens = _accum_0
+local first_large
+local _accum_0
+local _list_0 = numbers
+for _index_0 = 1, #_list_0 do
+        local n = _list_0[_index_0]
+        if n > 10 then
+                _accum_0 = n
+                break
+        end
+end
+first_large = _accum_0
 local func_a
 func_a = function()
         for i = 1, 10 do
@@ -1181,7 +1393,7 @@ if "Robert" == name then
 elseif "Dan" == name or "Daniel" == name then
         print("Your name, it's Dan")
 else
-        print("I don't know about your name")
+        print("I don't know about you with name " .. tostring(name))
 end
 local b = 1
 local next_number
@@ -1281,6 +1493,192 @@ if _tab_0 then
         end
         print("Vec2 " .. tostring(x) .. ", " .. tostring(y))
 end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        if 1 == _exp_0[1] and 2 == _exp_0[2] and 3 == _exp_0[3] then
+                _match_0 = true
+                print("1, 2, 3")
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local b = _exp_0[2]
+                if 1 == _exp_0[1] and b ~= nil and 3 == _exp_0[3] then
+                        _match_1 = true
+                        print("1, " .. tostring(b) .. ", 3")
+                end
+        end
+        if not _match_1 then
+                if _tab_0 then
+                        local b = _exp_0[3]
+                        if b == nil then
+                                b = 3
+                        end
+                        if 1 == _exp_0[1] and 2 == _exp_0[2] then
+                                print("1, 2, " .. tostring(b))
+                        end
+                end
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local result = _exp_0.result
+        if true == _exp_0.success and result ~= nil then
+                _match_0 = true
+                print("success", result)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                if false == _exp_0.success then
+                        _match_1 = true
+                        print("failed", result)
+                end
+        end
+        if not _match_1 then
+                print("invalid")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local content
+        do
+                local _obj_0 = _exp_0.data
+                local _type_1 = type(_obj_0)
+                if "table" == _type_1 or "userdata" == _type_1 then
+                        content = _obj_0.content
+                end
+        end
+        local _val_0
+        do
+                local _obj_0 = _exp_0.data
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.type
+                end
+        end
+        if "success" == _val_0 and content ~= nil then
+                _match_0 = true
+                print("success", content)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local content
+                do
+                        local _obj_0 = _exp_0.data
+                        local _type_1 = type(_obj_0)
+                        if "table" == _type_1 or "userdata" == _type_1 then
+                                content = _obj_0.content
+                        end
+                end
+                local _val_0
+                do
+                        local _obj_0 = _exp_0.data
+                        if _obj_0 ~= nil then
+                                _val_0 = _obj_0.type
+                        end
+                end
+                if "error" == _val_0 and content ~= nil then
+                        _match_1 = true
+                        print("failed", content)
+                end
+        end
+        if not _match_1 then
+                print("invalid")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local fourth = _exp_0[4]
+        local _val_0
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.a
+                end
+        end
+        local _val_1
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_1 = _obj_0.b
+                end
+        end
+        local _val_2
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_2 = _obj_0.a
+                end
+        end
+        local _val_3
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_3 = _obj_0.b
+                end
+        end
+        local _val_4
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_4 = _obj_0.a
+                end
+        end
+        local _val_5
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_5 = _obj_0.b
+                end
+        end
+        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                print("matched", fourth)
+        end
+end
+local segments = {
+        "admin",
+        "users",
+        "logs",
+        "view"
+}
+local _type_0 = type(segments)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local groups
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #segments + -3 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = segments[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                groups = _accum_0
+        end
+        local resource = segments[#segments - 1]
+        local action = segments[#segments]
+        if resource ~= nil and action ~= nil then
+                print("Group:", groups)
+                print("Resource:", resource)
+                print("Action:", action)
+        end
+end
 local Inventory
 local _class_0
 local _base_0 = {
@@ -1937,6 +2335,10 @@ do
         _with_1["key-name"] = value
 end
 _with_0[#_with_0 + 1] = "abc"
+local _with_0 = obj
+if _with_0 ~= nil then
+        print(obj.name)
+end
 do
         local var = "hello"
         print(var)
@@ -2027,6 +2429,38 @@ local inventory = {
                 }
         }
 }
+local map
+map = function(arr, action)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                _accum_0[_len_0] = action(item)
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+local filter
+filter = function(arr, cond)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                if cond(item) then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        end
+        return _accum_0
+end
+local reduce
+reduce = function(arr, init, action)
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                init = action(init, item)
+        end
+        return init
+end
 print(reduce(filter(map({
         1,
         2,
@@ -2084,6 +2518,12 @@ end
 print("yuescript")
 print(3)
 print("Valid enum type:", "Static")
+do
+        print(123, "hello")
+end
+do
+        print(123, "hello")
+end
 if tb ~= nil then
         tb:func()
 end
@@ -2184,6 +2624,16 @@ for _key_0, _value_0 in pairs(b) do
         end
 end
 merge = _tab_0
+local last
+do
+        local _item_0 = data.items
+        last = _item_0[#_item_0]
+end
+local second_last
+do
+        local _item_0 = data.items
+        second_last = _item_0[#_item_0 - 1]
+end
 local mt = { }
 local add
 add = function(self, right)
@@ -2314,6 +2764,14 @@ func({
         2,
         3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
         name = "abc",
         values = {
@@ -2554,6 +3012,59 @@ end
 local two, four
 local _obj_0 = items
 two, four = _obj_0[2], _obj_0[4]
+local orders = {
+        "first",
+        "second",
+        "third",
+        "fourth",
+        "last"
+}
+local first, bulk, last = orders[1], (function()
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _max_0 = #orders + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = orders[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end)(), orders[#orders]
+print(first)
+print(bulk)
+print(last)
+local first, rest
+do
+        local _obj_0 = orders
+        first, rest = _obj_0[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)()
+end
+local start, last
+do
+        local _obj_0 = orders
+        start, last = (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -2 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0]
+end
+local _obj_0 = orders
+first, last = _obj_0[1], _obj_0[#_obj_0]
 local tuples = {
         {
                 "hello",
@@ -2655,6 +3166,56 @@ end)
 if success then
         print(result)
 end
+local a, b, c
+do
+        local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                return func()
+        end)
+        if _ok_0 then
+                a, b, c = _ret_0, _ret_1, _ret_2
+        end
+end
+do
+        local _exp_0 = ((function()
+                return (function(_arg_0, ...)
+                        local _ok_0 = _arg_0
+                        if _ok_0 then
+                                return ...
+                        end
+                end)(pcall(function()
+                        return func()
+                end))
+        end)())
+        if _exp_0 ~= nil then
+                a = _exp_0
+        else
+                a = "default"
+        end
+end
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(pcall(function()
+                return func()
+        end))
+end)())
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(xpcall(function()
+                print(123)
+                return func()
+        end, function(e)
+                print(e)
+                return e
+        end))
+end)())
 local a <const> = 123
 local _ <close> = setmetatable({ }, {
         __close = function()
@@ -2664,10 +3225,19 @@ local _ <close> = setmetatable({ }, {
 local a, b, c, d
 local _obj_0 = tb
 a, b, c, d = _obj_0.a, _obj_0.b, _obj_0[1], _obj_0[2]
+Constant = 123
 local some_string = "Here is a string\n  that has a line break in it."
 print("I am " .. tostring(math.random() * 100) .. "% sure.")
 local integer = 1000000
 local hex = 0xEFBBBF
+local binary = 19
+local str = "key: value\nlist:\n  - item1\n  - " .. tostring(expr)
+local fn
+fn = function()
+        local str = "foo:\n  bar: baz"
+        return str
+end
+local str = "path: \"C:\\Program Files\\App\"\nnote: 'He said: \"" .. tostring(Hello) .. "!\"'"
 local my_function
 my_function = function() end
 my_function()
@@ -2867,11 +3437,10 @@ for i, item in ipairs(items) do
         _len_0 = _len_0 + 1
 end
 doubled = _accum_0
-local iter = ipairs(items)
 local slice
 local _accum_0 = { }
 local _len_0 = 1
-for i, item in iter do
+for i, item in ipairs(items) do
         if i > 1 and i < 3 then
                 _accum_0[_len_0] = item
                 _len_0 = _len_0 + 1
@@ -2978,8 +3547,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
@@ -2989,7 +3557,8 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 2, #_list_0 do
+local _max_0 = #_list_0
+for _index_0 = 2, _max_0 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
@@ -2999,12 +3568,46 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 1, #_list_0, 2 do
+local _max_0 = #_list_0
+for _index_0 = 1, _max_0, 2 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
 end
 slice = _accum_0
+local slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -4 + 1
+local _max_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, _max_0 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+slice = _accum_0
+local reverse_slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, 1, -1 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+reverse_slice = _accum_0
+local sub_list
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+for _index_0 = 2, 4 do
+        local _item_0 = _list_0[_index_0]
+        _accum_0[_len_0] = _item_0
+        _len_0 = _len_0 + 1
+end
+sub_list = _accum_0
 for i = 10, 20 do
         print(i)
 end
@@ -3015,8 +3618,7 @@ for key, value in pairs(object) do
         print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
-for _index_0 = 2, _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
@@ -3034,12 +3636,24 @@ local _len_0 = 1
 for i = 1, 20 do
         if i % 2 == 0 then
                 _accum_0[_len_0] = i * 2
+                _len_0 = _len_0 + 1
         else
                 _accum_0[_len_0] = i
+                _len_0 = _len_0 + 1
         end
-        _len_0 = _len_0 + 1
 end
 doubled_evens = _accum_0
+local first_large
+local _accum_0
+local _list_0 = numbers
+for _index_0 = 1, #_list_0 do
+        local n = _list_0[_index_0]
+        if n > 10 then
+                _accum_0 = n
+                break
+        end
+end
+first_large = _accum_0
 local func_a
 func_a = function()
         for i = 1, 10 do
@@ -3188,7 +3802,7 @@ if "Robert" == name then
 elseif "Dan" == name or "Daniel" == name then
         print("Your name, it's Dan")
 else
-        print("I don't know about your name")
+        print("I don't know about you with name " .. tostring(name))
 end
 local b = 1
 local next_number
@@ -3288,6 +3902,192 @@ if _tab_0 then
         end
         print("Vec2 " .. tostring(x) .. ", " .. tostring(y))
 end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        if 1 == _exp_0[1] and 2 == _exp_0[2] and 3 == _exp_0[3] then
+                _match_0 = true
+                print("1, 2, 3")
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local b = _exp_0[2]
+                if 1 == _exp_0[1] and b ~= nil and 3 == _exp_0[3] then
+                        _match_1 = true
+                        print("1, " .. tostring(b) .. ", 3")
+                end
+        end
+        if not _match_1 then
+                if _tab_0 then
+                        local b = _exp_0[3]
+                        if b == nil then
+                                b = 3
+                        end
+                        if 1 == _exp_0[1] and 2 == _exp_0[2] then
+                                print("1, 2, " .. tostring(b))
+                        end
+                end
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local result = _exp_0.result
+        if true == _exp_0.success and result ~= nil then
+                _match_0 = true
+                print("success", result)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                if false == _exp_0.success then
+                        _match_1 = true
+                        print("failed", result)
+                end
+        end
+        if not _match_1 then
+                print("invalid")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local content
+        do
+                local _obj_0 = _exp_0.data
+                local _type_1 = type(_obj_0)
+                if "table" == _type_1 or "userdata" == _type_1 then
+                        content = _obj_0.content
+                end
+        end
+        local _val_0
+        do
+                local _obj_0 = _exp_0.data
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.type
+                end
+        end
+        if "success" == _val_0 and content ~= nil then
+                _match_0 = true
+                print("success", content)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local content
+                do
+                        local _obj_0 = _exp_0.data
+                        local _type_1 = type(_obj_0)
+                        if "table" == _type_1 or "userdata" == _type_1 then
+                                content = _obj_0.content
+                        end
+                end
+                local _val_0
+                do
+                        local _obj_0 = _exp_0.data
+                        if _obj_0 ~= nil then
+                                _val_0 = _obj_0.type
+                        end
+                end
+                if "error" == _val_0 and content ~= nil then
+                        _match_1 = true
+                        print("failed", content)
+                end
+        end
+        if not _match_1 then
+                print("invalid")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local fourth = _exp_0[4]
+        local _val_0
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.a
+                end
+        end
+        local _val_1
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_1 = _obj_0.b
+                end
+        end
+        local _val_2
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_2 = _obj_0.a
+                end
+        end
+        local _val_3
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_3 = _obj_0.b
+                end
+        end
+        local _val_4
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_4 = _obj_0.a
+                end
+        end
+        local _val_5
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_5 = _obj_0.b
+                end
+        end
+        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                print("matched", fourth)
+        end
+end
+local segments = {
+        "admin",
+        "users",
+        "logs",
+        "view"
+}
+local _type_0 = type(segments)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local groups
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #segments + -3 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = segments[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                groups = _accum_0
+        end
+        local resource = segments[#segments - 1]
+        local action = segments[#segments]
+        if resource ~= nil and action ~= nil then
+                print("Group:", groups)
+                print("Resource:", resource)
+                print("Action:", action)
+        end
+end
 local Inventory
 local _class_0
 local _base_0 = {
@@ -3944,6 +4744,10 @@ do
         _with_1["key-name"] = value
 end
 _with_0[#_with_0 + 1] = "abc"
+local _with_0 = obj
+if _with_0 ~= nil then
+        print(obj.name)
+end
 do
         local var = "hello"
         print(var)
diff --git a/spec/outputs/codes_from_doc_zh.lua b/spec/outputs/codes_from_doc_zh.lua
index ffa0483..b54d6d7 100644
--- a/spec/outputs/codes_from_doc_zh.lua
+++ b/spec/outputs/codes_from_doc_zh.lua
@@ -20,6 +20,38 @@ local inventory = {
                 }
         }
 }
+local map
+map = function(arr, action)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                _accum_0[_len_0] = action(item)
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+local filter
+filter = function(arr, cond)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                if cond(item) then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        end
+        return _accum_0
+end
+local reduce
+reduce = function(arr, init, action)
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                init = action(init, item)
+        end
+        return init
+end
 print(reduce(filter(map({
         1,
         2,
@@ -77,6 +109,12 @@ end
 print("yuescript")
 print(3)
 print("有效的枚举类型:", "Static")
+do
+        print(123, "hello")
+end
+do
+        print(123, "hello")
+end
 if tb ~= nil then
         tb:func()
 end
@@ -177,6 +215,16 @@ for _key_0, _value_0 in pairs(b) do
         end
 end
 merge = _tab_0
+local last
+do
+        local _item_0 = data.items
+        last = _item_0[#_item_0]
+end
+local second_last
+do
+        local _item_0 = data.items
+        second_last = _item_0[#_item_0 - 1]
+end
 local mt = { }
 local add
 add = function(self, right)
@@ -307,6 +355,14 @@ func({
         2,
         3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
         name = "abc",
         values = {
@@ -547,6 +603,59 @@ end
 local two, four
 local _obj_0 = items
 two, four = _obj_0[2], _obj_0[4]
+local orders = {
+        "first",
+        "second",
+        "third",
+        "fourth",
+        "last"
+}
+local first, bulk, last = orders[1], (function()
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _max_0 = #orders + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = orders[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end)(), orders[#orders]
+print(first)
+print(bulk)
+print(last)
+local first, rest
+do
+        local _obj_0 = orders
+        first, rest = _obj_0[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)()
+end
+local start, last
+do
+        local _obj_0 = orders
+        start, last = (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -2 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0]
+end
+local _obj_0 = orders
+first, last = _obj_0[1], _obj_0[#_obj_0]
 local tuples = {
         {
                 "hello",
@@ -648,6 +757,56 @@ end)
 if success then
         print(result)
 end
+local a, b, c
+do
+        local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                return func()
+        end)
+        if _ok_0 then
+                a, b, c = _ret_0, _ret_1, _ret_2
+        end
+end
+do
+        local _exp_0 = ((function()
+                return (function(_arg_0, ...)
+                        local _ok_0 = _arg_0
+                        if _ok_0 then
+                                return ...
+                        end
+                end)(pcall(function()
+                        return func()
+                end))
+        end)())
+        if _exp_0 ~= nil then
+                a = _exp_0
+        else
+                a = "default"
+        end
+end
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(pcall(function()
+                return func()
+        end))
+end)())
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(xpcall(function()
+                print(123)
+                return func()
+        end, function(e)
+                print(e)
+                return e
+        end))
+end)())
 local a <const> = 123
 local _ <close> = setmetatable({ }, {
         __close = function()
@@ -657,10 +816,19 @@ local _ <close> = setmetatable({ }, {
 local a, b, c, d
 local _obj_0 = tb
 a, b, c, d = _obj_0.a, _obj_0.b, _obj_0[1], _obj_0[2]
+Constant = 123
 local some_string = "这是一个字符串\n  并包括一个�行。"
 print("我有" .. tostring(math.random() * 100) .. "%的把�。")
 local integer = 1000000
 local hex = 0xEFBBBF
+local binary = 19
+local str = "key: value\nlist:\n  - item1\n  - " .. tostring(expr)
+local fn
+fn = function()
+        local str = "foo:\n  bar: baz"
+        return str
+end
+local str = "path: \"C:\\Program Files\\App\"\nnote: 'He said: \"" .. tostring(Hello) .. "!\"'"
 local my_function
 my_function = function() end
 my_function()
@@ -854,11 +1022,10 @@ for i, item in ipairs(items) do
         _len_0 = _len_0 + 1
 end
 doubled = _accum_0
-local iter = ipairs(items)
 local slice
 local _accum_0 = { }
 local _len_0 = 1
-for i, item in iter do
+for i, item in ipairs(items) do
         if i > 1 and i < 3 then
                 _accum_0[_len_0] = item
                 _len_0 = _len_0 + 1
@@ -965,8 +1132,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
@@ -976,7 +1142,8 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 2, #_list_0 do
+local _max_0 = #_list_0
+for _index_0 = 2, _max_0 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
@@ -986,12 +1153,46 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 1, #_list_0, 2 do
+local _max_0 = #_list_0
+for _index_0 = 1, _max_0, 2 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
 end
 slice = _accum_0
+local slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -4 + 1
+local _max_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, _max_0 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+slice = _accum_0
+local reverse_slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, 1, -1 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+reverse_slice = _accum_0
+local sub_list
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+for _index_0 = 2, 4 do
+        local _item_0 = _list_0[_index_0]
+        _accum_0[_len_0] = _item_0
+        _len_0 = _len_0 + 1
+end
+sub_list = _accum_0
 for i = 10, 20 do
         print(i)
 end
@@ -1002,8 +1203,7 @@ for key, value in pairs(object) do
         print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
-for _index_0 = 2, _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
@@ -1021,12 +1221,24 @@ local _len_0 = 1
 for i = 1, 20 do
         if i % 2 == 0 then
                 _accum_0[_len_0] = i * 2
+                _len_0 = _len_0 + 1
         else
                 _accum_0[_len_0] = i
+                _len_0 = _len_0 + 1
         end
-        _len_0 = _len_0 + 1
 end
 doubled_evens = _accum_0
+local first_large
+local _accum_0
+local _list_0 = numbers
+for _index_0 = 1, #_list_0 do
+        local n = _list_0[_index_0]
+        if n > 10 then
+                _accum_0 = n
+                break
+        end
+end
+first_large = _accum_0
 local func_a
 func_a = function()
         for i = 1, 10 do
@@ -1175,7 +1387,7 @@ if "Robert" == name then
 elseif "Dan" == name or "Daniel" == name then
         print("你的�字是Dan")
 else
-        print("我�知�你的�字")
+        print("我�认识你，你的�字是" .. tostring(name))
 end
 local b = 1
 local next_number
@@ -1275,6 +1487,192 @@ if _tab_0 then
         end
         print("Vec2 " .. tostring(x) .. ", " .. tostring(y))
 end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        if 1 == _exp_0[1] and 2 == _exp_0[2] and 3 == _exp_0[3] then
+                _match_0 = true
+                print("1, 2, 3")
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local b = _exp_0[2]
+                if 1 == _exp_0[1] and b ~= nil and 3 == _exp_0[3] then
+                        _match_1 = true
+                        print("1, " .. tostring(b) .. ", 3")
+                end
+        end
+        if not _match_1 then
+                if _tab_0 then
+                        local b = _exp_0[3]
+                        if b == nil then
+                                b = 3
+                        end
+                        if 1 == _exp_0[1] and 2 == _exp_0[2] then
+                                print("1, 2, " .. tostring(b))
+                        end
+                end
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local result = _exp_0.result
+        if true == _exp_0.success and result ~= nil then
+                _match_0 = true
+                print("�功", result)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                if false == _exp_0.success then
+                        _match_1 = true
+                        print("失败", result)
+                end
+        end
+        if not _match_1 then
+                print("无效值")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local content
+        do
+                local _obj_0 = _exp_0.data
+                local _type_1 = type(_obj_0)
+                if "table" == _type_1 or "userdata" == _type_1 then
+                        content = _obj_0.content
+                end
+        end
+        local _val_0
+        do
+                local _obj_0 = _exp_0.data
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.type
+                end
+        end
+        if "success" == _val_0 and content ~= nil then
+                _match_0 = true
+                print("�功", content)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local content
+                do
+                        local _obj_0 = _exp_0.data
+                        local _type_1 = type(_obj_0)
+                        if "table" == _type_1 or "userdata" == _type_1 then
+                                content = _obj_0.content
+                        end
+                end
+                local _val_0
+                do
+                        local _obj_0 = _exp_0.data
+                        if _obj_0 ~= nil then
+                                _val_0 = _obj_0.type
+                        end
+                end
+                if "error" == _val_0 and content ~= nil then
+                        _match_1 = true
+                        print("失败", content)
+                end
+        end
+        if not _match_1 then
+                print("无效值")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local fourth = _exp_0[4]
+        local _val_0
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.a
+                end
+        end
+        local _val_1
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_1 = _obj_0.b
+                end
+        end
+        local _val_2
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_2 = _obj_0.a
+                end
+        end
+        local _val_3
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_3 = _obj_0.b
+                end
+        end
+        local _val_4
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_4 = _obj_0.a
+                end
+        end
+        local _val_5
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_5 = _obj_0.b
+                end
+        end
+        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                print("匹��功", fourth)
+        end
+end
+local segments = {
+        "admin",
+        "users",
+        "logs",
+        "view"
+}
+local _type_0 = type(segments)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local groups
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #segments + -3 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = segments[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                groups = _accum_0
+        end
+        local resource = segments[#segments - 1]
+        local action = segments[#segments]
+        if resource ~= nil and action ~= nil then
+                print("Group:", groups)
+                print("Resource:", resource)
+                print("Action:", action)
+        end
+end
 local Inventory
 local _class_0
 local _base_0 = {
@@ -1931,6 +2329,10 @@ do
         _with_1["key-name"] = value
 end
 _with_0[#_with_0 + 1] = "abc"
+local _with_0 = obj
+if _with_0 ~= nil then
+        print(obj.name)
+end
 do
         local var = "hello"
         print(var)
@@ -2021,6 +2423,38 @@ local inventory = {
                 }
         }
 }
+local map
+map = function(arr, action)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                _accum_0[_len_0] = action(item)
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end
+local filter
+filter = function(arr, cond)
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                if cond(item) then
+                        _accum_0[_len_0] = item
+                        _len_0 = _len_0 + 1
+                end
+        end
+        return _accum_0
+end
+local reduce
+reduce = function(arr, init, action)
+        for _index_0 = 1, #arr do
+                local item = arr[_index_0]
+                init = action(init, item)
+        end
+        return init
+end
 print(reduce(filter(map({
         1,
         2,
@@ -2078,6 +2512,12 @@ end
 print("yuescript")
 print(3)
 print("有效的枚举类型:", "Static")
+do
+        print(123, "hello")
+end
+do
+        print(123, "hello")
+end
 if tb ~= nil then
         tb:func()
 end
@@ -2178,6 +2618,16 @@ for _key_0, _value_0 in pairs(b) do
         end
 end
 merge = _tab_0
+local last
+do
+        local _item_0 = data.items
+        last = _item_0[#_item_0]
+end
+local second_last
+do
+        local _item_0 = data.items
+        second_last = _item_0[#_item_0 - 1]
+end
 local mt = { }
 local add
 add = function(self, right)
@@ -2308,6 +2758,14 @@ func({
         2,
         3
 })
+local f
+f = function()
+        return {
+                1,
+                2,
+                3
+        }
+end
 local tb = {
         name = "abc",
         values = {
@@ -2548,6 +3006,59 @@ end
 local two, four
 local _obj_0 = items
 two, four = _obj_0[2], _obj_0[4]
+local orders = {
+        "first",
+        "second",
+        "third",
+        "fourth",
+        "last"
+}
+local first, bulk, last = orders[1], (function()
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _max_0 = #orders + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = orders[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        return _accum_0
+end)(), orders[#orders]
+print(first)
+print(bulk)
+print(last)
+local first, rest
+do
+        local _obj_0 = orders
+        first, rest = _obj_0[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)()
+end
+local start, last
+do
+        local _obj_0 = orders
+        start, last = (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -2 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0]
+end
+local _obj_0 = orders
+first, last = _obj_0[1], _obj_0[#_obj_0]
 local tuples = {
         {
                 "hello",
@@ -2649,6 +3160,56 @@ end)
 if success then
         print(result)
 end
+local a, b, c
+do
+        local _ok_0, _ret_0, _ret_1, _ret_2 = pcall(function()
+                return func()
+        end)
+        if _ok_0 then
+                a, b, c = _ret_0, _ret_1, _ret_2
+        end
+end
+do
+        local _exp_0 = ((function()
+                return (function(_arg_0, ...)
+                        local _ok_0 = _arg_0
+                        if _ok_0 then
+                                return ...
+                        end
+                end)(pcall(function()
+                        return func()
+                end))
+        end)())
+        if _exp_0 ~= nil then
+                a = _exp_0
+        else
+                a = "default"
+        end
+end
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(pcall(function()
+                return func()
+        end))
+end)())
+f((function()
+        return (function(_arg_0, ...)
+                local _ok_0 = _arg_0
+                if _ok_0 then
+                        return ...
+                end
+        end)(xpcall(function()
+                print(123)
+                return func()
+        end, function(e)
+                print(e)
+                return e
+        end))
+end)())
 local a <const> = 123
 local _ <close> = setmetatable({ }, {
         __close = function()
@@ -2658,10 +3219,19 @@ local _ <close> = setmetatable({ }, {
 local a, b, c, d
 local _obj_0 = tb
 a, b, c, d = _obj_0.a, _obj_0.b, _obj_0[1], _obj_0[2]
+Constant = 123
 local some_string = "这是一个字符串\n  并包括一个�行。"
 print("我有" .. tostring(math.random() * 100) .. "%的把�。")
 local integer = 1000000
 local hex = 0xEFBBBF
+local binary = 19
+local str = "key: value\nlist:\n  - item1\n  - " .. tostring(expr)
+local fn
+fn = function()
+        local str = "foo:\n  bar: baz"
+        return str
+end
+local str = "path: \"C:\\Program Files\\App\"\nnote: 'He said: \"" .. tostring(Hello) .. "!\"'"
 local my_function
 my_function = function() end
 my_function()
@@ -2855,11 +3425,10 @@ for i, item in ipairs(items) do
         _len_0 = _len_0 + 1
 end
 doubled = _accum_0
-local iter = ipairs(items)
 local slice
 local _accum_0 = { }
 local _len_0 = 1
-for i, item in iter do
+for i, item in ipairs(items) do
         if i > 1 and i < 3 then
                 _accum_0[_len_0] = item
                 _len_0 = _len_0 + 1
@@ -2966,8 +3535,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
@@ -2977,7 +3545,8 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 2, #_list_0 do
+local _max_0 = #_list_0
+for _index_0 = 2, _max_0 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
@@ -2987,12 +3556,46 @@ local slice
 local _accum_0 = { }
 local _len_0 = 1
 local _list_0 = items
-for _index_0 = 1, #_list_0, 2 do
+local _max_0 = #_list_0
+for _index_0 = 1, _max_0, 2 do
         local item = _list_0[_index_0]
         _accum_0[_len_0] = item
         _len_0 = _len_0 + 1
 end
 slice = _accum_0
+local slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -4 + 1
+local _max_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, _max_0 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+slice = _accum_0
+local reverse_slice
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+local _min_0 = #_list_0 + -1 + 1
+for _index_0 = _min_0, 1, -1 do
+        local item = _list_0[_index_0]
+        _accum_0[_len_0] = item
+        _len_0 = _len_0 + 1
+end
+reverse_slice = _accum_0
+local sub_list
+local _accum_0 = { }
+local _len_0 = 1
+local _list_0 = items
+for _index_0 = 2, 4 do
+        local _item_0 = _list_0[_index_0]
+        _accum_0[_len_0] = _item_0
+        _len_0 = _len_0 + 1
+end
+sub_list = _accum_0
 for i = 10, 20 do
         print(i)
 end
@@ -3003,8 +3606,7 @@ for key, value in pairs(object) do
         print(key, value)
 end
 local _list_0 = items
-local _max_0 = 4
-for _index_0 = 2, _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
@@ -3022,12 +3624,24 @@ local _len_0 = 1
 for i = 1, 20 do
         if i % 2 == 0 then
                 _accum_0[_len_0] = i * 2
+                _len_0 = _len_0 + 1
         else
                 _accum_0[_len_0] = i
+                _len_0 = _len_0 + 1
         end
-        _len_0 = _len_0 + 1
 end
 doubled_evens = _accum_0
+local first_large
+local _accum_0
+local _list_0 = numbers
+for _index_0 = 1, #_list_0 do
+        local n = _list_0[_index_0]
+        if n > 10 then
+                _accum_0 = n
+                break
+        end
+end
+first_large = _accum_0
 local func_a
 func_a = function()
         for i = 1, 10 do
@@ -3176,7 +3790,7 @@ if "Robert" == name then
 elseif "Dan" == name or "Daniel" == name then
         print("你的�字是Dan")
 else
-        print("我�知�你的�字")
+        print("我�认识你，你的�字是" .. tostring(name))
 end
 local b = 1
 local next_number
@@ -3276,6 +3890,192 @@ if _tab_0 then
         end
         print("Vec2 " .. tostring(x) .. ", " .. tostring(y))
 end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        if 1 == _exp_0[1] and 2 == _exp_0[2] and 3 == _exp_0[3] then
+                _match_0 = true
+                print("1, 2, 3")
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local b = _exp_0[2]
+                if 1 == _exp_0[1] and b ~= nil and 3 == _exp_0[3] then
+                        _match_1 = true
+                        print("1, " .. tostring(b) .. ", 3")
+                end
+        end
+        if not _match_1 then
+                if _tab_0 then
+                        local b = _exp_0[3]
+                        if b == nil then
+                                b = 3
+                        end
+                        if 1 == _exp_0[1] and 2 == _exp_0[2] then
+                                print("1, 2, " .. tostring(b))
+                        end
+                end
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local result = _exp_0.result
+        if true == _exp_0.success and result ~= nil then
+                _match_0 = true
+                print("�功", result)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                if false == _exp_0.success then
+                        _match_1 = true
+                        print("失败", result)
+                end
+        end
+        if not _match_1 then
+                print("无效值")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+local _match_0 = false
+if _tab_0 then
+        local content
+        do
+                local _obj_0 = _exp_0.data
+                local _type_1 = type(_obj_0)
+                if "table" == _type_1 or "userdata" == _type_1 then
+                        content = _obj_0.content
+                end
+        end
+        local _val_0
+        do
+                local _obj_0 = _exp_0.data
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.type
+                end
+        end
+        if "success" == _val_0 and content ~= nil then
+                _match_0 = true
+                print("�功", content)
+        end
+end
+if not _match_0 then
+        local _match_1 = false
+        if _tab_0 then
+                local content
+                do
+                        local _obj_0 = _exp_0.data
+                        local _type_1 = type(_obj_0)
+                        if "table" == _type_1 or "userdata" == _type_1 then
+                                content = _obj_0.content
+                        end
+                end
+                local _val_0
+                do
+                        local _obj_0 = _exp_0.data
+                        if _obj_0 ~= nil then
+                                _val_0 = _obj_0.type
+                        end
+                end
+                if "error" == _val_0 and content ~= nil then
+                        _match_1 = true
+                        print("失败", content)
+                end
+        end
+        if not _match_1 then
+                print("无效值")
+        end
+end
+local _exp_0 = tb
+local _type_0 = type(_exp_0)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local fourth = _exp_0[4]
+        local _val_0
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_0 = _obj_0.a
+                end
+        end
+        local _val_1
+        do
+                local _obj_0 = _exp_0[1]
+                if _obj_0 ~= nil then
+                        _val_1 = _obj_0.b
+                end
+        end
+        local _val_2
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_2 = _obj_0.a
+                end
+        end
+        local _val_3
+        do
+                local _obj_0 = _exp_0[2]
+                if _obj_0 ~= nil then
+                        _val_3 = _obj_0.b
+                end
+        end
+        local _val_4
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_4 = _obj_0.a
+                end
+        end
+        local _val_5
+        do
+                local _obj_0 = _exp_0[3]
+                if _obj_0 ~= nil then
+                        _val_5 = _obj_0.b
+                end
+        end
+        if 1 == _val_0 and 2 == _val_1 and 3 == _val_2 and 4 == _val_3 and 5 == _val_4 and 6 == _val_5 and fourth ~= nil then
+                print("匹��功", fourth)
+        end
+end
+local segments = {
+        "admin",
+        "users",
+        "logs",
+        "view"
+}
+local _type_0 = type(segments)
+local _tab_0 = "table" == _type_0 or "userdata" == _type_0
+if _tab_0 then
+        local groups
+        do
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #segments + -3 + 1
+                for _index_0 = 1, _max_0 do
+                        local _item_0 = segments[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                groups = _accum_0
+        end
+        local resource = segments[#segments - 1]
+        local action = segments[#segments]
+        if resource ~= nil and action ~= nil then
+                print("Group:", groups)
+                print("Resource:", resource)
+                print("Action:", action)
+        end
+end
 local Inventory
 local _class_0
 local _base_0 = {
@@ -3932,6 +4732,10 @@ do
         _with_1["key-name"] = value
 end
 _with_0[#_with_0 + 1] = "abc"
+local _with_0 = obj
+if _with_0 ~= nil then
+        print(obj.name)
+end
 do
         local var = "hello"
         print(var)
diff --git a/spec/outputs/comprehension.lua b/spec/outputs/comprehension.lua
index 9a7c478..663bd44 100644
--- a/spec/outputs/comprehension.lua
+++ b/spec/outputs/comprehension.lua
@@ -243,8 +243,11 @@ end
 do
         local _accum_0 = { }
         local _len_0 = 1
+        local _min_0 = 1 + 2
         local _max_0 = 3 + 4
-        for _index_0 = 1 + 2, _max_0 < 0 and #items + _max_0 or _max_0 do
+        _min_0 = _min_0 < 0 and #items + _min_0 + 1 or _min_0
+        _max_0 = _max_0 < 0 and #items + _max_0 + 1 or _max_0
+        for _index_0 = _min_0, _max_0 do
                 local item = items[_index_0]
                 _accum_0[_len_0] = item
                 _len_0 = _len_0 + 1
@@ -254,8 +257,11 @@ end
 do
         local _accum_0 = { }
         local _len_0 = 1
+        local _min_0 = hello() * 4
         local _max_0 = 2 - thing[4]
-        for _index_0 = hello() * 4, _max_0 < 0 and #items + _max_0 or _max_0 do
+        _min_0 = _min_0 < 0 and #items + _min_0 + 1 or _min_0
+        _max_0 = _max_0 < 0 and #items + _max_0 + 1 or _max_0
+        for _index_0 = _min_0, _max_0 do
                 local item = items[_index_0]
                 _accum_0[_len_0] = item
                 _len_0 = _len_0 + 1
diff --git a/spec/outputs/destructure.lua b/spec/outputs/destructure.lua
index 44da58b..ba216b5 100644
--- a/spec/outputs/destructure.lua
+++ b/spec/outputs/destructure.lua
@@ -621,4 +621,94 @@ do
                 print(meta_field, abc, def)
         end
 end
+do
+        local clients = {
+                "VIP_Alice",
+                "User_Bob",
+                "User_Clara",
+                "VIP_Eva"
+        }
+        local vipStart, regulars, vipEnd = clients[1], (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #clients + -2 + 1
+                for _index_0 = 2, _max_0 do
+                        local _item_0 = clients[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), clients[#clients]
+        print(vipStart)
+        print(regulars)
+        print(vipEnd)
+end
+do
+        local setupMeeting
+        setupMeeting = function(participants)
+                local chair, secretary = participants[1], participants[#participants]
+                return print(chair, secretary)
+        end
+        setupMeeting({
+                "Alice",
+                "Bob",
+                "Charlie",
+                "David"
+        })
+end
+do
+        local getTransactions
+        getTransactions = function()
+                return {
+                        {
+                                id = "T1",
+                                amount = 100
+                        },
+                        {
+                                id = "T2",
+                                amount = 200
+                        },
+                        {
+                                id = "T3",
+                                amount = 300
+                        }
+                }
+        end
+        local id, amount
+        do
+                local _item_0 = getTransactions()
+                local _obj_0 = _item_0[#_item_0]
+                id, amount = _obj_0.id, _obj_0.amount
+        end
+        assert(id == "T3")
+        assert(amount == 300)
+end
+do
+        local middle
+        local _accum_0 = { }
+        local _len_0 = 1
+        local _list_0 = tb
+        local _max_0 = #_list_0 + -2 + 1
+        for _index_0 = 2, _max_0 do
+                local _item_0 = _list_0[_index_0]
+                _accum_0[_len_0] = _item_0
+                _len_0 = _len_0 + 1
+        end
+        middle = _accum_0
+end
+do
+        local a, abc, b, def, sub, d, e
+        local _obj_0 = tb
+        a, abc, b, def, sub, d, e = _obj_0[1], _obj_0.abc, _obj_0[2], _obj_0.def, (function()
+                local _accum_0 = { }
+                local _len_0 = 1
+                local _max_0 = #_obj_0 + -3 + 1
+                for _index_0 = 3, _max_0 do
+                        local _item_0 = _obj_0[_index_0]
+                        _accum_0[_len_0] = _item_0
+                        _len_0 = _len_0 + 1
+                end
+                return _accum_0
+        end)(), _obj_0[#_obj_0 - 1], _obj_0[#_obj_0]
+end
 return nil
diff --git a/spec/outputs/do.lua b/spec/outputs/do.lua
index 6473e03..96d1022 100644
--- a/spec/outputs/do.lua
+++ b/spec/outputs/do.lua
@@ -32,10 +32,10 @@ local t = {
 }
 return function(y, k)
         if y == nil then
-                do
+                y = ((function()
                         x = 10 + 2
-                        y = x
-                end
+                        return x
+                end)())
         end
         if k == nil then
                 do
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/literals.lua b/spec/outputs/literals.lua
index a578d58..6de5411 100644
--- a/spec/outputs/literals.lua
+++ b/spec/outputs/literals.lua
@@ -8,10 +8,18 @@ local _ = {
         0xfF2323,
         0xabcdef,
         0xABCDEF,
+        0XFBC400,
         0x123p-123,
         0xABCP+321,
         0x.1p-111,
         0xABCP-321,
+        0x0.1E,
+        0xA23p-4,
+        0X1.921FB54442D18P+1,
+        1,
+        8,
+        15,
+        201,
         .2323,
         .2323e-1,
         .2323e13434,
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/syntax.lua b/spec/outputs/syntax.lua
index 5fd1821..040a325 100644
--- a/spec/outputs/syntax.lua
+++ b/spec/outputs/syntax.lua
@@ -239,9 +239,11 @@ x = 0
 local _list_0 = values
 for _index_0 = 1, #_list_0 do
         local v = _list_0[_index_0]
-        if ntype(v) == "fndef" then
-                _ = x + 1
-        end
+        _ = ((function()
+                if ntype(v) == "fndef" then
+                        return x + 1
+                end
+        end)())
 end
 hello = {
         something = world,
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 d4c80c1..edb2341 100644
--- a/spec/outputs/try_catch.lua
+++ b/spec/outputs/try_catch.lua
@@ -8,10 +8,10 @@ local _anon_func_2 = function(tb)
         return tb.func()
 end
 local _anon_func_3 = function(tb)
-        return tb.func()
+        return (tb.func())
 end
 local _anon_func_4 = function(tb)
-        return tb:func(1, 2, 3)
+        return (tb:func(1, 2, 3))
 end
 local _anon_func_5 = function(tb)
         return tb.func(1)
@@ -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()
@@ -64,7 +102,7 @@ f = function()
                 print("OK")
         end
         if xpcall(function()
-                return func(1)
+                return (func(1))
         end, function(err)
                 return print(err)
         end) then
@@ -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 bf43953..e00d016 100644
--- a/spec/outputs/unicode/assign.lua
+++ b/spec/outputs/unicode/assign.lua
@@ -36,17 +36,15 @@ local _u53d8_u91cfx
 do
         local _u51fd_u6570 = _u83b7_u53d6_u5904_u7406_u51fd_u6570()
         if _u51fd_u6570 then
-                do
+                _u53d8_u91cfx = ((function()
                         _u51fd_u6570()
-                        _u53d8_u91cfx = 123
-                end
+                        return 123
+                end)())
         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/attrib.lua b/spec/outputs/unicode/attrib.lua
index 1c48de4..5e5bb99 100644
--- a/spec/outputs/unicode/attrib.lua
+++ b/spec/outputs/unicode/attrib.lua
@@ -48,17 +48,21 @@ do
         end
         local _u5173_u95ed_u53d8_u91cfb
         if not false then
-                if _u6761_u4ef6x then
-                        _u5173_u95ed_u53d8_u91cfb = 1
-                end
+                _u5173_u95ed_u53d8_u91cfb = ((function()
+                        if _u6761_u4ef6x then
+                                return 1
+                        end
+                end)())
         end
         local _close_0 <close> = _u5173_u95ed_u53d8_u91cfb
         local _u5e38_u91cfc
         if true then
-                local _exp_0 = _u6761_u4ef6x
-                if "abc" == _exp_0 then
-                        _u5e38_u91cfc = 998
-                end
+                _u5e38_u91cfc = ((function()
+                        local _exp_0 = _u6761_u4ef6x
+                        if "abc" == _exp_0 then
+                                return 998
+                        end
+                end)())
         end
         local _u5173_u95ed_u53d8_u91cfd
         if (function()
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/do.lua b/spec/outputs/unicode/do.lua
index f9c3079..7bf1da3 100644
--- a/spec/outputs/unicode/do.lua
+++ b/spec/outputs/unicode/do.lua
@@ -32,10 +32,10 @@ local _u53d8_u91cft = {
 }
 return function(_u53c2_u6570y, _u53c2_u6570k)
         if _u53c2_u6570y == nil then
-                do
+                _u53c2_u6570y = ((function()
                         _u53d8_u91cfx = 10 + 2
-                        _u53c2_u6570y = _u53d8_u91cfx
-                end
+                        return _u53d8_u91cfx
+                end)())
         end
         if _u53c2_u6570k == nil then
                 do
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 099080f..b4e78cd 100644
--- a/spec/outputs/unicode/macro.lua
+++ b/spec/outputs/unicode/macro.lua
@@ -215,24 +215,8 @@ do
 -- 这有个注释
 end
 local _ = require('下划线')
-local _call_0 = (_({
-        1,
-        2,
-        3,
-        4,
-        -2,
-        3
-}))
-_call_0 = _call_0["链"](_call_0)
-_call_0 = _call_0["映射"](_call_0, function(self)
-        return self * 2
-end)
-_call_0 = _call_0["过滤"](_call_0, function(self)
-        return self > 3
-end)
-local _u7ed3_u679ca = _call_0["�值"](_call_0)
-do
-        local _call_1 = (_({
+local _anon_func_0 = function(_)
+        local _call_0 = (_({
                 1,
                 2,
                 3,
@@ -240,27 +224,70 @@ do
                 -2,
                 3
         }))
-        _call_1 = _call_1["链"](_call_1)
-        _call_1 = _call_1["映射"](_call_1, function(self)
-                return self * 2
-        end)
-        _call_1 = _call_1["过滤"](_call_1, function(self)
+        return _call_0["链"](_call_0)
+end
+local _call_0 = ((function()
+        local _call_0 = ((function()
+                local _call_0 = (_anon_func_0(_))
+                return _call_0["映射"](_call_0, function(self)
+                        return self * 2
+                end)
+        end)())
+        return _call_0["过滤"](_call_0, function(self)
                 return self > 3
         end)
+end)())
+local _u7ed3_u679ca = _call_0["�值"](_call_0)
+local _anon_func_1 = function(_)
+        local _call_1 = (_({
+                1,
+                2,
+                3,
+                4,
+                -2,
+                3
+        }))
+        return _call_1["链"](_call_1)
+end
+do
+        local _call_1 = ((function()
+                local _call_1 = ((function()
+                        local _call_1 = (_anon_func_1(_))
+                        return _call_1["映射"](_call_1, function(self)
+                                return self * 2
+                        end)
+                end)())
+                return _call_1["过滤"](_call_1, function(self)
+                        return self > 3
+                end)
+        end)())
         _call_1["�一个"](_call_1, function(self)
                 return _u6253_u5370(self)
         end)
 end
-local _call_1 = _u539f_u70b9["��"]["根节点"]["游�对象"]
-_call_1 = _call_1["父节点"](_call_1)
-_call_1 = _call_1["�代"](_call_1)
-_call_1 = _call_1["选择�用"](_call_1)
-_call_1 = _call_1["选择��"](_call_1)
-_call_1 = _call_1["标签等于"](_call_1, "fx")
-_call_1 = _call_1["其中"](_call_1, function(x)
-        local _call_2 = x["�称"]
-        return _call_2["结尾为"](_call_2, "(克隆)")
-end)
+local _anon_func_2 = function(_u539f_u70b9)
+        local _call_1 = _u539f_u70b9["��"]["根节点"]["游�对象"]
+        return _call_1["父节点"](_call_1)
+end
+local _call_1 = ((function()
+        local _call_1 = ((function()
+                local _call_1 = ((function()
+                        local _call_1 = ((function()
+                                local _call_1 = ((function()
+                                        local _call_1 = (_anon_func_2(_u539f_u70b9))
+                                        return _call_1["�代"](_call_1)
+                                end)())
+                                return _call_1["选择�用"](_call_1)
+                        end)())
+                        return _call_1["选择��"](_call_1)
+                end)())
+                return _call_1["标签等于"](_call_1, "fx")
+        end)())
+        return _call_1["其中"](_call_1, function(x)
+                local _call_2 = x["�称"]
+                return _call_2["结尾为"](_call_2, "(克隆)")
+        end)
+end)())
 _u7ed3_u679c = _call_1["摧�"](_call_1)
 do
         do
@@ -332,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 ea97bb9..a13302b 100644
--- a/spec/outputs/unicode/syntax.lua
+++ b/spec/outputs/unicode/syntax.lua
@@ -258,9 +258,11 @@ _u53d8_u91cfx = 0
 local _list_0 = _u503c
 for _index_0 = 1, #_list_0 do
         local _u53d8_u91cfv = _list_0[_index_0]
-        if ntype(_u53d8_u91cfv) == "函数定义" then
-                _ = _u53d8_u91cfx + 1
-        end
+        _ = ((function()
+                if ntype(_u53d8_u91cfv) == "函数定义" then
+                        return _u53d8_u91cfx + 1
+                end
+        end)())
 end
 _u4f60_u597d = {
         ["�物"] = _u4e16_u754c,
@@ -284,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/try_catch.lua b/spec/outputs/unicode/try_catch.lua
index 22f29f9..f8c7849 100644
--- a/spec/outputs/unicode/try_catch.lua
+++ b/spec/outputs/unicode/try_catch.lua
@@ -32,11 +32,13 @@ pcall(function()
         return _u8868["函数"]()
 end)
 pcall(function()
-        return _u8868["函数"]()
+        return (_u8868["函数"]())
 end)
 pcall(function()
-        local _call_0 = _u8868
-        return _call_0["函数"](_call_0, 1, 2, 3)
+        return ((function()
+                local _call_0 = _u8868
+                return _call_0["函数"](_call_0, 1, 2, 3)
+        end)())
 end)
 pcall(function()
         return _u8868["函数"](1)
@@ -52,7 +54,7 @@ end)) then
         _u6253_u5370("好的")
 end
 if xpcall(function()
-        return _u51fd_u6570(1)
+        return (_u51fd_u6570(1))
 end, function(_u9519_u8bef)
         return _u6253_u5370(_u9519_u8bef)
 end) 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/Atomic.hpp b/src/3rdParty/efsw/Atomic.hpp
index 4008dfc..9015c60 100755..100644
--- a/src/3rdParty/efsw/Atomic.hpp
+++ b/src/3rdParty/efsw/Atomic.hpp
@@ -3,9 +3,7 @@
 
 #include <efsw/base.hpp>
 
-#ifdef EFSW_USE_CXX11
 #include <atomic>
-#endif
 
 namespace efsw {
 
@@ -14,36 +12,20 @@ template <typename T> class Atomic {
         explicit Atomic( T set = false ) : set_( set ) {}
 
         Atomic& operator=( T set ) {
-#ifdef EFSW_USE_CXX11
                 set_.store( set, std::memory_order_release );
-#else
-                set_ = set;
-#endif
                 return *this;
         }
 
         explicit operator T() const {
-#ifdef EFSW_USE_CXX11
                 return set_.load( std::memory_order_acquire );
-#else
-                return set_;
-#endif
         }
 
         T load() const {
-#ifdef EFSW_USE_CXX11
                 return set_.load( std::memory_order_acquire );
-#else
-                return set_;
-#endif
         }
 
   private:
-#ifdef EFSW_USE_CXX11
         std::atomic<T> set_;
-#else
-        volatile T set_;
-#endif
 };
 
 } // namespace efsw
diff --git a/src/3rdParty/efsw/Debug.cpp b/src/3rdParty/efsw/Debug.cpp
index 18cfd31..18cfd31 100755..100644
--- a/src/3rdParty/efsw/Debug.cpp
+++ b/src/3rdParty/efsw/Debug.cpp
diff --git a/src/3rdParty/efsw/Debug.hpp b/src/3rdParty/efsw/Debug.hpp
index 78d3557..fefaec4 100755..100644
--- a/src/3rdParty/efsw/Debug.hpp
+++ b/src/3rdParty/efsw/Debug.hpp
@@ -49,8 +49,10 @@ void efPRINTC( unsigned int cond, const char* format, ... );
 #define efDEBUGC( cond, format, args... ) \
         {}
 #else
-#define efDEBUG
-#define efDEBUGC
+#define efDEBUG( ... ) \
+        {}
+#define efDEBUGC( ... ) \
+        {}
 #endif
 
 #endif
diff --git a/src/3rdParty/efsw/DirWatcherGeneric.cpp b/src/3rdParty/efsw/DirWatcherGeneric.cpp
index 8b6bc8a..8b6bc8a 100755..100644
--- a/src/3rdParty/efsw/DirWatcherGeneric.cpp
+++ b/src/3rdParty/efsw/DirWatcherGeneric.cpp
diff --git a/src/3rdParty/efsw/DirWatcherGeneric.hpp b/src/3rdParty/efsw/DirWatcherGeneric.hpp
index ca52de7..ca52de7 100755..100644
--- a/src/3rdParty/efsw/DirWatcherGeneric.hpp
+++ b/src/3rdParty/efsw/DirWatcherGeneric.hpp
diff --git a/src/3rdParty/efsw/DirectorySnapshot.cpp b/src/3rdParty/efsw/DirectorySnapshot.cpp
index 6049e4a..f78475f 100755..100644
--- a/src/3rdParty/efsw/DirectorySnapshot.cpp
+++ b/src/3rdParty/efsw/DirectorySnapshot.cpp
@@ -44,7 +44,7 @@ void DirectorySnapshot::initFiles() {
         Files = FileSystem::filesInfoFromPath( DirectoryInfo.Filepath );
 
         FileInfoMap::iterator it = Files.begin();
-        std::list<std::string> eraseFiles;
+        std::vector<std::string> eraseFiles;
 
         /// Remove all non regular files and non directories
         for ( ; it != Files.end(); it++ ) {
@@ -53,7 +53,7 @@ void DirectorySnapshot::initFiles() {
                 }
         }
 
-        for ( std::list<std::string>::iterator eit = eraseFiles.begin(); eit != eraseFiles.end();
+        for ( std::vector<std::string>::iterator eit = eraseFiles.begin(); eit != eraseFiles.end();
                   eit++ ) {
                 Files.erase( *eit );
         }
diff --git a/src/3rdParty/efsw/DirectorySnapshot.hpp b/src/3rdParty/efsw/DirectorySnapshot.hpp
index 0e60542..0e60542 100755..100644
--- a/src/3rdParty/efsw/DirectorySnapshot.hpp
+++ b/src/3rdParty/efsw/DirectorySnapshot.hpp
diff --git a/src/3rdParty/efsw/DirectorySnapshotDiff.cpp b/src/3rdParty/efsw/DirectorySnapshotDiff.cpp
index 37ee507..37ee507 100755..100644
--- a/src/3rdParty/efsw/DirectorySnapshotDiff.cpp
+++ b/src/3rdParty/efsw/DirectorySnapshotDiff.cpp
diff --git a/src/3rdParty/efsw/DirectorySnapshotDiff.hpp b/src/3rdParty/efsw/DirectorySnapshotDiff.hpp
index 26a29ec..26a29ec 100755..100644
--- a/src/3rdParty/efsw/DirectorySnapshotDiff.hpp
+++ b/src/3rdParty/efsw/DirectorySnapshotDiff.hpp
diff --git a/src/3rdParty/efsw/FileInfo.cpp b/src/3rdParty/efsw/FileInfo.cpp
index 072cd6d..707f617 100755..100644
--- a/src/3rdParty/efsw/FileInfo.cpp
+++ b/src/3rdParty/efsw/FileInfo.cpp
@@ -35,10 +35,6 @@
 #endif
 #endif
 
-#if EFSW_PLATFORM != EFSW_PLATFORM_WIN32
-#include <filesystem>
-#endif
-
 namespace efsw {
 
 bool FileInfo::exists( const std::string& filePath ) {
@@ -186,12 +182,14 @@ bool FileInfo::isLink() const {
 std::string FileInfo::linksTo() {
 #if EFSW_PLATFORM != EFSW_PLATFORM_WIN32
         if ( isLink() ) {
-                std::error_code ec;
-                auto ch = std::filesystem::canonical( Filepath, ec );
+                char* ch = realpath( Filepath.c_str(), NULL );
+
+                if ( NULL != ch ) {
+                        std::string tstr( ch );
 
-                if ( !ec ) {
+                        free( ch );
 
-                        return ch.string();
+                        return tstr;
                 }
         }
 #endif
diff --git a/src/3rdParty/efsw/FileInfo.hpp b/src/3rdParty/efsw/FileInfo.hpp
index f1bcf4b..1b55c35 100755..100644
--- a/src/3rdParty/efsw/FileInfo.hpp
+++ b/src/3rdParty/efsw/FileInfo.hpp
@@ -2,7 +2,7 @@
 #define EFSW_FILEINFO_HPP
 
 #include <efsw/base.hpp>
-#include <list>
+#include <vector>
 #include <map>
 #include <string>
 
@@ -18,11 +18,11 @@ class FileInfo {
 
         FileInfo();
 
-        explicit FileInfo( const std::string& filepath );
+        FileInfo( const std::string& filepath );
 
         FileInfo( const std::string& filepath, bool linkInfo );
 
-        FileInfo( const FileInfo& ) = default;
+        FileInfo(const FileInfo&) = default;
 
         bool operator==( const FileInfo& Other ) const;
 
@@ -58,8 +58,8 @@ class FileInfo {
 };
 
 typedef std::map<std::string, FileInfo> FileInfoMap;
-typedef std::list<FileInfo> FileInfoList;
-typedef std::list<std::pair<std::string, FileInfo>> MovedList;
+typedef std::vector<FileInfo> FileInfoList;
+typedef std::vector<std::pair<std::string, FileInfo>> MovedList;
 
 } // namespace efsw
 
diff --git a/src/3rdParty/efsw/FileSystem.cpp b/src/3rdParty/efsw/FileSystem.cpp
index 867f120..1ed346c 100755..100644
--- a/src/3rdParty/efsw/FileSystem.cpp
+++ b/src/3rdParty/efsw/FileSystem.cpp
@@ -1,10 +1,19 @@
+#include <cstring>
 #include <efsw/FileSystem.hpp>
 #include <efsw/platform/platformimpl.hpp>
+#include <climits>
 
 #if EFSW_OS == EFSW_OS_MACOSX
 #include <CoreFoundation/CoreFoundation.h>
 #endif
 
+#if EFSW_OS == EFSW_OS_WIN
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#endif
+
 namespace efsw {
 
 bool FileSystem::isDirectory( const std::string& path ) {
@@ -26,13 +35,13 @@ bool FileSystem::slashAtEnd( std::string& dir ) {
 }
 
 void FileSystem::dirAddSlashAtEnd( std::string& dir ) {
-        if ( dir.size() > 1 && dir[dir.size() - 1] != getOSSlash() ) {
+        if ( dir.size() >= 1 && dir[dir.size() - 1] != getOSSlash() ) {
                 dir.push_back( getOSSlash() );
         }
 }
 
 void FileSystem::dirRemoveSlashAtEnd( std::string& dir ) {
-        if ( dir.size() > 1 && dir[dir.size() - 1] == getOSSlash() ) {
+        if ( dir.size() >= 1 && dir[dir.size() - 1] == getOSSlash() ) {
                 dir.erase( dir.size() - 1 );
         }
 }
@@ -91,13 +100,30 @@ std::string FileSystem::precomposeFileName( const std::string& name ) {
 
         CFStringNormalize( cfMutable, kCFStringNormalizationFormC );
 
-        char c_str[255 + 1];
-        CFStringGetCString( cfMutable, c_str, sizeof( c_str ) - 1, kCFStringEncodingUTF8 );
-
-        CFRelease( cfStringRef );
-        CFRelease( cfMutable );
+        const char* c_str = CFStringGetCStringPtr( cfMutable, kCFStringEncodingUTF8 );
+        if ( c_str != NULL ) {
+                std::string result( c_str );
+                CFRelease( cfStringRef );
+                CFRelease( cfMutable );
+                return result;
+        }
+        CFIndex length = CFStringGetLength( cfMutable );
+        CFIndex maxSize = CFStringGetMaximumSizeForEncoding( length, kCFStringEncodingUTF8 );
+        if ( maxSize == kCFNotFound ) {
+                CFRelease( cfStringRef );
+                CFRelease( cfMutable );
+                return std::string();
+        }
 
-        return std::string( c_str );
+        std::string result( maxSize + 1, '\0' );
+        if ( CFStringGetCString( cfMutable, &result[0], result.size(), kCFStringEncodingUTF8 ) ) {
+                result.resize( std::strlen( result.c_str() ) );
+                CFRelease( cfStringRef );
+                CFRelease( cfMutable );
+        } else {
+                result.clear();
+        }
+        return result;
 #else
         return name;
 #endif
@@ -115,4 +141,21 @@ std::string FileSystem::getCurrentWorkingDirectory() {
         return Platform::FileSystem::getCurrentWorkingDirectory();
 }
 
+std::string FileSystem::getRealPath( const std::string& path ) {
+        std::string realPath;
+#if defined( EFSW_PLATFORM_POSIX )
+        char dir[PATH_MAX];
+        realpath( path.c_str(), &dir[0] );
+        realPath = std::string( dir );
+#elif EFSW_OS == EFSW_OS_WIN
+        wchar_t dir[_MAX_PATH + 1];
+        GetFullPathNameW( String::fromUtf8( path ).toWideString().c_str(), _MAX_PATH, &dir[0],
+                                          nullptr );
+        realPath = String( dir ).toUtf8();
+#else
+#warning FileSystem::getRealPath() not implemented on this platform.
+#endif
+        return realPath;
+}
+
 } // namespace efsw
diff --git a/src/3rdParty/efsw/FileSystem.hpp b/src/3rdParty/efsw/FileSystem.hpp
index 6c24386..1d66ece 100755..100644
--- a/src/3rdParty/efsw/FileSystem.hpp
+++ b/src/3rdParty/efsw/FileSystem.hpp
@@ -3,7 +3,6 @@
 
 #include <efsw/FileInfo.hpp>
 #include <efsw/base.hpp>
-#include <map>
 
 namespace efsw {
 
@@ -34,6 +33,9 @@ class FileSystem {
         static bool changeWorkingDirectory( const std::string& path );
 
         static std::string getCurrentWorkingDirectory();
+
+        static std::string getRealPath( const std::string& path );
+
 };
 
 } // namespace efsw
diff --git a/src/3rdParty/efsw/FileWatcher.cpp b/src/3rdParty/efsw/FileWatcher.cpp
index 696a46f..f45b243 100755..100644
--- a/src/3rdParty/efsw/FileWatcher.cpp
+++ b/src/3rdParty/efsw/FileWatcher.cpp
@@ -1,119 +1,120 @@
-#include <efsw/FileSystem.hpp>
-#include <efsw/FileWatcherGeneric.hpp>
-#include <efsw/FileWatcherImpl.hpp>
-#include <efsw/efsw.hpp>
-
-#if EFSW_PLATFORM == EFSW_PLATFORM_WIN32
-#include <efsw/FileWatcherWin32.hpp>
-#define FILEWATCHER_IMPL FileWatcherWin32
-#define BACKEND_NAME "Win32"
-#elif EFSW_PLATFORM == EFSW_PLATFORM_INOTIFY
-#include <efsw/FileWatcherInotify.hpp>
-#define FILEWATCHER_IMPL FileWatcherInotify
-#define BACKEND_NAME "Inotify"
-#elif EFSW_PLATFORM == EFSW_PLATFORM_KQUEUE
-#include <efsw/FileWatcherKqueue.hpp>
-#define FILEWATCHER_IMPL FileWatcherKqueue
-#define BACKEND_NAME "Kqueue"
-#elif EFSW_PLATFORM == EFSW_PLATFORM_FSEVENTS
-#include <efsw/FileWatcherFSEvents.hpp>
-#define FILEWATCHER_IMPL FileWatcherFSEvents
-#define BACKEND_NAME "FSEvents"
-#else
-#define FILEWATCHER_IMPL FileWatcherGeneric
-#define BACKEND_NAME "Generic"
-#endif
-
-#include <efsw/Debug.hpp>
-
-namespace efsw {
-
-FileWatcher::FileWatcher() : mFollowSymlinks( false ), mOutOfScopeLinks( false ) {
-        efDEBUG( "Using backend: %s\n", BACKEND_NAME );
-
-        mImpl = new FILEWATCHER_IMPL( this );
-
-        if ( !mImpl->initOK() ) {
-                efSAFE_DELETE( mImpl );
-
-                efDEBUG( "Falled back to backend: %s\n", BACKEND_NAME );
-
-                mImpl = new FileWatcherGeneric( this );
-        }
-}
-
-FileWatcher::FileWatcher( bool useGenericFileWatcher ) :
-        mFollowSymlinks( false ), mOutOfScopeLinks( false ) {
-        if ( useGenericFileWatcher ) {
-                efDEBUG( "Using backend: Generic\n" );
-
-                mImpl = new FileWatcherGeneric( this );
-        } else {
-                efDEBUG( "Using backend: %s\n", BACKEND_NAME );
-
-                mImpl = new FILEWATCHER_IMPL( this );
-
-                if ( !mImpl->initOK() ) {
-                        efSAFE_DELETE( mImpl );
-
-                        efDEBUG( "Falled back to backend: %s\n", BACKEND_NAME );
-
-                        mImpl = new FileWatcherGeneric( this );
-                }
-        }
-}
-
-FileWatcher::~FileWatcher() {
-        efSAFE_DELETE( mImpl );
-}
-
-WatchID FileWatcher::addWatch( const std::string& directory, FileWatchListener* watcher ) {
-        if ( mImpl->mIsGeneric || !FileSystem::isRemoteFS( directory ) ) {
-                return mImpl->addWatch( directory, watcher, false );
-        } else {
-                return Errors::Log::createLastError( Errors::FileRemote, directory );
-        }
-}
-
-WatchID FileWatcher::addWatch( const std::string& directory, FileWatchListener* watcher,
-                                                           bool recursive ) {
-        if ( mImpl->mIsGeneric || !FileSystem::isRemoteFS( directory ) ) {
-                return mImpl->addWatch( directory, watcher, recursive );
-        } else {
-                return Errors::Log::createLastError( Errors::FileRemote, directory );
-        }
-}
-
-void FileWatcher::removeWatch( const std::string& directory ) {
-        mImpl->removeWatch( directory );
-}
-
-void FileWatcher::removeWatch( WatchID watchid ) {
-        mImpl->removeWatch( watchid );
-}
-
-void FileWatcher::watch() {
-        mImpl->watch();
-}
-
-std::list<std::string> FileWatcher::directories() {
-        return mImpl->directories();
-}
-
-void FileWatcher::followSymlinks( bool follow ) {
-        mFollowSymlinks = follow;
-}
-
-const bool& FileWatcher::followSymlinks() const {
-        return mFollowSymlinks;
-}
-
-void FileWatcher::allowOutOfScopeLinks( bool allow ) {
-        mOutOfScopeLinks = allow;
-}
-
-const bool& FileWatcher::allowOutOfScopeLinks() const {
-        return mOutOfScopeLinks;
-}
-
-} // namespace efsw
+#include <efsw/FileSystem.hpp>

+#include <efsw/FileWatcherGeneric.hpp>

+#include <efsw/FileWatcherImpl.hpp>

+#include <efsw/efsw.hpp>

+

+#if EFSW_PLATFORM == EFSW_PLATFORM_WIN32

+#include <efsw/FileWatcherWin32.hpp>

+#define FILEWATCHER_IMPL FileWatcherWin32

+#define BACKEND_NAME "Win32"

+#elif EFSW_PLATFORM == EFSW_PLATFORM_INOTIFY

+#include <efsw/FileWatcherInotify.hpp>

+#define FILEWATCHER_IMPL FileWatcherInotify

+#define BACKEND_NAME "Inotify"

+#elif EFSW_PLATFORM == EFSW_PLATFORM_KQUEUE

+#include <efsw/FileWatcherKqueue.hpp>

+#define FILEWATCHER_IMPL FileWatcherKqueue

+#define BACKEND_NAME "Kqueue"

+#elif EFSW_PLATFORM == EFSW_PLATFORM_FSEVENTS

+#include <efsw/FileWatcherFSEvents.hpp>

+#define FILEWATCHER_IMPL FileWatcherFSEvents

+#define BACKEND_NAME "FSEvents"

+#else

+#define FILEWATCHER_IMPL FileWatcherGeneric

+#define BACKEND_NAME "Generic"

+#endif

+

+#include <efsw/Debug.hpp>

+

+namespace efsw {

+

+FileWatcher::FileWatcher() : mFollowSymlinks( false ), mOutOfScopeLinks( false ) {

+        efDEBUG( "Using backend: %s\n", BACKEND_NAME );

+

+        mImpl = new FILEWATCHER_IMPL( this );

+

+        if ( !mImpl->initOK() ) {

+                efSAFE_DELETE( mImpl );

+

+                efDEBUG( "Falled back to backend: %s\n", BACKEND_NAME );

+

+                mImpl = new FileWatcherGeneric( this );

+        }

+}

+

+FileWatcher::FileWatcher( bool useGenericFileWatcher ) :

+        mFollowSymlinks( false ), mOutOfScopeLinks( false ) {

+        if ( useGenericFileWatcher ) {

+                efDEBUG( "Using backend: Generic\n" );

+

+                mImpl = new FileWatcherGeneric( this );

+        } else {

+                efDEBUG( "Using backend: %s\n", BACKEND_NAME );

+

+                mImpl = new FILEWATCHER_IMPL( this );

+

+                if ( !mImpl->initOK() ) {

+                        efSAFE_DELETE( mImpl );

+

+                        efDEBUG( "Falled back to backend: %s\n", BACKEND_NAME );

+

+                        mImpl = new FileWatcherGeneric( this );

+                }

+        }

+}

+

+FileWatcher::~FileWatcher() {

+        efSAFE_DELETE( mImpl );

+}

+

+WatchID FileWatcher::addWatch( const std::string& directory, FileWatchListener* watcher ) {

+        return addWatch( directory, watcher, false, {} );

+}

+

+WatchID FileWatcher::addWatch( const std::string& directory, FileWatchListener* watcher,

+                                                           bool recursive ) {

+        return addWatch( directory, watcher, recursive, {} );

+}

+

+WatchID FileWatcher::addWatch( const std::string& directory, FileWatchListener* watcher,

+                                                           bool recursive, const std::vector<WatcherOption>& options ) {

+        if ( mImpl->mIsGeneric || !FileSystem::isRemoteFS( directory ) ) {

+                return mImpl->addWatch( directory, watcher, recursive, options );

+        } else {

+                return Errors::Log::createLastError( Errors::FileRemote, directory );

+        }

+}

+

+void FileWatcher::removeWatch( const std::string& directory ) {

+        mImpl->removeWatch( directory );

+}

+

+void FileWatcher::removeWatch( WatchID watchid ) {

+        mImpl->removeWatch( watchid );

+}

+

+void FileWatcher::watch() {

+        mImpl->watch();

+}

+

+std::vector<std::string> FileWatcher::directories() {

+        return mImpl->directories();

+}

+

+void FileWatcher::followSymlinks( bool follow ) {

+        mFollowSymlinks = follow;

+}

+

+const bool& FileWatcher::followSymlinks() const {

+        return mFollowSymlinks;

+}

+

+void FileWatcher::allowOutOfScopeLinks( bool allow ) {

+        mOutOfScopeLinks = allow;

+}

+

+const bool& FileWatcher::allowOutOfScopeLinks() const {

+        return mOutOfScopeLinks;

+}

+

+} // namespace efsw

diff --git a/src/3rdParty/efsw/FileWatcherCWrapper.cpp b/src/3rdParty/efsw/FileWatcherCWrapper.cpp
index 5c49a66..8712d6e 100755..100644
--- a/src/3rdParty/efsw/FileWatcherCWrapper.cpp
+++ b/src/3rdParty/efsw/FileWatcherCWrapper.cpp
@@ -28,12 +28,12 @@ class Watcher_CAPI : public efsw::FileWatchListener {
  */
 static std::vector<Watcher_CAPI*> g_callbacks;
 
-Watcher_CAPI* find_callback( efsw_watcher watcher, efsw_pfn_fileaction_callback fn ) {
+Watcher_CAPI* find_callback( efsw_watcher watcher, efsw_pfn_fileaction_callback fn, void* param ) {
         for ( std::vector<Watcher_CAPI*>::iterator i = g_callbacks.begin(); i != g_callbacks.end();
                   ++i ) {
                 Watcher_CAPI* callback = *i;
 
-                if ( callback->mFn == fn && callback->mWatcher == watcher )
+                if ( callback->mFn == fn && callback->mWatcher == watcher && callback->mParam == param )
                         return *i;
         }
 
@@ -71,17 +71,35 @@ const char* efsw_getlasterror() {
         return log_str.c_str();
 }
 
+EFSW_API void efsw_clearlasterror() {
+        efsw::Errors::Log::clearLastError();
+}
+
 efsw_watchid efsw_addwatch( efsw_watcher watcher, const char* directory,
                                                         efsw_pfn_fileaction_callback callback_fn, int recursive, void* param ) {
-        Watcher_CAPI* callback = find_callback( watcher, callback_fn );
+        return efsw_addwatch_withoptions( watcher, directory, callback_fn, recursive, 0, 0, param );
+}
+
+efsw_watchid  efsw_addwatch_withoptions(efsw_watcher watcher, const char* directory,
+                                                                                efsw_pfn_fileaction_callback callback_fn, int recursive,
+                                                                                efsw_watcher_option *options, int options_number,
+                                                                                void* param) {
+        Watcher_CAPI* callback = find_callback( watcher, callback_fn, param );
 
         if ( callback == NULL ) {
                 callback = new Watcher_CAPI( watcher, callback_fn, param );
                 g_callbacks.push_back( callback );
         }
 
+        std::vector<efsw::WatcherOption> watcher_options{};
+        for ( int i = 0; i < options_number; i++ ) {
+                efsw_watcher_option* option = &options[i];
+                watcher_options.emplace_back( efsw::WatcherOption{
+                        static_cast<efsw::Option>(option->option), option->value } );
+        }
+
         return ( (efsw::FileWatcher*)watcher )
-                ->addWatch( std::string( directory ), callback, TOBOOL( recursive ) );
+                ->addWatch( std::string( directory ), callback, TOBOOL( recursive ), watcher_options );
 }
 
 void efsw_removewatch( efsw_watcher watcher, const char* directory ) {
diff --git a/src/3rdParty/efsw/FileWatcherFSEvents.cpp b/src/3rdParty/efsw/FileWatcherFSEvents.cpp
index bcfdbe6..70ec2b1 100755..100644
--- a/src/3rdParty/efsw/FileWatcherFSEvents.cpp
+++ b/src/3rdParty/efsw/FileWatcherFSEvents.cpp
@@ -41,6 +41,32 @@ bool FileWatcherFSEvents::isGranular() {
         return getOSXReleaseNumber() >= 11;
 }
 
+static std::string convertCFStringToStdString( CFStringRef cfString ) {
+        // Try to get the C string pointer directly
+        const char* cStr = CFStringGetCStringPtr( cfString, kCFStringEncodingUTF8 );
+
+        if ( cStr ) {
+                // If the pointer is valid, directly return a std::string from it
+                return std::string( cStr );
+        } else {
+                // If not, manually convert it
+                CFIndex length = CFStringGetLength( cfString );
+                CFIndex maxSize = CFStringGetMaximumSizeForEncoding( length, kCFStringEncodingUTF8 ) +
+                                                  1; // +1 for null terminator
+
+                char* buffer = new char[maxSize];
+
+                if ( CFStringGetCString( cfString, buffer, maxSize, kCFStringEncodingUTF8 ) ) {
+                        std::string result( buffer );
+                        delete[] buffer;
+                        return result;
+                } else {
+                        delete[] buffer;
+                        return "";
+                }
+        }
+}
+
 void FileWatcherFSEvents::FSEventCallback( ConstFSEventStreamRef /*streamRef*/, void* userData,
                                                                                    size_t numEvents, void* eventPaths,
                                                                                    const FSEventStreamEventFlags eventFlags[],
@@ -51,8 +77,24 @@ void FileWatcherFSEvents::FSEventCallback( ConstFSEventStreamRef /*streamRef*/,
         events.reserve( numEvents );
 
         for ( size_t i = 0; i < numEvents; i++ ) {
-                events.push_back( FSEvent( std::string( ( (char**)eventPaths )[i] ), (long)eventFlags[i],
-                                                                   (Uint64)eventIds[i] ) );
+                if ( isGranular() ) {
+                        CFDictionaryRef pathInfoDict =
+                                static_cast<CFDictionaryRef>( CFArrayGetValueAtIndex( (CFArrayRef)eventPaths, i ) );
+                        CFStringRef path = static_cast<CFStringRef>(
+                                CFDictionaryGetValue( pathInfoDict, kFSEventStreamEventExtendedDataPathKey ) );
+                        CFNumberRef cfInode = static_cast<CFNumberRef>(
+                                CFDictionaryGetValue( pathInfoDict, kFSEventStreamEventExtendedFileIDKey ) );
+
+                        if ( cfInode ) {
+                                unsigned long inode = 0;
+                                CFNumberGetValue( cfInode, kCFNumberLongType, &inode );
+                                events.push_back( FSEvent( convertCFStringToStdString( path ), (long)eventFlags[i],
+                                                                                   (Uint64)eventIds[i], inode ) );
+                        }
+                } else {
+                        events.push_back( FSEvent( std::string( ( (char**)eventPaths )[i] ),
+                                                                           (long)eventFlags[i], (Uint64)eventIds[i] ) );
+                }
         }
 
         watcher->handleActions( events );
@@ -63,7 +105,7 @@ void FileWatcherFSEvents::FSEventCallback( ConstFSEventStreamRef /*streamRef*/,
 }
 
 FileWatcherFSEvents::FileWatcherFSEvents( FileWatcher* parent ) :
-        FileWatcherImpl( parent ), mRunLoopRef( NULL ), mLastWatchID( 0 ), mThread( NULL ) {
+        FileWatcherImpl( parent ), mLastWatchID( 0 ) {
         mInitOK = true;
 
         watch();
@@ -72,10 +114,7 @@ FileWatcherFSEvents::FileWatcherFSEvents( FileWatcher* parent ) :
 FileWatcherFSEvents::~FileWatcherFSEvents() {
         mInitOK = false;
 
-        if ( mRunLoopRef.load() )
-                CFRunLoopStop( mRunLoopRef.load() );
-
-        efSAFE_DELETE( mThread );
+        mWatchCond.notify_all();
 
         WatchMap::iterator iter = mWatches.begin();
 
@@ -84,18 +123,11 @@ FileWatcherFSEvents::~FileWatcherFSEvents() {
 
                 efSAFE_DELETE( watch );
         }
-
-        mWatches.clear();
 }
 
 WatchID FileWatcherFSEvents::addWatch( const std::string& directory, FileWatchListener* watcher,
-                                                                           bool recursive ) {
-        /// Wait to the RunLoopRef to be ready
-        while ( NULL == mRunLoopRef.load() ) {
-                System::sleep( 1 );
-        }
-
-        std::string dir( directory );
+                                                                           bool recursive, const std::vector<WatcherOption>& options ) {
+        std::string dir( FileSystem::getRealPath( directory ) );
 
         FileInfo fi( dir );
 
@@ -135,12 +167,18 @@ WatchID FileWatcherFSEvents::addWatch( const std::string& directory, FileWatchLi
         pWatch->Directory = dir;
         pWatch->Recursive = recursive;
         pWatch->FWatcher = this;
+        pWatch->ModifiedFlags =
+                getOptionValue( options, Option::MacModifiedFilter, efswFSEventsModified );
+        pWatch->SanitizeEvents = getOptionValue( options, Option::MacSanitizeEvents, 0 ) != 0;
 
         pWatch->init();
 
-        Lock lock( mWatchesLock );
-        mWatches.insert( std::make_pair( mLastWatchID, pWatch ) );
+        {
+                Lock lock( mWatchesLock );
+                mWatches.insert( std::make_pair( mLastWatchID, pWatch ) );
+        }
 
+        mWatchCond.notify_all();
         return pWatch->ID;
 }
 
@@ -174,50 +212,20 @@ void FileWatcherFSEvents::removeWatch( WatchID watchid ) {
         efSAFE_DELETE( watch );
 }
 
-void FileWatcherFSEvents::watch() {
-        if ( NULL == mThread ) {
-                mThread = new Thread( &FileWatcherFSEvents::run, this );
-                mThread->launch();
-        }
-}
-
-void FileWatcherFSEvents::run() {
-        mRunLoopRef = CFRunLoopGetCurrent();
-
-        while ( mInitOK ) {
-                mNeedInitMutex.lock();
-
-                if ( !mNeedInit.empty() ) {
-                        for ( std::vector<WatcherFSEvents*>::iterator it = mNeedInit.begin();
-                                  it != mNeedInit.end(); ++it ) {
-                                ( *it )->initAsync();
-                        }
-
-                        mNeedInit.clear();
-                }
-
-                mNeedInitMutex.unlock();
-
-                if ( mWatches.empty() ) {
-                        System::sleep( 100 );
-                } else {
-                        CFRunLoopRunInMode( kCFRunLoopDefaultMode, 0.5, kCFRunLoopRunTimedOut );
-                }
-        }
-
-        mRunLoopRef = NULL;
-}
+void FileWatcherFSEvents::watch() {}
 
 void FileWatcherFSEvents::handleAction( Watcher* /*watch*/, const std::string& /*filename*/,
                                                                                 unsigned long /*action*/, std::string /*oldFilename*/ ) {
         /// Not used
 }
 
-std::list<std::string> FileWatcherFSEvents::directories() {
-        std::list<std::string> dirs;
+std::vector<std::string> FileWatcherFSEvents::directories() {
+        std::vector<std::string> dirs;
 
         Lock lock( mWatchesLock );
 
+        dirs.reserve( mWatches.size() );
+
         for ( WatchMap::iterator it = mWatches.begin(); it != mWatches.end(); ++it ) {
                 dirs.push_back( std::string( it->second->Directory ) );
         }
diff --git a/src/3rdParty/efsw/FileWatcherFSEvents.hpp b/src/3rdParty/efsw/FileWatcherFSEvents.hpp
index 5279847..daa538c 100755..100644
--- a/src/3rdParty/efsw/FileWatcherFSEvents.hpp
+++ b/src/3rdParty/efsw/FileWatcherFSEvents.hpp
@@ -7,33 +7,15 @@
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <CoreServices/CoreServices.h>
+#include <dispatch/dispatch.h>
 #include <efsw/WatcherFSEvents.hpp>
-#include <list>
 #include <map>
 #include <vector>
+#include <condition_variable>
+#include <mutex>
 
 namespace efsw {
 
-/* OSX < 10.7 has no file events */
-/* So i declare the events constants */
-enum FSEventEvents {
-        efswFSEventStreamCreateFlagFileEvents = 0x00000010,
-        efswFSEventStreamEventFlagItemCreated = 0x00000100,
-        efswFSEventStreamEventFlagItemRemoved = 0x00000200,
-        efswFSEventStreamEventFlagItemInodeMetaMod = 0x00000400,
-        efswFSEventStreamEventFlagItemRenamed = 0x00000800,
-        efswFSEventStreamEventFlagItemModified = 0x00001000,
-        efswFSEventStreamEventFlagItemFinderInfoMod = 0x00002000,
-        efswFSEventStreamEventFlagItemChangeOwner = 0x00004000,
-        efswFSEventStreamEventFlagItemXattrMod = 0x00008000,
-        efswFSEventStreamEventFlagItemIsFile = 0x00010000,
-        efswFSEventStreamEventFlagItemIsDir = 0x00020000,
-        efswFSEventStreamEventFlagItemIsSymlink = 0x00040000,
-        efswFSEventsModified = efswFSEventStreamEventFlagItemFinderInfoMod |
-                                                   efswFSEventStreamEventFlagItemModified |
-                                                   efswFSEventStreamEventFlagItemInodeMetaMod
-};
-
 /// Implementation for Win32 based on ReadDirectoryChangesW.
 /// @class FileWatcherFSEvents
 class FileWatcherFSEvents : public FileWatcherImpl {
@@ -52,48 +34,43 @@ class FileWatcherFSEvents : public FileWatcherImpl {
 
         /// Add a directory watch
         /// On error returns WatchID with Error type.
-        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive );
+        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive,
+                          const std::vector<WatcherOption> &options ) override;
 
         /// Remove a directory watch. This is a brute force lazy search O(nlogn).
-        void removeWatch( const std::string& directory );
+        void removeWatch( const std::string& directory ) override;
 
         /// Remove a directory watch. This is a map lookup O(logn).
-        void removeWatch( WatchID watchid );
+        void removeWatch( WatchID watchid ) override;
 
         /// Updates the watcher. Must be called often.
-        void watch();
+        void watch() override;
 
         /// Handles the action
         void handleAction( Watcher* watch, const std::string& filename, unsigned long action,
-                                           std::string oldFilename = "" );
+                                           std::string oldFilename = "" ) override;
 
         /// @return Returns a list of the directories that are being watched
-        std::list<std::string> directories();
+        std::vector<std::string> directories() override;
 
   protected:
         static void FSEventCallback( ConstFSEventStreamRef streamRef, void* userData, size_t numEvents,
                                                                  void* eventPaths, const FSEventStreamEventFlags eventFlags[],
                                                                  const FSEventStreamEventId eventIds[] );
 
-        Atomic<CFRunLoopRef> mRunLoopRef;
-
         /// Vector of WatcherWin32 pointers
         WatchMap mWatches;
 
         /// The last watchid
         WatchID mLastWatchID;
 
-        Thread* mThread;
-
         Mutex mWatchesLock;
 
-        bool pathInWatches( const std::string& path );
+        bool pathInWatches( const std::string& path ) override;
 
-        std::vector<WatcherFSEvents*> mNeedInit;
-        Mutex mNeedInitMutex;
+        std::mutex mWatchesMutex;
+        std::condition_variable mWatchCond;
 
-  private:
-        void run();
 };
 
 } // namespace efsw
diff --git a/src/3rdParty/efsw/FileWatcherGeneric.cpp b/src/3rdParty/efsw/FileWatcherGeneric.cpp
index 074cff1..468d27c 100755..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 ) {
+                                                                          bool recursive, const std::vector<WatcherOption>& /*options*/ ) {
         std::string dir( directory );
 
         FileSystem::dirAddSlashAtEnd( dir );
@@ -127,11 +127,13 @@ void FileWatcherGeneric::handleAction( Watcher*, const std::string&, unsigned lo
         /// Not used
 }
 
-std::list<std::string> FileWatcherGeneric::directories() {
-        std::list<std::string> dirs;
+std::vector<std::string> FileWatcherGeneric::directories() {
+        std::vector<std::string> dirs;
 
         Lock lock( mWatchesLock );
 
+        dirs.reserve( mWatches.size() );
+
         WatchList::iterator it = mWatches.begin();
 
         for ( ; it != mWatches.end(); ++it ) {
diff --git a/src/3rdParty/efsw/FileWatcherGeneric.hpp b/src/3rdParty/efsw/FileWatcherGeneric.hpp
index 4cb0b67..47f7e04 100755..100644
--- a/src/3rdParty/efsw/FileWatcherGeneric.hpp
+++ b/src/3rdParty/efsw/FileWatcherGeneric.hpp
@@ -4,7 +4,7 @@
 #include <efsw/DirWatcherGeneric.hpp>
 #include <efsw/FileWatcherImpl.hpp>
 #include <efsw/WatcherGeneric.hpp>
-#include <list>
+#include <vector>
 
 namespace efsw {
 
@@ -12,7 +12,7 @@ namespace efsw {
 /// @class FileWatcherGeneric
 class FileWatcherGeneric : public FileWatcherImpl {
   public:
-        typedef std::list<WatcherGeneric*> WatchList;
+        typedef std::vector<WatcherGeneric*> WatchList;
 
         FileWatcherGeneric( FileWatcher* parent );
 
@@ -20,23 +20,24 @@ class FileWatcherGeneric : public FileWatcherImpl {
 
         /// Add a directory watch
         /// On error returns WatchID with Error type.
-        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive );
+        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive,
+                                          const std::vector<WatcherOption> &options ) override;
 
         /// Remove a directory watch. This is a brute force lazy search O(nlogn).
-        void removeWatch( const std::string& directory );
+        void removeWatch( const std::string& directory ) override;
 
         /// Remove a directory watch. This is a map lookup O(logn).
-        void removeWatch( WatchID watchid );
+        void removeWatch( WatchID watchid ) override;
 
         /// Updates the watcher. Must be called often.
-        void watch();
+        void watch() override;
 
         /// Handles the action
         void handleAction( Watcher* watch, const std::string& filename, unsigned long action,
-                                           std::string oldFilename = "" );
+                                           std::string oldFilename = "" ) override;
 
         /// @return Returns a list of the directories that are being watched
-        std::list<std::string> directories();
+        std::vector<std::string> directories() override;
 
   protected:
         Thread* mThread;
@@ -49,7 +50,7 @@ class FileWatcherGeneric : public FileWatcherImpl {
 
         Mutex mWatchesLock;
 
-        bool pathInWatches( const std::string& path );
+        bool pathInWatches( const std::string& path ) override;
 
   private:
         void run();
diff --git a/src/3rdParty/efsw/FileWatcherImpl.cpp b/src/3rdParty/efsw/FileWatcherImpl.cpp
index f6b86a5..bf69a45 100755..100644
--- a/src/3rdParty/efsw/FileWatcherImpl.cpp
+++ b/src/3rdParty/efsw/FileWatcherImpl.cpp
@@ -1,23 +1,34 @@
-#include <efsw/FileWatcherImpl.hpp>
-#include <efsw/String.hpp>
-#include <efsw/System.hpp>
-
-namespace efsw {
-
-FileWatcherImpl::FileWatcherImpl( FileWatcher* parent ) :
-        mFileWatcher( parent ), mInitOK( false ), mIsGeneric( false ) {
-        System::maxFD();
-}
-
-FileWatcherImpl::~FileWatcherImpl() {}
-
-bool FileWatcherImpl::initOK() {
-        return static_cast<bool>( mInitOK );
-}
-
-bool FileWatcherImpl::linkAllowed( const std::string& curPath, const std::string& link ) {
-        return ( mFileWatcher->followSymlinks() && mFileWatcher->allowOutOfScopeLinks() ) ||
-                   -1 != String::strStartsWith( curPath, link );
-}
-
-} // namespace efsw
+#include <efsw/FileWatcherImpl.hpp>

+#include <efsw/String.hpp>

+#include <efsw/System.hpp>

+

+namespace efsw {

+

+FileWatcherImpl::FileWatcherImpl( FileWatcher* parent ) :

+        mFileWatcher( parent ), mInitOK( false ), mIsGeneric( false ) {

+        System::maxFD();

+}

+

+FileWatcherImpl::~FileWatcherImpl() {}

+

+bool FileWatcherImpl::initOK() {

+        return static_cast<bool>( mInitOK );

+}

+

+bool FileWatcherImpl::linkAllowed( const std::string& curPath, const std::string& link ) {

+        return ( mFileWatcher->followSymlinks() && mFileWatcher->allowOutOfScopeLinks() ) ||

+                   -1 != String::strStartsWith( curPath, link );

+}

+

+int FileWatcherImpl::getOptionValue( const std::vector<WatcherOption>& options, Option option,

+                                                                         int defaultValue ) {

+        for ( size_t i = 0; i < options.size(); i++ ) {

+                if ( options[i].mOption == option ) {

+                        return options[i].mValue;

+                }

+        }

+

+        return defaultValue;

+}

+

+} // namespace efsw

diff --git a/src/3rdParty/efsw/FileWatcherImpl.hpp b/src/3rdParty/efsw/FileWatcherImpl.hpp
index ea1beb8..a6ec472 100755..100644
--- a/src/3rdParty/efsw/FileWatcherImpl.hpp
+++ b/src/3rdParty/efsw/FileWatcherImpl.hpp
@@ -1,57 +1,64 @@
-#ifndef EFSW_FILEWATCHERIMPL_HPP
-#define EFSW_FILEWATCHERIMPL_HPP
-
-#include <efsw/Atomic.hpp>
-#include <efsw/Mutex.hpp>
-#include <efsw/Thread.hpp>
-#include <efsw/Watcher.hpp>
-#include <efsw/base.hpp>
-#include <efsw/efsw.hpp>
-
-namespace efsw {
-
-class FileWatcherImpl {
-  public:
-        FileWatcherImpl( FileWatcher* parent );
-
-        virtual ~FileWatcherImpl();
-
-        /// Add a directory watch
-        /// On error returns WatchID with Error type.
-        virtual WatchID addWatch( const std::string& directory, FileWatchListener* watcher,
-                                                          bool recursive ) = 0;
-
-        /// Remove a directory watch. This is a brute force lazy search O(nlogn).
-        virtual void removeWatch( const std::string& directory ) = 0;
-
-        /// Remove a directory watch. This is a map lookup O(logn).
-        virtual void removeWatch( WatchID watchid ) = 0;
-
-        /// Updates the watcher. Must be called often.
-        virtual void watch() = 0;
-
-        /// Handles the action
-        virtual void handleAction( Watcher* watch, const std::string& filename, unsigned long action,
-                                                           std::string oldFilename = "" ) = 0;
-
-        /// @return Returns a list of the directories that are being watched
-        virtual std::list<std::string> directories() = 0;
-
-        /// @return true if the backend init successfully
-        virtual bool initOK();
-
-        /// @return If the link is allowed according to the current path and the state of out scope
-        /// links
-        virtual bool linkAllowed( const std::string& curPath, const std::string& link );
-
-        /// Search if a directory already exists in the watches
-        virtual bool pathInWatches( const std::string& path ) = 0;
-
-        FileWatcher* mFileWatcher;
-        Atomic<bool> mInitOK;
-        bool mIsGeneric;
-};
-
-} // namespace efsw
-
-#endif
+#ifndef EFSW_FILEWATCHERIMPL_HPP

+#define EFSW_FILEWATCHERIMPL_HPP

+

+#include <efsw/Atomic.hpp>

+#include <efsw/Mutex.hpp>

+#include <efsw/Thread.hpp>

+#include <efsw/Watcher.hpp>

+#include <efsw/base.hpp>

+#include <efsw/efsw.hpp>

+

+namespace efsw {

+

+class FileWatcherImpl {

+  public:

+        FileWatcherImpl( FileWatcher* parent );

+

+        virtual ~FileWatcherImpl();

+

+        /// Add a directory watch

+        /// On error returns WatchID with Error type.

+        virtual WatchID addWatch( const std::string& directory, FileWatchListener* watcher,

+                                                          bool recursive, const std::vector<WatcherOption>& options = {} ) = 0;

+

+        /// Remove a directory watch. This is a brute force lazy search O(nlogn).

+        virtual void removeWatch( const std::string& directory ) = 0;

+

+        /// Remove a directory watch. This is a map lookup O(logn).

+        virtual void removeWatch( WatchID watchid ) = 0;

+

+        /// Updates the watcher. Must be called often.

+        virtual void watch() = 0;

+

+        /// Handles the action

+        virtual void handleAction( Watcher* watch, const std::string& filename, unsigned long action,

+                                                           std::string oldFilename = "" ) = 0;

+

+        /// @return Returns a list of the directories that are being watched

+        virtual std::vector<std::string> directories() = 0;

+

+        /// @return true if the backend init successfully

+        virtual bool initOK();

+

+        /// @return If the link is allowed according to the current path and the state of out scope

+        /// links

+        virtual bool linkAllowed( const std::string& curPath, const std::string& link );

+

+        /// Search if a directory already exists in the watches

+        virtual bool pathInWatches( const std::string& path ) = 0;

+

+  protected:

+        friend class FileWatcher;

+        friend class DirWatcherGeneric;

+

+        FileWatcher* mFileWatcher;

+        Atomic<bool> mInitOK;

+        bool mIsGeneric;

+

+        int getOptionValue( const std::vector<WatcherOption>& options, Option option,

+                                                int defaultValue );

+};

+

+} // namespace efsw

+

+#endif

diff --git a/src/3rdParty/efsw/FileWatcherInotify.cpp b/src/3rdParty/efsw/FileWatcherInotify.cpp
index e0da76b..1ec3d48 100755..100644
--- a/src/3rdParty/efsw/FileWatcherInotify.cpp
+++ b/src/3rdParty/efsw/FileWatcherInotify.cpp
@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <efsw/FileWatcherInotify.hpp>
 
 #if EFSW_PLATFORM == EFSW_PLATFORM_INOTIFY
@@ -26,7 +27,7 @@
 namespace efsw {
 
 FileWatcherInotify::FileWatcherInotify( FileWatcher* parent ) :
-        FileWatcherImpl( parent ), mFD( -1 ), mThread( NULL ) {
+        FileWatcherImpl( parent ), mFD( -1 ), mThread( NULL ), mIsTakingAction( false ) {
         mFD = inotify_init();
 
         if ( mFD < 0 ) {
@@ -38,13 +39,20 @@ FileWatcherInotify::FileWatcherInotify( FileWatcher* parent ) :
 
 FileWatcherInotify::~FileWatcherInotify() {
         mInitOK = false;
-
+        // There is deadlock when release FileWatcherInotify instance since its handAction
+        // function is still running and hangs in requiring lock without init lock captured.
+        while ( mIsTakingAction ) {
+                // It'd use condition-wait instead of sleep. Actually efsw has no such
+                // implementation so we just skip and sleep while for that to avoid deadlock.
+                usleep( 1000 );
+        };
         Lock initLock( mInitLock );
 
         efSAFE_DELETE( mThread );
 
         Lock l( mWatchesLock );
         Lock l2( mRealWatchesLock );
+
         WatchMap::iterator iter = mWatches.begin();
         WatchMap::iterator end = mWatches.end();
 
@@ -61,15 +69,17 @@ FileWatcherInotify::~FileWatcherInotify() {
 }
 
 WatchID FileWatcherInotify::addWatch( const std::string& directory, FileWatchListener* watcher,
-                                                                          bool recursive ) {
+                                                                          bool recursive, const std::vector<WatcherOption>& options ) {
         if ( !mInitOK )
                 return Errors::Log::createLastError( Errors::Unspecified, directory );
         Lock initLock( mInitLock );
-        return addWatch( directory, watcher, recursive, NULL );
+        bool syntheticEvents = getOptionValue( options, Options::LinuxProduceSyntheticEvents, 0 ) != 0;
+        return addWatch( directory, watcher, recursive, syntheticEvents, NULL );
 }
 
 WatchID FileWatcherInotify::addWatch( const std::string& directory, FileWatchListener* watcher,
-                                                                          bool recursive, WatcherInotify* parent ) {
+                                                                          bool recursive, bool syntheticEvents,
+                                                                          WatcherInotify* parent, bool fromInternalEvent ) {
         std::string dir( directory );
 
         FileSystem::dirAddSlashAtEnd( dir );
@@ -133,6 +143,7 @@ WatchID FileWatcherInotify::addWatch( const std::string& directory, FileWatchLis
         {
                 Lock lock( mWatchesLock );
                 mWatches.insert( std::make_pair( wd, pWatch ) );
+                mWatchesRef[pWatch->Directory] = wd;
         }
 
         if ( NULL == pWatch->Parent ) {
@@ -151,7 +162,17 @@ WatchID FileWatcherInotify::addWatch( const std::string& directory, FileWatchLis
                         const FileInfo& cfi = it->second;
 
                         if ( cfi.isDirectory() && cfi.isReadable() ) {
-                                addWatch( cfi.Filepath, watcher, recursive, pWatch );
+                                addWatch( cfi.Filepath, watcher, recursive, syntheticEvents, pWatch );
+                        }
+                }
+
+                if ( fromInternalEvent && parent != NULL && syntheticEvents ) {
+                        for ( const auto& file : files ) {
+                                if ( file.second.isRegularFile() ) {
+                                        pWatch->Listener->handleFileAction(
+                                                pWatch->ID, pWatch->Directory,
+                                                FileSystem::fileNameFromPath( file.second.Filepath ), Actions::Add );
+                                }
                         }
                 }
         }
@@ -161,6 +182,8 @@ WatchID FileWatcherInotify::addWatch( const std::string& directory, FileWatchLis
 
 void FileWatcherInotify::removeWatchLocked( WatchID watchid ) {
         WatchMap::iterator iter = mWatches.find( watchid );
+        if ( iter == mWatches.end() )
+                return;
 
         WatcherInotify* watch = iter->second;
 
@@ -173,22 +196,21 @@ void FileWatcherInotify::removeWatchLocked( WatchID watchid ) {
                 }
         }
 
-        if ( watch->Recursive ) {
+        if ( watch->Recursive && NULL == watch->Parent ) {
                 WatchMap::iterator it = mWatches.begin();
-                std::list<WatchID> eraseWatches;
+                std::vector<WatchID> eraseWatches;
 
-                for ( ; it != mWatches.end(); ++it ) {
-                        if ( it->second != watch && it->second->inParentTree( watch ) ) {
+                for ( ; it != mWatches.end(); ++it )
+                        if ( it->second != watch && it->second->inParentTree( watch ) )
                                 eraseWatches.push_back( it->second->InotifyID );
-                        }
-                }
 
-                for ( std::list<WatchID>::iterator eit = eraseWatches.begin(); eit != eraseWatches.end();
+                for ( std::vector<WatchID>::iterator eit = eraseWatches.begin(); eit != eraseWatches.end();
                           ++eit ) {
                         removeWatch( *eit );
                 }
         }
 
+        mWatchesRef.erase( watch->Directory );
         mWatches.erase( iter );
 
         if ( NULL == watch->Parent ) {
@@ -217,52 +239,11 @@ void FileWatcherInotify::removeWatch( const std::string& directory ) {
         Lock lock( mWatchesLock );
         Lock l( mRealWatchesLock );
 
-        WatchMap::iterator iter = mWatches.begin();
-
-        for ( ; iter != mWatches.end(); ++iter ) {
-                if ( directory == iter->second->Directory ) {
-                        WatcherInotify* watch = iter->second;
-
-                        if ( watch->Recursive ) {
-                                WatchMap::iterator it = mWatches.begin();
-                                std::list<WatchID> eraseWatches;
-
-                                for ( ; it != mWatches.end(); ++it ) {
-                                        if ( it->second->inParentTree( watch ) ) {
-                                                eraseWatches.push_back( it->second->InotifyID );
-                                        }
-                                }
-
-                                for ( std::list<WatchID>::iterator eit = eraseWatches.begin();
-                                          eit != eraseWatches.end(); ++eit ) {
-                                        removeWatchLocked( *eit );
-                                }
-                        }
-
-                        mWatches.erase( iter );
-
-                        if ( NULL == watch->Parent ) {
-                                WatchMap::iterator eraseit = mRealWatches.find( watch->InotifyID );
-
-                                if ( eraseit != mRealWatches.end() ) {
-                                        mRealWatches.erase( eraseit );
-                                }
-                        }
-
-                        int err = inotify_rm_watch( mFD, watch->InotifyID );
-
-                        if ( err < 0 ) {
-                                efDEBUG( "Error removing watch %d: %s\n", watch->InotifyID, strerror( errno ) );
-                        } else {
-                                efDEBUG( "Removed watch %s with id: %d\n", watch->Directory.c_str(),
-                                                 watch->InotifyID );
-                        }
-
-                        efSAFE_DELETE( watch );
+        std::unordered_map<std::string, WatchID>::iterator ref = mWatchesRef.find( directory );
+        if ( ref == mWatchesRef.end() )
+                return;
 
-                        break;
-                }
-        }
+        removeWatchLocked( ref->second );
 }
 
 void FileWatcherInotify::removeWatch( WatchID watchid ) {
@@ -270,13 +251,6 @@ void FileWatcherInotify::removeWatch( WatchID watchid ) {
                 return;
         Lock initLock( mInitLock );
         Lock lock( mWatchesLock );
-
-        WatchMap::iterator iter = mWatches.find( watchid );
-
-        if ( iter == mWatches.end() ) {
-                return;
-        }
-
         removeWatchLocked( watchid );
 }
 
@@ -295,10 +269,8 @@ Watcher* FileWatcherInotify::watcherContainsDirectory( std::string dir ) {
 
         for ( WatchMap::iterator it = mWatches.begin(); it != mWatches.end(); ++it ) {
                 Watcher* watcher = it->second;
-
-                if ( watcher->Directory == watcherPath ) {
+                if ( watcher->Directory == watcherPath )
                         return watcher;
-                }
         }
 
         return NULL;
@@ -422,7 +394,7 @@ void FileWatcherInotify::run() {
                                 const std::string& oldFileName = ( *it ).second;
 
                                 /// Check if the file move was a folder already being watched
-                                std::list<Watcher*> eraseWatches;
+                                std::vector<Watcher*> eraseWatches;
 
                                 {
                                         Lock lock( mWatchesLock );
@@ -439,12 +411,15 @@ void FileWatcherInotify::run() {
                                 }
 
                                 /// Remove invalid watches
-                                eraseWatches.sort();
+                                std::stable_sort( eraseWatches.begin(), eraseWatches.end(),
+                                                                  []( const Watcher* left, const Watcher* right ) {
+                                                                          return left->Directory < right->Directory;
+                                                                  } );
 
                                 if ( eraseWatches.empty() ) {
                                         handleAction( watch, oldFileName, IN_DELETE );
                                 } else {
-                                        for ( std::list<Watcher*>::reverse_iterator eit = eraseWatches.rbegin();
+                                        for ( std::vector<Watcher*>::reverse_iterator eit = eraseWatches.rbegin();
                                                   eit != eraseWatches.rend(); ++eit ) {
                                                 Watcher* rmWatch = *eit;
 
@@ -485,8 +460,9 @@ void FileWatcherInotify::checkForNewWatcher( Watcher* watch, std::string fpath )
                 }
 
                 if ( !found ) {
-                        addWatch( fpath, watch->Listener, watch->Recursive,
-                                          static_cast<WatcherInotify*>( watch ) );
+                        WatcherInotify* iWatch = static_cast<WatcherInotify*>( watch );
+                        addWatch( fpath, watch->Listener, watch->Recursive, iWatch->syntheticEvents,
+                                          static_cast<WatcherInotify*>( watch ), true );
                 }
         }
 }
@@ -496,7 +472,7 @@ void FileWatcherInotify::handleAction( Watcher* watch, const std::string& filena
         if ( !watch || !watch->Listener || !mInitOK ) {
                 return;
         }
-
+        mIsTakingAction = true;
         Lock initLock( mInitLock );
 
         std::string fpath( watch->Directory + filename );
@@ -563,18 +539,20 @@ void FileWatcherInotify::handleAction( Watcher* watch, const std::string& filena
                         }
                 }
         }
+        mIsTakingAction = false;
 }
 
-std::list<std::string> FileWatcherInotify::directories() {
-        std::list<std::string> dirs;
+std::vector<std::string> FileWatcherInotify::directories() {
+        std::vector<std::string> dirs;
 
         Lock l( mRealWatchesLock );
 
+        dirs.reserve( mRealWatches.size() );
+
         WatchMap::iterator it = mRealWatches.begin();
 
-        for ( ; it != mRealWatches.end(); ++it ) {
+        for ( ; it != mRealWatches.end(); ++it )
                 dirs.push_back( it->second->Directory );
-        }
 
         return dirs;
 }
@@ -585,11 +563,9 @@ bool FileWatcherInotify::pathInWatches( const std::string& path ) {
         /// Search in the real watches, since it must allow adding a watch already watched as a subdir
         WatchMap::iterator it = mRealWatches.begin();
 
-        for ( ; it != mRealWatches.end(); ++it ) {
-                if ( it->second->Directory == path ) {
+        for ( ; it != mRealWatches.end(); ++it )
+                if ( it->second->Directory == path )
                         return true;
-                }
-        }
 
         return false;
 }
diff --git a/src/3rdParty/efsw/FileWatcherInotify.hpp b/src/3rdParty/efsw/FileWatcherInotify.hpp
index dc922ac..26d2c0b 100755..100644
--- a/src/3rdParty/efsw/FileWatcherInotify.hpp
+++ b/src/3rdParty/efsw/FileWatcherInotify.hpp
@@ -7,6 +7,7 @@
 
 #include <efsw/WatcherInotify.hpp>
 #include <map>
+#include <unordered_map>
 #include <vector>
 
 namespace efsw {
@@ -24,23 +25,24 @@ class FileWatcherInotify : public FileWatcherImpl {
 
         /// Add a directory watch
         /// On error returns WatchID with Error type.
-        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive );
+        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive,
+                                          const std::vector<WatcherOption>& options ) override;
 
         /// Remove a directory watch. This is a brute force lazy search O(nlogn).
-        void removeWatch( const std::string& directory );
+        void removeWatch( const std::string& directory ) override;
 
         /// Remove a directory watch. This is a map lookup O(logn).
-        void removeWatch( WatchID watchid );
+        void removeWatch( WatchID watchid ) override;
 
         /// Updates the watcher. Must be called often.
-        void watch();
+        void watch() override;
 
         /// Handles the action
         void handleAction( Watcher* watch, const std::string& filename, unsigned long action,
-                                           std::string oldFilename = "" );
+                                           std::string oldFilename = "" ) override;
 
         /// @return Returns a list of the directories that are being watched
-        std::list<std::string> directories();
+        std::vector<std::string> directories() override;
 
   protected:
         /// Map of WatchID to WatchStruct pointers
@@ -49,6 +51,8 @@ class FileWatcherInotify : public FileWatcherImpl {
         /// User added watches
         WatchMap mRealWatches;
 
+        std::unordered_map<std::string, WatchID> mWatchesRef;
+
         /// inotify file descriptor
         int mFD;
 
@@ -57,12 +61,14 @@ class FileWatcherInotify : public FileWatcherImpl {
         Mutex mWatchesLock;
         Mutex mRealWatchesLock;
         Mutex mInitLock;
+        bool mIsTakingAction;
         std::vector<std::pair<WatcherInotify*, std::string>> mMovedOutsideWatches;
 
         WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive,
-                                          WatcherInotify* parent = NULL );
+                                          bool syntheticEvents, WatcherInotify* parent = NULL,
+                                          bool fromInternalEvent = false );
 
-        bool pathInWatches( const std::string& path );
+        bool pathInWatches( const std::string& path ) override;
 
   private:
         void run();
diff --git a/src/3rdParty/efsw/FileWatcherKqueue.cpp b/src/3rdParty/efsw/FileWatcherKqueue.cpp
index 38ffad9..ad03036 100755..100644
--- a/src/3rdParty/efsw/FileWatcherKqueue.cpp
+++ b/src/3rdParty/efsw/FileWatcherKqueue.cpp
@@ -45,7 +45,7 @@ FileWatcherKqueue::~FileWatcherKqueue() {
 }
 
 WatchID FileWatcherKqueue::addWatch( const std::string& directory, FileWatchListener* watcher,
-                                                                         bool recursive ) {
+                                                                         bool recursive, const std::vector<WatcherOption>& /*options*/ ) {
         static bool s_ug = false;
 
         std::string dir( directory );
@@ -184,11 +184,13 @@ void FileWatcherKqueue::run() {
 void FileWatcherKqueue::handleAction( Watcher* /*watch*/, const std::string& /*filename*/,
                                                                           unsigned long /*action*/, std::string /*oldFilename*/ ) {}
 
-std::list<std::string> FileWatcherKqueue::directories() {
-        std::list<std::string> dirs;
+std::vector<std::string> FileWatcherKqueue::directories() {
+        std::vector<std::string> dirs;
 
         Lock lock( mWatchesLock );
 
+        dirs.reserve( mWatches.size() );
+
         WatchMap::iterator it = mWatches.begin();
 
         for ( ; it != mWatches.end(); ++it ) {
diff --git a/src/3rdParty/efsw/FileWatcherKqueue.hpp b/src/3rdParty/efsw/FileWatcherKqueue.hpp
index 1bf3755..ff5327b 100755..100644
--- a/src/3rdParty/efsw/FileWatcherKqueue.hpp
+++ b/src/3rdParty/efsw/FileWatcherKqueue.hpp
@@ -21,23 +21,24 @@ class FileWatcherKqueue : public FileWatcherImpl {
 
         /// Add a directory watch
         /// On error returns WatchID with Error type.
-        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive );
+        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive,
+                                          const std::vector<WatcherOption> &options ) override;
 
         /// Remove a directory watch. This is a brute force lazy search O(nlogn).
-        void removeWatch( const std::string& directory );
+        void removeWatch( const std::string& directory ) override;
 
         /// Remove a directory watch. This is a map lookup O(logn).
-        void removeWatch( WatchID watchid );
+        void removeWatch( WatchID watchid ) override;
 
         /// Updates the watcher. Must be called often.
-        void watch();
+        void watch() override;
 
         /// Handles the action
         void handleAction( Watcher* watch, const std::string& filename, unsigned long action,
-                                           std::string oldFilename = "" );
+                                           std::string oldFilename = "" ) override;
 
         /// @return Returns a list of the directories that are being watched
-        std::list<std::string> directories();
+        std::vector<std::string> directories() override;
 
   protected:
         /// Map of WatchID to WatchStruct pointers
@@ -53,7 +54,7 @@ class FileWatcherKqueue : public FileWatcherImpl {
 
         Mutex mWatchesLock;
 
-        std::list<WatchID> mRemoveList;
+        std::vector<WatchID> mRemoveList;
 
         long mFileDescriptorCount;
 
@@ -61,7 +62,7 @@ class FileWatcherKqueue : public FileWatcherImpl {
 
         bool isAddingWatcher() const;
 
-        bool pathInWatches( const std::string& path );
+        bool pathInWatches( const std::string& path ) override;
 
         void addFD();
 
diff --git a/src/3rdParty/efsw/FileWatcherWin32.cpp b/src/3rdParty/efsw/FileWatcherWin32.cpp
index 963dc98..19b71d7 100755..100644
--- a/src/3rdParty/efsw/FileWatcherWin32.cpp
+++ b/src/3rdParty/efsw/FileWatcherWin32.cpp
@@ -1,257 +1,267 @@
-#include <efsw/FileSystem.hpp>
-#include <efsw/FileWatcherWin32.hpp>
-#include <efsw/Lock.hpp>
-#include <efsw/String.hpp>
-#include <efsw/System.hpp>
-
-#if EFSW_PLATFORM == EFSW_PLATFORM_WIN32
-
-namespace efsw {
-
-FileWatcherWin32::FileWatcherWin32( FileWatcher* parent ) :
-        FileWatcherImpl( parent ), mLastWatchID( 0 ), mThread( NULL ) {
-        mIOCP = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 1 );
-        if ( mIOCP && mIOCP != INVALID_HANDLE_VALUE )
-                mInitOK = true;
-}
-
-FileWatcherWin32::~FileWatcherWin32() {
-        mInitOK = false;
-
-        if ( mIOCP && mIOCP != INVALID_HANDLE_VALUE ) {
-                PostQueuedCompletionStatus( mIOCP, 0, reinterpret_cast<ULONG_PTR>( this ), NULL );
-        }
-
-        efSAFE_DELETE( mThread );
-
-        removeAllWatches();
-
-        CloseHandle( mIOCP );
-}
-
-WatchID FileWatcherWin32::addWatch( const std::string& directory, FileWatchListener* watcher,
-                                                                        bool recursive ) {
-        std::string dir( directory );
-
-        FileInfo fi( dir );
-
-        if ( !fi.isDirectory() ) {
-                return Errors::Log::createLastError( Errors::FileNotFound, dir );
-        } else if ( !fi.isReadable() ) {
-                return Errors::Log::createLastError( Errors::FileNotReadable, dir );
-        }
-
-        FileSystem::dirAddSlashAtEnd( dir );
-
-        Lock lock( mWatchesLock );
-
-        if ( pathInWatches( dir ) ) {
-                return Errors::Log::createLastError( Errors::FileRepeated, dir );
-        }
-
-        WatchID watchid = ++mLastWatchID;
-
-        WatcherStructWin32* watch = CreateWatch(
-                String::fromUtf8( dir ).toWideString().c_str(), recursive,
-                FILE_NOTIFY_CHANGE_CREATION | FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_FILE_NAME |
-                        FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_SIZE,
-                mIOCP );
-
-        if ( NULL == watch ) {
-                return Errors::Log::createLastError( Errors::FileNotFound, dir );
-        }
-
-        // Add the handle to the handles vector
-        watch->Watch->ID = watchid;
-        watch->Watch->Watch = this;
-        watch->Watch->Listener = watcher;
-        watch->Watch->DirName = new char[dir.length() + 1];
-        strcpy( watch->Watch->DirName, dir.c_str() );
-
-        mWatches.insert( watch );
-
-        return watchid;
-}
-
-void FileWatcherWin32::removeWatch( const std::string& directory ) {
-        Lock lock( mWatchesLock );
-
-        Watches::iterator iter = mWatches.begin();
-
-        for ( ; iter != mWatches.end(); ++iter ) {
-                if ( directory == ( *iter )->Watch->DirName ) {
-                        removeWatch( *iter );
-                        break;
-                }
-        }
-}
-
-void FileWatcherWin32::removeWatch( WatchID watchid ) {
-        Lock lock( mWatchesLock );
-
-        Watches::iterator iter = mWatches.begin();
-
-        for ( ; iter != mWatches.end(); ++iter ) {
-                // Find the watch ID
-                if ( ( *iter )->Watch->ID == watchid ) {
-                        removeWatch( *iter );
-                        return;
-                }
-        }
-}
-
-void FileWatcherWin32::removeWatch( WatcherStructWin32* watch ) {
-        Lock lock( mWatchesLock );
-
-        DestroyWatch( watch );
-        mWatches.erase( watch );
-}
-
-void FileWatcherWin32::watch() {
-        if ( NULL == mThread ) {
-                mThread = new Thread( &FileWatcherWin32::run, this );
-                mThread->launch();
-        }
-}
-
-void FileWatcherWin32::removeAllWatches() {
-        Lock lock( mWatchesLock );
-
-        Watches::iterator iter = mWatches.begin();
-
-        for ( ; iter != mWatches.end(); ++iter ) {
-                DestroyWatch( ( *iter ) );
-        }
-
-        mWatches.clear();
-}
-
-void FileWatcherWin32::run() {
-        do {
-                if ( mInitOK && !mWatches.empty() ) {
-                        DWORD numOfBytes = 0;
-                        OVERLAPPED* ov = NULL;
-                        ULONG_PTR compKey = 0;
-                        BOOL res = FALSE;
-
-                        while ( ( res = GetQueuedCompletionStatus( mIOCP, &numOfBytes, &compKey, &ov,
-                                                                                                           INFINITE ) ) != FALSE ) {
-                                if ( compKey != 0 && compKey == reinterpret_cast<ULONG_PTR>( this ) ) {
-                                        break;
-                                } else {
-                                        Lock lock( mWatchesLock );
-                                        WatchCallback( numOfBytes, ov );
-                                }
-                        }
-                } else {
-                        System::sleep( 10 );
-                }
-        } while ( mInitOK );
-
-        removeAllWatches();
-}
-
-void FileWatcherWin32::handleAction( Watcher* watch, const std::string& filename,
-                                                                         unsigned long action, std::string /*oldFilename*/ ) {
-        Action fwAction;
-
-        switch ( action ) {
-                case FILE_ACTION_RENAMED_OLD_NAME:
-                        watch->OldFileName = filename;
-                        return;
-                case FILE_ACTION_ADDED:
-                        fwAction = Actions::Add;
-                        break;
-                case FILE_ACTION_RENAMED_NEW_NAME: {
-                        fwAction = Actions::Moved;
-
-                        std::string fpath( watch->Directory + filename );
-
-                        // Update the directory path
-                        if ( watch->Recursive && FileSystem::isDirectory( fpath ) ) {
-                                // Update the new directory path
-                                std::string opath( watch->Directory + watch->OldFileName );
-                                FileSystem::dirAddSlashAtEnd( opath );
-                                FileSystem::dirAddSlashAtEnd( fpath );
-
-                                for ( Watches::iterator it = mWatches.begin(); it != mWatches.end(); ++it ) {
-                                        if ( ( *it )->Watch->Directory == opath ) {
-                                                ( *it )->Watch->Directory = fpath;
-
-                                                break;
-                                        }
-                                }
-                        }
-
-                        std::string folderPath( static_cast<WatcherWin32*>( watch )->DirName );
-                        std::string realFilename = filename;
-                        std::size_t sepPos = filename.find_last_of( "/\\" );
-                        std::string oldFolderPath =
-                                static_cast<WatcherWin32*>( watch )->DirName +
-                                watch->OldFileName.substr( 0, watch->OldFileName.find_last_of( "/\\" ) );
-
-                        if ( sepPos != std::string::npos ) {
-                                folderPath += filename.substr( 0, sepPos );
-                                realFilename = filename.substr( sepPos + 1 );
-                        }
-
-                        if ( folderPath == oldFolderPath ) {
-                                watch->Listener->handleFileAction(
-                                        watch->ID, folderPath, realFilename, fwAction,
-                                        FileSystem::fileNameFromPath( watch->OldFileName ) );
-                        } else {
-                                watch->Listener->handleFileAction( watch->ID,
-                                                                                                   static_cast<WatcherWin32*>( watch )->DirName,
-                                                                                                   filename, fwAction, watch->OldFileName );
-                        }
-                        return;
-                }
-                case FILE_ACTION_REMOVED:
-                        fwAction = Actions::Delete;
-                        break;
-                case FILE_ACTION_MODIFIED:
-                        fwAction = Actions::Modified;
-                        break;
-                default:
-                        return;
-        };
-
-        std::string folderPath( static_cast<WatcherWin32*>( watch )->DirName );
-        std::string realFilename = filename;
-        std::size_t sepPos = filename.find_last_of( "/\\" );
-
-        if ( sepPos != std::string::npos ) {
-                folderPath += filename.substr( 0, sepPos );
-                realFilename = filename.substr( sepPos + 1 );
-        }
-
-        watch->Listener->handleFileAction( watch->ID, folderPath, realFilename, fwAction );
-}
-
-std::list<std::string> FileWatcherWin32::directories() {
-        std::list<std::string> dirs;
-
-        Lock lock( mWatchesLock );
-
-        for ( Watches::iterator it = mWatches.begin(); it != mWatches.end(); ++it ) {
-                dirs.push_back( std::string( ( *it )->Watch->DirName ) );
-        }
-
-        return dirs;
-}
-
-bool FileWatcherWin32::pathInWatches( const std::string& path ) {
-        Lock lock( mWatchesLock );
-
-        for ( Watches::iterator it = mWatches.begin(); it != mWatches.end(); ++it ) {
-                if ( ( *it )->Watch->DirName == path ) {
-                        return true;
-                }
-        }
-
-        return false;
-}
-
-} // namespace efsw
-
-#endif
+#include <efsw/FileSystem.hpp>

+#include <efsw/FileWatcherWin32.hpp>

+#include <efsw/Lock.hpp>

+#include <efsw/String.hpp>

+#include <efsw/System.hpp>

+

+#if EFSW_PLATFORM == EFSW_PLATFORM_WIN32

+

+namespace efsw {

+

+FileWatcherWin32::FileWatcherWin32( FileWatcher* parent ) :

+        FileWatcherImpl( parent ), mLastWatchID( 0 ), mThread( NULL ) {

+        mIOCP = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 1 );

+        if ( mIOCP && mIOCP != INVALID_HANDLE_VALUE )

+                mInitOK = true;

+}

+

+FileWatcherWin32::~FileWatcherWin32() {

+        mInitOK = false;

+

+        if ( mIOCP && mIOCP != INVALID_HANDLE_VALUE ) {

+                PostQueuedCompletionStatus( mIOCP, 0, reinterpret_cast<ULONG_PTR>( this ), NULL );

+        }

+

+        efSAFE_DELETE( mThread );

+

+        removeAllWatches();

+

+        if ( mIOCP )

+                CloseHandle( mIOCP );

+}

+

+WatchID FileWatcherWin32::addWatch( const std::string& directory, FileWatchListener* watcher,

+                                                                        bool recursive, const std::vector<WatcherOption> &options ) {

+        std::string dir( directory );

+

+        FileInfo fi( dir );

+

+        if ( !fi.isDirectory() ) {

+                return Errors::Log::createLastError( Errors::FileNotFound, dir );

+        } else if ( !fi.isReadable() ) {

+                return Errors::Log::createLastError( Errors::FileNotReadable, dir );

+        }

+

+        FileSystem::dirAddSlashAtEnd( dir );

+

+        Lock lock( mWatchesLock );

+

+        if ( pathInWatches( dir ) ) {

+                return Errors::Log::createLastError( Errors::FileRepeated, dir );

+        }

+

+        WatchID watchid = ++mLastWatchID;

+

+        DWORD bufferSize = static_cast<DWORD>( getOptionValue(options, Option::WinBufferSize, 63 * 1024) );

+        DWORD notifyFilter = static_cast<DWORD>( getOptionValue(options, Option::WinNotifyFilter,

+                FILE_NOTIFY_CHANGE_CREATION | FILE_NOTIFY_CHANGE_LAST_WRITE |

+                FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME |

+                FILE_NOTIFY_CHANGE_SIZE) );

+

+        WatcherStructWin32* watch = CreateWatch( String::fromUtf8( dir ).toWideString().c_str(),

+                                                                                         recursive, bufferSize, notifyFilter, mIOCP );

+

+        if ( NULL == watch ) {

+                return Errors::Log::createLastError( Errors::FileNotFound, dir );

+        }

+

+        // Add the handle to the handles vector

+        watch->Watch->ID = watchid;

+        watch->Watch->Watch = this;

+        watch->Watch->Listener = watcher;

+        watch->Watch->DirName = new char[dir.length() + 1];

+        strcpy( watch->Watch->DirName, dir.c_str() );

+

+        mWatches.insert( watch );

+

+        return watchid;

+}

+

+void FileWatcherWin32::removeWatch( const std::string& directory ) {

+        Lock lock( mWatchesLock );

+

+        Watches::iterator iter = mWatches.begin();

+

+        for ( ; iter != mWatches.end(); ++iter ) {

+                if ( directory == ( *iter )->Watch->DirName ) {

+                        removeWatch( *iter );

+                        break;

+                }

+        }

+}

+

+void FileWatcherWin32::removeWatch( WatchID watchid ) {

+        Lock lock( mWatchesLock );

+

+        Watches::iterator iter = mWatches.begin();

+

+        for ( ; iter != mWatches.end(); ++iter ) {

+                // Find the watch ID

+                if ( ( *iter )->Watch->ID == watchid ) {

+                        removeWatch( *iter );

+                        return;

+                }

+        }

+}

+

+void FileWatcherWin32::removeWatch( WatcherStructWin32* watch ) {

+        Lock lock( mWatchesLock );

+

+        DestroyWatch( watch );

+        mWatches.erase( watch );

+}

+

+void FileWatcherWin32::watch() {

+        if ( NULL == mThread ) {

+                mThread = new Thread( &FileWatcherWin32::run, this );

+                mThread->launch();

+        }

+}

+

+void FileWatcherWin32::removeAllWatches() {

+        Lock lock( mWatchesLock );

+

+        Watches::iterator iter = mWatches.begin();

+

+        for ( ; iter != mWatches.end(); ++iter ) {

+                DestroyWatch( ( *iter ) );

+        }

+

+        mWatches.clear();

+}

+

+void FileWatcherWin32::run() {

+        do {

+                if ( mInitOK && !mWatches.empty() ) {

+                        DWORD numOfBytes = 0;

+                        OVERLAPPED* ov = NULL;

+                        ULONG_PTR compKey = 0;

+                        BOOL res = FALSE;

+

+                        while ( ( res = GetQueuedCompletionStatus( mIOCP, &numOfBytes, &compKey, &ov,

+                                                                                                           INFINITE ) ) != FALSE ) {

+                                if ( compKey != 0 && compKey == reinterpret_cast<ULONG_PTR>( this ) ) {

+                                        break;

+                                } else {

+                                        Lock lock( mWatchesLock );

+                                        if (mWatches.find( (WatcherStructWin32*)ov ) != mWatches.end())

+                                                WatchCallback( numOfBytes, ov );

+                                }

+                        }

+                } else {

+                        System::sleep( 10 );

+                }

+        } while ( mInitOK );

+

+        removeAllWatches();

+}

+

+void FileWatcherWin32::handleAction( Watcher* watch, const std::string& filename,

+                                                                         unsigned long action, std::string /*oldFilename*/ ) {

+        Action fwAction;

+

+        switch ( action ) {

+                case FILE_ACTION_RENAMED_OLD_NAME:

+                        watch->OldFileName = filename;

+                        return;

+                case FILE_ACTION_ADDED:

+                        fwAction = Actions::Add;

+                        break;

+                case FILE_ACTION_RENAMED_NEW_NAME: {

+                        fwAction = Actions::Moved;

+

+                        std::string fpath( watch->Directory + filename );

+

+                        // Update the directory path

+                        if ( watch->Recursive && FileSystem::isDirectory( fpath ) ) {

+                                // Update the new directory path

+                                std::string opath( watch->Directory + watch->OldFileName );

+                                FileSystem::dirAddSlashAtEnd( opath );

+                                FileSystem::dirAddSlashAtEnd( fpath );

+

+                                for ( Watches::iterator it = mWatches.begin(); it != mWatches.end(); ++it ) {

+                                        if ( ( *it )->Watch->Directory == opath ) {

+                                                ( *it )->Watch->Directory = fpath;

+

+                                                break;

+                                        }

+                                }

+                        }

+

+                        std::string folderPath( static_cast<WatcherWin32*>( watch )->DirName );

+                        std::string realFilename = filename;

+                        std::size_t sepPos = filename.find_last_of( "/\\" );

+                        std::string oldFolderPath =

+                                static_cast<WatcherWin32*>( watch )->DirName +

+                                watch->OldFileName.substr( 0, watch->OldFileName.find_last_of( "/\\" ) );

+

+                        if ( sepPos != std::string::npos ) {

+                                folderPath +=

+                                        filename.substr( 0, sepPos + 1 < filename.size() ? sepPos + 1 : sepPos );

+                                realFilename = filename.substr( sepPos + 1 );

+                        }

+

+                        if ( folderPath == oldFolderPath ) {

+                                watch->Listener->handleFileAction(

+                                        watch->ID, folderPath, realFilename, fwAction,

+                                        FileSystem::fileNameFromPath( watch->OldFileName ) );

+                        } else {

+                                watch->Listener->handleFileAction( watch->ID,

+                                                                                                   static_cast<WatcherWin32*>( watch )->DirName,

+                                                                                                   filename, fwAction, watch->OldFileName );

+                        }

+                        return;

+                }

+                case FILE_ACTION_REMOVED:

+                        fwAction = Actions::Delete;

+                        break;

+                case FILE_ACTION_MODIFIED:

+                        fwAction = Actions::Modified;

+                        break;

+                default:

+                        return;

+        };

+

+        std::string folderPath( static_cast<WatcherWin32*>( watch )->DirName );

+        std::string realFilename = filename;

+        std::size_t sepPos = filename.find_last_of( "/\\" );

+

+        if ( sepPos != std::string::npos ) {

+                folderPath += filename.substr( 0, sepPos + 1 < filename.size() ? sepPos + 1 : sepPos );

+                realFilename = filename.substr( sepPos + 1 );

+        }

+

+        FileSystem::dirAddSlashAtEnd( folderPath );

+

+        watch->Listener->handleFileAction( watch->ID, folderPath, realFilename, fwAction );

+}

+

+std::vector<std::string> FileWatcherWin32::directories() {

+        std::vector<std::string> dirs;

+

+        Lock lock( mWatchesLock );

+

+        dirs.reserve( mWatches.size() );

+

+        for ( Watches::iterator it = mWatches.begin(); it != mWatches.end(); ++it ) {

+                dirs.push_back( std::string( ( *it )->Watch->DirName ) );

+        }

+

+        return dirs;

+}

+

+bool FileWatcherWin32::pathInWatches( const std::string& path ) {

+        Lock lock( mWatchesLock );

+

+        for ( Watches::iterator it = mWatches.begin(); it != mWatches.end(); ++it ) {

+                if ( ( *it )->Watch->DirName == path ) {

+                        return true;

+                }

+        }

+

+        return false;

+}

+

+} // namespace efsw

+

+#endif

diff --git a/src/3rdParty/efsw/FileWatcherWin32.hpp b/src/3rdParty/efsw/FileWatcherWin32.hpp
index 94439cf..3016aac 100755..100644
--- a/src/3rdParty/efsw/FileWatcherWin32.hpp
+++ b/src/3rdParty/efsw/FileWatcherWin32.hpp
@@ -1,70 +1,71 @@
-#ifndef EFSW_FILEWATCHERWIN32_HPP
-#define EFSW_FILEWATCHERWIN32_HPP
-
-#include <efsw/base.hpp>
-
-#if EFSW_PLATFORM == EFSW_PLATFORM_WIN32
-
-#include <efsw/WatcherWin32.hpp>
-#include <map>
-#include <set>
-#include <vector>
-
-namespace efsw {
-
-/// Implementation for Win32 based on ReadDirectoryChangesW.
-/// @class FileWatcherWin32
-class FileWatcherWin32 : public FileWatcherImpl {
-  public:
-        /// type for a map from WatchID to WatcherWin32 pointer
-        typedef std::set<WatcherStructWin32*> Watches;
-
-        FileWatcherWin32( FileWatcher* parent );
-
-        virtual ~FileWatcherWin32();
-
-        /// Add a directory watch
-        /// On error returns WatchID with Error type.
-        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive );
-
-        /// Remove a directory watch. This is a brute force lazy search O(nlogn).
-        void removeWatch( const std::string& directory );
-
-        /// Remove a directory watch. This is a map lookup O(logn).
-        void removeWatch( WatchID watchid );
-
-        /// Updates the watcher. Must be called often.
-        void watch();
-
-        /// Handles the action
-        void handleAction( Watcher* watch, const std::string& filename, unsigned long action,
-                                           std::string oldFilename = "" );
-
-        /// @return Returns a list of the directories that are being watched
-        std::list<std::string> directories();
-
-  protected:
-        HANDLE mIOCP;
-        Watches mWatches;
-
-        /// The last watchid
-        WatchID mLastWatchID;
-        Thread* mThread;
-        Mutex mWatchesLock;
-
-        bool pathInWatches( const std::string& path );
-
-        /// Remove all directory watches.
-        void removeAllWatches();
-
-        void removeWatch( WatcherStructWin32* watch );
-
-  private:
-        void run();
-};
-
-} // namespace efsw
-
-#endif
-
-#endif
+#ifndef EFSW_FILEWATCHERWIN32_HPP

+#define EFSW_FILEWATCHERWIN32_HPP

+

+#include <efsw/base.hpp>

+

+#if EFSW_PLATFORM == EFSW_PLATFORM_WIN32

+

+#include <efsw/WatcherWin32.hpp>

+#include <map>

+#include <unordered_set>

+#include <vector>

+

+namespace efsw {

+

+/// Implementation for Win32 based on ReadDirectoryChangesW.

+/// @class FileWatcherWin32

+class FileWatcherWin32 : public FileWatcherImpl {

+  public:

+        /// type for a map from WatchID to WatcherWin32 pointer

+        typedef std::unordered_set<WatcherStructWin32*> Watches;

+

+        FileWatcherWin32( FileWatcher* parent );

+

+        virtual ~FileWatcherWin32();

+

+        /// Add a directory watch

+        /// On error returns WatchID with Error type.

+        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive,

+                                          const std::vector<WatcherOption> &options ) override;

+

+        /// Remove a directory watch. This is a brute force lazy search O(nlogn).

+        void removeWatch( const std::string& directory ) override;

+

+        /// Remove a directory watch. This is a map lookup O(logn).

+        void removeWatch( WatchID watchid ) override;

+

+        /// Updates the watcher. Must be called often.

+        void watch() override;

+

+        /// Handles the action

+        void handleAction( Watcher* watch, const std::string& filename, unsigned long action,

+                                           std::string oldFilename = "" ) override;

+

+        /// @return Returns a list of the directories that are being watched

+        std::vector<std::string> directories() override;

+

+  protected:

+        HANDLE mIOCP;

+        Watches mWatches;

+

+        /// The last watchid

+        WatchID mLastWatchID;

+        Thread* mThread;

+        Mutex mWatchesLock;

+

+        bool pathInWatches( const std::string& path ) override;

+

+        /// Remove all directory watches.

+        void removeAllWatches();

+

+        void removeWatch( WatcherStructWin32* watch );

+

+  private:

+        void run();

+};

+

+} // namespace efsw

+

+#endif

+

+#endif

diff --git a/src/3rdParty/efsw/LICENSE b/src/3rdParty/efsw/LICENSE
index 37f354a..37f354a 100755..100644
--- a/src/3rdParty/efsw/LICENSE
+++ b/src/3rdParty/efsw/LICENSE
diff --git a/src/3rdParty/efsw/Lock.hpp b/src/3rdParty/efsw/Lock.hpp
index e8c522a..e8c522a 100755..100644
--- a/src/3rdParty/efsw/Lock.hpp
+++ b/src/3rdParty/efsw/Lock.hpp
diff --git a/src/3rdParty/efsw/Log.cpp b/src/3rdParty/efsw/Log.cpp
index ddf7a62..6f32df7 100755..100644
--- a/src/3rdParty/efsw/Log.cpp
+++ b/src/3rdParty/efsw/Log.cpp
@@ -1,20 +1,31 @@
 #include <efsw/efsw.hpp>
+#include <efsw/Debug.hpp>
 
 namespace efsw { namespace Errors {
 
-static std::string LastError;
+static std::string LastError = "";
+static Error LastErrorCode = NoError;
 
 std::string Log::getLastErrorLog() {
         return LastError;
 }
 
+Error Log::getLastErrorCode() {
+        return LastErrorCode;
+}
+
+void Log::clearLastError() {
+        LastErrorCode = NoError;
+        LastError = "";
+}
+
 Error Log::createLastError( Error err, std::string log ) {
         switch ( err ) {
                 case FileNotFound:
                         LastError = "File not found ( " + log + " )";
                         break;
                 case FileRepeated:
-                        LastError = "File reapeated in watches ( " + log + " )";
+                        LastError = "File repeated in watches ( " + log + " )";
                         break;
                 case FileOutOfScope:
                         LastError = "Symlink file out of scope ( " + log + " )";
@@ -23,11 +34,15 @@ Error Log::createLastError( Error err, std::string log ) {
                         LastError =
                                 "File is located in a remote file system, use a generic watcher. ( " + log + " )";
                         break;
+                case WatcherFailed:
+                        LastError = "File system watcher failed ( " + log + " )";
+                        break;
                 case Unspecified:
                 default:
                         LastError = log;
         }
 
+        efDEBUG( "%s\n", LastError.c_str() );
         return err;
 }
 
diff --git a/src/3rdParty/efsw/Mutex.cpp b/src/3rdParty/efsw/Mutex.cpp
index c961db1..c961db1 100755..100644
--- a/src/3rdParty/efsw/Mutex.cpp
+++ b/src/3rdParty/efsw/Mutex.cpp
diff --git a/src/3rdParty/efsw/Mutex.hpp b/src/3rdParty/efsw/Mutex.hpp
index d98ad17..d98ad17 100755..100644
--- a/src/3rdParty/efsw/Mutex.hpp
+++ b/src/3rdParty/efsw/Mutex.hpp
diff --git a/src/3rdParty/efsw/String.cpp b/src/3rdParty/efsw/String.cpp
index e3ba68f..e3ba68f 100755..100644
--- a/src/3rdParty/efsw/String.cpp
+++ b/src/3rdParty/efsw/String.cpp
diff --git a/src/3rdParty/efsw/String.hpp b/src/3rdParty/efsw/String.hpp
index 65bce33..b42b945 100755..100644
--- a/src/3rdParty/efsw/String.hpp
+++ b/src/3rdParty/efsw/String.hpp
@@ -11,7 +11,6 @@
 #include <cstdlib>
 #include <cstring>
 #include <efsw/base.hpp>
-#include <fstream>
 #include <iostream>
 #include <locale>
 #include <sstream>
@@ -24,7 +23,7 @@ namespace efsw {
  * **/
 class String {
   public:
-        typedef Uint32 StringBaseType;
+        typedef char32_t StringBaseType;
         typedef std::basic_string<StringBaseType> StringType;
         typedef StringType::iterator Iterator;                                                   //! Iterator type
         typedef StringType::const_iterator ConstIterator;                                //! Constant iterator type
diff --git a/src/3rdParty/efsw/System.cpp b/src/3rdParty/efsw/System.cpp
index ba68bf4..ba68bf4 100755..100644
--- a/src/3rdParty/efsw/System.cpp
+++ b/src/3rdParty/efsw/System.cpp
diff --git a/src/3rdParty/efsw/System.hpp b/src/3rdParty/efsw/System.hpp
index 498e121..498e121 100755..100644
--- a/src/3rdParty/efsw/System.hpp
+++ b/src/3rdParty/efsw/System.hpp
diff --git a/src/3rdParty/efsw/Thread.cpp b/src/3rdParty/efsw/Thread.cpp
index e3f0fa0..cfa88b4 100755..100644
--- a/src/3rdParty/efsw/Thread.cpp
+++ b/src/3rdParty/efsw/Thread.cpp
@@ -34,7 +34,8 @@ void Thread::terminate() {
 }
 
 void Thread::run() {
-        mEntryPoint->run();
+        if ( mEntryPoint )
+                mEntryPoint->run();
 }
 
 } // namespace efsw
diff --git a/src/3rdParty/efsw/Thread.hpp b/src/3rdParty/efsw/Thread.hpp
index b60373c..b60373c 100755..100644
--- a/src/3rdParty/efsw/Thread.hpp
+++ b/src/3rdParty/efsw/Thread.hpp
diff --git a/src/3rdParty/efsw/Utf.hpp b/src/3rdParty/efsw/Utf.hpp
index 6e9ea71..1b042cd 100755..100644
--- a/src/3rdParty/efsw/Utf.hpp
+++ b/src/3rdParty/efsw/Utf.hpp
@@ -1,721 +1,721 @@
-/** NOTE:
- *      This code is based on the Utf implementation from SFML2. License zlib/png (
- *http://www.sfml-dev.org/license.php ) The class was modified to fit efsw own needs. This is not
- *the original implementation from SFML2.
- * */
-
-#ifndef EFSW_UTF_HPP
-#define EFSW_UTF_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <cstdlib>
-#include <efsw/base.hpp>
-#include <locale>
-#include <string>
-
-namespace efsw {
-
-template <unsigned int N> class Utf;
-
-////////////////////////////////////////////////////////////
-/// \brief Specialization of the Utf template for UTF-8
-///
-////////////////////////////////////////////////////////////
-template <> class Utf<8> {
-  public:
-        ////////////////////////////////////////////////////////////
-        /// \brief Decode a single UTF-8 character
-        ///
-        /// Decoding a character means finding its unique 32-bits
-        /// code (called the codepoint) in the Unicode standard.
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Codepoint of the decoded UTF-8 character
-        /// \param replacement Replacement character to use in case the UTF-8 sequence is invalid
-        ///
-        /// \return Iterator pointing to one past the last read element of the input sequence
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In>
-        static In Decode( In begin, In end, Uint32& output, Uint32 replacement = 0 );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Encode a single UTF-8 character
-        ///
-        /// Encoding a character means converting a unique 32-bits
-        /// code (called the codepoint) in the target encoding, UTF-8.
-        ///
-        /// \param input       Codepoint to encode as UTF-8
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to UTF-8 (use 0 to skip them)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename Out> static Out Encode( Uint32 input, Out output, Uint8 replacement = 0 );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Advance to the next UTF-8 character
-        ///
-        /// This function is necessary for multi-elements encodings, as
-        /// a single character may use more than 1 storage element.
-        ///
-        /// \param begin Iterator pointing to the beginning of the input sequence
-        /// \param end   Iterator pointing to the end of the input sequence
-        ///
-        /// \return Iterator pointing to one past the last read element of the input sequence
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In> static In Next( In begin, In end );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Count the number of characters of a UTF-8 sequence
-        ///
-        /// This function is necessary for multi-elements encodings, as
-        /// a single character may use more than 1 storage element, thus the
-        /// total size can be different from (begin - end).
-        ///
-        /// \param begin Iterator pointing to the beginning of the input sequence
-        /// \param end   Iterator pointing to the end of the input sequence
-        ///
-        /// \return Iterator pointing to one past the last read element of the input sequence
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In> static std::size_t Count( In begin, In end );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an ANSI characters range to UTF-8
-        ///
-        /// The current global locale will be used by default, unless you
-        /// pass a custom one in the \a locale parameter.
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        /// \param locale Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out FromAnsi( In begin, In end, Out output, const std::locale& locale = std::locale() );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a wide characters range to UTF-8
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out FromWide( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a latin-1 (ISO-5589-1) characters range to UTF-8
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        /// \param locale Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out FromLatin1( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an UTF-8 characters range to ANSI characters
-        ///
-        /// The current global locale will be used by default, unless you
-        /// pass a custom one in the \a locale parameter.
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to ANSI (use 0 to skip them)
-        /// \param locale      Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out ToAnsi( In begin, In end, Out output, char replacement = 0,
-                                           const std::locale& locale = std::locale() );
-
-#ifndef EFSW_NO_WIDECHAR
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an UTF-8 characters range to wide characters
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out ToWide( In begin, In end, Out output, wchar_t replacement = 0 );
-#endif
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an UTF-8 characters range to latin-1 (ISO-5589-1) characters
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out ToLatin1( In begin, In end, Out output, char replacement = 0 );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a UTF-8 characters range to UTF-8
-        ///
-        /// This functions does nothing more than a direct copy;
-        /// it is defined only to provide the same interface as other
-        /// specializations of the efsw::Utf<> template, and allow
-        /// generic code to be written on top of it.
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out toUtf8( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a UTF-8 characters range to UTF-16
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out ToUtf16( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a UTF-8 characters range to UTF-32
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out ToUtf32( In begin, In end, Out output );
-};
-
-////////////////////////////////////////////////////////////
-/// \brief Specialization of the Utf template for UTF-16
-///
-////////////////////////////////////////////////////////////
-template <> class Utf<16> {
-  public:
-        ////////////////////////////////////////////////////////////
-        /// \brief Decode a single UTF-16 character
-        ///
-        /// Decoding a character means finding its unique 32-bits
-        /// code (called the codepoint) in the Unicode standard.
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Codepoint of the decoded UTF-16 character
-        /// \param replacement Replacement character to use in case the UTF-8 sequence is invalid
-        ///
-        /// \return Iterator pointing to one past the last read element of the input sequence
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In>
-        static In Decode( In begin, In end, Uint32& output, Uint32 replacement = 0 );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Encode a single UTF-16 character
-        ///
-        /// Encoding a character means converting a unique 32-bits
-        /// code (called the codepoint) in the target encoding, UTF-16.
-        ///
-        /// \param input       Codepoint to encode as UTF-16
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to UTF-16 (use 0 to skip them)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename Out> static Out Encode( Uint32 input, Out output, Uint16 replacement = 0 );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Advance to the next UTF-16 character
-        ///
-        /// This function is necessary for multi-elements encodings, as
-        /// a single character may use more than 1 storage element.
-        ///
-        /// \param begin Iterator pointing to the beginning of the input sequence
-        /// \param end   Iterator pointing to the end of the input sequence
-        ///
-        /// \return Iterator pointing to one past the last read element of the input sequence
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In> static In Next( In begin, In end );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Count the number of characters of a UTF-16 sequence
-        ///
-        /// This function is necessary for multi-elements encodings, as
-        /// a single character may use more than 1 storage element, thus the
-        /// total size can be different from (begin - end).
-        ///
-        /// \param begin Iterator pointing to the beginning of the input sequence
-        /// \param end   Iterator pointing to the end of the input sequence
-        ///
-        /// \return Iterator pointing to one past the last read element of the input sequence
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In> static std::size_t Count( In begin, In end );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an ANSI characters range to UTF-16
-        ///
-        /// The current global locale will be used by default, unless you
-        /// pass a custom one in the \a locale parameter.
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        /// \param locale Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out FromAnsi( In begin, In end, Out output, const std::locale& locale = std::locale() );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a wide characters range to UTF-16
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out FromWide( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a latin-1 (ISO-5589-1) characters range to UTF-16
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        /// \param locale Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out FromLatin1( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an UTF-16 characters range to ANSI characters
-        ///
-        /// The current global locale will be used by default, unless you
-        /// pass a custom one in the \a locale parameter.
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to ANSI (use 0 to skip them)
-        /// \param locale      Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out ToAnsi( In begin, In end, Out output, char replacement = 0,
-                                           const std::locale& locale = std::locale() );
-
-#ifndef EFSW_NO_WIDECHAR
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an UTF-16 characters range to wide characters
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out ToWide( In begin, In end, Out output, wchar_t replacement = 0 );
-#endif
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out ToLatin1( In begin, In end, Out output, char replacement = 0 );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a UTF-16 characters range to UTF-8
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out toUtf8( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a UTF-16 characters range to UTF-16
-        ///
-        /// This functions does nothing more than a direct copy;
-        /// it is defined only to provide the same interface as other
-        /// specializations of the efsw::Utf<> template, and allow
-        /// generic code to be written on top of it.
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out ToUtf16( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a UTF-16 characters range to UTF-32
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out ToUtf32( In begin, In end, Out output );
-};
-
-////////////////////////////////////////////////////////////
-/// \brief Specialization of the Utf template for UTF-32
-///
-////////////////////////////////////////////////////////////
-template <> class Utf<32> {
-  public:
-        ////////////////////////////////////////////////////////////
-        /// \brief Decode a single UTF-32 character
-        ///
-        /// Decoding a character means finding its unique 32-bits
-        /// code (called the codepoint) in the Unicode standard.
-        /// For UTF-32, the character value is the same as the codepoint.
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Codepoint of the decoded UTF-32 character
-        /// \param replacement Replacement character to use in case the UTF-8 sequence is invalid
-        ///
-        /// \return Iterator pointing to one past the last read element of the input sequence
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In>
-        static In Decode( In begin, In end, Uint32& output, Uint32 replacement = 0 );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Encode a single UTF-32 character
-        ///
-        /// Encoding a character means converting a unique 32-bits
-        /// code (called the codepoint) in the target encoding, UTF-32.
-        /// For UTF-32, the codepoint is the same as the character value.
-        ///
-        /// \param input       Codepoint to encode as UTF-32
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to UTF-32 (use 0 to skip them)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename Out> static Out Encode( Uint32 input, Out output, Uint32 replacement = 0 );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Advance to the next UTF-32 character
-        ///
-        /// This function is trivial for UTF-32, which can store
-        /// every character in a single storage element.
-        ///
-        /// \param begin Iterator pointing to the beginning of the input sequence
-        /// \param end   Iterator pointing to the end of the input sequence
-        ///
-        /// \return Iterator pointing to one past the last read element of the input sequence
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In> static In Next( In begin, In end );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Count the number of characters of a UTF-32 sequence
-        ///
-        /// This function is trivial for UTF-32, which can store
-        /// every character in a single storage element.
-        ///
-        /// \param begin Iterator pointing to the beginning of the input sequence
-        /// \param end   Iterator pointing to the end of the input sequence
-        ///
-        /// \return Iterator pointing to one past the last read element of the input sequence
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In> static std::size_t Count( In begin, In end );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an ANSI characters range to UTF-32
-        ///
-        /// The current global locale will be used by default, unless you
-        /// pass a custom one in the \a locale parameter.
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        /// \param locale Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out FromAnsi( In begin, In end, Out output, const std::locale& locale = std::locale() );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a wide characters range to UTF-32
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out FromWide( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a latin-1 (ISO-5589-1) characters range to UTF-32
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        /// \param locale Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out FromLatin1( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an UTF-32 characters range to ANSI characters
-        ///
-        /// The current global locale will be used by default, unless you
-        /// pass a custom one in the \a locale parameter.
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to ANSI (use 0 to skip them)
-        /// \param locale      Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out ToAnsi( In begin, In end, Out output, char replacement = 0,
-                                           const std::locale& locale = std::locale() );
-
-#ifndef EFSW_NO_WIDECHAR
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an UTF-32 characters range to wide characters
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out ToWide( In begin, In end, Out output, wchar_t replacement = 0 );
-#endif
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters
-        ///
-        /// \param begin       Iterator pointing to the beginning of the input sequence
-        /// \param end         Iterator pointing to the end of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out>
-        static Out ToLatin1( In begin, In end, Out output, char replacement = 0 );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a UTF-32 characters range to UTF-8
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out toUtf8( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a UTF-32 characters range to UTF-16
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out ToUtf16( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Convert a UTF-32 characters range to UTF-32
-        ///
-        /// This functions does nothing more than a direct copy;
-        /// it is defined only to provide the same interface as other
-        /// specializations of the efsw::Utf<> template, and allow
-        /// generic code to be written on top of it.
-        ///
-        /// \param begin  Iterator pointing to the beginning of the input sequence
-        /// \param end    Iterator pointing to the end of the input sequence
-        /// \param output Iterator pointing to the beginning of the output sequence
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In, typename Out> static Out ToUtf32( In begin, In end, Out output );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Decode a single ANSI character to UTF-32
-        ///
-        /// This function does not exist in other specializations
-        /// of efsw::Utf<>, it is defined for convenience (it is used by
-        /// several other conversion functions).
-        ///
-        /// \param input  Input ANSI character
-        /// \param locale Locale to use for conversion
-        ///
-        /// \return Converted character
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In>
-        static Uint32 DecodeAnsi( In input, const std::locale& locale = std::locale() );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Decode a single wide character to UTF-32
-        ///
-        /// This function does not exist in other specializations
-        /// of efsw::Utf<>, it is defined for convenience (it is used by
-        /// several other conversion functions).
-        ///
-        /// \param input Input wide character
-        ///
-        /// \return Converted character
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename In> static Uint32 DecodeWide( In input );
-
-        ////////////////////////////////////////////////////////////
-        /// \brief Encode a single UTF-32 character to ANSI
-        ///
-        /// This function does not exist in other specializations
-        /// of efsw::Utf<>, it is defined for convenience (it is used by
-        /// several other conversion functions).
-        ///
-        /// \param codepoint   Iterator pointing to the beginning of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement if the input character is not convertible to ANSI (use 0 to
-        /// skip it) \param locale      Locale to use for conversion
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename Out>
-        static Out EncodeAnsi( Uint32 codepoint, Out output, char replacement = 0,
-                                                   const std::locale& locale = std::locale() );
-
-#ifndef EFSW_NO_WIDECHAR
-        ////////////////////////////////////////////////////////////
-        /// \brief Encode a single UTF-32 character to wide
-        ///
-        /// This function does not exist in other specializations
-        /// of efsw::Utf<>, it is defined for convenience (it is used by
-        /// several other conversion functions).
-        ///
-        /// \param codepoint   Iterator pointing to the beginning of the input sequence
-        /// \param output      Iterator pointing to the beginning of the output sequence
-        /// \param replacement Replacement if the input character is not convertible to wide (use 0 to
-        /// skip it)
-        ///
-        /// \return Iterator to the end of the output sequence which has been written
-        ///
-        ////////////////////////////////////////////////////////////
-        template <typename Out>
-        static Out EncodeWide( Uint32 codepoint, Out output, wchar_t replacement = 0 );
-#endif
-};
-
-#include "Utf.inl"
-
-// Make typedefs to get rid of the template syntax
-typedef Utf<8> Utf8;
-typedef Utf<16> Utf16;
-typedef Utf<32> Utf32;
-
-} // namespace efsw
-#endif
-
-////////////////////////////////////////////////////////////
-/// \class efsw::Utf
-/// \ingroup system
-///
-/// Utility class providing generic functions for UTF conversions.
-///
-/// efsw::Utf is a low-level, generic interface for counting, iterating,
-/// encoding and decoding Unicode characters and strings. It is able
-/// to handle ANSI, wide, UTF-8, UTF-16 and UTF-32 encodings.
-///
-/// efsw::Utf<X> functions are all static, these classes are not meant to
-/// be instanciated. All the functions are template, so that you
-/// can use any character / string type for a given encoding.
-///
-/// It has 3 specializations:
-/// \li efsw::Utf<8> (typedef'd to efsw::Utf8)
-/// \li efsw::Utf<16> (typedef'd to efsw::Utf16)
-/// \li efsw::Utf<32> (typedef'd to efsw::Utf32)
-///
-////////////////////////////////////////////////////////////
+/** NOTE:

+ *      This code is based on the Utf implementation from SFML2. License zlib/png (

+ *http://www.sfml-dev.org/license.php ) The class was modified to fit efsw own needs. This is not

+ *the original implementation from SFML2.

+ * */

+

+#ifndef EFSW_UTF_HPP

+#define EFSW_UTF_HPP

+

+////////////////////////////////////////////////////////////

+// Headers

+////////////////////////////////////////////////////////////

+#include <cstdlib>

+#include <efsw/base.hpp>

+#include <locale>

+#include <string>

+

+namespace efsw {

+

+template <unsigned int N> class Utf;

+

+////////////////////////////////////////////////////////////

+/// \brief Specialization of the Utf template for UTF-8

+///

+////////////////////////////////////////////////////////////

+template <> class Utf<8> {

+  public:

+        ////////////////////////////////////////////////////////////

+        /// \brief Decode a single UTF-8 character

+        ///

+        /// Decoding a character means finding its unique 32-bits

+        /// code (called the codepoint) in the Unicode standard.

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Codepoint of the decoded UTF-8 character

+        /// \param replacement Replacement character to use in case the UTF-8 sequence is invalid

+        ///

+        /// \return Iterator pointing to one past the last read element of the input sequence

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In>

+        static In Decode( In begin, In end, Uint32& output, Uint32 replacement = 0 );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Encode a single UTF-8 character

+        ///

+        /// Encoding a character means converting a unique 32-bits

+        /// code (called the codepoint) in the target encoding, UTF-8.

+        ///

+        /// \param input       Codepoint to encode as UTF-8

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to UTF-8 (use 0 to skip them)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename Out> static Out Encode( Uint32 input, Out output, Uint8 replacement = 0 );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Advance to the next UTF-8 character

+        ///

+        /// This function is necessary for multi-elements encodings, as

+        /// a single character may use more than 1 storage element.

+        ///

+        /// \param begin Iterator pointing to the beginning of the input sequence

+        /// \param end   Iterator pointing to the end of the input sequence

+        ///

+        /// \return Iterator pointing to one past the last read element of the input sequence

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In> static In Next( In begin, In end );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Count the number of characters of a UTF-8 sequence

+        ///

+        /// This function is necessary for multi-elements encodings, as

+        /// a single character may use more than 1 storage element, thus the

+        /// total size can be different from (begin - end).

+        ///

+        /// \param begin Iterator pointing to the beginning of the input sequence

+        /// \param end   Iterator pointing to the end of the input sequence

+        ///

+        /// \return Iterator pointing to one past the last read element of the input sequence

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In> static std::size_t Count( In begin, In end );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an ANSI characters range to UTF-8

+        ///

+        /// The current global locale will be used by default, unless you

+        /// pass a custom one in the \a locale parameter.

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        /// \param locale Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out FromAnsi( In begin, In end, Out output, const std::locale& locale = std::locale() );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a wide characters range to UTF-8

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out FromWide( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a latin-1 (ISO-5589-1) characters range to UTF-8

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        /// \param locale Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out FromLatin1( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an UTF-8 characters range to ANSI characters

+        ///

+        /// The current global locale will be used by default, unless you

+        /// pass a custom one in the \a locale parameter.

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to ANSI (use 0 to skip them)

+        /// \param locale      Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out ToAnsi( In begin, In end, Out output, char replacement = 0,

+                                           const std::locale& locale = std::locale() );

+

+#ifndef EFSW_NO_WIDECHAR

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an UTF-8 characters range to wide characters

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out ToWide( In begin, In end, Out output, wchar_t replacement = 0 );

+#endif

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an UTF-8 characters range to latin-1 (ISO-5589-1) characters

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out ToLatin1( In begin, In end, Out output, char replacement = 0 );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a UTF-8 characters range to UTF-8

+        ///

+        /// This functions does nothing more than a direct copy;

+        /// it is defined only to provide the same interface as other

+        /// specializations of the efsw::Utf<> template, and allow

+        /// generic code to be written on top of it.

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out toUtf8( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a UTF-8 characters range to UTF-16

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out ToUtf16( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a UTF-8 characters range to UTF-32

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out ToUtf32( In begin, In end, Out output );

+};

+

+////////////////////////////////////////////////////////////

+/// \brief Specialization of the Utf template for UTF-16

+///

+////////////////////////////////////////////////////////////

+template <> class Utf<16> {

+  public:

+        ////////////////////////////////////////////////////////////

+        /// \brief Decode a single UTF-16 character

+        ///

+        /// Decoding a character means finding its unique 32-bits

+        /// code (called the codepoint) in the Unicode standard.

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Codepoint of the decoded UTF-16 character

+        /// \param replacement Replacement character to use in case the UTF-8 sequence is invalid

+        ///

+        /// \return Iterator pointing to one past the last read element of the input sequence

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In>

+        static In Decode( In begin, In end, Uint32& output, Uint32 replacement = 0 );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Encode a single UTF-16 character

+        ///

+        /// Encoding a character means converting a unique 32-bits

+        /// code (called the codepoint) in the target encoding, UTF-16.

+        ///

+        /// \param input       Codepoint to encode as UTF-16

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to UTF-16 (use 0 to skip them)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename Out> static Out Encode( Uint32 input, Out output, Uint16 replacement = 0 );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Advance to the next UTF-16 character

+        ///

+        /// This function is necessary for multi-elements encodings, as

+        /// a single character may use more than 1 storage element.

+        ///

+        /// \param begin Iterator pointing to the beginning of the input sequence

+        /// \param end   Iterator pointing to the end of the input sequence

+        ///

+        /// \return Iterator pointing to one past the last read element of the input sequence

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In> static In Next( In begin, In end );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Count the number of characters of a UTF-16 sequence

+        ///

+        /// This function is necessary for multi-elements encodings, as

+        /// a single character may use more than 1 storage element, thus the

+        /// total size can be different from (begin - end).

+        ///

+        /// \param begin Iterator pointing to the beginning of the input sequence

+        /// \param end   Iterator pointing to the end of the input sequence

+        ///

+        /// \return Iterator pointing to one past the last read element of the input sequence

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In> static std::size_t Count( In begin, In end );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an ANSI characters range to UTF-16

+        ///

+        /// The current global locale will be used by default, unless you

+        /// pass a custom one in the \a locale parameter.

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        /// \param locale Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out FromAnsi( In begin, In end, Out output, const std::locale& locale = std::locale() );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a wide characters range to UTF-16

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out FromWide( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a latin-1 (ISO-5589-1) characters range to UTF-16

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        /// \param locale Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out FromLatin1( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an UTF-16 characters range to ANSI characters

+        ///

+        /// The current global locale will be used by default, unless you

+        /// pass a custom one in the \a locale parameter.

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to ANSI (use 0 to skip them)

+        /// \param locale      Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out ToAnsi( In begin, In end, Out output, char replacement = 0,

+                                           const std::locale& locale = std::locale() );

+

+#ifndef EFSW_NO_WIDECHAR

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an UTF-16 characters range to wide characters

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out ToWide( In begin, In end, Out output, wchar_t replacement = 0 );

+#endif

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out ToLatin1( In begin, In end, Out output, char replacement = 0 );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a UTF-16 characters range to UTF-8

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out toUtf8( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a UTF-16 characters range to UTF-16

+        ///

+        /// This functions does nothing more than a direct copy;

+        /// it is defined only to provide the same interface as other

+        /// specializations of the efsw::Utf<> template, and allow

+        /// generic code to be written on top of it.

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out ToUtf16( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a UTF-16 characters range to UTF-32

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out ToUtf32( In begin, In end, Out output );

+};

+

+////////////////////////////////////////////////////////////

+/// \brief Specialization of the Utf template for UTF-32

+///

+////////////////////////////////////////////////////////////

+template <> class Utf<32> {

+  public:

+        ////////////////////////////////////////////////////////////

+        /// \brief Decode a single UTF-32 character

+        ///

+        /// Decoding a character means finding its unique 32-bits

+        /// code (called the codepoint) in the Unicode standard.

+        /// For UTF-32, the character value is the same as the codepoint.

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Codepoint of the decoded UTF-32 character

+        /// \param replacement Replacement character to use in case the UTF-8 sequence is invalid

+        ///

+        /// \return Iterator pointing to one past the last read element of the input sequence

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In>

+        static In Decode( In begin, In end, Uint32& output, Uint32 replacement = 0 );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Encode a single UTF-32 character

+        ///

+        /// Encoding a character means converting a unique 32-bits

+        /// code (called the codepoint) in the target encoding, UTF-32.

+        /// For UTF-32, the codepoint is the same as the character value.

+        ///

+        /// \param input       Codepoint to encode as UTF-32

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to UTF-32 (use 0 to skip them)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename Out> static Out Encode( Uint32 input, Out output, Uint32 replacement = 0 );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Advance to the next UTF-32 character

+        ///

+        /// This function is trivial for UTF-32, which can store

+        /// every character in a single storage element.

+        ///

+        /// \param begin Iterator pointing to the beginning of the input sequence

+        /// \param end   Iterator pointing to the end of the input sequence

+        ///

+        /// \return Iterator pointing to one past the last read element of the input sequence

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In> static In Next( In begin, In end );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Count the number of characters of a UTF-32 sequence

+        ///

+        /// This function is trivial for UTF-32, which can store

+        /// every character in a single storage element.

+        ///

+        /// \param begin Iterator pointing to the beginning of the input sequence

+        /// \param end   Iterator pointing to the end of the input sequence

+        ///

+        /// \return Iterator pointing to one past the last read element of the input sequence

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In> static std::size_t Count( In begin, In end );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an ANSI characters range to UTF-32

+        ///

+        /// The current global locale will be used by default, unless you

+        /// pass a custom one in the \a locale parameter.

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        /// \param locale Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out FromAnsi( In begin, In end, Out output, const std::locale& locale = std::locale() );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a wide characters range to UTF-32

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out FromWide( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a latin-1 (ISO-5589-1) characters range to UTF-32

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        /// \param locale Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out FromLatin1( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an UTF-32 characters range to ANSI characters

+        ///

+        /// The current global locale will be used by default, unless you

+        /// pass a custom one in the \a locale parameter.

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to ANSI (use 0 to skip them)

+        /// \param locale      Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out ToAnsi( In begin, In end, Out output, char replacement = 0,

+                                           const std::locale& locale = std::locale() );

+

+#ifndef EFSW_NO_WIDECHAR

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an UTF-32 characters range to wide characters

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out ToWide( In begin, In end, Out output, wchar_t replacement = 0 );

+#endif

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters

+        ///

+        /// \param begin       Iterator pointing to the beginning of the input sequence

+        /// \param end         Iterator pointing to the end of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out>

+        static Out ToLatin1( In begin, In end, Out output, char replacement = 0 );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a UTF-32 characters range to UTF-8

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out toUtf8( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a UTF-32 characters range to UTF-16

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out ToUtf16( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Convert a UTF-32 characters range to UTF-32

+        ///

+        /// This functions does nothing more than a direct copy;

+        /// it is defined only to provide the same interface as other

+        /// specializations of the efsw::Utf<> template, and allow

+        /// generic code to be written on top of it.

+        ///

+        /// \param begin  Iterator pointing to the beginning of the input sequence

+        /// \param end    Iterator pointing to the end of the input sequence

+        /// \param output Iterator pointing to the beginning of the output sequence

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In, typename Out> static Out ToUtf32( In begin, In end, Out output );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Decode a single ANSI character to UTF-32

+        ///

+        /// This function does not exist in other specializations

+        /// of efsw::Utf<>, it is defined for convenience (it is used by

+        /// several other conversion functions).

+        ///

+        /// \param input  Input ANSI character

+        /// \param locale Locale to use for conversion

+        ///

+        /// \return Converted character

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In>

+        static Uint32 DecodeAnsi( In input, const std::locale& locale = std::locale() );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Decode a single wide character to UTF-32

+        ///

+        /// This function does not exist in other specializations

+        /// of efsw::Utf<>, it is defined for convenience (it is used by

+        /// several other conversion functions).

+        ///

+        /// \param input Input wide character

+        ///

+        /// \return Converted character

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename In> static Uint32 DecodeWide( In input );

+

+        ////////////////////////////////////////////////////////////

+        /// \brief Encode a single UTF-32 character to ANSI

+        ///

+        /// This function does not exist in other specializations

+        /// of efsw::Utf<>, it is defined for convenience (it is used by

+        /// several other conversion functions).

+        ///

+        /// \param codepoint   Iterator pointing to the beginning of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement if the input character is not convertible to ANSI (use 0 to

+        /// skip it) \param locale      Locale to use for conversion

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename Out>

+        static Out EncodeAnsi( Uint32 codepoint, Out output, char replacement = 0,

+                                                   const std::locale& locale = std::locale() );

+

+#ifndef EFSW_NO_WIDECHAR

+        ////////////////////////////////////////////////////////////

+        /// \brief Encode a single UTF-32 character to wide

+        ///

+        /// This function does not exist in other specializations

+        /// of efsw::Utf<>, it is defined for convenience (it is used by

+        /// several other conversion functions).

+        ///

+        /// \param codepoint   Iterator pointing to the beginning of the input sequence

+        /// \param output      Iterator pointing to the beginning of the output sequence

+        /// \param replacement Replacement if the input character is not convertible to wide (use 0 to

+        /// skip it)

+        ///

+        /// \return Iterator to the end of the output sequence which has been written

+        ///

+        ////////////////////////////////////////////////////////////

+        template <typename Out>

+        static Out EncodeWide( Uint32 codepoint, Out output, wchar_t replacement = 0 );

+#endif

+};

+

+#include "Utf.inl"

+

+// Make typedefs to get rid of the template syntax

+typedef Utf<8> Utf8;

+typedef Utf<16> Utf16;

+typedef Utf<32> Utf32;

+

+} // namespace efsw

+#endif

+

+////////////////////////////////////////////////////////////

+/// \class efsw::Utf

+/// \ingroup system

+///

+/// Utility class providing generic functions for UTF conversions.

+///

+/// efsw::Utf is a low-level, generic interface for counting, iterating,

+/// encoding and decoding Unicode characters and strings. It is able

+/// to handle ANSI, wide, UTF-8, UTF-16 and UTF-32 encodings.

+///

+/// efsw::Utf<X> functions are all static, these classes are not meant to

+/// be instanciated. All the functions are template, so that you

+/// can use any character / string type for a given encoding.

+///

+/// It has 3 specializations:

+/// \li efsw::Utf<8> (typedef'd to efsw::Utf8)

+/// \li efsw::Utf<16> (typedef'd to efsw::Utf16)

+/// \li efsw::Utf<32> (typedef'd to efsw::Utf32)

+///

+////////////////////////////////////////////////////////////

diff --git a/src/3rdParty/efsw/Utf.inl b/src/3rdParty/efsw/Utf.inl
index 5b6c2e0..5c9d7a3 100755..100644
--- a/src/3rdParty/efsw/Utf.inl
+++ b/src/3rdParty/efsw/Utf.inl
@@ -1,576 +1,576 @@
-// References :
-// http://www.unicode.org/
-// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
-// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.h
-// http://people.w3.org/rishida/scripts/uniview/conversion
-////////////////////////////////////////////////////////////
-
-template <typename In> In Utf<8>::Decode( In begin, In end, Uint32& output, Uint32 replacement ) {
-        // Some useful precomputed data
-        static const int trailing[256] = {
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
-                2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5 };
-        static const Uint32 offsets[6] = { 0x00000000, 0x00003080, 0x000E2080,
-                                                                           0x03C82080, 0xFA082080, 0x82082080 };
-
-        // Decode the character
-        int trailingBytes = trailing[static_cast<Uint8>( *begin )];
-        if ( begin + trailingBytes < end ) {
-                output = 0;
-                switch ( trailingBytes ) {
-                        case 5:
-                                output += static_cast<Uint8>( *begin++ );
-                                output <<= 6;
-                        case 4:
-                                output += static_cast<Uint8>( *begin++ );
-                                output <<= 6;
-                        case 3:
-                                output += static_cast<Uint8>( *begin++ );
-                                output <<= 6;
-                        case 2:
-                                output += static_cast<Uint8>( *begin++ );
-                                output <<= 6;
-                        case 1:
-                                output += static_cast<Uint8>( *begin++ );
-                                output <<= 6;
-                        case 0:
-                                output += static_cast<Uint8>( *begin++ );
-                }
-                output -= offsets[trailingBytes];
-        } else {
-                // Incomplete character
-                begin = end;
-                output = replacement;
-        }
-
-        return begin;
-}
-
-template <typename Out> Out Utf<8>::Encode( Uint32 input, Out output, Uint8 replacement ) {
-        // Some useful precomputed data
-        static const Uint8 firstBytes[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-
-        // Encode the character
-        if ( ( input > 0x0010FFFF ) || ( ( input >= 0xD800 ) && ( input <= 0xDBFF ) ) ) {
-                // Invalid character
-                if ( replacement )
-                        *output++ = replacement;
-        } else {
-                // Valid character
-
-                // Get the number of bytes to write
-                int bytesToWrite = 1;
-                if ( input < 0x80 )
-                        bytesToWrite = 1;
-                else if ( input < 0x800 )
-                        bytesToWrite = 2;
-                else if ( input < 0x10000 )
-                        bytesToWrite = 3;
-                else if ( input <= 0x0010FFFF )
-                        bytesToWrite = 4;
-
-                // Extract the bytes to write
-                Uint8 bytes[4];
-                switch ( bytesToWrite ) {
-                        case 4:
-                                bytes[3] = static_cast<Uint8>( ( input | 0x80 ) & 0xBF );
-                                input >>= 6;
-                        case 3:
-                                bytes[2] = static_cast<Uint8>( ( input | 0x80 ) & 0xBF );
-                                input >>= 6;
-                        case 2:
-                                bytes[1] = static_cast<Uint8>( ( input | 0x80 ) & 0xBF );
-                                input >>= 6;
-                        case 1:
-                                bytes[0] = static_cast<Uint8>( input | firstBytes[bytesToWrite] );
-                }
-
-                // Add them to the output
-                const Uint8* currentByte = bytes;
-                switch ( bytesToWrite ) {
-                        case 4:
-                                *output++ = *currentByte++;
-                        case 3:
-                                *output++ = *currentByte++;
-                        case 2:
-                                *output++ = *currentByte++;
-                        case 1:
-                                *output++ = *currentByte++;
-                }
-        }
-
-        return output;
-}
-
-template <typename In> In Utf<8>::Next( In begin, In end ) {
-        Uint32 codepoint;
-        return Decode( begin, end, codepoint );
-}
-
-template <typename In> std::size_t Utf<8>::Count( In begin, In end ) {
-        std::size_t length = 0;
-        while ( begin < end ) {
-                begin = Next( begin, end );
-                ++length;
-        }
-
-        return length;
-}
-
-template <typename In, typename Out>
-Out Utf<8>::FromAnsi( In begin, In end, Out output, const std::locale& locale ) {
-        while ( begin < end ) {
-                Uint32 codepoint = Utf<32>::DecodeAnsi( *begin++, locale );
-                output = Encode( codepoint, output );
-        }
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<8>::FromWide( In begin, In end, Out output ) {
-        while ( begin < end ) {
-                Uint32 codepoint = Utf<32>::DecodeWide( *begin++ );
-                output = Encode( codepoint, output );
-        }
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<8>::FromLatin1( In begin, In end, Out output ) {
-        // Latin-1 is directly compatible with Unicode encodings,
-        // and can thus be treated as (a sub-range of) UTF-32
-        while ( begin < end )
-                output = Encode( *begin++, output );
-
-        return output;
-}
-
-template <typename In, typename Out>
-Out Utf<8>::ToAnsi( In begin, In end, Out output, char replacement, const std::locale& locale ) {
-        while ( begin < end ) {
-                Uint32 codepoint;
-                begin = Decode( begin, end, codepoint );
-                output = Utf<32>::EncodeAnsi( codepoint, output, replacement, locale );
-        }
-
-        return output;
-}
-
-#ifndef EFSW_NO_WIDECHAR
-template <typename In, typename Out>
-Out Utf<8>::ToWide( In begin, In end, Out output, wchar_t replacement ) {
-        while ( begin < end ) {
-                Uint32 codepoint;
-                begin = Decode( begin, end, codepoint );
-                output = Utf<32>::EncodeWide( codepoint, output, replacement );
-        }
-
-        return output;
-}
-#endif
-
-template <typename In, typename Out>
-Out Utf<8>::ToLatin1( In begin, In end, Out output, char replacement ) {
-        // Latin-1 is directly compatible with Unicode encodings,
-        // and can thus be treated as (a sub-range of) UTF-32
-        while ( begin < end ) {
-                Uint32 codepoint;
-                begin = Decode( begin, end, codepoint );
-                *output++ = codepoint < 256 ? static_cast<char>( codepoint ) : replacement;
-        }
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<8>::toUtf8( In begin, In end, Out output ) {
-        while ( begin < end )
-                *output++ = *begin++;
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<8>::ToUtf16( In begin, In end, Out output ) {
-        while ( begin < end ) {
-                Uint32 codepoint;
-                begin = Decode( begin, end, codepoint );
-                output = Utf<16>::Encode( codepoint, output );
-        }
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<8>::ToUtf32( In begin, In end, Out output ) {
-        while ( begin < end ) {
-                Uint32 codepoint;
-                begin = Decode( begin, end, codepoint );
-                *output++ = codepoint;
-        }
-
-        return output;
-}
-
-template <typename In> In Utf<16>::Decode( In begin, In end, Uint32& output, Uint32 replacement ) {
-        Uint16 first = *begin++;
-
-        // If it's a surrogate pair, first convert to a single UTF-32 character
-        if ( ( first >= 0xD800 ) && ( first <= 0xDBFF ) ) {
-                if ( begin < end ) {
-                        Uint32 second = *begin++;
-                        if ( ( second >= 0xDC00 ) && ( second <= 0xDFFF ) ) {
-                                // The second element is valid: convert the two elements to a UTF-32 character
-                                output = static_cast<Uint32>( ( ( first - 0xD800 ) << 10 ) + ( second - 0xDC00 ) +
-                                                                                          0x0010000 );
-                        } else {
-                                // Invalid character
-                                output = replacement;
-                        }
-                } else {
-                        // Invalid character
-                        begin = end;
-                        output = replacement;
-                }
-        } else {
-                // We can make a direct copy
-                output = first;
-        }
-
-        return begin;
-}
-
-template <typename Out> Out Utf<16>::Encode( Uint32 input, Out output, Uint16 replacement ) {
-        if ( input < 0xFFFF ) {
-                // The character can be copied directly, we just need to check if it's in the valid range
-                if ( ( input >= 0xD800 ) && ( input <= 0xDFFF ) ) {
-                        // Invalid character (this range is reserved)
-                        if ( replacement )
-                                *output++ = replacement;
-                } else {
-                        // Valid character directly convertible to a single UTF-16 character
-                        *output++ = static_cast<Uint16>( input );
-                }
-        } else if ( input > 0x0010FFFF ) {
-                // Invalid character (greater than the maximum unicode value)
-                if ( replacement )
-                        *output++ = replacement;
-        } else {
-                // The input character will be converted to two UTF-16 elements
-                input -= 0x0010000;
-                *output++ = static_cast<Uint16>( ( input >> 10 ) + 0xD800 );
-                *output++ = static_cast<Uint16>( ( input & 0x3FFUL ) + 0xDC00 );
-        }
-
-        return output;
-}
-
-template <typename In> In Utf<16>::Next( In begin, In end ) {
-        Uint32 codepoint;
-        return Decode( begin, end, codepoint );
-}
-
-template <typename In> std::size_t Utf<16>::Count( In begin, In end ) {
-        std::size_t length = 0;
-        while ( begin < end ) {
-                begin = Next( begin, end );
-                ++length;
-        }
-
-        return length;
-}
-
-template <typename In, typename Out>
-Out Utf<16>::FromAnsi( In begin, In end, Out output, const std::locale& locale ) {
-        while ( begin < end ) {
-                Uint32 codepoint = Utf<32>::DecodeAnsi( *begin++, locale );
-                output = Encode( codepoint, output );
-        }
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<16>::FromWide( In begin, In end, Out output ) {
-        while ( begin < end ) {
-                Uint32 codepoint = Utf<32>::DecodeWide( *begin++ );
-                output = Encode( codepoint, output );
-        }
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<16>::FromLatin1( In begin, In end, Out output ) {
-        // Latin-1 is directly compatible with Unicode encodings,
-        // and can thus be treated as (a sub-range of) UTF-32
-        while ( begin < end )
-                *output++ = *begin++;
-
-        return output;
-}
-
-template <typename In, typename Out>
-Out Utf<16>::ToAnsi( In begin, In end, Out output, char replacement, const std::locale& locale ) {
-        while ( begin < end ) {
-                Uint32 codepoint;
-                begin = Decode( begin, end, codepoint );
-                output = Utf<32>::EncodeAnsi( codepoint, output, replacement, locale );
-        }
-
-        return output;
-}
-
-#ifndef EFSW_NO_WIDECHAR
-template <typename In, typename Out>
-Out Utf<16>::ToWide( In begin, In end, Out output, wchar_t replacement ) {
-        while ( begin < end ) {
-                Uint32 codepoint;
-                begin = Decode( begin, end, codepoint );
-                output = Utf<32>::EncodeWide( codepoint, output, replacement );
-        }
-
-        return output;
-}
-#endif
-
-template <typename In, typename Out>
-Out Utf<16>::ToLatin1( In begin, In end, Out output, char replacement ) {
-        // Latin-1 is directly compatible with Unicode encodings,
-        // and can thus be treated as (a sub-range of) UTF-32
-        while ( begin < end ) {
-                *output++ = *begin < 256 ? static_cast<char>( *begin ) : replacement;
-                begin++;
-        }
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<16>::toUtf8( In begin, In end, Out output ) {
-        while ( begin < end ) {
-                Uint32 codepoint;
-                begin = Decode( begin, end, codepoint );
-                output = Utf<8>::Encode( codepoint, output );
-        }
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<16>::ToUtf16( In begin, In end, Out output ) {
-        while ( begin < end )
-                *output++ = *begin++;
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<16>::ToUtf32( In begin, In end, Out output ) {
-        while ( begin < end ) {
-                Uint32 codepoint;
-                begin = Decode( begin, end, codepoint );
-                *output++ = codepoint;
-        }
-
-        return output;
-}
-
-template <typename In> In Utf<32>::Decode( In begin, In /*end*/, Uint32& output, Uint32 ) {
-        output = *begin++;
-        return begin;
-}
-
-template <typename Out> Out Utf<32>::Encode( Uint32 input, Out output, Uint32 /*replacement*/ ) {
-        *output++ = input;
-        return output;
-}
-
-template <typename In> In Utf<32>::Next( In begin, In /*end*/ ) {
-        return ++begin;
-}
-
-template <typename In> std::size_t Utf<32>::Count( In begin, In end ) {
-        return begin - end;
-}
-
-template <typename In, typename Out>
-Out Utf<32>::FromAnsi( In begin, In end, Out output, const std::locale& locale ) {
-        while ( begin < end )
-                *output++ = DecodeAnsi( *begin++, locale );
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<32>::FromWide( In begin, In end, Out output ) {
-        while ( begin < end )
-                *output++ = DecodeWide( *begin++ );
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<32>::FromLatin1( In begin, In end, Out output ) {
-        // Latin-1 is directly compatible with Unicode encodings,
-        // and can thus be treated as (a sub-range of) UTF-32
-        while ( begin < end )
-                *output++ = *begin++;
-
-        return output;
-}
-
-template <typename In, typename Out>
-Out Utf<32>::ToAnsi( In begin, In end, Out output, char replacement, const std::locale& locale ) {
-        while ( begin < end )
-                output = EncodeAnsi( *begin++, output, replacement, locale );
-
-        return output;
-}
-
-#ifndef EFSW_NO_WIDECHAR
-template <typename In, typename Out>
-Out Utf<32>::ToWide( In begin, In end, Out output, wchar_t replacement ) {
-        while ( begin < end )
-                output = EncodeWide( *begin++, output, replacement );
-
-        return output;
-}
-#endif
-
-template <typename In, typename Out>
-Out Utf<32>::ToLatin1( In begin, In end, Out output, char replacement ) {
-        // Latin-1 is directly compatible with Unicode encodings,
-        // and can thus be treated as (a sub-range of) UTF-32
-        while ( begin < end ) {
-                *output++ = *begin < 256 ? static_cast<char>( *begin ) : replacement;
-                begin++;
-        }
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<32>::toUtf8( In begin, In end, Out output ) {
-        while ( begin < end )
-                output = Utf<8>::Encode( *begin++, output );
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<32>::ToUtf16( In begin, In end, Out output ) {
-        while ( begin < end )
-                output = Utf<16>::Encode( *begin++, output );
-
-        return output;
-}
-
-template <typename In, typename Out> Out Utf<32>::ToUtf32( In begin, In end, Out output ) {
-        while ( begin < end )
-                *output++ = *begin++;
-
-        return output;
-}
-
-template <typename In> Uint32 Utf<32>::DecodeAnsi( In input, const std::locale& locale ) {
-        // On Windows, gcc's standard library (glibc++) has almost
-        // no support for Unicode stuff. As a consequence, in this
-        // context we can only use the default locale and ignore
-        // the one passed as parameter.
-
-#if EFSW_PLATFORM == EFSW_PLATFORM_WIN && /* if Windows ... */                  \
-        ( defined( __GLIBCPP__ ) ||                                                 \
-          defined( __GLIBCXX__ ) ) && /* ... and standard library is glibc++ ... */ \
-        !( defined( __SGI_STL_PORT ) ||                                             \
-           defined( _STLPORT_VERSION ) ) /* ... and STLPort is not used on top of it */
-
-        wchar_t character = 0;
-        mbtowc( &character, &input, 1 );
-        return static_cast<Uint32>( character );
-
-#else
-// Get the facet of the locale which deals with character conversion
-#ifndef EFSW_NO_WIDECHAR
-        const std::ctype<wchar_t>& facet = std::use_facet<std::ctype<wchar_t>>( locale );
-#else
-        const std::ctype<char>& facet = std::use_facet<std::ctype<char>>( locale );
-#endif
-
-        // Use the facet to convert each character of the input string
-        return static_cast<Uint32>( facet.widen( input ) );
-
-#endif
-}
-
-template <typename In> Uint32 Utf<32>::DecodeWide( In input ) {
-        // The encoding of wide characters is not well defined and is left to the system;
-        // however we can safely assume that it is UCS-2 on Windows and
-        // UCS-4 on Unix systems.
-        // In both cases, a simple copy is enough (UCS-2 is a subset of UCS-4,
-        // and UCS-4 *is* UTF-32).
-
-        return input;
-}
-
-template <typename Out>
-Out Utf<32>::EncodeAnsi( Uint32 codepoint, Out output, char replacement,
-                                                 const std::locale& locale ) {
-        // On Windows, gcc's standard library (glibc++) has almost
-        // no support for Unicode stuff. As a consequence, in this
-        // context we can only use the default locale and ignore
-        // the one passed as parameter.
-
-#if EFSW_PLATFORM == EFSW_PLATFORM_WIN && /* if Windows ... */                  \
-        ( defined( __GLIBCPP__ ) ||                                                 \
-          defined( __GLIBCXX__ ) ) && /* ... and standard library is glibc++ ... */ \
-        !( defined( __SGI_STL_PORT ) ||                                             \
-           defined( _STLPORT_VERSION ) ) /* ... and STLPort is not used on top of it */
-
-        char character = 0;
-        if ( wctomb( &character, static_cast<wchar_t>( codepoint ) ) >= 0 )
-                *output++ = character;
-        else if ( replacement )
-                *output++ = replacement;
-
-        return output;
-
-#else
-// Get the facet of the locale which deals with character conversion
-#ifndef EFSW_NO_WIDECHAR
-        const std::ctype<wchar_t>& facet = std::use_facet<std::ctype<wchar_t>>( locale );
-#else
-        const std::ctype<char>& facet = std::use_facet<std::ctype<char>>( locale );
-#endif
-
-        // Use the facet to convert each character of the input string
-        *output++ = facet.narrow( static_cast<wchar_t>( codepoint ), replacement );
-
-        return output;
-
-#endif
-}
-
-#ifndef EFSW_NO_WIDECHAR
-template <typename Out>
-Out Utf<32>::EncodeWide( Uint32 codepoint, Out output, wchar_t replacement ) {
-        // The encoding of wide characters is not well defined and is left to the system;
-        // however we can safely assume that it is UCS-2 on Windows and
-        // UCS-4 on Unix systems.
-        // For UCS-2 we need to check if the source characters fits in (UCS-2 is a subset of UCS-4).
-        // For UCS-4 we can do a direct copy (UCS-4 *is* UTF-32).
-
-        switch ( sizeof( wchar_t ) ) {
-                case 4: {
-                        *output++ = static_cast<wchar_t>( codepoint );
-                        break;
-                }
-
-                default: {
-                        if ( ( codepoint <= 0xFFFF ) && ( ( codepoint < 0xD800 ) || ( codepoint > 0xDFFF ) ) ) {
-                                *output++ = static_cast<wchar_t>( codepoint );
-                        } else if ( replacement ) {
-                                *output++ = replacement;
-                        }
-                        break;
-                }
-        }
-
-        return output;
-}
-#endif
+// References :

+// http://www.unicode.org/

+// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c

+// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.h

+// http://people.w3.org/rishida/scripts/uniview/conversion

+////////////////////////////////////////////////////////////

+

+template <typename In> In Utf<8>::Decode( In begin, In end, Uint32& output, Uint32 replacement ) {

+        // Some useful precomputed data

+        static const int trailing[256] = {

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,

+                2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5 };

+        static const Uint32 offsets[6] = { 0x00000000, 0x00003080, 0x000E2080,

+                                                                           0x03C82080, 0xFA082080, 0x82082080 };

+

+        // Decode the character

+        int trailingBytes = trailing[static_cast<Uint8>( *begin )];

+        if ( begin + trailingBytes < end ) {

+                output = 0;

+                switch ( trailingBytes ) {

+                        case 5:

+                                output += static_cast<Uint8>( *begin++ );

+                                output <<= 6;

+                        case 4:

+                                output += static_cast<Uint8>( *begin++ );

+                                output <<= 6;

+                        case 3:

+                                output += static_cast<Uint8>( *begin++ );

+                                output <<= 6;

+                        case 2:

+                                output += static_cast<Uint8>( *begin++ );

+                                output <<= 6;

+                        case 1:

+                                output += static_cast<Uint8>( *begin++ );

+                                output <<= 6;

+                        case 0:

+                                output += static_cast<Uint8>( *begin++ );

+                }

+                output -= offsets[trailingBytes];

+        } else {

+                // Incomplete character

+                begin = end;

+                output = replacement;

+        }

+

+        return begin;

+}

+

+template <typename Out> Out Utf<8>::Encode( Uint32 input, Out output, Uint8 replacement ) {

+        // Some useful precomputed data

+        static const Uint8 firstBytes[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

+

+        // Encode the character

+        if ( ( input > 0x0010FFFF ) || ( ( input >= 0xD800 ) && ( input <= 0xDBFF ) ) ) {

+                // Invalid character

+                if ( replacement )

+                        *output++ = replacement;

+        } else {

+                // Valid character

+

+                // Get the number of bytes to write

+                int bytesToWrite = 1;

+                if ( input < 0x80 )

+                        bytesToWrite = 1;

+                else if ( input < 0x800 )

+                        bytesToWrite = 2;

+                else if ( input < 0x10000 )

+                        bytesToWrite = 3;

+                else if ( input <= 0x0010FFFF )

+                        bytesToWrite = 4;

+

+                // Extract the bytes to write

+                Uint8 bytes[4];

+                switch ( bytesToWrite ) {

+                        case 4:

+                                bytes[3] = static_cast<Uint8>( ( input | 0x80 ) & 0xBF );

+                                input >>= 6;

+                        case 3:

+                                bytes[2] = static_cast<Uint8>( ( input | 0x80 ) & 0xBF );

+                                input >>= 6;

+                        case 2:

+                                bytes[1] = static_cast<Uint8>( ( input | 0x80 ) & 0xBF );

+                                input >>= 6;

+                        case 1:

+                                bytes[0] = static_cast<Uint8>( input | firstBytes[bytesToWrite] );

+                }

+

+                // Add them to the output

+                const Uint8* currentByte = bytes;

+                switch ( bytesToWrite ) {

+                        case 4:

+                                *output++ = *currentByte++;

+                        case 3:

+                                *output++ = *currentByte++;

+                        case 2:

+                                *output++ = *currentByte++;

+                        case 1:

+                                *output++ = *currentByte++;

+                }

+        }

+

+        return output;

+}

+

+template <typename In> In Utf<8>::Next( In begin, In end ) {

+        Uint32 codepoint;

+        return Decode( begin, end, codepoint );

+}

+

+template <typename In> std::size_t Utf<8>::Count( In begin, In end ) {

+        std::size_t length = 0;

+        while ( begin < end ) {

+                begin = Next( begin, end );

+                ++length;

+        }

+

+        return length;

+}

+

+template <typename In, typename Out>

+Out Utf<8>::FromAnsi( In begin, In end, Out output, const std::locale& locale ) {

+        while ( begin < end ) {

+                Uint32 codepoint = Utf<32>::DecodeAnsi( *begin++, locale );

+                output = Encode( codepoint, output );

+        }

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<8>::FromWide( In begin, In end, Out output ) {

+        while ( begin < end ) {

+                Uint32 codepoint = Utf<32>::DecodeWide( *begin++ );

+                output = Encode( codepoint, output );

+        }

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<8>::FromLatin1( In begin, In end, Out output ) {

+        // Latin-1 is directly compatible with Unicode encodings,

+        // and can thus be treated as (a sub-range of) UTF-32

+        while ( begin < end )

+                output = Encode( *begin++, output );

+

+        return output;

+}

+

+template <typename In, typename Out>

+Out Utf<8>::ToAnsi( In begin, In end, Out output, char replacement, const std::locale& locale ) {

+        while ( begin < end ) {

+                Uint32 codepoint;

+                begin = Decode( begin, end, codepoint );

+                output = Utf<32>::EncodeAnsi( codepoint, output, replacement, locale );

+        }

+

+        return output;

+}

+

+#ifndef EFSW_NO_WIDECHAR

+template <typename In, typename Out>

+Out Utf<8>::ToWide( In begin, In end, Out output, wchar_t replacement ) {

+        while ( begin < end ) {

+                Uint32 codepoint;

+                begin = Decode( begin, end, codepoint );

+                output = Utf<32>::EncodeWide( codepoint, output, replacement );

+        }

+

+        return output;

+}

+#endif

+

+template <typename In, typename Out>

+Out Utf<8>::ToLatin1( In begin, In end, Out output, char replacement ) {

+        // Latin-1 is directly compatible with Unicode encodings,

+        // and can thus be treated as (a sub-range of) UTF-32

+        while ( begin < end ) {

+                Uint32 codepoint;

+                begin = Decode( begin, end, codepoint );

+                *output++ = codepoint < 256 ? static_cast<char>( codepoint ) : replacement;

+        }

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<8>::toUtf8( In begin, In end, Out output ) {

+        while ( begin < end )

+                *output++ = *begin++;

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<8>::ToUtf16( In begin, In end, Out output ) {

+        while ( begin < end ) {

+                Uint32 codepoint;

+                begin = Decode( begin, end, codepoint );

+                output = Utf<16>::Encode( codepoint, output );

+        }

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<8>::ToUtf32( In begin, In end, Out output ) {

+        while ( begin < end ) {

+                Uint32 codepoint;

+                begin = Decode( begin, end, codepoint );

+                *output++ = codepoint;

+        }

+

+        return output;

+}

+

+template <typename In> In Utf<16>::Decode( In begin, In end, Uint32& output, Uint32 replacement ) {

+        Uint16 first = *begin++;

+

+        // If it's a surrogate pair, first convert to a single UTF-32 character

+        if ( ( first >= 0xD800 ) && ( first <= 0xDBFF ) ) {

+                if ( begin < end ) {

+                        Uint32 second = *begin++;

+                        if ( ( second >= 0xDC00 ) && ( second <= 0xDFFF ) ) {

+                                // The second element is valid: convert the two elements to a UTF-32 character

+                                output = static_cast<Uint32>( ( ( first - 0xD800 ) << 10 ) + ( second - 0xDC00 ) +

+                                                                                          0x0010000 );

+                        } else {

+                                // Invalid character

+                                output = replacement;

+                        }

+                } else {

+                        // Invalid character

+                        begin = end;

+                        output = replacement;

+                }

+        } else {

+                // We can make a direct copy

+                output = first;

+        }

+

+        return begin;

+}

+

+template <typename Out> Out Utf<16>::Encode( Uint32 input, Out output, Uint16 replacement ) {

+        if ( input < 0xFFFF ) {

+                // The character can be copied directly, we just need to check if it's in the valid range

+                if ( ( input >= 0xD800 ) && ( input <= 0xDFFF ) ) {

+                        // Invalid character (this range is reserved)

+                        if ( replacement )

+                                *output++ = replacement;

+                } else {

+                        // Valid character directly convertible to a single UTF-16 character

+                        *output++ = static_cast<Uint16>( input );

+                }

+        } else if ( input > 0x0010FFFF ) {

+                // Invalid character (greater than the maximum unicode value)

+                if ( replacement )

+                        *output++ = replacement;

+        } else {

+                // The input character will be converted to two UTF-16 elements

+                input -= 0x0010000;

+                *output++ = static_cast<Uint16>( ( input >> 10 ) + 0xD800 );

+                *output++ = static_cast<Uint16>( ( input & 0x3FFUL ) + 0xDC00 );

+        }

+

+        return output;

+}

+

+template <typename In> In Utf<16>::Next( In begin, In end ) {

+        Uint32 codepoint;

+        return Decode( begin, end, codepoint );

+}

+

+template <typename In> std::size_t Utf<16>::Count( In begin, In end ) {

+        std::size_t length = 0;

+        while ( begin < end ) {

+                begin = Next( begin, end );

+                ++length;

+        }

+

+        return length;

+}

+

+template <typename In, typename Out>

+Out Utf<16>::FromAnsi( In begin, In end, Out output, const std::locale& locale ) {

+        while ( begin < end ) {

+                Uint32 codepoint = Utf<32>::DecodeAnsi( *begin++, locale );

+                output = Encode( codepoint, output );

+        }

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<16>::FromWide( In begin, In end, Out output ) {

+        while ( begin < end ) {

+                Uint32 codepoint = Utf<32>::DecodeWide( *begin++ );

+                output = Encode( codepoint, output );

+        }

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<16>::FromLatin1( In begin, In end, Out output ) {

+        // Latin-1 is directly compatible with Unicode encodings,

+        // and can thus be treated as (a sub-range of) UTF-32

+        while ( begin < end )

+                *output++ = *begin++;

+

+        return output;

+}

+

+template <typename In, typename Out>

+Out Utf<16>::ToAnsi( In begin, In end, Out output, char replacement, const std::locale& locale ) {

+        while ( begin < end ) {

+                Uint32 codepoint;

+                begin = Decode( begin, end, codepoint );

+                output = Utf<32>::EncodeAnsi( codepoint, output, replacement, locale );

+        }

+

+        return output;

+}

+

+#ifndef EFSW_NO_WIDECHAR

+template <typename In, typename Out>

+Out Utf<16>::ToWide( In begin, In end, Out output, wchar_t replacement ) {

+        while ( begin < end ) {

+                Uint32 codepoint;

+                begin = Decode( begin, end, codepoint );

+                output = Utf<32>::EncodeWide( codepoint, output, replacement );

+        }

+

+        return output;

+}

+#endif

+

+template <typename In, typename Out>

+Out Utf<16>::ToLatin1( In begin, In end, Out output, char replacement ) {

+        // Latin-1 is directly compatible with Unicode encodings,

+        // and can thus be treated as (a sub-range of) UTF-32

+        while ( begin < end ) {

+                *output++ = *begin < 256 ? static_cast<char>( *begin ) : replacement;

+                begin++;

+        }

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<16>::toUtf8( In begin, In end, Out output ) {

+        while ( begin < end ) {

+                Uint32 codepoint;

+                begin = Decode( begin, end, codepoint );

+                output = Utf<8>::Encode( codepoint, output );

+        }

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<16>::ToUtf16( In begin, In end, Out output ) {

+        while ( begin < end )

+                *output++ = *begin++;

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<16>::ToUtf32( In begin, In end, Out output ) {

+        while ( begin < end ) {

+                Uint32 codepoint;

+                begin = Decode( begin, end, codepoint );

+                *output++ = codepoint;

+        }

+

+        return output;

+}

+

+template <typename In> In Utf<32>::Decode( In begin, In /*end*/, Uint32& output, Uint32 ) {

+        output = *begin++;

+        return begin;

+}

+

+template <typename Out> Out Utf<32>::Encode( Uint32 input, Out output, Uint32 /*replacement*/ ) {

+        *output++ = input;

+        return output;

+}

+

+template <typename In> In Utf<32>::Next( In begin, In /*end*/ ) {

+        return ++begin;

+}

+

+template <typename In> std::size_t Utf<32>::Count( In begin, In end ) {

+        return begin - end;

+}

+

+template <typename In, typename Out>

+Out Utf<32>::FromAnsi( In begin, In end, Out output, const std::locale& locale ) {

+        while ( begin < end )

+                *output++ = DecodeAnsi( *begin++, locale );

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<32>::FromWide( In begin, In end, Out output ) {

+        while ( begin < end )

+                *output++ = DecodeWide( *begin++ );

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<32>::FromLatin1( In begin, In end, Out output ) {

+        // Latin-1 is directly compatible with Unicode encodings,

+        // and can thus be treated as (a sub-range of) UTF-32

+        while ( begin < end )

+                *output++ = *begin++;

+

+        return output;

+}

+

+template <typename In, typename Out>

+Out Utf<32>::ToAnsi( In begin, In end, Out output, char replacement, const std::locale& locale ) {

+        while ( begin < end )

+                output = EncodeAnsi( *begin++, output, replacement, locale );

+

+        return output;

+}

+

+#ifndef EFSW_NO_WIDECHAR

+template <typename In, typename Out>

+Out Utf<32>::ToWide( In begin, In end, Out output, wchar_t replacement ) {

+        while ( begin < end )

+                output = EncodeWide( *begin++, output, replacement );

+

+        return output;

+}

+#endif

+

+template <typename In, typename Out>

+Out Utf<32>::ToLatin1( In begin, In end, Out output, char replacement ) {

+        // Latin-1 is directly compatible with Unicode encodings,

+        // and can thus be treated as (a sub-range of) UTF-32

+        while ( begin < end ) {

+                *output++ = *begin < 256 ? static_cast<char>( *begin ) : replacement;

+                begin++;

+        }

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<32>::toUtf8( In begin, In end, Out output ) {

+        while ( begin < end )

+                output = Utf<8>::Encode( *begin++, output );

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<32>::ToUtf16( In begin, In end, Out output ) {

+        while ( begin < end )

+                output = Utf<16>::Encode( *begin++, output );

+

+        return output;

+}

+

+template <typename In, typename Out> Out Utf<32>::ToUtf32( In begin, In end, Out output ) {

+        while ( begin < end )

+                *output++ = *begin++;

+

+        return output;

+}

+

+template <typename In> Uint32 Utf<32>::DecodeAnsi( In input, const std::locale& locale ) {

+        // On Windows, gcc's standard library (glibc++) has almost

+        // no support for Unicode stuff. As a consequence, in this

+        // context we can only use the default locale and ignore

+        // the one passed as parameter.

+

+#if EFSW_PLATFORM == EFSW_PLATFORM_WIN && /* if Windows ... */                  \

+        ( defined( __GLIBCPP__ ) ||                                                 \

+          defined( __GLIBCXX__ ) ) && /* ... and standard library is glibc++ ... */ \

+        !( defined( __SGI_STL_PORT ) ||                                             \

+           defined( _STLPORT_VERSION ) ) /* ... and STLPort is not used on top of it */

+

+        wchar_t character = 0;

+        mbtowc( &character, &input, 1 );

+        return static_cast<Uint32>( character );

+

+#else

+// Get the facet of the locale which deals with character conversion

+#ifndef EFSW_NO_WIDECHAR

+        const std::ctype<wchar_t>& facet = std::use_facet<std::ctype<wchar_t>>( locale );

+#else

+        const std::ctype<char>& facet = std::use_facet<std::ctype<char>>( locale );

+#endif

+

+        // Use the facet to convert each character of the input string

+        return static_cast<Uint32>( facet.widen( input ) );

+

+#endif

+}

+

+template <typename In> Uint32 Utf<32>::DecodeWide( In input ) {

+        // The encoding of wide characters is not well defined and is left to the system;

+        // however we can safely assume that it is UCS-2 on Windows and

+        // UCS-4 on Unix systems.

+        // In both cases, a simple copy is enough (UCS-2 is a subset of UCS-4,

+        // and UCS-4 *is* UTF-32).

+

+        return input;

+}

+

+template <typename Out>

+Out Utf<32>::EncodeAnsi( Uint32 codepoint, Out output, char replacement,

+                                                 const std::locale& locale ) {

+        // On Windows, gcc's standard library (glibc++) has almost

+        // no support for Unicode stuff. As a consequence, in this

+        // context we can only use the default locale and ignore

+        // the one passed as parameter.

+

+#if EFSW_PLATFORM == EFSW_PLATFORM_WIN && /* if Windows ... */                  \

+        ( defined( __GLIBCPP__ ) ||                                                 \

+          defined( __GLIBCXX__ ) ) && /* ... and standard library is glibc++ ... */ \

+        !( defined( __SGI_STL_PORT ) ||                                             \

+           defined( _STLPORT_VERSION ) ) /* ... and STLPort is not used on top of it */

+

+        char character = 0;

+        if ( wctomb( &character, static_cast<wchar_t>( codepoint ) ) >= 0 )

+                *output++ = character;

+        else if ( replacement )

+                *output++ = replacement;

+

+        return output;

+

+#else

+// Get the facet of the locale which deals with character conversion

+#ifndef EFSW_NO_WIDECHAR

+        const std::ctype<wchar_t>& facet = std::use_facet<std::ctype<wchar_t>>( locale );

+#else

+        const std::ctype<char>& facet = std::use_facet<std::ctype<char>>( locale );

+#endif

+

+        // Use the facet to convert each character of the input string

+        *output++ = facet.narrow( static_cast<wchar_t>( codepoint ), replacement );

+

+        return output;

+

+#endif

+}

+

+#ifndef EFSW_NO_WIDECHAR

+template <typename Out>

+Out Utf<32>::EncodeWide( Uint32 codepoint, Out output, wchar_t replacement ) {

+        // The encoding of wide characters is not well defined and is left to the system;

+        // however we can safely assume that it is UCS-2 on Windows and

+        // UCS-4 on Unix systems.

+        // For UCS-2 we need to check if the source characters fits in (UCS-2 is a subset of UCS-4).

+        // For UCS-4 we can do a direct copy (UCS-4 *is* UTF-32).

+

+        switch ( sizeof( wchar_t ) ) {

+                case 4: {

+                        *output++ = static_cast<wchar_t>( codepoint );

+                        break;

+                }

+

+                default: {

+                        if ( ( codepoint <= 0xFFFF ) && ( ( codepoint < 0xD800 ) || ( codepoint > 0xDFFF ) ) ) {

+                                *output++ = static_cast<wchar_t>( codepoint );

+                        } else if ( replacement ) {

+                                *output++ = replacement;

+                        }

+                        break;

+                }

+        }

+

+        return output;

+}

+#endif

diff --git a/src/3rdParty/efsw/Watcher.cpp b/src/3rdParty/efsw/Watcher.cpp
index 913ae3c..913ae3c 100755..100644
--- a/src/3rdParty/efsw/Watcher.cpp
+++ b/src/3rdParty/efsw/Watcher.cpp
diff --git a/src/3rdParty/efsw/Watcher.hpp b/src/3rdParty/efsw/Watcher.hpp
index 84f0980..84f0980 100755..100644
--- a/src/3rdParty/efsw/Watcher.hpp
+++ b/src/3rdParty/efsw/Watcher.hpp
diff --git a/src/3rdParty/efsw/WatcherFSEvents.cpp b/src/3rdParty/efsw/WatcherFSEvents.cpp
index b562d3c..f963374 100755..100644
--- a/src/3rdParty/efsw/WatcherFSEvents.cpp
+++ b/src/3rdParty/efsw/WatcherFSEvents.cpp
@@ -8,22 +8,11 @@
 namespace efsw {
 
 WatcherFSEvents::WatcherFSEvents() :
-        Watcher(), FWatcher( NULL ), FSStream( NULL ), WatcherGen( NULL ), initializedAsync( false ) {}
-
-WatcherFSEvents::WatcherFSEvents( WatchID id, std::string directory, FileWatchListener* listener,
-                                                                  bool recursive, WatcherFSEvents* /*parent*/ ) :
-        Watcher( id, directory, listener, recursive ),
-        FWatcher( NULL ),
-        FSStream( NULL ),
-        WatcherGen( NULL ),
-        initializedAsync( false ) {}
+        Watcher(), FWatcher( NULL ), FSStream( NULL ), WatcherGen( NULL ) {}
 
 WatcherFSEvents::~WatcherFSEvents() {
         if ( NULL != FSStream ) {
-                if ( initializedAsync ) {
-                        FSEventStreamStop( FSStream );
-                }
-
+                FSEventStreamStop( FSStream );
                 FSEventStreamInvalidate( FSStream );
                 FSEventStreamRelease( FSStream );
         }
@@ -39,7 +28,9 @@ void WatcherFSEvents::init() {
         Uint32 streamFlags = kFSEventStreamCreateFlagNone;
 
         if ( FileWatcherFSEvents::isGranular() ) {
-                streamFlags = efswFSEventStreamCreateFlagFileEvents;
+                streamFlags = efswFSEventStreamCreateFlagFileEvents | efswFSEventStreamCreateFlagNoDefer |
+                                          efswFSEventStreamCreateFlagUseExtendedData |
+                                          efswFSEventStreamCreateFlagUseCFTypes;
         } else {
                 WatcherGen = new WatcherGeneric( ID, Directory, Listener, FWatcher.load(), Recursive );
         }
@@ -52,49 +43,49 @@ void WatcherFSEvents::init() {
         ctx.release = NULL;
         ctx.copyDescription = NULL;
 
+        dispatch_queue_t queue = dispatch_queue_create( NULL, NULL );
+
         FSStream =
                 FSEventStreamCreate( kCFAllocatorDefault, &FileWatcherFSEvents::FSEventCallback, &ctx,
-                                                         CFDirectoryArray, kFSEventStreamEventIdSinceNow, 0.25, streamFlags );
-        FWatcher.load()->mNeedInitMutex.lock();
-        FWatcher.load()->mNeedInit.push_back( this );
-        FWatcher.load()->mNeedInitMutex.unlock();
+                                                         CFDirectoryArray, kFSEventStreamEventIdSinceNow, 0., streamFlags );
 
-        CFRelease( CFDirectoryArray );
-        CFRelease( CFDirectory );
-}
+        FSEventStreamSetDispatchQueue( FSStream, queue );
 
-void WatcherFSEvents::initAsync() {
-        FSEventStreamScheduleWithRunLoop( FSStream, FWatcher.load()->mRunLoopRef.load(),
-                                                                          kCFRunLoopDefaultMode );
         FSEventStreamStart( FSStream );
-        initializedAsync = true;
+
+        CFRelease( CFDirectoryArray );
+        CFRelease( CFDirectory );
 }
 
 void WatcherFSEvents::sendFileAction( WatchID watchid, const std::string& dir,
                                                                           const std::string& filename, Action action,
                                                                           std::string oldFilename ) {
         Listener->handleFileAction( watchid, FileSystem::precomposeFileName( dir ),
-                                                                FileSystem::precomposeFileName( filename ), action, oldFilename );
+                                                                FileSystem::precomposeFileName( filename ), action,
+                                                                FileSystem::precomposeFileName( oldFilename ) );
 }
 
 void WatcherFSEvents::handleAddModDel( const Uint32& flags, const std::string& path,
-                                                                           std::string& dirPath, std::string& filePath ) {
-        if ( flags & efswFSEventStreamEventFlagItemCreated ) {
-                if ( FileInfo::exists( path ) ) {
-                        sendFileAction( ID, dirPath, filePath, Actions::Add );
-                }
+                                                                           std::string& dirPath, std::string& filePath, Uint64 inode ) {
+        if ( ( flags & efswFSEventStreamEventFlagItemCreated ) && FileInfo::exists( path ) &&
+                 ( !SanitizeEvents || FilesAdded.find( inode ) != FilesAdded.end() ) ) {
+                sendFileAction( ID, dirPath, filePath, Actions::Add );
+
+                if ( SanitizeEvents )
+                        FilesAdded.insert( inode );
         }
 
-        if ( flags & efswFSEventsModified ) {
+        if ( flags & ModifiedFlags ) {
                 sendFileAction( ID, dirPath, filePath, Actions::Modified );
         }
 
-        if ( flags & efswFSEventStreamEventFlagItemRemoved ) {
+        if ( ( flags & efswFSEventStreamEventFlagItemRemoved ) && !FileInfo::exists( path ) ) {
                 // Since i don't know the order, at least i try to keep the data consistent with the real
                 // state
-                if ( !FileInfo::exists( path ) ) {
-                        sendFileAction( ID, dirPath, filePath, Actions::Delete );
-                }
+                sendFileAction( ID, dirPath, filePath, Actions::Delete );
+
+                if ( SanitizeEvents )
+                        FilesAdded.erase( inode );
         }
 }
 
@@ -136,19 +127,20 @@ void WatcherFSEvents::handleActions( std::vector<FSEvent>& events ) {
                         // been added modified and erased, but i can't know if first was erased and then added
                         // and modified, or added, then modified and then erased. I don't know what they were
                         // thinking by doing this...
-                        efDEBUG( "Event in: %s - flags: %ld\n", event.Path.c_str(), event.Flags );
+                        efDEBUG( "Event in: %s - flags: 0x%x\n", event.Path.c_str(), event.Flags );
 
                         if ( event.Flags & efswFSEventStreamEventFlagItemRenamed ) {
                                 if ( ( i + 1 < esize ) &&
                                          ( events[i + 1].Flags & efswFSEventStreamEventFlagItemRenamed ) &&
-                                         ( events[i + 1].Id == event.Id + 1 ) ) {
+                                         ( events[i + 1].inode == event.inode ) ) {
                                         FSEvent& nEvent = events[i + 1];
                                         std::string newDir( FileSystem::pathRemoveFileName( nEvent.Path ) );
                                         std::string newFilepath( FileSystem::fileNameFromPath( nEvent.Path ) );
 
                                         if ( event.Path != nEvent.Path ) {
                                                 if ( dirPath == newDir ) {
-                                                        if ( !FileInfo::exists( event.Path ) ) {
+                                                        if ( !FileInfo::exists( event.Path ) ||
+                                                                 0 == strcasecmp( event.Path.c_str(), nEvent.Path.c_str() ) ) {
                                                                 sendFileAction( ID, dirPath, newFilepath, Actions::Moved,
                                                                                                 filePath );
                                                         } else {
@@ -159,12 +151,12 @@ void WatcherFSEvents::handleActions( std::vector<FSEvent>& events ) {
                                                         sendFileAction( ID, dirPath, filePath, Actions::Delete );
                                                         sendFileAction( ID, newDir, newFilepath, Actions::Add );
 
-                                                        if ( nEvent.Flags & efswFSEventsModified ) {
+                                                        if ( nEvent.Flags & ModifiedFlags ) {
                                                                 sendFileAction( ID, newDir, newFilepath, Actions::Modified );
                                                         }
                                                 }
                                         } else {
-                                                handleAddModDel( nEvent.Flags, nEvent.Path, dirPath, filePath );
+                                                handleAddModDel( nEvent.Flags, nEvent.Path, dirPath, filePath, event.inode );
                                         }
 
                                         if ( nEvent.Flags & ( efswFSEventStreamEventFlagItemCreated |
@@ -180,14 +172,14 @@ void WatcherFSEvents::handleActions( std::vector<FSEvent>& events ) {
                                 } else if ( FileInfo::exists( event.Path ) ) {
                                         sendFileAction( ID, dirPath, filePath, Actions::Add );
 
-                                        if ( event.Flags & efswFSEventsModified ) {
+                                        if ( event.Flags & ModifiedFlags ) {
                                                 sendFileAction( ID, dirPath, filePath, Actions::Modified );
                                         }
                                 } else {
                                         sendFileAction( ID, dirPath, filePath, Actions::Delete );
                                 }
                         } else {
-                                handleAddModDel( event.Flags, event.Path, dirPath, filePath );
+                                handleAddModDel( event.Flags, event.Path, dirPath, filePath, event.inode );
                         }
                 } else {
                         efDEBUG( "Directory: %s changed\n", event.Path.c_str() );
@@ -197,7 +189,7 @@ void WatcherFSEvents::handleActions( std::vector<FSEvent>& events ) {
 }
 
 void WatcherFSEvents::process() {
-        std::set<std::string>::iterator it = DirsChanged.begin();
+        std::unordered_set<std::string>::iterator it = DirsChanged.begin();
 
         for ( ; it != DirsChanged.end(); it++ ) {
                 if ( !FileWatcherFSEvents::isGranular() ) {
diff --git a/src/3rdParty/efsw/WatcherFSEvents.hpp b/src/3rdParty/efsw/WatcherFSEvents.hpp
index 4dbb231..f05b094 100755..100644
--- a/src/3rdParty/efsw/WatcherFSEvents.hpp
+++ b/src/3rdParty/efsw/WatcherFSEvents.hpp
@@ -9,51 +9,72 @@
 #include <CoreServices/CoreServices.h>
 #include <efsw/FileInfo.hpp>
 #include <efsw/WatcherGeneric.hpp>
-#include <set>
+#include <unordered_set>
 #include <vector>
 
 namespace efsw {
 
+/* OSX < 10.7 has no file events */
+/* So i declare the events constants */
+enum FSEventEvents {
+        efswFSEventStreamCreateFlagUseCFTypes = 0x00000001,
+        efswFSEventStreamCreateFlagNoDefer = 0x00000002,
+        efswFSEventStreamCreateFlagFileEvents = 0x00000010,
+        efswFSEventStreamCreateFlagUseExtendedData = 0x00000040,
+        efswFSEventStreamEventFlagItemCreated = 0x00000100,
+        efswFSEventStreamEventFlagItemRemoved = 0x00000200,
+        efswFSEventStreamEventFlagItemInodeMetaMod = 0x00000400,
+        efswFSEventStreamEventFlagItemRenamed = 0x00000800,
+        efswFSEventStreamEventFlagItemModified = 0x00001000,
+        efswFSEventStreamEventFlagItemFinderInfoMod = 0x00002000,
+        efswFSEventStreamEventFlagItemChangeOwner = 0x00004000,
+        efswFSEventStreamEventFlagItemXattrMod = 0x00008000,
+        efswFSEventStreamEventFlagItemIsFile = 0x00010000,
+        efswFSEventStreamEventFlagItemIsDir = 0x00020000,
+        efswFSEventStreamEventFlagItemIsSymlink = 0x00040000,
+        efswFSEventsModified = efswFSEventStreamEventFlagItemFinderInfoMod |
+                                                   efswFSEventStreamEventFlagItemModified |
+                                                   efswFSEventStreamEventFlagItemInodeMetaMod
+};
+
 class FileWatcherFSEvents;
 
 class FSEvent {
   public:
-        FSEvent( std::string path, long flags, Uint64 id ) : Path( path ), Flags( flags ), Id( id ) {}
+        FSEvent( std::string path, long flags, Uint64 id, Uint64 inode = 0 ) :
+                Path( path ), Flags( flags ), Id( id ), inode( inode ) {}
 
         std::string Path;
-        long Flags;
-        Uint64 Id;
+        long Flags{ 0 };
+        Uint64 Id{ 0 };
+        Uint64 inode{ 0 };
 };
 
 class WatcherFSEvents : public Watcher {
   public:
         WatcherFSEvents();
 
-        WatcherFSEvents( WatchID id, std::string directory, FileWatchListener* listener, bool recursive,
-                                         WatcherFSEvents* parent = NULL );
-
         ~WatcherFSEvents();
 
         void init();
 
-        void initAsync();
-
         void handleActions( std::vector<FSEvent>& events );
 
         void process();
 
         Atomic<FileWatcherFSEvents*> FWatcher;
         FSEventStreamRef FSStream;
+        Uint64 ModifiedFlags{ efswFSEventsModified };
+        bool SanitizeEvents{ false };
 
   protected:
         void handleAddModDel( const Uint32& flags, const std::string& path, std::string& dirPath,
-                                                  std::string& filePath );
+                                                  std::string& filePath, Uint64 inode );
 
         WatcherGeneric* WatcherGen;
 
-        Atomic<bool> initializedAsync;
-
-        std::set<std::string> DirsChanged;
+        std::unordered_set<std::string> DirsChanged;
+        std::unordered_set<Uint64> FilesAdded;
 
         void sendFileAction( WatchID watchid, const std::string& dir, const std::string& filename,
                                                  Action action, std::string oldFilename = "" );
diff --git a/src/3rdParty/efsw/WatcherGeneric.cpp b/src/3rdParty/efsw/WatcherGeneric.cpp
index a6bb106..a6bb106 100755..100644
--- a/src/3rdParty/efsw/WatcherGeneric.cpp
+++ b/src/3rdParty/efsw/WatcherGeneric.cpp
diff --git a/src/3rdParty/efsw/WatcherGeneric.hpp b/src/3rdParty/efsw/WatcherGeneric.hpp
index 9cf8365..d11ec20 100755..100644
--- a/src/3rdParty/efsw/WatcherGeneric.hpp
+++ b/src/3rdParty/efsw/WatcherGeneric.hpp
@@ -17,7 +17,7 @@ class WatcherGeneric : public Watcher {
 
         ~WatcherGeneric();
 
-        void watch();
+        void watch() override;
 
         void watchDir( std::string dir );
 
diff --git a/src/3rdParty/efsw/WatcherInotify.cpp b/src/3rdParty/efsw/WatcherInotify.cpp
index 7259bb1..812ddae 100755..100644
--- a/src/3rdParty/efsw/WatcherInotify.cpp
+++ b/src/3rdParty/efsw/WatcherInotify.cpp
@@ -4,10 +4,6 @@ namespace efsw {
 
 WatcherInotify::WatcherInotify() : Watcher(), Parent( NULL ) {}
 
-WatcherInotify::WatcherInotify( WatchID id, std::string directory, FileWatchListener* listener,
-                                                                bool recursive, WatcherInotify* parent ) :
-        Watcher( id, directory, listener, recursive ), Parent( parent ), DirInfo( directory ) {}
-
 bool WatcherInotify::inParentTree( WatcherInotify* parent ) {
         WatcherInotify* tNext = Parent;
 
diff --git a/src/3rdParty/efsw/WatcherInotify.hpp b/src/3rdParty/efsw/WatcherInotify.hpp
index bf2ff5e..ec55ed0 100755..100644
--- a/src/3rdParty/efsw/WatcherInotify.hpp
+++ b/src/3rdParty/efsw/WatcherInotify.hpp
@@ -10,15 +10,13 @@ class WatcherInotify : public Watcher {
   public:
         WatcherInotify();
 
-        WatcherInotify( WatchID id, std::string directory, FileWatchListener* listener, bool recursive,
-                                        WatcherInotify* parent = NULL );
-
         bool inParentTree( WatcherInotify* parent );
 
         WatcherInotify* Parent;
         WatchID InotifyID;
 
         FileInfo DirInfo;
+        bool syntheticEvents{ false };
 };
 
 } // namespace efsw
diff --git a/src/3rdParty/efsw/WatcherKqueue.cpp b/src/3rdParty/efsw/WatcherKqueue.cpp
index 441948a..424b989 100755..100644
--- a/src/3rdParty/efsw/WatcherKqueue.cpp
+++ b/src/3rdParty/efsw/WatcherKqueue.cpp
@@ -139,7 +139,7 @@ void WatcherKqueue::addAll() {
 void WatcherKqueue::removeAll() {
         efDEBUG( "removeAll(): Removing all child watchers\n" );
 
-        std::list<WatchID> erase;
+        std::vector<WatchID> erase;
 
         for ( WatchMap::iterator it = mWatches.begin(); it != mWatches.end(); it++ ) {
                 efDEBUG( "removeAll(): Removed child watcher %s\n", it->second->Directory.c_str() );
@@ -147,7 +147,7 @@ void WatcherKqueue::removeAll() {
                 erase.push_back( it->second->ID );
         }
 
-        for ( std::list<WatchID>::iterator eit = erase.begin(); eit != erase.end(); eit++ ) {
+        for ( std::vector<WatchID>::iterator eit = erase.begin(); eit != erase.end(); eit++ ) {
                 removeWatch( *eit );
         }
 }
@@ -354,7 +354,8 @@ void WatcherKqueue::watch() {
         bool needScan = false;
 
         // Then we get the the events of the current folder
-        while ( ( nev = kevent( mKqueue, &mChangeList[0], mChangeListCount + 1, &event, 1,
+        while ( !mChangeList.empty() &&
+                        ( nev = kevent( mKqueue, mChangeList.data(), mChangeListCount + 1, &event, 1,
                                                         &mWatcher->mTimeOut ) ) != 0 ) {
                 // An error ocurred?
                 if ( nev == -1 ) {
@@ -436,7 +437,6 @@ void WatcherKqueue::moveDirectory( std::string oldPath, std::string newPath, boo
 
 WatchID WatcherKqueue::addWatch( const std::string& directory, FileWatchListener* watcher,
                                                                  bool recursive, WatcherKqueue* parent ) {
-        static long s_fc = 0;
         static bool s_ug = false;
 
         std::string dir( directory );
@@ -478,8 +478,6 @@ WatchID WatcherKqueue::addWatch( const std::string& directory, FileWatchListener
 
                 watch->addAll();
 
-                s_fc++;
-
                 // if failed to open the directory... erase the watcher
                 if ( !watch->initOK() ) {
                         int le = watch->lastErrno();
@@ -502,9 +500,8 @@ WatchID WatcherKqueue::addWatch( const std::string& directory, FileWatchListener
                 }
         } else {
                 if ( !s_ug ) {
-                        efDEBUG( "Started using WatcherGeneric, reached file descriptors limit: %ld. Folders "
-                                         "added: %ld\n",
-                                         mWatcher->mFileDescriptorCount, s_fc );
+                        efDEBUG( "Started using WatcherGeneric, reached file descriptors limit: %ld.\n",
+                                         mWatcher->mFileDescriptorCount );
                         s_ug = true;
                 }
 
diff --git a/src/3rdParty/efsw/WatcherKqueue.hpp b/src/3rdParty/efsw/WatcherKqueue.hpp
index 87d898c..75c0f62 100755..100644
--- a/src/3rdParty/efsw/WatcherKqueue.hpp
+++ b/src/3rdParty/efsw/WatcherKqueue.hpp
@@ -49,7 +49,7 @@ class WatcherKqueue : public Watcher {
 
         WatchID watchingDirectory( std::string dir );
 
-        void watch();
+        void watch() override;
 
         WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive,
                                           WatcherKqueue* parent );
diff --git a/src/3rdParty/efsw/WatcherWin32.cpp b/src/3rdParty/efsw/WatcherWin32.cpp
index 3e8bcc7..712419e 100755..100644
--- a/src/3rdParty/efsw/WatcherWin32.cpp
+++ b/src/3rdParty/efsw/WatcherWin32.cpp
@@ -1,34 +1,114 @@
+#include <efsw/Debug.hpp>
 #include <efsw/String.hpp>
 #include <efsw/WatcherWin32.hpp>
 
 #if EFSW_PLATFORM == EFSW_PLATFORM_WIN32
 
+#include <algorithm>
+
 namespace efsw {
 
-/// Unpacks events and passes them to a user defined callback.
-void CALLBACK WatchCallback( DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped ) {
-        if ( dwNumberOfBytesTransfered == 0 || NULL == lpOverlapped ) {
-                return;
+struct EFSW_FILE_NOTIFY_EXTENDED_INFORMATION_EX {
+        DWORD NextEntryOffset;
+        DWORD Action;
+        LARGE_INTEGER CreationTime;
+        LARGE_INTEGER LastModificationTime;
+        LARGE_INTEGER LastChangeTime;
+        LARGE_INTEGER LastAccessTime;
+        LARGE_INTEGER AllocatedLength;
+        LARGE_INTEGER FileSize;
+        DWORD FileAttributes;
+        DWORD ReparsePointTag;
+        LARGE_INTEGER FileId;
+        LARGE_INTEGER ParentFileId;
+        DWORD FileNameLength;
+        WCHAR FileName[1];
+};
+
+typedef EFSW_FILE_NOTIFY_EXTENDED_INFORMATION_EX* EFSW_PFILE_NOTIFY_EXTENDED_INFORMATION_EX;
+
+typedef BOOL( WINAPI* EFSW_LPREADDIRECTORYCHANGESEXW )( HANDLE hDirectory, LPVOID lpBuffer,
+                                                                                                   DWORD nBufferLength, BOOL bWatchSubtree,
+                                                                                                   DWORD dwNotifyFilter, LPDWORD lpBytesReturned,
+                                                                                                   LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
+                                                                                                   DWORD ReadDirectoryNotifyInformationClass );
+
+static EFSW_LPREADDIRECTORYCHANGESEXW pReadDirectoryChangesExW = NULL;
+
+#define EFSW_ReadDirectoryNotifyExtendedInformation 2
+
+static void initReadDirectoryChangesEx() {
+        static bool hasInit = false;
+        if ( !hasInit ) {
+                hasInit = true;
+
+                HMODULE hModule = GetModuleHandleW( L"Kernel32.dll" );
+                if ( !hModule )
+                        return;
+
+                pReadDirectoryChangesExW =
+                        (EFSW_LPREADDIRECTORYCHANGESEXW)GetProcAddress( hModule, "ReadDirectoryChangesExW" );
         }
+}
 
-        char szFile[MAX_PATH];
+void WatchCallbackOld( WatcherWin32* pWatch ) {
         PFILE_NOTIFY_INFORMATION pNotify;
-        WatcherStructWin32* tWatch = (WatcherStructWin32*)lpOverlapped;
-        WatcherWin32* pWatch = tWatch->Watch;
         size_t offset = 0;
-
         do {
                 bool skip = false;
 
                 pNotify = (PFILE_NOTIFY_INFORMATION)&pWatch->Buffer[offset];
                 offset += pNotify->NextEntryOffset;
+                int count =
+                        WideCharToMultiByte( CP_UTF8, 0, pNotify->FileName,
+                                                                 pNotify->FileNameLength / sizeof( WCHAR ), NULL, 0, NULL, NULL );
+                if ( count == 0 )
+                        continue;
+
+                std::string nfile( count, '\0' );
+
+                count = WideCharToMultiByte( CP_UTF8, 0, pNotify->FileName,
+                                                                         pNotify->FileNameLength / sizeof( WCHAR ), &nfile[0], count,
+                                                                         NULL, NULL );
+
+                if ( FILE_ACTION_MODIFIED == pNotify->Action ) {
+                        FileInfo fifile( std::string( pWatch->DirName ) + nfile );
+
+                        if ( pWatch->LastModifiedEvent.file.ModificationTime == fifile.ModificationTime &&
+                                 pWatch->LastModifiedEvent.file.Size == fifile.Size &&
+                                 pWatch->LastModifiedEvent.fileName == nfile ) {
+                                skip = true;
+                        }
+
+                        pWatch->LastModifiedEvent.fileName = nfile;
+                        pWatch->LastModifiedEvent.file = fifile;
+                }
+
+                if ( !skip ) {
+                        pWatch->Watch->handleAction( pWatch, nfile, pNotify->Action );
+                }
+        } while ( pNotify->NextEntryOffset != 0 );
+}
+
+void WatchCallbackEx( WatcherWin32* pWatch ) {
+        EFSW_PFILE_NOTIFY_EXTENDED_INFORMATION_EX pNotify;
+        size_t offset = 0;
+        do {
+                bool skip = false;
+
+                pNotify = (EFSW_PFILE_NOTIFY_EXTENDED_INFORMATION_EX)&pWatch->Buffer[offset];
+                offset += pNotify->NextEntryOffset;
+                int count =
+                        WideCharToMultiByte( CP_UTF8, 0, pNotify->FileName,
+                                                                 pNotify->FileNameLength / sizeof( WCHAR ), NULL, 0, NULL, NULL );
+                if ( count == 0 )
+                        continue;
 
-                int count = WideCharToMultiByte( CP_UTF8, 0, pNotify->FileName,
-                                                                                 pNotify->FileNameLength / sizeof( WCHAR ), szFile,
-                                                                                 MAX_PATH - 1, NULL, NULL );
-                szFile[count] = TEXT( '\0' );
+                std::string nfile( count, '\0' );
 
-                std::string nfile( szFile );
+                count = WideCharToMultiByte( CP_UTF8, 0, pNotify->FileName,
+                                                                         pNotify->FileNameLength / sizeof( WCHAR ), &nfile[0], count,
+                                                                         NULL, NULL );
 
                 if ( FILE_ACTION_MODIFIED == pNotify->Action ) {
                         FileInfo fifile( std::string( pWatch->DirName ) + nfile );
@@ -41,12 +121,59 @@ void CALLBACK WatchCallback( DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOve
 
                         pWatch->LastModifiedEvent.fileName = nfile;
                         pWatch->LastModifiedEvent.file = fifile;
+                } else if ( FILE_ACTION_RENAMED_OLD_NAME == pNotify->Action ) {
+                        pWatch->OldFiles.emplace_back( nfile, pNotify->FileId );
+                        skip = true;
+                } else if ( FILE_ACTION_RENAMED_NEW_NAME == pNotify->Action ) {
+                        std::string oldFile;
+                        LARGE_INTEGER oldFileId{};
+
+                        for ( auto it = pWatch->OldFiles.begin(); it != pWatch->OldFiles.end(); ++it ) {
+                                if ( it->second.QuadPart == pNotify->FileId.QuadPart ) {
+                                        oldFile = it->first;
+                                        oldFileId = it->second;
+                                        it = pWatch->OldFiles.erase( it );
+                                        break;
+                                }
+                        }
+
+                        if ( oldFile.empty() ) {
+                                pWatch->Watch->handleAction( pWatch, nfile, FILE_ACTION_ADDED );
+                                skip = true;
+                        } else {
+                                pWatch->Watch->handleAction( pWatch, oldFile, FILE_ACTION_RENAMED_OLD_NAME );
+                        }
                 }
 
                 if ( !skip ) {
                         pWatch->Watch->handleAction( pWatch, nfile, pNotify->Action );
                 }
         } while ( pNotify->NextEntryOffset != 0 );
+}
+
+/// Unpacks events and passes them to a user defined callback.
+void CALLBACK WatchCallback( DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped ) {
+        if ( NULL == lpOverlapped ) {
+                return;
+        }
+
+        WatcherStructWin32* tWatch = (WatcherStructWin32*)lpOverlapped;
+        WatcherWin32* pWatch = tWatch->Watch;
+
+        if ( dwNumberOfBytesTransfered == 0 ) {
+                if ( nullptr != pWatch && !pWatch->StopNow ) {
+                        RefreshWatch( tWatch );
+                } else {
+                        return;
+                }
+        }
+
+        // Fork watch depending on the Windows API supported
+        if ( pWatch->Extended ) {
+                WatchCallbackEx( pWatch );
+        } else {
+                WatchCallbackOld( pWatch );
+        }
 
         if ( !pWatch->StopNow ) {
                 RefreshWatch( tWatch );
@@ -54,11 +181,40 @@ void CALLBACK WatchCallback( DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOve
 }
 
 /// Refreshes the directory monitoring.
-bool RefreshWatch( WatcherStructWin32* pWatch ) {
-        return ReadDirectoryChangesW( pWatch->Watch->DirHandle, pWatch->Watch->Buffer,
-                                                                  sizeof( pWatch->Watch->Buffer ), pWatch->Watch->Recursive,
-                                                                  pWatch->Watch->NotifyFilter, NULL, &pWatch->Overlapped,
-                                                                  NULL ) != 0;
+RefreshResult RefreshWatch( WatcherStructWin32* pWatch ) {
+        initReadDirectoryChangesEx();
+
+        bool bRet = false;
+        RefreshResult ret = RefreshResult::Failed;
+        pWatch->Watch->Extended = false;
+
+        if ( pReadDirectoryChangesExW ) {
+                bRet = pReadDirectoryChangesExW( pWatch->Watch->DirHandle, pWatch->Watch->Buffer.data(),
+                                                                          (DWORD)pWatch->Watch->Buffer.size(), pWatch->Watch->Recursive,
+                                                                          pWatch->Watch->NotifyFilter, NULL, &pWatch->Overlapped,
+                                                                                 NULL, EFSW_ReadDirectoryNotifyExtendedInformation ) != 0;
+                if ( bRet ) {
+                        ret = RefreshResult::SucessEx;
+                        pWatch->Watch->Extended = true;
+                }
+        }
+
+        if ( !bRet ) {
+                bRet = ReadDirectoryChangesW( pWatch->Watch->DirHandle, pWatch->Watch->Buffer.data(),
+                                                                          (DWORD)pWatch->Watch->Buffer.size(), pWatch->Watch->Recursive,
+                                                                          pWatch->Watch->NotifyFilter, NULL, &pWatch->Overlapped,
+                                                                          NULL ) != 0;
+
+                if ( bRet )
+                        ret = RefreshResult::Success;
+        }
+
+        if ( !bRet ) {
+                std::string error = std::to_string( GetLastError() );
+                Errors::Log::createLastError( Errors::WatcherFailed, error );
+        }
+
+        return ret;
 }
 
 /// Stops monitoring a directory.
@@ -70,19 +226,17 @@ void DestroyWatch( WatcherStructWin32* pWatch ) {
                 CloseHandle( pWatch->Watch->DirHandle );
                 efSAFE_DELETE_ARRAY( pWatch->Watch->DirName );
                 efSAFE_DELETE( pWatch->Watch );
+                efSAFE_DELETE( pWatch );
         }
 }
 
 /// Starts monitoring a directory.
-WatcherStructWin32* CreateWatch( LPCWSTR szDirectory, bool recursive, DWORD NotifyFilter,
-                                                                 HANDLE iocp ) {
-        WatcherStructWin32* tWatch;
-        size_t ptrsize = sizeof( *tWatch );
-        tWatch = static_cast<WatcherStructWin32*>(
-                HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, ptrsize ) );
-
-        WatcherWin32* pWatch = new WatcherWin32();
-        tWatch->Watch = pWatch;
+WatcherStructWin32* CreateWatch( LPCWSTR szDirectory, bool recursive,
+                                                                 DWORD bufferSize, DWORD notifyFilter, HANDLE iocp ) {
+        WatcherStructWin32* tWatch = new WatcherStructWin32();
+        WatcherWin32* pWatch = new WatcherWin32(bufferSize);
+        if (tWatch)
+                tWatch->Watch = pWatch;
 
         pWatch->DirHandle = CreateFileW(
                 szDirectory, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
@@ -90,17 +244,17 @@ WatcherStructWin32* CreateWatch( LPCWSTR szDirectory, bool recursive, DWORD Noti
 
         if ( pWatch->DirHandle != INVALID_HANDLE_VALUE &&
                  CreateIoCompletionPort( pWatch->DirHandle, iocp, 0, 1 ) ) {
-                pWatch->NotifyFilter = NotifyFilter;
+                pWatch->NotifyFilter = notifyFilter;
                 pWatch->Recursive = recursive;
 
-                if ( RefreshWatch( tWatch ) ) {
+                if ( RefreshResult::Failed != RefreshWatch( tWatch ) ) {
                         return tWatch;
                 }
         }
 
         CloseHandle( pWatch->DirHandle );
         efSAFE_DELETE( pWatch->Watch );
-        HeapFree( GetProcessHeap(), 0, tWatch );
+        efSAFE_DELETE( tWatch );
         return NULL;
 }
 
diff --git a/src/3rdParty/efsw/WatcherWin32.hpp b/src/3rdParty/efsw/WatcherWin32.hpp
index 71e13be..ea1e8e4 100755..100644
--- a/src/3rdParty/efsw/WatcherWin32.hpp
+++ b/src/3rdParty/efsw/WatcherWin32.hpp
@@ -3,6 +3,7 @@
 
 #include <efsw/FileInfo.hpp>
 #include <efsw/FileWatcherImpl.hpp>
+#include <vector>
 
 #if EFSW_PLATFORM == EFSW_PLATFORM_WIN32
 
@@ -21,6 +22,8 @@ namespace efsw {
 
 class WatcherWin32;
 
+enum RefreshResult { Failed, Success, SucessEx };
+
 /// Internal watch data
 struct WatcherStructWin32 {
         OVERLAPPED Overlapped;
@@ -32,39 +35,41 @@ struct sLastModifiedEvent {
         std::string fileName;
 };
 
-bool RefreshWatch( WatcherStructWin32* pWatch );
+RefreshResult RefreshWatch( WatcherStructWin32* pWatch );
 
 void CALLBACK WatchCallback( DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped );
 
 void DestroyWatch( WatcherStructWin32* pWatch );
 
-WatcherStructWin32* CreateWatch( LPCWSTR szDirectory, bool recursive, DWORD NotifyFilter,
-                                                                 HANDLE iocp );
+WatcherStructWin32* CreateWatch( LPCWSTR szDirectory, bool recursive,
+                                                             DWORD bufferSize, DWORD notifyFilter, HANDLE iocp );
 
 class WatcherWin32 : public Watcher {
   public:
-        WatcherWin32() :
+        WatcherWin32(DWORD dwBufferSize) :
                 Struct( NULL ),
                 DirHandle( NULL ),
+                Buffer(),
                 lParam( 0 ),
                 NotifyFilter( 0 ),
                 StopNow( false ),
+                Extended( false ),
                 Watch( NULL ),
-                DirName( NULL ) {}
+                DirName( NULL ) {
+                        Buffer.resize(dwBufferSize);
+                }
 
         WatcherStructWin32* Struct;
         HANDLE DirHandle;
-        BYTE Buffer
-                [63 *
-                 1024]; // do NOT make this bigger than 64K because it will fail if the folder being watched
-                                // is on the network! (see
-                                // http://msdn.microsoft.com/en-us/library/windows/desktop/aa365465(v=vs.85).aspx)
+        std::vector<BYTE> Buffer;
         LPARAM lParam;
         DWORD NotifyFilter;
         bool StopNow;
+        bool Extended;
         FileWatcherImpl* Watch;
         char* DirName;
         sLastModifiedEvent LastModifiedEvent;
+        std::vector<std::pair<std::string, LARGE_INTEGER>> OldFiles;
 };
 
 } // namespace efsw
diff --git a/src/3rdParty/efsw/base.hpp b/src/3rdParty/efsw/base.hpp
index 43abc4f..43abc4f 100755..100644
--- a/src/3rdParty/efsw/base.hpp
+++ b/src/3rdParty/efsw/base.hpp
diff --git a/src/3rdParty/efsw/efsw.h b/src/3rdParty/efsw/efsw.h
index 28e63e2..30cf595 100755..100644
--- a/src/3rdParty/efsw/efsw.h
+++ b/src/3rdParty/efsw/efsw.h
@@ -1,7 +1,7 @@
 /**
         @author Sepul Sepehr Taghdisian
 
-        Copyright (c) 2013 Martin Lucas Golini
+        Copyright (c) 2024 Martín Lucas Golini
 
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal
@@ -32,31 +32,31 @@
 extern "C" {
 #endif
 
-#if defined(_WIN32)
-        #ifdef EFSW_DYNAMIC
-                // Windows platforms
-                #ifdef EFSW_EXPORTS
-                        // From DLL side, we must export
-                        #define EFSW_API __declspec(dllexport)
-                #else
-                        // From client application side, we must import
-                        #define EFSW_API __declspec(dllimport)
-                #endif
-        #else
-                // No specific directive needed for static build
-                #ifndef EFSW_API
-                #define EFSW_API
-                #endif
-        #endif
+#if defined( _WIN32 )
+#ifdef EFSW_DYNAMIC
+// Windows platforms
+#ifdef EFSW_EXPORTS
+// From DLL side, we must export
+#define EFSW_API __declspec( dllexport )
 #else
-        #if ( __GNUC__ >= 4 ) && defined( EFSW_EXPORTS )
-                #define EFSW_API __attribute__ ((visibility("default")))
-        #endif
-
-        // Other platforms don't need to define anything
-        #ifndef EFSW_API
-        #define EFSW_API
-        #endif
+// From client application side, we must import
+#define EFSW_API __declspec( dllimport )
+#endif
+#else
+// No specific directive needed for static build
+#ifndef EFSW_API
+#define EFSW_API
+#endif
+#endif
+#else
+#if ( __GNUC__ >= 4 ) && defined( EFSW_EXPORTS )
+#define EFSW_API __attribute__( ( visibility( "default" ) ) )
+#endif
+
+// Other platforms don't need to define anything
+#ifndef EFSW_API
+#define EFSW_API
+#endif
 #endif
 
 /// Type for a watch id
@@ -65,84 +65,127 @@ typedef long efsw_watchid;
 /// Type for watcher
 typedef void* efsw_watcher;
 
-enum efsw_action
-{
-        EFSW_ADD = 1,           /// Sent when a file is created or renamed
-        EFSW_DELETE = 2,        /// Sent when a file is deleted or renamed
-        EFSW_MODIFIED = 3,      /// Sent when a file is modified
-        EFSW_MOVED = 4          /// Sent when a file is moved
+enum efsw_action {
+        EFSW_ADD = 1,      /// Sent when a file is created or renamed
+        EFSW_DELETE = 2,   /// Sent when a file is deleted or renamed
+        EFSW_MODIFIED = 3, /// Sent when a file is modified
+        EFSW_MOVED = 4     /// Sent when a file is moved
+};
+
+enum efsw_error {
+        EFSW_NOTFOUND = -1,
+        EFSW_REPEATED = -2,
+        EFSW_OUTOFSCOPE = -3,
+        EFSW_NOTREADABLE = -4,
+        EFSW_REMOTE = -5,
+        EFSW_WATCHER_FAILED = -6,
+        EFSW_UNSPECIFIED = -7
 };
 
-enum efsw_error
-{
-        EFSW_NOTFOUND           = -1,
-        EFSW_REPEATED           = -2,
-        EFSW_OUTOFSCOPE         = -3,
-        EFSW_NOTREADABLE        = -4,
-        EFSW_REMOTE                     = -5,
-        EFSW_UNSPECIFIED        = -6
+enum efsw_option {
+        /// For Windows, the default buffer size of 63*1024 bytes sometimes is not enough and
+        /// file system events may be dropped. For that, using a different (bigger) buffer size
+        /// can be defined here, but note that this does not work for network drives,
+        /// because a buffer larger than 64K will fail the folder being watched, see
+        /// http://msdn.microsoft.com/en-us/library/windows/desktop/aa365465(v=vs.85).aspx)
+        EFSW_OPT_WIN_BUFFER_SIZE = 1,
+        /// For Windows, per default all events are captured but we might only be interested
+        /// in a subset; the value of the option should be set to a bitwise or'ed set of
+        /// FILE_NOTIFY_CHANGE_* flags.
+        EFSW_OPT_WIN_NOTIFY_FILTER = 2,
+        /// For macOS (FSEvents backend), per default all modified event types are capture but we might
+        // only be interested in a subset; the value of the option should be set to a set of bitwise
+        // from:
+        // kFSEventStreamEventFlagItemFinderInfoMod
+        // kFSEventStreamEventFlagItemModified
+        // kFSEventStreamEventFlagItemInodeMetaMod
+        // Default configuration will set the 3 flags
+        EFSW_OPT_MAC_MODIFIED_FILTER = 3,
+        /// macOS sometimes informs incorrect or old file states that may confuse the consumer
+        /// The events sanitizer will try to sanitize incorrectly reported events in favor of reducing
+        /// the number of events reported. This will have an small performance and memory impact as a
+        /// consequence.
+        EFSW_OPT_MAC_SANITIZE_EVENTS = 4,
+        /// Linux does not support natively recursive watchers. This means that when using recursive
+        /// watches efsw registers new watchers for each directory. If new file are created between
+        /// the time efsw takes to register the new directory those events might be missed. To avoid
+        /// missing new file notifications efsw will trigger synthetic new file events for existing
+        /// files in the new directroy watched. This might have the unintended consequence of sending
+        /// duplicated created events due to the system also emitting this event.
+        LINUX_PRODUCE_SYNTHETIC_EVENTS = 5,
 };
 
 /// Basic interface for listening for file events.
-typedef void (*efsw_pfn_fileaction_callback) (
-                efsw_watcher watcher,
-                efsw_watchid watchid,
-                const char* dir,
-                const char* filename,
-                enum efsw_action action,
-                const char* old_filename,
-                void* param
-);
+typedef void ( *efsw_pfn_fileaction_callback )( efsw_watcher watcher, efsw_watchid watchid,
+                                                                                                const char* dir, const char* filename,
+                                                                                                enum efsw_action action, const char* old_filename,
+                                                                                                void* param );
+
+typedef struct {
+        enum efsw_option option;
+        int value;
+} efsw_watcher_option;
 
 /**
  * Creates a new file-watcher
  * @param generic_mode Force the use of the Generic file watcher
  */
-efsw_watcher EFSW_API efsw_create(int generic_mode);
+efsw_watcher EFSW_API efsw_create( int generic_mode );
 
 /// Release the file-watcher and unwatch any directories
-void EFSW_API efsw_release(efsw_watcher watcher);
+void EFSW_API efsw_release( efsw_watcher watcher );
 
-/// Retreive last error occured by file-watcher
+/// Retrieve last error occured by file-watcher
 EFSW_API const char* efsw_getlasterror();
 
-/// Add a directory watch. Same as the other addWatch, but doesn't have recursive option.
-/// For backwards compatibility.
+/// Reset file-watcher last error
+EFSW_API void efsw_clearlasterror();
+
+/// Add a directory watch
 /// On error returns WatchID with Error type.
-efsw_watchid EFSW_API efsw_addwatch(efsw_watcher watcher, const char* directory, 
-        efsw_pfn_fileaction_callback callback_fn, int recursive, void* param);
+efsw_watchid EFSW_API efsw_addwatch( efsw_watcher watcher, const char* directory,
+                                                                         efsw_pfn_fileaction_callback callback_fn, int recursive,
+                                                                         void* param );
+
+/// Add a directory watch, specifying options
+/// @param options Pointer to an array of watcher options
+/// @param nr_options Number of options referenced by \p options
+efsw_watchid EFSW_API efsw_addwatch_withoptions( efsw_watcher watcher, const char* directory,
+                                                                                                 efsw_pfn_fileaction_callback callback_fn,
+                                                                                                 int recursive, efsw_watcher_option* options,
+                                                                                                 int options_number, void* param );
 
 /// Remove a directory watch. This is a brute force search O(nlogn).
-void EFSW_API efsw_removewatch(efsw_watcher watcher, const char* directory);
+void EFSW_API efsw_removewatch( efsw_watcher watcher, const char* directory );
 
 /// Remove a directory watch. This is a map lookup O(logn).
-void EFSW_API efsw_removewatch_byid(efsw_watcher watcher, efsw_watchid watchid);
+void EFSW_API efsw_removewatch_byid( efsw_watcher watcher, efsw_watchid watchid );
 
 /// Starts watching ( in other thread )
-void EFSW_API efsw_watch(efsw_watcher watcher);
+void EFSW_API efsw_watch( efsw_watcher watcher );
 
 /**
  * Allow recursive watchers to follow symbolic links to other directories
  * followSymlinks is disabled by default
  */
-void EFSW_API efsw_follow_symlinks(efsw_watcher watcher, int enable);
+void EFSW_API efsw_follow_symlinks( efsw_watcher watcher, int enable );
 
 /** @return If can follow symbolic links to directorioes */
-int EFSW_API efsw_follow_symlinks_isenabled(efsw_watcher watcher);
+int EFSW_API efsw_follow_symlinks_isenabled( efsw_watcher watcher );
 
 /**
  * When enable this it will allow symlinks to watch recursively out of the pointed directory.
  * follorSymlinks must be enabled to this work.
- * For example, added symlink to /home/folder, and the symlink points to /, this by default is not allowed,
- * it's only allowed to symlink anything from /home/ and deeper. This is to avoid great levels of recursion.
- * Enabling this could lead in infinite recursion, and crash the watcher ( it will try not to avoid this ).
- * Buy enabling out of scope links, it will allow this behavior.
+ * For example, added symlink to /home/folder, and the symlink points to /, this by default is not
+ * allowed, it's only allowed to symlink anything from /home/ and deeper. This is to avoid great
+ * levels of recursion. Enabling this could lead in infinite recursion, and crash the watcher ( it
+ * will try not to avoid this ). Buy enabling out of scope links, it will allow this behavior.
  * allowOutOfScopeLinks are disabled by default.
  */
-void EFSW_API efsw_allow_outofscopelinks(efsw_watcher watcher, int allow);
+void EFSW_API efsw_allow_outofscopelinks( efsw_watcher watcher, int allow );
 
 /// @return Returns if out of scope links are allowed
-int EFSW_API efsw_outofscopelinks_isallowed(efsw_watcher watcher);
+int EFSW_API efsw_outofscopelinks_isallowed( efsw_watcher watcher );
 
 #ifdef __cplusplus
 }
diff --git a/src/3rdParty/efsw/efsw.hpp b/src/3rdParty/efsw/efsw.hpp
index 12af116..11a5dec 100755..100644
--- a/src/3rdParty/efsw/efsw.hpp
+++ b/src/3rdParty/efsw/efsw.hpp
@@ -1,195 +1,261 @@
-/**
-        @author Martín Lucas Golini
-
-        Copyright (c) 2013 Martín Lucas Golini
-
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-
-        The above copyright notice and this permission notice shall be included in
-        all copies or substantial portions of the Software.
-
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-        THE SOFTWARE.
-
-        This software is a fork of the "simplefilewatcher" by James Wynn (james@jameswynn.com)
-        http://code.google.com/p/simplefilewatcher/ also MIT licensed.
-*/
-
-#ifndef ESFW_HPP
-#define ESFW_HPP
-
-#include <list>
-#include <string>
-
-#if defined( _WIN32 )
-#ifdef EFSW_DYNAMIC
-// Windows platforms
-#ifdef EFSW_EXPORTS
-// From DLL side, we must export
-#define EFSW_API __declspec( dllexport )
-#else
-// From client application side, we must import
-#define EFSW_API __declspec( dllimport )
-#endif
-#else
-// No specific directive needed for static build
-#ifndef EFSW_API
-#define EFSW_API
-#endif
-#endif
-#else
-#if ( __GNUC__ >= 4 ) && defined( EFSW_EXPORTS )
-#ifndef EFSW_API
-#define EFSW_API __attribute__( ( visibility( "default" ) ) )
-#endif
-#endif
-
-// Other platforms don't need to define anything
-#ifndef EFSW_API
-#define EFSW_API
-#endif
-#endif
-
-namespace efsw {
-
-/// Type for a watch id
-typedef long WatchID;
-
-// forward declarations
-class FileWatcherImpl;
-class FileWatchListener;
-
-/// Actions to listen for. Rename will send two events, one for
-/// the deletion of the old file, and one for the creation of the
-/// new file.
-namespace Actions {
-enum Action {
-        /// Sent when a file is created or renamed
-        Add = 1,
-        /// Sent when a file is deleted or renamed
-        Delete = 2,
-        /// Sent when a file is modified
-        Modified = 3,
-        /// Sent when a file is moved
-        Moved = 4
-};
-}
-typedef Actions::Action Action;
-
-/// Errors log namespace
-namespace Errors {
-
-enum Error {
-        FileNotFound = -1,
-        FileRepeated = -2,
-        FileOutOfScope = -3,
-        FileNotReadable = -4,
-        FileRemote = -5, /** Directory in remote file system ( create a generic FileWatcher instance to
-                                                watch this directory ). */
-        Unspecified = -6
-};
-
-class EFSW_API Log {
-  public:
-        /// @return The last error logged
-        static std::string getLastErrorLog();
-
-        /// Creates an error of the type specified
-        static Error createLastError( Error err, std::string log );
-};
-
-} // namespace Errors
-typedef Errors::Error Error;
-
-/// Listens to files and directories and dispatches events
-/// to notify the listener of files and directories changes.
-/// @class FileWatcher
-class EFSW_API FileWatcher {
-  public:
-        /// Default constructor, will use the default platform file watcher
-        FileWatcher();
-
-        /// Constructor that lets you force the use of the Generic File Watcher
-        explicit FileWatcher( bool useGenericFileWatcher );
-
-        virtual ~FileWatcher();
-
-        /// Add a directory watch. Same as the other addWatch, but doesn't have recursive option.
-        /// For backwards compatibility.
-        /// On error returns WatchID with Error type.
-        WatchID addWatch( const std::string& directory, FileWatchListener* watcher );
-
-        /// Add a directory watch
-        /// On error returns WatchID with Error type.
-        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive );
-
-        /// Remove a directory watch. This is a brute force search O(nlogn).
-        void removeWatch( const std::string& directory );
-
-        /// Remove a directory watch. This is a map lookup O(logn).
-        void removeWatch( WatchID watchid );
-
-        /// Starts watching ( in other thread )
-        void watch();
-
-        /// @return Returns a list of the directories that are being watched
-        std::list<std::string> directories();
-
-        /** Allow recursive watchers to follow symbolic links to other directories
-         * followSymlinks is disabled by default
-         */
-        void followSymlinks( bool follow );
-
-        /** @return If can follow symbolic links to directorioes */
-        const bool& followSymlinks() const;
-
-        /** When enable this it will allow symlinks to watch recursively out of the pointed directory.
-         * follorSymlinks must be enabled to this work.
-         * For example, added symlink to /home/folder, and the symlink points to /, this by default is
-         * not allowed, it's only allowed to symlink anything from /home/ and deeper. This is to avoid
-         * great levels of recursion. Enabling this could lead in infinite recursion, and crash the
-         * watcher ( it will try not to avoid this ). Buy enabling out of scope links, it will allow
-         * this behavior. allowOutOfScopeLinks are disabled by default.
-         */
-        void allowOutOfScopeLinks( bool allow );
-
-        /// @return Returns if out of scope links are allowed
-        const bool& allowOutOfScopeLinks() const;
-
-  private:
-        /// The implementation
-        FileWatcherImpl* mImpl;
-        bool mFollowSymlinks;
-        bool mOutOfScopeLinks;
-};
-
-/// Basic interface for listening for file events.
-/// @class FileWatchListener
-class FileWatchListener {
-  public:
-        virtual ~FileWatchListener() {}
-
-        /// Handles the action file action
-        /// @param watchid The watch id for the directory
-        /// @param dir The directory
-        /// @param filename The filename that was accessed (not full path)
-        /// @param action Action that was performed
-        /// @param oldFilename The name of the file or directory moved
-        virtual void handleFileAction( WatchID watchid, const std::string& dir,
-                                                                   const std::string& filename, Action action,
-                                                                   std::string oldFilename = "" ) = 0;
-};
-
-} // namespace efsw
-
-#endif
+/**

+        @author Martín Lucas Golini

+

+        Copyright (c) 2024 Martín Lucas Golini

+

+        Permission is hereby granted, free of charge, to any person obtaining a copy

+        of this software and associated documentation files (the "Software"), to deal

+        in the Software without restriction, including without limitation the rights

+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+        copies of the Software, and to permit persons to whom the Software is

+        furnished to do so, subject to the following conditions:

+

+        The above copyright notice and this permission notice shall be included in

+        all copies or substantial portions of the Software.

+

+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

+        THE SOFTWARE.

+

+        This software is a fork of the "simplefilewatcher" by James Wynn (james@jameswynn.com)

+        http://code.google.com/p/simplefilewatcher/ also MIT licensed.

+*/

+

+#ifndef ESFW_HPP

+#define ESFW_HPP

+

+#include <string>

+#include <vector>

+

+#if defined( _WIN32 )

+#ifdef EFSW_DYNAMIC

+// Windows platforms

+#ifdef EFSW_EXPORTS

+// From DLL side, we must export

+#define EFSW_API __declspec( dllexport )

+#else

+// From client application side, we must import

+#define EFSW_API __declspec( dllimport )

+#endif

+#else

+// No specific directive needed for static build

+#ifndef EFSW_API

+#define EFSW_API

+#endif

+#endif

+#else

+#if ( __GNUC__ >= 4 ) && defined( EFSW_EXPORTS )

+#ifndef EFSW_API

+#define EFSW_API __attribute__( ( visibility( "default" ) ) )

+#endif

+#endif

+

+// Other platforms don't need to define anything

+#ifndef EFSW_API

+#define EFSW_API

+#endif

+#endif

+

+namespace efsw {

+

+/// Type for a watch id

+typedef long WatchID;

+

+// forward declarations

+class FileWatcherImpl;

+class FileWatchListener;

+class WatcherOption;

+

+/// Actions to listen for. Rename will send two events, one for

+/// the deletion of the old file, and one for the creation of the

+/// new file.

+namespace Actions {

+enum Action {

+        /// Sent when a file is created or renamed

+        Add = 1,

+        /// Sent when a file is deleted or renamed

+        Delete = 2,

+        /// Sent when a file is modified

+        Modified = 3,

+        /// Sent when a file is moved

+        Moved = 4

+};

+}

+typedef Actions::Action Action;

+

+/// Errors log namespace

+namespace Errors {

+

+enum Error {

+        NoError = 0,

+        FileNotFound = -1,

+        FileRepeated = -2,

+        FileOutOfScope = -3,

+        FileNotReadable = -4,

+        /// Directory in remote file system

+        /// ( create a generic FileWatcher instance to watch this directory ).

+        FileRemote = -5,

+        /// File system watcher failed to watch for changes.

+        WatcherFailed = -6,

+        Unspecified = -7

+};

+

+class EFSW_API Log {

+  public:

+        /// @return The last error logged

+        static std::string getLastErrorLog();

+

+        /// @return The code of the last error logged

+        static Error getLastErrorCode();

+

+        /// Reset last error

+        static void clearLastError();

+

+        /// Creates an error of the type specified

+        static Error createLastError( Error err, std::string log );

+};

+

+} // namespace Errors

+typedef Errors::Error Error;

+

+/// Optional file watcher settings.

+namespace Options {

+enum Option {

+        /// For Windows, the default buffer size of 63*1024 bytes sometimes is not enough and

+        /// file system events may be dropped. For that, using a different (bigger) buffer size

+        /// can be defined here, but note that this does not work for network drives,

+        /// because a buffer larger than 64K will fail the folder being watched, see

+        /// http://msdn.microsoft.com/en-us/library/windows/desktop/aa365465(v=vs.85).aspx)

+        WinBufferSize = 1,

+        /// For Windows, per default all events are captured but we might only be interested

+        /// in a subset; the value of the option should be set to a bitwise or'ed set of

+        /// FILE_NOTIFY_CHANGE_* flags.

+        WinNotifyFilter = 2,

+        /// For macOS (FSEvents backend), per default all modified event types are capture but we might

+        /// only be interested in a subset; the value of the option should be set to a set of bitwise

+        /// from:

+        /// kFSEventStreamEventFlagItemFinderInfoMod

+        /// kFSEventStreamEventFlagItemModified

+        /// kFSEventStreamEventFlagItemInodeMetaMod

+        /// Default configuration will set the 3 flags

+        MacModifiedFilter = 3,

+        /// macOS sometimes informs incorrect or old file states that may confuse the consumer

+        /// The events sanitizer will try to sanitize incorrectly reported events in favor of reducing

+        /// the number of events reported. This will have an small performance and memory impact as a

+        /// consequence.

+        MacSanitizeEvents = 4,

+        /// Linux does not support natively recursive watchers. This means that when using recursive

+        /// watches efsw registers new watchers for each directory. If new file are created between

+        /// the time efsw takes to register the new directory those events might be missed. To avoid

+        /// missing new file notifications efsw will trigger synthetic created file events for existing

+        /// files in the new directroy watched. This might have the unintended consequence of sending

+        /// duplicated created events due to the system also emitting this event.

+        LinuxProduceSyntheticEvents = 5,

+};

+}

+typedef Options::Option Option;

+

+/// Listens to files and directories and dispatches events

+/// to notify the listener of files and directories changes.

+/// @class FileWatcher

+class EFSW_API FileWatcher {

+  public:

+        /// Default constructor, will use the default platform file watcher

+        FileWatcher();

+

+        /// Constructor that lets you force the use of the Generic File Watcher

+        explicit FileWatcher( bool useGenericFileWatcher );

+

+        virtual ~FileWatcher();

+

+        /// Add a directory watch. Same as the other addWatch, but doesn't have recursive option.

+        /// For backwards compatibility.

+        /// On error returns WatchID with Error type.

+        WatchID addWatch( const std::string& directory, FileWatchListener* watcher );

+

+        /// Add a directory watch

+        /// On error returns WatchID with Error type.

+        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive );

+

+        /// Add a directory watch, allowing customization with options

+        /// @param directory The folder to be watched

+        /// @param watcher The listener to receive events

+        /// @param recursive Set this to true to include subdirectories

+        /// @param options Allows customization of a watcher

+        /// @return Returns the watch id for the directory or, on error, a WatchID with Error type.

+        WatchID addWatch( const std::string& directory, FileWatchListener* watcher, bool recursive,

+                                          const std::vector<WatcherOption>& options );

+

+        /// Remove a directory watch. This is a brute force search O(nlogn).

+        void removeWatch( const std::string& directory );

+

+        /// Remove a directory watch. This is a map lookup O(logn).

+        void removeWatch( WatchID watchid );

+

+        /// Starts watching ( in other thread )

+        void watch();

+

+        /// @return Returns a list of the directories that are being watched

+        std::vector<std::string> directories();

+

+        /** Allow recursive watchers to follow symbolic links to other directories

+         * followSymlinks is disabled by default

+         */

+        void followSymlinks( bool follow );

+

+        /** @return If can follow symbolic links to directorioes */

+        const bool& followSymlinks() const;

+

+        /** When enable this it will allow symlinks to watch recursively out of the pointed directory.

+         * follorSymlinks must be enabled to this work.

+         * For example, added symlink to /home/folder, and the symlink points to /, this by default is

+         * not allowed, it's only allowed to symlink anything from /home/ and deeper. This is to avoid

+         * great levels of recursion. Enabling this could lead in infinite recursion, and crash the

+         * watcher ( it will try not to avoid this ). Buy enabling out of scope links, it will allow

+         * this behavior. allowOutOfScopeLinks are disabled by default.

+         */

+        void allowOutOfScopeLinks( bool allow );

+

+        /// @return Returns if out of scope links are allowed

+        const bool& allowOutOfScopeLinks() const;

+

+  private:

+        /// The implementation

+        FileWatcherImpl* mImpl;

+        bool mFollowSymlinks;

+        bool mOutOfScopeLinks;

+};

+

+/// Basic interface for listening for file events.

+/// @class FileWatchListener

+class FileWatchListener {

+  public:

+        virtual ~FileWatchListener() {}

+

+        /// Handles the action file action

+        /// @param watchid The watch id for the directory

+        /// @param dir The directory

+        /// @param filename The filename that was accessed (not full path)

+        /// @param action Action that was performed

+        /// @param oldFilename The name of the file or directory moved

+        virtual void handleFileAction( WatchID watchid, const std::string& dir,

+                                                                   const std::string& filename, Action action,

+                                                                   std::string oldFilename = "" ) = 0;

+};

+

+/// Optional, typically platform specific parameter for customization of a watcher.

+/// @class WatcherOption

+class WatcherOption {

+  public:

+        WatcherOption( Option option, int value ) : mOption( option ), mValue( value ){};

+        Option mOption;

+        int mValue;

+};

+

+} // namespace efsw

+

+#endif

diff --git a/src/3rdParty/efsw/inotify-nosys.h b/src/3rdParty/efsw/inotify-nosys.h
index be1e627..be1e627 100755..100644
--- a/src/3rdParty/efsw/inotify-nosys.h
+++ b/src/3rdParty/efsw/inotify-nosys.h
diff --git a/src/3rdParty/efsw/platform/platformimpl.hpp b/src/3rdParty/efsw/platform/platformimpl.hpp
index 5442580..5442580 100755..100644
--- a/src/3rdParty/efsw/platform/platformimpl.hpp
+++ b/src/3rdParty/efsw/platform/platformimpl.hpp
diff --git a/src/3rdParty/efsw/platform/posix/FileSystemImpl.cpp b/src/3rdParty/efsw/platform/posix/FileSystemImpl.cpp
index 92eeb47..92eeb47 100755..100644
--- a/src/3rdParty/efsw/platform/posix/FileSystemImpl.cpp
+++ b/src/3rdParty/efsw/platform/posix/FileSystemImpl.cpp
diff --git a/src/3rdParty/efsw/platform/posix/FileSystemImpl.hpp b/src/3rdParty/efsw/platform/posix/FileSystemImpl.hpp
index 0bfba76..0bfba76 100755..100644
--- a/src/3rdParty/efsw/platform/posix/FileSystemImpl.hpp
+++ b/src/3rdParty/efsw/platform/posix/FileSystemImpl.hpp
diff --git a/src/3rdParty/efsw/platform/posix/MutexImpl.cpp b/src/3rdParty/efsw/platform/posix/MutexImpl.cpp
index 2233798..2233798 100755..100644
--- a/src/3rdParty/efsw/platform/posix/MutexImpl.cpp
+++ b/src/3rdParty/efsw/platform/posix/MutexImpl.cpp
diff --git a/src/3rdParty/efsw/platform/posix/MutexImpl.hpp b/src/3rdParty/efsw/platform/posix/MutexImpl.hpp
index a33d827..a33d827 100755..100644
--- a/src/3rdParty/efsw/platform/posix/MutexImpl.hpp
+++ b/src/3rdParty/efsw/platform/posix/MutexImpl.hpp
diff --git a/src/3rdParty/efsw/platform/posix/SystemImpl.cpp b/src/3rdParty/efsw/platform/posix/SystemImpl.cpp
index 37d4120..37d4120 100755..100644
--- a/src/3rdParty/efsw/platform/posix/SystemImpl.cpp
+++ b/src/3rdParty/efsw/platform/posix/SystemImpl.cpp
diff --git a/src/3rdParty/efsw/platform/posix/SystemImpl.hpp b/src/3rdParty/efsw/platform/posix/SystemImpl.hpp
index 9322b06..9322b06 100755..100644
--- a/src/3rdParty/efsw/platform/posix/SystemImpl.hpp
+++ b/src/3rdParty/efsw/platform/posix/SystemImpl.hpp
diff --git a/src/3rdParty/efsw/platform/posix/ThreadImpl.cpp b/src/3rdParty/efsw/platform/posix/ThreadImpl.cpp
index e0ae84f..772fbc9 100755..100644
--- a/src/3rdParty/efsw/platform/posix/ThreadImpl.cpp
+++ b/src/3rdParty/efsw/platform/posix/ThreadImpl.cpp
@@ -5,11 +5,10 @@
 
 #include <cassert>
 #include <efsw/Debug.hpp>
-#include <iostream>
 
 namespace efsw { namespace Platform {
 
-ThreadImpl::ThreadImpl( Thread* owner ) : mIsActive( false ) {
+ThreadImpl::ThreadImpl( efsw::Thread* owner ) : mIsActive( false ) {
         mIsActive = pthread_create( &mThread, NULL, &ThreadImpl::entryPoint, owner ) == 0;
 
         if ( !mIsActive ) {
@@ -17,14 +16,16 @@ ThreadImpl::ThreadImpl( Thread* owner ) : mIsActive( false ) {
         }
 }
 
+ThreadImpl::~ThreadImpl() {
+        terminate();
+}
+
 void ThreadImpl::wait() {
         // Wait for the thread to finish, no timeout
         if ( mIsActive ) {
                 assert( pthread_equal( pthread_self(), mThread ) == 0 );
 
-                pthread_join( mThread, NULL );
-
-                mIsActive = false; // Reset the thread state
+                mIsActive = pthread_join( mThread, NULL ) != 0;
         }
 }
 
@@ -41,14 +42,14 @@ void ThreadImpl::terminate() {
 }
 
 void* ThreadImpl::entryPoint( void* userData ) {
-        // The Thread instance is stored in the user data
-        Thread* owner = static_cast<Thread*>( userData );
-
 // Tell the thread to handle cancel requests immediatly
 #ifdef PTHREAD_CANCEL_ASYNCHRONOUS
         pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, NULL );
 #endif
 
+        // The Thread instance is stored in the user data
+        Thread* owner = static_cast<Thread*>( userData );
+
         // Forward to the owner
         owner->run();
 
diff --git a/src/3rdParty/efsw/platform/posix/ThreadImpl.hpp b/src/3rdParty/efsw/platform/posix/ThreadImpl.hpp
index ffc6da0..2e02f9a 100755..100644
--- a/src/3rdParty/efsw/platform/posix/ThreadImpl.hpp
+++ b/src/3rdParty/efsw/platform/posix/ThreadImpl.hpp
@@ -5,6 +5,7 @@
 
 #if defined( EFSW_PLATFORM_POSIX )
 
+#include <efsw/Atomic.hpp>
 #include <pthread.h>
 
 namespace efsw {
@@ -15,7 +16,9 @@ namespace Platform {
 
 class ThreadImpl {
   public:
-        ThreadImpl( Thread* owner );
+        explicit ThreadImpl( efsw::Thread* owner );
+
+        ~ThreadImpl();
 
         void wait();
 
@@ -25,7 +28,7 @@ class ThreadImpl {
         static void* entryPoint( void* userData );
 
         pthread_t mThread;
-        bool mIsActive;
+        Atomic<bool> mIsActive;
 };
 
 } // namespace Platform
diff --git a/src/3rdParty/efsw/platform/win/FileSystemImpl.cpp b/src/3rdParty/efsw/platform/win/FileSystemImpl.cpp
index 2b87513..2b87513 100755..100644
--- a/src/3rdParty/efsw/platform/win/FileSystemImpl.cpp
+++ b/src/3rdParty/efsw/platform/win/FileSystemImpl.cpp
diff --git a/src/3rdParty/efsw/platform/win/FileSystemImpl.hpp b/src/3rdParty/efsw/platform/win/FileSystemImpl.hpp
index e952efc..e952efc 100755..100644
--- a/src/3rdParty/efsw/platform/win/FileSystemImpl.hpp
+++ b/src/3rdParty/efsw/platform/win/FileSystemImpl.hpp
diff --git a/src/3rdParty/efsw/platform/win/MutexImpl.cpp b/src/3rdParty/efsw/platform/win/MutexImpl.cpp
index 62b7f83..62b7f83 100755..100644
--- a/src/3rdParty/efsw/platform/win/MutexImpl.cpp
+++ b/src/3rdParty/efsw/platform/win/MutexImpl.cpp
diff --git a/src/3rdParty/efsw/platform/win/MutexImpl.hpp b/src/3rdParty/efsw/platform/win/MutexImpl.hpp
index 7b06492..7b06492 100755..100644
--- a/src/3rdParty/efsw/platform/win/MutexImpl.hpp
+++ b/src/3rdParty/efsw/platform/win/MutexImpl.hpp
diff --git a/src/3rdParty/efsw/platform/win/SystemImpl.cpp b/src/3rdParty/efsw/platform/win/SystemImpl.cpp
index d1f2b21..d1f2b21 100755..100644
--- a/src/3rdParty/efsw/platform/win/SystemImpl.cpp
+++ b/src/3rdParty/efsw/platform/win/SystemImpl.cpp
diff --git a/src/3rdParty/efsw/platform/win/SystemImpl.hpp b/src/3rdParty/efsw/platform/win/SystemImpl.hpp
index 99b4867..99b4867 100755..100644
--- a/src/3rdParty/efsw/platform/win/SystemImpl.hpp
+++ b/src/3rdParty/efsw/platform/win/SystemImpl.hpp
diff --git a/src/3rdParty/efsw/platform/win/ThreadImpl.cpp b/src/3rdParty/efsw/platform/win/ThreadImpl.cpp
index d0fde8b..463934c 100755..100644
--- a/src/3rdParty/efsw/platform/win/ThreadImpl.cpp
+++ b/src/3rdParty/efsw/platform/win/ThreadImpl.cpp
@@ -8,7 +8,7 @@
 
 namespace efsw { namespace Platform {
 
-ThreadImpl::ThreadImpl( Thread* owner ) {
+ThreadImpl::ThreadImpl( efsw::Thread* owner ) {
         mThread = reinterpret_cast<HANDLE>(
                 _beginthreadex( NULL, 0, &ThreadImpl::entryPoint, owner, 0, &mThreadId ) );
 
diff --git a/src/3rdParty/efsw/platform/win/ThreadImpl.hpp b/src/3rdParty/efsw/platform/win/ThreadImpl.hpp
index 1afb593..455f24c 100755..100644
--- a/src/3rdParty/efsw/platform/win/ThreadImpl.hpp
+++ b/src/3rdParty/efsw/platform/win/ThreadImpl.hpp
@@ -19,7 +19,7 @@ namespace Platform {
 
 class ThreadImpl {
   public:
-        ThreadImpl( Thread* owner );
+        explicit ThreadImpl( efsw::Thread* owner );
 
         ~ThreadImpl();
 
diff --git a/src/3rdParty/efsw/sophist.h b/src/3rdParty/efsw/sophist.h
index 3a64504..82e5c36 100755..100644
--- a/src/3rdParty/efsw/sophist.h
+++ b/src/3rdParty/efsw/sophist.h
@@ -1,147 +1,147 @@
-/* sophist.h - 0.3 - public domain - Sean Barrett 2010
-** Knowledge drawn from Brian Hook's posh.h and http://predef.sourceforge.net
-** Sophist provides portable types; you typedef/#define them to your own names
-**
-** defines:
-**   - SOPHIST_endian    - either SOPHIST_little_endian or SOPHIST_big_endian
-**   - SOPHIST_has_64    - either 0 or 1; if 0, int64 types aren't defined
-**   - SOPHIST_pointer64 - either 0 or 1; if 1, pointer is 64-bit
-**
-**   - SOPHIST_intptr, SOPHIST_uintptr - integer same size as pointer
-**   - SOPHIST_int8,  SOPHIST_uint8,  SOPHIST_int16, SOPHIST_uint16
-**   - SOPHIST_int32, SOPHIST_uint32, SOPHIST_int64, SOPHIST_uint64
-**   - SOPHIST_int64_constant(number)      - macros for creating 64-bit
-**   - SOPHIST_uint64_constant(number)       integer constants
-**   - SOPHIST_printf_format64 - string for printf format for int64
-*/
-
-#ifndef __INCLUDE_SOPHIST_H__
-#define __INCLUDE_SOPHIST_H__
-
-#define SOPHIST_compiletime_assert(name,val) \
-            typedef int SOPHIST__assert##name[(val) ? 1 : -1]
-
-/* define a couple synthetic rules to make code more readable */
-#if (defined(__sparc__) || defined(__sparc)) && \
-    (defined(__arch64__) || defined(__sparcv9) || defined(__sparc_v9__))
-  #define SOPHIST_sparc64
-#endif
-
-#if (defined(linux) || defined(__linux__)) &&   \
-    (defined(__alpha)||defined(__alpha__)||defined(__x86_64__)||defined(_M_X64))
-  #define SOPHIST_linux64
-#endif
-
-/* basic types */
-typedef   signed  char SOPHIST_int8;
-typedef unsigned  char SOPHIST_uint8;
-
-typedef   signed short SOPHIST_int16;
-typedef unsigned short SOPHIST_uint16;
-
-#ifdef __palmos__
-  typedef   signed long SOPHIST_int32;
-  typedef unsigned long SOPHIST_uint32;
-#else
-  typedef   signed  int SOPHIST_int32;
-  typedef unsigned  int SOPHIST_uint32;
-#endif
-
-#ifndef SOPHIST_NO_64
-   #if defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__)     \
-       || (defined(__alpha) && defined(__DECC))
-
-     typedef   signed __int64 SOPHIST_int64;
-     typedef unsigned __int64 SOPHIST_uint64;
-     #define SOPHIST_has_64              1
-     #define SOPHIST_int64_constant(x)   (x##i64)
-     #define SOPHIST_uint64_constant(x)  (x##ui64)
-     #define SOPHIST_printf_format64     "I64"
-
-   #elif defined(__LP64__) || defined(__powerpc64__) || defined(SOPHIST_sparc64)
-
-     typedef   signed long    SOPHIST_int64;
-     typedef unsigned long    SOPHIST_uint64;
-
-     #define SOPHIST_has_64              1
-     #define SOPHIST_int64_constant(x)   ((SOPHIST_int64) x)
-     #define SOPHIST_uint64_constant(x)  ((SOPHIST_uint64) x)
-     #define SOPHIST_printf_format64     "l"
-
-   #elif defined(_LONG_LONG) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)  \
-       || defined(__GNUC__)  || defined(__MWERKS__) || defined(__APPLE_CC__) \
-       || defined(sgi)       || defined (__sgi)     || defined(__sgi__)      \
-       || defined(_CRAYC)
-
-     typedef   signed long long SOPHIST_int64;
-     typedef unsigned long long SOPHIST_uint64;
-
-     #define SOPHIST_has_64              1
-     #define SOPHIST_int64_constant(x)   (x##LL)
-     #define SOPHIST_uint64_constant(x)  (x##ULL)
-     #define SOPHIST_printf_format64     "ll"
-   #endif
-#endif
-
-#ifndef SOPHIST_has_64
-#define SOPHIST_has_64 0
-#endif
-
-SOPHIST_compiletime_assert( int8 , sizeof(SOPHIST_int8 ) == 1);
-SOPHIST_compiletime_assert(uint16, sizeof(SOPHIST_int16) == 2);
-SOPHIST_compiletime_assert( int32, sizeof(SOPHIST_int32 ) == 4);
-SOPHIST_compiletime_assert(uint32, sizeof(SOPHIST_uint32) == 4);
-
-#if SOPHIST_has_64
-  SOPHIST_compiletime_assert( int64, sizeof(SOPHIST_int64 ) == 8);
-  SOPHIST_compiletime_assert(uint64, sizeof(SOPHIST_uint64) == 8);
-#endif
-
-/* determine whether pointers are 64-bit */
-
-#if    defined(SOPHIST_linux64) || defined(SOPHIST_sparc64)      \
-    || defined(__osf__) || (defined(_WIN64) && !defined(_XBOX))  \
-    || defined(__64BIT__)                                        \
-    || defined(__LP64)  || defined(__LP64__) || defined(_LP64)   \
-    || defined(_ADDR64) || defined(_CRAYC)                       \
-
-  #define SOPHIST_pointer64 1
-
-  SOPHIST_compiletime_assert(pointer64, sizeof(void*) == 8);  
-
-  typedef SOPHIST_int64  SOPHIST_intptr;
-  typedef SOPHIST_uint64 SOPHIST_uintptr;
-#else
-
-  #define SOPHIST_pointer64 0
-
-  SOPHIST_compiletime_assert(pointer64, sizeof(void*) <= 4);  
-  
-  /* do we care about pointers that are only 16-bit? */
-  typedef SOPHIST_int32  SOPHIST_intptr;
-  typedef SOPHIST_uint32 SOPHIST_uintptr;
-
-#endif 
-
-SOPHIST_compiletime_assert(intptr, sizeof(SOPHIST_intptr) == sizeof(char *));
-
-/* enumerate known little endian cases; fallback to big-endian */
-
-#define SOPHIST_little_endian 1
-#define SOPHIST_big_endian 2
-
-#if    defined(__386__) || defined(i386)    || defined(__i386__)  \
-    || defined(__X86)   || defined(_M_IX86)                       \
-    || defined(_M_X64)  || defined(__x86_64__)                    \
-    || defined(alpha)   || defined(__alpha) || defined(__alpha__) \
-    || defined(_M_ALPHA)                                          \
-    || defined(ARM)     || defined(_ARM)    || defined(__arm__)   \
-    || defined(WIN32)   || defined(_WIN32)  || defined(__WIN32__) \
-    || defined(_WIN32_WCE) || defined(__NT__)                     \
-    || defined(__MIPSEL__)
-  #define SOPHIST_endian  SOPHIST_little_endian
-#else
-  #define SOPHIST_endian  SOPHIST_big_endian
-#endif
-
-#endif /* __INCLUDE_SOPHIST_H__ */
+/* sophist.h - 0.3 - public domain - Sean Barrett 2010

+** Knowledge drawn from Brian Hook's posh.h and http://predef.sourceforge.net

+** Sophist provides portable types; you typedef/#define them to your own names

+**

+** defines:

+**   - SOPHIST_endian    - either SOPHIST_little_endian or SOPHIST_big_endian

+**   - SOPHIST_has_64    - either 0 or 1; if 0, int64 types aren't defined

+**   - SOPHIST_pointer64 - either 0 or 1; if 1, pointer is 64-bit

+**

+**   - SOPHIST_intptr, SOPHIST_uintptr - integer same size as pointer

+**   - SOPHIST_int8,  SOPHIST_uint8,  SOPHIST_int16, SOPHIST_uint16

+**   - SOPHIST_int32, SOPHIST_uint32, SOPHIST_int64, SOPHIST_uint64

+**   - SOPHIST_int64_constant(number)      - macros for creating 64-bit

+**   - SOPHIST_uint64_constant(number)       integer constants

+**   - SOPHIST_printf_format64 - string for printf format for int64

+*/

+

+#ifndef __INCLUDE_SOPHIST_H__

+#define __INCLUDE_SOPHIST_H__

+

+#define SOPHIST_compiletime_assert(name,val) \

+            typedef int SOPHIST__assert##name[(val) ? 1 : -1]

+

+/* define a couple synthetic rules to make code more readable */

+#if (defined(__sparc__) || defined(__sparc)) && \

+    (defined(__arch64__) || defined(__sparcv9) || defined(__sparc_v9__))

+  #define SOPHIST_sparc64

+#endif

+

+#if (defined(linux) || defined(__linux__)) &&   \

+    (defined(__alpha)||defined(__alpha__)||defined(__x86_64__)||defined(_M_X64))

+  #define SOPHIST_linux64

+#endif

+

+/* basic types */

+typedef   signed  char SOPHIST_int8;

+typedef unsigned  char SOPHIST_uint8;

+

+typedef   signed short SOPHIST_int16;

+typedef unsigned short SOPHIST_uint16;

+

+#ifdef __palmos__

+  typedef   signed long SOPHIST_int32;

+  typedef unsigned long SOPHIST_uint32;

+#else

+  typedef   signed  int SOPHIST_int32;

+  typedef unsigned  int SOPHIST_uint32;

+#endif

+

+#ifndef SOPHIST_NO_64

+   #if defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__)     \

+       || (defined(__alpha) && defined(__DECC))

+

+     typedef   signed __int64 SOPHIST_int64;

+     typedef unsigned __int64 SOPHIST_uint64;

+     #define SOPHIST_has_64              1

+     #define SOPHIST_int64_constant(x)   (x##i64)

+     #define SOPHIST_uint64_constant(x)  (x##ui64)

+     #define SOPHIST_printf_format64     "I64"

+

+   #elif defined(__LP64__) || defined(__powerpc64__) || defined(SOPHIST_sparc64)

+

+     typedef   signed long    SOPHIST_int64;

+     typedef unsigned long    SOPHIST_uint64;

+

+     #define SOPHIST_has_64              1

+     #define SOPHIST_int64_constant(x)   ((SOPHIST_int64) x)

+     #define SOPHIST_uint64_constant(x)  ((SOPHIST_uint64) x)

+     #define SOPHIST_printf_format64     "l"

+

+   #elif defined(_LONG_LONG) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)  \

+       || defined(__GNUC__)  || defined(__MWERKS__) || defined(__APPLE_CC__) \

+       || defined(sgi)       || defined (__sgi)     || defined(__sgi__)      \

+       || defined(_CRAYC)

+

+     typedef   signed long long SOPHIST_int64;

+     typedef unsigned long long SOPHIST_uint64;

+

+     #define SOPHIST_has_64              1

+     #define SOPHIST_int64_constant(x)   (x##LL)

+     #define SOPHIST_uint64_constant(x)  (x##ULL)

+     #define SOPHIST_printf_format64     "ll"

+   #endif

+#endif

+

+#ifndef SOPHIST_has_64

+#define SOPHIST_has_64 0

+#endif

+

+SOPHIST_compiletime_assert( int8 , sizeof(SOPHIST_int8 ) == 1);

+SOPHIST_compiletime_assert(uint16, sizeof(SOPHIST_int16) == 2);

+SOPHIST_compiletime_assert( int32, sizeof(SOPHIST_int32 ) == 4);

+SOPHIST_compiletime_assert(uint32, sizeof(SOPHIST_uint32) == 4);

+

+#if SOPHIST_has_64

+  SOPHIST_compiletime_assert( int64, sizeof(SOPHIST_int64 ) == 8);

+  SOPHIST_compiletime_assert(uint64, sizeof(SOPHIST_uint64) == 8);

+#endif

+

+/* determine whether pointers are 64-bit */

+

+#if    defined(SOPHIST_linux64) || defined(SOPHIST_sparc64)      \

+    || defined(__osf__) || (defined(_WIN64) && !defined(_XBOX))  \

+    || defined(__64BIT__)                                        \

+    || defined(__LP64)  || defined(__LP64__) || defined(_LP64)   \

+    || defined(_ADDR64) || defined(_CRAYC)                       \

+

+  #define SOPHIST_pointer64 1

+

+  SOPHIST_compiletime_assert(pointer64, sizeof(void*) == 8);  

+

+  typedef SOPHIST_int64  SOPHIST_intptr;

+  typedef SOPHIST_uint64 SOPHIST_uintptr;

+#else

+

+  #define SOPHIST_pointer64 0

+

+  SOPHIST_compiletime_assert(pointer64, sizeof(void*) <= 4);  

+  

+  /* do we care about pointers that are only 16-bit? */

+  typedef SOPHIST_int32  SOPHIST_intptr;

+  typedef SOPHIST_uint32 SOPHIST_uintptr;

+

+#endif 

+

+SOPHIST_compiletime_assert(intptr, sizeof(SOPHIST_intptr) == sizeof(char *));

+

+/* enumerate known little endian cases; fallback to big-endian */

+

+#define SOPHIST_little_endian 1

+#define SOPHIST_big_endian 2

+

+#if    defined(__386__) || defined(i386)    || defined(__i386__)  \

+    || defined(__X86)   || defined(_M_IX86)                       \

+    || defined(_M_X64)  || defined(__x86_64__)                    \

+    || defined(alpha)   || defined(__alpha) || defined(__alpha__) \

+    || defined(_M_ALPHA)                                          \

+    || defined(ARM)     || defined(_ARM)    || defined(__arm__)   \

+    || defined(WIN32)   || defined(_WIN32)  || defined(__WIN32__) \

+    || defined(_WIN32_WCE) || defined(__NT__)                     \

+    || defined(__MIPSEL__)

+  #define SOPHIST_endian  SOPHIST_little_endian

+#else

+  #define SOPHIST_endian  SOPHIST_big_endian

+#endif

+

+#endif /* __INCLUDE_SOPHIST_H__ */

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 e670126..1937eb8 100644
--- a/src/yuescript/yue_ast.h
+++ b/src/yuescript/yue_ast.h
@@ -233,8 +233,15 @@ AST_NODE(ImportAs)
         AST_MEMBER(ImportAs, &literal, &target)
 AST_END(ImportAs)
 
+AST_NODE(ImportGlobal)
+        ast_ptr<true, Seperator_t> sep;
+        ast_list<true, UnicodeName_t> segs;
+        ast_ptr<false, Variable_t> target;
+        AST_MEMBER(ImportGlobal, &sep, &segs, &target)
+AST_END(ImportGlobal)
+
 AST_NODE(Import)
-        ast_sel<true, ImportAs_t, ImportFrom_t, FromImport_t> content;
+        ast_sel<true, ImportAs_t, ImportFrom_t, FromImport_t, ImportGlobal_t> content;
         AST_MEMBER(Import, &content)
 AST_END(Import)
 
@@ -273,6 +280,8 @@ AST_NODE(ExpList)
         ast_ptr<true, Seperator_t> sep;
         ast_list<true, Exp_t> exprs;
         AST_MEMBER(ExpList, &sep, &exprs)
+        bool followStmtProcessed = false;
+        Statement_t* followStmt = nullptr;
 AST_END(ExpList)
 
 AST_NODE(Return)
@@ -285,9 +294,9 @@ AST_END(Return)
 AST_NODE(With)
         ast_ptr<false, ExistentialOp_t> eop;
         ast_ptr<true, ExpList_t> valueList;
-        ast_ptr<false, Assign_t> assigns;
+        ast_ptr<false, Assign_t> assign;
         ast_sel<true, Block_t, Statement_t> body;
-        AST_MEMBER(With, &eop, &valueList, &assigns, &body)
+        AST_MEMBER(With, &eop, &valueList, &assign, &body)
 AST_END(With)
 
 AST_NODE(SwitchList)
@@ -302,20 +311,21 @@ AST_NODE(SwitchCase)
         AST_MEMBER(SwitchCase, &condition, &body)
 AST_END(SwitchCase)
 
+AST_NODE(Assignment)
+        ast_ptr<false, ExpList_t> expList;
+        ast_ptr<true, Assign_t> assign;
+        AST_MEMBER(Assignment, &expList, &assign)
+AST_END(Assignment)
+
 AST_NODE(Switch)
         ast_ptr<true, Exp_t> target;
+        ast_ptr<false, Assignment_t> assignment;
         ast_ptr<true, Seperator_t> sep;
         ast_list<true, SwitchCase_t> branches;
         ast_sel<false, Block_t, Statement_t> lastBranch;
-        AST_MEMBER(Switch, &target, &sep, &branches, &lastBranch)
+        AST_MEMBER(Switch, &target, &assignment, &sep, &branches, &lastBranch)
 AST_END(Switch)
 
-AST_NODE(Assignment)
-        ast_ptr<false, ExpList_t> expList;
-        ast_ptr<true, Assign_t> assign;
-        AST_MEMBER(Assignment, &expList, &assign)
-AST_END(Assignment)
-
 AST_NODE(IfCond)
         ast_ptr<true, Exp_t> condition;
         ast_ptr<false, Assignment_t> assignment;
@@ -343,7 +353,7 @@ AST_NODE(While)
 AST_END(While)
 
 AST_NODE(Repeat)
-        ast_ptr<true, Body_t> body;
+        ast_sel<true, Block_t, Statement_t> body;
         ast_ptr<true, Exp_t> condition;
         AST_MEMBER(Repeat, &body, &condition)
 AST_END(Repeat)
@@ -381,9 +391,10 @@ AST_NODE(CatchBlock)
 AST_END(CatchBlock)
 
 AST_NODE(Try)
+        ast_ptr<false, ExistentialOp_t> eop;
         ast_sel<true, Block_t, Exp_t> func;
         ast_ptr<false, CatchBlock_t> catchBlock;
-        AST_MEMBER(Try, &func, &catchBlock)
+        AST_MEMBER(Try, &eop, &func, &catchBlock)
 AST_END(Try)
 
 AST_NODE(Comprehension)
@@ -547,8 +558,8 @@ AST_NODE(SimpleValue)
         ast_sel<true,
                 TableLit_t, ConstValue_t,
                 If_t, Switch_t, With_t, ClassDecl_t,
-                ForEach_t, For_t, While_t, Do_t, Try_t,
-                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)
 
@@ -620,6 +654,7 @@ AST_END(Slice)
 
 AST_NODE(Parens)
         ast_ptr<true, Exp_t> expr;
+        bool extra = false;
         AST_MEMBER(Parens, &expr)
 AST_END(Parens)
 
@@ -638,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)
@@ -724,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)
@@ -741,15 +782,17 @@ AST_END(Export)
 AST_NODE(FnArgDef)
         ast_sel<true, Variable_t, SelfItem_t> name;
         ast_ptr<false, ExistentialOp_t> op;
+        ast_ptr<false, Name_t> label;
         ast_ptr<false, Exp_t> defaultValue;
-        AST_MEMBER(FnArgDef, &name, &op, &defaultValue)
+        AST_MEMBER(FnArgDef, &name, &op, &label, &defaultValue)
 AST_END(FnArgDef)
 
 AST_NODE(FnArgDefList)
         ast_ptr<true, Seperator_t> sep;
         ast_list<false, FnArgDef_t> definitions;
         ast_ptr<false, VarArg_t> varArg;
-        AST_MEMBER(FnArgDefList, &sep, &definitions, &varArg)
+        ast_ptr<false, Name_t> label;
+        AST_MEMBER(FnArgDefList, &sep, &definitions, &varArg, &label)
 AST_END(FnArgDefList)
 
 AST_NODE(OuterVarShadow)
@@ -837,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)
 
@@ -855,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 a2a1864..d676750 100644
--- a/src/yuescript/yue_compiler.cpp
+++ b/src/yuescript/yue_compiler.cpp
@@ -7,9 +7,12 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*/
 
 #include <chrono>
+#include <cmath>
+#include <iomanip>
 #include <memory>
 #include <optional>
 #include <set>
+#include <sstream>
 #include <stack>
 #include <string>
 #include <unordered_map>
@@ -75,7 +78,7 @@ static std::unordered_set<std::string> Metamethods = {
         "close"s // Lua 5.4
 };
 
-const std::string_view version = "0.27.3"sv;
+const std::string_view version = "0.29.3"sv;
 const std::string_view extension = "yue"sv;
 
 class CompileError : public std::logic_error {
@@ -162,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;
@@ -426,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;
@@ -555,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;
                         }
@@ -568,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;
                         }
@@ -590,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;
@@ -871,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() {
@@ -892,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);
@@ -1080,8 +1089,8 @@ private:
                         if (unary->ops.empty()) {
                                 Value_t* value = static_cast<Value_t*>(unary->expos.back());
                                 if (auto chain = ast_cast<ChainValue_t>(value->item); chain && chain->items.size() == 1) {
-                                        if (auto exp = chain->get_by_path<Callable_t, Parens_t, Exp_t>()) {
-                                                if (auto insideValue = singleValueFrom(exp)) {
+                                        if (auto parens = chain->get_by_path<Callable_t, Parens_t>(); parens && parens->extra) {
+                                                if (auto insideValue = singleValueFrom(parens->expr)) {
                                                         return insideValue;
                                                 }
                                         }
@@ -1249,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);
                 }
@@ -1272,6 +1281,8 @@ private:
                 Common,
                 EndWithColon,
                 EndWithEOP,
+                EndWithSlice,
+                HasRIndex,
                 HasEOP,
                 HasKeyword,
                 HasUnicode,
@@ -1290,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;
@@ -1315,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;
@@ -1837,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>(): {
@@ -2048,13 +2065,16 @@ private:
                                         if (item.targetVar.empty()) {
                                                 throw CompileError("can only declare variable as const"sv, item.target);
                                         }
-                                        markVarConst(item.targetVar);
+                                        markVarLocalConst(item.targetVar);
                                 }
                         }
                 }
         }
 
         bool transformAssignment(ExpListAssign_t* assignment, str_list& out, bool optionalDestruct = false) {
+                if (assignment->action.is<SubBackcall_t>()) {
+                        YUEE("AST node mismatch", assignment->action);
+                }
                 checkAssignable(assignment->expList);
                 BLOCK_START
                 auto assign = ast_cast<Assign_t>(assignment->action);
@@ -2317,6 +2337,17 @@ private:
                                 out.back().insert(0, preDefine);
                                 return false;
                         }
+                        case id<Try_t>(): {
+                                auto tryNode = static_cast<Try_t*>(value);
+                                if (tryNode->eop) {
+                                        auto assignList = assignment->expList.get();
+                                        std::string preDefine = getPreDefineLine(assignment);
+                                        transformTry(tryNode, out, ExpUsage::Assignment, assignList);
+                                        out.back().insert(0, preDefine);
+                                        return false;
+                                }
+                                break;
+                        }
                         case id<Switch_t>(): {
                                 auto switchNode = static_cast<Switch_t*>(value);
                                 auto assignList = assignment->expList.get();
@@ -2388,6 +2419,13 @@ private:
                                 out.back().insert(0, preDefine);
                                 return false;
                         }
+                        case id<Repeat_t>(): {
+                                auto expList = assignment->expList.get();
+                                std::string preDefine = getPreDefineLine(assignment);
+                                transformRepeatInPlace(static_cast<Repeat_t*>(value), out, expList);
+                                out.back().insert(0, preDefine);
+                                return false;
+                        }
                         case id<TableLit_t>(): {
                                 auto tableLit = static_cast<TableLit_t*>(value);
                                 if (hasSpreadExp(tableLit->values.objects())) {
@@ -2440,12 +2478,14 @@ private:
                         switch (type) {
                                 case ChainType::HasEOP:
                                 case ChainType::EndWithColon:
+                                case ChainType::EndWithSlice:
                                 case ChainType::MetaFieldInvocation: {
                                         std::string preDefine = getPreDefineLine(assignment);
                                         transformChainValue(chainValue, out, ExpUsage::Assignment, expList, false, optionalDestruct);
                                         out.back().insert(0, preDefine);
                                         return false;
                                 }
+                                case ChainType::HasRIndex:
                                 case ChainType::HasKeyword:
                                 case ChainType::HasUnicode:
                                 case ChainType::Macro:
@@ -2461,6 +2501,10 @@ private:
                 auto info = extractDestructureInfo(assignment, false, optionalDestruct);
                 if (info.destructures.empty()) {
                         transformAssignmentCommon(assignment, out);
+                        if (assignment->expList->followStmt) {
+                                transformStatement(assignment->expList->followStmt, out);
+                                assignment->expList->followStmtProcessed = true;
+                        }
                         return true;
                 } else {
                         auto x = assignment;
@@ -2726,8 +2770,12 @@ private:
                                 temp.push_back(indent() + "end"s + nlr(x));
                         }
                         out.push_back(join(temp));
+                        if (assignment->expList->followStmt) {
+                                transformStatement(assignment->expList->followStmt, out);
+                                assignment->expList->followStmtProcessed = true;
+                        }
+                        return false;
                 }
-                return false;
         }
 
         void transformAssignItem(ast_node* value, str_list& out) {
@@ -2793,20 +2841,46 @@ private:
                 if (!tableItems) throw CompileError("invalid destructure value"sv, node);
                 std::list<DestructItem> pairs;
                 int index = 0;
+                int count = 0;
+                bool hasSpread = false;
                 auto subMetaDestruct = node->new_ptr<TableLit_t>();
                 for (auto pair : *tableItems) {
                         switch (pair->get_id()) {
                                 case id<Exp_t>():
                                 case id<NormalDef_t>(): {
+                                        ++index;
                                         Exp_t* defVal = nullptr;
                                         if (auto nd = ast_cast<NormalDef_t>(pair)) {
                                                 pair = nd->item.get();
                                                 defVal = nd->defVal.get();
                                         }
-                                        ++index;
-                                        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);
@@ -2817,7 +2891,6 @@ private:
                                                                 throw CompileError("default value is not supported here"sv, defVal);
                                                         }
                                                 }
-                                                auto indexItem = toAst<Exp_t>(std::to_string(index), value);
                                                 for (auto& p : subPairs) {
                                                         if (sep) p.structure->items.push_front(sep);
                                                         p.structure->items.push_front(indexItem);
@@ -2828,7 +2901,6 @@ private:
                                                 auto varName = singleVariableFrom(exp, AccessType::None);
                                                 if (varName == "_"sv) break;
                                                 auto chain = exp->new_ptr<ChainValue_t>();
-                                                auto indexItem = toAst<Exp_t>(std::to_string(index), exp);
                                                 chain->items.push_back(indexItem);
                                                 pairs.push_back({exp,
                                                         varName,
@@ -2886,7 +2958,25 @@ private:
                                                 }
                                         }
                                         if (auto exp = np->value.as<Exp_t>()) {
-                                                if (!varDefOnly && !isAssignable(exp)) throw CompileError("can't do destructure value"sv, exp);
+                                                bool assignable = false;
+                                                try {
+                                                        assignable = isAssignable(exp);
+                                                } catch (const CompileError& e) {
+                                                        if (!varDefOnly) throw e;
+                                                }
+                                                if (!assignable && !varDefOnly) {
+                                                        if (optional) break;
+                                                        throw CompileError("can't destructure value"sv, pair);
+                                                }
+                                                if (optional && varDefOnly && !assignable) {
+                                                        if (defVal) {
+                                                                throw CompileError("default value is not supported here"sv, defVal);
+                                                        }
+                                                        auto chain = exp->new_ptr<ChainValue_t>();
+                                                        if (keyIndex) chain->items.push_back(keyIndex);
+                                                        pairs.push_back({exp, Empty, chain, nullptr});
+                                                        break;
+                                                }
                                                 auto item = singleValueFrom(exp)->item.get();
                                                 ast_node* subExp = ast_cast<SimpleTable_t>(item);
                                                 if (subExp || (subExp = item->get_by_path<TableLit_t>()) || (subExp = item->get_by_path<Comprehension_t>())) {
@@ -2935,7 +3025,13 @@ private:
                                         auto tb = static_cast<TableBlockIndent_t*>(pair);
                                         ++index;
                                         auto subPairs = destructFromExp(tb, varDefOnly, optional);
-                                        auto indexItem = toAst<Exp_t>(std::to_string(index), tb);
+                                        ast_ptr<true, ast_node> indexItem;
+                                        if (hasSpread) {
+                                                int rIndex = count - index;
+                                                indexItem.set(toAst<ReversedIndex_t>('#' + (rIndex == 0 ? Empty : "-"s + std::to_string(rIndex)), tb));
+                                        } else {
+                                                indexItem.set(toAst<Exp_t>(std::to_string(index), tb));
+                                        }
                                         for (auto& p : subPairs) {
                                                 if (sep) p.structure->items.push_front(sep);
                                                 p.structure->items.push_front(indexItem);
@@ -2992,6 +3088,42 @@ private:
                                         subMetaDestruct->values.push_back(newPairDef);
                                         break;
                                 }
+                                case id<SpreadListExp_t>():
+                                case id<SpreadExp_t>(): {
+                                        ++index;
+                                        if (hasSpread) {
+                                                throw CompileError("duplicated spread expression"sv, pair);
+                                        }
+                                        hasSpread = true;
+                                        for (auto item : *tableItems) {
+                                                if (ast_is<
+                                                                SpreadListExp_t, SpreadExp_t,
+                                                                TableBlockIndent_t,
+                                                                Exp_t, NormalDef_t>(item)) {
+                                                        count++;
+                                                }
+                                        }
+                                        Exp_t* exp = nullptr;
+                                        if (auto se = ast_cast<SpreadExp_t>(pair)) {
+                                                exp = se->exp.get();
+                                        } else {
+                                                exp = ast_to<SpreadListExp_t>(pair)->exp.get();
+                                        }
+                                        auto varName = singleVariableFrom(exp, AccessType::None);
+                                        if (varName == "_"sv) break;
+                                        int start = index;
+                                        int stop = index - count - 1;
+                                        auto chain = exp->new_ptr<ChainValue_t>();
+                                        auto slice = toAst<Slice_t>(
+                                                '[' + (start == 1 ? Empty : std::to_string(start)) + ',' + (stop == -1 ? Empty : std::to_string(stop)) + ']', exp);
+                                        chain->items.push_back(slice);
+                                        auto nil = toAst<Exp_t>("nil"sv, slice);
+                                        pairs.push_back({exp,
+                                                varName,
+                                                chain,
+                                                nil.get()});
+                                        break;
+                                }
                                 default: YUEE("AST node mismatch", pair); break;
                         }
                 }
@@ -3108,7 +3240,11 @@ private:
                                                 break;
                                         default: YUEE("AST node mismatch", destructNode); break;
                                 }
-                                if (dlist->empty()) throw CompileError("expect items to be destructured"sv, destructNode);
+                                if (dlist->empty()) {
+                                        if (!optional) {
+                                                throw CompileError("expect items to be destructured"sv, destructNode);
+                                        }
+                                }
                                 for (auto item : *dlist) {
                                         switch (item->get_id()) {
                                                 case id<MetaVariablePairDef_t>(): {
@@ -3244,7 +3380,9 @@ private:
                                                 simpleValue->value.set(tab);
                                                 auto pairs = destructFromExp(newExp(simpleValue, expr), varDefOnly, optional);
                                                 if (pairs.empty()) {
-                                                        throw CompileError("expect items to be destructured"sv, tab);
+                                                        if (!optional) {
+                                                                throw CompileError("expect items to be destructured"sv, tab);
+                                                        }
                                                 }
                                                 destruct.items = std::move(pairs);
                                                 if (!varDefOnly) {
@@ -3262,6 +3400,7 @@ private:
                                                         } else if (destruct.items.size() == 1 && !singleValueFrom(*j)) {
                                                                 auto p = destruct.value.get();
                                                                 auto parens = p->new_ptr<Parens_t>();
+                                                                parens->extra = true;
                                                                 if (auto tableBlock = ast_cast<TableBlock_t>(p)) {
                                                                         auto tableLit = p->new_ptr<TableLit_t>();
                                                                         tableLit->values.dup(tableBlock->values);
@@ -3282,7 +3421,7 @@ private:
                                                                 destruct.valueVar.clear();
                                                         }
                                                 }
-                                                destructs.push_back(destruct);
+                                                destructs.push_back(std::move(destruct));
                                         }
                                 }
                         } else {
@@ -4201,12 +4340,22 @@ private:
 
         std::optional<std::pair<std::string, str_list>> upValueFuncFromExp(Exp_t* exp, str_list* ensureArgListInTheEnd, bool blockRewrite) {
                 if (checkUpValueFuncAvailable(exp)) {
+                        auto block = exp->new_ptr<Block_t>();
+                        if (auto sVal = simpleSingleValueFrom(exp)) {
+                                if (auto doNode = sVal->value.as<Do_t>()) {
+                                        if (auto blk = doNode->body->content.as<Block_t>()) {
+                                                block->statements.dup(blk->statements);
+                                        } else {
+                                                block->statements.push_back(doNode->body->content.to<Statement_t>());
+                                        }
+                                        return getUpValueFuncFromBlock(block, ensureArgListInTheEnd, false, blockRewrite);
+                                }
+                        }
                         auto returnNode = exp->new_ptr<Return_t>();
                         returnNode->explicitReturn = false;
                         auto returnList = exp->new_ptr<ExpListLow_t>();
                         returnList->exprs.push_back(exp);
                         returnNode->valueList.set(returnList);
-                        auto block = exp->new_ptr<Block_t>();
                         auto stmt = exp->new_ptr<Statement_t>();
                         stmt->content.set(returnNode);
                         block->statements.push_back(stmt);
@@ -4283,7 +4432,9 @@ private:
                         return false;
                 };
                 switch (usage) {
-                        case ExpUsage::Common: YUEE("AST node mismatch", x); return;
+                        case ExpUsage::Common:
+                                YUEE("AST node mismatch", x);
+                                return;
                         case ExpUsage::Return:
                         case ExpUsage::Closure: {
                                 prepareValue();
@@ -4406,6 +4557,7 @@ private:
                         case id<ForEach_t>(): transformForEachClosure(static_cast<ForEach_t*>(value), out); break;
                         case id<For_t>(): transformForClosure(static_cast<For_t*>(value), out); break;
                         case id<While_t>(): transformWhileClosure(static_cast<While_t*>(value), out); break;
+                        case id<Repeat_t>(): transformRepeatClosure(static_cast<Repeat_t*>(value), out); break;
                         case id<Do_t>(): transformDo(static_cast<Do_t*>(value), out, ExpUsage::Closure); break;
                         case id<Try_t>(): transformTry(static_cast<Try_t*>(value), out, ExpUsage::Closure); break;
                         case id<UnaryValue_t>(): transformUnaryValue(static_cast<UnaryValue_t*>(value), out); break;
@@ -4725,11 +4877,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) {
@@ -4737,9 +4885,13 @@ private:
                                                                 finalArgs.push_back(arg);
                                                         }
                                                 }
-                                                newBlock->statements.push_back(toAst<Statement_t>(funcName + ' ' + join(finalArgs, ","sv), x));
+                                                newBlock->statements.push_back(toAst<Statement_t>(funcName + ' ' + (finalArgs.empty() ? "nil"s : join(finalArgs, ","sv)), x));
                                                 auto sVal = singleValueFrom(static_cast<Statement_t*>(newBlock->statements.back())->content.to<ExpListAssign_t>()->expList);
-                                                ast_to<InvokeArgs_t>(sVal->item.to<ChainValue_t>()->items.back())->args.dup(newInvoke->args);
+                                                auto invokArgs = ast_to<InvokeArgs_t>(sVal->item.to<ChainValue_t>()->items.back());
+                                                if (finalArgs.empty()) {
+                                                        invokArgs->args.clear();
+                                                }
+                                                invokArgs->args.dup(newInvoke->args);
                                                 transformBlock(newBlock, out, usage, assignList, isRoot);
                                                 return;
                                         }
@@ -4750,6 +4902,7 @@ private:
                                 newSimpleValue->value.set(funLit);
                                 auto newExpInParens = newExp(newSimpleValue, x);
                                 auto newParens = x->new_ptr<Parens_t>();
+                                newParens->extra = true;
                                 newParens->expr.set(newExpInParens);
                                 auto newCallable = x->new_ptr<Callable_t>();
                                 newCallable->item.set(newParens);
@@ -4795,7 +4948,7 @@ private:
                                         auto varName = variableToString(ast_to<Variable_t>(var));
                                         auto closeVar = getUnusedName("_close_"sv);
                                         addToScope(closeVar);
-                                        getCloses.push_back(closeVar + "=if type("s + varName + ") in ['table', 'userdata'] then assert "s + varName + ".<> and "s + varName +".<close>, \""s + "variable '"s + varName + "' got a non-closable value\" elseif "s + varName + " == nil then nil else error \""s + "variable '"s + varName + "' got a non-closable value\"");
+                                        getCloses.push_back(closeVar + "=if type("s + varName + ") in ['table', 'userdata'] then assert "s + varName + ".<> and "s + varName + ".<close>, \""s + "variable '"s + varName + "' got a non-closable value\" elseif "s + varName + " == nil then nil else error \""s + "variable '"s + varName + "' got a non-closable value\"");
                                         doCloses.push_front(closeVar + "? "s + varName);
                                 }
                                 popScope();
@@ -4815,6 +4968,38 @@ private:
                                 newBlock->statements.push_back(toAst<Statement_t>("if "s + okVar + " then return ... else error ..."s, x));
                                 transformBlock(newBlock, out, usage, assignList, isRoot);
                                 return;
+                        } else if (auto expListAssign = stmt->content.as<ExpListAssign_t>();
+                                expListAssign && expListAssign->action && expListAssign->action.is<SubBackcall_t>()) {
+                                auto x = *nodes.begin();
+                                auto newBlock = x->new_ptr<Block_t>();
+                                if (it != nodes.begin()) {
+                                        for (auto i = nodes.begin(); i != it; ++i) {
+                                                newBlock->statements.push_back(*i);
+                                        }
+                                }
+                                auto doBackcall = static_cast<SubBackcall_t*>(expListAssign->action.get());
+                                auto backcall = expListAssign->new_ptr<Backcall_t>();
+                                auto argsDef = backcall->new_ptr<FnArgsDef_t>();
+                                try {
+                                        auto defList = toAst<FnArgDefList_t>(YueFormat{}.toString(expListAssign->expList), expListAssign->expList);
+                                        argsDef->defList.set(defList);
+                                } catch (const std::exception&) {
+                                        throw CompileError("backcall syntax error", backcall);
+                                }
+                                backcall->argsDef.set(argsDef);
+                                backcall->arrow.set(doBackcall->arrow);
+                                backcall->value.set(doBackcall->value);
+                                auto newStmt = backcall->new_ptr<Statement_t>();
+                                newStmt->content.set(backcall);
+                                newStmt->comments.dup(stmt->comments);
+                                newStmt->appendix.set(stmt->appendix);
+                                newBlock->statements.push_back(newStmt);
+                                auto ait = it;
+                                for (auto i = ++ait; i != nodes.end(); ++i) {
+                                        newBlock->statements.push_back(*i);
+                                }
+                                transformBlock(newBlock, out, usage, assignList, isRoot);
+                                return;
                         }
                         if (auto local = stmt->content.as<Local_t>()) {
                                 if (!local->collected) {
@@ -4986,36 +5171,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));
@@ -5224,18 +5418,29 @@ private:
                 auto macroLit = macro->decl.to<MacroLit_t>();
                 auto argsDef = macroLit->argsDef.get();
                 str_list newArgs;
+                str_list argChecks;
+                bool hasCheck = false;
                 if (argsDef) {
                         for (auto def_ : argsDef->definitions.objects()) {
                                 auto def = static_cast<FnArgDef_t*>(def_);
                                 if (def->name.is<SelfItem_t>()) {
                                         throw CompileError("self name is not supported for macro function argument"sv, def->name);
                                 } else {
+                                        if (def->op) throw CompileError("invalid existence checking"sv, def->op);
+                                        if (def->label) {
+                                                hasCheck = true;
+                                                const auto& astName = argChecks.emplace_back(_parser.toString(def->label));
+                                                if (!_parser.hasAST(astName)) {
+                                                        throw CompileError("invalid AST name"sv, def->label);
+                                                }
+                                        } else {
+                                                argChecks.emplace_back();
+                                        }
                                         std::string defVal;
                                         if (def->defaultValue) {
                                                 defVal = _parser.toString(def->defaultValue);
                                                 Utils::trim(defVal);
-                                                defVal.insert(0, "=[==========["sv);
-                                                defVal.append("]==========]"sv);
+                                                defVal = '=' + Utils::toLuaDoubleString(defVal);
                                         }
                                         newArgs.emplace_back(_parser.toString(def->name) + defVal);
                                 }
@@ -5243,6 +5448,14 @@ private:
                         if (argsDef->varArg) {
                                 newArgs.emplace_back(_parser.toString(argsDef->varArg));
                         }
+                        if (argsDef->label) {
+                                hasCheck = true;
+                                const auto& astName = _parser.toString(argsDef->label);
+                                if (!_parser.hasAST(astName)) {
+                                        throw CompileError("invalid AST name"sv, argsDef->label);
+                                }
+                                argChecks.emplace_back("..."s + astName);
+                        }
                 }
                 std::string macroCodes = "_ENV=require('yue').macro_env\n("s + join(newArgs, ","sv) + ")->"s + _parser.toString(macroLit->body);
                 auto chunkName = "=(macro "s + macroName + ')';
@@ -5273,6 +5486,24 @@ private:
                         throw CompileError("failed to generate macro function\n"s + err, macroLit);
                 } // cur true macro
                 lua_remove(L, -2); // cur macro
+                if (hasCheck) {
+                        lua_createtable(L, 0, 0); // cur macro checks
+                        int i = 1;
+                        for (const auto& check : argChecks) {
+                                if (check.empty()) {
+                                        lua_pushboolean(L, 0);
+                                        lua_rawseti(L, -2, i);
+                                } else {
+                                        lua_pushlstring(L, check.c_str(), check.size());
+                                        lua_rawseti(L, -2, i);
+                                }
+                                i++;
+                        }
+                        lua_createtable(L, 2, 0); // cur macro checks macrotab
+                        lua_insert(L, -3); // cur macrotab macro checks
+                        lua_rawseti(L, -3, 1); // macrotab[1] = checks, cur macrotab macro
+                        lua_rawseti(L, -2, 2); // macrotab[2] = macro, cur macrotab
+                } // cur macro
                 if (exporting && _config.exporting && !_config.module.empty()) {
                         pushModuleTable(_config.module); // cur macro module
                         lua_pushlstring(L, macroName.c_str(), macroName.size()); // cur macro module name
@@ -5347,6 +5578,9 @@ private:
                                                 case id<While_t>():
                                                         transformWhileInPlace(static_cast<While_t*>(value), out);
                                                         return;
+                                                case id<Repeat_t>():
+                                                        transformRepeatInPlace(static_cast<Repeat_t*>(value), out);
+                                                        return;
                                                 case id<For_t>():
                                                         transformForInPlace(static_cast<For_t*>(value), out);
                                                         return;
@@ -5427,7 +5661,11 @@ private:
                         auto def = static_cast<FnArgDef_t*>(_def);
                         auto& arg = argItems.emplace_back();
                         switch (def->name->get_id()) {
-                                case id<Variable_t>(): arg.name = variableToString(static_cast<Variable_t*>(def->name.get())); break;
+                                case id<Variable_t>(): {
+                                        if (def->op) throw CompileError("invalid existence checking"sv, def->op);
+                                        arg.name = variableToString(static_cast<Variable_t*>(def->name.get()));
+                                        break;
+                                }
                                 case id<SelfItem_t>(): {
                                         assignSelf = true;
                                         if (def->op) {
@@ -5566,10 +5804,50 @@ 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())) {
                         auto parens = x->new_ptr<Parens_t>();
+                        parens->extra = true;
                         {
                                 auto chainValue = x->new_ptr<ChainValue_t>();
                                 for (auto item : chainList) {
@@ -6082,7 +6360,7 @@ private:
                         case id<ColonChainItem_t>():
                         case id<Exp_t>():
                                 if (_withVars.empty()) {
-                                        throw CompileError("short dot/colon and indexing syntax must be called within a with block"sv, x);
+                                        throw CompileError("short dot/colon/indexing syntax must be called within a with block"sv, x);
                                 } else {
                                         temp.push_back(_withVars.top());
                                 }
@@ -6163,6 +6441,7 @@ private:
                                                                 ++next;
                                                                 if (next != chainList.end()) {
                                                                         auto paren = x->new_ptr<Parens_t>();
+                                                                        paren->extra = true;
                                                                         paren->expr.set(newExp(chainValue, x));
                                                                         auto ncallable = x->new_ptr<Callable_t>();
                                                                         ncallable->item.set(paren);
@@ -6215,6 +6494,7 @@ private:
                                                         simpleValue->value.set(funLit);
                                                         auto exp = newExp(simpleValue, x);
                                                         auto paren = x->new_ptr<Parens_t>();
+                                                        paren->extra = true;
                                                         paren->expr.set(exp);
                                                         auto callable = x->new_ptr<Callable_t>();
                                                         callable->item.set(paren);
@@ -6226,6 +6506,93 @@ private:
                                                 }
                                                 return;
                                         }
+                                        break;
+                                }
+                                case id<ReversedIndex_t>(): {
+                                        auto rIndex = static_cast<ReversedIndex_t*>(*it);
+                                        auto current = it;
+                                        auto prevChain = x->new_ptr<ChainValue_t>();
+                                        for (auto i = chainList.begin(); i != current; ++i) {
+                                                prevChain->items.push_back(*i);
+                                        }
+                                        auto var = singleVariableFrom(prevChain, AccessType::None);
+                                        if (!var.empty() && isLocal(var)) {
+                                                auto indexNode = toAst<Exp_t>('#' + var, rIndex);
+                                                if (rIndex->modifier) {
+                                                        auto opValue = rIndex->new_ptr<ExpOpValue_t>();
+                                                        opValue->op.set(toAst<BinaryOperator_t>("-"sv, rIndex));
+                                                        opValue->pipeExprs.dup(rIndex->modifier->pipeExprs);
+                                                        indexNode->opValues.push_back(opValue);
+                                                        indexNode->opValues.dup(rIndex->modifier->opValues);
+                                                        indexNode->nilCoalesed.set(rIndex->modifier->nilCoalesed);
+                                                }
+                                                prevChain->items.push_back(indexNode);
+                                                auto next = current;
+                                                ++next;
+                                                for (auto i = next; i != chainList.end(); ++i) {
+                                                        prevChain->items.push_back(*i);
+                                                }
+                                                if (usage == ExpUsage::Assignment) {
+                                                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                                                        assignment->expList.set(assignList);
+                                                        auto assign = x->new_ptr<Assign_t>();
+                                                        assign->values.push_back(newExp(prevChain, x));
+                                                        assignment->action.set(assign);
+                                                        transformAssignment(assignment, out);
+                                                        return;
+                                                }
+                                                transformChainValue(prevChain, out, usage, assignList);
+                                                return;
+                                        } else {
+                                                auto itemVar = getUnusedName("_item_"sv);
+                                                auto asmt = assignmentFrom(toAst<Exp_t>(itemVar, x), newExp(prevChain, x), x);
+                                                auto stmt1 = x->new_ptr<Statement_t>();
+                                                stmt1->content.set(asmt);
+                                                auto newChain = x->new_ptr<ChainValue_t>();
+                                                newChain->items.push_back(toAst<Callable_t>(itemVar, x));
+                                                auto indexNode = toAst<Exp_t>('#' + itemVar, rIndex);
+                                                if (rIndex->modifier) {
+                                                        auto opValue = rIndex->new_ptr<ExpOpValue_t>();
+                                                        opValue->op.set(toAst<BinaryOperator_t>("-"sv, rIndex));
+                                                        opValue->pipeExprs.dup(rIndex->modifier->pipeExprs);
+                                                        indexNode->opValues.push_back(opValue);
+                                                        indexNode->opValues.dup(rIndex->modifier->opValues);
+                                                        indexNode->nilCoalesed.set(rIndex->modifier->nilCoalesed);
+                                                }
+                                                newChain->items.push_back(indexNode);
+                                                auto next = current;
+                                                ++next;
+                                                for (auto i = next; i != chainList.end(); ++i) {
+                                                        newChain->items.push_back(*i);
+                                                }
+                                                auto expList = x->new_ptr<ExpList_t>();
+                                                expList->exprs.push_back(newExp(newChain, x));
+                                                auto expListAssign = x->new_ptr<ExpListAssign_t>();
+                                                expListAssign->expList.set(expList);
+                                                auto stmt2 = x->new_ptr<Statement_t>();
+                                                stmt2->content.set(expListAssign);
+                                                auto block = x->new_ptr<Block_t>();
+                                                block->statements.push_back(stmt1);
+                                                block->statements.push_back(stmt2);
+                                                auto body = x->new_ptr<Body_t>();
+                                                body->content.set(block);
+                                                auto doNode = x->new_ptr<Do_t>();
+                                                doNode->body.set(body);
+                                                if (usage == ExpUsage::Assignment) {
+                                                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                                                        assignment->expList.set(assignList);
+                                                        auto assign = x->new_ptr<Assign_t>();
+                                                        auto sVal = x->new_ptr<SimpleValue_t>();
+                                                        sVal->value.set(doNode);
+                                                        assign->values.push_back(newExp(sVal, x));
+                                                        assignment->action.set(assign);
+                                                        transformAssignment(assignment, out);
+                                                        return;
+                                                }
+                                                transformDo(doNode, out, usage);
+                                                return;
+                                        }
+                                        break;
                                 }
                         }
                 }
@@ -6410,7 +6777,7 @@ private:
                                 }
                         }
                 }
-                int len = lua_objlen(L, -1);
+                int len = static_cast<int>(lua_objlen(L, -1));
                 lua_pushnil(L); // cur nil
                 for (int i = len; i >= 1; i--) {
                         lua_pop(L, 1); // cur
@@ -6422,7 +6789,25 @@ private:
                                 break;
                         }
                 }
-                if (!lua_isfunction(L, -1)) {
+                str_list checks;
+                if (lua_istable(L, -1)) {
+                        lua_rawgeti(L, -1, 1); // cur macrotab checks
+                        int len = static_cast<int>(lua_objlen(L, -1));
+                        for (int i = 1; i <= len; i++) {
+                                lua_rawgeti(L, -1, i);
+                                if (lua_toboolean(L, -1) == 0) {
+                                        checks.emplace_back();
+                                } else {
+                                        size_t str_len = 0;
+                                        auto str = lua_tolstring(L, -1, &str_len);
+                                        checks.emplace_back(std::string{str, str_len});
+                                }
+                                lua_pop(L, 1);
+                        }
+                        lua_pop(L, 1);
+                        lua_rawgeti(L, -1, 2); // cur macrotab macroFunc
+                        lua_remove(L, -2); // cur macroFunc
+                } else if (!lua_isfunction(L, -1)) {
                         auto code = expandBuiltinMacro(macroName, x);
                         if (!code.empty()) return code;
                         if (macroName == "is_ast"sv) {
@@ -6467,11 +6852,34 @@ private:
                 } // cur macroFunc
                 pushYue("pcall"sv); // cur macroFunc pcall
                 lua_insert(L, -2); // cur pcall macroFunc
-                if (!lua_checkstack(L, argStrs.size())) {
+                if (!lua_checkstack(L, static_cast<int>(argStrs.size()))) {
                         throw CompileError("too much macro params"s, x);
                 }
+                auto checkIt = checks.begin();
+                node_container::const_iterator argIt;
+                if (args) {
+                        argIt = args->begin();
+                }
                 for (const auto& arg : argStrs) {
+                        if (checkIt != checks.end()) {
+                                if (checkIt->empty()) {
+                                        ++checkIt;
+                                } else {
+                                        if ((*checkIt)[0] == '.') {
+                                                auto astName = checkIt->substr(3);
+                                                if (!_parser.match(astName, arg)) {
+                                                        throw CompileError("expecting \""s + astName + "\", AST mismatch"s, *argIt);
+                                                }
+                                        } else {
+                                                if (!_parser.match(*checkIt, arg)) {
+                                                        throw CompileError("expecting \""s + *checkIt + "\", AST mismatch"s, *argIt);
+                                                }
+                                                ++checkIt;
+                                        }
+                                }
+                        }
                         lua_pushlstring(L, arg.c_str(), arg.size());
+                        ++argIt;
                 } // cur pcall macroFunc args...
                 bool success = lua_pcall(L, static_cast<int>(argStrs.size()), 1, 0) == 0;
                 if (!success) { // cur err
@@ -6601,14 +7009,14 @@ private:
                 } else {
                         if (!codes.empty()) {
                                 if (isBlock) {
-                                        info = _parser.parse<BlockEnd_t>(codes);
+                                        info = _parser.parse<BlockEnd_t>(codes, false);
                                         if (info.error) {
                                                 throw CompileError("failed to expand macro as block: "s + info.error.value().msg, x);
                                         }
                                 } else {
-                                        info = _parser.parse<Exp_t>(codes);
+                                        info = _parser.parse<Exp_t>(codes, false);
                                         if (!info.node && allowBlockMacroReturn) {
-                                                info = _parser.parse<BlockEnd_t>(codes);
+                                                info = _parser.parse<BlockEnd_t>(codes, false);
                                                 if (info.error) {
                                                         throw CompileError("failed to expand macro as expr or block: "s + info.error.value().msg, x);
                                                 }
@@ -6631,6 +7039,7 @@ private:
                                         exp.set(info.node);
                                         if (!exp->opValues.empty() || (chainList.size() > 2 || (chainList.size() == 2 && !ast_is<Invoke_t, InvokeArgs_t>(chainList.back())))) {
                                                 auto paren = x->new_ptr<Parens_t>();
+                                                paren->extra = true;
                                                 paren->expr.set(exp);
                                                 auto callable = x->new_ptr<Callable_t>();
                                                 callable->item.set(paren);
@@ -6743,6 +7152,9 @@ private:
                 if (transformChainEndWithColonItem(chainList, out, usage, assignList)) {
                         return;
                 }
+                if (transformChainEndWithSlice(chainList, out, usage, assignList)) {
+                        return;
+                }
                 transformChainList(chainList, out, usage, assignList);
         }
 
@@ -7138,6 +7550,33 @@ private:
         void transformNum(Num_t* num, str_list& out) {
                 std::string numStr = _parser.toString(num);
                 numStr.erase(std::remove(numStr.begin(), numStr.end(), '_'), numStr.end());
+                if (numStr.size() > 2 && numStr[0] == '0') {
+                        if (numStr[1] == 'b' || numStr[1] == 'B') {
+                                std::string binaryPart = numStr.substr(2);
+                                try {
+                                        unsigned long long value = std::stoull(binaryPart, nullptr, 2);
+                                        numStr = std::to_string(value);
+                                } catch (const std::exception&) {
+                                        throw CompileError("invalid binary literal"sv, num);
+                                }
+                        } else if (getLuaTarget(num) < 502) {
+                                if (numStr[1] == 'x' || numStr[1] == 'X') {
+                                        if (numStr.find_first_of(".-"sv) != std::string::npos) {
+                                                std::stringstream ss(numStr);
+                                                double v;
+                                                ss >> std::hexfloat >> v;
+                                                if (ss.fail() || !std::isfinite(v)) {
+                                                        throw CompileError("invalid hex‑float literal"sv, num);
+                                                }
+                                                std::ostringstream outSs;
+                                                outSs << std::setprecision(17) << v;
+                                                numStr = outSs.str();
+                                        } else {
+                                                numStr.erase(std::remove(numStr.begin(), numStr.end(), '+'), numStr.end());
+                                        }
+                                }
+                        }
+                }
                 out.push_back(numStr);
         }
 
@@ -7823,6 +8262,11 @@ private:
         }
 
         bool transformForEachHead(AssignableNameList_t* nameList, ast_node* loopTarget, str_list& out, bool inClosure) {
+                enum class NumState {
+                        Unknown,
+                        Positive,
+                        Negtive
+                };
                 auto x = nameList;
                 str_list temp;
                 str_list vars;
@@ -7889,15 +8333,35 @@ private:
                                 for (auto item : chainList) {
                                         chain->items.push_back(item);
                                 }
-                                std::string startValue("1"sv);
+                                std::string startValue;
+                                NumState startStatus = NumState::Unknown;
                                 if (auto exp = slice->startValue.as<Exp_t>()) {
                                         transformExp(exp, temp, ExpUsage::Closure);
+                                        if (temp.back().at(0) == '-') {
+                                                if (_parser.match<Num_t>(temp.back().substr(1))) {
+                                                        startStatus = NumState::Negtive;
+                                                }
+                                        } else {
+                                                if (_parser.match<Num_t>(temp.back())) {
+                                                        startStatus = NumState::Positive;
+                                                }
+                                        }
                                         startValue = std::move(temp.back());
                                         temp.pop_back();
                                 }
                                 std::string stopValue;
+                                NumState stopStatus = NumState::Unknown;
                                 if (auto exp = slice->stopValue.as<Exp_t>()) {
                                         transformExp(exp, temp, ExpUsage::Closure);
+                                        if (temp.back().at(0) == '-') {
+                                                if (_parser.match<Num_t>(temp.back().substr(1))) {
+                                                        stopStatus = NumState::Negtive;
+                                                }
+                                        } else {
+                                                if (_parser.match<Num_t>(temp.back())) {
+                                                        stopStatus = NumState::Positive;
+                                                }
+                                        }
                                         stopValue = std::move(temp.back());
                                         temp.pop_back();
                                 }
@@ -7919,8 +8383,33 @@ private:
                                         transformChainValue(chain, temp, ExpUsage::Closure);
                                         _buf << prefix << indent() << "local "sv << listVar << " = "sv << temp.back() << nll(nameList);
                                 }
+                                if (startValue.empty()) {
+                                        startValue = "1"s;
+                                        startStatus = NumState::Positive;
+                                }
+                                std::string minVar;
+                                if (startStatus != NumState::Positive) {
+                                        std::string prefix;
+                                        if (!extraScope && !inClosure && needScope) {
+                                                extraScope = true;
+                                                prefix = indent() + "do"s + nll(x);
+                                                pushScope();
+                                        }
+                                        minVar = getUnusedName("_min_"sv);
+                                        varBefore.push_back(minVar);
+                                        if (startStatus == NumState::Negtive) {
+                                                _buf << prefix << indent() << "local "sv << minVar << " = "sv << "#"sv << listVar << " + "sv << startValue << " + 1"sv << nll(nameList);
+                                        } else {
+                                                _buf << prefix << indent() << "local "sv << minVar << " = "sv << startValue << nll(nameList);
+                                        }
+                                }
+                                bool defaultStop = false;
+                                if (stopValue.empty()) {
+                                        stopValue = "#"s + listVar;
+                                        defaultStop = true;
+                                }
                                 std::string maxVar;
-                                if (!stopValue.empty()) {
+                                if (stopStatus != NumState::Positive) {
                                         std::string prefix;
                                         if (!extraScope && !inClosure && needScope) {
                                                 extraScope = true;
@@ -7929,14 +8418,45 @@ private:
                                         }
                                         maxVar = getUnusedName("_max_"sv);
                                         varBefore.push_back(maxVar);
-                                        _buf << prefix << indent() << "local "sv << maxVar << " = "sv << stopValue << nll(nameList);
+                                        if (stopStatus == NumState::Negtive) {
+                                                _buf << indent() << "local "sv << maxVar << " = "sv << "#"sv << listVar << " + "sv << stopValue << " + 1"sv << nll(nameList);
+                                        } else {
+                                                _buf << prefix << indent() << "local "sv << maxVar << " = "sv << stopValue << nll(nameList);
+                                        }
+                                }
+                                if (startStatus == NumState::Unknown) {
+                                        _buf << indent() << minVar << " = "sv << minVar << " < 0 and #"sv << listVar << " + "sv << minVar << " + 1 or "sv << minVar << nll(nameList);
+                                }
+                                if (!defaultStop && stopStatus == NumState::Unknown) {
+                                        _buf << indent() << maxVar << " = "sv << maxVar << " < 0 and #"sv << listVar << " + "sv << maxVar << " + 1 or "sv << maxVar << nll(nameList);
                                 }
                                 _buf << indent() << "for "sv << indexVar << " = "sv;
-                                _buf << startValue << ", "sv;
+                                if (startValue.empty()) {
+                                        _buf << "1"sv;
+                                } else {
+                                        switch (startStatus) {
+                                                case NumState::Unknown:
+                                                case NumState::Negtive:
+                                                        _buf << minVar;
+                                                        break;
+                                                case NumState::Positive:
+                                                        _buf << startValue;
+                                                        break;
+                                        }
+                                }
+                                _buf << ", "sv;
                                 if (stopValue.empty()) {
                                         _buf << "#"sv << listVar;
                                 } else {
-                                        _buf << maxVar << " < 0 and #"sv << listVar << " + "sv << maxVar << " or "sv << maxVar;
+                                        switch (stopStatus) {
+                                                case NumState::Unknown:
+                                                case NumState::Negtive:
+                                                        _buf << maxVar;
+                                                        break;
+                                                case NumState::Positive:
+                                                        _buf << stopValue;
+                                                        break;
+                                        }
                                 }
                                 if (!stepValue.empty()) {
                                         _buf << ", "sv << stepValue;
@@ -7976,7 +8496,7 @@ private:
                 pushScope();
                 for (const auto& var : vars) forceAddToScope(var);
                 for (const auto& var : varAfter) addToScope(var);
-                if (!varConstAfter.empty()) markVarConst(varConstAfter);
+                if (!varConstAfter.empty()) markVarLocalConst(varConstAfter);
                 if (!destructPairs.empty()) {
                         temp.clear();
                         for (auto& pair : destructPairs) {
@@ -8061,7 +8581,7 @@ private:
                 _buf << indent() << "for "sv << varName << " = "sv << start << ", "sv << stop << (step.empty() ? Empty : ", "s + step) << " do"sv << nll(var);
                 pushScope();
                 forceAddToScope(varName);
-                markVarConst(varName);
+                markVarLocalConst(varName);
                 out.push_back(clearBuf());
         }
 
@@ -8069,26 +8589,59 @@ private:
                 transformForHead(forNode->varName, forNode->startValue, forNode->stopValue, forNode->stepValue, out);
         }
 
-        void transform_plain_body(ast_node* body, str_list& out, ExpUsage usage, ExpList_t* assignList = nullptr) {
-                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);
@@ -8099,40 +8652,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
@@ -8146,6 +8689,7 @@ private:
                         }
                         return traversal::Return;
                 });
+                return type;
         }
 
         void addDoToLastLineReturn(ast_node* body) {
@@ -8169,10 +8713,10 @@ private:
                 }
         }
 
-        void transformLoopBody(ast_node* body, str_list& out, const std::string& appendContent, ExpUsage usage, ExpList_t* assignList = nullptr) {
+        void transformLoopBody(ast_node* body, str_list& out, uint32_t breakLoopType, ExpUsage usage, ExpList_t* assignList = nullptr) {
                 str_list temp;
                 bool extraDo = false;
-                bool withContinue = hasContinueStatement(body);
+                bool withContinue = hasContinue(breakLoopType);
                 int target = getLuaTarget(body);
                 std::string extraLabel;
                 if (withContinue) {
@@ -8181,7 +8725,7 @@ private:
                                         if (!block->statements.empty()) {
                                                 auto stmt = static_cast<Statement_t*>(block->statements.back());
                                                 if (auto breakLoop = ast_cast<BreakLoop_t>(stmt->content)) {
-                                                        extraDo = _parser.toString(breakLoop) == "break"sv;
+                                                        extraDo = breakLoop->type.is<Break_t>();
                                                 }
                                         }
                                 }
@@ -8214,9 +8758,6 @@ private:
                                         popScope();
                                         _buf << indent() << "end"sv << nll(body);
                                 }
-                                if (!appendContent.empty()) {
-                                        _buf << indent() << appendContent;
-                                }
                                 _buf << indent() << _continueVars.top().var << " = true"sv << nll(body);
                                 popScope();
                                 _buf << indent() << "until true"sv << nlr(body);
@@ -8226,14 +8767,9 @@ private:
                                 temp.push_back(clearBuf());
                                 _continueVars.pop();
                         } else {
-                                if (!appendContent.empty()) {
-                                        temp.push_back(indent() + appendContent);
-                                }
                                 temp.push_back(extraLabel);
                                 _continueVars.pop();
                         }
-                } else if (!appendContent.empty()) {
-                        temp.back().append(indent() + appendContent);
                 }
                 out.push_back(join(temp));
         }
@@ -8241,8 +8777,9 @@ private:
         std::string transformRepeatBody(Repeat_t* repeatNode, str_list& out) {
                 str_list temp;
                 bool extraDo = false;
-                auto body = repeatNode->body->content.get();
-                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;
@@ -8253,7 +8790,7 @@ private:
                                         if (!block->statements.empty()) {
                                                 auto stmt = static_cast<Statement_t*>(block->statements.back());
                                                 if (auto breakLoop = ast_cast<BreakLoop_t>(stmt->content)) {
-                                                        extraDo = _parser.toString(breakLoop) == "break"sv;
+                                                        extraDo = breakLoop->type.is<Break_t>();
                                                 }
                                         }
                                 }
@@ -8316,7 +8853,8 @@ private:
         void transformFor(For_t* forNode, str_list& out) {
                 str_list temp;
                 transformForHead(forNode, temp);
-                transformLoopBody(forNode->body, temp, Empty, ExpUsage::Common);
+                auto breakLoopType = getBreakLoopType(forNode->body, Empty);
+                transformLoopBody(forNode->body, temp, breakLoopType, ExpUsage::Common);
                 popScope();
                 out.push_back(join(temp) + indent() + "end"s + nlr(forNode));
         }
@@ -8327,13 +8865,24 @@ private:
                 addToScope(accum);
                 std::string len = getUnusedName("_len_"sv);
                 addToScope(len);
-                _buf << indent() << "local "sv << accum << " = { }"sv << nll(forNode);
+                auto breakLoopType = getBreakLoopType(forNode->body, accum);
+                _buf << indent() << "local "sv << accum << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(forNode);
+                out.emplace_back(clearBuf());
                 _buf << indent() << "local "sv << len << " = 1"sv << nll(forNode);
-                out.push_back(clearBuf());
+                auto& lenAssign = out.emplace_back(clearBuf());
                 transformForHead(forNode, out);
-                auto expList = toAst<ExpList_t>(accum + '[' + len + ']', x);
-                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;
@@ -8412,7 +8961,8 @@ private:
         void transformForEach(ForEach_t* forEach, str_list& out) {
                 str_list temp;
                 bool extraScoped = transformForEachHead(forEach->nameList, forEach->loopValue, temp, false);
-                transformLoopBody(forEach->body, temp, Empty, ExpUsage::Common);
+                auto breakLoopType = getBreakLoopType(forEach->body, Empty);
+                transformLoopBody(forEach->body, temp, breakLoopType, ExpUsage::Common);
                 popScope();
                 out.push_back(temp.front() + temp.back() + indent() + "end"s + nlr(forEach));
                 if (extraScoped) {
@@ -8427,13 +8977,24 @@ private:
                 addToScope(accum);
                 std::string len = getUnusedName("_len_"sv);
                 addToScope(len);
-                _buf << indent() << "local "sv << accum << " = { }"sv << nll(forEach);
+                auto breakLoopType = getBreakLoopType(forEach->body, accum);
+                _buf << indent() << "local "sv << accum << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(forEach);
+                out.emplace_back(clearBuf());
                 _buf << indent() << "local "sv << len << " = 1"sv << nll(forEach);
-                out.push_back(clearBuf());
+                auto& lenAssign = out.emplace_back(clearBuf());
                 transformForEachHead(forEach->nameList, forEach->loopValue, out, true);
-                auto expList = toAst<ExpList_t>(accum + '[' + len + ']', x);
-                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;
@@ -8617,12 +9178,64 @@ private:
                 out.push_back(temp.empty() ? "\"\""s : join(temp, " .. "sv));
         }
 
+        void transformYAMLMultiline(YAMLMultiline_t* multiline, str_list& out) {
+                std::optional<std::string> indent;
+                str_list temp;
+                for (auto line_ : multiline->lines.objects()) {
+                        auto line = static_cast<YAMLLine_t*>(line_);
+                        auto indentStr = _parser.toString(line->indent);
+                        if (!indent) {
+                                indent = indentStr;
+                        }
+                        if (std::string_view{indentStr.c_str(), indent.value().size()} != indent.value()) {
+                                throw CompileError("inconsistent indent"sv, line);
+                        }
+                        indentStr = indentStr.substr(indent.value().size());
+                        str_list segs;
+                        bool firstSeg = true;
+                        for (auto seg_ : line->segments.objects()) {
+                                auto content = static_cast<YAMLLineContent_t*>(seg_)->content.get();
+                                switch (content->get_id()) {
+                                        case id<YAMLLineInner_t>(): {
+                                                auto seqStr = _parser.toString(content);
+                                                Utils::replace(seqStr, "\\#"sv, "#"sv);
+                                                if (firstSeg) {
+                                                        firstSeg = false;
+                                                        seqStr.insert(0, indentStr);
+                                                }
+                                                segs.push_back(Utils::toLuaDoubleString(seqStr));
+                                                break;
+                                        }
+                                        case id<Exp_t>(): {
+                                                if (firstSeg) {
+                                                        firstSeg = false;
+                                                        if (!indentStr.empty()) {
+                                                                segs.push_back(Utils::toLuaDoubleString(indentStr));
+                                                        }
+                                                }
+                                                transformExp(static_cast<Exp_t*>(content), segs, ExpUsage::Closure);
+                                                segs.back() = globalVar("tostring"sv, content, AccessType::Read) + '(' + segs.back() + ')';
+                                                break;
+                                        }
+                                        default: YUEE("AST node mismatch", content); break;
+                                }
+                        }
+                        temp.push_back(join(segs, " .. "sv));
+                }
+                auto str = join(temp, " .. '\\n' .. "sv);
+                Utils::replace(str, "\" .. '\\n' .. \""sv, "\\n"sv);
+                Utils::replace(str, "\" .. '\\n'"sv, "\\n\""sv);
+                Utils::replace(str, "'\\n' .. \""sv, "\"\\n"sv);
+                out.push_back(str);
+        }
+
         void transformString(String_t* string, str_list& out) {
                 auto str = string->str.get();
                 switch (str->get_id()) {
                         case id<SingleString_t>(): transformSingleString(static_cast<SingleString_t*>(str), out); break;
                         case id<DoubleString_t>(): transformDoubleString(static_cast<DoubleString_t*>(str), out); break;
                         case id<LuaString_t>(): transformLuaString(static_cast<LuaString_t*>(str), out); break;
+                        case id<YAMLMultiline_t>(): transformYAMLMultiline(static_cast<YAMLMultiline_t*>(str), out); break;
                         default: YUEE("AST node mismatch", str); break;
                 }
         }
@@ -8804,7 +9417,7 @@ private:
                                                 auto names = transformAssignDefs(assignment->expList.get(), DefOp::Get);
                                                 for (const auto& name : names) {
                                                         forceAddToScope(name.first);
-                                                        markVarConst(name.first);
+                                                        markVarLocalConst(name.first);
                                                         varDefs.push_back(name.first);
                                                         classConstVars.push_back(name.first);
                                                 }
@@ -8818,7 +9431,7 @@ private:
                                                                 for (const auto& item : destruct.items) {
                                                                         if (!item.targetVar.empty()) {
                                                                                 forceAddToScope(item.targetVar);
-                                                                                markVarConst(item.targetVar);
+                                                                                markVarLocalConst(item.targetVar);
                                                                                 varDefs.push_back(item.targetVar);
                                                                                 classConstVars.push_back(item.targetVar);
                                                                         }
@@ -9200,11 +9813,11 @@ private:
                 std::string withVar;
                 bool needScope = !currentScope().lastStatement && !returnValue;
                 bool extraScope = false;
-                if (with->assigns) {
+                if (with->assign) {
                         auto vars = getAssignVars(with);
                         if (vars.front().empty() || isDeclaredAsGlobal(vars.front())) {
-                                if (with->assigns->values.objects().size() == 1) {
-                                        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;
                                         }
@@ -9214,7 +9827,7 @@ private:
                                         auto assignment = x->new_ptr<ExpListAssign_t>();
                                         assignment->expList.set(toAst<ExpList_t>(withVar, x));
                                         auto assign = x->new_ptr<Assign_t>();
-                                        assign->values.push_back(with->assigns->values.objects().front());
+                                        assign->values.push_back(with->assign->values.objects().front());
                                         assignment->action.set(assign);
                                         if (needScope) {
                                                 extraScope = true;
@@ -9228,7 +9841,7 @@ private:
                                 auto assign = x->new_ptr<Assign_t>();
                                 assign->values.push_back(toAst<Exp_t>(withVar, x));
                                 bool skipFirst = true;
-                                for (auto value : with->assigns->values.objects()) {
+                                for (auto value : with->assign->values.objects()) {
                                         if (skipFirst) {
                                                 skipFirst = false;
                                                 continue;
@@ -9241,7 +9854,7 @@ private:
                                 withVar = vars.front();
                                 auto assignment = x->new_ptr<ExpListAssign_t>();
                                 assignment->expList.set(with->valueList);
-                                assignment->action.set(with->assigns);
+                                assignment->action.set(with->assign);
                                 if (needScope) {
                                         extraScope = true;
                                         temp.push_back(indent() + "do"s + nll(with));
@@ -9319,15 +9932,57 @@ private:
                         }
                 }
                 _withVars.push(withVar);
+                std::string breakWithVar;
+                if (assignList || returnValue) {
+                        auto breakLoopType = getBreakLoopType(with->body, withVar);
+                        if (hasBreakWithValue(breakLoopType)) {
+                                breakWithVar = withVar;
+                        }
+                }
                 if (with->eop) {
                         auto ifNode = x->new_ptr<If_t>();
                         ifNode->type.set(toAst<IfType_t>("if"sv, x));
                         ifNode->nodes.push_back(toAst<IfCond_t>(withVar + "~=nil"s, x));
                         ifNode->nodes.push_back(with->body);
-                        transformIf(ifNode, temp, ExpUsage::Common);
+                        if (breakWithVar.empty()) {
+                                transformIf(ifNode, temp, ExpUsage::Common);
+                        } else {
+                                auto simpleValue = x->new_ptr<SimpleValue_t>();
+                                simpleValue->value.set(ifNode);
+                                auto exp = newExp(simpleValue, x);
+                                auto expList = x->new_ptr<ExpList_t>();
+                                expList->exprs.push_back(exp);
+                                auto expListAssign = x->new_ptr<ExpListAssign_t>();
+                                expListAssign->expList.set(expList);
+                                auto stmt = x->new_ptr<Statement_t>();
+                                stmt->content.set(expListAssign);
+                                auto repeatNode = toAst<Repeat_t>("repeat\n\t--\nuntil true"s, x);
+                                auto block = x->new_ptr<Block_t>();
+                                block->statements.push_back(stmt);
+                                repeatNode->body.set(block);
+                                auto sVal = x->new_ptr<SimpleValue_t>();
+                                sVal->value.set(repeatNode);
+                                auto asmt = assignmentFrom(toAst<Exp_t>(breakWithVar, x), newExp(sVal, x), x);
+                                transformAssignment(asmt, temp);
+                        }
                 } else {
                         bool transformed = false;
-                        if (!extraScope && assignList) {
+                        if (!breakWithVar.empty()) {
+                                auto repeatNode = toAst<Repeat_t>("repeat\n\t--\nuntil true"s, x);
+                                auto block = x->new_ptr<Block_t>();
+                                if (auto blk = with->body.as<Block_t>()) {
+                                        block->statements.dup(blk->statements);
+                                } else {
+                                        auto stmt = with->body.to<Statement_t>();
+                                        block->statements.push_back(stmt);
+                                }
+                                repeatNode->body.set(block);
+                                auto sVal = x->new_ptr<SimpleValue_t>();
+                                sVal->value.set(repeatNode);
+                                auto asmt = assignmentFrom(toAst<Exp_t>(breakWithVar, x), newExp(sVal, x), x);
+                                transformAssignment(asmt, temp);
+                                transformed = true;
+                        } else if (!extraScope && assignList) {
                                 if (auto block = with->body.as<Block_t>()) {
                                         if (!block->statements.empty()) {
                                                 Statement_t* stmt = static_cast<Statement_t*>(block->statements.back());
@@ -9392,12 +10047,18 @@ private:
                 switch (item->get_id()) {
                         case id<ClassDecl_t>(): {
                                 auto classDecl = static_cast<ClassDecl_t*>(item);
+                                std::string varName;
                                 if (classDecl->name) {
                                         if (auto var = classDecl->name->item.as<Variable_t>()) {
-                                                addGlobalVar(variableToString(var), classDecl->name->item);
+                                                varName = variableToString(var);
+                                                addGlobalVar(varName, var);
                                         }
                                 }
+                                if (varName.empty()) {
+                                        throw CompileError("missing name for class", classDecl);
+                                }
                                 transformClassDecl(classDecl, out, ExpUsage::Common);
+                                markVarGlobalConst(varName);
                                 break;
                         }
                         case id<GlobalOp_t>():
@@ -9411,9 +10072,11 @@ private:
                                 auto values = global->item.to<GlobalValues_t>();
                                 if (values->valueList) {
                                         auto expList = x->new_ptr<ExpList_t>();
+                                        str_list varNames;
                                         for (auto name : values->nameList->names.objects()) {
                                                 auto var = static_cast<Variable_t*>(name);
-                                                addGlobalVar(variableToString(var), var);
+                                                varNames.emplace_back(variableToString(var));
+                                                addGlobalVar(varNames.back(), var);
                                                 auto callable = x->new_ptr<Callable_t>();
                                                 callable->item.set(name);
                                                 auto chainValue = x->new_ptr<ChainValue_t>();
@@ -9432,10 +10095,17 @@ private:
                                         }
                                         assignment->action.set(assign);
                                         transformAssignment(assignment, out);
+                                        for (const auto& name : varNames) {
+                                                markVarGlobalConst(name);
+                                        }
                                 } else {
                                         for (auto name : values->nameList->names.objects()) {
                                                 auto var = static_cast<Variable_t*>(name);
-                                                addGlobalVar(variableToString(var), var);
+                                                auto varName = variableToString(var);
+                                                addGlobalVar(varName, var);
+                                                if (global->constAttrib) {
+                                                        markVarGlobalConst(varName);
+                                                }
                                         }
                                 }
                                 break;
@@ -9784,8 +10454,47 @@ private:
                 out.push_back(join(temp));
         }
 
-        void transformTry(Try_t* tryNode, str_list& out, ExpUsage usage) {
+        void transformTry(Try_t* tryNode, str_list& out, ExpUsage usage, ExpList_t* assignList = nullptr) {
                 auto x = tryNode;
+                if (tryNode->eop && usage == ExpUsage::Assignment) {
+                        str_list rets;
+                        pushScope();
+                        auto okVar = getUnusedName("_ok_"sv);
+                        for (size_t i = 0; i < assignList->exprs.size(); i++) {
+                                auto retVar = getUnusedName("_ret_"sv);
+                                rets.emplace_back(retVar);
+                                addToScope(retVar);
+                        }
+                        popScope();
+                        auto varList = join(rets, ","sv);
+                        auto ifNode = toAst<If_t>("if "s + okVar + ',' + varList + ":=try nil then "s + varList, x);
+                        auto exp = ast_to<IfCond_t>(ifNode->nodes.front())->assignment->assign->values.front();
+                        auto sVal = simpleSingleValueFrom(exp);
+                        auto newTry = sVal->value.to<Try_t>();
+                        newTry->func.set(tryNode->func);
+                        newTry->catchBlock.set(tryNode->catchBlock);
+                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                        assignment->expList.set(assignList);
+                        auto assign = x->new_ptr<Assign_t>();
+                        assign->values.push_back(ifNode);
+                        assignment->action.set(assign);
+                        transformAssignment(assignment, out);
+                        return;
+                }
+                if (tryNode->eop && usage != ExpUsage::Common) {
+                        auto okVar = getUnusedName("_ok_"sv);
+                        auto code = "do\n\t"s + okVar + ", ... = try nil\n\t... if "s + okVar;
+                        auto doNode = toAst<Do_t>(code, x);
+                        auto block = doNode->body->content.to<Block_t>();
+                        auto asmt = static_cast<Statement_t*>(block->statements.front())->content.to<ExpListAssign_t>();
+                        auto assign = asmt->action.to<Assign_t>();
+                        auto sVal = simpleSingleValueFrom(assign->values.back());
+                        auto newTry = sVal->value.to<Try_t>();
+                        newTry->func.set(tryNode->func);
+                        newTry->catchBlock.set(tryNode->catchBlock);
+                        transformDo(doNode, out, usage);
+                        return;
+                }
                 ast_ptr<true, Exp_t> errHandler;
                 if (tryNode->catchBlock) {
                         auto catchBlock = tryNode->catchBlock.get();
@@ -10097,7 +10806,7 @@ private:
                 out.push_back(join(temp));
                 auto vars = getAssignVars(assignment);
                 for (const auto& var : vars) {
-                        markVarConst(var);
+                        markVarLocalConst(var);
                 }
         }
 
@@ -10325,12 +11034,36 @@ private:
                 transformAssignment(assignment, out);
                 if (auto var = ast_cast<Variable_t>(target)) {
                         auto moduleName = variableToString(var);
-                        markVarConst(moduleName);
+                        markVarLocalConst(moduleName);
                 } else {
                         markDestructureConst(assignment);
                 }
         }
 
+        void transformImportGlobal(ImportGlobal_t* importNode, str_list& out) {
+                auto uname = static_cast<UnicodeName_t*>(importNode->segs.front());
+                auto var = _parser.toString(uname);
+                auto isNormal = _parser.match<Name_t>(var) && _parser.match<Variable_t>(var);
+                auto varName = unicodeVariableFrom(uname);
+                str_list temp;
+                auto it = ++importNode->segs.objects().begin();
+                for (; it != importNode->segs.objects().end(); ++it) {
+                        temp.emplace_back(_parser.toString(*it));
+                }
+                temp.emplace_front(var);
+                if (isLocal(varName) || !isNormal) {
+                        temp.emplace_front("_G"s);
+                }
+                std::string stmt;
+                if (importNode->target) {
+                        stmt = "const "s + _parser.toString(importNode->target) + '=' + join(temp, "."sv);
+                } else {
+                        stmt = "const "s + temp.back() + '=' + join(temp, "."sv);
+                }
+                auto localAttrib = toAst<LocalAttrib_t>(stmt, importNode);
+                transformLocalAttrib(localAttrib, out);
+        }
+
         void transformImport(Import_t* import, str_list& out) {
                 auto content = import->content.get();
                 switch (content->get_id()) {
@@ -10343,6 +11076,9 @@ private:
                         case id<FromImport_t>():
                                 transformFromImport(static_cast<FromImport_t*>(content), out);
                                 break;
+                        case id<ImportGlobal_t>():
+                                transformImportGlobal(static_cast<ImportGlobal_t*>(content), out);
+                                break;
                         default: YUEE("AST node mismatch", content); break;
                 }
         }
@@ -10362,15 +11098,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) {
@@ -10406,15 +11154,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));
@@ -10449,9 +11208,7 @@ private:
                         expListAssign->expList.set(expList);
                         auto stmt = x->new_ptr<Statement_t>();
                         stmt->content.set(expListAssign);
-                        auto body = x->new_ptr<Body_t>();
-                        body->content.set(stmt);
-                        repeat->body.set(body);
+                        repeat->body.set(stmt);
                         transformRepeat(repeat, out);
                         return;
                 }
@@ -10459,7 +11216,8 @@ private:
                 pushScope();
                 bool isUntil = _parser.toString(whileNode->type) == "until"sv;
                 auto condStr = transformCondExp(whileNode->condition, isUntil);
-                transformLoopBody(whileNode->body, temp, Empty, ExpUsage::Common);
+                auto breakLoopType = getBreakLoopType(whileNode->body, Empty);
+                transformLoopBody(whileNode->body, temp, breakLoopType, ExpUsage::Common);
                 popScope();
                 _buf << indent() << "while "sv << condStr << " do"sv << nll(whileNode);
                 _buf << temp.back();
@@ -10467,6 +11225,106 @@ private:
                 out.push_back(clearBuf());
         }
 
+        void transformRepeatInPlace(Repeat_t* repeatNode, str_list& out, ExpList_t* expList = nullptr) {
+                auto x = repeatNode;
+                str_list temp;
+                bool extraScope = false;
+                if (expList) {
+                        if (!currentScope().lastStatement) {
+                                extraScope = true;
+                                temp.push_back(indent() + "do"s + nll(repeatNode));
+                                pushScope();
+                        }
+                }
+                auto accumVar = getUnusedName("_accum_"sv);
+                addToScope(accumVar);
+                auto lenVar = getUnusedName("_len_"sv);
+                addToScope(lenVar);
+                auto breakLoopType = getBreakLoopType(repeatNode->body, accumVar);
+                _buf << indent() << "local "sv << accumVar << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(repeatNode);
+                temp.emplace_back(clearBuf());
+                _buf << indent() << "local "s << lenVar << " = 1"s << nll(repeatNode);
+                auto& lenAssign = temp.emplace_back(clearBuf());
+                auto condStr = transformCondExp(repeatNode->condition, false);
+                temp.push_back(indent() + "repeat"s + nll(repeatNode));
+                pushScope();
+                if (hasBreakWithValue(breakLoopType)) {
+                        lenAssign.clear();
+                        transformLoopBody(repeatNode->body, temp, breakLoopType, ExpUsage::Common);
+                } else {
+                        auto assignLeft = toAst<ExpList_t>(accumVar + '[' + lenVar + ']', x);
+                        auto followStmt = toAst<Statement_t>(lenVar + "+=1"s, repeatNode);
+                        assignLeft->followStmt = followStmt.get();
+                        transformLoopBody(repeatNode->body, temp, breakLoopType, ExpUsage::Assignment, assignLeft);
+                        if (!assignLeft->followStmtProcessed) {
+                                lenAssign.clear();
+                        }
+                }
+                popScope();
+                temp.push_back(indent() + "until "s + condStr + nlr(repeatNode));
+                if (expList) {
+                        auto assign = x->new_ptr<Assign_t>();
+                        assign->values.push_back(toAst<Exp_t>(accumVar, x));
+                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                        assignment->expList.set(expList);
+                        assignment->action.set(assign);
+                        transformAssignment(assignment, temp);
+                        if (extraScope) popScope();
+                } else {
+                        temp.push_back(indent() + "return "s + accumVar + nlr(repeatNode));
+                }
+                if (expList && extraScope) {
+                        temp.push_back(indent() + "end"s + nlr(repeatNode));
+                }
+                out.push_back(join(temp));
+        }
+
+        void transformRepeatClosure(Repeat_t* repeatNode, str_list& out) {
+                auto x = repeatNode;
+                auto simpleValue = x->new_ptr<SimpleValue_t>();
+                simpleValue->value.set(repeatNode);
+                if (transformAsUpValueFunc(newExp(simpleValue, x), out)) {
+                        return;
+                }
+                str_list temp;
+                pushAnonFunctionScope();
+                pushAnonVarArg();
+                std::string& funcStart = temp.emplace_back();
+                pushScope();
+                auto accumVar = getUnusedName("_accum_"sv);
+                addToScope(accumVar);
+                auto lenVar = getUnusedName("_len_"sv);
+                addToScope(lenVar);
+                auto breakLoopType = getBreakLoopType(repeatNode->body, accumVar);
+                _buf << indent() << "local "sv << accumVar << (hasBreakWithValue(breakLoopType) ? ""sv : " = { }"sv) << nll(repeatNode);
+                temp.emplace_back(clearBuf());
+                auto& lenAssign = temp.emplace_back(indent() + "local "s + lenVar + " = 1"s + nll(repeatNode));
+                auto condStr = transformCondExp(repeatNode->condition, false);
+                temp.push_back(indent() + "repeat"s + nll(repeatNode));
+                pushScope();
+                if (hasBreakWithValue(breakLoopType)) {
+                        lenAssign.clear();
+                        transformLoopBody(repeatNode->body, temp, breakLoopType, ExpUsage::Common);
+                } else {
+                        auto assignLeft = toAst<ExpList_t>(accumVar + '[' + lenVar + ']', x);
+                        auto followStmt = toAst<Statement_t>(lenVar + "+=1"s, repeatNode);
+                        assignLeft->followStmt = followStmt.get();
+                        transformLoopBody(repeatNode->body, temp, breakLoopType, ExpUsage::Assignment, assignLeft);
+                        if (!assignLeft->followStmtProcessed) {
+                                lenAssign.clear();
+                        }
+                }
+                popScope();
+                temp.push_back(indent() + "until "s + condStr + nlr(repeatNode));
+                temp.push_back(indent() + "return "s + accumVar + nlr(repeatNode));
+                popScope();
+                funcStart = anonFuncStart() + nll(repeatNode);
+                temp.push_back(indent() + anonFuncEnd());
+                popAnonVarArg();
+                popFunctionScope();
+                out.push_back(join(temp));
+        }
+
         void transformRepeat(Repeat_t* repeat, str_list& out) {
                 str_list temp;
                 pushScope();
@@ -10500,10 +11358,26 @@ private:
                         pushScope();
                 }
                 bool extraScope = false;
+                if (switchNode->assignment) {
+                        if (needScope) {
+                                extraScope = true;
+                                temp.push_back(indent() + "do"s + nll(x));
+                                pushScope();
+                        }
+                        auto asmt = x->new_ptr<ExpListAssign_t>();
+                        auto expList = x->new_ptr<ExpList_t>();
+                        expList->exprs.push_back(switchNode->target);
+                        if (switchNode->assignment->expList) {
+                                expList->exprs.dup(switchNode->assignment->expList->exprs);
+                        }
+                        asmt->expList.set(expList);
+                        asmt->action.set(switchNode->assignment->assign);
+                        transformAssignment(asmt, temp);
+                }
                 auto objVar = singleVariableFrom(switchNode->target, AccessType::Read);
                 if (objVar.empty() || !isLocal(objVar)) {
                         if (usage == ExpUsage::Common || usage == ExpUsage::Assignment) {
-                                if (needScope) {
+                                if (needScope && !extraScope) {
                                         extraScope = true;
                                         temp.push_back(indent() + "do"s + nll(x));
                                         pushScope();
@@ -10561,8 +11435,9 @@ private:
                                 }
                                 temp.back().append(indent() + "if "s + tabCheckVar + " then"s + nll(branch));
                                 pushScope();
-                                auto assignment = assignmentFrom(static_cast<Exp_t*>(valueList->exprs.front()), toAst<Exp_t>(objVar, branch), branch);
-                                auto 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) {
@@ -10572,8 +11447,31 @@ private:
                                         const auto& destruct = std::get<Destructure>(des);
                                         for (const auto& item : destruct.items) {
                                                 if (!item.defVal) {
-                                                        transformExp(item.target, conds, ExpUsage::Closure);
-                                                        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);
+                                                        }
                                                 }
                                         }
                                 }
@@ -10871,7 +11769,7 @@ private:
                         }
                         transformAssignment(assignment, temp);
                         for (const auto& name : vars) {
-                                markVarConst(name);
+                                markVarLocalConst(name);
                         }
                         if (localAttrib->attrib.is<CloseAttrib_t>()) {
                                 str_list leftVars, rightVars;
@@ -10943,7 +11841,7 @@ private:
                                 temp.push_back(indent() + "local "s + join(leftVars, ", "sv) + " = "s + join(items, ", "sv) + nll(x));
                         }
                         for (const auto& var : vars) {
-                                markVarConst(var);
+                                markVarLocalConst(var);
                         }
                 }
                 if (!listB->exprs.empty()) {
@@ -10968,18 +11866,24 @@ private:
                         temp.push_back(indent() + "local "s + join(vars, ", "sv) + nll(x));
                         transformAssignment(assignment, temp);
                         for (const auto& name : vars) {
-                                markVarConst(name);
+                                markVarLocalConst(name);
                         }
                 }
                 out.push_back(join(temp));
         }
 
         void transformBreakLoop(BreakLoop_t* breakLoop, str_list& out) {
-                auto keyword = _parser.toString(breakLoop);
+                auto isBreak = breakLoop->type.is<Break_t>();
+                auto keyword = isBreak ? "break"s : "continue"s;
                 if (_enableBreakLoop.empty() || !_enableBreakLoop.top()) {
                         throw CompileError(keyword + " is not inside a loop"s, breakLoop);
                 }
-                if (keyword == "break"sv) {
+                if (isBreak) {
+                        if (breakLoop->value) {
+                                auto exp = toAst<Exp_t>(breakLoop->varBWV, breakLoop->value);
+                                auto assignment = assignmentFrom(exp, breakLoop->value, breakLoop);
+                                transformAssignment(assignment, out);
+                        }
                         out.push_back(indent() + keyword + nll(breakLoop));
                         return;
                 }
diff --git a/src/yuescript/yue_compiler.h b/src/yuescript/yue_compiler.h
index d352636..aff5978 100644
--- a/src/yuescript/yue_compiler.h
+++ b/src/yuescript/yue_compiler.h
@@ -31,6 +31,7 @@ struct YueConfig {
         bool reserveLineNumber = true;
         bool useSpaceOverTab = false;
         bool reserveComment = false;
+        bool lax = false;
         // internal options
         bool exporting = false;
         bool profiling = false;
diff --git a/src/yuescript/yue_parser.cpp b/src/yuescript/yue_parser.cpp
index ceb1f7c..1942e23 100644
--- a/src/yuescript/yue_parser.cpp
+++ b/src/yuescript/yue_parser.cpp
@@ -67,24 +67,28 @@ YueParser::YueParser() {
         num_char = range('0', '9') >> *(range('0', '9') | '_' >> and_(range('0', '9')));
         num_char_hex = range('0', '9') | range('a', 'f') | range('A', 'F');
         num_lit = num_char_hex >> *(num_char_hex | '_' >> and_(num_char_hex));
+        num_bin_lit = set("01") >> *(set("01") | '_' >> and_(set("01")));
         Num =
-                "0x" >> (
-                        +num_lit >> (
-                                '.' >> +num_lit >> -num_expo_hex |
-                                num_expo_hex |
-                                lj_num |
-                                true_()
-                        ) | (
-                                '.' >> +num_lit >> -num_expo_hex
-                        )
+                '0' >> (
+                        set("xX") >> (
+                                num_lit >> (
+                                        '.' >> num_lit >> -num_expo_hex |
+                                        num_expo_hex |
+                                        lj_num |
+                                        true_()
+                                ) | (
+                                        '.' >> num_lit >> -num_expo_hex
+                                )
+                        ) |
+                        set("bB") >> num_bin_lit
                 ) |
-                +num_char >> (
-                        '.' >> +num_char >> -num_expo |
+                num_char >> (
+                        '.' >> num_char >> -num_expo |
                         num_expo |
                         lj_num |
                         true_()
                 ) |
-                '.' >> +num_char >> -num_expo;
+                '.' >> num_char >> -num_expo;
 
         cut = false_();
         Seperator = true_();
@@ -114,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;
         });
 
@@ -158,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 | \
@@ -321,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;
@@ -338,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 >> "::";
 
@@ -346,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");
@@ -366,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 |
@@ -375,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;
@@ -402,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;
         });
 
@@ -431,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_(
@@ -557,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 =
@@ -607,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('=') >> ']';
@@ -635,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
         );
@@ -677,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 |
@@ -734,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)));
 
@@ -755,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");
 
@@ -837,24 +880,24 @@ YueParser::YueParser() {
         key_value_line = check_indent_match >> space >> (
                 key_value_list >> -(space >> ',') |
                 TableBlockIndent |
-                '*' >> space >> (SpreadExp | Exp | TableBlock)
+                ('*' | '-' >> space_one) >> space >> (SpreadExp | Exp | TableBlock)
         );
 
         fn_arg_def_list = FnArgDef >> *(space >> ',' >> space >> FnArgDef);
 
         fn_arg_def_lit_line = (
-                push_indent_match >> (space >> fn_arg_def_list >> pop_indent | pop_indent)
+                push_indent_match >> ensure(space >> fn_arg_def_list, pop_indent)
         ) | (
                 space
         );
 
         fn_arg_def_lit_lines = fn_arg_def_lit_line >> *(-(space >> ',') >> space_break >> fn_arg_def_lit_line);
 
-        FnArgDef = (Variable | SelfItem >> -ExistentialOp) >> -(space >> '=' >> space >> Exp);
+        FnArgDef = (Variable | SelfItem >> -ExistentialOp) >> -(space >> '`' >> space >> Name) >> -(space >> '=' >> space >> Exp);
 
         FnArgDefList = Seperator >> (
-                fn_arg_def_lit_lines >> -(-(space >> ',') >> white >> VarArg) |
-                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"));
@@ -883,6 +926,7 @@ YueParser::YueParser() {
 
         FnArrowBack = '<' >> set("-=");
         Backcall = -(FnArgsDef >> space) >> FnArrowBack >> space >> ChainValue;
+        SubBackcall = FnArrowBack >> space >> ChainValue;
 
         PipeBody = Seperator >>
                 pipe_operator >> space >> UnaryExp >>
@@ -896,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 =
@@ -936,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;
@@ -997,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
 
@@ -1031,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);
@@ -1049,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;
@@ -1086,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;
 }
@@ -1134,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 02292e1..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);
@@ -164,6 +166,7 @@ private:
         NONE_AST_RULE(num_char);
         NONE_AST_RULE(num_char_hex);
         NONE_AST_RULE(num_lit);
+        NONE_AST_RULE(num_bin_lit);
         NONE_AST_RULE(num_expo);
         NONE_AST_RULE(num_expo_hex);
         NONE_AST_RULE(lj_num);
@@ -216,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);
@@ -283,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);
@@ -314,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);
@@ -358,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);
@@ -370,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);
@@ -426,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);
@@ -443,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>