useblocks 1.1.85-dev.1 → 1.1.85-dev.10

package/vendor/@rc-component/input/es/utils/commonUtils.js

@@ -0,0 +1,40 @@
+//#region node_modules/@rc-component/input/es/utils/commonUtils.js
+function hasAddon(props) {
+	return !!(props.addonBefore || props.addonAfter);
+}
+function hasPrefixSuffix(props) {
+	return !!(props.prefix || props.suffix || props.allowClear);
+}
+function cloneEvent(event, target, value) {
+	const currentTarget = target.cloneNode(true);
+	const newEvent = Object.create(event, {
+		target: { value: currentTarget },
+		currentTarget: { value: currentTarget }
+	});
+	currentTarget.value = value;
+	if (typeof target.selectionStart === "number" && typeof target.selectionEnd === "number") {
+		currentTarget.selectionStart = target.selectionStart;
+		currentTarget.selectionEnd = target.selectionEnd;
+	}
+	currentTarget.setSelectionRange = (...args) => {
+		target.setSelectionRange(...args);
+	};
+	return newEvent;
+}
+function resolveOnChange(target, e, onChange, targetValue) {
+	if (!onChange) return;
+	let event = e;
+	if (e.type === "click") {
+		event = cloneEvent(e, target, "");
+		onChange(event);
+		return;
+	}
+	if (target.type !== "file" && targetValue !== void 0) {
+		event = cloneEvent(e, target, targetValue);
+		onChange(event);
+		return;
+	}
+	onChange(event);
+}
+//#endregion
+export { hasAddon, hasPrefixSuffix, resolveOnChange };

package/vendor/@rc-component/input/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@rc-component/input",
+  "version": "1.1.2",
+  "license": "MIT",
+  "type": "module"
+}

package/vendor/@rc-component/input-number/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-present yiminghe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/vendor/@rc-component/input-number/es/InputNumber.js

