@tuuject/koi-react 0.0.0-stage → 0.1.0

package/styled-system/patterns/flex.js

@@ -0,0 +1,27 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const flexConfig = { transform(props) {
+  const { direction, align, justify, wrap: wrap2, basis, grow, shrink, ...rest } = props;
+  return {
+    display: "flex",
+    flexDirection: direction,
+    alignItems: align,
+    justifyContent: justify,
+    flexWrap: wrap2,
+    flexBasis: basis,
+    flexGrow: grow,
+    flexShrink: shrink,
+    ...rest
+  };
+} }
+
+export function flexRaw(styles) {
+  const s = getPatternStyles(flexConfig, styles || {})
+  return flexConfig.transform(s, patternFns)
+}
+
+export const flex = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function flex(styles = {}) {
+  return css(flexRaw(styles))
+}), { raw: flexRaw, propKeys: ["align","basis","direction","grow","justify","shrink","wrap"] })

package/styled-system/patterns/float.d.ts

@@ -0,0 +1,23 @@
+import type { TokenValue } from '../types/tokens';
+import type { ConditionalValue, SystemProperties, SystemStyleObject } from '../types/system';
+
+export interface FloatProperties {
+  offset?: ConditionalValue<TokenValue<"spacing"> | SystemProperties["top"]>
+  offsetX?: ConditionalValue<TokenValue<"spacing"> | SystemProperties["left"]>
+  offsetY?: ConditionalValue<TokenValue<"spacing"> | SystemProperties["top"]>
+  placement?: ConditionalValue<"bottom-end" | "bottom-start" | "top-end" | "top-start" | "bottom-center" | "top-center" | "middle-center" | "middle-end" | "middle-start">
+}
+
+type FloatRestStyles = Omit<SystemStyleObject, keyof FloatProperties>
+
+interface FloatStyles extends FloatProperties, FloatRestStyles {}
+
+interface FloatPatternFn {
+  (styles?: FloatStyles): string
+  raw: (styles?: FloatStyles) => SystemStyleObject
+  propKeys: Array<keyof FloatProperties>
+}
+
+export declare function floatRaw(styles?: FloatStyles): SystemStyleObject;
+
+export declare const float: FloatPatternFn;

package/styled-system/patterns/float.js

@@ -0,0 +1,84 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const floatConfig = {
+  transform(props, { map }) {
+    const { offset, offsetX, offsetY, placement, ...rest } = props;
+    return {
+      display: "inline-flex",
+      justifyContent: "center",
+      alignItems: "center",
+      position: "absolute",
+      insetBlockStart: map(placement, (v) => {
+        const [side] = v.split("-");
+        const map2 = {
+          top: offsetY,
+          middle: "50%",
+          bottom: "auto"
+        };
+        return map2[side];
+      }),
+      insetBlockEnd: map(placement, (v) => {
+        const [side] = v.split("-");
+        const map2 = {
+          top: "auto",
+          middle: "50%",
+          bottom: offsetY
+        };
+        return map2[side];
+      }),
+      insetInlineStart: map(placement, (v) => {
+        const [, align] = v.split("-");
+        const map2 = {
+          start: offsetX,
+          center: "50%",
+          end: "auto"
+        };
+        return map2[align];
+      }),
+      insetInlineEnd: map(placement, (v) => {
+        const [, align] = v.split("-");
+        const map2 = {
+          start: "auto",
+          center: "50%",
+          end: offsetX
+        };
+        return map2[align];
+      }),
+      translate: map(placement, (v) => {
+        const [side, align] = v.split("-");
+        const mapX = {
+          start: "-50%",
+          center: "-50%",
+          end: "50%"
+        };
+        const mapY = {
+          top: "-50%",
+          middle: "-50%",
+          bottom: "50%"
+        };
+        return `${mapX[align]} ${mapY[side]}`;
+      }),
+      ...rest
+    };
+  },
+  defaultValues(props) {
+    const offset = props.offset || "0";
+    return {
+      offset,
+      offsetX: offset,
+      offsetY: offset,
+      placement: "top-end"
+    };
+  }
+}
+
+export function floatRaw(styles) {
+  const s = getPatternStyles(floatConfig, styles || {})
+  return floatConfig.transform(s, patternFns)
+}
+
+export const float = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function float(styles = {}) {
+  return css(floatRaw(styles))
+}), { raw: floatRaw, propKeys: ["offset","offsetX","offsetY","placement"] })

