@tamagui/web 1.114.4 → 1.115.0

package/dist/cjs/helpers/{mergeVariants.js → mergeVariants.cjs}

@@ -3,15 +3,21 @@ 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);
+    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 mergeVariants_exports = {};
 __export(mergeVariants_exports, {
   mergeVariants: () => mergeVariants
@@ -20,12 +26,9 @@ module.exports = __toCommonJS(mergeVariants_exports);
 const mergeVariants = (parentVariants, ourVariants, level = 0) => {
   const variants = {};
   for (const key in ourVariants) {
-    const parentVariant = parentVariants?.[key], ourVariant = ourVariants[key];
-    !parentVariant || typeof ourVariant == "function" ? variants[key] = ourVariant : parentVariant && !ourVariant ? variants[key] = parentVariant[key] : level === 0 ? variants[key] = mergeVariants(
-      parentVariant,
-      ourVariant,
-      level + 1
-    ) : variants[key] = {
+    const parentVariant = parentVariants?.[key],
+      ourVariant = ourVariants[key];
+    !parentVariant || typeof ourVariant == "function" ? variants[key] = ourVariant : parentVariant && !ourVariant ? variants[key] = parentVariant[key] : level === 0 ? variants[key] = mergeVariants(parentVariant, ourVariant, level + 1) : variants[key] = {
       ...parentVariant,
       ...ourVariant
     };
@@ -34,5 +37,4 @@ const mergeVariants = (parentVariants, ourVariants, level = 0) => {
     ...parentVariants,
     ...variants
   };
-};
-//# sourceMappingURL=mergeVariants.js.map
+};

package/dist/cjs/helpers/normalizeColor.cjs

@@ -0,0 +1,48 @@
+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 normalizeColor_exports = {};
+__export(normalizeColor_exports, {
+  getRgba: () => getRgba,
+  normalizeColor: () => normalizeColor,
+  rgba: () => import_normalize_css_color2.rgba
+});
+module.exports = __toCommonJS(normalizeColor_exports);
+var import_normalize_css_color = require("@tamagui/normalize-css-color"),
+  import_normalize_css_color2 = require("@tamagui/normalize-css-color");
+const normalizeColor = (color, opacity) => {
+    if (color) {
+      if (color[0] === "$") return color;
+      if (color.startsWith("var(")) {
+        if (typeof opacity == "number" && opacity < 1) return `color-mix(in srgb, ${color} ${opacity * 100}%, transparent)`;
+      } else {
+        const rgba3 = getRgba(color);
+        if (rgba3) {
+          const colors = `${rgba3.r},${rgba3.g},${rgba3.b}`;
+          return opacity === 1 ? `rgb(${colors})` : `rgba(${colors},${opacity ?? rgba3.a ?? 1})`;
+        }
+      }
+      return color;
+    }
+  },
+  getRgba = color => {
+    const colorNum = (0, import_normalize_css_color.normalizeCSSColor)(color);
+    if (colorNum != null) return (0, import_normalize_css_color.rgba)(colorNum);
+  };

package/dist/cjs/helpers/{normalizeShadow.js → normalizeShadow.cjs}

@@ -3,28 +3,38 @@ 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);
+    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 normalizeShadow_exports = {};
 __export(normalizeShadow_exports, {
   normalizeShadow: () => normalizeShadow
 });
 module.exports = __toCommonJS(normalizeShadow_exports);
-var import_defaultOffset = require("./defaultOffset"), import_normalizeColor = require("./normalizeColor");
+var import_defaultOffset = require("./defaultOffset.cjs"),
+  import_normalizeColor = require("./normalizeColor.cjs");
 function normalizeShadow({
   shadowColor,
   shadowOffset,
   shadowOpacity,
   shadowRadius
 }) {
-  const { height, width } = shadowOffset || import_defaultOffset.defaultOffset;
+  const {
+    height,
+    width
+  } = shadowOffset || import_defaultOffset.defaultOffset;
   return {
     shadowOffset: {
       width: width || 0,
@@ -34,5 +44,4 @@ function normalizeShadow({
     shadowColor: (0, import_normalizeColor.normalizeColor)(shadowColor, 1),
     shadowOpacity: shadowOpacity ?? (shadowColor ? (0, import_normalizeColor.getRgba)(shadowColor)?.a : 1)
   };
-}
-//# sourceMappingURL=normalizeShadow.js.map
+}

package/dist/cjs/helpers/normalizeStyle.cjs

@@ -0,0 +1,47 @@
+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 normalizeStyle_exports = {};
+__export(normalizeStyle_exports, {
+  normalizeStyle: () => normalizeStyle
+});
+module.exports = __toCommonJS(normalizeStyle_exports);
+var import_expandStyle = require("./expandStyle.cjs"),
+  import_expandStyles = require("./expandStyles.cjs"),
+  import_isObj = require("./isObj.cjs"),
+  import_normalizeValueWithProperty = require("./normalizeValueWithProperty.cjs"),
+  import_pseudoDescriptors = require("./pseudoDescriptors.cjs");
+function normalizeStyle(style, disableNormalize = !1) {
+  const res = {};
+  for (let key in style) {
+    const prop = style[key];
+    if (prop == null) continue;
+    if (key in import_pseudoDescriptors.pseudoDescriptors ||
+    // this should capture all parent-based styles like media, group, etc
+    key[0] === "$" && (0, import_isObj.isObj)(prop)) {
+      res[key] = normalizeStyle(prop, disableNormalize);
+      continue;
+    }
+    const value = disableNormalize ? prop : (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(prop, key),
+      out = (0, import_expandStyle.expandStyle)(key, value);
+    out ? Object.assign(res, Object.fromEntries(out)) : res[key] = value;
+  }
+  return (0, import_expandStyles.fixStyles)(res), res;
+}

package/dist/cjs/helpers/normalizeStylePropKeys.cjs

@@ -0,0 +1,26 @@
+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 normalizeStylePropKeys_exports = {};
+__export(normalizeStylePropKeys_exports, {
+  normalizeStylePropKeys: () => normalizeStylePropKeys
+});
+module.exports = __toCommonJS(normalizeStylePropKeys_exports);
+const normalizeStylePropKeys = {};

package/dist/cjs/helpers/normalizeStylePropKeys.native.cjs

@@ -0,0 +1,37 @@
+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 normalizeStylePropKeys_native_exports = {};
+__export(normalizeStylePropKeys_native_exports, {
+  normalizeStylePropKeys: () => normalizeStylePropKeys
+});
+module.exports = __toCommonJS(normalizeStylePropKeys_native_exports);
+const normalizeStylePropKeys = {
+  backgroundColor: !0,
+  borderColor: !0,
+  borderTopColor: !0,
+  borderRightColor: !0,
+  borderBottomColor: !0,
+  borderLeftColor: !0,
+  color: !0,
+  shadowColor: !0,
+  textDecorationColor: !0,
+  textShadowColor: !0
+};

package/dist/cjs/helpers/normalizeStylePropKeys.native.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/helpers/normalizeStylePropKeys.native.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,yBAAyB;AAAA,EACpC,iBAAiB;AAAA,EACjB,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,iBAAiB;AAAA,EACjB,OAAO;AAAA,EACP,aAAa;AAAA,EACb,qBAAqB;AAAA,EACrB,iBAAiB;AACnB;",
+  "names": []
+}

package/dist/cjs/helpers/{normalizeValueWithProperty.js → normalizeValueWithProperty.cjs}

@@ -3,42 +3,46 @@ 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);
+    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 normalizeValueWithProperty_exports = {};
 __export(normalizeValueWithProperty_exports, {
   normalizeValueWithProperty: () => normalizeValueWithProperty,
   reverseMapClassNameToValue: () => reverseMapClassNameToValue
 });
 module.exports = __toCommonJS(normalizeValueWithProperty_exports);
-var import_constants = require("@tamagui/constants"), import_helpers = require("@tamagui/helpers"), import_insertStyleRule = require("./insertStyleRule");
+var import_constants = require("@tamagui/constants"),
+  import_helpers = require("@tamagui/helpers"),
+  import_insertStyleRule = require("./insertStyleRule.cjs");
 const stylePropsAllPlusTransforms = {
   ...import_helpers.stylePropsAll,
   translateX: !0,
   translateY: !0
 };
 function normalizeValueWithProperty(value, property = "") {
-  if (!import_constants.isWeb || import_helpers.stylePropsUnitless[property] || property && !stylePropsAllPlusTransforms[property] || typeof value == "boolean")
-    return value;
+  if (!import_constants.isWeb || import_helpers.stylePropsUnitless[property] || property && !stylePropsAllPlusTransforms[property] || typeof value == "boolean") return value;
   let res = value;
   return value && typeof value == "object" ? value : (typeof value == "number" ? res = `${value}px` : property && (res = `${res}`), res);
 }
 const rcache = {};
 function reverseMapClassNameToValue(key, className) {
   const cssRule = (0, import_insertStyleRule.getAllSelectors)()[className];
-  if (rcache[cssRule])
-    return rcache[cssRule];
+  if (rcache[cssRule]) return rcache[cssRule];
   if (!cssRule) {
-    process.env.NODE_ENV === "development" && console.warn(
-      `No CSS rule found for ${key} looking for selector ".${className}", you may not be injecting extracted CSS`
-    );
+    process.env.NODE_ENV === "development" && console.warn(`No CSS rule found for ${key} looking for selector ".${className}", you may not be injecting extracted CSS`);
     return;
   }
   const cssVal = cssRule.replace(/.*:/, "").replace(/;.*/, "").trim();
@@ -50,5 +54,4 @@ function reverseMapClassNameToValue(key, className) {
     key,
     className
   }), res;
-}
-//# sourceMappingURL=normalizeValueWithProperty.js.map
+}

package/dist/cjs/helpers/objectIdentityKey.cjs

@@ -0,0 +1,39 @@
+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 objectIdentityKey_exports = {};
+__export(objectIdentityKey_exports, {
+  objectIdentityKey: () => objectIdentityKey
+});
+module.exports = __toCommonJS(objectIdentityKey_exports);
+function objectIdentityKey(obj) {
+  let k = "";
+  for (const key in obj) {
+    k += key;
+    const arg = obj[key];
+    let type = typeof arg;
+    if (!arg || type !== "object" && type !== "function") k += type + arg;else if (cache.has(arg)) k += cache.get(arg);else {
+      let v = Math.random();
+      cache.set(arg, v), k += v;
+    }
+  }
+  return k;
+}
+const cache = /* @__PURE__ */new WeakMap();

package/dist/cjs/helpers/propMapper.cjs

@@ -0,0 +1,254 @@
+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 propMapper_exports = {};
+__export(propMapper_exports, {
+  getFontFamilyFromNameOrVariable: () => getFontFamilyFromNameOrVariable,
+  getPropMappedFontFamily: () => getPropMappedFontFamily,
+  getTokenForKey: () => getTokenForKey,
+  propMapper: () => propMapper
+});
+module.exports = __toCommonJS(propMapper_exports);
+var import_constants = require("@tamagui/constants"),
+  import_helpers = require("@tamagui/helpers"),
+  import_config = require("../config.cjs"),
+  import_createVariable = require("../createVariable.cjs"),
+  import_expandStyle = require("./expandStyle.cjs"),
+  import_normalizeStyle = require("./normalizeStyle.cjs"),
+  import_getVariantExtras = require("./getVariantExtras.cjs"),
+  import_isObj = require("./isObj.cjs"),
+  import_pseudoDescriptors = require("./pseudoDescriptors.cjs"),
+  import_skipProps = require("./skipProps.cjs");
+const propMapper = (key, value, styleState) => {
+    if (lastFontFamilyToken = null, key === "elevationAndroid") return;
+    const {
+      conf,
+      styleProps,
+      fontFamily,
+      staticConfig
+    } = styleState;
+    if (value === "unset") {
+      const unsetVal = conf.unset?.[key];
+      if (unsetVal != null) value = unsetVal;else return;
+    }
+    styleProps.fallbackProps && (styleState.props = styleProps.fallbackProps);
+    const {
+      variants
+    } = staticConfig;
+    if (process.env.NODE_ENV === "development" && fontFamily && fontFamily[0] === "$" && !(fontFamily in conf.fontsParsed) && console.warn(`Warning: no fontFamily "${fontFamily}" found in config: ${Object.keys(conf.fontsParsed).join(", ")}`), !styleProps.noExpand && variants && key in variants) {
+      const variantValue = resolveVariants(key, value, styleProps, styleState, "");
+      if (variantValue) return variantValue;
+    }
+    if (styleProps.disableExpandShorthands || key in conf.shorthands && (key = conf.shorthands[key]), value && (value[0] === "$" ? value = getTokenForKey(key, value, styleProps.resolveValues, styleState) : (0, import_createVariable.isVariable)(value) && (value = resolveVariableValue(key, value, styleProps.resolveValues))), value != null) {
+      const result = (styleProps.noExpand ? null : (0, import_expandStyle.expandStyle)(key, value)) || [[key, value]];
+      return key === "fontFamily" && lastFontFamilyToken && fontFamilyCache.set(result, lastFontFamilyToken), result;
+    }
+  },
+  resolveVariants = (key, value, styleProps, styleState, parentVariantKey) => {
+    const {
+        staticConfig,
+        conf,
+        debug
+      } = styleState,
+      {
+        variants
+      } = staticConfig;
+    if (!variants) return;
+    let variantValue = getVariantDefinition(variants[key], value, conf);
+    if (process.env.NODE_ENV === "development" && debug === "verbose" && (console.groupCollapsed(`\u2666\uFE0F\u2666\uFE0F\u2666\uFE0F resolve variant ${key}`), console.info({
+      key,
+      value,
+      variantValue,
+      variants
+    }), console.groupEnd()), !variantValue) {
+      if (process.env.TAMAGUI_WARN_ON_MISSING_VARIANT === "1" && typeof value != "boolean") {
+        const name = staticConfig.componentName || "[UnnamedComponent]";
+        console.warn(`No variant found: ${name} has variant "${key}", but no matching value "${value}"`);
+      }
+      return;
+    }
+    if (typeof variantValue == "function") {
+      const fn = variantValue,
+        extras = (0, import_getVariantExtras.getVariantExtras)(styleState);
+      variantValue = fn(value, extras), process.env.NODE_ENV === "development" && debug === "verbose" && (console.groupCollapsed("   expanded functional variant", key), console.info({
+        fn,
+        variantValue,
+        extras
+      }), console.groupEnd());
+    }
+    let fontFamilyResult;
+    if ((0, import_isObj.isObj)(variantValue)) {
+      const fontFamilyUpdate = variantValue.fontFamily || variantValue[conf.inverseShorthands.fontFamily];
+      fontFamilyUpdate && (fontFamilyResult = getFontFamilyFromNameOrVariable(fontFamilyUpdate, conf), styleState.fontFamily = fontFamilyResult, process.env.NODE_ENV === "development" && debug === "verbose" && console.info("   updating font family", fontFamilyResult)), variantValue = resolveTokensAndVariants(key, variantValue, styleProps, styleState, parentVariantKey);
+    }
+    if (variantValue) {
+      const expanded = (0, import_normalizeStyle.normalizeStyle)(variantValue, !!styleProps.noNormalize);
+      process.env.NODE_ENV === "development" && debug === "verbose" && console.info("   expanding styles from ", variantValue, "to", expanded);
+      const next = Object.entries(expanded);
+      return fontFamilyResult && fontFamilyResult[0] === "$" && fontFamilyCache.set(next, (0, import_createVariable.getVariableValue)(fontFamilyResult)), next;
+    }
+  };
+function getFontFamilyFromNameOrVariable(input, conf) {
+  if ((0, import_createVariable.isVariable)(input)) {
+    const val = variableToFontNameCache.get(input);
+    if (val) return val;
+    for (const key in conf.fontsParsed) {
+      const familyVariable = conf.fontsParsed[key].family;
+      if ((0, import_createVariable.isVariable)(familyVariable) && (variableToFontNameCache.set(familyVariable, key), familyVariable === input)) return key;
+    }
+  } else if (typeof input == "string" && input[0] === "$") return input;
+}
+const variableToFontNameCache = /* @__PURE__ */new WeakMap(),
+  fontFamilyCache = /* @__PURE__ */new WeakMap(),
+  getPropMappedFontFamily = expanded => expanded && fontFamilyCache.get(expanded),
+  resolveTokensAndVariants = (key, value, styleProps, styleState, parentVariantKey) => {
+    const {
+        conf,
+        staticConfig,
+        debug,
+        theme
+      } = styleState,
+      {
+        variants
+      } = staticConfig,
+      res = {};
+    process.env.NODE_ENV === "development" && debug === "verbose" && console.info("   - resolveTokensAndVariants", key, value);
+    for (const _key in value) {
+      const subKey = conf.shorthands[_key] || _key,
+        val = value[_key];
+      if (!(!styleProps.noSkip && subKey in import_skipProps.skipProps)) {
+        if (styleProps.noExpand) res[subKey] = val;else if (variants && subKey in variants) {
+          if (parentVariantKey && parentVariantKey === key) res[subKey] =
+          // SYNC WITH *1
+          val[0] === "$" ? getTokenForKey(subKey, val, styleProps.resolveValues, styleState) : val;else {
+            const variantOut = resolveVariants(subKey, val, styleProps, styleState, key);
+            if (variantOut) for (const [key2, val2] of variantOut) val2 != null && (key2 in import_pseudoDescriptors.pseudoDescriptors ? (res[key2] ??= {}, Object.assign(res[key2], val2)) : res[key2] = val2);
+          }
+          continue;
+        }
+        if ((0, import_createVariable.isVariable)(val)) {
+          res[subKey] = resolveVariableValue(subKey, val, styleProps.resolveValues), process.env.NODE_ENV === "development" && debug === "verbose" && console.info("variable", subKey, res[subKey]);
+          continue;
+        }
+        if (typeof val == "string") {
+          const fVal =
+          // SYNC WITH *1
+          val[0] === "$" ? getTokenForKey(subKey, val, styleProps.resolveValues, styleState) : val;
+          res[subKey] = fVal;
+          continue;
+        }
+        if ((0, import_isObj.isObj)(val)) {
+          const subObject = resolveTokensAndVariants(subKey, val, styleProps, styleState, key);
+          process.env.NODE_ENV === "development" && debug === "verbose" && console.info("object", subKey, subObject), res[subKey] ??= {}, Object.assign(res[subKey], subObject);
+        } else res[subKey] = val;
+        process.env.NODE_ENV === "development" && debug && res[subKey]?.[0] === "$" && console.warn(`\u26A0\uFE0F Missing token in theme ${theme.name}:`, subKey, res[subKey], theme);
+      }
+    }
+    return res;
+  },
+  tokenCats = ["size", "color", "radius", "space", "zIndex"].map(name => ({
+    name,
+    spreadName: `...${name}`
+  }));
+function getVariantDefinition(variant, value, conf) {
+  if (typeof variant == "function") return variant;
+  const exact = variant[value];
+  if (exact) return exact;
+  if (value != null) {
+    const {
+      tokensParsed
+    } = conf;
+    for (const {
+      name,
+      spreadName
+    } of tokenCats) if (spreadName in variant && value in tokensParsed[name]) return variant[spreadName];
+    const fontSizeVariant = variant["...fontSize"];
+    if (fontSizeVariant && conf.fontSizeTokens.has(value)) return fontSizeVariant;
+  }
+  return variant[`:${typeof value}`] || variant["..."];
+}
+const fontShorthand = {
+  fontSize: "size",
+  fontWeight: "weight"
+};
+let lastFontFamilyToken = null;
+const getTokenForKey = (key, value, resolveAs = "none", styleState) => {
+  if (resolveAs === "none") return value;
+  const {
+      theme,
+      conf = (0, import_config.getConfig)(),
+      context,
+      fontFamily,
+      staticConfig
+    } = styleState,
+    tokensParsed = conf.tokensParsed;
+  let valOrVar,
+    hasSet = !1;
+  const customTokenAccept = staticConfig?.accept?.[key];
+  if (customTokenAccept) {
+    const val = theme?.[value] ?? tokensParsed[customTokenAccept][value];
+    val != null && (resolveAs = "value", valOrVar = val, hasSet = !0);
+  }
+  if (theme && value in theme) valOrVar = theme[value], process.env.NODE_ENV === "development" && styleState.debug === "verbose" && (globalThis.tamaguiAvoidTracking = !0, console.info(` - resolving ${key} to theme value ${value} resolveAs ${resolveAs}`, valOrVar), globalThis.tamaguiAvoidTracking = !1), hasSet = !0;else {
+    if (value in conf.specificTokens) hasSet = !0, valOrVar = conf.specificTokens[value];else {
+      switch (key) {
+        case "fontFamily":
+          {
+            valOrVar = (context?.language ? (0, import_getVariantExtras.getFontsForLanguage)(conf.fontsParsed, context.language) : conf.fontsParsed)[value]?.family || value, lastFontFamilyToken = value, hasSet = !0;
+            break;
+          }
+        case "fontSize":
+        case "lineHeight":
+        case "letterSpacing":
+        case "fontWeight":
+          {
+            const fam = fontFamily || conf.defaultFontToken;
+            if (fam) {
+              const fontsParsed = context?.language ? (0, import_getVariantExtras.getFontsForLanguage)(conf.fontsParsed, context.language) : conf.fontsParsed;
+              valOrVar = (fontsParsed[fam] || fontsParsed[conf.defaultFontToken])?.[fontShorthand[key] || key]?.[value] || value, hasSet = !0;
+            }
+            break;
+          }
+      }
+      for (const cat in import_helpers.tokenCategories) if (key in import_helpers.tokenCategories[cat]) {
+        const res = tokensParsed[cat][value];
+        res != null && (valOrVar = res, hasSet = !0);
+      }
+    }
+    if (!hasSet) {
+      const spaceVar = tokensParsed.space[value];
+      spaceVar != null && (valOrVar = spaceVar, hasSet = !0);
+    }
+  }
+  if (hasSet) {
+    const out = resolveVariableValue(key, valOrVar, resolveAs);
+    return process.env.NODE_ENV === "development" && styleState.debug === "verbose" && (globalThis.tamaguiAvoidTracking = !0, console.info("resolved", resolveAs, valOrVar, out), globalThis.tamaguiAvoidTracking = !1), out;
+  }
+  process.env.NODE_ENV === "development" && styleState.debug === "verbose" && console.warn(`Warning: no token found for ${key}, omitting`);
+};
+function resolveVariableValue(key, valOrVar, resolveValues) {
+  if (resolveValues === "none") return valOrVar;
+  if ((0, import_createVariable.isVariable)(valOrVar)) {
+    if (resolveValues === "value") return valOrVar.val;
+    const get = valOrVar?.get;
+    return typeof get == "function" ? get(resolveValues === "web" ? "web" : void 0) : valOrVar.variable;
+  }
+  return valOrVar;
+}