@xaui/native 0.9.1-alpha.3 → 0.9.1-alpha.30

package/dist/input.type-D2qgi03E.d.ts

@@ -0,0 +1,167 @@
+import { ReactNode } from 'react';
+import { StyleProp, TextStyle, ViewStyle, TextInputProps, TextProps, ViewProps } from 'react-native';
+import { T as TextStyleProps, V as ViewStyleProps } from './style-props.type-CfnoGEP7.js';
+import { S as Size, R as RadiusKey } from './theme.type-C2gNHpEx.js';
+
+type InputSlot = 'root' | 'label' | 'field' | 'textArea' | 'placeholder' | 'description' | 'error' | 'prefix' | 'suffix' | 'icon';
+/**
+ * The library's four emphasis levels, narrowed like the `Card`'s (§1 bis). A field
+ * **reports nothing** — an error is `isInvalid`, which is a state and not a variant — so
+ * `success`, `warning` and `danger` are absent here for the same reason they are there.
+ *
+ * This is where the theme's `field*` family is finally read, and the four names split
+ * HeroUI's two-name `primary | secondary` by saying what each of their ends already is:
+ *
+ * - **`primary`** — the `fieldBackground` fill plus the theme's `field` shadow. HeroUI's
+ *   `primary`, with the elevation their flat token only implies.
+ * - **`secondary`** — the neutral `default` fill. HeroUI's `secondary`, and the default
+ *   here: on a plain background a white field is its border and nothing else, while on a
+ *   card the `fieldBackground` token *is* the card's own colour.
+ * - **`tertiary`** — the border alone, no fill. The same drop the `Button`'s `tertiary`
+ *   makes.
+ * - **`ghost`** — neither. A bare field for a toolbar or an inline edit; it has no border
+ *   to move, so its focus shows in the caret alone.
+ *
+ * The first three name the `fieldBorder` edge and `ghost` gives it up. Its width is the
+ * theme's `borderWidth.field` — HeroUI's `--field-border-width`, which they ship at `0`
+ * and we ship at `1`. That is the one shipped default where the two differ;
+ * `createTheme({ borderWidth: { field: 0 } })` reproduces theirs.
+ */
+type InputVariant = 'primary' | 'secondary' | 'tertiary' | 'ghost';
+/**
+ * Where the label sits relative to the field's box.
+ *
+ * `outside` is the label above the box, in the column's flow. `inside` lifts it into the
+ * box, above the text — the label is taken **out of flow** and placed against the box's
+ * own padding, so the JSX is identical either way and nothing is reparented (R4).
+ *
+ * Because the inside label positions itself against the top of the root, it assumes the
+ * field is the first thing in the column's flow: write `Input.Description` and
+ * `Input.Error` after the field, which is where they belong anyway.
+ */
+type InputLabelPlacement = 'outside' | 'inside';
+type InputSize = Size;
+/**
+ * What the `Input` itself understands. R14 — a name in here is the component's, so the
+ * style prop that shares it is not exposed: `size` is the field's scale and never
+ * `ViewStyle`'s, and `color` is R7's tint.
+ */
+type InputOwnProps = {
+    variant?: InputVariant;
+    /** The field's height, its padding, the gaps and the type. Never width. */
+    size?: InputSize;
+    /** Overrides the `field` radius the theme chose for every size. */
+    radius?: RadiusKey;
+    /** Above the box, or lifted into it. @default 'outside' */
+    labelPlacement?: InputLabelPlacement;
+    /**
+     * A raw tint (`'#7c3aed'`), never a token (R7). It lands where the variant put its
+     * tokens — the fill of a `default`, the border of a `tertiary` — and, because the focus
+     * colour is a role like any other, it is also what the field borders on focus.
+     */
+    color?: string;
+    /**
+     * Paints the border, the label and the description in `danger`, and takes the focus
+     * treatment off: an error outranks focus, and a field that is both should read as
+     * wrong rather than as busy.
+     *
+     * It does **not** mount or unmount `Input.Error`. That stays the caller's — a slot that
+     * silently renders nothing is a slot you cannot debug.
+     */
+    isInvalid?: boolean;
+    /** Dims the field and makes it uneditable. */
+    isDisabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+    children?: ReactNode;
+};
+/**
+ * R14 — the input's own props, the wrapper `View`'s, and every `ViewStyle` key neither
+ * already claims. **`TextInputProps` are not here**: they belong to `Input.Field`, which
+ * is the node that has them.
+ */
+type InputProps = InputOwnProps & Omit<ViewProps, keyof InputOwnProps> & Omit<ViewStyleProps, keyof InputOwnProps | keyof ViewProps> & {
+    /** R12 — merge into the single child instead of rendering a `View`. */
+    asChild?: boolean;
+};
+/**
+ * Everything `TextInput` accepts, plus the `TextStyle` keys as props (R14).
+ *
+ * `editable` is absent: it is `disabled` under another name, and R8 keeps that off the
+ * public surface — `isDisabled` on the root is what stops the field.
+ */
+type InputFieldProps = Omit<TextInputProps, 'editable'> & Omit<TextStyleProps, keyof TextInputProps>;
+/** `Text`'s own props win over the `TextStyle` keys of the same name (R14). */
+type InputTextProps = TextProps & Omit<TextStyleProps, keyof TextProps> & {
+    children?: ReactNode;
+};
+type InputLabelProps = InputTextProps;
+type InputDescriptionProps = InputTextProps;
+type InputErrorProps = InputTextProps;
+/**
+ * Read off `TextInput`'s own props rather than spelled out: React Native has renamed the
+ * payload of these two more than once, and a hand-written `NativeSyntheticEvent<…>` here
+ * would be a second declaration free to drift from the node that actually fires them.
+ */
+type FieldFocusEvent = Parameters<NonNullable<TextInputProps['onFocus']>>[0];
+type FieldBlurEvent = Parameters<NonNullable<TextInputProps['onBlur']>>[0];
+/**
+ * R5 — resolved styles, not props for a slot to resolve a second time. Each entry is the
+ * cached `StyleSheet` reference with the uncached tint pass layered over it, so a slot
+ * merges its own `style` on top and does no work of its own.
+ */
+type InputContextValue = {
+    labelStyle: StyleProp<TextStyle>;
+    fieldStyle: StyleProp<TextStyle>;
+    /** Layered *over* `fieldStyle` by `Input.TextArea`: only what a multiline field adds. */
+    textAreaStyle: StyleProp<TextStyle>;
+    /**
+     * Values, not a style: `rows` is a raw number, so the height it implies is arithmetic
+     * the slot does — and these are the two measurements it needs, flattened once here
+     * rather than in every text area on the screen.
+     */
+    textArea: {
+        lineHeight: number;
+        paddingVertical: number;
+    };
+    descriptionStyle: StyleProp<TextStyle>;
+    errorStyle: StyleProp<TextStyle>;
+    /**
+     * The two decorators of an `InputGroup`, already pinned to their edge and inset by the
+     * field's own padding. They are resolved here, on the root, because the size that
+     * decides that padding is the root's — the group itself adds no axis of its own.
+     */
+    prefixStyle: StyleProp<ViewStyle>;
+    suffixStyle: StyleProp<ViewStyle>;
+    /**
+     * Values, not a style: an icon is a third party's component, and `size` and `color` are
+     * props it takes rather than a style it accepts. Flattened once here, the way the `Chip`
+     * and the `Alert` publish theirs.
+     */
+    icon: {
+        size: number | undefined;
+        color: string | undefined;
+    };
+    /**
+     * A value and not a style: `placeholderTextColor` is a `TextInput` prop, so the root
+     * flattens its placeholder slot once here rather than in the field.
+     */
+    placeholderTextColor?: string;
+    /**
+     * The focus state lives on the **root**, because the root's recipe resolves on it (R5)
+     * and it needs the value before it renders — but the node that hears the event is
+     * `Input.Field`, three levels down. These are how it reports back. Their identity is
+     * stable, so publishing them costs no re-render of a memoized slot.
+     */
+    onFieldFocus: (event: FieldFocusEvent) => void;
+    onFieldBlur: (event: FieldBlurEvent) => void;
+    /**
+     * The id the label carries and the field points at, so a screen reader reads "Courriel,
+     * champ de saisie" rather than just the placeholder.
+     */
+    labelId: string;
+    descriptionId: string;
+    isDisabled: boolean;
+    isInvalid: boolean;
+};
+
+export type { InputFieldProps as I, InputProps as a, InputContextValue as b, InputDescriptionProps as c, InputErrorProps as d, InputLabelPlacement as e, InputLabelProps as f, InputSize as g, InputSlot as h, InputVariant as i };