package/styled-system/patterns/grid-item.d.ts

@@ -0,0 +1,24 @@
+import type { ConditionalValue, SystemStyleObject } from '../types/system';
+
+export interface GridItemProperties {
+  colEnd?: ConditionalValue<number>
+  colSpan?: ConditionalValue<number>
+  colStart?: ConditionalValue<number>
+  rowEnd?: ConditionalValue<number>
+  rowSpan?: ConditionalValue<number>
+  rowStart?: ConditionalValue<number>
+}
+
+type GridItemRestStyles = Omit<SystemStyleObject, keyof GridItemProperties>
+
+interface GridItemStyles extends GridItemProperties, GridItemRestStyles {}
+
+interface GridItemPatternFn {
+  (styles?: GridItemStyles): string
+  raw: (styles?: GridItemStyles) => SystemStyleObject
+  propKeys: Array<keyof GridItemProperties>
+}
+
+export declare function gridItemRaw(styles?: GridItemStyles): SystemStyleObject;
+
+export declare const gridItem: GridItemPatternFn;

package/styled-system/patterns/grid-item.js

@@ -0,0 +1,26 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const gridItemConfig = { transform(props, { map }) {
+  const { colSpan, rowSpan, colStart, rowStart, colEnd, rowEnd, ...rest } = props;
+  const spanFn = (v) => v === "auto" ? v : `span ${v}`;
+  return {
+    gridColumn: colSpan != null ? map(colSpan, spanFn) : void 0,
+    gridRow: rowSpan != null ? map(rowSpan, spanFn) : void 0,
+    gridColumnStart: colStart,
+    gridColumnEnd: colEnd,
+    gridRowStart: rowStart,
+    gridRowEnd: rowEnd,
+    ...rest
+  };
+} }
+
+export function gridItemRaw(styles) {
+  const s = getPatternStyles(gridItemConfig, styles || {})
+  return gridItemConfig.transform(s, patternFns)
+}
+
+export const gridItem = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function gridItem(styles = {}) {
+  return css(gridItemRaw(styles))
+}), { raw: gridItemRaw, propKeys: ["colEnd","colSpan","colStart","rowEnd","rowSpan","rowStart"] })

package/styled-system/patterns/grid.d.ts

@@ -0,0 +1,24 @@
+import type { TokenValue } from '../types/tokens';
+import type { ConditionalValue, SystemProperties, SystemStyleObject } from '../types/system';
+
+export interface GridProperties {
+  columnGap?: SystemProperties["gap"]
+  columns?: ConditionalValue<number>
+  gap?: SystemProperties["gap"]
+  minChildWidth?: ConditionalValue<TokenValue<"sizes"> | SystemProperties["width"]>
+  rowGap?: SystemProperties["gap"]
+}
+
+type GridRestStyles = Omit<SystemStyleObject, keyof GridProperties>
+
+interface GridStyles extends GridProperties, GridRestStyles {}
+
+interface GridPatternFn {
+  (styles?: GridStyles): string
+  raw: (styles?: GridStyles) => SystemStyleObject
+  propKeys: Array<keyof GridProperties>
+}
+
+export declare function gridRaw(styles?: GridStyles): SystemStyleObject;
+
+export declare const grid: GridPatternFn;

package/styled-system/patterns/grid.js

