@channel.io/bezier-react 1.5.0 → 1.6.0

package/dist/esm/node_modules/@radix-ui/react-presence/dist/index.module.mjs

@@ -0,0 +1,125 @@
+import { Children, cloneElement, useState, useRef, useEffect, useCallback, useReducer } from 'react';
+import { flushSync } from 'react-dom';
+import { useComposedRefs as $6ed0406888f73fc4$export$c7b2cbe3552a0d05 } from '../../react-compose-refs/dist/index.module.mjs';
+import { useLayoutEffect as $9f79659886946c16$export$e5c5a5f917a5871c } from '../../react-use-layout-effect/dist/index.module.mjs';
+
+function $fe963b355347cc68$export$3e6543de14f8614f(initialState, machine) {
+  return useReducer((state, event) => {
+    const nextState = machine[state][event];
+    return nextState !== null && nextState !== void 0 ? nextState : state;
+  }, initialState);
+}
+const $921a889cee6df7e8$export$99c2b779aa4e8b8b = props => {
+  const {
+    present: present,
+    children: children
+  } = props;
+  const presence = $921a889cee6df7e8$var$usePresence(present);
+  const child = typeof children === 'function' ? children({
+    present: presence.isPresent
+  }) : Children.only(children);
+  const ref = $6ed0406888f73fc4$export$c7b2cbe3552a0d05(presence.ref, child.ref);
+  const forceMount = typeof children === 'function';
+  return forceMount || presence.isPresent ? /*#__PURE__*/cloneElement(child, {
+    ref: ref
+  }) : null;
+};
+$921a889cee6df7e8$export$99c2b779aa4e8b8b.displayName = 'Presence';
+/* -------------------------------------------------------------------------------------------------
+ * usePresence
+ * -----------------------------------------------------------------------------------------------*/
+function $921a889cee6df7e8$var$usePresence(present) {
+  const [node1, setNode] = useState();
+  const stylesRef = useRef({});
+  const prevPresentRef = useRef(present);
+  const prevAnimationNameRef = useRef('none');
+  const initialState = present ? 'mounted' : 'unmounted';
+  const [state, send] = $fe963b355347cc68$export$3e6543de14f8614f(initialState, {
+    mounted: {
+      UNMOUNT: 'unmounted',
+      ANIMATION_OUT: 'unmountSuspended'
+    },
+    unmountSuspended: {
+      MOUNT: 'mounted',
+      ANIMATION_END: 'unmounted'
+    },
+    unmounted: {
+      MOUNT: 'mounted'
+    }
+  });
+  useEffect(() => {
+    const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);
+    prevAnimationNameRef.current = state === 'mounted' ? currentAnimationName : 'none';
+  }, [state]);
+  $9f79659886946c16$export$e5c5a5f917a5871c(() => {
+    const styles = stylesRef.current;
+    const wasPresent = prevPresentRef.current;
+    const hasPresentChanged = wasPresent !== present;
+    if (hasPresentChanged) {
+      const prevAnimationName = prevAnimationNameRef.current;
+      const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(styles);
+      if (present) send('MOUNT');else if (currentAnimationName === 'none' || (styles === null || styles === void 0 ? void 0 : styles.display) === 'none')
+        // If there is no exit animation or the element is hidden, animations won't run
+        // so we unmount instantly
+        send('UNMOUNT');else {
+        /**
+        * When `present` changes to `false`, we check changes to animation-name to
+        * determine whether an animation has started. We chose this approach (reading
+        * computed styles) because there is no `animationrun` event and `animationstart`
+        * fires after `animation-delay` has expired which would be too late.
+        */
+        const isAnimating = prevAnimationName !== currentAnimationName;
+        if (wasPresent && isAnimating) send('ANIMATION_OUT');else send('UNMOUNT');
+      }
+      prevPresentRef.current = present;
+    }
+  }, [present, send]);
+  $9f79659886946c16$export$e5c5a5f917a5871c(() => {
+    if (node1) {
+      /**
+      * Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`
+      * event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we
+      * make sure we only trigger ANIMATION_END for the currently active animation.
+      */
+      const handleAnimationEnd = event => {
+        const currentAnimationName = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);
+        const isCurrentAnimation = currentAnimationName.includes(event.animationName);
+        if (event.target === node1 && isCurrentAnimation)
+          // With React 18 concurrency this update is applied
+          // a frame after the animation ends, creating a flash of visible content.
+          // By manually flushing we ensure they sync within a frame, removing the flash.
+          flushSync(() => send('ANIMATION_END'));
+      };
+      const handleAnimationStart = event => {
+        if (event.target === node1)
+          // if animation occurred, store its name as the previous animation.
+          prevAnimationNameRef.current = $921a889cee6df7e8$var$getAnimationName(stylesRef.current);
+      };
+      node1.addEventListener('animationstart', handleAnimationStart);
+      node1.addEventListener('animationcancel', handleAnimationEnd);
+      node1.addEventListener('animationend', handleAnimationEnd);
+      return () => {
+        node1.removeEventListener('animationstart', handleAnimationStart);
+        node1.removeEventListener('animationcancel', handleAnimationEnd);
+        node1.removeEventListener('animationend', handleAnimationEnd);
+      };
+    } else
+      // Transition to the unmounted state if the node is removed prematurely.
+      // We avoid doing so during cleanup as the node may change but still exist.
+      send('ANIMATION_END');
+  }, [node1, send]);
+  return {
+    isPresent: ['mounted', 'unmountSuspended'].includes(state),
+    ref: useCallback(node => {
+      if (node) stylesRef.current = getComputedStyle(node);
+      setNode(node);
+    }, [])
+  };
+}
+/* -----------------------------------------------------------------------------------------------*/
+function $921a889cee6df7e8$var$getAnimationName(styles) {
+  return (styles === null || styles === void 0 ? void 0 : styles.animationName) || 'none';
+}
+
+export { $921a889cee6df7e8$export$99c2b779aa4e8b8b as Presence };
+//# sourceMappingURL=index.module.mjs.map

