@mbler/mcx-core 0.0.2-alpha

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RuanhoR
+
+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.

package/README.md

@@ -0,0 +1,2 @@
+# mcx
+

package/dist/index.cjs.js

@@ -0,0 +1,1039 @@
+'use strict';
+
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var t = require('@babel/types');
+var Parser = require('@babel/parser');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var t__namespace = /*#__PURE__*/_interopNamespaceDefault(t);
+var Parser__namespace = /*#__PURE__*/_interopNamespaceDefault(Parser);
+
+let Lexer$1 = class Lexer {
+    text;
+    booleanProxyCache;
+    constructor(text) {
+        this.text = text;
+        this.booleanProxyCache = new WeakMap();
+    }
+    get tokens() {
+        return {
+            [Symbol.iterator]: () => this.tokenIterator()
+        };
+    }
+    /**
+     * 解析标签属性，如：<div id="app" disabled />
+     */
+    parseAttributes(tagContent) {
+        const attributes = {};
+        let currentKey = '';
+        let currentValue = '';
+        let inKey = true;
+        let name = '';
+        let inValue = false;
+        let quoteChar = null;
+        let isTagName = true;
+        for (let i = 0; i < tagContent.length; i++) {
+            const char = tagContent[i];
+            if (isTagName) {
+                if (char === ' ' || char === '>') {
+                    name = currentKey.trim();
+                    currentKey = '';
+                    isTagName = false;
+                    if (char === '>')
+                        break;
+                }
+                else {
+                    currentKey += char;
+                }
+                continue;
+            }
+            if (inValue) {
+                if (char === quoteChar &&
+                    (currentValue.length === 0 || currentValue[currentValue.length - 1] !== '\\')) {
+                    attributes[currentKey.trim()] = currentValue;
+                    currentKey = '';
+                    currentValue = '';
+                    inKey = true;
+                    inValue = false;
+                    quoteChar = null;
+                }
+                else {
+                    currentValue += char;
+                }
+            }
+            else if (char === '=' && inKey) {
+                inKey = false;
+                inValue = true;
+                const nextIndex = i + 1;
+                const nextChar = nextIndex < tagContent.length ? tagContent[nextIndex] : ' ';
+                quoteChar = (nextChar === '"' || nextChar === "'") ? nextChar : null;
+            }
+            else if (char === ' ' && inKey && currentKey) {
+                attributes[currentKey.trim()] = 'true';
+                currentKey = '';
+            }
+            else if (inKey) {
+                currentKey += char;
+            }
+        }
+        if (isTagName) {
+            name = currentKey.trim();
+        }
+        else if (currentKey) {
+            attributes[currentKey.trim()] = inValue ?
+                currentValue.replace(/^["']/, '').replace(/["']$/, '') :
+                'true';
+        }
+        return {
+            name,
+            arr: attributes,
+        };
+    }
+    /**
+     * 拆分输入文本为 Token 流：Tag、TagEnd、Content
+     * 新增：忽略 HTML 注释 <!-- ... --> 并记录每个 token 的起始位置与行号
+     */
+    *tagSplitIterator() {
+        const text = this.text;
+        let i = 0;
+        let line = 1;
+        const len = text.length;
+        while (i < len) {
+            const ch = text[i];
+            if (ch === '<') {
+                // 检查注释 <!-- ... -->
+                if (text.startsWith('!--', i + 1)) {
+                    const endIdx = text.indexOf('-->', i + 4);
+                    const commentEnd = endIdx === -1 ? len - 1 : endIdx + 2;
+                    // 更新行号
+                    const segment = text.slice(i, commentEnd + 1);
+                    for (const c of segment)
+                        if (c === '\n')
+                            line++;
+                    i = commentEnd + 1;
+                    continue; // 跳过注释
+                }
+                // 普通标签读取到 '>'
+                const tokenStart = i;
+                const tokenStartLine = line;
+                let j = i + 1;
+                let sawGt = false;
+                for (; j < len; j++) {
+                    const c = text[j];
+                    if (c === '>') {
+                        sawGt = true;
+                        break;
+                    }
+                    if (c === '\n')
+                        line++;
+                }
+                const tokenEnd = j;
+                const buffer = text.slice(tokenStart, sawGt ? j + 1 : len);
+                const type = buffer.startsWith('</') ? 'TagEnd' : 'Tag';
+                const tok = {
+                    data: buffer,
+                    type,
+                    startIndex: tokenStart,
+                    endIndex: sawGt ? tokenEnd : len - 1,
+                    startLine: tokenStartLine
+                };
+                yield tok;
+                i = sawGt ? j + 1 : len;
+            }
+            else {
+                // 内容直到下一个 '<'
+                const contentStart = i;
+                const contentStartLine = line;
+                let j = i;
+                for (; j < len; j++) {
+                    const c = text[j];
+                    if (c === '<')
+                        break;
+                    if (c === '\n')
+                        line++;
+                }
+                const data = text.slice(contentStart, j);
+                const n = {
+                    data,
+                    type: 'Content',
+                    startIndex: contentStart,
+                    endIndex: j - 1,
+                    startLine: contentStartLine
+                };
+                yield n;
+                i = j;
+            }
+        }
+    }
+    /**
+     * 生成 Token 迭代器，用于遍历所有结构化 Token
+     * 改为基于 stack 的解析以支持嵌套，并为 ParsedTagNode 添加 loc: { start:{line,index}, end:{line,index} }
+     * Content 改为递归节点数组 (ParsedTagContentNode | ParsedTagNode)[]
+     */
+    *tokenIterator() {
+        const rawTokens = Array.from(this.tagSplitIterator());
+        const stack = [];
+        for (let idx = 0; idx < rawTokens.length; idx++) {
+            const token = rawTokens[idx];
+            if (!token)
+                continue;
+            if (token.type === 'Content') {
+                const contentNode = {
+                    data: token.data,
+                    type: 'TagContent'
+                };
+                if (stack.length > 0) {
+                    const top = stack[stack.length - 1];
+                    top.content.push(contentNode);
+                }
+            }
+            else if (token.type === 'Tag') {
+                const inner = token.data.slice(1, -1).trim();
+                // 自闭合 <br/> 或 <img ... /> 也当作单节点（没有 end），这里简单检测末尾 '/'
+                const isSelfClosing = inner.endsWith('/');
+                const arr = this.parseAttributes(isSelfClosing ? inner.slice(0, -1).trim() : inner);
+                const node = {
+                    start: token,
+                    name: arr.name,
+                    arr: arr.arr,
+                    // content 现在是一个数组，包含文本节点或子标签
+                    content: [],
+                    end: null,
+                    // loc: start/end positions will be set when available
+                    loc: {
+                        start: { line: token.startLine || 1, index: token.startIndex || 0 },
+                        end: { line: token.startLine || 1, index: token.endIndex || (token.startIndex || 0) }
+                    }
+                };
+                if (isSelfClosing) {
+                    // self-closing: immediately close and attach to parent or root
+                    if (stack.length > 0) {
+                        stack[stack.length - 1].content.push(node);
+                    }
+                    else {
+                        // yield top-level node
+                        yield node;
+                    }
+                }
+                else {
+                    stack.push(node);
+                }
+            }
+            else if (token.type === 'TagEnd') {
+                // 从 '</name>' 中提取 name
+                const name = token.data.replace(/^<\/\s*/, '').replace(/\s*>$/, '').trim();
+                // 找到最近的匹配开始标签
+                for (let s = stack.length - 1; s >= 0; s--) {
+                    const candidate = stack[s];
+                    if (candidate && candidate.name === name) {
+                        // 设置结束
+                        candidate.end = token;
+                        candidate.loc.end = { line: token.startLine || candidate.loc.start.line, index: token.endIndex || (token.loc.start.index) };
+                        // 从 stack 中移除并附加到父节点或作为顶层节点产出
+                        stack.splice(s, 1);
+                        if (stack.length > 0) {
+                            stack[stack.length - 1].content.push(candidate);
+                        }
+                        else {
+                            // yield completed top-level node
+                            yield candidate;
+                        }
+                        break;
+                    }
+                }
+                // 如果没有匹配的开始标签，则忽略（或可扩展为错误处理）
+            }
+        }
+        // 如果有未闭合的标签，则把它们作为顶层节点输出（保留当前内容）
+        while (stack.length > 0) {
+            const node = stack.shift();
+            if (stack.length > 0) {
+                stack[0].content.push(node);
+            }
+            else {
+                yield node;
+            }
+        }
+    }
+    /**
+     * 创建一个动态布尔属性访问的 Proxy（可选功能）
+     */
+    getBooleanCheckProxy() {
+        if (!this.booleanProxyCache.has(this)) {
+            const charMap = new Map();
+            const proxy = new Proxy({}, {
+                get(_, prop) {
+                    if (typeof prop !== 'string')
+                        return false;
+                    return charMap.get(prop) || false;
+                },
+                set(_, prop, value) {
+                    if (typeof prop !== 'string')
+                        return false;
+                    charMap.set(prop, Boolean(value));
+                    return true;
+                },
+            });
+            this.booleanProxyCache.set(this, proxy);
+        }
+        return this.booleanProxyCache.get(this);
+    }
+};
+class McxAst {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    getAST() {
+        const lexer = new Lexer$1(this.text);
+        // 现在 tokenIterator 直接产生顶层 ParsedTagNode（并且注释已被忽略）
+        return Array.from(lexer.tokens);
+    }
+    get data() {
+        return this.getAST();
+    }
+    parseAST() {
+        return this.getAST();
+    }
+    /**
+     * 生成代码字符串（递归处理 content 数组）
+     * @param node 要生成代码的AST节点
+     * @returns 生成的代码字符串
+     */
+    static generateCode(node) {
+        let code = `<${node.name}`;
+        // 添加属性
+        for (const [key, value] of Object.entries(node.arr || {})) {
+            if (value === 'true') {
+                code += ` ${key}`;
+            }
+            else {
+                code += ` ${key}=${String(value)}`;
+            }
+        }
+        code += '>';
+        // 添加内容（content 现在为数组）
+        const contentArr = node.content;
+        if (Array.isArray(contentArr)) {
+            for (const item of contentArr) {
+                if (item.type === 'TagContent') {
+                    code += item.data;
+                }
+                else {
+                    code += McxAst.generateCode(item);
+                }
+            }
+        }
+        // 添加结束标签
+        code += `</${node.name}>`;
+        return code;
+    }
+}
+
+const STATUS = [0, 1]; // 0: 搜集 key，1: 搜集 value
+class Lexer {
+    code;
+    constructor(code) {
+        this.code = code;
+    }
+    // 对外暴露的 tokenize 方法（生成器函数）
+    *tokenize() {
+        let currStatus = STATUS[0]; // 0: key，1: value
+        let key = "";
+        let value = "";
+        for (const char of this.code) {
+            if (/\s/.test(char)) {
+                if (char === '\n') {
+                    if (currStatus === STATUS[1] && key && value) {
+                        const propNode = {
+                            key,
+                            value: this.HandlerValue(value),
+                            type: "PropChar"
+                        };
+                        yield propNode;
+                    }
+                    key = "";
+                    value = "";
+                    currStatus = STATUS[0];
+                }
+                continue; // 跳过所有空白字符
+            }
+            if (char === '=') {
+                if (currStatus === STATUS[0]) {
+                    currStatus = STATUS[1]; // 切换到 value 状态
+                }
+            }
+            else {
+                if (currStatus === STATUS[0]) {
+                    key += char; // 搜集 key
+                }
+                else if (currStatus === STATUS[1]) {
+                    value += char; // 搜集 value
+                }
+            }
+        }
+        if (key && value) {
+            const propNode = {
+                key,
+                value: this.HandlerValue(value),
+                type: "PropChar"
+            };
+            yield propNode;
+        }
+    }
+    HandlerValue(value) {
+        try {
+            const num = Number(value);
+            if (!Number.isNaN(num))
+                return num;
+            if (["[", "{"].includes(value.slice(0, 1)) && ["]", "}"].includes(value.slice(-1))) {
+                return JSON.parse(value);
+            }
+        }
+        catch { }
+        return value;
+    }
+}
+// 默认导出解析函数
+function PropParser(code) {
+    const lexer = new Lexer(code);
+    return Array.from(lexer.tokenize());
+}
+
+var AST = {
+    tag: McxAst,
+    prop: PropParser
+};
+
+class McxUtlis {
+    /**
+     * 检查文件是否存在
+     * @param path 文件路径
+     * @returns 是否存在
+     */
+    static async FileExsit(path) {
+        try {
+            await fs__namespace.access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 读取文件内容，支持返回 string 或 object，带重试机制
+     * @param filePath 文件路径
+     * @param opt 配置选项
+     * @returns 文件内容（string | object），出错时返回 {}
+     */
+    static async readFile(filePath, opt = {}) {
+        // 补全必填字段，确保类型安全
+        const opts = {
+            delay: 200, // 默认延迟
+            maxRetries: 3, // 默认最大重试次数
+            want: 'string', // 默认返回字符串
+            ...opt, // 用户传入的配置覆盖默认值
+        };
+        for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
+            try {
+                const buffer = await fs__namespace.readFile(filePath);
+                let text;
+                if (opts.want === 'string') {
+                    text = buffer.toString(); // Buffer -> string
+                }
+                else if (opts.want === 'object') {
+                    try {
+                        text = JSON.parse(buffer.toString()); // Buffer -> string -> object
+                    }
+                    catch (parseErr) {
+                        // JSON 解析失败时返回空对象
+                        text = {};
+                    }
+                }
+                else {
+                    // 默认情况也返回字符串
+                    text = buffer.toString();
+                }
+                return text;
+            }
+            catch (err) {
+                // 如果不是最后一次尝试，则等待后重试
+                if (attempt < opts.maxRetries - 1) {
+                    await McxUtlis.sleep(opts.delay);
+                }
+            }
+        }
+        return opts.want === 'object' ? {} : '';
+    }
+    static sleep(time) {
+        return new Promise((resolve) => setTimeout(resolve, time));
+    }
+    // 在运行时进行对象类型验证
+    static TypeVerify(obj, types) {
+        for (const item of Object.entries(types)) {
+            const [key, ShouldType] = item;
+            if (!(typeof obj[key] === ShouldType))
+                return false;
+        }
+        return true;
+    }
+    static AbsoluteJoin(baseDir, inputPath) {
+        return path__namespace.isAbsolute(inputPath) ?
+            inputPath :
+            path__namespace.join(baseDir, inputPath);
+    }
+}
+
+class JsCompileData {
+    node;
+    BuildCache;
+    File = "__repl";
+    isFile = false;
+    constructor(node, BuildCache = {
+        export: [],
+        import: [],
+        call: []
+    }) {
+        this.node = node;
+        this.BuildCache = BuildCache;
+    }
+    setFilePath(dir) {
+        this.isFile = true;
+        this.File = dir;
+    }
+}
+
+class Utils {
+    static async FileAST(fileDir, parserOpt) {
+        if (typeof fileDir !== "string")
+            throw new TypeError("[read file]: compile utils was passed a non-string value");
+        const file = await fs.readFile(fileDir, "utf-8");
+        if (typeof file !== "string")
+            throw new Error("[read file]: not found file " + fileDir);
+        try {
+            return Parser__namespace.parse(file).program;
+        }
+        catch (err) {
+            throw new Error("[compile ast]: " + err.stack);
+        }
+    }
+    static async FileContent(fileDir) {
+        const file = await fs.readFile(fileDir, "utf-8");
+        return file;
+    }
+    static nodeStringValue(node) {
+        if (node.type == "StringLiteral") {
+            return node.value;
+        }
+        else if (node.type == "Identifier") {
+            return node.name;
+        }
+        throw new TypeError("[read id error]: no way to read string id");
+    }
+    static CheckImportNode(node, ir) {
+        const newList = Utils.ImportToCache(node);
+        // Eliminate common differences
+        if (newList.source !== ir.source)
+            return false;
+        if (newList.imported.length !== ir.imported.length)
+            return false;
+        // in this for, newList.imported and ir.imported is same length
+        for (let irIndex = 0; irIndex < newList.imported.length; irIndex++) {
+            const newItem = newList.imported[irIndex];
+            const oldItem = ir.imported[irIndex];
+            if (newItem?.import !== oldItem?.import || newItem?.as !== oldItem?.as || newItem?.isAll !== oldItem?.isAll)
+                return false;
+        }
+        return true;
+    }
+    static CacheToImportNode(ir) {
+        if (!ir)
+            throw new TypeError("plase call use right ImportList");
+        // first verify ir.raw
+        if (ir?.raw && Utils.CheckImportNode(ir?.raw, ir))
+            return ir.raw;
+        let result = [];
+        for (let ImportIt of ir.imported) {
+            if (!ImportIt)
+                continue;
+            if (ImportIt.isAll) {
+                result.push(t__namespace.importNamespaceSpecifier(t__namespace.identifier(ImportIt.as)));
+                continue;
+            }
+            if (ImportIt.import == "default") {
+                result.push(t__namespace.importDefaultSpecifier(t__namespace.identifier(ImportIt.as)));
+                continue;
+            }
+            if (!ImportIt.import)
+                throw new TypeError("[compile node]: not found imported");
+            result.push(t__namespace.importSpecifier(t__namespace.identifier(ImportIt.as), t__namespace.identifier(ImportIt.import)));
+        }
+        return t__namespace.importDeclaration(result, t__namespace.stringLiteral(ir.source));
+    }
+    static ImportToCache(node) {
+        const result = [];
+        for (let item of node.specifiers) {
+            const thisName = item.local.name;
+            if (item.type == "ImportNamespaceSpecifier") {
+                result.push({
+                    isAll: true,
+                    as: thisName
+                });
+            }
+            else if (item.type == "ImportDefaultSpecifier") {
+                result.push({
+                    isAll: false,
+                    import: "default",
+                    as: thisName
+                });
+            }
+            else if (item.type == "ImportSpecifier") {
+                result.push({
+                    isAll: false,
+                    as: thisName,
+                    import: Utils.nodeStringValue(item.imported)
+                });
+            }
+        }
+        return {
+            source: Utils.nodeStringValue(node.source),
+            imported: result
+        };
+    }
+}
+
+class CompileJS {
+    node;
+    constructor(node) {
+        this.node = node;
+        if (!t__namespace.isProgram(node))
+            throw new Error("[compile error]: jsCompile can't work in a not program");
+        this.CompileData = new JsCompileData(node);
+        this.run();
+        this.writeBuildCache();
+    }
+    TopContext = {};
+    indexTemp = {};
+    push(source) {
+        for (const node of source.imported) {
+            this.indexTemp[node.as] = {
+                source: source.source,
+                import: node.import,
+                isAll: node.isAll,
+            };
+        }
+    }
+    takeInnerMost(node) {
+        if (!t__namespace.isMemberExpression(node))
+            throw new Error("[take item}: must MemberExpression");
+        let current = node;
+        while (true) {
+            if (t__namespace.isMemberExpression(current)) {
+                current = current.object;
+                continue;
+            }
+            if (t__namespace.isCallExpression(current)) {
+                const callee = current.callee;
+                if (t__namespace.isMemberExpression(callee)) {
+                    current = callee.object;
+                    continue;
+                }
+                current = callee;
+                continue;
+            }
+            if (t__namespace.isIdentifier(current) ||
+                t__namespace.isThisExpression(current) ||
+                t__namespace.isSuper(current) ||
+                t__namespace.isImport(current) ||
+                t__namespace.isNewExpression(current) ||
+                (typeof t__namespace.isLiteral === "function" && t__namespace.isLiteral(current))) {
+                return current;
+            }
+            if (t__namespace.isLiteral(current)) {
+                return current;
+            }
+            return t__namespace.stringLiteral("");
+        }
+    }
+    writeImportKeys = [];
+    extractIdentifierNames(node) {
+        const identifiers = [];
+        if (t__namespace.isIdentifier(node)) {
+            identifiers.push(node.name);
+        }
+        else if (t__namespace.isMemberExpression(node)) {
+            identifiers.push(...this.extractIdentifierNames(node.object));
+            if (node.property.type !== "PrivateName") {
+                identifiers.push(...this.extractIdentifierNames(node.property));
+            }
+        }
+        else if (t__namespace.isCallExpression(node)) {
+            identifiers.push(...this.extractIdentifierNames(node.callee));
+            for (const arg of node.arguments) {
+                if (t__namespace.isExpression(arg)) {
+                    identifiers.push(...this.extractIdentifierNames(arg));
+                }
+            }
+        }
+        else if (t__namespace.isBinaryExpression(node) || t__namespace.isLogicalExpression(node)) {
+            identifiers.push(...this.extractIdentifierNames(node.left));
+            identifiers.push(...this.extractIdentifierNames(node.right));
+        }
+        else if (t__namespace.isUnaryExpression(node)) {
+            identifiers.push(...this.extractIdentifierNames(node.argument));
+        }
+        else if (t__namespace.isConditionalExpression(node)) {
+            identifiers.push(...this.extractIdentifierNames(node.test));
+            identifiers.push(...this.extractIdentifierNames(node.consequent));
+            identifiers.push(...this.extractIdentifierNames(node.alternate));
+        }
+        return identifiers;
+    }
+    writeBuildCache() {
+        const currenySource = [];
+        let build = [];
+        for (const [as, data] of Object.entries(this.indexTemp)) {
+            // only include imports that were actually referenced
+            if (!this.writeImportKeys.includes(as))
+                continue;
+            if (currenySource.includes(data.source)) {
+                let isFound = false;
+                for (const index in build) {
+                    const i = build[index];
+                    if (!i)
+                        continue;
+                    if (i.source == data.source) {
+                        i.imported.push({
+                            as: as,
+                            isAll: data.isAll,
+                            import: data.import,
+                        });
+                        isFound = true;
+                    }
+                }
+                if (!isFound)
+                    throw new Error("[mcx compoiler]: internal error: unexpected source");
+            }
+            else {
+                build.push({
+                    source: data.source,
+                    imported: [
+                        {
+                            as,
+                            import: data.import,
+                            isAll: data.isAll,
+                        },
+                    ],
+                });
+                currenySource.push(data.source);
+            }
+        }
+        // write filtered imports into CompileData.BuildCache
+        this.CompileData.BuildCache.import = build;
+    }
+    CompileData;
+    getCompileData() {
+        return this.CompileData;
+    }
+    conditionalInTempImport(node, thisContext, remove) {
+        // If identifier, mark it
+        if (t__namespace.isIdentifier(node)) {
+            if (node.name in this.indexTemp &&
+                !this.writeImportKeys.includes(node.name)) {
+                this.writeImportKeys.push(node.name);
+            }
+            return;
+        }
+        if (node.type == "FunctionExpression") {
+            this.tre(t__namespace.blockStatement([node.body]));
+            return;
+        }
+        if (node.type == "ArrowFunctionExpression") {
+            if (t__namespace.isExpression(node.body)) {
+                this.conditionalInTempImport(node.body, thisContext, remove);
+            }
+            else {
+                this.tre(node.body);
+            }
+            return;
+        }
+        if (t__namespace.isLiteral(node))
+            return;
+        // If member expression, collect identifiers inside it
+        if (t__namespace.isMemberExpression(node)) {
+            const names = this.extractIdentifierNames(node);
+            for (const n of names) {
+                if (n in this.indexTemp && !this.writeImportKeys.includes(n))
+                    this.writeImportKeys.push(n);
+            }
+            // recurse into object and property when applicable
+            this.conditionalInTempImport(node.object, thisContext, remove);
+            if (t__namespace.isExpression(node.property))
+                this.conditionalInTempImport(node.property, thisContext, remove);
+            return;
+        }
+        // Call expression: record call for buildcache and mark identifiers used in callee and args
+        if (t__namespace.isCallExpression(node) &&
+            node.callee?.type !== "V8IntrinsicIdentifier") {
+            this.CompileData.BuildCache.call.push({
+                source: node.callee,
+                arguments: node.arguments,
+                remove,
+            });
+            this.conditionalInTempImport(node.callee, thisContext, remove);
+            for (const arg of node.arguments) {
+                if (t__namespace.isExpression(arg))
+                    this.conditionalInTempImport(arg, thisContext, remove);
+            }
+            return;
+        }
+        // Generic expressions: try to extract identifier names and mark them
+        try {
+            const names = this.extractIdentifierNames(node);
+            for (const n of names) {
+                if (n in this.indexTemp && !this.writeImportKeys.includes(n))
+                    this.writeImportKeys.push(n);
+            }
+        }
+        catch (_) {
+            // ignore
+        }
+    }
+    tre(node, ExtendContext = {}) {
+        if (!t__namespace.isBlock(node))
+            throw new Error("[compile error]: can't for in not block node");
+        const isTop = t__namespace.isProgram(node);
+        const currenyContext = isTop ? this.TopContext : ExtendContext;
+        for (let index = 0; index < node.body.length; index++) {
+            const item = node.body[index];
+            const remove = () => {
+                node.body.splice(index, 1);
+                index--;
+            };
+            if (!item)
+                continue;
+            if (item.type == "ImportDeclaration") {
+                if (!isTop)
+                    throw new Error("[compile node]: import declaration must use in top.");
+                this.push(Utils.ImportToCache(item));
+                remove();
+            }
+            else if (item.type == "BlockStatement") {
+                this.tre(item, currenyContext);
+            }
+            else if (item.type == "BreakStatement" ||
+                item.type == "EmptyStatement" ||
+                item.type == "ContinueStatement" ||
+                item.type == "ThrowStatement" ||
+                item.type == "WithStatement") {
+                continue;
+            }
+            else if (item.type == "TryStatement") {
+                this.tre(item.block, currenyContext);
+            }
+            else if (item.type == "IfStatement") {
+                const If = item.test;
+                this.conditionalInTempImport(If, currenyContext, remove);
+                const nodes = [item.consequent];
+                if (item.alternate)
+                    nodes.push(item.alternate);
+                // if ... else ... make one by one
+                this.tre(t__namespace.blockStatement(nodes), currenyContext);
+            }
+            else if (item.type == "WhileStatement") {
+                this.tre(t__namespace.blockStatement([item.body]), currenyContext);
+            }
+            else if (item.type == "ClassDeclaration") {
+                if (item.superClass) {
+                    const superClass = item.superClass;
+                    let superId = null;
+                    if (superClass.type == "Identifier") {
+                        superId = superClass.name;
+                    }
+                    if (superClass.type == "MemberExpression") {
+                        // take the innermost item
+                        const tempNode = this.takeInnerMost(superClass);
+                        if (tempNode.type == "Identifier") {
+                            superId = tempNode.name;
+                        }
+                    }
+                    // Prevent values that are not allowed to be extends
+                    if (superClass.type == "ArrayExpression" ||
+                        superClass.type == "BooleanLiteral" ||
+                        superClass.type == "BinaryExpression" ||
+                        superClass.type == "ThisExpression" ||
+                        superClass.type == "ArrowFunctionExpression" ||
+                        superClass.type == "BigIntLiteral" ||
+                        superClass.type == "NumericLiteral" ||
+                        superClass.type == "NullLiteral" ||
+                        superClass.type == "AssignmentExpression" ||
+                        superClass.type == "Super" ||
+                        superClass.type == "NewExpression" ||
+                        superClass.type == "DoExpression" ||
+                        superClass.type == "StringLiteral" ||
+                        superClass.type == "YieldExpression" ||
+                        superClass.type == "RecordExpression" ||
+                        superClass.type == "RegExpLiteral" ||
+                        superClass.type == "DecimalLiteral" ||
+                        superClass.type == "BindExpression")
+                        throw new Error("[compilr error]: class can't extends a not constructor or null");
+                    if (superId) {
+                        if (this.indexTemp[superId]) {
+                            this.writeImportKeys.push(superId);
+                        }
+                    }
+                }
+            }
+            else if (item.type == "DoWhileStatement") {
+                this.tre(t__namespace.blockStatement([item.body]));
+                this.conditionalInTempImport(item.test, currenyContext, remove);
+            }
+            else if (item.type == "VariableDeclaration") {
+                const declaration = item.declarations;
+                for (const varDef of declaration) {
+                    const init = varDef.init;
+                    const id = varDef.id;
+                    if (id.type == "Identifier") {
+                        if (!init && (item.kind == "let" || item.kind == "var"))
+                            currenyContext[id.name] = {
+                                status: "wait",
+                            };
+                        if (!init)
+                            throw new Error("[compilr node]: 'const' must has a init");
+                        currenyContext[id.name] = init;
+                    }
+                }
+            }
+            else if (item.type == "ReturnStatement") {
+                const body = item.argument;
+                if (!body)
+                    continue;
+                this.conditionalInTempImport(body, currenyContext, remove);
+            }
+            else if (item.type == "ExportAllDeclaration" ||
+                item.type == "ExportDefaultDeclaration" ||
+                item.type == "ExportNamedDeclaration") {
+                if (!isTop) {
+                    throw new Error("[compiler]: export node can't in not top");
+                }
+                this.CompileData.BuildCache.export.push(item);
+                remove();
+            }
+            else if (item.type == "SwitchStatement") {
+                const vaule = item.discriminant;
+                this.conditionalInTempImport(vaule, currenyContext, remove);
+                for (const caseItem of item.cases) {
+                    if (caseItem.test) {
+                        this.conditionalInTempImport(caseItem.test, currenyContext, remove);
+                    }
+                    this.tre(t__namespace.blockStatement(caseItem.consequent), currenyContext);
+                }
+            }
+            else if (item.type == "ExpressionStatement") {
+                this.conditionalInTempImport(item.expression, currenyContext, remove);
+            }
+            else if (item.type == "FunctionDeclaration") {
+                const funcBody = item.body;
+                this.tre(funcBody, currenyContext);
+            }
+        }
+    }
+    run() {
+        if (!t__namespace.isBlock(this.node))
+            throw new Error("[compile error]: can't for a not block");
+        this.tre(this.node);
+    }
+}
+function compileJSFn(code) {
+    const comiler = new CompileJS(Parser.parse(code, { sourceType: "module" }).program);
+    comiler.run();
+    return comiler.getCompileData();
+}
+
+class CompileMain {
+    opt;
+    main = "";
+    constructor(opt) {
+        this.opt = opt;
+        if (typeof opt.main == "string")
+            this.main = path.join(opt.ProjectDir, opt.main);
+    }
+    async start() {
+        if (!this.main)
+            throw new Error("[mcx load]: mcx loader must has a main file");
+        const mainCode = await fs.readFile(this.main, "utf-8");
+        const IR = this.compMain(mainCode);
+        if (!IR)
+            throw new Error("[mcx compile]: compile main file error");
+        IR.setFilePath(this.main);
+        for (const importPackage of IR.BuildCache.import) {
+        }
+    }
+    compMain(code) {
+        const ext = path.extname(this.main);
+        if (ext !== ".js") {
+            throw new Error("[load project]: main file must is a javascript.");
+        }
+        const ir = compileJSFn(code);
+        return ir;
+    }
+}
+
+/*import _compile from "./_compile.js"*/
+/**
+ * @description - this is a function factory to generate mcxProject
+ */
+function CompileMcxProject(BuildOpt) {
+    return (new Compile(BuildOpt)).start();
+}
+class Compile {
+    BuildOpt;
+    constructor(BuildOpt) {
+        this.BuildOpt = BuildOpt;
+        // 类型验证
+        if (!McxUtlis.TypeVerify(this.BuildOpt, {
+            cacheDir: "string",
+            main: "string",
+            moduleDir: "string",
+            output: "string",
+            isCache: "boolean"
+        })) {
+            throw new TypeError("[compile checker]Input Opt is not right");
+        }
+    }
+    async start() {
+        const compileMain = new CompileMain(this.BuildOpt);
+        await compileMain.start();
+    }
+}
+
+async function CompileMcxDir(BuildOpt) {
+    await CompileMcxProject(BuildOpt);
+}
+
+var index = {
+    load: CompileMcxDir,
+    AST: AST,
+    utils: McxUtlis,
+};
+
+module.exports = index;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@mbler/mcx-core",
+  "version": "0.0.2-alpha",
+  "description": "a DSL compiler of mcx",
+  "main": "dist/index.cjs.js",
+  "scripts": {
+    "test": "node __test__/index.js",
+    "build": "rollup -c"
+  },
+  "keywords": [
+    "compiler",
+    "minecraft",
+    "dsl"
+  ],
+  "dependencies": {
+    "@babel/generator": "7.28.5",
+    "@babel/parser": "7.28.5",
+    "@babel/types": "7.28.6"
+  },
+  "module": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "__test__"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "author": "ruanhor",
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/babel__generator": "^7.27.0",
+    "@types/node": "^25.2.0",
+    "rollup": "^4.57.1",
+    "tslib": "^2.8.1"
+  }
+}