react-native-css 3.0.0-nightly.75f8b74 → 3.0.0-nightly.9c84741

package/src/compiler/declarations.ts

@@ -3,11 +3,11 @@
 import Color from "colorjs.io";
 import type {
   Angle,
-  BorderBlockColor,
   BorderSideWidth,
   BorderStyle,
   ColorOrAuto,
   CssColor,
+  CustomProperty,
   Declaration,
   DimensionPercentageFor_LengthValue,
   EnvironmentVariable,
@@ -63,12 +63,16 @@ const propertyRename: Record<string, string> = {
   "background-image": "experimental_backgroundImage",
 };
 
+// TODO: We need a better way to handle this
 const unparsedRuntimeParsing = new Set([
   "animation",
+  "border",
+  "box-shadow",
   "text-shadow",
   "transform",
-  "box-shadow",
-  "border",
+  "scale",
+  "rotate",
+  "translate",
 ]);
 
 const parsers: {
@@ -92,37 +96,45 @@ const parsers: {
   "block-size": parseSizeDeclaration,
   "border": parseBorder,
   "border-block": parseBorderBlock,
-  "border-block-color": parseBorderBlockColor,
+  "border-block-color": parseBorderColor,
   "border-block-end": parseBorderBlockEnd,
   "border-block-end-color": parseColorDeclaration,
   "border-block-end-width": parseBorderSideWidthDeclaration,
   "border-block-start": parseBorderBlockStart,
   "border-block-start-color": parseColorDeclaration,
+  "border-block-start-style": parseBorderStyleDeclaration,
   "border-block-start-width": parseBorderSideWidthDeclaration,
+  "border-block-style": parseBorderBlockStyle,
   "border-block-width": parseBorderBlockWidth,
   "border-bottom": parseBorderSide,
   "border-bottom-color": parseColorDeclaration,
   "border-bottom-left-radius": parseSize2DDimensionPercentageDeclaration,
   "border-bottom-right-radius": parseSize2DDimensionPercentageDeclaration,
+  "border-bottom-style": parseBorderStyleDeclaration,
   "border-bottom-width": parseBorderSideWidthDeclaration,
   "border-color": parseBorderColor,
   "border-end-end-radius": parseSize2DDimensionPercentageDeclaration,
   "border-end-start-radius": parseSize2DDimensionPercentageDeclaration,
   "border-inline": parseBorderInline,
-  "border-inline-color": parseBorderBlockColor,
+  "border-inline-color": parseBorderColor,
   "border-inline-end": parseBorderInlineEnd,
   "border-inline-end-color": parseColorDeclaration,
+  "border-inline-end-style": parseBorderInlineStyle,
   "border-inline-end-width": parseBorderSideWidthDeclaration,
   "border-inline-start": parseBorderInlineStart,
   "border-inline-start-color": parseColorDeclaration,
+  "border-inline-start-style": parseBorderInlineStyle,
   "border-inline-start-width": parseBorderSideWidthDeclaration,
-  "border-inline-width": parseBorderBlockWidth,
+  "border-inline-style": parseBorderInlineStyle,
+  "border-inline-width": parseBorderInlineWidth,
   "border-left": parseBorderSide,
   "border-left-color": parseColorDeclaration,
+  "border-left-style": parseBorderStyleDeclaration,
   "border-left-width": parseBorderSideWidthDeclaration,
   "border-radius": parseBorderRadius,
   "border-right": parseBorderSide,
   "border-right-color": parseColorDeclaration,
+  "border-right-style": parseBorderStyleDeclaration,
   "border-right-width": parseBorderSideWidthDeclaration,
   "border-start-end-radius": parseSize2DDimensionPercentageDeclaration,
   "border-start-start-radius": parseSize2DDimensionPercentageDeclaration,
@@ -131,11 +143,12 @@ const parsers: {
   "border-top-color": parseColorDeclaration,
   "border-top-left-radius": parseSize2DDimensionPercentageDeclaration,
   "border-top-right-radius": parseSize2DDimensionPercentageDeclaration,
+  "border-top-style": parseBorderStyleDeclaration,
   "border-top-width": parseBorderSideWidthDeclaration,
   "border-width": parseBorderWidth,
   "bottom": parseSizeDeclaration,
   "box-shadow": parseBoxShadow,
-  "caret-color": parseColorOrAuto,
+  "caret-color": parseColorOrAutoDeclaration,
   "color": parseFontColorDeclaration,
   "column-gap": parseGap,
   "container": parseContainer,
@@ -227,6 +240,7 @@ const parsers: {
   "translate": parseTranslate,
   "user-select": parseUserSelect,
   "vertical-align": parseVerticalAlign,
+  "visibility": parseVisibility,
   "width": parseSizeDeclaration,
   "z-index": parseZIndex,
 };
@@ -256,9 +270,9 @@ export function parseDeclaration(
   }
 
   if (declaration.property === "unparsed") {
-    parseDeclarationUnparsed(declaration, builder);
+    parseUnparsedDeclaration(declaration, builder);
   } else if (declaration.property === "custom") {
-    parseDeclarationCustom(declaration, builder);
+    parseCustomDeclaration(declaration, builder);
   } else {
     parseWithParser(declaration, builder);
   }
@@ -270,6 +284,7 @@ function parseWithParser(declaration: Declaration, builder: StylesheetBuilder) {
 
     builder.descriptorProperty = declaration.property;
 
+    builder.setWarningProperty(declaration.property);
     const value = parser(declaration, builder, declaration.property);
 
     if (value !== undefined) {
@@ -343,15 +358,41 @@ function parseBorderRadius(
 }
 
 function parseBorderColor(
-  { value }: DeclarationType<"border-color">,
+  declaration: DeclarationType<
+    "border-color" | "border-block-color" | "border-inline-color"
+  >,
   builder: StylesheetBuilder,
 ) {
-  builder.addShorthand("border-color", {
-    "border-top-color": parseColor(value.top, builder),
-    "border-bottom-color": parseColor(value.bottom, builder),
-    "border-left-color": parseColor(value.left, builder),
-    "border-right-color": parseColor(value.right, builder),
-  });
+  switch (declaration.property) {
+    case "border-color":
+      builder.addShorthand("border-color", {
+        "border-top-color": parseColor(declaration.value.top, builder),
+        "border-bottom-color": parseColor(declaration.value.bottom, builder),
+        "border-left-color": parseColor(declaration.value.left, builder),
+        "border-right-color": parseColor(declaration.value.right, builder),
+      });
+      break;
+    case "border-block-color":
+      builder.addDescriptor(
+        "border-top-color",
+        parseColor(declaration.value.start, builder),
+      );
+      builder.addDescriptor(
+        "border-bottom-color",
+        parseColor(declaration.value.end, builder),
+      );
+      break;
+    case "border-inline-color":
+      builder.addDescriptor(
+        "border-left-color",
+        parseColor(declaration.value.start, builder),
+      );
+      builder.addDescriptor(
+        "border-right-color",
+        parseColor(declaration.value.end, builder),
+      );
+      break;
+  }
 }
 
 function parseBorderWidth(
@@ -397,18 +438,14 @@ function parseBorderBlock(
   { value }: DeclarationType<"border-block">,
   builder: StylesheetBuilder,
 ) {
-  builder.addDescriptor("border-top-color", parseColor(value.color, builder));
+  builder.addDescriptor("border-block-color", parseColor(value.color, builder));
   builder.addDescriptor(
-    "border-bottom-color",
-    parseColor(value.color, builder),
-  );
-  builder.addDescriptor(
-    "border-top-width",
+    "border-block-width",
     parseBorderSideWidth(value.width, builder),
   );
   builder.addDescriptor(
-    "border-bottom-width",
-    parseBorderSideWidth(value.width, builder),
+    "border-block-style",
+    parseBorderStyle(value.style, builder),
   );
 }
 
@@ -416,9 +453,12 @@ function parseBorderBlockStart(
   { value }: DeclarationType<"border-block-start">,
   builder: StylesheetBuilder,
 ) {
-  builder.addDescriptor("border-top-color", parseColor(value.color, builder));
   builder.addDescriptor(
-    "border-top-width",
+    "border-block-start-color",
+    parseColor(value.color, builder),
+  );
+  builder.addDescriptor(
+    "border-block-start-width",
     parseBorderSideWidth(value.width, builder),
   );
 }
@@ -428,11 +468,11 @@ function parseBorderBlockEnd(
   builder: StylesheetBuilder,
 ) {
   builder.addDescriptor(
-    "border-bottom-color",
+    "border-block-end-color",
     parseColor(value.color, builder),
   );
   builder.addDescriptor(
-    "border-bottom-width",
+    "border-block-end-width",
     parseBorderSideWidth(value.width, builder),
   );
 }
@@ -441,38 +481,94 @@ function parseBorderInline(
   { value }: DeclarationType<"border-inline">,
   builder: StylesheetBuilder,
 ) {
-  builder.addDescriptor("border-left-color", parseColor(value.color, builder));
-  builder.addDescriptor("border-right-color", parseColor(value.color, builder));
   builder.addDescriptor(
-    "border-left-width",
-    parseBorderSideWidth(value.width, builder),
+    "border-inline-color",
+    parseColor(value.color, builder),
   );
   builder.addDescriptor(
-    "border-right-width",
+    "border-inline-width",
     parseBorderSideWidth(value.width, builder),
   );
+  builder.addDescriptor(
+    "border-inline-style",
+    parseBorderStyle(value.style, builder),
+  );
 }
 
 function parseBorderInlineStart(
   { value }: DeclarationType<"border-inline-start">,
   builder: StylesheetBuilder,
 ) {
-  builder.addDescriptor("border-left-color", parseColor(value.color, builder));
   builder.addDescriptor(
-    "border-left-width",
+    "border-inline-start-color",
+    parseColor(value.color, builder),
+  );
+  builder.addDescriptor(
+    "border-inline-start-width",
     parseBorderSideWidth(value.width, builder),
   );
+  builder.addDescriptor(
+    "border-inline-start-style",
+    parseBorderStyle(value.style, builder),
+  );
 }
 
 function parseBorderInlineEnd(
   { value }: DeclarationType<"border-inline-end">,
   builder: StylesheetBuilder,
 ) {
-  builder.addDescriptor("border-right-color", parseColor(value.color, builder));
   builder.addDescriptor(
-    "border-right-width",
+    "border-inline-end-color",
+    parseColor(value.color, builder),
+  );
+  builder.addDescriptor(
+    "border-inline-end-width",
     parseBorderSideWidth(value.width, builder),
   );
+  builder.addDescriptor(
+    "border-inline-end-style",
+    parseBorderStyle(value.style, builder),
+  );
+}
+
+export function parseBorderInlineWidth(
+  declaration: DeclarationType<"border-inline-width">,
+  builder: StylesheetBuilder,
+) {
+  builder.addDescriptor(
+    "border-inline-width",
+    parseBorderSideWidth(declaration.value.start, builder),
+  );
+}
+
+export function parseBorderInlineStyle(
+  declaration: DeclarationType<
+    | "border-inline-style"
+    | "border-inline-start-style"
+    | "border-inline-end-style"
+  >,
+  builder: StylesheetBuilder,
+) {
+  if (typeof declaration.value === "string") {
+    builder.addDescriptor(
+      declaration.property,
+      parseBorderStyle(declaration.value, builder),
+    );
+  } else if (declaration.value.start === declaration.value.end) {
+    builder.addDescriptor(
+      declaration.property,
+      parseBorderStyle(declaration.value.start, builder),
+    );
+  } else {
+    builder.addDescriptor(
+      "border-inline-start-style",
+      parseBorderStyle(declaration.value.start, builder),
+    );
+    builder.addDescriptor(
+      "border-inline-end-style",
+      parseBorderStyle(declaration.value.end, builder),
+    );
+  }
 }
 
 function parseFlexFlow(
@@ -595,22 +691,22 @@ function parseTransform(
 ) {
   builder.addDescriptor("transform", [
     {},
-    "@transform",
+    "transform",
     value.flatMap((t): StyleDescriptor[] => {
       switch (t.type) {
         case "perspective":
-          return [[{}, "@perspective", parseLength(t.value, builder)]];
+          return [[{}, "perspective", parseLength(t.value, builder)]];
         case "translate":
           return [
             [
               {},
-              "@translateX",
+              "translateX",
               parseLengthOrCoercePercentageToRuntime(t.value[0], builder),
             ],
             [
               [
                 {},
-                "@translateY",
+                "translateY",
                 parseLengthOrCoercePercentageToRuntime(t.value[1], builder),
               ],
             ],
@@ -619,7 +715,7 @@ function parseTransform(
           return [
             [
               {},
-              "@translateX",
+              "translateX",
               parseLengthOrCoercePercentageToRuntime(t.value, builder),
             ],
           ];
@@ -627,22 +723,22 @@ function parseTransform(
           return [
             [
               {},
-              "@translateY",
+              "translateY",
               parseLengthOrCoercePercentageToRuntime(t.value, builder),
             ],
           ];
         case "rotate":
-          return [[{}, "@rotate", parseAngle(t.value, builder)]];
+          return [[{}, "rotate", parseAngle(t.value, builder)]];
         case "rotateX":
-          return [[{}, "@rotateX", parseAngle(t.value, builder)]];
+          return [[{}, "rotateX", parseAngle(t.value, builder)]];
         case "rotateY":
-          return [[{}, "@rotateY", parseAngle(t.value, builder)]];
+          return [[{}, "rotateY", parseAngle(t.value, builder)]];
         case "rotateZ":
-          return [[{}, "@rotateZ", parseAngle(t.value, builder)]];
+          return [[{}, "rotateZ", parseAngle(t.value, builder)]];
         case "scale":
           return [
-            [{}, "@scaleX", parseLength(t.value[0], builder)],
-            [{}, "@scaleY", parseLength(t.value[1], builder)],
+            [{}, "scaleX", parseLength(t.value[0], builder)],
+            [{}, "scaleY", parseLength(t.value[1], builder)],
           ];
         case "scaleX":
           return [[{}, "scaleX", parseLength(t.value, builder)]];
@@ -691,21 +787,29 @@ function parseRotate(
   { value }: DeclarationType<"rotate">,
   builder: StylesheetBuilder,
 ) {
-  builder.addDescriptor("rotateX", [
-    {},
-    "rotateX",
-    parseAngle(value.x, builder),
-  ]);
-  builder.addDescriptor("rotateY", [
-    {},
-    "rotateY",
-    parseAngle(value.y, builder),
-  ]);
-  builder.addDescriptor("rotateZ", [
-    {},
-    "rotateZ",
-    parseAngle(value.z, builder),
-  ]);
+  if (value.x) {
+    builder.addDescriptor("rotateX", [
+      {},
+      "rotateX",
+      parseAngle(value.angle, builder),
+    ]);
+  }
+
+  if (value.y) {
+    builder.addDescriptor("rotateY", [
+      {},
+      "rotateY",
+      parseAngle(value.angle, builder),
+    ]);
+  }
+
+  if (value.z) {
+    builder.addDescriptor("rotateZ", [
+      {},
+      "rotateZ",
+      parseAngle(value.angle, builder),
+    ]);
+  }
 }
 
 function parseScale(
@@ -743,7 +847,17 @@ function parseLetterSpacing(
   if (value.type === "normal") {
     return;
   }
-  return parseLength(value.value, builder);
+  const descriptor = parseLength(value.value, builder);
+
+  if (
+    Array.isArray(descriptor) &&
+    descriptor[1] === "em" &&
+    typeof descriptor[2] === "number"
+  ) {
+    return descriptor[2];
+  }
+
+  return descriptor;
 }
 
 function parseTextDecoration(
@@ -772,7 +886,11 @@ function parseZIndex(
   }
 }
 
-function parseContainerType(_value: unknown, _builder: StylesheetBuilder) {
+function parseContainerType(
+  _declaration: DeclarationType<"container-type">,
+  builder: StylesheetBuilder,
+) {
+  builder.addContainer(["___default___"]);
   return;
 }
 
@@ -792,7 +910,7 @@ function parseContainer(
   return;
 }
 
-export function parseDeclarationUnparsed(
+export function parseUnparsedDeclaration(
   declaration: Extract<Declaration, { property: "unparsed" }>,
   builder: StylesheetBuilder,
 ) {
@@ -803,6 +921,8 @@ export function parseDeclarationUnparsed(
     return;
   }
 
+  builder.setWarningProperty(property);
+
   /**
    * React Native doesn't support all the logical properties
    */
@@ -817,24 +937,15 @@ export function parseDeclarationUnparsed(
   builder.descriptorProperty = property;
 
   if (unparsedRuntimeParsing.has(property)) {
-    const args = parseUnparsed(declaration.value.value, builder);
+    const args = parseUnparsed(declaration.value.value, builder, property);
 
     if (property === "animation") {
-      builder.addDescriptor("animation", [
-        {},
-        `@${toRNProperty(property)}`,
-        args,
-      ]);
+      builder.addDescriptor("animation", [{}, property, args]);
     } else {
-      builder.addDescriptor(property, [
-        {},
-        `@${toRNProperty(property)}`,
-        args,
-        1,
-      ]);
+      builder.addDescriptor(property, [{}, toRNProperty(property), args, 1]);
     }
   } else {
-    const value = parseUnparsed(declaration.value.value, builder);
+    const value = parseUnparsed(declaration.value.value, builder, property);
 
     builder.addDescriptor(property, value);
 
@@ -848,19 +959,37 @@ export function parseDeclarationUnparsed(
   }
 }
 
-export function parseDeclarationCustom(
+export function parseCustomDeclaration(
   declaration: Extract<Declaration, { property: "custom" }>,
   builder: StylesheetBuilder,
 ) {
   const property = declaration.value.name;
-  if (
+
+  if (property === "-webkit-line-clamp") {
+    builder.addDescriptor(
+      property,
+      parseUnparsed(declaration.value.value, builder, property),
+    );
+  } else if (property === "-rn-ripple-style") {
+    builder.addDescriptor(
+      property,
+      parseUnparsed(declaration.value.value, builder, property) ===
+        "borderless",
+    );
+  } else if (property === "object-fit") {
+    // https://github.com/parcel-bundler/lightningcss/issues/1046
+    parseObjectFit(declaration.value, builder);
+  } else if (property === "object-position") {
+    // https://github.com/parcel-bundler/lightningcss/issues/1047
+    parseObjectPosition(declaration.value, builder);
+  } else if (
     validProperties.has(property) ||
     property.startsWith("--") ||
     property.startsWith("-rn-")
   ) {
     builder.addDescriptor(
       property,
-      parseUnparsed(declaration.value.value, builder, allowAuto.has(property)),
+      parseUnparsed(declaration.value.value, builder, property),
     );
   } else {
     builder.addWarning("property", declaration.value.name);
@@ -870,9 +999,13 @@ export function parseDeclarationCustom(
 export function reduceParseUnparsed(
   tokenOrValues: TokenOrValue[],
   builder: StylesheetBuilder,
+  property: string,
+  allowAuto: boolean,
 ): StyleDescriptor {
   const result = tokenOrValues
-    .map((tokenOrValue) => parseUnparsed(tokenOrValue, builder))
+    .map((tokenOrValue) =>
+      parseUnparsed(tokenOrValue, builder, property, allowAuto),
+    )
     .filter((v) => v !== undefined);
 
   if (result.length === 0) {
@@ -891,6 +1024,8 @@ export function reduceParseUnparsed(
     }
   }
 
+  // Groups are the tokens grouped together by comma location
+  // If a group only has 1 item, it shouldn't be an array
   groups = groups.flatMap((group): StyleDescriptor[] => {
     if (!Array.isArray(group)) {
       return [];
@@ -906,6 +1041,17 @@ export function reduceParseUnparsed(
       } else {
         return [first];
       }
+    } else if (
+      // This is a special case for <ratio> values
+      group.includes("/") &&
+      group.every((item) =>
+        typeof item === "string" && item === "/"
+          ? item
+          : typeof item === "number",
+      )
+    ) {
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      return [group.join(" ")];
     } else {
       return [group];
     }
@@ -917,11 +1063,13 @@ export function reduceParseUnparsed(
 export function unparsedFunction(
   token: Extract<TokenOrValue, { type: "function" }>,
   builder: StylesheetBuilder,
+  property: string,
+  allowAuto: boolean,
 ): StyleFunction {
   return [
     {},
-    token.value.name,
-    reduceParseUnparsed(token.value.arguments, builder),
+    toRNProperty(token.value.name),
+    reduceParseUnparsed(token.value.arguments, builder, property, allowAuto),
   ];
 }
 
@@ -938,7 +1086,8 @@ export function parseUnparsed(
     | undefined
     | null,
   builder: StylesheetBuilder,
-  allowAuto = false,
+  property: string,
+  allowAuto = allowAutoProperties.has(property),
 ): StyleDescriptor {
   if (tokenOrValue === undefined || tokenOrValue === null) {
     return;
@@ -961,7 +1110,12 @@ export function parseUnparsed(
   }
 
   if (Array.isArray(tokenOrValue)) {
-    const args = reduceParseUnparsed(tokenOrValue, builder);
+    const args = reduceParseUnparsed(
+      tokenOrValue,
+      builder,
+      property,
+      allowAuto,
+    );
     if (!args) return;
     if (Array.isArray(args) && args.length === 1) return args[0];
     return args;
@@ -969,11 +1123,21 @@ export function parseUnparsed(
 
   switch (tokenOrValue.type) {
     case "unresolved-color": {
-      return parseUnresolvedColor(tokenOrValue.value, builder);
+      return parseUnresolvedColor(
+        tokenOrValue.value,
+        builder,
+        property,
+        allowAuto,
+      );
     }
     case "var": {
       let args: StyleDescriptor = tokenOrValue.value.name.ident.slice(2);
-      const fallback = parseUnparsed(tokenOrValue.value.fallback, builder);
+      const fallback = parseUnparsed(
+        tokenOrValue.value.fallback,
+        builder,
+        property,
+        allowAuto,
+      );
       if (fallback !== undefined) {
         args = [args, fallback];
       }
@@ -982,43 +1146,53 @@ export function parseUnparsed(
     }
     case "function": {
       switch (tokenOrValue.value.name) {
-        case "translate":
-        case "rotate":
-        case "rotateX":
-        case "rotateY":
-        case "skewX":
-        case "skewY":
-        case "scale":
-        case "scaleX":
-        case "scaleY":
-        case "translateX":
-        case "translateY":
-          tokenOrValue.value.name = `@${tokenOrValue.value.name}`;
-          return unparsedFunction(tokenOrValue, builder);
+        case "blur":
         case "brightness":
         case "contrast":
         case "cubic-bezier":
         case "drop-shadow":
         case "fontScale":
+        case "getPixelSizeForLayoutSize":
         case "grayscale":
         case "hsl":
         case "hsla":
         case "hue-rotate":
         case "invert":
-        case "linear-gradient":
         case "opacity":
         case "pixelScale":
-        case "pixelSizeForLayoutSize":
         case "platformColor":
-        case "radial-gradient":
         case "rgb":
         case "rgba":
+        case "rotate":
+        case "rotateX":
+        case "rotateY":
         case "roundToNearestPixel":
         case "saturate":
+        case "scale":
+        case "scaleX":
+        case "scaleY":
         case "sepia":
         case "shadow":
+        case "skewX":
+        case "skewY":
         case "steps":
-          return unparsedFunction(tokenOrValue, builder);
+        case "translate":
+        case "translateX":
+        case "translateY":
+          return unparsedFunction(tokenOrValue, builder, property, allowAuto);
+        case "linear-gradient":
+        case "radial-gradient":
+          // These are special as React Native requires the '-' in their name
+          return [
+            {},
+            tokenOrValue.value.name,
+            reduceParseUnparsed(
+              tokenOrValue.value.arguments,
+              builder,
+              property,
+              allowAuto,
+            ),
+          ];
         case "hairlineWidth":
           return [{}, tokenOrValue.value.name, []];
         case "calc":
@@ -1029,9 +1203,10 @@ export function parseUnparsed(
             tokenOrValue.value.name,
             tokenOrValue.value.arguments,
             builder,
+            property,
           );
         default: {
-          builder.addWarning("function", tokenOrValue.value.name);
+          builder.addWarning("value", `${tokenOrValue.value.name}()`);
           return;
         }
       }
@@ -1050,7 +1225,7 @@ export function parseUnparsed(
             return;
           }
 
-          if (value === "inherit") {
+          if (value === "inherit" || value === "initial") {
             builder.addWarning("value", value);
             return;
           } else if (value === "currentcolor") {
@@ -1061,6 +1236,8 @@ export function parseUnparsed(
             return true;
           } else if (value === "false") {
             return false;
+          } else if (value === "infinity") {
+            return Number.MAX_SAFE_INTEGER;
           } else {
             return value;
           }
@@ -1077,11 +1254,16 @@ export function parseUnparsed(
           return parseDimension(tokenOrValue.value, builder);
         case "comma":
           return CommaSeparator as unknown as StyleDescriptor;
+        case "delim": {
+          if (tokenOrValue.value.value === "/") {
+            return tokenOrValue.value.value;
+          }
+          return;
+        }
         case "at-keyword":
         case "hash":
         case "id-hash":
         case "unquoted-url":
-        case "delim":
         case "white-space":
         case "comment":
         case "colon":
@@ -1152,23 +1334,35 @@ export function parseLength(
   const { inlineRem = 14 } = builder.getOptions();
 
   if (typeof length === "number") {
-    return length;
+    return round(length);
   }
 
   if ("unit" in length) {
     switch (length.unit) {
-      case "px":
-        return length.value;
+      case "px": {
+        if (length.value === Infinity) {
+          return 9999;
+        } else if (length.value === -Infinity) {
+          return -9999;
+        } else {
+          // Normalize large values to safe integers, e.g. `calc(infinity * 1px)`
+          const value = Math.max(
+            Math.min(length.value, Number.MAX_SAFE_INTEGER),
+            Number.MIN_SAFE_INTEGER,
+          );
+          return round(value);
+        }
+      }
       case "rem":
         if (typeof inlineRem === "number") {
           return length.value * inlineRem;
         } else {
-          return [{}, "rem", length.value];
+          return [{}, "rem", round(length.value)];
         }
       case "vw":
       case "vh":
       case "em":
-        return [{}, length.unit, length.value, 1];
+        return [{}, length.unit, round(length.value), 1];
       case "in":
       case "cm":
       case "mm":
@@ -1251,7 +1445,7 @@ export function parseAngle(angle: Angle | number, builder: StylesheetBuilder) {
     case "rad":
       return `${angle.value}${angle.type}`;
     default:
-      builder.addWarning("value", angle.value);
+      builder.addWarning("value", `${angle.value} ${angle.type}`);
       return undefined;
   }
 }
@@ -1334,7 +1528,7 @@ export function parseSize(
   return;
 }
 
-export function parseColorOrAuto(
+export function parseColorOrAutoDeclaration(
   { value }: { value: ColorOrAuto },
   builder: StylesheetBuilder,
 ) {
@@ -1836,7 +2030,10 @@ export function parseOverflow(
 }
 
 export function parseBorderStyleDeclaration(
-  declaration: DeclarationType<"border-style">,
+  declaration: Extract<
+    DeclarationType<Declaration["property"]>,
+    { value: LineStyle | BorderStyle }
+  >,
   builder: StylesheetBuilder,
 ) {
   return parseBorderStyle(declaration.value, builder);
@@ -1869,34 +2066,53 @@ export function parseBorderStyle(
   return undefined;
 }
 
-export function parseBorderBlockColor(
-  { value }: { value: BorderBlockColor },
+export function parseBorderBlockWidth(
+  declaration: DeclarationType<"border-block-width">,
   builder: StylesheetBuilder,
 ) {
-  builder.addDescriptor("border-top-color", parseColor(value.start, builder));
-  builder.addDescriptor("border-bottom-color", parseColor(value.end, builder));
-  return;
+  const start = parseBorderSideWidth(declaration.value.start, builder);
+  const end = parseBorderSideWidth(declaration.value.end, builder);
+
+  if (start === end) {
+    builder.addDescriptor("border-block-width", start);
+  } else {
+    builder.addDescriptor("border-block-start-width", start);
+    builder.addDescriptor("border-block-end-width", end);
+  }
 }
 
-export function parseBorderBlockWidth(
-  declaration: DeclarationType<"border-block-width" | "border-inline-width">,
+function parseBorderBlockStyle(
+  declaration: DeclarationType<"border-block-style">,
   builder: StylesheetBuilder,
 ) {
-  builder.addDescriptor(
-    "border-top-width",
-    parseBorderSideWidth(declaration.value.start, builder),
-  );
-  builder.addDescriptor(
-    "border-bottom-width",
-    parseBorderSideWidth(declaration.value.end, builder),
-  );
+  const start = parseBorderStyle(declaration.value.start, builder);
+  const end = parseBorderStyle(declaration.value.end, builder);
+
+  if (start == end) {
+    builder.addDescriptor("border-block-style", start);
+  } else {
+    builder.addDescriptor("border-block-start-style", start);
+    builder.addDescriptor("border-block-end-style", end);
+  }
 }
 
 export function parseBorderSideWidthDeclaration(
-  declaration: { value: BorderSideWidth },
+  declaration: DeclarationType<
+    | "border-block-end-width"
+    | "border-block-start-width"
+    | "border-bottom-width"
+    | "border-inline-end-width"
+    | "border-inline-start-width"
+    | "border-left-width"
+    | "border-right-width"
+    | "border-top-width"
+  >,
   builder: StylesheetBuilder,
 ) {
-  return parseBorderSideWidth(declaration.value, builder);
+  builder.addDescriptor(
+    declaration.property,
+    parseBorderSideWidth(declaration.value, builder),
+  );
 }
 
 export function parseBorderSideWidth(
@@ -1959,7 +2175,8 @@ export function parseLineHeight(
         case "percentage":
         case "calc":
           builder.addWarning(
-            "value",
+            "style",
+            "line-height",
             typeof length.value === "number"
               ? length.value
               : JSON.stringify(length.value),
@@ -2222,7 +2439,11 @@ export function parseDimension(
 ): StyleDescriptor {
   switch (unit) {
     case "px":
-      return value;
+      if (value === Infinity) {
+        return 9999;
+      } else {
+        return value;
+      }
     case "%":
       return `${value}%`;
     case "rnh":
@@ -2249,20 +2470,24 @@ export function parseUserSelect(
 }
 
 export function parseSVGPaint(
-  { value }: DeclarationType<"fill" | "stroke">,
+  { value, property }: DeclarationType<"fill" | "stroke">,
   builder: StylesheetBuilder,
 ) {
+  let parsedValue: StyleDescriptor | undefined;
+
   if (value.type === "none") {
-    return "transparent";
+    parsedValue = "transparent";
   } else if (value.type === "color") {
-    return parseColor(value.value, builder);
+    parsedValue = parseColor(value.value, builder);
+  } else {
+    return;
   }
 
-  return;
+  builder.addDescriptor(property, parsedValue);
 }
 
 export function round(number: number) {
-  return Math.round((number + Number.EPSILON) * 100) / 100;
+  return Math.round((number + Number.EPSILON) * 10000) / 10000;
 }
 
 export function parseDimensionPercentageFor_LengthValue(
@@ -2278,7 +2503,7 @@ export function parseDimensionPercentageFor_LengthValue(
   }
 }
 
-const allowAuto = new Set(["pointer-events"]);
+const allowAutoProperties = new Set(["pointer-events"]);
 
 export function parseEnv(
   value: EnvironmentVariable,
@@ -2296,7 +2521,7 @@ export function parseEnv(
             "var",
             [
               `--react-native-css-${value.name.value}`,
-              parseUnparsed(value.fallback, builder),
+              parseUnparsed(value.fallback, builder, value.name.value),
             ],
             1,
           ];
@@ -2319,8 +2544,9 @@ export function parseCalcFn(
   name: string,
   tokens: TokenOrValue[],
   builder: StylesheetBuilder,
+  property: string,
 ): StyleDescriptor {
-  const args = parseCalcArguments(tokens, builder);
+  const args = parseCalcArguments(tokens, builder, property);
   if (args) {
     return [{}, name, args];
   }
@@ -2331,12 +2557,11 @@ export function parseCalcFn(
 export function parseCalcArguments(
   [...args]: TokenOrValue[],
   builder: StylesheetBuilder,
+  property: string,
 ) {
   const parsed: StyleDescriptor[] = [];
 
-  let mode: "number" | "percentage" | undefined;
-
-  for (const [currentIndex, arg] of args.entries()) {
+  for (const arg of args) {
     switch (arg.type) {
       case "env": {
         parsed.push(parseEnv(arg.value, builder));
@@ -2345,7 +2570,7 @@ export function parseCalcArguments(
       case "var":
       case "function":
       case "unresolved-color": {
-        const value = parseUnparsed(arg, builder);
+        const value = parseUnparsed(arg, builder, property);
 
         if (value === undefined) {
           return undefined;
@@ -2356,11 +2581,9 @@ export function parseCalcArguments(
       }
       case "length": {
         const value = parseLength(arg.value, builder);
-
         if (value !== undefined) {
           parsed.push(value);
         }
-
         break;
       }
       case "color":
@@ -2383,49 +2606,19 @@ export function parseCalcArguments(
             }
             break;
           case "percentage":
-            mode ??= "percentage";
-            if (mode !== "percentage") return;
-            parsed.push(`${arg.value.value * 100}%`);
+            parsed.push(`${round(arg.value.value * 100)}%`);
             break;
           case "number": {
-            mode ??= "number";
-            if (mode !== "number") return;
-            parsed.push(arg.value.value);
+            parsed.push(round(arg.value.value));
             break;
           }
           case "parenthesis-block": {
-            /**
-             * If we have a parenthesis block, we just treat it as a nested calc function
-             * Because there could be multiple parenthesis blocks, this is recursive
-             */
-            let closeParenthesisIndex = -1;
-            for (let index = args.length - 1; index > 0; index--) {
-              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-              const value = args[index]!;
-              if (
-                value.type === "token" &&
-                value.value.type === "close-parenthesis"
-              ) {
-                closeParenthesisIndex = index;
-                break;
-              }
-            }
-
-            if (closeParenthesisIndex === -1) {
-              return;
-            }
-
-            const innerCalcArgs = args
-              // Extract the inner calcArgs including the parenthesis. This mutates args
-              .splice(currentIndex, closeParenthesisIndex - currentIndex + 1)
-              // Then drop the surrounding parenthesis
-              .slice(1, -1);
-
-            parsed.push(parseCalcFn("calc", innerCalcArgs, builder));
-
+            parsed.push("(");
             break;
           }
           case "close-parenthesis":
+            parsed.push(")");
+            break;
           case "string":
           case "function":
           case "ident":
@@ -2474,6 +2667,8 @@ export function parseTranslateProp(
 export function parseUnresolvedColor(
   color: UnresolvedColor,
   builder: StylesheetBuilder,
+  property: string,
+  allowAuto: boolean,
 ): StyleDescriptor {
   switch (color.type) {
     case "rgb":
@@ -2484,26 +2679,31 @@ export function parseUnresolvedColor(
           round(color.r * 255),
           round(color.g * 255),
           round(color.b * 255),
-          parseUnparsed(color.alpha, builder),
+          parseUnparsed(color.alpha, builder, property),
         ],
       ];
     case "hsl":
       return [
         {},
         color.type,
-        [color.h, color.s, color.l, parseUnparsed(color.alpha, builder)],
+        [
+          color.h,
+          color.s,
+          color.l,
+          parseUnparsed(color.alpha, builder, property),
+        ],
       ];
     case "light-dark": {
       const extraRule = builder.extendRule({
         m: [["=", "prefers-color-scheme", "dark"]],
       });
       builder.addUnnamedDescriptor(
-        reduceParseUnparsed(color.dark, builder),
+        reduceParseUnparsed(color.dark, builder, property, allowAuto),
         false,
         extraRule,
       );
       builder.addExtraRule(extraRule);
-      return reduceParseUnparsed(color.light, builder);
+      return reduceParseUnparsed(color.light, builder, property, allowAuto);
     }
     default:
       color satisfies never;
@@ -2600,7 +2800,12 @@ export function addTransitionValue(
         declaration.property,
         declaration.value
           .map((v) => v.property)
-          .filter((v) => v in parsers || v === "all" || v === "none")
+          .filter(
+            (v) =>
+              (v in parsers && !["visibility"].includes(v)) ||
+              v === "all" ||
+              v === "none",
+          )
           .map((v) => toRNProperty(v)),
       );
       return;
@@ -2749,7 +2954,7 @@ function parseGradient(
     case "linear": {
       return [
         {},
-        "@linear-gradient",
+        "linear-gradient",
         [
           parseLineDirection(gradient.direction, builder),
           ...gradient.items.map((item) => parseGradientItem(item, builder)),
@@ -2799,6 +3004,46 @@ function parseGradientItem(
   }
 }
 
+function parseObjectFit(
+  declaration: CustomProperty,
+  builder: StylesheetBuilder,
+) {
+  builder.addMapping({
+    "object-fit": "contentFit",
+  });
+  builder.addDescriptor(
+    "object-fit",
+    parseUnparsed(declaration.value, builder, "object-fit"),
+  );
+}
+
+function parseObjectPosition(
+  declaration: CustomProperty,
+  builder: StylesheetBuilder,
+) {
+  builder.addMapping({
+    "object-position": "contentPosition",
+  });
+  builder.addDescriptor("object-position", [
+    {},
+    "join",
+    [parseUnparsed(declaration.value, builder, "object-position"), " "],
+  ]);
+}
+
+function parseVisibility(
+  declaration: DeclarationType<"visibility">,
+  builder: StylesheetBuilder,
+) {
+  if (declaration.value === "visible") {
+    builder.addDescriptor("opacity", 1);
+  } else if (declaration.value === "hidden") {
+    builder.addDescriptor("opacity", 0);
+  } else {
+    builder.addWarning("value", declaration.value);
+  }
+}
+
 function parseFilter(
   declaration: DeclarationType<"filter">,
   builder: StylesheetBuilder,
@@ -2826,6 +3071,16 @@ function parseFilter(
             [value.type]: parseAngle(value.value, builder),
           } as unknown as StyleDescriptor;
         case "drop-shadow":
+          return [
+            {},
+            toRNProperty(value.type),
+            [
+              parseLength(value.value.xOffset, builder),
+              parseLength(value.value.yOffset, builder),
+              parseLength(value.value.blur, builder),
+              parseColor(value.value.color, builder),
+            ],
+          ] as unknown as StyleDescriptor;
         case "url":
           return;
       }