stop reusing variables, rename project.

13 files changed, 306 insertions, 316 deletions

diff --git a/src/moonp.cpp b/src/yue.cpp
index 27c6016..b5f91ff 100644
--- a/src/moonp.cpp
+++ b/src/yue.cpp
@@ -6,8 +6,8 @@ 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 "MoonP/moon_compiler.h"
-#include "MoonP/moon_parser.h"
+#include "yuescript/yue_compiler.h"
+#include "yuescript/yue_parser.h"
 
 #include <iostream>
 #include <iomanip>
@@ -24,29 +24,29 @@ using namespace std::string_view_literals;
 #include "ghc/fs_std.hpp"
 #include "linenoise.hpp"
 
-#if not (defined MOONP_NO_MACRO && defined MOONP_COMPILER_ONLY)
+#if not (defined YUE_NO_MACRO && defined YUE_COMPILER_ONLY)
 #define _DEFER(code,line) std::shared_ptr<void> _defer_##line(nullptr, [&](auto){code;})
 #define DEFER(code) _DEFER(code,__LINE__)
 extern "C" {
 #include "lua.h"
 #include "lauxlib.h"
 #include "lualib.h"
-int luaopen_moonp(lua_State* L);
+int luaopen_yue(lua_State* L);
 } // extern "C"
 
 static void openlibs(void* state) {
         lua_State* L = static_cast<lua_State*>(state);
         luaL_openlibs(L);
-        luaopen_moonp(L);
+        luaopen_yue(L);
 }
 
-void pushMoonp(lua_State* L, std::string_view name) {
+void pushYue(lua_State* L, std::string_view name) {
         lua_getglobal(L, "package"); // package
         lua_getfield(L, -1, "loaded"); // package loaded
-        lua_getfield(L, -1, "moonp"); // package loaded moonp
-        lua_pushlstring(L, &name.front(), name.size()); // package loaded moonp name
-        lua_gettable(L, -2); // loaded[name], package loaded moonp item
-        lua_insert(L, -4); // item package loaded moonp
+        lua_getfield(L, -1, "yue"); // package loaded yue
+        lua_pushlstring(L, &name.front(), name.size()); // package loaded yue name
+        lua_gettable(L, -2); // loaded[name], package loaded yue item
+        lua_insert(L, -4); // item package loaded yue
         lua_pop(L, 3); // item
 }
 
@@ -71,15 +71,15 @@ void pushOptions(lua_State* L, int lineOffset) {
         lua_pushinteger(L, lineOffset);
         lua_rawset(L, -3);
 }
-#endif // not (defined MOONP_NO_MACRO && defined MOONP_COMPILER_ONLY)
+#endif // not (defined YUE_NO_MACRO && defined YUE_COMPILER_ONLY)
 
-#ifndef MOONP_NO_MACRO
-#define MOONP_ARGS nullptr,openlibs
+#ifndef YUE_NO_MACRO
+#define YUE_ARGS nullptr,openlibs
 #else
-#define MOONP_ARGS
-#endif // MOONP_NO_MACRO
+#define YUE_ARGS
+#endif // YUE_NO_MACRO
 
-#ifndef MOONP_COMPILER_ONLY
+#ifndef YUE_COMPILER_ONLY
 static const char luaminifyCodes[] =
 #include "LuaMinify.h"
 
@@ -92,16 +92,16 @@ static void pushLuaminify(lua_State* L) {
                 luaL_error(L, err.c_str());
         }
 }
