@niibase/uniwind 1.0.0

package/dist/module/core/native/parsers/fontVariant.js

@@ -0,0 +1 @@
+export const parseFontVariant = (fontVariant) => fontVariant.split(" ").filter((token) => token !== "undefined");

package/dist/module/core/native/parsers/gradient.d.ts

@@ -0,0 +1,8 @@
+export declare const resolveGradient: (value: string) => {
+    colorStops: {
+        color: string;
+        positions: string[][] | undefined;
+    }[];
+    type: "linear-gradient";
+    direction: string | undefined;
+}[];

package/dist/module/core/native/parsers/gradient.js

@@ -0,0 +1,26 @@
+const gradientDirectionTokens = /* @__PURE__ */ new Set(["to", "top", "right", "bottom", "left"]);
+export const resolveGradient = (value) => {
+  const tokens = value.split(", ");
+  const directionToken = tokens.find((token) => token.includes("to") || token.includes("deg"));
+  const filtered = tokens.filter((token) => token !== directionToken);
+  const colorStops = filtered.map((token) => {
+    const [color, position] = token.split(" ");
+    return {
+      color,
+      positions: position !== void 0 ? [position] : void 0
+    };
+  });
+  const direction = directionToken?.split(" ").reduce((acc, token) => {
+    if (gradientDirectionTokens.has(token) || token.includes("deg")) {
+      return `${acc} ${token.replace(",", "")}`;
+    }
+    return acc;
+  }, "").trim();
+  return [
+    {
+      colorStops,
+      type: "linear-gradient",
+      direction
+    }
+  ];
+};

package/dist/module/core/native/parsers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './boxShadow';
+export * from './fontVariant';
+export * from './gradient';
+export * from './textShadow';
+export * from './transforms';

package/dist/module/core/native/parsers/index.js

@@ -0,0 +1,5 @@
+export * from "./boxShadow.js";
+export * from "./fontVariant.js";
+export * from "./gradient.js";
+export * from "./textShadow.js";
+export * from "./transforms.js";

package/dist/module/core/native/parsers/textShadow.d.ts

@@ -0,0 +1 @@
+export declare const parseTextShadowMutation: (styles: Record<string, any>) => void;

package/dist/module/core/native/parsers/textShadow.js

@@ -0,0 +1,32 @@
+export const parseTextShadowMutation = (styles) => {
+  const tokens = styles.textShadow.replace(/,/g, "").split(" ");
+  if (tokens.length === 0) {
+    return;
+  }
+  const color = tokens.find((token) => token.startsWith("#")) ?? "#000000";
+  const offsets = tokens.filter((token) => token !== color);
+  const [offsetX, offsetY, radius] = offsets;
+  if (offsetX !== void 0 && offsetY !== void 0) {
+    Object.defineProperty(styles, "textShadowOffset", {
+      configurable: true,
+      enumerable: true,
+      value: {
+        width: Number(offsetX),
+        height: Number(offsetY)
+      }
+    });
+    delete styles.textShadow;
+  }
+  if (radius !== void 0) {
+    Object.defineProperty(styles, "textShadowRadius", {
+      configurable: true,
+      enumerable: true,
+      value: Number(radius)
+    });
+  }
+  Object.defineProperty(styles, "textShadowColor", {
+    configurable: true,
+    enumerable: true,
+    value: color
+  });
+};

package/dist/module/core/native/parsers/transforms.d.ts

@@ -0,0 +1 @@
+export declare const parseTransformsMutation: (styles: Record<string, any>) => void;

package/dist/module/core/native/parsers/transforms.js

