@tamagui/web 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/helpers/variables.native.cjs

@@ -0,0 +1,873 @@
+"use strict";
+
+
+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: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var variables_exports = {};
+__export(variables_exports, {
+	getInlineValuesFromProps: () => getInlineValuesFromProps,
+	getInlineValuesKey: () => getInlineValuesKey,
+	getMergedInlineTheme: () => getMergedInlineTheme,
+	getThemeKeySet: () => getThemeKeySet,
+	getVariablesCSSRules: () => getVariablesCSSRules,
+	inlineLayerKey: () => inlineLayerKey,
+	isUnitlessVariableKey: () => isUnitlessVariableKey,
+	mergeConfigVariablesIntoTheme: () => mergeConfigVariablesIntoTheme,
+	resolveVariableValueToCSS: () => resolveVariableValueToCSS
+});
+module.exports = __toCommonJS(variables_exports);
+var import_helpers = require("@tamagui/helpers");
+var import_runtime = require("@tamagui/style-grammar/runtime");
+var import_config = require("../config.native.js");
+var import_createVariable = require("../createVariable.native.js");
+var import_directStyle = require("./directStyle.native.js");
+var import_warnOnce = require("./warnOnce.native.js");
+function _type_of(obj) {
+	"@swc/helpers - typeof";
+	return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var unitlessSuffixes = [
+	"opacity",
+	"scale",
+	"zindex",
+	"weight",
+	"flex",
+	"grow",
+	"shrink",
+	"ratio",
+	"elevation"
+];
+var isUnitlessVariableKey = function(key) {
+	var lower = key.toLowerCase();
+	return unitlessSuffixes.some(function(suffix) {
+		return lower.endsWith(suffix);
+	});
+};
+var tokenCategoryOrder = [
+	"color",
+	"space",
+	"size",
+	"radius",
+	"zIndex"
+];
+var themeKeySets = /* @__PURE__ */ new WeakMap();
+var getThemeKeySet = function(conf) {
+	var existing = themeKeySets.get(conf.themes);
+	if (existing) return existing;
+	var set = /* @__PURE__ */ new Set();
+	for (var themeName in conf.themes) {
+		for (var key in conf.themes[themeName]) {
+			set.add(key);
+		}
+	}
+	if (process.env.NODE_ENV === "development") {
+		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+		try {
+			for (var _iterator = set[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+				var key1 = _step.value;
+				if (import_helpers.reservedThemeProps[key1]) {
+					console.error(`[tamagui] theme key "${key1}" collides with a <Theme> prop, so it can never be set inline (<Theme ${key1}="...">). Rename it.`);
+				}
+			}
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion && _iterator.return != null) {
+					_iterator.return();
+				}
+			} finally {
+				if (_didIteratorError) {
+					throw _iteratorError;
+				}
+			}
+		}
+	}
+	themeKeySets.set(conf.themes, set);
+	return set;
+};
+var findToken = function(tokensParsed, name) {
+	var found;
+	var foundCategory;
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = tokenCategoryOrder[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var category = _step.value;
+			var _tokensParsed_category;
+			var token = (_tokensParsed_category = tokensParsed[category]) === null || _tokensParsed_category === void 0 ? void 0 : _tokensParsed_category[name];
+			if (!token) continue;
+			if (!found) {
+				found = token;
+				foundCategory = category;
+				if (process.env.NODE_ENV !== "development") break;
+			} else {
+				(0, import_warnOnce.warnOnce)(`ambiguous:${name}`, `Theme inline value: "${name}" exists in multiple token categories; using "${foundCategory}". Rename one of the colliding tokens.`);
+				break;
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return found;
+};
+var cssVariablePrefix = process.env.TAMAGUI_CSS_VARIABLE_PREFIX || "";
+var themeKeyVar = function(key) {
+	return `var(--${cssVariablePrefix}${(0, import_helpers.simpleHash)(key, 40)})`;
+};
+function resolveVariableValueToCSS(key, value, conf) {
+	if (typeof value === "number") {
+		return isUnitlessVariableKey(key) ? `${value}` : `${value}px`;
+	}
+	if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value && "needsPx" in value) {
+		return `${value.val}px`;
+	}
+	if (typeof value !== "string") {
+		return;
+	}
+	var name = value;
+	if (getThemeKeySet(conf).has(name)) {
+		return themeKeyVar(name);
+	}
+	var token = findToken(conf.tokensParsed, name);
+	if (token) {
+		return token.variable;
+	}
+	return value;
+}
+var resolveDeclarations = function(valuesIn, conf, skip) {
+	var out = [];
+	if (!valuesIn) return out;
+	var values = valuesIn;
+	var keySet = getThemeKeySet(conf);
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = Object.keys(values).sort()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var key = _step.value;
+			var value = values[key];
+			if (value == null) continue;
+			if (skip === null || skip === void 0 ? void 0 : skip.has(key)) continue;
+			if (!keySet.has(key)) {
+				(0, import_warnOnce.warnOnce)(`unknown:${key}`, `Theme inline value: "${key}" is not a theme key or config-declared variable (createTamagui({ variables })) \u2014 dropping. Native can't resolve undeclared keys, so declaring it keeps platforms in sync.`);
+				continue;
+			}
+			var cssValue = resolveVariableValueToCSS(key, value, conf);
+			if (cssValue !== void 0) {
+				out.push([key, cssValue]);
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return out;
+};
+var toDeclarationBlock = function(declarations) {
+	return declarations.map(function(param) {
+		var [key, value] = param;
+		return `--${cssVariablePrefix}${(0, import_helpers.simpleHash)(key, 40)}:${value};`;
+	}).join("");
+};
+var schemePrefix = /^(light|dark)_/;
+var getThemedBucketNames = function(themes) {
+	if (!themes) return [];
+	var names = [];
+	for (var name in themes) {
+		if (name !== "light" && name !== "dark" && themes[name]) {
+			names.push(name);
+		}
+	}
+	return names.sort();
+};
+var themeBucketNameSets = /* @__PURE__ */ new WeakMap();
+var getThemeBucketNames = function(conf) {
+	var set = themeBucketNameSets.get(conf.themes);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		for (var themeName in conf.themes) {
+			var parts = themeName.replace(schemePrefix, "").split("_");
+			for (var i = 1; i <= parts.length; i++) {
+				set.add(parts.slice(0, i).join("_"));
+			}
+		}
+		themeBucketNameSets.set(conf.themes, set);
+	}
+	return set;
+};
+var warnOnUnknownThemeBucket = function(name, conf) {
+	if (!getThemeBucketNames(conf).has(name)) {
+		(0, import_warnOnce.warnOnce)(`unknown-theme:${name}`, `Theme inline value: modifier "${name}:" doesn't match any theme name in your config, so it will never apply.`);
+	}
+};
+var getCycleDroppedKeys = function(props) {
+	var values = props.values;
+	var themes = props.themes;
+	var light = themes === null || themes === void 0 ? void 0 : themes.light;
+	var dark = themes === null || themes === void 0 ? void 0 : themes.dark;
+	var dropped = null;
+	var check = function(map) {
+		for (var key in map) {
+			var path = [];
+			var pathSet = /* @__PURE__ */ new Set();
+			var current = key;
+			while (true) {
+				if (pathSet.has(current)) {
+					dropped || (dropped = /* @__PURE__ */ new Set());
+					var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+					try {
+						for (var _iterator2 = path[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+							var k = _step2.value;
+							dropped.add(k);
+						}
+					} catch (err) {
+						_didIteratorError2 = true;
+						_iteratorError2 = err;
+					} finally {
+						try {
+							if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+								_iterator2.return();
+							}
+						} finally {
+							if (_didIteratorError2) {
+								throw _iteratorError2;
+							}
+						}
+					}
+					break;
+				}
+				path.push(current);
+				pathSet.add(current);
+				var value = map[current];
+				if (typeof value !== "string") break;
+				var next = value;
+				if (!(next in map)) break;
+				current = next;
+			}
+		}
+	};
+	var checkWithSchemes = function(base) {
+		check({
+			...base,
+			...light
+		});
+		check({
+			...base,
+			...dark
+		});
+	};
+	checkWithSchemes(values || {});
+	var bucketNames = getThemedBucketNames(props.themes);
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = bucketNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var name = _step.value;
+			var merged = { ...values };
+			var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+			try {
+				for (var _iterator1 = bucketNames[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+					var other = _step1.value;
+					if (other === name || name.startsWith(`${other}_`)) {
+						Object.assign(merged, themes[other]);
+					}
+				}
+			} catch (err) {
+				_didIteratorError1 = true;
+				_iteratorError1 = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+						_iterator1.return();
+					}
+				} finally {
+					if (_didIteratorError1) {
+						throw _iteratorError1;
+					}
+				}
+			}
+			checkWithSchemes(merged);
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	if (dropped && process.env.NODE_ENV === "development") {
+		var names = [...dropped];
+		(0, import_warnOnce.warnOnce)(`cycle:${names.join(",")}`, `Theme inline values: reference cycle involving "${names.join("\", \"")}". These keys cannot resolve on either platform and are dropped.`);
+	}
+	return dropped;
+};
+var rulesCache = /* @__PURE__ */ new Map();
+function getVariablesCSSRules(props, conf) {
+	var cycleDropped = getCycleDroppedKeys(props);
+	var themes = props.themes;
+	var base = resolveDeclarations(props.values, conf, cycleDropped);
+	var dark = resolveDeclarations(themes === null || themes === void 0 ? void 0 : themes.dark, conf, cycleDropped);
+	var light = resolveDeclarations(themes === null || themes === void 0 ? void 0 : themes.light, conf, cycleDropped);
+	var themed = [];
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = getThemedBucketNames(props.themes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var name = _step.value;
+			if (process.env.NODE_ENV === "development") {
+				warnOnUnknownThemeBucket(name, conf);
+			}
+			var declarations = resolveDeclarations(themes[name], conf, cycleDropped);
+			if (declarations.length) {
+				themed.push([name, declarations]);
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	if (!base.length && !dark.length && !light.length && !themed.length) {
+		return null;
+	}
+	var prefersColorThemes = !!(0, import_config.getSetting)("shouldAddPrefersColorThemes");
+	var payload = JSON.stringify([
+		base,
+		themed,
+		dark,
+		light,
+		prefersColorThemes
+	]);
+	var cached = rulesCache.get(payload);
+	if (cached) return cached;
+	var identifier = `tvar_${(0, import_helpers.simpleHash)(payload, "strict")}`;
+	var cls = `.${identifier}:not(#t_theme_full_name)`;
+	var rules = [];
+	if (base.length) {
+		rules.push(`:root ${cls} {${toDeclarationBlock(base)}}`);
+	}
+	var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+	try {
+		for (var _iterator1 = themed[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+			var [name1, declarations1] = _step1.value;
+			rules.push(`:root .t_${name1} ${cls}, :root.t_${name1} ${cls} {${toDeclarationBlock(declarations1)}}`);
+		}
+	} catch (err) {
+		_didIteratorError1 = true;
+		_iteratorError1 = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+				_iterator1.return();
+			}
+		} finally {
+			if (_didIteratorError1) {
+				throw _iteratorError1;
+			}
+		}
+	}
+	var schemeRule = function(scheme) {
+		var opposite = scheme === "dark" ? "light" : "dark";
+		var declarations2 = scheme === "light" ? light : dark;
+		return `:root .t_${scheme} ${cls}, :root.t_${scheme} ${cls}, :root .t_${opposite} .t_${scheme} ${cls}, :root.t_${opposite} .t_${scheme} ${cls} {${toDeclarationBlock(declarations2)}}`;
+	};
+	if (light.length) {
+		rules.push(schemeRule("light"));
+	}
+	if (dark.length) {
+		rules.push(schemeRule("dark"));
+	}
+	if (prefersColorThemes) {
+		if (light.length) {
+			rules.push(`@media (prefers-color-scheme:light){:root ${cls} {${toDeclarationBlock(light)}}}`);
+		}
+		if (dark.length) {
+			rules.push(`@media (prefers-color-scheme:dark){:root ${cls} {${toDeclarationBlock(dark)}}}`);
+		}
+	}
+	var result = {
+		identifier,
+		rules
+	};
+	if (rulesCache.size >= 1e4) {
+		rulesCache.clear();
+	}
+	rulesCache.set(payload, result);
+	return result;
+}
+var inlineLayerKey = "_tmgInlineLayer";
+var serializeInlineValue = function(value) {
+	return value && (typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" ? `object:px${value.val}` : `${typeof value === "undefined" ? "undefined" : _type_of(value)}:${String(value)}`;
+};
+var serializeBucket = function(bucket) {
+	if (!bucket) return "";
+	var map = bucket;
+	return Object.keys(map).sort().map(function(key) {
+		var value = serializeInlineValue(map[key]);
+		return `${key.length}:${key}${value.length}:${value}`;
+	}).join("");
+};
+var inlineKeys = /* @__PURE__ */ new WeakMap();
+var getInlineValuesKey = function(inline) {
+	var cached = inlineKeys.get(inline);
+	if (cached !== void 0) return cached;
+	var key = serializeBucket(inline.values);
+	if (inline.themes) {
+		var themes = inline.themes;
+		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+		try {
+			for (var _iterator = Object.keys(themes).sort()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+				var name = _step.value;
+				key += `;${name}=${serializeBucket(themes[name])}`;
+			}
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion && _iterator.return != null) {
+					_iterator.return();
+				}
+			} finally {
+				if (_didIteratorError) {
+					throw _iteratorError;
+				}
+			}
+		}
+	}
+	inlineKeys.set(inline, key);
+	return key;
+};
+var registryViews = /* @__PURE__ */ new WeakMap();
+var getModifierRegistry = function(conf) {
+	var view = registryViews.get(conf.themes);
+	if (!view) {
+		view = { get(name) {
+			if (import_runtime.grammarPlatformNames.has(name)) return "platform";
+			if ((0, import_runtime.isRootThemeName)(name) && getThemeBucketNames(conf).has(name)) return "theme";
+			return "state";
+		} };
+		registryViews.set(conf.themes, view);
+	}
+	return view;
+};
+var parsedInlineValues = /* @__PURE__ */ new WeakMap();
+var addFlatValue = function(out, key, raw, conf, onIssue) {
+	var report = function(once, message, dropped) {
+		var diagnosis = message.replace(/\.$/, "");
+		if (onIssue) onIssue({
+			key,
+			raw: String(raw),
+			message: diagnosis
+		});
+		else (0, import_warnOnce.warnOnce)(once, `${diagnosis}. ${dropped}`);
+	};
+	if (typeof raw !== "string") {
+		out.values[key] = raw;
+		return;
+	}
+	var configValues = parsedInlineValues.get(conf.themes);
+	if (!configValues) {
+		configValues = /* @__PURE__ */ new Map();
+		parsedInlineValues.set(conf.themes, configValues);
+	}
+	var parsed = configValues.get(raw);
+	if (!parsed) {
+		parsed = (0, import_runtime.parseValue)(raw, getModifierRegistry(conf));
+		if (configValues.size >= 1e4) {
+			configValues.clear();
+		}
+		configValues.set(raw, parsed);
+	}
+	if (!parsed.ok) {
+		report(`parse:${key}:${raw}`, `<Theme ${key}="${raw}">: ${parsed.errors[0].message}`, "Dropping.");
+		return;
+	}
+	var { base, clauses } = parsed.value;
+	if (base !== null) {
+		out.values[key] = base;
+	}
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = clauses[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var clause = _step.value;
+			var themeName = void 0;
+			var applies = true;
+			var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+			try {
+				for (var _iterator1 = clause.modifiers[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+					var modifier = _step1.value;
+					if (import_runtime.grammarPlatformNames.has(modifier)) {
+						applies && (applies = (0, import_directStyle.platformMatches)(modifier));
+						continue;
+					}
+					if ((0, import_runtime.isRootThemeName)(modifier) && getThemeBucketNames(conf).has(modifier)) {
+						if (themeName !== void 0) {
+							report(`two-themes:${key}:${raw}`, `<Theme ${key}="${raw}">: "${themeName}:${modifier}:" targets two themes at once, which a subtree value can't express. Name the composed theme instead.`, "Dropping the clause.");
+							applies = false;
+							break;
+						}
+						themeName = modifier;
+						continue;
+					}
+					report(`unsupported-modifier:${modifier}`, `<Theme ${key}="${raw}">: "${modifier}:" isn't supported here. Theme values apply to a whole subtree, so only theme (dark:) and platform (ios:) modifiers work.`, "Dropping the clause.");
+					applies = false;
+					break;
+				}
+			} catch (err) {
+				_didIteratorError1 = true;
+				_iteratorError1 = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+						_iterator1.return();
+					}
+				} finally {
+					if (_didIteratorError1) {
+						throw _iteratorError1;
+					}
+				}
+			}
+			if (!applies) continue;
+			if (themeName === void 0) {
+				out.values[key] = clause.payload;
+			} else {
+				var _out, _ref, _themeName;
+				;
+				((_ref = (_out = out).themes || (_out.themes = {}))[_themeName = themeName] || (_ref[_themeName] = {}))[key] = clause.payload;
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+};
+var flatLayers = /* @__PURE__ */ new WeakMap();
+function getInlineValuesFromProps(props, conf, onIssue) {
+	var hasKey = false;
+	var cacheKey = "";
+	for (var key in props) {
+		if (import_helpers.reservedThemeProps[key]) continue;
+		hasKey = true;
+		var value = props[key];
+		if (value == null) continue;
+		var serialized = serializeInlineValue(value);
+		cacheKey += `${key.length}:${key}${serialized.length}:${serialized}`;
+	}
+	if (!hasKey) return null;
+	var configLayers = flatLayers.get(conf.themes);
+	if (!configLayers) {
+		configLayers = /* @__PURE__ */ new Map();
+		flatLayers.set(conf.themes, configLayers);
+	}
+	var cached = onIssue ? void 0 : configLayers.get(cacheKey);
+	if (cached) return cached;
+	var out = {
+		values: {},
+		themes: null
+	};
+	for (var key1 in props) {
+		if (import_helpers.reservedThemeProps[key1]) continue;
+		var value1 = props[key1];
+		if (value1 == null) continue;
+		addFlatValue(out, key1, value1, conf, onIssue);
+	}
+	var layer = {
+		values: out.values,
+		themes: out.themes || void 0
+	};
+	if (!onIssue) {
+		if (configLayers.size >= 1e4) {
+			configLayers.clear();
+		}
+		configLayers.set(cacheKey, layer);
+	}
+	return layer;
+}
+var mergedThemeCache = /* @__PURE__ */ new WeakMap();
+function getMergedInlineTheme(parentTheme, inline, themeName, conf) {
+	var name = themeName || "light";
+	var activeScheme = name === "dark" || name.startsWith("dark_") ? "dark" : "light";
+	var bucketNames = getThemedBucketNames(inline.themes);
+	var matched;
+	if (bucketNames.length) {
+		var baseName = name.replace(schemePrefix, "");
+		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+		try {
+			for (var _iterator = bucketNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+				var bucketName = _step.value;
+				if (process.env.NODE_ENV === "development") {
+					warnOnUnknownThemeBucket(bucketName, conf);
+				}
+				if (baseName === bucketName || baseName.startsWith(`${bucketName}_`)) {
+					matched || (matched = []);
+					matched.push(bucketName);
+				}
+			}
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion && _iterator.return != null) {
+					_iterator.return();
+				}
+			} finally {
+				if (_didIteratorError) {
+					throw _iteratorError;
+				}
+			}
+		}
+	}
+	var cacheKey = `${getInlineValuesKey(inline)}|${activeScheme}|${matched ? matched.join(",") : ""}`;
+	var existingInfo = parentTheme[inlineLayerKey];
+	if ((existingInfo === null || existingInfo === void 0 ? void 0 : existingInfo.key) === cacheKey) {
+		return parentTheme;
+	}
+	var byKey = mergedThemeCache.get(parentTheme);
+	var cached = byKey === null || byKey === void 0 ? void 0 : byKey.get(cacheKey);
+	if (cached) return cached;
+	var values = inline.values || {};
+	var themes = inline.themes || {};
+	var light = themes.light || {};
+	var dark = themes.dark || {};
+	var base = { ...values };
+	if (matched) {
+		var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+		try {
+			for (var _iterator1 = matched[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+				var bucketName1 = _step1.value;
+				Object.assign(base, themes[bucketName1]);
+			}
+		} catch (err) {
+			_didIteratorError1 = true;
+			_iteratorError1 = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+					_iterator1.return();
+				}
+			} finally {
+				if (_didIteratorError1) {
+					throw _iteratorError1;
+				}
+			}
+		}
+	}
+	var effective = {
+		...base,
+		...activeScheme === "dark" ? dark : light
+	};
+	var opposite = {
+		...base,
+		...activeScheme === "dark" ? light : dark
+	};
+	var dropped = getCycleDroppedKeys(inline);
+	var keySet = getThemeKeySet(conf);
+	var resolveRaw = function(keyIn, map) {
+		var key2 = keyIn;
+		var value = map[key2];
+		while (typeof value === "string") {
+			var name2 = value;
+			if (name2 in map && !(dropped === null || dropped === void 0 ? void 0 : dropped.has(name2))) {
+				key2 = name2;
+				value = map[name2];
+				continue;
+			}
+			var themeValue = parentTheme[name2];
+			if (themeValue !== void 0) {
+				return (0, import_createVariable.isVariable)(themeValue) ? themeValue.val : themeValue;
+			}
+			var token = findToken(conf.tokensParsed, name2);
+			if (token) return token.val;
+			return value;
+		}
+		if (value && (typeof value === "undefined" ? "undefined" : _type_of(value)) === "object") {
+			return value.val;
+		}
+		return value;
+	};
+	var info = {
+		key: cacheKey,
+		overridden: new Set(existingInfo === null || existingInfo === void 0 ? void 0 : existingInfo.overridden),
+		pairs: { ...existingInfo === null || existingInfo === void 0 ? void 0 : existingInfo.pairs }
+	};
+	var merged = { ...parentTheme };
+	var didOverride = false;
+	var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+	try {
+		for (var _iterator2 = Object.keys(effective).sort()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+			var key = _step2.value;
+			if (dropped === null || dropped === void 0 ? void 0 : dropped.has(key)) continue;
+			if (effective[key] == null) continue;
+			if (!keySet.has(key)) {
+				(0, import_warnOnce.warnOnce)(`unknown:${key}`, `Theme inline value: "${key}" is not a theme key or config-declared variable (createTamagui({ variables })) \u2014 dropping. Native can't resolve undeclared keys, so declaring it keeps platforms in sync.`);
+				continue;
+			}
+			var raw = resolveRaw(key, effective);
+			if (raw === void 0) continue;
+			didOverride = true;
+			merged[key] = (0, import_createVariable.createVariable)({
+				key,
+				name: key,
+				val: raw
+			});
+			info.overridden.add(key);
+			delete info.pairs[key];
+			var activeLiteral = effective[key];
+			var oppositeLiteral = opposite[key];
+			var isLiteral = function(v) {
+				return typeof v === "string" && !(v in effective) && !(v in parentTheme) && !findToken(conf.tokensParsed, v) || typeof v === "number";
+			};
+			if (isLiteral(activeLiteral) && isLiteral(oppositeLiteral)) {
+				info.pairs[key] = {
+					light: activeScheme === "light" ? activeLiteral : oppositeLiteral,
+					dark: activeScheme === "dark" ? activeLiteral : oppositeLiteral
+				};
+			}
+		}
+	} catch (err) {
+		_didIteratorError2 = true;
+		_iteratorError2 = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+				_iterator2.return();
+			}
+		} finally {
+			if (_didIteratorError2) {
+				throw _iteratorError2;
+			}
+		}
+	}
+	if (!didOverride) {
+		return parentTheme;
+	}
+	Object.defineProperty(merged, inlineLayerKey, {
+		value: info,
+		enumerable: false
+	});
+	byKey || (byKey = /* @__PURE__ */ new Map());
+	mergedThemeCache.set(parentTheme, byKey);
+	if (byKey.size >= 1e4) {
+		byKey.clear();
+	}
+	byKey.set(cacheKey, merged);
+	return merged;
+}
+function mergeConfigVariablesIntoTheme(theme, themeName, variables, tokensParsed) {
+	var scheme = themeName.startsWith("dark") ? "dark" : "light";
+	var resolving = /* @__PURE__ */ new Set();
+	var resolveRawValue = function(key2, value) {
+		if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value !== null) {
+			if ((0, import_createVariable.isVariable)(value)) return value.val;
+			if ("needsPx" in value) return value;
+			if ("light" in value || "dark" in value) {
+				var _value_scheme;
+				return resolveRawValue(key2, (_value_scheme = value[scheme]) !== null && _value_scheme !== void 0 ? _value_scheme : value.light);
+			}
+			return;
+		}
+		if (typeof value === "string") {
+			var name = value;
+			if (name in variables && !(name in theme)) {
+				if (resolving.has(name)) {
+					(0, import_warnOnce.warnOnce)(`config-cycle:${name}`, `createTamagui variables: reference cycle at "${name}" \u2014 dropping.`);
+					return;
+				}
+				resolving.add(name);
+				var res = resolveRawValue(name, variables[name]);
+				resolving.delete(name);
+				return res;
+			}
+			var themeValue = theme[name];
+			if (themeValue !== void 0) {
+				return (0, import_createVariable.isVariable)(themeValue) ? themeValue.val : themeValue;
+			}
+			var token = findToken(tokensParsed, name);
+			return token ? token.val : value;
+		}
+		return value;
+	};
+	for (var key in variables) {
+		if (key in theme) continue;
+		var raw = resolveRawValue(key, variables[key]);
+		if (raw === void 0) continue;
+		var needsPx = typeof raw === "number" && !isUnitlessVariableKey(key);
+		if ((typeof raw === "undefined" ? "undefined" : _type_of(raw)) === "object" && raw !== null && "needsPx" in raw) {
+			needsPx = true;
+			raw = raw.val;
+		}
+		var variable = (0, import_createVariable.createVariable)({
+			key,
+			name: key,
+			val: raw
+		});
+		if (needsPx) {
+			variable.needsPx = true;
+		}
+		theme[key] = variable;
+	}
+}