@ringcentral/spring-ui 1.12.0 → 1.13.0

package/Dialer.js

@@ -1,156 +1,287 @@
-import { createContext, useContext, cloneElement, useRef, useEffect, forwardRef, useCallback, useImperativeHandle, useLayoutEffect, useMemo } from 'react';
-import { useLongPress, useForkRef, useWindowContext, useId, useClasses, useEventCallback, useAudio, logInDev, useOnlyOneFocusable, useKeyboardMoveFocus, globalStateClasses, combineProps, getSelectionPosition, setSelectionPosition, useKeyDownOnce, useSleep } from '@ringcentral/spring-base';
-import { useThemeProps } from '@ringcentral/spring-theme';
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { c as composeEventHandlers } from './chunks/composeEventHandlers.js';
-import '@mui/utils';
-import { V as VisuallyHidden } from './chunks/VisuallyHidden.js';
-import { I as IconButton } from './chunks/IconButtonLabel.js';
-import { DialButton1Lg, DialButton1Sm, DialButton2Lg, DialButton2Sm, DialButton3Lg, DialButton3Sm, DialButton4Lg, DialButton4Sm, DialButton5Lg, DialButton5Sm, DialButton6Lg, DialButton6Sm, DialButton7Lg, DialButton7Sm, DialButton8Lg, DialButton8Sm, DialButton9Lg, DialButton9Sm, AsteriskMd, DialButton0Lg, DialButton0Sm, HashMd } from '@ringcentral/spring-icon';
-import { T as TextField } from './chunks/TextField.js';
-import '@mui/base';
-import './chunks/Icon.js';
-import './chunks/Squircle.js';
-import './chunks/withTooltip.js';
-import './chunks/Tooltip.js';
-import 'framer-motion';
-import 'clsx';
-import './chunks/usePrefersReducedMotion.js';
-import './chunks/getFade.js';
-import './Popper.js';
-import '@floating-ui/react-dom';
-import './chunks/Modal.js';
-import './chunks/useFocusTrapStack.js';
-import './chunks/Backdrop.js';
-import './chunks/PopperPaper.js';
-import './chunks/ShowHideEye.js';
-import './chunks/useMotionSafeTransition.js';
-import './chunks/useHelperTextId.js';
-import './chunks/hasContent.js';
+import { cloneElement, createContext, forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef } from "react";
+import { combineProps, getSelectionPosition, globalStateClasses, logInDev, setSelectionPosition, useAudio, useClasses, useEventCallback, useForkRef, useId, useKeyDownOnce, useKeyboardMoveFocus, useLongPress, useOnlyOneFocusable, useSleep, useWindowContext } from "@ringcentral/spring-base";
+import { useThemeProps } from "@ringcentral/spring-theme";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { AsteriskMd, DialButton0Lg, DialButton0Sm, DialButton1Lg, DialButton1Sm, DialButton2Lg, DialButton2Sm, DialButton3Lg, DialButton3Sm, DialButton4Lg, DialButton4Sm, DialButton5Lg, DialButton5Sm, DialButton6Lg, DialButton6Sm, DialButton7Lg, DialButton7Sm, DialButton8Lg, DialButton8Sm, DialButton9Lg, DialButton9Sm, HashMd } from "@ringcentral/spring-icon";
+import { IconButton as IconButton_IconButton } from "./IconButton.js";
+import { VisuallyHidden as VisuallyHidden_VisuallyHidden } from "./VisuallyHidden.js";
+import { composeEventHandlers } from "./chunks/4491.js";
+import { TextField as TextField_TextField } from "./TextField.js";
+
+
+
+
+
 
 const DialerContext = createContext({});
-const useDialerContext = () => useContext(DialerContext);
+const useDialerContext = ()=>useContext(DialerContext);
+
+
+
+
+
+
+
 
 const holdTime = 1000;