-#endif // MOONP_COMPILER_ONLY
+#endif // YUE_COMPILER_ONLY
 
 int main(int narg, const char** args) {
         const char* help =
-"Usage: moonp [options|files|directories] ...\n\n"
+"Usage: yue [options|files|directories] ...\n\n"
 "   -h       Print this message\n"
-#ifndef MOONP_COMPILER_ONLY
+#ifndef YUE_COMPILER_ONLY
 "   -e str   Execute a file or raw codes\n"
 "   -m       Generate minified codes\n"
-#endif // MOONP_COMPILER_ONLY
+#endif // YUE_COMPILER_ONLY
 "   -t path  Specify where to place compiled files\n"
 "   -o file  Write output to file\n"
 "   -s       Use spaces in generated codes instead of tabs\n"
@@ -109,19 +109,19 @@ int main(int narg, const char** args) {
 "   -b       Dump compile time (doesn't write output)\n"
 "   -l       Write line numbers from source codes\n"
 "   -v       Print version\n"
-#ifndef MOONP_COMPILER_ONLY
+#ifndef YUE_COMPILER_ONLY
 "   --       Read from standard in, print to standard out\n"
 "            (Must be first and only argument)\n\n"
 "   Execute without options to enter REPL, type symbol '$'\n"
 "   in a single line to start/stop multi-line mode\n"
-#endif // MOONP_COMPILER_ONLY
+#endif // YUE_COMPILER_ONLY
 ;
-#ifndef MOONP_COMPILER_ONLY
+#ifndef YUE_COMPILER_ONLY
         if (narg == 1) {
                 lua_State* L = luaL_newstate();
                 openlibs(L);
                 DEFER(lua_close(L));
-                pushMoonp(L, "insert_loader"sv);
+                pushYue(L, "insert_loader"sv);
                 if (lua_pcall(L, 0, 0, 0) != 0) {
                         std::cout << lua_tostring(L, -1) << '\n';
                         return 1;
@@ -131,7 +131,7 @@ int main(int narg, const char** args) {
                 linenoise::SetCompletionCallback([](const char* editBuffer, std::vector<std::string>& completions) {
                         std::string buf = editBuffer;
                         std::string tmp = buf;
-                        MoonP::Utils::trim(tmp);
+                        yue::Utils::trim(tmp);
                         if (tmp.empty()) return;
                         std::string pre;
                         auto pos = buf.find_first_not_of(" \t\n");
@@ -176,33 +176,33 @@ int main(int narg, const char** args) {
                                         break;
                         }
                 });
-                std::cout << "Moonscript+ "sv << MoonP::version << '\n';
+                std::cout << "Yuescript "sv << yue::version << '\n';
                 while (true) {
                         count++;
                         std::string codes;
                         bool quit = linenoise::Readline("> ", codes);
                         if (quit) return 0;
                         linenoise::AddHistory(codes.c_str());
-                        MoonP::Utils::trim(codes);
+                        yue::Utils::trim(codes);
                         if (codes == "$"sv) {
                                 codes.clear();
                                 for (std::string line; !(quit = linenoise::Readline("", line));) {
                                         auto temp = line;
-                                        MoonP::Utils::trim(temp);
+                                        yue::Utils::trim(temp);
                                         if (temp == "$"sv) {
                                                 break;
                                         }
                                         codes += '\n';
                                         codes += line;
                                         linenoise::AddHistory(line.c_str());
-                                        MoonP::Utils::trim(codes);
+                                        yue::Utils::trim(codes);
                                 }
                                 if (quit) return 0;
                         }
                         codes.insert(0, "global *\n"sv);
                         int top = lua_gettop(L);
                         DEFER(lua_settop(L, top));
-                        pushMoonp(L, "loadstring"sv);
+                        pushYue(L, "loadstring"sv);
                         lua_pushlstring(L, codes.c_str(), codes.size());
                         lua_pushstring(L, (std::string("=(repl ") + std::to_string(count) + ')').c_str());
                         pushOptions(L, -1);
@@ -226,7 +226,7 @@ int main(int narg, const char** args) {
                                 continue;
                         }
                         lua_pop(L, 1);
-                        pushMoonp(L, "pcall"sv);
+                        pushYue(L, "pcall"sv);
                         lua_insert(L, -2);
                         int last = lua_gettop(L) - 2;
                         if (lua_pcall(L, 1, LUA_MULTRET, 0) != 0) {
@@ -251,8 +251,8 @@ int main(int narg, const char** args) {
                 return 0;
         }
         bool minify = false;
-#endif // MOONP_COMPILER_ONLY
-        MoonP::MoonConfig config;
+#endif // YUE_COMPILER_ONLY
+        yue::YueConfig config;
         config.implicitReturnRoot = true;
         config.lintGlobalVariable = false;
         config.reserveLineNumber = false;
@@ -274,12 +274,12 @@ int main(int narg, const char** args) {
                         while ((ch = std::cin.get()) != EOF) {
                                 codes += ch;
                         }
-                        MoonP::MoonConfig conf;
+                        yue::YueConfig conf;
                         conf.implicitReturnRoot = true;
                         conf.lintGlobalVariable = false;
                         conf.reserveLineNumber = false;
                         conf.useSpaceOverTab = true;
-                        auto result = MoonP::MoonCompiler{MOONP_ARGS}.compile(codes, conf);
+                        auto result = yue::YueCompiler{YUE_ARGS}.compile(codes, conf);
                         if (result.error.empty()) {
                                 std::cout << result.codes;
                                 return 0;
@@ -288,14 +288,14 @@ int main(int narg, const char** args) {
                                 std::cout << result.error << '\n';
                                 return 1;
                         }
-#ifndef MOONP_COMPILER_ONLY
+#ifndef YUE_COMPILER_ONLY
                 } else if (arg == "-e"sv) {
                         ++i;
                         if (i < narg) {
                                 lua_State* L = luaL_newstate();
                                 openlibs(L);
                                 DEFER(lua_close(L));
-                                pushMoonp(L, "insert_loader"sv);
+                                pushYue(L, "insert_loader"sv);
                                 if (lua_pcall(L, 0, 0, 0) != 0) {
                                         std::cout << lua_tostring(L, -1) << '\n';
                                         return 1;
@@ -308,7 +308,7 @@ int main(int narg, const char** args) {
                                         if (ext == ".lua") {
                                                 lua_getglobal(L, "load");
                                         } else {
-                                                pushMoonp(L, "loadstring"sv);
+                                                pushYue(L, "loadstring"sv);
                                         }
                                         std::string s(
                                                 (std::istreambuf_iterator<char>(input)),
@@ -316,7 +316,7 @@ int main(int narg, const char** args) {
                                         lua_pushlstring(L, s.c_str(), s.size());
                                         lua_pushlstring(L, evalStr.c_str(), evalStr.size());
                                 } else {
-                                        pushMoonp(L, "loadstring"sv);
+                                        pushYue(L, "loadstring"sv);
                                         lua_pushlstring(L, evalStr.c_str(), evalStr.size());
                                         lua_pushliteral(L, "=(eval str)");
                                 }
@@ -329,7 +329,7 @@ int main(int narg, const char** args) {
                                         return 1;
                                 }
                                 lua_pop(L, 1);
-                                pushMoonp(L, "pcall"sv);
+                                pushYue(L, "pcall"sv);
                                 lua_insert(L, -2);
                                 int argCount = 0;
                                 i++;
@@ -354,7 +354,7 @@ int main(int narg, const char** args) {
                         }
                 } else if (arg == "-m"sv) {
                         minify = true;
-#endif // MOONP_COMPILER_ONLY
+#endif // YUE_COMPILER_ONLY
                 } else if (arg == "-s"sv) {
                         config.useSpaceOverTab = true;
                 } else if (arg == "-l"sv) {
@@ -375,7 +375,7 @@ int main(int narg, const char** args) {
                         std::cout << help;
                         return 0;
                 } else if (arg == "-v"sv) {
-                        std::cout << "Moonscript+ version: "sv << MoonP::version << '\n';
+                        std::cout << "Yuescript version: "sv << yue::version << '\n';
                         return 0;
                 } else if (arg == "-o"sv) {
                         ++i;
@@ -397,7 +397,7 @@ int main(int narg, const char** args) {
                                         if (!item.is_directory()) {
                                                 auto ext = item.path().extension().string();
                                                 for (char& ch : ext) ch = std::tolower(ch);
-                                                if (!ext.empty() && ext.substr(1) == MoonP::extension) {
+                                                if (!ext.empty() && ext.substr(1) == yue::extension) {
                                                         files.emplace_back(item.path().string(), item.path().lexically_relative(arg).string());
                                                 }
                                         }
@@ -425,12 +425,12 @@ int main(int narg, const char** args) {
                                         std::istreambuf_iterator<char>());
                                 if (dumpCompileTime) {
                                         auto start = std::chrono::high_resolution_clock::now();
-                                        auto result = MoonP::MoonCompiler{MOONP_ARGS}.compile(s, config);
+                                        auto result = yue::YueCompiler{YUE_ARGS}.compile(s, config);
                                         auto end = std::chrono::high_resolution_clock::now();
                                         if (!result.codes.empty()) {
                                                 std::chrono::duration<double> diff = end - start;
                                                 start = std::chrono::high_resolution_clock::now();
-                                                MoonP::MoonParser{}.parse<MoonP::File_t>(s);
+                                                yue::YueParser{}.parse<yue::File_t>(s);
                                                 end = std::chrono::high_resolution_clock::now();
                                                 std::chrono::duration<double> parseDiff = end - start;
                                                 std::ostringstream buf;
@@ -445,7 +445,7 @@ int main(int narg, const char** args) {
                                                 return std::tuple{1, file.first, buf.str()};
                                         }
                                 }
-                                auto result = MoonP::MoonCompiler{MOONP_ARGS}.compile(s, config);
+                                auto result = yue::YueCompiler{YUE_ARGS}.compile(s, config);
                                 if (result.error.empty()) {
                                         if (!writeToFile) {
                                                 return std::tuple{0, file.first, result.codes + '\n'};
@@ -475,7 +475,7 @@ int main(int narg, const char** args) {
                                                 if (output) {
                                                         const auto& codes = result.codes;
                                                         if (config.reserveLineNumber) {
-                                                                auto head = std::string("-- [moonp]: "sv) + file.first + '\n';
+                                                                auto head = std::string("-- [yue]: "sv) + file.first + '\n';
                                                                 output.write(head.c_str(), head.size());
                                                         }
                                                         output.write(codes.c_str(), codes.size());
@@ -497,7 +497,7 @@ int main(int narg, const char** args) {
                 results.push_back(std::move(task));
         }
         int ret = 0;
-#ifndef MOONP_COMPILER_ONLY
+#ifndef YUE_COMPILER_ONLY
         lua_State* L = nullptr;
         DEFER({
                 if (L) lua_close(L);
@@ -507,7 +507,7 @@ int main(int narg, const char** args) {
                 luaL_openlibs(L);
                 pushLuaminify(L);
         }
-#endif // MOONP_COMPILER_ONLY
+#endif // YUE_COMPILER_ONLY
         std::list<std::string> errs;
         for (auto& result : results) {
                 int val = 0;
@@ -518,7 +518,7 @@ int main(int narg, const char** args) {
                         ret = val;
                         errs.push_back(msg);
                 } else {
-#ifndef MOONP_COMPILER_ONLY
+#ifndef YUE_COMPILER_ONLY
                         if (minify) {
                                 std::ifstream input(file, std::ios::in);
                                 if (input) {
@@ -560,7 +560,7 @@ int main(int narg, const char** args) {
                         }
 #else
                         std::cout << msg;
-#endif // MOONP_COMPILER_ONLY
+#endif // YUE_COMPILER_ONLY
                 }
         }
         for (const auto& err : errs) {
diff --git a/src/MoonP/ast.cpp b/src/yuescript/ast.cpp
index 4929021..3deefb1 100644
--- a/src/MoonP/ast.cpp
+++ b/src/yuescript/ast.cpp
@@ -11,7 +11,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
 #include <cassert>
 
-#include "MoonP/ast.hpp"
+#include "yuescript/ast.hpp"
 
 
 namespace parserlib {
diff --git a/src/MoonP/ast.hpp b/src/yuescript/ast.hpp
index 104202d..c88fcf9 100644
--- a/src/MoonP/ast.hpp
+++ b/src/yuescript/ast.hpp
@@ -17,7 +17,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 #include <stdexcept>
 #include <type_traits>
 
-#include "MoonP/parser.hpp"
+#include "yuescript/parser.hpp"
 
 
 namespace parserlib {
diff --git a/src/MoonP/parser.cpp b/src/yuescript/parser.cpp
index 8dc2ff9..a44ae34 100644
--- a/src/MoonP/parser.cpp
+++ b/src/yuescript/parser.cpp
@@ -16,7 +16,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 #include <unordered_map>
 #include <unordered_set>
 
-#include "MoonP/parser.hpp"
+#include "yuescript/parser.hpp"
 
 
 namespace parserlib {
diff --git a/src/MoonP/parser.hpp b/src/yuescript/parser.hpp
index f70475f..f70475f 100644
--- a/src/MoonP/parser.hpp
+++ b/src/yuescript/parser.hpp
diff --git a/src/MoonP/stacktraceplus.h b/src/yuescript/stacktraceplus.h
index e884a2c..b165754 100644
--- a/src/MoonP/stacktraceplus.h
+++ b/src/yuescript/stacktraceplus.h
@@ -36,7 +36,7 @@ local string_gmatch = string.gmatch
 local string_sub = string.sub
 local table_concat = table.concat
 
-local moonp = require("moonp")
+local yue = require("yue")
 
 local _M = {
         max_tb_output_len = 70, -- controls the maximum length of the 'stringified' table before cutting with ' (more...)'
@@ -161,8 +161,8 @@ local function GuessFunctionName(info)
         if type(info.source) == "string" and info.source:sub(1,1) == "@" then
                 local fname = info.source:sub(2)
                 local text
-                if moonp.file_exist(fname) then
-                        text = moonp.read_file(fname)
+                if yue.file_exist(fname) then
+                        text = yue.read_file(fname)
                 end
                 if not text then
                         -- print("file not found: "..tostring(err))     -- whoops!
@@ -317,27 +317,27 @@ function Dumper:DumpLocals (level)
         end
 end
 
-local function getMoonLineNumber(fname, line)
-        local moonCompiled = require("moonp").moon_compiled
-        local source = moonCompiled["@"..fname]
+local function getYueLineNumber(fname, line)
+        local yueCompiled = require("yue").yue_compiled
+        local source = yueCompiled["@"..fname]
         if not source then
-                source = moonCompiled["@="..fname]
+                source = yueCompiled["@="..fname]
         end
         if not source then
-                local name_path = fname:gsub("%.", moonp.dirsep)
+                local name_path = fname:gsub("%.", yue.dirsep)
                 local file_exist, file_path
                 for path in package.path:gmatch("[^;]+") do
                         file_path = path:gsub("?", name_path)
-                        file_exist = moonp.file_exist(file_path)
+                        file_exist = yue.file_exist(file_path)
                         if file_exist then
                                 break
                         end
                 end
                 if file_exist then
-                        local codes = moonp.read_file(file_path)
-                        local moonFile = codes:match("^%s*--%s*%[moonp%]:%s*([^\n]*)")
-                        if moonFile then
-                                fname = moonFile:gsub("^%s*(.-)%s*$", "%1")
+                        local codes = yue.read_file(file_path)
+                        local yueFile = codes:match("^%s*--%s*%[yue%]:%s*([^\n]*)")
+                        if yueFile then
+                                fname = yueFile:gsub("^%s*(.-)%s*$", "%1")
                                 source = codes
                         end
                 end
@@ -409,12 +409,12 @@ function _M.stacktrace(thread, message, level)
                         local fn = fname:match("%[string \"(.-)\"%]")
                         if fn then fname = fn end
                         fname = fname:gsub("^%s*(.-)%s*$", "%1")
-                        fname, line = getMoonLineNumber(fname, line)
+                        fname, line = getYueLineNumber(fname, line)
                         if _M.simplified then
                                 message = table.concat({
                                         "", fname, ":",
                                         line, ": ", msg})
-                                message = message:gsub("^%(moonplus%):%s*%d+:%s*", "")
+                                message = message:gsub("^%(yuescript%):%s*%d+:%s*", "")
                                 message = message:gsub("%s(%d+):", "%1:")
                         else
                                 message = table.concat({
@@ -441,7 +441,7 @@ Stack Traceback
                 elseif info.what == "main" or info.what == "Lua" then
                         info.source = info.source
                 end
-                info.source, info.currentline = getMoonLineNumber(info.source, info.currentline)
+                info.source, info.currentline = getYueLineNumber(info.source, info.currentline)
                 if info.what == "main" then
                         if _M.simplified then
                                 dumper:add_f("(%d) '%s':%d\r\n", level_to_show, info.source, info.currentline)
diff --git a/src/MoonP/moon_ast.h b/src/yuescript/yue_ast.h
index 6b738d4..090765c 100644
--- a/src/MoonP/moon_ast.h
+++ b/src/yuescript/yue_ast.h
@@ -8,7 +8,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 
-#include "MoonP/ast.hpp"
+#include "yuescript/ast.hpp"
 
 namespace parserlib {
 
diff --git a/src/MoonP/moon_compiler.cpp b/src/yuescript/yue_compiler.cpp
index 24e4a97..22311f4 100644
--- a/src/MoonP/moon_compiler.cpp
+++ b/src/yuescript/yue_compiler.cpp
@@ -12,12 +12,11 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <stack>
 #include <vector>
 #include <memory>
-#include <cassert>
 
-#include "MoonP/moon_parser.h"
-#include "MoonP/moon_compiler.h"
+#include "yuescript/yue_parser.h"
+#include "yuescript/yue_compiler.h"
 
-#ifndef MOONP_NO_MACRO
+#ifndef YUE_NO_MACRO
 
 extern "C" {
 #include "lua.h"
@@ -26,7 +25,7 @@ extern "C" {
 } // extern "C"
 
 // name of table stored in lua registry
-#define MOONP_MODULE "__moon_modules__"
+#define YUE_MODULE "__yue_modules__"
 
 #if LUA_VERSION_NUM > 501
         #ifndef LUA_COMPAT_5_1
@@ -34,9 +33,9 @@ extern "C" {
         #endif // LUA_COMPAT_5_1
 #endif // LUA_VERSION_NUM
 
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
 
-namespace MoonP {
+namespace yue {
 using namespace std::string_view_literals;
 using namespace parserlib;
 
@@ -46,6 +45,12 @@ using namespace parserlib;
 
 #define _DEFER(code,line) std::shared_ptr<void> _defer_##line(nullptr, [&](auto){code;})
 #define DEFER(code) _DEFER(code,__LINE__)
+#define YUEE(msg,node) throw std::logic_error( \
+        _info.errorMessage( \
+                std::string("[File] ") + __FILE__ \
+                + ", [Func] " + __FUNCTION__ \
+                + ", [Line] " + std::to_string(__LINE__) \
+                + ", [Error] " + msg, node))
 
 typedef std::list<std::string> str_list;
 
@@ -53,13 +58,13 @@ inline std::string s(std::string_view sv) {
         return std::string(sv);
 }
 
-const std::string_view version = "0.6.3"sv;
-const std::string_view extension = "mp"sv;
+const std::string_view version = "0.6.5"sv;
+const std::string_view extension = "yue"sv;
 
-class MoonCompilerImpl {
+class YueCompilerImpl {
 public:
-#ifndef MOONP_NO_MACRO
-        MoonCompilerImpl(lua_State* sharedState,
+#ifndef YUE_NO_MACRO
+        YueCompilerImpl(lua_State* sharedState,
                 const std::function<void(void*)>& luaOpen,
                 bool sameModule,
                 std::string_view moduleName = {}):
@@ -72,8 +77,8 @@ public:
                 _sameModule = true;
                 int top = lua_gettop(L);
                 DEFER(lua_settop(L, top));
-                lua_pushliteral(L, MOONP_MODULE); // MOONP_MODULE
-                lua_rawget(L, LUA_REGISTRYINDEX); // reg[MOONP_MODULE], tb
+                lua_pushliteral(L, YUE_MODULE); // YUE_MODULE
+                lua_rawget(L, LUA_REGISTRYINDEX); // reg[YUE_MODULE], tb
                 BREAK_IF(lua_istable(L, -1) == 0);
                 int idx = static_cast<int>(lua_objlen(L, -1)); // idx = #tb, tb
                 BREAK_IF(idx == 0);
@@ -81,19 +86,19 @@ public:
                 BLOCK_END
         }
 
-        ~MoonCompilerImpl() {
+        ~YueCompilerImpl() {
                 if (L && _stateOwner) {
                         lua_close(L);
                         L = nullptr;
                 }
         }
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
 
-        CompileInfo compile(std::string_view codes, const MoonConfig& config) {
+        CompileInfo compile(std::string_view codes, const YueConfig& config) {
                 _config = config;
-#ifndef MOONP_NO_MACRO
+#ifndef YUE_NO_MACRO
                 if (L) passOptions();
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
                 _info = _parser.parse<File_t>(codes);
                 std::unique_ptr<GlobalVars> globals;
                 std::unique_ptr<Options> options;
@@ -119,14 +124,14 @@ public:
                                                 globals->push_back({var.first, line, col});
                                         }
                                 }
-#ifndef MOONP_NO_MACRO
+#ifndef YUE_NO_MACRO
                                 if (L) {
                                         int top = lua_gettop(L);
                                         DEFER(lua_settop(L, top));
                                         if (!options) {
                                                 options = std::make_unique<Options>();
                                         }
-                                        pushMoonp("options"sv);
+                                        pushYue("options"sv);
                                         lua_pushnil(L); // options startKey
                                         while (lua_next(L, -2) != 0) { // options key value
                                                 size_t len = 0;
@@ -138,7 +143,7 @@ public:
                                                 lua_pop(L, 1); // options key
                                         }
                                 }
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
                                 return {std::move(out.back()), Empty, std::move(globals), std::move(options)};
                         } catch (const std::logic_error& error) {
                                 return {Empty, error.what(), std::move(globals), std::move(options)};
@@ -162,31 +167,31 @@ public:
                 _withVars = {};
                 _continueVars = {};
                 _enableReturn = {};
-#ifndef MOONP_NO_MACRO
+#ifndef YUE_NO_MACRO
                 if (_useModule) {
                         _useModule = false;
                         if (!_sameModule) {
                                 int top = lua_gettop(L);
                                 DEFER(lua_settop(L, top));
-                                lua_pushliteral(L, MOONP_MODULE); // MOONP_MODULE
-                                lua_rawget(L, LUA_REGISTRYINDEX); // reg[MOONP_MODULE], tb
+                                lua_pushliteral(L, YUE_MODULE); // YUE_MODULE
+                                lua_rawget(L, LUA_REGISTRYINDEX); // reg[YUE_MODULE], tb
                                 int idx = static_cast<int>(lua_objlen(L, -1));
                                 lua_pushnil(L); // tb nil
                                 lua_rawseti(L, -2, idx); // tb[idx] = nil, tb
                         }
                 }
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
         }
 private:
-#ifndef MOONP_NO_MACRO
+#ifndef YUE_NO_MACRO
         bool _stateOwner = false;
         bool _useModule = false;
         bool _sameModule = false;
         lua_State* L = nullptr;
         std::function<void(void*)> _luaOpen;
-#endif // MOONP_NO_MACRO
-        MoonConfig _config;
-        MoonParser _parser;
+#endif // YUE_NO_MACRO
+        YueConfig _config;
+        YueParser _parser;
         ParseInfo _info;
         int _indentOffset = 0;
         std::stack<bool> _varArgs;
@@ -523,7 +528,7 @@ private:
                         case id<Statement_t>(): {
                                 return static_cast<Statement_t*>(body);
                         }
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", body); break;
                 }
                 return nullptr;
         }
@@ -875,7 +880,7 @@ private:
                                         statement->appendix.set(nullptr);
                                         break;
                                 }
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", appendix->item.get()); break;
                         }
                 }
                 auto content = statement->content.get();
@@ -947,7 +952,7 @@ private:
                                 }
                                 break;
                         }
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", content); break;
                 }
                 if (statement->needSep && !out.back().empty()) {
                         auto index = std::string::npos;
@@ -1287,7 +1292,7 @@ private:
                         case id<Switch_t>(): transformSwitch(static_cast<Switch_t*>(value), out, ExpUsage::Closure); break;
                         case id<TableBlock_t>(): transformTableBlock(static_cast<TableBlock_t*>(value), out); break;
                         case id<Exp_t>(): transformExp(static_cast<Exp_t*>(value), out, ExpUsage::Closure); break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", value); break;
                 }
         }
 
@@ -1411,7 +1416,7 @@ private:
                                         }
                                         break;
                                 }
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", pair); break;
                         }
                 }
                 return pairs;
@@ -1574,7 +1579,7 @@ private:
                                 }
                                 break;
                         }
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", action); break;
                 }
         }
 
@@ -1632,7 +1637,7 @@ private:
                                         ifCondPairs.back().second = node;
                                         ifCondPairs.emplace_back();
                                         break;
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", node); break;
                         }
                 }
                 auto assign = ifCondPairs.front().first->assign.get();
@@ -1853,7 +1858,7 @@ private:
                                         transformExp(arg, out, ExpUsage::Closure);
                                         return;
                                 }
-                                default: assert(false); return;
+                                default: YUEE("invalid expression usage", x); return;
                         }
                 }
         }
@@ -1863,7 +1868,9 @@ private:
                         transform_backcall_exp(exp->backcalls.objects(), out, usage, assignList);
                         return;
                 }
-                assert(usage == ExpUsage::Closure);
+                if (usage != ExpUsage::Closure) {
+                        YUEE("invalid expression usage", exp);
+                }
                 str_list temp;
                         transform_backcall_exp(exp->backcalls.objects(), temp, ExpUsage::Closure);
                 for (auto _opValue : exp->opValues.objects()) {
@@ -1881,7 +1888,7 @@ private:
                         case id<simple_table_t>(): transform_simple_table(static_cast<simple_table_t*>(item), out); break;
                         case id<ChainValue_t>(): transformChainValue(static_cast<ChainValue_t*>(item), out, ExpUsage::Closure); break;
                         case id<String_t>(): transformString(static_cast<String_t*>(item), out); break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", value); break;
                 }
         }
 
@@ -1916,7 +1923,7 @@ private:
                                 out.push_back(s("..."sv));
                                 break;
                         case id<Parens_t>(): transformParens(static_cast<Parens_t*>(item), out); break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", item); break;
                 }
         }
 
@@ -1945,7 +1952,7 @@ private:
                         case id<Comprehension_t>(): transformComprehension(static_cast<Comprehension_t*>(value), out, ExpUsage::Closure); break;
                         case id<FunLit_t>(): transformFunLit(static_cast<FunLit_t*>(value), out); break;
                         case id<Num_t>(): transformNum(static_cast<Num_t*>(value), out); break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", value); break;
                 }
         }
 
@@ -2304,10 +2311,10 @@ private:
                 }
         }
 
-#ifndef MOONP_NO_MACRO
+#ifndef YUE_NO_MACRO
         void passOptions() {
                 if (!_config.options.empty()) {
-                        pushMoonp("options"sv); // options
+                        pushYue("options"sv); // options
                         for (const auto& option : _config.options) {
                                 lua_pushlstring(L, option.second.c_str(), option.second.size());
                                 lua_setfield(L, -2, option.first.c_str());
@@ -2318,8 +2325,8 @@ private:
 
         void pushCurrentModule() {
                 if (_useModule) {
-                        lua_pushliteral(L, MOONP_MODULE); // MOONP_MODULE
-                        lua_rawget(L, LUA_REGISTRYINDEX); // reg[MOONP_MODULE], tb
+                        lua_pushliteral(L, YUE_MODULE); // YUE_MODULE
+                        lua_rawget(L, LUA_REGISTRYINDEX); // reg[YUE_MODULE], tb
                         int idx = static_cast<int>(lua_objlen(L, -1)); // idx = #tb, tb
                         lua_rawgeti(L, -1, idx); // tb[idx], tb cur
                         lua_remove(L, -2); // cur
@@ -2334,14 +2341,14 @@ private:
                         passOptions();
                         _stateOwner = true;
                 }
-                lua_pushliteral(L, MOONP_MODULE); // MOONP_MODULE
-                lua_rawget(L, LUA_REGISTRYINDEX); // reg[MOONP_MODULE], tb
+                lua_pushliteral(L, YUE_MODULE); // YUE_MODULE
+                lua_rawget(L, LUA_REGISTRYINDEX); // reg[YUE_MODULE], tb
                 if (lua_isnil(L, -1) != 0) { // tb == nil
                         lua_pop(L, 1);
                         lua_newtable(L); // tb
-                        lua_pushliteral(L, MOONP_MODULE); // tb MOONP_MODULE
-                        lua_pushvalue(L, -2); // tb MOONP_MODULE tb
-                        lua_rawset(L, LUA_REGISTRYINDEX); // reg[MOONP_MODULE] = tb, tb
+                        lua_pushliteral(L, YUE_MODULE); // tb YUE_MODULE
+                        lua_pushvalue(L, -2); // tb YUE_MODULE tb
+                        lua_rawset(L, LUA_REGISTRYINDEX); // reg[YUE_MODULE] = tb, tb
                 } // tb
                 int idx = static_cast<int>(lua_objlen(L, -1)); // idx = #tb, tb
                 lua_newtable(L); // tb cur
@@ -2350,20 +2357,20 @@ private:
                 lua_remove(L, -2); // cur
         }
 
-        void pushMoonp(std::string_view name) {
+        void pushYue(std::string_view name) {
                 lua_getglobal(L, "package"); // package
                 lua_getfield(L, -1, "loaded"); // package loaded
-                lua_getfield(L, -1, "moonp"); // package loaded moonp
-                lua_pushlstring(L, &name.front(), name.size()); // package loaded moonp name
-                lua_gettable(L, -2); // loaded[name], package loaded moonp item
-                lua_insert(L, -4); // item package loaded moonp
+                lua_getfield(L, -1, "yue"); // package loaded yue
+                lua_pushlstring(L, &name.front(), name.size()); // package loaded yue name
+                lua_gettable(L, -2); // loaded[name], package loaded yue item
+                lua_insert(L, -4); // item package loaded yue
                 lua_pop(L, 3); // item
         }
 
         bool isModuleLoaded(std::string_view name) {
                 int top = lua_gettop(L);
                 DEFER(lua_settop(L, top));
-                lua_pushliteral(L, MOONP_MODULE); // MOONP_MODULE
+                lua_pushliteral(L, YUE_MODULE); // YUE_MODULE
                 lua_rawget(L, LUA_REGISTRYINDEX); // modules
                 lua_pushlstring(L, &name.front(), name.size());
                 lua_rawget(L, -2); // modules module
@@ -2374,7 +2381,7 @@ private:
         }
 
         void pushModuleTable(std::string_view name) {
-                lua_pushliteral(L, MOONP_MODULE); // MOONP_MODULE
+                lua_pushliteral(L, YUE_MODULE); // YUE_MODULE
                 lua_rawget(L, LUA_REGISTRYINDEX); // modules
                 lua_pushlstring(L, &name.front(), name.size());
                 lua_rawget(L, -2); // modules module
@@ -2442,7 +2449,7 @@ private:
                 pushCurrentModule(); // cur
                 int top = lua_gettop(L) - 1;
                 DEFER(lua_settop(L, top));
-                pushMoonp("loadstring"sv); // cur loadstring
+                pushYue("loadstring"sv); // cur loadstring
                 lua_pushlstring(L, macroCodes.c_str(), macroCodes.size()); // cur loadstring codes
                 lua_pushlstring(L, chunkName.c_str(), chunkName.size()); // cur loadstring codes chunk
                 pushOptions(macro->m_begin.m_line - 1); // cur loadstring codes chunk options
@@ -2455,7 +2462,7 @@ private:
                         throw std::logic_error(_info.errorMessage(s("failed to load macro codes, at (macro "sv) + macroName + s("): "sv) + err, macro->macroLit));
                 }
                 lua_pop(L, 1); // cur f
-                pushMoonp("pcall"sv); // cur f pcall
+                pushYue("pcall"sv); // cur f pcall
                 lua_insert(L, -2); // cur pcall f
                 if (lua_pcall(L, 1, 2, 0) != 0) { // f(), cur success macro
                         std::string err = lua_tostring(L, -1);
@@ -2482,7 +2489,7 @@ private:
         void transformMacro(Macro_t* macro, str_list&, bool) {
                 throw std::logic_error(_info.errorMessage("macro feature not supported"sv, macro));
         }
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
 
         void transformReturn(Return_t* returnNode, str_list& out) {
                 if (!_enableReturn.top()) {
@@ -2613,11 +2620,11 @@ private:
                                                 case id<self_t>():
                                                         arg.name = "self"sv;
                                                         break;
-                                                default: assert(false); break;
+                                                default: YUEE("AST node mismatch", selfName->name.get()); break;
                                         }
                                         break;
                                 }
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", def->name.get()); break;
                         }
                         forceAddToScope(arg.name);
                         if (def->defaultValue) {
@@ -2710,7 +2717,7 @@ private:
                         case id<self_t>():
                                 out.push_back(s("self"sv));
                                 break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", name); break;
                 }
         }
 
@@ -3170,24 +3177,24 @@ private:
                                         temp.back() = s(temp.back().front() == '[' ? "[ "sv : "["sv) + temp.back() + s("]"sv);
                                         break;
                                 case id<InvokeArgs_t>(): transformInvokeArgs(static_cast<InvokeArgs_t*>(item), temp); break;
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", item); break;
                         }
                 }
                 switch (usage) {
                         case ExpUsage::Common:
-                                out.push_back(indent() + join(temp) + nll(chainList.front()));
+                                out.push_back(indent() + join(temp) + nll(x));
                                 break;
                         case ExpUsage::Return:
-                                out.push_back(indent() + s("return "sv) + join(temp) + nll(chainList.front()));
+                                out.push_back(indent() + s("return "sv) + join(temp) + nll(x));
                                 break;
-                        case ExpUsage::Assignment: assert(false); break;
+                        case ExpUsage::Assignment: YUEE("invalid expression usage", x); break;
                         default:
                                 out.push_back(join(temp));
                                 break;
                 }
         }
 
-#ifndef MOONP_NO_MACRO
+#ifndef YUE_NO_MACRO
         std::tuple<std::string,std::string,str_list> expandMacroStr(ChainValue_t* chainValue) {
                 const auto& chainList = chainValue->items.objects();
                 auto x = ast_to<Callable_t>(chainList.front())->item.to<MacroName_t>();
@@ -3212,7 +3219,7 @@ private:
                         }
                         auto fcodes = _parser.toString(args->back());
                         Utils::trim(fcodes);
-                        pushMoonp("loadstring"sv); // loadstring
+                        pushYue("loadstring"sv); // loadstring
                         lua_pushlstring(L, fcodes.c_str(), fcodes.size()); // loadstring codes
                         lua_pushliteral(L, "=(macro in-place)"); // loadstring codes chunk
                         pushOptions(args->back()->m_begin.m_line - 1); // loadstring codes chunk options
@@ -3225,7 +3232,7 @@ private:
                                 throw std::logic_error(_info.errorMessage(s("failed to load macro codes, at (macro in-place): "sv) + err, x));
                         }
                         lua_pop(L, 1); // f
-                        pushMoonp("pcall"sv); // f pcall
+                        pushYue("pcall"sv); // f pcall
                         lua_insert(L, -2); // pcall f
                         if (lua_pcall(L, 1, 2, 0) != 0) { // f(), success macroFunc
                                 std::string err = lua_tostring(L, -1);
@@ -3236,7 +3243,7 @@ private:
                                 throw std::logic_error(_info.errorMessage(s("failed to generate macro function\n"sv) + err, x));
                         } // true macroFunc
                         lua_remove(L, -2); // macroFunc
-                        pushMoonp("pcall"sv); // macroFunc pcall
+                        pushYue("pcall"sv); // macroFunc pcall
                         lua_insert(L, -2); // pcall macroFunc
                         bool success = lua_pcall(L, 1, 2, 0) == 0;
                         if (!success) { // err
@@ -3254,7 +3261,7 @@ private:
                 if (lua_isfunction(L, -1) == 0) {
                         throw std::logic_error(_info.errorMessage("can not resolve macro"sv, x));
                 } // cur macroFunc
-                pushMoonp("pcall"sv); // cur macroFunc pcall
+                pushYue("pcall"sv); // cur macroFunc pcall
                 lua_insert(L, -2); // cur pcall macroFunc
                 auto item = *(++chainList.begin());
                 const node_container* args = nullptr;
@@ -3457,11 +3464,11 @@ private:
                         }
                 }
         }
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
 
         void transformChainValue(ChainValue_t* chainValue, str_list& out, ExpUsage usage, ExpList_t* assignList = nullptr, bool allowBlockMacroReturn = false) {
                 if (isMacroChain(chainValue)) {
-#ifndef MOONP_NO_MACRO
+#ifndef YUE_NO_MACRO
                         ast_ptr<false,ast_node> node;
                         std::unique_ptr<input> codes;
                         std::string luaCodes;
@@ -3515,7 +3522,7 @@ private:
 #else
                         (void)allowBlockMacroReturn;
                         throw std::logic_error(_info.errorMessage("macro feature not supported"sv, chainValue));
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
                 }
                 const auto& chainList = chainValue->items.objects();
                 if (transformChainEndWithEOP(chainList, out, usage, assignList)) {
@@ -3561,7 +3568,7 @@ private:
                                 case id<DoubleString_t>(): transformDoubleString(static_cast<DoubleString_t*>(arg), temp); break;
                                 case id<LuaString_t>(): transformLuaString(static_cast<LuaString_t*>(arg), temp); break;
                                 case id<TableLit_t>(): transformTableLit(static_cast<TableLit_t*>(arg), temp); break;
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", arg); break;
                         }
                 }
                 out.push_back(s("("sv) + join(temp, ", "sv) + s(")"sv));
@@ -3624,7 +3631,7 @@ private:
                                         temp.back() = indent() + s("if "sv) + temp.back() + s(" then"sv) + nll(item);
                                         pushScope();
                                         break;
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", item); break;
                         }
                 }
                 if (auto stmt = comp->value.as<Statement_t>()) {
@@ -3680,7 +3687,7 @@ private:
                                         temp.back() = indent() + s("if "sv) + temp.back() + s(" then"sv) + nll(item);
                                         pushScope();
                                         break;
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", item); break;
                         }
                 }
                 {
@@ -3760,13 +3767,13 @@ private:
                                         varAfter.push_back(desVar);
                                         break;
                                 }
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", item); break;
                         }
                 }
                 switch (loopTarget->getId()) {
                         case id<star_exp_t>(): {
                                 auto star_exp = static_cast<star_exp_t*>(loopTarget);
-                                auto listVar = singleVariableFrom(star_exp->value);
+                                std::string listVar;
                                 auto indexVar = getUnusedName("_index_"sv);
                                 varAfter.push_back(indexVar);
                                 auto value = singleValueFrom(star_exp->value);
@@ -3779,12 +3786,6 @@ private:
                                 auto slice = ast_cast<Slice_t>(chainList.back());
                                 BREAK_IF(!slice);
                                 endWithSlice = true;
-                                if (listVar.empty() && chainList.size() == 2 &&
-                                        ast_is<Callable_t>(chainList.front())) {
-                                        transformCallable(static_cast<Callable_t*>(chainList.front()), temp);
-                                        listVar = temp.back();
-                                        temp.pop_back();
-                                }
                                 chainList.pop_back();
                                 auto chain = x->new_ptr<ChainValue_t>();
                                 for (auto item : chainList) {
@@ -3808,12 +3809,10 @@ private:
                                         stepValue = temp.back();
                                         temp.pop_back();
                                 }
-                                if (listVar.empty()) {
-                                        listVar = getUnusedName("_list_"sv);
-                                        varBefore.push_back(listVar);
-                                        transformChainValue(chain, temp, ExpUsage::Closure);
-                                        _buf << indent() << "local "sv << listVar << " = "sv << temp.back() << nll(nameList);
-                                }
+                                listVar = getUnusedName("_list_"sv);
+                                varBefore.push_back(listVar);
+                                transformChainValue(chain, temp, ExpUsage::Closure);
+                                _buf << indent() << "local "sv << listVar << " = "sv << temp.back() << nll(nameList);
                                 std::string maxVar;
                                 if (!stopValue.empty()) {
                                         maxVar = getUnusedName("_max_"sv);
@@ -3859,7 +3858,7 @@ private:
                                 _buf << indent() << "for "sv << join(vars, ", "sv) << " in "sv << temp.back() << " do"sv << nlr(loopTarget);
                                 out.push_back(clearBuf());
                                 break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", loopTarget); break;
                 }
                 for (auto& var : varBefore) addToScope(var);
                 pushScope();
@@ -3926,7 +3925,7 @@ private:
                         switch (arg->getId()) {
                                 case id<Exp_t>(): transformExp(static_cast<Exp_t*>(arg), temp, ExpUsage::Closure); break;
                                 case id<TableBlock_t>(): transformTableBlock(static_cast<TableBlock_t*>(arg), temp); break;
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", arg); break;
                         }
                 }
                 out.push_back(s("("sv) + join(temp, ", "sv) + s(")"sv));
@@ -3963,7 +3962,7 @@ private:
                                 transformBlock(newBlock, out, usage, assignList);
                                 break;
                         }
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", body); break;
                 }
         }
 