@@ -0,0 +1,30 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const gridConfig = {
+  transform(props, { map, isCssUnit }) {
+    const { columnGap, rowGap, gap, columns, minChildWidth, ...rest } = props;
+    const getValue = (v) => isCssUnit(v) ? v : `token(sizes.${v}, ${v})`;
+    return {
+      display: "grid",
+      gridTemplateColumns: columns != null ? map(columns, (v) => `repeat(${v}, minmax(0, 1fr))`) : minChildWidth != null ? map(minChildWidth, (v) => `repeat(auto-fit, minmax(${getValue(v)}, 1fr))`) : void 0,
+      gap,
+      columnGap,
+      rowGap,
+      ...rest
+    };
+  },
+  defaultValues(props) {
+    return { gap: props.columnGap || props.rowGap ? void 0 : "8px" };
+  }
+}
+
+export function gridRaw(styles) {
+  const s = getPatternStyles(gridConfig, styles || {})
+  return gridConfig.transform(s, patternFns)
+}
+
+export const grid = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function grid(styles = {}) {
+  return css(gridRaw(styles))
+}), { raw: gridRaw, propKeys: ["columnGap","columns","gap","minChildWidth","rowGap"] })

package/styled-system/patterns/hstack.d.ts

@@ -0,0 +1,20 @@
+import type { SystemProperties, SystemStyleObject } from '../types/system';
+
+export interface HstackProperties {
+  gap?: SystemProperties["gap"]
+  justify?: SystemProperties["justifyContent"]
+}
+
+type HstackRestStyles = Omit<SystemStyleObject, keyof HstackProperties>
+
+interface HstackStyles extends HstackProperties, HstackRestStyles {}
+
+interface HstackPatternFn {
+  (styles?: HstackStyles): string
+  raw: (styles?: HstackStyles) => SystemStyleObject
+  propKeys: Array<keyof HstackProperties>
+}
+
+export declare function hstackRaw(styles?: HstackStyles): SystemStyleObject;
+
+export declare const hstack: HstackPatternFn;

package/styled-system/patterns/hstack.js

@@ -0,0 +1,27 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const hstackConfig = {
+  transform(props) {
+    const { justify, gap, ...rest } = props;
+    return {
+      display: "flex",
+      alignItems: "center",
+      justifyContent: justify,
+      gap,
+      flexDirection: "row",
+      ...rest
+    };
+  },
+  defaultValues: { gap: "8px" }
+}
+
+export function hstackRaw(styles) {
+  const s = getPatternStyles(hstackConfig, styles || {})
+  return hstackConfig.transform(s, patternFns)
+}
+
+export const hstack = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function hstack(styles = {}) {
+  return css(hstackRaw(styles))
+}), { raw: hstackRaw, propKeys: ["gap","justify"] })

package/styled-system/patterns/index.d.ts

@@ -0,0 +1,20 @@
+export * from './aspect-ratio';
+export * from './bleed';
+export * from './box';
+export * from './center';
+export * from './circle';
+export * from './container';
+export * from './cq';
+export * from './divider';
+export * from './flex';
+export * from './float';
+export * from './grid';
+export * from './grid-item';
+export * from './hstack';
+export * from './link-overlay';
+export * from './spacer';
+export * from './square';
+export * from './stack';
+export * from './visually-hidden';
+export * from './vstack';
+export * from './wrap';

package/styled-system/patterns/index.js

@@ -0,0 +1,20 @@
+export * from './aspect-ratio';
+export * from './bleed';
+export * from './box';
+export * from './center';
+export * from './circle';
+export * from './container';
+export * from './cq';
+export * from './divider';
+export * from './flex';
+export * from './float';
+export * from './grid';
+export * from './grid-item';
+export * from './hstack';
+export * from './link-overlay';
+export * from './spacer';
+export * from './square';
+export * from './stack';
+export * from './visually-hidden';
+export * from './vstack';
+export * from './wrap';

package/styled-system/patterns/link-overlay.d.ts

