@mintlify/common 1.0.1259 → 1.0.1260

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

@@ -3,17 +3,76 @@ 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') &&
@@ -29,45 +88,77 @@ export const rehypeDynamicTailwindCss = (tailwindSelectors) => (tree) => {
                 // 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, normalizedTailwindSelectors);
+                    statement.expression = transformExpressionClassNames(statement.expression, moduleScopes, context);
                 }
             }
         }
         if (node.type === 'mdxjsEsm' && node.data && node.data.estree) {
-            transformMdxJsEsmNode(node.data.estree, moduleScopes, normalizedTailwindSelectors);
+            transformMdxJsEsmNode(node.data.estree, moduleScopes, scopeByNode, context);
         }
     });
 };
+const createBinding = (scopes, init) => ({
+    init,
+    scopes,
+    reassigned: false,
+    mutated: false,
+    aliasOf: [],
+});
 const collectDeclarations = (statements, scope, scopes) => {
     for (const statement of statements) {
-        const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
-        if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'FunctionDeclaration' && declaration.id) {
-            scope.set(declaration.id.name, { scopes });
+        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 === null || declaration === void 0 ? void 0 : declaration.type) !== 'VariableDeclaration')
+        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, { init: declarator.init, scopes });
+                scope.set(declarator.id.name, createBinding(scopes, declarator.init));
             }
             else {
-                getPatternNames(declarator.id).forEach((name) => scope.set(name, { scopes }));
+                getPatternNames(declarator.id).forEach((name) => scope.set(name, createBinding(scopes)));
             }
         }
     }
 };
-const getPatternNames = (pattern) => {
+const collectVarNames = (root) => {
+    const names = [];
+    walk(root, {
+        enter(node) {
+            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.name];
+            return [pattern];
         case 'AssignmentPattern':
-            return getPatternNames(pattern.left);
+            return getPatternIdentifiers(pattern.left);
         case 'RestElement':
-            return getPatternNames(pattern.argument);
+            return getPatternIdentifiers(pattern.argument);
         case 'ArrayPattern':
-            return pattern.elements.flatMap((element) => (element ? getPatternNames(element) : []));
+            return pattern.elements.flatMap((element) => (element ? getPatternIdentifiers(element) : []));
         case 'ObjectPattern':
-            return pattern.properties.flatMap((property) => getPatternNames(property.type === 'Property' ? property.value : property));
+            return pattern.properties.flatMap((property) => getPatternIdentifiers(property.type === 'Property' ? property.value : property));
         default:
             return [];
     }
@@ -84,64 +175,304 @@ const resolveBinding = (name, scopes) => {
 const isFunctionNode = (node) => node.type === 'FunctionDeclaration' ||
     node.type === 'FunctionExpression' ||
     node.type === 'ArrowFunctionExpression';
-const transformMdxJsEsmNode = (estreeNode, moduleScopes, tailwindSelectors) => {
+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) {
-            if (isFunctionNode(node)) {
-                const scope = new Map();
-                const chain = [...scopes, scope];
-                node.params.flatMap(getPatternNames).forEach((name) => scope.set(name, { scopes: chain }));
-                scopes.push(scope);
-                return;
-            }
-            if (node.type === 'BlockStatement') {
-                const scope = new Map();
-                collectDeclarations(node.body, scope, [...scopes, scope]);
+            const scope = scopeByNode.get(node);
+            if (scope)
                 scopes.push(scope);
-                return;
-            }
-            if (node.type === 'JSXAttribute' &&
-                node.name.type === 'JSXIdentifier' &&
-                (node.name.name === 'className' || node.name.name === 'class')) {
+            if (node.type === 'JSXAttribute' && isClassAttribute(node)) {
                 // example: className="bg-green-500"
                 if (node.value && node.value.type === 'Literal') {
-                    transformLiteral(node.value, tailwindSelectors);
+                    transformLiteral(node.value, context);
                 }
                 if (node.value &&
                     node.value.type === 'JSXExpressionContainer' &&
                     node.value.expression.type !== 'JSXEmptyExpression') {
-                    node.value.expression = transformExpressionClassNames(node.value.expression, scopes, tailwindSelectors);
+                    node.value.expression = transformExpressionClassNames(node.value.expression, scopes, context);
                 }
             }
         },
         leave(node) {
-            if (node.type === 'BlockStatement' || isFunctionNode(node)) {
+            if (scopeByNode.has(node))
                 scopes.pop();
-            }
         },
     });
 };
-const transformExpressionClassNames = (expr, scopes, tailwindSelectors, inlining = new Set()) => {
-    const transform = (child) => transformExpressionClassNames(child, scopes, tailwindSelectors, inlining);
+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 = transform(element.argument);
+        element.argument = transformStructural(element.argument);
         return element;
     };
     switch (expr.type) {
         case 'Literal':
-            transformLiteral(expr, tailwindSelectors);
+            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, tailwindSelectors);
+                    const transformedValue = transformClassNames(quasi.value.cooked, context.tailwindSelectors);
                     if (quasi.value.cooked !== transformedValue) {
                         quasi.value.cooked = transformedValue;
                         quasi.value.raw = transformedValue;
+                        context.changes.count++;
                     }
                 }
             });