-const DialDelete = (inProps) => {
-    const props = useThemeProps({ props: inProps, name: 'DialDelete' });
+const DialDelete = (inProps)=>{
+    const props = useThemeProps({
+        props: inProps,
+        name: 'DialDelete'
+    });
     const { onDelete, onClear, children } = props;
     const { onClearRef, onDeleteRef } = useDialerContext();
-    const handleClear = (e, reason) => {
+    const handleClear = (e, reason)=>{
         onClear?.(e, reason);
         onClearRef?.current?.(e, reason);
     };
-    const handleDelete = (e, reason) => {
+    const handleDelete = (e, reason)=>{
         onDelete?.(e, reason);
         onDeleteRef?.current?.(e, reason);
     };
-    const { ref, ...events } = useLongPress({ onTap: handleDelete, onPress: handleClear }, children.props, { delay: holdTime, externalWindow: props.externalWindow });
+    const { ref, ...events } = useLongPress({
+        onTap: handleDelete,
+        onPress: handleClear
+    }, children.props, {
+        delay: holdTime,
+        externalWindow: props.externalWindow
+    });
+    // React 17/18: JSX `ref` lives on the element (`children.ref`), not `children.props.ref`.
+    // React 19+: `element.ref` is deprecated — switch to `children.props.ref` (or
+    // `@mui/utils` `getReactElementRef`, which picks the right source by React.version).
     const forkEleRef = useForkRef(children.ref, ref);
-    return cloneElement(children, {
+    return /*#__PURE__*/ cloneElement(children, {
         ref: forkEleRef,
-        ...events,
+        ...events
     });
 };
 DialDelete.displayName = 'SuiDialDelete';
 
-var DialPadButton$1 = {"sui-dial-pad-button-root":"sui-dial-pad-button-root","sui-icon":"sui-icon","sui-dial-pad-button-medium":"sui-dial-pad-button-medium","sui-dial-pad-button-large":"sui-dial-pad-button-large","sui-dial-pad-button-label-container":"sui-dial-pad-button-label-container"};
 
-const emptyFunction = () => {
+
+
+
+
+
+
+
+
+// extracted by css-extract-rspack-plugin
+/* export default */ var DialPadButton = ({"sui-dial-pad-button-root":"sui-dial-pad-button-root","sui-icon":"sui-icon","sui-dial-pad-button-medium":"sui-dial-pad-button-medium","sui-dial-pad-button-large":"sui-dial-pad-button-large","sui-dial-pad-button-label-container":"sui-dial-pad-button-label-container"});
+
+
+
+
+const emptyFunction = ()=>{
+//
 };
-const DialPadButton = (props) => {
+const DialPadButton_DialPadButton = (props)=>{
     const { value, classes, longPressValue, longPressDelay = 1000, onKeyEffect = emptyFunction, className, iconSize = 'medium', size = 'xxlarge', label, ...rest } = props;
     const { externalWindow } = useWindowContext();
     const labelId = useId();
     const isPressEvent = typeof longPressDelay === 'number' && typeof longPressValue === 'string';
     const { ref, ...events } = useLongPress({
-        onTap: (e, reason) => {
+        onTap: (e, reason)=>{
             onKeyEffect(value, reason);
         },
-        onPress: isPressEvent
-            ? (e, reason) => {
-                onKeyEffect(longPressValue, reason);
-            }
-            : undefined,
-    }, rest, { delay: longPressDelay, externalWindow });
+        onPress: isPressEvent ? (e, reason)=>{
+            onKeyEffect(longPressValue, reason);
+        } : undefined
+    }, rest, {
+        delay: longPressDelay,
+        externalWindow
+    });
     const cls = useClasses('dial-pad-button', classes, className);
-    const button = (jsx(IconButton, { ref: ref, color: "secondary", variant: "outlined", "aria-labelledby": label ? labelId : undefined, className: cls('root', iconSize), ...rest, ...events, size: size }));
-    return label ? (jsxs("div", { id: labelId, className: cls('label-container'), children: [button, jsx("span", { children: label })] })) : (button);
+    const button = /*#__PURE__*/ jsx(IconButton_IconButton, {
+        ref: ref,
+        color: "secondary",
+        variant: "outlined",
+        "aria-labelledby": label ? labelId : undefined,
+        className: cls('root', iconSize),
+        ...rest,
+        ...events,
+        size: size
+    });
+    return label ? /*#__PURE__*/ jsxs("div", {
+        id: labelId,
+        className: cls('label-container'),
+        children: [
+            button,
+            /*#__PURE__*/ jsx("span", {
+                children: label
+            })
+        ]
+    }) : button;
 };
-DialPadButton.displayName = 'SuiDialPadButton';
+DialPadButton_DialPadButton.displayName = 'SuiDialPadButton';
+
+
+
+
+
+// extracted by css-extract-rspack-plugin
+/* export default */ var DialPad = ({"sui-dial-pad-root":"sui-dial-pad-root","sui-dial-pad-auto-size":"sui-dial-pad-auto-size","sui-dial-pad-button":"sui-dial-pad-button"});
 
-var DialPad$1 = {"sui-dial-pad-root":"sui-dial-pad-root","sui-dial-pad-auto-size":"sui-dial-pad-auto-size","sui-dial-pad-button":"sui-dial-pad-button"};
 
 const DIALER_PAD_ICONS = [
-    [DialButton1Lg, DialButton1Sm, '1'],
-    [DialButton2Lg, DialButton2Sm, '2', 'A B C'],
-    [DialButton3Lg, DialButton3Sm, '3', 'D E F'],
-    [DialButton4Lg, DialButton4Sm, '4', 'G H I'],
-    [DialButton5Lg, DialButton5Sm, '5', 'J K L'],
-    [DialButton6Lg, DialButton6Sm, '6', 'M N O'],
-    [DialButton7Lg, DialButton7Sm, '7', 'P Q R S'],
-    [DialButton8Lg, DialButton8Sm, '8', 'T U V'],
-    [DialButton9Lg, DialButton9Sm, '9', 'W X Y Z'],
-    [AsteriskMd, AsteriskMd, '*'],
-    [DialButton0Lg, DialButton0Sm, '0', '+'],
-    [HashMd, HashMd, '#'],
+    [
+        DialButton1Lg,
+        DialButton1Sm,
+        '1'
+    ],
+    [
+        DialButton2Lg,
+        DialButton2Sm,
+        '2',
+        'A B C'
+    ],
+    [
+        DialButton3Lg,
+        DialButton3Sm,
+        '3',
+        'D E F'
+    ],
+    [
+        DialButton4Lg,
+        DialButton4Sm,
+        '4',
+        'G H I'
+    ],
+    [
+        DialButton5Lg,
+        DialButton5Sm,
+        '5',
+        'J K L'
+    ],
+    [
+        DialButton6Lg,
+        DialButton6Sm,
+        '6',
+        'M N O'
+    ],
+    [
+        DialButton7Lg,
+        DialButton7Sm,
+        '7',
+        'P Q R S'
+    ],
+    [
+        DialButton8Lg,
+        DialButton8Sm,
+        '8',
+        'T U V'
+    ],
+    [
+        DialButton9Lg,
+        DialButton9Sm,
+        '9',
+        'W X Y Z'
+    ],
+    [
+        AsteriskMd,
+        AsteriskMd,
+        '*'
+    ],
+    [
+        DialButton0Lg,
+        DialButton0Sm,
+        '0',
+        '+'
+    ],
+    [
+        HashMd,
+        HashMd,
+        '#'
+    ]
 ];
 const DIALER_PAD_PLUS = '+';
 const ACCEPTABLE_KEYS = [
-    ...DIALER_PAD_ICONS.map(([, , value]) => value),
-    DIALER_PAD_PLUS,
+    ...DIALER_PAD_ICONS.map(([, , value])=>value),
+    DIALER_PAD_PLUS
 ];
 
-const useDialKeyboard = ({ onKeyDown: onKeyDownArg, onKeyUp: onKeyUpArg, } = {}) => {
+
+
+
+
+
+/**
+ * Provide you can get event apply on trigger events area
+ * @param options onKeyDown, onKeyUp that you also want apply on target
+ * @returns  onKeyDown, onKeyUp, control
+ */ const useDialKeyboard = ({ onKeyDown: onKeyDownArg, onKeyUp: onKeyUpArg } = {})=>{
     const control = useRef(null);
+    // we need `onKeyup` & `onKeydown` to get called in same amount, but also make sure of the performance.
     const keyBufferRef = useRef([]);
-    const onKeyDown = useEventCallback((e) => {
+    const onKeyDown = useEventCallback((e)=>{
         onKeyDownArg?.(e);
         const key = e.key;
-        if (!ACCEPTABLE_KEYS.includes(key))
-            return;
+        if (!ACCEPTABLE_KEYS.includes(key)) return;
         e.preventDefault();
         e.stopPropagation();
         const buffer = keyBufferRef.current;
         if (!buffer.includes(key)) {
-            keyBufferRef.current = [...buffer, key];
+            keyBufferRef.current = [
+                ...buffer,
+                key
+            ];
             control.current?.handleKeyboardEffect(key, false);
         }
     });
-    const onKeyUp = useEventCallback((e) => {
+    const onKeyUp = useEventCallback((e)=>{
         onKeyUpArg?.(e);
         const key = e.key;
-        if (!ACCEPTABLE_KEYS.includes(key))
-            return;
+        if (!ACCEPTABLE_KEYS.includes(key)) return;
         e.preventDefault();
         e.stopPropagation();
-        keyBufferRef.current = keyBufferRef.current.filter((bufferedKey) => bufferedKey !== key);
+        keyBufferRef.current = keyBufferRef.current.filter((bufferedKey)=>bufferedKey !== key);
         control.current?.handleKeyboardEffect(key, true);
     });
-    return { onKeyDown, onKeyUp, control };
+    return {
+        onKeyDown,
+        onKeyUp,
+        control
+    };
 };
 
-const useKeyAudio = ({ sounds, processor }) => {
+
+
+
+
+
+/**
+ * Custom hook that handles playing audio for key presses in a dial pad.
+ *
+ * @param audioOption - The audio options for configuring the hook.
+ * @returns A function that plays the audio for a given key.
+ */ const useKeyAudio = ({ sounds, processor })=>{
     const audio = useAudio();
     const lastPlayRef = useRef();
-    useEffect(() => {
+    useEffect(()=>{
         processor?.(audio);
-    }, [audio, processor]);
-    const play = async (src) => {
+    }, [
+        audio,
+        processor
+    ]);
+    const play = async (src)=>{
         const lastPlay = lastPlayRef.current;
-        if (lastPlay)
-            await lastPlay;
+        /* https://developers.google.com/web/updates/2017/06/play-request-was-interrupted
+     * prevent play request interrupted
+     */ if (lastPlay) await lastPlay;
         audio.currentTime = 0;
         audio.src = src;
-        lastPlayRef.current = audio.play().catch((reason) => {
+        lastPlayRef.current = audio.play().catch((reason)=>{
             if (process.env.NODE_ENV !== 'production') {
-                logInDev({ scope: 'DialerPad', message: reason });
+                logInDev({
+                    scope: 'DialerPad',
+                    message: reason
+                });
             }
         });
     };
-    return (key) => {
-        if (!sounds)
-            return false;
-        const playTarget = (key === DIALER_PAD_PLUS ? '0' : key);
+    return (key)=>{
+        if (!sounds) return false;
+        const playTarget = key === (/* inlined export .DIALER_PAD_PLUS */"+") ? '0' : key;
         const sound = sounds[playTarget];
         if (sound) {
             return play(sound);
@@ -159,10 +290,75 @@ const useKeyAudio = ({ sounds, processor }) => {
     };
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 const MOVE_FOCUSED_ATTR_KEY = 'data-move-focused';
 const DIAL_BUTTON_ATTR_KEY = 'data-dial-button';
-const DialPad = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'DialPad' });
+/**
+ * DialPad component for entering phone numbers with keypad buttons.
+ *
+ * **Usage**: DialPad is typically used within a Dialer component along with DialTextField for a complete dialing experience.
+ *
+ * @example
+ * ```tsx
+ * import { Dialer, DialPad, DialTextField, DialDelete, IconButton, DialerPadSoundsMPEG } from '@ringcentral/spring-ui';
+ * import { BackspaceMd } from '@ringcentral/spring-icon';
+ *
+ * function MyDialer() {
+ *   const [value, setValue] = useState('');
+ *
+ *   return (
+ *     <Dialer>
+ *       <div className="inline-flex flex-col w-[240px]">
+ *         <div className="pl-4 pr-2 pt-2">
+ *           <DialTextField
+ *             value={value}
+ *             fullWidth
+ *             onChange={setValue}
+ *             placeholder="Enter a number"
+ *             endAdornment={
+ *               value.length > 0 && (
+ *                 <DialDelete>
+ *                   <IconButton
+ *                     symbol={BackspaceMd}
+ *                     title="delete"
+ *                     size="large"
+ *                     color="secondary"
+ *                   />
+ *                 </DialDelete>
+ *               )
+ *             }
+ *           />
+ *         </div>
+ *         <div className="flex items-center justify-center p-2">
+ *           <DialPad
+ *             sounds={DialerPadSoundsMPEG}
+ *             size="large"
+ *           />
+ *         </div>
+ *       </div>
+ *     </Dialer>
+ *   );
+ * }
+ * ```
+ */ const DialPad_DialPad = /*#__PURE__*/ forwardRef((inProps, ref)=>{
+    const props = useThemeProps({
+        props: inProps,
+        name: 'DialPad'
+    });
     const { size = 'large', sounds, autoSize, classes, onChange: onChangeProp, action, control, getDialPadButtonProps, sinkId, persistBgTime = 200, volume = 1, muted = false, longPressDelay = 1000, className, ...divProps } = props;
     const { externalWindow, globalThis: contextGlobal } = useWindowContext();
     const contextWindow = externalWindow ?? contextGlobal;
@@ -175,103 +371,138 @@ const DialPad = forwardRef((inProps, ref) => {
     const focusedIndexRef = useRef(0);
     const { focusIndex, getItemProps, moveFocusedId } = useOnlyOneFocusable({
         focusedIndexRef,
-        containerRef,
+        containerRef
     });
     const { onKeyFocusedIndexHandle } = useKeyboardMoveFocus({
         options: DIALER_PAD_ICONS,
         focusedIndexRef,
         infinite: true,
         columns: 3,
-        onFocusedIndexChange: (event, toIndex) => {
+        onFocusedIndexChange: (event, toIndex)=>{
             focusedIndexRef.current = toIndex;
             focusIndex(toIndex);
             event.preventDefault();
-        },
+        }
     });
-    const audioProcessor = useCallback((audio) => {
+    const audioProcessor = useCallback((audio)=>{
         const audioWithSinkId = audio;
-        if (typeof volume !== 'undefined')
-            audio.volume = volume;
-        if (typeof muted !== 'undefined')
-            audio.muted = muted;
-        if (typeof audioWithSinkId.setSinkId === 'function')
-            void audioWithSinkId.setSinkId(sinkId || '');
-    }, [muted, sinkId, volume]);
+        if (typeof volume !== 'undefined') audio.volume = volume;
+        if (typeof muted !== 'undefined') audio.muted = muted;
+        if (typeof audioWithSinkId.setSinkId === 'function') void audioWithSinkId.setSinkId(// when pass undefined, use '' to remove sinkId to default
+        sinkId || '');
+    }, [
+        muted,
+        sinkId,
+        volume
+    ]);
     const play = useKeyAudio({
         sounds,
-        processor: audioProcessor,
+        processor: audioProcessor
     });
-    const playAudio = useEventCallback((value) => {
-        const key = value === DIALER_PAD_PLUS ? '0' : value;
+    const playAudio = useEventCallback((value)=>{
+        const key = value === (/* inlined export .DIALER_PAD_PLUS */"+") ? '0' : value;
         const keyButtonElm = containerRef.current?.querySelector(`[${MOVE_FOCUSED_ATTR_KEY}="${moveFocusedId}"][${DIAL_BUTTON_ATTR_KEY}="${key}"]`);
         if (keyButtonElm) {
+            // * to keep color when quick trigger insert key or click very quick
             const oldTimer = keyTimerMapRef.current[key];
-            if (oldTimer)
-                contextWindow.clearTimeout(oldTimer);
+            if (oldTimer) contextWindow.clearTimeout(oldTimer);
             keyButtonElm.classList.add(globalStateClasses.active);
-            keyTimerMapRef.current[key] = contextWindow.setTimeout(() => {
+            keyTimerMapRef.current[key] = contextWindow.setTimeout(()=>{
                 keyButtonElm.classList.remove(globalStateClasses.active);
                 delete keyTimerMapRef.current[key];
             }, persistBgTime);
         }
         return play(value);
     });
-    const handleChange = (value, reason) => {
+    const handleChange = (value, reason)=>{
         playAudio(value);
         onInsertRef?.current?.(value, reason);
         onChangeProp?.(value, reason);
     };
-    const handleKeyboardEffect = useEventCallback((value, isKeyup) => {
+    const handleKeyboardEffect = useEventCallback((value, isKeyup)=>{
         if (isKeyup) {
             handleChange(value, 'customKeyboard');
-            const toIndex = ACCEPTABLE_KEYS.findIndex((x) => x === value);
+            const toIndex = ACCEPTABLE_KEYS.findIndex((x)=>x === value);
             focusedIndexRef.current = toIndex;
+            // * mean that current focus on that dialPad, move focus to dialPad container
             const activeElement = externalWindow?.document.activeElement;
-            if (activeElement?.getAttribute(MOVE_FOCUSED_ATTR_KEY) ===
-                moveFocusedId &&
-                activeElement.getAttribute(DIAL_BUTTON_ATTR_KEY) !== null) {
+            if (activeElement?.getAttribute(MOVE_FOCUSED_ATTR_KEY) === moveFocusedId && activeElement.getAttribute(DIAL_BUTTON_ATTR_KEY) !== null) {
                 hiddenRef.current?.focus();
             }
         }
     });
-    const handleKeyEffect = useEventCallback((value, reason) => {
+    const handleKeyEffect = useEventCallback((value, reason)=>{
         handleChange(value, reason);
     });
     const forkActionRef = useForkRef(dialPadActionRef, action);
-    useImperativeHandle(forkActionRef, () => ({ playAudio }), [playAudio]);
-    useImperativeHandle(control, () => ({ handleKeyboardEffect }), [
-        handleKeyboardEffect,
+    useImperativeHandle(forkActionRef, ()=>({
+            playAudio
+        }), [
+        playAudio
     ]);
-    useEffect(() => () => {
-        for (const timer of Object.values(keyTimerMapRef.current)) {
-            contextWindow.clearTimeout(timer);
-        }
-    }, [contextWindow]);
-    return (jsxs("div", { ref: forkRef, className: cls('root', { 'auto-size': autoSize }), ...divProps, children: [jsx(VisuallyHidden, { ref: hiddenRef, tabIndex: -1 }), DIALER_PAD_ICONS.map(([lgIcon, smIcon, key, additionLabel], index) => {
-                const ariaLabelArr = additionLabel
-                    ? [key, additionLabel]
-                    : [key];
-                const iconSize = isNaN(parseInt(key))
-                    ? 'medium'
-                    : 'large';
+    useImperativeHandle(control, ()=>({
+            handleKeyboardEffect
+        }), [
+        handleKeyboardEffect
+    ]);
+    // * clean when unmount
+    useEffect(()=>()=>{
+            for (const timer of Object.values(keyTimerMapRef.current)){
+                contextWindow.clearTimeout(timer);
+            }
+        }, [
+        contextWindow
+    ]);
+    return /*#__PURE__*/ jsxs("div", {
+        ref: forkRef,
+        className: cls('root', {
+            'auto-size': autoSize
+        }),
+        ...divProps,
+        children: [
+            /*#__PURE__*/ jsx(VisuallyHidden_VisuallyHidden, {
+                ref: hiddenRef,
+                tabIndex: -1
+            }),
+            DIALER_PAD_ICONS.map(([lgIcon, smIcon, key, additionLabel], index)=>{
+                const ariaLabelArr = additionLabel ? [
+                    key,
+                    additionLabel
+                ] : [
+                    key
+                ];
+                const iconSize = isNaN(parseInt(key)) ? 'medium' : 'large';
                 const icon = size === 'large' ? lgIcon : smIcon;
                 const itemProps = getItemProps(index);
                 const { onKeyDown: customOnKeyDown, ...customButtonProps } = getDialPadButtonProps?.(key) ?? {};
-                return (jsx(DialPadButton, { classes: classes, symbol: icon, value: key, onKeyEffect: handleKeyEffect, ...combineProps(itemProps, {
+                return /*#__PURE__*/ jsx(DialPadButton_DialPadButton, {
+                    classes: classes,
+                    symbol: icon,
+                    value: key,
+                    onKeyEffect: handleKeyEffect,
+                    ...combineProps(itemProps, {
                         'aria-label': ariaLabelArr.join(', '),
                         ...customButtonProps,
-                        ...(key === '0'
-                            ? {
-                                longPressValue: DIALER_PAD_PLUS,
-                                longPressDelay,
-                            }
-                            : {}),
-                    }), [DIAL_BUTTON_ATTR_KEY]: key, onKeyDown: composeEventHandlers(customOnKeyDown, onKeyFocusedIndexHandle), tabIndex: itemProps.tabIndex, size: size === 'large' ? 'xxxlarge' : 'xxlarge', iconSize: iconSize }, key));
-            })] }));
+                        ...key === '0' ? {
+                            longPressValue: (/* inlined export .DIALER_PAD_PLUS */"+"),
+                            longPressDelay
+                        } : {}
+                    }),
+                    [DIAL_BUTTON_ATTR_KEY]: key,
+                    onKeyDown: composeEventHandlers(customOnKeyDown, onKeyFocusedIndexHandle),
+                    // Roving tabindex must win over getDialPadButtonProps.
+                    tabIndex: itemProps.tabIndex,
+                    size: size === 'large' ? 'xxxlarge' : 'xxlarge',
+                    iconSize: iconSize
+                }, key);
+            })
+        ]
+    });
 });
-DialPad.displayName = 'SuiDialPad';
+DialPad_DialPad.displayName = 'SuiDialPad';
 
-var DialerPadSoundsOGG = {
+
+/* export default */ var DialerPadSoundsOGG = ({
     '0': 'data:audio/ogg;base64,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',
     '1': 'data:audio/ogg;base64,T2dnUwACAAAAAAAAAAB0Nx8FAAAAALH2CDABHgF2b3JiaXMAAAAAAUSsAAAAAAAAMKkDAAAAAAC4AU9nZ1MAAAAAAAAAAAAAdDcfBQEAAADtBChfET3////////////////////VA3ZvcmJpcy0AAABYaXBoLk9yZyBsaWJWb3JiaXMgSSAyMDEwMTEwMSAoU2NoYXVmZW51Z2dldCkAAAAAAQV2b3JiaXMrQkNWAQAIAAAAMUwgxYDQkFUAABAAAGAkKQ6TZkkppZShKHmYlEhJKaWUxTCJmJSJxRhjjDHGGGOMMcYYY4wgNGQVAAAEAIAoCY6j5klqzjlnGCeOcqA5aU44pyAHilHgOQnC9SZjbqa0pmtuziklCA1ZBQAAAgBASCGFFFJIIYUUYoghhhhiiCGHHHLIIaeccgoqqKCCCjLIIINMMumkk0466aijjjrqKLTQQgsttNJKTDHVVmOuvQZdfHPOOeecc84555xzzglCQ1YBACAAAARCBhlkEEIIIYUUUogppphyCjLIgNCQVQAAIACAAAAAAEeRFEmxFMuxHM3RJE/yLFETNdEzRVNUTVVVVVV1XVd2Zdd2ddd2fVmYhVu4fVm4hVvYhV33hWEYhmEYhmEYhmH4fd/3fd/3fSA0ZBUAIAEAoCM5luMpoiIaouI5ogOEhqwCAGQAAAQAIAmSIimSo0mmZmquaZu2aKu2bcuyLMuyDISGrAIAAAEABAAAAAAAoGmapmmapmmapmmapmmapmmapmmaZlmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVlAaMgqAEACAEDHcRzHcSRFUiTHciwHCA1ZBQDIAAAIAEBSLMVyNEdzNMdzPMdzPEd0RMmUTM30TA8IDVkFAAACAAgAAAAAAEAxHMVxHMnRJE9SLdNyNVdzPddzTdd1XVdVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVgdCQVQAABAAAIZ1mlmqACDOQYSA0ZBUAgAAAABihCEMMCA1ZBQAABAAAiKHkIJrQmvPNOQ6a5aCpFJvTwYlUmye5qZibc84555xszhnjnHPOKcqZxaCZ0JpzzkkMmqWgmdCac855EpsHranSmnPOGeecDsYZYZxzzmnSmgep2Vibc85Z0JrmqLkUm3POiZSbJ7W5VJtzzjnnnHPOOeecc86pXpzOwTnhnHPOidqba7kJXZxzzvlknO7NCeGcc84555xzzjnnnHPOCUJDVgEAQAAABGHYGMadgiB9jgZiFCGmIZMedI8Ok6AxyCmkHo2ORkqpg1BSGSeldILQkFUAACAAAIQQUkghhRRSSCGFFFJIIYYYYoghp5xyCiqopJKKKsoos8wyyyyzzDLLrMPOOuuwwxBDDDG00kosNdVWY4215p5zrjlIa6W11lorpZRSSimlIDRkFQAAAgBAIGSQQQYZhRRSSCGGmHLKKaegggoIDVkFAAACAAgAAADwJM8RHdERHdERHdERHdERHc/xHFESJVESJdEyLVMzPVVUVVd2bVmXddu3hV3Ydd/Xfd/XjV8XhmVZlmVZlmVZlmVZlmVZlmUJQkNWAQAgAAAAQgghhBRSSCGFlGKMMcecg05CCYHQkFUAACAAgAAAAABHcRTHkRzJkSRLsiRN0izN8jRP8zTRE0VRNE1TFV3RFXXTFmVTNl3TNWXTVWXVdmXZtmVbt31Ztn3f933f933f933f933f13UgNGQVACABAKAjOZIiKZIiOY7jSJIEhIasAgBkAAAEAKAojuI4jiNJkiRZkiZ5lmeJmqmZnumpogqEhqwCAAABAAQAAAAAAKBoiqeYiqeIiueIjiiJlmmJmqq5omzKruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6QGjIKgBAAgBAR3IkR3IkRVIkRXIkBwgNWQUAyAAACADAMRxDUiTHsixN8zRP8zTREz3RMz1VdEUXCA1ZBQAAAgAIAAAAAADAkAxLsRzN0SRRUi3VUjXVUi1VVD1VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXVNE3TNIHQkJUAABkAAOjFCCGEEJKjlloQvlfKOSg1914xZhTE3nulmEGOcvCZYko5KLWnzjGliJFcWyuRIsRhDjpVTimoQefWSQgtB0JDVgQAUQAAAEKIMcQYYoxByCBEjDEIGYSIMQYhg9BBCCWFlDIIIZWQUsQYg9BBySCElEJJGZSQUkilAACAAAcAgAALodCQFQFAnAAAgpBziDEIFWMQOgipdBBSqhiDkDknJXMOSiglpRBKShVjEDLnJGTOSQklpBRKSamDkFIopaVQSmoppRhTSi12EFIKpaQUSmkptRRbSi3GijEImXNSMuekhFJaCqWkljknpYOQUgehlJJSa6Wk1jLnpHTQSekglFJSaamU1FooJbWSUmslldZaazGm1mIMpaQUSmmtpNRiaim21lqsFWMQMuekZM5JCaWkFEpJLXNOSgchlc5BKSWV1kpJqWXOSekglNJBKKWk0lpJpbVQSkslpdZCKa211mJMqbUaSkmtpNRaSam11FqtrbUYOwgphVJaCqW0llqKMaUWYyiltZJSayWl1lprtbbWYgyltFRSaa2k1FpqrcbWWqyppRhTazG21mqNMcYcY805pRRjainG1FqMLbYcY6w1dxBSCqWkFkpJLbUUY2otxlBKaiWV1kpJLbbWakytxRpKaa2k1FpJqbXWWo2ttRpTSjGm1mpMqcUYY8y1tRhzai3G1lqsqbUYY6w1xxhrLQAAYMABACDAhDJQaMhKACAKAAAxBiHGnDMIKcUYhMYgpRiDECnFmHMQIqUYcw5CxphzEErJGHMOQikdhBJKSamDEEopKRUAAFDgAAAQYIOmxOIAhYasBABCAgAYhJRizDnnIJSSUoSQUow55xyEUlKKEFKKMeecg1BKSpVSTDHmHIRSUmqpUkoxxpyDUEpKqWWMMeYchBBKSam1jDHGnIMQQikptdY55xx0EkpJpaXYOuecgxBKKSWl1lrnHIQQSkmlpdZi65yDEEIpJaXUWoshhFJKSSWllmKLMYRSSiklpZRaizGWVFJKqaXWYouxxlJKSiml1lqLMcaaUmqptdZijLHGWlNKqbXWWosxxlprAQAABw4AAAFG0ElGlUXYaMKFB6DQkBUBQBQAAGAMYgwxhpxzEDIIkXMMQgchcs5J6aRkUkJpIaVMSkglpBY556R0UjIpoaVQUiYlpFRaKQAA7MABAOzAQig0ZCUAkAcAACGkFGOMMYaUUooxxhxDSinFGGOMKaUYY4wx55RSjDHGmHOMMcYcc845xhhjzDnnHGPMMeecc44xxpxzzjnHHHPOOeecY84555xzzgkAACpwAAAIsFFkc4KRoEJDVgIAqQAAhDFKMeYchFIahRhzzjkIpTRIMeaccxBKqRhzzjkIpZRSMeaccxBKKSVzzjkIIZSSUuaccxBCKCWlzjkIIYRSSkqdcxBCKKGUlEIIpZRSUkqphRBKKaWUVFoqpZSSUkqptVZKKSWllFpqrQAA8AQHAKACG1ZHOCkaCyw0ZCUAkAEAwBiDkEEGIWMQQgghhBBCCAkAABhwAAAIMKEMFBqyEgBIBQAADFKKMQelpBQpxZhzEEpJKVKKMecglJJSxZhzEEpJqbWKMecglJJSa51zEEpJqbUYO+cglJJSazGGEEpJqbUYYwwhlJJSazHWWkpJqbUYa8y1lJJSazHWWmtKrbUYa60155RaazHWWnPOBQAgNDgAgB3YsDrCSdFYYKEhKwGAPAAASCnGGGOMMaUUY4wxxphSijHGGGOMMcYYY4wxphhjjDHGGGOMMcYYY4wxxhhjjDHGGGOMMeYYY4wxxhhjzDnGGGOMOeYcY4wxxpxzTgAAUIEDAECAjSKbE4wEFRqyEgAIBwAAjGHMOecglJBKo5RzEEIoJZVWGqWcgxJCKSm1ljknJaVSUmottsw5KSmVklJrLXYSUmotpdZirLGDkFJrqbUWY40dhFJaii3GGnPtIJSSWmsxxlprKKWl2GKssdaaQymptRZjrTXnXFJqLcZaa82155JSazHGWmutuafWYqyx1lxz7z21FmONteace84FAJg8OABAJdg4w0rSWeFocKEhKwGA3AAARinGnHMOQgghhBBCCJVSjDnnHIQQQgghhBAqpRhzzjkIIYQQQgghZIw55xx0EEIIIYQQQsgYc845CCGEEEIIIYTQOecchBBCCCGEUEIppXPOOQchhBBCCCGEUErnHIQQQgghhBJKKKWUzjkIIYQQQgilhFJKKSGEEEIIIYQSSimllFI6CCGEEEIIpZRSSimlhBBCCCGEEEoppZRSSgkhhBBCCCGUUkoppZQSQgghhBJKKaWUUkopJYQQQgihlFJKKaWUUkoIIYRSSimllFJKKaWUEEIoIZRSSimllFJKKSGEEkoopZRSSimllFJCCCWUUkoppZRSSimlhBBCKKWUUkoppZRSSgkhlFJKKaWUUkoppZRSAADQgQMAQIARlRZipxlXHoEjChkmoEJDVgIA4QAAACGUUkoppZRSaiSllFJKKaWUUiMlpZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKpZRSSimllFJKKaWUUkoppZRSSimlAKjLDAfA6AkbZ1hJOiscDS40ZCUAkBYAABjDmGOOQSehlJRaa5iCUELopKTSSmyxNUpBCCGEUlJKrbXWMuiolJJKSq3FFmOMmYNSUiolpdRijLHWDkJKLbUWW4ux5lprB6GklFqLLcZaa669g5BKa63lGGOwOefaQSgptdhijDXXWnsOqbQWY4y19lxrzTmIUlKKMdYac80199xLSq3FmmuuNQefcxCmpdhqjTXnnHsQOvjUWo255h500EHnHnRKrdZaa849ByF88Lm1WGvNNefegw86CN9qqzXnXGvvPfeeg24x1lxz0MEHIXzwQbgYa8859xyEDjr4HgwAyI1wAEBcMJKQOsuw0ogbT8AQgRQasgoAiAEAIIxBBiGElFJKKaWUYoopxhhjjDHGGGOMMcYYY4wxxgQAACY4AAAEWMGuzNKqjeKmTvKiDwKf0BGbkSGXUjGTE0GP1FCLlWCHVnCDF4CFhqwEAMgAABCIseZac44QlNZi7blUSjlqseeUIYKctJxLyQxBTlprLWTIKCcxthQyhBS02lrplFKMYquxdIwxSanFlkrnIAAAAIIAAAMRMhMIFECBgQwAOEBIkAIACgsMHcNFQEAuIaPAoHBMOCedNgAAQYjMEImIxSAxoRooKqYDgMUFhnwAyNDYSLu4gC4DXNDFXQdCCEIQglgcQAEJODjhhife8IQbnKBTVOogAAAAAAAQAOABACDZACKimZnj6PD4AAkRGSEpMTlBSVEJAAAAAAAgAPgAAEhWgIhoZuY4Ojw+QEJERkhKTE5QUlQCAAAAAAAAAACAgIAAAAAAAEAAAACAgE9nZ1MABNcZAAAAAAAAdDcfBQIAAAB90D1rDDpdT59ucP8Z/9ABAaTZln09D/JG7sabbYw8/3w7bAMkwcd7qbhiUI+pv/9pfRIZbvhutwvREnt/XRVOxPzgbye2O4+g9wDsBfs+4S5v9bPxrca9rX6ZJznncX+UNb59K+H4u5ectvX3bjdOX5w59ox/HbyCr8E1T/z3UAT/7Pi7Jf1ds66v/byiSjQmXCJ9yFsikxOro+c/77GT3/X/P3BOWgr0DfuRcO8b/8tDMVPtPpV82Q4AvJyz3/yQxKnzzfPGcM+Y5h8A7hbOFWmnb8AeyqVaWWg3XobuFMIjYfEc1bXHS0siGVXw2/3QxqmfWgEAmhVE3OV7Jaa29JUUWxOHZkeGLWcvv/zyF3mRF7zI5RPO/xUAgJiff/75VQAAAhzJGAAgaioLI//Z9+P9Pm5idsVuN30wlEIAO70fOaTn1iBS/Z92QWlxTYNgZu/P//dxPp1Px9P1cn88P78n/zG9eL4+19M6fCIYUkUB9SsW7GunNmyCn9abCQT6ZqvY6WD56pdRfllZHvc2AgwYEi4AXiUk3UXiVpx/NlcV7/OLovbIsPcAAAAAFAAIEGKMAgAAAH96PoD93xMAAEXUJXptF+XSVp7Eqstrl3bdSlEEEBSDE7E83tFLDJoAwH3VCdb3j/g0bV13ZNjZNstz+0TC92XyoxbxfTViEkjBAgweJeT1VcILMf/bXlX0fYmiZmTYewAAAAAAAAGOYxQAAAB4cxcSYP96VgAAKEaTbep+MOvLLAY3RsPsoNvNCVEAQBFxjXboxp5vuRpRIFVBcQSlMln0lAbTgh4vYl2mLq3QjARRuGDHwBr8rkIcRIACfhVE+e02imO+VPFQ43w9Miw5gmu7Q+Lbt0YF377x3jcAAGLrHmCMAONUJWMA4CbJYrIrUflM2lgD7LPRgpm9Luo9n3EBODixMlodb4P/ZdEVRl0xMcss+Xz2+F7HtQ31OP3/4vZE6Go7/k/2f7J/8/6N91+/f/0m++X9ZwoAlQMcZO8gBw5y0EH7smbNmjVr1vzJevXLivkQ8ydd9/KTNkx0lFHQ48+HI/bAM1ZWs+VnvXt1a3bW0/s+a/mMZ325NU+dPOtdn7Xm6qdXf7l3Xb36rC+++zlnnHHG0885Y/nUqTPOODl5/+/jk5Pj8fjheNybZrftx92+tl08zGOF1QgHDjpwYMtBBw5aBw7KbDlo30HhoE1YGd5zExv5/F5ixutCEUVpnG/qfpqiti12j/fcfd7wqMThSPPNvpvbxk44xuHOSDju3LxtLDzcublrJMaRkZEY48hIVI/Rhj7//PPPP//888/P559//vnnn3/++SIVhFMAeYWNT9pWluxDKmm7j+TOc98cqtIZ5qqog/y72c49TV3+64am1vZPyuHz4/FxPp72j4fxND4cxg0tPhzGNS0+zMfT+PB4OPyBW+XKZPeWMQoku2MUQOPUR5U53g4hsN1f0m05P72irudPPXN6aempZ545c8XpL3zpS2eefuZ3fveXnnnmS//v937p2V/6f//f7/2yL/3O//f//e4vfen//X//35c9+3f+3//3e5/9zJd+9+/9smee+cLv/rIzT5/+wrPPXFra/9TpecJ2CG30gfHuj+9Ohze9/Z237LnpB37wO95yyw/8PX/PD/17fugP/sF/9+/5we+85e3vfOetbrnllltu2TM6umfPaDZN02wqZTlLwWTJhb8zfzgc7t+/f//+/X//97///e9/p0+fPn369DPPPPPMM88888wzzzzzhS89+5lnnnnmmTNPnz79zOnT//vf//53//79+/fnD4fD4XCY8/M5FxYWAAlOZQEODg==',
     '2': 'data:audio/ogg;base64,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',
@@ -283,10 +514,10 @@ var DialerPadSoundsOGG = {
     '8': 'data:audio/ogg;base64,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',
     '9': 'data:audio/ogg;base64,T2dnUwACAAAAAAAAAABwncJuAAAAAO8QcZMBHgF2b3JiaXMAAAAAAUSsAAAAAAAAMKkDAAAAAAC4AU9nZ1MAAAAAAAAAAAAAcJ3CbgEAAACo/1bgET3////////////////////VA3ZvcmJpcy0AAABYaXBoLk9yZyBsaWJWb3JiaXMgSSAyMDEwMTEwMSAoU2NoYXVmZW51Z2dldCkAAAAAAQV2b3JiaXMrQkNWAQAIAAAAMUwgxYDQkFUAABAAAGAkKQ6TZkkppZShKHmYlEhJKaWUxTCJmJSJxRhjjDHGGGOMMcYYY4wgNGQVAAAEAIAoCY6j5klqzjlnGCeOcqA5aU44pyAHilHgOQnC9SZjbqa0pmtuziklCA1ZBQAAAgBASCGFFFJIIYUUYoghhhhiiCGHHHLIIaeccgoqqKCCCjLIIINMMumkk0466aijjjrqKLTQQgsttNJKTDHVVmOuvQZdfHPOOeecc84555xzzglCQ1YBACAAAARCBhlkEEIIIYUUUogppphyCjLIgNCQVQAAIACAAAAAAEeRFEmxFMuxHM3RJE/yLFETNdEzRVNUTVVVVVV1XVd2Zdd2ddd2fVmYhVu4fVm4hVvYhV33hWEYhmEYhmEYhmH4fd/3fd/3fSA0ZBUAIAEAoCM5luMpoiIaouI5ogOEhqwCAGQAAAQAIAmSIimSo0mmZmquaZu2aKu2bcuyLMuyDISGrAIAAAEABAAAAAAAoGmapmmapmmapmmapmmapmmapmmaZlmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVlAaMgqAEACAEDHcRzHcSRFUiTHciwHCA1ZBQDIAAAIAEBSLMVyNEdzNMdzPMdzPEd0RMmUTM30TA8IDVkFAAACAAgAAAAAAEAxHMVxHMnRJE9SLdNyNVdzPddzTdd1XVdVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVgdCQVQAABAAAIZ1mlmqACDOQYSA0ZBUAgAAAABihCEMMCA1ZBQAABAAAiKHkIJrQmvPNOQ6a5aCpFJvTwYlUmye5qZibc84555xszhnjnHPOKcqZxaCZ0JpzzkkMmqWgmdCac855EpsHranSmnPOGeecDsYZYZxzzmnSmgep2Vibc85Z0JrmqLkUm3POiZSbJ7W5VJtzzjnnnHPOOeecc86pXpzOwTnhnHPOidqba7kJXZxzzvlknO7NCeGcc84555xzzjnnnHPOCUJDVgEAQAAABGHYGMadgiB9jgZiFCGmIZMedI8Ok6AxyCmkHo2ORkqpg1BSGSeldILQkFUAACAAAIQQUkghhRRSSCGFFFJIIYYYYoghp5xyCiqopJKKKsoos8wyyyyzzDLLrMPOOuuwwxBDDDG00kosNdVWY4215p5zrjlIa6W11lorpZRSSimlIDRkFQAAAgBAIGSQQQYZhRRSSCGGmHLKKaegggoIDVkFAAACAAgAAADwJM8RHdERHdERHdERHdERHc/xHFESJVESJdEyLVMzPVVUVVd2bVmXddu3hV3Ydd/Xfd/XjV8XhmVZlmVZlmVZlmVZlmVZlmUJQkNWAQAgAAAAQgghhBRSSCGFlGKMMcecg05CCYHQkFUAACAAgAAAAABHcRTHkRzJkSRLsiRN0izN8jRP8zTRE0VRNE1TFV3RFXXTFmVTNl3TNWXTVWXVdmXZtmVbt31Ztn3f933f933f933f933f13UgNGQVACABAKAjOZIiKZIiOY7jSJIEhIasAgBkAAAEAKAojuI4jiNJkiRZkiZ5lmeJmqmZnumpogqEhqwCAAABAAQAAAAAAKBoiqeYiqeIiueIjiiJlmmJmqq5omzKruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6QGjIKgBAAgBAR3IkR3IkRVIkRXIkBwgNWQUAyAAACADAMRxDUiTHsixN8zRP8zTREz3RMz1VdEUXCA1ZBQAAAgAIAAAAAADAkAxLsRzN0SRRUi3VUjXVUi1VVD1VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXVNE3TNIHQkJUAABkAAOjFCCGEEJKjlloQvlfKOSg1914xZhTE3nulmEGOcvCZYko5KLWnzjGliJFcWyuRIsRhDjpVTimoQefWSQgtB0JDVgQAUQAAAEKIMcQYYoxByCBEjDEIGYSIMQYhg9BBCCWFlDIIIZWQUsQYg9BBySCElEJJGZSQUkilAACAAAcAgAALodCQFQFAnAAAgpBziDEIFWMQOgipdBBSqhiDkDknJXMOSiglpRBKShVjEDLnJGTOSQklpBRKSamDkFIopaVQSmoppRhTSi12EFIKpaQUSmkptRRbSi3GijEImXNSMuekhFJaCqWkljknpYOQUgehlJJSa6Wk1jLnpHTQSekglFJSaamU1FooJbWSUmslldZaazGm1mIMpaQUSmmtpNRiaim21lqsFWMQMuekZM5JCaWkFEpJLXNOSgchlc5BKSWV1kpJqWXOSekglNJBKKWk0lpJpbVQSkslpdZCKa211mJMqbUaSkmtpNRaSam11FqtrbUYOwgphVJaCqW0llqKMaUWYyiltZJSayWl1lprtbbWYgyltFRSaa2k1FpqrcbWWqyppRhTazG21mqNMcYcY805pRRjainG1FqMLbYcY6w1dxBSCqWkFkpJLbUUY2otxlBKaiWV1kpJLbbWakytxRpKaa2k1FpJqbXWWo2ttRpTSjGm1mpMqcUYY8y1tRhzai3G1lqsqbUYY6w1xxhrLQAAYMABACDAhDJQaMhKACAKAAAxBiHGnDMIKcUYhMYgpRiDECnFmHMQIqUYcw5CxphzEErJGHMOQikdhBJKSamDEEopKRUAAFDgAAAQYIOmxOIAhYasBABCAgAYhJRizDnnIJSSUoSQUow55xyEUlKKEFKKMeecg1BKSpVSTDHmHIRSUmqpUkoxxpyDUEpKqWWMMeYchBBKSam1jDHGnIMQQikptdY55xx0EkpJpaXYOuecgxBKKSWl1lrnHIQQSkmlpdZi65yDEEIpJaXUWoshhFJKSSWllmKLMYRSSiklpZRaizGWVFJKqaXWYouxxlJKSiml1lqLMcaaUmqptdZijLHGWlNKqbXWWosxxlprAQAABw4AAAFG0ElGlUXYaMKFB6DQkBUBQBQAAGAMYgwxhpxzEDIIkXMMQgchcs5J6aRkUkJpIaVMSkglpBY556R0UjIpoaVQUiYlpFRaKQAA7MABAOzAQig0ZCUAkAcAACGkFGOMMYaUUooxxhxDSinFGGOMKaUYY4wx55RSjDHGmHOMMcYcc845xhhjzDnnHGPMMeecc44xxpxzzjnHHHPOOeecY84555xzzgkAACpwAAAIsFFkc4KRoEJDVgIAqQAAhDFKMeYchFIahRhzzjkIpTRIMeaccxBKqRhzzjkIpZRSMeaccxBKKSVzzjkIIZSSUuaccxBCKCWlzjkIIYRSSkqdcxBCKKGUlEIIpZRSUkqphRBKKaWUVFoqpZSSUkqptVZKKSWllFpqrQAA8AQHAKACG1ZHOCkaCyw0ZCUAkAEAwBiDkEEGIWMQQgghhBBCCAkAABhwAAAIMKEMFBqyEgBIBQAADFKKMQelpBQpxZhzEEpJKVKKMecglJJSxZhzEEpJqbWKMecglJJSa51zEEpJqbUYO+cglJJSazGGEEpJqbUYYwwhlJJSazHWWkpJqbUYa8y1lJJSazHWWmtKrbUYa60155RaazHWWnPOBQAgNDgAgB3YsDrCSdFYYKEhKwGAPAAASCnGGGOMMaUUY4wxxphSijHGGGOMMcYYY4wxphhjjDHGGGOMMcYYY4wxxhhjjDHGGGOMMeYYY4wxxhhjzDnGGGOMOeYcY4wxxpxzTgAAUIEDAECAjSKbE4wEFRqyEgAIBwAAjGHMOecglJBKo5RzEEIoJZVWGqWcgxJCKSm1ljknJaVSUmottsw5KSmVklJrLXYSUmotpdZirLGDkFJrqbUWY40dhFJaii3GGnPtIJSSWmsxxlprKKWl2GKssdaaQymptRZjrTXnXFJqLcZaa82155JSazHGWmutuafWYqyx1lxz7z21FmONteace84FAJg8OABAJdg4w0rSWeFocKEhKwGA3AAARinGnHMOQgghhBBCCJVSjDnnHIQQQgghhBAqpRhzzjkIIYQQQgghZIw55xx0EEIIIYQQQsgYc845CCGEEEIIIYTQOecchBBCCCGEUEIppXPOOQchhBBCCCGEUErnHIQQQgghhBJKKKWUzjkIIYQQQgilhFJKKSGEEEIIIYQSSimllFI6CCGEEEIIpZRSSimlhBBCCCGEEEoppZRSSgkhhBBCCCGUUkoppZQSQgghhBJKKaWUUkopJYQQQgihlFJKKaWUUkoIIYRSSimllFJKKaWUEEIoIZRSSimllFJKKSGEEkoopZRSSimllFJCCCWUUkoppZRSSimlhBBCKKWUUkoppZRSSgkhlFJKKaWUUkoppZRSAADQgQMAQIARlRZipxlXHoEjChkmoEJDVgIA4QAAACGUUkoppZRSaiSllFJKKaWUUiMlpZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKpZRSSimllFJKKaWUUkoppZRSSimlAKjLDAfA6AkbZ1hJOiscDS40ZCUAkBYAABjDmGOOQSehlJRaa5iCUELopKTSSmyxNUpBCCGEUlJKrbXWMuiolJJKSq3FFmOMmYNSUiolpdRijLHWDkJKLbUWW4ux5lprB6GklFqLLcZaa669g5BKa63lGGOwOefaQSgptdhijDXXWnsOqbQWY4y19lxrzTmIUlKKMdYac80199xLSq3FmmuuNQefcxCmpdhqjTXnnHsQOvjUWo255h500EHnHnRKrdZaa849ByF88Lm1WGvNNefegw86CN9qqzXnXGvvPfeeg24x1lxz0MEHIXzwQbgYa8859xyEDjr4HgwAyI1wAEBcMJKQOsuw0ogbT8AQgRQasgoAiAEAIIxBBiGElFJKKaWUYoopxhhjjDHGGGOMMcYYY4wxxgQAACY4AAAEWMGuzNKqjeKmTvKiDwKf0BGbkSGXUjGTE0GP1FCLlWCHVnCDF4CFhqwEAMgAABCIseZac44QlNZi7blUSjlqseeUIYKctJxLyQxBTlprLWTIKCcxthQyhBS02lrplFKMYquxdIwxSanFlkrnIAAAAIIAAAMRMhMIFECBgQwAOEBIkAIACgsMHcNFQEAuIaPAoHBMOCedNgAAQYjMEImIxSAxoRooKqYDgMUFhnwAyNDYSLu4gC4DXNDFXQdCCEIQglgcQAEJODjhhife8IQbnKBTVOogAAAAAAAQAOABACDZACKimZnj6PD4AAkRGSEpMTlBSVEJAAAAAAAgAPgAAEhWgIhoZuY4Ojw+QEJERkhKTE5QUlQCAAAAAAAAAACAgIAAAAAAAEAAAACAgE9nZ1MABNcZAAAAAAAAcJ3CbgIAAADrgeKcCTufZmD+/7sBAYTZ5FMDo2u1B95y/fgwVv/5CXNzeAMg0VCv75qoz6ZpjN/fDKoZvX23O5SwO+9DenwHM//JqLfbbjIAOhUkxVUkALH8+qya4sNNsAzjeCMe/Ybf9Jv9pice3N/f3wcAWD4AAACAAGMMAMD3tPRosHgdzQ77x6DsNAxDTcc5MAH08PotnwDgce2y++qwPPlX54/XftYWybqYcrA83F//72n53CDHw2dZJYMKalJWVnVVF3kMRk/Fr3OnJvo6KTepV/zJ7ebx7Us9Ze7KtDu5v3lerLFhFWEJvEAF/iRU7nffA778tlSvddT1QUwBAJZHAQAAgABjFADA9f9OAHD2+yIAAAAAN7zs3//5F6/u+ziiZHmdGQcAAAAAReTXfD+vNiEAAAAAAIBhXqWv/N6tEHpx/knz++Vcenu7S6Qg6aEAPiXk7jc/HdP8tVTn26i3gpgCACyPBQAAAAKMpAAA9oUqAPDXvwMAAACAMNEKexRaLR1XczU0l+xQrEcFAAAAAJRUXqdU/1AAAAAAAIBUgR1ltksdxhyCgLYNSl+XhmEAnhVE+uIbuE9+f1XvzVeM6bM4Sfzz+Bln/Pj77wAA70AAAKMEGCErSTIA+I78Fd4qK5qpqKNl1cAd/cUiANTv8gCARDZYbBf/bJU3gyazou4hlW1dl3ly28yG9bd9Hc1u00VRd1X3EIIrgIh5yMx2+3ZkzRp+/0524CD33+hAxm8yABAY7AUms4L7r3VQG//+S9NZs7bH3U1sw8TzCPH4vjcMPZnMeDqPxw8nR9hw8+0dz+PjP/99fMRw882PfuRVtbx6ZcsvBjt23nksAbPl//47sk3m3LmZUIzHD0fxNQ85J53/Pi6uqXXWdrftNPugzPPff+PeQcGYbLUhDwDehEPKywWkmt9+07q3+FwAUT1xJA5vjlWm7p4VLRnu3PzAhyROJ3NlYLhrqd195uB5FYS2VduQnPWVxb4/xD5/zvfDD3Hl/MXvhx/iyvlV88MPrpxffT+MceX8fD+MaSUDMNOT544pmCBa11NJ9ZqqT2OEpWPl04pR/yIm/zHZi/ld/h//PImTn9bm4szi/+a19Ee8jyrN/ca+LQCkD+aDWGn+mfdbhGrfrn+JAbsvur95LX7Ynq0JrPFvqf2PxvsP+H6tGVw+o//NczX3fyl/f0x29517k7U+/8KzfQDJjVvGKBLmp1fMH8J+9+7du7O8Hd7u3w9tnN7enWXU4W0+JLjHX236t4eqXXZnebtwqKLyx1/B5G8PVfTox1/t94fD4UA2Tu/enXIe7t+/fyC7/eHH9055u/+//310QP09t+y1J+vmT33pS2c2+S7Rf/vf/XvecRx5/IXf/bufvQJd+9t/zw99x3Hu8e/+3V/27Lboxjt/8A9+x9ziqd/53V+2iujf9M533moMWe5/6swVNUqGu3vGKKa8f//+/RDj7d27sy63t/uHSh79+FnzfzvnOvzw7Levc2QBDg4=',
     '*': 'data:audio/ogg;base64,T2dnUwACAAAAAAAAAAC0fMFwAAAAAKxAgE8BHgF2b3JiaXMAAAAAAUSsAAAAAAAAMKkDAAAAAAC4AU9nZ1MAAAAAAAAAAAAAtHzBcAEAAACRnqZfET3////////////////////VA3ZvcmJpcy0AAABYaXBoLk9yZyBsaWJWb3JiaXMgSSAyMDEwMTEwMSAoU2NoYXVmZW51Z2dldCkAAAAAAQV2b3JiaXMrQkNWAQAIAAAAMUwgxYDQkFUAABAAAGAkKQ6TZkkppZShKHmYlEhJKaWUxTCJmJSJxRhjjDHGGGOMMcYYY4wgNGQVAAAEAIAoCY6j5klqzjlnGCeOcqA5aU44pyAHilHgOQnC9SZjbqa0pmtuziklCA1ZBQAAAgBASCGFFFJIIYUUYoghhhhiiCGHHHLIIaeccgoqqKCCCjLIIINMMumkk0466aijjjrqKLTQQgsttNJKTDHVVmOuvQZdfHPOOeecc84555xzzglCQ1YBACAAAARCBhlkEEIIIYUUUogppphyCjLIgNCQVQAAIACAAAAAAEeRFEmxFMuxHM3RJE/yLFETNdEzRVNUTVVVVVV1XVd2Zdd2ddd2fVmYhVu4fVm4hVvYhV33hWEYhmEYhmEYhmH4fd/3fd/3fSA0ZBUAIAEAoCM5luMpoiIaouI5ogOEhqwCAGQAAAQAIAmSIimSo0mmZmquaZu2aKu2bcuyLMuyDISGrAIAAAEABAAAAAAAoGmapmmapmmapmmapmmapmmapmmaZlmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVmWZVlAaMgqAEACAEDHcRzHcSRFUiTHciwHCA1ZBQDIAAAIAEBSLMVyNEdzNMdzPMdzPEd0RMmUTM30TA8IDVkFAAACAAgAAAAAAEAxHMVxHMnRJE9SLdNyNVdzPddzTdd1XVdVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVgdCQVQAABAAAIZ1mlmqACDOQYSA0ZBUAgAAAABihCEMMCA1ZBQAABAAAiKHkIJrQmvPNOQ6a5aCpFJvTwYlUmye5qZibc84555xszhnjnHPOKcqZxaCZ0JpzzkkMmqWgmdCac855EpsHranSmnPOGeecDsYZYZxzzmnSmgep2Vibc85Z0JrmqLkUm3POiZSbJ7W5VJtzzjnnnHPOOeecc86pXpzOwTnhnHPOidqba7kJXZxzzvlknO7NCeGcc84555xzzjnnnHPOCUJDVgEAQAAABGHYGMadgiB9jgZiFCGmIZMedI8Ok6AxyCmkHo2ORkqpg1BSGSeldILQkFUAACAAAIQQUkghhRRSSCGFFFJIIYYYYoghp5xyCiqopJKKKsoos8wyyyyzzDLLrMPOOuuwwxBDDDG00kosNdVWY4215p5zrjlIa6W11lorpZRSSimlIDRkFQAAAgBAIGSQQQYZhRRSSCGGmHLKKaegggoIDVkFAAACAAgAAADwJM8RHdERHdERHdERHdERHc/xHFESJVESJdEyLVMzPVVUVVd2bVmXddu3hV3Ydd/Xfd/XjV8XhmVZlmVZlmVZlmVZlmVZlmUJQkNWAQAgAAAAQgghhBRSSCGFlGKMMcecg05CCYHQkFUAACAAgAAAAABHcRTHkRzJkSRLsiRN0izN8jRP8zTRE0VRNE1TFV3RFXXTFmVTNl3TNWXTVWXVdmXZtmVbt31Ztn3f933f933f933f933f13UgNGQVACABAKAjOZIiKZIiOY7jSJIEhIasAgBkAAAEAKAojuI4jiNJkiRZkiZ5lmeJmqmZnumpogqEhqwCAAABAAQAAAAAAKBoiqeYiqeIiueIjiiJlmmJmqq5omzKruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6ruu6QGjIKgBAAgBAR3IkR3IkRVIkRXIkBwgNWQUAyAAACADAMRxDUiTHsixN8zRP8zTREz3RMz1VdEUXCA1ZBQAAAgAIAAAAAADAkAxLsRzN0SRRUi3VUjXVUi1VVD1VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVXVNE3TNIHQkJUAABkAAOjFCCGEEJKjlloQvlfKOSg1914xZhTE3nulmEGOcvCZYko5KLWnzjGliJFcWyuRIsRhDjpVTimoQefWSQgtB0JDVgQAUQAAAEKIMcQYYoxByCBEjDEIGYSIMQYhg9BBCCWFlDIIIZWQUsQYg9BBySCElEJJGZSQUkilAACAAAcAgAALodCQFQFAnAAAgpBziDEIFWMQOgipdBBSqhiDkDknJXMOSiglpRBKShVjEDLnJGTOSQklpBRKSamDkFIopaVQSmoppRhTSi12EFIKpaQUSmkptRRbSi3GijEImXNSMuekhFJaCqWkljknpYOQUgehlJJSa6Wk1jLnpHTQSekglFJSaamU1FooJbWSUmslldZaazGm1mIMpaQUSmmtpNRiaim21lqsFWMQMuekZM5JCaWkFEpJLXNOSgchlc5BKSWV1kpJqWXOSekglNJBKKWk0lpJpbVQSkslpdZCKa211mJMqbUaSkmtpNRaSam11FqtrbUYOwgphVJaCqW0llqKMaUWYyiltZJSayWl1lprtbbWYgyltFRSaa2k1FpqrcbWWqyppRhTazG21mqNMcYcY805pRRjainG1FqMLbYcY6w1dxBSCqWkFkpJLbUUY2otxlBKaiWV1kpJLbbWakytxRpKaa2k1FpJqbXWWo2ttRpTSjGm1mpMqcUYY8y1tRhzai3G1lqsqbUYY6w1xxhrLQAAYMABACDAhDJQaMhKACAKAAAxBiHGnDMIKcUYhMYgpRiDECnFmHMQIqUYcw5CxphzEErJGHMOQikdhBJKSamDEEopKRUAAFDgAAAQYIOmxOIAhYasBABCAgAYhJRizDnnIJSSUoSQUow55xyEUlKKEFKKMeecg1BKSpVSTDHmHIRSUmqpUkoxxpyDUEpKqWWMMeYchBBKSam1jDHGnIMQQikptdY55xx0EkpJpaXYOuecgxBKKSWl1lrnHIQQSkmlpdZi65yDEEIpJaXUWoshhFJKSSWllmKLMYRSSiklpZRaizGWVFJKqaXWYouxxlJKSiml1lqLMcaaUmqptdZijLHGWlNKqbXWWosxxlprAQAABw4AAAFG0ElGlUXYaMKFB6DQkBUBQBQAAGAMYgwxhpxzEDIIkXMMQgchcs5J6aRkUkJpIaVMSkglpBY556R0UjIpoaVQUiYlpFRaKQAA7MABAOzAQig0ZCUAkAcAACGkFGOMMYaUUooxxhxDSinFGGOMKaUYY4wx55RSjDHGmHOMMcYcc845xhhjzDnnHGPMMeecc44xxpxzzjnHHHPOOeecY84555xzzgkAACpwAAAIsFFkc4KRoEJDVgIAqQAAhDFKMeYchFIahRhzzjkIpTRIMeaccxBKqRhzzjkIpZRSMeaccxBKKSVzzjkIIZSSUuaccxBCKCWlzjkIIYRSSkqdcxBCKKGUlEIIpZRSUkqphRBKKaWUVFoqpZSSUkqptVZKKSWllFpqrQAA8AQHAKACG1ZHOCkaCyw0ZCUAkAEAwBiDkEEGIWMQQgghhBBCCAkAABhwAAAIMKEMFBqyEgBIBQAADFKKMQelpBQpxZhzEEpJKVKKMecglJJSxZhzEEpJqbWKMecglJJSa51zEEpJqbUYO+cglJJSazGGEEpJqbUYYwwhlJJSazHWWkpJqbUYa8y1lJJSazHWWmtKrbUYa60155RaazHWWnPOBQAgNDgAgB3YsDrCSdFYYKEhKwGAPAAASCnGGGOMMaUUY4wxxphSijHGGGOMMcYYY4wxphhjjDHGGGOMMcYYY4wxxhhjjDHGGGOMMeYYY4wxxhhjzDnGGGOMOeYcY4wxxpxzTgAAUIEDAECAjSKbE4wEFRqyEgAIBwAAjGHMOecglJBKo5RzEEIoJZVWGqWcgxJCKSm1ljknJaVSUmottsw5KSmVklJrLXYSUmotpdZirLGDkFJrqbUWY40dhFJaii3GGnPtIJSSWmsxxlprKKWl2GKssdaaQymptRZjrTXnXFJqLcZaa82155JSazHGWmutuafWYqyx1lxz7z21FmONteace84FAJg8OABAJdg4w0rSWeFocKEhKwGA3AAARinGnHMOQgghhBBCCJVSjDnnHIQQQgghhBAqpRhzzjkIIYQQQgghZIw55xx0EEIIIYQQQsgYc845CCGEEEIIIYTQOecchBBCCCGEUEIppXPOOQchhBBCCCGEUErnHIQQQgghhBJKKKWUzjkIIYQQQgilhFJKKSGEEEIIIYQSSimllFI6CCGEEEIIpZRSSimlhBBCCCGEEEoppZRSSgkhhBBCCCGUUkoppZQSQgghhBJKKaWUUkopJYQQQgihlFJKKaWUUkoIIYRSSimllFJKKaWUEEIoIZRSSimllFJKKSGEEkoopZRSSimllFJCCCWUUkoppZRSSimlhBBCKKWUUkoppZRSSgkhlFJKKaWUUkoppZRSAADQgQMAQIARlRZipxlXHoEjChkmoEJDVgIA4QAAACGUUkoppZRSaiSllFJKKaWUUiMlpZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKpZRSSimllFJKKaWUUkoppZRSSimlAKjLDAfA6AkbZ1hJOiscDS40ZCUAkBYAABjDmGOOQSehlJRaa5iCUELopKTSSmyxNUpBCCGEUlJKrbXWMuiolJJKSq3FFmOMmYNSUiolpdRijLHWDkJKLbUWW4ux5lprB6GklFqLLcZaa669g5BKa63lGGOwOefaQSgptdhijDXXWnsOqbQWY4y19lxrzTmIUlKKMdYac80199xLSq3FmmuuNQefcxCmpdhqjTXnnHsQOvjUWo255h500EHnHnRKrdZaa849ByF88Lm1WGvNNefegw86CN9qqzXnXGvvPfeeg24x1lxz0MEHIXzwQbgYa8859xyEDjr4HgwAyI1wAEBcMJKQOsuw0ogbT8AQgRQasgoAiAEAIIxBBiGElFJKKaWUYoopxhhjjDHGGGOMMcYYY4wxxgQAACY4AAAEWMGuzNKqjeKmTvKiDwKf0BGbkSGXUjGTE0GP1FCLlWCHVnCDF4CFhqwEAMgAABCIseZac44QlNZi7blUSjlqseeUIYKctJxLyQxBTlprLWTIKCcxthQyhBS02lrplFKMYquxdIwxSanFlkrnIAAAAIIAAAMRMhMIFECBgQwAOEBIkAIACgsMHcNFQEAuIaPAoHBMOCedNgAAQYjMEImIxSAxoRooKqYDgMUFhnwAyNDYSLu4gC4DXNDFXQdCCEIQglgcQAEJODjhhife8IQbnKBTVOogAAAAAAAQAOABACDZACKimZnj6PD4AAkRGSEpMTlBSVEJAAAAAAAgAPgAAEhWgIhoZuY4Ojw+QEJERkhKTE5QUlQCAAAAAAAAAACAgIAAAAAAAEAAAACAgE9nZ1MABNcZAAAAAAAAtHzBcAIAAAAbCNR+Cjxd9Wln9f+eAQFM2cLZuAQfeeBNP+6f/H/ebqcWYAJpmcF5xBCcPs+4tqyuWDzpRPc0IetsJ/2dz4fqsQ2XMBswb7gnwRdcDeHZuIJ8w0/qwzcbD/Pd91Kb5/pxUNb49u6E4/+93Gnb/u2djNNvz53O+NfBXuWHqDbYFB8tfBV+/lu0o/+hcNmdaWsvKU3Lo0sdW9tKaWV0/R06F+/+PdfkBAAaJVT9TQTBxCHXjuGpL97JAhtaBsbT3/w3/xu/+f/v//ebv+MqKjgAknT//uXJyXTOAAAMFCykZBQAACGyCnOI82MaW8XzrKSHIf9HVYV+PTRNivyUj6OIDWdm8839ezvOdL7aHObLy2RtPTxPV15fc7r/XtfD54cffvjhWYBvX+cAoLjl66+//vrrr7/++nyjjsNPJelwdHR0dMxNe/aM2zNud3T27qz0pUyjsMLtcP/v/L8f/fvR/bf//Xv//tv8/fu/55DaIt5Y6UfMTv1x9nb2djqd+lPfOZdZaIjJ1MLXX3/99buvv/66VjZGzB5+8mRWBF4lJN53v8PKZs9KFN5BnyTAPjoCBwAFAAKMZBQAAAAAgCmWVF5pbVvpwvW/wD/eQFvJSFhum9d1rYqgvPiqyQocKQCwkrRupv/1Tq7N1Nn8iTyvkojK41oaa7P/Lp2XO5WU1arqABJ+AD4lJN8X3z8ms1WR6IfGhpIEGBwcBAAAAIBkjAEAAAAKQWSIbRSkC5Yo7GfL8PUgai9MUiu+Wu+fZa6A6krK57SOokjYwgRbUzykxqwrOUxt+4qHPPK9kB4jfR8Zj138FnaEonDBAgCeJSTS1Wt4Okl3R/Pwo9/LAhtM5tujIRanz86tLDVLSw3quq5ftmLSr/ec5xQxApQAwQ1JMgAo3PEifL3T7px8vHfa0//z/n2KruS6tVJ83OT8//yQgTxmBRJChFkErrE7YiDMmrX991/sHdQGCsD/ydg7KID/EQcOCvfff/8dSw+TyUQbct+Px5MPRyfYkc6dO2cyrIDGqXc/61lnBOIoPOjceceOkQy45Xc/61lnrfQcF4MdO92s88gA+f7+4Z8PHz5I6Mmdb380cxnAuTcfPhybhF3ud9Za9/5zonbbns6aNX+Y7fbteeuggzL8+2+kTcBvAL5jA/a32/Cto6DIpnE+vrNrLBxHdu0aqZPnzqYlDkdGrn9gT4xxePO2sTgy1e8PtfMXc35+HgPhDnzHOP98fH/4wVzJy/n5/WEMrpyffmgjOApg0RoMNaPv0vFD7GbhtGsmhQt7P+2dmNSY1m1BfSkbWuanh21ZG+7/Yo3VVkFprB1Ph8Ph8PBnffXfMh+Pxw/Xw8GggPbtKg5vbbX/v6fn59Pj4yfivl3wl//zGgTc8n/e6K/h/Z/n5+FNt+S6+VNnrtC5BGOt3f7w41neDoewkHU4hBjv3nvXRxWAevv3f/Nlt3dnfefcdOrn21PPnNlEMpVSJqN7bhmjlPufOXNFbcu61qPdH/jB7/jMmU89c7opdn/g7/l73nGvLAZb7n/qS7/72W1ouOeWvcaMjo5mFXP8hS996dkrdJBpOnrT22+1VxaX+0+fXlqq61rnw5vefqu9stjUdV0vnT79v/my2x9+fO/dqXPI7f5Tz5xuWp6Ojo6Ojo6mCq7D2/35QxHMTae306m9ycLCgqjs0RXYoV1Y0Mapww/n29cBDg4=',
-    '#': 'data:audio/ogg;base64,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',
-};
+    '#': 'data:audio/ogg;base64,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'
+});
 
-var DialerPadSoundsMPEG = {
+/* export default */ var DialerPadSoundsMPEG = ({
     '0': 'data:audio/mpeg;base64,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',
     '1': 'data:audio/mpeg;base64,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',
     '2': 'data:audio/mpeg;base64,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',
@@ -298,16 +529,39 @@ var DialerPadSoundsMPEG = {
     '8': 'data:audio/mpeg;base64,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',
     '9': 'data:audio/mpeg;base64,SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU5LjI3LjEwMAAAAAAAAAAAAAAA//tAwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAAHAAAIwQBoaGhoaGhoaGhoaGhoaICAgICAgICAgICAgICAlJSUlJSUlJSUlJSUlJS+vr6+vr6+vr6+vr6+vr7o6Ojo6Ojo6Ojo6Ojo6PT09PT09PT09PT09PT0//////////////////8AAAAATGF2YzU5LjM3AAAAAAAAAAAAAAAAJAPpAAAAAAAACMFobdQOAAAAAAD/+8DEAAAKSEEwdPwAKfgMqT895ggAuXcDMN+r39mBDHCpPwbYGcWNTC2GIHGZjGYhaBOiBJW7bvxexhhhYAAAPDw9+AB//mHn/r8AAADw9/4AAB/v//DAAAABAeHn/rAAAAAPDw9+gsAAAEAAA1g/KAgAAAAAAAuAKYAodLLjAiBFmSoAQZG4tJk/L2jwCJgOBQFQBkxAwIDZXEBMXcwEwCQBjAYA0HhZTCTBBO4OJMxsQnTBYBeh0wdRby2xgbAENRVrMBMBNIZAEYAQAeW1XwmHaVFZtdeXOw/5IxJ+qF/fhIOlVcAAAAAeAAAACABSyMsS+LnGAmAUYHQHxg/AmiABwwFgSzFOQVOxgngxABAzCEBrMI4IkwcgrzEmBwMVwA0w7FUzgxYKMk0TIw8wsgEFEKAAmAkAqiwoE4sSntw7uxnYvArvhgAA8ABeUYEBCGgAkRnCxAY6zHJxZKUG0jZg/glYaCcDAmCpAEwsBnGAYAD5gE4EQYFABdmCCAbJhAgXuaGMIAGEaARpgUoB0coyaUIDjKETNIAiNNjFIann1lEO8f9xMCABQAAAamEAGmOdzyxzCCTWE2xIkgpMEWQ5YazCAQVXf5vBIjmJwACWUZMlZIDlsg8PKaFI5H0uYAAAAB9wDHAAUIQkAtQgo6FTJ4fOojoy8PTMDLMN2Xo2vTRTCBCmMCAE8GgkAEJUwZgxjADBoMaESs/QR7jHvAHFhCRYG4eAxKADk4GDvvMXf+kq09eMa//1hhh3CxgRXXWFAAAAAAu4AAAMIhQwgIQuEAIKRUDAQcmP1ScvcRnZBm5HCYXiQ9Gu4hdZj0hEGEkBmGAdGCiCEZHQHplbC7mR5HSelmHBjyDMmFCFYYJgLpgXgYGAkAuAQBF4yJqMWzvNXWi1eDXRLzwuAEcHqYothqCCB5UT78DtJUnJX2UM5//5CyHFshhbaNtP//9MAAD/yIABgAgAQf/7UMT6gUxASx297wAhdwmjPb/pHIAEAGMUMAHAGTAGQDUwHUB5MCQAzzBKgRgwUAHYMK9CCzDYyE83OEVyML5CuTBRwJ8wPMDzMBTAHTDBwgUw68RPMgUKQjbgjmkwVUFbMFlAQTAmAHYwEQBEBQD4YAyALoXrAoD2sRJBwuayJocOEQAMEAIjFhgACBAA2YAmAEhwBAMAAgOAMAqAJAYAgMAUADo6IQBsEgBI6AAFlA4AVKgAQEAAiYixH4vZ14bciHKrt09PT36kbp7f4Yb/+0DE+ABHPD03zPGI4YqMY32eeI0YbwwsYYf9azhqgt515qcwzlHP+nwwqbBB4WmvZ1P1f///Z6ExZRhAAAAAAEFHN7tIkgAAAAAAA4YCQbJhbBpmWMMiYDAE4NBCMMITw3MimDEyJZNOF/AwDQHjAkArNQUBEwD0rTPTC4MUQmYKhNGIGKEdnZf4GI7MuoBoxOwlzA/C6MLcFYwPQZTBOAyAQEBgqgiBgIIKAdMBkB9uLOl6GP/7gMT6ARG0cRPuf8gjq5th9r/wBA0BgYBwBwOBAMBwBEu0EABMWBIASyVSpimAeAWAgA1vqkXapQsEAQDC/peFwnCZ1QyaKN61ySQO97EYlA2daax/uX8m9VfsUliVVaWlETeD+CAwGgVO/LvlDh8RBUFdn93QWJdjvEGJgAr97GAA3rjTr5KxNoCRAIgJkSxGQAxDCSaSmt1/k3gBcuQzhumYhrLCkV6qP5ubi9n+5uCbhRmpX7cFuEsWZYsHD5au9tPis8WW27PdZxbV30fUeECUzb92ubWy6FgubasAAY7x5nZzQZMlRZQWGDihRCWYIylFtMNAk9VBQoxyYUNV072KpjSUUNDWZ5gBWUAiREjnqqS06tytZI1LbEFBvGgoThE/mCzLFUxBTUUzLjEwMFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVM//uAxOmAG/SzHfnvAAF7kuM/sPAFQU1FMy4xMDBVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVX/+xDE9gDJFH8VrDzLaB2EoJQAiM1VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVf/7EMTWA8AAAaQAAAAgAAA0gAAABFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV',
     '#': 'data:audio/mpeg;base64,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',
-    '*': 'data:audio/mpeg;base64,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',
-};
+    '*': 'data:audio/mpeg;base64,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'
+});
+
+
+
+
+
+
 
-function getDialPadValueOnlyRegex() {
+
+
+
+
+
+
+
+// ! alway new Regex for regex will have index issue
+// https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/RegExp
+/**
+ * return regex with only allow dialPad value `1234567890*+#-`
+ */ function getDialPadValueOnlyRegex() {
     return /[1234567890*+#]+/g;
 }
 
-const useFixedEndSelection = () => {
+
+
+
+
+/**
+ * bind with ref, let input can always focus at end of latest character
+ */ const useFixedEndSelection = ()=>{
     const ref = useRef(null);
-    const keypadModeFixedAtLatest = useEventCallback(() => {
+    const keypadModeFixedAtLatest = useEventCallback(()=>{
         const { position, isSelectRange } = getSelectionPosition(ref);
         const value = ref.current?.value || '';
         if (isSelectRange || position.start < value.length) {
@@ -315,11 +569,11 @@ const useFixedEndSelection = () => {
             setSelectionPosition(ref, {
                 start: targetPosition,
                 end: targetPosition,
-                scrollIntoView: true,
+                scrollIntoView: true
             });
         }
     });
-    const onKeyDown = (e) => {
+    const onKeyDown = (e)=>{
         if ([
             'ArrowUp',
             'ArrowLeft',
@@ -328,7 +582,7 @@ const useFixedEndSelection = () => {
             'PageUp',
             'PageDown',
             'Home',
-            'End',
+            'End'
         ].includes(e.key)) {
             e.preventDefault();
             e.stopPropagation();
@@ -339,97 +593,123 @@ const useFixedEndSelection = () => {
         ref,
         onFocus: keypadModeFixedAtLatest,
         onClick: keypadModeFixedAtLatest,
-        onKeyDown,
+        onKeyDown
     };
 };
 
-const DialTextField = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'DialTextField' });
-    const { value, onChange, onEmit, onKeyDown, onKeyUp, inputRef: inputRefProp, inputProps: inputPropsProp, keypadMode, onlyAllowKeypadValue = keypadMode, externalWindow = window, ...rest } = props;
+
+
+
+
+
+
+
+
+
+
+
+const DialTextField = /*#__PURE__*/ forwardRef((inProps, ref)=>{
+    const props = useThemeProps({
+        props: inProps,
+        name: 'DialTextField'
+    });
+    const { value, onChange, onEmit, onKeyDown, onKeyUp, inputRef: inputRefProp, inputProps: inputPropsProp, keypadMode, onlyAllowKeypadValue = keypadMode, externalWindow = window, // textVariant = 'headline1',
+    ...rest } = props;
     const dialerContext = useDialerContext();
-    const playAudio = (key) => {
+    const playAudio = (key)=>{
         dialerContext.dialPadActionRef?.current?.playAudio(key);
     };
-    const { ref: inputRef, onFocus: onKeypadModeFocus, onKeyDown: onKeypadModeKeyDown, onClick: onKeypadModeClick, } = useFixedEndSelection();
+    const { ref: inputRef, onFocus: onKeypadModeFocus, onKeyDown: onKeypadModeKeyDown, onClick: onKeypadModeClick } = useFixedEndSelection();
     const forkContextRef = useForkRef(dialerContext.inputRef, inputRef);
     const forkInputRef = useForkRef(inputRefProp, forkContextRef);
     const scrollToPositionRef = useRef();
     const isNotTriggerRefocusRef = useRef(false);
-    const maxLength = keypadMode
-        ? undefined
-        : (inputPropsProp?.maxLength ?? 30);
-    const checkNotReFocus = useEventCallback((reason, isFocus) => {
+    const maxLength = keypadMode ? undefined : inputPropsProp?.maxLength ?? 30;
+    const checkNotReFocus = useEventCallback((reason, isFocus)=>{
         const elm = inputRef.current;
         const isInputFocus = isFocus ?? externalWindow.document.activeElement === elm;
         if (reason !== 'click' && !isInputFocus) {
+            // ! both keydown and touch, only when focus need re-focus
             isNotTriggerRefocusRef.current = true;
         }
     });
-    useImperativeHandle(dialerContext.onClearRef, () => (e, reason) => {
-        if (reason !== 'keyboard') {
-            checkNotReFocus(reason);
-        }
-        scrollToPositionRef.current = 0;
-        onChange?.('');
-    }, [checkNotReFocus, onChange]);
-    useImperativeHandle(dialerContext.onDeleteRef, () => (e, reason) => {
-        const elm = inputRef.current;
-        if (elm && value?.length) {
-            const isFocus = externalWindow.document.activeElement === elm;
-            let toPosition;
-            let toValue;
-            if (isFocus) {
-                const { position, isSelectRange } = getSelectionPosition(inputRef);
-                if (isSelectRange) {
-                    toPosition = position.start;
-                    toValue =
-                        value.slice(0, position.start) + value.slice(position.end);
+    /**
+     * outside clear via this method, with check current input state
+     */ useImperativeHandle(dialerContext.onClearRef, ()=>(e, reason)=>{
+            // * when clear from keyboard,
+            // * must need re-focus, so not check,
+            if (reason !== 'keyboard') {
+                checkNotReFocus(reason);
+            }
+            scrollToPositionRef.current = 0;
+            onChange?.('');
+        }, [
+        checkNotReFocus,
+        onChange
+    ]);
+    /**
+     * outside delete value via this method, with check current input state
+     */ useImperativeHandle(dialerContext.onDeleteRef, ()=>(e, reason)=>{
+            const elm = inputRef.current;
+            if (elm && value?.length) {
+                const isFocus = externalWindow.document.activeElement === elm;
+                let toPosition;
+                let toValue;
+                if (isFocus) {
+                    const { position, isSelectRange } = getSelectionPosition(inputRef);
+                    if (isSelectRange) {
+                        toPosition = position.start;
+                        toValue = value.slice(0, position.start) + value.slice(position.end);
+                    } else if (position.start > 0) {
+                        toPosition = position.start - 1;
+                        toValue = value.slice(0, toPosition) + value.slice(position.end);
+                    }
+                } else {
+                    toPosition = value.length - 1;
+                    toValue = value.slice(0, -1);
                 }
-                else if (position.start > 0) {
-                    toPosition = position.start - 1;
-                    toValue = value.slice(0, toPosition) + value.slice(position.end);
+                if (toValue !== undefined) {
+                    // * when delete from keyboard and value to be empty,
+                    // * must need re-focus, so not check,
+                    if (!(reason === 'keyboard' && toValue === '')) {
+                        checkNotReFocus(reason);
+                    }
+                    scrollToPositionRef.current = toPosition;
+                    onChange?.(toValue);
                 }
             }
-            else {
-                toPosition = value.length - 1;
-                toValue = value.slice(0, -1);
-            }
-            if (toValue !== undefined) {
-                if (!(reason === 'keyboard' && toValue === '')) {
-                    checkNotReFocus(reason);
+        }, [
+        checkNotReFocus,
+        externalWindow,
+        inputRef,
+        onChange,
+        value
+    ]);
+    /**
+     * outside change value via this method, with check current input state
+     */ useImperativeHandle(dialerContext.onInsertRef, ()=>(addValue, reason)=>{
+            const elm = inputRef.current;
+            if (elm) {
+                const isFocus = externalWindow.document.activeElement === elm;
+                let toPosition;
+                let toValue;
+                // * when keypadMode also add value at latest
+                if (!isFocus || keypadMode) {
+                    toValue = value + addValue;
+                    toPosition = toValue.length;
+                } else {
+                    const { position } = getSelectionPosition(inputRef);
+                    toValue = value.slice(0, position.start) + addValue + value.slice(position.end);
+                    toPosition = position.start + 1;
+                }
+                if (maxLength === undefined || maxLength !== undefined && toValue.length <= maxLength) {
+                    checkNotReFocus(reason, isFocus);
+                    scrollToPositionRef.current = toPosition;
+                    onChange?.(toValue);
+                    onEmit?.(addValue, reason);
                 }
-                scrollToPositionRef.current = toPosition;
-                onChange?.(toValue);
-            }
-        }
-    }, [checkNotReFocus, externalWindow, inputRef, onChange, value]);
-    useImperativeHandle(dialerContext.onInsertRef, () => (addValue, reason) => {
-        const elm = inputRef.current;
-        if (elm) {
-            const isFocus = externalWindow.document.activeElement === elm;
-            let toPosition;
-            let toValue;
-            if (!isFocus || keypadMode) {
-                toValue = value + addValue;
-                toPosition = toValue.length;
-            }
-            else {
-                const { position } = getSelectionPosition(inputRef);
-                toValue =
-                    value.slice(0, position.start) +
-                        addValue +
-                        value.slice(position.end);
-                toPosition = position.start + 1;
-            }
-            if (maxLength === undefined ||
-                (maxLength !== undefined && toValue.length <= maxLength)) {
-                checkNotReFocus(reason, isFocus);
-                scrollToPositionRef.current = toPosition;
-                onChange?.(toValue);
-                onEmit?.(addValue, reason);
             }
-        }
-    }, [
+        }, [
         checkNotReFocus,
         externalWindow,
         inputRef,
@@ -437,25 +717,28 @@ const DialTextField = forwardRef((inProps, ref) => {
         maxLength,
         onChange,
         onEmit,
-        value,
+        value
     ]);
-    useLayoutEffect(() => {
+    useLayoutEffect(()=>{
         const scrollToPosition = scrollToPositionRef.current;
         if (!isNotTriggerRefocusRef.current && scrollToPosition !== undefined) {
             setSelectionPosition(inputRef, {
                 start: scrollToPosition,
                 end: scrollToPosition,
-                scrollIntoView: true,
+                scrollIntoView: true
             });
         }
         scrollToPositionRef.current = undefined;
         isNotTriggerRefocusRef.current = false;
     });
     const events = useKeyDownOnce(ACCEPTABLE_KEYS, {
-        onKeyDown: (e) => {
+        onKeyDown: (e)=>{
             playAudio(e.key);
             if (keypadMode) {
-                if (['Delete', 'Backspace'].includes(e.key)) {
+                if ([
+                    'Delete',
+                    'Backspace'
+                ].includes(e.key)) {
                     e.preventDefault();
                     e.stopPropagation();
                 }
@@ -463,33 +746,31 @@ const DialTextField = forwardRef((inProps, ref) => {
             }
             onKeyDown?.(e);
         },
-        onKeyUp,
+        onKeyUp
     });
     const { sleep } = useSleep();
-    const handleChange = useEventCallback((e) => {
+    const handleChange = useEventCallback((e)=>{
         const currValue = e.target.value;
+        // * handle copy paste
         if (onlyAllowKeypadValue) {
             const filterValue = (currValue.match(getDialPadValueOnlyRegex()) || []).join('');
-            if (filterValue === value)
-                return;
+            if (filterValue === value) return;
             if (onEmit) {
                 const emitValues = filterValue.replace(value, '');
                 const valueArr = emitValues.split('');
                 if (valueArr.length > 1) {
-                    (async () => {
-                        for (let i = 0; i < valueArr.length; i++) {
+                    (async ()=>{
+                        for(let i = 0; i < valueArr.length; i++){
                             playAudio(valueArr[i]);
                             onChange(value + valueArr.slice(0, i + 1).join(''));
                             if (i !== valueArr.length - 1) {
                                 await sleep(300);
-                            }
-                            else {
+                            } else {
                                 onEmit(emitValues, 'keyboard');
                             }
                         }
                     })();
-                }
-                else {
+                } else {
                     playAudio(valueArr[0]);
                     onChange(filterValue);
                     onEmit(emitValues, 'keyboard');
@@ -501,7 +782,7 @@ const DialTextField = forwardRef((inProps, ref) => {
         }
         onChange(currValue);
     });
-    const handleKeyPress = useEventCallback((e) => {
+    const handleKeyPress = useEventCallback((e)=>{
         inputPropsProp?.onKeyPress?.(e);
         if (onlyAllowKeypadValue) {
             const isMatch = getDialPadValueOnlyRegex().test(e.key);
@@ -511,16 +792,17 @@ const DialTextField = forwardRef((inProps, ref) => {
             }
         }
     });
-    const inputProps = useMemo(() => combineProps({
-        onFocus: keypadMode ? onKeypadModeFocus : undefined,
-        onClick: keypadMode ? onKeypadModeClick : undefined,
-        onKeyPress: handleKeyPress,
-        onChange: handleChange,
-        onKeyDown: events.onKeyDown,
-        onKeyUp: events.onKeyUp,
-        maxLength,
-        autoComplete: 'off',
-    }, inputPropsProp), [
+    const inputProps = useMemo(()=>combineProps({
+            onFocus: keypadMode ? onKeypadModeFocus : undefined,
+            onClick: keypadMode ? onKeypadModeClick : undefined,
+            onKeyPress: handleKeyPress,
+            onChange: handleChange,
+            onKeyDown: events.onKeyDown,
+            onKeyUp: events.onKeyUp,
+            maxLength,
+            // in dialer not need autoComplete
+            autoComplete: 'off'
+        }, inputPropsProp), [
         keypadMode,
         onKeypadModeFocus,
         onKeypadModeClick,
@@ -529,26 +811,55 @@ const DialTextField = forwardRef((inProps, ref) => {
         events.onKeyDown,
         events.onKeyUp,
         maxLength,
-        inputPropsProp,
+        inputPropsProp
     ]);
-    return (jsx(TextField, { ref: ref, inputRef: forkInputRef, clearBtn: false, inputProps: inputProps, value: value, variant: "quiet", onChange: handleChange, ...rest }));
+    return /*#__PURE__*/ jsx(TextField_TextField, {
+        ref: ref,
+        inputRef: forkInputRef,
+        clearBtn: false,
+        inputProps: inputProps,
+        value: value,
+        variant: "quiet",
+        onChange: handleChange,
+        ...rest
+    });
 });
 DialTextField.displayName = 'SuiDialTextField';
 
-const Dialer = ({ children }) => {
+
+
+
+
+
+
+
+
+
+const Dialer = ({ children })=>{
     const dialPadActionRef = useRef(null);
     const onInsertRef = useRef(null);
     const inputRef = useRef(null);
     const onDeleteRef = useRef(null);
     const onClearRef = useRef(null);
-    return (jsx(DialerContext.Provider, { value: {
+    return /*#__PURE__*/ jsx(DialerContext.Provider, {
+        value: {
             dialPadActionRef,
             onInsertRef,
             onDeleteRef,
             inputRef,
-            onClearRef,
-        }, children: children }));
+            onClearRef
+        },
+        children: children
+    });
 };
 Dialer.displayName = 'SuiDialer';
 
-export { ACCEPTABLE_KEYS, DIALER_PAD_ICONS, DIALER_PAD_PLUS, DialDelete, DialPad, DialPadButton, DialTextField, Dialer, DialerContext, DialerPadSoundsMPEG, DialerPadSoundsOGG, DialPadButton$1 as dialPadButtonStyle, DialPad$1 as dialPadStyle, getDialPadValueOnlyRegex, useDialKeyboard, useDialerContext, useFixedEndSelection, useKeyAudio };
+
+
+
+
+
+
+
+
+export { ACCEPTABLE_KEYS, DIALER_PAD_ICONS, DIALER_PAD_PLUS, DialDelete, DialPad as dialPadStyle, DialPadButton as dialPadButtonStyle, DialPadButton_DialPadButton as DialPadButton, DialPad_DialPad as DialPad, DialTextField, Dialer, DialerContext, DialerPadSoundsMPEG, DialerPadSoundsOGG, getDialPadValueOnlyRegex, useDialKeyboard, useDialerContext, useFixedEndSelection, useKeyAudio };