@wix/site-ui 1.30.0 → 1.31.0

package/dist/3056.js

@@ -0,0 +1,229 @@
+import { Timeout, useTimeout } from "./42.js";
+import { useRefWithInit } from "./8272.js";
+import { useOnMount } from "./2861.js";
+import { isMouseLikePointerType } from "./6330.js";
+import { useFloatingTree, useFloatingParentNodeId } from "./285.js";
+import { useStableCallback } from "./7541.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import { isElement } from "./3829.js";
+import { ownerDocument } from "./9829.js";
+import { getNodeChildren } from "./5992.js";
+import { createChangeEventDetails } from "./4768.js";
+import { triggerHover } from "./2418.js";
+import { getTarget, contains } from "./4549.js";
+import { isTargetInsideEnabledTrigger, isInteractiveElement } from "./8758.js";
+import { mergeCleanups } from "./4495.js";
+import { addEventListener } from "./4723.js";
+import * as __rspack_external_react from "react";
+class HoverInteraction {
+    constructor(){
+        this.pointerType = void 0;
+        this.interactedInside = false;
+        this.handler = void 0;
+        this.blockMouseMove = true;
+        this.performedPointerEventsMutation = false;
+        this.pointerEventsScopeElement = null;
+        this.pointerEventsReferenceElement = null;
+        this.pointerEventsFloatingElement = null;
+        this.restTimeoutPending = false;
+        this.openChangeTimeout = new Timeout();
+        this.restTimeout = new Timeout();
+        this.handleCloseOptions = void 0;
+    }
+    static create() {
+        return new HoverInteraction();
+    }
+    dispose = ()=>{
+        this.openChangeTimeout.clear();
+        this.restTimeout.clear();
+    };
+    disposeEffect = ()=>this.dispose;
+}
+const pointerEventsMutationOwnerByScopeElement = new WeakMap();
+function clearSafePolygonPointerEventsMutation(instance) {
+    if (!instance.performedPointerEventsMutation) return;
+    const scopeElement = instance.pointerEventsScopeElement;
+    if (scopeElement && pointerEventsMutationOwnerByScopeElement.get(scopeElement) === instance) {
+        instance.pointerEventsScopeElement?.style.removeProperty('pointer-events');
+        instance.pointerEventsReferenceElement?.style.removeProperty('pointer-events');
+        instance.pointerEventsFloatingElement?.style.removeProperty('pointer-events');
+        pointerEventsMutationOwnerByScopeElement.delete(scopeElement);
+    }
+    instance.performedPointerEventsMutation = false;
+    instance.pointerEventsScopeElement = null;
+    instance.pointerEventsReferenceElement = null;
+    instance.pointerEventsFloatingElement = null;
+}
+function applySafePolygonPointerEventsMutation(instance, options) {
+    const { scopeElement, referenceElement, floatingElement } = options;
+    const existingOwner = pointerEventsMutationOwnerByScopeElement.get(scopeElement);
+    if (existingOwner && existingOwner !== instance) clearSafePolygonPointerEventsMutation(existingOwner);
+    clearSafePolygonPointerEventsMutation(instance);
+    instance.performedPointerEventsMutation = true;
+    instance.pointerEventsScopeElement = scopeElement;
+    instance.pointerEventsReferenceElement = referenceElement;
+    instance.pointerEventsFloatingElement = floatingElement;
+    pointerEventsMutationOwnerByScopeElement.set(scopeElement, instance);
+    scopeElement.style.pointerEvents = 'none';
+    referenceElement.style.pointerEvents = 'auto';
+    floatingElement.style.pointerEvents = 'auto';
+}
+function useHoverInteractionSharedState(store) {
+    const data = store.context.dataRef.current;
+    const instance = useRefWithInit(()=>data.hoverInteractionState ?? HoverInteraction.create()).current;
+    if (!data.hoverInteractionState) data.hoverInteractionState = instance;
+    useOnMount(data.hoverInteractionState.disposeEffect);
+    return data.hoverInteractionState;
+}
+function resolveValue(value, pointerType) {
+    if (null != pointerType && !isMouseLikePointerType(pointerType)) return 0;
+    if ('function' == typeof value) return value();
+    return value;
+}
+function getDelay(value, prop, pointerType) {
+    const result = resolveValue(value, pointerType);
+    if ('number' == typeof result) return result;
+    return result?.[prop];
+}
+function getRestMs(value) {
+    if ('function' == typeof value) return value();
+    return value;
+}
+function useHoverShared_isClickLikeOpenEvent(openEventType, interactedInside) {
+    return interactedInside || 'click' === openEventType || 'mousedown' === openEventType;
+}
+function isHoverOpenEvent(openEventType) {
+    return openEventType?.includes('mouse') && 'mousedown' !== openEventType;
+}
+function useHoverFloatingInteraction(context, parameters = {}) {
+    const { enabled = true, closeDelay: closeDelayProp = 0, nodeId: nodeIdProp } = parameters;
+    const store = 'rootStore' in context ? context.rootStore : context;
+    const open = store.useState('open');
+    const floatingElement = store.useState('floatingElement');
+    const domReferenceElement = store.useState('domReferenceElement');
+    const { dataRef } = store.context;
+    const tree = useFloatingTree();
+    const parentId = useFloatingParentNodeId();
+    const instance = useHoverInteractionSharedState(store);
+    const childClosedTimeout = useTimeout();
+    const isClickLikeOpenEvent = useStableCallback(()=>useHoverShared_isClickLikeOpenEvent(dataRef.current.openEvent?.type, instance.interactedInside));
+    const isHoverOpen = useStableCallback(()=>isHoverOpenEvent(dataRef.current.openEvent?.type));
+    const clearPointerEvents = useStableCallback(()=>{
+        clearSafePolygonPointerEventsMutation(instance);
+    });
+    useIsoLayoutEffect(()=>{
+        if (!open) {
+            instance.pointerType = void 0;
+            instance.restTimeoutPending = false;
+            instance.interactedInside = false;
+            clearPointerEvents();
+        }
+    }, [
+        open,
+        instance,
+        clearPointerEvents
+    ]);
+    __rspack_external_react.useEffect(()=>clearPointerEvents, [
+        clearPointerEvents
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!enabled) return;
+        if (open && instance.handleCloseOptions?.blockPointerEvents && isHoverOpen() && isElement(domReferenceElement) && floatingElement) {
+            const ref = domReferenceElement;
+            const floatingEl = floatingElement;
+            const doc = ownerDocument(floatingElement);
+            const parentFloating = tree?.nodesRef.current.find((node)=>node.id === parentId)?.context?.elements.floating;
+            if (parentFloating) parentFloating.style.pointerEvents = '';
+            const cachedScopeElement = instance.pointerEventsScopeElement !== floatingEl ? instance.pointerEventsScopeElement : null;
+            const parentScopeElement = parentFloating !== floatingEl ? parentFloating : null;
+            const scopeElement = instance.handleCloseOptions?.getScope?.() ?? cachedScopeElement ?? parentScopeElement ?? ref.closest('[data-rootownerid]') ?? doc.body;
+            applySafePolygonPointerEventsMutation(instance, {
+                scopeElement,
+                referenceElement: ref,
+                floatingElement: floatingEl
+            });
+            return ()=>{
+                clearPointerEvents();
+            };
+        }
+    }, [
+        enabled,
+        open,
+        domReferenceElement,
+        floatingElement,
+        instance,
+        isHoverOpen,
+        tree,
+        parentId,
+        clearPointerEvents
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!enabled) return;
+        function hasParentChildren() {
+            return !!(tree && parentId && getNodeChildren(tree.nodesRef.current, parentId).length > 0);
+        }
+        function closeWithDelay(event) {
+            const closeDelay = getDelay(closeDelayProp, 'close', instance.pointerType);
+            const close = ()=>{
+                store.setOpen(false, createChangeEventDetails(triggerHover, event));
+                tree?.events.emit('floating.closed', event);
+            };
+            if (closeDelay) instance.openChangeTimeout.start(closeDelay, close);
+            else {
+                instance.openChangeTimeout.clear();
+                close();
+            }
+        }
+        function handleInteractInside(event) {
+            const target = getTarget(event);
+            if (!isInteractiveElement(target)) {
+                instance.interactedInside = false;
+                return;
+            }
+            instance.interactedInside = target?.closest('[aria-haspopup]') != null;
+        }
+        function onFloatingMouseEnter() {
+            instance.openChangeTimeout.clear();
+            childClosedTimeout.clear();
+            tree?.events.off('floating.closed', onNodeClosed);
+            clearPointerEvents();
+        }
+        function onFloatingMouseLeave(event) {
+            if (hasParentChildren() && tree) return void tree.events.on('floating.closed', onNodeClosed);
+            if (isTargetInsideEnabledTrigger(event.relatedTarget, store.context.triggerElements)) return;
+            const currentNodeId = dataRef.current.floatingContext?.nodeId ?? nodeIdProp;
+            const relatedTarget = event.relatedTarget;
+            const isMovingIntoDescendantFloating = tree && currentNodeId && isElement(relatedTarget) && getNodeChildren(tree.nodesRef.current, currentNodeId, false).some((node)=>contains(node.context?.elements.floating, relatedTarget));
+            if (isMovingIntoDescendantFloating) return;
+            if (instance.handler) return void instance.handler(event);
+            clearPointerEvents();
+            if (!isClickLikeOpenEvent()) closeWithDelay(event);
+        }
+        function onNodeClosed(event) {
+            if (!tree || !parentId || hasParentChildren()) return;
+            childClosedTimeout.start(0, ()=>{
+                tree.events.off('floating.closed', onNodeClosed);
+                store.setOpen(false, createChangeEventDetails(triggerHover, event));
+                tree.events.emit('floating.closed', event);
+            });
+        }
+        const floating = floatingElement;
+        return mergeCleanups(floating && addEventListener(floating, 'mouseenter', onFloatingMouseEnter), floating && addEventListener(floating, 'mouseleave', onFloatingMouseLeave), floating && addEventListener(floating, 'pointerdown', handleInteractInside, true), ()=>{
+            tree?.events.off('floating.closed', onNodeClosed);
+        });
+    }, [
+        enabled,
+        floatingElement,
+        store,
+        dataRef,
+        closeDelayProp,
+        nodeIdProp,
+        isClickLikeOpenEvent,
+        clearPointerEvents,
+        instance,
+        tree,
+        parentId,
+        childClosedTimeout
+    ]);
+}
+export { applySafePolygonPointerEventsMutation, clearSafePolygonPointerEventsMutation, getDelay, getRestMs, useHoverFloatingInteraction, useHoverInteractionSharedState, useHoverShared_isClickLikeOpenEvent };

