@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/border-beam/useBorderSize.js

@@ -0,0 +1,56 @@
+import { isSameBorderWidth } from "./util.js";
+import { shallowRef, watch } from "vue";
+// src/border-beam/useBorderSize.ts
+var DEFAULT_BORDER_WIDTH = [
+	0,
+	0,
+	0,
+	0
+];
+function normalizeValue(val) {
+	const size = Number.parseFloat(val);
+	return Number.isFinite(size) ? size : 0;
+}
+var isClipped = (value) => !!value && value !== "visible";
+/**
+* Border width (top, right, bottom, left) of the host element. The beam layer is positioned
+* against the padding box of its host, so it is pushed outwards by these to cover the border.
+* A host that clips its overflow (Card, Image ...) would cut that part off: the layer then
+* stays on the padding box (`0`), right inside the border.
+* Read once per host element (after it is mounted), like the PC implementation.
+*/
+function useBorderSize(domNode) {
+	const borderWidth = shallowRef(DEFAULT_BORDER_WIDTH);
+	const setBorderWidth = (next) => {
+		if (!isSameBorderWidth(borderWidth.value, next)) borderWidth.value = next;
+	};
+	watch(domNode, (node) => {
+		if (!node) {
+			setBorderWidth(DEFAULT_BORDER_WIDTH);
+			return;
+		}
+		let computedStyle;
+		try {
+			computedStyle = getComputedStyle(node);
+		} catch {
+			setBorderWidth(DEFAULT_BORDER_WIDTH);
+			return;
+		}
+		const { borderTopWidth, borderRightWidth, borderBottomWidth, borderLeftWidth, overflow, overflowX, overflowY } = computedStyle;
+		if (isClipped(overflow) || isClipped(overflowX) || isClipped(overflowY)) {
+			setBorderWidth(DEFAULT_BORDER_WIDTH);
+			return;
+		}
+		setBorderWidth([
+			normalizeValue(borderTopWidth),
+			normalizeValue(borderRightWidth),
+			normalizeValue(borderBottomWidth),
+			normalizeValue(borderLeftWidth)
+		]);
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	return borderWidth;
+}
+export { useBorderSize as default };

package/dist/border-beam/util.d.ts

@@ -0,0 +1,10 @@
+import type { BorderBeamColor } from './interface';
+/** top, right, bottom, left */
+export type BorderWidth = readonly [number, number, number, number];
+export declare const DEFAULT_BORDER_BEAM_DURATION = 6;
+/** the last 30% of the beam is reserved for the transparent tail */
+export declare const MAX_BEAM_COLOR_STOP_PERCENT = 70;
+export declare function getBorderBeamGradient(value?: BorderBeamColor): string | undefined;
+export declare function isSameBorderWidth(left: BorderWidth, right: BorderWidth): boolean;
+/** `2` -> `-2px`, `'0.5rem'` -> `calc(-1 * 0.5rem)` */
+export declare function getInset(width: number | string): string;

package/dist/border-beam/util.js

@@ -0,0 +1,30 @@
+function normalizeBorderBeamColor(value) {
+	return typeof value === "string" ? value ? [{
+		color: value,
+		percent: 0
+	}] : [] : value ?? [];
+}
+function fillGradientEnd(items) {
+	const lastItem = items[items.length - 1];
+	if (!lastItem || lastItem.percent === 100) return items;
+	return [...items, {
+		...lastItem,
+		percent: 100
+	}];
+}
+/** maps the public `0 ~ 100` stops into the visible segment, so the tail stays reserved */
+function getMappedBeamColorStopPercent(percent) {
+	return Number((Math.min(Math.max(percent, 0), 100) / 100 * 70).toFixed(2));
+}
+function getBorderBeamGradient(value) {
+	const stops = fillGradientEnd(normalizeBorderBeamColor(value)).map((item) => `${item.color} ${getMappedBeamColorStopPercent(item.percent)}%`);
+	return stops.length ? `linear-gradient(to left, ${stops.join(", ")}, transparent)` : void 0;
+}
+function isSameBorderWidth(left, right) {
+	return left[0] === right[0] && left[1] === right[1] && left[2] === right[2] && left[3] === right[3];
+}
+/** `2` -> `-2px`, `'0.5rem'` -> `calc(-1 * 0.5rem)` */
+function getInset(width) {
+	return typeof width === "string" ? `calc(-1 * ${width})` : `-${width}px`;
+}
+export { getBorderBeamGradient, getInset, isSameBorderWidth };

package/dist/button/Button.js

@@ -0,0 +1,4 @@
+import Button_vue_vue_type_script_setup_true_lang_default from "./Button.vue_vue_type_script_setup_true_lang.js";
+// src/button/Button.vue
+var Button_default = Button_vue_vue_type_script_setup_true_lang_default;
+export { Button_default as default };

package/dist/button/Button.vue.d.ts

@@ -0,0 +1,26 @@
+import type { ButtonProps, ButtonSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = ButtonSlots;
+declare const __VLS_base: import("vue").DefineComponent<ButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<ButtonProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    iconPlacement: "start" | "end";
+    shape: import("./interface").ButtonShape;
+    loading: boolean | {
+        delay?: number;
+        icon?: import("..").RenderNodeFn;
+    };
+    htmlType: import("./interface").ButtonHTMLType;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, 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/dist/button/Button.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,162 @@
+import Spinner_default from "../_base/Spinner.js";
+import { useCompactItemContext } from "../_base/compact.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { useDisabled, useSize } from "../config-provider/context.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, onBeforeUnmount, openBlock, ref, renderSlot, resolveDynamicComponent, unref, useSlots, watch, withCtx } from "vue";
+// src/button/Button.vue?vue&type=script&setup=true&lang.ts
+var Button_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmButton",
+	inheritAttrs: false,
+	__name: "Button",
+	props: {
+		type: {},
+		color: {},
+		variant: {},
+		icon: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		iconPlacement: { default: "start" },
+		shape: { default: "default" },
+		size: {},
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		loading: {
+			type: [Boolean, Object],
+			default: false
+		},
+		ghost: { type: Boolean },
+		danger: { type: Boolean },
+		block: { type: Boolean },
+		href: {},
+		target: {},
+		htmlType: { default: "button" },
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["click"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const typeMap = {
+			default: ["default", "outlined"],
+			primary: ["primary", "solid"],
+			dashed: ["default", "dashed"],
+			link: ["primary", "link"],
+			text: ["default", "text"]
+		};
+		const compact = useCompactItemContext();
+		const size = useSize(() => props.size ?? compact.size.value);
+		const disabled = useDisabled(() => props.disabled);
+		const colorVariant = computed(() => {
+			const [typeColor, typeVariant] = typeMap[props.type ?? "default"] ?? typeMap.default;
+			return [props.color ?? (props.danger ? "danger" : typeColor), props.variant ?? typeVariant];
+		});
+		function getLoadingConfig(loading) {
+			if (typeof loading === "object" && loading) {
+				const delay = typeof loading.delay === "number" && !Number.isNaN(loading.delay) ? loading.delay : 0;
+				return {
+					loading: delay <= 0,
+					delay
+				};
+			}
+			return {
+				loading: !!loading,
+				delay: 0
+			};
+		}
+		const innerLoading = ref(getLoadingConfig(props.loading).loading);
+		let delayTimer;
+		watch(() => props.loading, (val) => {
+			clearTimeout(delayTimer);
+			const config = getLoadingConfig(val);
+			if (config.delay > 0) delayTimer = setTimeout(() => {
+				innerLoading.value = true;
+			}, config.delay);
+			else innerLoading.value = config.loading;
+		}, {
+			immediate: true,
+			deep: true
+		});
+		onBeforeUnmount(() => clearTimeout(delayTimer));
+		const loadingIcon = computed(() => typeof props.loading === "object" ? props.loading?.icon : void 0);
+		const hasIcon = computed(() => innerLoading.value || !!slots.icon || props.icon !== void 0 && props.icon !== null && props.icon !== false);
+		const classNames = computed(() => {
+			const [color, variant] = colorVariant.value;
+			return [
+				"am-button",
+				`am-button-color-${color}`,
+				`am-button-variant-${variant}`,
+				{
+					[`am-button-${props.shape}`]: props.shape !== "default",
+					"am-button-sm": size.value === "small",
+					"am-button-lg": size.value === "large",
+					"am-button-block": props.block,
+					"am-button-ghost": props.ghost,
+					"am-button-loading": innerLoading.value,
+					"am-button-disabled": disabled.value,
+					"am-button-icon-only": hasIcon.value && !slots.default,
+					"am-button-icon-end": props.iconPlacement === "end"
+				},
+				compact.classes.value,
+				props.rootClass,
+				props.classes?.root
+			];
+		});
+		function handleClick(event) {
+			if (innerLoading.value || disabled.value) {
+				event.preventDefault();
+				return;
+			}
+			emit("click", event);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.href !== void 0 ? "a" : "button"), mergeProps(_ctx.$attrs, {
+				class: classNames.value,
+				style: __props.styles?.root,
+				type: __props.href !== void 0 ? void 0 : __props.htmlType,
+				href: __props.href !== void 0 && !unref(disabled) ? __props.href : void 0,
+				target: __props.href !== void 0 ? __props.target : void 0,
+				disabled: __props.href === void 0 && unref(disabled) ? true : void 0,
+				"aria-disabled": unref(disabled) || void 0,
+				"aria-busy": innerLoading.value || void 0,
+				onClick: handleClick
+			}), {
+				default: withCtx(() => [hasIcon.value ? (openBlock(), createElementBlock("span", {
+					key: 0,
+					class: normalizeClass(["am-button-icon", __props.classes?.icon]),
+					style: normalizeStyle(__props.styles?.icon)
+				}, [innerLoading.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [loadingIcon.value ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: loadingIcon.value
+				}, null, 8, ["node"])) : (openBlock(), createBlock(unref(Spinner_default), { key: 1 }))], 64)) : renderSlot(_ctx.$slots, "icon", {}, () => [createVNode(unref(RenderNode_default), { node: __props.icon }, null, 8, ["node"])], void 0, 1)], 6)) : createCommentVNode("", true), _ctx.$slots.default ? (openBlock(), createElementBlock("span", {
+					key: 1,
+					class: normalizeClass(["am-button-content", __props.classes?.content]),
+					style: normalizeStyle(__props.styles?.content)
+				}, [renderSlot(_ctx.$slots, "default")], 6)) : createCommentVNode("", true)]),
+				_: 3
+			}, 16, [
+				"class",
+				"style",
+				"type",
+				"href",
+				"target",
+				"disabled",
+				"aria-disabled",
+				"aria-busy"
+			]);
+		};
+	}
+});
+export { Button_vue_vue_type_script_setup_true_lang_default as default };