@@ -0,0 +1,17 @@
+import type { SystemStyleObject } from '../types/system';
+
+export interface LinkOverlayProperties {}
+
+type LinkOverlayRestStyles = Omit<SystemStyleObject, keyof LinkOverlayProperties>
+
+interface LinkOverlayStyles extends LinkOverlayProperties, LinkOverlayRestStyles {}
+
+interface LinkOverlayPatternFn {
+  (styles?: LinkOverlayStyles): string
+  raw: (styles?: LinkOverlayStyles) => SystemStyleObject
+  propKeys: Array<keyof LinkOverlayProperties>
+}
+
+export declare function linkOverlayRaw(styles?: LinkOverlayStyles): SystemStyleObject;
+
+export declare const linkOverlay: LinkOverlayPatternFn;

package/styled-system/patterns/link-overlay.js

@@ -0,0 +1,25 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const linkOverlayConfig = { transform(props) {
+  return {
+    _before: {
+      content: "\"\"",
+      position: "absolute",
+      inset: "0",
+      zIndex: "0",
+      ...props["_before"]
+    },
+    ...props
+  };
+} }
+
+export function linkOverlayRaw(styles) {
+  const s = getPatternStyles(linkOverlayConfig, styles || {})
+  return linkOverlayConfig.transform(s, patternFns)
+}
+
+export const linkOverlay = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function linkOverlay(styles = {}) {
+  return css(linkOverlayRaw(styles))
+}), { raw: linkOverlayRaw, propKeys: [] })

package/styled-system/patterns/runtime.js

@@ -0,0 +1,25 @@
+import { mapObject, withDefaults } from '../helpers';
+
+const CSS_FUNCTION_REGEX = /^(min|max|clamp|calc)\(.*\)/
+const CSS_VAR_REGEX = /^var\(--.+\)$/
+const CSS_UNIT_REGEX = /^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?(?:cm|mm|Q|in|pc|pt|px|em|ex|ch|rem|lh|rlh|vw|vh|vmin|vmax|vb|vi|svw|svh|lvw|lvh|dvw|dvh|cqw|cqh|cqi|cqb|cqmin|cqmax|%)$/
+
+export function isCssFunction(v) {
+  return typeof v === "string" && CSS_FUNCTION_REGEX.test(v)
+}
+
+export function isCssVar(v) {
+  return typeof v === "string" && CSS_VAR_REGEX.test(v)
+}
+
+export function isCssUnit(v) {
+  return typeof v === "string" && CSS_UNIT_REGEX.test(v)
+}
+
+export const patternFns = { map: mapObject, isCssFunction, isCssVar, isCssUnit }
+
+export function getPatternStyles(pattern, styles) {
+  if (!pattern?.defaultValues) return styles
+  const defaults = typeof pattern.defaultValues === "function" ? pattern.defaultValues(styles) : pattern.defaultValues
+  return withDefaults(defaults, styles)
+}

package/styled-system/patterns/spacer.d.ts

@@ -0,0 +1,20 @@
+import type { TokenValue } from '../types/tokens';
+import type { ConditionalValue, SystemStyleObject } from '../types/system';
+
+export interface SpacerProperties {
+  size?: ConditionalValue<TokenValue<"spacing">>
+}
+
+type SpacerRestStyles = Omit<SystemStyleObject, keyof SpacerProperties>
+
+interface SpacerStyles extends SpacerProperties, SpacerRestStyles {}
+
+interface SpacerPatternFn {
+  (styles?: SpacerStyles): string
+  raw: (styles?: SpacerStyles) => SystemStyleObject
+  propKeys: Array<keyof SpacerProperties>
+}
+
+export declare function spacerRaw(styles?: SpacerStyles): SystemStyleObject;
+
+export declare const spacer: SpacerPatternFn;

package/styled-system/patterns/spacer.js

