@bamboocss/shared 1.11.1 → 1.11.2

package/dist/index.cjs

@@ -0,0 +1,1033 @@
+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;
+	const value = _value.trim();
+	if (value[0] === "[" && value[value.length - 1] === "]") {
+		const innerValue = value.slice(1, -1);
+		let bracketCount = 0;
+		for (let i = 0; i < innerValue.length; i++) if (innerValue[i] === "[") bracketCount++;
+		else if (innerValue[i] === "]") {
+			if (bracketCount === 0) return value;
+			bracketCount--;
+		}
+		if (bracketCount === 0) return innerValue.trim();
+	}
+	return value;
+};
+//#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/cache-map.ts
+var CacheMap = class {
+	cache;
+	keysInUse;
+	maxCacheSize;
+	constructor(maxCacheSize = 1e3) {
+		this.maxCacheSize = maxCacheSize;
+		this.cache = /* @__PURE__ */ new Map();
+		this.keysInUse = [];
+	}
+	get(key) {
+		if (!this.cache.has(key)) return;
+		this.updateKeyUsage(key);
+		return this.cache.get(key);
+	}
+	set(key, value) {
+		if (!this.cache.has(key) && this.cache.size === this.maxCacheSize) this.evictLeastRecentlyUsed();
+		this.cache.set(key, value);
+		this.updateKeyUsage(key);
+		return this;
+	}
+	delete(key) {
+		const result = this.cache.delete(key);
+		if (result) {
+			const index = this.keysInUse.indexOf(key);
+			if (index !== -1) this.keysInUse.splice(index, 1);
+		}
+		return result;
+	}
+	updateKeyUsage(key) {
+		const index = this.keysInUse.indexOf(key);
+		if (index !== -1) this.keysInUse.splice(index, 1);
+		this.keysInUse.push(key);
+	}
+	evictLeastRecentlyUsed() {
+		const keyToEvict = this.keysInUse.shift();
+		if (keyToEvict !== void 0) this.cache.delete(keyToEvict);
+	}
+	clear() {
+		this.cache.clear();
+		this.keysInUse = [];
+	}
+	has(key) {
+		return this.cache.has(key);
+	}
+	get size() {
+		return this.cache.size;
+	}
+	forEach(callback, thisArg) {
+		this.cache.forEach(callback, thisArg);
+	}
+	keys() {
+		return this.cache.keys();
+	}
+	values() {
+		return this.cache.values();
+	}
+	entries() {
+		return this.cache.entries();
+	}
+	getOrInsert(key, defaultValue) {
+		if (this.cache.has(key)) {
+			this.updateKeyUsage(key);
+			return this.cache.get(key);
+		}
+		this.set(key, defaultValue);
+		return defaultValue;
+	}
+	getOrInsertComputed(key, callback) {
+		if (this.cache.has(key)) {
+			this.updateKeyUsage(key);
+			return this.cache.get(key);
+		}
+		const value = callback(key);
+		this.set(key, value);
+		return value;
+	}
+	[Symbol.iterator]() {
+		return this.cache[Symbol.iterator]();
+	}
+	[Symbol.toStringTag] = "CacheMap";
+	toJSON = () => {
+		return this.cache;
+	};
+};
+//#endregion
+//#region src/calc.ts
+function isCssVar$1(value) {
+	return require_uniq.isObject(value) && "ref" in value;
+}
+function getRef(operand) {
+	return isCssVar$1(operand) ? operand.ref : operand.toString();
+}
+const calcRegex = /calc/g;
+const toExpression = (operator, ...operands) => operands.map(getRef).join(` ${operator} `).replace(calcRegex, "");
+const multiply = (...operands) => `calc(${toExpression("*", ...operands)})`;
+const calc = { negate(x) {
+	const value = getRef(x);
+	if (value != null && !Number.isNaN(parseFloat(value))) return String(value).startsWith("-") ? String(value).slice(1) : `-${value}`;
+	return multiply(value, -1);
+} };
+//#endregion
+//#region src/camelcase-property.ts
+const regex = /-(\w|$)/g;
+const callback = (_dashChar, char) => char.toUpperCase();
+const camelCaseProperty = require_uniq.memo((property) => {
+	if (property.startsWith("--")) return property;
+	let str = property.toLowerCase();
+	str = str.startsWith("-ms-") ? str.substring(1) : str;
+	return str.replace(regex, callback);
+});
+//#endregion
+//#region src/capitalize.ts
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+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/css-var.ts
+const escRegex = /[^a-zA-Z0-9_\u0081-\uffff-]/g;
+function esc$1(string) {
+	return `${string}`.replace(escRegex, (s) => `\\${s}`);
+}
+const dashCaseRegex = /[A-Z]/g;
+function dashCase$1(string) {
+	return string.replace(dashCaseRegex, (match) => `-${match.toLowerCase()}`);
+}
+function cssVar(name, options = {}) {
+	const { fallback = "", prefix = "", hash } = options;
+	const variable = hash ? [
+		"-",
+		prefix,
+		require_uniq.toHash(name)
+	].filter(Boolean).join("-") : dashCase$1([
+		"-",
+		prefix,
+		esc$1(name)
+	].filter(Boolean).join("-"));
+	return {
+		var: variable,
+		ref: `var(${variable}${fallback ? `, ${fallback}` : ""})`
+	};
+}
+//#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);
+	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);
+		else current[key] = value;
+		else current = current[key];
+	}
+	return target;
+};
+//#endregion
+//#region src/entries.ts
+function fromEntries(entries) {
+	const result = {};
+	entries.forEach((kv) => {
+		result[kv[0]] = kv[1];
+	});
+	return result;
+}
+function entries(obj) {
+	const result = [];
+	for (const key in obj) result.push([key, obj[key]]);
+	return result;
+}
+function mapEntries(obj, f) {
+	const result = {};
+	for (const key in obj) {
+		const kv = f(key, obj[key]);
+		result[kv[0]] = kv[1];
+	}
+	return result;
+}
+//#endregion
+//#region src/error.ts
+var BambooError = class extends Error {
+	code;
+	hint;
+	constructor(code, message, opts) {
+		super(message, { cause: opts?.cause });
+		this.code = `ERR_BAMBOO_${code}`;
+		this.hint = opts?.hint;
+	}
+};
+//#endregion
+//#region src/esc.ts
+const rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|^-|[^\x80-\uFFFF\w-]/g;
+const fcssescape = function(ch, asCodePoint) {
+	if (!asCodePoint) return "\\" + ch;
+	if (ch === "\0") return "�";
+	if (ch === "-" && ch.length === 1) return "\\-";
+	return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16);
+};
+const esc = (sel) => {
+	return (sel + "").replace(rcssescape, fcssescape);
+};
+//#endregion
+//#region src/flatten.ts
+function filterDefault(path) {
+	if (path[0] === "DEFAULT") return path;
+	return path.filter((item) => item !== "DEFAULT");
+}
+function flatten(values, stop) {
+	const result = {};
+	require_uniq.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 result;
+}
+//#endregion
+//#region src/get-or-create-set.ts
+function getOrCreateSet(map, key) {
+	let set = map.get(key);
+	if (!set) {
+		map.set(key, /* @__PURE__ */ new Set());
+		set = map.get(key);
+	}
+	return set;
+}
+//#endregion
+//#region src/merge-anything.ts
+/**
+* Credits: https://github.com/mesqueeb/merge-anything
+*/
+const MERGE_OMIT$1 = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function concatArrays(originVal, newVal) {
+	if (Array.isArray(originVal) && Array.isArray(newVal)) return originVal.concat(newVal);
+	return newVal;
+}
+function assignProp(carry, key, newVal, originalObject) {
+	const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+	if (propType === "enumerable") carry[key] = newVal;
+	if (propType === "nonenumerable") Object.defineProperty(carry, key, {
+		value: newVal,
+		enumerable: false,
+		writable: true,
+		configurable: true
+	});
+}
+function mergeRecursively(origin, newComer, compareFn) {
+	if (!require_uniq.isObject(newComer)) return newComer;
+	let newObject = {};
+	if (require_uniq.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;
+			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);
+			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;
+		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);
+		assignProp(carry, key, compareFn ? compareFn(targetVal, newVal, key) : newVal, newComer);
+		return carry;
+	}, newObject);
+}
+function mergeAndConcat(object, ...otherObjects) {
+	return otherObjects.reduce((result, newComer) => {
+		return mergeRecursively(result, newComer, concatArrays);
+	}, object);
+}
+//#endregion
+//#region src/merge-with.ts
+const MERGE_OMIT = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+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;
+		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);
+		else target[key] = source[key];
+		else target[key] = merged;
+	}
+	return target;
+}
+//#endregion
+//#region src/traverse.ts
+const defaultOptions = {
+	separator: ".",
+	maxDepth: Infinity
+};
+function traverse(obj, callback, options = defaultOptions) {
+	const maxDepth = options.maxDepth ?? defaultOptions.maxDepth;
+	const separator = options.separator ?? defaultOptions.separator;
+	const stack = [{
+		value: obj,
+		path: "",
+		paths: [],
+		depth: -1,
+		parent: null,
+		key: ""
+	}];
+	while (stack.length > 0) {
+		const currentItem = stack.pop();
+		if (currentItem.parent !== null) callback(currentItem);
+		if (options.stop?.(currentItem)) continue;
+		if (require_uniq.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];
+				const value = currentItem.value[key];
+				const path = currentItem.path ? currentItem.path + separator + key : key;
+				const paths = currentItem.paths.concat(key);
+				stack.push({
+					value,
+					path,
+					paths,
+					depth: currentItem.depth + 1,
+					parent: currentItem.value,
+					key
+				});
+			}
+		}
+	}
+}
+//#endregion
+//#region src/omit.ts
+const omit = (obj, paths) => {
+	const result = { ...obj };
+	traverse(result, ({ path, parent, key }) => {
+		if (paths.includes(path)) delete parent[key];
+	});
+	return result;
+};
+//#endregion
+//#region src/bamboo-config-name.ts
+const BAMBOO_CONFIG_NAME = "__bamboo.config__";
+//#endregion
+//#region src/split.ts
+function splitBy(value, separator = ",") {
+	const result = [];
+	let current = "";
+	let depth = 0;
+	for (let i = 0; i < value.length; i++) {
+		const char = value[i];
+		if (char === "(") depth++;
+		else if (char === ")") depth--;
+		else if (char === separator && depth === 0) {
+			result.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	result.push(current);
+	return result;
+}
+function splitDotPath(path) {
+	return path.split(".").reduce((acc, curr) => {
+		const last = acc[acc.length - 1];
+		if (last != null && !isNaN(Number(last)) && !isNaN(Number(curr))) acc[acc.length - 1] = `${last}.${curr}`;
+		else acc.push(curr);
+		return acc;
+	}, []);
+}
+function getNegativePath(path) {
+	return path.slice(0, -1).concat(`-${path.at(-1)}`);
+}
+function getDotPath(obj, path, fallback) {
+	if (typeof path !== "string") return fallback;
+	const idx = path.indexOf(".");
+	if (idx === -1) return obj?.[path] ?? fallback;
+	const key = path.slice(0, idx);
+	const nextPath = path.slice(idx + 1);
+	const checkValue = obj?.[key]?.[nextPath];
+	if (checkValue) return checkValue;
+	return getDotPath(obj?.[key], nextPath, fallback) ?? fallback;
+}
+//#endregion
+//#region src/pick.ts
+const pick = (obj, paths) => {
+	const result = {};
+	traverse(obj, ({ path, value }) => {
+		if (paths.includes(path)) deepSet(result, splitDotPath(path), value);
+	});
+	return result;
+};
+//#endregion
+//#region src/property-priority.ts
+/**
+* Slightly modified from https://github.com/facebook/stylex/blob/main/packages/%40stylexjs/babel-plugin/src/shared/utils/property-priorities.js
+* License: MIT
+*/
+const longHandPhysical = /* @__PURE__ */ new Set();
+const longHandLogical = /* @__PURE__ */ new Set();
+const shorthandsOfLonghands = /* @__PURE__ */ new Set();
+const shorthandsOfShorthands = /* @__PURE__ */ new Set();
+longHandLogical.add("backgroundBlendMode");
+longHandLogical.add("isolation");
+longHandLogical.add("mixBlendMode");
+shorthandsOfShorthands.add("animation");
+longHandLogical.add("animationComposition");
+longHandLogical.add("animationDelay");
+longHandLogical.add("animationDirection");
+longHandLogical.add("animationDuration");
+longHandLogical.add("animationFillMode");
+longHandLogical.add("animationIterationCount");
+longHandLogical.add("animationName");
+longHandLogical.add("animationPlayState");
+shorthandsOfLonghands.add("animationRange");
+longHandLogical.add("animationRangeEnd");
+longHandLogical.add("animationRangeStart");
+longHandLogical.add("animationTimingFunction");
+longHandLogical.add("animationTimeline");
+shorthandsOfLonghands.add("scrollTimeline");
+longHandLogical.add("scrollTimelineAxis");
+longHandLogical.add("scrollTimelineName");
+longHandLogical.add("timelineScope");
+shorthandsOfLonghands.add("viewTimeline");
+longHandLogical.add("viewTimelineAxis");
+longHandLogical.add("viewTimelineInset");
+longHandLogical.add("viewTimelineName");
+shorthandsOfShorthands.add("background");
+longHandLogical.add("backgroundAttachment");
+longHandLogical.add("backgroundClip");
+longHandLogical.add("backgroundColor");
+longHandLogical.add("backgroundImage");
+longHandLogical.add("backgroundOrigin");
+longHandLogical.add("backgroundRepeat");
+longHandLogical.add("backgroundSize");
+shorthandsOfLonghands.add("backgroundPosition");
+longHandLogical.add("backgroundPositionX");
+longHandLogical.add("backgroundPositionY");
+shorthandsOfShorthands.add("border");
+shorthandsOfLonghands.add("borderColor");
+shorthandsOfLonghands.add("borderStyle");
+shorthandsOfLonghands.add("borderWidth");
+shorthandsOfShorthands.add("borderBlock");
+longHandLogical.add("borderBlockColor");
+longHandLogical.add("borderBlockStyle");
+longHandLogical.add("borderBlockWidth");
+shorthandsOfLonghands.add("borderBlockStart");
+shorthandsOfLonghands.add("borderTop");
+longHandLogical.add("borderBlockStartColor");
+longHandPhysical.add("borderTopColor");
+longHandLogical.add("borderBlockStartStyle");
+longHandPhysical.add("borderTopStyle");
+longHandLogical.add("borderBlockStartWidth");
+longHandPhysical.add("borderTopWidth");
+shorthandsOfLonghands.add("borderBlockEnd");
+shorthandsOfLonghands.add("borderBottom");
+longHandLogical.add("borderBlockEndColor");
+longHandPhysical.add("borderBottomColor");
+longHandLogical.add("borderBlockEndStyle");
+longHandPhysical.add("borderBottomStyle");
+longHandLogical.add("borderBlockEndWidth");
+longHandPhysical.add("borderBottomWidth");
+shorthandsOfShorthands.add("borderInline");
+shorthandsOfLonghands.add("borderInlineColor");
+shorthandsOfLonghands.add("borderInlineStyle");
+shorthandsOfLonghands.add("borderInlineWidth");
+shorthandsOfLonghands.add("borderInlineStart");
+shorthandsOfLonghands.add("borderLeft");
+longHandLogical.add("borderInlineStartColor");
+longHandPhysical.add("borderLeftColor");
+longHandLogical.add("borderInlineStartStyle");
+longHandPhysical.add("borderLeftStyle");
+longHandLogical.add("borderInlineStartWidth");
+longHandPhysical.add("borderLeftWidth");
+shorthandsOfLonghands.add("borderInlineEnd");
+shorthandsOfLonghands.add("borderRight");
+longHandLogical.add("borderInlineEndColor");
+longHandPhysical.add("borderRightColor");
+longHandLogical.add("borderInlineEndStyle");
+longHandPhysical.add("borderRightStyle");
+longHandLogical.add("borderInlineEndWidth");
+longHandPhysical.add("borderRightWidth");
+shorthandsOfLonghands.add("borderImage");
+longHandLogical.add("borderImageOutset");
+longHandLogical.add("borderImageRepeat");
+longHandLogical.add("borderImageSlice");
+longHandLogical.add("borderImageSource");
+longHandLogical.add("borderImageWidth");
+shorthandsOfLonghands.add("borderRadius");
+longHandLogical.add("borderStartEndRadius");
+longHandLogical.add("borderStartStartRadius");
+longHandLogical.add("borderEndEndRadius");
+longHandLogical.add("borderEndStartRadius");
+longHandPhysical.add("borderTopLeftRadius");
+longHandPhysical.add("borderTopRightRadius");
+longHandPhysical.add("borderBottomLeftRadius");
+longHandPhysical.add("borderBottomRightRadius");
+longHandLogical.add("boxShadow");
+longHandLogical.add("accentColor");
+longHandLogical.add("appearance");
+longHandLogical.add("aspectRatio");
+shorthandsOfLonghands.add("caret");
+longHandLogical.add("caretColor");
+longHandLogical.add("caretShape");
+longHandLogical.add("cursor");
+longHandLogical.add("imeMode");
+longHandLogical.add("inputSecurity");
+shorthandsOfLonghands.add("outline");
+longHandLogical.add("outlineColor");
+longHandLogical.add("outlineOffset");
+longHandLogical.add("outlineStyle");
+longHandLogical.add("outlineWidth");
+longHandLogical.add("pointerEvents");
+longHandLogical.add("resize");
+longHandLogical.add("textOverflow");
+longHandLogical.add("userSelect");
+shorthandsOfLonghands.add("gridGap");
+shorthandsOfLonghands.add("gap");
+longHandLogical.add("gridRowGap");
+longHandLogical.add("rowGap");
+longHandLogical.add("gridColumnGap");
+longHandLogical.add("columnGap");
+shorthandsOfLonghands.add("placeContent");
+longHandLogical.add("alignContent");
+longHandLogical.add("justifyContent");
+shorthandsOfLonghands.add("placeItems");
+longHandLogical.add("alignItems");
+longHandLogical.add("justifyItems");
+shorthandsOfLonghands.add("placeSelf");
+longHandLogical.add("alignSelf");
+longHandLogical.add("justifySelf");
+longHandLogical.add("boxSizing");
+longHandLogical.add("fieldSizing");
+longHandLogical.add("blockSize");
+longHandPhysical.add("height");
+longHandLogical.add("inlineSize");
+longHandPhysical.add("width");
+longHandLogical.add("maxBlockSize");
+longHandPhysical.add("maxHeight");
+longHandLogical.add("maxInlineSize");
+longHandPhysical.add("maxWidth");
+longHandLogical.add("minBlockSize");
+longHandPhysical.add("minHeight");
+longHandLogical.add("minInlineSize");
+longHandPhysical.add("minWidth");
+shorthandsOfShorthands.add("margin");
+shorthandsOfLonghands.add("marginBlock");
+longHandLogical.add("marginBlockStart");
+longHandPhysical.add("marginTop");
+longHandLogical.add("marginBlockEnd");
+longHandPhysical.add("marginBottom");
+shorthandsOfLonghands.add("marginInline");
+longHandLogical.add("marginInlineStart");
+longHandPhysical.add("marginLeft");
+longHandLogical.add("marginInlineEnd");
+longHandPhysical.add("marginRight");
+longHandLogical.add("marginTrim");
+shorthandsOfLonghands.add("overscrollBehavior");
+longHandLogical.add("overscrollBehaviorBlock");
+longHandPhysical.add("overscrollBehaviorY");
+longHandLogical.add("overscrollBehaviorInline");
+longHandPhysical.add("overscrollBehaviorX");
+shorthandsOfShorthands.add("padding");
+shorthandsOfLonghands.add("paddingBlock");
+longHandLogical.add("paddingBlockStart");
+longHandPhysical.add("paddingTop");
+longHandLogical.add("paddingBlockEnd");
+longHandPhysical.add("paddingBottom");
+shorthandsOfLonghands.add("paddingInline");
+longHandLogical.add("paddingInlineStart");
+longHandPhysical.add("paddingLeft");
+longHandLogical.add("paddingInlineEnd");
+longHandPhysical.add("paddingRight");
+longHandLogical.add("visibility");
+longHandLogical.add("color");
+longHandLogical.add("colorScheme");
+longHandLogical.add("forcedColorAdjust");
+longHandLogical.add("opacity");
+longHandLogical.add("printColorAdjust");
+shorthandsOfLonghands.add("columns");
+longHandLogical.add("columnCount");
+longHandLogical.add("columnWidth");
+longHandLogical.add("columnFill");
+longHandLogical.add("columnSpan");
+shorthandsOfLonghands.add("columnRule");
+longHandLogical.add("columnRuleColor");
+longHandLogical.add("columnRuleStyle");
+longHandLogical.add("columnRuleWidth");
+longHandLogical.add("contain");
+shorthandsOfLonghands.add("containIntrinsicSize");
+longHandLogical.add("containIntrinsicBlockSize");
+longHandLogical.add("containIntrinsicWidth");
+longHandLogical.add("containIntrinsicHeight");
+longHandLogical.add("containIntrinsicInlineSize");
+shorthandsOfLonghands.add("container");
+longHandLogical.add("containerName");
+longHandLogical.add("containerType");
+longHandLogical.add("contentVisibility");
+longHandLogical.add("counterIncrement");
+longHandLogical.add("counterReset");
+longHandLogical.add("counterSet");
+longHandLogical.add("display");
+shorthandsOfLonghands.add("flex");
+longHandLogical.add("flexBasis");
+longHandLogical.add("flexGrow");
+longHandLogical.add("flexShrink");
+shorthandsOfLonghands.add("flexFlow");
+longHandLogical.add("flexDirection");
+longHandLogical.add("flexWrap");
+longHandLogical.add("order");
+shorthandsOfShorthands.add("font");
+longHandLogical.add("fontFamily");
+longHandLogical.add("fontSize");
+longHandLogical.add("fontStretch");
+longHandLogical.add("fontStyle");
+longHandLogical.add("fontWeight");
+longHandLogical.add("lineHeight");
+shorthandsOfLonghands.add("fontVariant");
+longHandLogical.add("fontVariantAlternates");
+longHandLogical.add("fontVariantCaps");
+longHandLogical.add("fontVariantEastAsian");
+longHandLogical.add("fontVariantEmoji");
+longHandLogical.add("fontVariantLigatures");
+longHandLogical.add("fontVariantNumeric");
+longHandLogical.add("fontVariantPosition");
+longHandLogical.add("fontFeatureSettings");
+longHandLogical.add("fontKerning");
+longHandLogical.add("fontLanguageOverride");
+longHandLogical.add("fontOpticalSizing");
+longHandLogical.add("fontPalette");
+longHandLogical.add("fontVariationSettings");
+longHandLogical.add("fontSizeAdjust");
+longHandLogical.add("fontSmooth");
+longHandLogical.add("fontSynthesisPosition");
+longHandLogical.add("fontSynthesisSmallCaps");
+longHandLogical.add("fontSynthesisStyle");
+longHandLogical.add("fontSynthesisWeight");
+shorthandsOfLonghands.add("fontSynthesis");
+longHandLogical.add("lineHeightStep");
+longHandLogical.add("boxDecorationBreak");
+longHandLogical.add("breakAfter");
+longHandLogical.add("breakBefore");
+longHandLogical.add("breakInside");
+longHandLogical.add("orphans");
+longHandLogical.add("widows");
+longHandLogical.add("content");
+longHandLogical.add("quotes");
+shorthandsOfShorthands.add("grid");
+longHandLogical.add("gridAutoFlow");
+longHandLogical.add("gridAutoRows");
+longHandLogical.add("gridAutoColumns");
+shorthandsOfShorthands.add("gridTemplate");
+shorthandsOfLonghands.add("gridTemplateAreas");
+longHandLogical.add("gridTemplateColumns");
+longHandLogical.add("gridTemplateRows");
+shorthandsOfShorthands.add("gridArea");
+shorthandsOfLonghands.add("gridRow");
+longHandLogical.add("gridRowStart");
+longHandLogical.add("gridRowEnd");
+shorthandsOfLonghands.add("gridColumn");
+longHandLogical.add("gridColumnStart");
+longHandLogical.add("gridColumnEnd");
+longHandLogical.add("alignTracks");
+longHandLogical.add("justifyTracks");
+longHandLogical.add("masonryAutoFlow");
+longHandLogical.add("imageOrientation");
+longHandLogical.add("imageRendering");
+longHandLogical.add("imageResolution");
+longHandLogical.add("objectFit");
+longHandLogical.add("objectPosition");
+longHandLogical.add("initialLetter");
+longHandLogical.add("initialLetterAlign");
+shorthandsOfLonghands.add("listStyle");
+longHandLogical.add("listStyleImage");
+longHandLogical.add("listStylePosition");
+longHandLogical.add("listStyleType");
+longHandLogical.add("clip");
+longHandLogical.add("clipPath");
+shorthandsOfLonghands.add("mask");
+longHandLogical.add("maskClip");
+longHandLogical.add("maskComposite");
+longHandLogical.add("maskImage");
+longHandLogical.add("maskMode");
+longHandLogical.add("maskOrigin");
+longHandLogical.add("maskPosition");
+longHandLogical.add("maskRepeat");
+longHandLogical.add("maskSize");
+longHandLogical.add("maskType");
+shorthandsOfLonghands.add("maskBorder");
+longHandLogical.add("maskBorderMode");
+longHandLogical.add("maskBorderOutset");
+longHandLogical.add("maskBorderRepeat");
+longHandLogical.add("maskBorderSlice");
+longHandLogical.add("maskBorderSource");
+longHandLogical.add("maskBorderWidth");
+shorthandsOfShorthands.add("all");
+longHandLogical.add("textRendering");
+longHandLogical.add("zoom");
+shorthandsOfLonghands.add("offset");
+longHandLogical.add("offsetAnchor");
+longHandLogical.add("offsetDistance");
+longHandLogical.add("offsetPath");
+longHandLogical.add("offsetPosition");
+longHandLogical.add("offsetRotate");
+longHandLogical.add("WebkitBoxOrient");
+longHandLogical.add("WebkitLineClamp");
+longHandPhysical.add("lineClamp");
+longHandPhysical.add("maxLines");
+longHandLogical.add("blockOverflow");
+shorthandsOfLonghands.add("overflow");
+longHandLogical.add("overflowBlock");
+longHandPhysical.add("overflowY");
+longHandLogical.add("overflowInline");
+longHandPhysical.add("overflowX");
+longHandLogical.add("overflowClipMargin");
+longHandLogical.add("scrollGutter");
+longHandLogical.add("scrollBehavior");
+longHandLogical.add("page");
+longHandLogical.add("pageBreakAfter");
+longHandLogical.add("pageBreakBefore");
+longHandLogical.add("pageBreakInside");
+shorthandsOfShorthands.add("inset");
+shorthandsOfLonghands.add("insetBlock");
+longHandLogical.add("insetBlockStart");
+longHandPhysical.add("top");
+longHandLogical.add("insetBlockEnd");
+longHandPhysical.add("bottom");
+shorthandsOfLonghands.add("insetInline");
+longHandLogical.add("insetInlineStart");
+longHandPhysical.add("left");
+longHandLogical.add("insetInlineEnd");
+longHandPhysical.add("right");
+longHandLogical.add("clear");
+longHandLogical.add("float");
+longHandLogical.add("overlay");
+longHandLogical.add("position");
+longHandLogical.add("zIndex");
+longHandLogical.add("rubyAlign");
+longHandLogical.add("rubyMerge");
+longHandLogical.add("rubyPosition");
+longHandLogical.add("overflowAnchor");
+shorthandsOfShorthands.add("scrollMargin");
+shorthandsOfLonghands.add("scrollMarginBlock");
+longHandLogical.add("scrollMarginBlockStart");
+longHandPhysical.add("scrollMarginTop");
+longHandLogical.add("scrollMarginBlockEnd");
+longHandPhysical.add("scrollMarginBottom");
+shorthandsOfLonghands.add("scrollMarginInline");
+longHandLogical.add("scrollMarginInlineStart");
+longHandPhysical.add("scrollMarginLeft");
+longHandLogical.add("scrollMarginInlineEnd");
+longHandPhysical.add("scrollMarginRight");
+shorthandsOfShorthands.add("scrollPadding");
+shorthandsOfLonghands.add("scrollPaddingBlock");
+longHandLogical.add("scrollPaddingBlockStart");
+longHandPhysical.add("scrollPaddingTop");
+longHandLogical.add("scrollPaddingBlockEnd");
+longHandPhysical.add("scrollPaddingBottom");
+shorthandsOfLonghands.add("scrollPaddingInline");
+longHandLogical.add("scrollPaddingInlineStart");
+longHandPhysical.add("scrollPaddingLeft");
+longHandLogical.add("scrollPaddingInlineEnd");
+longHandPhysical.add("scrollPaddingRight");
+longHandLogical.add("scrollSnapAlign");
+longHandLogical.add("scrollSnapStop");
+shorthandsOfLonghands.add("scrollSnapType");
+longHandLogical.add("scrollbarColor");
+longHandLogical.add("scrollbarWidth");
+longHandLogical.add("shapeImageThreshold");
+longHandLogical.add("shapeMargin");
+longHandLogical.add("shapeOutside");
+longHandLogical.add("azimuth");
+longHandLogical.add("borderCollapse");
+longHandLogical.add("borderSpacing");
+longHandLogical.add("captionSide");
+longHandLogical.add("emptyCells");
+longHandLogical.add("tableLayout");
+longHandLogical.add("verticalAlign");
+shorthandsOfLonghands.add("textDecoration");
+longHandLogical.add("textDecorationColor");
+longHandLogical.add("textDecorationLine");
+longHandLogical.add("textDecorationSkip");
+longHandLogical.add("textDecorationSkipInk");
+longHandLogical.add("textDecorationStyle");
+longHandLogical.add("textDecorationThickness");
+shorthandsOfLonghands.add("WebkitTextStroke");
+longHandLogical.add("WebkitTextStrokeColor");
+longHandLogical.add("WebkitTextStrokeWidth");
+longHandLogical.add("WebkitTextFillColor");
+shorthandsOfLonghands.add("textEmphasis");
+longHandLogical.add("textEmphasisColor");
+longHandLogical.add("textEmphasisPosition");
+longHandLogical.add("textEmphasisStyle");
+longHandLogical.add("textShadow");
+longHandLogical.add("textUnderlineOffset");
+longHandLogical.add("textUnderlinePosition");
+longHandLogical.add("hangingPunctuation");
+longHandLogical.add("hyphenateCharacter");
+longHandLogical.add("hyphenateLimitChars");
+longHandLogical.add("hyphens");
+longHandLogical.add("letterSpacing");
+longHandLogical.add("lineBreak");
+longHandLogical.add("overflowWrap");
+longHandLogical.add("paintOrder");
+longHandLogical.add("tabSize");
+longHandLogical.add("textAlign");
+longHandLogical.add("textAlignLast");
+longHandLogical.add("textIndent");
+longHandLogical.add("textJustify");
+longHandLogical.add("textSizeAdjust");
+longHandLogical.add("textTransform");
+shorthandsOfLonghands.add("textWrap");
+longHandLogical.add("textWrapMode");
+longHandLogical.add("textWrapStyle");
+longHandLogical.add("whiteSpace");
+longHandLogical.add("whiteSpaceCollapse");
+longHandLogical.add("whiteSpaceTrim");
+longHandLogical.add("wordBreak");
+longHandLogical.add("wordSpacing");
+longHandLogical.add("wordWrap");
+longHandLogical.add("backfaceVisibility");
+longHandLogical.add("perspective");
+longHandLogical.add("perspectiveOrigin");
+longHandLogical.add("rotate");
+longHandLogical.add("scale");
+longHandLogical.add("transform");
+longHandLogical.add("transformBox");
+longHandLogical.add("transformOrigin");
+longHandLogical.add("transformStyle");
+longHandLogical.add("translate");
+shorthandsOfLonghands.add("transition");
+longHandLogical.add("transitionBehavior");
+longHandLogical.add("transitionDelay");
+longHandLogical.add("transitionDuration");
+longHandLogical.add("transitionProperty");
+longHandLogical.add("transitionTimingFunction");
+longHandLogical.add("viewTransitionName");
+longHandLogical.add("willChange");
+longHandLogical.add("direction");
+longHandLogical.add("textCombineUpright");
+longHandLogical.add("textOrientation");
+longHandLogical.add("unicodeBidi");
+longHandLogical.add("writingMode");
+longHandLogical.add("backdropFilter");
+longHandLogical.add("filter");
+longHandLogical.add("mathDepth");
+longHandLogical.add("mathShift");
+longHandLogical.add("mathStyle");
+longHandLogical.add("touchAction");
+function getPropertyPriority(key) {
+	if (key === "all") return 0;
+	if (key.startsWith("--")) return 1;
+	if (longHandPhysical.has(key)) return 4e3;
+	if (longHandLogical.has(key)) return 3e3;
+	if (shorthandsOfLonghands.has(key)) return 2e3;
+	if (shorthandsOfShorthands.has(key)) return 1e3;
+	return 3e3;
+}
+//#endregion
+//#region src/regex.ts
+const createRegex = (item) => {
+	const regex = item.map((item) => typeof item === "string" ? `^${item}$` : item.source).join("|");
+	return new RegExp(regex);
+};
+//#endregion
+//#region src/serialize.ts
+const stringifyJson = (config) => {
+	return JSON.stringify(config, (_key, value) => {
+		if (typeof value === "function") return value.toString();
+		return value;
+	});
+};
+const parseJson = (config) => {
+	return JSON.parse(config);
+};
+//#endregion
+//#region src/to-json.ts
+function mapToJson(map) {
+	const obj = {};
+	map.forEach((value, key) => {
+		if (value instanceof Map) obj[key] = Object.fromEntries(value);
+		else obj[key] = value;
+	});
+	return obj;
+}
+//#endregion
+//#region src/typegen.ts
+function unionType(values, opts = {}) {
+	const { fallback, stringify = JSON.stringify } = opts;
+	const arr = Array.from(values);
+	if (fallback != null && !arr.length) return fallback;
+	return arr.map((v) => stringify(v)).join(" | ");
+}
+//#endregion
+//#region src/unit-conversion.ts
+const BASE_FONT_SIZE = 16;
+const UNIT_PX = "px";
+const UNIT_EM = "em";
+const UNIT_REM = "rem";
+const DIGIT_REGEX = new RegExp(String.raw`-?\d+(?:\.\d+|\d*)`);
+const UNIT_REGEX = new RegExp(`${UNIT_PX}|${UNIT_EM}|${UNIT_REM}`);
+const VALUE_REGEX = new RegExp(`${DIGIT_REGEX.source}(${UNIT_REGEX.source})`);
+function getUnit(value = "") {
+	return value.match(VALUE_REGEX)?.[1];
+}
+function toPx(value = "") {
+	if (typeof value === "number") return `${value}px`;
+	const unit = getUnit(value);
+	if (!unit) return value;
+	if (unit === UNIT_PX) return value;
+	if (unit === UNIT_EM || unit === UNIT_REM) return `${parseFloat(value) * BASE_FONT_SIZE}${UNIT_PX}`;
+}
+function toEm(value = "", fontSize = BASE_FONT_SIZE) {
+	const unit = getUnit(value);
+	if (!unit) return value;
+	if (unit === UNIT_EM) return value;
+	if (unit === UNIT_PX) return `${parseFloat(value) / fontSize}${UNIT_EM}`;
+	if (unit === UNIT_REM) return `${parseFloat(value) * BASE_FONT_SIZE / fontSize}${UNIT_EM}`;
+}
+function toRem(value = "") {
+	const unit = getUnit(value);
+	if (!unit) return value;
+	if (unit === UNIT_REM) return value;
+	if (unit === UNIT_EM) return `${parseFloat(value)}${UNIT_REM}`;
+	if (unit === UNIT_PX) return `${parseFloat(value) / BASE_FONT_SIZE}${UNIT_REM}`;
+}
+//#endregion
+exports.BAMBOO_CONFIG_NAME = BAMBOO_CONFIG_NAME;
+exports.BambooError = BambooError;
+exports.CacheMap = CacheMap;
+exports.assign = assign;
+exports.astish = require_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.createRegex = createRegex;
+exports.cssVar = cssVar;
+exports.dashCase = dashCase;
+exports.deepSet = deepSet;
+exports.entries = entries;
+exports.esc = esc;
+exports.filterBaseConditions = require_uniq.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.getPropertyPriority = getPropertyPriority;
+exports.getSlotCompoundVariant = require_uniq.getSlotCompoundVariant;
+exports.getSlotRecipes = require_uniq.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.mapEntries = mapEntries;
+exports.mapObject = require_uniq.mapObject;
+exports.mapToJson = mapToJson;
+exports.markImportant = require_uniq.markImportant;
+exports.memo = require_uniq.memo;
+exports.mergeAndConcat = mergeAndConcat;
+exports.mergeProps = require_uniq.mergeProps;
+exports.mergeWith = mergeWith;
+exports.normalizeStyleObject = require_uniq.normalizeStyleObject;
+exports.omit = omit;
+exports.parseJson = parseJson;
+exports.patternFns = require_uniq.patternFns;
+exports.pick = pick;
+exports.splitBy = splitBy;
+exports.splitDotPath = splitDotPath;
+exports.splitProps = require_uniq.splitProps;
+exports.stringifyJson = stringifyJson;
+exports.toEm = toEm;
+exports.toHash = require_uniq.toHash;
+exports.toPx = toPx;
+exports.toRem = toRem;
+exports.toResponsiveObject = require_uniq.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;