@tamagui/static 1.89.26 → 1.89.27-1708113113238

package/dist/esm/extractor/extractToClassNames.native.js

@@ -15,273 +15,470 @@ import { hoistClassNames } from "./hoistClassNames";
 import { logLines } from "./logLines";
 import { getFontFamilyClassNameFromProps } from "./propsToFontFamilyCache";
 import { timer } from "./timer";
-const mergeStyleGroups = {
-  shadowOpacity: !0,
-  shadowRadius: !0,
-  shadowColor: !0,
-  shadowOffset: !0
-};
-async function extractToClassNames({
-  extractor,
-  source,
-  sourcePath,
-  options,
-  shouldPrintDebug
-}) {
-  const tm = timer(), { getStylesAtomic } = requireTamaguiCore("web");
-  if (sourcePath != null && sourcePath.includes("node_modules"))
-    return null;
-  if (shouldPrintDebug && console.warn(`--- ${sourcePath} --- 
-
-`), typeof source != "string")
-    throw new Error("`source` must be a string of javascript");
-  if (sourcePath && !path.isAbsolute(sourcePath))
-    throw new Error(
-      "`sourcePath` must be an absolute path to a .js file, got: " + sourcePath
-    );
-  /.[tj]sx?$/i.test(sourcePath || "") || console.warn(`${sourcePath == null ? void 0 : sourcePath.slice(0, 100)} - bad filename.`), !options.disableExtraction && !options._disableLoadTamagui && await extractor.loadTamagui(options);
-  const shouldLogTiming = options.logTimings ?? !0, start = Date.now(), mem = process.env.TAMAGUI_SHOW_MEMORY_USAGE && shouldLogTiming ? process.memoryUsage() : null;
-  let ast;
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
-    ast = babelParse(source, sourcePath);
-  } catch (err) {
-    throw console.error("babel parse error:", sourcePath == null ? void 0 : sourcePath.slice(0, 100)), err;
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
   }
