@tamagui/style-grammar 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/dist/cjs/candidate.native.cjs

@@ -0,0 +1,821 @@
+"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 candidate_exports = {};
+__export(candidate_exports, {
+	classifyCandidate: () => classifyCandidate,
+	decodeArbitrary: () => decodeArbitrary,
+	encodeArbitrary: () => encodeArbitrary,
+	formatCandidate: () => formatCandidate,
+	hasTokenName: () => hasTokenName,
+	parseCandidate: () => parseCandidate
+});
+module.exports = __toCommonJS(candidate_exports);
+var import_registry = require("./registry.native.js");
+var import_modifierRegistry = require("./modifierRegistry.native.js");
+var import_resolvePayload = require("./resolvePayload.native.js");
+var import_safeAreaVariables = require("./safeAreaVariables.native.js");
+function _instanceof(left, right) {
+	if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+		return !!right[Symbol.hasInstance](left);
+	} else {
+		return left instanceof right;
+	}
+}
+var sizingConveniences = /* @__PURE__ */ new Set([
+	"full",
+	"auto",
+	"screen",
+	"min",
+	"max",
+	"fit"
+]);
+var fontGenerics = /* @__PURE__ */ new Set([
+	"sans",
+	"serif",
+	"mono"
+]);
+var numericPattern = /^\d+(?:\.\d+)?$/;
+var extraPrefixes = [
+	"border-x",
+	"border-y",
+	"rounded-t",
+	"rounded-r",
+	"rounded-b",
+	"rounded-l"
+];
+var negativeTokenProps = /* @__PURE__ */ new Set([
+	"margin",
+	"marginTop",
+	"marginRight",
+	"marginBottom",
+	"marginLeft",
+	"marginHorizontal",
+	"marginVertical",
+	"top",
+	"right",
+	"bottom",
+	"left",
+	"inset",
+	"x",
+	"y",
+	"letterSpacing"
+]);
+var borderWidthKeywords = /* @__PURE__ */ new Set([
+	"thin",
+	"medium",
+	"thick"
+]);
+var ambiguousCssKeywords = /* @__PURE__ */ new Set([
+	"auto",
+	"dashed",
+	"dotted",
+	"double",
+	"groove",
+	"hidden",
+	"inherit",
+	"initial",
+	"inset",
+	"none",
+	"outset",
+	"revert",
+	"revert-layer",
+	"ridge",
+	"solid",
+	"unset"
+]);
+var cssLengthUnits = "(?:px|em|rem|ex|ch|cap|ic|lh|rlh|vw|vh|vmin|vmax|svw|svh|svmin|svmax|lvw|lvh|lvmin|lvmax|dvw|dvh|dvmin|dvmax|cm|mm|q|in|pt|pc)";
+var cssLengthPattern = new RegExp(`^-?(?:\\d+|\\d*\\.\\d+)${cssLengthUnits}$`, "i");
+function hasName(names, name) {
+	if (!names) return false;
+	if (Array.isArray(names)) return names.includes(name);
+	if (_instanceof(names, Set)) return names.has(name);
+	return Object.prototype.hasOwnProperty.call(names, name);
+}
+function splitCandidate(candidate) {
+	var parts = [];
+	var current = "";
+	var bracketDepth = 0;
+	var escaped = false;
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = candidate[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var char = _step.value;
+			if (escaped) {
+				current += char;
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				current += char;
+				escaped = true;
+				continue;
+			}
+			if (char === "[") bracketDepth++;
+			if (char === "]") bracketDepth--;
+			if (char === ":" && bracketDepth === 0) {
+				parts.push(current);
+				current = "";
+			} else {
+				current += char;
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	if (!current || bracketDepth !== 0) return null;
+	return {
+		modifiers: parts,
+		base: current
+	};
+}
+var modifierRegistryCache = /* @__PURE__ */ new WeakMap();
+function getModifierRegistry(config) {
+	var registry = modifierRegistryCache.get(config);
+	if (!registry) {
+		registry = (0, import_modifierRegistry.createModifierRegistry)(config).registry;
+		modifierRegistryCache.set(config, registry);
+	}
+	return registry;
+}
+function modifierKind(modifier, config) {
+	var canonical = import_registry.modifierAliases[modifier] || modifier;
+	return getModifierRegistry(config).get(canonical) || null;
+}
+function modifiersAreKnown(modifiers, config) {
+	var seen = /* @__PURE__ */ new Set();
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = modifiers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var modifier = _step.value;
+			var kind = modifierKind(modifier, config);
+			if (!kind || seen.has(kind)) return false;
+			seen.add(kind);
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return true;
+}
+function hasTokenDomain(config, category) {
+	var _config_tokenNames;
+	return ((_config_tokenNames = config.tokenNames) === null || _config_tokenNames === void 0 ? void 0 : _config_tokenNames[category]) !== void 0;
+}
+function hasTokenName(config, category, name) {
+	var _config_tokenNames;
+	return hasName((_config_tokenNames = config.tokenNames) === null || _config_tokenNames === void 0 ? void 0 : _config_tokenNames[category], name);
+}
+function resolveEntries(prefix, config) {
+	var _config_shorthands;
+	var registered = import_registry.prefixToEntries[prefix];
+	if (registered) return registered;
+	if (prefix === "border-x" || prefix === "border-y") {
+		var props = prefix === "border-x" ? ["borderLeft", "borderRight"] : ["borderTop", "borderBottom"];
+		return import_registry.grammarEntries.filter(function(entry) {
+			return props.some(function(prop) {
+				return entry.prop === `${prop}Width` || entry.prop === `${prop}Color`;
+			});
+		});
+	}
+	if (prefix.startsWith("rounded-")) {
+		var props1 = import_registry.radiusCornerProps[prefix.slice("rounded-".length)];
+		return props1 ? import_registry.grammarEntries.filter(function(entry) {
+			return props1.includes(entry.prop);
+		}) : [];
+	}
+	var expanded = (_config_shorthands = config.shorthands) === null || _config_shorthands === void 0 ? void 0 : _config_shorthands[prefix];
+	if (!expanded) return [];
+	return import_registry.grammarEntries.filter(function(entry) {
+		return entry.prop === expanded;
+	});
+}
+function findPrefix(base, config) {
+	var prefixes = new Set(Object.keys(import_registry.prefixToEntries));
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = extraPrefixes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var prefix = _step.value;
+			prefixes.add(prefix);
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	for (var shorthand in config.shorthands) prefixes.add(shorthand);
+	var found = null;
+	var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+	try {
+		for (var _iterator1 = prefixes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+			var prefix1 = _step1.value;
+			if (base.startsWith(`${prefix1}-`) && (!found || prefix1.length > found.length)) {
+				found = prefix1;
+			}
+		}
+	} catch (err) {
+		_didIteratorError1 = true;
+		_iteratorError1 = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+				_iterator1.return();
+			}
+		} finally {
+			if (_didIteratorError1) {
+				throw _iteratorError1;
+			}
+		}
+	}
+	return found;
+}
+function arbitraryInner(rawValue) {
+	if (rawValue.length <= 2 || rawValue[0] !== "[" || rawValue.at(-1) !== "]") {
+		return null;
+	}
+	var inner = rawValue.slice(1, -1);
+	return arbitraryValueIsBalanced(decodeArbitrary(inner)) ? inner : null;
+}
+function arbitraryValueIsBalanced(value) {
+	var opening = /* @__PURE__ */ new Set([
+		"(",
+		"[",
+		"{"
+	]);
+	var matching = {
+		")": "(",
+		"]": "[",
+		"}": "{"
+	};
+	var stack = [];
+	var quote = "";
+	var escaped = false;
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = value[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var char = _step.value;
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (quote) {
+				if (char === quote) quote = "";
+				continue;
+			}
+			if (char === "\"" || char === "'") {
+				quote = char;
+				continue;
+			}
+			if (opening.has(char)) {
+				stack.push(char);
+				continue;
+			}
+			var expected = matching[char];
+			if (expected && stack.pop() !== expected) return false;
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return !escaped && !quote && stack.length === 0;
+}
+function fractionIsValid(value) {
+	var fraction = /^(\d+)\/(\d+)$/.exec(value);
+	return !!fraction && Number(fraction[2]) !== 0;
+}
+function arbitraryBorderKind(value) {
+	if (/^-?(?:\d+|\d*\.\d+)$/.test(value)) return "width";
+	if (cssLengthPattern.test(value) || borderWidthKeywords.has(value)) return "width";
+	if (/^(?:calc|min|max|clamp)\(/.test(value)) return "width";
+	if (ambiguousCssKeywords.has(value) || value.startsWith("var(")) return null;
+	if (value.startsWith("#") || /^(?:rgb|hsl|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark)\(/.test(value) || /^[a-zA-Z][a-zA-Z0-9-]*$/.test(value)) {
+		return "color";
+	}
+	return null;
+}
+function tokenLookupName(category, value) {
+	if (category !== "color") return value;
+	var suffix = (0, import_resolvePayload.splitColorOpacitySuffix)(value);
+	return suffix.kind === "none" ? value : suffix.name;
+}
+function chooseEntry(entries, prefix, rawValue, negative, config) {
+	if ((0, import_safeAreaVariables.getSafeAreaEdge)(rawValue)) {
+		var entry = entries.find(function(param) {
+			var { tokenCategory } = param;
+			return tokenCategory === "space" || tokenCategory === "size" || tokenCategory === "radius" || tokenCategory === "fontSize" || tokenCategory === "lineHeight" || tokenCategory === "letterSpacing";
+		});
+		if (entry) {
+			return {
+				entry,
+				valueKind: "convenience",
+				convenience: "safe-area"
+			};
+		}
+	}
+	var arbitrary = arbitraryInner(rawValue);
+	if (arbitrary !== null) {
+		if (!arbitrary) return null;
+		if (prefix.startsWith("border")) {
+			var width = entries.find(function(entry2) {
+				return entry2.prop.endsWith("Width");
+			});
+			var color = entries.find(function(entry2) {
+				return entry2.prop.endsWith("Color");
+			});
+			var kind = arbitraryBorderKind(decodeArbitrary(arbitrary));
+			if (!kind || !width || !color) return null;
+			return {
+				entry: kind === "width" ? width : color,
+				valueKind: "arbitrary"
+			};
+		}
+		if (prefix === "text") {
+			return {
+				entry: entries.find(function(entry2) {
+					return entry2.prop === "fontSize";
+				}),
+				valueKind: "arbitrary"
+			};
+		}
+		if (prefix === "font") {
+			return {
+				entry: entries.find(function(entry2) {
+					return entry2.prop === "fontFamily";
+				}),
+				valueKind: "arbitrary"
+			};
+		}
+		return {
+			entry: entries[0],
+			valueKind: "arbitrary"
+		};
+	}
+	if (prefix === "text") {
+		var fontSize = entries.find(function(entry2) {
+			return entry2.prop === "fontSize";
+		});
+		if (fontSize && hasTokenName(config, "fontSize", rawValue)) {
+			return {
+				entry: fontSize,
+				valueKind: "token"
+			};
+		}
+		if (import_registry.textAlignKeywords.has(rawValue)) {
+			return {
+				entry: entries.find(function(entry2) {
+					return entry2.prop === "textAlign";
+				}),
+				valueKind: "enum"
+			};
+		}
+		return null;
+	}
+	if (prefix === "font") {
+		var fontFamily = entries.find(function(entry2) {
+			return entry2.prop === "fontFamily";
+		});
+		var fontWeight = entries.find(function(entry2) {
+			return entry2.prop === "fontWeight";
+		});
+		if (!fontFamily) return null;
+		var matchesFamily = hasTokenName(config, "fontFamily", rawValue);
+		var matchesWeight = fontWeight && hasTokenName(config, "fontWeight", rawValue);
+		if (matchesFamily && matchesWeight) return null;
+		if (matchesFamily) {
+			return {
+				entry: fontFamily,
+				valueKind: "token"
+			};
+		}
+		if (matchesWeight) {
+			return {
+				entry: fontWeight,
+				valueKind: "token"
+			};
+		}
+		return fontGenerics.has(rawValue) ? {
+			entry: fontFamily,
+			valueKind: "convenience",
+			convenience: "font-generic"
+		} : null;
+	}
+	if (prefix.startsWith("border")) {
+		var width1 = entries.find(function(entry2) {
+			return entry2.prop.endsWith("Width");
+		});
+		var color1 = entries.find(function(entry2) {
+			return entry2.prop.endsWith("Color");
+		});
+		var token = negative ? `-${rawValue}` : rawValue;
+		var matchesWidth = width1 && hasTokenName(config, "space", token);
+		var colorName = tokenLookupName("color", rawValue);
+		var matchesColor = color1 && hasTokenName(config, "color", colorName);
+		if (matchesWidth && matchesColor) return null;
+		if (matchesWidth) {
+			return {
+				entry: width1,
+				valueKind: "token"
+			};
+		}
+		if (matchesColor) {
+			return {
+				entry: color1,
+				valueKind: "token"
+			};
+		}
+		return null;
+	}
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var entry1 = _step.value;
+			if (entry1.tokenCategory) {
+				var name = negative ? `-${rawValue}` : rawValue;
+				var tokenName = tokenLookupName(entry1.tokenCategory, name);
+				if (hasTokenName(config, entry1.tokenCategory, tokenName)) {
+					return {
+						entry: entry1,
+						valueKind: "token"
+					};
+				}
+				if (entry1.tokenCategory === "size" && (sizingConveniences.has(rawValue) || fractionIsValid(rawValue))) {
+					return {
+						entry: entry1,
+						valueKind: "convenience",
+						convenience: "sizing-keyword"
+					};
+				}
+				if (entry1.tokenCategory === "zIndex" && numericPattern.test(rawValue)) {
+					return {
+						entry: entry1,
+						valueKind: "convenience",
+						convenience: "integer"
+					};
+				}
+				continue;
+			}
+			if (prefix === "opacity" || prefix === "scale") {
+				if (numericPattern.test(rawValue)) {
+					return {
+						entry: entry1,
+						valueKind: "convenience",
+						convenience: "percentage"
+					};
+				}
+				continue;
+			}
+			if (entry1.prop === "zIndex" && numericPattern.test(rawValue)) {
+				return {
+					entry: entry1,
+					valueKind: "convenience",
+					convenience: "integer"
+				};
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return null;
+}
+function parseCandidate(candidate, config) {
+	var split = splitCandidate(candidate);
+	if (!split || !modifiersAreKnown(split.modifiers, config)) {
+		return null;
+	}
+	var modifiers = split.modifiers.map(function(modifier) {
+		return import_registry.modifierAliases[modifier] || modifier;
+	});
+	var negative = split.base[0] === "-";
+	var core = negative ? split.base.slice(1) : split.base;
+	var prefix = findPrefix(core, config);
+	var dynamic;
+	if (prefix) {
+		var rawValue = core.slice(prefix.length + 1);
+		if (rawValue) {
+			var entries = resolveEntries(prefix, config);
+			var selected = chooseEntry(entries, prefix, rawValue, negative, config);
+			if (selected && (!negative || selected.valueKind === "token" && negativeTokenProps.has(selected.entry.prop))) {
+				dynamic = {
+					prefix,
+					rawValue,
+					selected
+				};
+				if (selected.valueKind === "token") {
+					return {
+						candidate,
+						base: split.base,
+						modifiers,
+						negative,
+						kind: "dynamic",
+						prefix,
+						rawValue,
+						arbitrary: arbitraryInner(rawValue) !== null,
+						entry: selected.entry,
+						valueKind: selected.valueKind,
+						convenience: selected.convenience
+					};
+				}
+			}
+		}
+	}
+	var direct = import_registry.wholeClassUtilities[split.base];
+	if (!negative && direct) {
+		var convenience = import_registry.wholeClassConveniences[split.base];
+		return {
+			candidate,
+			base: split.base,
+			modifiers,
+			kind: "utility",
+			valueKind: convenience ? "convenience" : "enum",
+			properties: direct,
+			convenience,
+			negative: false
+		};
+	}
+	if (dynamic) {
+		return {
+			candidate,
+			base: split.base,
+			modifiers,
+			negative,
+			kind: "dynamic",
+			prefix: dynamic.prefix,
+			rawValue: dynamic.rawValue,
+			arbitrary: arbitraryInner(dynamic.rawValue) !== null,
+			entry: dynamic.selected.entry,
+			valueKind: dynamic.selected.valueKind,
+			convenience: dynamic.selected.convenience
+		};
+	}
+	return null;
+}
+function classifyCandidate(candidate, config) {
+	var parsed = parseCandidate(candidate, config);
+	return parsed ? {
+		kind: "tamagui",
+		parsed
+	} : {
+		kind: "passthrough",
+		reason: "not in the configured Tamagui grammar"
+	};
+}
+function tokenValidationConfig(entry, value, config) {
+	var tokenNames = { ...config === null || config === void 0 ? void 0 : config.tokenNames };
+	var category = entry.tokenCategory;
+	if (tokenNames[category] === void 0) {
+		tokenNames[category] = [tokenLookupName(category, value)];
+	}
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = (import_registry.prefixToEntries[entry.prefix] || [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var other = _step.value;
+			if (other.tokenCategory && tokenNames[other.tokenCategory] === void 0) {
+				tokenNames[other.tokenCategory] = [];
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return {
+		...config,
+		tokenNames
+	};
+}
+function formatCandidate(param, config) {
+	var { prop, value, valueKind, modifiers = [] } = param;
+	var _parsed_entry;
+	var entry = import_registry.grammarEntries.find(function(candidate3) {
+		return candidate3.prop === prop;
+	});
+	if (!entry) return null;
+	if (valueKind === "arbitrary" && value === "") return null;
+	if (!modifiersAreKnown(modifiers, config || {})) return null;
+	var normalizedModifiers = modifiers.map(function(modifier) {
+		return import_registry.modifierAliases[modifier] || modifier;
+	});
+	if (valueKind === "enum") {
+		var _standaloneValueProps_prop;
+		var whole = (_standaloneValueProps_prop = import_registry.standaloneValueProps[prop]) === null || _standaloneValueProps_prop === void 0 ? void 0 : _standaloneValueProps_prop[value];
+		if (whole) {
+			var candidate = normalizedModifiers.length ? `${normalizedModifiers.join(":")}:${whole}` : whole;
+			if (config) {
+				var parsed = parseCandidate(candidate, config);
+				if (!(parsed === null || parsed === void 0 ? void 0 : parsed.properties) || parsed.properties[prop] !== value) return null;
+			}
+			return candidate;
+		}
+		if (prop === "fontWeight") {
+			var _wholeClassUtilities_core;
+			var name = import_registry.fontWeightNames[value];
+			if (!name) return null;
+			var core = `font-${name}`;
+			if (String((_wholeClassUtilities_core = import_registry.wholeClassUtilities[core]) === null || _wholeClassUtilities_core === void 0 ? void 0 : _wholeClassUtilities_core.fontWeight) !== value) return null;
+			var candidate1 = normalizedModifiers.length ? `${normalizedModifiers.join(":")}:${core}` : core;
+			if (config) {
+				var parsed1 = parseCandidate(candidate1, config);
+				if (!(parsed1 === null || parsed1 === void 0 ? void 0 : parsed1.properties) || String(parsed1.properties.fontWeight) !== value) {
+					return null;
+				}
+			}
+			return candidate1;
+		}
+	}
+	if (!entry.prefix) return null;
+	if (valueKind === "token") {
+		if (!entry.tokenCategory) return null;
+		var sourceDomainKnown = !!config && hasTokenDomain(config, entry.tokenCategory);
+		var lookupName = tokenLookupName(entry.tokenCategory, value);
+		if (sourceDomainKnown && !hasTokenName(config, entry.tokenCategory, lookupName)) return null;
+		var colliding = import_registry.prefixToEntries[entry.prefix].filter(function(other2) {
+			return other2.prop !== prop && other2.tokenCategory;
+		});
+		if (colliding.length) {
+			if (!config || !sourceDomainKnown) return null;
+			var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+			try {
+				for (var _iterator = colliding[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+					var other = _step.value;
+					if (!hasTokenDomain(config, other.tokenCategory)) return null;
+					if (hasTokenName(config, other.tokenCategory, value)) return null;
+				}
+			} catch (err) {
+				_didIteratorError = true;
+				_iteratorError = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion && _iterator.return != null) {
+						_iterator.return();
+					}
+				} finally {
+					if (_didIteratorError) {
+						throw _iteratorError;
+					}
+				}
+			}
+		}
+	}
+	var formattedValue = valueKind === "arbitrary" ? `[${encodeArbitrary(value)}]` : value;
+	var core1 = formattedValue[0] === "-" && formattedValue[1] !== "[" ? `-${entry.prefix}-${formattedValue.slice(1)}` : formattedValue ? `${entry.prefix}-${formattedValue}` : entry.prefix;
+	var candidate2 = normalizedModifiers.length ? `${normalizedModifiers.join(":")}:${core1}` : core1;
+	var whole1 = import_registry.wholeClassUtilities[core1];
+	if (whole1) {
+		if (valueKind === "token") {
+			if (!config || !hasTokenDomain(config, entry.tokenCategory)) return null;
+		} else if (config) {
+			var _parsed_entry1;
+			var parsed2 = parseCandidate(candidate2, config);
+			if ((parsed2 === null || parsed2 === void 0 ? void 0 : parsed2.kind) === "utility") {
+				var _parsed_properties;
+				return Object.prototype.hasOwnProperty.call(parsed2.properties, prop) && String((_parsed_properties = parsed2.properties) === null || _parsed_properties === void 0 ? void 0 : _parsed_properties[prop]) === value ? candidate2 : null;
+			}
+			return (parsed2 === null || parsed2 === void 0 ? void 0 : (_parsed_entry1 = parsed2.entry) === null || _parsed_entry1 === void 0 ? void 0 : _parsed_entry1.prop) === prop && parsed2.valueKind === valueKind ? candidate2 : null;
+		} else if (Object.prototype.hasOwnProperty.call(whole1, prop) && String(whole1[prop]) === value) {
+			return candidate2;
+		} else {
+			return null;
+		}
+	}
+	if (valueKind === "token") {
+		var _parsed_entry2;
+		if (!hasTokenDomain(config || {}, entry.tokenCategory) && parseCandidate(candidate2, config || {})) {
+			return null;
+		}
+		var parsed3 = parseCandidate(candidate2, tokenValidationConfig(entry, value, config));
+		var parsedValue = (parsed3 === null || parsed3 === void 0 ? void 0 : parsed3.rawValue) ? `${parsed3.negative ? "-" : ""}${parsed3.rawValue}` : null;
+		if ((parsed3 === null || parsed3 === void 0 ? void 0 : parsed3.kind) !== "dynamic" || ((_parsed_entry2 = parsed3.entry) === null || _parsed_entry2 === void 0 ? void 0 : _parsed_entry2.prop) !== prop || parsed3.valueKind !== "token" || parsedValue !== value) {
+			return null;
+		}
+		return candidate2;
+	}
+	var parsed4 = parseCandidate(candidate2, config || {});
+	if (!parsed4 || ((_parsed_entry = parsed4.entry) === null || _parsed_entry === void 0 ? void 0 : _parsed_entry.prop) !== prop || parsed4.valueKind !== valueKind) return null;
+	return candidate2;
+}
+function encodeArbitrary(value) {
+	var encoded = "";
+	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+	try {
+		for (var _iterator = value[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+			var char = _step.value;
+			if (char === "\\" || char === "_" || char === "[" || char === "]") {
+				encoded += `\\${char}`;
+			} else if (/\s/.test(char)) {
+				encoded += "_";
+			} else {
+				encoded += char;
+			}
+		}
+	} catch (err) {
+		_didIteratorError = true;
+		_iteratorError = err;
+	} finally {
+		try {
+			if (!_iteratorNormalCompletion && _iterator.return != null) {
+				_iterator.return();
+			}
+		} finally {
+			if (_didIteratorError) {
+				throw _iteratorError;
+			}
+		}
+	}
+	return encoded;
+}
+function decodeArbitrary(value) {
+	var decoded = "";
+	for (var index = 0; index < value.length; index++) {
+		var char = value[index];
+		if (char === "\\" && index + 1 < value.length) {
+			decoded += value[++index];
+		} else {
+			decoded += char === "_" ? " " : char;
+		}
+	}
+	return decoded;
+}