@colorye/react-native-css 0.3.0

package/dist/utils/babel.js

@@ -0,0 +1,363 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.areAllClassesStatic = areAllClassesStatic;
+exports.computeStaticStyles = computeStaticStyles;
+exports.getInheritStyleExpression = getInheritStyleExpression;
+exports.getRootInheritStyleExpression = getRootInheritStyleExpression;
+exports.getStaticClassNameValue = getStaticClassNameValue;
+exports.getStaticMergeExpression = getStaticMergeExpression;
+exports.getStyleExpression = getStyleExpression;
+exports.inlineStaticAttributes = inlineStaticAttributes;
+exports.isClassStatic = isClassStatic;
+exports.isFragmentElement = isFragmentElement;
+exports.isImportOrRequire = isImportOrRequire;
+exports.isRootLevelJSXElement = isRootLevelJSXElement;
+exports.isStaticClassName = isStaticClassName;
+exports.objectToAST = objectToAST;
+exports.tryGetStaticStyleInfo = tryGetStaticStyleInfo;
+var _transformerRuntime = _interopRequireDefault(require("../transformer-runtime.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function isImportOrRequire(statement) {
+  var _statement$node;
+  return statement.isImportDeclaration() || ((_statement$node = statement.node) === null || _statement$node === void 0 || (_statement$node = _statement$node.declarations) === null || _statement$node === void 0 || (_statement$node = _statement$node[0]) === null || _statement$node === void 0 || (_statement$node = _statement$node.init) === null || _statement$node === void 0 || (_statement$node = _statement$node.callee) === null || _statement$node === void 0 ? void 0 : _statement$node.name) === "require";
+}
+function isFragmentElement(t, elementName) {
+  return t.isJSXIdentifier(elementName) && (elementName.name === "Fragment" || elementName.name === "React.Fragment") || t.isJSXMemberExpression(elementName) && elementName.object.name === "React" && elementName.property.name === "Fragment" || t.isJSXIdentifier(elementName, {
+    name: ""
+  }) // JSX shorthand fragment
+;
+}
+function isRootLevelJSXElement(path) {
+  var currentPath = path;
+  while (currentPath.parentPath) {
+    var parent = currentPath.parentPath;
+    if (parent.isReturnStatement()) return true;
+    if (parent.isArrowFunctionExpression() && parent.node.body === currentPath.node) return true;
+    if (parent.isJSXElement() && parent !== path) return false;
+    if (parent.isConditionalExpression() || parent.isLogicalExpression() || parent.isParenthesizedExpression()) {
+      currentPath = parent;
+      continue;
+    }
+    currentPath = parent;
+  }
+  return false;
+}
+
+// ============================================================================
+// Static style detection helpers
+// ============================================================================
+
+/**
+ * Check if className is a static string literal
+ */
+function isStaticClassName(t, classNameAttr) {
+  if (!classNameAttr) return false;
+  if (t.isStringLiteral(classNameAttr.value)) return true;
+  if (t.isJSXExpressionContainer(classNameAttr.value) && t.isStringLiteral(classNameAttr.value.expression)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Get static className string value
+ */
+function getStaticClassNameValue(t, classNameAttr) {
+  if (!classNameAttr) return null;
+  if (t.isStringLiteral(classNameAttr.value)) return classNameAttr.value.value;
+  if (t.isJSXExpressionContainer(classNameAttr.value) && t.isStringLiteral(classNameAttr.value.expression)) {
+    return classNameAttr.value.expression.value;
+  }
+  return null;
+}
+
+/**
+ * Check if a class is fully static (no dynamic breakpoint / dark mode queries)
+ */
+function isClassStatic(stylesheet, className) {
+  if (!className) return true;
+  if (className === "group" || className.startsWith("group") || className.startsWith("peer") || className.startsWith("active:") || className.startsWith("pressed:") || className.startsWith("disabled:") || className.startsWith("dark:") || className.startsWith("light:") || className.startsWith("sm:") || className.startsWith("md:") || className.startsWith("lg:") || className.startsWith("xl:") || className.startsWith("2xl:") || className.startsWith("portrait:") || className.startsWith("landscape:")) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Check if all classes in className string are static
+ */
+function areAllClassesStatic(stylesheet, classNameValue) {
+  if (!classNameValue || !stylesheet) return false;
+  var classes = classNameValue.trim().split(/\s+/).filter(Boolean);
+  return classes.every(function (cls) {
+    return isClassStatic(stylesheet, cls);
+  });
+}
+
+/**
+ * Compute merged static styles from className string using Runtime compiler
+ */
+function computeStaticStyles(stylesheet, classNameValue) {
+  if (!classNameValue || !stylesheet) return {};
+  try {
+    var computed = _transformerRuntime["default"].getStyle(stylesheet, [undefined, classNameValue, undefined]);
+    return computed || {};
+  } catch (_unused) {
+    return {};
+  }
+}
+
+/**
+ * Inlines static className and contentContainerClassName attributes directly into styles
+ */
+function inlineStaticAttributes(path, state, t) {
+  if (!state.stylesheetData) return;
+  var openingElement = path.node.openingElement;
+  var stylesheet = state.stylesheetData;
+  var classPropMappings = [{
+    classProp: "className",
+    styleProp: "style"
+  }, {
+    classProp: "contentContainerClassName",
+    styleProp: "contentContainerStyle"
+  }];
+  var _loop = function _loop() {
+      var _classPropMappings$_i = _classPropMappings[_i],
+        classProp = _classPropMappings$_i.classProp,
+        styleProp = _classPropMappings$_i.styleProp;
+      var classAttrIndex = openingElement.attributes.findIndex(function (attr) {
+        var _attr$name;
+        return t.isJSXAttribute(attr) && ((_attr$name = attr.name) === null || _attr$name === void 0 ? void 0 : _attr$name.name) === classProp;
+      });
+      if (classAttrIndex === -1) return 0; // continue
+      var classAttr = openingElement.attributes[classAttrIndex];
+      if (!isStaticClassName(t, classAttr)) return 0; // continue
+      var classValue = getStaticClassNameValue(t, classAttr);
+      if (!classValue || !areAllClassesStatic(stylesheet, classValue)) return 0; // continue
+      var staticStyles = computeStaticStyles(stylesheet, classValue);
+      if (!staticStyles || Object.keys(staticStyles).length === 0) return 0; // continue
+      var styleAST = objectToAST(t, staticStyles);
+
+      // Find existing style prop if present
+      var existingStyle = openingElement.attributes.find(function (attr) {
+        var _attr$name2;
+        return t.isJSXAttribute(attr) && ((_attr$name2 = attr.name) === null || _attr$name2 === void 0 ? void 0 : _attr$name2.name) === styleProp;
+      });
+      if (existingStyle) {
+        var currentVal = t.isJSXExpressionContainer(existingStyle.value) ? existingStyle.value.expression : existingStyle.value;
+        existingStyle.value = t.jsxExpressionContainer(t.arrayExpression([styleAST, currentVal]));
+      } else {
+        openingElement.attributes.push(t.jsxAttribute(t.jsxIdentifier(styleProp), t.jsxExpressionContainer(styleAST)));
+      }
+
+      // Remove the static class attribute to achieve zero runtime parsing
+      openingElement.attributes.splice(classAttrIndex, 1);
+    },
+    _ret;
+  for (var _i = 0, _classPropMappings = classPropMappings; _i < _classPropMappings.length; _i++) {
+    _ret = _loop();
+    if (_ret === 0) continue;
+  }
+}
+
+/**
+ * Convert JavaScript object to Babel AST
+ */
+function objectToAST(t, obj) {
+  if (obj === null || obj === undefined) return t.nullLiteral();
+  if (Array.isArray(obj)) {
+    return t.arrayExpression(obj.map(function (item) {
+      return objectToAST(t, item);
+    }));
+  }
+  if (_typeof(obj) === "object") {
+    return t.objectExpression(Object.entries(obj).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      return t.objectProperty(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? t.identifier(key) : t.stringLiteral(key), objectToAST(t, value));
+    }));
+  }
+  if (typeof obj === "string") return t.stringLiteral(obj);
+  if (typeof obj === "number") return t.numericLiteral(obj);
+  if (typeof obj === "boolean") return t.booleanLiteral(obj);
+  return t.nullLiteral();
+}
+
+/**
+ * Try to get static style info for an element
+ * Returns { staticStyles, hasInheritStyle, inlineStyleExpr } or null if not static
+ */
+function tryGetStaticStyleInfo(path, state, t) {
+  var openingElement = path.node.openingElement;
+  var classNameAttr = openingElement.attributes.find(function (attr) {
+    var _attr$name3;
+    return t.isJSXAttribute(attr) && ((_attr$name3 = attr.name) === null || _attr$name3 === void 0 ? void 0 : _attr$name3.name) === "className";
+  });
+
+  // Check if className is static
+  if (!isStaticClassName(t, classNameAttr)) return null;
+
+  // Get stylesheet
+  var stylesheet = state.stylesheetData;
+  if (!stylesheet) return null;
+  var classNameValue = getStaticClassNameValue(t, classNameAttr);
+  if (!classNameValue) return null;
+
+  // Check if all classes are fully static
+  if (!areAllClassesStatic(stylesheet, classNameValue)) return null;
+
+  // Compute static styles from className
+  var staticStyles = computeStaticStyles(stylesheet, classNameValue);
+
+  // Get inheritStyle attribute (for mergeStyles call)
+  var inheritStyleAttr = openingElement.attributes.find(function (attr) {
+    var _attr$name4;
+    return t.isJSXAttribute(attr) && ((_attr$name4 = attr.name) === null || _attr$name4 === void 0 ? void 0 : _attr$name4.name) === "inheritStyle";
+  });
+
+  // Get style attribute
+  var styleAttr = openingElement.attributes.find(function (attr) {
+    var _attr$name5;
+    return t.isJSXAttribute(attr) && ((_attr$name5 = attr.name) === null || _attr$name5 === void 0 ? void 0 : _attr$name5.name) === "style";
+  });
+  return {
+    staticStyles: staticStyles,
+    inheritStyleAttr: inheritStyleAttr,
+    styleAttr: styleAttr
+  };
+}
+
+/**
+ * Generate mergeStyles(inheritStyle, staticStyles, inlineStyle) expression
+ */
+function getStaticMergeExpression(path, state, t, staticInfo) {
+  var _inheritStyleAttr$val, _styleAttr$value;
+  var staticStyles = staticInfo.staticStyles,
+    inheritStyleAttr = staticInfo.inheritStyleAttr,
+    styleAttr = staticInfo.styleAttr;
+
+  // Get inheritStyle expression
+  var propInheritStyle = getMemoizedInheritStyleExpression(path, t);
+  var inheritStyleExpr = inheritStyleAttr === null || inheritStyleAttr === void 0 || (_inheritStyleAttr$val = inheritStyleAttr.value) === null || _inheritStyleAttr$val === void 0 ? void 0 : _inheritStyleAttr$val.expression;
+
+  // Build inheritStyle array: [props.inheritStyle, explicitInheritStyle]
+  var inheritArg;
+  if (propInheritStyle || inheritStyleExpr) {
+    inheritArg = t.arrayExpression([propInheritStyle || t.nullLiteral(), inheritStyleExpr || t.nullLiteral()]);
+  } else {
+    inheritArg = t.nullLiteral();
+  }
+
+  // Static styles as inline object
+  var staticArg = Object.keys(staticStyles).length > 0 ? objectToAST(t, staticStyles) : t.nullLiteral();
+
+  // Inline style expression
+  var inlineArg = (styleAttr === null || styleAttr === void 0 || (_styleAttr$value = styleAttr.value) === null || _styleAttr$value === void 0 ? void 0 : _styleAttr$value.expression) || t.nullLiteral();
+
+  // mergeStyles(inheritStyle, staticStyles, inlineStyle)
+  return t.callExpression(state.mergeStylesId, [inheritArg, staticArg, inlineArg]);
+}
+
+// ============================================================================
+// InheritStyle helpers
+// ============================================================================
+
+var inheritStyleMemo = new WeakMap();
+function getMemoizedInheritStyleExpression(path, t) {
+  var currentPath = path;
+  var funcPath = null;
+  while (currentPath && !funcPath) {
+    if (currentPath.isFunction()) {
+      funcPath = currentPath;
+      break;
+    }
+    currentPath = currentPath.parentPath;
+  }
+  if (!funcPath) return undefined;
+  if (inheritStyleMemo.has(funcPath.node)) {
+    return inheritStyleMemo.get(funcPath.node);
+  }
+  var result;
+  var params = funcPath.node.params;
+  var parentPath = funcPath.parentPath;
+  if (parentPath && parentPath.isCallExpression() && parentPath.node.callee && parentPath.node.callee.type === "Identifier" && ["useMemo", "useCallback"].includes(parentPath.node.callee.name)) {
+    result = undefined;
+  } else if (params.length === 0) {
+    funcPath.node.params = [t.identifier("props")];
+    result = t.memberExpression(t.identifier("props"), t.identifier("inheritStyle"), false, false);
+  } else if (params.length > 0) {
+    var firstParam = params[0];
+    if (t.isIdentifier(firstParam)) {
+      result = t.memberExpression(firstParam, t.identifier("inheritStyle"), false, false);
+    } else if (t.isObjectPattern(firstParam)) {
+      var restElement = firstParam.properties.find(function (p) {
+        return t.isRestElement(p);
+      });
+      if (restElement) {
+        result = t.memberExpression(restElement.argument, t.identifier("inheritStyle"), false, false);
+      } else {
+        var restProp = t.restElement(t.identifier("rest"));
+        firstParam.properties.push(restProp);
+        result = t.memberExpression(t.identifier("rest"), t.identifier("inheritStyle"), false, false);
+      }
+    }
+  }
+  inheritStyleMemo.set(funcPath.node, result);
+  return result;
+}
+
+// ============================================================================
+// Style expression generators (for dynamic/fallback cases)
+// ============================================================================
+
+function getStyleExpression(path, state, t) {
+  var openingElement = path.node.openingElement;
+  var elementName = openingElement.name;
+  var propInheritStyle = getMemoizedInheritStyleExpression(path, t);
+  var inheritStyle = openingElement.attributes.find(function (attr) {
+    var _attr$name6;
+    return ((_attr$name6 = attr.name) === null || _attr$name6 === void 0 ? void 0 : _attr$name6.name) === "inheritStyle";
+  });
+  var className = openingElement.attributes.find(function (attr) {
+    var _attr$name7;
+    return ((_attr$name7 = attr.name) === null || _attr$name7 === void 0 ? void 0 : _attr$name7.name) === "className";
+  });
+  var style = openingElement.attributes.find(function (attr) {
+    var _attr$name8;
+    return ((_attr$name8 = attr.name) === null || _attr$name8 === void 0 ? void 0 : _attr$name8.name) === "style";
+  });
+  return t.callExpression(state.getStyleId, [state.stylesheetId, t.arrayExpression([t.arrayExpression([propInheritStyle || t.nullLiteral(), inheritStyle && inheritStyle.value.expression || t.nullLiteral()]), className && (t.isStringLiteral(className.value) ? t.stringLiteral(className.value.value) : className.value.expression) || t.nullLiteral(), style && style.value.expression || t.nullLiteral(), t.isJSXIdentifier(elementName) ? t.stringLiteral(elementName.name) : t.isJSXMemberExpression(elementName) ? t.stringLiteral("".concat(elementName.object.name, ".").concat(elementName.property.name)) : t.stringLiteral("Unknown")])]);
+}
+function getInheritStyleExpression(path, state, t) {
+  var _inheritStyle$value, _styleAttr$value2;
+  var openingElement = path.node.openingElement;
+  var inheritStyle = openingElement.attributes.find(function (attr) {
+    var _attr$name9;
+    return ((_attr$name9 = attr.name) === null || _attr$name9 === void 0 ? void 0 : _attr$name9.name) === "inheritStyle";
+  });
+  var propInheritStyle = getMemoizedInheritStyleExpression(path, t);
+  var inheritStyleExpr = (inheritStyle === null || inheritStyle === void 0 || (_inheritStyle$value = inheritStyle.value) === null || _inheritStyle$value === void 0 ? void 0 : _inheritStyle$value.expression) || propInheritStyle;
+  var classNameAttr = openingElement.attributes.find(function (attr) {
+    var _attr$name0;
+    return ((_attr$name0 = attr.name) === null || _attr$name0 === void 0 ? void 0 : _attr$name0.name) === "className";
+  });
+  var styleAttr = openingElement.attributes.find(function (attr) {
+    var _attr$name1;
+    return ((_attr$name1 = attr.name) === null || _attr$name1 === void 0 ? void 0 : _attr$name1.name) === "style";
+  });
+  return t.callExpression(state.getInheritStyleId, [t.callExpression(state.getStyleId, [state.stylesheetId, t.arrayExpression([inheritStyleExpr || t.nullLiteral(), (classNameAttr === null || classNameAttr === void 0 ? void 0 : classNameAttr.value) && (t.isStringLiteral(classNameAttr.value) ? t.stringLiteral(classNameAttr.value.value) : classNameAttr.value.expression) || t.nullLiteral(), (styleAttr === null || styleAttr === void 0 || (_styleAttr$value2 = styleAttr.value) === null || _styleAttr$value2 === void 0 ? void 0 : _styleAttr$value2.expression) || t.nullLiteral(), t.isJSXIdentifier(openingElement.name) ? t.stringLiteral(openingElement.name.name) : t.isJSXMemberExpression(openingElement.name) ? t.stringLiteral("".concat(openingElement.name.object.name, ".").concat(openingElement.name.property.name)) : t.stringLiteral("Unknown")])])]);
+}
+function getRootInheritStyleExpression(path, t) {
+  var propInheritStyle = getMemoizedInheritStyleExpression(path, t);
+  return propInheritStyle || t.identifier("undefined");
+}

package/dist/utils/css.js

@@ -0,0 +1,263 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseStylesheetWithLightning = parseStylesheetWithLightning;
+var _lightningcss = require("lightningcss");
+var _helper = require("./helper");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Unwrap @layer and @supports blocks to expose standard CSS rules
+ */
+function flattenBlocks(cssStr) {
+  var result = "";
+  var i = 0;
+  var len = cssStr.length;
+  while (i < len) {
+    // Skip comments
+    if (cssStr[i] === "/" && cssStr[i + 1] === "*") {
+      var commentEnd = cssStr.indexOf("*/", i + 2);
+      if (commentEnd === -1) {
+        result += cssStr.substring(i);
+        break;
+      }
+      result += cssStr.substring(i, commentEnd + 2);
+      i = commentEnd + 2;
+      continue;
+    }
+
+    // Skip strings
+    if (cssStr[i] === '"' || cssStr[i] === "'") {
+      var _char = cssStr[i];
+      var strEnd = i + 1;
+      while (strEnd < len) {
+        if (cssStr[strEnd] === "\\") {
+          strEnd += 2;
+        } else if (cssStr[strEnd] === _char) {
+          strEnd++;
+          break;
+        } else {
+          strEnd++;
+        }
+      }
+      result += cssStr.substring(i, strEnd);
+      i = strEnd;
+      continue;
+    }
+
+    // Check for at-rules
+    if (cssStr[i] === "@") {
+      var remaining = cssStr.substring(i);
+      var layerMatch = remaining.match(/^@(layer|supports|property)[^{]*\{/i);
+      if (layerMatch) {
+        var layerType = layerMatch[1].toLowerCase();
+        // Skip @layer base entirely because React Native views should not inherit browser base resets (* { border: 0 solid; margin: 0 })
+        var isLayerBase = /^@layer\s+base\s*\{/i.test(layerMatch[0]);
+        if (layerType === "property" || isLayerBase) {
+          var _braceCount = 1;
+          var _j = i + layerMatch[0].length;
+          while (_j < len && _braceCount > 0) {
+            if (cssStr[_j] === "{") _braceCount++;else if (cssStr[_j] === "}") _braceCount--;
+            _j++;
+          }
+          i = _j;
+          continue;
+        }
+        var braceCount = 1;
+        var j = i + layerMatch[0].length;
+        var innerContent = "";
+        while (j < len && braceCount > 0) {
+          if (cssStr[j] === "{") braceCount++;else if (cssStr[j] === "}") braceCount--;
+          if (braceCount > 0) innerContent += cssStr[j];
+          j++;
+        }
+        result += flattenBlocks(innerContent);
+        i = j;
+        continue;
+      }
+    }
+    result += cssStr[i];
+    i++;
+  }
+  return result;
+}
+
+/**
+ * Parse and lower modern CSS using LightningCSS (Rust-based engine)
+ * Handles OKLCH, color-mix, CSS nesting, @layer, and @media range queries
+ */
+function parseStylesheetWithLightning(rawCss) {
+  var transformed = (0, _lightningcss.transform)({
+    filename: "input.css",
+    code: Buffer.from(rawCss),
+    targets: {
+      safari: 14 << 16
+    },
+    minify: false
+  });
+  var cssText = flattenBlocks(transformed.code.toString());
+  var rawStylesheet = {};
+  var cleanSelector = function cleanSelector(sel) {
+    if (sel.includes(":root")) return [":root"];
+    var s = sel.trim();
+    if (!s.startsWith(".")) return [];
+
+    // Strip leading dot
+    s = s.slice(1);
+
+    // Extract class name (handling escaped chars like active\:scale-95, w-\[48\%\], etc.)
+    var classPart = "";
+    var i = 0;
+    while (i < s.length) {
+      if (s[i] === "\\") {
+        if (i + 1 < s.length) {
+          classPart += s[i + 1];
+          i += 2;
+          continue;
+        }
+      }
+      if (s[i] === ":" || s[i] === " " || s[i] === ">" || s[i] === "~" || s[i] === "+") {
+        break;
+      }
+      classPart += s[i];
+      i++;
+    }
+    if (!classPart) return [];
+    var names = [classPart];
+
+    // For variants like disabled:bg-navy-300 or active:opacity-80, also register the base class name
+    if (classPart.startsWith("disabled:") || classPart.startsWith("active:") || classPart.startsWith("pressed:")) {
+      var base = classPart.replace(/^(disabled|active|pressed):/, "");
+      if (base && !names.includes(base)) {
+        names.push(base);
+      }
+    }
+    return names;
+  };
+  var parseDeclarations = function parseDeclarations(bodyText) {
+    var decls = {};
+    var parts = bodyText.split(";");
+    var _iterator = _createForOfIteratorHelper(parts),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var part = _step.value;
+        var trimmed = part.trim();
+        if (!trimmed) continue;
+        var colonIdx = trimmed.indexOf(":");
+        if (colonIdx === -1) continue;
+        var prop = trimmed.slice(0, colonIdx).trim();
+        var val = trimmed.slice(colonIdx + 1).trim();
+        if (!prop || !val) continue;
+        if (prop.startsWith("--")) {
+          decls[prop] = val;
+        } else {
+          decls[(0, _helper.camelize)(prop)] = val;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return decls;
+  };
+
+  // 1. Separate media query blocks
+  var mediaBlocks = [];
+  var noMediaCss = cssText.replace(/@media\s*([^{]+)\{([\s\S]+?\}\s*)\}/g, function (_, query, inner) {
+    mediaBlocks.push({
+      query: query.trim(),
+      inner: inner
+    });
+    return "";
+  });
+
+  // 2. Parse regular rules
+  var ruleRe = /([^{}]+)\{([^{}]+)\}/g;
+  var match;
+  while ((match = ruleRe.exec(noMediaCss)) !== null) {
+    var rawSelectors = match[1].trim();
+    var body = match[2].trim();
+    if (rawSelectors.startsWith("@")) continue;
+    var selectors = rawSelectors.split(",").map(function (s) {
+      return s.trim();
+    });
+    var decls = parseDeclarations(body);
+    var _iterator2 = _createForOfIteratorHelper(selectors),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var sel = _step2.value;
+        if (!sel.startsWith(".") && !sel.includes(":root")) continue;
+        var names = cleanSelector(sel);
+        var _iterator3 = _createForOfIteratorHelper(names),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var name = _step3.value;
+            rawStylesheet[name] = _objectSpread(_objectSpread({}, rawStylesheet[name]), decls);
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+
+  // 3. Parse media query rules
+  for (var _i = 0, _mediaBlocks = mediaBlocks; _i < _mediaBlocks.length; _i++) {
+    var mb = _mediaBlocks[_i];
+    var mMatch = void 0;
+    var mRuleRe = /([^{}]+)\{([^{}]+)\}/g;
+    while ((mMatch = mRuleRe.exec(mb.inner)) !== null) {
+      var _rawSelectors = mMatch[1].trim();
+      var _body = mMatch[2].trim();
+      var _selectors = _rawSelectors.split(",").map(function (s) {
+        return s.trim();
+      });
+      var _decls = parseDeclarations(_body);
+      var _iterator4 = _createForOfIteratorHelper(_selectors),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _sel = _step4.value;
+          if (!_sel.startsWith(".") && !_sel.includes(":root")) continue;
+          var _names = cleanSelector(_sel);
+          var _iterator5 = _createForOfIteratorHelper(_names),
+            _step5;
+          try {
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var _name = _step5.value;
+              rawStylesheet[_name] = _objectSpread(_objectSpread({}, rawStylesheet[_name]), {}, _defineProperty({}, "@media ".concat(mb.query), _decls));
+            }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    }
+  }
+  return rawStylesheet;
+}

package/dist/utils/helper.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.camelize = camelize;
+function camelize(str) {
+  return str.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, function (_, chr) {
+    return chr.toUpperCase();
+  });
+}