@tamagui/web 1.47.9 → 1.48.1

package/src/createTamagui.ts

@@ -10,16 +10,19 @@ import {
   scanAllSheets,
 } from './helpers/insertStyleRule'
 import { registerCSSVariable, variableToCSS } from './helpers/registerCSSVariable'
-import { ensureThemeVariable, proxyThemeToParents } from './helpers/themes'
+import { ensureThemeVariable, proxyThemesToParents } from './helpers/themes'
 import { configureMedia } from './hooks/useMedia'
 import { parseFont, registerFontVariables } from './insertFont'
 import { Tamagui } from './Tamagui'
 import {
   CreateTamaguiProps,
+  DedupedTheme,
+  DedupedThemes,
   GetCSS,
   InferTamaguiConfig,
   TamaguiInternalConfig,
   ThemeParsed,
+  ThemesLikeObject,
 } from './types'
 
 // config is re-run by the @tamagui/static, dont double validate
@@ -44,7 +47,16 @@ export function createTamagui<Conf extends CreateTamaguiProps>(
     }
   }
 
-  scanAllSheets()
+  // faster $lookups
+  const tokensParsed: any = Object.fromEntries(
+    Object.entries(configIn.tokens).map(([k, v]) => {
+      const val = Object.fromEntries(Object.entries(v).map(([k, v]) => [`$${k}`, v]))
+      return [k, val]
+    })
+  )
+
+  const noThemes = Object.keys(configIn.themes).length === 0
+  const foundThemes = scanAllSheets(noThemes, tokensParsed)
   listenForSheetChanges()
 
   const fontTokens = Object.fromEntries(
@@ -71,7 +83,6 @@ export function createTamagui<Conf extends CreateTamaguiProps>(
   const specificTokens = {}
 
   const themeConfig = (() => {
-    const themes = { ...configIn.themes }
     const cssRuleSets: string[] = []
 
     if (process.env.TAMAGUI_DOES_SSR_CSS !== 'true') {
@@ -142,61 +153,9 @@ export function createTamagui<Conf extends CreateTamaguiProps>(
       }
     }
 
-    // dedupe themes to avoid duplicate CSS generation
-    type DedupedTheme = {
-      names: string[]
-      theme: ThemeParsed
-    }
-    const dedupedThemes: {
-      [key: string]: DedupedTheme
-    } = {}
-    const existing = new Map<string, DedupedTheme>()
-
-    // first, de-dupe and parse them
-    for (const themeName in themes) {
-      // forces us to separate the dark/light themes (otherwise we generate bad t_light prefix selectors)
-      const darkOrLightSpecificPrefix = themeName.startsWith('dark')
-        ? 'dark'
-        : themeName.startsWith('light')
-        ? 'light'
-        : ''
-
-      const rawTheme = themes[themeName] as ThemeParsed
-
-      // dont force referential equality but may need something more consistent than JSON.stringify
-      // separate between dark/light
-      const key = darkOrLightSpecificPrefix + JSON.stringify(rawTheme)
-
-      // if existing, avoid
-      if (existing.has(key)) {
-        const e = existing.get(key)!
-        themes[themeName] = e.theme
-        e.names.push(themeName)
-        continue
-      }
-
-      // ensure each theme object unique for dedupe
-      const theme = { ...rawTheme }
-      // parse into variables
-      for (const key in theme) {
-        // make sure properly names theme variables
-        ensureThemeVariable(theme, key)
-      }
-      themes[themeName] = theme
-
-      // set deduped
-      dedupedThemes[themeName] = {
-        names: [themeName],
-        theme,
-      }
-
-      existing.set(key, dedupedThemes[themeName])
-    }
-
-    // proxy upwards to get parent variables (themes are subset going down)
-    for (const themeName in themes) {
-      themes[themeName] = proxyThemeToParents(themeName, themes[themeName], themes)
-    }
+    const themesIn = { ...configIn.themes } as ThemesLikeObject
+    const dedupedThemes = foundThemes ?? getThemesDeduped(themesIn)
+    const themes = proxyThemesToParents(dedupedThemes, tokensParsed)
 
     return {
       themes,
@@ -206,11 +165,12 @@ export function createTamagui<Conf extends CreateTamaguiProps>(
         let themeRuleSets: string[] = []
 
         if (isWeb) {
-          for (const themeName in dedupedThemes) {
+          for (const { names, theme } of dedupedThemes) {
             const nextRules = getThemeCSSRules({
               config: configIn,
-              themeName,
-              ...dedupedThemes[themeName],
+              themeName: names[0],
+              names,
+              theme,
             })
             themeRuleSets = [...themeRuleSets, ...nextRules]
           }
@@ -221,14 +181,6 @@ export function createTamagui<Conf extends CreateTamaguiProps>(
     }
   })()
 
-  // faster $lookups
-  const tokensParsed: any = Object.fromEntries(
-    Object.entries(configIn.tokens).map(([k, v]) => {
-      const val = Object.fromEntries(Object.entries(v).map(([k, v]) => [`$${k}`, v]))
-      return [k, val]
-    })
-  )
-
   const shorthands = configIn.shorthands || {}
 
   let lastCSSInsertedRulesIndex = -1
@@ -328,3 +280,51 @@ ${runtimeStyles}`
 
   return config as any
 }
+
+// dedupes the themes if given them via JS config
+function getThemesDeduped(themes: ThemesLikeObject): DedupedThemes {
+  const dedupedThemes: DedupedThemes = []
+  const existing = new Map<string, DedupedTheme>()
+
+  // first, de-dupe and parse them
+  for (const themeName in themes) {
+    // forces us to separate the dark/light themes (otherwise we generate bad t_light prefix selectors)
+    const darkOrLightSpecificPrefix = themeName.startsWith('dark')
+      ? 'dark'
+      : themeName.startsWith('light')
+      ? 'light'
+      : ''
+
+    const rawTheme = themes[themeName]
+
+    // dont force referential equality but may need something more consistent than JSON.stringify
+    // separate between dark/light
+    const key = darkOrLightSpecificPrefix + JSON.stringify(rawTheme)
+
+    // if existing, avoid
+    if (existing.has(key)) {
+      const e = existing.get(key)!
+      e.names.push(themeName)
+      continue
+    }
+
+    // ensure each theme object unique for dedupe
+    // is ThemeParsed because we call ensureThemeVariable
+    const theme = { ...rawTheme } as any as ThemeParsed
+    // parse into variables
+    for (const key in theme) {
+      // make sure properly names theme variables
+      ensureThemeVariable(theme, key)
+    }
+
+    // set deduped
+    const deduped: DedupedTheme = {
+      names: [themeName],
+      theme,
+    }
+    dedupedThemes.push(deduped)
+    existing.set(key, deduped)
+  }
+
+  return dedupedThemes
+}

package/src/createVariable.ts

@@ -22,16 +22,17 @@ export type MakeVariable<A = any> = A extends string | number ? Variable<A> : A
 
 type VariableIn<A = any> = Pick<Variable<A>, 'key' | 'name' | 'val'>
 export const createVariable = <A extends string | number | Variable = any>(
-  props: VariableIn<A>
+  props: VariableIn<A>,
+  skipHash = false
 ): Variable<A> => {
-  if (isVariable(props)) return props
+  if (!skipHash && isVariable(props)) return props
   const { key, name, val } = props
   return {
     [IS_VAR]: true,
     key: key!,
-    name: simpleHash(name, 40),
+    name: skipHash ? '' : simpleHash(name, 40),
     val: val as any,
-    variable: isWeb ? createCSSVariable(name) : '',
+    variable: isWeb ? (skipHash ? `var(--${name})` : createCSSVariable(name)) : '',
   }
 }
 

package/src/helpers/ThemeManager.tsx

@@ -154,24 +154,6 @@ export class ThemeManager {
     return this._allKeys
   }
 
-  // gets value going up to parents
-  getValue(key: string, state: ThemeManagerState = this.state) {
-    if (!key) return
-    let theme = state.theme
-    let manager = this as ThemeManager | null
-    while (theme && manager) {
-      if (key in theme) {
-        return theme[key]
-      }
-      manager = manager.parentManager
-      theme = manager?.state.theme
-    }
-    const tokens = getTokens()
-    if (key in tokens.color) {
-      return tokens.color[key]
-    }
-  }
-
   notify(forced = false) {
     this.themeListeners.forEach((cb) => cb(this.state.name, this, forced))
   }
@@ -325,7 +307,7 @@ function getState(
     if (found) {
       result = {
         name: found,
-        theme: getThemeUnwrapped(themes[found]),
+        theme: themes[found],
         className: getNextThemeClassName(found),
         parentName,
         componentName,

package/src/helpers/insertStyleRule.tsx

@@ -1,6 +1,16 @@
 import { isClient } from '@tamagui/constants'
 
-import type { RulesToInsert, StyleObject } from '../types'
+import { getConfig } from '../config'
+import { Variable, createVariable } from '../createVariable'
+import type {
+  DedupedTheme,
+  DedupedThemes,
+  RulesToInsert,
+  ThemeParsed,
+  Tokens,
+  TokensParsed,
+} from '../types'
+import { ensureThemeVariable } from './themes'
 
 const allSelectors: Record<string, string> = {}
 const allRules: Record<string, string> = {}
@@ -63,16 +73,26 @@ export function listenForSheetChanges() {
 
 let lastScannedSheets: Set<CSSStyleSheet> | null = null
 
-export function scanAllSheets() {
+export function scanAllSheets(
+  collectThemes = false,
+  tokens?: TokensParsed
+): DedupedThemes | undefined {
   if (process.env.NODE_ENV === 'test') return
   if (!isClient) return
 
+  let themes: DedupedThemes | undefined
+
   const sheets = document.styleSheets || []
   const prev = lastScannedSheets
   const current = new Set(sheets as any as CSSStyleSheet[])
   if (document.styleSheets) {
     for (const sheet of current) {
-      sheet && updateSheetStyles(sheet)
+      if (sheet) {
+        const out = updateSheetStyles(sheet, false, collectThemes, tokens)
+        if (out) {
+          themes = out
+        }
+      }
     }
     lastScannedSheets = current
   }
@@ -84,6 +104,8 @@ export function scanAllSheets() {
       }
     }
   }
+
+  return themes
 }
 
 function track(id: string, remove = false) {
@@ -92,7 +114,15 @@ function track(id: string, remove = false) {
   return next
 }
 
-function updateSheetStyles(sheet: CSSStyleSheet, remove = false) {
+const bailAfterEnv = process.env.TAMAGUI_BAIL_AFTER_SCANNING_X_CSS_RULES
+const bailAfter = bailAfterEnv ? +bailAfterEnv : 250
+
+function updateSheetStyles(
+  sheet: CSSStyleSheet,
+  remove = false,
+  collectThemes = false,
+  tokens?: TokensParsed
+): DedupedThemes | undefined {
   // avoid errors on cross origin sheets
   // https://stackoverflow.com/questions/49993633/uncaught-domexception-failed-to-read-the-cssrules-property
   let rules: CSSRuleList
@@ -105,8 +135,8 @@ function updateSheetStyles(sheet: CSSStyleSheet, remove = false) {
     return
   }
 
-  const firstSelector = getTamaguiSelector(rules[0])?.[0]
-  const lastSelector = getTamaguiSelector(rules[rules.length - 1])?.[0]
+  const firstSelector = getTamaguiSelector(rules[0], collectThemes)?.[0]
+  const lastSelector = getTamaguiSelector(rules[rules.length - 1], collectThemes)?.[0]
   const cacheKey = `${rules.length}${firstSelector}${lastSelector}`
   const lastScanned = scannedCache.get(sheet)
 
@@ -120,22 +150,36 @@ function updateSheetStyles(sheet: CSSStyleSheet, remove = false) {
   const len = rules.length
   let fails = 0
 
+  let dedupedThemes: DedupedThemes | undefined
+
   for (let i = 0; i < len; i++) {
     const rule = rules[i]
     if (!(rule instanceof CSSStyleRule)) continue
 
-    const response = getTamaguiSelector(rule)
+    const response = getTamaguiSelector(rule, collectThemes)
 
-    if (!response) {
+    if (response) {
+      // reset to 0 on any success as eg every other theme scan we get empty
+      fails = 0
+    } else {
       fails++
-      if (fails > 20) {
+      if (fails > bailAfter) {
         // conservatively bail out of non-tamagui sheets
         return
       }
       continue
     }
 
-    const [identifier, cssRule] = response
+    const [identifier, cssRule, isTheme] = response
+
+    if (isTheme) {
+      const deduped = addThemesFromCSS(cssRule, tokens)
+      if (deduped) {
+        dedupedThemes ||= []
+        dedupedThemes.push(deduped)
+      }
+      continue
+    }
 
     // track references
     const total = track(identifier, remove)
@@ -156,32 +200,132 @@ function updateSheetStyles(sheet: CSSStyleSheet, remove = false) {
   }
 
   scannedCache.set(sheet, cacheKey)
+
+  return dedupedThemes
+}
+
+let colorVarToVal: Record<string, string>
+let rootComputedStyle: CSSStyleDeclaration | null = null
+
+function addThemesFromCSS(cssStyleRule: CSSStyleRule, tokens?: TokensParsed) {
+  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 rulesWithBraces = (cssStyleRule.cssText || '')
+    .slice(cssStyleRule.selectorText.length + 2, -1)
+    .trim()
+  const rules = rulesWithBraces.split(';')
+
+  // get theme object parsed
+  const values: ThemeParsed = {}
+  // build values first
+  for (const rule of rules) {
+    const sepI = rule.indexOf(':')
+    if (sepI === -1) continue
+    const key = rule.slice(rule.indexOf('--') + 2, sepI)
+    const val = rule.slice(sepI + 2)
+    let value: string
+    if (val[3] === '(') {
+      // var()
+      const varName = val.slice(6, -1)
+      const tokenVal = colorVarToVal[varName]
+      // either hydrate it from tokens directly or from computed style on body if no token
+      if (tokenVal) {
+        value = tokenVal
+      } else {
+        rootComputedStyle ||= getComputedStyle(document.body)
+        value = rootComputedStyle.getPropertyValue('--' + varName)
+      }
+    } else {
+      value = val
+    }
+    values[key] = createVariable(
+      {
+        key,
+        name: key,
+        val: value,
+      },
+      true
+    )
+  }
+
+  const dedupedEntry: DedupedTheme = {
+    names: [],
+    theme: values,
+  }
+
+  // loop selectors and build deduped
+  for (const selector of selectors) {
+    let scheme = selector.includes('t_dark')
+      ? 'dark'
+      : selector.includes('t_light')
+      ? 'light'
+      : ''
+    let name = selector.slice(selector.lastIndexOf('.t_') + 3)
+
+    if (name.startsWith(scheme)) {
+      // we have some hardcoded for component themes t_light_name
+      name = name.slice(scheme.length + 1)
+    }
+    // for base dark and light
+    if (scheme === name) {
+      scheme = ''
+    }
+    const themeName = `${scheme}${scheme && name ? '_' : ''}${name}`
+
+    if (dedupedEntry.names.includes(themeName)) {
+      continue
+    }
+
+    dedupedEntry.names.push(themeName)
+  }
+
+  return dedupedEntry
 }
 
 function getTamaguiSelector(
-  rule: CSSRule | null
-): readonly [string, CSSStyleRule] | null {
+  rule: CSSRule | null,
+  collectThemes = false
+): readonly [string, CSSStyleRule] | [string, CSSStyleRule, true] | undefined {
   if (rule instanceof CSSStyleRule) {
     const text = rule.selectorText
-    if (text[0] === '.' && text[1] === '_') {
-      return [text.slice(1), rule]
-    }
-    if (text.startsWith(':root') && text.includes('._')) {
-      return [getIdentifierFromTamaguiSelector(text), rule]
+    if (text[0] === ':' && text[1] === 'r') {
+      if (text.startsWith(':root ._')) {
+        return [getIdentifierFromTamaguiSelector(text), rule]
+      }
+      if (collectThemes) {
+        if (text.startsWith(':root.t_') || text.startsWith(':root .t_')) {
+          return [
+            text.slice(0, 20), // just used as uid
+            rule,
+            true,
+          ]
+        }
+      }
     }
   } else if (rule instanceof CSSMediaRule) {
     // tamagui only ever inserts 1 rule per media
-    if (rule.cssRules.length > 1) return null
+    if (rule.cssRules.length > 1) return
     return getTamaguiSelector(rule.cssRules[0])
   }
-  return null
 }
 
-const getIdentifierFromTamaguiSelector = (selector: string) =>
-  selector
-    .replace(/(:root)+\s+/, '')
-    .replace(/:[a-z]+$/, '')
-    .slice(1)
+const getIdentifierFromTamaguiSelector = (selector: string) => {
+  let res = selector.slice(8)
+  if (selector.includes(':')) {
+    return res.replace(/:[a-z]+$/, '')
+  }
+  return res
+}
 
 const sheet = isClient
   ? document.head.appendChild(document.createElement('style')).sheet

package/src/helpers/propMapper.ts

@@ -120,13 +120,13 @@ const resolveVariants: StyleResolver = (
 
   if (typeof variantValue === 'function') {
     const fn = variantValue as VariantSpreadFunction<any>
-
-    variantValue = fn(value, getVariantExtras(styleState))
+    const extras = getVariantExtras(styleState)
+    variantValue = fn(value, extras)
 
     if (process.env.NODE_ENV === 'development' && debug === 'verbose') {
       console.groupCollapsed('   expanded functional variant', key)
       // rome-ignore lint/nursery/noConsoleLog: <explanation>
-      console.log({ fn, variantValue })
+      console.log({ fn, variantValue, extras })
       console.groupEnd()
     }
   }

package/src/helpers/themes.ts

@@ -1,6 +1,13 @@
+import { getConfig } from '../config'
 import { createVariable, isVariable } from '../createVariable'
 import { GetThemeUnwrapped } from '../hooks/getThemeUnwrapped'
-import { CreateTamaguiProps } from '../types'
+import {
+  CreateTamaguiProps,
+  DedupedThemes,
+  ThemeParsed,
+  Tokens,
+  TokensParsed,
+} from '../types'
 
 // mutates, freeze after
 // shared by createTamagui so extracted here
@@ -25,13 +32,44 @@ export function ensureThemeVariable(theme: any, key: string) {
   }
 }
 
+const themesRaw: Record<string, ThemeParsed> = {}
+
+// this seems expensive but its necessary to do two loops unless we want to refactor a variety of things again
+// not *too* much work but not a big cost doing the two loops
+export function proxyThemesToParents(
+  dedupedThemes: DedupedThemes,
+  tokens: Tokens
+): Record<string, ThemeParsed> {
+  // fill it in so we can look it up next
+  for (const { names, theme } of dedupedThemes) {
+    for (const name of names) {
+      themesRaw[name] = theme
+    }
+  }
+
+  const themes: Record<string, ThemeParsed> = {}
+  // now go back and re-fill it in
+  // we do have to call this once per non-duplicated theme!
+  // because they could have different parent chains
+  // despite being the same theme
+
+  for (const { names, theme } of dedupedThemes) {
+    for (const themeName of names) {
+      const proxiedTheme = proxyThemeToParents(themeName, theme, tokens)
+      themes[themeName] = proxiedTheme
+    }
+  }
+
+  return themes
+}
+
 export function proxyThemeToParents(
   themeName: string,
-  theme: any,
-  themes: CreateTamaguiProps['themes']
+  theme: ThemeParsed,
+  tokens: TokensParsed = getConfig().tokensParsed
 ) {
-  // we could test if this is better as just a straight object spread or fancier proxy
   const cur: string[] = []
+
   // if theme is dark_blue_alt1_Button
   // this will be the parent names in order: ['dark', 'dark_blue', 'dark_blue_alt1"]
   const parents = themeName
@@ -44,21 +82,21 @@ export function proxyThemeToParents(
 
   const numParents = parents.length
 
+  // TODO maybe faster to just object spread? needs profiling on native + web
   // proxy fallback values to parent theme values
   return new Proxy(theme, {
     get(target, key) {
       if (key === GetThemeUnwrapped) return theme
-      if (numParents && !Reflect.has(target, key)) {
-        // check parents
-        for (let i = numParents - 1; i >= 0; i--) {
-          const parent = themes[parents[i]]
-          if (!parent) continue
-          if (Reflect.has(parent, key)) {
-            return Reflect.get(parent, key)
-          }
+      if (Reflect.has(target, key)) return Reflect.get(target, key)
+      // check parents
+      for (let i = numParents - 1; i >= 0; i--) {
+        const parent = themesRaw[parents[i]]
+        if (!parent) continue
+        if (Reflect.has(parent, key)) {
+          return Reflect.get(parent, key)
         }
       }
-      return Reflect.get(target, key)
+      return Reflect.get(tokens, key)
     },
   })
 }

package/src/hooks/useTheme.tsx

@@ -61,6 +61,13 @@ export const useThemeWithState = (
   const { themeManager, state } = changedThemeState
   const { theme, name, className } = state
   if (!theme) {
+    if (process.env.NODE_ENV === 'develpoment') {
+      throw new Error(
+        `No theme given props ${JSON.stringify(props)} in themes: ${Object.keys(
+          getConfig().themes
+        )}`
+      )
+    }
     throw `❌`
   }
 
@@ -109,8 +116,10 @@ export function getThemeProxied(
       if (typeof key === 'string' && keys) {
         // auto convert variables to plain
         const keyString = key[0] === '$' ? key.slice(1) : key
-        const val = themeManager?.getValue(keyString)
+        const val = theme[keyString]
         if (val && typeof val === 'object') {
+          // TODO this could definitely be done better by at the very minimum
+          // proxying it up front and just having a listener here
           return new Proxy(val as any, {
             // when they touch the actual value we only track it
             // if its a variable (web), its ignored!

package/src/types.tsx

@@ -2112,3 +2112,13 @@ export type GetRef<C> = C extends TamaguiComponent<any, infer Ref>
     ) extends Ref<infer T> | string | undefined
   ? T
   : unknown
+
+export type ThemesLikeObject = Record<string, Record<string, string>>
+
+// dedupe themes to avoid duplicate CSS generation
+export type DedupedTheme = {
+  names: string[]
+  theme: ThemeParsed
+}
+
+export type DedupedThemes = DedupedTheme[]

package/types/createComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createComponent.d.ts","sourceRoot":"","sources":["../src/createComponent.tsx"],"names":[],"mappings":"AAIA,OAAO,KAWN,MAAM,OAAO,CAAA;AAgBd,OAAO,EACL,SAAS,EACT,cAAc,EACd,UAAU,EACV,WAAW,EACX,YAAY,EACZ,gBAAgB,EAEhB,qBAAqB,EACrB,cAAc,EAIf,MAAM,SAAS,CAAA;AAUhB,eAAO,MAAM,qBAAqB,EAAE,qBAMnC,CAAA;AAwBD,eAAO,MAAM,QAAQ,eAAsB,CAAA;AAqB3C,wBAAgB,eAAe,CAC7B,kBAAkB,SAAS,MAAM,GAAG,EAAE,EACtC,GAAG,GAAG,cAAc,EACpB,SAAS,GAAG,KAAK,EACjB,YAAY,EAAE,YAAY,4DA+1B3B;AAGD,wBAAgB,QAAQ,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,EAAE,GAAG,CAAA;CAAE,OAEjD;AAMD,eAAO,MAAM,MAAM,0DA8CjB,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IAC5B,SAAS,CAAC,EAAE,cAAc,CAAA;IAC1B,SAAS,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB,CAAA;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,mBAkGxD"}
+{"version":3,"file":"createComponent.d.ts","sourceRoot":"","sources":["../src/createComponent.tsx"],"names":[],"mappings":"AAIA,OAAO,KAWN,MAAM,OAAO,CAAA;AAgBd,OAAO,EACL,SAAS,EACT,cAAc,EACd,UAAU,EACV,WAAW,EACX,YAAY,EACZ,gBAAgB,EAEhB,qBAAqB,EACrB,cAAc,EAIf,MAAM,SAAS,CAAA;AAUhB,eAAO,MAAM,qBAAqB,EAAE,qBAMnC,CAAA;AAwBD,eAAO,MAAM,QAAQ,eAAsB,CAAA;AAqB3C,wBAAgB,eAAe,CAC7B,kBAAkB,SAAS,MAAM,GAAG,EAAE,EACtC,GAAG,GAAG,cAAc,EACpB,SAAS,GAAG,KAAK,EACjB,YAAY,EAAE,YAAY,4DAg2B3B;AAGD,wBAAgB,QAAQ,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,EAAE,GAAG,CAAA;CAAE,OAEjD;AAMD,eAAO,MAAM,MAAM,0DA8CjB,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IAC5B,SAAS,CAAC,EAAE,cAAc,CAAA;IAC1B,SAAS,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB,CAAA;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,mBAkGxD"}

package/types/createTamagui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createTamagui.d.ts","sourceRoot":"","sources":["../src/createTamagui.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,kBAAkB,EAElB,kBAAkB,EAGnB,MAAM,SAAS,CAAA;AAKhB,wBAAgB,aAAa,CAAC,IAAI,SAAS,kBAAkB,EAC3D,QAAQ,EAAE,IAAI,GACb,kBAAkB,CAAC,IAAI,CAAC,CA4S1B"}
+{"version":3,"file":"createTamagui.d.ts","sourceRoot":"","sources":["../src/createTamagui.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,kBAAkB,EAIlB,kBAAkB,EAInB,MAAM,SAAS,CAAA;AAKhB,wBAAgB,aAAa,CAAC,IAAI,SAAS,kBAAkB,EAC3D,QAAQ,EAAE,IAAI,GACb,kBAAkB,CAAC,IAAI,CAAC,CAyP1B"}