@homebound/truss 2.0.5 → 2.0.6

package/build/plugin/index.js

@@ -1355,7 +1355,7 @@ function buildPropsArgs(segments, options) {
     if (seg.styleArrayArg) {
       args.push(
         t3.spreadElement(
-          buildUnknownObjectSpreadFallback(
+          buildUnknownSpreadFallback(
             seg.styleArrayArg,
             options.asStyleArrayHelperName,
             options.needsAsStyleArrayHelper
@@ -1394,13 +1394,6 @@ function rewriteCssAttributeExpressions(ast, filename, debug, stylexNamespaceNam
       const value = path.node.value;
       if (!t3.isJSXExpressionContainer(value)) return;
       if (!t3.isExpression(value.expression)) return;
-      if (!isCssRewriteableExpression(value.expression, path)) {
-        skippedCssPropMessages.push({
-          message: explainSkippedCssRewrite(value.expression, path),
-          line: path.node.loc?.start.line ?? null
-        });
-        return;
-      }
       const propsArgs = lowerCssExpressionToPropsArgs(
         value.expression,
         path,
@@ -1464,11 +1457,8 @@ function buildDebugElements(line, options) {
   options.needsTrussDebugInfo.current = true;
   return [t3.newExpression(t3.identifier(options.trussDebugInfoName), [t3.stringLiteral(`${options.filename}:${line}`)])];
 }
-function isCssRewriteableExpression(expr, path) {
-  return !!lowerCssExpressionToPropsArgs(expr, path, "asStyleArray", { current: false });
-}
 function lowerCssExpressionToPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
-  return buildStyleObjectPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) ?? buildStyleArrayLikePropsArgsFromExpression(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper);
+  return buildStyleObjectPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) ?? buildStyleArrayLikePropsArgsFromExpression(expr, path);
 }
 function explainSkippedCssRewrite(expr, path) {
   if (t3.isObjectExpression(expr)) {
@@ -1476,7 +1466,7 @@ function explainSkippedCssRewrite(expr, path) {
       if (!t3.isSpreadElement(prop)) {
         return `[truss] Unsupported pattern: Could not rewrite css prop: object contains a non-spread property (${formatNodeSnippet(expr)})`;
       }
-      const normalizedArg = normalizeStyleArrayLikeExpression(prop.argument, path, /* @__PURE__ */ new Set());
+      const normalizedArg = normalizeStyleExpression(prop.argument);
       if (!normalizedArg) {
         return `[truss] Unsupported pattern: Could not rewrite css prop: spread argument is not style-array-like (${formatNodeSnippet(prop.argument)})`;
       }
@@ -1520,53 +1510,46 @@ function removeExistingClassNameAttribute(path) {
 }
 function buildStyleObjectPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   if (!t3.isObjectExpression(expr) || expr.properties.length === 0) return null;
-  const result = collectStyleCompositionEntries(expr, path);
-  if (!result) {
-    if (expr.properties.every(function(prop) {
-      return t3.isSpreadElement(prop);
-    })) {
-      return expr.properties.map(function(prop) {
-        const spread = prop;
-        return t3.spreadElement(
-          buildUnknownObjectSpreadFallback(spread.argument, asStyleArrayHelperName, needsAsStyleArrayHelper)
-          // I.e. `css={{ ...css }}` or `css={{ ...xss }}`
-        );
-      });
-    }
-    return null;
-  }
-  if (result.droppedPropertyKeys.length > 0) return null;
-  return buildPropsArgsFromStyleCompositionEntries(
-    result.entries,
-    path,
-    asStyleArrayHelperName,
-    needsAsStyleArrayHelper
-  );
+  const allSpreads = expr.properties.every(function(prop) {
+    return t3.isSpreadElement(prop);
+  });
+  if (!allSpreads) return null;
+  if (hasStyleArraySpread(expr, path)) {
+    const result = flattenStyleObject(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper);
+    return result.elements.filter(Boolean);
+  }
+  return expr.properties.map(function(prop) {
+    const spread = prop;
+    return t3.spreadElement(
+      buildUnknownSpreadFallback(spread.argument, asStyleArrayHelperName, needsAsStyleArrayHelper)
+      // I.e. `css={{ ...css }}` or `css={{ ...xss }}`
+    );
+  });
 }
-function buildStyleArrayLikePropsArgsFromExpression(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
-  const normalizedExpr = normalizeStyleArrayLikeExpression(expr, path, /* @__PURE__ */ new Set());
+function buildStyleArrayLikePropsArgsFromExpression(expr, path) {
+  const normalizedExpr = normalizeStyleExpression(expr);
   if (!normalizedExpr) return null;
-  return buildStyleArrayLikePropsArgs(normalizedExpr, path, /* @__PURE__ */ new Set());
+  return buildStyleArrayLikePropsArgs(normalizedExpr, path);
 }
-function buildStyleArrayLikePropsArgs(expr, path, seen) {
-  if (seen.has(expr)) return null;
-  seen.add(expr);
+function buildStyleArrayLikePropsArgs(expr, path) {
   if (t3.isArrayExpression(expr)) {
     const propsArgs = [];
     for (const el of expr.elements) {
       if (!el) continue;
       if (t3.isSpreadElement(el)) {
-        const normalizedArg = normalizeStyleArrayLikeExpression(el.argument, path, /* @__PURE__ */ new Set());
+        const normalizedArg = normalizeStyleExpression(el.argument);
         if (!normalizedArg) {
           propsArgs.push(t3.spreadElement(el.argument));
           continue;
         }
-        const nestedArgs = buildStyleArrayLikePropsArgs(normalizedArg, path, seen);
-        if (nestedArgs && t3.isArrayExpression(normalizedArg)) {
-          propsArgs.push(...nestedArgs);
-        } else {
-          propsArgs.push(t3.spreadElement(buildSafeSpreadArgument(normalizedArg)));
+        if (t3.isArrayExpression(normalizedArg)) {
+          const nestedArgs = buildStyleArrayLikePropsArgs(normalizedArg, path);
+          if (nestedArgs) {
+            propsArgs.push(...nestedArgs);
+            continue;
+          }
         }
+        propsArgs.push(t3.spreadElement(buildSafeSpreadArgument(normalizedArg)));
         continue;
       }
       propsArgs.push(el);
@@ -1581,15 +1564,15 @@ function buildStyleArrayLikePropsArgs(expr, path, seen) {
 function rewriteStyleObjectExpressions(ast, messages, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   traverse(ast, {
     ObjectExpression(path) {
-      const result = tryBuildStyleArrayFromObject(path, asStyleArrayHelperName, needsAsStyleArrayHelper);
-      if (!result.rewritten) return;
+      if (!hasStyleArraySpread(path.node, path)) return;
+      const result = flattenStyleObject(path.node, path, asStyleArrayHelperName, needsAsStyleArrayHelper);
       if (result.droppedPropertyKeys.length > 0) {
         messages.push({
           message: `[truss] Unsupported pattern: Dropped non-spread properties from style composition object (${result.droppedPropertyKeys.join(", ")})`,
           line: path.node.loc?.start.line ?? null
         });
       }
-      path.replaceWith(result.rewritten);
+      path.replaceWith(t3.arrayExpression(result.elements));
     }
   });
 }
@@ -1601,258 +1584,148 @@ function rewriteCssSpreadCalls(ast, cssBindingName, asStyleArrayHelperName, need
       if (!arg || t3.isSpreadElement(arg) || !t3.isExpression(arg) || path.node.arguments.length !== 1) return;
       const styleObject = unwrapStyleObjectExpression(arg);
       if (!styleObject) return;
-      const result = tryBuildStyleArrayFromObjectExpression(
-        styleObject,
-        path,
-        asStyleArrayHelperName,
-        needsAsStyleArrayHelper
-      );
-      if (!result.rewritten) return;
-      path.replaceWith(result.rewritten);
+      if (!hasStyleArraySpread(styleObject, path)) return;
+      const result = flattenStyleObject(styleObject, path, asStyleArrayHelperName, needsAsStyleArrayHelper);
+      path.replaceWith(t3.arrayExpression(result.elements));
     }
   });
 }
-function tryBuildStyleArrayFromObject(path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
-  return tryBuildStyleArrayFromObjectExpression(path.node, path, asStyleArrayHelperName, needsAsStyleArrayHelper);
-}
-function tryBuildStyleArrayFromObjectExpression(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
-  const result = collectStyleCompositionEntries(expr, path);
-  if (!result) return { rewritten: null, droppedPropertyKeys: [] };
-  const elements = buildArrayElementsFromStyleCompositionEntries(
-    result.entries,
-    path,
-    asStyleArrayHelperName,
-    needsAsStyleArrayHelper
-  );
-  return { rewritten: t3.arrayExpression(elements), droppedPropertyKeys: result.droppedPropertyKeys };
-}
-function collectStyleCompositionEntries(expr, path) {
-  if (expr.properties.length === 0) return null;
-  let sawKnownStyle = false;
-  const entries = [];
+function flattenStyleObject(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
+  const elements = [];
   const droppedPropertyKeys = [];
   for (const prop of expr.properties) {
     if (!t3.isSpreadElement(prop)) {
       droppedPropertyKeys.push(formatDroppedPropertyKey(prop));
       continue;
     }
-    const normalizedArg = normalizeStyleArrayLikeExpression(prop.argument, path, /* @__PURE__ */ new Set());
-    if (!normalizedArg) {
-      entries.push({ kind: "unknown", expr: prop.argument });
+    const normalized = normalizeStyleExpression(prop.argument);
+    if (!normalized) {
+      elements.push(
+        t3.spreadElement(buildUnknownSpreadFallback(prop.argument, asStyleArrayHelperName, needsAsStyleArrayHelper))
+      );
       continue;
     }
-    if (isKnownStyleArrayLike(normalizedArg, path, /* @__PURE__ */ new Set())) {
-      sawKnownStyle = true;
-      entries.push({ kind: "known", expr: normalizedArg });
+    if (t3.isArrayExpression(normalized)) {
+      elements.push(...normalized.elements);
+    } else if (expressionContainsArray(normalized, path)) {
+      elements.push(t3.spreadElement(buildSafeSpreadArgument(normalized)));
     } else {
-      entries.push({ kind: "unknown", expr: normalizedArg });
+      elements.push(
+        t3.spreadElement(buildUnknownSpreadFallback(normalized, asStyleArrayHelperName, needsAsStyleArrayHelper))
+        // I.e. `...borderBottomStyles`
+      );
     }
   }
-  return sawKnownStyle ? { entries, droppedPropertyKeys } : null;
+  return { elements, droppedPropertyKeys };
 }
-function buildPropsArgsFromStyleCompositionEntries(entries, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
-  const propsArgs = [];
-  for (const entry of entries) {
-    const nestedArgs = entry.kind === "known" ? buildStyleArrayLikePropsArgs(entry.expr, path, /* @__PURE__ */ new Set()) : null;
-    if (nestedArgs && t3.isArrayExpression(entry.expr)) {
-      propsArgs.push(...nestedArgs);
-      continue;
-    }
-    propsArgs.push(
-      t3.spreadElement(
-        entry.kind === "known" ? buildSafeSpreadArgument(entry.expr) : buildUnknownObjectSpreadFallback(entry.expr, asStyleArrayHelperName, needsAsStyleArrayHelper)
-      )
-    );
-  }
-  return propsArgs;
+function hasStyleArraySpread(expr, path) {
+  return expr.properties.some(function(prop) {
+    return t3.isSpreadElement(prop) && expressionContainsArray(prop.argument, path);
+  });
 }
-function buildArrayElementsFromStyleCompositionEntries(entries, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
-  const elements = [];
-  for (const entry of entries) {
-    const nestedArgs = entry.kind === "known" ? buildStyleArrayLikePropsArgs(entry.expr, path, /* @__PURE__ */ new Set()) : null;
-    if (nestedArgs && t3.isArrayExpression(entry.expr)) {
-      elements.push(...entry.expr.elements);
-      continue;
+function expressionContainsArray(expr, path) {
+  if (t3.isArrayExpression(expr)) return true;
+  if (t3.isConditionalExpression(expr)) {
+    return expressionContainsArray(expr.consequent, path) || expressionContainsArray(expr.alternate, path);
+  }
+  if (t3.isLogicalExpression(expr)) {
+    return expressionContainsArray(expr.left, path) || expressionContainsArray(expr.right, path);
+  }
+  if (t3.isObjectExpression(expr)) {
+    return expr.properties.some(function(p) {
+      return t3.isSpreadElement(p) && expressionContainsArray(p.argument, path);
+    });
+  }
+  if (t3.isIdentifier(expr)) {
+    const binding = path.scope.getBinding(expr.name);
+    if (binding?.path.isVariableDeclarator()) {
+      const init = binding.path.node.init;
+      if (init) return expressionContainsArray(init, binding.path);
+    }
+    return false;
+  }
+  if (t3.isMemberExpression(expr) && t3.isIdentifier(expr.object)) {
+    const binding = path.scope.getBinding(expr.object.name);
+    if (binding?.path.isVariableDeclarator()) {
+      const init = binding.path.node.init;
+      if (init && t3.isObjectExpression(init)) {
+        const propName = getStaticMemberPropertyName(expr, path);
+        if (propName) {
+          for (const prop of init.properties) {
+            if (!t3.isObjectProperty(prop) || prop.computed) continue;
+            if (!isMatchingPropertyName(prop.key, propName)) continue;
+            if (t3.isExpression(prop.value)) {
+              return expressionContainsArray(prop.value, binding.path);
+            }
+          }
+        }
+      }
     }
-    elements.push(
-      t3.spreadElement(
-        entry.kind === "known" ? buildSafeSpreadArgument(entry.expr) : asStyleArrayHelperName && needsAsStyleArrayHelper ? buildUnknownObjectSpreadFallback(entry.expr, asStyleArrayHelperName, needsAsStyleArrayHelper) : buildInlineAsStyleArrayExpression(entry.expr)
-      )
-    );
+    return false;
   }
-  return elements;
-}
-function isCssSpreadCall(expr, cssBindingName) {
-  return t3.isMemberExpression(expr.callee) && !expr.callee.computed && t3.isIdentifier(expr.callee.object, { name: cssBindingName }) && t3.isIdentifier(expr.callee.property, { name: "spread" });
-}
-function unwrapStyleObjectExpression(expr) {
-  if (t3.isObjectExpression(expr)) return expr;
-  if (t3.isTSAsExpression(expr) || t3.isTSSatisfiesExpression(expr) || t3.isTSNonNullExpression(expr)) {
-    return unwrapStyleObjectExpression(expr.expression);
+  if (t3.isCallExpression(expr)) {
+    const returnExpr = getCallReturnExpression(expr, path);
+    return returnExpr ? expressionContainsArray(returnExpr, path) : false;
   }
-  return null;
+  return false;
 }
-function normalizeStyleArrayLikeExpression(expr, path, seen) {
-  if (seen.has(expr)) return null;
-  seen.add(expr);
+function normalizeStyleExpression(expr) {
   if (t3.isArrayExpression(expr)) return expr;
+  if (isEmptyObjectExpression(expr)) return t3.arrayExpression([]);
   if (t3.isLogicalExpression(expr) && expr.operator === "&&") {
-    const consequent = normalizeStyleArrayLikeExpression(expr.right, path, seen);
+    const consequent = normalizeStyleExpression(expr.right);
     if (!consequent) return null;
     return t3.conditionalExpression(expr.left, consequent, t3.arrayExpression([]));
   }
   if (t3.isLogicalExpression(expr) && (expr.operator === "||" || expr.operator === "??")) {
-    const left = normalizeStyleArrayLikeExpression(expr.left, path, seen);
-    const right = normalizeStyleArrayLikeBranch(expr.right, path, seen);
+    const left = normalizeStyleExpression(expr.left);
+    const right = normalizeStyleBranch(expr.right);
     if (!left || !right) return null;
     return t3.logicalExpression(expr.operator, left, right);
   }
   if (t3.isConditionalExpression(expr)) {
-    const consequent = normalizeStyleArrayLikeBranch(expr.consequent, path, seen);
-    const alternate = normalizeStyleArrayLikeBranch(expr.alternate, path, seen);
+    const consequent = normalizeStyleBranch(expr.consequent);
+    const alternate = normalizeStyleBranch(expr.alternate);
     if (!consequent || !alternate) return null;
     return t3.conditionalExpression(expr.test, consequent, alternate);
   }
   if (t3.isIdentifier(expr) || t3.isMemberExpression(expr) || t3.isCallExpression(expr)) {
-    const nestedSeen = new Set(seen);
-    nestedSeen.delete(expr);
-    if (isStyleArrayLike(expr, path, nestedSeen)) return expr;
+    return expr;
   }
   return null;
 }
-function normalizeStyleArrayLikeBranch(expr, path, seen) {
-  if (isEmptyObjectExpression(expr)) {
-    return t3.arrayExpression([]);
-  }
+function normalizeStyleBranch(expr) {
+  if (isEmptyObjectExpression(expr)) return t3.arrayExpression([]);
   if (t3.isObjectExpression(expr)) {
-    return tryBuildStyleArrayFromObjectExpression(expr, path).rewritten;
-  }
-  return normalizeStyleArrayLikeExpression(expr, path, seen);
-}
-function isStyleArrayLike(expr, path, seen) {
-  if (seen.has(expr)) return false;
-  seen.add(expr);
-  if (t3.isArrayExpression(expr)) return true;
-  if (t3.isLogicalExpression(expr) && expr.operator === "&&") {
-    return isStyleArrayLike(expr.right, path, seen);
-  }
-  if (t3.isLogicalExpression(expr) && (expr.operator === "||" || expr.operator === "??")) {
-    return isStyleArrayLike(expr.left, path, seen) && isStyleArrayLikeBranch(expr.right, path, seen);
-  }
-  if (t3.isConditionalExpression(expr)) {
-    return isStyleArrayLikeBranch(expr.consequent, path, seen) && isStyleArrayLikeBranch(expr.alternate, path, seen);
-  }
-  if (t3.isIdentifier(expr)) {
-    const possibleValues = resolvePossibleStyleValues(expr, path, new Set(seen));
-    if (possibleValues) {
-      return possibleValues.every(function(value) {
-        return isStyleArrayLike(value, path, new Set(seen));
-      });
-    }
-    const binding = path.scope.getBinding(expr.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
-    const init = bindingPath.node.init;
-    return !!(init && isStyleArrayLike(init, bindingPath, seen));
-  }
-  if (t3.isCallExpression(expr)) {
-    const possibleValues = resolvePossibleStyleValues(expr, path, new Set(seen));
-    if (possibleValues) {
-      return possibleValues.every(function(value) {
-        return isStyleArrayLike(value, path, new Set(seen));
-      });
-    }
-    const returnExpr = getCallStyleArrayLikeExpression(expr, path);
-    return returnExpr ? isStyleArrayLike(returnExpr, path, seen) : true;
-  }
-  if (t3.isMemberExpression(expr)) {
-    const possibleValues = resolvePossibleStyleValues(expr, path, new Set(seen));
-    if (possibleValues) {
-      return possibleValues.every(function(value) {
-        return isStyleArrayLike(value, path, new Set(seen));
-      });
-    }
-    const object = expr.object;
-    if (!t3.isIdentifier(object)) return false;
-    const binding = path.scope.getBinding(object.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
-    const init = bindingPath.node.init;
-    if (!init || !t3.isObjectExpression(init)) return false;
-    const propertyName = getStaticMemberPropertyName(expr, path);
-    if (!propertyName) return false;
-    for (const prop of init.properties) {
-      if (!t3.isObjectProperty(prop) || prop.computed) continue;
-      if (!isMatchingPropertyName(prop.key, propertyName)) continue;
-      const value = prop.value;
-      return t3.isExpression(value) && isStyleArrayLike(value, bindingPath, seen);
+    if (expr.properties.length === 0) return t3.arrayExpression([]);
+    const allSpreads = expr.properties.every(function(p) {
+      return t3.isSpreadElement(p);
+    });
+    if (!allSpreads) return null;
+    const elements = [];
+    for (const prop of expr.properties) {
+      const spread = prop;
+      const normalized = normalizeStyleExpression(spread.argument);
+      if (!normalized) return null;
+      if (t3.isArrayExpression(normalized)) {
+        elements.push(...normalized.elements);
+      } else {
+        elements.push(t3.spreadElement(buildSafeSpreadArgument(normalized)));
+      }
     }
+    return t3.arrayExpression(elements);
   }
-  return false;
+  return normalizeStyleExpression(expr);
 }
-function isKnownStyleArrayLike(expr, path, seen) {
-  if (seen.has(expr)) return false;
-  seen.add(expr);
-  if (t3.isArrayExpression(expr)) return true;
-  if (t3.isLogicalExpression(expr) && expr.operator === "&&") {
-    return isKnownStyleArrayLike(expr.right, path, seen);
-  }
-  if (t3.isLogicalExpression(expr) && (expr.operator === "||" || expr.operator === "??")) {
-    return isKnownStyleArrayLike(expr.left, path, seen) && isStyleArrayLikeBranch(expr.right, path, seen);
-  }
-  if (t3.isConditionalExpression(expr)) {
-    return isStyleArrayLikeBranch(expr.consequent, path, seen) && isStyleArrayLikeBranch(expr.alternate, path, seen);
-  }
-  if (t3.isIdentifier(expr)) {
-    const possibleValues = resolvePossibleStyleValues(expr, path, new Set(seen));
-    if (possibleValues) {
-      return possibleValues.every(function(value) {
-        return isKnownStyleArrayLike(value, path, new Set(seen));
-      });
-    }
-    const binding = path.scope.getBinding(expr.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
-    const init = bindingPath.node.init;
-    return !!(init && isKnownStyleArrayLike(init, bindingPath, seen));
-  }
-  if (t3.isCallExpression(expr)) {
-    const possibleValues = resolvePossibleStyleValues(expr, path, new Set(seen));
-    if (possibleValues) {
-      return possibleValues.every(function(value) {
-        return isKnownStyleArrayLike(value, path, new Set(seen));
-      });
-    }
-    const returnExpr = getCallStyleArrayLikeExpression(expr, path);
-    return !!(returnExpr && isKnownStyleArrayLike(returnExpr, path, seen));
-  }
-  if (t3.isMemberExpression(expr)) {
-    const possibleValues = resolvePossibleStyleValues(expr, path, new Set(seen));
-    if (possibleValues) {
-      return possibleValues.every(function(value) {
-        return isKnownStyleArrayLike(value, path, new Set(seen));
-      });
-    }
-    const object = expr.object;
-    if (!t3.isIdentifier(object)) return false;
-    const binding = path.scope.getBinding(object.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
-    const init = bindingPath.node.init;
-    if (!init || !t3.isObjectExpression(init)) return false;
-    const propertyName = getStaticMemberPropertyName(expr, path);
-    if (!propertyName) return false;
-    for (const prop of init.properties) {
-      if (!t3.isObjectProperty(prop) || prop.computed) continue;
-      if (!isMatchingPropertyName(prop.key, propertyName)) continue;
-      const value = prop.value;
-      return t3.isExpression(value) && isKnownStyleArrayLike(value, bindingPath, seen);
-    }
-  }
-  return false;
+function isCssSpreadCall(expr, cssBindingName) {
+  return t3.isMemberExpression(expr.callee) && !expr.callee.computed && t3.isIdentifier(expr.callee.object, { name: cssBindingName }) && t3.isIdentifier(expr.callee.property, { name: "spread" });
 }
-function isStyleArrayLikeBranch(expr, path, seen) {
-  return isEmptyObjectExpression(expr) || isStyleArrayLike(expr, path, seen);
+function unwrapStyleObjectExpression(expr) {
+  if (t3.isObjectExpression(expr)) return expr;
+  if (t3.isTSAsExpression(expr) || t3.isTSSatisfiesExpression(expr) || t3.isTSNonNullExpression(expr)) {
+    return unwrapStyleObjectExpression(expr.expression);
+  }
+  return null;
 }
 function isMatchingPropertyName(key, name) {
   return t3.isIdentifier(key) && key.name === name || t3.isStringLiteral(key) && key.value === name;
@@ -1860,18 +1733,10 @@ function isMatchingPropertyName(key, name) {
 function isEmptyObjectExpression(expr) {
   return t3.isObjectExpression(expr) && expr.properties.length === 0;
 }
-function buildUnknownObjectSpreadFallback(expr, asStyleArrayHelperName, needsAsStyleArrayHelper) {
+function buildUnknownSpreadFallback(expr, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   needsAsStyleArrayHelper.current = true;
   return t3.callExpression(t3.identifier(asStyleArrayHelperName), [expr]);
 }
-function buildInlineAsStyleArrayExpression(expr) {
-  return t3.conditionalExpression(
-    t3.callExpression(t3.memberExpression(t3.identifier("Array"), t3.identifier("isArray")), [expr]),
-    expr,
-    t3.conditionalExpression(expr, t3.arrayExpression([expr]), t3.arrayExpression([]))
-    // I.e. `xss` becomes `[xss]` when truthy
-  );
-}
 function buildSafeSpreadArgument(expr) {
   return t3.isConditionalExpression(expr) || t3.isLogicalExpression(expr) ? t3.parenthesizedExpression(expr) : expr;
 }
@@ -1884,14 +1749,13 @@ function getStaticMemberPropertyName(expr, path) {
   }
   if (t3.isIdentifier(expr.property)) {
     const binding = path.scope.getBinding(expr.property.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return null;
-    const init = bindingPath.node.init;
+    if (!binding?.path.isVariableDeclarator()) return null;
+    const init = binding.path.node.init;
     return t3.isStringLiteral(init) ? init.value : null;
   }
   return null;
 }
-function getCallStyleArrayLikeExpression(expr, path) {
+function getCallReturnExpression(expr, path) {
   const localReturnExpr = getLocalFunctionReturnExpression(expr, path);
   if (localReturnExpr) return localReturnExpr;
   const firstArg = expr.arguments[0];
@@ -1900,57 +1764,15 @@ function getCallStyleArrayLikeExpression(expr, path) {
   }
   return null;
 }
-function resolvePossibleStyleValues(expr, path, seen) {
-  if (seen.has(expr)) return null;
-  seen.add(expr);
-  if (t3.isObjectExpression(expr) || t3.isArrayExpression(expr)) {
-    return [expr];
-  }
-  if (t3.isIdentifier(expr)) {
-    const binding = path.scope.getBinding(expr.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return null;
-    const init = bindingPath.node.init;
-    return init && t3.isExpression(init) ? resolvePossibleStyleValues(init, bindingPath, seen) : null;
-  }
-  if (t3.isCallExpression(expr)) {
-    const returnExpr = getCallStyleArrayLikeExpression(expr, path);
-    return returnExpr ? resolvePossibleStyleValues(returnExpr, path, seen) : null;
-  }
-  if (t3.isMemberExpression(expr)) {
-    const object = expr.object;
-    if (!t3.isExpression(object)) return null;
-    const objectValues = resolvePossibleStyleValues(object, path, seen);
-    if (!objectValues) return null;
-    const propertyName = getStaticMemberPropertyName(expr, path);
-    const values = [];
-    for (const objectValue of objectValues) {
-      if (!t3.isObjectExpression(objectValue)) continue;
-      for (const prop of objectValue.properties) {
-        if (!t3.isObjectProperty(prop) || prop.computed || !t3.isExpression(prop.value)) continue;
-        if (propertyName) {
-          if (isMatchingPropertyName(prop.key, propertyName)) {
-            values.push(prop.value);
-          }
-        } else {
-          values.push(prop.value);
-        }
-      }
-    }
-    return values.length > 0 ? values : null;
-  }
-  return null;
-}
 function getLocalFunctionReturnExpression(expr, path) {
   if (!t3.isIdentifier(expr.callee)) return null;
   const binding = path.scope.getBinding(expr.callee.name);
-  const bindingPath = binding?.path;
-  if (!bindingPath) return null;
-  if (bindingPath.isFunctionDeclaration()) {
-    return getFunctionLikeReturnExpression(bindingPath.node);
+  if (!binding) return null;
+  if (binding.path.isFunctionDeclaration()) {
+    return getFunctionLikeReturnExpression(binding.path.node);
   }
-  if (bindingPath.isVariableDeclarator()) {
-    const init = bindingPath.node.init;
+  if (binding.path.isVariableDeclarator()) {
+    const init = binding.path.node.init;
     if (init && (t3.isArrowFunctionExpression(init) || t3.isFunctionExpression(init))) {
       return getFunctionLikeReturnExpression(init);
     }