@mgcrea/react-native-tailwind 0.2.0

package/dist/babel/index.cjs

@@ -0,0 +1,1111 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/babel/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => reactNativeTailwindBabelPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parser/borders.ts
+var BORDER_WIDTH_SCALE = {
+  "": 1,
+  "0": 0,
+  "2": 2,
+  "4": 4,
+  "8": 8
+};
+var BORDER_RADIUS_SCALE = {
+  none: 0,
+  sm: 2,
+  "": 4,
+  md: 6,
+  lg: 8,
+  xl: 12,
+  "2xl": 16,
+  "3xl": 24,
+  full: 9999
+};
+function parseBorder(cls) {
+  if (cls.startsWith("border-")) {
+    return parseBorderWidth(cls);
+  }
+  if (cls === "border") {
+    return { borderWidth: 1 };
+  }
+  if (cls.startsWith("rounded")) {
+    return parseBorderRadius(cls);
+  }
+  if (cls === "border-solid") return { borderStyle: "solid" };
+  if (cls === "border-dotted") return { borderStyle: "dotted" };
+  if (cls === "border-dashed") return { borderStyle: "dashed" };
+  return null;
+}
+function parseBorderWidth(cls) {
+  const allArbMatch = cls.match(/^border-\[(\d+)(?:px)?\]$/);
+  if (allArbMatch) {
+    return { borderWidth: parseInt(allArbMatch[1], 10) };
+  }
+  const dirArbMatch = cls.match(/^border-([trbl])-\[(\d+)(?:px)?\]$/);
+  if (dirArbMatch) {
+    const dir = dirArbMatch[1];
+    const value = parseInt(dirArbMatch[2], 10);
+    const propMap = {
+      t: "borderTopWidth",
+      r: "borderRightWidth",
+      b: "borderBottomWidth",
+      l: "borderLeftWidth"
+    };
+    return { [propMap[dir]]: value };
+  }
+  const dirMatch = cls.match(/^border-([trbl])-?(\d*)$/);
+  if (dirMatch) {
+    const dir = dirMatch[1];
+    const scaleKey = dirMatch[2] || "";
+    const value = BORDER_WIDTH_SCALE[scaleKey];
+    if (typeof value === "number") {
+      const propMap = {
+        t: "borderTopWidth",
+        r: "borderRightWidth",
+        b: "borderBottomWidth",
+        l: "borderLeftWidth"
+      };
+      return { [propMap[dir]]: value };
+    }
+  }
+  const allMatch = cls.match(/^border-(\d+)$/);
+  if (allMatch) {
+    const value = BORDER_WIDTH_SCALE[allMatch[1]];
+    if (value !== void 0) {
+      return { borderWidth: value };
+    }
+  }
+  return null;
+}
+function parseBorderRadius(cls) {
+  const allArbMatch = cls.match(/^rounded-\[(\d+)(?:px)?\]$/);
+  if (allArbMatch) {
+    return { borderRadius: parseInt(allArbMatch[1], 10) };
+  }
+  const cornerArbMatch = cls.match(/^rounded-(tl|tr|bl|br)-\[(\d+)(?:px)?\]$/);
+  if (cornerArbMatch) {
+    const corner = cornerArbMatch[1];
+    const value = parseInt(cornerArbMatch[2], 10);
+    const propMap = {
+      tl: "borderTopLeftRadius",
+      tr: "borderTopRightRadius",
+      bl: "borderBottomLeftRadius",
+      br: "borderBottomRightRadius"
+    };
+    return { [propMap[corner]]: value };
+  }
+  const sideArbMatch = cls.match(/^rounded-([trbl])-\[(\d+)(?:px)?\]$/);
+  if (sideArbMatch) {
+    const side = sideArbMatch[1];
+    const value = parseInt(sideArbMatch[2], 10);
+    const propMap = {
+      t: ["borderTopLeftRadius", "borderTopRightRadius"],
+      r: ["borderTopRightRadius", "borderBottomRightRadius"],
+      b: ["borderBottomLeftRadius", "borderBottomRightRadius"],
+      l: ["borderTopLeftRadius", "borderBottomLeftRadius"]
+    };
+    const result = {};
+    propMap[side].forEach((prop) => result[prop] = value);
+    return result;
+  }
+  const allMatch = cls.match(/^rounded(-\w+)?$/);
+  if (allMatch) {
+    const scaleKey = allMatch[1] ? allMatch[1].substring(1) : "";
+    const value = BORDER_RADIUS_SCALE[scaleKey];
+    if (value !== void 0) {
+      return { borderRadius: value };
+    }
+  }
+  const sideMatch = cls.match(/^rounded-([trbl])(?:-(\w+))?$/);
+  if (sideMatch) {
+    const side = sideMatch[1];
+    const scaleKey = sideMatch[2] || "";
+    const value = BORDER_RADIUS_SCALE[scaleKey];
+    if (value !== void 0) {
+      const propMap = {
+        t: ["borderTopLeftRadius", "borderTopRightRadius"],
+        r: ["borderTopRightRadius", "borderBottomRightRadius"],
+        b: ["borderBottomLeftRadius", "borderBottomRightRadius"],
+        l: ["borderTopLeftRadius", "borderBottomLeftRadius"]
+      };
+      const result = {};
+      propMap[side].forEach((prop) => result[prop] = value);
+      return result;
+    }
+  }
+  const cornerMatch = cls.match(/^rounded-(tl|tr|bl|br)(?:-(\w+))?$/);
+  if (cornerMatch) {
+    const corner = cornerMatch[1];
+    const scaleKey = cornerMatch[2] || "";
+    const value = BORDER_RADIUS_SCALE[scaleKey];
+    if (value !== void 0) {
+      const propMap = {
+        tl: "borderTopLeftRadius",
+        tr: "borderTopRightRadius",
+        bl: "borderBottomLeftRadius",
+        br: "borderBottomRightRadius"
+      };
+      return { [propMap[corner]]: value };
+    }
+  }
+  return null;
+}
+
+// src/parser/colors.ts
+var COLORS = {
+  // Gray
+  "gray-50": "#F9FAFB",
+  "gray-100": "#F3F4F6",
+  "gray-200": "#E5E7EB",
+  "gray-300": "#D1D5DB",
+  "gray-400": "#9CA3AF",
+  "gray-500": "#6B7280",
+  "gray-600": "#4B5563",
+  "gray-700": "#374151",
+  "gray-800": "#1F2937",
+  "gray-900": "#111827",
+  // Red
+  "red-50": "#FEF2F2",
+  "red-100": "#FEE2E2",
+  "red-200": "#FECACA",
+  "red-300": "#FCA5A5",
+  "red-400": "#F87171",
+  "red-500": "#EF4444",
+  "red-600": "#DC2626",
+  "red-700": "#B91C1C",
+  "red-800": "#991B1B",
+  "red-900": "#7F1D1D",
+  // Blue
+  "blue-50": "#EFF6FF",
+  "blue-100": "#DBEAFE",
+  "blue-200": "#BFDBFE",
+  "blue-300": "#93C5FD",
+  "blue-400": "#60A5FA",
+  "blue-500": "#3B82F6",
+  "blue-600": "#2563EB",
+  "blue-700": "#1D4ED8",
+  "blue-800": "#1E40AF",
+  "blue-900": "#1E3A8A",
+  // Green
+  "green-50": "#F0FDF4",
+  "green-100": "#DCFCE7",
+  "green-200": "#BBF7D0",
+  "green-300": "#86EFAC",
+  "green-400": "#4ADE80",
+  "green-500": "#22C55E",
+  "green-600": "#16A34A",
+  "green-700": "#15803D",
+  "green-800": "#166534",
+  "green-900": "#14532D",
+  // Yellow
+  "yellow-50": "#FEFCE8",
+  "yellow-100": "#FEF9C3",
+  "yellow-200": "#FEF08A",
+  "yellow-300": "#FDE047",
+  "yellow-400": "#FACC15",
+  "yellow-500": "#EAB308",
+  "yellow-600": "#CA8A04",
+  "yellow-700": "#A16207",
+  "yellow-800": "#854D0E",
+  "yellow-900": "#713F12",
+  // Purple
+  "purple-50": "#FAF5FF",
+  "purple-100": "#F3E8FF",
+  "purple-200": "#E9D5FF",
+  "purple-300": "#D8B4FE",
+  "purple-400": "#C084FC",
+  "purple-500": "#A855F7",
+  "purple-600": "#9333EA",
+  "purple-700": "#7E22CE",
+  "purple-800": "#6B21A8",
+  "purple-900": "#581C87",
+  // Pink
+  "pink-50": "#FDF2F8",
+  "pink-100": "#FCE7F3",
+  "pink-200": "#FBCFE8",
+  "pink-300": "#F9A8D4",
+  "pink-400": "#F472B6",
+  "pink-500": "#EC4899",
+  "pink-600": "#DB2777",
+  "pink-700": "#BE185D",
+  "pink-800": "#9D174D",
+  "pink-900": "#831843",
+  // Orange
+  "orange-50": "#FFF7ED",
+  "orange-100": "#FFEDD5",
+  "orange-200": "#FED7AA",
+  "orange-300": "#FDBA74",
+  "orange-400": "#FB923C",
+  "orange-500": "#F97316",
+  "orange-600": "#EA580C",
+  "orange-700": "#C2410C",
+  "orange-800": "#9A3412",
+  "orange-900": "#7C2D12",
+  // Indigo
+  "indigo-50": "#EEF2FF",
+  "indigo-100": "#E0E7FF",
+  "indigo-200": "#C7D2FE",
+  "indigo-300": "#A5B4FC",
+  "indigo-400": "#818CF8",
+  "indigo-500": "#6366F1",
+  "indigo-600": "#4F46E5",
+  "indigo-700": "#4338CA",
+  "indigo-800": "#3730A3",
+  "indigo-900": "#312E81",
+  // Basic colors
+  white: "#FFFFFF",
+  black: "#000000",
+  transparent: "transparent"
+};
+function parseColor(cls, customColors) {
+  const getColor = (key) => {
+    return customColors?.[key] ?? COLORS[key];
+  };
+  if (cls.startsWith("bg-")) {
+    const colorKey = cls.substring(3);
+    const color = getColor(colorKey);
+    if (color) {
+      return { backgroundColor: color };
+    }
+  }
+  if (cls.startsWith("text-")) {
+    const colorKey = cls.substring(5);
+    const color = getColor(colorKey);
+    if (color) {
+      return { color };
+    }
+  }
+  if (cls.startsWith("border-") && !cls.match(/^border-[0-9]/)) {
+    const colorKey = cls.substring(7);
+    const color = getColor(colorKey);
+    if (color) {
+      return { borderColor: color };
+    }
+  }
+  return null;
+}
+
+// src/parser/layout.ts
+var DISPLAY_MAP = {
+  flex: { display: "flex" },
+  hidden: { display: "none" }
+};
+var FLEX_DIRECTION_MAP = {
+  "flex-row": { flexDirection: "row" },
+  "flex-row-reverse": { flexDirection: "row-reverse" },
+  "flex-col": { flexDirection: "column" },
+  "flex-col-reverse": { flexDirection: "column-reverse" }
+};
+var FLEX_WRAP_MAP = {
+  "flex-wrap": { flexWrap: "wrap" },
+  "flex-wrap-reverse": { flexWrap: "wrap-reverse" },
+  "flex-nowrap": { flexWrap: "nowrap" }
+};
+var FLEX_MAP = {
+  "flex-1": { flex: 1 },
+  "flex-auto": { flex: 1 },
+  "flex-none": { flex: 0 }
+};
+var GROW_SHRINK_MAP = {
+  grow: { flexGrow: 1 },
+  "grow-0": { flexGrow: 0 },
+  shrink: { flexShrink: 1 },
+  "shrink-0": { flexShrink: 0 }
+};
+var JUSTIFY_CONTENT_MAP = {
+  "justify-start": { justifyContent: "flex-start" },
+  "justify-end": { justifyContent: "flex-end" },
+  "justify-center": { justifyContent: "center" },
+  "justify-between": { justifyContent: "space-between" },
+  "justify-around": { justifyContent: "space-around" },
+  "justify-evenly": { justifyContent: "space-evenly" }
+};
+var ALIGN_ITEMS_MAP = {
+  "items-start": { alignItems: "flex-start" },
+  "items-end": { alignItems: "flex-end" },
+  "items-center": { alignItems: "center" },
+  "items-baseline": { alignItems: "baseline" },
+  "items-stretch": { alignItems: "stretch" }
+};
+var ALIGN_SELF_MAP = {
+  "self-auto": { alignSelf: "auto" },
+  "self-start": { alignSelf: "flex-start" },
+  "self-end": { alignSelf: "flex-end" },
+  "self-center": { alignSelf: "center" },
+  "self-stretch": { alignSelf: "stretch" },
+  "self-baseline": { alignSelf: "baseline" }
+};
+var ALIGN_CONTENT_MAP = {
+  "content-start": { alignContent: "flex-start" },
+  "content-end": { alignContent: "flex-end" },
+  "content-center": { alignContent: "center" },
+  "content-between": { alignContent: "space-between" },
+  "content-around": { alignContent: "space-around" },
+  "content-stretch": { alignContent: "stretch" }
+};
+var POSITION_MAP = {
+  absolute: { position: "absolute" },
+  relative: { position: "relative" }
+};
+var OVERFLOW_MAP = {
+  "overflow-hidden": { overflow: "hidden" },
+  "overflow-visible": { overflow: "visible" },
+  "overflow-scroll": { overflow: "scroll" }
+};
+function parseLayout(cls) {
+  return DISPLAY_MAP[cls] ?? FLEX_DIRECTION_MAP[cls] ?? FLEX_WRAP_MAP[cls] ?? FLEX_MAP[cls] ?? GROW_SHRINK_MAP[cls] ?? JUSTIFY_CONTENT_MAP[cls] ?? ALIGN_ITEMS_MAP[cls] ?? ALIGN_SELF_MAP[cls] ?? ALIGN_CONTENT_MAP[cls] ?? POSITION_MAP[cls] ?? OVERFLOW_MAP[cls] ?? null;
+}
+
+// src/parser/sizing.ts
+var SIZE_SCALE = {
+  0: 0,
+  0.5: 2,
+  1: 4,
+  1.5: 6,
+  2: 8,
+  2.5: 10,
+  3: 12,
+  3.5: 14,
+  4: 16,
+  5: 20,
+  6: 24,
+  7: 28,
+  8: 32,
+  9: 36,
+  10: 40,
+  11: 44,
+  12: 48,
+  14: 56,
+  16: 64,
+  20: 80,
+  24: 96,
+  28: 112,
+  32: 128,
+  36: 144,
+  40: 160,
+  44: 176,
+  48: 192,
+  52: 208,
+  56: 224,
+  60: 240,
+  64: 256,
+  72: 288,
+  80: 320,
+  96: 384
+};
+var SIZE_PERCENTAGES = {
+  full: "100%",
+  "1/2": "50%",
+  "1/3": "33.333333%",
+  "2/3": "66.666667%",
+  "1/4": "25%",
+  "2/4": "50%",
+  "3/4": "75%",
+  "1/5": "20%",
+  "2/5": "40%",
+  "3/5": "60%",
+  "4/5": "80%",
+  "1/6": "16.666667%",
+  "2/6": "33.333333%",
+  "3/6": "50%",
+  "4/6": "66.666667%",
+  "5/6": "83.333333%"
+};
+function parseArbitrarySize(value) {
+  const pxMatch = value.match(/^\[(\d+)(?:px)?\]$/);
+  if (pxMatch) {
+    return parseInt(pxMatch[1], 10);
+  }
+  const percentMatch = value.match(/^\[(\d+(?:\.\d+)?)%\]$/);
+  if (percentMatch) {
+    return `${percentMatch[1]}%`;
+  }
+  if (value.startsWith("[") && value.endsWith("]")) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `[react-native-tailwind] Unsupported arbitrary size unit: ${value}. Only px and % are supported.`
+      );
+    }
+    return null;
+  }
+  return null;
+}
+function parseSizing(cls) {
+  if (cls.startsWith("w-")) {
+    const sizeKey = cls.substring(2);
+    const arbitrarySize = parseArbitrarySize(sizeKey);
+    if (arbitrarySize !== null) {
+      return { width: arbitrarySize };
+    }
+    const percentage = SIZE_PERCENTAGES[sizeKey];
+    if (percentage) {
+      return { width: percentage };
+    }
+    const numericSize = SIZE_SCALE[sizeKey];
+    if (numericSize !== void 0) {
+      return { width: numericSize };
+    }
+    if (sizeKey === "auto") {
+      return { width: "auto" };
+    }
+  }
+  if (cls.startsWith("h-")) {
+    const sizeKey = cls.substring(2);
+    const arbitrarySize = parseArbitrarySize(sizeKey);
+    if (arbitrarySize !== null) {
+      return { height: arbitrarySize };
+    }
+    const percentage = SIZE_PERCENTAGES[sizeKey];
+    if (percentage) {
+      return { height: percentage };
+    }
+    const numericSize = SIZE_SCALE[sizeKey];
+    if (numericSize !== void 0) {
+      return { height: numericSize };
+    }
+    if (sizeKey === "auto") {
+      return { height: "auto" };
+    }
+  }
+  if (cls.startsWith("min-w-")) {
+    const sizeKey = cls.substring(6);
+    const arbitrarySize = parseArbitrarySize(sizeKey);
+    if (arbitrarySize !== null) {
+      return { minWidth: arbitrarySize };
+    }
+    const percentage = SIZE_PERCENTAGES[sizeKey];
+    if (percentage) {
+      return { minWidth: percentage };
+    }
+    const numericSize = SIZE_SCALE[sizeKey];
+    if (numericSize !== void 0) {
+      return { minWidth: numericSize };
+    }
+  }
+  if (cls.startsWith("min-h-")) {
+    const sizeKey = cls.substring(6);
+    const arbitrarySize = parseArbitrarySize(sizeKey);
+    if (arbitrarySize !== null) {
+      return { minHeight: arbitrarySize };
+    }
+    const percentage = SIZE_PERCENTAGES[sizeKey];
+    if (percentage) {
+      return { minHeight: percentage };
+    }
+    const numericSize = SIZE_SCALE[sizeKey];
+    if (numericSize !== void 0) {
+      return { minHeight: numericSize };
+    }
+  }
+  if (cls.startsWith("max-w-")) {
+    const sizeKey = cls.substring(6);
+    const arbitrarySize = parseArbitrarySize(sizeKey);
+    if (arbitrarySize !== null) {
+      return { maxWidth: arbitrarySize };
+    }
+    const percentage = SIZE_PERCENTAGES[sizeKey];
+    if (percentage) {
+      return { maxWidth: percentage };
+    }
+    const numericSize = SIZE_SCALE[sizeKey];
+    if (numericSize !== void 0) {
+      return { maxWidth: numericSize };
+    }
+  }
+  if (cls.startsWith("max-h-")) {
+    const sizeKey = cls.substring(6);
+    const arbitrarySize = parseArbitrarySize(sizeKey);
+    if (arbitrarySize !== null) {
+      return { maxHeight: arbitrarySize };
+    }
+    const percentage = SIZE_PERCENTAGES[sizeKey];
+    if (percentage) {
+      return { maxHeight: percentage };
+    }
+    const numericSize = SIZE_SCALE[sizeKey];
+    if (numericSize !== void 0) {
+      return { maxHeight: numericSize };
+    }
+  }
+  return null;
+}
+
+// src/parser/spacing.ts
+var SPACING_SCALE = {
+  0: 0,
+  0.5: 2,
+  1: 4,
+  1.5: 6,
+  2: 8,
+  2.5: 10,
+  3: 12,
+  3.5: 14,
+  4: 16,
+  5: 20,
+  6: 24,
+  7: 28,
+  8: 32,
+  9: 36,
+  10: 40,
+  11: 44,
+  12: 48,
+  14: 56,
+  16: 64,
+  20: 80,
+  24: 96,
+  28: 112,
+  32: 128,
+  36: 144,
+  40: 160,
+  44: 176,
+  48: 192,
+  52: 208,
+  56: 224,
+  60: 240,
+  64: 256,
+  72: 288,
+  80: 320,
+  96: 384
+};
+function parseSpacing(cls) {
+  if (cls.startsWith("m-") || cls.startsWith("m")) {
+    return parseMargin(cls);
+  }
+  if (cls.startsWith("p-") || cls.startsWith("p")) {
+    return parsePadding(cls);
+  }
+  if (cls.startsWith("gap-")) {
+    return parseGap(cls);
+  }
+  return null;
+}
+function parseMargin(cls) {
+  const allMatch = cls.match(/^m-(\d+(?:\.\d+)?)$/);
+  if (allMatch) {
+    const value = SPACING_SCALE[allMatch[1]];
+    if (value !== void 0) {
+      return { margin: value };
+    }
+  }
+  const xMatch = cls.match(/^mx-(\d+(?:\.\d+)?)$/);
+  if (xMatch) {
+    const value = SPACING_SCALE[xMatch[1]];
+    if (value !== void 0) {
+      return { marginHorizontal: value };
+    }
+  }
+  const yMatch = cls.match(/^my-(\d+(?:\.\d+)?)$/);
+  if (yMatch) {
+    const value = SPACING_SCALE[yMatch[1]];
+    if (value !== void 0) {
+      return { marginVertical: value };
+    }
+  }
+  const tMatch = cls.match(/^mt-(\d+(?:\.\d+)?)$/);
+  if (tMatch) {
+    const value = SPACING_SCALE[tMatch[1]];
+    if (value !== void 0) {
+      return { marginTop: value };
+    }
+  }
+  const rMatch = cls.match(/^mr-(\d+(?:\.\d+)?)$/);
+  if (rMatch) {
+    const value = SPACING_SCALE[rMatch[1]];
+    if (value !== void 0) {
+      return { marginRight: value };
+    }
+  }
+  const bMatch = cls.match(/^mb-(\d+(?:\.\d+)?)$/);
+  if (bMatch) {
+    const value = SPACING_SCALE[bMatch[1]];
+    if (value !== void 0) {
+      return { marginBottom: value };
+    }
+  }
+  const lMatch = cls.match(/^ml-(\d+(?:\.\d+)?)$/);
+  if (lMatch) {
+    const value = SPACING_SCALE[lMatch[1]];
+    if (value !== void 0) {
+      return { marginLeft: value };
+    }
+  }
+  return null;
+}
+function parsePadding(cls) {
+  const allMatch = cls.match(/^p-(\d+(?:\.\d+)?)$/);
+  if (allMatch) {
+    const value = SPACING_SCALE[allMatch[1]];
+    if (value !== void 0) {
+      return { padding: value };
+    }
+  }
+  const xMatch = cls.match(/^px-(\d+(?:\.\d+)?)$/);
+  if (xMatch) {
+    const value = SPACING_SCALE[xMatch[1]];
+    if (value !== void 0) {
+      return { paddingHorizontal: value };
+    }
+  }
+  const yMatch = cls.match(/^py-(\d+(?:\.\d+)?)$/);
+  if (yMatch) {
+    const value = SPACING_SCALE[yMatch[1]];
+    if (value !== void 0) {
+      return { paddingVertical: value };
+    }
+  }
+  const tMatch = cls.match(/^pt-(\d+(?:\.\d+)?)$/);
+  if (tMatch) {
+    const value = SPACING_SCALE[tMatch[1]];
+    if (value !== void 0) {
+      return { paddingTop: value };
+    }
+  }
+  const rMatch = cls.match(/^pr-(\d+(?:\.\d+)?)$/);
+  if (rMatch) {
+    const value = SPACING_SCALE[rMatch[1]];
+    if (value !== void 0) {
+      return { paddingRight: value };
+    }
+  }
+  const bMatch = cls.match(/^pb-(\d+(?:\.\d+)?)$/);
+  if (bMatch) {
+    const value = SPACING_SCALE[bMatch[1]];
+    if (value !== void 0) {
+      return { paddingBottom: value };
+    }
+  }
+  const lMatch = cls.match(/^pl-(\d+(?:\.\d+)?)$/);
+  if (lMatch) {
+    const value = SPACING_SCALE[lMatch[1]];
+    if (value !== void 0) {
+      return { paddingLeft: value };
+    }
+  }
+  return null;
+}
+function parseGap(cls) {
+  const match = cls.match(/^gap-(\d+(?:\.\d+)?)$/);
+  if (match) {
+    const value = SPACING_SCALE[match[1]];
+    if (value !== void 0) {
+      return { gap: value };
+    }
+  }
+  return null;
+}
+
+// src/parser/typography.ts
+var FONT_SIZES = {
+  xs: 12,
+  sm: 14,
+  base: 16,
+  lg: 18,
+  xl: 20,
+  "2xl": 24,
+  "3xl": 30,
+  "4xl": 36,
+  "5xl": 48,
+  "6xl": 60,
+  "7xl": 72,
+  "8xl": 96,
+  "9xl": 128
+};
+function parseTypography(cls) {
+  if (cls.startsWith("text-")) {
+    const sizeKey = cls.substring(5);
+    const fontSize = FONT_SIZES[sizeKey];
+    if (fontSize !== void 0) {
+      return { fontSize };
+    }
+  }
+  if (cls === "font-thin") {
+    return { fontWeight: "100" };
+  }
+  if (cls === "font-extralight") {
+    return { fontWeight: "200" };
+  }
+  if (cls === "font-light") {
+    return { fontWeight: "300" };
+  }
+  if (cls === "font-normal") {
+    return { fontWeight: "400" };
+  }
+  if (cls === "font-medium") {
+    return { fontWeight: "500" };
+  }
+  if (cls === "font-semibold") {
+    return { fontWeight: "600" };
+  }
+  if (cls === "font-bold") {
+    return { fontWeight: "700" };
+  }
+  if (cls === "font-extrabold") {
+    return { fontWeight: "800" };
+  }
+  if (cls === "font-black") {
+    return { fontWeight: "900" };
+  }
+  if (cls === "italic") {
+    return { fontStyle: "italic" };
+  }
+  if (cls === "not-italic") {
+    return { fontStyle: "normal" };
+  }
+  if (cls === "text-left") {
+    return { textAlign: "left" };
+  }
+  if (cls === "text-center") {
+    return { textAlign: "center" };
+  }
+  if (cls === "text-right") {
+    return { textAlign: "right" };
+  }
+  if (cls === "text-justify") {
+    return { textAlign: "justify" };
+  }
+  if (cls === "underline") {
+    return { textDecorationLine: "underline" };
+  }
+  if (cls === "line-through") {
+    return { textDecorationLine: "line-through" };
+  }
+  if (cls === "no-underline") {
+    return { textDecorationLine: "none" };
+  }
+  if (cls === "uppercase") {
+    return { textTransform: "uppercase" };
+  }
+  if (cls === "lowercase") {
+    return { textTransform: "lowercase" };
+  }
+  if (cls === "capitalize") {
+    return { textTransform: "capitalize" };
+  }
+  if (cls === "normal-case") {
+    return { textTransform: "none" };
+  }
+  if (cls === "leading-none") {
+    return { lineHeight: 16 };
+  }
+  if (cls === "leading-tight") {
+    return { lineHeight: 20 };
+  }
+  if (cls === "leading-snug") {
+    return { lineHeight: 22 };
+  }
+  if (cls === "leading-normal") {
+    return { lineHeight: 24 };
+  }
+  if (cls === "leading-relaxed") {
+    return { lineHeight: 28 };
+  }
+  if (cls === "leading-loose") {
+    return { lineHeight: 32 };
+  }
+  return null;
+}
+
+// src/parser/index.ts
+function parseClassName(className, customColors) {
+  const classes = className.split(/\s+/).filter(Boolean);
+  const style = {};
+  for (const cls of classes) {
+    const parsedStyle = parseClass(cls, customColors);
+    Object.assign(style, parsedStyle);
+  }
+  return style;
+}
+function parseClass(cls, customColors) {
+  const parsers = [
+    parseSpacing,
+    (cls2) => parseColor(cls2, customColors),
+    parseLayout,
+    parseTypography,
+    parseBorder,
+    parseSizing
+  ];
+  for (const parser of parsers) {
+    const result = parser(cls);
+    if (result !== null) {
+      return result;
+    }
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.warn(`[react-native-tailwind] Unknown class: "${cls}"`);
+  }
+  return {};
+}
+
+// src/utils/styleKey.ts
+function generateStyleKey(className) {
+  const classes = className.split(/\s+/).filter(Boolean).sort();
+  const key = "_" + classes.join("_").replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_");
+  return key;
+}
+
+// src/babel/config-loader.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var configCache = /* @__PURE__ */ new Map();
+function findTailwindConfig(startDir) {
+  let currentDir = startDir;
+  const root = path.parse(currentDir).root;
+  const configNames = [
+    "tailwind.config.mjs",
+    "tailwind.config.js",
+    "tailwind.config.cjs",
+    "tailwind.config.ts"
+  ];
+  while (currentDir !== root) {
+    for (const configName of configNames) {
+      const configPath = path.join(currentDir, configName);
+      if (fs.existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return null;
+}
+function loadTailwindConfig(configPath) {
+  if (configCache.has(configPath)) {
+    return configCache.get(configPath);
+  }
+  try {
+    const resolvedPath = require.resolve(configPath);
+    delete require.cache[resolvedPath];
+    const config = require(configPath);
+    const resolved = "default" in config ? config.default : config;
+    configCache.set(configPath, resolved);
+    return resolved;
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(`[react-native-tailwind] Failed to load config from ${configPath}:`, error);
+    }
+    configCache.set(configPath, null);
+    return null;
+  }
+}
+function flattenColors(colors, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(colors)) {
+    const newKey = prefix ? `${prefix}-${key}` : key;
+    if (typeof value === "string") {
+      result[newKey] = value;
+    } else if (typeof value === "object" && value !== null) {
+      Object.assign(result, flattenColors(value, newKey));
+    }
+  }
+  return result;
+}
+function extractCustomColors(filename) {
+  const projectDir = path.dirname(filename);
+  const configPath = findTailwindConfig(projectDir);
+  if (!configPath) {
+    return {};
+  }
+  const config = loadTailwindConfig(configPath);
+  if (!config?.theme) {
+    return {};
+  }
+  if (config.theme.colors && !config.theme.extend?.colors && process.env.NODE_ENV !== "production") {
+    console.warn(
+      "[react-native-tailwind] Using theme.colors will override all default colors. Use theme.extend.colors to add custom colors while keeping defaults."
+    );
+  }
+  const colors = config.theme.extend?.colors ?? config.theme.colors ?? {};
+  return flattenColors(colors);
+}
+
+// src/babel/index.ts
+var SUPPORTED_CLASS_ATTRIBUTES = [
+  "className",
+  "contentContainerClassName",
+  "columnWrapperClassName",
+  "ListHeaderComponentClassName",
+  "ListFooterComponentClassName"
+];
+function getTargetStyleProp(attributeName) {
+  if (attributeName === "contentContainerClassName") {
+    return "contentContainerStyle";
+  }
+  if (attributeName === "columnWrapperClassName") {
+    return "columnWrapperStyle";
+  }
+  if (attributeName === "ListHeaderComponentClassName") {
+    return "ListHeaderComponentStyle";
+  }
+  if (attributeName === "ListFooterComponentClassName") {
+    return "ListFooterComponentStyle";
+  }
+  return "style";
+}
+function reactNativeTailwindBabelPlugin({
+  types: t
+}) {
+  return {
+    name: "react-native-tailwind",
+    visitor: {
+      Program: {
+        enter(_path, state) {
+          state.styleRegistry = /* @__PURE__ */ new Map();
+          state.hasClassNames = false;
+          state.hasStyleSheetImport = false;
+          state.customColors = extractCustomColors(state.file.opts.filename ?? "");
+        },
+        exit(path2, state) {
+          if (!state.hasClassNames || state.styleRegistry.size === 0) {
+            return;
+          }
+          if (!state.hasStyleSheetImport) {
+            addStyleSheetImport(path2, t);
+          }
+          injectStyles(path2, state.styleRegistry, t);
+        }
+      },
+      // Check if StyleSheet is already imported
+      ImportDeclaration(path2, state) {
+        const node = path2.node;
+        if (node.source.value === "react-native") {
+          const specifiers = node.specifiers;
+          const hasStyleSheet = specifiers.some((spec) => {
+            if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported)) {
+              return spec.imported.name === "StyleSheet";
+            }
+            return false;
+          });
+          if (hasStyleSheet) {
+            state.hasStyleSheetImport = true;
+          } else {
+            node.specifiers.push(t.importSpecifier(t.identifier("StyleSheet"), t.identifier("StyleSheet")));
+            state.hasStyleSheetImport = true;
+          }
+        }
+      },
+      JSXAttribute(path2, state) {
+        const node = path2.node;
+        const attributeName = node.name.name;
+        if (!SUPPORTED_CLASS_ATTRIBUTES.includes(attributeName)) {
+          return;
+        }
+        const value = node.value;
+        if (!t.isStringLiteral(value)) {
+          if (process.env.NODE_ENV !== "production") {
+            const filename = state.file.opts.filename ?? "unknown";
+            const targetStyleProp2 = getTargetStyleProp(attributeName);
+            console.warn(
+              `[react-native-tailwind] Dynamic ${attributeName} values are not supported at ${filename}. Use the ${targetStyleProp2} prop for dynamic values.`
+            );
+          }
+          return;
+        }
+        const className = value.value.trim();
+        if (!className) {
+          path2.remove();
+          return;
+        }
+        state.hasClassNames = true;
+        const styleObject = parseClassName2(className, state.customColors);
+        const styleKey = generateStyleKey2(className);
+        state.styleRegistry.set(styleKey, styleObject);
+        const targetStyleProp = getTargetStyleProp(attributeName);
+        const parent = path2.parent;
+        const styleAttribute = parent.attributes.find(
+          (attr) => t.isJSXAttribute(attr) && attr.name.name === targetStyleProp
+        );
+        if (styleAttribute) {
+          mergeStyleAttribute(path2, styleAttribute, styleKey, t);
+        } else {
+          replaceWithStyleAttribute(path2, styleKey, targetStyleProp, t);
+        }
+      }
+    }
+  };
+}
+function addStyleSheetImport(path2, t) {
+  const importDeclaration = t.importDeclaration(
+    [t.importSpecifier(t.identifier("StyleSheet"), t.identifier("StyleSheet"))],
+    t.stringLiteral("react-native")
+  );
+  path2.unshiftContainer("body", importDeclaration);
+}
+function replaceWithStyleAttribute(classNamePath, styleKey, targetStyleProp, t) {
+  const styleAttribute = t.jsxAttribute(
+    t.jsxIdentifier(targetStyleProp),
+    t.jsxExpressionContainer(t.memberExpression(t.identifier("styles"), t.identifier(styleKey)))
+  );
+  classNamePath.replaceWith(styleAttribute);
+}
+function mergeStyleAttribute(classNamePath, styleAttribute, styleKey, t) {
+  const existingStyle = styleAttribute.value.expression;
+  const styleArray = t.arrayExpression([
+    t.memberExpression(t.identifier("styles"), t.identifier(styleKey)),
+    existingStyle
+  ]);
+  styleAttribute.value = t.jsxExpressionContainer(styleArray);
+  classNamePath.remove();
+}
+function injectStyles(path2, styleRegistry, t) {
+  const styleProperties = [];
+  for (const [key, styleObject] of styleRegistry) {
+    const properties = Object.entries(styleObject).map(([styleProp, styleValue]) => {
+      let valueNode;
+      if (typeof styleValue === "number") {
+        valueNode = t.numericLiteral(styleValue);
+      } else if (typeof styleValue === "string") {
+        valueNode = t.stringLiteral(styleValue);
+      } else {
+        valueNode = t.valueToNode(styleValue);
+      }
+      return t.objectProperty(t.identifier(styleProp), valueNode);
+    });
+    styleProperties.push(t.objectProperty(t.identifier(key), t.objectExpression(properties)));
+  }
+  const styleSheet = t.variableDeclaration("const", [
+    t.variableDeclarator(
+      t.identifier("styles"),
+      t.callExpression(t.memberExpression(t.identifier("StyleSheet"), t.identifier("create")), [
+        t.objectExpression(styleProperties)
+      ])
+    )
+  ]);
+  path2.pushContainer("body", styleSheet);
+}
+function parseClassName2(className, customColors) {
+  return parseClassName(className, customColors);
+}
+function generateStyleKey2(className) {
+  return generateStyleKey(className);
+}