package/dist/pressable-feedback.type-BA2C9sSz.d.cts

@@ -0,0 +1,127 @@
+import { ReactNode } from 'react';
+import { PressableProps, StyleProp, ViewStyle } from 'react-native';
+import { SharedValue } from 'react-native-reanimated';
+import { V as ViewStyleProps } from './style-props.type-CfnoGEP7.cjs';
+
+type AnimationConfig = {
+    scale?: boolean;
+    highlight?: boolean;
+    ripple?: boolean;
+};
+/**
+ * `false` and `'disabled'` turn this component's animations off. `'disable-all'` turns
+ * them off for its descendants too — a long list kills every row's worklets with one
+ * prop instead of threading it down. An object switches them off one at a time.
+ */
+type AnimationProp = boolean | 'disabled' | 'disable-all' | AnimationConfig;
+/** `animation` once normalised — what the components actually read. */
+type ResolvedAnimation = {
+    scale: boolean;
+    highlight: boolean;
+    ripple: boolean;
+    /** True when every sub-animation is off: the branch that mounts no worklet at all. */
+    none: boolean;
+    /** Propagated to descendants through context. */
+    disableAll: boolean;
+};
+/**
+ * R14 — it renders a `Pressable`, so it takes that node's style keys as props. The
+ * primitive every pressable component in the library is built on cannot be the one place
+ * where `padding={16}` has to become an object again.
+ */
+type PressableFeedbackProps = Omit<PressableProps, 'style' | 'children' | 'disabled'> & ViewStyleProps & {
+    /** Controlled: the root owns the state, because its recipe resolves on it (R5). */
+    isPressed?: boolean;
+    /** R8: `disabled` is not part of the public vocabulary, `isX` is. */
+    isDisabled?: boolean;
+    /**
+     * Merge into the single child instead of rendering a pressable (R12) — **keeping the
+     * feedback**. Swapping this component out for a bare `Slot` would silently drop the
+     * touch feedback of every `asChild` control.
+     */
+    asChild?: boolean;
+    animation?: AnimationProp;
+    style?: StyleProp<ViewStyle>;
+    /**
+     * The overlays are children, not a prop — `<PressableFeedback.Highlight />` or
+     * `<PressableFeedback.Ripple />`, in any order: the root paints them under everything
+     * else wherever they sit. The scale is the root's own and needs nothing rendered.
+     *
+     * `Pressable`'s function form is dropped on purpose. It exists to hand the press state
+     * to children; here the root above already owns that state and this publishes it
+     * through context, so the function form would be a second, quieter source of truth.
+     */
+    children?: ReactNode;
+};
+/**
+ * A slot's own animation, overriding the blanket one on the root. `false` switches that
+ * slot off; the object tunes it. Deliberately two knobs rather than a full timing
+ * surface — anything past this is a different animation, and that is a component's job,
+ * not a prop's.
+ */
+type SlotAnimation = boolean | {
+    /** Milliseconds. Falls back to the shared press timing. */
+    duration?: number;
+    /** How far the overlay goes at full press, 0 to 1. */
+    opacity?: number;
+};
+/** One ripple wave. Two of them, so a rapid double tap does not cut the one in flight. */
+type RippleWave = {
+    /** `0 → 1` as the circle opens. */
+    expand: SharedValue<number>;
+    /** `0 → 1` as the ink arrives, on its own curve. */
+    alpha: SharedValue<number>;
+    /** Where the finger landed, in the root's coordinates. */
+    origin: SharedValue<{
+        x: number;
+        y: number;
+    }>;
+};
+/**
+ * The corner keys an overlay copies off the root. The `Left`/`Right` forms are absent
+ * rather than forgotten: R13 bans them, because RN mirrors only the logical ones under RTL.
+ */
+type RadiusStyle = Pick<ViewStyle, 'borderRadius' | 'borderStartStartRadius' | 'borderStartEndRadius' | 'borderEndStartRadius' | 'borderEndEndRadius'>;
+type FeedbackContext = {
+    /**
+     * The overlay's ink, resolved by the root from its own background.
+     *
+     * A wash or a wave has to contrast with what it sits on, and only the root knows that —
+     * it flattens its own `style` and reads `backgroundColor`, then takes the contrasting
+     * side the same way a tint does. Black ink at 10% on a saturated fill is close to
+     * invisible, which is the one thing a press indicator cannot be.
+     */
+    ink: string;
+    /**
+     * The root's own corners, so an overlay rounds itself to match. `corners` and not
+     * `radius`: the ripple already has a radius, and it is a length in points rather than a
+     * shape.
+     *
+     * An absolute fill has square corners and every control here is rounded, so without this
+     * both the wash and the wave paint outside the surface at each corner. The overlay
+     * carries the clip rather than the root: clipping the root would also cut a child that
+     * legitimately overflows — a badge on a button's corner — and that child has nothing to
+     * do with the press.
+     */
+    corners: RadiusStyle;
+    isPressed: boolean;
+    animation: ResolvedAnimation;
+    /** Absent on the static branch, where nothing animates and no worklet is mounted. */
+    progress?: SharedValue<number>;
+    /** How big the root is — what the scale coefficient is computed from. */
+    size?: SharedValue<{
+        width: number;
+        height: number;
+    }>;
+    /**
+     * The two ripple waves, driven by the **root**.
+     *
+     * They belong to the root because the root is the touch surface. An overlay carrying its
+     * own handlers only hears touches that land on *it* — and it is a sibling of the label,
+     * not its parent, so pressing the text of a button would do nothing. Touches bubble to
+     * the `Pressable`, which is why the handlers live there and the waves are published down.
+     */
+    waves?: readonly [RippleWave, RippleWave];
+};
+
+export type { AnimationConfig as A, FeedbackContext as F, PressableFeedbackProps as P, RadiusStyle as R, SlotAnimation as S, AnimationProp as a, ResolvedAnimation as b, RippleWave as c };