package/dist/button/index.d.ts

@@ -0,0 +1,54 @@
+export type * from './interface';
+declare const Button: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").ButtonProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (event: MouseEvent) => any;
+    }, import("vue").PublicProps, {
+        disabled: boolean;
+        iconPlacement: "start" | "end";
+        shape: import("./interface").ButtonShape;
+        loading: boolean | {
+            delay?: number;
+            icon?: import("../index.ts").RenderNodeFn;
+        };
+        htmlType: import("./interface").ButtonHTMLType;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").ButtonProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        iconPlacement: "start" | "end";
+        shape: import("./interface").ButtonShape;
+        loading: boolean | {
+            delay?: number;
+            icon?: import("../index.ts").RenderNodeFn;
+        };
+        htmlType: import("./interface").ButtonHTMLType;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").ButtonProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, {
+    disabled: boolean;
+    iconPlacement: "start" | "end";
+    shape: import("./interface").ButtonShape;
+    loading: boolean | {
+        delay?: number;
+        icon?: import("../index.ts").RenderNodeFn;
+    };
+    htmlType: import("./interface").ButtonHTMLType;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").ButtonSlots;
+}), object>;
+export default Button;

package/dist/button/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import Button_default from "./Button.js";
+// src/button/index.ts
+var Button = withInstall(Button_default, "AmButton");
+export { Button as default };