@@ -0,0 +1,365 @@
+import useEvent from "../../util/es/hooks/useEvent.js";
+import { useLayoutUpdateEffect } from "../../util/es/hooks/useLayoutEffect.js";
+import { triggerFocus } from "../../util/es/Dom/focus.js";
+import proxyObject from "../../util/es/proxyObject.js";
+import "../../util/es/index.js";
+import { clsx } from "../../../clsx/dist/clsx.js";
+import { getNumberPrecision, num2str, validateNumber } from "../../mini-decimal/es/numberUtil.js";
+import { toFixed } from "../../mini-decimal/es/MiniDecimal.js";
+import es_default from "../../mini-decimal/es/index.js";
+import useCursor from "./hooks/useCursor.js";
+import StepHandler from "./StepHandler.js";
+import { getDecupleSteps } from "./utils/numberUtil.js";
+import useFrame_default from "./hooks/useFrame.js";
+import * as React$1 from "../../../react/index.js";
+//#region node_modules/@rc-component/input-number/es/InputNumber.js
+function _extends() {
+	_extends = Object.assign ? Object.assign.bind() : function(target) {
+		for (var i = 1; i < arguments.length; i++) {
+			var source = arguments[i];
+			for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+		}
+		return target;
+	};
+	return _extends.apply(this, arguments);
+}
+/**
+* We support `stringMode` which need handle correct type when user call in onChange
+* format max or min value
+* 1. if isInvalid return null
+* 2. if precision is undefined, return decimal
+* 3. format with precision
+*    I. if max > 0, round down with precision. Example: max= 3.5, precision=0  afterFormat: 3
+*    II. if max < 0, round up with precision. Example: max= -3.5, precision=0  afterFormat: -4
+*    III. if min > 0, round up with precision. Example: min= 3.5, precision=0  afterFormat: 4
+*    IV. if min < 0, round down with precision. Example: max= -3.5, precision=0  afterFormat: -3
+*/
+const getDecimalValue = (stringMode, decimalValue) => {
+	if (stringMode || decimalValue.isEmpty()) return decimalValue.toString();
+	return decimalValue.toNumber();
+};
+const getDecimalIfValidate = (value) => {
+	const decimal = es_default(value);
+	return decimal.isInvalidate() ? null : decimal;
+};
+const InputNumber = /*#__PURE__*/ React$1.forwardRef((props, ref) => {
+	const { mode = "input", prefixCls = "rc-input-number", className, style, classNames, styles, min, max, step = 1, defaultValue, value, disabled, readOnly, upHandler, downHandler, keyboard, changeOnWheel = false, controls = true, prefix, suffix, stringMode, parser, formatter, precision, decimalSeparator, onChange, onInput, onPressEnter, onStep, onMouseDown, onClick, onMouseUp, onMouseLeave, onMouseMove, onMouseEnter, onMouseOut, changeOnBlur = true, ...restProps } = props;
+	const [focus, setFocus] = React$1.useState(false);
+	const userTypingRef = React$1.useRef(false);
+	const compositionRef = React$1.useRef(false);
+	const shiftKeyRef = React$1.useRef(false);
+	const rootRef = React$1.useRef(null);
+	const inputRef = React$1.useRef(null);
+	React$1.useImperativeHandle(ref, () => proxyObject(inputRef.current, {
+		focus: (option) => {
+			triggerFocus(inputRef.current, option);
+		},
+		blur: () => {
+			inputRef.current?.blur();
+		},
+		nativeElement: rootRef.current
+	}));
+	const [decimalValue, setDecimalValue] = React$1.useState(() => es_default(value ?? defaultValue));
+	function setUncontrolledDecimalValue(newDecimal) {
+		if (value === void 0) setDecimalValue(newDecimal);
+	}
+	/**
+	* `precision` is used for formatter & onChange.
+	* It will auto generate by `value` & `step`.
+	* But it will not block user typing.
+	*
+	* Note: Auto generate `precision` is used for legacy logic.
+	* We should remove this since we already support high precision with BigInt.
+	*
+	* @param number  Provide which number should calculate precision
+	* @param userTyping  Change by user typing
+	*/
+	const getPrecision = React$1.useCallback((numStr, userTyping) => {
+		if (userTyping) return;
+		if (precision >= 0) return precision;
+		return Math.max(getNumberPrecision(numStr), getNumberPrecision(step));
+	}, [precision, step]);
+	const mergedParser = React$1.useCallback((num) => {
+		const numStr = String(num);
+		if (parser) return parser(numStr);
+		let parsedStr = numStr;
+		if (decimalSeparator) parsedStr = parsedStr.replace(decimalSeparator, ".");
+		return parsedStr.replace(/[^\w.-]+/g, "");
+	}, [parser, decimalSeparator]);
+	const inputValueRef = React$1.useRef("");
+	const mergedFormatter = React$1.useCallback((number, userTyping) => {
+		if (formatter) return formatter(number, {
+			userTyping,
+			input: String(inputValueRef.current)
+		});
+		let str = typeof number === "number" ? num2str(number) : number;
+		if (!userTyping) {
+			const mergedPrecision = getPrecision(str, userTyping);
+			if (validateNumber(str) && (decimalSeparator || mergedPrecision >= 0)) str = toFixed(str, decimalSeparator || ".", mergedPrecision);
+		}
+		return str;
+	}, [
+		formatter,
+		getPrecision,
+		decimalSeparator
+	]);
+	/**
+	* Input text value control
+	*
+	* User can not update input content directly. It updates with follow rules by priority:
+	*  1. controlled `value` changed
+	*    * [SPECIAL] Typing like `1.` should not immediately convert to `1`
+	*  2. User typing with format (not precision)
+	*  3. Blur or Enter trigger revalidate
+	*/
+	const [inputValue, setInternalInputValue] = React$1.useState(() => {
+		const initValue = defaultValue ?? value;
+		if (decimalValue.isInvalidate() && ["string", "number"].includes(typeof initValue)) return Number.isNaN(initValue) ? "" : initValue;
+		return mergedFormatter(decimalValue.toString(), false);
+	});
+	inputValueRef.current = inputValue;
+	function setInputValue(newValue, userTyping) {
+		setInternalInputValue(mergedFormatter(newValue.isInvalidate() ? newValue.toString(false) : newValue.toString(!userTyping), userTyping));
+	}
+	const maxDecimal = React$1.useMemo(() => getDecimalIfValidate(max), [max, precision]);
+	const minDecimal = React$1.useMemo(() => getDecimalIfValidate(min), [min, precision]);
+	const upDisabled = React$1.useMemo(() => {
+		if (!maxDecimal || !decimalValue || decimalValue.isInvalidate()) return false;
+		return maxDecimal.lessEquals(decimalValue);
+	}, [maxDecimal, decimalValue]);
+	const downDisabled = React$1.useMemo(() => {
+		if (!minDecimal || !decimalValue || decimalValue.isInvalidate()) return false;
+		return decimalValue.lessEquals(minDecimal);
+	}, [minDecimal, decimalValue]);
+	const [recordCursor, restoreCursor] = useCursor(inputRef.current, focus);
+	/**
+	* Find target value closet within range.
+	* e.g. [11, 28]:
+	*    3  => 11
+	*    23 => 23
+	*    99 => 28
+	*/
+	const getRangeValue = (target) => {
+		if (maxDecimal && !target.lessEquals(maxDecimal)) return maxDecimal;
+		if (minDecimal && !minDecimal.lessEquals(target)) return minDecimal;
+		return null;
+	};
+	/**
+	* Check value is in [min, max] range
+	*/
+	const isInRange = (target) => !getRangeValue(target);
+	/**
+	* Trigger `onChange` if value validated and not equals of origin.
+	* Return the value that re-align in range.
+	*/
+	const triggerValueUpdate = (newValue, userTyping) => {
+		let updateValue = newValue;
+		let isRangeValidate = isInRange(updateValue) || updateValue.isEmpty();
+		if (!updateValue.isEmpty() && !userTyping) {
+			updateValue = getRangeValue(updateValue) || updateValue;
+			isRangeValidate = true;
+		}
+		if (!readOnly && !disabled && isRangeValidate) {
+			const numStr = updateValue.toString();
+			const mergedPrecision = getPrecision(numStr, userTyping);
+			if (mergedPrecision >= 0) {
+				updateValue = es_default(toFixed(numStr, ".", mergedPrecision));
+				if (!isInRange(updateValue)) updateValue = es_default(toFixed(numStr, ".", mergedPrecision, true));
+			}
+			if (!updateValue.equals(decimalValue)) {
+				setUncontrolledDecimalValue(updateValue);
+				onChange?.(updateValue.isEmpty() ? null : getDecimalValue(stringMode, updateValue));
+				if (value === void 0) setInputValue(updateValue, userTyping);
+			}
+			return updateValue;
+		}
+		return decimalValue;
+	};
+	const onNextPromise = useFrame_default();
+	const collectInputValue = (inputStr) => {
+		recordCursor();
+		inputValueRef.current = inputStr;
+		setInternalInputValue(inputStr);
+		if (!compositionRef.current) {
+			const finalValue = mergedParser(inputStr);
+			const finalDecimal = es_default(finalValue);
+			if (!finalDecimal.isNaN()) triggerValueUpdate(finalDecimal, true);
+		}
+		onInput?.(inputStr);
+		onNextPromise(() => {
+			let nextInputStr = inputStr;
+			if (!parser) nextInputStr = inputStr.replace(/。/g, ".");
+			if (nextInputStr !== inputStr) collectInputValue(nextInputStr);
+		});
+	};
+	const onCompositionStart = () => {
+		compositionRef.current = true;
+	};
+	const onCompositionEnd = () => {
+		compositionRef.current = false;
+		collectInputValue(inputRef.current.value);
+	};
+	const onInternalInput = (e) => {
+		collectInputValue(e.target.value);
+	};
+	const onInternalStep = useEvent((up, emitter) => {
+		if (up && upDisabled || !up && downDisabled) return;
+		userTypingRef.current = false;
+		let stepDecimal = es_default(shiftKeyRef.current ? getDecupleSteps(step) : step);
+		if (!up) stepDecimal = stepDecimal.negate();
+		const target = (decimalValue || es_default(0)).add(stepDecimal.toString());
+		const updatedValue = triggerValueUpdate(target, false);
+		onStep?.(getDecimalValue(stringMode, updatedValue), {
+			offset: shiftKeyRef.current ? getDecupleSteps(step) : step,
+			type: up ? "up" : "down",
+			emitter
+		});
+		inputRef.current?.focus();
+	});
+	/**
+	* Flush current input content to trigger value change & re-formatter input if needed.
+	* This will always flush input value for update.
+	* If it's invalidate, will fallback to last validate value.
+	*/
+	const flushInputValue = (userTyping) => {
+		const parsedValue = es_default(mergedParser(inputValue));
+		let formatValue;
+		if (!parsedValue.isNaN()) formatValue = triggerValueUpdate(parsedValue, userTyping);
+		else formatValue = triggerValueUpdate(decimalValue, userTyping);
+		if (value !== void 0) setInputValue(decimalValue, false);
+		else if (!formatValue.isNaN()) setInputValue(formatValue, false);
+	};
+	const onBeforeInput = () => {
+		userTypingRef.current = true;
+	};
+	const onKeyDown = (event) => {
+		const { key, shiftKey } = event;
+		userTypingRef.current = true;
+		shiftKeyRef.current = shiftKey;
+		if (key === "Enter") {
+			if (!compositionRef.current) userTypingRef.current = false;
+			flushInputValue(false);
+			onPressEnter?.(event);
+		}
+		if (keyboard === false) return;
+		if (!compositionRef.current && [
+			"Up",
+			"ArrowUp",
+			"Down",
+			"ArrowDown"
+		].includes(key)) {
+			onInternalStep(key === "Up" || key === "ArrowUp", "keyboard");
+			event.preventDefault();
+		}
+	};
+	const onKeyUp = () => {
+		userTypingRef.current = false;
+		shiftKeyRef.current = false;
+	};
+	React$1.useEffect(() => {
+		if (changeOnWheel && focus) {
+			const onWheel = (event) => {
+				onInternalStep(event.deltaY < 0, "wheel");
+				event.preventDefault();
+			};
+			const input = inputRef.current;
+			if (input) {
+				input.addEventListener("wheel", onWheel, { passive: false });
+				return () => input.removeEventListener("wheel", onWheel);
+			}
+		}
+	});
+	const onBlur = () => {
+		if (changeOnBlur) flushInputValue(false);
+		setFocus(false);
+		userTypingRef.current = false;
+	};
+	const onInternalMouseDown = (event) => {
+		if (inputRef.current && event.target !== inputRef.current) {
+			inputRef.current.focus();
+			event.preventDefault();
+		}
+		onMouseDown?.(event);
+	};
+	useLayoutUpdateEffect(() => {
+		if (!decimalValue.isInvalidate()) setInputValue(decimalValue, false);
+	}, [precision, formatter]);
+	useLayoutUpdateEffect(() => {
+		const newValue = es_default(value);
+		setDecimalValue(newValue);
+		const currentParsedValue = es_default(mergedParser(inputValue));
+		if (!newValue.equals(currentParsedValue) || !userTypingRef.current || formatter) setInputValue(newValue, userTypingRef.current);
+	}, [value]);
+	useLayoutUpdateEffect(() => {
+		if (formatter) restoreCursor();
+	}, [inputValue]);
+	const sharedHandlerProps = {
+		prefixCls,
+		onStep: onInternalStep,
+		className: classNames?.action,
+		style: styles?.action
+	};
+	const upNode = /*#__PURE__*/ React$1.createElement(StepHandler, _extends({}, sharedHandlerProps, {
+		action: "up",
+		disabled: upDisabled
+	}), upHandler);
+	const downNode = /*#__PURE__*/ React$1.createElement(StepHandler, _extends({}, sharedHandlerProps, {
+		action: "down",
+		disabled: downDisabled
+	}), downHandler);
+	return /*#__PURE__*/ React$1.createElement("div", {
+		ref: rootRef,
+		className: clsx(prefixCls, `${prefixCls}-mode-${mode}`, className, classNames?.root, {
+			[`${prefixCls}-focused`]: focus,
+			[`${prefixCls}-disabled`]: disabled,
+			[`${prefixCls}-readonly`]: readOnly,
+			[`${prefixCls}-not-a-number`]: decimalValue.isNaN(),
+			[`${prefixCls}-out-of-range`]: !decimalValue.isInvalidate() && !isInRange(decimalValue)
+		}),
+		style: {
+			...styles?.root,
+			...style
+		},
+		onMouseDown: onInternalMouseDown,
+		onMouseUp,
+		onMouseLeave,
+		onMouseMove,
+		onMouseEnter,
+		onMouseOut,
+		onClick,
+		onFocus: () => {
+			setFocus(true);
+		},
+		onBlur,
+		onKeyDown,
+		onKeyUp,
+		onCompositionStart,
+		onCompositionEnd,
+		onBeforeInput
+	}, mode === "spinner" && controls && downNode, prefix !== void 0 && /*#__PURE__*/ React$1.createElement("div", {
+		className: clsx(`${prefixCls}-prefix`, classNames?.prefix),
+		style: styles?.prefix
+	}, prefix), /*#__PURE__*/ React$1.createElement("input", _extends({
+		autoComplete: "off",
+		role: "spinbutton",
+		"aria-valuemin": min,
+		"aria-valuemax": max,
+		"aria-valuenow": decimalValue.isInvalidate() ? null : decimalValue.toString(),
+		step,
+		ref: inputRef,
+		className: clsx(`${prefixCls}-input`, classNames?.input),
+		style: styles?.input,
+		value: inputValue,
+		onChange: onInternalInput,
+		disabled,
+		readOnly
+	}, restProps)), suffix !== void 0 && /*#__PURE__*/ React$1.createElement("div", {
+		className: clsx(`${prefixCls}-suffix`, classNames?.suffix),
+		style: styles?.suffix
+	}, suffix), mode === "spinner" && controls && upNode, mode === "input" && controls && /*#__PURE__*/ React$1.createElement("div", {
+		className: clsx(`${prefixCls}-actions`, classNames?.actions),
+		style: styles?.actions
+	}, upNode, downNode));
+});
+//#endregion
+export { InputNumber as default };

