@plumeria/compiler 2.4.2 → 3.0.0

package/bin/css.js

@@ -1,25 +1,4 @@
 #!/usr/bin/env node
-
 const path = require('path');
-const { styleText } = require('util');
-const { enableCompileCache } = require('node:module');
-
-enableCompileCache();
-
-const { register } = require('rscute/register');
-
-register();
-
-try {
-  const stats = process.argv.includes('--stats');
-  const view = process.argv.includes('--view');
-  const paths = process.argv.includes('--paths');
-
-  require(path.resolve(__dirname, '../dist/index.js'));
-
-  if (!stats && !view && !paths)
-    console.log(styleText(['green', 'bold'], '✓ extract...'));
-} catch (error) {
-  console.error('Compilation failed:', error.message);
-  process.exit(1);
-}
+require('rscute/register').register();
+require(path.resolve(__dirname, '../dist/index.js'));

package/dist/index.js

@@ -3,231 +3,178 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const promises_1 = require("fs/promises");
-const postcss_1 = __importDefault(require("postcss"));
-const postcss_combine_media_query_1 = __importDefault(require("postcss-combine-media-query"));
-const execute_1 = require("rscute/execute");
-const glob_1 = require("@rust-gear/glob");
-const lightningcss_1 = require("lightningcss");
 const core_1 = require("@swc/core");
