@bamboocss/shared 1.11.2 → 1.11.4

package/dist/index.cjs

@@ -1,6 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_uniq = require("./uniq-xizdZz1Z.cjs");
-const require_astish = require("./astish.cjs");
 //#region src/arbitrary-value.ts
 const getArbitraryValue = (_value) => {
 	if (!_value || typeof _value !== "string") return _value;
@@ -18,12 +16,39 @@ const getArbitraryValue = (_value) => {
 	return value;
 };
 //#endregion
+//#region src/assert.ts
+const isString = (v) => typeof v === "string";
+const isBoolean = (v) => typeof v === "boolean";
+const isFunction = (v) => typeof v === "function";
+function isObject(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+const isSymbol = (v) => typeof v === "symbol";
+const isObjectOrArray = (obj) => typeof obj === "object" && obj !== null;
+//#endregion
 //#region src/assign.ts
 function assign(target, ...sources) {
 	for (const source of sources) for (const key in source) if (!target?.hasOwnProperty?.(key)) target[key] = source[key];
 	return target;
 }
 //#endregion
+//#region src/astish.ts
+const newRule = /(?:([\u0080-\uFFFF\w-%@]+) *:? *([^{;]+?);|([^;}{]*?) *{)|(}\s*)/g;
+const ruleClean = /\/\*[^]*?\*\/|  +/g;
+const ruleNewline = /\n+/g;
+const empty = " ";
+const astish = (val, tree = [{}]) => {
+	if (!val) return tree[0];
+	let block, left;
+	while (block = newRule.exec(val.replace(ruleClean, ""))) if (block[4]) tree.shift();
+	else if (block[3]) {
+		left = block[3].replace(ruleNewline, empty).trim();
+		if (!left.includes("&") && !left.startsWith("@")) left = "& " + left;
+		tree.unshift(tree[0][left] = tree[0][left] || {});
+	} else tree[0][block[1]] = block[2].replace(ruleNewline, empty).trim();
+	return tree[0];
+};
+//#endregion
 //#region src/cache-map.ts
 var CacheMap = class {
 	cache;
@@ -112,7 +137,7 @@ var CacheMap = class {
 //#endregion
 //#region src/calc.ts
 function isCssVar$1(value) {
-	return require_uniq.isObject(value) && "ref" in value;
+	return isObject(value) && "ref" in value;
 }
 function getRef(operand) {
 	return isCssVar$1(operand) ? operand.ref : operand.toString();
@@ -126,10 +151,23 @@ const calc = { negate(x) {
 	return multiply(value, -1);
 } };
 //#endregion
+//#region src/memo.ts
+const memo = (fn) => {
+	const cache = /* @__PURE__ */ new Map();
+	const get = (...args) => {
+		const key = JSON.stringify(args);
+		if (cache.has(key)) return cache.get(key);
+		const result = fn(...args);
+		cache.set(key, result);
+		return result;
+	};
+	return get;
+};
+//#endregion
 //#region src/camelcase-property.ts
 const regex = /-(\w|$)/g;
 const callback = (_dashChar, char) => char.toUpperCase();
-const camelCaseProperty = require_uniq.memo((property) => {
+const camelCaseProperty = memo((property) => {
 	if (property.startsWith("--")) return property;
 	let str = property.toLowerCase();
 	str = str.startsWith("-ms-") ? str.substring(1) : str;
@@ -142,6 +180,205 @@ const camelCaseRegex = /([a-z])([A-Z])/g;
 const dashCase = (s) => s.replace(camelCaseRegex, "$1-$2").toLowerCase();
 const uncapitalize = (s) => s.charAt(0).toLowerCase() + s.slice(1);
 //#endregion
+//#region src/compact.ts
+function compact(value) {
+	return Object.fromEntries(Object.entries(value ?? {}).filter(([_, value]) => value !== void 0));
+}
+//#endregion
+//#region src/condition.ts
+const isBaseCondition = (v) => v === "base";
+function filterBaseConditions(c) {
+	return c.slice().filter((v) => !isBaseCondition(v));
+}
+//#endregion
+//#region src/hash.ts
+function toChar(code) {
+	return String.fromCharCode(code + (code > 25 ? 39 : 97));
+}
+function toName(code) {
+	let name = "";
+	let x;
+	for (x = Math.abs(code); x > 52; x = x / 52 | 0) name = toChar(x % 52) + name;
+	return toChar(x % 52) + name;
+}
+function toPhash(h, x) {
+	let i = x.length;
+	while (i) h = h * 33 ^ x.charCodeAt(--i);
+	return h;
+}
+function toHash(value) {
+	return toName(toPhash(5381, value) >>> 0);
+}
+//#endregion
+//#region src/important.ts
+const importantRegex = /\s*!(important)?/i;
+function isImportant(value) {
+	return typeof value === "string" ? importantRegex.test(value) : false;
+}
+function withoutImportant(value) {
+	return typeof value === "string" ? value.replace(importantRegex, "").trim() : value;
+}
+function withoutSpace(str) {
+	return typeof str === "string" ? str.replaceAll(" ", "_") : str;
+}
+function markImportant(obj) {
+	if (typeof obj !== "object" || obj === null) return obj;
+	const result = Array.isArray(obj) ? [] : {};
+	const stack = [{
+		obj,
+		result
+	}];
+	while (stack.length > 0) {
+		const { obj, result } = stack.pop();
+		for (const [key, value] of Object.entries(obj)) if (typeof value === "string" || typeof value === "number") result[key] = `${value} !important`;
+		else if (typeof value === "object" && value !== null) {
+			const next = Array.isArray(value) ? [] : {};
+			result[key] = next;
+			stack.push({
+				obj: value,
+				result: next
+			});
+		} else result[key] = value;
+	}
+	return result;
+}
+//#endregion
+//#region src/merge-props.ts
+const MERGE_OMIT$2 = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function mergeProps(...sources) {
+	return sources.reduce((prev, obj) => {
+		if (!obj) return prev;
+		Object.keys(obj).forEach((key) => {
+			if (MERGE_OMIT$2.has(key)) return;
+			const prevValue = prev[key];
+			const value = obj[key];
+			if (isObject(prevValue) && isObject(value)) prev[key] = mergeProps(prevValue, value);
+			else prev[key] = value;
+		});
+		return prev;
+	}, {});
+}
+//#endregion
+//#region src/walk-object.ts
+const isNotNullish = (element) => element != null;
+function walkObject(target, predicate, options = {}) {
+	const { stop, getKey } = options;
+	function inner(value, path = []) {
+		if (isObjectOrArray(value)) {
+			const result = {};
+			for (const [prop, child] of Object.entries(value)) {
+				const key = getKey?.(prop, child) ?? prop;
+				const childPath = [...path, key];
+				if (stop?.(value, childPath)) return predicate(value, path);
+				const next = inner(child, childPath);
+				if (isNotNullish(next)) result[key] = next;
+			}
+			return result;
+		}
+		return predicate(value, path);
+	}
+	return inner(target);
+}
+function mapObject(obj, fn) {
+	if (Array.isArray(obj)) return obj.map((value) => fn(value));
+	if (!isObject(obj)) return fn(obj);
+	return walkObject(obj, (value) => fn(value));
+}
+//#endregion
+//#region src/normalize-style-object.ts
+function toResponsiveObject(values, breakpoints) {
+	return values.reduce((acc, current, index) => {
+		const key = breakpoints[index];
+		if (current != null) acc[key] = current;
+		return acc;
+	}, {});
+}
+function normalizeStyleObject(styles, context, shorthand = true) {
+	const { utility, conditions } = context;
+	const { hasShorthand, resolveShorthand } = utility;
+	return walkObject(styles, (value) => {
+		return Array.isArray(value) ? toResponsiveObject(value, conditions.breakpoints.keys) : value;
+	}, {
+		stop: (value) => Array.isArray(value),
+		getKey: shorthand ? (prop) => hasShorthand ? resolveShorthand(prop) : prop : void 0
+	});
+}
+//#endregion
+//#region src/classname.ts
+const fallbackCondition = {
+	shift: (v) => v,
+	finalize: (v) => v,
+	breakpoints: { keys: [] }
+};
+const sanitize = (value) => typeof value === "string" ? value.replaceAll(/[\n\s]+/g, " ") : value;
+const ENTRY_SEP = "]___[";
+const COND_SEP = "<___>";
+function createCss(context) {
+	const { utility, hash, grouped, conditions: conds = fallbackCondition } = context;
+	const formatClassName = (str) => [utility.prefix, str].filter(Boolean).join("-");
+	const hashFn = (conditions, className) => {
+		let result;
+		if (hash) {
+			const baseArray = [...conds.finalize(conditions), className];
+			result = formatClassName(utility.toHash(baseArray, toHash));
+		} else result = [...conds.finalize(conditions), formatClassName(className)].join(":");
+		return result;
+	};
+	if (grouped) return memo(({ base, ...styles } = {}) => {
+		const normalizedObject = normalizeStyleObject(Object.assign(styles, base), context);
+		const hashes = [];
+		walkObject(normalizedObject, (value, paths) => {
+			if (value == null) return;
+			const [prop, ...allConditions] = conds.shift(paths);
+			const conditions = filterBaseConditions(allConditions);
+			const parts = [`${prop}${ENTRY_SEP}value:${value}`];
+			if (conditions.length) parts.push(`cond:${conditions.join(COND_SEP)}`);
+			hashes.push(parts.join(ENTRY_SEP));
+		});
+		if (hashes.length === 0) return "";
+		hashes.sort();
+		const groupId = hashes.join("|");
+		return formatClassName(utility.toHash(["grouped", groupId], toHash));
+	});
+	return memo(({ base, ...styles } = {}) => {
+		const normalizedObject = normalizeStyleObject(Object.assign(styles, base), context);
+		const classNames = /* @__PURE__ */ new Set();
+		walkObject(normalizedObject, (value, paths) => {
+			if (value == null) return;
+			const important = isImportant(value);
+			const [prop, ...allConditions] = conds.shift(paths);
+			let className = hashFn(filterBaseConditions(allConditions), utility.transform(prop, withoutImportant(sanitize(value))).className);
+			if (important) className = `${className}!`;
+			classNames.add(className);
+		});
+		return Array.from(classNames).join(" ");
+	});
+}
+function compactStyles(...styles) {
+	return styles.flat().filter((style) => isObject(style) && Object.keys(compact(style)).length > 0);
+}
+function createMergeCss(context) {
+	function resolve(styles) {
+		const allStyles = compactStyles(...styles);
+		if (allStyles.length === 1) return allStyles;
+		return allStyles.map((style) => normalizeStyleObject(style, context));
+	}
+	function mergeCss(...styles) {
+		return mergeProps(...resolve(styles));
+	}
+	function assignCss(...styles) {
+		return Object.assign({}, ...resolve(styles));
+	}
+	return {
+		mergeCss: memo(mergeCss),
+		assignCss
+	};
+}
+//#endregion
 //#region src/css-var.ts
 const escRegex = /[^a-zA-Z0-9_\u0081-\uffff-]/g;
 function esc$1(string) {
@@ -156,7 +393,7 @@ function cssVar(name, options = {}) {
 	const variable = hash ? [
 		"-",
 		prefix,
-		require_uniq.toHash(name)
+		toHash(name)
 	].filter(Boolean).join("-") : dashCase$1([
 		"-",
 		prefix,
@@ -170,13 +407,13 @@ function cssVar(name, options = {}) {
 //#endregion
 //#region src/deep-set.ts
 const deepSet = (target, path, value) => {
-	const isValueObject = require_uniq.isObject(value);
-	if (!path.length && isValueObject) return require_uniq.mergeProps(target, value);
+	const isValueObject = isObject(value);
+	if (!path.length && isValueObject) return mergeProps(target, value);
 	let current = target;
 	for (let i = 0; i < path.length; i++) {
 		const key = path[i];
 		current[key] ||= {};
-		if (i === path.length - 1) if (isValueObject && require_uniq.isObject(current[key])) current[key] = require_uniq.mergeProps(current[key], value);
+		if (i === path.length - 1) if (isValueObject && isObject(current[key])) current[key] = mergeProps(current[key], value);
 		else current[key] = value;
 		else current = current[key];
 	}
@@ -235,11 +472,11 @@ function filterDefault(path) {
 }
 function flatten(values, stop) {
 	const result = {};
-	require_uniq.walkObject(values, (token, paths) => {
+	walkObject(values, (token, paths) => {
 		paths = filterDefault(paths);
 		if (token) result[paths.join(".")] = token.value;
 	}, { stop: stop ?? ((v) => {
-		return require_uniq.isObject(v) && "value" in v;
+		return isObject(v) && "value" in v;
 	}) });
 	return result;
 }
@@ -254,6 +491,31 @@ function getOrCreateSet(map, key) {
 	return set;
 }
 //#endregion
+//#region src/hypenate-property.ts
+const wordRegex = /([A-Z])/g;
+const msRegex = /^ms-/;
+const hypenateProperty = memo((property) => {
+	if (property.startsWith("--")) return property;
+	return property.replace(wordRegex, "-$1").replace(msRegex, "-ms-").toLowerCase();
+});
+//#endregion
+//#region src/is-css-function.ts
+const fnRegExp = new RegExp(`^(${[
+	"min",
+	"max",
+	"clamp",
+	"calc"
+].join("|")})\\(.*\\)`);
+const isCssFunction = (v) => typeof v === "string" && fnRegExp.test(v);
+//#endregion
+//#region src/is-css-unit.ts
+const lengthUnitsPattern = `(?:${"cm,mm,Q,in,pc,pt,px,em,ex,ch,rem,lh,rlh,vw,vh,vmin,vmax,vb,vi,svw,svh,lvw,lvh,dvw,dvh,cqw,cqh,cqi,cqb,cqmin,cqmax,%".split(",").join("|")})`;
+const lengthRegExp = new RegExp(`^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?${lengthUnitsPattern}$`);
+const isCssUnit = (v) => typeof v === "string" && lengthRegExp.test(v);
+//#endregion
+//#region src/is-css-var.ts
+const isCssVar = (v) => typeof v === "string" && /^var\(--.+\)$/.test(v);
+//#endregion
 //#region src/merge-anything.ts
 /**
 * Credits: https://github.com/mesqueeb/merge-anything
@@ -278,25 +540,25 @@ function assignProp(carry, key, newVal, originalObject) {
 	});
 }
 function mergeRecursively(origin, newComer, compareFn) {
-	if (!require_uniq.isObject(newComer)) return newComer;
+	if (!isObject(newComer)) return newComer;
 	let newObject = {};
-	if (require_uniq.isObject(origin)) {
+	if (isObject(origin)) {
 		const props = Object.getOwnPropertyNames(origin);
 		const symbols = Object.getOwnPropertySymbols(origin);
 		newObject = [...props, ...symbols].reduce((carry, key) => {
-			if (require_uniq.isString(key) && MERGE_OMIT$1.has(key)) return carry;
+			if (isString(key) && MERGE_OMIT$1.has(key)) return carry;
 			const targetVal = origin[key];
-			if (!require_uniq.isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key) || require_uniq.isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key)) assignProp(carry, key, targetVal, origin);
+			if (!isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key) || isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key)) assignProp(carry, key, targetVal, origin);
 			return carry;
 		}, {});
 	}
 	const props = Object.getOwnPropertyNames(newComer);
 	const symbols = Object.getOwnPropertySymbols(newComer);
 	return [...props, ...symbols].reduce((carry, key) => {
-		if (require_uniq.isString(key) && MERGE_OMIT$1.has(key)) return carry;
+		if (isString(key) && MERGE_OMIT$1.has(key)) return carry;
 		let newVal = newComer[key];
-		const targetVal = require_uniq.isObject(origin) ? origin[key] : void 0;
-		if (targetVal !== void 0 && require_uniq.isObject(newVal)) newVal = mergeRecursively(targetVal, newVal, compareFn);
+		const targetVal = isObject(origin) ? origin[key] : void 0;
+		if (targetVal !== void 0 && isObject(newVal)) newVal = mergeRecursively(targetVal, newVal, compareFn);
 		assignProp(carry, key, compareFn ? compareFn(targetVal, newVal, key) : newVal, newComer);
 		return carry;
 	}, newObject);
@@ -316,9 +578,9 @@ const MERGE_OMIT = new Set([
 function mergeWith(target, ...sources) {
 	const customizer = sources.pop();
 	for (const source of sources) for (const key in source) {
-		if (require_uniq.isString(key) && MERGE_OMIT.has(key)) continue;
+		if (isString(key) && MERGE_OMIT.has(key)) continue;
 		const merged = customizer(target[key], source[key]);
-		if (merged === void 0) if (require_uniq.isObject(target[key]) && require_uniq.isObject(source[key])) target[key] = mergeWith({}, target[key], source[key], customizer);
+		if (merged === void 0) if (isObject(target[key]) && isObject(source[key])) target[key] = mergeWith({}, target[key], source[key], customizer);
 		else target[key] = source[key];
 		else target[key] = merged;
 	}
@@ -345,7 +607,7 @@ function traverse(obj, callback, options = defaultOptions) {
 		const currentItem = stack.pop();
 		if (currentItem.parent !== null) callback(currentItem);
 		if (options.stop?.(currentItem)) continue;
-		if (require_uniq.isObjectOrArray(currentItem.value) && currentItem.depth < maxDepth) {
+		if (isObjectOrArray(currentItem.value) && currentItem.depth < maxDepth) {
 			const keys = Object.keys(currentItem.value);
 			for (let i = keys.length - 1; i >= 0; i--) {
 				const key = keys[i];
@@ -377,6 +639,19 @@ const omit = (obj, paths) => {
 //#region src/bamboo-config-name.ts
 const BAMBOO_CONFIG_NAME = "__bamboo.config__";
 //#endregion
+//#region src/pattern-fns.ts
+const patternFns = {
+	map: mapObject,
+	isCssFunction,
+	isCssVar,
+	isCssUnit
+};
+const getPatternStyles = (pattern, styles) => {
+	if (!pattern?.defaultValues) return styles;
+	const defaults = typeof pattern.defaultValues === "function" ? pattern.defaultValues(styles) : pattern.defaultValues;
+	return Object.assign({}, defaults, compact(styles));
+};
+//#endregion
 //#region src/split.ts
 function splitBy(value, separator = ",") {
 	const result = [];
@@ -910,6 +1185,46 @@ const parseJson = (config) => {
 	return JSON.parse(config);
 };
 //#endregion
+//#region src/slot.ts
+const getSlotRecipes = (recipe = {}) => {
+	const init = (slot) => ({
+		className: [recipe.className, slot].filter(Boolean).join("__"),
+		base: recipe.base?.[slot] ?? {},
+		variants: {},
+		defaultVariants: recipe.defaultVariants ?? {},
+		compoundVariants: recipe.compoundVariants ? getSlotCompoundVariant(recipe.compoundVariants, slot) : []
+	});
+	const recipeParts = (recipe.slots ?? []).map((slot) => [slot, init(slot)]);
+	for (const [variantsKey, variantsSpec] of Object.entries(recipe.variants ?? {})) for (const [variantKey, variantSpec] of Object.entries(variantsSpec)) recipeParts.forEach(([slot, slotRecipe]) => {
+		slotRecipe.variants[variantsKey] ??= {};
+		slotRecipe.variants[variantsKey][variantKey] = variantSpec[slot] ?? {};
+	});
+	return Object.fromEntries(recipeParts);
+};
+const getSlotCompoundVariant = (compoundVariants, slotName) => compoundVariants.filter((compoundVariant) => compoundVariant.css[slotName]).map((compoundVariant) => ({
+	...compoundVariant,
+	css: compoundVariant.css[slotName]
+}));
+//#endregion
+//#region src/split-props.ts
+function splitProps(props, ...keys) {
+	const descriptors = Object.getOwnPropertyDescriptors(props);
+	const dKeys = Object.keys(descriptors);
+	const split = (k) => {
+		const clone = {};
+		for (let i = 0; i < k.length; i++) {
+			const key = k[i];
+			if (descriptors[key]) {
+				Object.defineProperty(clone, key, descriptors[key]);
+				delete descriptors[key];
+			}
+		}
+		return clone;
+	};
+	const fn = (key) => split(Array.isArray(key) ? key : dKeys.filter(key));
+	return keys.map(fn).concat(split(dKeys));
+}
+//#endregion
 //#region src/to-json.ts
 function mapToJson(map) {
 	const obj = {};
@@ -928,6 +1243,15 @@ function unionType(values, opts = {}) {
 	return arr.map((v) => stringify(v)).join(" | ");
 }
 //#endregion
+//#region src/uniq.ts
+const uniq = (...items) => {
+	const set = items.reduce((acc, currItems) => {
+		if (currItems) currItems.forEach((item) => acc.add(item));
+		return acc;
+	}, /* @__PURE__ */ new Set([]));
+	return Array.from(set);
+};
+//#endregion
 //#region src/unit-conversion.ts
 const BASE_FONT_SIZE = 16;
 const UNIT_PX = "px";
@@ -965,69 +1289,69 @@ exports.BAMBOO_CONFIG_NAME = BAMBOO_CONFIG_NAME;
 exports.BambooError = BambooError;
 exports.CacheMap = CacheMap;
 exports.assign = assign;
-exports.astish = require_astish.astish;
+exports.astish = astish;
 exports.calc = calc;
 exports.camelCaseProperty = camelCaseProperty;
 exports.capitalize = capitalize;
-exports.compact = require_uniq.compact;
-exports.createCss = require_uniq.createCss;
-exports.createMergeCss = require_uniq.createMergeCss;
+exports.compact = compact;
+exports.createCss = createCss;
+exports.createMergeCss = createMergeCss;
 exports.createRegex = createRegex;
 exports.cssVar = cssVar;
 exports.dashCase = dashCase;
 exports.deepSet = deepSet;
 exports.entries = entries;
 exports.esc = esc;
-exports.filterBaseConditions = require_uniq.filterBaseConditions;
+exports.filterBaseConditions = filterBaseConditions;
 exports.flatten = flatten;
 exports.fromEntries = fromEntries;
 exports.getArbitraryValue = getArbitraryValue;
 exports.getDotPath = getDotPath;
 exports.getNegativePath = getNegativePath;
 exports.getOrCreateSet = getOrCreateSet;
-exports.getPatternStyles = require_uniq.getPatternStyles;
+exports.getPatternStyles = getPatternStyles;
 exports.getPropertyPriority = getPropertyPriority;
-exports.getSlotCompoundVariant = require_uniq.getSlotCompoundVariant;
-exports.getSlotRecipes = require_uniq.getSlotRecipes;
+exports.getSlotCompoundVariant = getSlotCompoundVariant;
+exports.getSlotRecipes = getSlotRecipes;
 exports.getUnit = getUnit;
-exports.hypenateProperty = require_uniq.hypenateProperty;
-exports.isBaseCondition = require_uniq.isBaseCondition;
-exports.isBoolean = require_uniq.isBoolean;
-exports.isCssFunction = require_uniq.isCssFunction;
-exports.isCssUnit = require_uniq.isCssUnit;
-exports.isCssVar = require_uniq.isCssVar;
-exports.isFunction = require_uniq.isFunction;
-exports.isImportant = require_uniq.isImportant;
-exports.isObject = require_uniq.isObject;
-exports.isObjectOrArray = require_uniq.isObjectOrArray;
-exports.isString = require_uniq.isString;
-exports.isSymbol = require_uniq.isSymbol;
+exports.hypenateProperty = hypenateProperty;
+exports.isBaseCondition = isBaseCondition;
+exports.isBoolean = isBoolean;
+exports.isCssFunction = isCssFunction;
+exports.isCssUnit = isCssUnit;
+exports.isCssVar = isCssVar;
+exports.isFunction = isFunction;
+exports.isImportant = isImportant;
+exports.isObject = isObject;
+exports.isObjectOrArray = isObjectOrArray;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
 exports.mapEntries = mapEntries;
-exports.mapObject = require_uniq.mapObject;
+exports.mapObject = mapObject;
 exports.mapToJson = mapToJson;
-exports.markImportant = require_uniq.markImportant;
-exports.memo = require_uniq.memo;
+exports.markImportant = markImportant;
+exports.memo = memo;
 exports.mergeAndConcat = mergeAndConcat;
-exports.mergeProps = require_uniq.mergeProps;
+exports.mergeProps = mergeProps;
 exports.mergeWith = mergeWith;
-exports.normalizeStyleObject = require_uniq.normalizeStyleObject;
+exports.normalizeStyleObject = normalizeStyleObject;
 exports.omit = omit;
 exports.parseJson = parseJson;
-exports.patternFns = require_uniq.patternFns;
+exports.patternFns = patternFns;
 exports.pick = pick;
 exports.splitBy = splitBy;
 exports.splitDotPath = splitDotPath;
-exports.splitProps = require_uniq.splitProps;
+exports.splitProps = splitProps;
 exports.stringifyJson = stringifyJson;
 exports.toEm = toEm;
-exports.toHash = require_uniq.toHash;
+exports.toHash = toHash;
 exports.toPx = toPx;
 exports.toRem = toRem;
-exports.toResponsiveObject = require_uniq.toResponsiveObject;
+exports.toResponsiveObject = toResponsiveObject;
 exports.traverse = traverse;
 exports.uncapitalize = uncapitalize;
 exports.unionType = unionType;
-exports.uniq = require_uniq.uniq;
-exports.walkObject = require_uniq.walkObject;
-exports.withoutImportant = require_uniq.withoutImportant;
-exports.withoutSpace = require_uniq.withoutSpace;
+exports.uniq = uniq;
+exports.walkObject = walkObject;
+exports.withoutImportant = withoutImportant;
+exports.withoutSpace = withoutSpace;