package/vendor/@rc-component/input-number/es/StepHandler.js

@@ -0,0 +1,57 @@
+import wrapperRaf from "../../util/es/raf.js";
+import { clsx } from "../../../clsx/dist/clsx.js";
+import * as React$1 from "../../../react/index.js";
+//#region node_modules/@rc-component/input-number/es/StepHandler.js
+/**
+* When click and hold on a button - the speed of auto changing the value.
+*/
+const STEP_INTERVAL = 200;
+/**
+* When click and hold on a button - the delay before auto changing the value.
+*/
+const STEP_DELAY = 600;
+function StepHandler({ prefixCls, action, children, disabled, className, style, onStep }) {
+	const isUpAction = action === "up";
+	const stepTimeoutRef = React$1.useRef();
+	const frameIds = React$1.useRef([]);
+	const onStopStep = () => {
+		clearTimeout(stepTimeoutRef.current);
+	};
+	const onStepMouseDown = (e) => {
+		e.preventDefault();
+		onStopStep();
+		onStep(isUpAction, "handler");
+		function loopStep() {
+			onStep(isUpAction, "handler");
+			stepTimeoutRef.current = setTimeout(loopStep, STEP_INTERVAL);
+		}
+		stepTimeoutRef.current = setTimeout(loopStep, STEP_DELAY);
+	};
+	React$1.useEffect(() => () => {
+		onStopStep();
+		frameIds.current.forEach((id) => {
+			wrapperRaf.cancel(id);
+		});
+	}, []);
+	const actionClassName = `${prefixCls}-action`;
+	const mergedClassName = clsx(actionClassName, `${actionClassName}-${action}`, { [`${actionClassName}-${action}-disabled`]: disabled }, className);
+	const safeOnStopStep = () => frameIds.current.push(wrapperRaf(onStopStep));
+	return /*#__PURE__*/ React$1.createElement("span", {
+		unselectable: "on",
+		role: "button",
+		onMouseUp: safeOnStopStep,
+		onMouseLeave: safeOnStopStep,
+		onMouseDown: (e) => {
+			onStepMouseDown(e);
+		},
+		"aria-label": isUpAction ? "Increase Value" : "Decrease Value",
+		"aria-disabled": disabled,
+		className: mergedClassName,
+		style
+	}, children || /*#__PURE__*/ React$1.createElement("span", {
+		unselectable: "on",
+		className: `${prefixCls}-action-${action}-inner`
+	}));
+}
+//#endregion
+export { StepHandler as default };