package/dist/pressable-feedback.type-Bs4dQlGj.d.ts

@@ -0,0 +1,127 @@
+import { ReactNode } from 'react';
+import { PressableProps, StyleProp, ViewStyle } from 'react-native';
+import { SharedValue } from 'react-native-reanimated';
+import { V as ViewStyleProps } from './style-props.type-CfnoGEP7.js';
+
+type AnimationConfig = {
+    scale?: boolean;
+    highlight?: boolean;
+    ripple?: boolean;
+};
+/**
+ * `false` and `'disabled'` turn this component's animations off. `'disable-all'` turns
+ * them off for its descendants too — a long list kills every row's worklets with one
+ * prop instead of threading it down. An object switches them off one at a time.
+ */
+type AnimationProp = boolean | 'disabled' | 'disable-all' | AnimationConfig;
+/** `animation` once normalised — what the components actually read. */
+type ResolvedAnimation = {
+    scale: boolean;
+    highlight: boolean;
+    ripple: boolean;
+    /** True when every sub-animation is off: the branch that mounts no worklet at all. */
+    none: boolean;
+    /** Propagated to descendants through context. */
+    disableAll: boolean;
+};
+/**
+ * R14 — it renders a `Pressable`, so it takes that node's style keys as props. The
+ * primitive every pressable component in the library is built on cannot be the one place
+ * where `padding={16}` has to become an object again.
+ */
+type PressableFeedbackProps = Omit<PressableProps, 'style' | 'children' | 'disabled'> & ViewStyleProps & {
+    /** Controlled: the root owns the state, because its recipe resolves on it (R5). */
+    isPressed?: boolean;
+    /** R8: `disabled` is not part of the public vocabulary, `isX` is. */
+    isDisabled?: boolean;
+    /**
+     * Merge into the single child instead of rendering a pressable (R12) — **keeping the
+     * feedback**. Swapping this component out for a bare `Slot` would silently drop the
+     * touch feedback of every `asChild` control.
+     */
+    asChild?: boolean;
+    animation?: AnimationProp;
+    style?: StyleProp<ViewStyle>;
+    /**
+     * The overlays are children, not a prop — `<PressableFeedback.Highlight />` or
+     * `<PressableFeedback.Ripple />`, in any order: the root paints them under everything
+     * else wherever they sit. The scale is the root's own and needs nothing rendered.
+     *
+     * `Pressable`'s function form is dropped on purpose. It exists to hand the press state
+     * to children; here the root above already owns that state and this publishes it
+     * through context, so the function form would be a second, quieter source of truth.
+     */
+    children?: ReactNode;
+};
+/**
+ * A slot's own animation, overriding the blanket one on the root. `false` switches that
+ * slot off; the object tunes it. Deliberately two knobs rather than a full timing
+ * surface — anything past this is a different animation, and that is a component's job,
+ * not a prop's.
+ */
+type SlotAnimation = boolean | {
+    /** Milliseconds. Falls back to the shared press timing. */
+    duration?: number;
+    /** How far the overlay goes at full press, 0 to 1. */
+    opacity?: number;
+};
+/** One ripple wave. Two of them, so a rapid double tap does not cut the one in flight. */
+type RippleWave = {
+    /** `0 → 1` as the circle opens. */
+    expand: SharedValue<number>;
+    /** `0 → 1` as the ink arrives, on its own curve. */
+    alpha: SharedValue<number>;
+    /** Where the finger landed, in the root's coordinates. */
+    origin: SharedValue<{
+        x: number;
+        y: number;
+    }>;
+};
+/**
+ * The corner keys an overlay copies off the root. The `Left`/`Right` forms are absent
+ * rather than forgotten: R13 bans them, because RN mirrors only the logical ones under RTL.
+ */
+type RadiusStyle = Pick<ViewStyle, 'borderRadius' | 'borderStartStartRadius' | 'borderStartEndRadius' | 'borderEndStartRadius' | 'borderEndEndRadius'>;
+type FeedbackContext = {
+    /**
+     * The overlay's ink, resolved by the root from its own background.
+     *
+     * A wash or a wave has to contrast with what it sits on, and only the root knows that —
+     * it flattens its own `style` and reads `backgroundColor`, then takes the contrasting
+     * side the same way a tint does. Black ink at 10% on a saturated fill is close to
+     * invisible, which is the one thing a press indicator cannot be.
+     */
+    ink: string;
+    /**
+     * The root's own corners, so an overlay rounds itself to match. `corners` and not
+     * `radius`: the ripple already has a radius, and it is a length in points rather than a
+     * shape.
+     *
+     * An absolute fill has square corners and every control here is rounded, so without this
+     * both the wash and the wave paint outside the surface at each corner. The overlay
+     * carries the clip rather than the root: clipping the root would also cut a child that
+     * legitimately overflows — a badge on a button's corner — and that child has nothing to
+     * do with the press.
+     */
+    corners: RadiusStyle;
+    isPressed: boolean;
+    animation: ResolvedAnimation;
+    /** Absent on the static branch, where nothing animates and no worklet is mounted. */
+    progress?: SharedValue<number>;
+    /** How big the root is — what the scale coefficient is computed from. */
+    size?: SharedValue<{
+        width: number;
+        height: number;
+    }>;
+    /**
+     * The two ripple waves, driven by the **root**.
+     *
+     * They belong to the root because the root is the touch surface. An overlay carrying its
+     * own handlers only hears touches that land on *it* — and it is a sibling of the label,
+     * not its parent, so pressing the text of a button would do nothing. Touches bubble to
+     * the `Pressable`, which is why the handlers live there and the waves are published down.
+     */
+    waves?: readonly [RippleWave, RippleWave];
+};
+
+export type { AnimationConfig as A, FeedbackContext as F, PressableFeedbackProps as P, RadiusStyle as R, SlotAnimation as S, AnimationProp as a, ResolvedAnimation as b, RippleWave as c };