@@ -0,0 +1,26 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const spacerConfig = { transform(props, { map, isCssUnit, isCssVar }) {
+  const { size, ...rest } = props;
+  return {
+    alignSelf: "stretch",
+    justifySelf: "stretch",
+    flex: map(size, (v) => {
+      if (v == null) return "1";
+      const val = isCssUnit(v) || isCssVar(v) ? v : `token(spacing.${v}, ${v})`;
+      return `0 0 ${val}`;
+    }),
+    ...rest
+  };
+} }
+
+export function spacerRaw(styles) {
+  const s = getPatternStyles(spacerConfig, styles || {})
+  return spacerConfig.transform(s, patternFns)
+}
+
+export const spacer = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function spacer(styles = {}) {
+  return css(spacerRaw(styles))
+}), { raw: spacerRaw, propKeys: ["size"] })

package/styled-system/patterns/square.d.ts

@@ -0,0 +1,19 @@
+import type { SystemProperties, SystemStyleObject } from '../types/system';
+
+export interface SquareProperties {
+  size?: SystemProperties["width"]
+}
+
+type SquareRestStyles = Omit<SystemStyleObject, keyof SquareProperties>
+
+interface SquareStyles extends SquareProperties, SquareRestStyles {}
+
+interface SquarePatternFn {
+  (styles?: SquareStyles): string
+  raw: (styles?: SquareStyles) => SystemStyleObject
+  propKeys: Array<keyof SquareProperties>
+}
+
+export declare function squareRaw(styles?: SquareStyles): SystemStyleObject;
+
+export declare const square: SquarePatternFn;

package/styled-system/patterns/square.js

@@ -0,0 +1,25 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const squareConfig = { transform(props) {
+  const { size, ...rest } = props;
+  return {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    flex: "0 0 auto",
+    width: size,
+    height: size,
+    ...rest
+  };
+} }
+
+export function squareRaw(styles) {
+  const s = getPatternStyles(squareConfig, styles || {})
+  return squareConfig.transform(s, patternFns)
+}
+
+export const square = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function square(styles = {}) {
+  return css(squareRaw(styles))
+}), { raw: squareRaw, propKeys: ["size"] })

package/styled-system/patterns/stack.d.ts

@@ -0,0 +1,22 @@
+import type { SystemProperties, SystemStyleObject } from '../types/system';
+
+export interface StackProperties {
+  align?: SystemProperties["alignItems"]
+  direction?: SystemProperties["flexDirection"]
+  gap?: SystemProperties["gap"]
+  justify?: SystemProperties["justifyContent"]
+}
+
+type StackRestStyles = Omit<SystemStyleObject, keyof StackProperties>
+
+interface StackStyles extends StackProperties, StackRestStyles {}
+
+interface StackPatternFn {
+  (styles?: StackStyles): string
+  raw: (styles?: StackStyles) => SystemStyleObject
+  propKeys: Array<keyof StackProperties>
+}
+
+export declare function stackRaw(styles?: StackStyles): SystemStyleObject;
+
+export declare const stack: StackPatternFn;

package/styled-system/patterns/stack.js

@@ -0,0 +1,30 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const stackConfig = {
+  transform(props) {
+    const { align, justify, direction, gap, ...rest } = props;
+    return {
+      display: "flex",
+      flexDirection: direction,
+      alignItems: align,
+      justifyContent: justify,
+      gap,
+      ...rest
+    };
+  },
+  defaultValues: {
+    direction: "column",
+    gap: "8px"
+  }
+}
+
+export function stackRaw(styles) {
+  const s = getPatternStyles(stackConfig, styles || {})
+  return stackConfig.transform(s, patternFns)
+}
+
+export const stack = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function stack(styles = {}) {
+  return css(stackRaw(styles))
+}), { raw: stackRaw, propKeys: ["align","direction","gap","justify"] })

package/styled-system/patterns/visually-hidden.d.ts