package/dist/3140.js

@@ -0,0 +1,4 @@
+function isElementDisabled(element) {
+    return null == element || element.hasAttribute('disabled') || 'true' === element.getAttribute('aria-disabled');
+}
+export { isElementDisabled };

package/dist/3248.js

@@ -0,0 +1,307 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useLabelableContext, fieldValidityMapping, useFieldRootContext } from "./1477.js";
+import { NOOP, useRefWithInit, EMPTY_OBJECT, mergeProps, useMergedRefs, useRenderElement, esm_formatErrorMessage } from "./8272.js";
+import { useFormContext } from "./5085.js";
+import { useFieldItemContext } from "./1457.js";
+import { useCheckboxGroupContext } from "./8979.js";
+import { useBaseUiId } from "./6046.js";
+import { useButton } from "./9189.js";
+import { useControlled } from "./8527.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import { useRegisterFieldControl } from "./4281.js";
+import { useAriaLabelledBy } from "./4490.js";
+import { useValueChanged } from "./2801.js";
+import { visuallyHiddenInput, visuallyHidden } from "./8225.js";
+import { createChangeEventDetails } from "./4768.js";
+import { getWindow } from "./3829.js";
+import * as __rspack_external_react from "react";
+function getDefaultFormSubmitter(form) {
+    if (!form) return null;
+    for (const candidate of form.elements){
+        const tagName = candidate.tagName;
+        if ('BUTTON' === tagName || 'INPUT' === tagName) {
+            const button = candidate;
+            if ('submit' === button.type) return button;
+        }
+    }
+    return null;
+}
+let CheckboxRootDataAttributes_CheckboxRootDataAttributes = /*#__PURE__*/ function(CheckboxRootDataAttributes) {
+    CheckboxRootDataAttributes["checked"] = "data-checked";
+    CheckboxRootDataAttributes["unchecked"] = "data-unchecked";
+    CheckboxRootDataAttributes["indeterminate"] = "data-indeterminate";
+    CheckboxRootDataAttributes["disabled"] = "data-disabled";
+    CheckboxRootDataAttributes["readonly"] = "data-readonly";
+    CheckboxRootDataAttributes["required"] = "data-required";
+    CheckboxRootDataAttributes["valid"] = "data-valid";
+    CheckboxRootDataAttributes["invalid"] = "data-invalid";
+    CheckboxRootDataAttributes["touched"] = "data-touched";
+    CheckboxRootDataAttributes["dirty"] = "data-dirty";
+    CheckboxRootDataAttributes["filled"] = "data-filled";
+    CheckboxRootDataAttributes["focused"] = "data-focused";
+    return CheckboxRootDataAttributes;
+}({});
+function useStateAttributesMapping(state) {
+    return __rspack_external_react.useMemo(()=>({
+            checked (value) {
+                if (state.indeterminate) return {};
+                if (value) return {
+                    [CheckboxRootDataAttributes_CheckboxRootDataAttributes.checked]: ''
+                };
+                return {
+                    [CheckboxRootDataAttributes_CheckboxRootDataAttributes.unchecked]: ''
+                };
+            },
+            ...fieldValidityMapping
+        }), [
+        state.indeterminate
+    ]);
+}
+const CheckboxRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) CheckboxRootContext.displayName = "CheckboxRootContext";
+function useCheckboxRootContext() {
+    const context = __rspack_external_react.useContext(CheckboxRootContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: CheckboxRootContext is missing. Checkbox parts must be placed within <Checkbox.Root>.' : esm_formatErrorMessage(14));
+    return context;
+}
+const PARENT_CHECKBOX = 'data-parent';
+const CheckboxRoot_CheckboxRoot = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { checked: checkedProp, className, defaultChecked = false, 'aria-labelledby': ariaLabelledByProp, disabled: disabledProp = false, form, id: idProp, indeterminate = false, inputRef: inputRefProp, name: nameProp, onCheckedChange, parent = false, readOnly = false, render, required = false, uncheckedValue, value: valueProp, nativeButton = false, style, ...elementProps } = componentProps;
+    const { clearErrors } = useFormContext();
+    const { disabled: rootDisabled, name: fieldName, setDirty, setFilled, setFocused, setTouched, state: fieldState, validationMode, validityData, shouldValidateOnChange, validation: localValidation } = useFieldRootContext();
+    const fieldItemContext = useFieldItemContext();
+    const { labelId, controlId, registerControlId, getDescriptionProps } = useLabelableContext();
+    const groupContext = useCheckboxGroupContext();
+    const parentContext = groupContext?.parent;
+    const isGroupedWithParent = parentContext && groupContext.allValues;
+    const disabled = rootDisabled || fieldItemContext.disabled || groupContext?.disabled || disabledProp;
+    const name = fieldName ?? nameProp;
+    const value = valueProp ?? name;
+    const id = useBaseUiId();
+    const parentId = useBaseUiId();
+    let inputId = controlId;
+    if (isGroupedWithParent) inputId = parent ? parentId : `${parentContext.id}-${value}`;
+    else if (idProp) inputId = idProp;
+    let groupProps = {};
+    if (isGroupedWithParent) {
+        if (parent) groupProps = groupContext.parent.getParentProps();
+        else if (value) groupProps = groupContext.parent.getChildProps(value);
+    }
+    const { checked: groupChecked = checkedProp, indeterminate: groupIndeterminate = indeterminate, onCheckedChange: groupOnChange, ...otherGroupProps } = groupProps;
+    const groupValue = groupContext?.value;
+    const setGroupValue = groupContext?.setValue;
+    const defaultGroupValue = groupContext?.defaultValue;
+    const controlRef = __rspack_external_react.useRef(null);
+    const controlSourceRef = useRefWithInit(()=>Symbol('checkbox-control'));
+    const hasRegisteredRef = __rspack_external_react.useRef(false);
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        native: nativeButton
+    });
+    const validation = groupContext?.validation ?? localValidation;
+    const [checked, setCheckedState] = useControlled({
+        controlled: value && groupValue && !parent ? groupValue.includes(value) : groupChecked,
+        default: value && defaultGroupValue && !parent ? defaultGroupValue.includes(value) : defaultChecked,
+        name: 'Checkbox',
+        state: 'checked'
+    });
+    useIsoLayoutEffect(()=>{
+        if (registerControlId === NOOP) return;
+        hasRegisteredRef.current = true;
+        registerControlId(controlSourceRef.current, inputId);
+    }, [
+        inputId,
+        registerControlId,
+        controlSourceRef
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        const controlSource = controlSourceRef.current;
+        return ()=>{
+            if (!hasRegisteredRef.current || registerControlId === NOOP) return;
+            hasRegisteredRef.current = false;
+            registerControlId(controlSource, void 0);
+        };
+    }, [
+        registerControlId,
+        controlSourceRef
+    ]);
+    useRegisterFieldControl(controlRef, id, checked, void 0, !groupContext);
+    const inputRef = __rspack_external_react.useRef(null);
+    const mergedInputRef = useMergedRefs(inputRefProp, inputRef, validation.inputRef);
+    const ariaLabelledBy = useAriaLabelledBy(ariaLabelledByProp, labelId, inputRef, !nativeButton, inputId ?? void 0);
+    useIsoLayoutEffect(()=>{
+        if (inputRef.current) {
+            inputRef.current.indeterminate = groupIndeterminate;
+            if (checked) setFilled(true);
+        }
+    }, [
+        checked,
+        groupIndeterminate,
+        setFilled
+    ]);
+    useValueChanged(checked, ()=>{
+        if (groupContext && !parent) return;
+        clearErrors(name);
+        setFilled(checked);
+        setDirty(checked !== validityData.initialValue);
+        if (shouldValidateOnChange()) validation.commit(checked);
+        else validation.commit(checked, true);
+    });
+    const inputProps = mergeProps({
+        checked,
+        disabled,
+        form,
+        name: parent ? void 0 : name,
+        id: nativeButton ? void 0 : inputId ?? void 0,
+        required,
+        ref: mergedInputRef,
+        style: name ? visuallyHiddenInput : visuallyHidden,
+        tabIndex: -1,
+        type: 'checkbox',
+        'aria-hidden': true,
+        onChange (event) {
+            if (event.nativeEvent.defaultPrevented) return;
+            if (readOnly) return void event.preventDefault();
+            const nextChecked = event.currentTarget.checked;
+            const details = createChangeEventDetails("none", event.nativeEvent);
+            groupOnChange?.(nextChecked, details);
+            onCheckedChange?.(nextChecked, details);
+            if (details.isCanceled) return;
+            setCheckedState(nextChecked);
+            if (value && groupValue && setGroupValue && !parent && !isGroupedWithParent) {
+                const nextGroupValue = nextChecked ? [
+                    ...groupValue,
+                    value
+                ] : groupValue.filter((item)=>item !== value);
+                setGroupValue(nextGroupValue, details);
+            }
+        },
+        onFocus () {
+            controlRef.current?.focus();
+        }
+    }, void 0 !== valueProp ? {
+        value: (groupContext ? checked && valueProp : valueProp) || ''
+    } : EMPTY_OBJECT, getDescriptionProps, groupContext ? validation.getValidationProps : validation.getInputValidationProps);
+    const computedChecked = isGroupedWithParent ? Boolean(groupChecked) : checked;
+    const computedIndeterminate = isGroupedWithParent ? groupIndeterminate || indeterminate : indeterminate;
+    __rspack_external_react.useEffect(()=>{
+        if (!parentContext || !value) return;
+        const disabledStates = parentContext.disabledStatesRef.current;
+        disabledStates.set(value, disabled);
+        return ()=>{
+            disabledStates.delete(value);
+        };
+    }, [
+        parentContext,
+        disabled,
+        value
+    ]);
+    const state = __rspack_external_react.useMemo(()=>({
+            ...fieldState,
+            checked: computedChecked,
+            disabled,
+            readOnly,
+            required,
+            indeterminate: computedIndeterminate
+        }), [
+        fieldState,
+        computedChecked,
+        disabled,
+        readOnly,
+        required,
+        computedIndeterminate
+    ]);
+    const stateAttributesMapping = useStateAttributesMapping(state);
+    const element = useRenderElement('span', componentProps, {
+        state,
+        ref: [
+            buttonRef,
+            controlRef,
+            forwardedRef,
+            groupContext?.registerControlRef
+        ],
+        props: [
+            {
+                id: nativeButton ? inputId ?? void 0 : id,
+                role: 'checkbox',
+                'aria-checked': groupIndeterminate ? 'mixed' : checked,
+                'aria-readonly': readOnly || void 0,
+                'aria-required': required || void 0,
+                'aria-labelledby': ariaLabelledBy,
+                [PARENT_CHECKBOX]: parent ? '' : void 0,
+                onFocus () {
+                    setFocused(true);
+                },
+                onBlur () {
+                    const inputEl = inputRef.current;
+                    if (!inputEl) return;
+                    setTouched(true);
+                    setFocused(false);
+                    if ('onBlur' === validationMode) validation.commit(groupContext ? groupValue : inputEl.checked);
+                },
+                onKeyDown (event) {
+                    if ('Enter' !== event.key) return;
+                    event.preventBaseUIHandler();
+                    if (event.defaultPrevented) return;
+                    const formToSubmit = inputRef.current?.form ?? null;
+                    const currentTarget = event.currentTarget;
+                    const nativeEvent = event.nativeEvent;
+                    const originalPreventDefault = event.preventDefault;
+                    const originalNativePreventDefault = nativeEvent.preventDefault;
+                    let preventDefaultCalledAfterPropagation = false;
+                    event.preventDefault = ()=>{
+                        preventDefaultCalledAfterPropagation = true;
+                        originalPreventDefault.call(event);
+                    };
+                    nativeEvent.preventDefault = ()=>{
+                        preventDefaultCalledAfterPropagation = true;
+                        originalNativePreventDefault.call(nativeEvent);
+                    };
+                    originalNativePreventDefault.call(nativeEvent);
+                    getWindow(currentTarget).queueMicrotask(()=>{
+                        event.preventDefault = originalPreventDefault;
+                        nativeEvent.preventDefault = originalNativePreventDefault;
+                        if (!preventDefaultCalledAfterPropagation) getDefaultFormSubmitter(formToSubmit)?.click();
+                    });
+                },
+                onClick (event) {
+                    if (readOnly || disabled) return;
+                    event.preventDefault();
+                    const input = inputRef.current;
+                    if (!input) return;
+                    input.dispatchEvent(new (getWindow(input)).PointerEvent('click', {
+                        bubbles: true,
+                        shiftKey: event.shiftKey,
+                        ctrlKey: event.ctrlKey,
+                        altKey: event.altKey,
+                        metaKey: event.metaKey
+                    }));
+                }
+            },
+            getDescriptionProps,
+            validation.getValidationProps,
+            elementProps,
+            otherGroupProps,
+            getButtonProps
+        ],
+        stateAttributesMapping
+    });
+    return /*#__PURE__*/ jsxs(CheckboxRootContext.Provider, {
+        value: state,
+        children: [
+            element,
+            !checked && !groupContext && name && !parent && void 0 !== uncheckedValue && /*#__PURE__*/ jsx("input", {
+                type: "hidden",
+                form: form,
+                name: name,
+                value: uncheckedValue
+            }),
+            /*#__PURE__*/ jsx("input", {
+                ...inputProps,
+                suppressHydrationWarning: true
+            })
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) CheckboxRoot_CheckboxRoot.displayName = "CheckboxRoot";
+export { CheckboxRoot_CheckboxRoot, PARENT_CHECKBOX, useCheckboxRootContext, useStateAttributesMapping };

package/dist/3296.js

@@ -0,0 +1,4 @@
+function clamp(val, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+    return Math.max(min, Math.min(val, max));
+}
+export { clamp };