81 files changed, 4443 insertions, 2916 deletions

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);