@@ -0,0 +1,17 @@
+import type { SystemStyleObject } from '../types/system';
+
+export interface VisuallyHiddenProperties {}
+
+type VisuallyHiddenRestStyles = Omit<SystemStyleObject, keyof VisuallyHiddenProperties>
+
+interface VisuallyHiddenStyles extends VisuallyHiddenProperties, VisuallyHiddenRestStyles {}
+
+interface VisuallyHiddenPatternFn {
+  (styles?: VisuallyHiddenStyles): string
+  raw: (styles?: VisuallyHiddenStyles) => SystemStyleObject
+  propKeys: Array<keyof VisuallyHiddenProperties>
+}
+
+export declare function visuallyHiddenRaw(styles?: VisuallyHiddenStyles): SystemStyleObject;
+
+export declare const visuallyHidden: VisuallyHiddenPatternFn;

package/styled-system/patterns/visually-hidden.js

@@ -0,0 +1,19 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const visuallyHiddenConfig = { transform(props) {
+  return {
+    srOnly: true,
+    ...props
+  };
+} }
+
+export function visuallyHiddenRaw(styles) {
+  const s = getPatternStyles(visuallyHiddenConfig, styles || {})
+  return visuallyHiddenConfig.transform(s, patternFns)
+}
+
+export const visuallyHidden = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function visuallyHidden(styles = {}) {
+  return css(visuallyHiddenRaw(styles))
+}), { raw: visuallyHiddenRaw, propKeys: [] })

package/styled-system/patterns/vstack.d.ts

@@ -0,0 +1,20 @@
+import type { SystemProperties, SystemStyleObject } from '../types/system';
+
+export interface VstackProperties {
+  gap?: SystemProperties["gap"]
+  justify?: SystemProperties["justifyContent"]
+}
+
+type VstackRestStyles = Omit<SystemStyleObject, keyof VstackProperties>
+
+interface VstackStyles extends VstackProperties, VstackRestStyles {}
+
+interface VstackPatternFn {
+  (styles?: VstackStyles): string
+  raw: (styles?: VstackStyles) => SystemStyleObject
+  propKeys: Array<keyof VstackProperties>
+}
+
+export declare function vstackRaw(styles?: VstackStyles): SystemStyleObject;
+
+export declare const vstack: VstackPatternFn;

package/styled-system/patterns/vstack.js

@@ -0,0 +1,27 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const vstackConfig = {
+  transform(props) {
+    const { justify, gap, ...rest } = props;
+    return {
+      display: "flex",
+      alignItems: "center",
+      justifyContent: justify,
+      gap,
+      flexDirection: "column",
+      ...rest
+    };
+  },
+  defaultValues: { gap: "8px" }
+}
+
+export function vstackRaw(styles) {
+  const s = getPatternStyles(vstackConfig, styles || {})
+  return vstackConfig.transform(s, patternFns)
+}
+
+export const vstack = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function vstack(styles = {}) {
+  return css(vstackRaw(styles))
+}), { raw: vstackRaw, propKeys: ["gap","justify"] })

package/styled-system/patterns/wrap.d.ts

@@ -0,0 +1,23 @@
+import type { SystemProperties, SystemStyleObject } from '../types/system';
+
+export interface WrapProperties {
+  align?: SystemProperties["alignItems"]
+  columnGap?: SystemProperties["gap"]
+  gap?: SystemProperties["gap"]
+  justify?: SystemProperties["justifyContent"]
+  rowGap?: SystemProperties["gap"]
+}
+
+type WrapRestStyles = Omit<SystemStyleObject, keyof WrapProperties>
+
+interface WrapStyles extends WrapProperties, WrapRestStyles {}
+
+interface WrapPatternFn {
+  (styles?: WrapStyles): string
+  raw: (styles?: WrapStyles) => SystemStyleObject
+  propKeys: Array<keyof WrapProperties>
+}
+
+export declare function wrapRaw(styles?: WrapStyles): SystemStyleObject;
+
+export declare const wrap: WrapPatternFn;