@tamagui/web 1.116.0 → 1.116.2

package/dist/cjs/helpers/log.js

@@ -0,0 +1,31 @@
+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 log_exports = {};
+__export(log_exports, {
+  log: () => log
+});
+module.exports = __toCommonJS(log_exports);
+var import_useMedia = require("../hooks/useMedia");
+function log(...args) {
+  if (process.env.NODE_ENV !== "production") {
+    (0, import_useMedia._disableMediaTouch)(!0);
+    try {
+      return console.info(...args);
+    } finally {
+      (0, import_useMedia._disableMediaTouch)(!1);
+    }
+  }
+}
+//# sourceMappingURL=log.js.map

package/dist/cjs/helpers/matchMedia.js

@@ -0,0 +1,34 @@
+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 matchMedia_exports = {};
+__export(matchMedia_exports, {
+  matchMedia: () => matchMedia,
+  setupMatchMedia: () => setupMatchMedia
+});
+module.exports = __toCommonJS(matchMedia_exports);
+const matchMedia = typeof window < "u" && window.matchMedia || matchMediaFallback;
+function matchMediaFallback(_) {
+  return {
+    match: (a, b) => !1,
+    addListener() {
+    },
+    removeListener() {
+    },
+    matches: !1
+  };
+}
+function setupMatchMedia(_) {
+}
+//# sourceMappingURL=matchMedia.js.map

package/dist/cjs/helpers/matchMedia.native.js

@@ -25,7 +25,7 @@ var matchMediaImpl = matchMediaFallback, matchMedia = function() {
   return matchMediaImpl(...args);
 };
 function matchMediaFallback(query) {
-  return process.env.NODE_ENV === "development" && console.warn("warning: matchMedia implementation is not provided."), {
+  return !process.env.IS_STATIC && process.env.NODE_ENV === "development" && console.warn("warning: matchMedia implementation is not provided."), {
     match: function(a, b) {
       return !1;
     },
@@ -37,7 +37,7 @@ function matchMediaFallback(query) {
   };
 }
 function setupMatchMedia(_) {
-  matchMediaImpl = _, globalThis.matchMedia = _;
+  process.env.NODE_ENV === "development" && typeof _ != "function" && (process.env.IS_STATIC || console.trace("setupMatchMedia was called without a function, this can cause issues on native", _)), matchMediaImpl = _, globalThis.matchMedia = _;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/helpers/matchMedia.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/helpers/Users/n8/tamagui/code/core/web/src/helpers/matchMedia.native.ts"],
-  "mappings": ";;;;;;;;;;;;;;;AAEA;;;;;;IAAIA,iBAA6BC,oBAEpBC,aAAyB,WAAA;oCAAIC,OAAAA,IAAAA,MAAAA,IAAAA,GAAAA,OAAAA,GAAAA,OAAAA,MAAAA;AAAAA,SAAAA,IAAAA,IAAAA,UAAAA,IAAAA;SAASH,eAAAA,GAAkBG,IAAAA;;AAErE,SAASF,mBAAmBG,OAAa;AACvC,SAAIC,QAAQC,IAAIC,aAAa,iBAC3BC,QAAQC,KAAK,qDAAA,GAER;IACLC,OAAO,SAACC,GAAGC,GAAAA;aAAM;;IACjBC,aAAa,WAAA;IAAO;IACpBC,gBAAgB,WAAA;IAAO;IACvBC,SAAS;EACX;AACF;AAEO,SAASC,gBAAgBC,GAAa;AAC3CjB,mBAAiBiB,GAEjBC,WAAW,aAAgBD;AAC7B;",
-  "names": ["matchMediaImpl", "matchMediaFallback", "matchMedia", "args", "query", "process", "env", "NODE_ENV", "console", "warn", "match", "a", "b", "addListener", "removeListener", "matches", "setupMatchMedia", "_", "globalThis"]
+  "mappings": ";;;;;;;;;;;;;;;AAEA;;;;;;IAAIA,iBAA6BC,oBAEpBC,aAAyB,WAAA;oCAAIC,OAAAA,IAAAA,MAAAA,IAAAA,GAAAA,OAAAA,GAAAA,OAAAA,MAAAA;AAAAA,SAAAA,IAAAA,IAAAA,UAAAA,IAAAA;SAASH,eAAAA,GAAkBG,IAAAA;;AAErE,SAASF,mBAAmBG,OAAa;AACvC,SAAI,CAACC,QAAQC,IAAIC,aAAaF,QAAQC,IAAIE,aAAa,iBACrDC,QAAQC,KAAK,qDAAA,GAER;IACLC,OAAO,SAACC,GAAGC,GAAAA;aAAM;;IACjBC,aAAa,WAAA;IAAO;IACpBC,gBAAgB,WAAA;IAAO;IACvBC,SAAS;EACX;AACF;AAEO,SAASC,gBAAgBC,GAAa;AAC3C,EAAIb,QAAQC,IAAIE,aAAa,iBACvB,OAAOU,KAAM,eACVb,QAAQC,IAAIC,aACfE,QAAQU,MACN,kFACAD,CAAAA,IAMRlB,iBAAiBkB,GAEjBE,WAAW,aAAgBF;AAC7B;",
+  "names": ["matchMediaImpl", "matchMediaFallback", "matchMedia", "args", "query", "process", "env", "IS_STATIC", "NODE_ENV", "console", "warn", "match", "a", "b", "addListener", "removeListener", "matches", "setupMatchMedia", "_", "trace", "globalThis"]
 }

package/dist/cjs/helpers/mergeProps.js

@@ -0,0 +1,41 @@
+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 mergeProps_exports = {};
+__export(mergeProps_exports, {
+  mergeProps: () => mergeProps
+});
+module.exports = __toCommonJS(mergeProps_exports);
+var import_useMedia = require("../hooks/useMedia"), import_pseudoDescriptors = require("./pseudoDescriptors");
+const mergeProps = (a, b, inverseShorthands) => {
+  const out = {};
+  for (const key in a)
+    mergeProp(out, a, b, key, inverseShorthands);
+  if (b)
+    for (const key in b)
+      mergeProp(out, b, void 0, key, inverseShorthands);
+  return out;
+};
+function mergeProp(out, a, b, key, inverseShorthands) {
+  const longhand = inverseShorthands?.[key] || null, val = a[key];
+  if (key in import_pseudoDescriptors.pseudoDescriptors || import_useMedia.mediaKeys.has(key)) {
+    out[key] = {
+      ...out[key],
+      ...val
+    };
+    return;
+  }
+  b && (key in b || longhand && longhand in b) || (out[longhand || key] = val);
+}
+//# sourceMappingURL=mergeProps.js.map

package/dist/cjs/helpers/mergeVariants.js

@@ -0,0 +1,38 @@
+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 mergeVariants_exports = {};
+__export(mergeVariants_exports, {
+  mergeVariants: () => mergeVariants
+});
+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] = {
+      ...parentVariant,
+      ...ourVariant
+    };
+  }
+  return {
+    ...parentVariants,
+    ...variants
+  };
+};
+//# sourceMappingURL=mergeVariants.js.map