package/dist/style-props.type-CfnoGEP7.d.cts

@@ -0,0 +1,31 @@
+import { ViewStyle, TextStyle, ImageStyle } from 'react-native';
+
+/**
+ * R13 — React Native mirrors a layout under RTL through the Start/End properties and only
+ * those. A props API is exactly where someone writes `paddingLeft` without thinking, so
+ * the type removes the temptation instead of leaving it to a review.
+ */
+type DirectionalStyleKey = 'left' | 'right' | 'paddingLeft' | 'paddingRight' | 'marginLeft' | 'marginRight' | 'borderLeftWidth' | 'borderRightWidth' | 'borderLeftColor' | 'borderRightColor' | 'borderTopLeftRadius' | 'borderTopRightRadius' | 'borderBottomLeftRadius' | 'borderBottomRightRadius';
+/**
+ * `pointerEvents` is a style key *and* a `View` prop. R14 says the component's own prop
+ * wins, so it stays the prop it has always been and is not exposed twice — the one name
+ * where the two vocabularies collide.
+ */
+type ComponentOwnedStyleKey = 'pointerEvents';
+/**
+ * The style keys of a node, exposed as props (R14). Not a maintained list: it derives
+ * from the React Native type, minus what R13 forbids.
+ *
+ * ```ts
+ * type CardProps = ViewStyleProps & { variant?: CardVariant }
+ * ```
+ */
+type StyleProps<Style> = Omit<Style, DirectionalStyleKey | ComponentOwnedStyleKey>;
+/** A root, or any slot that renders a view. */
+type ViewStyleProps = StyleProps<ViewStyle>;
+/** A text slot — `color`, `fontSize`, `letterSpacing`… */
+type TextStyleProps = StyleProps<TextStyle>;
+/** An image slot — `resizeMode`, `tintColor`… */
+type ImageStyleProps = StyleProps<ImageStyle>;
+
+export type { DirectionalStyleKey as D, ImageStyleProps as I, StyleProps as S, TextStyleProps as T, ViewStyleProps as V };

