@tamagui/static 1.0.0-beta.187 → 1.0.0-beta.2

package/dist/esm/extractor/createExtractor.js

@@ -1,10 +1,13 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { relative } from "path";
 import traverse from "@babel/traverse";
 import * as t from "@babel/types";
 import {
   getSplitStyles,
   mediaQueryConfig,
+  normalizeStyleObject,
+  proxyThemeVariables,
   pseudos,
   rnw
 } from "@tamagui/core-node";
@@ -20,12 +23,22 @@ import { loadTamagui } from "./loadTamagui";
 import { logLines } from "./logLines";
 import { normalizeTernaries } from "./normalizeTernaries";
 import { removeUnusedHooks } from "./removeUnusedHooks";
+import { timer } from "./timer";
 import { validHTMLAttributes } from "./validHTMLAttributes";
 const UNTOUCHED_PROPS = {
   key: true,
   style: true,
   className: true
 };
+const INLINE_EXTRACTABLE = {
+  ref: "ref",
+  key: "key",
+  onPress: "onClick",
+  onHoverIn: "onMouseEnter",
+  onHoverOut: "onMouseLeave",
+  onPressIn: "onMouseDown",
+  onPressOut: "onMouseUp"
+};
 const isAttr = /* @__PURE__ */ __name((x) => x.type === "attr", "isAttr");
 const validHooks = {
   useMedia: true,
@@ -33,11 +46,11 @@ const validHooks = {
 };
 const createTernary = /* @__PURE__ */ __name((x) => x, "createTernary");
 function createExtractor() {
+  if (!process.env.TAMAGUI_TARGET) {
+    console.log('\u26A0\uFE0F Please set process.env.TAMAGUI_TARGET to either "web" or "native"');
+    process.exit(1);
+  }
   const shouldAddDebugProp = !process.env.npm_package_dependencies_next && process.env.TAMAGUI_TARGET !== "native" && process.env.IDENTIFY_TAGS !== "false" && (process.env.NODE_ENV === "development" || process.env.DEBUG || process.env.IDENTIFY_TAGS);
-  require("esbuild-register/dist/node").register({
-    target: "es2019",
-    format: "cjs"
-  });
   let loadedTamaguiConfig;
   let hasLogged = false;
   return {
@@ -70,12 +83,18 @@ function createExtractor() {
       if (!Array.isArray(props.components)) {
         throw new Error(`Must provide components array with list of Tamagui component modules`);
       }
+      const ogDebug = shouldPrintDebug;
+      const tm = timer();
       const { components, tamaguiConfig } = loadTamagui({
         config,
         components: props.components || ["tamagui"]
       });
+      if (shouldPrintDebug === "verbose") {
+        console.log("tamagui.config.ts:", { components, config });
+      }
+      tm.mark("load-tamagui", shouldPrintDebug === "verbose");
       loadedTamaguiConfig = tamaguiConfig;
-      const defaultTheme = tamaguiConfig.themes[Object.keys(tamaguiConfig.themes)[0]];
+      const defaultTheme = proxyThemeVariables(tamaguiConfig.themes[Object.keys(tamaguiConfig.themes)[0]]);
       const body = fileOrPath.type === "Program" ? fileOrPath.get("body") : fileOrPath.program.body;
       const isInternalImport = /* @__PURE__ */ __name((importStr) => {
         return isInsideTamagui(sourcePath) && importStr[0] === ".";
@@ -87,17 +106,26 @@ function createExtractor() {
         obj[name] = components[name];
         return obj;
       }, {});
+      if (shouldPrintDebug === "verbose") {
+        console.log("validComponents", Object.keys(validComponents));
+      }
       let doesUseValidImport = false;
+      let hasImportedTheme = false;
       for (const bodyPath of body) {
         if (bodyPath.type !== "ImportDeclaration")
           continue;
         const node = "node" in bodyPath ? bodyPath.node : bodyPath;
         const from = node.source.value;
-        if (props.components.includes(from) || isInternalImport(from)) {
-          if (node.specifiers.some((specifier) => {
+        const isValidImport = props.components.includes(from) || isInternalImport(from);
+        if (isValidImport) {
+          const isValidComponent = node.specifiers.some((specifier) => {
             const name = specifier.local.name;
             return validComponents[name] || validHooks[name];
-          })) {
+          });
+          if (shouldPrintDebug === "verbose") {
+            console.log("import from", from, { isValidComponent });
+          }
+          if (isValidComponent) {
             doesUseValidImport = true;
             break;
           }
@@ -109,6 +137,7 @@ function createExtractor() {
       if (!doesUseValidImport) {
         return null;
       }
+      tm.mark("import-check", shouldPrintDebug === "verbose");
       let couldntParse = false;
       const modifiedComponents = /* @__PURE__ */ new Set();
       const bindingCache = {};
@@ -130,6 +159,7 @@ function createExtractor() {
         },
         JSXElement(traversePath) {
           var _a, _b, _c, _d, _e;
+          tm.mark("jsx-element", shouldPrintDebug === "verbose");
           const node = traversePath.node.openingElement;
           const ogAttributes = node.attributes;
           const componentName = findComponentName(traversePath.scope);
@@ -156,579 +186,772 @@ function createExtractor() {
           }
           const originalNodeName = node.name.name;
           res.found++;
-          if (shouldPrintDebug) {
-            console.log(`
-<${originalNodeName} />`);
-          }
-          const filePath = sourcePath.replace(process.cwd(), ".");
+          const filePath = `./${relative(process.cwd(), sourcePath)}`;
           const lineNumbers = node.loc ? node.loc.start.line + (node.loc.start.line !== node.loc.end.line ? `-${node.loc.end.line}` : "") : "";
-          if (shouldAddDebugProp && !disableDebugAttr) {
-            const preName = componentName ? `${componentName}.` : "";
-            res.modified++;
-            node.attributes.unshift(t.jsxAttribute(t.jsxIdentifier("data-is"), t.stringLiteral(`${preName}${node.name.name}@${filePath.replace("./", "")}:${lineNumbers}`)));
-          }
-          const shouldLog = !hasLogged;
-          if (shouldLog) {
-            const prefix = "      |";
-            console.log(prefixLogs || prefix, "                          total \xB7 optimized \xB7 flattened ");
-            hasLogged = true;
-          }
-          if (disableExtraction) {
-            return;
-          }
-          const { staticConfig } = component;
-          const isTextView = staticConfig.isText || false;
-          const validStyles = (_a = staticConfig == null ? void 0 : staticConfig.validStyles) != null ? _a : {};
-          function isValidStyleKey(name) {
-            var _a2;
-            return !!(!!validStyles[name] || !!pseudos[name] || ((_a2 = staticConfig.variants) == null ? void 0 : _a2[name]) || tamaguiConfig.shorthands[name] || (name[0] === "$" ? !!mediaQueryConfig[name.slice(1)] : false));
-          }
-          __name(isValidStyleKey, "isValidStyleKey");
-          let tagName = (_c = (_b = staticConfig.defaultProps) == null ? void 0 : _b.tag) != null ? _c : isTextView ? "span" : "div";
-          traversePath.get("openingElement").get("attributes").forEach((path) => {
-            const attr = path.node;
-            if (t.isJSXSpreadAttribute(attr))
-              return;
-            if (attr.name.name !== "tag")
-              return;
-            const val = attr.value;
-            if (!t.isStringLiteral(val))
-              return;
-            tagName = val.value;
-          });
-          const flatNode = getFlattenedNode({ isTextView, tag: tagName });
-          const inlineProps = /* @__PURE__ */ new Set([
-            ...props.inlineProps || [],
-            ...staticConfig.inlineProps || []
-          ]);
-          const deoptProps = /* @__PURE__ */ new Set([
-            ...props.deoptProps || [],
-            ...staticConfig.deoptProps || []
-          ]);
-          const staticNamespace = getStaticBindingsForScope(traversePath.scope, importsWhitelist, sourcePath, bindingCache, shouldPrintDebug);
-          const attemptEval = !evaluateVars ? evaluateAstNode : createEvaluator({
-            tamaguiConfig,
-            staticNamespace,
-            sourcePath,
-            traversePath,
-            shouldPrintDebug
-          });
-          const attemptEvalSafe = createSafeEvaluator(attemptEval);
-          if (shouldPrintDebug) {
-            console.log("  staticNamespace", Object.keys(staticNamespace).join(", "));
+          const tagId = [componentName, `${node.name.name}`, `${filePath}:${lineNumbers}`].filter(Boolean);
+          const debugPropValue = node.attributes.filter((n) => t.isJSXAttribute(n) && t.isJSXIdentifier(n.name) && n.name.name === "debug").map((n) => {
+            if (n.value === null)
+              return true;
+            if (t.isStringLiteral(n.value))
+              return n.value.value;
+            return false;
+          })[0];
+          if (debugPropValue) {
+            shouldPrintDebug = debugPropValue;
           }
-          const flattenedAttrs = [];
-          traversePath.get("openingElement").get("attributes").forEach((path) => {
-            const attr = path.node;
-            if (!t.isJSXSpreadAttribute(attr)) {
-              flattenedAttrs.push(attr);
-              return;
-            }
-            let arg;
-            try {
-              arg = attemptEval(attr.argument);
-            } catch (e) {
-              if (shouldPrintDebug) {
-                console.log("  couldnt parse spread", e.message);
-              }
-              flattenedAttrs.push(attr);
-              return;
-            }
-            if (arg !== void 0) {
-              try {
-                if (typeof arg !== "object" || arg == null) {
-                  if (shouldPrintDebug) {
-                    console.log("  non object or null arg", arg);
-                  }
-                  flattenedAttrs.push(attr);
-                } else {
-                  for (const k in arg) {
-                    const value = arg[k];
-                    if (!value && typeof value === "object") {
-                      console.log("shouldnt we handle this?", k, value, arg);
-                      continue;
+          try {
+            let isValidStyleKey = function(name) {
+              var _a2;
+              return !!(!!validStyles[name] || !!pseudos[name] || ((_a2 = staticConfig.variants) == null ? void 0 : _a2[name]) || tamaguiConfig.shorthands[name] || (name[0] === "$" ? !!mediaQueryConfig[name.slice(1)] : false));
+            }, evaluateAttribute = function(path) {
+              const attribute = path.node;
+              const attr = { type: "attr", value: attribute };
+              if (t.isJSXSpreadAttribute(attribute)) {
+                const arg = attribute.argument;
+                const conditional = t.isConditionalExpression(arg) ? [arg.test, arg.consequent, arg.alternate] : t.isLogicalExpression(arg) && arg.operator === "&&" ? [arg.left, arg.right, null] : null;
+                if (conditional) {
+                  const [test, alt, cons] = conditional;
+                  if (!test)
+                    throw new Error(`no test`);
+                  if ([alt, cons].some((side) => side && !isExtractable(side))) {
+                    if (shouldPrintDebug) {
+                      console.log("not extractable", alt, cons);
                     }
-                    flattenedAttrs.push(t.jsxAttribute(t.jsxIdentifier(k), t.jsxExpressionContainer(literalToAst(value))));
+                    return attr;
                   }
+                  return [
+                    ...createTernariesFromObjectProperties(test, alt) || [],
+                    ...cons && createTernariesFromObjectProperties(t.unaryExpression("!", test), cons) || []
+                  ].map((ternary) => ({
+                    type: "ternary",
+                    value: ternary
+                  }));
                 }
-              } catch (err) {
-                console.warn("cant parse spread, caught err", err);
-                couldntParse = true;
-              }
-            }
-          });
-          if (couldntParse) {
-            return;
-          }
-          node.attributes = flattenedAttrs;
-          if (staticConfig.defaultProps) {
-            for (const key in staticConfig.defaultProps) {
-              if (isValidStyleKey(key)) {
-                continue;
               }
-              const serialize = require("babel-literal-to-ast");
-              const val = staticConfig.defaultProps[key];
-              try {
-                const serializedDefaultProp = serialize(val);
-                node.attributes.unshift(t.jsxAttribute(t.jsxIdentifier(key), typeof val === "string" ? t.stringLiteral(val) : t.jsxExpressionContainer(serializedDefaultProp)));
-              } catch (err) {
-                console.warn(`\u26A0\uFE0F Error evaluating default prop for component ${node.name.name}, prop ${key}
- error: ${err}
- value:`, val, "\n defaultProps:", staticConfig.defaultProps);
-              }
-            }
-          }
-          let attrs = [];
-          let shouldDeopt = false;
-          let inlinePropCount = 0;
-          let hasSetOptimized = false;
-          attrs = traversePath.get("openingElement").get("attributes").flatMap((path) => {
-            try {
-              const res2 = evaluateAttribute(path);
-              if (!res2) {
-                path.remove();
-              }
-              return res2;
-            } catch (err) {
-              if (shouldPrintDebug) {
-                console.log("Error extracting attribute", err.message, err.stack);
-                console.log("node", path.node);
+              if (t.isJSXSpreadAttribute(attribute) || !attribute.name || typeof attribute.name.name !== "string") {
+                if (shouldPrintDebug) {
+                  console.log("  ! inlining, spread attr");
+                }
+                inlined.set(`${Math.random()}`, "spread");
+                return attr;
               }
-              return {
-                type: "attr",
-                value: path.node
-              };
-            }
-          }).flat(4).filter(isPresent);
-          if (shouldPrintDebug) {
-            console.log("  - attrs (before):\n", logLines(attrs.map(attrStr).join(", ")));
-          }
-          function evaluateAttribute(path) {
-            const attribute = path.node;
-            const attr = { type: "attr", value: attribute };
-            if (t.isJSXSpreadAttribute(attribute)) {
-              const arg = attribute.argument;
-              const conditional = t.isConditionalExpression(arg) ? [arg.test, arg.consequent, arg.alternate] : t.isLogicalExpression(arg) && arg.operator === "&&" ? [arg.left, arg.right, null] : null;
-              if (conditional) {
-                const [test, alt, cons] = conditional;
-                if (!test)
-                  throw new Error(`no test`);
-                if ([alt, cons].some((side) => side && !isExtractable(side))) {
-                  if (shouldPrintDebug) {
-                    console.log("not extractable", alt, cons);
-                  }
-                  return attr;
+              const name = attribute.name.name;
+              if (excludeProps == null ? void 0 : excludeProps.has(name)) {
+                if (shouldPrintDebug) {
+                  console.log("  excluding prop", name);
                 }
-                return [
-                  ...createTernariesFromObjectProperties(test, alt) || [],
-                  ...cons && createTernariesFromObjectProperties(t.unaryExpression("!", test), cons) || []
-                ].map((ternary) => ({
-                  type: "ternary",
-                  value: ternary
-                }));
+                return null;
               }
-            }
-            if (t.isJSXSpreadAttribute(attribute) || !attribute.name || typeof attribute.name.name !== "string") {
-              if (shouldPrintDebug) {
-                console.log("  ! inlining, spread attr");
+              if (inlineProps.has(name)) {
+                inlined.set(name, name);
+                if (shouldPrintDebug) {
+                  console.log("  ! inlining, inline prop", name);
+                }
+                return attr;
               }
-              inlinePropCount++;
-              return attr;
-            }
-            const name = attribute.name.name;
-            if (excludeProps == null ? void 0 : excludeProps.has(name)) {
-              if (shouldPrintDebug) {
-                console.log("  excluding prop", name);
+              if (deoptProps.has(name)) {
+                shouldDeopt = true;
+                inlined.set(name, name);
+                if (shouldPrintDebug) {
+                  console.log("  ! inlining, deopted prop", name);
+                }
+                return attr;
               }
-              return null;
-            }
-            if (inlineProps.has(name)) {
-              inlinePropCount++;
-              if (shouldPrintDebug) {
-                console.log("  ! inlining, inline prop", name);
+              if (UNTOUCHED_PROPS[name]) {
+                return attr;
               }
-              return attr;
-            }
-            if (deoptProps.has(name)) {
-              shouldDeopt = true;
-              inlinePropCount++;
-              if (shouldPrintDebug) {
-                console.log("  ! inlining, deopted prop", name);
+              if (INLINE_EXTRACTABLE[name]) {
+                inlined.set(name, INLINE_EXTRACTABLE[name]);
+                return attr;
               }
-              return attr;
-            }
-            if (UNTOUCHED_PROPS[name]) {
-              return attr;
-            }
-            if (name.startsWith("data-")) {
-              return attr;
-            }
-            if (name[0] === "$" && t.isJSXExpressionContainer(attribute == null ? void 0 : attribute.value)) {
-              if (disableExtractInlineMedia) {
+              if (name.startsWith("data-")) {
                 return attr;
               }
-              const shortname = name.slice(1);
-              if (mediaQueryConfig[shortname]) {
-                const expression = attribute.value.expression;
-                if (!t.isJSXEmptyExpression(expression)) {
-                  const ternaries2 = createTernariesFromObjectProperties(t.stringLiteral(shortname), expression, {
-                    inlineMediaQuery: shortname
-                  });
-                  if (ternaries2) {
-                    return ternaries2.map((value2) => ({
-                      type: "ternary",
-                      value: value2
-                    }));
+              if (name[0] === "$" && t.isJSXExpressionContainer(attribute == null ? void 0 : attribute.value)) {
+                if (disableExtractInlineMedia) {
+                  return attr;
+                }
+                const shortname = name.slice(1);
+                if (mediaQueryConfig[shortname]) {
+                  const expression = attribute.value.expression;
+                  if (!t.isJSXEmptyExpression(expression)) {
+                    const ternaries2 = createTernariesFromObjectProperties(t.stringLiteral(shortname), expression, {
+                      inlineMediaQuery: shortname
+                    });
+                    if (ternaries2) {
+                      return ternaries2.map((value2) => ({
+                        type: "ternary",
+                        value: value2
+                      }));
+                    }
                   }
                 }
               }
-            }
-            const [value, valuePath] = (() => {
-              if (t.isJSXExpressionContainer(attribute == null ? void 0 : attribute.value)) {
-                return [attribute.value.expression, path.get("value")];
-              } else {
-                return [attribute.value, path.get("value")];
+              const [value, valuePath] = (() => {
+                if (t.isJSXExpressionContainer(attribute == null ? void 0 : attribute.value)) {
+                  return [attribute.value.expression, path.get("value")];
+                } else {
+                  return [attribute.value, path.get("value")];
+                }
+              })();
+              const remove = /* @__PURE__ */ __name(() => {
+                Array.isArray(valuePath) ? valuePath.map((p) => p.remove()) : valuePath.remove();
+              }, "remove");
+              if (name === "ref") {
+                if (shouldPrintDebug) {
+                  console.log("  ! inlining, ref", name);
+                }
+                inlined.set("ref", "ref");
+                return attr;
               }
-            })();
-            const remove = /* @__PURE__ */ __name(() => {
-              Array.isArray(valuePath) ? valuePath.map((p) => p.remove()) : valuePath.remove();
-            }, "remove");
-            if (name === "ref") {
-              if (shouldPrintDebug) {
-                console.log("  ! inlining, ref", name);
+              if (name === "tag") {
+                return {
+                  type: "attr",
+                  value: path.node
+                };
               }
-              inlinePropCount++;
-              return attr;
-            }
-            if (name === "tag") {
-              return {
-                type: "attr",
-                value: path.node
-              };
-            }
-            if (disableExtractVariables) {
-              if (value) {
-                if (value.type === "StringLiteral" && value.value[0] === "$") {
-                  if (shouldPrintDebug) {
-                    console.log(`  ! inlining, native disable extract: ${name} =`, value.value);
+              if (disableExtractVariables) {
+                if (value) {
+                  if (value.type === "StringLiteral" && value.value[0] === "$") {
+                    if (shouldPrintDebug) {
+                      console.log(`  ! inlining, native disable extract: ${name} =`, value.value);
+                    }
+                    inlined.set(name, true);
+                    return attr;
                   }
-                  inlinePropCount++;
-                  return attr;
                 }
               }
-            }
-            const styleValue = attemptEvalSafe(value);
-            if (!isValidStyleKey(name)) {
-              let keys = [name];
-              let out = null;
-              if (staticConfig.propMapper) {
-                out = staticConfig.propMapper(name, styleValue, defaultTheme, staticConfig.defaultProps, staticConfig);
-                if (out) {
-                  out = rnw.createDOMProps(isTextView ? "span" : "div", out);
-                  delete out.className;
-                  keys = Object.keys(out);
-                }
+              if (name === "theme") {
+                inlined.set("theme", attr.value);
+                return attr;
               }
-              const attributes = keys.map((key) => {
-                const val = out[key];
-                if (!isValidStyleKey(key)) {
-                  if (validHTMLAttributes[key]) {
+              const styleValue = attemptEvalSafe(value);
+              if (!isValidStyleKey(name)) {
+                let keys = [name];
+                let out = null;
+                if (staticConfig.propMapper) {
+                  out = staticConfig.propMapper(name, styleValue, defaultTheme, staticConfig.defaultProps, "auto");
+                  if (out) {
+                    out = rnw.createDOMProps(isTextView ? "span" : "div", out);
+                    delete out.className;
+                    keys = Object.keys(out);
+                  }
+                }
+                let didInline = false;
+                const attributes = keys.map((key) => {
+                  const val = out[key];
+                  if (isValidStyleKey(key)) {
                     return {
-                      type: "attr",
-                      value: t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(literalToAst(val)))
+                      type: "style",
+                      value: { [name]: styleValue },
+                      name,
+                      attr: path.node
                     };
                   }
+                  if (validHTMLAttributes[key]) {
+                    return attr;
+                  }
                   if (shouldPrintDebug) {
                     console.log("  ! inlining, non-static", key);
                   }
-                  inlinePropCount++;
+                  didInline = true;
+                  inlined.set(key, val);
+                  return val;
+                });
+                if (didInline) {
+                  if (shouldPrintDebug) {
+                    console.log("  bailing flattening due to attributes", attributes);
+                  }
+                  return attr;
                 }
-                return {
-                  type: "style",
-                  value: { [name]: styleValue },
-                  name,
-                  attr: path.node
-                };
-              });
-              if (inlinePropCount) {
-                return attr;
+                return attributes;
               }
-              return attributes;
-            }
-            if (styleValue !== FAILED_EVAL) {
-              if (shouldPrintDebug) {
-                console.log(`  style: ${name} =`, styleValue);
-              }
-              if (!(name in staticConfig.defaultProps)) {
-                if (!hasSetOptimized) {
-                  res.optimized++;
-                  hasSetOptimized = true;
+              if (styleValue !== FAILED_EVAL) {
+                if (isValidStyleKey(name)) {
+                  if (shouldPrintDebug) {
+                    console.log(`  style: ${name} =`, styleValue);
+                  }
+                  if (!(name in staticConfig.defaultProps)) {
+                    if (!hasSetOptimized) {
+                      res.optimized++;
+                      hasSetOptimized = true;
+                    }
+                  }
+                  return {
+                    type: "style",
+                    value: { [name]: styleValue },
+                    name,
+                    attr: path.node
+                  };
+                } else {
+                  inlined.set(name, true);
+                  return attr;
                 }
               }
-              return {
-                type: "style",
-                value: { [name]: styleValue },
-                name,
-                attr: path.node
-              };
-            }
-            if (t.isBinaryExpression(value)) {
-              if (shouldPrintDebug) {
-                console.log(` binary expression ${name} = `, value);
-              }
-              const { operator, left, right } = value;
-              const lVal = attemptEvalSafe(left);
-              const rVal = attemptEvalSafe(right);
-              if (shouldPrintDebug) {
-                console.log(`  evalBinaryExpression lVal ${String(lVal)}, rVal ${String(rVal)}`);
+              if (t.isBinaryExpression(value)) {
+                if (shouldPrintDebug) {
+                  console.log(` binary expression ${name} = `, value);
+                }
+                const { operator, left, right } = value;
+                const lVal = attemptEvalSafe(left);
+                const rVal = attemptEvalSafe(right);
+                if (shouldPrintDebug) {
+                  console.log(`  evalBinaryExpression lVal ${String(lVal)}, rVal ${String(rVal)}`);
+                }
+                if (lVal !== FAILED_EVAL && t.isConditionalExpression(right)) {
+                  const ternary = addBinaryConditional(operator, left, right);
+                  if (ternary)
+                    return ternary;
+                }
+                if (rVal !== FAILED_EVAL && t.isConditionalExpression(left)) {
+                  const ternary = addBinaryConditional(operator, right, left);
+                  if (ternary)
+                    return ternary;
+                }
+                if (shouldPrintDebug) {
+                  console.log(`  evalBinaryExpression cant extract`);
+                }
+                inlined.set(name, true);
+                return attr;
               }
-              if (lVal !== FAILED_EVAL && t.isConditionalExpression(right)) {
-                const ternary = addBinaryConditional(operator, left, right);
-                if (ternary)
-                  return ternary;
+              const staticConditional = getStaticConditional(value);
+              if (staticConditional) {
+                if (shouldPrintDebug === "verbose") {
+                  console.log(` static conditional ${name}`, value);
+                }
+                return { type: "ternary", value: staticConditional };
               }
-              if (rVal !== FAILED_EVAL && t.isConditionalExpression(left)) {
-                const ternary = addBinaryConditional(operator, right, left);
-                if (ternary)
-                  return ternary;
+              const staticLogical = getStaticLogical(value);
+              if (staticLogical) {
+                if (shouldPrintDebug === "verbose") {
+                  console.log(` static ternary ${name} = `, value);
+                }
+                return { type: "ternary", value: staticLogical };
               }
+              inlined.set(name, true);
               if (shouldPrintDebug) {
-                console.log(`  evalBinaryExpression cant extract`);
+                console.log(` ! inline no match ${name}`, value);
               }
-              inlinePropCount++;
               return attr;
-            }
-            const staticConditional = getStaticConditional(value);
-            if (staticConditional) {
-              if (shouldPrintDebug) {
-                console.log(` static conditional ${name} = `, value);
-              }
-              return { type: "ternary", value: staticConditional };
-            }
-            const staticLogical = getStaticLogical(value);
-            if (staticLogical) {
-              if (shouldPrintDebug) {
-                console.log(` static ternary ${name} = `, value);
-              }
-              return { type: "ternary", value: staticLogical };
-            }
-            if (shouldPrintDebug) {
-              console.log("  ! inline prop via no match", name, value.type);
-            }
-            inlinePropCount++;
-            if (shouldPrintDebug) {
-              console.log(` inlining ${name} = `, value);
-            }
-            return attr;
-            function addBinaryConditional(operator, staticExpr, cond) {
-              if (getStaticConditional(cond)) {
-                const alt = attemptEval(t.binaryExpression(operator, staticExpr, cond.alternate));
-                const cons = attemptEval(t.binaryExpression(operator, staticExpr, cond.consequent));
-                if (shouldPrintDebug) {
-                  console.log("  binaryConditional", cond.test, cons, alt);
-                }
-                return {
-                  type: "ternary",
-                  value: {
-                    test: cond.test,
-                    remove,
-                    alternate: { [name]: alt },
-                    consequent: { [name]: cons }
-                  }
-                };
-              }
-              return null;
-            }
-            __name(addBinaryConditional, "addBinaryConditional");
-            function getStaticConditional(value2) {
-              if (t.isConditionalExpression(value2)) {
-                try {
-                  if (shouldPrintDebug) {
-                    console.log("attempt", value2.alternate, value2.consequent);
-                  }
-                  const aVal = attemptEval(value2.alternate);
-                  const cVal = attemptEval(value2.consequent);
+              function addBinaryConditional(operator, staticExpr, cond) {
+                if (getStaticConditional(cond)) {
+                  const alt = attemptEval(t.binaryExpression(operator, staticExpr, cond.alternate));
+                  const cons = attemptEval(t.binaryExpression(operator, staticExpr, cond.consequent));
                   if (shouldPrintDebug) {
-                    const type = value2.test.type;
-                    console.log("      static ternary", type, cVal, aVal);
+                    console.log("  binaryConditional", cond.test, cons, alt);
                   }
                   return {
-                    test: value2.test,
-                    remove,
-                    consequent: { [name]: cVal },
-                    alternate: { [name]: aVal }
+                    type: "ternary",
+                    value: {
+                      test: cond.test,
+                      remove,
+                      alternate: { [name]: alt },
+                      consequent: { [name]: cons }
+                    }
                   };
-                } catch (err) {
-                  if (shouldPrintDebug) {
-                    console.log("       cant eval ternary", err.message);
-                  }
                 }
+                return null;
               }
-              return null;
-            }
-            __name(getStaticConditional, "getStaticConditional");
-            function getStaticLogical(value2) {
-              if (t.isLogicalExpression(value2)) {
-                if (value2.operator === "&&") {
+              __name(addBinaryConditional, "addBinaryConditional");
+              function getStaticConditional(value2) {
+                if (t.isConditionalExpression(value2)) {
                   try {
-                    const val = attemptEval(value2.right);
+                    const aVal = attemptEval(value2.alternate);
+                    const cVal = attemptEval(value2.consequent);
                     if (shouldPrintDebug) {
-                      console.log("  staticLogical", value2.left, name, val);
+                      const type = value2.test.type;
+                      console.log("      static ternary", type, cVal, aVal);
                     }
                     return {
-                      test: value2.left,
+                      test: value2.test,
                       remove,
-                      consequent: { [name]: val },
-                      alternate: null
+                      consequent: { [name]: cVal },
+                      alternate: { [name]: aVal }
                     };
                   } catch (err) {
                     if (shouldPrintDebug) {
-                      console.log("  cant static eval logical", err);
+                      console.log("       cant eval ternary", err.message);
                     }
                   }
                 }
+                return null;
               }
-              return null;
+              __name(getStaticConditional, "getStaticConditional");
+              function getStaticLogical(value2) {
+                if (t.isLogicalExpression(value2)) {
+                  if (value2.operator === "&&") {
+                    try {
+                      const val = attemptEval(value2.right);
+                      if (shouldPrintDebug) {
+                        console.log("  staticLogical", value2.left, name, val);
+                      }
+                      return {
+                        test: value2.left,
+                        remove,
+                        consequent: { [name]: val },
+                        alternate: null
+                      };
+                    } catch (err) {
+                      if (shouldPrintDebug) {
+                        console.log("  cant static eval logical", err);
+                      }
+                    }
+                  }
+                }
+                return null;
+              }
+              __name(getStaticLogical, "getStaticLogical");
+            }, isExtractable = function(obj) {
+              return t.isObjectExpression(obj) && obj.properties.every((prop) => {
+                if (!t.isObjectProperty(prop)) {
+                  console.log("not object prop", prop);
+                  return false;
+                }
+                const propName = prop.key["name"];
+                if (!isValidStyleKey(propName) && propName !== "tag") {
+                  if (shouldPrintDebug) {
+                    console.log("  not a valid style prop!", propName);
+                  }
+                  return false;
+                }
+                return true;
+              });
+            }, createTernariesFromObjectProperties = function(test, side, ternaryPartial = {}) {
+              if (!side) {
+                return null;
+              }
+              if (!isExtractable(side)) {
+                throw new Error("not extractable");
+              }
+              return side.properties.flatMap((property) => {
+                if (!t.isObjectProperty(property)) {
+                  throw new Error("expected object property");
+                }
+                if (t.isIdentifier(property.key)) {
+                  const key = property.key.name;
+                  const mediaQueryKey = key.slice(1);
+                  const isMediaQuery = key[0] === "$" && mediaQueryConfig[mediaQueryKey];
+                  if (isMediaQuery) {
+                    if (t.isExpression(property.value)) {
+                      const ternaries2 = createTernariesFromObjectProperties(t.stringLiteral(mediaQueryKey), property.value, {
+                        inlineMediaQuery: mediaQueryKey
+                      });
+                      if (ternaries2) {
+                        return ternaries2.map((value) => ({
+                          ...ternaryPartial,
+                          ...value,
+                          test: t.logicalExpression("&&", value.test, test)
+                        }));
+                      } else {
+                        console.log("\u26A0\uFE0F no ternaries?", property);
+                      }
+                    } else {
+                      console.log("\u26A0\uFE0F not expression", property);
+                    }
+                  }
+                }
+                if (t.isConditionalExpression(property.value)) {
+                  const [truthy, falsy] = [
+                    t.objectExpression([t.objectProperty(property.key, property.value.consequent)]),
+                    t.objectExpression([t.objectProperty(property.key, property.value.alternate)])
+                  ].map((x) => attemptEval(x));
+                  return [
+                    createTernary({
+                      remove() {
+                      },
+                      ...ternaryPartial,
+                      test: t.logicalExpression("&&", test, property.value.test),
+                      consequent: truthy,
+                      alternate: null
+                    }),
+                    createTernary({
+                      ...ternaryPartial,
+                      test: t.logicalExpression("&&", test, t.unaryExpression("!", property.value.test)),
+                      consequent: falsy,
+                      alternate: null,
+                      remove() {
+                      }
+                    })
+                  ];
+                }
+                const obj = t.objectExpression([t.objectProperty(property.key, property.value)]);
+                const consequent = attemptEval(obj);
+                return createTernary({
+                  remove() {
+                  },
+                  ...ternaryPartial,
+                  test,
+                  consequent,
+                  alternate: null
+                });
+              });
+            }, mergeStyles = function(prev2, next) {
+              normalizeStyleObject(next);
+              for (const key in next) {
+                if (pseudos[key]) {
+                  prev2[key] = prev2[key] || {};
+                  if (shouldPrintDebug) {
+                    if (!next[key] || !prev2[key]) {
+                      console.log("warn: missing", key, prev2, next);
+                    }
+                  }
+                  Object.assign(prev2[key], next[key]);
+                } else {
+                  prev2[key] = next[key];
+                }
+              }
+            };
+            __name(isValidStyleKey, "isValidStyleKey");
+            __name(evaluateAttribute, "evaluateAttribute");
+            __name(isExtractable, "isExtractable");
+            __name(createTernariesFromObjectProperties, "createTernariesFromObjectProperties");
+            __name(mergeStyles, "mergeStyles");
+            node.attributes.find((n) => t.isJSXAttribute(n) && t.isJSXIdentifier(n.name) && n.name.name === "debug" && n.value === null);
+            if (shouldPrintDebug) {
+              console.log("\n");
+              console.log("\x1B[33m%s\x1B[0m", `${tagId[0]} | ${tagId[2]} -------------------`);
+              console.log("\x1B[1m", "\x1B[32m", `<${originalNodeName} />`);
             }
-            __name(getStaticLogical, "getStaticLogical");
-          }
-          __name(evaluateAttribute, "evaluateAttribute");
-          function isExtractable(obj) {
-            return t.isObjectExpression(obj) && obj.properties.every((prop) => {
-              if (!t.isObjectProperty(prop)) {
-                console.log("not object prop", prop);
-                return false;
+            if (shouldAddDebugProp && !disableDebugAttr) {
+              res.modified++;
+              node.attributes.unshift(t.jsxAttribute(t.jsxIdentifier("data-is"), t.stringLiteral(tagId.join(" "))));
+            }
+            const shouldLog = !hasLogged;
+            if (shouldLog) {
+              const prefix = "      |";
+              console.log(prefixLogs || prefix, "                          total \xB7 optimized \xB7 flattened ");
+              hasLogged = true;
+            }
+            if (disableExtraction) {
+              return;
+            }
+            const { staticConfig } = component;
+            const isTextView = staticConfig.isText || false;
+            const validStyles = (_a = staticConfig == null ? void 0 : staticConfig.validStyles) != null ? _a : {};
+            let tagName = (_c = (_b = staticConfig.defaultProps) == null ? void 0 : _b.tag) != null ? _c : isTextView ? "span" : "div";
+            traversePath.get("openingElement").get("attributes").forEach((path) => {
+              const attr = path.node;
+              if (t.isJSXSpreadAttribute(attr))
+                return;
+              if (attr.name.name !== "tag")
+                return;
+              const val = attr.value;
+              if (!t.isStringLiteral(val))
+                return;
+              tagName = val.value;
+            });
+            const flatNode = getFlattenedNode({ isTextView, tag: tagName });
+            const inlineProps = /* @__PURE__ */ new Set([
+              ...props.inlineProps || [],
+              ...staticConfig.inlineProps || []
+            ]);
+            const deoptProps = /* @__PURE__ */ new Set([
+              "animation",
+              ...props.deoptProps || [],
+              ...staticConfig.deoptProps || []
+            ]);
+            const staticNamespace = getStaticBindingsForScope(traversePath.scope, importsWhitelist, sourcePath, bindingCache, shouldPrintDebug);
+            const attemptEval = !evaluateVars ? evaluateAstNode : createEvaluator({
+              tamaguiConfig,
+              staticNamespace,
+              sourcePath,
+              traversePath,
+              shouldPrintDebug
+            });
+            const attemptEvalSafe = createSafeEvaluator(attemptEval);
+            if (shouldPrintDebug) {
+              console.log("  staticNamespace", Object.keys(staticNamespace).join(", "));
+            }
+            const flattenedAttrs = [];
+            traversePath.get("openingElement").get("attributes").forEach((path) => {
+              const attr = path.node;
+              if (!t.isJSXSpreadAttribute(attr)) {
+                flattenedAttrs.push(attr);
+                return;
               }
-              const propName = prop.key["name"];
-              if (!isValidStyleKey(propName) && propName !== "tag") {
+              let arg;
+              try {
+                arg = attemptEval(attr.argument);
+              } catch (e) {
                 if (shouldPrintDebug) {
-                  console.log("  not a valid style prop!", propName);
+                  console.log("  couldnt parse spread", e.message);
+                }
+                flattenedAttrs.push(attr);
+                return;
+              }
+              if (arg !== void 0) {
+                try {
+                  if (typeof arg !== "object" || arg == null) {
+                    if (shouldPrintDebug) {
+                      console.log("  non object or null arg", arg);
+                    }
+                    flattenedAttrs.push(attr);
+                  } else {
+                    for (const k in arg) {
+                      const value = arg[k];
+                      if (!value && typeof value === "object") {
+                        console.log("shouldnt we handle this?", k, value, arg);
+                        continue;
+                      }
+                      flattenedAttrs.push(t.jsxAttribute(t.jsxIdentifier(k), t.jsxExpressionContainer(literalToAst(value))));
+                    }
+                  }
+                } catch (err) {
+                  console.warn("cant parse spread, caught err", err);
+                  couldntParse = true;
                 }
-                return false;
               }
-              return true;
             });
-          }
-          __name(isExtractable, "isExtractable");
-          function createTernariesFromObjectProperties(test, side, ternaryPartial = {}) {
-            if (!side) {
-              return null;
+            if (couldntParse) {
+              return;
+            }
+            tm.mark("jsx-element-flattened", shouldPrintDebug === "verbose");
+            node.attributes = flattenedAttrs;
+            if (staticConfig.defaultProps) {
+              for (const key in staticConfig.defaultProps) {
+                if (isValidStyleKey(key)) {
+                  continue;
+                }
+                const serialize = require("babel-literal-to-ast");
+                const val = staticConfig.defaultProps[key];
+                try {
+                  const serializedDefaultProp = serialize(val);
+                  node.attributes.unshift(t.jsxAttribute(t.jsxIdentifier(key), typeof val === "string" ? t.stringLiteral(val) : t.jsxExpressionContainer(serializedDefaultProp)));
+                } catch (err) {
+                  console.warn(`\u26A0\uFE0F Error evaluating default prop for component ${node.name.name}, prop ${key}
+ error: ${err}
+ value:`, val, "\n defaultProps:", staticConfig.defaultProps);
+                }
+              }
             }
-            if (!isExtractable(side)) {
-              throw new Error("not extractable");
+            let attrs = [];
+            let shouldDeopt = false;
+            const inlined = /* @__PURE__ */ new Map();
+            let hasSetOptimized = false;
+            attrs = traversePath.get("openingElement").get("attributes").flatMap((path) => {
+              try {
+                const res2 = evaluateAttribute(path);
+                tm.mark("jsx-element-evaluate-attr", shouldPrintDebug === "verbose");
+                if (!res2) {
+                  path.remove();
+                }
+                return res2;
+              } catch (err) {
+                if (shouldPrintDebug) {
+                  console.log("Error extracting attribute", err.message, err.stack);
+                  console.log("node", path.node);
+                }
+                return {
+                  type: "attr",
+                  value: path.node
+                };
+              }
+            }).flat(4).filter(isPresent);
+            if (shouldPrintDebug) {
+              console.log("  - attrs (before):\n", logLines(attrs.map(attrStr).join(", ")));
             }
-            return side.properties.flatMap((property) => {
-              if (!t.isObjectProperty(property)) {
-                throw new Error("expected object property");
+            node.attributes = attrs.filter(isAttr).map((x) => x.value);
+            if (couldntParse || shouldDeopt) {
+              if (shouldPrintDebug) {
+                console.log(`  avoid optimizing:`, { couldntParse, shouldDeopt });
               }
-              if (t.isIdentifier(property.key)) {
-                const key = property.key.name;
-                const mediaQueryKey = key.slice(1);
-                const isMediaQuery = key[0] === "$" && mediaQueryConfig[mediaQueryKey];
-                if (isMediaQuery) {
-                  if (t.isExpression(property.value)) {
-                    const ternaries2 = createTernariesFromObjectProperties(t.stringLiteral(mediaQueryKey), property.value, {
-                      inlineMediaQuery: mediaQueryKey
-                    });
-                    if (ternaries2) {
-                      return ternaries2.map((value) => ({
-                        ...ternaryPartial,
-                        ...value,
-                        test: t.logicalExpression("&&", value.test, test)
-                      }));
-                    } else {
-                      console.log("\u26A0\uFE0F no ternaries?", property);
+              node.attributes = ogAttributes;
+              return;
+            }
+            const parentFn = findTopmostFunction(traversePath);
+            if (parentFn) {
+              modifiedComponents.add(parentFn);
+            }
+            let ternaries = [];
+            attrs = attrs.reduce((out, cur) => {
+              const next = attrs[attrs.indexOf(cur) + 1];
+              if (cur.type === "ternary") {
+                ternaries.push(cur.value);
+              }
+              if ((!next || next.type !== "ternary") && ternaries.length) {
+                const normalized = normalizeTernaries(ternaries).map(({ alternate, consequent, ...rest }) => {
+                  return {
+                    type: "ternary",
+                    value: {
+                      ...rest,
+                      alternate: alternate || null,
+                      consequent: consequent || null
                     }
-                  } else {
-                    console.log("\u26A0\uFE0F not expression", property);
+                  };
+                });
+                try {
+                  return [...out, ...normalized];
+                } finally {
+                  if (shouldPrintDebug) {
+                    console.log(`    normalizeTernaries (${ternaries.length} => ${normalized.length})`);
                   }
+                  ternaries = [];
                 }
               }
-              if (t.isConditionalExpression(property.value)) {
-                const [truthy, falsy] = [
-                  t.objectExpression([t.objectProperty(property.key, property.value.consequent)]),
-                  t.objectExpression([t.objectProperty(property.key, property.value.alternate)])
-                ].map((x) => attemptEval(x));
-                return [
-                  createTernary({
-                    remove() {
-                    },
-                    ...ternaryPartial,
-                    test: t.logicalExpression("&&", test, property.value.test),
-                    consequent: truthy,
-                    alternate: null
-                  }),
-                  createTernary({
-                    ...ternaryPartial,
-                    test: t.logicalExpression("&&", test, t.unaryExpression("!", property.value.test)),
-                    consequent: falsy,
-                    alternate: null,
-                    remove() {
-                    }
-                  })
-                ];
+              if (cur.type === "ternary") {
+                return out;
               }
-              const obj = t.objectExpression([t.objectProperty(property.key, property.value)]);
-              const consequent = attemptEval(obj);
-              return createTernary({
-                remove() {
-                },
-                ...ternaryPartial,
-                test,
-                consequent,
-                alternate: null
-              });
-            });
-          }
-          __name(createTernariesFromObjectProperties, "createTernariesFromObjectProperties");
-          node.attributes = attrs.filter(isAttr).map((x) => x.value);
-          if (couldntParse || shouldDeopt) {
+              out.push(cur);
+              return out;
+            }, []).flat();
+            const hasSpread = node.attributes.some((x) => t.isJSXSpreadAttribute(x));
+            const hasOnlyStringChildren = !hasSpread && (node.selfClosing || traversePath.node.children && traversePath.node.children.every((x) => x.type === "JSXText"));
+            let themeVal = inlined.get("theme");
+            inlined.delete("theme");
+            const allOtherPropsExtractable = [...inlined].every(([k, v]) => INLINE_EXTRACTABLE[k]);
+            const shouldWrapThme = allOtherPropsExtractable && !!themeVal;
+            const canFlattenProps = inlined.size === 0 || shouldWrapThme || allOtherPropsExtractable;
+            let shouldFlatten = !shouldDeopt && canFlattenProps && !hasSpread && staticConfig.neverFlatten !== true && (staticConfig.neverFlatten === "jsx" ? hasOnlyStringChildren : true);
             if (shouldPrintDebug) {
-              console.log(`  avoid optimizing:`, { couldntParse, shouldDeopt });
+              console.log(" - flatten?", objToStr({ hasSpread, shouldDeopt, shouldFlatten, canFlattenProps, shouldWrapThme, allOtherPropsExtractable, hasOnlyStringChildren }));
             }
-            node.attributes = ogAttributes;
-            return;
-          }
-          const parentFn = findTopmostFunction(traversePath);
-          if (parentFn) {
-            modifiedComponents.add(parentFn);
-          }
-          let ternaries = [];
-          attrs = attrs.reduce((out, cur) => {
-            const next = attrs[attrs.indexOf(cur) + 1];
-            if (cur.type === "ternary") {
-              ternaries.push(cur.value);
+            if (shouldFlatten && shouldWrapThme) {
+              if (shouldPrintDebug) {
+                console.log("  - wrapping theme", allOtherPropsExtractable, themeVal);
+              }
+              attrs = attrs.filter((x) => x.type === "attr" && t.isJSXAttribute(x.value) && x.value.name.name === "theme" ? false : true);
+              if (!hasImportedTheme) {
+                hasImportedTheme = true;
+                programPath.node.body.push(t.importDeclaration([t.importSpecifier(t.identifier("_TamaguiTheme"), t.identifier("Theme"))], t.stringLiteral("@tamagui/core")));
+              }
+              traversePath.replaceWith(t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier("_TamaguiTheme"), [
+                t.jsxAttribute(t.jsxIdentifier("name"), themeVal.value)
+              ]), t.jsxClosingElement(t.jsxIdentifier("_TamaguiTheme")), [traversePath.node]));
             }
-            if ((!next || next.type !== "ternary") && ternaries.length) {
-              const normalized = normalizeTernaries(ternaries).map(({ alternate, consequent, ...rest }) => {
-                return {
-                  type: "ternary",
-                  value: {
-                    ...rest,
-                    alternate: alternate || null,
-                    consequent: consequent || null
-                  }
+            if (shouldFlatten && staticConfig.defaultProps) {
+              const defaultStyleAttrs = Object.keys(staticConfig.defaultProps).flatMap((key) => {
+                if (!isValidStyleKey(key)) {
+                  return [];
+                }
+                const value = staticConfig.defaultProps[key];
+                const name = tamaguiConfig.shorthands[key] || key;
+                if (value === void 0) {
+                  console.warn(`\u26A0\uFE0F Error evaluating default style for component, prop ${key} ${value}`);
+                  shouldDeopt = true;
+                  return;
+                }
+                const attr = {
+                  type: "style",
+                  name,
+                  value: { [name]: value }
                 };
+                return attr;
               });
-              try {
-                return [...out, ...normalized];
-              } finally {
-                if (shouldPrintDebug) {
-                  console.log(`    normalizeTernaries (${ternaries.length} => ${normalized.length})`);
+              if (defaultStyleAttrs.length) {
+                attrs = [...defaultStyleAttrs, ...attrs];
+              }
+            }
+            if (shouldDeopt) {
+              node.attributes = ogAttributes;
+              return;
+            }
+            const ensureOverridden = {};
+            if (!shouldFlatten) {
+              for (const cur of attrs) {
+                if (cur.type === "style") {
+                  for (const key in cur.value) {
+                    const shouldEnsureOverridden = !!((_d = staticConfig.ensureOverriddenProp) == null ? void 0 : _d[key]);
+                    const isSetInAttrsAlready = attrs.some((x) => x.type === "attr" && x.value.type === "JSXAttribute" && x.value.name.name === key);
+                    if (!isSetInAttrsAlready) {
+                      const isVariant = !!((_e = staticConfig.variants) == null ? void 0 : _e[cur.name || ""]);
+                      if (isVariant || shouldEnsureOverridden) {
+                        ensureOverridden[key] = true;
+                      }
+                    }
+                  }
                 }
-                ternaries = [];
               }
             }
-            if (cur.type === "ternary") {
-              return out;
+            if (shouldPrintDebug) {
+              console.log("  - attrs (flattened): \n", logLines(attrs.map(attrStr).join(", ")));
+              console.log("  - ensureOverriden:", Object.keys(ensureOverridden).join(", "));
+            }
+            attrs = attrs.reduce((acc, cur) => {
+              if (!cur) {
+                return acc;
+              }
+              if (cur.type === "attr" && !t.isJSXSpreadAttribute(cur.value)) {
+                if (shouldFlatten) {
+                  if (cur.value.name.name === "tag") {
+                    return acc;
+                  }
+                }
+              }
+              if (cur.type !== "style") {
+                acc.push(cur);
+                return acc;
+              }
+              let key = Object.keys(cur.value)[0];
+              const value = cur.value[key];
+              const fullKey = tamaguiConfig.shorthands[key];
+              if (fullKey) {
+                cur.value = { [fullKey]: value };
+                key = fullKey;
+              }
+              if (disableExtractVariables) {
+                if (value[0] === "$") {
+                  if (shouldPrintDebug) {
+                    console.log(`   keeping variable inline: ${key} =`, value);
+                  }
+                  acc.push({
+                    type: "attr",
+                    value: t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(t.stringLiteral(value)))
+                  });
+                  return acc;
+                }
+              }
+              acc.push(cur);
+              return acc;
+            }, []);
+            tm.mark("jsx-element-expanded", shouldPrintDebug === "verbose");
+            if (shouldPrintDebug) {
+              console.log("  - attrs (expanded): \n", logLines(attrs.map(attrStr).join(", ")));
             }
-            out.push(cur);
-            return out;
-          }, []).flat();
-          const completeStaticProps = {
-            ...Object.keys(attrs).reduce((acc, index) => {
+            let prev = null;
+            attrs = attrs.reduce((acc, cur) => {
+              if (cur.type === "style") {
+                const key = Object.keys(cur.value)[0];
+                const value = cur.value[key];
+                const shouldKeepOriginalAttr = !shouldFlatten && !validStyles[key] && !pseudos[key] && !key.startsWith("data-");
+                if (shouldKeepOriginalAttr) {
+                  if (shouldPrintDebug) {
+                    console.log("     - keeping as non-style", key);
+                  }
+                  prev = cur;
+                  acc.push({
+                    type: "attr",
+                    value: t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(typeof value === "string" ? t.stringLiteral(value) : literalToAst(value)))
+                  });
+                  acc.push(cur);
+                  return acc;
+                }
+                if (ensureOverridden[key]) {
+                  acc.push({
+                    type: "attr",
+                    value: cur.attr || t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(t.nullLiteral()))
+                  });
+                }
+                if ((prev == null ? void 0 : prev.type) === "style") {
+                  mergeStyles(prev.value, cur.value);
+                  return acc;
+                }
+              }
+              prev = cur;
+              acc.push(cur);
+              return acc;
+            }, []);
+            const state = {
+              noClassNames: true,
+              focus: false,
+              hover: false,
+              mounted: true,
+              press: false,
+              pressIn: false
+            };
+            const completeStaticProps = Object.keys(attrs).reduce((acc, index) => {
               const cur = attrs[index];
               if (cur.type === "style") {
+                normalizeStyleObject(cur.value);
                 Object.assign(acc, cur.value);
               }
               if (cur.type === "attr") {
@@ -746,282 +969,185 @@ function createExtractor() {
                 acc[key] = value;
               }
               return acc;
-            }, {})
-          };
-          const hasSpread = node.attributes.some((x) => t.isJSXSpreadAttribute(x));
-          const hasOnlyStringChildren = !hasSpread && (node.selfClosing || traversePath.node.children && traversePath.node.children.every((x) => x.type === "JSXText"));
-          const shouldFlatten = !shouldDeopt && inlinePropCount === 0 && !hasSpread && staticConfig.neverFlatten !== true && (staticConfig.neverFlatten === "jsx" ? hasOnlyStringChildren : true);
-          if (shouldFlatten && staticConfig.defaultProps) {
-            const defaultStyleAttrs = Object.keys(staticConfig.defaultProps).flatMap((key) => {
-              if (!isValidStyleKey(key)) {
-                return;
+            }, {});
+            const completeProps = {
+              ...staticConfig.defaultProps,
+              ...completeStaticProps
+            };
+            if (shouldPrintDebug) {
+              console.log("  - attrs (combined \u{1F500}): \n", logLines(attrs.map(attrStr).join(", ")));
+              console.log("  - defaultProps: \n", logLines(objToStr(staticConfig.defaultProps)));
+              console.log("  - completeStaticProps: \n", logLines(objToStr(completeStaticProps)));
+            }
+            const getStyles = /* @__PURE__ */ __name((props2, debugName = "") => {
+              if (!props2 || !Object.keys(props2).length) {
+                if (shouldPrintDebug)
+                  console.log(" getStyles() no props");
+                return {};
+              }
+              if (excludeProps && !!excludeProps.size) {
+                for (const key in props2) {
+                  if (excludeProps.has(key)) {
+                    if (shouldPrintDebug)
+                      console.log(" delete excluded", key);
+                    delete props2[key];
+                  }
+                }
               }
               try {
-                const serialize = require("babel-literal-to-ast");
-                const val = staticConfig.defaultProps[key];
-                const value = serialize(val);
-                const name = tamaguiConfig.shorthands[key] || key;
-                return {
-                  type: "style",
-                  name,
-                  value
+                const out = getSplitStyles(props2, staticConfig, defaultTheme, {
+                  ...state,
+                  fallbackProps: completeProps
+                });
+                const outStyle = {
+                  ...out.style,
+                  ...out.pseudos
                 };
-              } catch (err) {
-                console.warn(`\u26A0\uFE0F Error evaluating default style for component, prop ${key}
- error: ${err}`);
-                shouldDeopt = true;
-              }
-            });
-            if (defaultStyleAttrs.length) {
-              attrs = [...defaultStyleAttrs, ...attrs];
-            }
-          }
-          if (shouldDeopt) {
-            node.attributes = ogAttributes;
-            return;
-          }
-          const ensureOverridden = {};
-          if (!shouldFlatten) {
-            for (const cur of attrs) {
-              if (cur.type === "style") {
-                for (const key in cur.value) {
-                  const shouldEnsureOverridden = !!((_d = staticConfig.ensureOverriddenProp) == null ? void 0 : _d[key]);
-                  const isSetInAttrsAlready = attrs.some((x) => x.type === "attr" && x.value.type === "JSXAttribute" && x.value.name.name === key);
-                  if (!isSetInAttrsAlready) {
-                    const isVariant = !!((_e = staticConfig.variants) == null ? void 0 : _e[cur.name || ""]);
-                    if (isVariant || shouldEnsureOverridden) {
-                      ensureOverridden[key] = true;
+                if (staticConfig.validStyles) {
+                  for (const key in outStyle) {
+                    if (!staticConfig.validStyles[key] && !pseudos[key] && !/(hover|focus|press)Style$/.test(key)) {
+                      if (shouldPrintDebug)
+                        console.log(" delete invalid style", key);
+                      delete outStyle[key];
                     }
                   }
                 }
-              }
-            }
-          }
-          if (shouldPrintDebug) {
-            console.log("  - attrs (flattened): \n", logLines(attrs.map(attrStr).join(", ")));
-            console.log("  - ensureOverriden:", Object.keys(ensureOverridden).join(", "));
-          }
-          attrs = attrs.reduce((acc, cur) => {
-            if (!cur) {
-              return acc;
-            }
-            if (shouldFlatten && cur.type === "attr" && !t.isJSXSpreadAttribute(cur.value) && cur.value.name.name === "tag") {
-              return acc;
-            }
-            if (cur.type !== "style") {
-              acc.push(cur);
-              return acc;
-            }
-            let key = Object.keys(cur.value)[0];
-            const value = cur.value[key];
-            const fullKey = tamaguiConfig.shorthands[key];
-            if (fullKey) {
-              cur.value = { [fullKey]: value };
-              key = fullKey;
-            }
-            if (disableExtractVariables) {
-              if (value[0] === "$") {
                 if (shouldPrintDebug) {
-                  console.log(`   keeping variable inline: ${key} =`, value);
+                  console.log(`       getStyles ${debugName} (props):
+`, logLines(objToStr(props2)));
+                  console.log(`       getStyles ${debugName} (out.viewProps):
+`, logLines(objToStr(out.viewProps)));
+                  console.log(`       getStyles ${debugName} (out.style):
+`, logLines(objToStr(outStyle || {}), true));
                 }
-                acc.push({
-                  type: "attr",
-                  value: t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(t.stringLiteral(value)))
-                });
-                return acc;
+                return outStyle;
+              } catch (err) {
+                console.log("error", err.message, err.stack);
+                return {};
               }
+            }, "getStyles");
+            const completeStylesProcessed = getStyles(completeProps, "completeStylesProcessed");
+            if (!completeStylesProcessed) {
+              throw new Error(`Impossible, no styles`);
             }
-            acc.push(cur);
-            return acc;
-          }, []);
-          if (shouldPrintDebug) {
-            console.log("  - attrs (expanded): \n", logLines(attrs.map(attrStr).join(", ")));
-          }
-          let prev = null;
-          function mergeStyles(prev2, next) {
-            for (const key in next) {
-              if (pseudos[key]) {
-                prev2[key] = prev2[key] || {};
-                Object.assign(prev2[key], next[key]);
+            const stylesToAddToInitialGroup = shouldFlatten ? difference(Object.keys(completeStylesProcessed), Object.keys(completeStaticProps)) : [];
+            if (stylesToAddToInitialGroup.length) {
+              const toAdd = pick(completeStylesProcessed, ...stylesToAddToInitialGroup);
+              const firstGroup = attrs.find((x) => x.type === "style");
+              if (shouldPrintDebug) {
+                console.log("    toAdd", objToStr(toAdd));
+              }
+              if (!firstGroup) {
+                attrs.unshift({ type: "style", value: toAdd });
               } else {
-                prev2[key] = next[key];
+                Object.assign(firstGroup.value, toAdd);
               }
             }
-          }
-          __name(mergeStyles, "mergeStyles");
-          attrs = attrs.reduce((acc, cur) => {
-            if (cur.type === "style") {
-              const key = Object.keys(cur.value)[0];
-              const value = cur.value[key];
-              const shouldKeepOriginalAttr = !shouldFlatten && !validStyles[key] && !pseudos[key] && !key.startsWith("data-");
-              if (shouldKeepOriginalAttr) {
-                if (shouldPrintDebug) {
-                  console.log("     - keeping as non-style", key);
-                }
-                prev = cur;
-                acc.push({
-                  type: "attr",
-                  value: t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(typeof value === "string" ? t.stringLiteral(value) : literalToAst(value)))
-                });
-                acc.push(cur);
-                return acc;
-              }
-              if (ensureOverridden[key]) {
-                acc.push({
-                  type: "attr",
-                  value: cur.attr || t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(t.nullLiteral()))
-                });
-              }
-              if ((prev == null ? void 0 : prev.type) === "style") {
-                mergeStyles(prev.value, cur.value);
-                return acc;
-              }
+            if (shouldPrintDebug) {
+              console.log("   -- stylesToAddToInitialGroup", stylesToAddToInitialGroup.join(", "), { shouldFlatten });
+              console.log("   -- completeStaticProps:\n", logLines(objToStr(completeStaticProps)));
+              console.log("   -- completeStylesProcessed:\n", logLines(objToStr(completeStylesProcessed)));
             }
-            prev = cur;
-            acc.push(cur);
-            return acc;
-          }, []);
-          if (shouldPrintDebug) {
-            console.log("  - attrs (combined \u{1F500}): \n", logLines(attrs.map(attrStr).join(", ")));
-          }
-          const getStyles = /* @__PURE__ */ __name((props2, debugName = "") => {
-            if (!props2)
-              return;
-            if (!Object.keys(props2).length)
-              return;
-            if (excludeProps && !!excludeProps.size) {
-              for (const key in props2) {
-                if (excludeProps.has(key)) {
-                  delete props2[key];
+            let getStyleError = null;
+            for (const attr of attrs) {
+              try {
+                if (shouldPrintDebug)
+                  console.log("  *", attrStr(attr));
+                switch (attr.type) {
+                  case "ternary":
+                    const a = getStyles(attr.value.alternate, "ternary.alternate");
+                    const c = getStyles(attr.value.consequent, "ternary.consequent");
+                    if (a)
+                      attr.value.alternate = a;
+                    if (c)
+                      attr.value.consequent = c;
+                    if (shouldPrintDebug)
+                      console.log("     => tern ", attrStr(attr));
+                    continue;
+                  case "style":
+                    if (shouldPrintDebug)
+                      console.log("  * styles in", logLines(objToStr(attr.value)));
+                    const styles = getStyles(attr.value, "style");
+                    if (shouldPrintDebug)
+                      console.log("  * styles out", logLines(objToStr(styles)));
+                    if (styles) {
+                      attr.value = Object.fromEntries(Object.keys(styles).map((k) => [k, completeStylesProcessed[k]]));
+                    }
+                    continue;
                 }
+              } catch (err) {
+                getStyleError = err;
               }
             }
-            const out = getSplitStyles(props2, staticConfig, defaultTheme, {
-              noClassNames: true
-            });
-            const outStyle = {
-              ...out.style,
-              ...out.pseudos
-            };
-            if (shouldPrintDebug === "verbose") {
-              console.log(`       getStyles ${debugName} (props):
-`, logLines(objToStr(props2)));
-              console.log(`       getStyles ${debugName} (out.viewProps):
-`, logLines(objToStr(out.viewProps)));
-              console.log(`       getStyles ${debugName} (out.style):
-`, logLines(objToStr(outStyle || {}), true));
+            tm.mark("jsx-element-styles", shouldPrintDebug === "verbose");
+            if (getStyleError) {
+              console.log(" \u26A0\uFE0F postprocessing error, deopt", getStyleError);
+              node.attributes = ogAttributes;
+              return node;
             }
-            for (const key in outStyle) {
-              if (staticConfig.validStyles) {
-                if (!staticConfig.validStyles[key] && !pseudos[key]) {
-                  delete outStyle[key];
+            const existingStyleKeys = /* @__PURE__ */ new Set();
+            for (let i = attrs.length - 1; i >= 0; i--) {
+              const attr = attrs[i];
+              if (shouldFlatten && canFlattenProps) {
+                if (attr.type === "attr") {
+                  if (t.isJSXAttribute(attr.value)) {
+                    if (t.isJSXIdentifier(attr.value.name)) {
+                      const name = attr.value.name.name;
+                      if (INLINE_EXTRACTABLE[name]) {
+                        attr.value.name.name = INLINE_EXTRACTABLE[name];
+                      }
+                    }
+                  }
                 }
               }
-            }
-            return outStyle;
-          }, "getStyles");
-          const completeStylesProcessed = getStyles({
-            ...staticConfig.defaultProps,
-            ...completeStaticProps
-          }, "completeStylesProcessed");
-          if (!completeStylesProcessed) {
-            throw new Error(`Impossible, no styles`);
-          }
-          const stylesToAddToInitialGroup = shouldFlatten ? difference(Object.keys(completeStylesProcessed), Object.keys(completeStaticProps)) : [];
-          if (stylesToAddToInitialGroup.length) {
-            const toAdd = pick(completeStylesProcessed, ...stylesToAddToInitialGroup);
-            const firstGroup = attrs.find((x) => x.type === "style");
-            if (shouldPrintDebug) {
-              console.log("    toAdd", objToStr(toAdd));
-            }
-            if (!firstGroup) {
-              attrs.unshift({ type: "style", value: toAdd });
-            } else {
-              Object.assign(firstGroup.value, toAdd);
-            }
-          }
-          if (shouldPrintDebug) {
-            console.log("   -- stylesToAddToInitialGroup", stylesToAddToInitialGroup.join(", "), { shouldFlatten });
-            console.log("   -- completeStaticProps:\n", logLines(objToStr(completeStaticProps)));
-            console.log("   -- completeStylesProcessed:\n", logLines(objToStr(completeStylesProcessed)));
-          }
-          let getStyleError = null;
-          for (const attr of attrs) {
-            try {
-              if (shouldPrintDebug)
-                console.log("  *", attrStr(attr));
-              switch (attr.type) {
-                case "ternary":
-                  const a = getStyles(attr.value.alternate, "ternary.alternate");
-                  const c = getStyles(attr.value.consequent, "ternary.consequent");
-                  if (a)
-                    attr.value.alternate = a;
-                  if (c)
-                    attr.value.consequent = c;
-                  if (shouldPrintDebug)
-                    console.log("     => tern ", attrStr(attr));
-                  continue;
-                case "style":
-                  const styles = getStyles(attr.value, "style");
-                  if (styles) {
-                    attr.value = Object.fromEntries(Object.keys(styles).map((k) => [k, completeStylesProcessed[k]]));
+              if (attr.type === "style") {
+                for (const key in attr.value) {
+                  if (existingStyleKeys.has(key)) {
+                    if (shouldPrintDebug) {
+                      console.log("  >> delete existing", key);
+                    }
+                    delete attr.value[key];
                   } else {
-                    console.warn("?????????");
+                    existingStyleKeys.add(key);
                   }
-                  continue;
+                }
               }
-            } catch (err) {
-              getStyleError = err;
             }
-          }
-          if (getStyleError) {
-            console.log(" \u26A0\uFE0F postprocessing error, deopt", getStyleError);
-            node.attributes = ogAttributes;
-            return node;
-          }
-          const existingStyleKeys = /* @__PURE__ */ new Set();
-          for (let i = attrs.length - 1; i >= 0; i--) {
-            const attr = attrs[i];
-            if (attr.type === "style") {
-              for (const key in attr.value) {
-                if (existingStyleKeys.has(key)) {
-                  delete attr.value[key];
-                } else {
-                  existingStyleKeys.add(key);
-                }
+            if (shouldFlatten) {
+              if (shouldPrintDebug) {
+                console.log("  [\u2705] flattening", originalNodeName, flatNode);
+              }
+              node.name.name = flatNode;
+              res.flattened++;
+              if (closingElement) {
+                closingElement.name.name = flatNode;
               }
             }
-          }
-          if (shouldPrintDebug) {
-            console.log("  - attrs (after):\n", logLines(attrs.map(attrStr).join(", ")));
-          }
-          if (shouldFlatten) {
             if (shouldPrintDebug) {
-              console.log("  [\u2705] flattening", originalNodeName, flatNode);
+              console.log(` \u274A\u274A inline props (${inlined.size}):`, shouldDeopt ? " deopted" : "", hasSpread ? " has spread" : "", staticConfig.neverFlatten ? "neverFlatten" : "");
+              console.log("  - attrs (end):\n", logLines(attrs.map(attrStr).join(", ")));
             }
-            node.name.name = flatNode;
-            res.flattened++;
-            if (closingElement) {
-              closingElement.name.name = flatNode;
+            onExtractTag({
+              attrs,
+              node,
+              lineNumbers,
+              filePath,
+              attemptEval,
+              jsxPath: traversePath,
+              originalNodeName,
+              isFlattened: shouldFlatten,
+              programPath
+            });
+          } catch (err) {
+            throw err;
+          } finally {
+            if (debugPropValue) {
+              shouldPrintDebug = ogDebug;
             }
           }
-          if (shouldPrintDebug) {
-            console.log(` \u274A\u274A inline props (${inlinePropCount}):`, shouldDeopt ? " deopted" : "", hasSpread ? " has spread" : "", staticConfig.neverFlatten ? "neverFlatten" : "");
-            console.log("  - attrs (end):\n", logLines(attrs.map(attrStr).join(", ")));
-          }
-          onExtractTag({
-            attrs,
-            node,
-            lineNumbers,
-            filePath,
-            attemptEval,
-            jsxPath: traversePath,
-            originalNodeName,
-            isFlattened: shouldFlatten,
-            programPath
-          });
         }
       });
+      tm.mark("jsx-done", shouldPrintDebug === "verbose");
       if (modifiedComponents.size) {
         const all = Array.from(modifiedComponents);
         if (shouldPrintDebug) {
@@ -1031,6 +1157,7 @@ function createExtractor() {
           removeUnusedHooks(comp, shouldPrintDebug);
         }
       }
+      tm.done(shouldPrintDebug === "verbose");
       return res;
     }
   };