@@ -0,0 +1,48 @@
+const transforms = [
+  "translateX",
+  "translateY",
+  "translateZ",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "scaleZ",
+  "skewX",
+  "skewY",
+  "perspective"
+];
+const processTransform = (transform, value) => {
+  if (transform.startsWith("scale") && typeof value === "string") {
+    return parseFloat(value.replace("%", "")) / 100;
+  }
+  return value;
+};
+export const parseTransformsMutation = (styles) => {
+  const transformTokens = typeof styles.transform === "string" ? styles.transform.split(" ").filter((token) => token !== "undefined") : [];
+  const transformsResult = [];
+  for (const transform of transforms) {
+    if (transformTokens.length > 0) {
+      for (const token of transformTokens) {
+        if (!token.startsWith(transform)) {
+          continue;
+        }
+        const transformValue = token.slice(transform.length + 1, -1);
+        transformsResult.push({ [transform]: processTransform(transform, transformValue) });
+      }
+    }
+    if (styles[transform] !== void 0) {
+      transformsResult.push({ [transform]: processTransform(transform, styles[transform]) });
+      delete styles[transform];
+    }
+  }
+  if (transformsResult.length > 0) {
+    Object.defineProperty(styles, "transform", {
+      configurable: true,
+      enumerable: true,
+      value: transformsResult
+    });
+  }
+};

package/dist/module/core/native/runtime.d.ts

@@ -0,0 +1,2 @@
+import type { UniwindRuntime as UniwindRuntimeType } from '../types';
+export declare const UniwindRuntime: UniwindRuntimeType;

package/dist/module/core/native/runtime.js

@@ -0,0 +1,28 @@
+import { Appearance, Dimensions, I18nManager, PixelRatio, StyleSheet } from "react-native";
+import { ColorScheme, Orientation } from "../../types.js";
+import { colorMix, lightDark } from "./native-utils.js";
+const window = Dimensions.get("window");
+const initialColorScheme = Appearance.getColorScheme() ?? ColorScheme.Light;
+export const UniwindRuntime = {
+  screen: {
+    width: window.width,
+    height: window.height
+  },
+  colorScheme: initialColorScheme,
+  currentThemeName: initialColorScheme,
+  orientation: window.width > window.height ? Orientation.Landscape : Orientation.Portrait,
+  fontScale: (value) => value * PixelRatio.getFontScale(),
+  hairlineWidth: StyleSheet.hairlineWidth,
+  rtl: I18nManager.isRTL,
+  insets: {
+    top: 0,
+    left: 0,
+    bottom: 0,
+    right: 0
+  },
+  colorMix,
+  pixelRatio: (value) => value * PixelRatio.get(),
+  cubicBezier: () => "",
+  lightDark: () => ""
+};
+UniwindRuntime.lightDark = lightDark.bind(UniwindRuntime);

package/dist/module/core/native/store.d.ts

@@ -0,0 +1,19 @@
+import { StyleDependency } from '../../types';
+import { ComponentState, CSSVariables, GenerateStyleSheetsCallback, RNStyle } from '../types';
+type StylesResult = {
+    styles: RNStyle;
+    dependencies: Array<StyleDependency>;
+};
+declare class UniwindStoreBuilder {
+    runtime: import("../types").UniwindRuntime;
+    vars: Record<string, unknown>;
+    runtimeThemeVariables: Map<string, CSSVariables>;
+    private stylesheet;
+    private cache;
+    private generateStyleSheetCallbackResult;
+    getStyles(className?: string, state?: ComponentState): StylesResult;
+    reinit: (generateStyleSheetCallback?: GenerateStyleSheetsCallback) => void;
+    private resolveStyles;
+}
+export declare const UniwindStore: UniwindStoreBuilder;
+export {};

package/dist/module/core/native/store.js