package/vendor/@rc-component/input-number/es/hooks/useCursor.js

@@ -0,0 +1,49 @@
+import warningOnce from "../../../util/es/warning.js";
+import { useRef } from "../../../../react/index.js";
+//#region node_modules/@rc-component/input-number/es/hooks/useCursor.js
+/**
+* Keep input cursor in the correct position if possible.
+* Is this necessary since we have `formatter` which may mass the content?
+*/
+function useCursor(input, focused) {
+	const selectionRef = useRef(null);
+	function recordCursor() {
+		try {
+			const { selectionStart: start, selectionEnd: end, value } = input;
+			const beforeTxt = value.substring(0, start);
+			const afterTxt = value.substring(end);
+			selectionRef.current = {
+				start,
+				end,
+				value,
+				beforeTxt,
+				afterTxt
+			};
+		} catch (e) {}
+	}
+	/**
+	* Restore logic:
+	*  1. back string same
+	*  2. start string same
+	*/
+	function restoreCursor() {
+		if (input && selectionRef.current && focused) try {
+			const { value } = input;
+			const { beforeTxt, afterTxt, start } = selectionRef.current;
+			let startPos = value.length;
+			if (value.startsWith(beforeTxt)) startPos = beforeTxt.length;
+			else if (value.endsWith(afterTxt)) startPos = value.length - selectionRef.current.afterTxt.length;
+			else {
+				const beforeLastChar = beforeTxt[start - 1];
+				const newIndex = value.indexOf(beforeLastChar, start - 1);
+				if (newIndex !== -1) startPos = newIndex + 1;
+			}
+			input.setSelectionRange(startPos, startPos);
+		} catch (e) {
+			warningOnce(false, `Something warning of cursor restore. Please fire issue about this: ${e.message}`);
+		}
+	}
+	return [recordCursor, restoreCursor];
+}
+//#endregion
+export { useCursor as default };