@@ -4172,13 +4171,13 @@ private:
                         case id<LuaString_t>(): transformLuaString(static_cast<LuaString_t*>(key), temp);
                                 temp.back() = s("[ "sv) + temp.back() + s("]"sv);
                                 break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", key); break;
                 }
                 auto value = pair->value.get();
                 switch (value->getId()) {
                         case id<Exp_t>(): transformExp(static_cast<Exp_t*>(value), temp, ExpUsage::Closure); break;
                         case id<TableBlock_t>(): transformTableBlock(static_cast<TableBlock_t*>(value), temp); break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", value); break;
                 }
                 out.push_back(temp.front() + s(" = "sv) + temp.back());
         }
@@ -4188,7 +4187,7 @@ private:
                 switch (name->getId()) {
                         case id<SelfName_t>(): transformSelfName(static_cast<SelfName_t*>(name), out); break;
                         case id<Name_t>(): out.push_back(_parser.toString(name)); break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", name); break;
                 }
         }
 
@@ -4232,7 +4231,7 @@ private:
                                         }
                                         break;
                                 }
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", content); break;
                         }
                 }
                 out.push_back(temp.empty() ? s("\"\""sv) : join(temp, " .. "sv));
@@ -4244,7 +4243,7 @@ private:
                         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;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", str); break;
                 }
         }
 