@@ -0,0 +1,172 @@
+import { Dimensions, Platform } from "react-native";
+import { Orientation, StyleDependency } from "../../types.js";
+import { UniwindListener } from "../listener.js";
+import { cloneWithAccessors } from "./native-utils.js";
+import { parseBoxShadow, parseFontVariant, parseTextShadowMutation, parseTransformsMutation, resolveGradient } from "./parsers/index.js";
+import { UniwindRuntime } from "./runtime.js";
+class UniwindStoreBuilder {
+  runtime = UniwindRuntime;
+  vars = {};
+  runtimeThemeVariables = /* @__PURE__ */ new Map();
+  stylesheet = {};
+  cache = /* @__PURE__ */ new Map();
+  generateStyleSheetCallbackResult = null;
+  getStyles(className, state) {
+    if (className === void 0 || className === "") {
+      return {
+        styles: {},
+        dependencies: []
+      };
+    }
+    const cacheKey = `${className}${state?.isDisabled ?? false}${state?.isFocused ?? false}${state?.isPressed ?? false}`;
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const result = this.resolveStyles(className, state);
+    this.cache.set(cacheKey, result);
+    UniwindListener.subscribe(
+      () => this.cache.delete(cacheKey),
+      result.dependencies,
+      { once: true }
+    );
+    return result;
+  }
+  reinit = (generateStyleSheetCallback) => {
+    const config = generateStyleSheetCallback?.(this.runtime) ?? this.generateStyleSheetCallbackResult;
+    if (!config) {
+      return;
+    }
+    const { scopedVars, stylesheet, vars } = config;
+    this.generateStyleSheetCallbackResult = config;
+    this.stylesheet = stylesheet;
+    this.vars = vars;
+    const themeVars = scopedVars[`__uniwind-theme-${this.runtime.currentThemeName}`];
+    const platformVars = scopedVars[`__uniwind-platform-${Platform.OS}`];
+    const runtimeThemeVars = this.runtimeThemeVariables.get(this.runtime.currentThemeName);
+    if (themeVars) {
+      Object.defineProperties(this.vars, Object.getOwnPropertyDescriptors(themeVars));
+    }
+    if (platformVars) {
+      Object.defineProperties(this.vars, Object.getOwnPropertyDescriptors(platformVars));
+    }
+    if (runtimeThemeVars) {
+      Object.defineProperties(this.vars, Object.getOwnPropertyDescriptors(runtimeThemeVars));
+    }
+    if (__DEV__ && generateStyleSheetCallback) {
+      UniwindListener.notifyAll();
+    }
+  };
+  resolveStyles(classNames, state) {
+    const result = {};
+    let vars = this.vars;
+    const dependencies = /* @__PURE__ */ new Set();
+    const bestBreakpoints = /* @__PURE__ */ new Map();
+    for (const className of classNames.split(" ")) {
+      if (!(className in this.stylesheet)) {
+        continue;
+      }
+      for (const style of this.stylesheet[className]) {
+        if (style.dependencies) {
+          style.dependencies.forEach((dep) => dependencies.add(dep));
+        }
+        if (style.minWidth > this.runtime.screen.width || style.maxWidth < this.runtime.screen.width || style.theme !== null && this.runtime.currentThemeName !== style.theme || style.orientation !== null && this.runtime.orientation !== style.orientation || style.rtl !== null && this.runtime.rtl !== style.rtl || style.active !== null && state?.isPressed !== style.active || style.focus !== null && state?.isFocused !== style.focus || style.disabled !== null && state?.isDisabled !== style.disabled) {
+          continue;
+        }
+        for (const [property, valueGetter] of style.entries) {
+          const previousBest = bestBreakpoints.get(property);
+          if (previousBest && (previousBest.minWidth > style.minWidth || previousBest.complexity > style.complexity || previousBest.importantProperties.includes(property))) {
+            continue;
+          }
+          if (property[0] === "-") {
+            if (vars === this.vars) {
+              vars = cloneWithAccessors(this.vars);
+            }
+            Object.defineProperty(vars, property, {
+              configurable: true,
+              enumerable: true,
+              get: valueGetter
+            });
+          } else {
+            Object.defineProperty(result, property, {
+              configurable: true,
+              enumerable: true,
+              get: () => valueGetter.call(vars)
+            });
+          }
+          bestBreakpoints.set(property, style);
+        }
+      }
+    }
+    if (result.lineHeight !== void 0 && result.lineHeight < 6) {
+      Object.defineProperty(result, "lineHeight", {
+        value: result.fontSize * result.lineHeight,
+        configurable: true,
+        enumerable: true
+      });
+    }
+    if (result.boxShadow !== void 0) {
+      Object.defineProperty(result, "boxShadow", {
+        value: parseBoxShadow(result.boxShadow),
+        configurable: true,
+        enumerable: true
+      });
+    }
+    if (result.visibility === "hidden") {
+      Object.defineProperty(result, "display", {
+        value: "none",
+        configurable: true,
+        enumerable: true
+      });
+    }
+    if (result.borderStyle !== void 0 && result.borderColor === void 0) {
+      Object.defineProperty(result, "borderColor", {
+        value: "#000000",
+        configurable: true,
+        enumerable: true
+      });
+    }
+    if (result.outlineStyle !== void 0 && result.outlineColor === void 0) {
+      Object.defineProperty(result, "outlineColor", {
+        value: "#000000",
+        configurable: true,
+        enumerable: true
+      });
+    }
+    if (result.fontVariant !== void 0) {
+      Object.defineProperty(result, "fontVariant", {
+        value: parseFontVariant(result.fontVariant),
+        configurable: true,
+        enumerable: true
+      });
+    }
+    parseTransformsMutation(result);
+    if (result.experimental_backgroundImage !== void 0) {
+      Object.defineProperty(result, "experimental_backgroundImage", {
+        value: resolveGradient(result.experimental_backgroundImage),
+        configurable: true,
+        enumerable: true
+      });
+    }
+    if (result.textShadow !== void 0) {
+      parseTextShadowMutation(result);
+    }
+    return {
+      styles: { ...result },
+      dependencies: Array.from(dependencies)
+    };
+  }
+}
+export const UniwindStore = new UniwindStoreBuilder();
+Dimensions.addEventListener("change", ({ window }) => {
+  const newOrientation = window.width > window.height ? Orientation.Landscape : Orientation.Portrait;
+  const orientationChanged = UniwindStore.runtime.orientation !== newOrientation;
+  UniwindStore.runtime.screen = {
+    width: window.width,
+    height: window.height
+  };
+  UniwindStore.runtime.orientation = newOrientation;
+  UniwindListener.notify([
+    ...orientationChanged ? [StyleDependency.Orientation] : [],
+    StyleDependency.Dimensions
+  ]);
+});

