@plumeria/webpack-plugin 7.1.2 → 7.2.1

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import type { LoaderContext } from 'webpack';
-export default function loader(this: LoaderContext<unknown>, source: string): Promise<void>;
+import loader from '@plumeria/turbopack-loader';
+export default loader;

package/dist/index.js

@@ -3,1322 +3,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = loader;
-const core_1 = require("@swc/core");
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const zss_engine_1 = require("zss-engine");
-const utils_1 = require("@plumeria/utils");
-const VIRTUAL_FILE_PATH = path_1.default.resolve(__dirname, '..', 'zero-virtual.css');
-if (process.env.NODE_ENV === 'production') {
-    (0, fs_1.writeFileSync)(VIRTUAL_FILE_PATH, '/** Placeholder file */\n', 'utf-8');
-}
-async function loader(source) {
-    const callback = this.async();
-    const isProduction = process.env.NODE_ENV === 'production';
-    if (this.resourcePath.includes('node_modules') ||
-        !source.includes('@plumeria/core')) {
-        return callback(null, source);
-    }
-    const fileStyles = {};
-    this.clearDependencies();
-    this.addDependency(this.resourcePath);
-    const ast = (0, core_1.parseSync)(source, {
-        syntax: 'typescript',
-        tsx: true,
-        target: 'es2022',
-    });
-    for (const node of ast.body) {
-        if (node.type === 'ImportDeclaration') {
-            const sourcePath = node.source.value;
-            const actualPath = (0, utils_1.resolveImportPath)(sourcePath, this.resourcePath);
-            if (actualPath) {
-                this.addDependency(actualPath);
-            }
-        }
-    }
-    const scannedTables = (0, utils_1.scanAll)();
-    const localConsts = (0, utils_1.collectLocalConsts)(ast);
-    const resourcePath = this.resourcePath;
-    const importMap = {};
-    const createThemeImportMap = {};
-    const createStaticImportMap = {};
-    const plumeriaAliases = {};
-    (0, utils_1.traverse)(ast, {
-        ImportDeclaration({ node }) {
-            const sourcePath = node.source.value;
-            if (sourcePath === '@plumeria/core') {
-                node.specifiers.forEach((specifier) => {
-                    if (specifier.type === 'ImportNamespaceSpecifier') {
-                        plumeriaAliases[specifier.local.value] = 'NAMESPACE';
-                    }
-                    else if (specifier.type === 'ImportDefaultSpecifier') {
-                        plumeriaAliases[specifier.local.value] = 'NAMESPACE';
-                    }
-                    else if (specifier.type === 'ImportSpecifier') {
-                        const importedName = specifier.imported
-                            ? specifier.imported.value
-                            : specifier.local.value;
-                        plumeriaAliases[specifier.local.value] = importedName;
-                    }
-                });
-            }
-            const actualPath = (0, utils_1.resolveImportPath)(sourcePath, resourcePath);
-            if (actualPath) {
-                node.specifiers.forEach((specifier) => {
-                    if (specifier.type === 'ImportSpecifier') {
-                        const importedName = specifier.imported
-                            ? specifier.imported.value
-                            : specifier.local.value;
-                        const localName = specifier.local.value;
-                        const uniqueKey = `${actualPath}-${importedName}`;
-                        if (scannedTables.staticTable[uniqueKey]) {
-                            importMap[localName] = scannedTables.staticTable[uniqueKey];
-                        }
-                        if (scannedTables.keyframesHashTable[uniqueKey]) {
-                            importMap[localName] =
-                                scannedTables.keyframesHashTable[uniqueKey];
-                        }
-                        if (scannedTables.viewTransitionHashTable[uniqueKey]) {
-                            importMap[localName] =
-                                scannedTables.viewTransitionHashTable[uniqueKey];
-                        }
-                        if (scannedTables.createHashTable[uniqueKey]) {
-                            importMap[localName] = scannedTables.createHashTable[uniqueKey];
-                        }
-                        if (scannedTables.variantsHashTable[uniqueKey]) {
-                            importMap[localName] = scannedTables.variantsHashTable[uniqueKey];
-                        }
-                        if (scannedTables.createThemeHashTable[uniqueKey]) {
-                            createThemeImportMap[localName] =
-                                scannedTables.createThemeHashTable[uniqueKey];
-                        }
-                        if (scannedTables.createStaticHashTable[uniqueKey]) {
-                            createStaticImportMap[localName] =
-                                scannedTables.createStaticHashTable[uniqueKey];
-                        }
-                    }
-                });
-            }
-        },
-    });
-    const mergedStaticTable = {};
-    for (const key of Object.keys(scannedTables.staticTable)) {
-        mergedStaticTable[key] = scannedTables.staticTable[key];
-    }
-    for (const key of Object.keys(localConsts)) {
-        mergedStaticTable[key] = localConsts[key];
-    }
-    for (const key of Object.keys(importMap)) {
-        mergedStaticTable[key] = importMap[key];
-    }
-    const mergedKeyframesTable = {};
-    for (const key of Object.keys(scannedTables.keyframesHashTable)) {
-        mergedKeyframesTable[key] = scannedTables.keyframesHashTable[key];
-    }
-    for (const key of Object.keys(importMap)) {
-        mergedKeyframesTable[key] = importMap[key];
-    }
-    const mergedViewTransitionTable = {};
-    for (const key of Object.keys(scannedTables.viewTransitionHashTable)) {
-        mergedViewTransitionTable[key] = scannedTables.viewTransitionHashTable[key];
-    }
-    for (const key of Object.keys(importMap)) {
-        mergedViewTransitionTable[key] = importMap[key];
-    }
-    const mergedCreateTable = {};
-    for (const key of Object.keys(scannedTables.createHashTable)) {
-        mergedCreateTable[key] = scannedTables.createHashTable[key];
-    }
-    for (const key of Object.keys(importMap)) {
-        mergedCreateTable[key] = importMap[key];
-    }
-    const mergedVariantsTable = {};
-    for (const key of Object.keys(scannedTables.variantsHashTable)) {
-        mergedVariantsTable[key] = scannedTables.variantsHashTable[key];
-    }
-    for (const key of Object.keys(importMap)) {
-        mergedVariantsTable[key] = importMap[key];
-    }
-    const mergedCreateThemeHashTable = {};
-    for (const key of Object.keys(scannedTables.createThemeHashTable)) {
-        mergedCreateThemeHashTable[key] = scannedTables.createThemeHashTable[key];
-        if (key.startsWith(`${resourcePath}-`)) {
-            const varName = key.slice(resourcePath.length + 1);
-            mergedCreateThemeHashTable[varName] =
-                scannedTables.createThemeHashTable[key];
-        }
-    }
-    for (const key of Object.keys(createThemeImportMap)) {
-        mergedCreateThemeHashTable[key] = createThemeImportMap[key];
-    }
-    const mergedCreateStaticHashTable = {};
-    for (const key of Object.keys(scannedTables.createStaticHashTable)) {
-        mergedCreateStaticHashTable[key] = scannedTables.createStaticHashTable[key];
-        if (key.startsWith(`${resourcePath}-`)) {
-            const varName = key.slice(resourcePath.length + 1);
-            mergedCreateStaticHashTable[varName] =
-                scannedTables.createStaticHashTable[key];
-        }
-    }
-    for (const key of Object.keys(createStaticImportMap)) {
-        mergedCreateStaticHashTable[key] = createStaticImportMap[key];
-    }
-    const localCreateStyles = {};
-    const replacements = [];
-    const extractedSheets = [];
-    const addSheet = (sheet) => {
-        if (!extractedSheets.includes(sheet)) {
-            extractedSheets.push(sheet);
-        }
-    };
-    const processedDecls = new Set();
-    const idSpans = new Set();
-    const excludedSpans = new Set();
-    if (scannedTables.extractedSheet) {
-        addSheet(scannedTables.extractedSheet);
-    }
-    const checkVariantAssignment = (decl) => {
-        if (decl.init &&
-            utils_1.t.isCallExpression(decl.init) &&
-            utils_1.t.isIdentifier(decl.init.callee)) {
-            const varName = decl.init.callee.value;
-            if ((localCreateStyles[varName] &&
-                localCreateStyles[varName].type === 'variant') ||
-                mergedVariantsTable[varName]) {
-                throw new Error(`Plumeria: Assigning the return value of "css.variants" to a variable is not supported.\nPlease pass the variant function directly to "css.props". Found assignment to: ${utils_1.t.isIdentifier(decl.id) ? decl.id.value : 'unknown'}`);
-            }
-        }
-    };
-    const registerStyle = (node, declSpan, isExported) => {
-        let propName;
-        if (utils_1.t.isIdentifier(node.id) &&
-            node.init &&
-            utils_1.t.isCallExpression(node.init) &&
-            node.init.arguments.length >= 1) {
-            const callee = node.init.callee;
-            if (utils_1.t.isMemberExpression(callee) &&
-                utils_1.t.isIdentifier(callee.object) &&
-                utils_1.t.isIdentifier(callee.property)) {
-                const objectName = callee.object.value;
-                const propertyName = callee.property.value;
-                const alias = plumeriaAliases[objectName];
-                if (alias === 'NAMESPACE' || objectName === 'css') {
-                    propName = propertyName;
-                }
-            }
-            else if (utils_1.t.isIdentifier(callee)) {
-                const calleeName = callee.value;
-                const originalName = plumeriaAliases[calleeName];
-                if (originalName) {
-                    propName = originalName;
-                }
-            }
-        }
-        if (propName) {
-            if (propName === 'create' &&
-                utils_1.t.isObjectExpression(node.init.arguments[0].expression)) {
-                const obj = (0, utils_1.objectExpressionToObject)(node.init.arguments[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
-                if (obj) {
-                    const hashMap = {};
-                    Object.entries(obj).forEach(([key, style]) => {
-                        const records = (0, utils_1.getStyleRecords)(style);
-                        if (!isProduction) {
-                            (0, utils_1.extractOndemandStyles)(style, extractedSheets, scannedTables);
-                            records.forEach((r) => {
-                                addSheet(r.sheet);
-                            });
-                        }
-                        const atomMap = {};
-                        records.forEach((r) => (atomMap[r.key] = r.hash));
-                        hashMap[key] = atomMap;
-                    });
-                    if (utils_1.t.isIdentifier(node.id)) {
-                        idSpans.add(node.id.span.start);
-                    }
-                    localCreateStyles[node.id.value] = {
-                        name: node.id.value,
-                        type: 'create',
-                        obj,
-                        hashMap,
-                        isExported,
-                        initSpan: {
-                            start: node.init.span.start - ast.span.start,
-                            end: node.init.span.end - ast.span.start,
-                        },
-                        declSpan: {
-                            start: declSpan.start - ast.span.start,
-                            end: declSpan.end - ast.span.start,
-                        },
-                    };
-                }
-            }
-            else if (propName === 'variants' &&
-                utils_1.t.isObjectExpression(node.init.arguments[0].expression)) {
-                if (utils_1.t.isIdentifier(node.id)) {
-                    idSpans.add(node.id.span.start);
-                }
-                const obj = (0, utils_1.objectExpressionToObject)(node.init.arguments[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable, (name) => {
-                    if (localCreateStyles[name]) {
-                        return localCreateStyles[name].obj;
-                    }
-                    if (mergedCreateTable[name]) {
-                        const hash = mergedCreateTable[name];
-                        if (scannedTables.createObjectTable[hash]) {
-                            return scannedTables.createObjectTable[hash];
-                        }
-                    }
-                    return undefined;
-                });
-                const { hashMap, sheets } = (0, utils_1.processVariants)(obj);
-                if (!isProduction) {
-                    sheets.forEach(addSheet);
-                }
-                localCreateStyles[node.id.value] = {
-                    name: node.id.value,
-                    type: 'variant',
-                    obj,
-                    hashMap,
-                    isExported,
-                    initSpan: {
-                        start: node.init.span.start - ast.span.start,
-                        end: node.init.span.end - ast.span.start,
-                    },
-                    declSpan: {
-                        start: declSpan.start - ast.span.start,
-                        end: declSpan.end - ast.span.start,
-                    },
-                };
-            }
-            else if (propName === 'createTheme' &&
-                utils_1.t.isObjectExpression(node.init.arguments[0].expression)) {
-                if (utils_1.t.isIdentifier(node.id)) {
-                    idSpans.add(node.id.span.start);
-                }
-                const obj = (0, utils_1.objectExpressionToObject)(node.init.arguments[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
-                const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                const uniqueKey = `${resourcePath}-${node.id.value}`;
-                scannedTables.createThemeHashTable[uniqueKey] = hash;
-                scannedTables.createThemeObjectTable[hash] = obj;
-                localCreateStyles[node.id.value] = {
-                    name: node.id.value,
-                    type: 'constant',
-                    obj,
-                    hashMap: scannedTables.createAtomicMapTable[hash],
-                    isExported,
-                    initSpan: {
-                        start: node.init.span.start - ast.span.start,
-                        end: node.init.span.end - ast.span.start,
-                    },
-                    declSpan: {
-                        start: declSpan.start - ast.span.start,
-                        end: declSpan.end - ast.span.start,
-                    },
-                };
-            }
-        }
-    };
-    (0, utils_1.traverse)(ast, {
-        ImportDeclaration({ node }) {
-            if (node.specifiers) {
-                node.specifiers.forEach((specifier) => {
-                    if (specifier.local) {
-                        excludedSpans.add(specifier.local.span.start);
-                    }
-                    if (specifier.imported) {
-                        excludedSpans.add(specifier.imported.span.start);
-                    }
-                });
-            }
-        },
-        ExportDeclaration({ node }) {
-            if (utils_1.t.isVariableDeclaration(node.declaration)) {
-                processedDecls.add(node.declaration);
-                node.declaration.declarations.forEach((decl) => {
-                    checkVariantAssignment(decl);
-                    registerStyle(decl, node.span, true);
-                });
-            }
-        },
-        VariableDeclaration({ node }) {
-            if (processedDecls.has(node))
-                return;
-            node.declarations.forEach((decl) => {
-                checkVariantAssignment(decl);
-                registerStyle(decl, node.span, false);
-            });
-        },
-        CallExpression({ node }) {
-            const callee = node.callee;
-            let propName;
-            if (utils_1.t.isMemberExpression(callee) &&
-                utils_1.t.isIdentifier(callee.object) &&
-                utils_1.t.isIdentifier(callee.property)) {
-                const objectName = callee.object.value;
-                const propertyName = callee.property.value;
-                const alias = plumeriaAliases[objectName];
-                if (alias === 'NAMESPACE' || objectName === 'css') {
-                    propName = propertyName;
-                }
-            }
-            else if (utils_1.t.isIdentifier(callee)) {
-                const calleeName = callee.value;
-                const originalName = plumeriaAliases[calleeName];
-                if (originalName) {
-                    propName = originalName;
-                }
-            }
-            if (propName) {
-                const args = node.arguments;
-                if (propName === 'keyframes' &&
-                    args.length > 0 &&
-                    utils_1.t.isObjectExpression(args[0].expression)) {
-                    const obj = (0, utils_1.objectExpressionToObject)(args[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
-                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                    scannedTables.keyframesObjectTable[hash] = obj;
-                    if (!isProduction) {
-                        (0, utils_1.extractOndemandStyles)({ kf: `kf-${hash}` }, extractedSheets, scannedTables);
-                    }
-                    replacements.push({
-                        start: node.span.start - ast.span.start,
-                        end: node.span.end - ast.span.start,
-                        content: JSON.stringify(`kf-${hash}`),
-                    });
-                }
-                else if (propName === 'viewTransition' &&
-                    args.length > 0 &&
-                    utils_1.t.isObjectExpression(args[0].expression)) {
-                    const obj = (0, utils_1.objectExpressionToObject)(args[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
-                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                    scannedTables.viewTransitionObjectTable[hash] = obj;
-                    if (!isProduction) {
-                        (0, utils_1.extractOndemandStyles)({ vt: `vt-${hash}` }, extractedSheets, scannedTables);
-                    }
-                    replacements.push({
-                        start: node.span.start - ast.span.start,
-                        end: node.span.end - ast.span.start,
-                        content: JSON.stringify(`vt-${hash}`),
-                    });
-                }
-                else if ((propName === 'createTheme' || propName === 'createStatic') &&
-                    args.length > 0 &&
-                    utils_1.t.isObjectExpression(args[0].expression)) {
-                    const obj = (0, utils_1.objectExpressionToObject)(args[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
-                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                    if (propName === 'createTheme') {
-                        scannedTables.createThemeObjectTable[hash] = obj;
-                    }
-                    else {
-                        scannedTables.createStaticObjectTable[hash] = obj;
-                    }
-                    const prefix = propName === 'createTheme' ? 'tm-' : 'st-';
-                    replacements.push({
-                        start: node.span.start - ast.span.start,
-                        end: node.span.end - ast.span.start,
-                        content: JSON.stringify(`${prefix}${hash}`),
-                    });
-                }
-                else if (propName === 'create' &&
-                    args.length > 0 &&
-                    utils_1.t.isObjectExpression(args[0].expression)) {
-                    const obj = (0, utils_1.objectExpressionToObject)(args[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
-                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                    scannedTables.createObjectTable[hash] = obj;
-                    Object.entries(obj).forEach(([_key, style]) => {
-                        if (typeof style === 'object' && style !== null) {
-                            const records = (0, utils_1.getStyleRecords)(style);
-                            if (!isProduction) {
-                                (0, utils_1.extractOndemandStyles)(style, extractedSheets, scannedTables);
-                                records.forEach((r) => addSheet(r.sheet));
-                            }
-                        }
-                    });
-                }
-            }
-        },
-    });
-    (0, utils_1.traverse)(ast, {
-        MemberExpression({ node }) {
-            if (utils_1.t.isIdentifier(node.object) && utils_1.t.isIdentifier(node.property)) {
-                const varName = node.object.value;
-                const propName = node.property.value;
-                const uniqueKey = `${resourcePath}-${varName}`;
-                let hash = scannedTables.createHashTable[uniqueKey];
-                if (!hash) {
-                    hash = mergedCreateTable[varName];
-                }
-                if (hash) {
-                    let atomMap;
-                    if (scannedTables.createAtomicMapTable[hash]) {
-                        atomMap = scannedTables.createAtomicMapTable[hash][propName];
-                    }
-                    if (atomMap) {
-                        replacements.push({
-                            start: node.span.start - ast.span.start,
-                            end: node.span.end - ast.span.start,
-                            content: JSON.stringify(atomMap),
-                        });
-                    }
-                }
-                let themeHash = scannedTables.createThemeHashTable[uniqueKey];
-                if (!themeHash) {
-                    themeHash = mergedCreateThemeHashTable[varName];
-                }
-                if (themeHash) {
-                    const atomicMap = scannedTables.createAtomicMapTable[themeHash];
-                    if (atomicMap && atomicMap && atomicMap[propName]) {
-                        replacements.push({
-                            start: node.span.start - ast.span.start,
-                            end: node.span.end - ast.span.start,
-                            content: JSON.stringify(atomicMap[propName]),
-                        });
-                    }
-                }
-                let staticHash = scannedTables.createStaticHashTable[uniqueKey];
-                if (!staticHash) {
-                    staticHash = mergedCreateStaticHashTable[varName];
-                }
-                if (staticHash) {
-                    const staticObj = scannedTables.createStaticObjectTable[staticHash];
-                    if (staticObj && staticObj[propName] !== undefined) {
-                        replacements.push({
-                            start: node.span.start - ast.span.start,
-                            end: node.span.end - ast.span.start,
-                            content: JSON.stringify(staticObj[propName]),
-                        });
-                    }
-                }
-            }
-        },
-        Identifier({ node }) {
-            if (excludedSpans.has(node.span.start))
-                return;
-            if (idSpans.has(node.span.start))
-                return;
-            const styleInfo = localCreateStyles[node.value];
-            if (styleInfo) {
-                if (styleInfo.type === 'variant') {
-                    const hashMap = styleInfo.hashMap;
-                    const independentKeys = Object.keys(hashMap).filter((k) => k !== '_compound');
-                    const compoundGroups = hashMap._compound || [];
-                    const independentChecks = independentKeys
-                        .map((key) => {
-                        const mapObj = hashMap[key];
-                        if (typeof mapObj === 'string') {
-                            return `classes.push("${mapObj}");`;
-                        }
-                        const mapStr = JSON.stringify(mapObj);
-                        return `
-              var v${key} = ${mapStr};
-              if (props["${key}"] && v${key}[props["${key}"]]) {
-                classes.push(v${key}[props["${key}"]]);
-              } else if (v${key}["default"]) {
-                classes.push(v${key}["default"]);
-              }
-            `;
-                    })
-                        .join('\n');
-                    const compoundChecks = compoundGroups
-                        .map((group) => {
-                        const keys = group.keys;
-                        const mapObj = group.map;
-                        const mapStr = JSON.stringify(mapObj);
-                        const keyExpr = keys
-                            .map((k) => `(props["${k}"] || "default")`)
-                            .join(' + ":" + ');
-                        return `
-              var c${keys.join('_')} = ${mapStr};
-              var k = ${keyExpr};
-              if (c${keys.join('_')}[k]) {
-                classes.push(c${keys.join('_')}[k]);
-              }
-            `;
-                    })
-                        .join('\n');
-                    const runtimeFn = `(props) => {
-             var classes = [];
-             ${independentChecks}
-             ${compoundChecks}
-             return classes.join(" ");
-           }`;
-                    replacements.push({
-                        start: node.span.start - ast.span.start,
-                        end: node.span.end - ast.span.start,
-                        content: runtimeFn,
-                    });
-                }
-                else {
-                    replacements.push({
-                        start: node.span.start - ast.span.start,
-                        end: node.span.end - ast.span.start,
-                        content: JSON.stringify(styleInfo.hashMap),
-                    });
-                }
-                return;
-            }
-            const varName = node.value;
-            const uniqueKey = `${resourcePath}-${varName}`;
-            let hash = scannedTables.createHashTable[uniqueKey];
-            if (!hash) {
-                hash = mergedCreateTable[varName];
-            }
-            if (hash) {
-                const obj = scannedTables.createObjectTable[hash];
-                const atomicMap = scannedTables.createAtomicMapTable[hash];
-                if (obj && atomicMap) {
-                    const hashMap = {};
-                    Object.keys(obj).forEach((key) => {
-                        if (atomicMap[key]) {
-                            hashMap[key] = atomicMap[key];
-                        }
-                    });
-                    replacements.push({
-                        start: node.span.start - ast.span.start,
-                        end: node.span.end - ast.span.start,
-                        content: JSON.stringify(hashMap),
-                    });
-                }
-            }
-            let themeHash = scannedTables.createThemeHashTable[uniqueKey];
-            if (!themeHash) {
-                themeHash = mergedCreateThemeHashTable[varName];
-            }
-            if (themeHash) {
-                const atomicMap = scannedTables.createAtomicMapTable[themeHash];
-                if (atomicMap) {
-                    replacements.push({
-                        start: node.span.start - ast.span.start,
-                        end: node.span.end - ast.span.start,
-                        content: JSON.stringify(atomicMap),
-                    });
-                    return;
-                }
-            }
-            let staticHash = scannedTables.createStaticHashTable[uniqueKey];
-            if (!staticHash) {
-                staticHash = mergedCreateStaticHashTable[varName];
-            }
-            if (staticHash) {
-                const staticObj = scannedTables.createStaticObjectTable[staticHash];
-                if (staticObj) {
-                    replacements.push({
-                        start: node.span.start - ast.span.start,
-                        end: node.span.end - ast.span.start,
-                        content: JSON.stringify(staticObj),
-                    });
-                }
-            }
-        },
-        CallExpression({ node }) {
-            const callee = node.callee;
-            let isPropsCall = false;
-            if (utils_1.t.isMemberExpression(callee) &&
-                utils_1.t.isIdentifier(callee.object) &&
-                utils_1.t.isIdentifier(callee.property)) {
-                const objectName = callee.object.value;
-                const propertyName = callee.property.value;
-                const alias = plumeriaAliases[objectName];
-                if ((alias === 'NAMESPACE' || objectName === 'css') &&
-                    propertyName === 'props') {
-                    isPropsCall = true;
-                }
-            }
-            else if (utils_1.t.isIdentifier(callee)) {
-                const calleeName = callee.value;
-                const originalName = plumeriaAliases[calleeName];
-                if (originalName === 'props') {
-                    isPropsCall = true;
-                }
-            }
-            if (isPropsCall) {
-                const args = node.arguments;
-                const resolveStyleObject = (expr) => {
-                    if (utils_1.t.isObjectExpression(expr)) {
-                        return (0, utils_1.objectExpressionToObject)(expr, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
-                    }
-                    else if (utils_1.t.isMemberExpression(expr) &&
-                        utils_1.t.isIdentifier(expr.object) &&
-                        (utils_1.t.isIdentifier(expr.property) ||
-                            expr.property.type === 'Computed')) {
-                        if (expr.property.type === 'Computed') {
-                            return {};
-                        }
-                        const varName = expr.object.value;
-                        const propName = expr.property.value;
-                        const styleInfo = localCreateStyles[varName];
-                        if (styleInfo && styleInfo.obj[propName]) {
-                            const style = styleInfo.obj[propName];
-                            if (typeof style === 'object' && style !== null) {
-                                return style;
-                            }
-                        }
-                        const hash = mergedCreateTable[varName];
-                        if (hash) {
-                            const obj = scannedTables.createObjectTable[hash];
-                            if (obj && obj[propName]) {
-                                const style = obj[propName];
-                                if (typeof style === 'object' && style !== null) {
-                                    return style;
-                                }
-                            }
-                        }
-                    }
-                    else if (utils_1.t.isIdentifier(expr)) {
-                        const varName = expr.value;
-                        const uniqueKey = `${this.resourcePath}-${varName}`;
-                        let hash = scannedTables.createHashTable[uniqueKey];
-                        if (!hash) {
-                            hash = mergedCreateTable[varName];
-                        }
-                        if (hash) {
-                            const obj = scannedTables.createObjectTable[hash];
-                            if (obj && typeof obj === 'object') {
-                                return obj;
-                            }
-                        }
-                        const styleInfo = localCreateStyles[varName];
-                        if (styleInfo && styleInfo.obj) {
-                            return styleInfo.obj;
-                        }
-                        if (localCreateStyles[varName]) {
-                            return localCreateStyles[varName].obj;
-                        }
-                        const vHash = mergedVariantsTable[varName];
-                        if (vHash) {
-                            return scannedTables.variantsObjectTable[vHash];
-                        }
-                    }
-                    return null;
-                };
-                const conditionals = [];
-                let groupIdCounter = 0;
-                let baseStyle = {};
-                let isOptimizable = true;
-                for (const arg of args) {
-                    const expr = arg.expression;
-                    if (utils_1.t.isCallExpression(expr) && utils_1.t.isIdentifier(expr.callee)) {
-                        const varName = expr.callee.value;
-                        let variantObj;
-                        const uniqueKey = `${this.resourcePath}-${varName}`;
-                        let hash = scannedTables.variantsHashTable[uniqueKey];
-                        if (!hash) {
-                            hash = mergedVariantsTable[varName];
-                        }
-                        if (hash && scannedTables.variantsObjectTable[hash]) {
-                            variantObj = scannedTables.variantsObjectTable[hash];
-                        }
-                        if (!variantObj) {
-                            if (localCreateStyles[varName] &&
-                                localCreateStyles[varName].obj) {
-                                variantObj = localCreateStyles[varName].obj;
-                            }
-                        }
-                        if (variantObj) {
-                            const callArgs = expr.arguments;
-                            if (callArgs.length === 1 && !callArgs[0].spread) {
-                                const arg = callArgs[0].expression;
-                                if (arg.type === 'ObjectExpression') {
-                                    for (const prop of arg.properties) {
-                                        let groupName;
-                                        let valExpr;
-                                        if (prop.type === 'KeyValueProperty' &&
-                                            prop.key.type === 'Identifier') {
-                                            groupName = prop.key.value;
-                                            valExpr = prop.value;
-                                        }
-                                        else if (prop.type === 'Identifier') {
-                                            groupName = prop.value;
-                                            valExpr = prop;
-                                        }
-                                        if (groupName && valExpr) {
-                                            const groupVariants = variantObj[groupName];
-                                            if (!groupVariants)
-                                                continue;
-                                            const currentGroupId = ++groupIdCounter;
-                                            const valStart = valExpr.span.start - ast.span.start;
-                                            const valEnd = valExpr.span.end - ast.span.start;
-                                            const valSource = source.substring(valStart, valEnd);
-                                            if (valExpr.type === 'StringLiteral') {
-                                                if (groupVariants[valExpr.value]) {
-                                                    baseStyle = (0, utils_1.deepMerge)(baseStyle, groupVariants[valExpr.value]);
-                                                }
-                                                continue;
-                                            }
-                                            Object.entries(groupVariants).forEach(([optionName, style]) => {
-                                                conditionals.push({
-                                                    test: valExpr,
-                                                    testLHS: valSource,
-                                                    testString: `${valSource} === '${optionName}'`,
-                                                    truthy: style,
-                                                    falsy: {},
-                                                    groupId: currentGroupId,
-                                                    groupName,
-                                                    valueName: optionName,
-                                                    varName,
-                                                });
-                                            });
-                                        }
-                                    }
-                                    continue;
-                                }
-                                const argStart = arg.span.start - ast.span.start;
-                                const argEnd = arg.span.end - ast.span.start;
-                                const argSource = source.substring(argStart, argEnd);
-                                if (utils_1.t.isStringLiteral(arg)) {
-                                    if (variantObj[arg.value]) {
-                                        baseStyle = (0, utils_1.deepMerge)(baseStyle, variantObj[arg.value]);
-                                    }
-                                    continue;
-                                }
-                                const currentGroupId = ++groupIdCounter;
-                                Object.entries(variantObj).forEach(([key, style]) => {
-                                    conditionals.push({
-                                        test: arg,
-                                        testLHS: argSource,
-                                        testString: `${argSource} === '${key}'`,
-                                        truthy: style,
-                                        falsy: {},
-                                        groupId: currentGroupId,
-                                        groupName: undefined,
-                                        valueName: key,
-                                        varName,
-                                    });
-                                });
-                                continue;
-                            }
-                            isOptimizable = false;
-                            break;
-                        }
-                    }
-                    else if (utils_1.t.isIdentifier(expr)) {
-                        const varName = expr.value;
-                        let variantObj;
-                        const uniqueKey = `${this.resourcePath}-${varName}`;
-                        let hash = scannedTables.variantsHashTable[uniqueKey];
-                        if (!hash) {
-                            hash = mergedVariantsTable[varName];
-                        }
-                        if (hash && scannedTables.variantsObjectTable[hash]) {
-                            variantObj = scannedTables.variantsObjectTable[hash];
-                        }
-                        if (!variantObj) {
-                            if (localCreateStyles[varName] &&
-                                localCreateStyles[varName].obj) {
-                                variantObj = localCreateStyles[varName].obj;
-                            }
-                        }
-                        if (variantObj) {
-                            Object.entries(variantObj).forEach(([groupName, groupVariants]) => {
-                                if (!groupVariants)
-                                    return;
-                                const currentGroupId = ++groupIdCounter;
-                                Object.entries(groupVariants).forEach(([optionName, style]) => {
-                                    conditionals.push({
-                                        test: expr,
-                                        testLHS: `props["${groupName}"]`,
-                                        testString: `props["${groupName}"] === '${optionName}'`,
-                                        truthy: style,
-                                        falsy: {},
-                                        groupId: currentGroupId,
-                                        groupName: groupName,
-                                        valueName: optionName,
-                                        varName: varName,
-                                    });
-                                });
-                            });
-                            continue;
-                        }
-                    }
-                    const getSource = (node) => {
-                        const start = node.span.start - ast.span.start;
-                        const end = node.span.end - ast.span.start;
-                        return source.substring(start, end);
-                    };
-                    const collectConditions = (node, currentTestStrings = []) => {
-                        const staticStyle = resolveStyleObject(node);
-                        if (staticStyle) {
-                            if (currentTestStrings.length === 0) {
-                                baseStyle = (0, utils_1.deepMerge)(baseStyle, staticStyle);
-                            }
-                            else {
-                                const combinedTest = currentTestStrings.join(' && ');
-                                conditionals.push({
-                                    test: node,
-                                    testString: combinedTest,
-                                    truthy: staticStyle,
-                                    falsy: {},
-                                    varName: undefined,
-                                });
-                            }
-                            return true;
-                        }
-                        if (node.type === 'ConditionalExpression') {
-                            const testSource = getSource(node.test);
-                            if (currentTestStrings.length === 0) {
-                                const trueStyle = resolveStyleObject(node.consequent);
-                                const falseStyle = resolveStyleObject(node.alternate);
-                                if (trueStyle && falseStyle) {
-                                    conditionals.push({
-                                        test: node,
-                                        testString: testSource,
-                                        truthy: trueStyle,
-                                        falsy: falseStyle,
-                                        varName: undefined,
-                                    });
-                                    return true;
-                                }
-                            }
-                            collectConditions(node.consequent, [
-                                ...currentTestStrings,
-                                `(${testSource})`,
-                            ]);
-                            collectConditions(node.alternate, [
-                                ...currentTestStrings,
-                                `!(${testSource})`,
-                            ]);
-                            return true;
-                        }
-                        else if (node.type === 'BinaryExpression' &&
-                            node.operator === '&&') {
-                            const leftSource = getSource(node.left);
-                            collectConditions(node.right, [
-                                ...currentTestStrings,
-                                `(${leftSource})`,
-                            ]);
-                            return true;
-                        }
-                        else if (node.type === 'ParenthesisExpression') {
-                            return collectConditions(node.expression, currentTestStrings);
-                        }
-                        return false;
-                    };
-                    const handled = collectConditions(expr);
-                    if (handled)
-                        continue;
-                    isOptimizable = false;
-                    break;
-                }
-                if (isOptimizable &&
-                    (args.length > 0 || Object.keys(baseStyle).length > 0)) {
-                    if (conditionals.length === 0) {
-                        if (!isProduction) {
-                            (0, utils_1.extractOndemandStyles)(baseStyle, extractedSheets, scannedTables);
-                        }
-                        const records = (0, utils_1.getStyleRecords)(baseStyle);
-                        if (!isProduction) {
-                            records.forEach((r) => addSheet(r.sheet));
-                        }
-                        const className = records.map((r) => r.hash).join(' ');
-                        replacements.push({
-                            start: node.span.start - ast.span.start,
-                            end: node.span.end - ast.span.start,
-                            content: JSON.stringify(className),
-                        });
-                    }
-                    else {
-                        const propertyCounts = {};
-                        const addCounts = (style) => {
-                            Object.keys(style).forEach((key) => {
-                                propertyCounts[key] = (propertyCounts[key] || 0) + 1;
-                            });
-                        };
-                        addCounts(baseStyle);
-                        const participation = {};
-                        const registerParticipation = (style, sourceId) => {
-                            Object.keys(style).forEach((key) => {
-                                if (!participation[key])
-                                    participation[key] = new Set();
-                                participation[key].add(sourceId);
-                            });
-                        };
-                        registerParticipation(baseStyle, 'base');
-                        conditionals
-                            .filter((c) => c.groupId === undefined)
-                            .forEach((c, idx) => {
-                            const sourceId = `std_${idx}`;
-                            registerParticipation(c.truthy, sourceId);
-                            registerParticipation(c.falsy, sourceId);
-                        });
-                        const variantGroups = {};
-                        conditionals.forEach((c) => {
-                            if (c.groupId !== undefined) {
-                                if (!variantGroups[c.groupId])
-                                    variantGroups[c.groupId] = [];
-                                variantGroups[c.groupId].push(c);
-                            }
-                        });
-                        Object.entries(variantGroups).forEach(([groupId, opts]) => {
-                            const sourceId = `var_${groupId}`;
-                            opts.forEach((opt) => {
-                                registerParticipation(opt.truthy, sourceId);
-                                registerParticipation(opt.falsy, sourceId);
-                            });
-                        });
-                        const conflictingKeys = new Set();
-                        Object.entries(participation).forEach(([key, sources]) => {
-                            if (sources.size > 1) {
-                                conflictingKeys.add(key);
-                            }
-                        });
-                        const baseIndependent = {};
-                        const baseConflict = {};
-                        Object.entries(baseStyle).forEach(([key, val]) => {
-                            if (conflictingKeys.has(key)) {
-                                baseConflict[key] = val;
-                            }
-                            else {
-                                baseIndependent[key] = val;
-                            }
-                        });
-                        const indepConditionals = [];
-                        const conflictConditionals = [];
-                        const splitConditional = (c) => {
-                            const truthyIndep = {};
-                            const truthyConf = {};
-                            const falsyIndep = {};
-                            const falsyConf = {};
-                            let hasIndep = false;
-                            let hasConf = false;
-                            Object.entries(c.truthy).forEach(([k, v]) => {
-                                if (conflictingKeys.has(k)) {
-                                    truthyConf[k] = v;
-                                    hasConf = true;
-                                }
-                                else {
-                                    truthyIndep[k] = v;
-                                    hasIndep = true;
-                                }
-                            });
-                            Object.entries(c.falsy).forEach(([k, v]) => {
-                                if (conflictingKeys.has(k)) {
-                                    falsyConf[k] = v;
-                                    hasConf = true;
-                                }
-                                else {
-                                    falsyIndep[k] = v;
-                                    hasIndep = true;
-                                }
-                            });
-                            if (hasIndep) {
-                                indepConditionals.push({
-                                    ...c,
-                                    truthy: truthyIndep,
-                                    falsy: falsyIndep,
-                                });
-                            }
-                            if (hasConf) {
-                                conflictConditionals.push({
-                                    ...c,
-                                    truthy: truthyConf,
-                                    falsy: falsyConf,
-                                });
-                            }
-                        };
-                        conditionals.forEach(splitConditional);
-                        const classParts = [];
-                        if (Object.keys(baseIndependent).length > 0) {
-                            if (!isProduction) {
-                                (0, utils_1.extractOndemandStyles)(baseIndependent, extractedSheets, scannedTables);
-                            }
-                            const records = (0, utils_1.getStyleRecords)(baseIndependent);
-                            if (!isProduction) {
-                                records.forEach((r) => addSheet(r.sheet));
-                            }
-                            const className = records.map((r) => r.hash).join(' ');
-                            if (className)
-                                classParts.push(JSON.stringify(className));
-                        }
-                        const indepStd = indepConditionals.filter((c) => c.groupId === undefined);
-                        indepStd.forEach((c) => {
-                            const processBranch = (style) => {
-                                if (Object.keys(style).length === 0)
-                                    return '""';
-                                if (!isProduction)
-                                    (0, utils_1.extractOndemandStyles)(style, extractedSheets, scannedTables);
-                                const records = (0, utils_1.getStyleRecords)(style);
-                                if (!isProduction)
-                                    records.forEach((r) => addSheet(r.sheet));
-                                return JSON.stringify(records.map((r) => r.hash).join(' '));
-                            };
-                            const tClass = processBranch(c.truthy);
-                            const fClass = processBranch(c.falsy);
-                            let testStr = c.testString;
-                            if (!testStr && c.test) {
-                                const start = c.test.span.start - ast.span.start;
-                                const end = c.test.span.end - ast.span.start;
-                                testStr = source.substring(start, end);
-                            }
-                            classParts.push(`(${testStr} ? ${tClass} : ${fClass})`);
-                        });
-                        const indepVarGroups = {};
-                        indepConditionals.forEach((c) => {
-                            if (c.groupId !== undefined) {
-                                if (!indepVarGroups[c.groupId])
-                                    indepVarGroups[c.groupId] = [];
-                                indepVarGroups[c.groupId].push(c);
-                            }
-                        });
-                        Object.values(indepVarGroups).forEach((options) => {
-                            let commonTestExpr = null;
-                            const lookupMap = {};
-                            if (options.length > 0) {
-                                if (options[0].testLHS) {
-                                    commonTestExpr = options[0].testLHS;
-                                }
-                                else if (options[0].testString) {
-                                    commonTestExpr = options[0].testString;
-                                }
-                                else {
-                                    const firstTest = options[0].test;
-                                    const firstStart = firstTest.span.start - ast.span.start;
-                                    const firstEnd = firstTest.span.end - ast.span.start;
-                                    commonTestExpr = source.substring(firstStart, firstEnd);
-                                }
-                                options.forEach((opt) => {
-                                    if (opt.valueName && opt.truthy) {
-                                        if (!isProduction)
-                                            (0, utils_1.extractOndemandStyles)(opt.truthy, extractedSheets, scannedTables);
-                                        const records = (0, utils_1.getStyleRecords)(opt.truthy);
-                                        if (!isProduction)
-                                            records.forEach((r) => addSheet(r.sheet));
-                                        const className = records.map((r) => r.hash).join(' ');
-                                        if (className) {
-                                            lookupMap[opt.valueName] = className;
-                                        }
-                                    }
-                                });
-                            }
-                            if (commonTestExpr && Object.keys(lookupMap).length > 0) {
-                                const entries = Object.entries(lookupMap)
-                                    .map(([key, val]) => `"${key}":"${val}"`)
-                                    .join(',');
-                                classParts.push(`({${entries}}[${commonTestExpr}] || "")`);
-                            }
-                        });
-                        if (Object.keys(baseConflict).length > 0 ||
-                            conflictConditionals.length > 0) {
-                            const conflictStd = conflictConditionals.filter((c) => c.groupId === undefined);
-                            const conflictVarGroups = {};
-                            conflictConditionals.forEach((c) => {
-                                if (c.groupId !== undefined) {
-                                    if (!conflictVarGroups[c.groupId])
-                                        conflictVarGroups[c.groupId] = [];
-                                    conflictVarGroups[c.groupId].push(c);
-                                }
-                            });
-                            const dimensions = [];
-                            conflictStd.forEach((c) => {
-                                let testStr = c.testString;
-                                if (!testStr && c.test) {
-                                    const start = c.test.span.start - ast.span.start;
-                                    const end = c.test.span.end - ast.span.start;
-                                    testStr = source.substring(start, end);
-                                }
-                                dimensions.push({
-                                    type: 'std',
-                                    testExpr: testStr,
-                                    options: [
-                                        { value: 0, style: c.falsy, label: 'false' },
-                                        { value: 1, style: c.truthy, label: 'true' },
-                                    ],
-                                });
-                            });
-                            Object.entries(conflictVarGroups).forEach(([_groupId, opts]) => {
-                                let commonTestExpr = null;
-                                if (opts.length > 0) {
-                                    if (opts[0].testLHS) {
-                                        commonTestExpr = opts[0].testLHS;
-                                    }
-                                    else if (opts[0].testString) {
-                                        commonTestExpr = opts[0].testString;
-                                    }
-                                    else {
-                                        const firstTest = opts[0].test;
-                                        const firstStart = firstTest.span.start - ast.span.start;
-                                        const firstEnd = firstTest.span.end - ast.span.start;
-                                        commonTestExpr = source.substring(firstStart, firstEnd);
-                                    }
-                                }
-                                const options = opts.map((opt) => ({
-                                    value: opt.valueName,
-                                    style: opt.truthy,
-                                    label: opt.valueName || 'default',
-                                }));
-                                dimensions.push({
-                                    type: 'var',
-                                    testExpr: commonTestExpr || '""',
-                                    options: options,
-                                });
-                            });
-                            const results = {};
-                            const recurse = (dimIndex, currentStyle, keyParts) => {
-                                if (dimIndex >= dimensions.length) {
-                                    if (!isProduction)
-                                        (0, utils_1.extractOndemandStyles)(currentStyle, extractedSheets, scannedTables);
-                                    const records = (0, utils_1.getStyleRecords)(currentStyle);
-                                    if (!isProduction)
-                                        records.forEach((r) => addSheet(r.sheet));
-                                    const className = records.map((r) => r.hash).join(' ');
-                                    const finalKey = keyParts.join('__');
-                                    if (className)
-                                        results[finalKey] = className;
-                                    return;
-                                }
-                                const dim = dimensions[dimIndex];
-                                dim.options.forEach((opt) => {
-                                    const nextStyle = (0, utils_1.deepMerge)(currentStyle, opt.style);
-                                    recurse(dimIndex + 1, nextStyle, [
-                                        ...keyParts,
-                                        String(opt.value),
-                                    ]);
-                                });
-                            };
-                            recurse(0, baseConflict, []);
-                            let baseConflictClass = '';
-                            if (Object.keys(baseConflict).length > 0) {
-                                if (!isProduction)
-                                    (0, utils_1.extractOndemandStyles)(baseConflict, extractedSheets, scannedTables);
-                                const records = (0, utils_1.getStyleRecords)(baseConflict);
-                                if (!isProduction)
-                                    records.forEach((r) => addSheet(r.sheet));
-                                baseConflictClass = records.map((r) => r.hash).join(' ');
-                            }
-                            const keyExprs = [];
-                            dimensions.forEach((dim) => {
-                                if (dim.type === 'std') {
-                                    keyExprs.push(`(${dim.testExpr} ? "1" : "0")`);
-                                }
-                                else {
-                                    keyExprs.push(dim.testExpr || '""');
-                                }
-                            });
-                            const masterKeyExpr = keyExprs.length > 0 ? keyExprs.join(' + "__" + ') : '""';
-                            const tableJson = JSON.stringify(results);
-                            const fallback = baseConflictClass
-                                ? JSON.stringify(baseConflictClass)
-                                : '""';
-                            classParts.push(`(${tableJson}[${masterKeyExpr}] || ${fallback})`);
-                        }
-                        const replacement = classParts.length > 0 ? classParts.join(' + " " + ') : '""';
-                        replacements.push({
-                            start: node.span.start - ast.span.start,
-                            end: node.span.end - ast.span.start,
-                            content: replacement,
-                        });
-                    }
-                }
-            }
-        },
-    });
-    Object.values(localCreateStyles).forEach((info) => {
-        if (info.type === 'constant') {
-            return;
-        }
-        if (info.isExported) {
-            replacements.push({
-                start: info.declSpan.start,
-                end: info.declSpan.end,
-                content: JSON.stringify(''),
-            });
-        }
-        else {
-            replacements.push({
-                start: info.declSpan.start,
-                end: info.declSpan.end,
-                content: '',
-            });
-        }
-    });
-    const optInCSS = await (0, utils_1.optimizer)(extractedSheets.join(''));
-    const buffer = Buffer.from(source);
-    let offset = 0;
-    const parts = [];
-    replacements
-        .sort((a, b) => a.start - b.start || b.end - a.end)
-        .forEach((r) => {
-        if (r.start < offset)
-            return;
-        parts.push(buffer.subarray(offset, r.start));
-        parts.push(Buffer.from(r.content));
-        offset = r.end;
-    });
-    parts.push(buffer.subarray(offset));
-    const transformedSource = Buffer.concat(parts).toString();
-    const VIRTUAL_CSS_PATH = require.resolve(VIRTUAL_FILE_PATH);
-    function stringifyRequest(loaderContext, request) {
-        const context = loaderContext.context || loaderContext.rootContext;
-        const relativePath = path_1.default.relative(context, request);
-        const requestPath = relativePath.startsWith('.')
-            ? relativePath
-            : './' + relativePath;
-        return JSON.stringify(requestPath);
-    }
-    const virtualCssRequest = stringifyRequest(this, `${VIRTUAL_CSS_PATH}`);
-    const postfix = `\nimport ${virtualCssRequest};`;
-    const css = (0, fs_1.readFileSync)(VIRTUAL_FILE_PATH, 'utf-8');
-    function generateOrderedCSS(styles) {
-        const sections = [];
-        if (styles.keyframeStyles?.trim()) {
-            if (!css.includes(styles.keyframeStyles))
-                sections.push(styles.keyframeStyles);
-        }
-        if (styles.viewTransitionStyles?.trim()) {
-            if (!css.includes(styles.viewTransitionStyles))
-                sections.push(styles.viewTransitionStyles);
-        }
-        if (styles.themeStyles?.trim()) {
-            if (!css.includes(styles.themeStyles))
-                sections.push(styles.themeStyles);
-        }
-        if (styles.baseStyles?.trim()) {
-            sections.push(styles.baseStyles);
-        }
-        return sections.join('\n');
-    }
-    const orderedCSS = await (0, utils_1.optimizer)(generateOrderedCSS(fileStyles));
-    const relativeId = path_1.default.relative(process.cwd(), this.resourcePath);
-    const hmrCode = `
-    if (module.hot) {
-      module.hot.accept(${virtualCssRequest});
-
-      const styleId = "plumeria-hmr";
-      const fileKey = ${JSON.stringify(relativeId)};
-      
-      let styleEl = document.getElementById(styleId);
-      
-      if (!styleEl) {
-        styleEl = document.createElement("style");
-        styleEl.id = styleId;
-        document.head.prepend(styleEl);
-        styleEl.__plumeriaStyles = {};
-      }
-
-      styleEl.__plumeriaStyles[fileKey] = ${JSON.stringify(orderedCSS)};
-      styleEl.textContent = Object.values(styleEl.__plumeriaStyles).join('\\n');
-
-      module.hot.dispose(() => {
-        if (styleEl && styleEl.__plumeriaStyles) {
-          delete styleEl.__plumeriaStyles[fileKey];
-          styleEl.textContent = Object.values(styleEl.__plumeriaStyles).join('\\n');
-          
-          if (Object.keys(styleEl.__plumeriaStyles).length === 0 && styleEl.parentNode) {
-            styleEl.parentNode.removeChild(styleEl);
-          }
-        }
-      });
-    }
-  `;
-    if (extractedSheets.length > 0 && process.env.NODE_ENV === 'development') {
-        (0, fs_1.appendFileSync)(VIRTUAL_FILE_PATH, optInCSS, 'utf-8');
-    }
-    const useClientDirective = /^\s*['"]use client['"]/;
-    if (process.env.NODE_ENV === 'production')
-        return callback(null, transformedSource);
-    if (!useClientDirective.test(source)) {
-        callback(null, transformedSource + postfix);
-        return;
-    }
-    else {
-        callback(null, transformedSource + hmrCode);
-    }
-}
+const turbopack_loader_1 = __importDefault(require("@plumeria/turbopack-loader"));
+exports.default = turbopack_loader_1.default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/webpack-plugin",
-  "version": "7.1.2",
+  "version": "7.2.1",
   "description": "Plumeria Webpack plugin",
   "author": "Refirst 11",
   "license": "MIT",
@@ -18,16 +18,10 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist/",
-    "zero-virtual.css"
+    "dist/"
   ],
   "dependencies": {
-    "@plumeria/utils": "^7.1.2"
-  },
-  "devDependencies": {
-    "@swc/core": "1.15.8",
-    "webpack": "5.101.0",
-    "zss-engine": "2.2.4"
+    "@plumeria/turbopack-loader": "^7.2.1"
   },
   "publishConfig": {
     "access": "public",

package/zero-virtual.css

@@ -1 +0,0 @@
-/** Placeholder file */