@tamagui/web 1.2.5

package/src/updateTheme.ts

@@ -0,0 +1,26 @@
+import { addTheme } from './addTheme'
+import { activeThemeManagers } from './hooks/useTheme'
+import { ThemeDefinition } from './types'
+
+export function updateTheme({
+  name,
+  theme,
+}: {
+  name: string
+  theme: Partial<Record<keyof ThemeDefinition, any>>
+}) {
+  const next = addTheme({ name, theme, insertCSS: true, update: true })
+
+  if (process.env.TAMAGUI_TARGET === 'native') {
+    activeThemeManagers.forEach((manager) => {
+      if (manager.state.name === name) {
+        manager.updateState({
+          name,
+          forceTheme: next.theme,
+        })
+      }
+    })
+  }
+
+  return next
+}

package/src/views/FontLanguage.native.tsx

@@ -0,0 +1,12 @@
+import React, { useMemo } from 'react'
+
+import { FontLanguageContext } from '../contexts/FontLanguageContext'
+import { FontLanguageProps } from './FontLanguage.types'
+
+export const FontLanguage = ({ children, ...props }: FontLanguageProps) => {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const value = useMemo(() => props, [JSON.stringify(props)])
+  return (
+    <FontLanguageContext.Provider value={value}>{children}</FontLanguageContext.Provider>
+  )
+}

package/src/views/FontLanguage.tsx

@@ -0,0 +1,16 @@
+import { FontLanguageProps } from './FontLanguage.types'
+
+export const FontLanguage = ({ children, ...props }: FontLanguageProps) => {
+  return (
+    <div
+      style={{
+        display: 'contents',
+      }}
+      className={Object.entries(props)
+        .map(([name, language]) => `t_lang-${name}-${language}`)
+        .join(' ')}
+    >
+      {children}
+    </div>
+  )
+}

package/src/views/FontLanguage.types.ts

@@ -0,0 +1,13 @@
+import React from 'react'
+
+import { FontLanguages, FontTokens } from '../types'
+
+type FontFamilies = FontTokens extends `$${infer Token}` ? Token : never
+
+export type LanguageContextType = Partial<{
+  [key in FontFamilies]: FontLanguages | 'default'
+}>
+
+export type FontLanguageProps = LanguageContextType & {
+  children?: React.ReactNode
+}

package/src/views/Slot.tsx