package/dist/cjs/helpers/normalizeColor.js

@@ -0,0 +1,43 @@
+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);
+};
+//# sourceMappingURL=normalizeColor.js.map

package/dist/cjs/helpers/normalizeShadow.js

@@ -0,0 +1,38 @@
+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 normalizeShadow_exports = {};
+__export(normalizeShadow_exports, {
+  normalizeShadow: () => normalizeShadow
+});
+module.exports = __toCommonJS(normalizeShadow_exports);
+var import_defaultOffset = require("./defaultOffset"), import_normalizeColor = require("./normalizeColor");
+function normalizeShadow({
+  shadowColor,
+  shadowOffset,
+  shadowOpacity,
+  shadowRadius
+}) {
+  const { height, width } = shadowOffset || import_defaultOffset.defaultOffset;
+  return {
+    shadowOffset: {
+      width: width || 0,
+      height: height || 0
+    },
+    shadowRadius: shadowRadius || 0,
+    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.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 normalizeStyle_exports = {};
+__export(normalizeStyle_exports, {
+  normalizeStyle: () => normalizeStyle
+});
+module.exports = __toCommonJS(normalizeStyle_exports);
+var import_expandStyle = require("./expandStyle"), import_expandStyles = require("./expandStyles"), import_isObj = require("./isObj"), import_normalizeValueWithProperty = require("./normalizeValueWithProperty"), import_pseudoDescriptors = require("./pseudoDescriptors");
+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;
+}
+//# sourceMappingURL=normalizeStyle.js.map

package/dist/cjs/helpers/normalizeStylePropKeys.js

@@ -0,0 +1,21 @@
+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 = {};
+//# sourceMappingURL=normalizeStylePropKeys.js.map

package/dist/cjs/helpers/normalizeValueWithProperty.js

@@ -0,0 +1,54 @@
+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 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");
+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;
+  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 (!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`
+    );
+    return;
+  }
+  const cssVal = cssRule.replace(/.*:/, "").replace(/;.*/, "").trim();
+  let res;
+  return cssVal.startsWith("var(") ? res = cssVal : import_helpers.stylePropsUnitless[key] ? res = +cssVal : cssVal.endsWith("px") ? res = +cssVal.replace("px", "") : res = cssVal, rcache[cssRule] = res, process.env.NODE_ENV === "development" && typeof res == "number" && Number.isNaN(res) && console.info("Tamagui invalid parsed value, NaN:", {
+    res,
+    cssVal,
+    cssRule,
+    key,
+    className
+  }), res;
+}
+//# sourceMappingURL=normalizeValueWithProperty.js.map

package/dist/cjs/helpers/objectIdentityKey.js

@@ -0,0 +1,38 @@
+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();
+//# sourceMappingURL=objectIdentityKey.js.map

package/dist/cjs/helpers/propMapper.js

@@ -0,0 +1,238 @@
+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"), import_createVariable = require("../createVariable"), import_expandStyle = require("./expandStyle"), import_normalizeStyle = require("./normalizeStyle"), import_getVariantExtras = require("./getVariantExtras"), import_isObj = require("./isObj"), import_pseudoDescriptors = require("./pseudoDescriptors"), import_skipProps = require("./skipProps");
+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;
+}
+//# sourceMappingURL=propMapper.js.map