package/dist/module/core/types.d.ts

@@ -0,0 +1,73 @@
+import type { ImageStyle, StyleProp, TextStyle, ViewStyle } from 'react-native';
+import { ColorScheme, Orientation, StyleDependency, UniwindConfig } from '../types';
+export type Style = {
+    entries: Array<[string, () => unknown]>;
+    minWidth: number;
+    maxWidth: number;
+    orientation: Orientation | null;
+    theme: ColorScheme | null;
+    rtl: boolean | null;
+    native: boolean;
+    dependencies: Array<StyleDependency> | null;
+    index: number;
+    className: string;
+    importantProperties: Array<string>;
+    complexity: number;
+    active: boolean | null;
+    focus: boolean | null;
+    disabled: boolean | null;
+};
+export type StyleSheets = Record<string, Array<Style>>;
+export type GenerateStyleSheetsCallback = (rt: UniwindRuntime) => {
+    stylesheet: StyleSheets;
+    vars: Record<string, unknown>;
+    scopedVars: Partial<Record<string, Record<string, unknown>>>;
+};
+type UserThemes = UniwindConfig extends {
+    themes: infer T extends readonly string[];
+} ? T : readonly string[];
+export type ThemeName = UserThemes[number];
+export type UniwindRuntime = {
+    screen: {
+        width: number;
+        height: number;
+    };
+    orientation: Orientation;
+    colorScheme: ColorScheme;
+    currentThemeName: ThemeName;
+    rtl: boolean;
+    insets: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    hairlineWidth: number;
+    pixelRatio: (value: number) => number;
+    fontScale: (value: number) => number;
+    colorMix: (color: string, weight: number | string, mixColor: string) => string;
+    cubicBezier: (x1: number, y1: number, x2: number, y2: number) => string;
+    lightDark: (light: string, dark: string) => string;
+};
+export type RNStyle = ViewStyle & TextStyle & ImageStyle & {
+    accentColor?: string;
+    fill?: string;
+};
+export type RNStylesProps = 'style' | 'contentContainerStyle' | 'imageStyle' | 'ListFooterComponentStyle' | 'ListHeaderComponentStyle' | 'columnWrapperStyle';
+export type RNClassNameProps = GetClassName<RNStylesProps>;
+type GetClassName<T extends string> = T extends `${infer S}Style` ? `${S}ClassName` : 'className';
+export type UniwindComponentProps = {
+    [K in RNStylesProps]?: StyleProp<RNStyle>;
+} & {
+    [K in RNClassNameProps]?: string;
+};
+declare global {
+    var __uniwindThemes__: ReadonlyArray<string> | undefined;
+}
+export type ComponentState = {
+    isPressed?: boolean;
+    isDisabled?: boolean;
+    isFocused?: boolean;
+};
+export type CSSVariables = Record<string, string | number>;
+export {};