package/dist/style-props.type-CfnoGEP7.d.ts

@@ -0,0 +1,31 @@
+import { ViewStyle, TextStyle, ImageStyle } from 'react-native';
+
+/**
+ * R13 — React Native mirrors a layout under RTL through the Start/End properties and only
+ * those. A props API is exactly where someone writes `paddingLeft` without thinking, so
+ * the type removes the temptation instead of leaving it to a review.
+ */
+type DirectionalStyleKey = 'left' | 'right' | 'paddingLeft' | 'paddingRight' | 'marginLeft' | 'marginRight' | 'borderLeftWidth' | 'borderRightWidth' | 'borderLeftColor' | 'borderRightColor' | 'borderTopLeftRadius' | 'borderTopRightRadius' | 'borderBottomLeftRadius' | 'borderBottomRightRadius';
+/**
+ * `pointerEvents` is a style key *and* a `View` prop. R14 says the component's own prop
+ * wins, so it stays the prop it has always been and is not exposed twice — the one name
+ * where the two vocabularies collide.
+ */
+type ComponentOwnedStyleKey = 'pointerEvents';
+/**
+ * The style keys of a node, exposed as props (R14). Not a maintained list: it derives
+ * from the React Native type, minus what R13 forbids.
+ *
+ * ```ts
+ * type CardProps = ViewStyleProps & { variant?: CardVariant }
+ * ```
+ */
+type StyleProps<Style> = Omit<Style, DirectionalStyleKey | ComponentOwnedStyleKey>;
+/** A root, or any slot that renders a view. */
+type ViewStyleProps = StyleProps<ViewStyle>;
+/** A text slot — `color`, `fontSize`, `letterSpacing`… */
+type TextStyleProps = StyleProps<TextStyle>;
+/** An image slot — `resizeMode`, `tintColor`… */
+type ImageStyleProps = StyleProps<ImageStyle>;
+
+export type { DirectionalStyleKey as D, ImageStyleProps as I, StyleProps as S, TextStyleProps as T, ViewStyleProps as V };