@@ -4396,7 +4395,7 @@ private:
                                         case id<Statement_t>():
                                                 transformStatement(static_cast<Statement_t*>(content), statements);
                                                 break;
-                                        default: assert(false); break;
+                                        default:YUEE("AST node mismatch", content); break;
                                 }
                         }
                         for (auto& member : members) {
@@ -4602,7 +4601,7 @@ private:
                                 case id<normal_pair_t>():
                                         transform_normal_pair(static_cast<normal_pair_t*>(keyValue), temp);
                                         break;
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", keyValue); break;
                         }
                         if (type == MemType::Property) {
                                 incIndentOffset();
@@ -4621,7 +4620,7 @@ private:
                         case id<AssignableChain_t>(): transformAssignableChain(static_cast<AssignableChain_t*>(item), out); break;
                         case id<Variable_t>(): transformVariable(static_cast<Variable_t*>(item), out); break;
                         case id<SelfName_t>(): transformSelfName(static_cast<SelfName_t*>(item), out); break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", item); break;
                 }
         }
 
@@ -4646,14 +4645,8 @@ private:
                         checkAssignable(with->valueList);
                         auto vars = getAssignVars(with);
                         if (vars.front().empty()) {
-                                if (with->assigns->values.objects().size() == 1) {
-                                        auto var = singleVariableFrom(with->assigns->values.objects().front());
-                                        if (!var.empty()) {
-                                                withVar = var;
-                                        }
-                                }
-                                if (withVar.empty()) {
-                                        withVar = getUnusedName("_with_"sv);
+                                withVar = getUnusedName("_with_"sv);
+                                {
                                         auto assignment = x->new_ptr<ExpListAssign_t>();
                                         assignment->expList.set(toAst<ExpList_t>(withVar, x));
                                         auto assign = x->new_ptr<Assign_t>();
@@ -4693,21 +4686,18 @@ private:
                                 transformAssignment(assignment, temp);
                         }
                 } else {
-                        withVar = singleVariableFrom(with->valueList);
-                        if (withVar.empty()) {
-                                withVar = getUnusedName("_with_"sv);
-                                auto assignment = x->new_ptr<ExpListAssign_t>();
-                                assignment->expList.set(toAst<ExpList_t>(withVar, x));
-                                auto assign = x->new_ptr<Assign_t>();
-                                assign->values.dup(with->valueList->exprs);
-                                assignment->action.set(assign);
-                                if (!returnValue) {
-                                        scoped = true;
-                                        temp.push_back(indent() + s("do"sv) + nll(with));
-                                        pushScope();
-                                }
-                                transformAssignment(assignment, temp);
+                        withVar = getUnusedName("_with_"sv);
+                        auto assignment = x->new_ptr<ExpListAssign_t>();
+                        assignment->expList.set(toAst<ExpList_t>(withVar, x));
+                        auto assign = x->new_ptr<Assign_t>();
+                        assign->values.dup(with->valueList->exprs);
+                        assignment->action.set(assign);
+                        if (!returnValue) {
+                                scoped = true;
+                                temp.push_back(indent() + s("do"sv) + nll(with));
+                                pushScope();
                         }
+                        transformAssignment(assignment, temp);
                 }
                 if (!with->eop && !scoped && !returnValue) {
                         pushScope();
@@ -4843,7 +4833,7 @@ private:
                                 }
                                 break;
                         }
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", item); break;
                 }
         }
 