@@ -150,13 +481,13 @@ const transformExpressionClassNames = (expr, scopes, tailwindSelectors, inlining
             return expr;
         case 'ConditionalExpression':
             // example: ${isActive ? "bg-red-500" : "bg-blue-500"}
-            expr.consequent = transform(expr.consequent);
-            expr.alternate = transform(expr.alternate);
+            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 = transform(expr.left);
-            expr.right = transform(expr.right);
+            expr.left = (structural ? transformStructural : transform)(expr.left);
+            expr.right = (structural ? transformStructural : transform)(expr.right);
             return expr;
         case 'BinaryExpression':
             if (expr.operator === '+') {
@@ -174,60 +505,74 @@ const transformExpressionClassNames = (expr, scopes, tailwindSelectors, inlining
                 return expr;
             // example: ["bg-red-500", "bg-blue-500"].join(" ")
             if (expr.callee.type === 'MemberExpression' && expr.callee.object.type !== 'Super') {
-                expr.callee.object = transform(expr.callee.object);
+                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));
             }
-            expr.arguments = expr.arguments.map(transformElement);
             return expr;
         case 'ObjectExpression':
             // example: cn({ "bg-blue-500": isActive })
-            transformObjectKeys(expr, transform, tailwindSelectors);
+            transformObjectKeys(expr, transform, transformStructural, context);
             return expr;
         case 'MemberExpression':
             // example: const styles = { active: "bg-red-500" }; className={styles.active}
-            return transformMemberExpression(expr, scopes, transform);
+            return transformMemberExpression(expr, scopes, transform, context);
         case 'Identifier': {
             // example: const classes = "bg-red-500"; className={classes}
             const binding = resolveBinding(expr.name, scopes);
-            if (!(binding === null || binding === void 0 ? void 0 : binding.init) || inlining.has(binding))
+            if (!binding || inlining.has(binding))
                 return expr;
-            const inlined = cloneForUse(binding.init, binding.scopes, scopes, new Set([binding]));
-            if (!inlined)
+            const inlined = cloneForUse(expr, scopes, scopes, createCloneState(context), structural);
+            if (!inlined || inlined.type === 'Identifier')
                 return expr;
-            const before = serialize(inlined);
-            const transformed = transformExpressionClassNames(inlined, scopes, tailwindSelectors, new Set([...inlining, binding]));
-            return serialize(transformed) === before ? expr : transformed;
+            const nextInlining = new Set([...inlining, binding]);
+            return applyIfChanged(expr, inlined, (child) => transformExpressionClassNames(child, scopes, context, nextInlining), context);
         }
         default:
             return expr;
     }
 };
-const transformMemberExpression = (expr, scopes, transform) => {
+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, new Set());
-        if (!inlined)
-            return expr;
-        const before = serialize(inlined);
-        const transformed = transform(inlined);
-        return serialize(transformed) === before ? expr : transformed;
+        const inlined = resolved && cloneForUse(resolved.expr, resolved.scopes, scopes, createCloneState(context));
+        return inlined ? applyIfChanged(expr, inlined, transform, context) : expr;
     }
-    const object = resolveObject(expr.object, scopes);
+    const object = resolveObject(expr.object, scopes, context);
     if (!object)
         return expr;
-    const before = serialize(object);
+    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 (serialize(object) !== before)
+    if (context.changes.count !== before)
         expr.object = object;
     return expr;
 };
