@tamagui/web 1.116.0 → 1.116.2

package/dist/cjs/helpers/getStylesAtomic.js

@@ -0,0 +1,152 @@
+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 getStylesAtomic_exports = {};
+__export(getStylesAtomic_exports, {
+  getStyleAtomic: () => getStyleAtomic,
+  getStylesAtomic: () => getStylesAtomic,
+  styleToCSS: () => styleToCSS
+});
+module.exports = __toCommonJS(getStylesAtomic_exports);
+var import_helpers = require("@tamagui/helpers"), import_config = require("../config"), import_defaultOffset = require("./defaultOffset"), import_normalizeColor = require("./normalizeColor"), import_normalizeValueWithProperty = require("./normalizeValueWithProperty"), import_pseudoDescriptors = require("./pseudoDescriptors"), import_transformsToString = require("./transformsToString"), import_useMedia = require("../hooks/useMedia");
+function getStylesAtomic(style) {
+  styleToCSS(style);
+  const out = [];
+  for (const key in style) {
+    if (key === "$$css") continue;
+    const val = style[key];
+    if (key in import_pseudoDescriptors.pseudoDescriptors)
+      val && out.push(...getStyleAtomic(val, import_pseudoDescriptors.pseudoDescriptors[key]));
+    else if ((0, import_useMedia.isMediaKey)(key))
+      for (const subKey in val) {
+        const so = getStyleObject(val, subKey);
+        so && (so[0] = key, out.push(so));
+      }
+    else {
+      const so = getStyleObject(style, key);
+      so && out.push(so);
+    }
+  }
+  return out;
+}
+const getStyleAtomic = (style, pseudo) => {
+  styleToCSS(style);
+  const out = [];
+  for (const key in style) {
+    const so = getStyleObject(style, key, pseudo);
+    so && out.push(so);
+  }
+  return out;
+};
+let conf = null;
+const getStyleObject = (style, key, pseudo) => {
+  let val = style[key];
+  if (val == null) return;
+  key === "transform" && Array.isArray(style.transform) && (val = (0, import_transformsToString.transformsToString)(val));
+  const value = (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(val, key), hash = (0, import_helpers.simpleHash)(typeof value == "string" ? value : `${value}`), pseudoPrefix = pseudo ? `0${pseudo.name}-` : "";
+  conf ||= (0, import_config.getConfigMaybe)();
+  const identifier = `_${conf?.inverseShorthands[key] || key}-${pseudoPrefix}${hash}`, rules = createAtomicRules(identifier, key, value, pseudo);
+  return [
+    // array for performance
+    key,
+    value,
+    identifier,
+    pseudo?.name,
+    rules
+  ];
+};
+function styleToCSS(style) {
+  const { shadowOffset, shadowRadius, shadowColor, shadowOpacity } = style;
+  if (shadowRadius || shadowColor) {
+    const offset = shadowOffset || import_defaultOffset.defaultOffset, width = (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(offset.width), height = (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(offset.height), radius = (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(shadowRadius), color = (0, import_normalizeColor.normalizeColor)(shadowColor, shadowOpacity), shadow = `${width} ${height} ${radius} ${color}`;
+    style.boxShadow = style.boxShadow ? `${style.boxShadow}, ${shadow}` : shadow, delete style.shadowOffset, delete style.shadowRadius, delete style.shadowColor, delete style.shadowOpacity;
+  }
+  const { textShadowColor, textShadowOffset, textShadowRadius } = style;
+  if (textShadowColor || textShadowOffset || textShadowRadius) {
+    const { height, width } = textShadowOffset || import_defaultOffset.defaultOffset, radius = textShadowRadius || 0, color = (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(textShadowColor, "textShadowColor");
+    if (color && (height !== 0 || width !== 0 || radius !== 0)) {
+      const blurRadius = (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(radius), offsetX = (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(width), offsetY = (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(height);
+      style.textShadow = `${offsetX} ${offsetY} ${blurRadius} ${color}`;
+    }
+    delete style.textShadowColor, delete style.textShadowOffset, delete style.textShadowRadius;
+  }
+}
+function createDeclarationBlock(style, important = !1) {
+  let next = "";
+  for (const [key, value] of style)
+    next += `${hyphenateStyleName(key)}:${value}${important ? " !important" : ""};`;
+  return `{${next}}`;
+}
+const hcache = {}, toHyphenLower = (match) => `-${match.toLowerCase()}`, hyphenateStyleName = (key) => {
+  if (key in hcache) return hcache[key];
+  const val = key.replace(/[A-Z]/g, toHyphenLower);
+  return hcache[key] = val, val;
+}, selectorPriority = (() => {
+  const res = {};
+  for (const key in import_pseudoDescriptors.pseudoDescriptors) {
+    const pseudo = import_pseudoDescriptors.pseudoDescriptors[key];
+    res[pseudo.name] = `${[...Array(pseudo.priority)].map(() => ":root").join("")} `;
+  }
+  return res;
+})();
+function createAtomicRules(identifier, property, value, pseudo) {
+  const pseudoIdPostfix = pseudo ? pseudo.name === "disabled" ? "[aria-disabled]" : `:${pseudo.name}` : "", pseudoSelector = pseudo?.selector;
+  let selector = pseudo ? pseudoSelector ? `${pseudoSelector} .${identifier}` : `${selectorPriority[pseudo.name]} .${identifier}${pseudoIdPostfix}` : `:root .${identifier}`;
+  pseudoSelector === import_pseudoDescriptors.pseudoDescriptors.enterStyle.selector && (selector = `${selector}, .${identifier}${pseudoSelector}`);
+  const important = !!pseudo;
+  let rules = [];
+  switch (property) {
+    // Equivalent to using '::placeholder'
+    case "placeholderTextColor": {
+      const block = createDeclarationBlock(
+        [
+          ["color", value],
+          ["opacity", 1]
+        ],
+        important
+      );
+      rules.push(`${selector}::placeholder${block}`);
+      break;
+    }
+    // all webkit prefixed rules
+    case "backgroundClip":
+    case "userSelect": {
+      const webkitProperty = `Webkit${`${property[0].toUpperCase()}${property.slice(1)}`}`, block = createDeclarationBlock(
+        [
+          [property, value],
+          [webkitProperty, value]
+        ],
+        important
+      );
+      rules.push(`${selector}${block}`);
+      break;
+    }
+    // Polyfill for additional 'pointer-events' values
+    case "pointerEvents": {
+      let finalValue = value;
+      value === "auto" || value === "box-only" ? (finalValue = "auto", value === "box-only" && rules.push(`${selector}>*${boxOnly}`)) : (value === "none" || value === "box-none") && (finalValue = "none", value === "box-none" && rules.push(`${selector}>*${boxNone}`));
+      const block = createDeclarationBlock([["pointerEvents", finalValue]], !0);
+      rules.push(`${selector}${block}`);
+      break;
+    }
+    default: {
+      const block = createDeclarationBlock([[property, value]], important);
+      rules.push(`${selector}${block}`);
+      break;
+    }
+  }
+  return pseudo?.name === "hover" && (rules = rules.map((r) => `@media (hover) {${r}}`)), rules;
+}
+const boxNone = createDeclarationBlock([["pointerEvents", "auto"]], !0), boxOnly = createDeclarationBlock([["pointerEvents", "none"]], !0);
+//# sourceMappingURL=getStylesAtomic.js.map

package/dist/cjs/helpers/getThemeCSSRules.js

@@ -0,0 +1,89 @@
+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 getThemeCSSRules_exports = {};
+__export(getThemeCSSRules_exports, {
+  getThemeCSSRules: () => getThemeCSSRules
+});
+module.exports = __toCommonJS(getThemeCSSRules_exports);
+var import_helpers = require("@tamagui/helpers"), import_constants = require("../constants/constants"), import_createVariable = require("../createVariable"), import_registerCSSVariable = require("./registerCSSVariable"), import_config = require("../config"), import_sortString = require("./sortString");
+const darkLight = ["dark", "light"], lightDark = ["light", "dark"];
+function getThemeCSSRules(props) {
+  const cssRuleSets = [];
+  if (!process.env.TAMAGUI_DOES_SSR_CSS || process.env.TAMAGUI_DOES_SSR_CSS === "mutates-themes" || process.env.TAMAGUI_DOES_SSR_CSS === "false") {
+    const { config, themeName, theme, names } = props, hasDarkLight = props.hasDarkLight ?? (config.themes && ("light" in config.themes || "dark" in config.themes)), CNP = `.${import_constants.THEME_CLASSNAME_PREFIX}`;
+    let vars = "";
+    for (const themeKey in theme) {
+      const variable = theme[themeKey];
+      let value = null;
+      import_registerCSSVariable.tokensValueToVariable.has(variable.val) ? value = import_registerCSSVariable.tokensValueToVariable.get(variable.val).variable : value = variable.val, vars += `--${process.env.TAMAGUI_CSS_VARIABLE_PREFIX || ""}${(0, import_helpers.simpleHash)(
+        themeKey,
+        40
+      )}:${value};`;
+    }
+    const isDarkBase = themeName === "dark", isLightBase = themeName === "light", baseSelectors = names.map((name) => `${CNP}${name}`), selectorsSet = new Set(isDarkBase || isLightBase ? baseSelectors : []);
+    if (hasDarkLight) {
+      const maxDepth = (0, import_config.getSetting)("maxDarkLightNesting") ?? 3;
+      for (const subName of names) {
+        const isDark = isDarkBase || subName.startsWith("dark_"), isLight = !isDark && (isLightBase || subName.startsWith("light_"));
+        if (!(isDark || isLight)) {
+          selectorsSet.add(`${CNP}${subName}`);
+          continue;
+        }
+        const childSelector = `${CNP}${subName.replace(/^(dark|light)_/, "")}`, order = isDark ? darkLight : lightDark, [stronger, weaker] = order, numSelectors = Math.round(maxDepth * 1.5);
+        for (let depth = 0; depth < numSelectors; depth++) {
+          const isOdd = depth % 2 === 1;
+          if (isOdd && depth < 3)
+            continue;
+          const parents = new Array(depth + 1).fill(0).map((_, idx) => `${CNP}${idx % 2 === 0 ? stronger : weaker}`);
+          let parentSelectors = parents.length > 1 ? parents.slice(1) : parents;
+          if (isOdd) {
+            const [_first, second, ...rest] = parentSelectors;
+            parentSelectors = [second, ...rest, second];
+          }
+          const lastParentSelector = parentSelectors[parentSelectors.length - 1], nextChildSelector = childSelector === lastParentSelector ? "" : childSelector, parentSelectorString = parentSelectors.join(" ");
+          selectorsSet.add(`${parentSelectorString} ${nextChildSelector}`);
+        }
+      }
+    }
+    const selectors = [...selectorsSet].sort(import_sortString.sortString), css = `${selectors.map((x) => `:root${isBaseTheme(x) && (0, import_config.getSetting)("themeClassNameOnRoot") ? "" : " "}${x}`).join(", ")} {${vars}}`;
+    if (cssRuleSets.push(css), (0, import_config.getSetting)("shouldAddPrefersColorThemes")) {
+      const bgString = theme.background ? `background:${(0, import_createVariable.variableToString)(theme.background)};` : "", fgString = theme.color ? `color:${(0, import_createVariable.variableToString)(theme.color)}` : "", bodyRules = `body{${bgString}${fgString}}`, isDark = themeName.startsWith("dark"), baseName = isDark ? "dark" : "light", themeRules = `${selectors.map((x) => {
+        if (x == darkSelector || x === lightSelector) return ":root";
+        if (!(isDark && x.startsWith(lightSelector) || !isDark && x.startsWith(darkSelector)))
+          return x.replace(/^\.t_(dark|light) /, "").trim();
+      }).filter(Boolean).join(", ")} {${vars}}`, prefersMediaSelectors = `@media(prefers-color-scheme:${baseName}){
+    ${bodyRules}
+    ${themeRules}
+  }`;
+      cssRuleSets.push(prefersMediaSelectors);
+    }
+    const selectionStyles = (0, import_config.getSetting)("selectionStyles");
+    if (selectionStyles) {
+      const rules = selectionStyles(theme);
+      if (rules) {
+        const selectionSelectors = baseSelectors.map((s) => `${s} ::selection`).join(", "), styles = Object.entries(rules).flatMap(
+          ([k, v]) => v ? `${k === "backgroundColor" ? "background" : k}:${(0, import_createVariable.variableToString)(v)}` : []
+        ).join(";");
+        if (styles) {
+          const css2 = `${selectionSelectors}{${styles}}`;
+          cssRuleSets.push(css2);
+        }
+      }
+    }
+  }
+  return cssRuleSets;
+}
+const darkSelector = ".t_dark", lightSelector = ".t_light", isBaseTheme = (x) => x === darkSelector || x === lightSelector || x.startsWith(".t_dark ") || x.startsWith(".t_light ");
+//# sourceMappingURL=getThemeCSSRules.js.map

package/dist/cjs/helpers/getVariantExtras.js

@@ -0,0 +1,58 @@
+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 getVariantExtras_exports = {};
+__export(getVariantExtras_exports, {
+  getFontsForLanguage: () => getFontsForLanguage,
+  getVariantExtras: () => getVariantExtras
+});
+module.exports = __toCommonJS(getVariantExtras_exports);
+var import_createVariable = require("../createVariable");
+const cache = /* @__PURE__ */ new WeakMap(), getVariantExtras = (styleState) => {
+  if (cache.has(styleState))
+    return cache.get(styleState);
+  const { props, conf, context, theme } = styleState;
+  let fonts = conf.fontsParsed;
+  context?.language && (fonts = getFontsForLanguage(conf.fontsParsed, context.language));
+  const next = {
+    fonts,
+    tokens: conf.tokensParsed,
+    theme,
+    get fontFamily() {
+      return (0, import_createVariable.getVariableValue)(styleState.fontFamily || styleState.props.fontFamily) || props.fontFamily || (0, import_createVariable.getVariableValue)(styleState.conf.defaultFont);
+    },
+    get font() {
+      return fonts[this.fontFamily] || (!props.fontFamily || props.fontFamily[0] === "$" ? fonts[styleState.conf.defaultFont] : void 0);
+    },
+    props
+  };
+  return cache.set(styleState, next), next;
+}, fontLanguageCache = /* @__PURE__ */ new WeakMap();
+function getFontsForLanguage(fonts, language) {
+  if (fontLanguageCache.has(language))
+    return fontLanguageCache.get(language);
+  const next = {
+    ...fonts,
+    ...Object.fromEntries(
+      Object.entries(language).map(([name, lang]) => {
+        if (lang === "default")
+          return [];
+        const langKey = `$${name}_${lang}`;
+        return [`$${name}`, fonts[langKey]];
+      })
+    )
+  };
+  return fontLanguageCache.set(language, next), next;
+}
+//# sourceMappingURL=getVariantExtras.js.map

package/dist/cjs/helpers/insertStyleRule.js

@@ -0,0 +1,231 @@
+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 insertStyleRule_exports = {};
+__export(insertStyleRule_exports, {
+  getAllRules: () => getAllRules,
+  getAllSelectors: () => getAllSelectors,
+  getAllTransforms: () => getAllTransforms,
+  insertStyleRules: () => insertStyleRules,
+  insertedTransforms: () => insertedTransforms,
+  listenForSheetChanges: () => listenForSheetChanges,
+  scanAllSheets: () => scanAllSheets,
+  setNonce: () => setNonce,
+  shouldInsertStyleRules: () => shouldInsertStyleRules,
+  updateRules: () => updateRules
+});
+module.exports = __toCommonJS(insertStyleRule_exports);
+var import_constants = require("@tamagui/constants"), import_helpers = require("@tamagui/helpers"), import_createVariable = require("../createVariable");
+const scannedCache = /* @__PURE__ */ new WeakMap(), totalSelectorsInserted = /* @__PURE__ */ new Map(), allSelectors = {}, allRules = {}, insertedTransforms = {}, getAllSelectors = () => allSelectors, getAllRules = () => Object.values(allRules), getAllTransforms = () => insertedTransforms;
+function addTransform(identifier, css, rule) {
+  const s = css.indexOf("transform:");
+  if (s === -1) {
+    process.env.NODE_ENV === "development" && console.error(`\u274C Invalid transform, likely used deg/% improperly ${identifier}`);
+    return;
+  }
+  const startI = s + 10, endI = css.indexOf(";"), value = css.slice(startI, endI);
+  if (!insertedTransforms[identifier])
+    return insertedTransforms[identifier] = value, !0;
+}
+function listenForSheetChanges() {
+  if (!import_constants.isClient) return;
+  new MutationObserver((entries) => {
+    for (const entry of entries)
+      if (entry instanceof HTMLStyleElement && entry.sheet || entry instanceof HTMLLinkElement && entry.href.endsWith(".css")) {
+        scanAllSheets();
+        break;
+      }
+  }).observe(document.head, {
+    childList: !0
+  });
+}
+let lastScannedSheets = null;
+function scanAllSheets(collectThemes = !1, tokens) {
+  if (process.env.NODE_ENV === "test" || !import_constants.isClient) return;
+  let themes;
+  const sheets = document.styleSheets || [], prev = lastScannedSheets, current = new Set(sheets);
+  for (const sheet2 of current)
+    if (sheet2) {
+      const out = updateSheetStyles(sheet2, !1, collectThemes, tokens);
+      out && (themes = out);
+    }
+  if (lastScannedSheets = current, prev)
+    for (const sheet2 of prev)
+      sheet2 && !current.has(sheet2) && updateSheetStyles(sheet2, !0);
+  return themes;
+}
+function track(id, remove = !1) {
+  const next = (totalSelectorsInserted.get(id) || 0) + (remove ? -1 : 1);
+  return totalSelectorsInserted.set(id, next), next;
+}
+const bailAfterEnv = process.env.TAMAGUI_BAIL_AFTER_SCANNING_X_CSS_RULES, bailAfter = bailAfterEnv ? +bailAfterEnv : 700;
+function updateSheetStyles(sheet2, remove = !1, collectThemes = !1, tokens) {
+  let rules;
+  try {
+    if (rules = sheet2.cssRules, !rules)
+      return;
+  } catch {
+    return;
+  }
+  const firstSelector = getTamaguiSelector(rules[0], collectThemes)?.[0], lastSelector = getTamaguiSelector(rules[rules.length - 1], collectThemes)?.[0], cacheKey = `${rules.length}${firstSelector}${lastSelector}`, lastScanned = scannedCache.get(sheet2);
+  if (!remove && lastScanned === cacheKey)
+    return;
+  const len = rules.length;
+  let fails = 0, dedupedThemes;
+  const nameToTheme = {};
+  for (let i = 0; i < len; i++) {
+    const rule = rules[i];
+    if (!(rule instanceof CSSStyleRule)) continue;
+    const response = getTamaguiSelector(rule, collectThemes);
+    if (response)
+      fails = 0;
+    else {
+      if (fails++, fails > bailAfter)
+        return;
+      continue;
+    }
+    const [identifier, cssRule, isTheme] = response;
+    if (isTheme) {
+      const deduped = addThemesFromCSS(cssRule, tokens);
+      if (deduped) {
+        for (const name of deduped.names)
+          nameToTheme[name] ? (Object.apply(nameToTheme[name], deduped.theme), deduped.names = deduped.names.filter((x) => x !== name)) : nameToTheme[name] = deduped.theme;
+        dedupedThemes ||= [], dedupedThemes.push(deduped);
+      }
+      continue;
+    }
+    if (!process.env.TAMAGUI_REACT_19) {
+      const total = track(identifier, remove);
+      remove ? total === 0 && delete allSelectors[identifier] : identifier in allSelectors || (!identifier.startsWith("_transform-") || addTransform(identifier, cssRule.cssText, cssRule)) && (allSelectors[identifier] = cssRule.cssText);
+    }
+  }
+  return scannedCache.set(sheet2, cacheKey), dedupedThemes;
+}
+let colorVarToVal, rootComputedStyle = null;
+function addThemesFromCSS(cssStyleRule, tokens) {
+  const selectors = cssStyleRule.selectorText.split(",");
+  if (!selectors.length) return;
+  if (tokens && !colorVarToVal) {
+    colorVarToVal = {};
+    for (const key in tokens.color) {
+      const token = tokens.color[key];
+      colorVarToVal[token.name] = token.val;
+    }
+  }
+  const rules = (cssStyleRule.cssText || "").slice(
+    cssStyleRule.selectorText.length + 2,
+    -1
+  ).split(";"), values = {};
+  for (const rule of rules) {
+    const sepI = rule.indexOf(":");
+    if (sepI === -1) continue;
+    const varIndex = rule.indexOf("--");
+    let key = rule.slice(varIndex === -1 ? 0 : varIndex + 2, sepI);
+    process.env.TAMAGUI_CSS_VARIABLE_PREFIX && (key = key.replace(process.env.TAMAGUI_CSS_VARIABLE_PREFIX, ""));
+    const val = rule.slice(sepI + 2);
+    let value;
+    if (val[0] === "v" && val.startsWith("var(")) {
+      const varName = val.slice(6, -1), tokenVal = colorVarToVal[varName];
+      tokenVal ? value = tokenVal : (rootComputedStyle ||= getComputedStyle(document.body), value = rootComputedStyle.getPropertyValue("--" + varName));
+    } else
+      value = val;
+    values[key] = (0, import_createVariable.createVariable)(
+      {
+        key,
+        name: key,
+        val: value
+      },
+      !0
+    );
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const selector of selectors) {
+    const lastThemeSelectorIndex = selector.lastIndexOf(".t_"), name = selector.slice(lastThemeSelectorIndex).slice(3), [schemeChar] = selector[lastThemeSelectorIndex - 5], scheme = schemeChar === "d" ? "dark" : schemeChar === "i" ? "light" : "", themeName = scheme && scheme !== name ? `${scheme}_${name}` : name;
+    !themeName || themeName === "light_dark" || themeName === "dark_light" || names.add(themeName);
+  }
+  return {
+    names: [...names],
+    theme: values
+  };
+}
+function getTamaguiSelector(rule, collectThemes = !1) {
+  if (rule instanceof CSSStyleRule) {
+    const text = rule.selectorText;
+    if (text[0] === ":" && text[1] === "r") {
+      if (text.startsWith(":root ._"))
+        return [getIdentifierFromTamaguiSelector(text), rule];
+      if (collectThemes && /^(:root\s?(\.t_[a-z0-9_]+\s*)+(,)?\s*)+$/i.test(text))
+        return [
+          text.slice(0, 20),
+          // just used as uid
+          rule,
+          !0
+        ];
+    }
+  } else if (rule instanceof CSSMediaRule)
+    return rule.cssRules.length > 1 ? void 0 : getTamaguiSelector(rule.cssRules[0]);
+}
+const getIdentifierFromTamaguiSelector = (selector) => {
+  const dotIndex = selector.indexOf(":");
+  return dotIndex > -1 ? selector.slice(7, dotIndex) : selector.slice(7);
+};
+let sheet = null;
+function updateRules(identifier, rules) {
+  if (!process.env.TAMAGUI_REACT_19)
+    return identifier in allRules ? !1 : (allRules[identifier] = rules.join(" "), identifier.startsWith("_transform-") ? addTransform(identifier, rules[0]) : !0);
+}
+let nonce = "";
+function setNonce(_) {
+  nonce = _;
+}
+function insertStyleRules(rulesToInsert) {
+  if (!process.env.TAMAGUI_REACT_19) {
+    if (!sheet && import_constants.isClient && document.head) {
+      const styleTag = document.createElement("style");
+      nonce && (styleTag.nonce = nonce), sheet = document.head.appendChild(styleTag).sheet;
+    }
+    if (!sheet) return;
+    for (const key in rulesToInsert) {
+      const styleObject = rulesToInsert[key], identifier = styleObject[import_helpers.StyleObjectIdentifier];
+      if (!shouldInsertStyleRules(identifier))
+        continue;
+      const rules = styleObject[import_helpers.StyleObjectRules];
+      allSelectors[identifier] = rules.join(`
+`), track(identifier), updateRules(identifier, rules);
+      for (const rule of rules)
+        if (process.env.NODE_ENV === "production")
+          try {
+            sheet.insertRule(rule, sheet.cssRules.length);
+          } catch (err) {
+            console.error("Error inserting CSS", err);
+          }
+        else
+          sheet.insertRule(rule, sheet.cssRules.length);
+    }
+  }
+}
+const minInsertAmt = process.env.TAMAGUI_INSERT_SELECTOR_TRIES ? +process.env.TAMAGUI_INSERT_SELECTOR_TRIES : 1;
+function shouldInsertStyleRules(identifier) {
+  if (process.env.TAMAGUI_REACT_19)
+    return !0;
+  {
+    if (process.env.IS_STATIC === "is_static")
+      return !0;
+    const total = totalSelectorsInserted.get(identifier);
+    return process.env.NODE_ENV === "development" && totalSelectorsInserted.size > +(process.env.TAMAGUI_STYLE_INSERTION_WARNING_LIMIT || 1e4) && console.warn(
+      'Warning: inserting many CSS rules, you may be animating something and generating many CSS insertions, which can degrade performance. Instead, try using the "disableClassName" property on elements that change styles often. To disable this warning set TAMAGUI_STYLE_INSERTION_WARNING_LIMIT from 50000 to something higher'
+    ), total === void 0 || total < minInsertAmt;
+  }
+}
+//# sourceMappingURL=insertStyleRule.js.map

package/dist/cjs/helpers/isActivePlatform.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 isActivePlatform_exports = {};
+__export(isActivePlatform_exports, {
+  isActivePlatform: () => isActivePlatform
+});
+module.exports = __toCommonJS(isActivePlatform_exports);
+var import_constants = require("@tamagui/constants");
+function isActivePlatform(key) {
+  if (!key.startsWith("$platform"))
+    return !0;
+  const platform = key.slice(10);
+  return (
+    // web, ios, android
+    platform === import_constants.currentPlatform || // web, native
+    platform === "web"
+  );
+}
+//# sourceMappingURL=isActivePlatform.js.map

package/dist/cjs/helpers/isActiveTheme.js

@@ -0,0 +1,24 @@
+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 isActiveTheme_exports = {};
+__export(isActiveTheme_exports, {
+  isActiveTheme: () => isActiveTheme
+});
+module.exports = __toCommonJS(isActiveTheme_exports);
+function isActiveTheme(key, activeThemeName) {
+  if (key.startsWith("$theme-"))
+    return key.slice(7).startsWith(activeThemeName);
+}
+//# sourceMappingURL=isActiveTheme.js.map

package/dist/cjs/helpers/isObj.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 isObj_exports = {};
+__export(isObj_exports, {
+  isObj: () => isObj
+});
+module.exports = __toCommonJS(isObj_exports);
+const isObj = (x) => x && !Array.isArray(x) && typeof x == "object";
+//# sourceMappingURL=isObj.js.map

package/dist/cjs/helpers/isTamaguiComponent.js

@@ -0,0 +1,24 @@
+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 isTamaguiComponent_exports = {};
+__export(isTamaguiComponent_exports, {
+  isTamaguiComponent: () => isTamaguiComponent
+});
+module.exports = __toCommonJS(isTamaguiComponent_exports);
+function isTamaguiComponent(comp, name) {
+  const config = comp?.staticConfig;
+  return !!(config && (!name || name === config.componentName));
+}
+//# sourceMappingURL=isTamaguiComponent.js.map

package/dist/cjs/helpers/isTamaguiElement.js

@@ -0,0 +1,30 @@
+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 isTamaguiElement_exports = {};
+__export(isTamaguiElement_exports, {
+  isTamaguiElement: () => isTamaguiElement
+});
+module.exports = __toCommonJS(isTamaguiElement_exports);
+var import_react = __toESM(require("react")), import_isTamaguiComponent = require("./isTamaguiComponent");
+const isTamaguiElement = (child, name) => import_react.default.isValidElement(child) && (0, import_isTamaguiComponent.isTamaguiComponent)(child.type, name);
+//# sourceMappingURL=isTamaguiElement.js.map