@@ -4942,7 +4932,7 @@ private:
                                 case id<normal_pair_t>(): transform_normal_pair(static_cast<normal_pair_t*>(pair), temp); break;
                                 case id<TableBlockIndent_t>(): transformTableBlockIndent(static_cast<TableBlockIndent_t*>(pair), temp); break;
                                 case id<TableBlock_t>(): transformTableBlock(static_cast<TableBlock_t*>(pair), temp); break;
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", pair); break;
                         }
                         temp.back() = indent() + temp.back() + (pair == pairs.back() ? Empty : s(","sv)) + nll(pair);
                 }
@@ -4986,7 +4976,7 @@ private:
                                         temp.back() = indent() + s("if "sv) + temp.back() + s(" then"sv) + nll(item);
                                         pushScope();
                                         break;
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", item); break;
                         }
                 }
                 transformExp(comp->key, kv, ExpUsage::Closure);
@@ -5158,7 +5148,7 @@ private:
                                         expList->exprs.push_back(exp);
                                         break;
                                 }
-                                default: assert(false); break;
+                                default: YUEE("AST node mismatch", name); break;
                         }
                 }
                 if (objAssign) {
@@ -5196,7 +5186,7 @@ private:
                 }
                 if (auto tabLit = import->target.as<ImportTabLit_t>()) {
                         auto newTab = x->new_ptr<ImportTabLit_t>();
-#ifndef MOONP_NO_MACRO
+#ifndef YUE_NO_MACRO
                         bool importAllMacro = false;
                         std::list<std::pair<std::string,std::string>> macroPairs;
                         for (auto item : tabLit->items.objects()) {
@@ -5220,7 +5210,7 @@ private:
                                         case id<normal_pair_t>():
                                                 newTab->items.push_back(item);
                                                 break;
-                                        default: assert(false); break;
+                                        default: YUEE("AST node mismatch", item); break;
                                 }
                         }
                         if (importAllMacro || !macroPairs.empty()) {
@@ -5231,7 +5221,7 @@ private:
                                 pushCurrentModule(); // cur
                                 int top = lua_gettop(L) - 1; // Lua state may be setup by pushCurrentModule()
                                 DEFER(lua_settop(L, top));
-                                pushMoonp("find_modulepath"sv); // cur find_modulepath
+                                pushYue("find_modulepath"sv); // cur find_modulepath
                                 lua_pushlstring(L, moduleName.c_str(), moduleName.size()); // cur find_modulepath moduleName
                                 if (lua_pcall(L, 1, 1, 0) != 0) {
                                         std::string err = lua_tostring(L, -1);
@@ -5243,7 +5233,7 @@ private:
                                 std::string moduleFullName = lua_tostring(L, -1);
                                 lua_pop(L, 1); // cur
                                 if (!isModuleLoaded(moduleFullName)) {
-                                        pushMoonp("read_file"sv); // cur read_file
+                                        pushYue("read_file"sv); // cur read_file
                                         lua_pushlstring(L, moduleFullName.c_str(), moduleFullName.size()); // cur load_text moduleFullName
                                         if (lua_pcall(L, 1, 1, 0) != 0) {
                                                 std::string err = lua_tostring(L, -1);
@@ -5253,8 +5243,8 @@ private:
                                                 throw std::logic_error(_info.errorMessage("failed to get module text"sv, x));
                                         } // cur text
                                         std::string text = lua_tostring(L, -1);
-                                        auto compiler = MoonCompilerImpl(L, _luaOpen, false, moduleFullName);
-                                        MoonConfig config;
+                                        auto compiler = YueCompilerImpl(L, _luaOpen, false, moduleFullName);
+                                        YueConfig config;
                                         config.lineOffset = 0;
                                         config.lintGlobalVariable = false;
                                         config.reserveLineNumber = false;
@@ -5279,7 +5269,7 @@ private:
                                         lua_setfield(L, -3, pair.second.c_str()); // cur[second] = val, cur mod
                                 }
                         }
-#else // MOONP_NO_MACRO
+#else // YUE_NO_MACRO
                         for (auto item : tabLit->items.objects()) {
                                 switch (item->getId()) {
                                         case id<MacroName_t>():
@@ -5292,10 +5282,10 @@ private:
                                         case id<normal_pair_t>():
                                                 newTab->items.push_back(item);
                                                 break;
-                                        default: assert(false); break;
+                                        default: YUEE("AST node mismatch", item); break;
                                 }
                         }
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
                         if (newTab->items.empty()) {
                                 out.push_back(Empty);
                                 return;
@@ -5339,7 +5329,7 @@ private:
                         case id<ImportFrom_t>():
                                 transformImportFrom(static_cast<ImportFrom_t*>(content), out);
                                 break;
-                        default: assert(false); break;
+                        default: YUEE("AST node mismatch", content); break;
                 }
         }
 