-  tm.mark("babel-parse", shouldPrintDebug === "verbose");
-  const cssMap = /* @__PURE__ */ new Map(), existingHoists = {};
-  let hasFlattened = !1;
-  const res = await extractor.parse(ast, {
-    shouldPrintDebug,
-    ...options,
-    sourcePath,
-    extractStyledDefinitions: !0,
-    onStyleRule(identifier, rules) {
-      const css = rules.join(";");
-      shouldPrintDebug && console.info(`adding styled() rule: .${identifier} ${css}`), cssMap.set(`.${identifier}`, { css, commentTexts: [] });
-    },
-    getFlattenedNode: ({ tag }) => (hasFlattened = !0, tag),
-    onExtractTag: ({
-      parserProps,
-      attrs,
-      node,
-      attemptEval,
-      jsxPath,
-      originalNodeName,
-      filePath,
-      lineNumbers,
-      programPath,
-      isFlattened,
-      staticConfig
-    }) => {
-      var _a;
-      if (staticConfig.acceptsClassName === !1) {
-        shouldPrintDebug && console.info("bail, acceptsClassName is false");
-        return;
+  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
       }
-      const didFlattenThisTag = hasFlattened;
-      hasFlattened = !1;
-      let finalClassNames = [];
-      const finalAttrs = [];
-      let finalStyles = [], viewStyles = {};
-      for (const attr of attrs)
-        attr.type === "style" && (viewStyles = {
-          ...viewStyles,
-          ...attr.value
-        });
-      const ensureNeededPrevStyle = (style) => {
-        if (!Object.keys(style).some((key) => mergeStyleGroups[key]))
-          return style;
-        for (const k in mergeStyleGroups)
-          k in viewStyles && (style[k] = style[k] ?? viewStyles[k]);
-        return style;
-      }, addStyles = (style) => {
-        if (!style)
-          return [];
-        const styleWithPrev = ensureNeededPrevStyle(style), res2 = getStylesAtomic(styleWithPrev);
-        return res2.length && (finalStyles = [...finalStyles, ...res2]), res2;
-      };
-      let lastMediaImportance = 1;
-      for (const attr of attrs)
-        switch (attr.type) {
-          case "style": {
-            if (isFlattened) {
-              const styles2 = addStyles(attr.value), newFontFamily = getFontFamilyClassNameFromProps(attr.value) || "", newClassNames = concatClassName(
-                styles2.map((x) => x.identifier).join(" ") + newFontFamily
-              ), existing = finalClassNames.find(
-                (x) => x.type == "StringLiteral"
-              );
-              if (existing) {
-                let previous = existing.value;
-                newFontFamily && (shouldPrintDebug && console.info(` newFontFamily: ${newFontFamily}`), previous = previous.replace(/font_[a-z]+/i, "")), existing.value = `${previous} ${newClassNames}`;
-              } else
-                finalClassNames = [...finalClassNames, t.stringLiteral(newClassNames)];
-            } else {
-              const styles2 = getStylesAtomic(attr.value);
-              finalStyles = [...finalStyles, ...styles2];
-              for (const style of styles2) {
-                const prop = style.pseudo ? `${style.property}-${style.pseudo}` : style.property;
-                finalAttrs.push(
-                  t.jsxAttribute(t.jsxIdentifier(prop), t.stringLiteral(style.identifier))
-                );
-              }
-            }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _define_property(obj, key, value) {
+  return key in obj ? Object.defineProperty(obj, key, {
+    value,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : obj[key] = value, obj;
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {}, ownKeys2 = Object.keys(source);
+    typeof Object.getOwnPropertySymbols == "function" && (ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+    }))), ownKeys2.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  return source = source ?? {}, Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  }), target;
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t2, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t2[0] & 1)
+        throw t2[1];
+      return t2[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t2 = op[0] & 2 ? y.return : op[0] ? y.throw || ((t2 = y.return) && t2.call(y), 0) : y.next) && !(t2 = t2.call(y, op[1])).done)
+          return t2;
+        switch (y = 0, t2 && (op = [
+          op[0] & 2,
+          t2.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t2 = op;
             break;
-          }
-          case "attr": {
-            const val = attr.value;
-            if (t.isJSXSpreadAttribute(val))
-              isSimpleSpread(val) && finalClassNames.push(
-                t.logicalExpression(
-                  "&&",
-                  val.argument,
-                  t.memberExpression(val.argument, t.identifier("className"))
-                )
-              );
-            else if (val.name.name === "className") {
-              const value = val.value;
-              if (value)
-                try {
-                  const evaluatedValue = attemptEval(value);
-                  finalClassNames.push(t.stringLiteral(evaluatedValue));
-                } catch {
-                  finalClassNames.push(value.expression);
-                }
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t2 = _.trys, !(t2 = t2.length > 0 && t2[t2.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
               continue;
             }
-            finalAttrs.push(val);
-            break;
-          }
-          case "ternary": {
-            const mediaExtraction = extractMediaStyle(
-              parserProps,
-              attr.value,
-              jsxPath,
-              extractor.getTamagui(),
-              sourcePath || "",
-              lastMediaImportance,
-              shouldPrintDebug
-            );
-            if (shouldPrintDebug && mediaExtraction && console.info(
-              "ternary (mediaStyles)",
-              ((_a = mediaExtraction.ternaryWithoutMedia) == null ? void 0 : _a.inlineMediaQuery) ?? "",
-              mediaExtraction.mediaStyles.map((x) => x.identifier).join(".")
-            ), !mediaExtraction) {
-              addTernaryStyle(
-                attr.value,
-                addStyles(attr.value.consequent),
-                addStyles(attr.value.alternate)
-              );
-              continue;
+            if (op[0] === 3 && (!t2 || op[1] > t2[0] && op[1] < t2[3])) {
+              _.label = op[1];
+              break;
             }
-            lastMediaImportance++, mediaExtraction.mediaStyles && (finalStyles = [...finalStyles, ...mediaExtraction.mediaStyles]), mediaExtraction.ternaryWithoutMedia ? addTernaryStyle(
-              mediaExtraction.ternaryWithoutMedia,
-              mediaExtraction.mediaStyles,
-              []
-            ) : finalClassNames = [
-              ...finalClassNames,
-              ...mediaExtraction.mediaStyles.map((x) => t.stringLiteral(x.identifier))
-            ];
-            break;
-          }
-        }
-      function addTernaryStyle(ternary, a, b) {
-        const cCN = a.map((x) => x.identifier).join(" "), aCN = b.map((x) => x.identifier).join(" ");
-        a.length && b.length ? finalClassNames.push(
-          t.conditionalExpression(
-            ternary.test,
-            t.stringLiteral(cCN),
-            t.stringLiteral(aCN)
-          )
-        ) : finalClassNames.push(
-          t.conditionalExpression(
-            ternary.test,
-            t.stringLiteral(" " + cCN),
-            t.stringLiteral(" " + aCN)
-          )
-        );
-      }
-      if (shouldPrintDebug && console.info(
-        `  finalClassNames
-`,
-        logLines(finalClassNames.map((x) => x.value).join(" "))
-      ), node.attributes = finalAttrs, finalClassNames.length) {
-        const extraClassNames = (() => {
-          let value = "";
-          return isFlattened && (process.env.TAMAGUI_DEBUG_OPTIMIZATIONS && (value += "is_tamagui_flattened"), staticConfig.componentName && (value += ` is_${staticConfig.componentName}`)), value;
-        })(), names = buildClassName(finalClassNames, extraClassNames), nameExpr = names ? hoistClassNames(jsxPath, existingHoists, names) : null;
-        let expr = nameExpr;
-        if (nameExpr && !t.isIdentifier(nameExpr) && didFlattenThisTag) {
-          ensureImportingConcat(programPath);
-          const simpleSpreads = attrs.filter((x) => x.type === "attr" && t.isJSXSpreadAttribute(x.value) && isSimpleSpread(x.value));
-          expr = t.callExpression(t.identifier("concatClassName"), [
-            expr,
-            ...simpleSpreads.map((val) => val.value.argument)
-          ]);
+            if (op[0] === 6 && _.label < t2[1]) {
+              _.label = t2[1], t2 = op;
+              break;
+            }
+            if (t2 && _.label < t2[2]) {
+              _.label = t2[2], _.ops.push(op);
+              break;
+            }
+            t2[2] && _.ops.pop(), _.trys.pop();
+            continue;
         }
-        node.attributes.push(
-          t.jsxAttribute(t.jsxIdentifier("className"), t.jsxExpressionContainer(expr))
-        );
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t2 = 0;
       }
-      const comment = util.format(
-        "/* %s:%s (%s) */",
-        filePath,
-        lineNumbers,
-        originalNodeName
-      );
-      for (const { identifier, rules } of finalStyles) {
-        const className = `.${identifier}`;
-        if (cssMap.has(className)) {
-          if (comment) {
-            const val = cssMap.get(className);
-            val.commentTexts.push(comment), cssMap.set(className, val);
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
+var mergeStyleGroups = {
+  shadowOpacity: !0,
+  shadowRadius: !0,
+  shadowColor: !0,
+  shadowOffset: !0
+};
+function extractToClassNames(_) {
+  return _extractToClassNames.apply(this, arguments);
+}
+function _extractToClassNames() {
+  return _extractToClassNames = _async_to_generator(function(param) {
+    var extractor, source, sourcePath, options, shouldPrintDebug, tm, getStylesAtomic, _options_logTimings, shouldLogTiming, start, mem, ast, cssMap, existingHoists, hasFlattened, res, styles, result, memUsed, _$path, numOptimized, numFound, numFlattened, memory, timing, timingStr, pre, memStr;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (extractor = param.extractor, source = param.source, sourcePath = param.sourcePath, options = param.options, shouldPrintDebug = param.shouldPrintDebug, tm = timer(), getStylesAtomic = requireTamaguiCore("web").getStylesAtomic, sourcePath != null && sourcePath.includes("node_modules"))
+            return [
+              2,
+              null
+            ];
+          if (shouldPrintDebug && console.warn("--- ".concat(sourcePath, ` --- 
+
+`)), typeof source != "string")
+            throw new Error("`source` must be a string of javascript");
+          if (sourcePath && !path.isAbsolute(sourcePath))
+            throw new Error("`sourcePath` must be an absolute path to a .js file, got: " + sourcePath);
+          return /.[tj]sx?$/i.test(sourcePath || "") || console.warn("".concat(sourcePath == null ? void 0 : sourcePath.slice(0, 100), " - bad filename.")), !options.disableExtraction && !options._disableLoadTamagui ? [
+            4,
+            extractor.loadTamagui(options)
+          ] : [
+            3,
+            2
+          ];
+        case 1:
+          _state.sent(), _state.label = 2;
+        case 2:
+          shouldLogTiming = (_options_logTimings = options.logTimings) !== null && _options_logTimings !== void 0 ? _options_logTimings : !0, start = Date.now(), mem = process.env.TAMAGUI_SHOW_MEMORY_USAGE && shouldLogTiming ? process.memoryUsage() : null;
+          try {
+            ast = babelParse(source, sourcePath);
+          } catch (err) {
+            throw console.error("babel parse error:", sourcePath == null ? void 0 : sourcePath.slice(0, 100)), err;
           }
-        } else
-          rules.length && cssMap.set(className, {
-            css: rules.join(`
+          return tm.mark("babel-parse", shouldPrintDebug === "verbose"), cssMap = /* @__PURE__ */ new Map(), existingHoists = {}, hasFlattened = !1, [
+            4,
+            extractor.parse(ast, _object_spread_props(_object_spread({
+              shouldPrintDebug
+            }, options), {
+              sourcePath,
+              extractStyledDefinitions: !0,
+              onStyleRule: function(identifier, rules) {
+                var css = rules.join(";");
+                shouldPrintDebug && console.info("adding styled() rule: .".concat(identifier, " ").concat(css)), cssMap.set(".".concat(identifier), {
+                  css,
+                  commentTexts: []
+                });
+              },
+              getFlattenedNode: function(param2) {
+                var tag = param2.tag;
+                return hasFlattened = !0, tag;
+              },
+              onExtractTag: function(param2) {
+                var parserProps = param2.parserProps, attrs = param2.attrs, node = param2.node, attemptEval = param2.attemptEval, jsxPath = param2.jsxPath, originalNodeName = param2.originalNodeName, filePath = param2.filePath, lineNumbers = param2.lineNumbers, programPath = param2.programPath, isFlattened = param2.isFlattened, staticConfig = param2.staticConfig, addTernaryStyle = function(ternary, a, b) {
+                  var cCN = a.map(function(x) {
+                    return x.identifier;
+                  }).join(" "), aCN = b.map(function(x) {
+                    return x.identifier;
+                  }).join(" ");
+                  a.length && b.length ? finalClassNames.push(t.conditionalExpression(ternary.test, t.stringLiteral(cCN), t.stringLiteral(aCN))) : finalClassNames.push(t.conditionalExpression(ternary.test, t.stringLiteral(" " + cCN), t.stringLiteral(" " + aCN)));
+                };
+                if (staticConfig.acceptsClassName === !1) {
+                  shouldPrintDebug && console.info("bail, acceptsClassName is false");
+                  return;
+                }
+                var didFlattenThisTag = hasFlattened;
+                hasFlattened = !1;
+                var finalClassNames = [], finalAttrs = [], finalStyles = [], viewStyles = {}, _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
+                try {
+                  for (var _iterator = attrs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+                    var attr = _step.value;
+                    attr.type === "style" && (viewStyles = _object_spread({}, viewStyles, attr.value));
+                  }
+                } catch (err) {
+                  _didIteratorError = !0, _iteratorError = err;
+                } finally {
+                  try {
+                    !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+                  } finally {
+                    if (_didIteratorError)
+                      throw _iteratorError;
+                  }
+                }
+                var ensureNeededPrevStyle = function(style2) {
+                  var keys = Object.keys(style2);
+                  if (!keys.some(function(key) {
+                    return mergeStyleGroups[key];
+                  }))
+                    return style2;
+                  for (var k in mergeStyleGroups)
+                    if (k in viewStyles) {
+                      var _style_k;
+                      style2[k] = (_style_k = style2[k]) !== null && _style_k !== void 0 ? _style_k : viewStyles[k];
+                    }
+                  return style2;
+                }, addStyles = function(style2) {
+                  if (!style2)
+                    return [];
+                  var styleWithPrev = ensureNeededPrevStyle(style2), res2 = getStylesAtomic(styleWithPrev);
+                  return res2.length && (finalStyles = _to_consumable_array(finalStyles).concat(_to_consumable_array(res2))), res2;
+                }, lastMediaImportance = 1, _iteratorNormalCompletion1 = !0, _didIteratorError1 = !1, _iteratorError1 = void 0;
+                try {
+                  for (var _iterator1 = attrs[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
+                    var attr1 = _step1.value;
+                    switch (attr1.type) {
+                      case "style": {
+                        if (isFlattened) {
+                          var styles1 = addStyles(attr1.value), newFontFamily = getFontFamilyClassNameFromProps(attr1.value) || "", newClassNames = concatClassName(styles1.map(function(x) {
+                            return x.identifier;
+                          }).join(" ") + newFontFamily), existing = finalClassNames.find(function(x) {
+                            return x.type == "StringLiteral";
+                          });
+                          if (existing) {
+                            var previous = existing.value;
+                            newFontFamily && (shouldPrintDebug && console.info(" newFontFamily: ".concat(newFontFamily)), previous = previous.replace(/font_[a-z]+/i, "")), existing.value = "".concat(previous, " ").concat(newClassNames);
+                          } else
+                            finalClassNames = _to_consumable_array(finalClassNames).concat([
+                              t.stringLiteral(newClassNames)
+                            ]);
+                        } else {
+                          var styles2 = getStylesAtomic(attr1.value);
+                          finalStyles = _to_consumable_array(finalStyles).concat(_to_consumable_array(styles2));
+                          var _iteratorNormalCompletion2 = !0, _didIteratorError2 = !1, _iteratorError2 = void 0;
+                          try {
+                            for (var _iterator2 = styles2[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
+                              var style = _step2.value, prop = style.pseudo ? "".concat(style.property, "-").concat(style.pseudo) : style.property;
+                              finalAttrs.push(t.jsxAttribute(t.jsxIdentifier(prop), t.stringLiteral(style.identifier)));
+                            }
+                          } catch (err) {
+                            _didIteratorError2 = !0, _iteratorError2 = err;
+                          } finally {
+                            try {
+                              !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
+                            } finally {
+                              if (_didIteratorError2)
+                                throw _iteratorError2;
+                            }
+                          }
+                        }
+                        break;
+                      }
+                      case "attr": {
+                        var val = attr1.value;
+                        if (t.isJSXSpreadAttribute(val))
+                          isSimpleSpread(val) && finalClassNames.push(t.logicalExpression("&&", val.argument, t.memberExpression(val.argument, t.identifier("className"))));
+                        else if (val.name.name === "className") {
+                          var value = val.value;
+                          if (value)
+                            try {
+                              var evaluatedValue = attemptEval(value);
+                              finalClassNames.push(t.stringLiteral(evaluatedValue));
+                            } catch {
+                              finalClassNames.push(value.expression);
+                            }
+                          continue;
+                        }
+                        finalAttrs.push(val);
+                        break;
+                      }
+                      case "ternary": {
+                        var mediaExtraction = extractMediaStyle(parserProps, attr1.value, jsxPath, extractor.getTamagui(), sourcePath || "", lastMediaImportance, shouldPrintDebug);
+                        if (shouldPrintDebug && mediaExtraction) {
+                          var _mediaExtraction_ternaryWithoutMedia, _mediaExtraction_ternaryWithoutMedia_inlineMediaQuery;
+                          console.info("ternary (mediaStyles)", (_mediaExtraction_ternaryWithoutMedia_inlineMediaQuery = (_mediaExtraction_ternaryWithoutMedia = mediaExtraction.ternaryWithoutMedia) === null || _mediaExtraction_ternaryWithoutMedia === void 0 ? void 0 : _mediaExtraction_ternaryWithoutMedia.inlineMediaQuery) !== null && _mediaExtraction_ternaryWithoutMedia_inlineMediaQuery !== void 0 ? _mediaExtraction_ternaryWithoutMedia_inlineMediaQuery : "", mediaExtraction.mediaStyles.map(function(x) {
+                            return x.identifier;
+                          }).join("."));
+                        }
+                        if (!mediaExtraction) {
+                          addTernaryStyle(attr1.value, addStyles(attr1.value.consequent), addStyles(attr1.value.alternate));
+                          continue;
+                        }
+                        lastMediaImportance++, mediaExtraction.mediaStyles && (finalStyles = _to_consumable_array(finalStyles).concat(_to_consumable_array(mediaExtraction.mediaStyles))), mediaExtraction.ternaryWithoutMedia ? addTernaryStyle(mediaExtraction.ternaryWithoutMedia, mediaExtraction.mediaStyles, []) : finalClassNames = _to_consumable_array(finalClassNames).concat(_to_consumable_array(mediaExtraction.mediaStyles.map(function(x) {
+                          return t.stringLiteral(x.identifier);
+                        })));
+                        break;
+                      }
+                    }
+                  }
+                } catch (err) {
+                  _didIteratorError1 = !0, _iteratorError1 = err;
+                } finally {
+                  try {
+                    !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+                  } finally {
+                    if (_didIteratorError1)
+                      throw _iteratorError1;
+                  }
+                }
+                if (shouldPrintDebug && console.info(`  finalClassNames
+`, logLines(finalClassNames.map(function(x) {
+                  return x.value;
+                }).join(" "))), node.attributes = finalAttrs, finalClassNames.length) {
+                  var extraClassNames = function() {
+                    var value2 = "";
+                    return isFlattened && (process.env.TAMAGUI_DEBUG_OPTIMIZATIONS && (value2 += "is_tamagui_flattened"), staticConfig.componentName && (value2 += " is_".concat(staticConfig.componentName))), value2;
+                  }(), names = buildClassName(finalClassNames, extraClassNames), nameExpr = names ? hoistClassNames(jsxPath, existingHoists, names) : null, expr = nameExpr;
+                  if (nameExpr && !t.isIdentifier(nameExpr) && didFlattenThisTag) {
+                    ensureImportingConcat(programPath);
+                    var simpleSpreads = attrs.filter(function(x) {
+                      return x.type === "attr" && t.isJSXSpreadAttribute(x.value) && isSimpleSpread(x.value);
+                    });
+                    expr = t.callExpression(t.identifier("concatClassName"), [
+                      expr
+                    ].concat(_to_consumable_array(simpleSpreads.map(function(val2) {
+                      return val2.value.argument;
+                    }))));
+                  }
+                  node.attributes.push(t.jsxAttribute(t.jsxIdentifier("className"), t.jsxExpressionContainer(expr)));
+                }
+                var comment = util.format("/* %s:%s (%s) */", filePath, lineNumbers, originalNodeName), _iteratorNormalCompletion3 = !0, _didIteratorError3 = !1, _iteratorError3 = void 0;
+                try {
+                  for (var _iterator3 = finalStyles[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = !0) {
+                    var _step_value = _step3.value, identifier = _step_value.identifier, rules = _step_value.rules, className = ".".concat(identifier);
+                    if (cssMap.has(className)) {
+                      if (comment) {
+                        var val1 = cssMap.get(className);
+                        val1.commentTexts.push(comment), cssMap.set(className, val1);
+                      }
+                    } else
+                      rules.length && cssMap.set(className, {
+                        css: rules.join(`
 `),
-            commentTexts: [comment]
-          });
-      }
-    }
-  });
-  if (!res || !res.modified && !res.optimized && !res.flattened && !res.styled)
-    return shouldPrintDebug && console.info("no res or none modified", res), null;
-  const styles = Array.from(cssMap.values()).map((x) => x.css).join(`
-`).trim(), result = generate(
-    ast,
-    {
-      concise: !1,
-      filename: sourcePath,
-      // this makes the debug output terrible, and i think sourcemap works already
-      retainLines: !1,
-      sourceFileName: sourcePath,
-      sourceMaps: !0
-    },
-    source
-  );
-  if (shouldPrintDebug && (console.info(
-    `
+                        commentTexts: [
+                          comment
+                        ]
+                      });
+                  }
+                } catch (err) {
+                  _didIteratorError3 = !0, _iteratorError3 = err;
+                } finally {
+                  try {
+                    !_iteratorNormalCompletion3 && _iterator3.return != null && _iterator3.return();
+                  } finally {
+                    if (_didIteratorError3)
+                      throw _iteratorError3;
+                  }
+                }
+              }
+            }))
+          ];
+        case 3:
+          return res = _state.sent(), !res || !res.modified && !res.optimized && !res.flattened && !res.styled ? (shouldPrintDebug && console.info("no res or none modified", res), [
+            2,
+            null
+          ]) : (styles = Array.from(cssMap.values()).map(function(x) {
+            return x.css;
+          }).join(`
+`).trim(), result = generate(ast, {
+            concise: !1,
+            filename: sourcePath,
+            // this makes the debug output terrible, and i think sourcemap works already
+            retainLines: !1,
+            sourceFileName: sourcePath,
+            sourceMaps: !0
+          }, source), shouldPrintDebug && (console.info(`
  -------- output code ------- 
 
-`,
-    result.code.split(`
-`).filter((x) => !x.startsWith("//")).join(`
-`)
-  ), console.info(`
+`, result.code.split(`
+`).filter(function(x) {
+            return !x.startsWith("//");
+          }).join(`
+`)), console.info(`
  -------- output style -------- 
 
-`, styles)), shouldLogTiming) {
-    const memUsed = mem ? Math.round((process.memoryUsage().heapUsed - mem.heapUsed) / 1024 / 1204 * 10) / 10 : 0, path2 = basename(sourcePath || "").replace(/\.[jt]sx?$/, "").slice(0, 22).trim().padStart(24), numOptimized = `${res.optimized + res.styled}`.padStart(3), numFound = `${res.found + res.styled}`.padStart(3), numFlattened = `${res.flattened}`.padStart(3), memory = memUsed ? ` ${memUsed}MB` : "", timingStr = `${Date.now() - start}ms`.padStart(6), pre = getPrefixLogs(options), memStr = memory ? `(${memory})` : "";
-    console.info(
-      `${pre} ${path2}   \xB7  ${numFound} found   \xB7  ${numOptimized} opt   \xB7  ${numFlattened} flat  ${timingStr} ${memStr}`
-    );
-  }
-  return {
-    ast,
-    styles,
-    js: result.code,
-    map: result.map
-  };
+`, styles)), shouldLogTiming && (memUsed = mem ? Math.round((process.memoryUsage().heapUsed - mem.heapUsed) / 1024 / 1204 * 10) / 10 : 0, _$path = basename(sourcePath || "").replace(/\.[jt]sx?$/, "").slice(0, 22).trim().padStart(24), numOptimized = "".concat(res.optimized + res.styled).padStart(3), numFound = "".concat(res.found + res.styled).padStart(3), numFlattened = "".concat(res.flattened).padStart(3), memory = memUsed ? " ".concat(memUsed, "MB") : "", timing = Date.now() - start, timingStr = "".concat(timing, "ms").padStart(6), pre = getPrefixLogs(options), memStr = memory ? "(".concat(memory, ")") : "", console.info("".concat(pre, " ").concat(_$path, "   \xB7  ").concat(numFound, " found   \xB7  ").concat(numOptimized, " opt   \xB7  ").concat(numFlattened, " flat  ").concat(timingStr, " ").concat(memStr))), [
+            2,
+            {
+              ast,
+              styles,
+              js: result.code,
+              map: result.map
+            }
+          ]);
+      }
+    });
+  }), _extractToClassNames.apply(this, arguments);
 }
 export {
   extractToClassNames