@sdata/web-vue 3.30.0 → 4.0.0

package/es/input/{input.d.ts → input.vue.d.ts}

@@ -1,14 +1,22 @@
 import type { PropType } from 'vue';
 import { Size } from '../_utils/constant';
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+declare var __VLS_7: {}, __VLS_23: {}, __VLS_36: {}, __VLS_43: {};
+type __VLS_Slots = {} & {
+    prefix?: (props: typeof __VLS_7) => any;
+} & {
+    suffix?: (props: typeof __VLS_23) => any;
+} & {
+    prepend?: (props: typeof __VLS_36) => any;
+} & {
+    append?: (props: typeof __VLS_43) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     modelValue: StringConstructor;
     defaultValue: {
         type: StringConstructor;
         default: string;
     };
-    size: {
-        type: PropType<Size>;
-    };
+    size: PropType<Size>;
     allowClear: {
         type: BooleanConstructor;
         default: boolean;
@@ -45,15 +53,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
-    wordLength: {
-        type: PropType<(value: string) => number>;
-    };
-    wordSlice: {
-        type: PropType<(value: string, maxLength: number) => string>;
-    };
-    inputAttrs: {
-        type: ObjectConstructor;
-    };
+    wordLength: PropType<(value: string) => number>;
+    wordSlice: PropType<(value: string, maxLength: number) => string>;
+    inputAttrs: ObjectConstructor;
     type: {
         type: PropType<"text" | "password">;
         default: string;
@@ -66,27 +68,23 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     append: StringConstructor;
 }>, {
     inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
-    render: () => import("vue/jsx-runtime").JSX.Element;
-}, {}, {}, {
-    focus(): void;
-    blur(): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    'update:modelValue': (_value: string) => true;
-    input: (_value: string, _ev: Event) => true;
-    change: (_value: string, _ev: Event) => true;
-    pressEnter: (_ev: KeyboardEvent) => true;
-    clear: (_ev: MouseEvent) => true;
-    focus: (_ev: FocusEvent) => true;
-    blur: (_ev: FocusEvent) => true;
+    focus: () => void | undefined;
+    blur: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    clear: (_event: MouseEvent) => void;
+    focus: (_event: FocusEvent) => void;
+    blur: (_event: FocusEvent) => void;
+    change: (_value: string, _event: Event) => void;
+    input: (_value: string, _event: Event) => void;
+    "update:modelValue": (_value: string) => void;
+    pressEnter: (_event: KeyboardEvent) => void;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     modelValue: StringConstructor;
     defaultValue: {
         type: StringConstructor;
         default: string;
     };
-    size: {
-        type: PropType<Size>;
-    };
+    size: PropType<Size>;
     allowClear: {
         type: BooleanConstructor;
         default: boolean;
@@ -123,15 +121,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
-    wordLength: {
-        type: PropType<(value: string) => number>;
-    };
-    wordSlice: {
-        type: PropType<(value: string, maxLength: number) => string>;
-    };
-    inputAttrs: {
-        type: ObjectConstructor;
-    };
+    wordLength: PropType<(value: string) => number>;
+    wordSlice: PropType<(value: string, maxLength: number) => string>;
+    inputAttrs: ObjectConstructor;
     type: {
         type: PropType<"text" | "password">;
         default: string;
@@ -143,13 +135,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     prepend: StringConstructor;
     append: StringConstructor;
 }>> & Readonly<{
-    onClear?: ((_ev: MouseEvent) => any) | undefined;
-    onFocus?: ((_ev: FocusEvent) => any) | undefined;
-    onBlur?: ((_ev: FocusEvent) => any) | undefined;
-    onChange?: ((_value: string, _ev: Event) => any) | undefined;
-    onInput?: ((_value: string, _ev: Event) => any) | undefined;
+    onClear?: ((_event: MouseEvent) => any) | undefined;
+    onFocus?: ((_event: FocusEvent) => any) | undefined;
+    onBlur?: ((_event: FocusEvent) => any) | undefined;
+    onChange?: ((_value: string, _event: Event) => any) | undefined;
+    onInput?: ((_value: string, _event: Event) => any) | undefined;
     "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
-    onPressEnter?: ((_ev: KeyboardEvent) => any) | undefined;
+    onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
 }>, {
     type: "text" | "password";
     disabled: boolean;
@@ -166,4 +158,11 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     showWordLimit: boolean;
     fitWidthFallback: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/input/input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,377 @@
+import { useFormItem } from "../_hooks/use-form-item.js";
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/objectSpread2.js";
+import { getPrefixCls } from "../_utils/global-config.js";
+import { isFunction, isNull, isObject, isUndefined } from "../_utils/is.js";
+import icon_hover_default from "../_components/icon-hover.js";
+import { isActivationKey } from "../_utils/keyboard.js";
+import IconClose from "../icon/icon-close/index.js";
+import { useI18n } from "../locale/index.js";
+import { useAllowClear } from "../_hooks/use-allow-clear.js";
+import feedback_icon_default from "../_components/feedback-icon.js";
+import { useCursor } from "../_hooks/use-cursor.js";
+import { useFitWidth } from "../_hooks/use-fit-width.js";
+import { isReadonlyModificationKey, useReadonlyTip, useReadonlyTipText } from "../_hooks/use-readonly-tip.js";
+import { useSize } from "../_hooks/use-size.js";
+import { INPUT_EVENTS } from "../_utils/constant.js";
+import { countGraphemes, sliceGraphemes } from "../_utils/grapheme.js";
+import { Enter } from "../_utils/keycode.js";
+import { omit } from "../_utils/omit.js";
+import pick from "../_utils/pick.js";
+import Tooltip from "../tooltip/index.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, mergeProps, nextTick, normalizeClass, openBlock, ref, renderSlot, toDisplayString, toRef, unref, useAttrs, useSlots, watch, withCtx } from "vue";
+import { createReusableTemplate } from "@vueuse/core";
+//#region components/input/input.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = [
+	"value",
+	"type",
+	"placeholder",
+	"readonly",
+	"disabled"
+];
+var input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent(_objectSpread2(_objectSpread2({}, {
+	name: "Input",
+	inheritAttrs: false
+}), {}, {
+	__name: "input",
+	props: {
+		modelValue: String,
+		defaultValue: {
+			type: String,
+			default: ""
+		},
+		size: String,
+		allowClear: {
+			type: Boolean,
+			default: false
+		},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		readonly: {
+			type: [Boolean, String],
+			default: false
+		},
+		error: {
+			type: Boolean,
+			default: false
+		},
+		placeholder: String,
+		fitWidth: {
+			type: Boolean,
+			default: false
+		},
+		maxWFull: {
+			type: Boolean,
+			default: true
+		},
+		maxLength: {
+			type: [Number, Object],
+			default: 0
+		},
+		showWordLimit: {
+			type: Boolean,
+			default: false
+		},
+		wordLength: Function,
+		wordSlice: Function,
+		inputAttrs: Object,
+		type: {
+			type: String,
+			default: "text"
+		},
+		fitWidthFallback: {
+			type: String,
+			default: "4ch"
+		},
+		prepend: String,
+		append: String
+	},
+	emits: {
+		"update:modelValue": (_value) => true,
+		"input": (_value, _event) => true,
+		"change": (_value, _event) => true,
+		"pressEnter": (_event) => true,
+		"clear": (_event) => true,
+		"focus": (_event) => true,
+		"blur": (_event) => true
+	},
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const attrs = useAttrs();
+		const slots = useSlots();
+		const [DefineInput, ReuseInput] = createReusableTemplate();
+		const { t } = useI18n();
+		const prefixCls = getPrefixCls("input");
+		const inputRef = ref();
+		const { mergedSize: formSize, mergedDisabled, mergedError: formError, feedback, eventHandlers, formItemCtx } = useFormItem({
+			size: toRef(props, "size"),
+			disabled: toRef(props, "disabled"),
+			error: toRef(props, "error")
+		});
+		const { mergedSize } = useSize(formSize);
+		const { mergedAllowClear } = useAllowClear(toRef(props, "allowClear"));
+		const [recordCursor, setCursor] = useCursor(inputRef);
+		const { tipVisible, show: showReadonlyTip } = useReadonlyTip(toRef(props, "readonly"), mergedDisabled);
+		const readonlyTipText = useReadonlyTipText(toRef(props, "readonly"));
+		const innerValue = ref(props.defaultValue);
+		const computedValue = computed(() => {
+			var _props$modelValue;
+			return (_props$modelValue = props.modelValue) !== null && _props$modelValue !== void 0 ? _props$modelValue : innerValue.value;
+		});
+		let previousValue = computedValue.value;
+		watch(toRef(props, "modelValue"), (value) => {
+			if (isUndefined(value) || isNull(value)) innerValue.value = "";
+		});
+		watch(computedValue, (_value, oldValue) => {
+			previousValue = oldValue;
+		});
+		const focused = ref(false);
+		const showClearBtn = computed(() => mergedAllowClear.value && !props.readonly && !mergedDisabled.value && Boolean(computedValue.value));
+		const isComposition = ref(false);
+		const compositionValue = ref("");
+		const fitWidthText = computed(() => {
+			const value = compositionValue.value || computedValue.value;
+			return (props.type === "password" ? "•".repeat(Array.from(value).length) : value) || props.placeholder;
+		});
+		const { fitWidthStyle, fitWidthValue } = useFitWidth({
+			fitWidth: () => props.fitWidth,
+			text: fitWidthText,
+			fallbackWidth: () => props.fitWidthFallback,
+			target: inputRef
+		});
+		const getValueLength = (value) => isFunction(props.wordLength) ? props.wordLength(value) : countGraphemes(value);
+		const valueLength = computed(() => getValueLength(computedValue.value));
+		const maxLength = computed(() => isObject(props.maxLength) ? props.maxLength.length : props.maxLength);
+		const maxLengthErrorOnly = computed(() => isObject(props.maxLength) && Boolean(props.maxLength.errorOnly));
+		const mergedError = computed(() => formError.value || Boolean(isObject(props.maxLength) && props.maxLength.errorOnly && valueLength.value > maxLength.value));
+		const defaultMaxLength = computed(() => Math.floor(maxLength.value / getValueLength("a")));
+		const updateValue = (nextValue) => {
+			if (maxLength.value && !maxLengthErrorOnly.value && getValueLength(nextValue) > maxLength.value) if (isFunction(props.wordSlice)) nextValue = props.wordSlice(nextValue, maxLength.value);
+			else if (isFunction(props.wordLength)) nextValue = nextValue.slice(0, defaultMaxLength.value);
+			else nextValue = sliceGraphemes(nextValue, defaultMaxLength.value);
+			innerValue.value = nextValue;
+			emit("update:modelValue", nextValue);
+		};
+		const handleMousedown = (event) => {
+			if (inputRef.value && event.target !== inputRef.value) {
+				event.preventDefault();
+				inputRef.value.focus();
+			}
+		};
+		const emitChange = (value, event) => {
+			if (value !== previousValue) {
+				var _eventHandlers$value, _eventHandlers$value$;
+				previousValue = value;
+				emit("change", value, event);
+				(_eventHandlers$value = eventHandlers.value) === null || _eventHandlers$value === void 0 || (_eventHandlers$value$ = _eventHandlers$value.onChange) === null || _eventHandlers$value$ === void 0 || _eventHandlers$value$.call(_eventHandlers$value, event);
+			}
+		};
+		const handleFocus = (event) => {
+			var _eventHandlers$value2, _eventHandlers$value3;
+			focused.value = true;
+			emit("focus", event);
+			(_eventHandlers$value2 = eventHandlers.value) === null || _eventHandlers$value2 === void 0 || (_eventHandlers$value3 = _eventHandlers$value2.onFocus) === null || _eventHandlers$value3 === void 0 || _eventHandlers$value3.call(_eventHandlers$value2, event);
+		};
+		const handleBlur = (event) => {
+			var _eventHandlers$value4, _eventHandlers$value5;
+			focused.value = false;
+			emitChange(computedValue.value, event);
+			emit("blur", event);
+			(_eventHandlers$value4 = eventHandlers.value) === null || _eventHandlers$value4 === void 0 || (_eventHandlers$value5 = _eventHandlers$value4.onBlur) === null || _eventHandlers$value5 === void 0 || _eventHandlers$value5.call(_eventHandlers$value4, event);
+		};
+		const keepControl = () => {
+			recordCursor();
+			nextTick(() => {
+				if (inputRef.value && computedValue.value !== inputRef.value.value) {
+					inputRef.value.value = computedValue.value;
+					setCursor();
+				}
+			});
+		};
+		const handleComposition = (event) => {
+			const { value, selectionStart, selectionEnd } = event.target;
+			if (event.type === "compositionend") {
+				var _eventHandlers$value6, _eventHandlers$value7;
+				isComposition.value = false;
+				compositionValue.value = "";
+				if (maxLength.value && !maxLengthErrorOnly.value && valueLength.value >= maxLength.value && getValueLength(value) > maxLength.value && selectionStart === selectionEnd) {
+					keepControl();
+					return;
+				}
+				updateValue(value);
+				emit("input", value, event);
+				(_eventHandlers$value6 = eventHandlers.value) === null || _eventHandlers$value6 === void 0 || (_eventHandlers$value7 = _eventHandlers$value6.onInput) === null || _eventHandlers$value7 === void 0 || _eventHandlers$value7.call(_eventHandlers$value6, event);
+				keepControl();
+			} else {
+				var _event$data;
+				isComposition.value = true;
+				compositionValue.value = computedValue.value + ((_event$data = event.data) !== null && _event$data !== void 0 ? _event$data : "");
+			}
+		};
+		const handleInput = (event) => {
+			const { value } = event.target;
+			if (!isComposition.value) {
+				var _eventHandlers$value8, _eventHandlers$value9;
+				if (maxLength.value && !maxLengthErrorOnly.value && valueLength.value >= maxLength.value && getValueLength(value) > maxLength.value && event.inputType === "insertText") {
+					keepControl();
+					return;
+				}
+				updateValue(value);
+				emit("input", value, event);
+				(_eventHandlers$value8 = eventHandlers.value) === null || _eventHandlers$value8 === void 0 || (_eventHandlers$value9 = _eventHandlers$value8.onInput) === null || _eventHandlers$value9 === void 0 || _eventHandlers$value9.call(_eventHandlers$value8, event);
+				keepControl();
+			}
+		};
+		const handleClear = (event) => {
+			updateValue("");
+			emitChange("", event);
+			emit("clear", event);
+		};
+		const handleClearKeydown = (event) => {
+			if (isActivationKey(event)) {
+				event.preventDefault();
+				handleClear(event);
+			}
+		};
+		const handleKeyDown = (event) => {
+			if (props.readonly && !mergedDisabled.value && isReadonlyModificationKey(event)) showReadonlyTip();
+			const keyCode = event.key || event.code;
+			if (!isComposition.value && keyCode === Enter.key) {
+				emitChange(computedValue.value, event);
+				emit("pressEnter", event);
+			}
+		};
+		const hasOuter = computed(() => Boolean(slots.prepend || slots.append || props.prepend || props.append));
+		const outerCls = computed(() => [
+			`${prefixCls}-outer`,
+			`${prefixCls}-outer-size-${mergedSize.value}`,
+			{
+				[`${prefixCls}-outer-has-suffix`]: Boolean(slots.suffix),
+				[`${prefixCls}-outer-disabled`]: mergedDisabled.value,
+				[`${prefixCls}-fit-width`]: props.fitWidth,
+				[`${prefixCls}-max-w-full`]: props.maxWFull
+			}
+		]);
+		const wrapperCls = computed(() => [`${prefixCls}-wrapper`, {
+			[`${prefixCls}-error`]: mergedError.value,
+			[`${prefixCls}-disabled`]: mergedDisabled.value,
+			[`${prefixCls}-focus`]: focused.value,
+			[`${prefixCls}-fit-width`]: props.fitWidth,
+			[`${prefixCls}-max-w-full`]: props.maxWFull
+		}]);
+		const cls = computed(() => [prefixCls, `${prefixCls}-size-${mergedSize.value}`]);
+		const wrapperAttrs = computed(() => {
+			const values = omit(attrs, INPUT_EVENTS);
+			return _objectSpread2(_objectSpread2({}, values), {}, { style: [fitWidthStyle.value, values.style] });
+		});
+		const inputEventAttrs = computed(() => pick(attrs, INPUT_EVENTS));
+		const mergeInputAttrs = computed(() => {
+			const values = _objectSpread2(_objectSpread2({}, inputEventAttrs.value), props.inputAttrs);
+			if (formItemCtx.fieldId && values.id === void 0) values.id = formItemCtx.fieldId;
+			if (mergedError.value) values["aria-invalid"] = true;
+			values.style = [props.fitWidth ? {
+				flex: `0 1 ${fitWidthValue}`,
+				width: fitWidthValue,
+				minWidth: 0
+			} : void 0, values.style];
+			return values;
+		});
+		const focus = () => {
+			var _inputRef$value;
+			return (_inputRef$value = inputRef.value) === null || _inputRef$value === void 0 ? void 0 : _inputRef$value.focus();
+		};
+		const blur = () => {
+			var _inputRef$value2;
+			return (_inputRef$value2 = inputRef.value) === null || _inputRef$value2 === void 0 ? void 0 : _inputRef$value2.blur();
+		};
+		__expose({
+			inputRef,
+			focus,
+			blur
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [createVNode(unref(DefineInput), null, {
+				default: withCtx(({ hasOuter = false }) => [createElementVNode("span", mergeProps(hasOuter ? void 0 : wrapperAttrs.value, {
+					class: wrapperCls.value,
+					onMousedown: handleMousedown
+				}), [
+					unref(slots).prefix ? (openBlock(), createElementBlock("span", {
+						key: 0,
+						class: normalizeClass(`${unref(prefixCls)}-prefix`)
+					}, [renderSlot(_ctx.$slots, "prefix")], 2)) : createCommentVNode("", true),
+					createElementVNode("input", mergeProps({
+						ref_key: "inputRef",
+						ref: inputRef
+					}, mergeInputAttrs.value, {
+						class: cls.value,
+						value: computedValue.value,
+						type: props.type,
+						placeholder: props.placeholder,
+						readonly: !!props.readonly,
+						disabled: unref(mergedDisabled),
+						onInput: handleInput,
+						onKeydown: handleKeyDown,
+						onFocus: handleFocus,
+						onBlur: handleBlur,
+						onCompositionstart: handleComposition,
+						onCompositionupdate: handleComposition,
+						onCompositionend: handleComposition
+					}), null, 16, _hoisted_1),
+					showClearBtn.value ? (openBlock(), createBlock(icon_hover_default, {
+						key: 1,
+						prefix: unref(prefixCls),
+						class: normalizeClass(`${unref(prefixCls)}-clear-btn`),
+						role: "button",
+						tabindex: "0",
+						"aria-label": unref(t)("a11y.clear"),
+						onClick: handleClear,
+						onKeydown: handleClearKeydown
+					}, {
+						default: withCtx(() => [createVNode(unref(IconClose))]),
+						_: 1
+					}, 8, [
+						"prefix",
+						"class",
+						"aria-label"
+					])) : createCommentVNode("", true),
+					unref(slots).suffix || Boolean(props.maxLength) && props.showWordLimit || unref(feedback) ? (openBlock(), createElementBlock("span", {
+						key: 2,
+						class: normalizeClass([`${unref(prefixCls)}-suffix`, { [`${unref(prefixCls)}-suffix-has-feedback`]: unref(feedback) }])
+					}, [
+						Boolean(props.maxLength) && props.showWordLimit ? (openBlock(), createElementBlock("span", {
+							key: 0,
+							class: normalizeClass(`${unref(prefixCls)}-word-limit`)
+						}, toDisplayString(valueLength.value) + "/" + toDisplayString(maxLength.value), 3)) : createCommentVNode("", true),
+						renderSlot(_ctx.$slots, "suffix"),
+						unref(feedback) ? (openBlock(), createBlock(feedback_icon_default, {
+							key: 1,
+							type: unref(feedback)
+						}, null, 8, ["type"])) : createCommentVNode("", true)
+					], 2)) : createCommentVNode("", true)
+				], 16)]),
+				_: 3
+			}), createVNode(unref(Tooltip), {
+				"popup-visible": unref(tipVisible),
+				content: unref(readonlyTipText),
+				position: "top"
+			}, {
+				default: withCtx(() => [hasOuter.value ? (openBlock(), createElementBlock("span", mergeProps({ key: 0 }, wrapperAttrs.value, { class: outerCls.value }), [
+					unref(slots).prepend || props.prepend ? (openBlock(), createElementBlock("span", {
+						key: 0,
+						class: normalizeClass(`${unref(prefixCls)}-prepend`)
+					}, [renderSlot(_ctx.$slots, "prepend", {}, () => [createTextVNode(toDisplayString(props.prepend), 1)])], 2)) : createCommentVNode("", true),
+					createVNode(unref(ReuseInput), { "has-outer": "" }),
+					unref(slots).append || props.append ? (openBlock(), createElementBlock("span", {
+						key: 1,
+						class: normalizeClass(`${unref(prefixCls)}-append`)
+					}, [renderSlot(_ctx.$slots, "append", {}, () => [createTextVNode(toDisplayString(props.append), 1)])], 2)) : createCommentVNode("", true)
+				], 16)) : (openBlock(), createBlock(unref(ReuseInput), { key: 1 }))]),
+				_: 3
+			}, 8, ["popup-visible", "content"])], 64);
+		};
+	}
+}));
+//#endregion
+export { input_vue_vue_type_script_setup_true_lang_default as default };

package/es/input-mask/input-mask.vue_vue_type_script_setup_true_lang.js

@@ -1,4 +1,4 @@
-import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/objectSpread2.js";
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/objectSpread2.js";
 import { getPrefixCls } from "../_utils/global-config.js";
 import Input from "../input/index.js";
 import { formatInputMask, resolveDeletion } from "./mask-engine.js";

package/es/input-mask/mask-engine.js

@@ -1,13 +1,13 @@
-import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/objectSpread2.js";
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/objectSpread2.js";
 import { codeUnitToGraphemeIndex, graphemeIndexToCodeUnit, splitGraphemes } from "../_utils/grapheme.js";
 //#region components/input-mask/mask-engine.ts
 var defaultInputMaskFormatChars = {
 	"9": /[0-9]/,
 	"a": /[A-Za-z]/,
 	"*": /[A-Za-z0-9]/,
-	"H": /* @__PURE__ */ new RegExp("\\p{Script=Han}", "u"),
-	"L": /* @__PURE__ */ new RegExp("\\p{Letter}", "u"),
-	"N": /* @__PURE__ */ new RegExp("[\\p{Letter}\\p{Number}]", "u")
+	"H": new RegExp("\\p{Script=Han}", "u"),
+	"L": new RegExp("\\p{Letter}", "u"),
+	"N": new RegExp("[\\p{Letter}\\p{Number}]", "u")
 };
 var matches = (pattern, character) => {
 	pattern.lastIndex = 0;

package/es/input-mask/presets.js

@@ -113,7 +113,7 @@ var inputMaskPresets = {
 	"fqdn": {
 		placeholder: "example.com",
 		inputMode: "url",
-		normalize: filterCharacters(/* @__PURE__ */ new RegExp("[\\p{Letter}\\p{Number}._*-]", "u")),
+		normalize: filterCharacters(new RegExp("[\\p{Letter}\\p{Number}._*-]", "u")),
 		accepts: (value) => !value.includes("..")
 	},
 	"semver": {