@@ -5598,25 +5588,25 @@ private:
         }
 };
 
-const std::string MoonCompilerImpl::Empty;
+const std::string YueCompilerImpl::Empty;
 
-MoonCompiler::MoonCompiler(void* sharedState,
+YueCompiler::YueCompiler(void* sharedState,
         const std::function<void(void*)>& luaOpen,
         bool sameModule):
-#ifndef MOONP_NO_MACRO
-_compiler(std::make_unique<MoonCompilerImpl>(static_cast<lua_State*>(sharedState), luaOpen, sameModule)) {}
+#ifndef YUE_NO_MACRO
+_compiler(std::make_unique<YueCompilerImpl>(static_cast<lua_State*>(sharedState), luaOpen, sameModule)) {}
 #else
-_compiler(std::make_unique<MoonCompilerImpl>()) {
+_compiler(std::make_unique<YueCompilerImpl>()) {
         (void)sharedState;
         (void)luaOpen;
         (void)sameModule;
 }
-#endif // MOONP_NO_MACRO
+#endif // YUE_NO_MACRO
 
-MoonCompiler::~MoonCompiler() {}
+YueCompiler::~YueCompiler() {}
 
-CompileInfo MoonCompiler::compile(std::string_view codes, const MoonConfig& config) {
+CompileInfo YueCompiler::compile(std::string_view codes, const YueConfig& config) {
         return _compiler->compile(codes, config);
 }
 
-} // namespace MoonP
+} // namespace yue
diff --git a/src/MoonP/moon_compiler.h b/src/yuescript/yue_compiler.h
index 5855b2d..2e8c86a 100644
--- a/src/MoonP/moon_compiler.h
+++ b/src/yuescript/yue_compiler.h
@@ -16,14 +16,14 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <unordered_map>
 #include <functional>
 
-namespace MoonP {
+namespace yue {
 
 extern const std::string_view version;
 extern const std::string_view extension;
 
 using Options = std::unordered_map<std::string,std::string>;
 
-struct MoonConfig {
+struct YueConfig {
         bool lintGlobalVariable = false;
         bool implicitReturnRoot = true;
         bool reserveLineNumber = true;
@@ -47,17 +47,17 @@ struct CompileInfo {
         std::unique_ptr<Options> options;
 };
 
-class MoonCompilerImpl;
+class YueCompilerImpl;
 
-class MoonCompiler {
+class YueCompiler {
 public:
-        MoonCompiler(void* luaState = nullptr,
+        YueCompiler(void* luaState = nullptr,
                 const std::function<void(void*)>& luaOpen = nullptr,
                 bool sameModule = false);
-        virtual ~MoonCompiler();
-        CompileInfo compile(std::string_view codes, const MoonConfig& config = {});
+        virtual ~YueCompiler();
+        CompileInfo compile(std::string_view codes, const YueConfig& config = {});
 private:
-        std::unique_ptr<MoonCompilerImpl> _compiler;
+        std::unique_ptr<YueCompilerImpl> _compiler;
 };
 
-} // namespace MoonP
+} // namespace yue
diff --git a/src/MoonP/moon_parser.cpp b/src/yuescript/yue_parser.cpp
index a581e15..cf3da01 100644
--- a/src/MoonP/moon_parser.cpp
+++ b/src/yuescript/yue_parser.cpp
@@ -6,11 +6,11 @@ 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 "MoonP/moon_parser.h"
+#include "yuescript/yue_parser.h"
 
 namespace pl = parserlib;
 
-namespace MoonP {
+namespace yue {
 using namespace std::string_view_literals;
 
 std::unordered_set<std::string> LuaKeywords = {
@@ -29,10 +29,10 @@ std::unordered_set<std::string> Keywords = {
         "until", "while", // Lua keywords
         "as", "class", "continue", "export", "extends",
         "from", "global", "import", "macro", "switch",
-        "unless", "using", "when", "with" // Moon keywords
+        "unless", "using", "when", "with" // Yue keywords
 };
 
-MoonParser::MoonParser() {
+YueParser::YueParser() {
         plain_space = *set(" \t");
         Break = nl(-expr('\r') >> '\n');
         Any = Break | any();
@@ -245,7 +245,7 @@ MoonParser::MoonParser() {
         IfElse = -(Break >> *EmptyLine >> CheckIndent) >> key("else") >> plain_body;
         If = key("if") >> Seperator >> IfCond >> plain_body_with("then") >> *IfElseIf >> -IfElse;
         Unless = key("unless") >> Seperator >> IfCond >> plain_body_with("then") >> *IfElseIf >> -IfElse;
-        
+
         While = key("while") >> disable_do_chain(Exp) >> plain_body_with("do");
         Repeat = key("repeat") >> Body >> Break >> *EmptyLine >> CheckIndent >> key("until") >> Exp;
 
@@ -611,7 +611,7 @@ MoonParser::MoonParser() {
         File = White >> -Shebang >> Block >> eof();
 }
 
-ParseInfo MoonParser::parse(std::string_view codes, rule& r) {
+ParseInfo YueParser::parse(std::string_view codes, rule& r) {
         ParseInfo res;
         try {
                 res.codes = std::make_unique<input>();
@@ -650,19 +650,19 @@ ParseInfo MoonParser::parse(std::string_view codes, rule& r) {
         return res;
 }
 
-std::string MoonParser::toString(ast_node* node) {
+std::string YueParser::toString(ast_node* node) {
         return _converter.to_bytes(std::wstring(node->m_begin.m_it, node->m_end.m_it));
 }
 
-std::string MoonParser::toString(input::iterator begin, input::iterator end) {
+std::string YueParser::toString(input::iterator begin, input::iterator end) {
         return _converter.to_bytes(std::wstring(begin, end));
 }
 
-input MoonParser::encode(std::string_view codes) {
+input YueParser::encode(std::string_view codes) {
         return _converter.from_bytes(&codes.front(), &codes.back() + 1);
 }
 
-std::string MoonParser::decode(const input& codes) {
+std::string YueParser::decode(const input& codes) {
         return _converter.to_bytes(codes);
 }
 
@@ -716,4 +716,4 @@ std::string ParseInfo::errorMessage(std::string_view msg, const input_range* loc
         return buf.str();
 }
 
-} // namespace MoonP
+} // namespace yue
diff --git a/src/MoonP/moon_parser.h b/src/yuescript/yue_parser.h
index b165070..f9a0d54 100644
--- a/src/MoonP/moon_parser.h
+++ b/src/yuescript/yue_parser.h
@@ -16,10 +16,10 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <sstream>
 #include <string_view>
 
-#include "MoonP/ast.hpp"
-#include "MoonP/moon_ast.h"
+#include "yuescript/ast.hpp"
+#include "yuescript/yue_ast.h"
 
-namespace MoonP {
+namespace yue {
 using namespace parserlib;
 
 struct ParseInfo {
@@ -42,9 +42,9 @@ struct identity { typedef T type; };
 extern std::unordered_set<std::string> LuaKeywords;
 extern std::unordered_set<std::string> Keywords;
 
-class MoonParser {
+class YueParser {
 public:
-        MoonParser();
+        YueParser();
 
         template<class AST>
         ParseInfo parse(std::string_view codes) {
@@ -314,4 +314,4 @@ namespace Utils {
         void trim(std::string& str);
 };
 
-} // namespace MoonP
+} // namespace yue
diff --git a/src/MoonP/moonplus.cpp b/src/yuescript/yuescript.cpp
index 9b9689c..9928f4d 100644
--- a/src/MoonP/moonplus.cpp
+++ b/src/yuescript/yuescript.cpp
@@ -5,28 +5,28 @@ Permission is hereby granted, free of charge, to any person obtaining a copy of
 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. */
-#include "MoonP/moon_compiler.h"
+#include "yuescript/yue_compiler.h"
 
 extern "C" {
 
 #include "lua.h"
 #include "lauxlib.h"
 
-static const char moonplusCodes[] =
-#include "MoonP/moonplus.h"
+static const char yuescriptCodes[] =
+#include "yuescript/yuescript.h"
 
-static void init_moonplus(lua_State* L) {
-        if (luaL_loadbuffer(L, moonplusCodes, sizeof(moonplusCodes) / sizeof(moonplusCodes[0]) - 1, "=(moonplus)") != 0) {
-                std::string err = std::string("failed to load moonplus module.\n") + lua_tostring(L, -1);
+static void init_yuescript(lua_State* L) {
+        if (luaL_loadbuffer(L, yuescriptCodes, sizeof(yuescriptCodes) / sizeof(yuescriptCodes[0]) - 1, "=(yuescript)") != 0) {
+                std::string err = std::string("failed to load yuescript module.\n") + lua_tostring(L, -1);
                 luaL_error(L, err.c_str());
         } else if (lua_pcall(L, 0, 0, 0) != 0) {
-                std::string err = std::string("failed to init moonplus module.\n") + lua_tostring(L, -1);
+                std::string err = std::string("failed to init yuescript module.\n") + lua_tostring(L, -1);
                 luaL_error(L, err.c_str());
         }
 }
 
 static const char stpCodes[] =
-#include "MoonP/stacktraceplus.h"
+#include "yuescript/stacktraceplus.h"
 
 static int init_stacktraceplus(lua_State* L) {
         if (luaL_loadbuffer(L, stpCodes, sizeof(stpCodes) / sizeof(stpCodes[0]) - 1, "=(stacktraceplus)") != 0) {
@@ -39,10 +39,10 @@ static int init_stacktraceplus(lua_State* L) {
         return 1;
 }
 
-static int moontolua(lua_State* L) {
+static int yuetolua(lua_State* L) {
         size_t size = 0;
         const char* input = luaL_checklstring(L, 1, &size);
-        MoonP::MoonConfig config;
+        yue::YueConfig config;
         bool sameModule = false;
         if (lua_gettop(L) == 2) {
                 luaL_checktype(L, 2, LUA_TTABLE);
@@ -84,7 +84,7 @@ static int moontolua(lua_State* L) {
                 lua_pop(L, 1);
         }
         std::string s(input, size);
-        auto result = MoonP::MoonCompiler(L, nullptr, sameModule).compile(s, config);
+        auto result = yue::YueCompiler(L, nullptr, sameModule).compile(s, config);
         if (result.codes.empty() && !result.error.empty()) {
                 lua_pushnil(L);
         } else {
@@ -115,23 +115,23 @@ static int moontolua(lua_State* L) {
         return 3;
 }
 
-int luaopen_moonp(lua_State* L) {
+int luaopen_yue(lua_State* L) {
         lua_getglobal(L, "package"); // package
         lua_getfield(L, -1, "loaded"); // package loaded
-        lua_createtable(L, 0, 0); // package loaded moonp
-        lua_pushcfunction(L, moontolua); // package loaded moonp func
-        lua_setfield(L, -2, "to_lua"); // moonp["to_lua"] = func, package loaded moonp
-        lua_pushlstring(L, &MoonP::version.front(), MoonP::version.size()); // package loaded moonp version
-        lua_setfield(L, -2, "version"); // moonp["version"] = version, package loaded moonp
-        lua_createtable(L, 0, 0); // package loaded moonp options
-        lua_pushlstring(L, &MoonP::extension.front(), MoonP::extension.size()); // package loaded moonp options ext
-        lua_setfield(L, -2, "extension"); // options["extension"] = ext, package loaded moonp options
-        lua_setfield(L, -2, "options"); // moonp["options"] = options, package loaded moonp
-        lua_pushcfunction(L, init_stacktraceplus); // package loaded moonp func1
-        lua_setfield(L, -2, "load_stacktraceplus"); // moonp["load_stacktraceplus"] = func1, package loaded moonp
-        lua_setfield(L, -2, "moonp"); // loaded["moonp"] = moonp, package loaded
+        lua_createtable(L, 0, 0); // package loaded yue
+        lua_pushcfunction(L, yuetolua); // package loaded yue func
+        lua_setfield(L, -2, "to_lua"); // yue["to_lua"] = func, package loaded yue
+        lua_pushlstring(L, &yue::version.front(), yue::version.size()); // package loaded yue version
+        lua_setfield(L, -2, "version"); // yue["version"] = version, package loaded yue
+        lua_createtable(L, 0, 0); // package loaded yue options
+        lua_pushlstring(L, &yue::extension.front(), yue::extension.size()); // package loaded yue options ext
+        lua_setfield(L, -2, "extension"); // options["extension"] = ext, package loaded yue options
+        lua_setfield(L, -2, "options"); // yue["options"] = options, package loaded yue
+        lua_pushcfunction(L, init_stacktraceplus); // package loaded yue func1
+        lua_setfield(L, -2, "load_stacktraceplus"); // yue["load_stacktraceplus"] = func1, package loaded yue
+        lua_setfield(L, -2, "yue"); // loaded["yue"] = yue, package loaded
         lua_pop(L, 2); // empty
-        init_moonplus(L);
+        init_yuescript(L);
         return 0;
 }
 
diff --git a/src/MoonP/moonplus.h b/src/yuescript/yuescript.h
index ff82e9f..433751e 100644
--- a/src/MoonP/moonplus.h
+++ b/src/yuescript/yuescript.h
@@ -1,6 +1,6 @@
-R"moonplus_codes(
+R"yuescript_codes(
 --[[
-Copyright (C) 2020 by Leaf Corcoran, modified by Li Jin
+Copyright (C) 2020 by Leaf Corcoran, modified by Li Jin, 2021
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -20,17 +20,17 @@ 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.]]
 
-local moonp = require("moonp")
+local yue = require("yue")
 local concat, insert, remove = table.concat, table.insert, table.remove
 local unpack = unpack or table.unpack
 local lua = {
         loadstring = loadstring,
         load = load
 }
-local split, get_options, create_moonpath, moon_loader, load_text, moon_call, loadstring, loadfile, dofile, insert_loader, remove_loader, moon_require, find_modulepath
-moonp.dirsep = "/"
-moonp.moon_compiled = { }
-moonp.file_exist = function(fname)
+local split, get_options, create_yuepath, yue_loader, load_text, yue_call, loadstring, loadfile, dofile, insert_loader, remove_loader, yue_require, find_modulepath
+yue.dirsep = "/"
+yue.yue_compiled = { }
+yue.file_exist = function(fname)
         local file = io.open(fname)
         if file then
                 file:close()
@@ -39,7 +39,7 @@ moonp.file_exist = function(fname)
                 return false
         end
 end
-moonp.read_file = function(fname)
+yue.read_file = function(fname)
         local file, err = io.open(fname)
         if not file then
                 return nil, err
@@ -72,9 +72,9 @@ get_options = function(...)
                 return { }, ...
         end
 end
-create_moonpath = function(package_path)
-        local extension = moonp.options.extension
-        local moonpaths
+create_yuepath = function(package_path)
+        local extension = yue.options.extension
+        local yuepaths
         do
                 local _accum_0 = { }
                 local _len_0 = 1
@@ -96,19 +96,19 @@ create_moonpath = function(package_path)
                                 break
                         end
                 end
-                moonpaths = _accum_0
+                yuepaths = _accum_0
         end
-        return concat(moonpaths, ";")
+        return concat(yuepaths, ";")
 end
 find_modulepath = function(name)
-        if not package.moonpath then
-                package.moonpath = create_moonpath(package.path)
+        if not package.yuepath then
+                package.yuepath = create_yuepath(package.path)
         end
-        local name_path = name:gsub("%.", moonp.dirsep)
+        local name_path = name:match("[\\/]") and name or name:gsub("%.", yue.dirsep)
         local file_exist, file_path
-        for path in package.moonpath:gmatch("[^;]+") do
+        for path in package.yuepath:gmatch("[^;]+") do
                 file_path = path:gsub("?", name_path)
-                file_exist = moonp.file_exist(file_path)
+                file_exist = yue.file_exist(file_path)
                 if file_exist then
                         break
                 end
@@ -122,11 +122,11 @@ end
 load_text = function(name)
         local file_path = find_modulepath(name)
         if file_path then
-                return moonp.read_file(file_path), file_path
+                return yue.read_file(file_path), file_path
         end
         return nil, nil
 end
-moon_loader = function(name)
+yue_loader = function(name)
         local text, file_path = load_text(name)
         if text then
                 local res, err = loadstring(text, file_path)
@@ -135,27 +135,27 @@ moon_loader = function(name)
                 end
                 return res
         end
-        return nil, "Could not find moonp file"
+        return nil, "Could not find yue file"
 end
-moon_call = function(f, ...)
+yue_call = function(f, ...)
         local args = {
                 ...
         }
         return xpcall((function()
                 return f(unpack(args))
         end), function(err)
-                return moonp.stp.stacktrace(err, 1)
+                return yue.stp.stacktrace(err, 1)
         end)
 end
 loadstring = function(...)
         local options, str, chunk_name, mode, env = get_options(...)
-        chunk_name = chunk_name or "=(moonplus.loadstring)"
-        local code, err = moonp.to_lua(str, options)
+        chunk_name = chunk_name or "=(yuescript.loadstring)"
+        local code, err = yue.to_lua(str, options)
         if not code then
                 return nil, err
         end
         if chunk_name then
-                moonp.moon_compiled["@" .. chunk_name] = code
+                yue.yue_compiled["@" .. chunk_name] = code
         end
         return (lua.loadstring or lua.load)(code, chunk_name, unpack({
                 mode,
@@ -163,7 +163,7 @@ loadstring = function(...)
         }))
 end
 loadfile = function(fname, ...)
-        local text = moonp.read_file(fname)
+        local text = yue.read_file(fname)
         return loadstring(text, tostring(fname), ...)
 end
 dofile = function(...)
@@ -174,35 +174,35 @@ insert_loader = function(pos)
         if pos == nil then
                 pos = 2
         end
-        if not package.moonpath then
-                package.moonpath = create_moonpath(package.path)
+        if not package.yuepath then
+                package.yuepath = create_yuepath(package.path)
         end
         local loaders = package.loaders or package.searchers
         for _index_0 = 1, #loaders do
                 local loader = loaders[_index_0]
-                if loader == moon_loader then
+                if loader == yue_loader then
                         return false
                 end
         end
-        insert(loaders, pos, moon_loader)
+        insert(loaders, pos, yue_loader)
         return true
 end
 remove_loader = function()
         local loaders = package.loaders or package.searchers
         for i, loader in ipairs(loaders) do
-                if loader == moon_loader then
+                if loader == yue_loader then
                         remove(loaders, i)
                         return true
                 end
         end
         return false
 end
-moon_require = function(name)
+yue_require = function(name)
         insert_loader()
         local success, res = xpcall((function()
                 return require(name)
         end), function(err)
-                local msg = moonp.stp.stacktrace(err, 1)
+                local msg = yue.stp.stacktrace(err, 1)
                 print(msg)
                 return msg
         end)
@@ -212,21 +212,21 @@ moon_require = function(name)
                 return nil
         end
 end
-setmetatable(moonp, {
+setmetatable(yue, {
         __index = function(self, key)
                 if not (key == "stp") then
                         return nil
                 end
-                local stp = rawget(moonp, "stp")
+                local stp = rawget(yue, "stp")
                 if not stp then
                         do
-                                local _with_0 = moonp.load_stacktraceplus()
+                                local _with_0 = yue.load_stacktraceplus()
                                 _with_0.dump_locals = false
                                 _with_0.simplified = true
                                 stp = _with_0
                         end
-                        rawset(moonp, "stp", stp)
-                        rawset(moonp, "load_stacktraceplus", nil)
+                        rawset(yue, "stp", stp)
+                        rawset(yue, "load_stacktraceplus", nil)
                 end
                 return stp
         end,
@@ -237,15 +237,15 @@ setmetatable(moonp, {
 for k, v in pairs({
         insert_loader = insert_loader,
         remove_loader = remove_loader,
-        loader = moon_loader,
+        loader = yue_loader,
         dofile = dofile,
         loadfile = loadfile,
         loadstring = loadstring,
-        create_moonpath = create_moonpath,
+        create_yuepath = create_yuepath,
         find_modulepath = find_modulepath,
-        pcall = moon_call,
-        require = moon_require
+        pcall = yue_call,
+        require = yue_require
 }) do
-        moonp[k] = v
+        yue[k] = v
 end
-)moonplus_codes";
+)yuescript_codes";