package/vendor/@rc-component/input-number/es/hooks/useFrame.js

@@ -0,0 +1,21 @@
+import wrapperRaf from "../../../util/es/raf.js";
+import { useEffect, useRef } from "../../../../react/index.js";
+//#region node_modules/@rc-component/input-number/es/hooks/useFrame.js
+/**
+* Always trigger latest once when call multiple time
+*/
+var useFrame_default = (() => {
+	const idRef = useRef(0);
+	const cleanUp = () => {
+		wrapperRaf.cancel(idRef.current);
+	};
+	useEffect(() => cleanUp, []);
+	return (callback) => {
+		cleanUp();
+		idRef.current = wrapperRaf(() => {
+			callback();
+		});
+	};
+});
+//#endregion
+export { useFrame_default as default };

package/vendor/@rc-component/input-number/es/index.js

@@ -0,0 +1,5 @@
+import InputNumber from "./InputNumber.js";
+//#region node_modules/@rc-component/input-number/es/index.js
+var es_default = InputNumber;
+//#endregion
+export { es_default as default };

package/vendor/@rc-component/input-number/es/utils/numberUtil.js

@@ -0,0 +1,10 @@
+import { num2str, trimNumber } from "../../../mini-decimal/es/numberUtil.js";
+import "../../../mini-decimal/es/index.js";
+//#region node_modules/@rc-component/input-number/es/utils/numberUtil.js
+function getDecupleSteps(step) {
+	const stepStr = typeof step === "number" ? num2str(step) : trimNumber(step).fullStr;
+	if (!stepStr.includes(".")) return step + "0";
+	return trimNumber(stepStr.replace(/(\d)\.(\d)/g, "$1$2.")).fullStr;
+}
+//#endregion
+export { getDecupleSteps };