package/dist/esm/node_modules/@radix-ui/react-presence/dist/index.module.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.module.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/node_modules/@radix-ui/react-primitive/dist/index.module.mjs

@@ -0,0 +1,75 @@
+import $67UHm$babelruntimehelpersesmextends from '@babel/runtime/helpers/esm/extends';
+import { forwardRef, useEffect, createElement } from 'react';
+import { flushSync } from 'react-dom';
+import { Slot as $5e63c961fc1ce211$export$8c6ed5c666ac1360 } from '../../react-slot/dist/index.module.mjs';
+
+const $8927f6f2acc4f386$var$NODES = ['a', 'button', 'div', 'form', 'h2', 'h3', 'img', 'input', 'label', 'li', 'nav', 'ol', 'p', 'span', 'svg', 'ul']; // Temporary while we await merge of this fix:
+// https://github.com/DefinitelyTyped/DefinitelyTyped/pull/55396
+// prettier-ignore
+/* -------------------------------------------------------------------------------------------------
+ * Primitive
+ * -----------------------------------------------------------------------------------------------*/
+const $8927f6f2acc4f386$export$250ffa63cdc0d034 = $8927f6f2acc4f386$var$NODES.reduce((primitive, node) => {
+  const Node = /*#__PURE__*/forwardRef((props, forwardedRef) => {
+    const {
+      asChild: asChild,
+      ...primitiveProps
+    } = props;
+    const Comp = asChild ? $5e63c961fc1ce211$export$8c6ed5c666ac1360 : node;
+    useEffect(() => {
+      window[Symbol.for('radix-ui')] = true;
+    }, []);
+    return /*#__PURE__*/createElement(Comp, $67UHm$babelruntimehelpersesmextends({}, primitiveProps, {
+      ref: forwardedRef
+    }));
+  });
+  Node.displayName = `Primitive.${node}`;
+  return {
+    ...primitive,
+    [node]: Node
+  };
+}, {});
+/* -------------------------------------------------------------------------------------------------
+ * Utils
+ * -----------------------------------------------------------------------------------------------*/ /**
+                                                                                                     * Flush custom event dispatch
+                                                                                                     * https://github.com/radix-ui/primitives/pull/1378
+                                                                                                     *
+                                                                                                     * React batches *all* event handlers since version 18, this introduces certain considerations when using custom event types.
+                                                                                                     *
+                                                                                                     * Internally, React prioritises events in the following order:
+                                                                                                     *  - discrete
+                                                                                                     *  - continuous
+                                                                                                     *  - default
+                                                                                                     *
+                                                                                                     * https://github.com/facebook/react/blob/a8a4742f1c54493df00da648a3f9d26e3db9c8b5/packages/react-dom/src/events/ReactDOMEventListener.js#L294-L350
+                                                                                                     *
+                                                                                                     * `discrete` is an  important distinction as updates within these events are applied immediately.
+                                                                                                     * React however, is not able to infer the priority of custom event types due to how they are detected internally.
+                                                                                                     * Because of this, it's possible for updates from custom events to be unexpectedly batched when
+                                                                                                     * dispatched by another `discrete` event.
+                                                                                                     *
+                                                                                                     * In order to ensure that updates from custom events are applied predictably, we need to manually flush the batch.
+                                                                                                     * This utility should be used when dispatching a custom event from within another `discrete` event, this utility
+                                                                                                     * is not nessesary when dispatching known event types, or if dispatching a custom type inside a non-discrete event.
+                                                                                                     * For example:
+                                                                                                     *
+                                                                                                     * dispatching a known click 👎
+                                                                                                     * target.dispatchEvent(new Event(‘click’))
+                                                                                                     *
+                                                                                                     * dispatching a custom type within a non-discrete event 👎
+                                                                                                     * onScroll={(event) => event.target.dispatchEvent(new CustomEvent(‘customType’))}
+                                                                                                     *
+                                                                                                     * dispatching a custom type within a `discrete` event 👍
+                                                                                                     * onPointerDown={(event) => dispatchDiscreteCustomEvent(event.target, new CustomEvent(‘customType’))}
+                                                                                                     *
+                                                                                                     * Note: though React classifies `focus`, `focusin` and `focusout` events as `discrete`, it's  not recommended to use
+                                                                                                     * this utility with them. This is because it's possible for those handlers to be called implicitly during render
+                                                                                                     * e.g. when focus is within a component as it is unmounted, or when managing focus on mount.
+                                                                                                     */
+function $8927f6f2acc4f386$export$6d1a0317bde7de7f(target, event) {
+  if (target) flushSync(() => target.dispatchEvent(event));
+}
+
+export { $8927f6f2acc4f386$export$250ffa63cdc0d034 as Primitive, $8927f6f2acc4f386$export$6d1a0317bde7de7f as dispatchDiscreteCustomEvent };
+//# sourceMappingURL=index.module.mjs.map