package/dist/system/index.cjs

@@ -2,11 +2,14 @@
 
 
 
+var _chunkXQFAUDR2cjs = require('../chunk-XQFAUDR2.cjs');
 
 
+var _chunkF6CQ6CBIcjs = require('../chunk-F6CQ6CBI.cjs');
 
 
 
+var _chunkTGZZ3RZUcjs = require('../chunk-TGZZ3RZU.cjs');
 
 
 
@@ -16,8 +19,6 @@
 
 
 
-var _chunkV63JO65Fcjs = require('../chunk-V63JO65F.cjs');
-require('../chunk-3QBT3Q65.cjs');
 
 
 
@@ -30,10 +31,66 @@ require('../chunk-3QBT3Q65.cjs');
 
 
 
+var _chunkGPVNCJ3Zcjs = require('../chunk-GPVNCJ3Z.cjs');
+require('../chunk-7DPL3ZDS.cjs');
 
 
 
 
+var _chunkWR7YLDVVcjs = require('../chunk-WR7YLDVV.cjs');
+require('../chunk-EJQCQPET.cjs');
 
 
-exports.HIGHLIGHT_OPACITY = _chunkV63JO65Fcjs.HIGHLIGHT_OPACITY; exports.PRESS_DURATION = _chunkV63JO65Fcjs.PRESS_DURATION; exports.PRESS_SCALE = _chunkV63JO65Fcjs.PRESS_SCALE; exports.PressableFeedback = _chunkV63JO65Fcjs.PressableFeedback; exports.RELEASE_DURATION = _chunkV63JO65Fcjs.RELEASE_DURATION; exports.RIPPLE_COVERAGE = _chunkV63JO65Fcjs.RIPPLE_COVERAGE; exports.RIPPLE_DURATION = _chunkV63JO65Fcjs.RIPPLE_DURATION; exports.RIPPLE_OPACITY = _chunkV63JO65Fcjs.RIPPLE_OPACITY; exports.Slot = _chunkV63JO65Fcjs.Slot; exports.childrenToString = _chunkV63JO65Fcjs.childrenToString; exports.createRecipe = _chunkV63JO65Fcjs.createRecipe; exports.createSlotContext = _chunkV63JO65Fcjs.createSlotContext; exports.mergeProps = _chunkV63JO65Fcjs.mergeProps; exports.mergeRefs = _chunkV63JO65Fcjs.mergeRefs; exports.resolveAnimation = _chunkV63JO65Fcjs.resolveAnimation; exports.resolveSlotAnimation = _chunkV63JO65Fcjs.resolveSlotAnimation; exports.useFeedback = _chunkV63JO65Fcjs.useFeedback;
+
+var _chunkFNEUOBCVcjs = require('../chunk-FNEUOBCV.cjs');
+require('../chunk-57SJ4LJF.cjs');
+
+
+
+
+
+var _chunkZP2E2H2Gcjs = require('../chunk-ZP2E2H2G.cjs');
+
+
+
+var _chunkGLGU2WFLcjs = require('../chunk-GLGU2WFL.cjs');
+require('../chunk-MC7SY2QH.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CloseButton = _chunkTGZZ3RZUcjs.CloseButton; exports.FEEDBACK_OVERLAY = _chunkGPVNCJ3Zcjs.FEEDBACK_OVERLAY; exports.HIGHLIGHT_DURATION = _chunkGPVNCJ3Zcjs.HIGHLIGHT_DURATION; exports.HIGHLIGHT_OPACITY = _chunkGPVNCJ3Zcjs.HIGHLIGHT_OPACITY; exports.Icon = _chunkWR7YLDVVcjs.Icon; exports.IconContext = _chunkWR7YLDVVcjs.IconContext; exports.PRESS_DURATION = _chunkGPVNCJ3Zcjs.PRESS_DURATION; exports.PRESS_SCALE = _chunkGPVNCJ3Zcjs.PRESS_SCALE; exports.Portal = _chunkXQFAUDR2cjs.Portal; exports.PortalContext = _chunkXQFAUDR2cjs.PortalContext; exports.PortalHost = _chunkXQFAUDR2cjs.PortalHost; exports.PressableFeedback = _chunkGPVNCJ3Zcjs.PressableFeedback; exports.RIPPLE_CONFIRM_DURATION = _chunkGPVNCJ3Zcjs.RIPPLE_CONFIRM_DURATION; exports.RIPPLE_EXPAND_DURATION = _chunkGPVNCJ3Zcjs.RIPPLE_EXPAND_DURATION; exports.RIPPLE_FADE_IN = _chunkGPVNCJ3Zcjs.RIPPLE_FADE_IN; exports.RIPPLE_FADE_OUT = _chunkGPVNCJ3Zcjs.RIPPLE_FADE_OUT; exports.RIPPLE_FADE_OUT_DELAY = _chunkGPVNCJ3Zcjs.RIPPLE_FADE_OUT_DELAY; exports.RIPPLE_OPACITY = _chunkGPVNCJ3Zcjs.RIPPLE_OPACITY; exports.RIPPLE_START_SCALE = _chunkGPVNCJ3Zcjs.RIPPLE_START_SCALE; exports.SCALE_REFERENCE_WIDTH = _chunkGPVNCJ3Zcjs.SCALE_REFERENCE_WIDTH; exports.SelectionFill = _chunkF6CQ6CBIcjs.SelectionFill; exports.Slot = _chunkZP2E2H2Gcjs.Slot; exports.childrenToString = _chunkZP2E2H2Gcjs.childrenToString; exports.closeButtonBase = _chunkTGZZ3RZUcjs.closeButtonBase; exports.createRecipe = _chunkFNEUOBCVcjs.createRecipe; exports.createSlotContext = _chunkZP2E2H2Gcjs.createSlotContext; exports.markOverlay = _chunkGPVNCJ3Zcjs.markOverlay; exports.mergeProps = _chunkZP2E2H2Gcjs.mergeProps; exports.mergeRefs = _chunkGLGU2WFLcjs.mergeRefs; exports.pressScaleFor = _chunkGPVNCJ3Zcjs.pressScaleFor; exports.radiusAxis = _chunkFNEUOBCVcjs.radiusAxis; exports.resolveAnimation = _chunkGPVNCJ3Zcjs.resolveAnimation; exports.resolveSlotAnimation = _chunkGPVNCJ3Zcjs.resolveSlotAnimation; exports.rippleRadiusFor = _chunkGPVNCJ3Zcjs.rippleRadiusFor; exports.useFeedback = _chunkGPVNCJ3Zcjs.useFeedback; exports.useIconContext = _chunkWR7YLDVVcjs.useIconContext; exports.useStyleProps = _chunkGLGU2WFLcjs.useStyleProps;