@niibase/uniwind 1.6.4 → 1.8.0

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

@@ -0,0 +1,400 @@
+import { DEFAULT_SCREEN_HEIGHT, DEFAULT_SCREEN_WIDTH } from "@/common/consts";
+import { isDefined } from "@/common/utils";
+import { addMissingSpaces, pipe, removeKeys, toCamelCase } from "./utils.js";
+const transitions = { overlay: '"overlayColor"' };
+const cssToRNMap = {
+  backgroundSize: (value) => {
+    return {
+      resizeMode: value
+    };
+  },
+  transitionProperty: (value) => {
+    const properties = value.replace(/"/g, "").split(",").filter((token) => token !== "" && !token.startsWith("--")).map((token) => transitions[token.trim()] ?? `"${toCamelCase(token.trim())}"`);
+    if (properties.length === 1 && ['"allowDiscrete"', '"normal"'].includes(properties[0])) {
+      const behavior = properties[0] === '"allowDiscrete"' ? "allow-discrete" : "normal";
+      return {
+        transitionBehavior: `"${behavior}"`
+      };
+    }
+    return {
+      transitionProperty: properties
+    };
+  },
+  transitionDuration: (value) => {
+    return {
+      transitionDuration: value.includes('""') ? value.replace(/""/g, ",") : value
+    };
+  },
+  transitionTimingFunction: (value) => {
+    return {
+      transitionTimingFunction: value.includes('""') ? value.replace(/""/g, ",") : value
+    };
+  },
+  animation: (value) => {
+    if (Array.isArray(value)) {
+      const result = {};
+      for (const [key, val] of value) {
+        if (val === '"none"') {
+          continue;
+        }
+        const keyName = toCamelCase(`animation-${key.replace(/^"|"$/g, "")}`);
+        if (key === "name") {
+          result[keyName] = typeof val === "string" ? val.split(",").map((v) => v.startsWith('"') ? v : `"${v}"`) : val;
+        } else {
+          result[keyName] = val;
+        }
+      }
+      return result;
+    }
+    return {
+      animationName: value
+    };
+  },
+  flex: (value) => {
+    if (typeof value === "object") {
+      return value;
+    }
+    return {
+      flex: value
+    };
+  },
+  overflow: (value) => {
+    if (typeof value === "object") {
+      return value;
+    }
+    return {
+      overflow: value
+    };
+  },
+  backdropFilter: () => ({}),
+  filter: (value) => ({
+    filter: value
+  }),
+  backgroundImage: (value) => ({
+    experimental_backgroundImage: value
+  }),
+  borderSpacing: () => ({}),
+  translate: (value) => {
+    if (typeof value === "object" && "x" in value && "y" in value) {
+      return {
+        translateX: value.x,
+        translateY: value.y
+      };
+    }
+    if (typeof value === "string") {
+      const [x, y] = value.split(" ");
+      return {
+        translateX: x,
+        translateY: y ?? x
+      };
+    }
+    return {};
+  },
+  rotate: (value) => {
+    if (typeof value === "object") {
+      return value;
+    }
+    return {
+      rotate: value
+    };
+  },
+  scale: (value) => {
+    if (typeof value === "object") {
+      return {
+        scaleX: value.x,
+        scaleY: value.y,
+        scaleZ: value.z
+      };
+    }
+    if (typeof value === "string") {
+      const [x, y, z] = value.split(" ");
+      return {
+        scaleX: x,
+        scaleY: y,
+        scaleZ: z
+      };
+    }
+    return {};
+  },
+  transform: (value) => {
+    if (typeof value === "string" || Array.isArray(value)) {
+      return {
+        transform: value
+      };
+    }
+    if (typeof value === "object") {
+      return Object.keys(value).length === 0 ? { transform: [] } : value;
+    }
+    return {};
+  },
+  fontSize: (value) => {
+    return {
+      fontSize: value,
+      "--uniwind-em": value
+    };
+  },
+  borderInlineWidth: (value) => {
+    const borderWidth = typeof value === "object" ? Object.values(value)[0] : value;
+    return {
+      borderLeftWidth: borderWidth,
+      borderRightWidth: borderWidth
+    };
+  },
+  borderBlockWidth: (value) => {
+    const borderWidth = typeof value === "object" ? Object.values(value)[0] : value;
+    return {
+      borderTopWidth: borderWidth,
+      borderBottomWidth: borderWidth
+    };
+  },
+  borderInlineStyle: (value) => {
+    return {
+      borderStyle: value
+    };
+  },
+  borderBlockStyle: (value) => {
+    return {
+      borderStyle: value
+    };
+  },
+  borderStyle: (value) => {
+    const borderStyle = typeof value === "object" ? Object.values(value)[0] : value;
+    return {
+      borderStyle
+    };
+  },
+  transformOrigin: (value) => {
+    if (typeof value === "object") {
+      return {
+        transformOrigin: `${value.x} ${value.y}`
+      };
+    }
+    return {
+      transformOrigin: value
+    };
+  },
+  fontVariantNumeric: (value) => ({
+    fontVariant: value
+  }),
+  display: (value) => {
+    if (value === '"box"') {
+      return {
+        display: '"flex"'
+      };
+    }
+    return {
+      display: value
+    };
+  }
+};
+const BORDER_WIDTH_KEYS = ["borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth"];
+const BORDER_COLOR_KEYS = ["borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor"];
+const BORDER_RADIUS_KEYS = ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomLeftRadius", "borderBottomRightRadius"];
+const COMPONENT_RESPONSIVE_PROPS = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "minWidth",
+  "maxWidth",
+  "minHeight",
+  "maxHeight",
+  "padding",
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft",
+  "paddingHorizontal",
+  "paddingVertical",
+  "paddingStart",
+  "paddingEnd",
+  "margin",
+  "marginTop",
+  "marginRight",
+  "marginBottom",
+  "marginLeft",
+  "marginHorizontal",
+  "marginVertical",
+  "marginStart",
+  "marginEnd",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "gap",
+  "rowGap",
+  "columnGap",
+  "borderWidth",
+  "borderTopWidth",
+  "borderRightWidth",
+  "borderBottomWidth",
+  "borderLeftWidth",
+  "borderStartWidth",
+  "borderEndWidth",
+  "borderRadius",
+  "borderTopLeftRadius",
+  "borderTopRightRadius",
+  "borderBottomLeftRadius",
+  "borderBottomRightRadius",
+  "borderTopStartRadius",
+  "borderTopEndRadius",
+  "borderBottomStartRadius",
+  "borderBottomEndRadius",
+  "flexBasis",
+  "translateX",
+  "translateY"
+]);
+export class RN {
+  constructor(Processor) {
+    this.Processor = Processor;
+  }
+  cssToRN(property, value) {
+    const transformedProperty = property.startsWith("--") ? property : pipe(property)(
+      toCamelCase,
+      (x) => {
+        if (x.includes("padding") || x.includes("margin")) {
+          return x.replace("InlineStart", "Start").replace("InlineEnd", "End").replace("Inline", "Horizontal").replace("Block", "Vertical");
+        }
+        if (x.includes("border")) {
+          return x.replace("InlineStart", "Start").replace("InlineEnd", "End");
+        }
+        return x;
+      }
+    );
+    const rn = this.transformProperty(
+      transformedProperty,
+      typeof value === "string" ? addMissingSpaces(value) : value
+    );
+    const joinedStyles = this.joinStyles(rn);
+    return Object.entries(joinedStyles).filter(([, value2]) => isDefined(value2)).map(([prop, val]) => [prop, this.makeResponsive(prop, val)]);
+  }
+  makeResponsive(property, value) {
+    const mode = this.Processor.bundlerConfig.polyfills?.responsive;
+    if (!mode) {
+      return value;
+    }
+    if (typeof value === "string") {
+      const rawValue = value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+      if (rawValue.endsWith("%")) {
+        const numValue = parseFloat(rawValue);
+        if (!isNaN(numValue)) {
+          return `rt.makeResponsive(${numValue}, 100, true)`;
+        }
+      }
+    }
+    if (typeof value !== "number") {
+      return value;
+    }
+    const isTextMode = mode === true || mode === "text";
+    const isComponentMode = mode === true || mode === "components";
+    if (isTextMode && (property === "fontSize" || property === "--uniwind-em")) {
+      return `rt.makeResponsive(${value}, ${DEFAULT_SCREEN_HEIGHT}, true)`;
+    }
+    if (isComponentMode && COMPONENT_RESPONSIVE_PROPS.has(property)) {
+      return `rt.makeResponsive(${value}, ${DEFAULT_SCREEN_WIDTH})`;
+    }
+    return value;
+  }
+  transformProperty(property, value) {
+    if (property in cssToRNMap) {
+      return cssToRNMap[property](value);
+    }
+    if (typeof value === "object") {
+      const transformed = this.transformObjectProperty(property, value);
+      if (transformed) {
+        return transformed;
+      }
+    }
+    return {
+      [property]: value
+    };
+  }
+  transformObjectProperty(property, value) {
+    const properties = Object.keys(value);
+    const propertyEnd = property.includes("border") ? property.split("border").at(-1) ?? "" : "";
+    const transformedProperty = property.replace(propertyEnd, "");
+    const isSpacing = property.includes("margin") || property.includes("padding");
+    const wrapProperty = (prop) => `${transformedProperty}${prop}${propertyEnd}`;
+    if (properties.every((property2) => ["row", "column"].includes(property2))) {
+      return {
+        rowGap: value.row,
+        columnGap: value.column
+      };
+    }
+    if (properties.every((property2) => ["start", "end"].includes(property2))) {
+      if (isSpacing && property.includes("Horizontal")) {
+        return {
+          [`${property.replace("Horizontal", "Left")}`]: value.start,
+          [`${property.replace("Horizontal", "Right")}`]: value.end
+        };
+      }
+      if (isSpacing && property.includes("Vertical")) {
+        return {
+          [`${property.replace("Vertical", "Top")}`]: value.start,
+          [`${property.replace("Vertical", "Bottom")}`]: value.end
+        };
+      }
+      return {
+        [wrapProperty("Start")]: value.start,
+        [wrapProperty("End")]: value.end
+      };
+    }
+    if (properties.every((property2) => ["top", "right", "bottom", "left"].includes(property2))) {
+      if (transformedProperty === "inset") {
+        const isEverySideSame = properties.every((property2) => value[property2] === value.top);
+        return isEverySideSame ? { inset: value.top } : value;
+      }
+      return {
+        [wrapProperty("Top")]: value.top,
+        [wrapProperty("Right")]: value.right,
+        [wrapProperty("Bottom")]: value.bottom,
+        [wrapProperty("Left")]: value.left
+      };
+    }
+    if (properties.every((property2) => ["topLeft", "topRight", "bottomRight", "bottomLeft"].includes(property2))) {
+      return {
+        [wrapProperty("TopLeft")]: value.topLeft,
+        [wrapProperty("TopRight")]: value.topRight,
+        [wrapProperty("BottomRight")]: value.bottomRight,
+        [wrapProperty("BottomLeft")]: value.bottomLeft
+      };
+    }
+    if (properties.every((property2) => ["style", "width", "color"].includes(property2))) {
+      return {
+        [wrapProperty("Style")]: value.style,
+        [wrapProperty("Width")]: value.width,
+        [wrapProperty("Color")]: value.color
+      };
+    }
+  }
+  // Used when they're multiple styles with the same value that could be joined
+  joinStyles(styles) {
+    const keys = Object.keys(styles);
+    if (BORDER_WIDTH_KEYS.every((key) => keys.includes(key))) {
+      const borderWidth = styles.borderTopWidth;
+      if (BORDER_WIDTH_KEYS.every((key) => styles[key] === borderWidth)) {
+        return {
+          ...removeKeys(styles, BORDER_WIDTH_KEYS),
+          borderWidth
+        };
+      }
+    }
+    if (BORDER_COLOR_KEYS.every((key) => keys.includes(key))) {
+      const borderColor = styles.borderTopColor;
+      if (BORDER_COLOR_KEYS.every((key) => styles[key] === borderColor)) {
+        return {
+          ...removeKeys(styles, BORDER_COLOR_KEYS),
+          borderColor
+        };
+      }
+    }
+    if (BORDER_RADIUS_KEYS.every((key) => keys.includes(key))) {
+      const borderRadius = styles.borderTopLeftRadius;
+      if (BORDER_RADIUS_KEYS.every((key) => styles[key] === borderRadius)) {
+        return {
+          ...removeKeys(styles, BORDER_RADIUS_KEYS),
+          borderRadius
+        };
+      }
+    }
+    return styles;
+  }
+}

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