package/dist/esm/node_modules/@radix-ui/react-primitive/dist/index.module.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.module.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/node_modules/@radix-ui/react-radio-group/dist/index.module.mjs

@@ -0,0 +1,233 @@
+import $67UHm$babelruntimehelpersesmextends from '@babel/runtime/helpers/esm/extends';
+import { forwardRef, createElement, useRef, useEffect, useState } from 'react';
+import { composeEventHandlers as $e42e1063c40fb3ef$export$b9ecd428b558ff10 } from '../../primitive/dist/index.module.mjs';
+import { useComposedRefs as $6ed0406888f73fc4$export$c7b2cbe3552a0d05 } from '../../react-compose-refs/dist/index.module.mjs';
+import { createContextScope as $c512c27ab02ef895$export$50c7b4e9d9f19c1 } from '../../react-context/dist/index.module.mjs';
+import { Primitive as $8927f6f2acc4f386$export$250ffa63cdc0d034 } from '../../react-primitive/dist/index.module.mjs';
+import { createRovingFocusGroupScope as $d7bdfb9eb0fdf311$export$c7109489551a4f4, Root as $d7bdfb9eb0fdf311$export$be92b6f5f03c0fe9, Item as $d7bdfb9eb0fdf311$export$6d08773d2e66f8f2 } from '../../react-roving-focus/dist/index.module.mjs';
+import { useControllableState as $71cd76cc60e0454e$export$6f32135080cb4c3 } from '../../react-use-controllable-state/dist/index.module.mjs';
+import { useDirection as $f631663db3294ace$export$b39126d51d94e6f3 } from '../../react-direction/dist/index.module.mjs';
+import { useSize as $db6c3485150b8e66$export$1ab7ae714698c4b8 } from '../../react-use-size/dist/index.module.mjs';
+import { usePrevious as $010c2913dbd2fe3d$export$5cae361ad82dce8b } from '../../react-use-previous/dist/index.module.mjs';
+
+/* -------------------------------------------------------------------------------------------------
+ * Radio
+ * -----------------------------------------------------------------------------------------------*/
+const $ce77a8961b41be9e$var$RADIO_NAME = 'Radio';
+const [$ce77a8961b41be9e$var$createRadioContext, $ce77a8961b41be9e$export$67d2296460f1b002] = $c512c27ab02ef895$export$50c7b4e9d9f19c1($ce77a8961b41be9e$var$RADIO_NAME);
+const [$ce77a8961b41be9e$var$RadioProvider, $ce77a8961b41be9e$var$useRadioContext] = $ce77a8961b41be9e$var$createRadioContext($ce77a8961b41be9e$var$RADIO_NAME);
+const $ce77a8961b41be9e$export$d7b12c4107be0d61 = /*#__PURE__*/forwardRef((props, forwardedRef) => {
+  const {
+    __scopeRadio: __scopeRadio,
+    name: name,
+    checked = false,
+    required: required,
+    disabled: disabled,
+    value = 'on',
+    onCheck: onCheck,
+    ...radioProps
+  } = props;
+  const [button, setButton] = useState(null);
+  const composedRefs = $6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, node => setButton(node));
+  const hasConsumerStoppedPropagationRef = useRef(false); // We set this to true by default so that events bubble to forms without JS (SSR)
+  const isFormControl = button ? Boolean(button.closest('form')) : true;
+  return /*#__PURE__*/createElement($ce77a8961b41be9e$var$RadioProvider, {
+    scope: __scopeRadio,
+    checked: checked,
+    disabled: disabled
+  }, /*#__PURE__*/createElement($8927f6f2acc4f386$export$250ffa63cdc0d034.button, $67UHm$babelruntimehelpersesmextends({
+    type: "button",
+    role: "radio",
+    "aria-checked": checked,
+    "data-state": $ce77a8961b41be9e$var$getState(checked),
+    "data-disabled": disabled ? '' : undefined,
+    disabled: disabled,
+    value: value
+  }, radioProps, {
+    ref: composedRefs,
+    onClick: $e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onClick, event => {
+      // radios cannot be unchecked so we only communicate a checked state
+      if (!checked) onCheck === null || onCheck === void 0 || onCheck();
+      if (isFormControl) {
+        hasConsumerStoppedPropagationRef.current = event.isPropagationStopped(); // if radio is in a form, stop propagation from the button so that we only propagate
+        // one click event (from the input). We propagate changes from an input so that native
+        // form validation works and form events reflect radio updates.
+        if (!hasConsumerStoppedPropagationRef.current) event.stopPropagation();
+      }
+    })
+  })), isFormControl && /*#__PURE__*/createElement($ce77a8961b41be9e$var$BubbleInput, {
+    control: button,
+    bubbles: !hasConsumerStoppedPropagationRef.current,
+    name: name,
+    value: value,
+    checked: checked,
+    required: required,
+    disabled: disabled // We transform because the input is absolutely positioned but we have
+    ,
+
+    style: {
+      transform: 'translateX(-100%)'
+    }
+  }));
+});
+/* ---------------------------------------------------------------------------------------------- */
+const $ce77a8961b41be9e$var$BubbleInput = props => {
+  const {
+    control: control,
+    checked: checked,
+    bubbles = true,
+    ...inputProps
+  } = props;
+  const ref = useRef(null);
+  const prevChecked = $010c2913dbd2fe3d$export$5cae361ad82dce8b(checked);
+  const controlSize = $db6c3485150b8e66$export$1ab7ae714698c4b8(control); // Bubble checked change to parents (e.g form change event)
+  useEffect(() => {
+    const input = ref.current;
+    const inputProto = window.HTMLInputElement.prototype;
+    const descriptor = Object.getOwnPropertyDescriptor(inputProto, 'checked');
+    const setChecked = descriptor.set;
+    if (prevChecked !== checked && setChecked) {
+      const event = new Event('click', {
+        bubbles: bubbles
+      });
+      setChecked.call(input, checked);
+      input.dispatchEvent(event);
+    }
+  }, [prevChecked, checked, bubbles]);
+  return /*#__PURE__*/createElement("input", $67UHm$babelruntimehelpersesmextends({
+    type: "radio",
+    "aria-hidden": true,
+    defaultChecked: checked
+  }, inputProps, {
+    tabIndex: -1,
+    ref: ref,
+    style: {
+      ...props.style,
+      ...controlSize,
+      position: 'absolute',
+      pointerEvents: 'none',
+      opacity: 0,
+      margin: 0
+    }
+  }));
+};
+function $ce77a8961b41be9e$var$getState(checked) {
+  return checked ? 'checked' : 'unchecked';
+}
+const $f99a8c78507165f7$var$ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];
+/* -------------------------------------------------------------------------------------------------
+ * RadioGroup
+ * -----------------------------------------------------------------------------------------------*/
+const $f99a8c78507165f7$var$RADIO_GROUP_NAME = 'RadioGroup';
+const [$f99a8c78507165f7$var$createRadioGroupContext, $f99a8c78507165f7$export$c547093f11b76da2] = $c512c27ab02ef895$export$50c7b4e9d9f19c1($f99a8c78507165f7$var$RADIO_GROUP_NAME, [$d7bdfb9eb0fdf311$export$c7109489551a4f4, $ce77a8961b41be9e$export$67d2296460f1b002]);
+const $f99a8c78507165f7$var$useRovingFocusGroupScope = $d7bdfb9eb0fdf311$export$c7109489551a4f4();
+const $f99a8c78507165f7$var$useRadioScope = $ce77a8961b41be9e$export$67d2296460f1b002();
+const [$f99a8c78507165f7$var$RadioGroupProvider, $f99a8c78507165f7$var$useRadioGroupContext] = $f99a8c78507165f7$var$createRadioGroupContext($f99a8c78507165f7$var$RADIO_GROUP_NAME);
+const $f99a8c78507165f7$export$a98f0dcb43a68a25 = /*#__PURE__*/forwardRef((props, forwardedRef) => {
+  const {
+    __scopeRadioGroup: __scopeRadioGroup,
+    name: name,
+    defaultValue: defaultValue,
+    value: valueProp,
+    required = false,
+    disabled = false,
+    orientation: orientation,
+    dir: dir,
+    loop = true,
+    onValueChange: onValueChange,
+    ...groupProps
+  } = props;
+  const rovingFocusGroupScope = $f99a8c78507165f7$var$useRovingFocusGroupScope(__scopeRadioGroup);
+  const direction = $f631663db3294ace$export$b39126d51d94e6f3(dir);
+  const [value, setValue] = $71cd76cc60e0454e$export$6f32135080cb4c3({
+    prop: valueProp,
+    defaultProp: defaultValue,
+    onChange: onValueChange
+  });
+  return /*#__PURE__*/createElement($f99a8c78507165f7$var$RadioGroupProvider, {
+    scope: __scopeRadioGroup,
+    name: name,
+    required: required,
+    disabled: disabled,
+    value: value,
+    onValueChange: setValue
+  }, /*#__PURE__*/createElement($d7bdfb9eb0fdf311$export$be92b6f5f03c0fe9, $67UHm$babelruntimehelpersesmextends({
+    asChild: true
+  }, rovingFocusGroupScope, {
+    orientation: orientation,
+    dir: direction,
+    loop: loop
+  }), /*#__PURE__*/createElement($8927f6f2acc4f386$export$250ffa63cdc0d034.div, $67UHm$babelruntimehelpersesmextends({
+    role: "radiogroup",
+    "aria-required": required,
+    "aria-orientation": orientation,
+    "data-disabled": disabled ? '' : undefined,
+    dir: direction
+  }, groupProps, {
+    ref: forwardedRef
+  }))));
+});
+/* -------------------------------------------------------------------------------------------------
+ * RadioGroupItem
+ * -----------------------------------------------------------------------------------------------*/
+const $f99a8c78507165f7$var$ITEM_NAME = 'RadioGroupItem';
+const $f99a8c78507165f7$export$9f866c100ef519e4 = /*#__PURE__*/forwardRef((props, forwardedRef) => {
+  const {
+    __scopeRadioGroup: __scopeRadioGroup,
+    disabled: disabled,
+    ...itemProps
+  } = props;
+  const context = $f99a8c78507165f7$var$useRadioGroupContext($f99a8c78507165f7$var$ITEM_NAME, __scopeRadioGroup);
+  const isDisabled = context.disabled || disabled;
+  const rovingFocusGroupScope = $f99a8c78507165f7$var$useRovingFocusGroupScope(__scopeRadioGroup);
+  const radioScope = $f99a8c78507165f7$var$useRadioScope(__scopeRadioGroup);
+  const ref = useRef(null);
+  const composedRefs = $6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, ref);
+  const checked = context.value === itemProps.value;
+  const isArrowKeyPressedRef = useRef(false);
+  useEffect(() => {
+    const handleKeyDown = event => {
+      if ($f99a8c78507165f7$var$ARROW_KEYS.includes(event.key)) isArrowKeyPressedRef.current = true;
+    };
+    const handleKeyUp = () => isArrowKeyPressedRef.current = false;
+    document.addEventListener('keydown', handleKeyDown);
+    document.addEventListener('keyup', handleKeyUp);
+    return () => {
+      document.removeEventListener('keydown', handleKeyDown);
+      document.removeEventListener('keyup', handleKeyUp);
+    };
+  }, []);
+  return /*#__PURE__*/createElement($d7bdfb9eb0fdf311$export$6d08773d2e66f8f2, $67UHm$babelruntimehelpersesmextends({
+    asChild: true
+  }, rovingFocusGroupScope, {
+    focusable: !isDisabled,
+    active: checked
+  }), /*#__PURE__*/createElement($ce77a8961b41be9e$export$d7b12c4107be0d61, $67UHm$babelruntimehelpersesmextends({
+    disabled: isDisabled,
+    required: context.required,
+    checked: checked
+  }, radioScope, itemProps, {
+    name: context.name,
+    ref: composedRefs,
+    onCheck: () => context.onValueChange(itemProps.value),
+    onKeyDown: $e42e1063c40fb3ef$export$b9ecd428b558ff10(event => {
+      // According to WAI ARIA, radio groups don't activate items on enter keypress
+      if (event.key === 'Enter') event.preventDefault();
+    }),
+    onFocus: $e42e1063c40fb3ef$export$b9ecd428b558ff10(itemProps.onFocus, () => {
+      var _ref$current;
+      /**
+      * Our `RovingFocusGroup` will focus the radio when navigating with arrow keys
+      * and we need to "check" it in that case. We click it to "check" it (instead
+      * of updating `context.value`) so that the radio change event fires.
+      */
+      if (isArrowKeyPressedRef.current) (_ref$current = ref.current) === null || _ref$current === void 0 || _ref$current.click();
+    })
+  })));
+});
+/* ---------------------------------------------------------------------------------------------- */
+const $f99a8c78507165f7$export$be92b6f5f03c0fe9 = $f99a8c78507165f7$export$a98f0dcb43a68a25;
+const $f99a8c78507165f7$export$6d08773d2e66f8f2 = $f99a8c78507165f7$export$9f866c100ef519e4;
+
+export { $f99a8c78507165f7$export$6d08773d2e66f8f2 as Item, $f99a8c78507165f7$export$a98f0dcb43a68a25 as RadioGroup, $f99a8c78507165f7$export$9f866c100ef519e4 as RadioGroupItem, $f99a8c78507165f7$export$be92b6f5f03c0fe9 as Root, $f99a8c78507165f7$export$c547093f11b76da2 as createRadioGroupScope };
+//# sourceMappingURL=index.module.mjs.map

package/dist/esm/node_modules/@radix-ui/react-radio-group/dist/index.module.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.module.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}