@tamagui/web 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/helpers/getSplitStyles.native.cjs

@@ -0,0 +1,845 @@
+"use strict";
+
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getSplitStyles_exports = {};
+__export(getSplitStyles_exports, {
+	STYLE_TOKEN_PROVENANCE_KEY: () => import_styleProvenance2.STYLE_TOKEN_PROVENANCE_KEY,
+	getSplitStyles: () => getSplitStyles,
+	getStyleTokenProvenance: () => import_styleProvenance2.getStyleTokenProvenance,
+	getSubStyle: () => getSubStyle,
+	isValidStyleKey: () => isValidStyleKey,
+	styleOriginalValues: () => import_styleOriginalValues.styleOriginalValues,
+	useSplitStyles: () => useSplitStyles
+});
+module.exports = __toCommonJS(getSplitStyles_exports);
+var import_constants = require("@tamagui/constants");
+var import_helpers = require("@tamagui/helpers");
+var import_react = __toESM(require("react"), 1);
+var import_styleFrontend = require("./styleFrontend.native.js");
+var import_config = require("../config.native.js");
+var import_isDevTools = require("../constants/isDevTools.native.js");
+var import_mediaState = require("./mediaState.native.js");
+var import_expandStyles = require("./expandStyles.native.js");
+var import_getCSSStylesAtomic = require("./getCSSStylesAtomic.native.js");
+var import_getDefaultProps = require("./getDefaultProps.native.js");
+require("./insertStyleRule.native.js");
+var import_isObj = require("./isObj.native.js");
+var import_log = require("./log.native.js");
+var import_normalizeValueWithProperty = require("./normalizeValueWithProperty.native.js");
+var import_propMapper = require("./propMapper.native.js");
+var import_directStyle = require("./directStyle.native.js");
+var import_frontendProgram = require("./frontendProgram.native.js");
+var import_skipProps = require("./skipProps.native.js");
+var import_sortString = require("./sortString.native.js");
+var import_styleOriginalValues = require("./styleOriginalValues.native.js");
+var import_styleProvenance = require("./styleProvenance.native.js");
+var import_transformsToString = require("./transformsToString.native.js");
+var import_styleProvenance2 = require("./styleProvenance.native.js");
+function _type_of(obj) {
+	"@swc/helpers - typeof";
+	return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var shouldTrackStyleTokenProvenance = process.env.NODE_ENV === "development" && process.env.TAMAGUI_ENABLE_STYLE_TOKEN_PROVENANCE === "1";
+function compoundMatcherMatches(expected, actual) {
+	if (Array.isArray(expected)) return expected.some(function(value) {
+		return Object.is(value, actual);
+	});
+	return Object.is(expected, actual);
+}
+function compoundVariantMatches(compoundVariant, props) {
+	for (var key in compoundVariant) {
+		if (key === "style") continue;
+		if (!compoundMatcherMatches(compoundVariant[key], props[key])) return false;
+	}
+	return true;
+}
+var styledDefaultsCache = /* @__PURE__ */ new WeakMap();
+function getStyledDefaults(staticConfig) {
+	var entries = styledDefaultsCache.get(staticConfig);
+	if (entries === void 0) {
+		entries = null;
+		var defaults = staticConfig.defaultProps;
+		if (defaults) for (var key in defaults) (entries || (entries = [])).push([key, defaults[key]]);
+		styledDefaultsCache.set(staticConfig, entries);
+	}
+	return entries;
+}
+function contributeDisplacedStyledDefaults(styledDefaults, processedProps, shorthands, contribute) {
+	if (!styledDefaults) return;
+	for (var index = 0; index < styledDefaults.length; index++) {
+		var key = styledDefaults[index][0];
+		var styledValue = styledDefaults[index][1];
+		var propValue = processedProps[key];
+		if (!(key in import_helpers.stylePropsAll) && !(key in shorthands)) continue;
+		if (propValue !== void 0 && propValue !== styledValue && (typeof styledValue === "string" && styledValue.includes(":") || typeof propValue === "string" && propValue.includes(":"))) contribute(key, styledValue);
+	}
+}
+function forEachPropInForwardOrder(processedProps, staticConfig, shorthands, contribute) {
+	var processedBaseStyle = staticConfig.baseStyle;
+	var compoundVariants = staticConfig.compoundVariants;
+	var styledDefaults = getStyledDefaults(staticConfig);
+	if (!(compoundVariants === null || compoundVariants === void 0 ? void 0 : compoundVariants.length)) {
+		if (processedBaseStyle) for (var key in processedBaseStyle) contribute(key, processedBaseStyle[key]);
+		contributeDisplacedStyledDefaults(styledDefaults, processedProps, shorthands, contribute);
+		for (var key1 in processedProps) contribute(key1, processedProps[key1]);
+		return;
+	}
+	var propEntries = Object.entries(processedProps);
+	var orderedEntries = processedBaseStyle ? Object.entries(processedBaseStyle) : [];
+	contributeDisplacedStyledDefaults(styledDefaults, processedProps, shorthands, function(k, v) {
+		return orderedEntries.push([k, v]);
+	});
+	var compoundsByAnchor = /* @__PURE__ */ new Map();
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = compoundVariants[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var compoundVariant = _step.value;
+			if (!compoundVariantMatches(compoundVariant, processedProps)) continue;
+			var { style } = compoundVariant;
+			if (!(0, import_isObj.isPlainObject)(style)) continue;
+			var anchor = -1;
+			for (var selectorKey in compoundVariant) {
+				if (selectorKey === "style") continue;
+				for (var index = propEntries.length - 1; index >= 0; index--) if (propEntries[index][0] === selectorKey) {
+					anchor = Math.max(anchor, index);
+					break;
+				}
+			}
+			var entries = compoundsByAnchor.get(anchor) || [];
+			for (var key2 in style) entries.push([key2, style[key2]]);
+			compoundsByAnchor.set(anchor, entries);
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+		} finally {
+			if (_didIteratorError) throw _iteratorError;
+		}
+	}
+	for (var index1 = 0; index1 < orderedEntries.length; index1++) contribute(orderedEntries[index1][0], orderedEntries[index1][1]);
+	var beforeProps = compoundsByAnchor.get(-1);
+	if (beforeProps) for (var index2 = 0; index2 < beforeProps.length; index2++) contribute(beforeProps[index2][0], beforeProps[index2][1]);
+	for (var index3 = 0; index3 < propEntries.length; index3++) {
+		contribute(propEntries[index3][0], propEntries[index3][1]);
+		var compounds = compoundsByAnchor.get(index3);
+		if (compounds) for (var i = 0; i < compounds.length; i++) contribute(compounds[i][0], compounds[i][1]);
+	}
+}
+function isValidStyleKey(key, validStyles, accept) {
+	return Boolean(key in validStyles || import_constants.isWeb && (key === "transitionProperty" || key === "transitionDuration" || key === "transitionTimingFunction" || key === "transitionDelay" || key === "transitionBehavior") || accept && key in accept);
+}
+var getSplitStyles = function(props, staticConfig, theme, themeName, componentState, styleProps, parentSplitStyles, componentContext, groupContext, elementType, startedUnhydrated, debug, animationDriver) {
+	var _staticConfig_styleFrontend, _styleState_flatMediaKeys, _styleState_flatGroupKeys, _styleState_flatGroupMedia, _styleState_style;
+	var conf = (0, import_config.getConfig)();
+	if ((_staticConfig_styleFrontend = staticConfig.styleFrontend) === null || _staticConfig_styleFrontend === void 0 ? void 0 : _staticConfig_styleFrontend.normalizeStaticConfig) staticConfig = staticConfig.styleFrontend.normalizeStaticConfig(staticConfig, conf);
+	var driver = animationDriver || (componentContext === null || componentContext === void 0 ? void 0 : componentContext.animationDriver) || conf.animations;
+	var resolvedDriver = (driver === null || driver === void 0 ? void 0 : driver.isStub) ? null : driver;
+	if (props.passThrough) return null;
+	if (import_constants.isWeb && styleProps.isAnimated && (driver === null || driver === void 0 ? void 0 : driver.isReactNative) && !styleProps.noNormalize) styleProps.noNormalize = "values";
+	var { shorthands } = conf;
+	var { isHOC, isText, isInput, variants, isReactNative, inlineProps, parentStaticConfig, acceptsClassName } = staticConfig;
+	var viewProps = {};
+	var mediaState = styleProps.mediaState || import_mediaState.mediaState;
+	var shouldDoClasses = acceptsClassName && import_constants.isWeb && !styleProps.noClass;
+	var rulesToInsert = void 0;
+	var classNames = {};
+	props.space;
+	var hasMedia = false;
+	var pseudoGroups;
+	var mediaGroups;
+	var className = staticConfig.passthroughClassName || "";
+	if (className) shouldDoClasses = false;
+	var validStyles = staticConfig.validStyles || (staticConfig.isText || staticConfig.isInput ? import_helpers.stylePropsText : import_helpers.validStyles);
+	if (process.env.NODE_ENV === "development" && (debug === "profile" || globalThis.time)) time`split-styles-setup`;
+	var styleState = {
+		classNames,
+		conf,
+		props,
+		styleProps,
+		componentState,
+		staticConfig,
+		style: null,
+		theme,
+		viewProps,
+		context: componentContext,
+		debug,
+		flatRulesToInsert: rulesToInsert,
+		flatShouldDoClasses: shouldDoClasses,
+		flatThemeName: themeName,
+		flatMediaState: mediaState,
+		flatGroupContext: groupContext,
+		animationDriver: resolvedDriver
+	};
+	if (process.env.IS_STATIC === "is_static") {
+		var { fallbackProps } = styleProps;
+		if (fallbackProps) styleState.props = new Proxy(props, { get(_, key9, val2) {
+			if (!Reflect.has(props, key9)) return Reflect.get(fallbackProps, key9);
+			return Reflect.get(props, key9);
+		} });
+	}
+	if (process.env.NODE_ENV === "development" && (debug === "profile" || globalThis.time)) time`style-state`;
+	if (process.env.NODE_ENV === "development" && debug === "verbose" && import_constants.isClient) {
+		if (import_isDevTools.isDevTools) {
+			console.groupCollapsed("🔹 getSplitStyles 👇");
+			(0, import_log.log)({
+				props,
+				staticConfig,
+				shouldDoClasses,
+				styleProps,
+				rulesToInsert,
+				componentState,
+				styleState,
+				theme: { ...theme }
+			});
+		}
+	}
+	var { asChild } = props;
+	var { accept, neverSkipProps } = staticConfig;
+	var { noSkip, disableExpandShorthands, noExpand, styledContext } = styleProps;
+	var processedProps;
+	var styleFrontend = staticConfig.styleFrontend;
+	if (styleFrontend && !props[import_styleFrontend.STYLE_FRONTEND_PREPROCESSED]) processedProps = styleFrontend.preprocessProps(props, conf);
+	else processedProps = props;
+	var { webContainerType } = conf.settings;
+	var parentVariants = parentStaticConfig === null || parentStaticConfig === void 0 ? void 0 : parentStaticConfig.variants;
+	var mergeStylePropAtCurrentPosition = function(styleProp) {
+		if (styleProps.noMergeStyle || !styleProp) return;
+		if (isHOC) {
+			viewProps.style = normalizeStyle(styleProp);
+			return;
+		}
+		var isArray = Array.isArray(styleProp);
+		var length = isArray ? styleProp.length : 1;
+		for (var index = 0; index < length; index++) {
+			var style2 = isArray ? styleProp[index] : styleProp;
+			if (!style2) continue;
+			if (style2["$$css"]) {
+				for (var key9 in style2) (0, import_directStyle.clearDirectStyle)(styleState, key9);
+				Object.assign(styleState.classNames, style2);
+				continue;
+			}
+			var normalized = normalizeStyle(style2);
+			var styleOriginals = shouldTrackStyleTokenProvenance ? import_styleOriginalValues.styleOriginalValues.get(style2) : void 0;
+			for (var key12 in normalized) {
+				if (normalized[key12] == null) continue;
+				(0, import_directStyle.contributeStyleValue)(styleState, key12, normalized[key12], mergeStyle, styleOriginals === null || styleOriginals === void 0 ? void 0 : styleOriginals[key12]);
+			}
+		}
+	};
+	var flushForwardStylesToClasses = function() {
+		if (!shouldDoClasses) return;
+		(0, import_directStyle.flushDirectStyles)(styleState, true);
+	};
+	var contributeProp = function(keyOg, valOg) {
+		var keyInit = keyOg;
+		var valInit = valOg;
+		if (styleFrontend && keyInit.startsWith(import_styleFrontend.STYLE_FRONTEND_PASSTHROUGH_PREFIX)) keyInit = "className";
+		if (keyInit === "children") {
+			viewProps[keyInit] = valInit;
+			return;
+		}
+		if (keyInit === "ref") return;
+		if (keyInit[0] === "d" && keyInit.startsWith("data-")) return;
+		if (process.env.NODE_ENV === "development" && (debug === "profile" || globalThis.time)) time`before-prop-${keyInit}`;
+		if (process.env.NODE_ENV === "test" && keyInit === "jestAnimatedStyle") return;
+		if (keyInit === "transition" || keyInit === "transitionProperty" || keyInit === "transitionDuration" || keyInit === "transitionTimingFunction" || keyInit === "transitionDelay" || keyInit === "transitionBehavior") return;
+		if (accept) {
+			var accepted = accept[keyInit];
+			if ((accepted === "style" || accepted === "textStyle") && valInit && (typeof valInit === "undefined" ? "undefined" : _type_of(valInit)) === "object") {
+				viewProps[keyInit] = getSubStyle(styleState, keyInit, valInit, styleProps.noClass);
+				return;
+			}
+		}
+		if (!disableExpandShorthands) {
+			if (keyInit in shorthands) keyInit = shorthands[keyInit];
+		}
+		if (keyInit === "className") {
+			if (typeof valInit === "string" && valInit) {
+				className = `${className} ${valInit}`.trim();
+				if (styleFrontend) {
+					flushForwardStylesToClasses();
+					shouldDoClasses = false;
+					styleState.flatShouldDoClasses = false;
+				}
+			}
+			return;
+		}
+		if (keyInit === "style") {
+			mergeStylePropAtCurrentPosition(valInit);
+			return;
+		}
+		if (asChild) {
+			var defaults = (0, import_getDefaultProps.getDefaultProps)(staticConfig);
+			if (defaults) {
+				var _defaults_keyOg;
+				var defaultVal = (_defaults_keyOg = defaults[keyOg]) !== null && _defaults_keyOg !== void 0 ? _defaults_keyOg : defaults[keyInit];
+				if (defaultVal !== void 0 && valInit === defaultVal) return;
+			}
+		}
+		if (keyInit in import_skipProps.skipProps && !noSkip && !isHOC && !(neverSkipProps === null || neverSkipProps === void 0 ? void 0 : neverSkipProps[keyInit])) {
+			if (keyInit === "group");
+			if (keyInit === "container" && valInit) {}
+			if (keyInit === "transition" && typeof valInit === "string") {
+				var _driver_animations;
+				var animationConfig = driver === null || driver === void 0 ? void 0 : (_driver_animations = driver.animations) === null || _driver_animations === void 0 ? void 0 : _driver_animations[valInit];
+				if (animationConfig && (driver === null || driver === void 0 ? void 0 : driver.outputStyle) === "css" && process.env.IS_STATIC === "is_static") valInit = `all ${animationConfig}`;
+				else if (animationConfig) return;
+			} else return;
+		}
+		if ((0, import_frontendProgram.isFrontendProgram)(valInit)) {
+			if (isValidStyleKey(valInit.property, validStyles, accept)) (0, import_frontendProgram.contributeFrontendProgram)(styleState, valInit, mergeStyle);
+			else if (process.env.NODE_ENV === "development") console.warn(`[tamagui] "${valInit.property}" is not a valid style on this component; the frontend value is dropped.`);
+			return;
+		}
+		var isValidStyleKeyInit = isValidStyleKey(keyInit, validStyles, accept);
+		if (import_constants.isWeb) {
+			var _driver_View;
+			if ((staticConfig.isReactNative || styleProps.isAnimated && (driver === null || driver === void 0 ? void 0 : driver.isReactNative) && !((_driver_View = driver.View) === null || _driver_View === void 0 ? void 0 : _driver_View.acceptRenderProp)) && keyInit.startsWith("data-")) {
+				var _viewProps2, _dataSet;
+				keyInit = keyInit.replace("data-", "");
+				(_viewProps2 = viewProps)[_dataSet = "dataSet"] || (_viewProps2[_dataSet] = {});
+				viewProps["dataSet"][keyInit] = valInit;
+				return;
+			}
+			if (keyInit.startsWith("data-")) {
+				viewProps[keyInit] = valInit;
+				return;
+			}
+		}
+		if (!isValidStyleKeyInit) {
+			if (!import_constants.isAndroid) {
+				if (keyInit === "elevationAndroid") return;
+			}
+			if (keyInit === "userSelect") {
+				keyInit = "selectable";
+				valInit = valInit !== "none";
+			} else if (keyInit === "textOverflow") {
+				if (isText && valInit === "ellipsis") {
+					var _viewProps1, _viewProps22;
+					var _numberOfLines;
+					(_numberOfLines = (_viewProps1 = viewProps).numberOfLines) !== null && _numberOfLines !== void 0 || (_viewProps1.numberOfLines = 1);
+					var _ellipsizeMode;
+					(_ellipsizeMode = (_viewProps22 = viewProps).ellipsizeMode) !== null && _ellipsizeMode !== void 0 || (_viewProps22.ellipsizeMode = "tail");
+				}
+				return;
+			} else if (keyInit.startsWith("data-")) return;
+		}
+		var isVariant = !isValidStyleKeyInit && variants && keyInit in variants;
+		var isStyleLikeKey = isValidStyleKeyInit || isVariant;
+		var isStyleProp = isValidStyleKeyInit || isVariant && !noExpand;
+		if (isStyleProp && (asChild === "except-style" || asChild === "except-style-web")) return;
+		var shouldPassProp = !isStyleProp && isHOC || isHOC && parentVariants && keyInit in parentVariants || (inlineProps === null || inlineProps === void 0 ? void 0 : inlineProps.has(keyInit));
+		var parentVariant = parentVariants === null || parentVariants === void 0 ? void 0 : parentVariants[keyInit];
+		var isHOCShouldPassThrough = Boolean(isHOC && (isValidStyleKeyInit || parentVariant || keyInit in import_skipProps.skipProps));
+		var shouldPassThrough = shouldPassProp || isHOCShouldPassThrough;
+		if (process.env.NODE_ENV === "development" && debug === "verbose") {
+			console.groupCollapsed(`  \u{1F511} ${keyOg}${keyInit !== keyOg ? ` (shorthand for ${keyInit})` : ""} ${shouldPassThrough ? "(pass)" : ""}`);
+			(0, import_log.log)({
+				isVariant,
+				valInit,
+				shouldPassProp
+			});
+			if (import_constants.isClient) (0, import_log.log)({
+				variants,
+				variant: variants === null || variants === void 0 ? void 0 : variants[keyInit],
+				isVariant,
+				isHOCShouldPassThrough,
+				parentStaticConfig
+			});
+		}
+		if (shouldPassThrough) {
+			passDownProp(viewProps, keyInit, valInit);
+			if (process.env.NODE_ENV === "development" && debug === "verbose") console.groupEnd();
+			if (!isVariant) return;
+		}
+		if (!noSkip && !(neverSkipProps === null || neverSkipProps === void 0 ? void 0 : neverSkipProps[keyInit])) {
+			var _driver_animations1;
+			if (keyInit in import_skipProps.skipProps && !(keyInit === "transition" && typeof valInit === "string" && !(driver === null || driver === void 0 ? void 0 : (_driver_animations1 = driver.animations) === null || _driver_animations1 === void 0 ? void 0 : _driver_animations1[valInit]))) {
+				if (process.env.NODE_ENV === "development" && debug === "verbose") console.groupEnd();
+				return;
+			}
+		}
+		if (isText || isInput) {
+			if (valInit && (keyInit === "fontFamily" || keyInit === shorthands["fontFamily"]) && valInit in conf.fontsParsed) styleState.fontFamily = valInit;
+		}
+		var disablePropMap = !isStyleLikeKey;
+		if (!isHOC && isValidStyleKeyInit && valInit != null && !(valInit === "unset") && !(variants && keyInit in variants) && !(accept && keyInit in accept) && !(styledContext && keyInit in styledContext)) {
+			(0, import_directStyle.contributeStyleValue)(styleState, keyInit, valInit, mergeStyle);
+			return;
+		}
+		(0, import_propMapper.propMapper)(keyInit, valInit, styleState, disablePropMap, function(key9, val2, originalVal, conditionSource) {
+			var _parentStaticConfig_variants;
+			var isStyledContextProp = styledContext && key9 in styledContext;
+			if (key9 === "className") {
+				if (typeof val2 === "string" && val2) className = `${className} ${val2}`.trim();
+				return;
+			}
+			if (!isHOC && disablePropMap && !isStyledContextProp) {
+				if (key9 in import_helpers.stylePropsAll && !isValidStyleKey(key9, validStyles, accept)) {
+					if (process.env.NODE_ENV === "development") console.warn(`[tamagui] "${key9}" is a text style prop and this component is not text \u2014 it would render on neither platform. Use a Text-based component, or html.* for raw web elements.`);
+					return;
+				}
+				viewProps[key9] = val2;
+				return;
+			}
+			if (process.env.NODE_ENV === "development" && debug === "verbose") {
+				console.groupCollapsed("  💠 expanded", keyInit, "=>", key9);
+				(0, import_log.log)(val2);
+				console.groupEnd();
+			}
+			if (val2 == null) return;
+			if (accept && key9 in accept) {
+				viewProps[key9] = val2;
+				return;
+			}
+			var isHostStyleKey = !isHOC && isValidStyleKey(key9, validStyles, accept) || import_constants.isAndroid && key9 === "elevation";
+			var isContextProgramKey = !isHOC && Boolean(isStyledContextProp);
+			if (conditionSource !== void 0) {
+				if (isHostStyleKey || isContextProgramKey) (0, import_directStyle.contributeVariantClauseValue)(styleState, key9, val2, conditionSource, mergeStyle, originalVal, !isHostStyleKey);
+				else if (isHOC) {
+					var appended = (0, import_propMapper.appendFlatClause)(viewProps[key9], conditionSource, val2);
+					if (appended !== void 0) viewProps[key9] = appended;
+					else if (process.env.NODE_ENV === "development") console.warn(`[tamagui] conditional variant value for "${key9}" is not string-representable; dropping the clause`);
+				} else if (process.env.NODE_ENV === "development") console.warn(`[tamagui] "${key9}" is not a valid style on this component; the conditional variant value is dropped.`);
+				return;
+			}
+			if (isHostStyleKey || isContextProgramKey) {
+				(0, import_directStyle.contributeStyleValue)(styleState, key9, val2, mergeStyle, originalVal, !isHostStyleKey);
+				return;
+			}
+			isVariant = variants && key9 in variants;
+			if (inlineProps === null || inlineProps === void 0 ? void 0 : inlineProps.has(key9)) {
+				var _props_key;
+				viewProps[key9] = (_props_key = props[key9]) !== null && _props_key !== void 0 ? _props_key : val2;
+			}
+			if (isHOC && Boolean(parentStaticConfig === null || parentStaticConfig === void 0 ? void 0 : (_parentStaticConfig_variants = parentStaticConfig.variants) === null || _parentStaticConfig_variants === void 0 ? void 0 : _parentStaticConfig_variants[keyInit])) {
+				passDownProp(viewProps, key9, val2);
+				if (process.env.NODE_ENV === "development" && debug === "verbose") {
+					console.groupCollapsed(` - passing down prop ${key9}`);
+					(0, import_log.log)({
+						val: val2,
+						after: { ...viewProps[key9] }
+					});
+					console.groupEnd();
+				}
+				return;
+			}
+			if (!isVariant) {
+				if (isStyledContextProp) return;
+				if (key9 in import_helpers.stylePropsAll && !isValidStyleKey(key9, validStyles, accept)) {
+					if (process.env.NODE_ENV === "development") console.warn(`[tamagui] "${key9}" is a text style prop and this component is not text \u2014 it would render on neither platform. Use a Text-based component, or html.* for raw web elements.`);
+					return;
+				}
+				viewProps[key9] = val2;
+			}
+		});
+		if (process.env.NODE_ENV === "development" && debug === "verbose") {
+			try {
+				(0, import_log.log)(` \u2714\uFE0F expand complete`, keyInit);
+				(0, import_log.log)("style", { ...styleState.style });
+				(0, import_log.log)("viewProps", { ...viewProps });
+				(0, import_log.log)("transforms", { ...styleState.flatTransforms });
+			} catch (e) {}
+			console.groupEnd();
+		}
+	};
+	forEachPropInForwardOrder(processedProps, staticConfig, shorthands, contributeProp);
+	if (process.env.NODE_ENV === "development" && (debug === "profile" || globalThis.time)) time`split-styles-propsend`;
+	var conditionalStates = styleState.flatStateKeys || null;
+	var usesSafeArea = !!styleState.flatUsesSafeArea;
+	if ((_styleState_flatMediaKeys = styleState.flatMediaKeys) === null || _styleState_flatMediaKeys === void 0 ? void 0 : _styleState_flatMediaKeys.size) {
+		if (!hasMedia) hasMedia = /* @__PURE__ */ new Set();
+		if (typeof hasMedia !== "boolean") {
+			var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+			try {
+				for (var _iterator = styleState.flatMediaKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+					var key = _step.value;
+					hasMedia.add(key);
+				}
+			} catch (err) {
+				_didIteratorError = true;
+				_iteratorError = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+				} finally {
+					if (_didIteratorError) throw _iteratorError;
+				}
+			}
+		}
+	}
+	if ((_styleState_flatGroupKeys = styleState.flatGroupKeys) === null || _styleState_flatGroupKeys === void 0 ? void 0 : _styleState_flatGroupKeys.size) {
+		pseudoGroups || (pseudoGroups = /* @__PURE__ */ new Set());
+		var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+		try {
+			for (var _iterator1 = styleState.flatGroupKeys[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+				var key1 = _step1.value;
+				pseudoGroups.add(key1);
+			}
+		} catch (err) {
+			_didIteratorError1 = true;
+			_iteratorError1 = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion1 && _iterator1.return != null) _iterator1.return();
+			} finally {
+				if (_didIteratorError1) throw _iteratorError1;
+			}
+		}
+	}
+	if ((_styleState_flatGroupMedia = styleState.flatGroupMedia) === null || _styleState_flatGroupMedia === void 0 ? void 0 : _styleState_flatGroupMedia.size) {
+		mediaGroups || (mediaGroups = /* @__PURE__ */ new Set());
+		var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+		try {
+			for (var _iterator2 = styleState.flatGroupMedia[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+				var key2 = _step2.value;
+				mediaGroups.add(key2);
+			}
+		} catch (err) {
+			_didIteratorError2 = true;
+			_iteratorError2 = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion2 && _iterator2.return != null) _iterator2.return();
+			} finally {
+				if (_didIteratorError2) throw _iteratorError2;
+			}
+		}
+	}
+	var effectiveTransition = (_styleState_style = styleState.style) === null || _styleState_style === void 0 ? void 0 : _styleState_style.transition;
+	if (effectiveTransition != null && styleState.style && true) delete styleState.style.transition;
+	if (styleState.style) {
+		if ("containerType" in styleState.style) delete styleState.style.containerType;
+		if ("containerName" in styleState.style) delete styleState.style.containerName;
+	}
+	if (!(styleProps.noNormalize === false)) {
+		if (styleState.style) {
+			(0, import_expandStyles.fixStyles)(styleState.style);
+			if (!styleProps.noExpand && !styleProps.noMergeStyle) {
+				if (import_constants.isWeb && (isReactNative ? (driver === null || driver === void 0 ? void 0 : driver.inputStyle) !== "css" : true)) (0, import_getCSSStylesAtomic.styleToCSS)(styleState.style);
+			}
+		}
+		if (styleState.flatTransforms) {
+			var _styleState;
+			(_styleState = styleState).style || (_styleState.style = {});
+			mergeFlatTransforms(styleState.style, styleState.flatTransforms);
+		}
+		if (parentSplitStyles) {
+			if (!shouldDoClasses) for (var key4 in parentSplitStyles.style) {
+				var _styleState1;
+				if (key4 in classNames || styleState.style && key4 in styleState.style) continue;
+				(_styleState1 = styleState).style || (_styleState1.style = {});
+				styleState.style[key4] = parentSplitStyles.style[key4];
+			}
+		}
+	}
+	if (viewProps.tabIndex === 0) {
+		var _viewProps;
+		var _accessible;
+		(_accessible = (_viewProps = viewProps).accessible) !== null && _accessible !== void 0 || (_viewProps.accessible = true);
+	}
+	var style = styleState.style;
+	if (style === null || style === void 0 ? void 0 : style.fontFamily) {
+		var _getFont;
+		var faceInfo = (_getFont = (0, import_config.getFont)(style.fontFamily)) === null || _getFont === void 0 ? void 0 : _getFont.face;
+		if (faceInfo) {
+			var _faceInfo_style_fontWeight_, _faceInfo_style_fontWeight;
+			var overrideFace = (_faceInfo_style_fontWeight = faceInfo[style.fontWeight]) === null || _faceInfo_style_fontWeight === void 0 ? void 0 : (_faceInfo_style_fontWeight_ = _faceInfo_style_fontWeight[style.fontStyle || "normal"]) === null || _faceInfo_style_fontWeight_ === void 0 ? void 0 : _faceInfo_style_fontWeight_.val;
+			if (overrideFace) {
+				style.fontFamily = overrideFace;
+				styleState.fontFamily = overrideFace;
+				delete style.fontWeight;
+				delete style.fontStyle;
+			}
+		}
+		if (process.env.NODE_ENV === "development" && debug && debug !== "profile") (0, import_log.log)(`Found fontFamily native: ${style.fontFamily}`, faceInfo);
+	}
+	if (process.env.NODE_ENV === "development" && (debug === "profile" || globalThis.time)) time`split-styles-pre-result`;
+	if (shouldTrackStyleTokenProvenance && styleState.style && styleState.tokenProvenance) {
+		var provenance = {};
+		var hasProvenance = false;
+		for (var key6 in styleState.tokenProvenance) {
+			provenance[key6] = {
+				token: styleState.tokenProvenance[key6],
+				theme: themeName
+			};
+			hasProvenance = true;
+		}
+		if (hasProvenance) (0, import_styleProvenance.setStyleTokenProvenance)(styleState.style, provenance);
+	}
+	var result = {
+		hasMedia,
+		fontFamily: styleState.fontFamily,
+		viewProps,
+		style: styleState.style,
+		classNames,
+		rulesToInsert,
+		pseudoGroups,
+		mediaGroups,
+		overriddenContextProps: styleState.overriddenContextProps
+	};
+	if (effectiveTransition != null) result.effectiveTransition = effectiveTransition;
+	if (conditionalStates) result.programStates = conditionalStates;
+	if (usesSafeArea) result.usesSafeArea = true;
+	if ((0, import_directStyle.getDirectDynamicThemeAccess)(styleState)) result.dynamicThemeAccess = true;
+	if (styleState.flatEnterKeys || styleState.flatExitKeys) {
+		var effectiveKeys = function(keys) {
+			if (!keys) return;
+			var out = /* @__PURE__ */ new Set();
+			var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = void 0;
+			try {
+				for (var _iterator4 = keys[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+					var key9 = _step4.value;
+					out.add(key9 === "--t-x" || key9 === "--t-y" ? "translate" : key9 === "--t-scale-x" || key9 === "--t-scale-y" ? "scale" : key9);
+				}
+			} catch (err) {
+				_didIteratorError4 = true;
+				_iteratorError4 = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion4 && _iterator4.return != null) _iterator4.return();
+				} finally {
+					if (_didIteratorError4) throw _iteratorError4;
+				}
+			}
+			return out;
+		};
+		result.programLifecycleStyleKeys = {
+			enter: effectiveKeys(styleState.flatEnterKeys),
+			exit: effectiveKeys(styleState.flatExitKeys)
+		};
+	}
+	var asChildExceptStyleLike = asChild === "except-style" || asChild === "except-style-web";
+	if (!styleProps.noMergeStyle) {
+		if (!asChildExceptStyleLike) {
+			var style1 = styleState.style;
+			if (style1) viewProps.style = style1;
+		}
+	}
+	if (process.env.NODE_ENV === "development" && debug === "verbose") {
+		if (import_constants.isClient && import_isDevTools.isDevTools) {
+			console.groupEnd();
+			console.groupCollapsed("🔹 getSplitStyles ===>");
+			try {
+				var logs = {
+					...props.__tamaguiStyleDebugReceipt && { receipt: props.__tamaguiStyleDebugReceipt },
+					...result,
+					className,
+					componentState,
+					viewProps,
+					rulesToInsert,
+					parentSplitStyles
+				};
+				for (var key8 in logs) (0, import_log.log)(key8, logs[key8]);
+			} catch (e) {}
+			console.groupEnd();
+		}
+	}
+	if (process.env.NODE_ENV === "development" && (debug === "profile" || globalThis.time)) time`split-styles-done`;
+	return result;
+};
+function mergeFlatTransforms(target, flatTransforms) {
+	var transform = [];
+	if ("x" in flatTransforms) transform.push({ translateX: flatTransforms.x });
+	if ("y" in flatTransforms) transform.push({ translateY: flatTransforms.y });
+	if ("rotate" in flatTransforms) transform.push({ rotate: flatTransforms.rotate });
+	var hasScaleX = "scaleX" in flatTransforms;
+	var hasScaleY = "scaleY" in flatTransforms;
+	if (hasScaleX && hasScaleY && Object.is(flatTransforms.scaleX, flatTransforms.scaleY)) transform.push({ scale: flatTransforms.scaleX });
+	else {
+		if (hasScaleX) transform.push({ scaleX: flatTransforms.scaleX });
+		if (hasScaleY) transform.push({ scaleY: flatTransforms.scaleY });
+		if (!hasScaleX && !hasScaleY && "scale" in flatTransforms) transform.push({ scale: flatTransforms.scale });
+	}
+	var keys = [];
+	for (var key in flatTransforms) if (key !== "x" && key !== "y" && key !== "rotate" && key !== "scale" && key !== "scaleX" && key !== "scaleY") keys.push(key);
+	keys.sort(import_sortString.sortString);
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var key1 = _step.value;
+			transform.push({ [mapTransformKeys[key1] || key1]: flatTransforms[key1] });
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+		} finally {
+			if (_didIteratorError) throw _iteratorError;
+		}
+	}
+	if (Array.isArray(target.transform)) transform.push(...target.transform);
+	target.transform = transform;
+}
+function mergeStyle(styleState, key, val, _importance) {
+	var disableNormalize = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : false, originalVal = arguments.length > 5 ? arguments[5] : void 0;
+	var _staticConfig_parentStaticConfig, _staticConfig_parentStaticConfig1, _staticConfig_parentStaticConfig2, _contextConfig_propKeys;
+	var { viewProps, styleProps, staticConfig } = styleState;
+	var contextConfig = staticConfig.context || ((_staticConfig_parentStaticConfig = staticConfig.parentStaticConfig) === null || _staticConfig_parentStaticConfig === void 0 ? void 0 : _staticConfig_parentStaticConfig.context);
+	var contextProps = contextConfig === null || contextConfig === void 0 ? void 0 : contextConfig.props;
+	var inheritedContextPropKeys = !staticConfig.context || staticConfig.context === ((_staticConfig_parentStaticConfig1 = staticConfig.parentStaticConfig) === null || _staticConfig_parentStaticConfig1 === void 0 ? void 0 : _staticConfig_parentStaticConfig1.context) ? (_staticConfig_parentStaticConfig2 = staticConfig.parentStaticConfig) === null || _staticConfig_parentStaticConfig2 === void 0 ? void 0 : _staticConfig_parentStaticConfig2.contextProps : void 0;
+	var contextPropKeys = staticConfig.contextProps || inheritedContextPropKeys;
+	if (contextProps && key in contextProps || (contextPropKeys === null || contextPropKeys === void 0 ? void 0 : contextPropKeys.includes(key)) || (contextConfig === null || contextConfig === void 0 ? void 0 : (_contextConfig_propKeys = contextConfig.propKeys) === null || _contextConfig_propKeys === void 0 ? void 0 : _contextConfig_propKeys.includes(key))) {
+		var _styleState_originalContextPropValues;
+		var _styleState;
+		(_styleState = styleState).overriddenContextProps || (_styleState.overriddenContextProps = {});
+		var originalFromState = (_styleState_originalContextPropValues = styleState.originalContextPropValues) === null || _styleState_originalContextPropValues === void 0 ? void 0 : _styleState_originalContextPropValues[key];
+		var _ref;
+		styleState.overriddenContextProps[key] = (_ref = originalVal !== null && originalVal !== void 0 ? originalVal : originalFromState) !== null && _ref !== void 0 ? _ref : val;
+	}
+	if (key in import_helpers.stylePropsTransform) {
+		var _styleState1;
+		(_styleState1 = styleState).flatTransforms || (_styleState1.flatTransforms = {});
+		styleState.flatTransforms[key] = val;
+	} else {
+		var out = import_constants.isWeb && !disableNormalize && !styleProps.noNormalize ? (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(val, key) : val;
+		if (staticConfig.accept && key in staticConfig.accept) viewProps[key] = out;
+		else {
+			var _styleState2;
+			(_styleState2 = styleState).style || (_styleState2.style = {});
+			styleState.style[key] = key === "transform" && Array.isArray(out) ? [...out] : out;
+			if (shouldTrackStyleTokenProvenance) recordStyleTokenProvenance(styleState, key, originalVal);
+		}
+	}
+}
+function recordStyleTokenProvenance(styleState, key, originalVal) {
+	var _styleState_conf_themes;
+	var tokenName = typeof originalVal === "string" ? originalVal : "";
+	if (tokenName) {
+		var slash = tokenName.lastIndexOf("/");
+		var opacity = slash === -1 ? NaN : Number(tokenName.slice(slash + 1));
+		if (Number.isInteger(opacity) && opacity >= 0 && opacity <= 100) tokenName = tokenName.slice(0, slash);
+	}
+	if (tokenName !== "" && (Object.prototype.hasOwnProperty.call(styleState.theme, tokenName) || Object.prototype.hasOwnProperty.call(((_styleState_conf_themes = styleState.conf.themes) === null || _styleState_conf_themes === void 0 ? void 0 : _styleState_conf_themes[styleState.flatThemeName || ""]) || {}, tokenName) || Object.values(styleState.conf.tokensParsed).some(function(category) {
+		return Object.prototype.hasOwnProperty.call(category, tokenName);
+	}))) {
+		var _styleState;
+		((_styleState = styleState).tokenProvenance || (_styleState.tokenProvenance = {}))[key] = originalVal;
+	} else if (styleState.tokenProvenance && key in styleState.tokenProvenance) delete styleState.tokenProvenance[key];
+}
+var getSubStyle = function(styleState, _subKey, styleIn, avoidMergeTransform) {
+	var { staticConfig, conf, styleProps } = styleState;
+	var styleOut = {};
+	var originalValues;
+	var styleInOriginalValues = import_styleOriginalValues.styleOriginalValues.get(styleIn);
+	var parentProps = styleState.props;
+	styleState.props = Object.create(parentProps, Object.getOwnPropertyDescriptors(styleIn));
+	try {
+		var _loop = function(key1) {
+			var val = styleIn[key1];
+			key1 = conf.shorthands[key1] || key1;
+			if (!staticConfig.isHOC && key1 in import_skipProps.skipProps && !styleProps.noSkip) return key = key1, "continue";
+			(0, import_propMapper.propMapper)(key1, val, styleState, false, function(skey, sval, originalVal) {
+				var _styleInOriginalValues_skey;
+				var trackedOriginalVal = (_styleInOriginalValues_skey = styleInOriginalValues === null || styleInOriginalValues === void 0 ? void 0 : styleInOriginalValues[skey]) !== null && _styleInOriginalValues_skey !== void 0 ? _styleInOriginalValues_skey : originalVal;
+				if (trackedOriginalVal !== void 0) {
+					originalValues || (originalValues = {});
+					originalValues[skey] = trackedOriginalVal;
+				}
+				if (!avoidMergeTransform && skey in import_helpers.stylePropsTransform) mergeTransform(styleOut, skey, sval);
+				else styleOut[skey] = styleProps.noNormalize ? sval : (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(sval, key1);
+			});
+			key = key1;
+		};
+		for (var key in styleIn) _loop(key);
+	} finally {
+		styleState.props = parentProps;
+	}
+	if (!avoidMergeTransform) {
+		var _styleState_style;
+		var parentTransform = (_styleState_style = styleState.style) === null || _styleState_style === void 0 ? void 0 : _styleState_style.transform;
+		var flatTransforms = styleState.flatTransforms;
+		var styleOutTransform = styleOut.transform;
+		if (Array.isArray(styleOutTransform) && styleOutTransform.length) {
+			var len = styleOutTransform.length;
+			if (Array.isArray(parentTransform)) {
+				var merged = [];
+				outer: for (var i = 0; i < parentTransform.length; i++) {
+					var pt = parentTransform[i];
+					for (var pk in pt) {
+						for (var j = 0; j < len; j++) for (var sk in styleOutTransform[j]) {
+							if (pk === sk) continue outer;
+							break;
+						}
+						merged.push(pt);
+						break;
+					}
+				}
+				for (var i1 = 0; i1 < len; i1++) merged.push(styleOutTransform[i1]);
+				styleOut.transform = merged;
+			}
+			if (flatTransforms) outer: for (var fk in flatTransforms) {
+				var ck = fk === "x" ? "translateX" : fk === "y" ? "translateY" : fk;
+				for (var j1 = 0; j1 < len; j1++) for (var sk1 in styleOutTransform[j1]) {
+					if (ck === sk1) continue outer;
+					break;
+				}
+				mergeTransform(styleOut, fk, flatTransforms[fk]);
+			}
+		} else if (flatTransforms) mergeFlatTransforms(styleOut, flatTransforms);
+	}
+	if (!styleProps.noNormalize) (0, import_expandStyles.fixStyles)(styleOut);
+	if (originalValues) import_styleOriginalValues.styleOriginalValues.set(styleOut, originalValues);
+	return styleOut;
+};
+import_constants.isWeb && (import_react.default.useInsertionEffect || import_constants.useIsomorphicLayoutEffect);
+var useSplitStyles = function(a, b, c, d, e, f, g, h, i, j, k, l, m) {
+	"use no memo";
+	return getSplitStyles(a, b, c, d, e, f, g, h, i, j, k, l, m);
+};
+var mergeTransform = function(obj, key, val) {
+	var backwards = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+	var _obj;
+	if (typeof obj.transform === "string") return;
+	(_obj = obj).transform || (_obj.transform = []);
+	obj.transform[backwards ? "unshift" : "push"]({ [mapTransformKeys[key] || key]: val });
+};
+var mapTransformKeys = {
+	x: "translateX",
+	y: "translateY"
+};
+function passDownProp(viewProps, key, val) {
+	viewProps[key] = val;
+}
+function normalizeStyle(style) {
+	var out = {};
+	for (var key in style) {
+		var val = style[key];
+		if (key in import_helpers.stylePropsTransform) mergeTransform(out, key, val);
+		else out[key] = (0, import_normalizeValueWithProperty.normalizeValueWithProperty)(val, key);
+	}
+	if (import_constants.isWeb && Array.isArray(out.transform)) out.transform = (0, import_transformsToString.transformsToString)(out.transform);
+	(0, import_expandStyles.fixStyles)(out);
+	return out;
+}