@@ -0,0 +1,95 @@
+// via radix
+
+import { composeRefs } from '@tamagui/compose-refs'
+import { isWeb } from '@tamagui/constants'
+import { Children, ReactNode, cloneElement, forwardRef, isValidElement } from 'react'
+
+/* -------------------------------------------------------------------------------------------------
+ * Slot
+ * -----------------------------------------------------------------------------------------------*/
+
+interface SlotProps {
+  children: ReactNode
+}
+
+export const Slot = forwardRef<any, SlotProps>(function Slot(props, forwardedRef) {
+  const { children, ...slotProps } = props
+
+  if (isValidElement(children)) {
+    const childProps = {
+      ...mergeSlotProps(children, slotProps),
+      ref: composeRefs(forwardedRef, (children as any).ref),
+    }
+    return cloneElement(children, childProps)
+  }
+
+  return Children.count(children) > 1 ? Children.only(null) : null
+})
+
+/* -------------------------------------------------------------------------------------------------
+ * Slottable
+ * -----------------------------------------------------------------------------------------------*/
+
+export const Slottable = ({ children }: { children: ReactNode }) => {
+  return <>{children}</>
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+
+const pressMap = isWeb
+  ? {
+      onPress: 'onClick',
+      onPressOut: 'onMouseUp',
+      onPressIn: 'onMouseDown',
+    }
+  : {}
+
+function mergeSlotProps(child: any, slotProps: Record<string, any>) {
+  const childProps = child.props
+
+  // all child props should override
+  const overrideProps = { ...childProps }
+  const isHTMLChild = typeof child.type === 'string'
+
+  if (isHTMLChild) {
+    for (const key in pressMap) {
+      if (key in slotProps) {
+        slotProps[pressMap[key]] = slotProps[key]
+        delete slotProps[key]
+      }
+    }
+  }
+
+  for (let propName in childProps) {
+    const slotPropValue = slotProps[propName]
+    const childPropValue = childProps[propName]
+
+    if (isHTMLChild && pressMap[propName]) {
+      propName = pressMap[propName]
+      delete overrideProps[propName]
+    }
+
+    const isHandler = handleRegex.test(propName)
+    // if it's a handler, modify the override by composing the base handler
+    if (isHandler) {
+      overrideProps[propName] = mergeEvent(childPropValue, slotPropValue)
+    }
+    // if it's `style`, we merge them
+    else if (propName === 'style') {
+      overrideProps[propName] = { ...slotPropValue, ...childPropValue }
+    } else if (propName === 'className') {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(' ')
+    }
+  }
+
+  return { ...slotProps, ...overrideProps }
+}
+
+const handleRegex = /^on[A-Z]/
+
+export function mergeEvent(a?: Function, b?: Function) {
+  return (...args: unknown[]) => {
+    a?.(...args)
+    b?.(...args)
+  }
+}

package/src/views/Stack.tsx

@@ -0,0 +1,25 @@
+import type { View } from 'react-native'
+
+import { stackDefaultStyles } from '../constants/constants'
+import { createComponent } from '../createComponent'
+import { StackProps, StackPropsBase } from '../types'
+
+export const Stack = createComponent<StackProps, View, StackPropsBase>({
+  componentName: 'Stack',
+  acceptsClassName: true,
+  defaultProps: {
+    ...stackDefaultStyles,
+    flexDirection: 'column',
+  },
+})
+
+// test types
+// export const YStack = styled(Stack, {
+//   flexDirection: 'column',
+// })
+// // test types
+// const x00 = <Stack missing={0} /> // should err
+// const x0 = <YStack missing={0} /> // should err
+// const x1 = (props: StackProps) => <YStack {...props} />
+// type ys = typeof YStack
+// type ysv = ys extends StaticComponent<any, infer V> ? V : unknown

package/src/views/TamaguiProvider.tsx

@@ -0,0 +1,65 @@
+import { isClient, isRSC, isServer, isWeb } from '@tamagui/constants'
+import * as React from 'react'
+
+import { ButtonNestingContext } from '../contexts/ButtonNestingContext'
+import { TextAncestorContext } from '../contexts/TextAncestorContext'
+import { useMediaListeners } from '../hooks/useMedia'
+import type { TamaguiProviderProps } from '../types'
+import { ThemeProvider } from './ThemeProvider'
+
+export function TamaguiProvider({
+  children,
+  disableInjectCSS,
+  config,
+  ...themePropsProvider
+}: TamaguiProviderProps) {
+  if (isRSC) {
+    return (
+      <span
+        style={{ display: 'contents' }}
+        className={`t_${Object.keys(config.themes)[0] || 'light'}`}
+      >
+        {children}
+      </span>
+    )
+  }
+
+  if (!(isWeb && isServer)) {
+    useMediaListeners(config)
+  }
+
+  if (isClient) {
+    // inject CSS if asked to (not SSR compliant)
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    React.useLayoutEffect(() => {
+      // for easier support of hidden-until-js mount animations
+      // user must set t_unmounted on documentElement from SSR
+      if (document.documentElement.classList.contains('t_unmounted')) {
+        document.documentElement.classList.remove('t_unmounted')
+      }
+
+      if (disableInjectCSS) return
+      const style = document.createElement('style')
+      style.appendChild(document.createTextNode(config.getCSS()))
+      document.head.appendChild(style)
+      return () => {
+        document.head.removeChild(style)
+      }
+    }, [config, disableInjectCSS])
+  }
+
+  return (
+    <ButtonNestingContext.Provider value={false}>
+      <TextAncestorContext.Provider value={false}>
+        <ThemeProvider
+          themeClassNameOnRoot={config.themeClassNameOnRoot}
+          disableRootThemeClass={config.disableRootThemeClass}
+          {...themePropsProvider}
+          defaultTheme={themePropsProvider.defaultTheme ?? Object.keys(config.themes)[0]}
+        >
+          {children}
+        </ThemeProvider>
+      </TextAncestorContext.Provider>
+    </ButtonNestingContext.Provider>
+  )
+}

package/src/views/Text.tsx

@@ -0,0 +1,87 @@
+import { isWeb } from '@tamagui/constants'
+import { stylePropsTextOnly, validStyles } from '@tamagui/helpers'
+import type { Text as TextView } from 'react-native'
+
+import { createComponent } from '../createComponent'
+import { TextProps, TextPropsBase } from '../types'
+
+const ellipseStyle = {
+  maxWidth: '100%',
+  overflow: 'hidden',
+  textOverflow: 'ellipsis',
+  whiteSpace: 'nowrap',
+}
+
+export const Text = createComponent<TextProps, TextView, TextPropsBase>({
+  componentName: 'Text',
+  acceptsClassName: true,
+  isText: true,
+
+  defaultProps: {
+    // @ts-ignore
+    display: 'flex',
+    fontFamily: 'System',
+    ...(isWeb
+      ? {
+          display: 'inline',
+          boxSizing: 'border-box',
+          wordWrap: 'break-word',
+          margin: 0,
+        }
+      : {
+          suppressHighlighting: true,
+        }),
+  },
+
+  inlineWhenUnflattened: new Set(['fontFamily']),
+
+  variants: {
+    ...(isWeb && {
+      numberOfLines: {
+        1: ellipseStyle,
+
+        ':number': (numberOfLines) =>
+          numberOfLines >= 1
+            ? {
+                WebkitLineClamp: numberOfLines,
+                WebkitBoxOrient: 'vertical',
+                display: '-webkit-box',
+                overflow: 'hidden',
+              }
+            : null,
+      },
+    }),
+
+    // ??
+    ellipsizeMode: {
+      '...': () => null,
+    },
+
+    selectable: {
+      true: {
+        userSelect: 'text',
+        cursor: 'text',
+      },
+      false: {
+        userSelect: 'none',
+        cursor: 'default',
+      },
+    },
+
+    ellipse: {
+      true: isWeb
+        ? ellipseStyle
+        : {
+            numberOfLines: 1,
+            lineBreakMode: 'clip',
+          },
+    },
+  },
+
+  deoptProps: new Set(isWeb ? [] : ['ellipse']),
+
+  validStyles: {
+    ...validStyles,
+    ...stylePropsTextOnly,
+  },
+})

package/src/views/Theme.tsx

@@ -0,0 +1,83 @@
+import { isWeb } from '@tamagui/constants'
+import { Children, cloneElement } from 'react'
+
+import { variableToString } from '../createVariable'
+import { ThemeManagerContext } from '../helpers/ThemeManagerContext'
+import { useServerRef } from '../hooks/useServerHooks'
+import { ChangedThemeResponse, useChangeThemeEffect } from '../hooks/useTheme'
+import { ThemeProps } from '../types'
+
+export function Theme(props: ThemeProps) {
+  // @ts-expect-error only for internal views
+  if (props.disable) return props.children
+  const isRoot = !!props['_isRoot']
+  const themeState = useChangeThemeEffect(props, isRoot)
+  const children = props['data-themeable']
+    ? Children.map(props.children, (child) =>
+        cloneElement(child, { ['data-themeable']: true })
+      )
+    : props.children
+
+  return useThemedChildren(themeState, children, props)
+}
+
+export function useThemedChildren(
+  themeState: ChangedThemeResponse,
+  children: any,
+  options: { forceClassName?: boolean; shallow?: boolean }
+) {
+  const { themeManager, isNewTheme, className, theme } = themeState
+  const { shallow, forceClassName } = options
+
+  const hasEverThemed = useServerRef(false)
+  if (isNewTheme) {
+    hasEverThemed.current = true
+  }
+
+  // once a theme is set it always passes the context to avoid reparenting
+  // until then no context to avoid lots of context
+  if (!isNewTheme && !hasEverThemed.current && !forceClassName && !shallow) {
+    return children
+  }
+
+  // be sure to memoize shouldReset to avoid reparenting
+  let next = children
+
+  if (shallow && themeManager) {
+    next = Children.map(next, (child) => {
+      return cloneElement(
+        child,
+        undefined,
+        <Theme name={themeManager.state.parentName}>{child.props.children}</Theme>
+      )
+    })
+  }
+
+  next = (
+    <ThemeManagerContext.Provider value={themeManager}>
+      {next}
+    </ThemeManagerContext.Provider>
+  )
+
+  if (isWeb) {
+    const enableClassName =
+      forceClassName === true || (forceClassName !== false && isNewTheme)
+    return (
+      <span
+        className="_dsp_contents"
+        {...(theme &&
+          enableClassName && {
+            className: `${className} ${forceClassName ? 'forced1' : ''} _dsp_contents`,
+            style: {
+              // in order to provide currentColor, set color by default
+              color: variableToString(theme.color),
+            },
+          })}
+      >
+        {next}
+      </span>
+    )
+  }
+
+  return next
+}

package/src/views/ThemeProvider.tsx

@@ -0,0 +1,55 @@
+import { isClient } from '@tamagui/constants'
+import { createContext, useLayoutEffect, useMemo } from 'react'
+
+import { THEME_CLASSNAME_PREFIX } from '../constants/constants'
+import { Theme } from './Theme'
+
+export type ThemeProviderProps = {
+  className?: string
+  defaultTheme: string
+  disableRootThemeClass?: boolean
+  themeClassNameOnRoot?: boolean
+  children?: any
+  reset?: boolean
+}
+
+export const ThemeProviderRootContext = createContext<Pick<
+  ThemeProviderProps,
+  'defaultTheme'
+> | null>(null)
+
+export const ThemeProvider = (props: ThemeProviderProps) => {
+  // ensure theme is attached to root body node as well to work with modals by default
+  if (isClient) {
+    useLayoutEffect(() => {
+      if (props.disableRootThemeClass) return
+      const cn = `${THEME_CLASSNAME_PREFIX}${props.defaultTheme}`
+      const target = props.themeClassNameOnRoot ? document.documentElement : document.body
+      target.classList.add(cn)
+      return () => {
+        target.classList.remove(cn)
+      }
+    }, [props.defaultTheme, props.disableRootThemeClass, props.themeClassNameOnRoot])
+  }
+
+  return (
+    <ThemeProviderRootContext.Provider
+      value={useMemo(() => {
+        return {
+          defaultTheme: props.defaultTheme,
+        }
+        // NOTE DON'T CHANGE THIS ITS ONLY USED BY useThemeName for SSR safety for now...
+      }, [])}
+    >
+      <Theme
+        className={props.className}
+        name={props.defaultTheme}
+        forceClassName={props.disableRootThemeClass ? false : undefined}
+        // @ts-expect-error
+        _isRoot
+      >
+        {props.children}
+      </Theme>
+    </ThemeProviderRootContext.Provider>
+  )
+}

package/types/Tamagui.d.ts

@@ -0,0 +1,30 @@
+import * as Helpers from '@tamagui/helpers';
+declare class TamaguiManager {
+    Helpers: typeof Helpers;
+    get mediaState(): {
+        [x: string]: boolean;
+        [x: number]: boolean;
+    };
+    get config(): import("./types").TamaguiInternalConfig<import("./types").CreateTokens<import("./types").VariableVal>, {
+        [key: string]: Partial<import("./types").TamaguiBaseTheme> & {
+            [key: string]: import("./types").VariableVal;
+        };
+    }, import("./types").GenericShorthands, {
+        [key: string]: {
+            [key: string]: string | number;
+        };
+    }, {
+        [key: string]: string | any[] | {
+            [key: string]: any;
+        };
+    }, import("./types").GenericFonts>;
+    get insertedRules(): string[];
+    get allSelectors(): Record<string, string>;
+    get allTransforms(): {};
+    get identifierToValue(): Map<string, any>;
+}
+export declare const Tamagui: TamaguiManager;
+export declare const getValueFromIdentifier: (identifier: string) => any;
+export declare const setIdentifierValue: (identifier: string, value: any) => void;
+export {};
+//# sourceMappingURL=Tamagui.d.ts.map

package/types/Tamagui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tamagui.d.ts","sourceRoot":"","sources":["../src/Tamagui.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAA;AAS3C,cAAM,cAAc;IAClB,OAAO,iBAAU;IAEjB,IAAI,UAAU;;;MAEb;IAED,IAAI,MAAM;;;;;;;;;;;;uCAET;IAED,IAAI,aAAa,aAEhB;IAED,IAAI,YAAY,2BAEf;IAED,IAAI,aAAa,OAEhB;IAED,IAAI,iBAAiB,qBAEpB;CACF;AAED,eAAO,MAAM,OAAO,gBAAuB,CAAA;AAI3C,eAAO,MAAM,sBAAsB,eAAgB,MAAM,QAExD,CAAA;AAED,eAAO,MAAM,kBAAkB,eAAgB,MAAM,SAAS,GAAG,SAEhE,CAAA"}

package/types/addTheme.d.ts

@@ -0,0 +1,32 @@
+import { ThemeDefinition } from './types';
+export declare function addTheme(props: {
+    name: string;
+    theme: Partial<Record<keyof ThemeDefinition, any>>;
+    insertCSS?: boolean;
+    update?: boolean;
+}): {
+    theme: {
+        [x: string]: import("./createVariable").Variable<any>;
+        background?: import("./createVariable").Variable<any> | undefined;
+        backgroundHover?: import("./createVariable").Variable<any> | undefined;
+        backgroundPress?: import("./createVariable").Variable<any> | undefined;
+        backgroundFocus?: import("./createVariable").Variable<any> | undefined;
+        color?: import("./createVariable").Variable<any> | undefined;
+        colorHover?: import("./createVariable").Variable<any> | undefined;
+        colorPress?: import("./createVariable").Variable<any> | undefined;
+        colorFocus?: import("./createVariable").Variable<any> | undefined;
+        borderColor?: import("./createVariable").Variable<any> | undefined;
+        borderColorHover?: import("./createVariable").Variable<any> | undefined;
+        borderColorPress?: import("./createVariable").Variable<any> | undefined;
+        borderColorFocus?: import("./createVariable").Variable<any> | undefined;
+        shadowColor?: import("./createVariable").Variable<any> | undefined;
+        shadowColorHover?: import("./createVariable").Variable<any> | undefined;
+        shadowColorPress?: import("./createVariable").Variable<any> | undefined;
+        shadowColorFocus?: import("./createVariable").Variable<any> | undefined;
+    };
+    cssRules?: undefined;
+} | {
+    theme: any;
+    cssRules: string[];
+};
+//# sourceMappingURL=addTheme.d.ts.map

package/types/addTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addTheme.d.ts","sourceRoot":"","sources":["../src/addTheme.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAe,MAAM,SAAS,CAAA;AAEtD,wBAAgB,QAAQ,CAAC,KAAK,EAAE;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,eAAe,EAAE,GAAG,CAAC,CAAC,CAAA;IAClD,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;;;;;;;;;;;;;;;;;;;;;;;;EAoDA"}

package/types/config.d.ts

@@ -0,0 +1,49 @@
+import { ConfigListener, TamaguiInternalConfig, Tokens } from './types';
+export declare const setConfig: (next: TamaguiInternalConfig) => void;
+export declare const setConfigFont: (name: string, font: any, fontParsed: any) => void;
+export declare const getConfig: () => TamaguiInternalConfig<import("./types").CreateTokens<import("./types").VariableVal>, {
+    [key: string]: Partial<import("./types").TamaguiBaseTheme> & {
+        [key: string]: import("./types").VariableVal;
+    };
+}, import("./types").GenericShorthands, {
+    [key: string]: {
+        [key: string]: string | number;
+    };
+}, {
+    [key: string]: string | any[] | {
+        [key: string]: any;
+    };
+}, import("./types").GenericFonts>;
+export declare const getTokens: ({ prefixed }?: {
+    prefixed?: boolean | undefined;
+}) => Tokens;
+/**
+ * Note: this is the same as `getTokens`
+ */
+export declare const useTokens: () => import("./types").CreateTokens<import("./types").VariableVal>;
+export declare const getThemes: () => {
+    [x: string]: {
+        [x: string]: import("./createVariable").Variable<any>;
+        background?: import("./createVariable").Variable<any> | undefined;
+        backgroundHover?: import("./createVariable").Variable<any> | undefined;
+        backgroundPress?: import("./createVariable").Variable<any> | undefined;
+        backgroundFocus?: import("./createVariable").Variable<any> | undefined;
+        color?: import("./createVariable").Variable<any> | undefined;
+        colorHover?: import("./createVariable").Variable<any> | undefined;
+        colorPress?: import("./createVariable").Variable<any> | undefined;
+        colorFocus?: import("./createVariable").Variable<any> | undefined;
+        borderColor?: import("./createVariable").Variable<any> | undefined;
+        borderColorHover?: import("./createVariable").Variable<any> | undefined;
+        borderColorPress?: import("./createVariable").Variable<any> | undefined;
+        borderColorFocus?: import("./createVariable").Variable<any> | undefined;
+        shadowColor?: import("./createVariable").Variable<any> | undefined;
+        shadowColorHover?: import("./createVariable").Variable<any> | undefined;
+        shadowColorPress?: import("./createVariable").Variable<any> | undefined;
+        shadowColorFocus?: import("./createVariable").Variable<any> | undefined;
+    };
+};
+export declare const configListeners: Set<ConfigListener>;
+export declare const onConfiguredOnce: (cb: ConfigListener) => void;
+export declare const updateConfig: (key: string, value: any) => void;
+export declare const getFont: (name: string) => import("./types").GenericFont<string | number>;
+//# sourceMappingURL=config.d.ts.map

package/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAIvE,eAAO,MAAM,SAAS,SAAU,qBAAqB,SAGpD,CAAA;AAED,eAAO,MAAM,aAAa,SAAU,MAAM,QAAQ,GAAG,cAAc,GAAG,SAMrE,CAAA;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;kCASrB,CAAA;AAED,eAAO,MAAM,SAAS;;MAAuD,MAC/B,CAAA;AAE9C;;GAEG;AACH,eAAO,MAAM,SAAS,qEAAoB,CAAA;AAE1C,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;CAAqB,CAAA;AAE3C,eAAO,MAAM,eAAe,qBAA4B,CAAA;AAExD,eAAO,MAAM,gBAAgB,OAAQ,cAAc,SAMlD,CAAA;AAED,eAAO,MAAM,YAAY,QAAS,MAAM,SAAS,GAAG,SAEnD,CAAA;AAGD,eAAO,MAAM,OAAO,SAAU,MAAM,mDAQnC,CAAA"}

package/types/constants/constants.d.ts

@@ -0,0 +1,21 @@
+export declare const THEME_NAME_SEPARATOR = "_";
+export declare const THEME_CLASSNAME_PREFIX = "t_";
+export declare const webOnlyDefaultStyles: {
+    display: string;
+    flexBasis: string;
+    boxSizing: string;
+    position: string;
+    minHeight: number;
+    minWidth: number;
+};
+export declare const stackDefaultStyles: {
+    display: string;
+    flexBasis: string;
+    boxSizing: string;
+    position: string;
+    minHeight: number;
+    minWidth: number;
+    alignItems: string;
+    flexShrink: number;
+};
+//# sourceMappingURL=constants.d.ts.map

package/types/constants/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,MAAM,CAAA;AACvC,eAAO,MAAM,sBAAsB,OAAO,CAAA;AAE1C,eAAO,MAAM,oBAAoB;;;;;;;CAOhC,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;CAI9B,CAAA"}

package/types/constants/isDevTools.d.ts

@@ -0,0 +1,2 @@
+export declare const isDevTools: any;
+//# sourceMappingURL=isDevTools.d.ts.map

package/types/constants/isDevTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDevTools.d.ts","sourceRoot":"","sources":["../../src/constants/isDevTools.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,KASnB,CAAA"}

package/types/contexts/ButtonNestingContext.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const ButtonNestingContext: import("react").Context<boolean>;
+//# sourceMappingURL=ButtonNestingContext.d.ts.map

package/types/contexts/ButtonNestingContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ButtonNestingContext.d.ts","sourceRoot":"","sources":["../../src/contexts/ButtonNestingContext.tsx"],"names":[],"mappings":";AAEA,eAAO,MAAM,oBAAoB,kCAAuB,CAAA"}

package/types/contexts/FontLanguageContext.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const FontLanguageContext: import("react").Context<Partial<{
+    [x: string]: import("..").FontLanguages;
+}> | null>;
+//# sourceMappingURL=FontLanguageContext.d.ts.map

package/types/contexts/FontLanguageContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontLanguageContext.d.ts","sourceRoot":"","sources":["../../src/contexts/FontLanguageContext.tsx"],"names":[],"mappings":";AAIA,eAAO,MAAM,mBAAmB;;UAAkD,CAAA"}

package/types/contexts/TextAncestorContext.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const TextAncestorContext: React.Context<boolean>;
+//# sourceMappingURL=TextAncestorContext.d.ts.map

package/types/contexts/TextAncestorContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextAncestorContext.d.ts","sourceRoot":"","sources":["../../src/contexts/TextAncestorContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAwB,MAAM,OAAO,CAAA;AAE5C,eAAO,MAAM,mBAAmB,wBAAuB,CAAA"}