package/dist/button/interface.d.ts

@@ -0,0 +1,49 @@
+import type { CSSProperties } from 'vue';
+import type { RenderNodeFn, SizeType, VueNode } from '../_util/type';
+export type ButtonType = 'default' | 'primary' | 'dashed' | 'link' | 'text';
+export type ButtonColorType = 'default' | 'primary' | 'danger' | 'success' | 'warning';
+export type ButtonVariantType = 'outlined' | 'dashed' | 'solid' | 'filled' | 'text' | 'link';
+export type ButtonShape = 'default' | 'circle' | 'round';
+export type ButtonHTMLType = 'submit' | 'button' | 'reset';
+export interface ButtonSemanticClassNames {
+    root?: string;
+    icon?: string;
+    content?: string;
+}
+export interface ButtonSemanticStyles {
+    root?: CSSProperties;
+    icon?: CSSProperties;
+    content?: CSSProperties;
+}
+export interface ButtonProps {
+    /** Syntactic sugar of `color` + `variant` */
+    type?: ButtonType;
+    color?: ButtonColorType;
+    variant?: ButtonVariantType;
+    icon?: VueNode;
+    iconPlacement?: 'start' | 'end';
+    shape?: ButtonShape;
+    size?: SizeType;
+    disabled?: boolean;
+    loading?: boolean | {
+        delay?: number;
+        icon?: RenderNodeFn;
+    };
+    ghost?: boolean;
+    danger?: boolean;
+    /** Fit the width of the parent */
+    block?: boolean;
+    href?: string;
+    target?: string;
+    htmlType?: ButtonHTMLType;
+    rootClass?: string;
+    classes?: ButtonSemanticClassNames;
+    styles?: ButtonSemanticStyles;
+}
+export interface ButtonEmits {
+    click: [event: MouseEvent];
+}
+export interface ButtonSlots {
+    default?: () => any;
+    icon?: () => any;
+}

