@niibase/uniwind 1.6.3 → 1.7.0

package/dist/module/bundler/css-processor/functions.js

@@ -0,0 +1,190 @@
+import { Logger } from "../logger.js";
+import { pipe } from "./utils.js";
+export class Functions {
+  constructor(Processor) {
+    this.Processor = Processor;
+  }
+  logger = new Logger("Functions");
+  processCalc(calc) {
+    switch (calc.type) {
+      case "sum": {
+        const sum = calc.value.map((x) => this.processCalc(x)).join(" + ");
+        return this.tryEval(sum);
+      }
+      case "value":
+        return this.Processor.CSS.processValue(calc.value);
+      case "function":
+        return this.Processor.CSS.processValue(calc.value);
+      case "number":
+        return String(calc.value);
+      default:
+        this.logger.warn(`Unsupported calc type - ${calc.type}`);
+        return "";
+    }
+  }
+  processFunction(fn) {
+    if (typeof fn !== "object") {
+      this.logger.warn(`Unsupported function - ${fn}`);
+      return fn;
+    }
+    if (fn.name === "calc") {
+      const calc = this.Processor.CSS.processValue(fn.arguments);
+      return pipe(calc)(
+        String,
+        (x) => this.Processor.Functions.tryEval(x)
+      );
+    }
+    if (fn.name === "cubic-bezier") {
+      const cubicArguments = pipe(this.Processor.CSS.processValue(fn.arguments))(
+        String,
+        (x) => x.replace(/,\s/g, ",")
+      );
+      return `rt.cubicBezier(${cubicArguments})`;
+    }
+    if (fn.name === "steps") {
+      const stepsArguments = pipe(this.Processor.CSS.processValue(fn.arguments))(
+        String,
+        (x) => x.replace(/,\s/g, ",")
+      );
+      return `rt.steps(${stepsArguments})`;
+    }
+    if (fn.name === "linear") {
+      const linearArguments = pipe(this.Processor.CSS.processValue(fn.arguments))(
+        String,
+        (x) => x.replace(/,\s/g, ",")
+      );
+      return `rt.linear(${linearArguments})`;
+    }
+    if (fn.name === "max") {
+      return `Math.max(${this.Processor.CSS.processValue(fn.arguments)})`;
+    }
+    if (fn.name === "linear-gradient") {
+      return this.Processor.CSS.processValue(fn.arguments);
+    }
+    if (fn.name === "color-mix") {
+      return this.processColorMix(fn);
+    }
+    if (fn.name === "translate3d") {
+      const [x, y] = this.Processor.CSS.processValue(fn.arguments).split(", ").map((x2) => x2.replace(/\s??\s/g, ""));
+      return ` translateX(\${${x}}) translateY(\${${y}})`;
+    }
+    if (fn.name === "scale3d") {
+      const [x, y] = this.Processor.CSS.processValue(fn.arguments).split(", ").map((x2) => x2.replace(/\s??\s/g, ""));
+      return ` scaleX(\${${x}}) scaleY(\${${y}})`;
+    }
+    if (fn.name === "rotate") {
+      return ` rotate(\${${this.Processor.CSS.processValue(fn.arguments).replace(/\s??\s/g, "")}})`;
+    }
+    if ([
+      "blur",
+      "brightness",
+      "contrast",
+      "grayscale",
+      "invert",
+      "opacity",
+      "saturate",
+      "sepia",
+      "url",
+      "drop-shadow",
+      "hue-rotate"
+    ].includes(fn.name)) {
+      const value = this.Processor.CSS.processValue(fn.arguments);
+      return `\`${fn.name}(${typeof value === "string" && value.startsWith("this[") ? `\${${value}}` : value})\``;
+    }
+    if ([
+      "rgb",
+      "oklab",
+      "oklch",
+      "hsl",
+      "hwb",
+      "lab",
+      "lch",
+      "srgb"
+    ].includes(fn.name)) {
+      const color = `${fn.name}(${this.Processor.CSS.processValue(fn.arguments)})`;
+      return this.Processor.Color.processColor(color);
+    }
+    if ([
+      "blur",
+      "brightness",
+      "contrast",
+      "grayscale",
+      "hue-rotate",
+      "invert",
+      "opacity",
+      "saturate",
+      "sepia",
+      "conic-gradient",
+      "radial-gradient"
+    ].includes(fn.name)) {
+      return '""';
+    }
+    if (["skewX", "skewY"].includes(fn.name)) {
+      return `"${fn.name}(${this.Processor.CSS.processValue(fn.arguments).replace(/"/g, "")})"`;
+    }
+    if (fn.name === "hairlineWidth") {
+      return "rt.hairlineWidth";
+    }
+    if (fn.name === "platformSelect") {
+      return `rt.platformSelect(${this.Processor.CSS.processValue(fn.arguments)})`;
+    }
+    if (fn.name === "pixelRatio") {
+      if (fn.arguments.length === 0) {
+        return "rt.pixelRatio(1)";
+      }
+      return `rt.pixelRatio(${this.Processor.CSS.processValue(fn.arguments)})`;
+    }
+    if (fn.name === "fontScale") {
+      if (fn.arguments.length === 0) {
+        return "rt.fontScale(1)";
+      }
+      return `rt.fontScale(${this.Processor.CSS.processValue(fn.arguments)})`;
+    }
+    if (fn.name === "drop-shadow") {
+      return void 0;
+    }
+    this.logger.warn(`Unsupported function - ${fn.name}`);
+    return fn.name;
+  }
+  processMathFunction(name, value) {
+    if (!Array.isArray(value)) {
+      return `Math.${name}(${this.processCalc(value)})`;
+    }
+    const values = value.map((x) => this.processCalc(x)).join(" , ");
+    return `Math.${name}(${values})`;
+  }
+  tryEval(value) {
+    const units = Array.from(
+      value.replace(/"/g, "").match(/(?<![A-Za-z-])(?:%|deg|rad|grad|turn)(?=\s|$)/g) ?? []
+    );
+    if (units.length === 0) {
+      return value;
+    }
+    if (new Set(units).size !== 1) {
+      this.logger.error(`Invalid calc, you can't mix multiple units`);
+      return value;
+    }
+    if (units.includes("%") && value.includes("+")) {
+      this.logger.error(`Invalid calc, you can't mix % with other units`);
+      return value;
+    }
+    const unit = units.at(0) ?? "";
+    try {
+      const numericValue = value.replace(/"/g, "").replace(new RegExp(unit, "g"), "");
+      return new Function(`return ${numericValue} + '${unit}'`)();
+    } catch {
+      this.logger.error(`Invalid calc ${value}`);
+      return value;
+    }
+  }
+  processColorMix(fn) {
+    const tokens = fn.arguments.map(
+      (arg) => pipe(arg)(
+        (x) => this.Processor.CSS.processValue(x),
+        String,
+        (x) => x.trim()
+      )
+    ).filter((token) => !["", ",", "in", "srgb", "rgb", "hsl", "hwb", "lab", "lch", "oklab", "oklch"].includes(token.replace(/"/g, "")));
+    return `rt.colorMix(${tokens.join(", ")})`;
+  }
+}

package/dist/module/bundler/css-processor/index.d.ts

@@ -0,0 +1,3 @@
+export * from './addMetaToStylesTemplate';
+export * from './processor';
+export * from './serialize';

package/dist/module/bundler/css-processor/index.js

@@ -0,0 +1,3 @@
+export * from "./addMetaToStylesTemplate.js";
+export * from "./processor.js";
+export * from "./serialize.js";

package/dist/module/bundler/css-processor/mq.d.ts

@@ -0,0 +1,12 @@
+import type { MediaQuery } from 'lightningcss';
+import type { ProcessorBuilder } from './processor';
+import type { MediaQueryResolver } from './types';
+export declare class MQ {
+    private readonly Processor;
+    constructor(Processor: ProcessorBuilder);
+    processMediaQueries(mediaQueries: Array<MediaQuery>): MediaQueryResolver;
+    private processCondition;
+    private processWidthMediaQuery;
+    private processPlainMediaQuery;
+    private getInitialMediaQueryResolver;
+}

package/dist/module/bundler/css-processor/mq.js

@@ -0,0 +1,78 @@
+import { Platform } from "@/common/consts";
+export class MQ {
+  constructor(Processor) {
+    this.Processor = Processor;
+  }
+  processMediaQueries(mediaQueries) {
+    const mq = this.getInitialMediaQueryResolver();
+    for (const mediaQuery of mediaQueries) {
+      const { condition, mediaType } = mediaQuery;
+      if ([
+        Platform.Android,
+        Platform.iOS,
+        Platform.Native,
+        Platform.AndroidTV,
+        Platform.AppleTV,
+        Platform.TV
+      ].includes(mediaType)) {
+        mq.platform = mediaType;
+        continue;
+      }
+      if (condition) this.processCondition(condition, mq);
+    }
+    return mq;
+  }
+  processCondition(condition, mq) {
+    if (condition.type === "operation") {
+      condition.conditions.forEach((nestedCondition) => {
+        this.processCondition(nestedCondition, mq);
+      });
+    } else if (condition.type === "feature") {
+      if (condition.value.type === "range") {
+        this.processWidthMediaQuery(condition.value, mq);
+      }
+      if (condition.value.type === "plain") {
+        this.processPlainMediaQuery(condition.value, mq);
+      }
+    }
+  }
+  processWidthMediaQuery(query, mq) {
+    const { operator, value } = query;
+    const result = this.Processor.CSS.processValue(value);
+    if (operator === "greater-than-equal" || operator === "greater-than") {
+      mq.minWidth = result;
+    }
+    if (operator === "less-than-equal" || operator === "less-than") {
+      mq.maxWidth = result;
+    }
+  }
+  processPlainMediaQuery(query, mq) {
+    const { value, name } = query;
+    switch (name) {
+      case "orientation":
+        mq.orientation = value.value;
+        break;
+      case "prefers-color-scheme":
+        mq.colorScheme = value.value;
+        break;
+      default:
+        break;
+    }
+  }
+  getInitialMediaQueryResolver() {
+    return {
+      minWidth: 0,
+      maxWidth: Number.MAX_VALUE,
+      platform: null,
+      rtl: null,
+      important: false,
+      colorScheme: null,
+      orientation: null,
+      theme: null,
+      active: null,
+      focus: null,
+      disabled: null,
+      dataAttributes: null
+    };
+  }
+}

package/dist/module/bundler/css-processor/processor.d.ts

@@ -0,0 +1,36 @@
+import type { CSSAnimationKeyframes } from 'react-native-reanimated';
+import type { UniwindBundlerConfig } from '../config';
+import { Color } from './color';
+import { CSS } from './css';
+import { Functions } from './functions';
+import { MQ } from './mq';
+import { RN } from './rn';
+import type { ProcessMetaValues } from './types';
+import { Units } from './units';
+import { Var } from './var';
+export declare class ProcessorBuilder {
+    readonly bundlerConfig: UniwindBundlerConfig;
+    stylesheets: Record<string, Array<any>>;
+    vars: Record<string, any>;
+    scopedVars: Record<string, Record<string, any>>;
+    keyframes: Record<string, CSSAnimationKeyframes>;
+    CSS: CSS;
+    RN: RN;
+    Var: Var;
+    MQ: MQ;
+    Color: Color;
+    Units: Units;
+    Functions: Functions;
+    meta: ProcessMetaValues;
+    private varsWithMediaQueries;
+    private pendingVarReferences;
+    private declarationConfig;
+    constructor(bundlerConfig: UniwindBundlerConfig);
+    transform(css: string): void;
+    private getDeclarationConfig;
+    private hasMediaQuery;
+    private addDeclaration;
+    private parseKeyFrames;
+    private parseDeclaration;
+    private parseRuleRec;
+}

package/dist/module/bundler/css-processor/processor.js

@@ -0,0 +1,336 @@
+import { UNIWIND_PLATFORM_VARIABLES, UNIWIND_THEME_VARIABLES } from "@/common/consts";
+import { transform } from "lightningcss";
+import { parseTransformsMutation } from "../../core/native/parsers/transforms.js";
+import { Color } from "./color.js";
+import { CSS } from "./css.js";
+import { Functions } from "./functions.js";
+import { MQ } from "./mq.js";
+import { RN } from "./rn.js";
+import { Units } from "./units.js";
+import { Var } from "./var.js";
+export class ProcessorBuilder {
+  constructor(bundlerConfig) {
+    this.bundlerConfig = bundlerConfig;
+    this.vars["--uniwind-em"] = this.bundlerConfig.polyfills?.rem ?? 16;
+  }
+  stylesheets = {};
+  vars = {};
+  scopedVars = {};
+  keyframes = {};
+  CSS = new CSS(this);
+  RN = new RN(this);
+  Var = new Var(this);
+  MQ = new MQ(this);
+  Color = new Color(this);
+  Units = new Units(this);
+  Functions = new Functions(this);
+  meta = {};
+  varsWithMediaQueries = {};
+  pendingVarReferences = /* @__PURE__ */ new Map();
+  declarationConfig = this.getDeclarationConfig();
+  transform(css) {
+    transform({
+      filename: "tailwind.css",
+      code: Buffer.from(css),
+      visitor: {
+        StyleSheet: (styleSheet) => {
+          styleSheet.rules.forEach((rule) => {
+            this.declarationConfig = this.getDeclarationConfig();
+            this.parseRuleRec(rule);
+          });
+          for (const [className, [varNames, animated]] of this.pendingVarReferences) {
+            if (animated && varNames.length === 1) {
+              const varName = varNames[0];
+              const varValue = this.vars[varName];
+              const styles = this.stylesheets[className]?.at(-2);
+              this.CSS.processAnimationVar(varValue, styles, (v) => {
+                this.vars[varName] = v;
+              });
+              continue;
+            }
+            for (const varName of varNames) {
+              const varStyles = this.varsWithMediaQueries[varName];
+              if (!varStyles || varStyles.length === 0) {
+                continue;
+              }
+              for (const varStyle of varStyles) {
+                this.stylesheets[className].push(varStyle);
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  getDeclarationConfig() {
+    return {
+      className: null,
+      rtl: null,
+      mediaQueries: [],
+      root: false,
+      theme: null,
+      active: null,
+      focus: null,
+      disabled: null,
+      dataAttributes: null
+    };
+  }
+  hasMediaQuery(mq) {
+    return mq.minWidth !== 0 || mq.maxWidth !== Number.MAX_VALUE || mq.orientation !== null || mq.colorScheme !== null;
+  }
+  addDeclaration(declaration, important = false) {
+    const isVar = this.declarationConfig.root || this.declarationConfig.className === null;
+    const mq = this.MQ.processMediaQueries(this.declarationConfig.mediaQueries);
+    const { property, value } = this.parseDeclaration(declaration);
+    const style = (() => {
+      if (!isVar) {
+        return this.stylesheets[this.declarationConfig.className]?.at(-1);
+      }
+      if (mq.platform !== null) {
+        const platformKey = `${UNIWIND_PLATFORM_VARIABLES}${mq.platform}`;
+        this.scopedVars[platformKey] ??= {};
+        return this.scopedVars[platformKey];
+      }
+      if (this.hasMediaQuery(mq)) {
+        this.varsWithMediaQueries[property] ??= [];
+        this.varsWithMediaQueries[property].push({});
+        return this.varsWithMediaQueries[property].at(-1);
+      }
+      if (this.declarationConfig.theme === null) {
+        return this.vars;
+      }
+      const themeKey = `${UNIWIND_THEME_VARIABLES}${this.declarationConfig.theme}`;
+      this.scopedVars[themeKey] ??= {};
+      return this.scopedVars[themeKey];
+    })();
+    if (!isVar || this.hasMediaQuery(mq)) {
+      Object.assign(style, mq);
+      style.importantProperties ??= [];
+      style.rtl = this.declarationConfig.rtl;
+      style.theme = mq.colorScheme ?? this.declarationConfig.theme;
+      style.maxWidth = mq.maxWidth;
+      style.minWidth = mq.minWidth;
+      style.orientation = mq.orientation;
+      style.active = this.declarationConfig.active;
+      style.focus = this.declarationConfig.focus;
+      style.disabled = this.declarationConfig.disabled;
+      style.dataAttributes = this.declarationConfig.dataAttributes;
+      this.meta.className = this.declarationConfig.className;
+    }
+    style[property] = value;
+    if (!isVar && important) {
+      style.importantProperties.push(property);
+    }
+    const match = typeof value === "string" ? value.match(/this\[`(.*?)`\]/) : null;
+    if (match && !isVar) {
+      const className = this.declarationConfig.className;
+      if (className === null) {
+        return;
+      }
+      if (!this.pendingVarReferences.has(className)) {
+        this.pendingVarReferences.set(className, [[], property === "animation"]);
+      }
+      const classVars = this.pendingVarReferences.get(className);
+      const varName = match[1];
+      if (!classVars[0].includes(varName)) {
+        classVars[0].push(varName);
+      }
+    }
+  }
+  parseKeyFrames(animationFrames) {
+    const [selectors, styles] = animationFrames;
+    const result = {};
+    for (let i = 0; i < selectors.length; i++) {
+      const selectorString = selectors[i];
+      const styleObj = styles[i];
+      const individualSelectors = typeof selectorString === "string" ? selectorString.split(",").map((s) => s.trim()).filter(Boolean) : [selectorString];
+      const resolvedStyles = {};
+      for (const [property, value] of Object.entries(styleObj)) {
+        const resolved = this.RN.cssToRN(property, value);
+        for (const [resolvedProperty, resolvedValue] of resolved) {
+          resolvedStyles[resolvedProperty] = resolvedValue;
+        }
+        if (property === "transform") {
+          parseTransformsMutation(resolvedStyles, true);
+        }
+      }
+      for (const selector of individualSelectors) {
+        if (result[selector] !== void 0) {
+          result[selector] = {
+            ...result[selector],
+            ...resolvedStyles
+          };
+        } else {
+          result[selector] = { ...resolvedStyles };
+        }
+      }
+    }
+    return result;
+  }
+  parseDeclaration(declaration) {
+    const parseValue = (property, value) => {
+      if (property === "animation") {
+        return this.CSS.processAnimation(value);
+      }
+      return this.CSS.processValue(value, property);
+    };
+    if (declaration.property === "unparsed") {
+      const property = declaration.value.propertyId.property;
+      return {
+        property,
+        value: parseValue(property, declaration.value.value)
+      };
+    }
+    if (declaration.property === "custom") {
+      const property = declaration.value.name;
+      return {
+        property,
+        value: parseValue(property, declaration.value.value)
+      };
+    }
+    return {
+      property: declaration.property,
+      value: parseValue(declaration.property, declaration.value)
+    };
+  }
+  parseRuleRec(rule) {
+    if (this.declarationConfig.className !== null) {
+      const lastStyle = this.stylesheets[this.declarationConfig.className]?.at(-1);
+      if (lastStyle !== void 0 && Object.keys(lastStyle).length > 0) {
+        this.stylesheets[this.declarationConfig.className]?.push({});
+      }
+    }
+    if (rule.type === "style") {
+      rule.value.selectors.forEach((selector) => {
+        const [maybeClassNameSelector] = selector;
+        const newClassName = maybeClassNameSelector?.type === "class" ? maybeClassNameSelector.name : void 0;
+        if (newClassName !== void 0) {
+          this.declarationConfig.className = newClassName;
+          this.stylesheets[newClassName] ??= [];
+          this.stylesheets[newClassName].push({});
+          rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
+          rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
+          rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
+          return;
+        }
+        let rtl = null;
+        let theme = null;
+        let active = null;
+        let focus = null;
+        let disabled = null;
+        let dataAttributes = null;
+        selector.forEach((selector2) => {
+          if (selector2.type === "pseudo-class" && selector2.kind === "where") {
+            selector2.selectors.forEach((selector3) => {
+              selector3.forEach((selector4) => {
+                if (selector4.type === "class" && this.bundlerConfig.themes.includes(selector4.name)) {
+                  theme = selector4.name;
+                }
+                if (selector4.type === "pseudo-class" && selector4.kind === "dir") {
+                  rtl = selector4.direction === "rtl";
+                }
+              });
+            });
+          }
+          if (selector2.type === "pseudo-class" && selector2.kind === "active") {
+            active = true;
+          }
+          if (selector2.type === "pseudo-class" && selector2.kind === "focus") {
+            focus = true;
+          }
+          if (selector2.type === "pseudo-class" && selector2.kind === "disabled") {
+            disabled = true;
+          }
+          if (selector2.type === "attribute" && selector2.operation === null && selector2.name.startsWith("data-")) {
+            dataAttributes ??= {};
+            dataAttributes[selector2.name] = `"true"`;
+          }
+          if (selector2.type === "attribute" && selector2.operation?.operator === "equal" && selector2.name.startsWith("data-")) {
+            dataAttributes ??= {};
+            dataAttributes[selector2.name] = `"${selector2.operation.value}"`;
+          }
+        });
+        if ([rtl, theme, active, focus, disabled, dataAttributes].some(Boolean)) {
+          this.declarationConfig.rtl = rtl;
+          this.declarationConfig.theme = theme;
+          this.declarationConfig.active = active;
+          this.declarationConfig.focus = focus;
+          this.declarationConfig.disabled = disabled;
+          this.declarationConfig.dataAttributes = dataAttributes;
+          rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
+          rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
+          rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
+          this.declarationConfig.rtl = null;
+          this.declarationConfig.theme = null;
+          this.declarationConfig.active = null;
+          this.declarationConfig.focus = null;
+          this.declarationConfig.disabled = null;
+          this.declarationConfig.dataAttributes = null;
+          return;
+        }
+        selector.forEach((selectorToken) => {
+          if (selectorToken.type === "pseudo-class" && selectorToken.kind === "root") {
+            this.declarationConfig.root = true;
+            rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
+            rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
+            rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
+          }
+        });
+      });
+      return;
+    }
+    if (rule.type === "supports") {
+      rule.value.rules.forEach((rule2) => this.parseRuleRec(rule2));
+      return;
+    }
+    if (rule.type === "media") {
+      const { mediaQueries } = rule.value.query;
+      this.declarationConfig.mediaQueries.push(...mediaQueries);
+      rule.value.rules.forEach((rule2) => this.parseRuleRec(rule2));
+      this.declarationConfig = this.getDeclarationConfig();
+      return;
+    }
+    if (rule.type === "keyframes") {
+      const keyframes = [[], []];
+      rule.value.keyframes.forEach((keyframe) => {
+        const selectors = keyframe.selectors.map((selector) => {
+          switch (selector.type) {
+            case "percentage":
+              return keyframe.selectors.length > 0 ? `${selector.value * 100}%` : selector.value;
+            case "from":
+            case "to":
+              return selector.type;
+            case "timeline-range-percentage":
+              return keyframe.selectors.length > 0 ? `${selector.value.percentage}%` : selector.value.percentage;
+            default:
+              return "";
+          }
+        });
+        keyframes[0].push(selectors.join(", "));
+        const keyframeStyle = {};
+        keyframe.declarations.declarations?.forEach((declaration) => {
+          if (["custom", "unparsed"].includes(declaration.property)) {
+            const { property, value } = this.parseDeclaration(declaration);
+            keyframeStyle[property] = value;
+          } else {
+            keyframeStyle[declaration.property] = !Array.isArray(declaration.value) || declaration.property.startsWith("animation-") ? this.CSS.processValue(declaration.value) : declaration.value.flatMap((value) => this.CSS.processValue(value));
+          }
+        });
+        keyframes[1].push(keyframeStyle);
+      });
+      this.keyframes[rule.value.name.value] = this.parseKeyFrames(keyframes);
+    }
+    if (rule.type === "layer-block") {
+      rule.value.rules.forEach((rule2) => this.parseRuleRec(rule2));
+      return;
+    }
+    if (rule.type === "nested-declarations") {
+      rule.value.declarations.declarations?.forEach((declaration) => this.addDeclaration(declaration));
+      rule.value.declarations.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
+      return;
+    }
+    if (rule.type === "property" && rule.value.initialValue) {
+      this.vars[rule.value.name] = this.CSS.processValue(rule.value.initialValue);
+    }
+  }
+}

package/dist/module/bundler/css-processor/rn.d.ts

@@ -0,0 +1,10 @@
+import type { ProcessorBuilder } from './processor';
+export declare class RN {
+    private readonly Processor;
+    constructor(Processor: ProcessorBuilder);
+    cssToRN(property: string, value: any): Array<[string, any]>;
+    private makeResponsive;
+    private transformProperty;
+    private transformObjectProperty;
+    private joinStyles;
+}