package/dist/module/core/web/cssListener.d.ts

@@ -0,0 +1,19 @@
+declare class CSSListenerBuilder {
+    private classNameMediaQueryListeners;
+    private listeners;
+    private registeredRules;
+    private processedStyleSheets;
+    private pendingInitialization;
+    constructor();
+    subscribeToClassName(classNames: string, listener: VoidFunction): () => void;
+    private scheduleInitialization;
+    private cancelPendingInitialization;
+    private initialize;
+    private isStyleRule;
+    private isMediaRule;
+    private collectParentMediaQueries;
+    private addMediaQueriesDeep;
+    private addMediaQuery;
+}
+export declare const CSSListener: CSSListenerBuilder;
+export {};

package/dist/module/core/web/cssListener.js

@@ -0,0 +1,137 @@
+import { StyleDependency } from "../../types.js";
+import { UniwindListener } from "../listener.js";
+class CSSListenerBuilder {
+  classNameMediaQueryListeners = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  registeredRules = /* @__PURE__ */ new Map();
+  processedStyleSheets = /* @__PURE__ */ new WeakSet();
+  pendingInitialization = void 0;
+  constructor() {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const observer = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        if (mutation.type === "childList") {
+          this.scheduleInitialization();
+        }
+      }
+    });
+    this.initialize();
+    observer.observe(document.head, {
+      childList: true,
+      subtree: false,
+      attributes: true,
+      attributeFilter: ["disabled", "media", "title", "href", "rel"]
+    });
+  }
+  subscribeToClassName(classNames, listener) {
+    const disposables = [];
+    classNames.split(" ").forEach((className) => {
+      const mediaQuery = this.classNameMediaQueryListeners.get(className);
+      if (!mediaQuery) {
+        return () => {
+        };
+      }
+      const listeners = this.listeners.get(mediaQuery);
+      listeners?.add(listener);
+      disposables.push(() => listeners?.delete(listener));
+    });
+    const disposeThemeListener = UniwindListener.subscribe(listener, [StyleDependency.Theme]);
+    return () => {
+      disposables.forEach((disposable) => disposable());
+      disposeThemeListener();
+    };
+  }
+  scheduleInitialization() {
+    this.cancelPendingInitialization();
+    if (typeof requestIdleCallback !== "undefined") {
+      this.pendingInitialization = requestIdleCallback(() => {
+        this.initialize();
+      }, { timeout: 50 });
+      return;
+    }
+    this.pendingInitialization = setTimeout(() => {
+      this.initialize();
+    }, 50);
+  }
+  cancelPendingInitialization() {
+    if (this.pendingInitialization !== void 0) {
+      if (typeof cancelIdleCallback !== "undefined") {
+        cancelIdleCallback(this.pendingInitialization);
+      } else {
+        clearTimeout(this.pendingInitialization);
+      }
+      this.pendingInitialization = void 0;
+    }
+  }
+  initialize() {
+    this.pendingInitialization = void 0;
+    for (const sheet of Array.from(document.styleSheets)) {
+      if (this.processedStyleSheets.has(sheet)) {
+        continue;
+      }
+      let rules;
+      try {
+        rules = sheet.cssRules;
+      } catch {
+        continue;
+      }
+      if (!rules) {
+        continue;
+      }
+      this.processedStyleSheets.add(sheet);
+      this.addMediaQueriesDeep(rules);
+    }
+  }
+  isStyleRule(rule) {
+    return rule.constructor.name === "CSSStyleRule";
+  }
+  isMediaRule(rule) {
+    return rule.constructor.name === "CSSMediaRule";
+  }
+  collectParentMediaQueries(rule, acc = []) {
+    const { parentRule } = rule;
+    if (!parentRule) {
+      return [];
+    }
+    if (this.isMediaRule(parentRule)) {
+      acc.push(parentRule);
+    }
+    const result = this.collectParentMediaQueries(parentRule, acc);
+    acc.push(...result);
+    return Array.from(new Set(acc));
+  }
+  addMediaQueriesDeep(rules) {
+    for (const rule of Array.from(rules)) {
+      if (this.isStyleRule(rule)) {
+        const mediaQueries = this.collectParentMediaQueries(rule);
+        if (mediaQueries.length > 0) {
+          this.addMediaQuery(mediaQueries, rule.selectorText);
+        }
+        continue;
+      }
+      if ("cssRules" in rule && rule.cssRules instanceof CSSRuleList) {
+        this.addMediaQueriesDeep(rule.cssRules);
+        continue;
+      }
+    }
+  }
+  addMediaQuery(mediaQueries, className) {
+    const rules = mediaQueries.map((mediaQuery) => mediaQuery.conditionText).sort().join(" and ");
+    const parsedClassName = className.replace(".", "").replace("\\", "");
+    const cachedMediaQueryList = this.registeredRules.get(rules);
+    if (cachedMediaQueryList) {
+      this.classNameMediaQueryListeners.set(parsedClassName, cachedMediaQueryList);
+      return;
+    }
+    const mediaQueryList = window.matchMedia(rules);
+    this.registeredRules.set(rules, mediaQueryList);
+    this.listeners.set(mediaQueryList, /* @__PURE__ */ new Set());
+    this.classNameMediaQueryListeners.set(parsedClassName, mediaQueryList);
+    mediaQueryList.addEventListener("change", () => {
+      this.listeners.get(mediaQueryList).forEach((listener) => listener());
+    });
+  }
+}
+export const CSSListener = new CSSListenerBuilder();