-const transformObjectKeys = (expr, transform, tailwindSelectors) => {
+const transformObjectKeys = (expr, transform, transformStructural, context) => {
     expr.properties.forEach((property) => {
         if (property.type === 'SpreadElement') {
-            property.argument = transform(property.argument);
+            property.argument = transformStructural(property.argument);
             return;
         }
         if (property.computed) {
@@ -238,51 +583,149 @@ const transformObjectKeys = (expr, transform, tailwindSelectors) => {
         const keyName = getPropertyKeyName(property);
         if (keyName === undefined)
             return;
-        const transformedValue = transformClassNames(keyName, tailwindSelectors);
+        const transformedValue = transformClassNames(keyName, context.tailwindSelectors);
         if (keyName !== transformedValue) {
             property.key = toLiteral(transformedValue);
             property.shorthand = false;
+            context.changes.count++;
         }
     });
 };
-const resolveObject = (node, scopes) => {
+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, new Set());
+    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()) => {
-    if (node.type === 'Super')
+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))
+        if (resolving.has(binding) || binding.mutated)
             return undefined;
-        return resolveStaticValue(binding.init, binding.scopes, new Set([...resolving, binding]));
+        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);
+        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);
+        return value && resolveStaticValue(value, object.scopes, resolving, depth + 1);
     }
     return { expr: node, scopes };
 };
-const cloneForUse = (expr, declarationScopes, useScopes, inlining) => {
-    const clone = (child) => cloneForUse(child, declarationScopes, useScopes, inlining);
+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 = clone(element.argument);
+        const argument = cloneStructural(element.argument);
         return argument && Object.assign(Object.assign({}, element), { argument });
     };
     const cloneAll = (items, cloneItem) => {
@@ -312,24 +755,26 @@ const cloneForUse = (expr, declarationScopes, useScopes, inlining) => {
             return left && right && Object.assign(Object.assign({}, expr), { left, right });
         }
         case 'LogicalExpression': {
-            const left = clone(expr.left);
-            const right = clone(expr.right);
+            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 = clone(expr.consequent);
-            const alternate = clone(expr.alternate);
+            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 = clone(property.argument);
+                    const argument = cloneStructural(property.argument);
                     return argument && Object.assign(Object.assign({}, property), { argument });
                 }
                 if (property.kind !== 'init' || property.method)
@@ -352,7 +797,10 @@ const cloneForUse = (expr, declarationScopes, useScopes, inlining) => {
             if (expr.object.type === 'Super' || expr.property.type === 'PrivateIdentifier') {
                 return undefined;
             }
-            const object = clone(expr.object);
+            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 });
         }
@@ -360,17 +808,28 @@ const cloneForUse = (expr, declarationScopes, useScopes, inlining) => {
             if (!isClassCall(expr) || expr.callee.type === 'Super')
                 return undefined;
             const callee = clone(expr.callee);
-            const args = cloneAll(expr.arguments, cloneElement);
+            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) && !inlining.has(binding)) {
-                const inlined = cloneForUse(binding.init, binding.scopes, useScopes, new Set([...inlining, binding]));
+            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;
             }
-            return binding === resolveBinding(expr.name, useScopes) ? structuredClone(expr) : undefined;
+            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;
@@ -406,8 +865,17 @@ const findPropertyValue = (object, key) => {
         const property = object.properties[i];
         if (!property || property.type === 'SpreadElement')
             return undefined;
-        if (getPropertyKeyName(property) === key)
-            return asExpression(property.value);
+        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;
 };
@@ -417,15 +885,16 @@ const asExpression = (node) => node.type === 'ObjectPattern' ||
     node.type === 'AssignmentPattern'
     ? undefined
     : node;
-const transformLiteral = (expr, tailwindSelectors) => {
+const transformLiteral = (expr, context) => {
     if (typeof expr.value !== 'string')
         return;
-    const transformedValue = transformClassNames(expr.value, tailwindSelectors);
+    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) => ({
@@ -433,7 +902,6 @@ const toLiteral = (value) => ({
     value,
     raw: JSON.stringify(value),
 });
-const serialize = (node) => JSON.stringify(node, (_key, value) => typeof value === 'bigint' ? value.toString() : value);
 const transformClassNames = (value, tailwindSelectors) => {
     var _a, _b, _c, _d;
     if (!tailwindSelectors || !tailwindSelectors.length)