package/vendor/@rc-component/input-number/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@rc-component/input-number",
+  "version": "1.6.2",
+  "license": "MIT",
+  "type": "module"
+}

package/vendor/@rc-component/mentions/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2019-present alipay.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/vendor/@rc-component/mentions/es/DropdownMenu.js

@@ -0,0 +1,52 @@
+import MenuItem_default from "../../menu/es/MenuItem.js";
+import ExportMenu from "../../menu/es/index.js";
+import MentionsContext from "./MentionsContext.js";
+import React, { useEffect, useRef } from "../../../react/index.js";
+//#region node_modules/@rc-component/mentions/es/DropdownMenu.js
+/**
+* We only use Menu to display the candidate.
+* The focus is controlled by textarea to make accessibility easy.
+*/
+function DropdownMenu(props) {
+	const { notFoundContent, activeIndex, setActiveIndex, selectOption, onFocus, onBlur, onScroll } = React.useContext(MentionsContext);
+	const { prefixCls, options, opened } = props;
+	const activeOption = options[activeIndex] || {};
+	const menuRef = useRef(null);
+	useEffect(() => {
+		if (activeIndex === -1 || !menuRef.current || !opened) return;
+		const activeItem = menuRef.current?.findItem?.({ key: activeOption.key });
+		if (activeItem) activeItem.scrollIntoView({
+			block: "nearest",
+			inline: "nearest"
+		});
+	}, [
+		activeIndex,
+		activeOption.key,
+		opened
+	]);
+	return /*#__PURE__*/ React.createElement(ExportMenu, {
+		ref: menuRef,
+		prefixCls: `${prefixCls}-menu`,
+		activeKey: activeOption.key,
+		onSelect: ({ key }) => {
+			const option = options.find(({ key: optionKey }) => optionKey === key);
+			selectOption(option);
+		},
+		onFocus,
+		onBlur,
+		onScroll
+	}, options.map((option, index) => {
+		const { key, disabled, className, style, label } = option;
+		return /*#__PURE__*/ React.createElement(MenuItem_default, {
+			key,
+			disabled,
+			className,
+			style,
+			onMouseEnter: () => {
+				setActiveIndex(index);
+			}
+		}, label);
+	}), !options.length && /*#__PURE__*/ React.createElement(MenuItem_default, { disabled: true }, notFoundContent));
+}
+//#endregion
+export { DropdownMenu as default };