package/dist/module/core/web/formatColor.d.ts

@@ -0,0 +1 @@
+export declare const formatColor: (color: string) => string;

package/dist/module/core/web/formatColor.js

@@ -0,0 +1,8 @@
+import { formatHex, formatHex8, parse } from "culori";
+export const formatColor = (color) => {
+  const parsedColor = parse(color);
+  if (!parsedColor) {
+    return color;
+  }
+  return parsedColor.alpha !== void 0 && parsedColor.alpha !== 1 ? formatHex8(parsedColor) : formatHex(parsedColor);
+};

package/dist/module/core/web/getWebStyles.d.ts

@@ -0,0 +1,2 @@
+import { RNStyle } from '../types';
+export declare const getWebStyles: (className?: string) => RNStyle;

package/dist/module/core/web/getWebStyles.js

@@ -0,0 +1,49 @@
+import { parseCSSValue } from "./parseCSSValue.js";
+const dummy = typeof document !== "undefined" ? Object.assign(document.createElement("div"), {
+  style: "display: none"
+}) : null;
+if (dummy) {
+  document.body.appendChild(dummy);
+}
+const getComputedStyles = () => {
+  if (!dummy) {
+    return {};
+  }
+  const computedStyles = window.getComputedStyle(dummy);
+  const styles = {};
+  for (let i = 0; i < computedStyles.length; i++) {
+    const prop = computedStyles[i];
+    styles[prop] = computedStyles.getPropertyValue(prop);
+  }
+  return styles;
+};
+const initialStyles = typeof document !== "undefined" ? getComputedStyles() : {};
+const getObjectDifference = (obj1, obj2) => {
+  const diff = {};
+  const keys = Object.keys(obj2);
+  keys.forEach((key) => {
+    if (obj2[key] !== obj1[key]) {
+      diff[key] = obj2[key];
+    }
+  });
+  return diff;
+};
+export const getWebStyles = (className) => {
+  if (className === void 0) {
+    return {};
+  }
+  if (!dummy) {
+    return {};
+  }
+  dummy.className = className;
+  const computedStyles = getObjectDifference(initialStyles, getComputedStyles());
+  return Object.fromEntries(
+    Object.entries(computedStyles).map(([key, value]) => {
+      const parsedKey = key[0] === "-" ? key : key.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+      return [
+        parsedKey,
+        parseCSSValue(value)
+      ];
+    })
+  );
+};

package/dist/module/core/web/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cssListener';
+export * from './formatColor';
+export * from './getWebStyles';
+export * from './parseCSSValue';

package/dist/module/core/web/index.js

@@ -0,0 +1,4 @@
+export * from "./cssListener.js";
+export * from "./formatColor.js";
+export * from "./getWebStyles.js";
+export * from "./parseCSSValue.js";