@mintlify/common 1.0.1258 → 1.0.1260

package/dist/mdx/plugins/rehype/rehypeDynamicTailwindCss.js

@@ -2,93 +2,906 @@ import { walk } from 'estree-walker';
 import { visit } from 'unist-util-visit';
 import { segment } from './segment.js';
 export const MINTLIFY_TAILWIND_PREFIX = 'mint-';
+const CLASS_HELPERS = new Set(['cn', 'clsx', 'classNames', 'classnames', 'twMerge', 'twJoin']);
+const NON_MUTATING_METHODS = new Set([
+    'at',
+    'charAt',
+    'concat',
+    'endsWith',
+    'includes',
+    'indexOf',
+    'join',
+    'lastIndexOf',
+    'padEnd',
+    'padStart',
+    'repeat',
+    'slice',
+    'split',
+    'startsWith',
+    'toLowerCase',
+    'toString',
+    'toUpperCase',
+    'trim',
+    'trimEnd',
+    'trimStart',
+]);
+const IMMUTABLE_GLOBALS = new Set(['undefined', 'NaN', 'Infinity']);
+const MAX_INLINE_DEPTH = 32;
+const MAX_NODES_PER_INLINE = 1000;
+const MAX_INLINED_NODES_PER_PAGE = 20000;
 export const rehypeDynamicTailwindCss = (tailwindSelectors) => (tree) => {
     const normalizedTailwindSelectors = tailwindSelectors === null || tailwindSelectors === void 0 ? void 0 : tailwindSelectors.map(normalizeSelector);
+    if (!(normalizedTailwindSelectors === null || normalizedTailwindSelectors === void 0 ? void 0 : normalizedTailwindSelectors.length))
+        return;
+    const moduleScope = new Map();
+    const moduleScopes = [moduleScope];
+    const scopeByNode = new Map();
+    const aliases = [];
+    visit(tree, (node) => {
+        if (node.type === 'mdxjsEsm' && node.data && node.data.estree) {
+            collectDeclarations(node.data.estree.body, moduleScope, moduleScopes);
+            collectVarNames(node.data.estree).forEach((name) => moduleScope.set(name, createBinding(moduleScopes)));
+        }
+    });
+    const estrees = [];
+    visit(tree, (node) => {
+        var _a;
+        if (node.type === 'mdxjsEsm' ||
+            node.type === 'mdxFlowExpression' ||
+            node.type === 'mdxTextExpression') {
+            if ((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree)
+                estrees.push(node.data.estree);
+        }
+        else if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+            node.attributes.forEach((attr) => {
+                var _a, _b;
+                const estree = attr.type === 'mdxJsxExpressionAttribute'
+                    ? (_a = attr.data) === null || _a === void 0 ? void 0 : _a.estree
+                    : attr.value && typeof attr.value !== 'string'
+                        ? (_b = attr.value.data) === null || _b === void 0 ? void 0 : _b.estree
+                        : undefined;
+                if (estree)
+                    estrees.push(estree);
+            });
+        }
+    });
+    estrees.forEach((estree) => analyzeProgram(estree, moduleScopes, scopeByNode, aliases));
+    propagateMutations(aliases);
+    const context = {
+        tailwindSelectors: normalizedTailwindSelectors,
+        changes: { count: 0 },
+        pageBudget: { remaining: MAX_INLINED_NODES_PER_PAGE },
+        inlineDepth: 0,
+    };
     visit(tree, (node) => {
+        var _a;
         if ((node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') &&
             node.name &&
             typeof node.name === 'string' &&
             node.attributes.length > 0) {
-            const className = node.attributes.find((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'className');
-            if (className && typeof className.value === 'string') {
-                className.value = transformClassNames(className.value, normalizedTailwindSelectors);
+            const className = node.attributes.find((attr) => attr.type === 'mdxJsxAttribute' && (attr.name === 'className' || attr.name === 'class'));
+            const value = className === null || className === void 0 ? void 0 : className.value;
+            if (className && typeof value === 'string') {
+                className.value = transformClassNames(value, normalizedTailwindSelectors);
+            }
+            else if (value && typeof value !== 'string' && ((_a = value.data) === null || _a === void 0 ? void 0 : _a.estree)) {
+                // example: <div className={isActive ? "bg-red-500" : "bg-blue-500"}>
+                const [statement] = value.data.estree.body;
+                if (statement && statement.type === 'ExpressionStatement') {
+                    statement.expression = transformExpressionClassNames(statement.expression, moduleScopes, context);
+                }
             }
         }
         if (node.type === 'mdxjsEsm' && node.data && node.data.estree) {
-            transformMdxJsEsmNode(node.data.estree, normalizedTailwindSelectors);
+            transformMdxJsEsmNode(node.data.estree, moduleScopes, scopeByNode, context);
         }
     });
 };
-const transformMdxJsEsmNode = (estreeNode, tailwindSelectors) => {
-    walk(estreeNode, {
+const createBinding = (scopes, init) => ({
+    init,
+    scopes,
+    reassigned: false,
+    mutated: false,
+    aliasOf: [],
+});
+const collectDeclarations = (statements, scope, scopes) => {
+    for (const statement of statements) {
+        if (statement.type === 'ImportDeclaration') {
+            statement.specifiers.forEach((specifier) => scope.set(specifier.local.name, createBinding(scopes)));
+            continue;
+        }
+        const declaration = statement.type === 'ExportNamedDeclaration' || statement.type === 'ExportDefaultDeclaration'
+            ? statement.declaration
+            : statement;
+        if (!declaration)
+            continue;
+        if ((declaration.type === 'FunctionDeclaration' || declaration.type === 'ClassDeclaration') &&
+            declaration.id) {
+            scope.set(declaration.id.name, createBinding(scopes));
+        }
+        if (declaration.type !== 'VariableDeclaration' || declaration.kind === 'var')
+            continue;
+        for (const declarator of declaration.declarations) {
+            if (declaration.kind === 'const' && declarator.id.type === 'Identifier' && declarator.init) {
+                scope.set(declarator.id.name, createBinding(scopes, declarator.init));
+            }
+            else {
+                getPatternNames(declarator.id).forEach((name) => scope.set(name, createBinding(scopes)));
+            }
+        }
+    }
+};
+const collectVarNames = (root) => {
+    const names = [];
+    walk(root, {
         enter(node) {
-            if (node.type === 'JSXAttribute' &&
-                node.name.type === 'JSXIdentifier' &&
-                (node.name.name === 'className' || node.name.name === 'class')) {
-                if (node.value && node.value.type === 'JSXExpressionContainer') {
-                    const expression = node.value.expression;
-                    if (expression.type === 'TemplateLiteral') {
-                        // example: className={`bg-green-500`}
-                        expression.quasis.forEach((quasi) => {
-                            if (quasi.value.cooked) {
-                                const originalValue = quasi.value.cooked;
-                                const transformedValue = transformClassNames(originalValue, tailwindSelectors);
-                                if (originalValue !== transformedValue) {
-                                    quasi.value.cooked = transformedValue;
-                                    quasi.value.raw = transformedValue;
-                                }
-                            }
-                        });
-                        // example: className={`${isActive ? "bg-red-500" : "bg-blue-500"}`}
-                        expression.expressions.forEach((expr) => {
-                            transformExpressionClassNames(expr, tailwindSelectors);
-                        });
+            if (node !== root && isFunctionNode(node)) {
+                this.skip();
+                return;
+            }
+            if (node.type === 'VariableDeclaration' && node.kind === 'var') {
+                node.declarations.forEach((declarator) => names.push(...getPatternNames(declarator.id)));
+            }
+        },
+    });
+    return names;
+};
+const getPatternNames = (pattern) => getPatternIdentifiers(pattern).map((identifier) => identifier.name);
+const getPatternIdentifiers = (pattern) => {
+    switch (pattern.type) {
+        case 'Identifier':
+            return [pattern];
+        case 'AssignmentPattern':
+            return getPatternIdentifiers(pattern.left);
+        case 'RestElement':
+            return getPatternIdentifiers(pattern.argument);
+        case 'ArrayPattern':
+            return pattern.elements.flatMap((element) => (element ? getPatternIdentifiers(element) : []));
+        case 'ObjectPattern':
+            return pattern.properties.flatMap((property) => getPatternIdentifiers(property.type === 'Property' ? property.value : property));
+        default:
+            return [];
+    }
+};
+const resolveBinding = (name, scopes) => {
+    var _a;
+    for (let i = scopes.length - 1; i >= 0; i--) {
+        const binding = (_a = scopes[i]) === null || _a === void 0 ? void 0 : _a.get(name);
+        if (binding)
+            return binding;
+    }
+    return undefined;
+};
+const isFunctionNode = (node) => node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'ArrowFunctionExpression';
+const isClassAttribute = (node) => node.name.type === 'JSXIdentifier' &&
+    (node.name.name === 'className' || node.name.name === 'class');
+const createScope = (node, scopes) => {
+    var _a;
+    const scope = new Map();
+    const chain = [...scopes, scope];
+    const declare = (name) => scope.set(name, createBinding(chain));
+    if (isFunctionNode(node)) {
+        if (node.type === 'FunctionExpression' && node.id)
+            declare(node.id.name);
+        node.params.flatMap(getPatternNames).forEach(declare);
+        collectVarNames(node.body).forEach(declare);
+        return scope;
+    }
+    switch (node.type) {
+        case 'BlockStatement':
+        case 'StaticBlock':
+            collectDeclarations(node.body, scope, chain);
+            return scope;
+        case 'SwitchStatement':
+            collectDeclarations(node.cases.flatMap((switchCase) => switchCase.consequent), scope, chain);
+            return scope;
+        case 'ForStatement':
+            if (((_a = node.init) === null || _a === void 0 ? void 0 : _a.type) === 'VariableDeclaration' && node.init.kind !== 'var') {
+                node.init.declarations.forEach((declarator) => getPatternNames(declarator.id).forEach(declare));
+            }
+            return scope;
+        case 'ForInStatement':
+        case 'ForOfStatement':
+            if (node.left.type === 'VariableDeclaration' && node.left.kind !== 'var') {
+                node.left.declarations.forEach((declarator) => getPatternNames(declarator.id).forEach(declare));
+            }
+            return scope;
+        case 'CatchClause':
+            if (node.param)
+                getPatternNames(node.param).forEach(declare);
+            return scope;
+        case 'ClassExpression':
+            if (node.id)
+                declare(node.id.name);
+            return scope;
+        default:
+            return undefined;
+    }
+};
+const propagateMutations = (aliases) => {
+    var _a;
+    const links = new Map();
+    const link = (from, to) => {
+        const targets = links.get(from);
+        if (targets)
+            targets.push(to);
+        else
+            links.set(from, [to]);
+    };
+    aliases.forEach((alias) => alias.aliasOf.forEach((source) => {
+        link(alias, source);
+        link(source, alias);
+    }));
+    const pending = [...links.keys()].filter((binding) => binding.mutated);
+    for (let current = pending.pop(); current; current = pending.pop()) {
+        for (const next of (_a = links.get(current)) !== null && _a !== void 0 ? _a : []) {
+            if (next.mutated)
+                continue;
+            next.mutated = true;
+            pending.push(next);
+        }
+    }
+};
+const analyzeProgram = (program, baseScopes, scopeByNode, aliases) => {
+    const scopes = [...baseScopes];
+    const ancestors = [];
+    const declaredIdentifiers = new Set();
+    const writtenIdentifiers = new Set();
+    const declare = (pattern) => pattern && getPatternIdentifiers(pattern).forEach((id) => declaredIdentifiers.add(id));
+    const write = (pattern) => getPatternIdentifiers(pattern).forEach((id) => writtenIdentifiers.add(id));
+    walk(program, {
+        enter(node, parent, key) {
+            const scope = createScope(node, scopes);
+            if (scope) {
+                scopes.push(scope);
+                scopeByNode.set(node, scope);
+            }
+            if (isFunctionNode(node)) {
+                if (node.type !== 'ArrowFunctionExpression')
+                    declare(node.id);
+                node.params.forEach(declare);
+            }
+            else if (node.type === 'VariableDeclarator') {
+                declare(node.id);
+                if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'VariableDeclaration' && parent.kind === 'var') {
+                    getPatternNames(node.id).forEach((name) => {
+                        const binding = resolveBinding(name, scopes);
+                        if (binding)
+                            binding.reassigned = true;
+                    });
+                }
+            }
+            else if (node.type === 'CatchClause') {
+                declare(node.param);
+            }
+            else if ((node.type === 'ClassDeclaration' || node.type === 'ClassExpression') && node.id) {
+                declare(node.id);
+            }
+            else if (node.type === 'ImportDeclaration') {
+                node.specifiers.forEach((specifier) => declare(specifier.local));
+            }
+            else if (node.type === 'AssignmentExpression') {
+                write(node.left);
+            }
+            else if (node.type === 'UpdateExpression' && node.argument.type === 'Identifier') {
+                writtenIdentifiers.add(node.argument);
+            }
+            else if ((node.type === 'ForInStatement' || node.type === 'ForOfStatement') &&
+                node.left.type !== 'VariableDeclaration') {
+                write(node.left);
+            }
+            if (node.type === 'Identifier' && !declaredIdentifiers.has(node)) {
+                const binding = resolveBinding(node.name, scopes);
+                if (writtenIdentifiers.has(node)) {
+                    if (binding)
+                        binding.reassigned = true;
+                }
+                else if (parent && isReferencePosition(parent, key)) {
+                    const usage = classifyReference(node, ancestors, scopes);
+                    if (usage === 'mutates') {
+                        if (binding)
+                            binding.mutated = true;
+                    }
+                    else if (usage !== 'reads' && binding) {
+                        usage.aliasOf.push(binding);
+                        aliases.push(usage);
                     }
                 }
+            }
+            ancestors.push(node);
+        },
+        leave(node) {
+            ancestors.pop();
+            if (scopeByNode.has(node) && scopes[scopes.length - 1] === scopeByNode.get(node)) {
+                scopes.pop();
+            }
+        },
+    });
+};
+const isReferencePosition = (parent, key) => {
+    switch (parent.type) {
+        case 'MemberExpression':
+            return key !== 'property' || parent.computed;
+        case 'Property':
+        case 'MethodDefinition':
+        case 'PropertyDefinition':
+            return key !== 'key' || parent.computed;
+        case 'LabeledStatement':
+        case 'BreakStatement':
+        case 'ContinueStatement':
+        case 'MetaProperty':
+            return false;
+        case 'ExportSpecifier':
+            return key === 'local';
+        case 'ImportSpecifier':
+            return false;
+        default:
+            return true;
+    }
+};
+const classifyReference = (node, ancestors, scopes) => {
+    var _a;
+    let child = node;
+    for (let i = ancestors.length - 1; i >= 0; i--) {
+        const parent = ancestors[i];
+        if (!parent)
+            break;
+        switch (parent.type) {
+            case 'MemberExpression':
+                if (parent.object !== child)
+                    return 'reads';
+                child = parent;
+                continue;
+            case 'ChainExpression':
+            case 'AwaitExpression':
+            case 'LogicalExpression':
+                child = parent;
+                continue;
+            case 'ConditionalExpression':
+                if (parent.test === child)
+                    return 'reads';
+                child = parent;
+                continue;
+            case 'SequenceExpression':
+                if (parent.expressions[parent.expressions.length - 1] !== child)
+                    return 'reads';
+                child = parent;
+                continue;
+            case 'CallExpression':
+            case 'NewExpression':
+                if (parent.callee === child) {
+                    if (child.type !== 'MemberExpression')
+                        return 'reads';
+                    return !child.computed &&
+                        child.property.type === 'Identifier' &&
+                        NON_MUTATING_METHODS.has(child.property.name)
+                        ? 'reads'
+                        : 'mutates';
+                }
+                return parent.type === 'CallExpression' &&
+                    parent.callee.type === 'Identifier' &&
+                    CLASS_HELPERS.has(parent.callee.name)
+                    ? 'reads'
+                    : 'mutates';
+            case 'SpreadElement':
+            case 'ArrayExpression':
+            case 'ObjectExpression':
+                child = parent;
+                continue;
+            case 'Property':
+                if (parent.value !== child)
+                    return 'reads';
+                child = parent;
+                continue;
+            case 'TemplateLiteral':
+            case 'BinaryExpression':
+            case 'TaggedTemplateExpression':
+            case 'IfStatement':
+            case 'WhileStatement':
+            case 'DoWhileStatement':
+            case 'SwitchStatement':
+            case 'SwitchCase':
+                return 'reads';
+            case 'UnaryExpression':
+                return parent.operator === 'delete' ? 'mutates' : 'reads';
+            case 'ExpressionStatement':
+            case 'JSXExpressionContainer':
+            case 'JSXSpreadAttribute':
+                return 'reads';
+            case 'VariableDeclarator': {
+                const declaration = ancestors[i - 1];
+                if (parent.init === child &&
+                    parent.id.type === 'Identifier' &&
+                    (declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'VariableDeclaration' &&
+                    declaration.kind === 'const') {
+                    return (_a = resolveBinding(parent.id.name, scopes)) !== null && _a !== void 0 ? _a : 'mutates';
+                }
+                return 'mutates';
+            }
+            default:
+                return 'mutates';
+        }
+    }
+    return 'reads';
+};
+const transformMdxJsEsmNode = (estreeNode, moduleScopes, scopeByNode, context) => {
+    const scopes = [...moduleScopes];
+    walk(estreeNode, {
+        enter(node) {
+            const scope = scopeByNode.get(node);
+            if (scope)
+                scopes.push(scope);
+            if (node.type === 'JSXAttribute' && isClassAttribute(node)) {
                 // example: className="bg-green-500"
-                if (node.value && node.value.type === 'Literal' && typeof node.value.value === 'string') {
-                    const originalValue = node.value.value;
-                    const transformedValue = transformClassNames(originalValue, tailwindSelectors);
-                    if (originalValue !== transformedValue) {
-                        node.value.value = transformedValue;
-                        if (typeof node.value.raw === 'string') {
-                            node.value.raw = JSON.stringify(transformedValue);
-                        }
-                    }
+                if (node.value && node.value.type === 'Literal') {
+                    transformLiteral(node.value, context);
+                }
+                if (node.value &&
+                    node.value.type === 'JSXExpressionContainer' &&
+                    node.value.expression.type !== 'JSXEmptyExpression') {
+                    node.value.expression = transformExpressionClassNames(node.value.expression, scopes, context);
                 }
             }
         },
+        leave(node) {
+            if (scopeByNode.has(node))
+                scopes.pop();
+        },
     });
 };
-const transformExpressionClassNames = (expr, tailwindSelectors) => {
-    if (!expr)
-        return;
-    if (expr.type === 'Literal' && typeof expr.value === 'string') {
-        const originalValue = expr.value;
-        const transformedValue = transformClassNames(originalValue, tailwindSelectors);
-        if (originalValue !== transformedValue) {
-            expr.value = transformedValue;
-            if (typeof expr.raw === 'string') {
-                expr.raw = JSON.stringify(transformedValue);
+const transformExpressionClassNames = (expr, scopes, context, inlining = new Set(), structural = false) => {
+    const transform = (child) => transformExpressionClassNames(child, scopes, context, inlining);
+    const transformStructural = (child) => transformExpressionClassNames(child, scopes, context, inlining, true);
+    const transformElement = (element) => {
+        if (element.type !== 'SpreadElement')
+            return transform(element);
+        element.argument = transformStructural(element.argument);
+        return element;
+    };
+    switch (expr.type) {
+        case 'Literal':
+            transformLiteral(expr, context);
+            return expr;
+        case 'TemplateLiteral':
+            // example: className={`bg-green-500`}
+            expr.quasis.forEach((quasi) => {
+                if (quasi.value.cooked) {
+                    const transformedValue = transformClassNames(quasi.value.cooked, context.tailwindSelectors);
+                    if (quasi.value.cooked !== transformedValue) {
+                        quasi.value.cooked = transformedValue;
+                        quasi.value.raw = transformedValue;
+                        context.changes.count++;
+                    }
+                }
+            });
+            // example: className={`${isActive ? "bg-red-500" : "bg-blue-500"}`}
+            expr.expressions = expr.expressions.map(transform);
+            return expr;
+        case 'ConditionalExpression':
+            // example: ${isActive ? "bg-red-500" : "bg-blue-500"}
+            expr.consequent = (structural ? transformStructural : transform)(expr.consequent);
+            expr.alternate = (structural ? transformStructural : transform)(expr.alternate);
+            return expr;
+        case 'LogicalExpression':
+            // example: ${isActive && "bg-red-500"}
+            expr.left = (structural ? transformStructural : transform)(expr.left);
+            expr.right = (structural ? transformStructural : transform)(expr.right);
+            return expr;
+        case 'BinaryExpression':
+            if (expr.operator === '+') {
+                // example: ${"bg-red-500" + "bg-blue-500"}
+                expr.left = transform(expr.left);
+                expr.right = transform(expr.right);
+            }
+            return expr;
+        case 'ArrayExpression':
+            // example: ["bg-red-500", "bg-blue-500"]
+            expr.elements = expr.elements.map((element) => element && transformElement(element));
+            return expr;
+        case 'CallExpression':
+            if (!isClassCall(expr))
+                return expr;
+            // example: ["bg-red-500", "bg-blue-500"].join(" ")
+            if (expr.callee.type === 'MemberExpression' && expr.callee.object.type !== 'Super') {
+                expr.callee.object = transformStructural(expr.callee.object);
+                expr.arguments = expr.arguments.map(transformElement);
             }
+            else {
+                expr.arguments = expr.arguments.map((argument) => argument.type === 'SpreadElement'
+                    ? transformElement(argument)
+                    : transformStructural(argument));
+            }
+            return expr;
+        case 'ObjectExpression':
+            // example: cn({ "bg-blue-500": isActive })
+            transformObjectKeys(expr, transform, transformStructural, context);
+            return expr;
+        case 'MemberExpression':
+            // example: const styles = { active: "bg-red-500" }; className={styles.active}
+            return transformMemberExpression(expr, scopes, transform, context);
+        case 'Identifier': {
+            // example: const classes = "bg-red-500"; className={classes}
+            const binding = resolveBinding(expr.name, scopes);
+            if (!binding || inlining.has(binding))
+                return expr;
+            const inlined = cloneForUse(expr, scopes, scopes, createCloneState(context), structural);
+            if (!inlined || inlined.type === 'Identifier')
+                return expr;
+            const nextInlining = new Set([...inlining, binding]);
+            return applyIfChanged(expr, inlined, (child) => transformExpressionClassNames(child, scopes, context, nextInlining), context);
         }
+        default:
+            return expr;
     }
-    else if (expr.type === 'ConditionalExpression') {
-        // example: ${isActive ? "bg-red-500" : "bg-blue-500"}
-        transformExpressionClassNames(expr.consequent, tailwindSelectors);
-        transformExpressionClassNames(expr.alternate, tailwindSelectors);
+};
+const createCloneState = (context) => ({
+    inlining: new Set(),
+    local: { remaining: MAX_NODES_PER_INLINE },
+    page: context.pageBudget,
+});
+const applyIfChanged = (original, replacement, transform, context) => {
+    if (context.inlineDepth >= MAX_INLINE_DEPTH)
+        return original;
+    context.inlineDepth++;
+    const before = context.changes.count;
+    const transformed = transform(replacement);
+    context.inlineDepth--;
+    return context.changes.count === before ? original : transformed;
+};
+const transformMemberExpression = (expr, scopes, transform, context) => {
+    if (getStaticKey(expr) !== undefined) {
+        const resolved = resolveStaticValue(expr, scopes);
+        const inlined = resolved && cloneForUse(resolved.expr, resolved.scopes, scopes, createCloneState(context));
+        return inlined ? applyIfChanged(expr, inlined, transform, context) : expr;
     }
-    else if (expr.type === 'LogicalExpression') {
-        // example: ${isActive && "bg-red-500"}
-        transformExpressionClassNames(expr.left, tailwindSelectors);
-        transformExpressionClassNames(expr.right, tailwindSelectors);
+    const object = resolveObject(expr.object, scopes, context);
+    if (!object)
+        return expr;
+    const before = context.changes.count;
+    object.properties.forEach((property) => {
+        const value = property.type === 'Property' ? asExpression(property.value) : undefined;
+        if (property.type === 'Property' && value)
+            property.value = transform(value);
+    });
+    if (context.changes.count !== before)
+        expr.object = object;
+    return expr;
+};
+const transformObjectKeys = (expr, transform, transformStructural, context) => {
+    expr.properties.forEach((property) => {
+        if (property.type === 'SpreadElement') {
+            property.argument = transformStructural(property.argument);
+            return;
+        }
+        if (property.computed) {
+            if (property.key.type !== 'PrivateIdentifier')
+                property.key = transform(property.key);
+            return;
+        }
+        const keyName = getPropertyKeyName(property);
+        if (keyName === undefined)
+            return;
+        const transformedValue = transformClassNames(keyName, context.tailwindSelectors);
+        if (keyName !== transformedValue) {
+            property.key = toLiteral(transformedValue);
+            property.shorthand = false;
+            context.changes.count++;
+        }
+    });
+};
+const resolveObject = (node, scopes, context) => {
+    if (node.type === 'ObjectExpression')
+        return node;
+    const resolved = resolveStaticValue(node, scopes);
+    if ((resolved === null || resolved === void 0 ? void 0 : resolved.expr.type) !== 'ObjectExpression')
+        return undefined;
+    const cloned = cloneForUse(resolved.expr, resolved.scopes, scopes, createCloneState(context));
+    return (cloned === null || cloned === void 0 ? void 0 : cloned.type) === 'ObjectExpression' ? cloned : undefined;
+};
+const resolveStaticValue = (node, scopes, resolving = new Set(), depth = 0) => {
+    if (node.type === 'Super' || depth >= MAX_INLINE_DEPTH)
+        return undefined;
+    if (node.type === 'Identifier') {
+        const binding = resolveBinding(node.name, scopes);
+        if (!(binding === null || binding === void 0 ? void 0 : binding.init))
+            return { expr: node, scopes };
+        if (resolving.has(binding) || binding.mutated)
+            return undefined;
+        return resolveStaticValue(binding.init, binding.scopes, new Set([...resolving, binding]), depth + 1);
+    }
+    if (node.type === 'MemberExpression') {
+        const key = getStaticKey(node);
+        if (key === undefined)
+            return { expr: node, scopes };
+        const object = resolveStaticValue(node.object, scopes, resolving, depth + 1);
+        if ((object === null || object === void 0 ? void 0 : object.expr.type) !== 'ObjectExpression')
+            return undefined;
+        const value = findPropertyValue(object.expr, key);
+        return value && resolveStaticValue(value, object.scopes, resolving, depth + 1);
     }
-    else if (expr.type === 'BinaryExpression' && expr.operator === '+') {
-        // example: ${"bg-red-500" + "bg-blue-500"}
-        transformExpressionClassNames(expr.left, tailwindSelectors);
-        transformExpressionClassNames(expr.right, tailwindSelectors);
+    return { expr: node, scopes };
+};
+const createsObjectCache = new WeakMap();
+const isStringCache = new WeakMap();
+const createsObject = (expr, scopes, visiting = new Set(), depth = 0) => {
+    const cached = createsObjectCache.get(expr);
+    if (cached !== undefined)
+        return cached;
+    if (depth >= MAX_INLINE_DEPTH)
+        return true;
+    const result = computeCreatesObject(expr, scopes, visiting, depth);
+    createsObjectCache.set(expr, result);
+    return result;
+};
+const computeCreatesObject = (expr, scopes, visiting, depth) => {
+    const check = (child) => createsObject(child, scopes, visiting, depth);
+    switch (expr.type) {
+        case 'Literal':
+            return 'regex' in expr;
+        case 'TemplateLiteral':
+        case 'BinaryExpression':
+        case 'UnaryExpression':
+            return false;
+        case 'ConditionalExpression':
+            return check(expr.consequent) || check(expr.alternate);
+        case 'LogicalExpression':
+            return check(expr.left) || check(expr.right);
+        case 'CallExpression':
+            if (!isClassCall(expr) || expr.callee.type === 'Super')
+                return true;
+            if (expr.callee.type === 'Identifier')
+                return false;
+            if (expr.callee.type !== 'MemberExpression' || expr.callee.object.type === 'Super')
+                return true;
+            return (expr.callee.property.type === 'Identifier' &&
+                expr.callee.property.name === 'concat' &&
+                !isString(expr.callee.object, scopes, visiting, depth));
+        case 'Identifier': {
+            const binding = resolveBinding(expr.name, scopes);
+            if (!(binding === null || binding === void 0 ? void 0 : binding.init) || visiting.has(binding))
+                return false;
+            return createsObject(binding.init, binding.scopes, new Set([...visiting, binding]), depth + 1);
+        }
+        case 'MemberExpression': {
+            const resolved = resolveStaticValue(expr, scopes);
+            if (resolved && resolved.expr !== expr) {
+                return createsObject(resolved.expr, resolved.scopes, visiting, depth + 1);
+            }
+            return (expr.object.type !== 'Super' && createsObject(expr.object, scopes, visiting, depth + 1));
+        }
+        default:
+            return true;
+    }
+};
+const isString = (expr, scopes, visiting, depth) => {
+    const cached = isStringCache.get(expr);
+    if (cached !== undefined)
+        return cached;
+    if (depth >= MAX_INLINE_DEPTH)
+        return false;
+    const result = computeIsString(expr, scopes, visiting, depth);
+    isStringCache.set(expr, result);
+    return result;
+};
+const computeIsString = (expr, scopes, visiting, depth) => {
+    switch (expr.type) {
+        case 'Literal':
+            return typeof expr.value === 'string';
+        case 'TemplateLiteral':
+            return true;
+        case 'BinaryExpression':
+            return (expr.operator === '+' &&
+                (isString(expr.left, scopes, visiting, depth) ||
+                    isString(expr.right, scopes, visiting, depth)));
+        case 'CallExpression':
+            return isClassCall(expr) && !createsObject(expr, scopes, visiting, depth);
+        case 'Identifier': {
+            const binding = resolveBinding(expr.name, scopes);
+            if (!(binding === null || binding === void 0 ? void 0 : binding.init) || visiting.has(binding))
+                return false;
+            return isString(binding.init, binding.scopes, new Set([...visiting, binding]), depth + 1);
+        }
+        default:
+            return false;
+    }
+};
+const getRootIdentifier = (expr) => {
+    if (expr.type === 'Identifier')
+        return expr;
+    if (expr.type === 'MemberExpression')
+        return getRootIdentifier(expr.object);
+    return undefined;
+};
+const cloneForUse = (expr, declarationScopes, useScopes, state, structural = false) => {
+    var _a;
+    state.local.remaining--;
+    state.page.remaining--;
+    if (state.local.remaining < 0 || state.page.remaining < 0)
+        return undefined;
+    const clone = (child) => cloneForUse(child, declarationScopes, useScopes, state);
+    const cloneStructural = (child) => cloneForUse(child, declarationScopes, useScopes, state, true);
+    const cloneElement = (element) => {
+        if (element.type !== 'SpreadElement')
+            return clone(element);
+        const argument = cloneStructural(element.argument);
+        return argument && Object.assign(Object.assign({}, element), { argument });
+    };
+    const cloneAll = (items, cloneItem) => {
+        const cloned = [];
+        for (const item of items) {
+            const result = cloneItem(item);
+            if (result === undefined)
+                return undefined;
+            cloned.push(result);
+        }
+        return cloned;
+    };
+    switch (expr.type) {
+        case 'Literal':
+            return structuredClone(expr);
+        case 'TemplateLiteral': {
+            const expressions = cloneAll(expr.expressions, clone);
+            return expressions && Object.assign(Object.assign({}, expr), { quasis: structuredClone(expr.quasis), expressions });
+        }
+        case 'ArrayExpression': {
+            const elements = cloneAll(expr.elements, (element) => element === null ? null : cloneElement(element));
+            return elements && Object.assign(Object.assign({}, expr), { elements });
+        }
+        case 'BinaryExpression': {
+            const left = clone(expr.left);
+            const right = clone(expr.right);
+            return left && right && Object.assign(Object.assign({}, expr), { left, right });
+        }
+        case 'LogicalExpression': {
+            const left = (structural ? cloneStructural : clone)(expr.left);
+            const right = (structural ? cloneStructural : clone)(expr.right);
+            return left && right && Object.assign(Object.assign({}, expr), { left, right });
+        }
+        case 'ConditionalExpression': {
+            const test = clone(expr.test);
+            const consequent = (structural ? cloneStructural : clone)(expr.consequent);
+            const alternate = (structural ? cloneStructural : clone)(expr.alternate);
+            return test && consequent && alternate && Object.assign(Object.assign({}, expr), { test, consequent, alternate });
+        }
+        case 'UnaryExpression': {
+            if (expr.operator === 'delete')
+                return undefined;
+            const argument = clone(expr.argument);
+            return argument && Object.assign(Object.assign({}, expr), { argument });
+        }
+        case 'ObjectExpression': {
+            const properties = cloneAll(expr.properties, (property) => {
+                if (property.type === 'SpreadElement') {
+                    const argument = cloneStructural(property.argument);
+                    return argument && Object.assign(Object.assign({}, property), { argument });
+                }
+                if (property.kind !== 'init' || property.method)
+                    return undefined;
+                const value = asExpression(property.value);
+                const clonedValue = value && clone(value);
+                if (!clonedValue)
+                    return undefined;
+                if (!property.computed) {
+                    return Object.assign(Object.assign({}, property), { key: structuredClone(property.key), value: clonedValue, shorthand: false });
+                }
+                if (property.key.type === 'PrivateIdentifier')
+                    return undefined;
+                const key = clone(property.key);
+                return key && Object.assign(Object.assign({}, property), { key, value: clonedValue, shorthand: false });
+            });
+            return properties && Object.assign(Object.assign({}, expr), { properties });
+        }
+        case 'MemberExpression': {
+            if (expr.object.type === 'Super' || expr.property.type === 'PrivateIdentifier') {
+                return undefined;
+            }
+            const root = getRootIdentifier(expr.object);
+            if (root && ((_a = resolveBinding(root.name, declarationScopes)) === null || _a === void 0 ? void 0 : _a.mutated))
+                return undefined;
+            const object = cloneStructural(expr.object);
+            const property = expr.computed ? clone(expr.property) : structuredClone(expr.property);
+            return object && property && Object.assign(Object.assign({}, expr), { object, property });
+        }
+        case 'CallExpression': {
+            if (!isClassCall(expr) || expr.callee.type === 'Super')
+                return undefined;
+            const callee = clone(expr.callee);
+            const args = cloneAll(expr.arguments, (argument) => expr.callee.type === 'Identifier' && argument.type !== 'SpreadElement'
+                ? cloneStructural(argument)
+                : cloneElement(argument));
+            return callee && args && Object.assign(Object.assign({}, expr), { callee, arguments: args });
+        }
+        case 'Identifier': {
+            const binding = resolveBinding(expr.name, declarationScopes);
+            if ((binding === null || binding === void 0 ? void 0 : binding.init) &&
+                !state.inlining.has(binding) &&
+                state.inlining.size < MAX_INLINE_DEPTH &&
+                (!createsObject(binding.init, binding.scopes) || (structural && !binding.mutated))) {
+                state.inlining.add(binding);
+                const inlined = cloneForUse(binding.init, binding.scopes, useScopes, state, structural);
+                state.inlining.delete(binding);
+                if (inlined)
+                    return inlined;
+            }
+            const useBinding = resolveBinding(expr.name, useScopes);
+            const isStable = binding
+                ? !binding.reassigned && !binding.mutated && binding === useBinding
+                : !useBinding && IMMUTABLE_GLOBALS.has(expr.name);
+            return isStable ? structuredClone(expr) : undefined;
+        }
+        default:
+            return undefined;
+    }
+};
+const isClassCall = (expr) => {
+    const { callee } = expr;
+    if (callee.type === 'Identifier')
+        return CLASS_HELPERS.has(callee.name);
+    return (callee.type === 'MemberExpression' &&
+        !callee.computed &&
+        callee.property.type === 'Identifier' &&
+        (callee.property.name === 'join' || callee.property.name === 'concat'));
+};
+const getStaticKey = (expr) => {
+    if (!expr.computed && expr.property.type === 'Identifier')
+        return expr.property.name;
+    if (expr.property.type === 'Literal' && typeof expr.property.value === 'string') {
+        return expr.property.value;
+    }
+    return undefined;
+};
+const getPropertyKeyName = (property) => {
+    if (!property.computed && property.key.type === 'Identifier')
+        return property.key.name;
+    if (property.key.type === 'Literal' && typeof property.key.value === 'string') {
+        return property.key.value;
+    }
+    return undefined;
+};
+const findPropertyValue = (object, key) => {
+    for (let i = object.properties.length - 1; i >= 0; i--) {
+        const property = object.properties[i];
+        if (!property || property.type === 'SpreadElement')
+            return undefined;
+        const name = getPropertyKeyName(property);
+        if (name === undefined) {
+            if (property.computed)
+                return undefined;
+            continue;
+        }
+        if (name !== key)
+            continue;
+        if (property.kind !== 'init' || property.method)
+            return undefined;
+        return asExpression(property.value);
+    }
+    return undefined;
+};
+const asExpression = (node) => node.type === 'ObjectPattern' ||
+    node.type === 'ArrayPattern' ||
+    node.type === 'RestElement' ||
+    node.type === 'AssignmentPattern'
+    ? undefined
+    : node;
+const transformLiteral = (expr, context) => {
+    if (typeof expr.value !== 'string')
+        return;
+    const transformedValue = transformClassNames(expr.value, context.tailwindSelectors);
+    if (expr.value !== transformedValue) {
+        expr.value = transformedValue;
+        if (typeof expr.raw === 'string') {
+            expr.raw = JSON.stringify(transformedValue);
+        }
+        context.changes.count++;
     }
 };
+const toLiteral = (value) => ({
+    type: 'Literal',
+    value,
+    raw: JSON.stringify(value),
+});
 const transformClassNames = (value, tailwindSelectors) => {
     var _a, _b, _c, _d;
     if (!tailwindSelectors || !tailwindSelectors.length)