@tamagui/static 1.115.1 → 1.115.3

package/dist/extractor/createLogger.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var createLogger_exports = {};
+__export(createLogger_exports, {
+  createLogger: () => createLogger
+});
+module.exports = __toCommonJS(createLogger_exports);
+var import_node_path = require("node:path"), import_getPrefixLogs = require("./getPrefixLogs");
+function createLogger(sourcePath, options) {
+  const shouldLogTiming = options.logTimings ?? !0, start = Date.now(), mem = process.env.TAMAGUI_SHOW_MEMORY_USAGE && shouldLogTiming ? process.memoryUsage() : null;
+  return (res) => {
+    if (!shouldLogTiming)
+      return;
+    const memUsed = mem ? Math.round((process.memoryUsage().heapUsed - mem.heapUsed) / 1024 / 1204 * 10) / 10 : 0, path = (0, import_node_path.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 = (0, import_getPrefixLogs.getPrefixLogs)(options), memStr = memory ? `(${memory})` : "";
+    console.info(
+      `${pre} ${path}   \xB7  ${numFound} found   \xB7  ${numOptimized} opt   \xB7  ${numFlattened} flat  ${timingStr} ${memStr}`
+    );
+  };
+}
+//# sourceMappingURL=createLogger.js.map

package/dist/extractor/ensureImportingConcat.js

@@ -0,0 +1,50 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var ensureImportingConcat_exports = {};
+__export(ensureImportingConcat_exports, {
+  ensureImportingConcat: () => ensureImportingConcat
+});
+module.exports = __toCommonJS(ensureImportingConcat_exports);
+var t = __toESM(require("@babel/types"));
+const importConcatPkg = "@tamagui/helpers";
+function ensureImportingConcat(path) {
+  const imported = path.get("body").find(
+    (x) => x.isImportDeclaration() && x.node.source.value === importConcatPkg
+  ), importSpecifier = t.importSpecifier(
+    t.identifier("concatClassName"),
+    t.identifier("concatClassName")
+  );
+  if (!imported) {
+    path.node.body.push(
+      t.importDeclaration([importSpecifier], t.stringLiteral(importConcatPkg))
+    );
+    return;
+  }
+  const specifiers = imported.node.specifiers;
+  specifiers.some(
+    (x) => t.isImportSpecifier(x) && t.isIdentifier(x.imported) && x.imported.name === "concatClassName"
+  ) || specifiers.push(
+    t.importSpecifier(t.identifier("concatClassName"), t.identifier("concatClassName"))
+  );
+}
+//# sourceMappingURL=ensureImportingConcat.js.map

package/dist/extractor/esbuildAliasPlugin.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var esbuildAliasPlugin_exports = {};
+__export(esbuildAliasPlugin_exports, {
+  esbuildAliasPlugin: () => esbuildAliasPlugin
+});
+module.exports = __toCommonJS(esbuildAliasPlugin_exports);
+const esbuildAliasPlugin = (config) => {
+  const alias = config && Object.keys(config);
+  return {
+    name: "path-alias",
+    setup(build) {
+      if (!alias || !alias.length)
+        return;
+      const main = (k, args) => ({
+        path: config[k].replace(/\/$/, "")
+      });
+      alias.forEach((k) => {
+        build.onResolve({ filter: new RegExp(`^.*${k}$`) }, (args) => main(k, args)), build.onResolve({ filter: new RegExp(`^.*\\/${k}\\/.*$`) }, (args) => main(k, args));
+      });
+    }
+  };
+};
+//# sourceMappingURL=esbuildAliasPlugin.js.map

package/dist/extractor/evaluateAstNode.js

@@ -0,0 +1,99 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var evaluateAstNode_exports = {};
+__export(evaluateAstNode_exports, {
+  evaluateAstNode: () => evaluateAstNode
+});
+module.exports = __toCommonJS(evaluateAstNode_exports);
+var t = __toESM(require("@babel/types"));
+function evaluateAstNode(exprNode, evalFn, shouldPrintDebug) {
+  if (exprNode !== void 0) {
+    if (exprNode === null)
+      return !0;
+    if (t.isJSXExpressionContainer(exprNode))
+      return evaluateAstNode(exprNode.expression);
+    if (t.isObjectExpression(exprNode)) {
+      const ret = {};
+      for (let idx = -1, len = exprNode.properties.length; ++idx < len; ) {
+        const value = exprNode.properties[idx];
+        if (!t.isObjectProperty(value))
+          throw new Error("evaluateAstNode can only evaluate object properties");
+        let key;
+        if (value.computed) {
+          if (typeof evalFn != "function")
+            throw new Error(
+              "evaluateAstNode does not support computed keys unless an eval function is provided"
+            );
+          key = evaluateAstNode(value.key, evalFn);
+        } else if (t.isIdentifier(value.key))
+          key = value.key.name;
+        else if (t.isStringLiteral(value.key) || t.isNumericLiteral(value.key))
+          key = value.key.value;
+        else
+          throw new Error("Unsupported key type: " + value.key.type);
+        if (typeof key != "string" && typeof key != "number")
+          throw new Error("key must be either a string or a number");
+        ret[key] = evaluateAstNode(value.value, evalFn);
+      }
+      return ret;
+    }
+    if (t.isArrayExpression(exprNode))
+      return exprNode.elements.map((x) => evaluateAstNode(x, evalFn));
+    if (t.isUnaryExpression(exprNode) && exprNode.operator === "-") {
+      const ret = evaluateAstNode(exprNode.argument, evalFn);
+      return ret == null ? null : -ret;
+    }
+    if (t.isTemplateLiteral(exprNode)) {
+      if (typeof evalFn != "function")
+        throw new Error(
+          "evaluateAstNode does not support template literals unless an eval function is provided"
+        );
+      let ret = "";
+      for (let idx = -1, len = exprNode.quasis.length; ++idx < len; ) {
+        const quasi = exprNode.quasis[idx], expr = exprNode.expressions[idx];
+        ret += quasi.value.raw, expr && (ret += evaluateAstNode(expr, evalFn));
+      }
+      return ret;
+    }
+    if (t.isNullLiteral(exprNode))
+      return null;
+    if (t.isNumericLiteral(exprNode) || t.isStringLiteral(exprNode) || t.isBooleanLiteral(exprNode))
+      return exprNode.value;
+    if (t.isBinaryExpression(exprNode)) {
+      if (exprNode.operator === "+")
+        return evaluateAstNode(exprNode.left, evalFn) + evaluateAstNode(exprNode.right, evalFn);
+      if (exprNode.operator === "-")
+        return evaluateAstNode(exprNode.left, evalFn) - evaluateAstNode(exprNode.right, evalFn);
+      if (exprNode.operator === "*")
+        return evaluateAstNode(exprNode.left, evalFn) * evaluateAstNode(exprNode.right, evalFn);
+      if (exprNode.operator === "/")
+        return evaluateAstNode(exprNode.left, evalFn) / evaluateAstNode(exprNode.right, evalFn);
+    }
+    if (typeof evalFn != "function")
+      throw new Error(
+        "evaluateAstNode does not support non-literal values unless an eval function is provided"
+      );
+    return evalFn(exprNode);
+  }
+}
+//# sourceMappingURL=evaluateAstNode.js.map

package/dist/extractor/extractHelpers.js

@@ -0,0 +1,109 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var extractHelpers_exports = {};
+__export(extractHelpers_exports, {
+  attrStr: () => attrStr,
+  findComponentName: () => findComponentName,
+  getValidComponent: () => getValidComponent,
+  getValidComponentsPaths: () => getValidComponentsPaths,
+  getValidImport: () => getValidImport,
+  isComponentPackage: () => isComponentPackage,
+  isInsideComponentPackage: () => isInsideComponentPackage,
+  isPresent: () => isPresent,
+  isSimpleSpread: () => isSimpleSpread,
+  isValidImport: () => isValidImport,
+  isValidModule: () => isValidModule,
+  isValidThemeHook: () => isValidThemeHook,
+  objToStr: () => objToStr,
+  ternaryStr: () => ternaryStr
+});
+module.exports = __toCommonJS(extractHelpers_exports);
+var import_node_path = require("node:path"), import_generator = __toESM(require("@babel/generator")), t = __toESM(require("@babel/types")), import_find_root = __toESM(require("find-root")), import_memoize = require("../helpers/memoize");
+function isPresent(input) {
+  return input != null;
+}
+function isSimpleSpread(node) {
+  return t.isIdentifier(node.argument) || t.isMemberExpression(node.argument);
+}
+const attrStr = (attr) => attr ? attr.type === "attr" ? getNameAttr(attr.value) : attr.type === "ternary" ? `...${ternaryStr(attr.value)}` : `${attr.type}(${objToStr(attr.value)})` : "", objToStr = (obj, spacer = ", ") => obj ? `{${Object.entries(obj).map(
+  ([k, v]) => `${k}:${Array.isArray(v) ? "[...]" : v && typeof v == "object" ? `${objToStr(v, ",")}` : JSON.stringify(v)}`
+).join(spacer)}}` : `${obj}`, getNameAttr = (attr) => t.isJSXSpreadAttribute(attr) ? `...${attr.argument.name}` : "name" in attr ? attr.name.name : `unknown-${attr.type}`, ternaryStr = (x) => [
+  "ternary(",
+  t.isIdentifier(x.test) ? x.test.name : t.isMemberExpression(x.test) ? [x.test.object.name, x.test.property.name] : (
+    // @ts-ignore
+    (0, import_generator.default)(x.test).code
+  ),
+  isFilledObj(x.consequent) ? ` ? ${objToStr(x.consequent)}` : " ? \u{1F6AB}",
+  isFilledObj(x.alternate) ? ` : ${objToStr(x.alternate)}` : " : \u{1F6AB}",
+  ")"
+].flat().join(""), isFilledObj = (obj) => obj && Object.keys(obj).length;
+function findComponentName(scope) {
+  const componentName = "";
+  let cur = scope.path;
+  for (; cur.parentPath && !t.isProgram(cur.parentPath.parent); )
+    cur = cur.parentPath;
+  let node = cur.parent;
+  if (t.isExportNamedDeclaration(node) && (node = node.declaration), t.isVariableDeclaration(node)) {
+    const [dec] = node.declarations;
+    if (t.isVariableDeclarator(dec) && t.isIdentifier(dec.id))
+      return dec.id.name;
+  }
+  return t.isFunctionDeclaration(node) ? node.id?.name : componentName;
+}
+function isValidThemeHook(props, jsxPath, n, sourcePath) {
+  if (!t.isIdentifier(n.object) || !t.isIdentifier(n.property)) return !1;
+  const binding = jsxPath.scope.getAllBindings()[n.object.name];
+  if (!binding?.path || !binding.path.isVariableDeclarator()) return !1;
+  const init = binding.path.node.init;
+  if (!init || !t.isCallExpression(init) || !t.isIdentifier(init.callee) || init.callee.name !== "useTheme") return !1;
+  const importNode = binding.scope.getBinding("useTheme")?.path.parent;
+  return !(!t.isImportDeclaration(importNode) || sourcePath && !isValidImport(props, sourcePath));
+}
+const isInsideComponentPackage = (props, moduleName) => getValidComponentsPaths(props).some((path) => moduleName.startsWith(path)), isComponentPackage = (props, srcName) => getValidComponentsPaths(props).some((path) => srcName.startsWith(path));
+function getValidComponent(props, moduleName, componentName) {
+  if (componentName[0].toUpperCase() !== componentName[0])
+    return !1;
+  for (const loaded of props.allLoadedComponents) {
+    if (!loaded) continue;
+    const isInModule = moduleName === "*" || moduleName.startsWith(loaded.moduleName), foundComponent = loaded.nameToInfo[componentName];
+    if (isInModule && foundComponent)
+      return foundComponent;
+  }
+  return null;
+}
+const isValidModule = (props, moduleName) => {
+  if (typeof moduleName != "string")
+    throw new Error("No module name");
+  const isLocal = moduleName.startsWith(".");
+  return {
+    isLocal,
+    isValid: isLocal ? isInsideComponentPackage(props, moduleName) : isComponentPackage(props, moduleName)
+  };
+}, getValidImport = (props, moduleName, componentName) => {
+  const { isValid, isLocal } = isValidModule(props, moduleName);
+  return !isValid || !componentName ? null : getValidComponent(props, isLocal ? "*" : moduleName, componentName) || null;
+}, isValidImport = (props, moduleName, componentName) => componentName ? !!getValidImport(props, moduleName, componentName) : isValidModule(props, moduleName).isValid, getValidComponentPackages = (0, import_memoize.memoize)((props) => [.../* @__PURE__ */ new Set(["@tamagui/core", "tamagui", ...props.components || []])]), getValidComponentsPaths = (0, import_memoize.memoize)((props) => getValidComponentPackages(props).flatMap((pkg) => {
+  const root = (0, import_find_root.default)(pkg);
+  return [(0, import_node_path.basename)(root), pkg].filter(Boolean);
+}));
+//# sourceMappingURL=extractHelpers.js.map

package/dist/extractor/extractMediaStyle.js

@@ -0,0 +1,123 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var extractMediaStyle_exports = {};
+__export(extractMediaStyle_exports, {
+  extractMediaStyle: () => extractMediaStyle,
+  isValidMediaCall: () => isValidMediaCall
+});
+module.exports = __toCommonJS(extractMediaStyle_exports);
+var t = __toESM(require("@babel/types")), core = __toESM(require("@tamagui/core")), import_requireTamaguiCore = require("../helpers/requireTamaguiCore"), import_extractHelpers = require("./extractHelpers");
+function extractMediaStyle(props, ternary, jsxPath, tamaguiConfig, sourcePath, importance = 0, shouldPrintDebug = !1) {
+  const { getStylesAtomic, mediaObjectToString } = (0, import_requireTamaguiCore.requireTamaguiCore)("web"), mt = getMediaQueryTernary(props, ternary, jsxPath, sourcePath);
+  if (!mt)
+    return null;
+  const { key } = mt;
+  if (!tamaguiConfig.media[key])
+    return console.error(`Media query "${key}" not found: ${Object.keys(tamaguiConfig.media)}`), null;
+  const getStyleObj = (styleObj, negate = !1) => styleObj ? { styleObj, negate } : null, styleOpts = [
+    getStyleObj(ternary.consequent, !1),
+    getStyleObj(ternary.alternate, !0)
+  ].filter(import_extractHelpers.isPresent);
+  if (shouldPrintDebug && !styleOpts.length)
+    return console.info("  media query, no styles?"), null;
+  const mediaKeyPrecendence = Object.keys(tamaguiConfig.media).reduce((acc, cur, i) => (acc[cur] = new Array(importance + 1).fill(":root").join(""), acc), {});
+  let mediaStyles = [];
+  for (const { styleObj, negate } of styleOpts) {
+    const singleMediaStyles = getStylesAtomic(styleObj).map((style) => {
+      const mediaStyle = core.createMediaStyle(
+        style,
+        key,
+        tamaguiConfig.media,
+        !0,
+        negate
+      ), className = `.${mediaStyle[core.StyleObjectIdentifier]}`;
+      return {
+        ...mediaStyle,
+        className
+      };
+    });
+    shouldPrintDebug === "verbose" && console.info(
+      "  media styles:",
+      importance,
+      styleObj,
+      singleMediaStyles.map((x) => x[core.StyleObjectIdentifier]).join(", ")
+    ), mediaStyles = [...mediaStyles, ...singleMediaStyles];
+  }
+  return ternary.remove(), { mediaStyles, ternaryWithoutMedia: mt.ternaryWithoutMedia };
+}
+function getMediaQueryTernary(props, ternary, jsxPath, sourcePath) {
+  if (t.isLogicalExpression(ternary.test) && ternary.test.operator === "&&") {
+    const mediaLeft = getMediaInfoFromExpression(
+      props,
+      ternary.test.left,
+      jsxPath,
+      sourcePath,
+      ternary.inlineMediaQuery
+    );
+    if (mediaLeft)
+      return {
+        ...mediaLeft,
+        ternaryWithoutMedia: {
+          ...ternary,
+          test: ternary.test.right
+        }
+      };
+  }
+  const result = getMediaInfoFromExpression(
+    props,
+    ternary.test,
+    jsxPath,
+    sourcePath,
+    ternary.inlineMediaQuery
+  );
+  return result ? {
+    ...result,
+    ternaryWithoutMedia: null
+  } : null;
+}
+function getMediaInfoFromExpression(props, test, jsxPath, sourcePath, inlineMediaQuery) {
+  if (inlineMediaQuery)
+    return {
+      key: inlineMediaQuery,
+      bindingName: inlineMediaQuery
+    };
+  if (t.isMemberExpression(test) && t.isIdentifier(test.object) && t.isIdentifier(test.property)) {
+    const name = test.object.name, key = test.property.name, binding = jsxPath.scope.getAllBindings()[name];
+    if (!binding) return !1;
+    const bindingNode = binding.path?.node;
+    return !t.isVariableDeclarator(bindingNode) || !bindingNode.init || !isValidMediaCall(props, jsxPath, bindingNode.init, sourcePath) ? !1 : { key, bindingName: name };
+  }
+  if (t.isIdentifier(test)) {
+    const key = test.name, node = jsxPath.scope.getBinding(test.name)?.path?.node;
+    return !t.isVariableDeclarator(node) || !node.init || !isValidMediaCall(props, jsxPath, node.init, sourcePath) ? !1 : { key, bindingName: key };
+  }
+  return null;
+}
+function isValidMediaCall(props, jsxPath, init, sourcePath) {
+  if (!init || !t.isCallExpression(init) || !t.isIdentifier(init.callee) || init.callee.name !== "useMedia") return !1;
+  const mediaBinding = jsxPath.scope.getAllBindings().useMedia;
+  if (!mediaBinding) return !1;
+  const useMediaImport = mediaBinding.path.parent;
+  return !(!t.isImportDeclaration(useMediaImport) || !(0, import_extractHelpers.isValidImport)(props, sourcePath));
+}
+//# sourceMappingURL=extractMediaStyle.js.map