@@ -0,0 +1,2 @@
+export declare const serialize: (value: any) => string;
+export declare const serializeJSObject: (obj: Record<string, any>, serializer: (key: string, value: string) => string) => string;

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

@@ -0,0 +1,101 @@
+import { Logger } from "@/bundler/logger";
+import { addMissingSpaces, isNumber, isValidJSValue, pipe, roundToPrecision, smartSplit } from "./utils.js";
+const parseStringValue = (value) => {
+  if (isValidJSValue(value)) {
+    return value;
+  }
+  if (value.startsWith("function")) {
+    return value;
+  }
+  const tokens = smartSplit(addMissingSpaces(value));
+  const parsedTokens = tokens.map((token) => {
+    if (token.startsWith('"')) {
+      return token.replace(/"/g, "");
+    }
+    if (/^[a-z]+$/i.test(token.replace(/,/g, ""))) {
+      return token;
+    }
+    if (isNumber(token)) {
+      return token;
+    }
+    const endsWithComma = token.endsWith(",");
+    const expr = endsWithComma ? token.slice(0, -1) : token;
+    if (!isValidJSValue(expr)) {
+      return token;
+    }
+    return [
+      "${",
+      expr,
+      "}",
+      endsWithComma ? "," : ""
+    ].join("");
+  });
+  return [
+    "`",
+    parsedTokens.join(" "),
+    "`"
+  ].join("");
+};
+export const serialize = (value) => {
+  const typeOfValue = typeof value;
+  switch (typeOfValue) {
+    case "string":
+      return parseStringValue(value);
+    case "symbol":
+      return String(value);
+    case "number":
+    case "bigint":
+      return String(roundToPrecision(value, 2));
+    case "boolean":
+      return value.toString();
+    case "object":
+      if (value === null) {
+        return "null";
+      }
+      if (Array.isArray(value)) {
+        return [
+          "[",
+          value.map(serialize).join(", "),
+          "]"
+        ].join("");
+      }
+      return [
+        "{",
+        Object.entries(value).map(([key, val]) => {
+          const serializedKey = isNumber(key) ? key : `"${key}"`;
+          return `${serializedKey}: ${serialize(val)}`;
+        }).join(", "),
+        "}"
+      ].join("");
+    case "undefined":
+      return "undefined";
+    case "function":
+      return "";
+    default:
+      typeOfValue;
+      return "";
+  }
+};
+export const serializeJSObject = (obj, serializer) => {
+  const serializedObject = pipe(obj)(
+    Object.entries,
+    (entries) => entries.map(([key, value]) => serializer(key, serialize(value))),
+    (serializedValues) => serializedValues.filter((serializedValue) => {
+      try {
+        new Function(`function validateJS() { const obj = ({ ${serializedValue} }) }`);
+        return true;
+      } catch {
+        Logger.error(`Failed to serialize ${serializedValue} as a valid JS object entry. Skipping.`);
+        return false;
+      }
+    }),
+    (entries) => entries.join(","),
+    (result) => {
+      if (result === "") {
+        return "";
+      }
+      return `${result},`;
+    }
+  );
+  return serializedObject;
+};

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

@@ -0,0 +1,28 @@
+import type { ColorScheme, Orientation, Platform } from '@/common/consts';
+import type { AbsoluteFontWeight, Declaration, GradientItemFor_DimensionPercentageFor_LengthValue, LineDirection, MathFunctionFor_DimensionPercentageFor_LengthValue, MathFunctionFor_Length, MediaFeatureValue, ParsedComponent, Token, TokenOrValue, UnresolvedColor } from 'lightningcss';
+export type MediaQueryResolver = {
+    maxWidth: number | null;
+    minWidth: number | null;
+    platform: Platform | null;
+    rtl: boolean | null;
+    important: boolean;
+    importantProperties?: Array<string>;
+    colorScheme: ColorScheme | null;
+    theme: string | null;
+    orientation: Orientation | null;
+    disabled: boolean | null;
+    active: boolean | null;
+    focus: boolean | null;
+    dataAttributes: Record<string, string> | null;
+};
+type TakeArray<T> = T extends Array<any> ? T : never;
+export type DeclarationValues = Declaration['value'] | TakeArray<Declaration['value']>[number] | TokenOrValue | Token | ParsedComponent | Array<TokenOrValue> | MediaFeatureValue | MathFunctionFor_DimensionPercentageFor_LengthValue | MathFunctionFor_Length | LineDirection | GradientItemFor_DimensionPercentageFor_LengthValue | AbsoluteFontWeight | UnresolvedColor;
+export type DeclarationProperty = Declaration['property'];
+export type ProcessMetaValues = {
+    className?: string | null;
+};
+export type AnimationFrame = [Array<string | number>, Array<Record<string, any>>];
+export type StyleSheetTemplate = {
+    [K: string]: Array<MediaQueryResolver & Record<string, unknown>>;
+};
+export {};

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

@@ -0,0 +1,10 @@
+import type { DimensionPercentageFor_LengthValue, Length, LengthValue } from 'lightningcss';
+import type { ProcessorBuilder } from './processor';
+export declare class Units {
+    private readonly Processor;
+    private readonly logger;
+    constructor(Processor: ProcessorBuilder);
+    processLength(length: LengthValue | DimensionPercentageFor_LengthValue | number): any;
+    processAnyLength(length: DimensionPercentageFor_LengthValue | Length | LengthValue): any;
+    replaceInfinity(value: any): any;
+}

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

@@ -0,0 +1,48 @@
+import { Logger } from "../logger.js";
+export class Units {
+  constructor(Processor) {
+    this.Processor = Processor;
+  }
+  logger = new Logger("Units");
+  processLength(length) {
+    if (typeof length === "number") {
+      return length;
+    }
+    if ("unit" in length) {
+      switch (length.unit) {
+        case "px":
+          return this.replaceInfinity(length.value);
+        case "vw":
+          return `rt.screen.width * ${length.value / 100}`;
+        case "vh":
+          return `rt.screen.height * ${length.value / 100}`;
+        case "rem":
+          return length.value * this.Processor.vars["--uniwind-em"];
+        case "em":
+          return `vars["--uniwind-em"]?.(vars) * ${length.value}`;
+        default:
+          this.logger.warn(`Unsupported unit - ${length.unit}`);
+          return length.value;
+      }
+    }
+    return this.Processor.CSS.processValue(length);
+  }
+  processAnyLength(length) {
+    if ("type" in length) {
+      switch (length.type) {
+        case "value":
+        case "dimension":
+          return this.processLength(length.value);
+        case "percentage":
+          return `${length.value * 100}%`;
+        default:
+          this.logger.warn(`Unsupported length type - ${length.type}`);
+          return length.value;
+      }
+    }
+    return this.processLength(length);
+  }
+  replaceInfinity(value) {
+    return value === Infinity ? 99999 : value;
+  }
+}

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

@@ -0,0 +1,23 @@
+export declare const toCamelCase: (str: string) => string;
+type P<I, O> = (data: I) => O;
+type PipeFns<T> = {
+    <A>(a: P<T, A>): A;
+    <A, B>(a: P<T, A>, b: P<A, B>): B;
+    <A, B, C>(a: P<T, A>, b: P<A, B>, c: P<B, C>): C;
+    <A, B, C, D>(a: P<T, A>, b: P<A, B>, c: P<B, C>, d: P<C, D>): D;
+    <A, B, C, D, E>(a: P<T, A>, b: P<A, B>, c: P<B, C>, d: P<C, D>, e: P<D, E>): E;
+    <A, B, C, D, E, F>(a: P<T, A>, b: P<A, B>, c: P<B, C>, d: P<C, D>, e: P<D, E>, f: P<E, F>): F;
+    <A, B, C, D, E, F, G>(a: P<T, A>, b: P<A, B>, c: P<B, C>, d: P<C, D>, e: P<D, E>, f: P<E, F>, g: P<F, G>): G;
+    <A, B, C, D, E, F, G, H>(a: P<T, A>, b: P<A, B>, c: P<B, C>, d: P<C, D>, e: P<D, E>, f: P<E, F>, g: P<F, G>, h: P<G, H>): H;
+    (...fns: Array<P<T, T>>): T;
+};
+export declare const pipe: <T>(data: T) => PipeFns<T>;
+export declare const isNumber: (data: any) => boolean;
+export declare const smartSplit: (str: string, separator?: string | RegExp) => string[];
+export declare const addMissingSpaces: (str: string) => string;
+export declare const isValidJSValue: (jsValueString: string) => boolean;
+export declare const shouldBeSerialized: (value: string) => boolean;
+export declare const roundToPrecision: (value: number, precision: number) => number;
+export declare const deepEqual: <T>(a: T, b: T) => boolean;
+export declare const removeKeys: <TObj extends Record<PropertyKey, any>, TKey extends keyof TObj>(obj: TObj, keysToRemove: Array<TKey>) => Omit<TObj, TKey>;
+export {};

package/dist/{shared/uniwind.PtWWxxnh.mjs → module/bundler/css-processor/utils.js}

@@ -1,8 +1,6 @@
-const name = "@niibase/uniwind";
-
-const toCamelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-const pipe = (data) => ((...fns) => fns.reduce((acc, fn) => fn(acc), data));
-const isNumber = (data) => {
+export const toCamelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+export const pipe = (data) => ((...fns) => fns.reduce((acc, fn) => fn(acc), data));
+export const isNumber = (data) => {
   if (typeof data === "number") {
     return true;
   }
@@ -11,7 +9,7 @@ const isNumber = (data) => {
   }
   return false;
 };
-const smartSplit = (str, separator = " ") => {
+export const smartSplit = (str, separator = " ") => {
   const escaper = "&&&";
   return pipe(str)(
     (x) => x.replace(/\s\?\?\s/g, `${escaper}??${escaper}`),
@@ -20,16 +18,14 @@ const smartSplit = (str, separator = " ") => {
     (x) => x.map((token) => token.replace(new RegExp(escaper, "g"), " "))
   );
 };
-const addMissingSpaces = (str) => pipe(str)(
+export const addMissingSpaces = (str) => pipe(str)(
   (x) => x.trim(),
-  (x) => x.replace(/([^ {])this/g, "$1 this"),
   (x) => x.replace(/\](?=\d)/g, "] "),
   (x) => x.replace(/\](?=")/g, "] "),
-  (x) => x.replace(/\)(?=\S)/g, ") "),
+  (x) => x.replace(/\)(?=[^\s,])/g, ") "),
   (x) => x.replace(/(?<!^)(?<!\s)"(?=\d)/g, '" ')
 );
-const uniq = (arr) => Array.from(new Set(arr));
-const isValidJSValue = (jsValueString) => {
+export const isValidJSValue = (jsValueString) => {
   try {
     new Function(`const test = ${jsValueString}`);
     return true;
@@ -37,13 +33,13 @@ const isValidJSValue = (jsValueString) => {
     return false;
   }
 };
-const shouldBeSerialized = (value) => {
+export const shouldBeSerialized = (value) => {
   if (value.includes("-")) {
     return value.split("-").some(shouldBeSerialized);
   }
   return [
     isNumber(value),
-    value.startsWith("this["),
+    value.startsWith("vars["),
     value.startsWith("rt."),
     /[*/+-]/.test(value),
     value.includes('"'),
@@ -52,8 +48,8 @@ const shouldBeSerialized = (value) => {
     value === ")"
   ].some(Boolean);
 };
-const roundToPrecision = (value, precision) => parseFloat(value.toFixed(precision));
-const deepEqual = (a, b) => {
+export const roundToPrecision = (value, precision) => parseFloat(value.toFixed(precision));
+export const deepEqual = (a, b) => {
   if (Object.is(a, b)) {
     return true;
   }
@@ -66,8 +62,6 @@ const deepEqual = (a, b) => {
   }
   return keysA.every((key) => deepEqual(a[key], b[key]) && Object.prototype.hasOwnProperty.call(b, key));
 };
-const removeKeys = (obj, keysToRemove) => Object.fromEntries(
+export const removeKeys = (obj, keysToRemove) => Object.fromEntries(
   Object.entries(obj).filter(([key]) => !keysToRemove.includes(key))
 );
-
-export { isValidJSValue as a, addMissingSpaces as b, shouldBeSerialized as c, deepEqual as d, removeKeys as e, isNumber as i, name as n, pipe as p, roundToPrecision as r, smartSplit as s, toCamelCase as t, uniq as u };