@bamboocss/shared 1.11.1

package/dist/index.js

@@ -0,0 +1,1557 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BAMBOO_CONFIG_NAME: () => BAMBOO_CONFIG_NAME,
+  BambooError: () => BambooError,
+  CacheMap: () => CacheMap,
+  assign: () => assign,
+  astish: () => astish,
+  calc: () => calc,
+  camelCaseProperty: () => camelCaseProperty,
+  capitalize: () => capitalize,
+  compact: () => compact,
+  createCss: () => createCss,
+  createMergeCss: () => createMergeCss,
+  createRegex: () => createRegex,
+  cssVar: () => cssVar,
+  dashCase: () => dashCase,
+  deepSet: () => deepSet,
+  entries: () => entries,
+  esc: () => esc2,
+  filterBaseConditions: () => filterBaseConditions,
+  flatten: () => flatten,
+  fromEntries: () => fromEntries,
+  getArbitraryValue: () => getArbitraryValue,
+  getDotPath: () => getDotPath,
+  getNegativePath: () => getNegativePath,
+  getOrCreateSet: () => getOrCreateSet,
+  getPatternStyles: () => getPatternStyles,
+  getPropertyPriority: () => getPropertyPriority,
+  getSlotCompoundVariant: () => getSlotCompoundVariant,
+  getSlotRecipes: () => getSlotRecipes,
+  getUnit: () => getUnit,
+  hypenateProperty: () => hypenateProperty,
+  isBaseCondition: () => isBaseCondition,
+  isBoolean: () => isBoolean,
+  isCssFunction: () => isCssFunction,
+  isCssUnit: () => isCssUnit,
+  isCssVar: () => isCssVar2,
+  isFunction: () => isFunction,
+  isImportant: () => isImportant,
+  isObject: () => isObject,
+  isObjectOrArray: () => isObjectOrArray,
+  isString: () => isString,
+  isSymbol: () => isSymbol,
+  mapEntries: () => mapEntries,
+  mapObject: () => mapObject,
+  mapToJson: () => mapToJson,
+  markImportant: () => markImportant,
+  memo: () => memo,
+  mergeAndConcat: () => mergeAndConcat,
+  mergeProps: () => mergeProps,
+  mergeWith: () => mergeWith,
+  normalizeStyleObject: () => normalizeStyleObject,
+  omit: () => omit,
+  parseJson: () => parseJson,
+  patternFns: () => patternFns,
+  pick: () => pick,
+  splitBy: () => splitBy,
+  splitDotPath: () => splitDotPath,
+  splitProps: () => splitProps,
+  stringifyJson: () => stringifyJson,
+  toEm: () => toEm,
+  toHash: () => toHash,
+  toPx: () => toPx,
+  toRem: () => toRem,
+  toResponsiveObject: () => toResponsiveObject,
+  traverse: () => traverse,
+  uncapitalize: () => uncapitalize,
+  unionType: () => unionType,
+  uniq: () => uniq,
+  walkObject: () => walkObject,
+  withoutImportant: () => withoutImportant,
+  withoutSpace: () => withoutSpace
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/arbitrary-value.ts
+var 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;
+};
+
+// src/assert.ts
+var isString = (v) => typeof v === "string";
+var isBoolean = (v) => typeof v === "boolean";
+var isFunction = (v) => typeof v === "function";
+function isObject(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value);
+}
+var isSymbol = (v) => typeof v === "symbol";
+var isObjectOrArray = (obj) => typeof obj === "object" && obj !== null;
+
+// 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;
+}
+
+// src/astish.ts
+var newRule = /(?:([\u0080-\uFFFF\w-%@]+) *:? *([^{;]+?);|([^;}{]*?) *{)|(}\s*)/g;
+var ruleClean = /\/\*[^]*?\*\/|  +/g;
+var ruleNewline = /\n+/g;
+var empty = " ";
+var 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];
+};
+
+// 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 void 0;
+    }
+    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(callback2, thisArg) {
+    this.cache.forEach(callback2, 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, callback2) {
+    if (this.cache.has(key)) {
+      this.updateKeyUsage(key);
+      return this.cache.get(key);
+    }
+    const value = callback2(key);
+    this.set(key, value);
+    return value;
+  }
+  [Symbol.iterator]() {
+    return this.cache[Symbol.iterator]();
+  }
+  [Symbol.toStringTag] = "CacheMap";
+  toJSON = () => {
+    return this.cache;
+  };
+};
+
+// src/calc.ts
+function isCssVar(value) {
+  return isObject(value) && "ref" in value;
+}
+function getRef(operand) {
+  return isCssVar(operand) ? operand.ref : operand.toString();
+}
+var calcRegex = /calc/g;
+var toExpression = (operator, ...operands) => operands.map(getRef).join(` ${operator} `).replace(calcRegex, "");
+var multiply = (...operands) => `calc(${toExpression("*", ...operands)})`;
+var 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);
+  }
+};
+
+// src/memo.ts
+var 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;
+};
+
+// src/camelcase-property.ts
+var regex = /-(\w|$)/g;
+var callback = (_dashChar, char) => char.toUpperCase();
+var camelCaseProperty = memo((property) => {
+  if (property.startsWith("--")) return property;
+  let str = property.toLowerCase();
+  str = str.startsWith("-ms-") ? str.substring(1) : str;
+  return str.replace(regex, callback);
+});
+
+// src/capitalize.ts
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+var camelCaseRegex = /([a-z])([A-Z])/g;
+var dashCase = (s) => s.replace(camelCaseRegex, "$1-$2").toLowerCase();
+var uncapitalize = (s) => s.charAt(0).toLowerCase() + s.slice(1);
+
+// src/compact.ts
+function compact(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([_, value2]) => value2 !== void 0));
+}
+
+// src/condition.ts
+var isBaseCondition = (v) => v === "base";
+function filterBaseConditions(c) {
+  return c.slice().filter((v) => !isBaseCondition(v));
+}
+
+// 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);
+}
+
+// src/important.ts
+var 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: obj2, result: result2 } = stack.pop();
+    for (const [key, value] of Object.entries(obj2)) {
+      if (typeof value === "string" || typeof value === "number") {
+        result2[key] = `${value} !important`;
+      } else if (typeof value === "object" && value !== null) {
+        const next = Array.isArray(value) ? [] : {};
+        result2[key] = next;
+        stack.push({ obj: value, result: next });
+      } else {
+        result2[key] = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/merge-props.ts
+var MERGE_OMIT = /* @__PURE__ */ 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.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;
+  }, {});
+}
+
+// src/walk-object.ts
+var 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));
+}
+
+// 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
+    }
+  );
+}
+
+// src/classname.ts
+var fallbackCondition = {
+  shift: (v) => v,
+  finalize: (v) => v,
+  breakpoints: { keys: [] }
+};
+var sanitize = (value) => typeof value === "string" ? value.replaceAll(/[\n\s]+/g, " ") : value;
+var ENTRY_SEP = "]___[";
+var 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 {
+      const baseArray = [...conds.finalize(conditions), formatClassName(className)];
+      result = baseArray.join(":");
+    }
+    return result;
+  };
+  if (grouped) {
+    return memo(({ base, ...styles } = {}) => {
+      const styleObject = Object.assign(styles, base);
+      const normalizedObject = normalizeStyleObject(styleObject, 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("|");
+      const shortHash = utility.toHash(["grouped", groupId], toHash);
+      return formatClassName(shortHash);
+    });
+  }
+  return memo(({ base, ...styles } = {}) => {
+    const styleObject = Object.assign(styles, base);
+    const normalizedObject = normalizeStyleObject(styleObject, context);
+    const classNames = /* @__PURE__ */ new Set();
+    walkObject(normalizedObject, (value, paths) => {
+      if (value == null) return;
+      const important = isImportant(value);
+      const [prop, ...allConditions] = conds.shift(paths);
+      const conditions = filterBaseConditions(allConditions);
+      const transformed = utility.transform(prop, withoutImportant(sanitize(value)));
+      let className = hashFn(conditions, transformed.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 };
+}
+
+// src/css-var.ts
+var escRegex = /[^a-zA-Z0-9_\u0081-\uffff-]/g;
+function esc(string) {
+  return `${string}`.replace(escRegex, (s) => `\\${s}`);
+}
+var dashCaseRegex = /[A-Z]/g;
+function dashCase2(string) {
+  return string.replace(dashCaseRegex, (match) => `-${match.toLowerCase()}`);
+}
+function cssVar(name, options = {}) {
+  const { fallback = "", prefix = "", hash } = options;
+  const variable = hash ? ["-", prefix, toHash(name)].filter(Boolean).join("-") : dashCase2(["-", prefix, esc(name)].filter(Boolean).join("-"));
+  const result = {
+    var: variable,
+    ref: `var(${variable}${fallback ? `, ${fallback}` : ""})`
+  };
+  return result;
+}
+
+// src/deep-set.ts
+var deepSet = (target, path, 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 && isObject(current[key])) {
+        current[key] = mergeProps(current[key], value);
+      } else {
+        current[key] = value;
+      }
+    } else {
+      current = current[key];
+    }
+  }
+  return target;
+};
+
+// src/entries.ts
+function fromEntries(entries2) {
+  const result = {};
+  entries2.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;
+}
+
+// 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;
+  }
+};
+
+// src/esc.ts
+var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|^-|[^\x80-\uFFFF\w-]/g;
+var fcssescape = function(ch, asCodePoint) {
+  if (!asCodePoint) return "\\" + ch;
+  if (ch === "\0") return "\uFFFD";
+  if (ch === "-" && ch.length === 1) return "\\-";
+  return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16);
+};
+var esc2 = (sel) => {
+  return (sel + "").replace(rcssescape, fcssescape);
+};
+
+// src/flatten.ts
+function filterDefault(path) {
+  if (path[0] === "DEFAULT") return path;
+  return path.filter((item) => item !== "DEFAULT");
+}
+function flatten(values, stop) {
+  const result = {};
+  walkObject(
+    values,
+    (token, paths) => {
+      paths = filterDefault(paths);
+      if (token) {
+        result[paths.join(".")] = token.value;
+      }
+    },
+    {
+      stop: stop ?? ((v) => {
+        return isObject(v) && "value" in v;
+      })
+    }
+  );
+  return result;
+}
+
+// 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;
+}
+
+// src/hypenate-property.ts
+var wordRegex = /([A-Z])/g;
+var msRegex = /^ms-/;
+var hypenateProperty = memo((property) => {
+  if (property.startsWith("--")) return property;
+  return property.replace(wordRegex, "-$1").replace(msRegex, "-ms-").toLowerCase();
+});
+
+// src/is-css-function.ts
+var fns = ["min", "max", "clamp", "calc"];
+var fnRegExp = new RegExp(`^(${fns.join("|")})\\(.*\\)`);
+var isCssFunction = (v) => typeof v === "string" && fnRegExp.test(v);
+
+// src/is-css-unit.ts
+var lengthUnits = "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,%";
+var lengthUnitsPattern = `(?:${lengthUnits.split(",").join("|")})`;
+var lengthRegExp = new RegExp(`^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?${lengthUnitsPattern}$`);
+var isCssUnit = (v) => typeof v === "string" && lengthRegExp.test(v);
+
+// src/is-css-var.ts
+var isCssVar2 = (v) => typeof v === "string" && /^var\(--.+\)$/.test(v);
+
+// src/merge-anything.ts
+var MERGE_OMIT2 = /* @__PURE__ */ 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 (!isObject(newComer)) return newComer;
+  let newObject = {};
+  if (isObject(origin)) {
+    const props2 = Object.getOwnPropertyNames(origin);
+    const symbols2 = Object.getOwnPropertySymbols(origin);
+    newObject = [...props2, ...symbols2].reduce(
+      (carry, key) => {
+        if (isString(key) && MERGE_OMIT2.has(key)) return carry;
+        const targetVal = origin[key];
+        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);
+  const result = [...props, ...symbols].reduce((carry, key) => {
+    if (isString(key) && MERGE_OMIT2.has(key)) return carry;
+    let newVal = newComer[key];
+    const targetVal = isObject(origin) ? origin[key] : void 0;
+    if (targetVal !== void 0 && isObject(newVal)) {
+      newVal = mergeRecursively(targetVal, newVal, compareFn);
+    }
+    const propToAssign = compareFn ? compareFn(targetVal, newVal, key) : newVal;
+    assignProp(carry, key, propToAssign, newComer);
+    return carry;
+  }, newObject);
+  return result;
+}
+function mergeAndConcat(object, ...otherObjects) {
+  return otherObjects.reduce((result, newComer) => {
+    return mergeRecursively(result, newComer, concatArrays);
+  }, object);
+}
+
+// src/merge-with.ts
+var MERGE_OMIT3 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function mergeWith(target, ...sources) {
+  const customizer = sources.pop();
+  for (const source of sources) {
+    for (const key in source) {
+      if (isString(key) && MERGE_OMIT3.has(key)) continue;
+      const merged = customizer(target[key], source[key]);
+      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;
+      }
+    }
+  }
+  return target;
+}
+
+// src/traverse.ts
+var defaultOptions = {
+  separator: ".",
+  maxDepth: Infinity
+};
+function traverse(obj, callback2, 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) {
+      callback2(currentItem);
+    }
+    if (options.stop?.(currentItem)) {
+      continue;
+    }
+    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];
+        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
+        });
+      }
+    }
+  }
+}
+
+// src/omit.ts
+var omit = (obj, paths) => {
+  const result = { ...obj };
+  traverse(result, ({ path, parent, key }) => {
+    if (paths.includes(path)) {
+      delete parent[key];
+    }
+  });
+  return result;
+};
+
+// src/bamboo-config-name.ts
+var BAMBOO_CONFIG_NAME = "__bamboo.config__";
+
+// src/pattern-fns.ts
+var patternFns = {
+  map: mapObject,
+  isCssFunction,
+  isCssVar: isCssVar2,
+  isCssUnit
+};
+var 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));
+};
+
+// 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;
+}
+
+// src/pick.ts
+var pick = (obj, paths) => {
+  const result = {};
+  traverse(obj, ({ path, value }) => {
+    if (paths.includes(path)) {
+      const pathParts = splitDotPath(path);
+      deepSet(result, pathParts, value);
+    }
+  });
+  return result;
+};
+
+// src/property-priority.ts
+var longHandPhysical = /* @__PURE__ */ new Set();
+var longHandLogical = /* @__PURE__ */ new Set();
+var shorthandsOfLonghands = /* @__PURE__ */ new Set();
+var 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;
+}
+
+// src/regex.ts
+var createRegex = (item) => {
+  const regex2 = item.map((item2) => typeof item2 === "string" ? `^${item2}$` : item2.source).join("|");
+  return new RegExp(regex2);
+};
+
+// src/serialize.ts
+var stringifyJson = (config) => {
+  return JSON.stringify(config, (_key, value) => {
+    if (typeof value === "function") return value.toString();
+    return value;
+  });
+};
+var parseJson = (config) => {
+  return JSON.parse(config);
+};
+
+// src/slot.ts
+var 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 slots = recipe.slots ?? [];
+  const recipeParts = 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);
+};
+var getSlotCompoundVariant = (compoundVariants, slotName) => compoundVariants.filter((compoundVariant) => compoundVariant.css[slotName]).map((compoundVariant) => ({ ...compoundVariant, css: compoundVariant.css[slotName] }));
+
+// 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));
+}
+
+// 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;
+}
+
+// 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(" | ");
+}
+
+// src/uniq.ts
+var 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);
+};
+
+// src/unit-conversion.ts
+var BASE_FONT_SIZE = 16;
+var UNIT_PX = "px";
+var UNIT_EM = "em";
+var UNIT_REM = "rem";
+var DIGIT_REGEX = new RegExp(String.raw`-?\d+(?:\.\d+|\d*)`);
+var UNIT_REGEX = new RegExp(`${UNIT_PX}|${UNIT_EM}|${UNIT_REM}`);
+var VALUE_REGEX = new RegExp(`${DIGIT_REGEX.source}(${UNIT_REGEX.source})`);
+function getUnit(value = "") {
+  const unit = value.match(VALUE_REGEX);
+  return unit?.[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}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BAMBOO_CONFIG_NAME,
+  BambooError,
+  CacheMap,
+  assign,
+  astish,
+  calc,
+  camelCaseProperty,
+  capitalize,
+  compact,
+  createCss,
+  createMergeCss,
+  createRegex,
+  cssVar,
+  dashCase,
+  deepSet,
+  entries,
+  esc,
+  filterBaseConditions,
+  flatten,
+  fromEntries,
+  getArbitraryValue,
+  getDotPath,
+  getNegativePath,
+  getOrCreateSet,
+  getPatternStyles,
+  getPropertyPriority,
+  getSlotCompoundVariant,
+  getSlotRecipes,
+  getUnit,
+  hypenateProperty,
+  isBaseCondition,
+  isBoolean,
+  isCssFunction,
+  isCssUnit,
+  isCssVar,
+  isFunction,
+  isImportant,
+  isObject,
+  isObjectOrArray,
+  isString,
+  isSymbol,
+  mapEntries,
+  mapObject,
+  mapToJson,
+  markImportant,
+  memo,
+  mergeAndConcat,
+  mergeProps,
+  mergeWith,
+  normalizeStyleObject,
+  omit,
+  parseJson,
+  patternFns,
+  pick,
+  splitBy,
+  splitDotPath,
+  splitProps,
+  stringifyJson,
+  toEm,
+  toHash,
+  toPx,
+  toRem,
+  toResponsiveObject,
+  traverse,
+  uncapitalize,
+  unionType,
+  uniq,
+  walkObject,
+  withoutImportant,
+  withoutSpace
+});