package/dist/button/style/index.css

@@ -0,0 +1,246 @@
+.am-button {
+  /* component tokens */
+  --am-button-height: var(--am-control-height);
+  --am-button-font-size: var(--am-font-size-lg);
+  --am-button-padding-inline: var(--am-padding);
+  --am-button-border-radius: var(--am-border-radius);
+  --am-button-font-weight: 400;
+  --am-button-icon-gap: 6px;
+  /* resolved by color-* classes */
+  --am-button-c: var(--am-color-primary);
+  --am-button-c-active: var(--am-color-primary-active);
+  --am-button-c-bg: var(--am-color-primary-bg);
+  --am-button-c-bg-active: var(--am-color-primary-bg-hover);
+  --am-button-solid-text: var(--am-color-text-light-solid);
+
+  position: relative;
+  display: inline-flex;
+  gap: var(--am-button-icon-gap);
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  height: var(--am-button-height);
+  margin: 0;
+  padding: 0 var(--am-button-padding-inline);
+  color: var(--am-color-text);
+  font-weight: var(--am-button-font-weight);
+  font-size: var(--am-button-font-size);
+  font-family: var(--am-font-family);
+  line-height: 1.2;
+  white-space: nowrap;
+  text-align: center;
+  text-decoration: none;
+  background: transparent;
+  border: var(--am-line-width) solid transparent;
+  border-radius: var(--am-button-border-radius);
+  outline: none;
+  cursor: pointer;
+  transition:
+    background-color var(--am-motion-duration-mid),
+    border-color var(--am-motion-duration-mid),
+    color var(--am-motion-duration-mid),
+    opacity var(--am-motion-duration-mid);
+  user-select: none;
+  touch-action: manipulation;
+  -webkit-tap-highlight-color: transparent;
+  appearance: none;
+}
+
+.am-button:focus-visible {
+  outline: 2px solid var(--am-color-primary-border);
+  outline-offset: 1px;
+}
+
+.am-button-icon {
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  font-size: 1.1em;
+}
+
+.am-button-content {
+  display: inline-flex;
+  align-items: center;
+  min-width: 0;
+}
+
+.am-button-icon-end {
+  flex-direction: row-reverse;
+}
+
+/* ---------- colors ---------- */
+.am-button-color-default {
+  --am-button-c: var(--am-color-text);
+  --am-button-c-active: var(--am-color-text-secondary);
+  --am-button-c-bg: var(--am-color-fill-tertiary);
+  --am-button-c-bg-active: var(--am-color-fill-secondary);
+  --am-button-solid-text: var(--am-color-bg-container);
+}
+
+.am-button-color-danger {
+  --am-button-c: var(--am-color-error);
+  --am-button-c-active: var(--am-color-error-active);
+  --am-button-c-bg: var(--am-color-error-bg);
+  --am-button-c-bg-active: var(--am-color-error-bg-hover);
+}
+
+.am-button-color-success {
+  --am-button-c: var(--am-color-success);
+  --am-button-c-active: var(--am-color-success-active);
+  --am-button-c-bg: var(--am-color-success-bg);
+  --am-button-c-bg-active: var(--am-color-success-border);
+}
+
+.am-button-color-warning {
+  --am-button-c: var(--am-color-warning);
+  --am-button-c-active: var(--am-color-warning-active);
+  --am-button-c-bg: var(--am-color-warning-bg);
+  --am-button-c-bg-active: var(--am-color-warning-border);
+}
+
+/* ---------- variants ---------- */
+.am-button-variant-solid {
+  color: var(--am-button-solid-text);
+  background: var(--am-button-c);
+}
+
+.am-button-variant-solid:active {
+  background: var(--am-button-c-active);
+}
+
+.am-button-variant-outlined,
+.am-button-variant-dashed {
+  color: var(--am-button-c);
+  background: var(--am-color-bg-container);
+  border-color: var(--am-button-c);
+}
+
+.am-button-variant-dashed {
+  border-style: dashed;
+}
+
+.am-button-color-default.am-button-variant-outlined,
+.am-button-color-default.am-button-variant-dashed {
+  border-color: var(--am-color-border);
+}
+
+.am-button-variant-outlined:active,
+.am-button-variant-dashed:active {
+  background: var(--am-button-c-bg);
+}
+
+.am-button-variant-filled {
+  color: var(--am-button-c);
+  background: var(--am-button-c-bg);
+}
+
+.am-button-variant-filled:active {
+  background: var(--am-button-c-bg-active);
+}
+
+.am-button-variant-text {
+  color: var(--am-button-c);
+}
+
+.am-button-variant-text:active {
+  background: var(--am-button-c-bg);
+}
+
+.am-button-variant-link {
+  height: auto;
+  padding: 0;
+  color: var(--am-button-c);
+  border: 0;
+}
+
+.am-button-variant-link:active {
+  opacity: var(--am-opacity-active);
+}
+
+/* ---------- ghost: for complex backgrounds ---------- */
+.am-button-ghost,
+.am-button-ghost:active {
+  background: transparent;
+}
+
+.am-button-ghost.am-button-variant-solid {
+  color: var(--am-button-c);
+  border-color: var(--am-button-c);
+}
+
+.am-button-ghost.am-button-color-default {
+  color: var(--am-color-white);
+  border-color: var(--am-color-white);
+}
+
+.am-button-ghost:active {
+  opacity: var(--am-opacity-active);
+}
+
+/* ---------- sizes ---------- */
+.am-button-sm {
+  --am-button-height: var(--am-control-height-sm);
+  --am-button-font-size: var(--am-font-size);
+  --am-button-padding-inline: var(--am-padding-sm);
+  --am-button-border-radius: var(--am-border-radius-sm);
+  --am-button-icon-gap: 4px;
+}
+
+.am-button-lg {
+  --am-button-height: var(--am-control-height-lg);
+  --am-button-font-size: var(--am-font-size-xl);
+  --am-button-padding-inline: var(--am-padding-lg);
+  --am-button-border-radius: var(--am-border-radius-lg);
+}
+
+/* ---------- shapes ---------- */
+.am-button-round {
+  --am-button-border-radius: 999px;
+}
+
+.am-button-circle {
+  --am-button-border-radius: 50%;
+
+  width: var(--am-button-height);
+  padding: 0;
+}
+
+.am-button-icon-only:not(.am-button-variant-link) {
+  width: var(--am-button-height);
+  padding: 0;
+}
+
+.am-button-block {
+  display: flex;
+  width: 100%;
+}
+
+/* ---------- states ---------- */
+.am-button-loading {
+  cursor: default;
+  opacity: 0.65;
+  pointer-events: none;
+}
+
+.am-button-disabled,
+.am-button-disabled:active {
+  cursor: not-allowed;
+  opacity: var(--am-opacity-disabled);
+}
+
+.am-button-disabled.am-button-variant-solid:active {
+  background: var(--am-button-c);
+}
+
+.am-button-disabled.am-button-variant-outlined:active,
+.am-button-disabled.am-button-variant-dashed:active {
+  background: var(--am-color-bg-container);
+}
+
+.am-button-disabled.am-button-variant-filled:active {
+  background: var(--am-button-c-bg);
+}
+
+.am-button-disabled.am-button-variant-text:active {
+  background: transparent;
+}

package/dist/calendar/Calendar.js

@@ -0,0 +1,4 @@
+import Calendar_vue_vue_type_script_setup_true_lang_default from "./Calendar.vue_vue_type_script_setup_true_lang.js";
+// src/calendar/Calendar.vue
+var Calendar_default = Calendar_vue_vue_type_script_setup_true_lang_default;
+export { Calendar_default as default };