-const find_up_1 = require("find-up");
-const processors_1 = require("@plumeria/core/processors");
-const extract_1 = require("./extract");
-async function generateStats(buildTime, coreFilePath) {
-    const cssCode = await (0, promises_1.readFile)(coreFilePath, 'utf8');
-    const cssSize = Buffer.byteLength(cssCode, 'utf8');
-    let rules = 0;
-    const topProperties = new Map();
-    (0, lightningcss_1.transform)({
-        filename: coreFilePath,
-        code: Buffer.from(cssCode),
-        visitor: {
-            Rule(rule) {
-                if (rule.type === 'style') {
-                    rules++;
-                    rule.value.declarations.declarations.forEach((decl) => {
-                        if ('property' in decl) {
-                            topProperties.set(decl.property, (topProperties.get(decl.property) || 0) + 1);
-                        }
-                    });
-                }
-            },
-        },
-    });
-    const sortedTopProperties = [...topProperties.entries()].sort((a, b) => b[1] - a[1]);
-    console.log('\n📦 Plumeria CSS Stats');
-    console.log('────────────────────────────');
-    console.log(`Total CSS size:           ${(cssSize / 1024).toFixed(3)} KB`);
-    console.log(`Rules:                    ${rules}`);
-    console.log('Top properties:');
-    for (let i = 0; i < Math.min(5, sortedTopProperties.length); i++) {
-        const [prop, count] = sortedTopProperties[i];
-        console.log(`  - ${prop}: ${count}`);
-    }
-    console.log(`Build time:               ${buildTime.toFixed(2)}s`);
-    console.log('────────────────────────────\n');
-}
-async function main() {
-    let projectRoot;
-    const workspaceRootFile = await (0, find_up_1.findUp)(async (directory) => {
-        const pnpmWsPath = path_1.default.join(directory, 'pnpm-workspace.yaml');
-        try {
-            await (0, promises_1.access)(pnpmWsPath);
-            return pnpmWsPath;
-        }
-        catch {
-        }
-        const pkgJsonPath = path_1.default.join(directory, 'package.json');
-        try {
-            await (0, promises_1.access)(pkgJsonPath);
-            const pkgJson = JSON.parse(await (0, promises_1.readFile)(pkgJsonPath, 'utf-8'));
-            if (pkgJson.workspaces) {
-                return pkgJsonPath;
-            }
-        }
-        catch {
-        }
-        return undefined;
-    });
-    if (workspaceRootFile) {
-        projectRoot = path_1.default.dirname(workspaceRootFile);
-    }
-    else {
-        const singleProjectRootFile = await (0, find_up_1.findUp)('package.json');
-        if (singleProjectRootFile) {
-            projectRoot = path_1.default.dirname(singleProjectRootFile);
-        }
-        else {
-            projectRoot = process.cwd();
-        }
-    }
-    let coreFilePath;
-    const coreSourcePackageJsonPath = path_1.default.join(process.cwd(), 'package.json');
-    const coreSourcePackageJson = JSON.parse(await (0, promises_1.readFile)(coreSourcePackageJsonPath, 'utf-8'));
-    const dependencies = {
-        ...coreSourcePackageJson.dependencies,
-        ...coreSourcePackageJson.devDependencies,
-    };
-    const coreVersion = dependencies['@plumeria/core'];
-    const resolvedCorePackageJsonPath = require.resolve('@plumeria/core/package.json', {
-        paths: [projectRoot, process.cwd()],
-    });
-    if (workspaceRootFile) {
-        if (coreVersion.includes('workspace')) {
-            coreFilePath = path_1.default.join(path_1.default.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
-        }
-        else {
-            const corePackageJson = JSON.parse(await (0, promises_1.readFile)(resolvedCorePackageJsonPath, 'utf-8'));
-            const exactCoreVersion = corePackageJson.version;
-            coreFilePath = path_1.default.join(projectRoot, 'node_modules', '.pnpm', `@plumeria+core@${exactCoreVersion}`, 'node_modules', '@plumeria', 'core', 'stylesheet.css');
-        }
-    }
-    else {
-        coreFilePath = path_1.default.join(path_1.default.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
-    }
-    const cleanUp = async () => {
-        if (process.env.CI) {
-            try {
-                await (0, promises_1.access)(coreFilePath);
-                await (0, promises_1.unlink)(coreFilePath);
-                console.log('File deleted successfully');
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT') {
-                    console.error(`Error deleting ${coreFilePath}:`, error);
-                }
-            }
-        }
+const zss_engine_1 = require("zss-engine");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("@plumeria/utils");
+const optimizer_1 = require("./optimizer");
+async function compile(options) {
+    const { pattern, output, cwd = process.cwd() } = options;
+    let staticTable = null;
+    let keyframesData = null;
+    let viewTransitionData = null;
+    let themeData = null;
+    const allSheets = new Set();
+    const dependencies = new Set();
+    staticTable = (0, utils_1.scanForCreateStatic)((p) => dependencies.add(p));
+    utils_1.tables.staticTable = staticTable;
+    keyframesData = (0, utils_1.scanForKeyframes)((p) => dependencies.add(p));
+    utils_1.tables.keyframesHashTable = keyframesData.keyframesHashTableLocal;
+    utils_1.tables.keyframesObjectTable = keyframesData.keyframesObjectTableLocal;
+    viewTransitionData = (0, utils_1.scanForViewTransition)((p) => dependencies.add(p));
+    utils_1.tables.viewTransitionHashTable =
+        viewTransitionData.viewTransitionHashTableLocal;
+    utils_1.tables.viewTransitionObjectTable =
+        viewTransitionData.viewTransitionObjectTableLocal;
+    themeData = (0, utils_1.scanForCreateTheme)((p) => dependencies.add(p));
+    utils_1.tables.themeTable = themeData.themeTableLocal;
+    utils_1.tables.createThemeObjectTable = themeData.createThemeObjectTableLocal;
+    const processFile = (filePath) => {
+        const source = fs_1.default.readFileSync(filePath, 'utf-8');
+        const extractedSheets = [];
+        let ast;
         try {
-            await (0, promises_1.writeFile)(coreFilePath, '', 'utf-8');
+            ast = (0, core_1.parseSync)(source, {
+                syntax: 'typescript',
+                tsx: true,
+                target: 'es2022',
+            });
         }
         catch (err) {
-            console.error('An error occurred:', err);
-        }
-    };
-    async function isCSS(code, filePath) {
-        if (!code.includes('css.props')) {
-            return false;
-        }
-        const ast = await (0, core_1.parse)(code, {
-            syntax: 'typescript',
-            tsx: filePath.endsWith('.tsx'),
-            decorators: false,
-            dynamicImport: true,
-        });
-        let found = false;
-        function visit(node) {
-            if (node.type === 'MemberExpression' && node.property?.value) {
-                if (node.object?.type === 'Identifier' && node.object.value === 'css') {
-                    if (node.property.value === 'props') {
-                        found = true;
+            console.warn(`Failed to parse ${filePath}:`, err);
+            return [];
+        }
+        const localConsts = (0, utils_1.collectLocalConsts)(ast);
+        Object.assign(utils_1.tables.staticTable, localConsts);
+        const localCreateStyles = {};
+        (0, utils_1.traverse)(ast, {
+            VariableDeclarator({ node }) {
+                if (node.id.type === 'Identifier' &&
+                    node.init &&
+                    utils_1.t.isCallExpression(node.init) &&
+                    utils_1.t.isMemberExpression(node.init.callee) &&
+                    utils_1.t.isIdentifier(node.init.callee.object, { name: 'css' }) &&
+                    utils_1.t.isIdentifier(node.init.callee.property, { name: 'create' }) &&
+                    node.init.arguments.length === 1 &&
+                    utils_1.t.isObjectExpression(node.init.arguments[0].expression)) {
+                    const obj = (0, utils_1.objectExpressionToObject)(node.init.arguments[0].expression, utils_1.tables.staticTable, utils_1.tables.keyframesHashTable, utils_1.tables.viewTransitionHashTable, utils_1.tables.themeTable);
+                    if (obj) {
+                        localCreateStyles[node.id.value] = obj;
+                        Object.entries(obj).forEach(([key, style]) => {
+                            const records = (0, utils_1.getStyleRecords)(key, style, 1);
+                            (0, utils_1.extractOndemandStyles)(style, extractedSheets);
+                            records.forEach((r) => {
+                                extractedSheets.push(r.sheet);
+                            });
+                        });
                     }
                 }
-            }
-            for (const key in node) {
-                const value = node[key];
-                if (value && typeof value === 'object') {
-                    if (Array.isArray(value)) {
-                        for (const item of value) {
-                            visit(item);
+            },
+            CallExpression({ node }) {
+                const callee = node.callee;
+                if (utils_1.t.isMemberExpression(callee) &&
+                    utils_1.t.isIdentifier(callee.object, { name: 'css' }) &&
+                    utils_1.t.isIdentifier(callee.property)) {
+                    const args = node.arguments;
+                    if (callee.property.value === 'props') {
+                        const merged = {};
+                        let allStatic = true;
+                        args.forEach((arg) => {
+                            const expr = arg.expression;
+                            if (utils_1.t.isObjectExpression(expr)) {
+                                const obj = (0, utils_1.objectExpressionToObject)(expr, utils_1.tables.staticTable, utils_1.tables.keyframesHashTable, utils_1.tables.viewTransitionHashTable, utils_1.tables.themeTable);
+                                if (obj) {
+                                    Object.assign(merged, obj);
+                                }
+                                else {
+                                    allStatic = false;
+                                }
+                            }
+                            else if (utils_1.t.isMemberExpression(expr)) {
+                                if (utils_1.t.isIdentifier(expr.object) &&
+                                    utils_1.t.isIdentifier(expr.property)) {
+                                    const varName = expr.object.value;
+                                    const propName = expr.property.value;
+                                    const styleSet = localCreateStyles[varName];
+                                    if (styleSet && styleSet[propName]) {
+                                        Object.assign(merged, styleSet[propName]);
+                                    }
+                                    else {
+                                        allStatic = false;
+                                    }
+                                }
+                                else {
+                                    allStatic = false;
+                                }
+                            }
+                            else if (utils_1.t.isIdentifier(expr)) {
+                                const obj = localCreateStyles[expr.value];
+                                if (obj) {
+                                    Object.assign(merged, obj);
+                                }
+                                else {
+                                    allStatic = false;
+                                }
+                            }
+                            else {
+                                allStatic = false;
+                            }
+                        });
+                        if (allStatic && Object.keys(merged).length > 0) {
+                            (0, utils_1.extractOndemandStyles)(merged, extractedSheets);
+                            const hash = (0, zss_engine_1.genBase36Hash)(merged, 1, 8);
+                            const records = (0, utils_1.getStyleRecords)(hash, merged, 1);
+                            records.forEach((r) => extractedSheets.push(r.sheet));
                         }
                     }
-                    else {
-                        visit(value);
+                    else if (callee.property.value === 'keyframes' &&
+                        args.length > 0 &&
+                        utils_1.t.isObjectExpression(args[0].expression)) {
+                        const obj = (0, utils_1.objectExpressionToObject)(args[0].expression, utils_1.tables.staticTable, utils_1.tables.keyframesHashTable, utils_1.tables.viewTransitionHashTable, utils_1.tables.themeTable);
+                        const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                        utils_1.tables.keyframesObjectTable[hash] = obj;
+                    }
+                    else if (callee.property.value === 'viewTransition' &&
+                        args.length > 0 &&
+                        utils_1.t.isObjectExpression(args[0].expression)) {
+                        const obj = (0, utils_1.objectExpressionToObject)(args[0].expression, utils_1.tables.staticTable, utils_1.tables.keyframesHashTable, utils_1.tables.viewTransitionHashTable, utils_1.tables.themeTable);
+                        const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                        utils_1.tables.viewTransitionObjectTable[hash] = obj;
+                    }
+                    else if (callee.property.value === 'createTheme' &&
+                        args.length > 0 &&
+                        utils_1.t.isObjectExpression(args[0].expression)) {
+                        const obj = (0, utils_1.objectExpressionToObject)(args[0].expression, utils_1.tables.staticTable, utils_1.tables.keyframesHashTable, utils_1.tables.viewTransitionHashTable, utils_1.tables.themeTable);
+                        const themeHash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                        utils_1.tables.createThemeObjectTable[themeHash] = obj;
                     }
                 }
-            }
-        }
-        visit(ast);
-        return found;
-    }
-    async function optimizeCSS() {
-        const cssCode = await (0, promises_1.readFile)(coreFilePath, 'utf8');
-        const merged = (0, postcss_1.default)([(0, postcss_combine_media_query_1.default)()]).process(cssCode, {
-            from: coreFilePath,
-            to: coreFilePath,
-        });
-        const light = (0, lightningcss_1.transform)({
-            filename: coreFilePath,
-            code: Buffer.from(merged.css),
-            minify: process.env.NODE_ENV === 'production',
-            targets: {
-                safari: 16,
-                edge: 110,
-                firefox: 110,
-                chrome: 110,
             },
         });
-        const optimizedCss = Buffer.from(light.code).toString('utf-8');
-        await (0, promises_1.writeFile)(coreFilePath, optimizedCss, 'utf-8');
-    }
-    const startTime = performance.now();
-    await cleanUp();
-    const scanRoot = process.cwd();
-    const files = (0, glob_1.globSync)('**/*.{js,jsx,ts,tsx,vue,svelte}', {
-        cwd: scanRoot,
-        exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**'],
+        return extractedSheets;
+    };
+    const files = fs_1.default.globSync(pattern, {
+        cwd,
+        exclude: ['**/node_modules/**', '**/dist/**', '**/.next/**'],
     });
-    const projectName = path_1.default.basename(projectRoot);
-    const filesSupportExtensions = await Promise.all(files.map(async (file) => {
-        const ext = path_1.default.extname(file);
-        if (ext === '.vue' || ext === '.svelte') {
-            return await (0, extract_1.extractVueAndSvelte)(file);
-        }
-        else {
-            return await (0, extract_1.extractTSFile)(file);
-        }
-    }));
-    const styleFiles = await Promise.all(filesSupportExtensions.map(async (file) => {
-        const code = extract_1.generatedTsMap.get(file);
-        const isCssFile = code ? await isCSS(code, file) : false;
-        return isCssFile ? file : null;
-    }))
-        .then((results) => results.filter(Boolean))
-        .then((results) => results.sort());
-    for (const file of styleFiles) {
-        const code = extract_1.generatedTsMap.get(file);
-        if (code) {
-            const ext = path_1.default.extname(file);
-            const tsPath = ext === '.vue' || ext === '.svelte' ? file.replace(ext, '.ts') : file;
-            await (0, execute_1.executeCode)(code, { filePath: tsPath });
-            if (process.argv.includes('--paths')) {
-                console.log(`✅: ${projectName}/${path_1.default.relative(projectRoot, file)}`);
-            }
-        }
-    }
-    await processors_1.gQueue.build(coreFilePath);
-    await processors_1.pQueue.build(coreFilePath);
-    await optimizeCSS();
-    extract_1.generatedTsMap.clear();
-    if (process.argv.includes('--stats')) {
-        const endTime = performance.now();
-        const buildTime = (endTime - startTime) / 1000;
-        await generateStats(buildTime, coreFilePath);
+    files.forEach((file) => {
+        const sheets = processFile(file);
+        sheets.forEach((sheet) => allSheets.add(sheet));
+    });
+    const outputPath = path_1.default.resolve(cwd, output);
+    const css = Array.from(allSheets).join('\n');
+    const outputDir = path_1.default.dirname(outputPath);
+    if (!fs_1.default.existsSync(outputDir)) {
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
     }
+    const optCSS = await (0, optimizer_1.optimizeCSS)(css);
+    fs_1.default.writeFileSync(outputPath, optCSS);
+}
+async function main() {
+    const coreFilePath = require.resolve('@plumeria/core/stylesheet.css');
+    await compile({ pattern: '**/*.{js,jsx,ts,tsx}', output: coreFilePath });
 }
-main().catch((error) => {
-    console.error('Compilation failed:', error);
-    process.exit(1);
+main().catch((err) => {
+    console.error(err);
 });

package/dist/optimizer.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeCSS = optimizeCSS;
+const postcss_1 = __importDefault(require("postcss"));
+const postcss_combine_media_query_1 = __importDefault(require("postcss-combine-media-query"));
+const lightningcss_1 = require("lightningcss");
+async function optimizeCSS(cssCode) {
+    const merged = await (0, postcss_1.default)([(0, postcss_combine_media_query_1.default)()]).process(cssCode, {
+        from: undefined,
+    });
+    const light = (0, lightningcss_1.transform)({
+        filename: 'stylesheet.css',
+        code: Buffer.from(merged.css),
+        minify: process.env.NODE_ENV === 'production',
+        targets: {
+            safari: 16,
+            edge: 110,
+            firefox: 110,
+            chrome: 110,
+        },
+    });
+    return Buffer.from(light.code).toString('utf-8');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/compiler",
-  "version": "2.4.2",
+  "version": "3.0.0",
   "description": "Plumeria swc based compiler",
   "author": "Refirst 11",
   "license": "MIT",
@@ -23,13 +23,16 @@
     "css": "./bin/css.js"
   },
   "dependencies": {
-    "@rust-gear/glob": "^0.2.7",
-    "@swc/core": "1.15.2",
-    "find-up": "^8.0.0",
+    "rscute": "^1.1.5",
     "lightningcss": "^1.30.2",
     "postcss": "^8.5.6",
     "postcss-combine-media-query": "^2.1.0",
-    "rscute": "^1.1.5"
+    "@plumeria/utils": "^3.0.0"
+  },
+  "devDependencies": {
+    "@swc/core": "1.15.2",
+    "zss-engine": "2.1.2",
+    "@plumeria/core": "^3.0.0"
   },
   "publishConfig": {
     "access": "public",

package/dist/extract.js

@@ -1,544 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generatedTsMap = void 0;
-exports.extractTSFile = extractTSFile;
-exports.extractVueAndSvelte = extractVueAndSvelte;
-const core_1 = require("@swc/core");
-const promises_1 = require("fs/promises");
-const path_1 = __importDefault(require("path"));
-const generatedTsMap = new Map();
-exports.generatedTsMap = generatedTsMap;
-function isInComment(code, position) {
-    const beforePosition = code.substring(0, position);
-    const lines = beforePosition.split('\n');
-    const currentLine = lines[lines.length - 1];
-    const singleLineCommentIndex = currentLine.indexOf('//');
-    if (singleLineCommentIndex !== -1) {
-        return true;
-    }
-    let inMultiLineComment = false;
-    let i = 0;
-    while (i < position) {
-        if (code.substring(i, i + 2) === '/*') {
-            inMultiLineComment = true;
-            i += 2;
-        }
-        else if (code.substring(i, i + 2) === '*/') {
-            inMultiLineComment = false;
-            i += 2;
-        }
-        else {
-            i++;
-        }
-    }
-    return inMultiLineComment;
-}
-function isInVueAttribute(code, position) {
-    let quotePosition = -1;
-    for (let i = position - 1; i >= 0; i--) {
-        const char = code[i];
-        if (char === '"' || char === "'") {
-            quotePosition = i;
-            break;
-        }
-    }
-    if (quotePosition === -1)
-        return false;
-    const beforeQuote = code.substring(Math.max(0, quotePosition - 30), quotePosition);
-    const vueAttributePattern = /(:|v-bind:)(class|style)\s*=\s*$/;
-    return vueAttributePattern.test(beforeQuote);
-}
-function isInString(code, position) {
-    let inSingleQuote = false;
-    let inDoubleQuote = false;
-    let inBacktick = false;
-    let escape = false;
-    for (let i = 0; i < position; i++) {
-        const char = code[i];
-        if (escape) {
-            escape = false;
-            continue;
-        }
-        if (char === '\\') {
-            escape = true;
-            continue;
-        }
-        if (!inSingleQuote && !inDoubleQuote && !inBacktick) {
-            if (char === "'") {
-                inSingleQuote = true;
-            }
-            else if (char === '"') {
-                inDoubleQuote = true;
-            }
-            else if (char === '`') {
-                inBacktick = true;
-            }
-        }
-        else {
-            if (inSingleQuote && char === "'") {
-                inSingleQuote = false;
-            }
-            else if (inDoubleQuote && char === '"') {
-                inDoubleQuote = false;
-            }
-            else if (inBacktick && char === '`') {
-                inBacktick = false;
-            }
-        }
-    }
-    const inStringLiteral = inSingleQuote || inDoubleQuote || inBacktick;
-    if (inStringLiteral && isInVueAttribute(code, position))
-        return false;
-    return inStringLiteral;
-}
-function isInHtmlText(code, position) {
-    let lastOpenTag = -1;
-    let lastCloseTag = -1;
-    for (let i = position - 1; i >= 0; i--) {
-        if (code[i] === '>' && lastCloseTag === -1) {
-            lastCloseTag = i;
-        }
-        if (code[i] === '<') {
-            lastOpenTag = i;
-            break;
-        }
-    }
-    let nextOpenTag = -1;
-    for (let i = position; i < code.length; i++) {
-        if (code[i] === '<') {
-            nextOpenTag = i;
-            break;
-        }
-    }
-    return lastCloseTag > lastOpenTag && nextOpenTag > position;
-}
-function expressionToString(expr) {
-    switch (expr.type) {
-        case 'Identifier':
-            return expr.value;
-        case 'MemberExpression': {
-            const obj = expressionToString(expr.object);
-            if (obj && expr.property.type === 'Identifier') {
-                return `${obj}.${expr.property.value}`;
-            }
-            break;
-        }
-        case 'CallExpression': {
-            if (expr.callee.type !== 'Super' && expr.callee.type !== 'Import') {
-                const callee = expressionToString(expr.callee);
-                if (callee) {
-                    const args = expr.arguments
-                        .map((arg) => expressionToString(arg.expression))
-                        .join(', ');
-                    return `${callee}(${args})`;
-                }
-            }
-            break;
-        }
-        case 'ObjectExpression': {
-            const properties = expr.properties
-                .map((prop) => {
-                if ('key' in prop && prop.key && prop.key.type === 'Identifier') {
-                    const key = prop.key.value;
-                    const value = expressionToString(prop.value);
-                    return `${key}: ${value}`;
-                }
-                return '[complex property]';
-            })
-                .join(', ');
-            console.warn(`css.props: Argument unsupported ${expr.type}: { ${properties} } Use css.create instead.`);
-            return '';
-        }
-        case 'StringLiteral':
-            return String(expr.value);
-    }
-    console.warn(`css.props: Argument unsupported ${expr.type}: Use css.create instead.`);
-    return '';
-}
-async function extractCreatedStyleKeys(ast) {
-    const createdStylesMap = new Map();
-    await visit(ast, {
-        VariableDeclarator: (node) => {
-            if (node.id.type === 'Identifier' &&
-                node.init &&
-                node.init.type === 'CallExpression' &&
-                node.init.callee.type === 'MemberExpression' &&
-                node.init.callee.object.type === 'Identifier' &&
-                node.init.callee.object.value === 'css' &&
-                node.init.callee.property.type === 'Identifier' &&
-                node.init.callee.property.value === 'create' &&
-                node.init.arguments.length > 0) {
-                const variableName = node.id.value;
-                const createArg = node.init.arguments[0].expression;
-                if (createArg && createArg.type === 'ObjectExpression') {
-                    const keys = [];
-                    for (const prop of createArg.properties) {
-                        if (prop.type === 'KeyValueProperty' &&
-                            prop.key.type === 'Identifier') {
-                            keys.push(prop.key.value);
-                        }
-                        else if (prop.type === 'Identifier') {
-                            keys.push(prop.value);
-                        }
-                    }
-                    if (keys.length > 0) {
-                        createdStylesMap.set(variableName, keys);
-                    }
-                }
-            }
-        },
-    });
-    return createdStylesMap;
-}
-async function extractCssProps(ast, code, createdStylesMap) {
-    const propsMatches = [];
-    if (code && !code.includes('css.props')) {
-        return propsMatches;
-    }
-    try {
-        await visit(ast, {
-            CallExpression: async (node) => {
-                if (node.callee.type === 'MemberExpression' &&
-                    node.callee.object.type === 'Identifier' &&
-                    node.callee.object.value === 'css' &&
-                    node.callee.property.type === 'Identifier' &&
-                    node.callee.property.value === 'props') {
-                    const staticArgs = [];
-                    const conditionalStyleObjects = [];
-                    for (const arg of node.arguments) {
-                        if (arg.expression) {
-                            if (arg.expression.type === 'ConditionalExpression' ||
-                                (arg.expression.type === 'BinaryExpression' &&
-                                    arg.expression.operator === '&&')) {
-                                const styles = extractStyleObjectsFromExpression(arg.expression);
-                                conditionalStyleObjects.push(...styles);
-                            }
-                            else if (arg.expression.type === 'MemberExpression' &&
-                                arg.expression.property.type === 'Computed' &&
-                                arg.expression.object.type === 'Identifier') {
-                                const styleVarName = arg.expression.object.value;
-                                const styleKeys = createdStylesMap.get(styleVarName);
-                                if (styleKeys) {
-                                    propsMatches.push(...styleKeys.map((key) => `css.props(${styleVarName}.${key})`));
-                                }
-                            }
-                            else {
-                                const argStr = expressionToString(arg.expression);
-                                if (argStr) {
-                                    staticArgs.push(argStr);
-                                }
-                            }
-                        }
-                    }
-                    if (staticArgs.length > 0) {
-                        propsMatches.push(`css.props(${staticArgs.join(', ')})`);
-                    }
-                    for (const styleObj of conditionalStyleObjects) {
-                        if (styleObj &&
-                            styleObj !== 'false' &&
-                            styleObj !== 'null' &&
-                            styleObj !== 'undefined') {
-                            propsMatches.push(`css.props(${styleObj})`);
-                        }
-                    }
-                }
-            },
-        });
-    }
-    catch (e) {
-        console.error(`Failed to parse code to extract css.props: ${e}`);
-    }
-    return [...new Set(propsMatches)];
-}
-function extractStyleObjectsFromExpression(expression) {
-    switch (expression.type) {
-        case 'BinaryExpression':
-            if (expression.operator === '&&') {
-                return extractStyleObjectsFromExpression(expression.right);
-            }
-            break;
-        case 'ConditionalExpression':
-            return [
-                ...extractStyleObjectsFromExpression(expression.consequent),
-                ...extractStyleObjectsFromExpression(expression.alternate),
-            ];
-        case 'BooleanLiteral':
-        case 'NullLiteral':
-            return [];
-        case 'Identifier':
-            if (expression.value === 'undefined') {
-                return [];
-            }
-        case 'ObjectExpression': {
-            const str = expressionToString(expression);
-            return str ? [str] : [];
-        }
-    }
-    const str = expressionToString(expression);
-    if (str) {
-        return [str];
-    }
-    return [];
-}
-async function extractStaticStringLiteralVariable(ast) {
-    const matches = [];
-    try {
-        for (const node of ast.body) {
-            if (node.type === 'VariableDeclaration') {
-                const allStringLiterals = node.declarations.length > 0 &&
-                    node.declarations.every((decl) => decl.init && decl.init.type === 'StringLiteral');
-                if (allStringLiterals) {
-                    const { code: extractedCode } = await (0, core_1.print)({
-                        type: 'Module',
-                        body: [node],
-                        span: { start: 0, end: 0, ctxt: 0 },
-                    });
-                    matches.push(extractedCode.trim());
-                }
-            }
-        }
-    }
-    catch (e) {
-        console.error(`Failed to parse code to extract static string literal variables: ${e}`);
-    }
-    return matches.join('\n');
-}
-function extractCssPropsFromTemplate(code) {
-    const matches = [];
-    const regex = /css\.props\(([^)]*)\)/g;
-    let match;
-    while ((match = regex.exec(code)) !== null) {
-        const matchStart = match.index;
-        if (isInComment(code, matchStart) ||
-            isInString(code, matchStart) ||
-            isInHtmlText(code, matchStart)) {
-            continue;
-        }
-        const scriptStartIndex = code.indexOf('<script');
-        const scriptEndIndex = code.indexOf('</script>');
-        if (scriptStartIndex !== -1 &&
-            scriptEndIndex !== -1 &&
-            match.index > scriptStartIndex &&
-            match.index < scriptEndIndex) {
-            continue;
-        }
-        const args = match[1];
-        if (args && !args.includes('{') && !args.includes('(')) {
-            matches.push(`css.props(${args})`);
-        }
-    }
-    return matches;
-}
-async function visit(node, visitor) {
-    if (!node)
-        return;
-    const visitorFunc = visitor[node.type];
-    if (visitorFunc) {
-        await visitorFunc(node);
-    }
-    for (const key in node) {
-        if (typeof node[key] === 'object' && node[key] !== null) {
-            if (Array.isArray(node[key])) {
-                for (const child of node[key]) {
-                    await visit(child, visitor);
-                }
-            }
-            else {
-                await visit(node[key], visitor);
-            }
-        }
-    }
-}
-function importDeclarationToString(node) {
-    const source = node.source.value;
-    const defaultImport = node.specifiers.find((s) => s.type === 'ImportDefaultSpecifier');
-    const namespaceImport = node.specifiers.find((s) => s.type === 'ImportNamespaceSpecifier');
-    const namedImports = node.specifiers.filter((s) => s.type === 'ImportSpecifier');
-    let importClause = '';
-    if (defaultImport) {
-        importClause += defaultImport.local.value;
-    }
-    if (namespaceImport) {
-        if (importClause)
-            importClause += ', ';
-        importClause += `* as ${namespaceImport.local.value}`;
-    }
-    if (namedImports.length > 0) {
-        if (importClause)
-            importClause += ', ';
-        const namedParts = namedImports.map((spec) => {
-            if (spec.imported && spec.imported.value !== spec.local.value) {
-                return `${spec.imported.value} as ${spec.local.value}`;
-            }
-            return spec.local.value;
-        });
-        importClause += `{ ${namedParts.join(', ')} }`;
-    }
-    if (importClause) {
-        return `import ${importClause} from '${source}';`;
-    }
-    return `import '${source}';`;
-}
-async function extractImportDeclarations(ast) {
-    const importDeclarations = [];
-    try {
-        await visit(ast, {
-            ImportDeclaration: (node) => {
-                importDeclarations.push(importDeclarationToString(node));
-            },
-        });
-    }
-    catch (e) {
-        console.error(`Failed to parse code to extract import declarations: ${e}`);
-    }
-    return importDeclarations.join('\n');
-}
-async function extractCssMethod(ast, methodName, code) {
-    if (!code.includes(`css.${methodName}`)) {
-        return '';
-    }
-    const matches = [];
-    try {
-        for (const node of ast.body) {
-            if (node.type === 'VariableDeclaration') {
-                const containsCssMethod = node.declarations.some((decl) => decl.init &&
-                    decl.init.type === 'CallExpression' &&
-                    decl.init.callee.type === 'MemberExpression' &&
-                    decl.init.callee.object.type === 'Identifier' &&
-                    decl.init.callee.object.value === 'css' &&
-                    decl.init.callee.property.type === 'Identifier' &&
-                    decl.init.callee.property.value === methodName);
-                if (containsCssMethod && node.span) {
-                    const { code: extractedCode } = await (0, core_1.print)({
-                        type: 'Module',
-                        body: [node],
-                        span: { start: 0, end: 0, ctxt: 0 },
-                    });
-                    matches.push(extractedCode.trim());
-                }
-            }
-        }
-    }
-    catch (e) {
-        console.error(`Failed to parse code to extract css.${methodName}: ${e}`);
-    }
-    return matches.join('\n');
-}
-async function extractVueAndSvelte(filePath) {
-    const ext = path_1.default.extname(filePath);
-    if (!(ext === '.svelte' || ext === '.vue'))
-        return filePath;
-    const code = await (0, promises_1.readFile)(filePath, 'utf8');
-    const lines = code.split(/\r?\n/);
-    let inScript = false;
-    const contentLines = [];
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!inScript && /^<script\b/.test(trimmed)) {
-            inScript = true;
-            continue;
-        }
-        if (inScript && /^<\/script>/.test(trimmed)) {
-            inScript = false;
-            continue;
-        }
-        if (inScript) {
-            contentLines.push(line);
-        }
-    }
-    const tsCode = contentLines.join('\n');
-    const tsPath = filePath.replace(ext, '.ts');
-    if (!tsCode.trim()) {
-        generatedTsMap.set(filePath, '');
-        return tsPath;
-    }
-    const ast = await (0, core_1.parse)(tsCode, {
-        syntax: 'typescript',
-        tsx: true,
-    });
-    const createdStylesMap = await extractCreatedStyleKeys(ast);
-    const propsFromScript = await extractCssProps(ast, code, createdStylesMap);
-    const propsFromTemplate = extractCssPropsFromTemplate(code);
-    const propsMatches = [...new Set([...propsFromScript, ...propsFromTemplate])];
-    const calls = propsMatches
-        .filter(Boolean)
-        .map((call) => `${call};`)
-        .join('\n');
-    const importSection = await extractImportDeclarations(ast);
-    const staticVariableSection = await extractStaticStringLiteralVariable(ast);
-    const cssCreateSection = await extractCssMethod(ast, 'create', code);
-    const cssKeyframesSection = await extractCssMethod(ast, 'keyframes', code);
-    const cssViewTransitionSection = await extractCssMethod(ast, 'viewTransition', code);
-    const cssCreateStaticSection = await extractCssMethod(ast, 'createStatic', code);
-    const cssCreateThemeSection = await extractCssMethod(ast, 'createTheme', code);
-    let finalCode = '';
-    if (importSection)
-        finalCode += importSection + '\n';
-    if (staticVariableSection)
-        finalCode += staticVariableSection + '\n';
-    if (cssKeyframesSection)
-        finalCode += cssKeyframesSection + '\n';
-    if (cssViewTransitionSection)
-        finalCode += cssViewTransitionSection + '\n';
-    if (cssCreateStaticSection)
-        finalCode += cssCreateStaticSection + '\n';
-    if (cssCreateThemeSection)
-        finalCode += cssCreateThemeSection + '\n';
-    if (cssCreateSection)
-        finalCode += cssCreateSection + '\n';
-    if (calls)
-        finalCode += calls + '\n';
-    generatedTsMap.set(filePath, finalCode);
-    return filePath;
-}
-async function extractTSFile(filePath) {
-    const code = await (0, promises_1.readFile)(filePath, 'utf8');
-    const ast = await (0, core_1.parse)(code, {
-        syntax: 'typescript',
-        tsx: true,
-    });
-    const createdStylesMap = await extractCreatedStyleKeys(ast);
-    const importSection = await extractImportDeclarations(ast);
-    const staticVariableSection = await extractStaticStringLiteralVariable(ast);
-    const cssCreateSection = await extractCssMethod(ast, 'create', code);
-    const cssKeyframesSection = await extractCssMethod(ast, 'keyframes', code);
-    const cssViewTransitionSection = await extractCssMethod(ast, 'viewTransition', code);
-    const cssCreateStaticSection = await extractCssMethod(ast, 'createStatic', code);
-    const cssCreateThemeSection = await extractCssMethod(ast, 'createTheme', code);
-    const propsMatches = await extractCssProps(ast, code, createdStylesMap);
-    const calls = propsMatches
-        .filter(Boolean)
-        .map((call) => `${call};`)
-        .join('\n');
-    let finalCode = '';
-    if (importSection)
-        finalCode += importSection + '\n';
-    if (staticVariableSection)
-        finalCode += staticVariableSection + '\n';
-    if (cssKeyframesSection)
-        finalCode += cssKeyframesSection + '\n';
-    if (cssViewTransitionSection)
-        finalCode += cssViewTransitionSection + '\n';
-    if (cssCreateStaticSection)
-        finalCode += cssCreateStaticSection + '\n';
-    if (cssCreateThemeSection)
-        finalCode += cssCreateThemeSection + '\n';
-    if (cssCreateSection)
-        finalCode += cssCreateSection + '\n';
-    finalCode += calls;
-    generatedTsMap.set(filePath, finalCode);
-    return filePath;
-}
-process.on('uncaughtException', async (error) => {
-    console.error('Uncaught Exception:', error);
-    generatedTsMap.clear();
-    process.exit(1);
-});
-process.on('unhandledRejection', async (reason, promise) => {
-    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
-    generatedTsMap.clear();
-    process.exit(1);
-});