courthive-components 6.10.2 → 6.11.0

package/dist/dist-D160D4O-.mjs

@@ -0,0 +1,3374 @@
+//#region node_modules/.pnpm/timepicker-ui@4.5.0/node_modules/timepicker-ui/dist/index.js
+var e = () => typeof window > "u", t = () => typeof document < "u", n = () => new Intl.DateTimeFormat(void 0, { hour: "numeric" }).resolvedOptions().hour12 ? "12h" : "24h", r = [
+	[
+		"ui",
+		"viewSwitch",
+		"ui",
+		"enableSwitchIcon"
+	],
+	[
+		"ui",
+		"allowPageScroll",
+		"ui",
+		"enableScrollbar"
+	],
+	[
+		"ui",
+		"keyboardIcon",
+		"ui",
+		"iconTemplate"
+	],
+	[
+		"ui",
+		"clockIcon",
+		"ui",
+		"iconTemplateMobile"
+	],
+	[
+		"behavior",
+		"returnFocus",
+		"behavior",
+		"focusInputAfterClose"
+	],
+	[
+		"timezone",
+		"list",
+		"timezone",
+		"whitelist"
+	],
+	[
+		"labels",
+		"clockTitle",
+		"labels",
+		"time"
+	],
+	[
+		"labels",
+		"keyboardTitle",
+		"labels",
+		"mobileTime"
+	],
+	[
+		"labels",
+		"clock",
+		"labels",
+		"clockLabel"
+	],
+	[
+		"labels",
+		"period",
+		"labels",
+		"periodLabel"
+	],
+	[
+		"labels",
+		"timeFields",
+		"labels",
+		"timeLabel"
+	],
+	[
+		"labels",
+		"range",
+		"labels",
+		"rangeSelectionLabel"
+	],
+	[
+		"labels",
+		"switchToKeyboard",
+		"labels",
+		"switchToKeyboardLabel"
+	],
+	[
+		"labels",
+		"switchToClock",
+		"labels",
+		"switchToClockLabel"
+	],
+	[
+		"labels",
+		"rangeFrom",
+		"range",
+		"fromLabel"
+	],
+	[
+		"labels",
+		"rangeTo",
+		"range",
+		"toLabel"
+	],
+	[
+		"labels",
+		"timezone",
+		"timezone",
+		"label"
+	]
+], i = [
+	[
+		"labels",
+		"hour",
+		"labels",
+		"mobileHour"
+	],
+	[
+		"labels",
+		"hour",
+		"labels",
+		"hourLabel"
+	],
+	[
+		"labels",
+		"hour",
+		"labels",
+		"announceHour"
+	],
+	[
+		"labels",
+		"minute",
+		"labels",
+		"mobileMinute"
+	],
+	[
+		"labels",
+		"minute",
+		"labels",
+		"minuteLabel"
+	],
+	[
+		"labels",
+		"minute",
+		"labels",
+		"announceMinute"
+	],
+	[
+		"ui",
+		"appendModalSelector",
+		"ui",
+		"appendTo"
+	]
+], a = (e, t, n) => {
+	let [r, i, a, o] = e, s = t[r];
+	if (!s || !(i in s)) return;
+	let c = t[a] ??= {};
+	n && o in c || (c[o] = s[i]);
+}, o = (e) => {
+	if (e === "now") return !0;
+	if (e) return {
+		time: e.time === "now" ? void 0 : e.time,
+		updateInput: e.updateInput
+	};
+}, s = (e) => {
+	"defaultTime" in e && (e.currentTime = o(e.defaultTime), delete e.defaultTime), "discreteHourJump" in e && (e.smoothHourSnap = !e.discreteHourJump, delete e.discreteHourJump), e.type === "auto" && (e.type = n());
+	let t = e.disabledTime;
+	if (t && "ranges" in t) {
+		let { ranges: n, ...r } = t;
+		e.disabledTime = {
+			...r,
+			interval: n
+		};
+	}
+}, c = (e, t) => {
+	if ("initialView" in e && (e.mobile = e.initialView === "keyboard", delete e.initialView), !e.clearButton || typeof e.clearButton != "object") return;
+	let { clearInput: n } = e.clearButton;
+	e.clearButton = !0, n !== void 0 && ((t.clearBehavior ??= {}).clearInput = n);
+};
+function l(e) {
+	let t = {};
+	return Object.entries(e).forEach(([e, n]) => {
+		t[e] = n ? { ...n } : void 0;
+	}), r.forEach((e) => a(e, t, !1)), i.forEach((e) => a(e, t, !0)), [...r, ...i].forEach(([e, n]) => delete t[e]?.[n]), t.clock && s(t.clock), t.ui && c(t.ui, t), t;
+}
+var u = {
+	clock: {
+		type: "12h",
+		incrementHours: 1,
+		incrementMinutes: 1,
+		autoSwitchToMinutes: !0,
+		showSeconds: !1,
+		incrementSeconds: 1,
+		autoSwitchToSeconds: !0,
+		disabledTime: void 0,
+		currentTime: void 0
+	},
+	ui: {
+		mode: "clock",
+		theme: "basic",
+		animation: !0,
+		backdrop: !0,
+		mobile: !1,
+		enableSwitchIcon: !1,
+		editable: !1,
+		enableScrollbar: !1,
+		cssClass: void 0,
+		appendTo: "",
+		iconTemplate: "",
+		iconTemplateMobile: "",
+		inline: void 0,
+		clearButton: !1
+	},
+	labels: {
+		am: "AM",
+		pm: "PM",
+		ok: "OK",
+		cancel: "Cancel",
+		time: "Select time",
+		mobileTime: "Enter Time",
+		mobileHour: "Hour",
+		mobileMinute: "Minute",
+		second: "Second",
+		clear: "Clear",
+		hourLabel: "Hour",
+		minuteLabel: "Minute",
+		clockLabel: "Clock",
+		periodLabel: "Period",
+		timeLabel: "Time",
+		format24Label: "24-hour",
+		rangeSelectionLabel: "Range selection",
+		switchToKeyboardLabel: "Switch to keyboard input",
+		switchToClockLabel: "Switch to clock",
+		toggleLabel: "Toggle",
+		timezoneSelectorLabel: "Timezone",
+		announceHour: "Hour",
+		announceMinute: "Minutes",
+		announceAmSelected: "AM selected",
+		announcePmSelected: "PM selected",
+		invalidTimeFormat: "Invalid time format",
+		announceCleared: "Time cleared"
+	},
+	behavior: {
+		focusInputAfterClose: !1,
+		focusTrap: !0,
+		delayHandler: 0,
+		id: void 0
+	},
+	callbacks: {
+		onOpen: void 0,
+		onShow: void 0,
+		onCancel: void 0,
+		onConfirm: void 0,
+		onUpdate: void 0,
+		onSelectHour: void 0,
+		onSelectMinute: void 0,
+		onSelectSecond: void 0,
+		onSelectAM: void 0,
+		onSelectPM: void 0,
+		onSelectPeriod: void 0,
+		onSwitchView: void 0,
+		onSwitchFace: void 0,
+		onError: void 0,
+		onTimezoneChange: void 0,
+		onRangeConfirm: void 0,
+		onRangeSwitch: void 0,
+		onRangeValidation: void 0,
+		onWheelScrollStart: void 0,
+		onWheelScrollEnd: void 0,
+		onClear: void 0
+	},
+	timezone: {
+		enabled: !1,
+		default: void 0,
+		whitelist: void 0,
+		label: "Timezone"
+	},
+	range: {
+		enabled: !1,
+		minDuration: void 0,
+		maxDuration: void 0,
+		fromLabel: "From",
+		toLabel: "To"
+	},
+	wheel: {
+		placement: void 0,
+		hideFooter: void 0,
+		commitOnScroll: void 0,
+		hideDisabled: void 0,
+		ignoreOutsideClick: void 0
+	},
+	clearBehavior: { clearInput: !0 }
+};
+function d(e, t = {}) {
+	let n = l(t);
+	return {
+		...e,
+		clock: {
+			...e.clock,
+			...n.clock
+		},
+		ui: {
+			...e.ui,
+			...n.ui
+		},
+		labels: {
+			...e.labels,
+			...n.labels
+		},
+		behavior: {
+			...e.behavior,
+			...n.behavior
+		},
+		callbacks: {
+			...e.callbacks,
+			...n.callbacks
+		},
+		timezone: {
+			...e.timezone,
+			...n.timezone
+		},
+		range: {
+			...e.range,
+			...n.range
+		},
+		wheel: {
+			...e.wheel,
+			...n.wheel
+		},
+		clearBehavior: {
+			...e.clearBehavior,
+			...n.clearBehavior
+		}
+	};
+}
+function f(e = {}) {
+	return d(u, e);
+}
+var p = class {
+	_degreesHours = null;
+	_degreesMinutes = null;
+	_degreesSeconds = null;
+	_options;
+	_isMobileView = !1;
+	_isTouchMouseMove = !1;
+	_disabledTime = null;
+	_cloned = null;
+	_isModalRemove = !0;
+	_isOpen = !1;
+	_isInitialized = !1;
+	_eventHandlersRegistered = !1;
+	_isDestroyed = !1;
+	_modalElement = null;
+	element;
+	instanceId;
+	customId;
+	constructor(e, t, n, r) {
+		this.element = e, this.instanceId = n, this.customId = r, this._options = t;
+	}
+	get degreesHours() {
+		return this._degreesHours;
+	}
+	get degreesMinutes() {
+		return this._degreesMinutes;
+	}
+	get degreesSeconds() {
+		return this._degreesSeconds;
+	}
+	get options() {
+		return this._options;
+	}
+	get isMobileView() {
+		return this._isMobileView;
+	}
+	get isTouchMouseMove() {
+		return this._isTouchMouseMove;
+	}
+	get disabledTime() {
+		return this._disabledTime;
+	}
+	get cloned() {
+		return this._cloned;
+	}
+	get isModalRemove() {
+		return this._isModalRemove;
+	}
+	get isOpen() {
+		return this._isOpen;
+	}
+	get isInitialized() {
+		return this._isInitialized;
+	}
+	get eventHandlersRegistered() {
+		return this._eventHandlersRegistered;
+	}
+	get isDestroyed() {
+		return this._isDestroyed;
+	}
+	setDegreesHours(e) {
+		this._degreesHours = e;
+	}
+	setDegreesMinutes(e) {
+		this._degreesMinutes = e;
+	}
+	setDegreesSeconds(e) {
+		this._degreesSeconds = e;
+	}
+	setOptions(e) {
+		this._options = e;
+	}
+	setIsMobileView(e) {
+		this._isMobileView = e;
+	}
+	setIsTouchMouseMove(e) {
+		this._isTouchMouseMove = e;
+	}
+	setDisabledTime(e) {
+		this._disabledTime = e;
+	}
+	setCloned(e) {
+		this._cloned = e;
+	}
+	setIsModalRemove(e) {
+		this._isModalRemove = e;
+	}
+	setIsOpen(e) {
+		this._isOpen = e;
+	}
+	setIsInitialized(e) {
+		this._isInitialized = e;
+	}
+	setEventHandlersRegistered(e) {
+		this._eventHandlersRegistered = e;
+	}
+	setIsDestroyed(e) {
+		this._isDestroyed = e;
+	}
+	updateOptions(e) {
+		this._options = d(this._options, e);
+	}
+	reset() {
+		this._degreesHours = null, this._degreesMinutes = null, this._degreesSeconds = null, this._isTouchMouseMove = !1, this._disabledTime = null, this._cloned = null, this._isModalRemove = !0, this._isOpen = !1, this._isInitialized = !1, this._isDestroyed = !0, this._eventHandlersRegistered = !1, this._modalElement = null;
+	}
+	q(e) {
+		return this.getModalElement()?.querySelector(e) ?? null;
+	}
+	qMobile(e, t) {
+		return this._isMobileView ? this.q(e) : this.q(t);
+	}
+	getModalElement() {
+		if (t() === !1) return null;
+		let e = this._modalElement;
+		if (e?.isConnected && e.dataset.ownerId === this.instanceId) return e;
+		let n = document.querySelectorAll("[data-owner-id]");
+		for (let e = 0; e < n.length; e++) if (n[e].dataset.ownerId === this.instanceId) return this._modalElement = n[e], this._modalElement;
+		return this._modalElement = null, null;
+	}
+	getInput() {
+		return this.element?.querySelector("input");
+	}
+	getClockFace() {
+		return this.qMobile(".tp-ui-clock-face.mobile", ".tp-ui-clock-face:not(.mobile)") ?? this.q(".tp-ui-clock-face");
+	}
+	getClockHand() {
+		return this.qMobile(".tp-ui-mobile-clock-wrapper .tp-ui-clock-hand", ".tp-ui-clock-hand:not(.mobile)");
+	}
+	getCircle() {
+		return this.qMobile(".tp-ui-mobile-clock-wrapper .tp-ui-circle-hand", ".tp-ui-circle-hand:not(.mobile)");
+	}
+	getTipsWrapper() {
+		return this.qMobile(".tp-ui-mobile-clock-wrapper .tp-ui-tips-wrapper", ".tp-ui-tips-wrapper:not(.mobile)");
+	}
+	getTipsWrapperFor24h() {
+		return this.qMobile(".tp-ui-mobile-clock-wrapper .tp-ui-tips-wrapper-24h", ".tp-ui-tips-wrapper-24h:not(.mobile)");
+	}
+	getMinutes() {
+		return this.q(".tp-ui-minutes");
+	}
+	getSeconds() {
+		return this.q(".tp-ui-seconds");
+	}
+	getHour() {
+		return this.q(".tp-ui-hour");
+	}
+	getAM() {
+		return this.q(".tp-ui-am");
+	}
+	getPM() {
+		return this.q(".tp-ui-pm");
+	}
+	getHourText() {
+		return this.q(".tp-ui-hour-text");
+	}
+	getMinutesText() {
+		return this.q(".tp-ui-minute-text");
+	}
+	getSecondsText() {
+		return this.q(".tp-ui-second-text");
+	}
+	getHeader() {
+		return this.q(".tp-ui-header");
+	}
+	getInputWrappers() {
+		return this.getModalElement()?.querySelectorAll(".tp-ui-input-wrapper") || null;
+	}
+	getDots() {
+		return this.q(".tp-ui-dots");
+	}
+	getMinutesTips() {
+		return this.q(".tp-ui-minutes-time");
+	}
+	getHourTips() {
+		return this.q(".tp-ui-hour-time-12");
+	}
+	getAllValueTips() {
+		let e = this.getModalElement();
+		return e ? [...e.querySelectorAll(".tp-ui-value-tips"), ...e.querySelectorAll(".tp-ui-value-tips-24h")] : [];
+	}
+	getOpenElementData() {
+		let e = this.element?.querySelectorAll("[data-open]");
+		if (e?.length > 0) {
+			let t = [];
+			return e.forEach(({ dataset: e }) => t.push(e.open ?? "")), [...new Set(t)];
+		}
+		return null;
+	}
+	getOpenElement() {
+		let e = Array.from(this.element.querySelectorAll("[data-open]"));
+		if (e.length === 0) {
+			let e = this.getInput();
+			return e?.setAttribute("data-open", "tp-ui-input"), [e];
+		}
+		let t = e[0].dataset.open;
+		return e.filter((e) => e.dataset.open === t);
+	}
+	getCancelButton() {
+		return this.q(".tp-ui-cancel-btn");
+	}
+	getOkButton() {
+		return this.q(".tp-ui-ok-btn");
+	}
+	getActiveTypeMode() {
+		return this.q(".tp-ui-type-mode.active");
+	}
+	getActiveType() {
+		let e = this.getActiveTypeMode()?.dataset.type;
+		return e === "AM" || e === "PM" ? e : void 0;
+	}
+	getKeyboardClockIcon() {
+		return this.q(".tp-ui-keyboard-icon");
+	}
+	getFooter() {
+		return this.q(".tp-ui-footer");
+	}
+	getWrapper() {
+		return this.q(".tp-ui-wrapper");
+	}
+}, m = {
+	MODAL_EXIT: 150,
+	TIPS_ANIMATION: 401,
+	MOBILE_TOGGLE: 450,
+	CLOCK_SCALE_DELAY: 150,
+	WRAPPER_TRANSITION: 400,
+	DROPDOWN_CLICK_DELAY: 10,
+	ANNOUNCE_DELAY: 100,
+	COMMIT_ON_SCROLL_DELAY: 400
+}, h = (e, t) => {
+	if (!e) return;
+	let n = e.querySelector(".timepicker-announcer");
+	n && (n.textContent = "", setTimeout(() => {
+		n.textContent = t;
+	}, m.ANNOUNCE_DELAY));
+}, g = (e, t, n) => {
+	e?.classList.toggle(t, n);
+}, _ = (e, t, n) => {
+	n ? e.getAttribute(t) !== n && e.setAttribute(t, n) : e.removeAttribute(t);
+}, v = (e, t) => {
+	e && _(e, "aria-pressed", String(t));
+}, y = (e, t) => {
+	g(e, "active", t), v(e, t);
+}, b = (e, t, n) => {
+	y(e, n === "AM"), y(t, n === "PM");
+}, ee = [
+	"aria-label",
+	"aria-valuemin",
+	"aria-valuemax",
+	"aria-valuenow",
+	"aria-valuetext"
+], x = (e) => {
+	if (!e) return;
+	let t = e.querySelector(".tp-ui-clock-face");
+	if (!t) return;
+	let n = e.querySelector("input.active") ?? e.querySelector(".tp-ui-hour");
+	ee.forEach((e) => _(t, e, n?.getAttribute(e)));
+}, S = (e, t) => {
+	if (!e) return;
+	e.value = t;
+	let n = parseInt(t, 10), r = !Number.isNaN(n);
+	_(e, "aria-valuenow", r && String(n)), _(e, "aria-valuetext", r && t), x(e.closest(".tp-ui-modal"));
+}, te = (e) => e.getAttribute("aria-disabled") === "true" || e.classList.contains("disabled"), C = (e, t) => {
+	e && (g(e, "disabled", t), _(e, "aria-disabled", String(t)));
+}, ne = "[role=\"button\"], [tabindex], input, select, textarea", re = "button, a[href], summary, input[type=\"button\"], input[type=\"submit\"], input[type=\"reset\"], input[type=\"image\"]", ie = (e) => e.matches(ne) && !e.matches(re), ae = (e) => e === "Enter" || e === " ", w = (e, t) => {
+	if (!e) return () => {};
+	let n = (n) => {
+		te(e) || t(n);
+	}, r = (n) => {
+		ae(n.key) && ie(e) && (n.key !== "Enter" && n.preventDefault(), !te(e) && t(n));
+	};
+	return e.addEventListener("click", n), e.addEventListener("keydown", r), () => {
+		e.removeEventListener("click", n), e.removeEventListener("keydown", r);
+	};
+}, oe = "tp-ui-pointer", se = [
+	"Shift",
+	"Control",
+	"Alt",
+	"Meta"
+], ce = (e) => {
+	let t = e.ownerDocument, n = () => g(e, oe, !0), r = (t) => {
+		se.includes(t.key) || g(e, oe, !1);
+	};
+	return e.addEventListener("pointerdown", n, !0), t.addEventListener("keydown", r, !0), () => {
+		e.removeEventListener("pointerdown", n, !0), t.removeEventListener("keydown", r, !0);
+	};
+}, T = () => typeof window > "u" || typeof window.matchMedia != "function" ? !1 : window.matchMedia("(prefers-reduced-motion: reduce)").matches, le = class {
+	core;
+	emitter;
+	timeouts = [];
+	constructor(e, t) {
+		this.core = e, this.emitter = t, this.setupEventListeners();
+	}
+	setupEventListeners() {
+		this.emitter.on("animation:clock", () => {
+			this.handleAnimationSwitchTipsMode();
+		});
+	}
+	clearAllTimeouts() {
+		this.timeouts.forEach(clearTimeout), this.timeouts = [];
+	}
+	setAnimationToOpen(e = !1) {
+		let t = this.core.getModalElement();
+		t && (!e && this.core.options.ui.animation && t.offsetHeight, t.classList.add("show"));
+	}
+	removeAnimationToClose() {
+		return this.clearAllTimeouts(), this.core.getModalElement()?.classList.remove("show"), this.core.options.ui.animation && !T() ? m.MODAL_EXIT : 0;
+	}
+	handleAnimationSwitchTipsMode() {
+		let e = this.core.getClockHand();
+		if (!e || !this.core.options.ui.animation || T()) return;
+		this.emitter.emit("animation:start", {}), e.classList.add("tp-ui-tips-animation");
+		let t = setTimeout(() => {
+			this.core.getClockHand()?.classList.remove("tp-ui-tips-animation"), this.emitter.emit("animation:end", {});
+		}, m.TIPS_ANIMATION);
+		this.timeouts.push(t);
+	}
+	destroy() {
+		this.clearAllTimeouts();
+	}
+}, ue = "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\" width=\"24px\" fill=\"#e3e3e3\"><path d=\"M160-200q-33 0-56.5-23.5T80-280v-400q0-33 23.5-56.5T160-760h640q33 0 56.5 23.5T880-680v400q0 33-23.5 56.5T800-200H160Zm0-80h640v-400H160v400Zm160-40h320v-80H320v80ZM200-440h80v-80h-80v80Zm120 0h80v-80h-80v80Zm120 0h80v-80h-80v80Zm120 0h80v-80h-80v80Zm120 0h80v-80h-80v80ZM200-560h80v-80h-80v80Zm120 0h80v-80h-80v80Zm120 0h80v-80h-80v80Zm120 0h80v-80h-80v80Zm120 0h80v-80h-80v80ZM160-280v-400 400Z\"/></svg>", de = "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\" width=\"24px\" fill=\"#e3e3e3\"><path d=\"m612-292 56-56-148-148v-184h-80v216l172 172ZM480-80q-83 0-156-31.5T197-197q-54-54-85.5-127T80-480q0-83 31.5-156T197-763q54-54 127-85.5T480-880q83 0 156 31.5T763-763q54 54 85.5 127T880-480q0 83-31.5 156T763-197q-54 54-127 85.5T480-80Zm0-400Zm0 320q133 0 226.5-93.5T800-480q0-133-93.5-226.5T480-800q-133 0-226.5 93.5T160-480q0 133 93.5 226.5T480-160Z\"/></svg>", E = new class {
+	plugins = /* @__PURE__ */ new Map();
+	register(e) {
+		this.plugins.has(e.name) || this.plugins.set(e.name, e);
+	}
+	getAll() {
+		return Array.from(this.plugins.values());
+	}
+	has(e) {
+		return this.plugins.has(e);
+	}
+	get(e) {
+		return this.plugins.get(e);
+	}
+	getTemplateProvider(e) {
+		return this.plugins.get(e)?.templateProvider;
+	}
+	getClearHandler(e) {
+		return this.plugins.get(e)?.clearHandler;
+	}
+}(), fe = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+}, D = (e) => String(e ?? "").replace(/[&<>"']/g, (e) => fe[e]), pe = [
+	"00",
+	"13",
+	"14",
+	"15",
+	"16",
+	"17",
+	"18",
+	"19",
+	"20",
+	"21",
+	"22",
+	"23"
+], me = [
+	"12",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9",
+	"10",
+	"11"
+], he = [
+	"00",
+	"05",
+	"10",
+	"15",
+	"20",
+	"25",
+	"30",
+	"35",
+	"40",
+	"45",
+	"50",
+	"55"
+], ge = (e, t, n) => {
+	let { timezone: { enabled: r, label: i } } = e;
+	if (!r || !E.has("timezone")) return "";
+	let a = D(i ?? u.timezone.label), o = D(n);
+	return `<div class="tp-ui-timezone ${t}">
+        <span class="tp-ui-timezone-label" id="tp-tz-label-${o}">${a}</span>
+        <div class="tp-ui-timezone-dropdown" role="combobox" aria-expanded="false" aria-haspopup="listbox" aria-labelledby="tp-tz-label-${o}" tabindex="0" data-tz-id="${o}">
+          <div class="tp-ui-timezone-selected" data-md3-ripple data-placeholder="${a}...">${a}...</div>
+          <svg class="tp-ui-timezone-arrow" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="6 9 12 15 18 9"></polyline></svg>
+          <div class="tp-ui-timezone-menu" role="listbox" aria-labelledby="tp-tz-label-${o}"></div>
+        </div>
+      </div>`;
+}, _e = (e) => {
+	let { range: { enabled: t, fromLabel: n, toLabel: r }, labels: { rangeSelectionLabel: i } } = e;
+	return !t || !E.has("range") ? "" : `<div class="tp-ui-range-header" role="tablist" aria-label="${D(i)}"><button type="button" class="tp-ui-range-tab tp-ui-range-from active" data-md3-ripple role="tab" tabindex="0" aria-selected="true"><span class="tp-ui-range-tab-label">${D(n)}</span><span class="tp-ui-range-tab-value tp-ui-range-from-time" aria-hidden="true">--:--</span></button><button type="button" class="tp-ui-range-tab tp-ui-range-to" data-md3-ripple role="tab" tabindex="-1" aria-selected="false"><span class="tp-ui-range-tab-label">${D(r)}</span><span class="tp-ui-range-tab-value tp-ui-range-to-time" aria-hidden="true">--:--</span></button></div>`;
+}, ve = (e, t) => {
+	let { ui: { clearButton: n }, labels: { clear: r } } = e;
+	if (!n) return "";
+	let i = D(r);
+	return `<div class="tp-ui-clear-btn ${t} disabled" data-md3-ripple tabindex="0" role="button" aria-label="${i}" aria-disabled="true">${i}</div>`;
+}, ye = (e, t, n) => {
+	if (e.isWheelMode) {
+		let t = E.getTemplateProvider("wheel");
+		return t ? `<div class="tp-ui-mobile-clock-wrapper ${e.mobileClass}">${t(n, e.instanceId)}</div>` : `<div class="tp-ui-mobile-clock-wrapper ${e.mobileClass}"></div>`;
+	}
+	let { clockLabel: r } = n.labels;
+	return `<div class="tp-ui-mobile-clock-wrapper ${e.mobileClass}"><div class="tp-ui-body ${e.mobileClass}" role="group" aria-label="${D(r)}"><div class="tp-ui-clock-face ${e.mobileClass}" role="slider" tabindex="0"><div class="tp-ui-dot ${e.mobileClass}" aria-hidden="true"></div><div class="tp-ui-clock-hand ${e.mobileClass}" aria-hidden="true"><div class="tp-ui-circle-hand ${e.mobileClass}"></div></div><div class="tp-ui-tips-wrapper ${e.mobileClass}" aria-hidden="true"></div>${e.clockType === "24h" ? `<div class="tp-ui-tips-wrapper-24h ${e.mobileClass}" aria-hidden="true"></div>` : ""}</div></div></div>`;
+}, be = {
+	min: "0",
+	max: "59",
+	valueNow: "0",
+	valueText: "00"
+}, xe = (e) => `<div class="tp-ui-dots ${e}" aria-hidden="true"><span></span><span></span></div>`, Se = (e, t, n) => {
+	let r = D(e.mobileLabel), i = t ? r : D(e.label);
+	return `<div class="tp-ui-input-wrapper ${t}"><div class="tp-ui-input-ripple-wrapper ${t}" data-md3-ripple><input name="${e.name}" ${n ? "readonly" : ""} class="${e.inputClass} ${t}" tabindex="0" type="number" min="${e.min}" max="${e.max}" aria-label="${i}" role="spinbutton" aria-valuemin="${e.min}" aria-valuemax="${e.max}" aria-valuenow="${e.valueNow}" aria-valuetext="${e.valueText}"></div><div class="${e.textClass} ${t}">${r}</div></div>`;
+}, Ce = (e, t) => {
+	let { labels: n, ui: { editable: r }, clock: { showSeconds: i } } = e, { mobileClass: a, clockType: o, instanceId: s } = t, c = D(a ? n.mobileTime : n.time), l = D(n.timeLabel), u = D(n.am), d = D(n.pm), f = D(n.periodLabel), p = o === "12h", m = p ? "12" : "0", h = [{
+		name: "hour",
+		inputClass: "tp-ui-hour",
+		textClass: "tp-ui-hour-text",
+		min: p ? "1" : "0",
+		max: p ? "12" : "23",
+		valueNow: m,
+		valueText: m,
+		label: n.hourLabel,
+		mobileLabel: n.mobileHour
+	}, {
+		name: "minutes",
+		inputClass: "tp-ui-minutes",
+		textClass: "tp-ui-minute-text",
+		...be,
+		label: n.minuteLabel,
+		mobileLabel: n.mobileMinute
+	}];
+	i && h.push({
+		name: "seconds",
+		inputClass: "tp-ui-seconds",
+		textClass: "tp-ui-second-text",
+		...be,
+		label: n.second,
+		mobileLabel: n.second
+	});
+	let g = !r && !a, _ = h.map((e) => Se(e, a, g)).join(xe(a)), v = o === "24h" ? "" : `<div class="tp-ui-wrapper-type-time ${a}" role="group" aria-label="${f}"><div class="tp-ui-type-mode tp-ui-am ${a}" data-md3-ripple tabindex="0" role="button" aria-label="${u}" aria-pressed="false" data-type="AM">${u}</div><div class="tp-ui-type-mode tp-ui-pm ${a}" data-md3-ripple tabindex="0" role="button" aria-label="${d}" aria-pressed="false" data-type="PM">${d}</div></div>`;
+	return `<div class="tp-ui-select-time ${a}" id="tp-ui-label-${D(s)}">${c}</div><div class="tp-ui-header ${a}"><div class="tp-ui-wrapper-time ${a} ${o === "24h" ? "tp-ui-wrapper-time-24h" : ""}" role="group" aria-label="${l}">${_}</div>${v}</div>`;
+}, we = (e, t) => `<button aria-label="${D(e)}" type="button" class="tp-ui-keyboard-icon">${t}</button>`, Te = (e, t) => {
+	let { ui: { enableSwitchIcon: n, iconTemplate: r, iconTemplateMobile: i }, labels: a } = e, o = D(a.cancel), s = D(a.ok), c = t ? we(a.switchToClockLabel, i || de) : we(a.switchToKeyboardLabel, r || ue), l = n ? `<div class="tp-ui-keyboard-icon-wrapper ${t}" data-md3-ripple data-view="desktop">${c}</div>` : "", u = ve(e, t);
+	return `<div class="tp-ui-footer ${t}" ${t ? "data-view=\"mobile\"" : ""}>${l}<div class="tp-ui-wrapper-btn ${t}">${u}<div class="tp-ui-cancel-btn ${t}" data-md3-ripple tabindex="0" role="button" aria-label="${o}">${o}</div><div class="tp-ui-ok-btn ${t}" data-md3-ripple tabindex="0" role="button" aria-label="${s}">${s}</div></div></div>`;
+}, Ee = (e, t) => {
+	let { ui: { mode: n, animation: r, theme: i, mobile: a }, clock: { incrementMinutes: o, showSeconds: s } } = e, c = a ? "mobile" : "", l = n === "compact-wheel" && E.has("wheel"), u = (n === "wheel" || l) && E.has("wheel"), d = !!e.range?.enabled && E.has("range"), f = !!e.timezone?.enabled && E.has("timezone"), p = {
+		mobileClass: c,
+		clockType: e.clock.type || "12h",
+		instanceId: t,
+		isWheelMode: u,
+		isCompactWheel: l,
+		isRangeMode: d
+	}, m = _e(e), h = ge(e, c, t), g = l ? "" : Ce(e, p), _ = ye(p, o ?? 1, e), v = l && e.wheel?.hideFooter === !0 ? "" : Te(e, c), y;
+	y = l ? " tp-ui-compact-wheel-mode" : u ? " tp-ui-wheel-mode" : "";
+	let b = D(t);
+	return `<div class="tp-ui-modal normalize ${c}${d ? " tp-ui-range-mode" : ""}${f ? " tp-ui-tz-mode" : ""}${y}${s ? " tp-ui-has-seconds" : ""}" data-theme="${D(i)}" role="dialog" aria-modal="true" aria-labelledby="tp-ui-label-${b}" data-owner-id="${b}"${r ? "" : " style=\"transition:none\""}><div class="tp-ui-wrapper ${c}" tabindex="0">${m}${g}${h}${_}${v}</div><div class="timepicker-announcer sr-only" role="status" aria-live="polite" aria-atomic="true"></div></div>`;
+};
+function O(e) {
+	return e.clock.type === "24h" ? "24h" : "12h";
+}
+function k(e) {
+	return {
+		clockType: O(e),
+		showSeconds: !!e.clock.showSeconds
+	};
+}
+function De(e) {
+	let t = e.ui.mode;
+	return t === "wheel" || t === "compact-wheel";
+}
+function Oe(e) {
+	return e.ui.mode === "compact-wheel";
+}
+function A(e) {
+	return Oe(e) && !!e.wheel?.placement;
+}
+function j(e) {
+	return !!e.ui.inline?.enabled;
+}
+var ke = (e) => !e || !t() ? null : typeof e == "string" ? document.querySelector(e) : e, Ae = (e) => e ? e.container ? ke(e.container) : !e.containerId || !t() ? null : document.getElementById(e.containerId) : null, je = "--tp-scrollbar-gap", Me = ["auto", "scroll"], Ne = /^tp-ui-[\w-]+$/, M = 0, Pe = [], N = "";
+function Fe(e) {
+	return Me.includes(window.getComputedStyle(e).overflowY);
+}
+function Ie(e) {
+	let { style: t } = e, n = e.clientWidth, r = parseFloat(window.getComputedStyle(e).paddingRight) || 0;
+	Pe.push({
+		element: e,
+		overflowY: t.overflowY,
+		paddingRight: t.paddingRight
+	}), t.overflowY = "hidden";
+	let i = Math.max(0, e.clientWidth - n);
+	return i > 0 && (t.paddingRight = `${r + i}px`), i;
+}
+function Le() {
+	if (M === 0) {
+		let { body: e, documentElement: t } = document, n = Fe(e) ? Ie(e) : 0, r = Ie(t);
+		N = t.style.getPropertyValue(je), t.style.setProperty(je, `${Math.max(n, r)}px`);
+	}
+	M += 1;
+}
+function Re() {
+	if (M !== 0 && (--M, M === 0)) {
+		Pe.forEach(({ element: e, overflowY: t, paddingRight: n }) => {
+			e.style.overflowY = t, e.style.paddingRight = n;
+		});
+		let e = document.documentElement;
+		N ? e.style.setProperty(je, N) : e.style.removeProperty(je), Pe = [], N = "";
+	}
+}
+var ze = class {
+	core;
+	scrollLocked = !1;
+	constructor(e, t) {
+		this.core = e;
+	}
+	clearExistingModal() {
+		if (t() === !1) return;
+		let e = this.core.getModalElement();
+		e && e.remove();
+	}
+	setModalTemplate() {
+		if (t() === !1) return;
+		this.clearExistingModal();
+		let e = Ee(this.core.options, this.core.instanceId);
+		if (this.core.options.ui.inline?.enabled) {
+			let t = Ae(this.core.options.ui.inline);
+			if (!t) return;
+			t.innerHTML = "", t.insertAdjacentHTML("beforeend", e);
+			let n = t.querySelector(".tp-ui-modal");
+			if (n) {
+				n.classList.add("tp-ui--inline");
+				let { showButtons: e } = this.core.options.ui.inline;
+				(e === !1 || e === void 0) && (n.querySelectorAll(".tp-ui-wrapper-btn, .tp-ui-wrapper-btn.mobile").forEach((e) => e.style.display = "none"), n.querySelectorAll(".tp-ui-footer").forEach((e) => {
+					e.querySelector(".tp-ui-keyboard-icon-wrapper") || (e.style.display = "none");
+				}));
+			}
+			return;
+		}
+		let { appendTo: n } = this.core.options.ui;
+		(n ? ke(n) : document.body)?.insertAdjacentHTML("beforeend", e);
+	}
+	lockScroll() {
+		t() !== !1 && (this.core.options.ui.inline?.enabled || A(this.core.options) || this.core.options.ui.enableScrollbar || this.scrollLocked || (this.scrollLocked = !0, Le()));
+	}
+	unlockScroll() {
+		t() !== !1 && this.scrollLocked && (this.scrollLocked = !1, Re());
+	}
+	setScrollbarOrNot() {
+		this.core.options.ui.enableScrollbar ? this.unlockScroll() : this.lockScroll();
+	}
+	removeBackdrop() {
+		if (this.core.options.ui.inline?.enabled || this.core.options.ui.backdrop) return;
+		let e = this.core.getModalElement(), t = this.core.getOpenElement();
+		e?.classList.add("removed"), t.forEach((e) => e?.classList.add("disabled"));
+	}
+	setNormalizeClass() {
+		let e = this.core.getModalElement();
+		e && (e.classList.add("tp-ui-normalize"), e.querySelectorAll(":scope > div").forEach((e) => e.classList.add("tp-ui-normalize")));
+	}
+	setInitialFocus() {
+		let { options: e } = this.core;
+		!e.behavior.focusTrap || typeof requestAnimationFrame > "u" || !e.ui.backdrop && !e.ui.inline?.enabled && !A(e) || requestAnimationFrame(() => this.focusWrapperUnlessInside());
+	}
+	focusWrapperUnlessInside() {
+		let e = this.core.getWrapper();
+		e && !e.contains(e.ownerDocument.activeElement) && e.focus();
+	}
+	getFocusedControlSelector() {
+		let e = this.core.getModalElement(), t = e?.ownerDocument.activeElement;
+		return !e || !t || !e.contains(t) ? null : Array.from(t.classList).filter((e) => Ne.test(e)).map((e) => `.${e}`).join("");
+	}
+	restoreFocus(e) {
+		e && this.core.getWrapper()?.querySelector(e)?.focus(), this.focusWrapperUnlessInside();
+	}
+	setFlexEndToFooterIfNoKeyboardIcon() {
+		let e = this.core.getFooter();
+		!this.core.options.ui.enableSwitchIcon && e && (e.style.justifyContent = "flex-end");
+	}
+	destroy() {
+		this.unlockScroll(), this.clearExistingModal();
+	}
+}, Be = /^(0?[1-9]|1[0-2]):([0-5]?\d)(?::([0-5]?\d))?\s*(AM|PM)$/i, Ve = /^([01]?\d|2[0-3]):([0-5]?\d)(?::([0-5]?\d))?$/, He = /^\s*\d{1,2}:\d{1,2}:\d{1,2}/, P = (e) => String(e).padStart(2, "0");
+function F(e, t) {
+	let n = e.trim().match(t.clockType === "12h" ? Be : Ve);
+	if (!n) return null;
+	let r = {
+		hour: P(n[1]),
+		minutes: P(n[2])
+	};
+	return t.showSeconds && (r.seconds = P(n[3] ?? "0")), t.clockType === "12h" && (r.type = n[4].toUpperCase()), r;
+}
+function Ue(e) {
+	return He.test(e);
+}
+function I(e, t) {
+	let n = `${P(e.hour)}:${P(e.minutes)}`, r = t.showSeconds ? `${n}:${P(e.seconds ?? "0")}` : n;
+	return t.clockType === "12h" && e.type ? `${r} ${e.type}` : r;
+}
+var We = (e, t, n) => {
+	if (n !== "12h" || !t) return e;
+	let r = t.toUpperCase();
+	return r === "PM" && e !== 12 ? e + 12 : r === "AM" && e === 12 ? 0 : e;
+};
+function Ge(e, t, n) {
+	return n === "24h" ? {
+		hour: P(e),
+		...t,
+		type: void 0
+	} : {
+		hour: P(e % 12 || 12),
+		...t,
+		type: e >= 12 ? "PM" : "AM"
+	};
+}
+function Ke(e, t, n) {
+	let r = We(parseInt(e.hour, 10), e.type, t), i = n.showSeconds ? P(e.seconds ?? "0") : void 0;
+	return Ge(r, {
+		minutes: e.minutes,
+		seconds: i
+	}, n.clockType);
+}
+function qe(e, t) {
+	let n = parseInt(e.hour, 10);
+	return Number.isNaN(n) ? 0 : We(n, e.type, t) * 3600;
+}
+function L(e, t) {
+	let n = parseInt(e.hour, 10), r = parseInt(e.minutes, 10), i = parseInt(e.seconds ?? "0", 10);
+	return Number.isNaN(n) || Number.isNaN(r) || Number.isNaN(i) ? 0 : We(n, e.type, t) * 3600 + r * 60 + i;
+}
+function Je(e) {
+	return {
+		degreesHours: Number(e.hour) * 30,
+		degreesMinutes: Number(e.minutes) * 6
+	};
+}
+var Ye = 8, Xe = 11, Ze = ({ hour: e, minutes: t, seconds: n, type: r }) => n === void 0 ? {
+	hour: e,
+	minutes: t,
+	type: r
+} : {
+	hour: e,
+	minutes: t,
+	seconds: n,
+	type: r
+}, Qe = (e, t, n) => {
+	let r = P(e.getMinutes()), i = n ? P(e.getSeconds()) : void 0;
+	return Ze(Ge(e.getHours(), {
+		minutes: r,
+		seconds: i
+	}, t === "24h" ? "24h" : "12h"));
+}, R = (e, t, r, i, a = !1) => {
+	let o = Ze({
+		hour: "12",
+		minutes: "00",
+		seconds: a ? "00" : void 0,
+		type: t === "24h" ? void 0 : "PM"
+	});
+	if (!e) return o;
+	let s = e.value.trim();
+	if (!r && !s) return o;
+	if (typeof r == "boolean" && r) return Qe(/* @__PURE__ */ new Date(), t, a);
+	if (typeof r == "object") {
+		let { time: e, preventClockType: o } = r, s = new Date(e ?? /* @__PURE__ */ new Date());
+		return o && i ? Qe(s, n(), a) : Qe(s, t, a);
+	}
+	let c = F(s, {
+		clockType: t === "24h" ? "24h" : "12h",
+		showSeconds: a
+	});
+	if (c) return Ze(c);
+	let [l, u] = s.split(" "), [d = "", f = "", p = ""] = l.split(":"), m = d.replace(/\D/g, ""), h = f.replace(/\D/g, ""), g = a ? p.replace(/\D/g, "") : "", _ = {
+		hour: m.padStart(2, "0"),
+		minutes: h.padStart(2, "0"),
+		type: t === "12h" ? u : void 0
+	};
+	if (a && (_.seconds = g.padStart(2, "0")), m.length > 2 || h.length > 2 || g.length > 2) return {
+		..._,
+		error: "Invalid input: too many digits.",
+		currentHour: d,
+		currentMin: f,
+		...a ? { currentSec: p } : {}
+	};
+	if (/[a-z]/i.test(l)) return {
+		..._,
+		error: "Input contains invalid letters."
+	};
+	if (s.includes(" ")) {
+		let e = a ? Xe : Ye;
+		if (!u || s.length > e || u !== "AM" && u !== "PM") return {
+			..._,
+			error: "Invalid AM/PM format or length.",
+			currentLength: s.length,
+			currentType: u
+		};
+	}
+	let v = Number(m), y = Number(h), b = Number(g), ee = y >= 0 && y <= 59 && b >= 0 && b <= 59, x = a ? { currentSec: b } : {};
+	if (t === "12h") {
+		if (v < 1 || v > 12 || !ee || u !== "AM" && u !== "PM") return {
+			..._,
+			error: "Invalid 12h time.",
+			currentHour: v,
+			currentMin: y,
+			...x,
+			currentType: u
+		};
+	} else if (v < 0 || v > 23 || !ee) return {
+		..._,
+		error: "Invalid 24h time.",
+		currentHour: v,
+		currentMin: y,
+		...x
+	};
+	return _;
+}, $e = (e, t, n) => {
+	let r = Number(e);
+	if (Number.isNaN(r)) return !1;
+	switch (t) {
+		case "hour": return n === "24h" ? r >= 0 && r <= 23 : r > 0 && r <= 12;
+		case "minutes": return r >= 0 && r <= 59;
+		default: return;
+	}
+}, et = 256, z = /* @__PURE__ */ new Map(), tt = (e, t) => (z.size >= et && z.clear(), z.set(e, t), t);
+function nt(e, t) {
+	let n = `${t}|${e}`, r = z.get(n);
+	if (r !== void 0) return r;
+	let i = e.split("-").map((e) => e.trim()), a = null;
+	if (i.length === 2) {
+		let n = F(i[0], {
+			clockType: t,
+			showSeconds: !0
+		}), r = F(i[1], {
+			clockType: t,
+			showSeconds: !0
+		});
+		if (n && r) {
+			let o = Ue(i[1]) ? 0 : 59;
+			a = {
+				start: L(n, t),
+				end: L(r, t) + o,
+				source: e
+			};
+		}
+	}
+	return tt(n, a);
+}
+var rt = [], it = /* @__PURE__ */ new WeakMap(), at = (e, t, n) => {
+	if (e.clockType !== n || e.sources.length !== t.length) return !1;
+	for (let n = 0; n < t.length; n++) if (e.sources[n] !== t[n]) return !1;
+	return !0;
+}, B = (e, t) => {
+	if (!e?.length) return rt;
+	let n = it.get(e);
+	if (n && at(n, e, t)) return n.ranges;
+	let r = e.map((e) => nt(e, t)).filter((e) => e !== null);
+	return it.set(e, {
+		clockType: t,
+		sources: [...e],
+		ranges: r
+	}), r;
+}, ot = (e, t) => {
+	for (let n = 0; n < e.length; n++) if (t >= e[n].start && t <= e[n].end) return !0;
+	return !1;
+};
+function st(e, t) {
+	let n = B(e, t);
+	for (let e = 0; e < n.length; e++) for (let t = e + 1; t < n.length; t++) if (n[e].start <= n[t].end && n[t].start <= n[e].end) return [n[e].source, n[t].source];
+	return null;
+}
+var V = (e, t) => {
+	if (!e || t === void 0) return !1;
+	let n = Number(t);
+	for (let t = 0; t < e.length; t++) if (Number(e[t]) === n) return !0;
+	return !1;
+}, ct = (e, t, n, r) => {
+	if (!r) return ot(t, n);
+	for (let r = 0; r < 60; r++) if (!V(e.seconds, r) && !ot(t, n + r)) return !1;
+	return !0;
+};
+function lt(e, t) {
+	return e ? V(e.hours, t.hour) || V(e.minutes, t.minutes) || V(e.seconds, t.seconds) ? !0 : e.intervals?.length ? ot(B(e.intervals, e.clockType), L(t, e.clockType)) : !1 : !1;
+}
+function ut(e, t, n) {
+	if (!e) return !1;
+	if (V(e.hours, t.hour) || V(e.minutes, t.minutes)) return !0;
+	let r = L(t, e.clockType), i = r - r % 60;
+	return ct(e, B(e.intervals, e.clockType), i, n);
+}
+function dt(e, t, n) {
+	if (!e) return !1;
+	if (V(e.hours, t.hour)) return !0;
+	if (!e.intervals?.length) return !1;
+	let r = B(e.intervals, e.clockType), i = qe(t, e.clockType);
+	for (let t = 0; t < 60; t++) {
+		let a = i + t * 60;
+		if (!V(e.minutes, t) && !ct(e, r, a, n)) return !1;
+	}
+	return !0;
+}
+function ft(e, t, n, r) {
+	return t === "hour" ? dt(e, n, r) : t === "minutes" ? ut(e, n, r) : lt(e, n);
+}
+function pt(e, t, n, r) {
+	let i = n - t + 1;
+	for (let n = 0; n <= i / 2; n++) for (let a of [e + n, e - n]) {
+		let e = t + ((a - t) % i + i) % i;
+		if (!r(e)) return e;
+	}
+	return e;
+}
+var mt = (e, t) => e % 12 % t == 0, H = {
+	hour: {
+		input: "getHour",
+		event: "select:hour",
+		announce: "announceHour"
+	},
+	minutes: {
+		input: "getMinutes",
+		event: "select:minute",
+		announce: "announceMinute"
+	},
+	seconds: {
+		input: "getSeconds",
+		event: "select:second",
+		announce: "second"
+	}
+}, U = [
+	"hour",
+	"minutes",
+	"seconds"
+], W = (e, t) => e[H[t].input](), G = (e, t, n) => {
+	e.emit(H[t].event, { [t]: n });
+}, ht = (e) => U.find((t) => W(e, t)?.classList.contains("active")) ?? "hour", gt = (e, t) => {
+	U.forEach((n) => g(W(e, n), "active", n === t)), x(e.getModalElement());
+}, _t = (e, t) => {
+	let n = W(e, t);
+	if (!n) return;
+	let r = e.options.labels[H[t].announce];
+	h(e.getModalElement(), `${r}: ${n.value}`);
+};
+function K(e) {
+	let t = {
+		hour: e.getHour()?.value,
+		minutes: e.getMinutes()?.value,
+		type: e.getActiveType()
+	};
+	return e.options.clock.showSeconds && (t.seconds = e.getSeconds()?.value ?? "00"), t;
+}
+var vt = (e, t) => t === "hour" ? e.options.clock.type === "12h" ? [1, 12] : [0, 23] : [0, 59], yt = (e, t, n) => {
+	let r = e.disabledTime?.value;
+	return ft(r ? {
+		...r,
+		clockType: O(e.options)
+	} : null, t, n, !!e.options.clock.showSeconds);
+}, bt = (e, t) => {
+	let n = K(e);
+	return (r) => yt(e, t, {
+		...n,
+		[t]: P(r)
+	});
+}, xt = (e) => {
+	let t = K(e), n = e.options.clock.showSeconds ? "seconds" : "minutes";
+	return !!t.hour && !!t.minutes && yt(e, n, t);
+}, St = " - ", Ct = 2, wt = (e) => e !== null, Tt = class {
+	core;
+	emitter;
+	constructor(e, t) {
+		this.core = e, this.emitter = t;
+	}
+	isCurrentTimeEnabled(e) {
+		let t = this.core.options.clock.currentTime;
+		return typeof t == "boolean" ? t : !!t?.[e];
+	}
+	preventClockTypeByCurrentTime() {
+		if (!this.isCurrentTimeEnabled("preventClockType")) return;
+		let e = this.core.getInput();
+		if (!e) return;
+		let { currentTime: t, type: n } = this.core.options.clock, { type: r } = R(e, n, t, !0);
+		this.core.updateOptions({ clock: { type: r ? "12h" : "24h" } });
+	}
+	updateInputValueWithCurrentTimeOnStart() {
+		if (!this.isCurrentTimeEnabled("updateInput")) return;
+		let e = this.core.getInput();
+		if (!e) return;
+		let { clock: t } = this.core.options, n = k(this.core.options);
+		e.value = I(R(e, t.type, t.currentTime, void 0, n.showSeconds), n);
+	}
+	syncInputFormat(e) {
+		let t = k(e), n = k(this.core.options);
+		if (t.clockType === n.clockType && t.showSeconds === n.showSeconds) return;
+		let r = this.core.getInput();
+		if (!r) return;
+		let i = r.value.split(St).map((e) => F(e, t));
+		i.length > Ct || !i.every(wt) || (r.value = i.map((e) => I(Ke(e, t.clockType, n), n)).join(St));
+	}
+	getInputValueOnOpenAndSet(e = !0) {
+		let t = this.core.getInput();
+		if (!t) return;
+		let { clock: n } = this.core.options, r = k(this.core.options), i = t.value.trim() ? void 0 : n.currentTime, a = R(t, n.type, i, void 0, r.showSeconds);
+		U.forEach((e) => {
+			let t = a[e];
+			t !== void 0 && S(W(this.core, e), t);
+		}), r.clockType === "12h" && this.activatePeriod(a.type ?? "AM"), e && this.emitter.emit("open", {
+			...a,
+			type: this.core.getActiveType(),
+			...Je(a)
+		});
+	}
+	activatePeriod(e) {
+		if (e !== "AM" && e !== "PM") return;
+		let t = this.core.getModalElement(), n = (e) => t?.querySelector(`[data-type='${e}']`);
+		b(n("AM"), n("PM"), e);
+	}
+	destroy() {}
+}, Et = "(orientation: landscape) and (max-height: 480px)", Dt = "tp-ui-view-switching", Ot = [
+	"select-time",
+	"keyboard-icon-wrapper",
+	"hour",
+	"minutes",
+	"seconds",
+	"hour-text",
+	"minute-text",
+	"second-text",
+	"header",
+	"wrapper-type-time",
+	"am",
+	"pm",
+	"input-wrapper",
+	"input-ripple-wrapper"
+].map((e) => `.tp-ui-${e}`).join(","), kt = [
+	[
+		".tp-ui-hour",
+		"hourLabel",
+		"mobileHour"
+	],
+	[
+		".tp-ui-minutes",
+		"minuteLabel",
+		"mobileMinute"
+	],
+	[
+		".tp-ui-seconds",
+		"second",
+		"second"
+	]
+], At = (e) => {
+	if (typeof requestAnimationFrame > "u") {
+		e();
+		return;
+	}
+	requestAnimationFrame(() => e());
+}, q = (e) => {
+	e?.classList.remove("mobile"), e?.classList.add("expanded");
+}, jt = class {
+	core;
+	emitter;
+	animatingModal = null;
+	constructor(e, t) {
+		this.core = e, this.emitter = t, this.setupEventListeners();
+	}
+	setupEventListeners() {
+		this.emitter.on("switch:view", () => {
+			this.toggleMobileClockFace();
+		});
+	}
+	checkMobileOption() {
+		this.core.setIsMobileView(!!this.core.options.ui.mobile);
+	}
+	toggleMobileClockFace() {
+		let e = this.core.getModalElement();
+		if (!e || this.animatingModal === e) return;
+		let t = e.querySelector(".tp-ui-wrapper");
+		if (!t) return;
+		let n = {
+			modal: e,
+			wrapper: t,
+			clockWrapper: e.querySelector(".tp-ui-mobile-clock-wrapper"),
+			heading: e.querySelector(".tp-ui-select-time"),
+			clockFace: this.core.getClockFace(),
+			switchButton: this.core.getKeyboardClockIcon(),
+			allElements: e.querySelectorAll("*"),
+			isOriginallyMobile: this.core.isMobileView
+		};
+		this.animatingModal = e;
+		let r = t.classList.contains("expanded");
+		this.isLandscape() ? this.switchLandscape(n, r) : r ? At(() => this.collapsePortrait(n)) : this.expandPortrait(n);
+	}
+	switchLandscape(e, t) {
+		let { modal: n, wrapper: r, clockWrapper: i, clockFace: a } = e, o = this.core.options.ui.animation && !T();
+		if (o && n.classList.add(Dt), t ? (a?.classList.remove("scale-in"), i?.classList.add("mobile"), this.finishCollapse(e)) : (this.showClockView(e), q(r), q(i), a?.classList.add("scale-in")), !o) {
+			this.release(e);
+			return;
+		}
+		setTimeout(() => {
+			n.classList.remove(Dt), this.release(e);
+		}, m.WRAPPER_TRANSITION);
+	}
+	collapsePortrait(e) {
+		e.clockFace?.classList.toggle("scale-in", !e.isOriginallyMobile), e.clockWrapper?.classList.remove("expanded"), e.isOriginallyMobile && e.clockWrapper?.classList.add("mobile"), At(() => {
+			this.finishCollapse(e), setTimeout(() => this.release(e), m.MOBILE_TOGGLE);
+		});
+	}
+	finishCollapse(e) {
+		let { wrapper: t, clockWrapper: n, isOriginallyMobile: r } = e;
+		t.classList.remove("expanded"), t.classList.add("mobile"), n?.classList.remove("expanded"), r && n?.classList.add("mobile"), e.allElements.forEach((e) => {
+			e === t || e === n || (e.classList.remove("expanded"), r && e.classList.add("mobile"));
+		}), this.switchView(e, !0);
+	}
+	showClockView(e) {
+		let { wrapper: t, clockWrapper: n } = e;
+		this.selectActiveField(), e.allElements.forEach((e) => {
+			e !== t && e !== n && q(e);
+		}), this.switchView(e, !1);
+	}
+	expandPortrait(e) {
+		let { wrapper: t, clockWrapper: n, clockFace: r } = e;
+		this.showClockView(e), At(() => {
+			q(t), At(() => {
+				q(n), r?.classList.remove("scale-in"), setTimeout(() => r?.classList.add("scale-in"), m.CLOCK_SCALE_DELAY), setTimeout(() => this.release(e), m.MOBILE_TOGGLE);
+			});
+		});
+	}
+	selectActiveField() {
+		let e = ht(this.core), t = W(this.core, e);
+		t && G(this.emitter, e, t.value);
+	}
+	switchView(e, t) {
+		let { modal: n, heading: r } = e, { labels: i, ui: a } = this.core.options, o = !t && !a.editable;
+		n.querySelectorAll(Ot).forEach((e) => e.classList.toggle("mobile", t)), kt.forEach(([e, r, a]) => {
+			let s = n.querySelector(e);
+			s && (s.toggleAttribute("readonly", o), _(s, "aria-label", i[t ? a : r]));
+		}), x(n);
+		let s = t ? i.mobileTime : i.time;
+		r && s && (r.textContent = s), this.setClockFaceHidden(e.clockFace, t), this.renderSwitchButton(e.switchButton, t);
+	}
+	renderSwitchButton(e, t) {
+		if (!e) return;
+		let { iconTemplate: n, iconTemplateMobile: r } = this.core.options.ui, { switchToKeyboardLabel: i, switchToClockLabel: a } = this.core.options.labels;
+		t ? (e.innerHTML = r || de, e.setAttribute("aria-label", a ?? "")) : (e.innerHTML = n || ue, e.setAttribute("aria-label", i ?? ""));
+	}
+	updateClockFaceAccessibility(e) {
+		this.setClockFaceHidden(this.core.getClockFace(), e);
+	}
+	setClockFaceHidden(e, t) {
+		e && (e.tabIndex = t ? -1 : 0, _(e, "aria-hidden", t && "true"));
+	}
+	isLandscape() {
+		return typeof window < "u" && typeof window.matchMedia == "function" && window.matchMedia(Et).matches;
+	}
+	release(e) {
+		this.animatingModal === e.modal && (this.animatingModal = null);
+	}
+	destroy() {
+		this.animatingModal = null;
+	}
+}, Mt = (e, t) => e ? e.classList.contains(t) : !1, Nt = (e, t) => {
+	e.forEach((e) => {
+		if (!nt(e, t)) throw Error(`Invalid ${t} format: "${e}"`);
+	});
+	let n = st(e, t);
+	if (n) throw Error(`Overlapping intervals: "${n[0]}" and "${n[1]}"`);
+	return !1;
+}, Pt = () => typeof window < "u" && window.crypto && typeof window.crypto.randomUUID == "function" ? window.crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (e) => {
+	let t = Math.random() * 16 | 0;
+	return (e === "x" ? t : t & 3 | 8).toString(16);
+}), Ft = (e, t) => (e?.forEach((e) => {
+	if (Number(e) > 59) throw Error(`The disabled ${t} value has to be less than 60`);
+}), e?.map((e) => P(Number(e)))), It = (e) => {
+	if (!e) return;
+	let { disabledTime: t, type: n } = e.clock;
+	if (!t || !Object.keys(t).length) return;
+	let { hours: r, minutes: i, seconds: a, interval: o } = t;
+	if (o) {
+		let t = Array.isArray(o) ? o : [o];
+		if (!n) throw Error("clockType required for interval");
+		return Nt(t, O(e)), { value: {
+			isInterval: !0,
+			clockType: n,
+			intervals: t
+		} };
+	}
+	r?.forEach((e) => {
+		if (n === "12h" && Number(e) > 12) throw Error("The disabled hours value has to be less than 13");
+		if (n === "24h" && Number(e) > 23) throw Error("The disabled hours value has to be less than 24");
+	});
+	let s = Ft(i, "minutes"), c = Ft(a, "seconds");
+	return { value: {
+		hours: r?.map((e) => e === "00" || Number(e) === 0 ? `0${Number(e)}` : `${Number(e)}`),
+		minutes: s,
+		seconds: c
+	} };
+}, Lt = (e, t, n, r) => {
+	if (e) {
+		if (Array.isArray(e)) return !e.map((e) => $e(e, t, n)).some((e) => e === !1);
+		if (typeof e == "string" || typeof e == "number") {
+			let i = $e(e, t, n), a = r?.map(Number).includes(Number(e));
+			return !(!i || a);
+		}
+	}
+}, Rt = class {
+	core;
+	constructor(e) {
+		this.core = e;
+	}
+	getDisableTime() {
+		let e = It(this.core.options);
+		this.core.setDisabledTime(e || null);
+	}
+	destroy() {}
+}, zt = class {
+	inputValueHandler;
+	mobileViewHandler;
+	disabledTimeHandler;
+	constructor(e, t) {
+		this.inputValueHandler = new Tt(e, t), this.mobileViewHandler = new jt(e, t), this.disabledTimeHandler = new Rt(e);
+	}
+	preventClockTypeByCurrentTime() {
+		this.inputValueHandler.preventClockTypeByCurrentTime();
+	}
+	updateInputValueWithCurrentTimeOnStart() {
+		this.inputValueHandler.updateInputValueWithCurrentTimeOnStart();
+	}
+	getInputValueOnOpenAndSet(e = !0) {
+		this.inputValueHandler.getInputValueOnOpenAndSet(e);
+	}
+	syncInputFormat(e) {
+		this.inputValueHandler.syncInputFormat(e);
+	}
+	checkMobileOption() {
+		this.mobileViewHandler.checkMobileOption();
+	}
+	updateClockFaceAccessibility(e) {
+		this.mobileViewHandler.updateClockFaceAccessibility(e);
+	}
+	getDisableTime() {
+		this.disabledTimeHandler.getDisableTime();
+	}
+	destroy() {
+		this.inputValueHandler.destroy(), this.mobileViewHandler.destroy(), this.disabledTimeHandler.destroy();
+	}
+}, Bt = "tp-ui", Vt = "active", Ht = class {
+	core;
+	constructor(e, t) {
+		this.core = e;
+	}
+	setInputClassToInputElement() {
+		let e = this.core.getInput();
+		e && (Mt(e, "tp-ui-input") || e.classList.add("tp-ui-input"));
+	}
+	setDataOpenToInputIfDoesntExistInWrapper() {
+		let e = this.core.getOpenElementData(), t = this.core.getInput();
+		e === null && t && t.setAttribute("data-open", "tp-ui-input");
+	}
+	setClassTopOpenElement() {
+		let e = this.core.getOpenElement();
+		for (let t of e) t && t.classList.add("tp-ui-open-element");
+	}
+	setTimepickerClassToElement() {
+		let e = this.core.element;
+		if (!e) return;
+		e.classList.add(Bt);
+		let t = this.core.options.ui.cssClass;
+		t && t !== Bt && e.classList.add(t);
+	}
+	destroy() {
+		let e = this.core.getModalElement();
+		e && e.removeAttribute("data-theme");
+	}
+}, Ut = class e extends Error {
+	constructor(t, n) {
+		super(`[TimepickerUI] ${t}`), this.code = n, this.name = "TimepickerError", Object.setPrototypeOf(this, e.prototype);
+	}
+	code;
+}, Wt = { INVALID_PARAMETER: "INVALID_PARAMETER" }, Gt = class {
+	core;
+	emitter;
+	constructor(e, t) {
+		this.core = e, this.emitter = t;
+	}
+	setErrorHandler() {
+		let e = this.core.getInput();
+		if (!e || (this.removeErrorHandler(), this.core.options.range?.enabled)) return !0;
+		let { clock: n } = this.core.options, { error: r, currentHour: i, currentMin: a, currentSec: o, currentType: s, currentLength: c } = R(e, n.type, void 0, void 0, !!n.showSeconds);
+		if (r) {
+			if (t() === !1) return !1;
+			let n = this.core.options.labels.invalidTimeFormat, l = this.getErrorId(), u = document.createElement("div");
+			u.id = l, u.classList.add("tp-ui-invalid-text"), u.setAttribute("role", "alert");
+			let d = document.createElement("b");
+			d.textContent = n, u.appendChild(d), e.classList.add("tp-ui-invalid-format"), e.nextElementSibling?.classList.contains("tp-ui-invalid-text") || e.after(u), this.linkErrorMessage(e, l), this.announceInModal(n);
+			let f = {
+				error: r,
+				rejectedHour: void 0,
+				rejectedMinute: void 0,
+				inputHour: i,
+				inputMinute: a,
+				inputType: s,
+				inputLength: c
+			};
+			return o !== void 0 && (f.inputSecond = o), this.emitter.emit("error", f), !1;
+		}
+		return !0;
+	}
+	removeErrorHandler() {
+		let e = this.core.getInput();
+		if (!e) return;
+		g(e, "tp-ui-invalid-format", !1), this.unlinkErrorMessage(e);
+		let t = e.nextElementSibling;
+		t?.classList.contains("tp-ui-invalid-text") && t.remove();
+	}
+	getErrorId() {
+		return `tp-ui-invalid-text-${this.core.instanceId}`;
+	}
+	getDescribedByIds(e) {
+		return (e.getAttribute("aria-describedby") ?? "").split(/\s+/).filter(Boolean);
+	}
+	linkErrorMessage(e, t) {
+		let n = this.getDescribedByIds(e).filter((e) => e !== t);
+		e.setAttribute("aria-describedby", [...n, t].join(" ")), e.setAttribute("aria-invalid", "true");
+	}
+	unlinkErrorMessage(e) {
+		let t = this.getErrorId(), n = this.getDescribedByIds(e);
+		n.includes(t) && (_(e, "aria-describedby", n.filter((e) => e !== t).join(" ")), e.removeAttribute("aria-invalid"));
+	}
+	announceInModal(e) {
+		let t = this.core.getModalElement();
+		if (t) {
+			if (!this.core.options.behavior.focusTrap) {
+				h(t, e);
+				return;
+			}
+			t.addEventListener("focusin", () => h(t, e), { once: !0 });
+		}
+	}
+	checkDisabledValuesOnStart() {
+		if (!this.core.options.clock.disabledTime) return;
+		let { disabledTime: e, type: t } = this.core.options.clock, n = O(this.core.options);
+		if (e.interval) {
+			if (!t) throw new Ut("clockType is required when using disabledTime.interval", Wt.INVALID_PARAMETER);
+			let r = Array.isArray(e.interval) ? e.interval : [e.interval];
+			try {
+				Nt(r, n);
+			} catch (e) {
+				throw new Ut(`Invalid disabledTime.interval: ${e.message}`, Wt.INVALID_PARAMETER);
+			}
+			return;
+		}
+		let { hours: r, minutes: i, seconds: a } = e, o = !r || Lt(r, "hour", n), s = !i || Lt(i, "minutes", n), c = !a || Lt(a, "minutes", n);
+		if (!o || !s) throw new Ut("Invalid hours or minutes in disabledTime option", Wt.INVALID_PARAMETER);
+		if (!c) throw new Ut("Invalid seconds in disabledTime option", Wt.INVALID_PARAMETER);
+	}
+	destroy() {
+		this.removeErrorHandler();
+	}
+};
+function Kt(e, t, n, r) {
+	e.on(n, r), t.push(() => e.off(n, r));
+}
+function J(e) {
+	e.splice(0).forEach((e) => e());
+}
+function qt(e) {
+	try {
+		e.emit("show", {});
+	} finally {
+		e.emit("open:request", {});
+	}
+}
+var Jt = class {
+	core;
+	emitter;
+	cleanupHandlers = [];
+	persistentCleanups = [];
+	okBlocked = !1;
+	constructor(e, t) {
+		this.core = e, this.emitter = t;
+	}
+	handleOpenOnClick() {
+		let e = this.core.getOpenElement();
+		if (!e) return;
+		let t = () => {
+			this.core.isDestroyed || qt(this.emitter);
+		};
+		e.forEach((e) => {
+			this.persistentCleanups.push(w(e, t));
+		});
+	}
+	handleCancelButton() {
+		let e = this.core.getCancelButton();
+		e && this.cleanupHandlers.push(w(e, () => {
+			this.core.isDestroyed || this.emitter.emit("cancel", {});
+		}));
+	}
+	handleOkButton() {
+		let e = this.core.getOkButton();
+		e && (this.cleanupHandlers.push(w(e, () => {
+			if (this.core.isDestroyed || e.getAttribute("aria-disabled") === "true") return;
+			if (this.core.getHour() && this.core.getMinutes()) {
+				this.emitter.emit("confirm", K(this.core));
+				return;
+			}
+			let t = this.core.getModalElement();
+			t && this.emitter.emit("confirm", this.readWheelCenter(t));
+		})), this.blockOkOnDisabledTime(e));
+	}
+	blockOkOnDisabledTime(e) {
+		if (this.core.options.range?.enabled) return;
+		let t = () => {
+			let t = xt(this.core);
+			!t && !this.okBlocked || (this.okBlocked = t, C(e, t));
+		};
+		t(), Kt(this.emitter, this.cleanupHandlers, "update", ({ hour: e }) => {
+			e && t();
+		});
+	}
+	readWheelCenter(e) {
+		let t = (t) => e.querySelector(`.tp-ui-wheel-${t} .tp-ui-wheel-item.is-center`)?.getAttribute("data-value") ?? void 0, n = {
+			hour: t("hours"),
+			minutes: t("minutes"),
+			type: t("ampm")
+		};
+		return this.core.options.clock.showSeconds && (n.seconds = t("seconds")), n;
+	}
+	handleAmClick() {
+		let e = this.core.getAM();
+		e && this.cleanupHandlers.push(w(e, () => {
+			this.core.isDestroyed || (b(e, this.core.getPM(), "AM"), h(this.core.getModalElement(), this.core.options.labels.announceAmSelected), this.emitter.emit("select:am", {}), this.emitter.emit("update", {
+				...K(this.core),
+				type: "AM"
+			}));
+		}));
+	}
+	handlePmClick() {
+		let e = this.core.getPM();
+		e && this.cleanupHandlers.push(w(e, () => {
+			this.core.isDestroyed || (b(this.core.getAM(), e, "PM"), h(this.core.getModalElement(), this.core.options.labels.announcePmSelected), this.emitter.emit("select:pm", {}), this.emitter.emit("update", {
+				...K(this.core),
+				type: "PM"
+			}));
+		}));
+	}
+	handleSwitchViewButton() {
+		let e = this.core.getKeyboardClockIcon();
+		e && this.cleanupHandlers.push(w(e, () => {
+			this.core.isDestroyed || this.emitter.emit("switch:view", {});
+		}));
+	}
+	detach() {
+		J(this.cleanupHandlers);
+	}
+	destroy() {
+		this.detach(), J(this.persistentCleanups);
+	}
+}, Yt = (e, t, n) => Math.max(t, Math.min(n, e)), Xt = (e, t) => {
+	if (e === "") return "";
+	let n = parseInt(e, 10);
+	return Number.isNaN(n) ? "" : Yt(n, +!!t, t ? 12 : 23).toString().padStart(2, "0");
+}, Zt = (e) => {
+	if (e === "") return "";
+	let t = parseInt(e, 10);
+	return Number.isNaN(t) ? "" : Yt(t, 0, 59).toString().padStart(2, "0");
+}, Qt = {
+	hour: Xt,
+	minutes: Zt,
+	seconds: Zt
+}, $t = class {
+	core;
+	emitter;
+	cleanupHandlers = [];
+	constructor(e, t) {
+		this.core = e, this.emitter = t;
+	}
+	handleHourEvents() {
+		this.bindTimeField("hour");
+	}
+	handleMinutesEvents() {
+		this.bindTimeField("minutes");
+	}
+	handleSecondsEvents() {
+		this.bindTimeField("seconds");
+	}
+	bindTimeField(e) {
+		let t = W(this.core, e);
+		if (!t) return;
+		let n = () => {
+			this.core.isDestroyed || (gt(this.core, e), G(this.emitter, e, t.value), this.emitter.emit("update", K(this.core)));
+		};
+		t.addEventListener("click", n), this.cleanupHandlers.push(() => t.removeEventListener("click", n));
+		let r = t.value, i = () => {
+			if (this.core.isDestroyed || t.hasAttribute("readonly")) return;
+			let n = Qt[e](t.value, this.core.options.clock.type === "12h");
+			S(t, n && this.nearestEnabled(e, Number(n))), t.value !== r && (r = t.value, this.emitter.emit("animation:clock", {}), G(this.emitter, e, t.value), this.emitter.emit("update", K(this.core)));
+		};
+		t.addEventListener("blur", i), this.cleanupHandlers.push(() => t.removeEventListener("blur", i));
+	}
+	nearestEnabled(e, t) {
+		let [n, r] = vt(this.core, e);
+		return P(pt(t, n, r, bt(this.core, e)));
+	}
+	detach() {
+		J(this.cleanupHandlers);
+	}
+	destroy() {
+		this.detach();
+	}
+}, en = [
+	1,
+	!0,
+	(e, { step: t }) => Math.floor(e / t) * t + t
+], tn = [
+	-1,
+	!0,
+	(e, { step: t }) => Math.ceil(e / t) * t - t
+], nn = {
+	ArrowUp: en,
+	ArrowDown: tn,
+	Home: [
+		1,
+		!1,
+		(e, { min: t }) => t
+	],
+	End: [
+		-1,
+		!1,
+		(e, { last: t }) => t
+	],
+	PageUp: [
+		1,
+		!1,
+		(e, { last: t, step: n, pageSteps: r }) => Math.min(t, Math.floor(e / n) * n + n * r)
+	],
+	PageDown: [
+		-1,
+		!1,
+		(e, { min: t, step: n, pageSteps: r }) => Math.max(t, Math.ceil(e / n) * n - n * r)
+	]
+}, rn = {
+	...nn,
+	ArrowRight: en,
+	ArrowLeft: tn
+}, an = ([e, t, n], r, i, a) => {
+	let { min: o, last: s, step: c } = i, l = n(r, i);
+	for (let n = (s - o) / c; n >= 0; n--) {
+		if (l < o || l > s) {
+			if (!t) return null;
+			l = l < o ? s : o;
+		}
+		if (!a(l)) return l;
+		l += e * c;
+	}
+	return null;
+}, on = class {
+	core;
+	emitter;
+	cleanupHandlers = [];
+	persistentCleanups = [];
+	constructor(e, t) {
+		this.core = e, this.emitter = t;
+	}
+	handleOpenOnEnterFocus() {
+		this.onKeydown(this.core.getInput(), (e) => {
+			e.key === "Enter" && !this.core.isOpen && this.core.isModalRemove && qt(this.emitter);
+		}, this.persistentCleanups);
+	}
+	handleEscClick() {
+		t() !== !1 && this.onKeydown(document, (e) => {
+			this.core.isOpen && e.key === "Escape" && this.emitter.emit("cancel", {});
+		});
+	}
+	handleKeyboardInput() {
+		U.forEach((e) => this.onKeydown(W(this.core, e), (t) => this.stepField(e, nn[t.key], t, !0))), this.onKeydown(this.core.getClockFace(), (e) => {
+			let t = ht(this.core);
+			ae(e.key) ? (e.preventDefault(), this.advanceFace(t)) : this.stepField(t, rn[e.key], e, !1);
+		}), x(this.core.getModalElement());
+	}
+	advanceFace(e) {
+		let t = U[U.indexOf(e) + 1], n = t === "minutes" ? "autoSwitchToMinutes" : "autoSwitchToSeconds";
+		!t || this.core.options.clock[n] === !1 || (W(this.core, t)?.click(), _t(this.core, t));
+	}
+	onKeydown(e, t, n = this.cleanupHandlers) {
+		if (!e) return;
+		let r = (e) => {
+			this.core.isDestroyed || t(e);
+		};
+		e.addEventListener("keydown", r), n.push(() => e.removeEventListener("keydown", r));
+	}
+	spinRange(e) {
+		let [t, n] = vt(this.core, e), { incrementHours: r, incrementMinutes: i, incrementSeconds: a } = this.core.options.clock, o = {
+			hour: r,
+			minutes: i,
+			seconds: a
+		}[e] || 1;
+		return {
+			min: Math.ceil(t / o) * o,
+			last: Math.floor(n / o) * o,
+			step: o,
+			pageSteps: e === "hour" ? 3 : 5
+		};
+	}
+	stepField(e, t, n, r) {
+		let i = W(this.core, e);
+		if (!t || !i) return;
+		n.preventDefault();
+		let a = an(t, parseInt(i.value) || 0, this.spinRange(e), bt(this.core, e));
+		if (a === null) return;
+		let o = P(a);
+		gt(this.core, e), S(i, o), r && _t(this.core, e), G(this.emitter, e, o), this.emitter.emit("update", K(this.core));
+	}
+	focusTrapHandler() {
+		let e = this.core.getWrapper();
+		e && this.onKeydown(e, (t) => {
+			if (t.key !== "Tab") return;
+			let n = e.querySelectorAll("button, [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"])"), r = [];
+			if (n.forEach((e) => {
+				e.getAttribute("aria-disabled") !== "true" && (e.hasAttribute("disabled") || e.hidden || e.getAttribute("aria-hidden") !== "true" && (e.offsetParent === null && e.getClientRects().length === 0 || r.push(e)));
+			}), r.length === 0) return;
+			let i = r[0], a = r[r.length - 1];
+			t.shiftKey && document.activeElement === i ? (a?.focus(), t.preventDefault()) : !t.shiftKey && document.activeElement === a && (i?.focus(), t.preventDefault());
+		});
+	}
+	detach() {
+		J(this.cleanupHandlers);
+	}
+	destroy() {
+		this.detach(), J(this.persistentCleanups);
+	}
+}, sn = class {
+	core;
+	emitter;
+	cleanupHandlers = [];
+	constructor(e, t) {
+		this.core = e, this.emitter = t;
+	}
+	handleBackdropClick() {
+		let e = this.core.getModalElement();
+		if (!e) return;
+		let t = !1, n = (n) => {
+			t = n.target !== e;
+		}, r = (n) => {
+			t ||= n.target !== e;
+		}, i = (n) => {
+			!this.core.isDestroyed && n.target === e && !t && this.emitter.emit("cancel", {});
+		};
+		e.addEventListener("pointerdown", n), e.addEventListener("pointerup", r), e.addEventListener("click", i), this.cleanupHandlers.push(() => {
+			e.removeEventListener("pointerdown", n), e.removeEventListener("pointerup", r), e.removeEventListener("click", i);
+		});
+	}
+	handlePointerModality() {
+		let e = this.core.getModalElement();
+		e && this.cleanupHandlers.push(ce(e));
+	}
+	detach() {
+		J(this.cleanupHandlers);
+	}
+	destroy() {
+		this.detach();
+	}
+}, cn = class {
+	buttonHandlers;
+	inputHandlers;
+	keyboardHandlers;
+	modalHandlers;
+	constructor(e, t) {
+		this.buttonHandlers = new Jt(e, t), this.inputHandlers = new $t(e, t), this.keyboardHandlers = new on(e, t), this.modalHandlers = new sn(e, t);
+	}
+	handleOpenOnClick() {
+		this.buttonHandlers.handleOpenOnClick();
+	}
+	handleOpenOnEnterFocus() {
+		this.keyboardHandlers.handleOpenOnEnterFocus();
+	}
+	handleCancelButton() {
+		this.buttonHandlers.handleCancelButton();
+	}
+	handleOkButton() {
+		this.buttonHandlers.handleOkButton();
+	}
+	handleBackdropClick() {
+		this.modalHandlers.handleBackdropClick();
+	}
+	handlePointerModality() {
+		this.modalHandlers.handlePointerModality();
+	}
+	handleEscClick() {
+		this.keyboardHandlers.handleEscClick();
+	}
+	handleAmClick() {
+		this.buttonHandlers.handleAmClick();
+	}
+	handlePmClick() {
+		this.buttonHandlers.handlePmClick();
+	}
+	handleHourEvents() {
+		this.inputHandlers.handleHourEvents();
+	}
+	handleMinutesEvents() {
+		this.inputHandlers.handleMinutesEvents();
+	}
+	handleSecondsEvents() {
+		this.inputHandlers.handleSecondsEvents();
+	}
+	handleKeyboardInput() {
+		this.keyboardHandlers.handleKeyboardInput();
+	}
+	focusTrapHandler() {
+		this.keyboardHandlers.focusTrapHandler();
+	}
+	handleSwitchViewButton() {
+		this.buttonHandlers.handleSwitchViewButton();
+	}
+	detach() {
+		this.buttonHandlers.detach(), this.inputHandlers.detach(), this.keyboardHandlers.detach(), this.modalHandlers.detach();
+	}
+	destroy() {
+		this.buttonHandlers.destroy(), this.inputHandlers.destroy(), this.keyboardHandlers.destroy(), this.modalHandlers.destroy();
+	}
+}, ln = (e = []) => {
+	let t = e[e.length - 1];
+	return t === void 0 ? void 0 : parseInt(t, 10) + 1;
+}, un = class {
+	emitter;
+	getClockSystem;
+	setHoursToClock;
+	setMinutesToClock;
+	setSecondsToClock;
+	updateAmPm;
+	convertDisabledTime;
+	constructor(e, t, n, r, i, a, o) {
+		this.emitter = e, this.getClockSystem = t, this.setHoursToClock = n, this.setMinutesToClock = r, this.setSecondsToClock = o, this.updateAmPm = i, this.convertDisabledTime = a;
+	}
+	setup() {
+		this.emitter.on("select:hour", ({ hour: e }) => {
+			this.showFace("hours", e, this.setHoursToClock);
+		}), this.emitter.on("select:minute", ({ minutes: e }) => {
+			this.showFace("minutes", e, this.setMinutesToClock);
+		}), this.emitter.on("select:second", ({ seconds: e }) => {
+			this.showFace("seconds", e, this.setSecondsToClock);
+		}), this.emitter.on("select:am", () => {
+			this.updateAmPm();
+		}), this.emitter.on("select:pm", () => {
+			this.updateAmPm();
+		}), this.emitter.on("animation:start", () => {
+			this.getClockSystem()?.blockInteractions();
+		}), this.emitter.on("animation:end", () => {
+			this.getClockSystem()?.unblockInteractions();
+		}), this.emitter.on("range:switch", (e) => {
+			this.refreshDisabledTimeForRange(e.disabledTime);
+		});
+	}
+	showFace(e, t, n) {
+		t && this.getClockSystem()?.setValueIfShown(e, t) || (this.emitter.emit("animation:clock", {}), n?.(t || null), this.emitter.emit("switch:face", { face: e }));
+	}
+	refreshDisabledTimeForRange(e) {
+		let t = this.getClockSystem();
+		if (!t) return;
+		let n = this.convertDisabledTime();
+		if (!e) {
+			t.updateDisabledTime(n);
+			return;
+		}
+		t.updateDisabledTime({
+			...n,
+			rangeFromType: e.fromType,
+			rangeFromHour: e.fromHour,
+			rangeFromMinute: e.fromMinute ?? ln(e.minutes),
+			rangeFromSecond: ln(e.seconds)
+		});
+	}
+}, dn = /* @__PURE__ */ new WeakMap(), fn = (e, t) => {
+	let n = e.clockType ?? t, r = dn.get(e);
+	if (r && r.clockType === n) return r;
+	let i = {
+		hours: e.hours,
+		minutes: e.minutes,
+		seconds: e.seconds,
+		intervals: e.isInterval ? e.intervals : void 0,
+		clockType: n
+	};
+	return dn.set(e, i), i;
+}, pn = 12, mn = 59, hn = 59, gn = (e, t, n) => n === "24h" ? e : t === "AM" ? e % pn : t === "PM" ? e % pn + pn : null, _n = (e, t, n, r, i) => {
+	let a = gn(e, r, i);
+	return a === null ? null : (a * 60 + t) * 60 + n;
+}, vn = (e, t, n, r, i, a) => {
+	let { rangeFromHour: o, rangeFromMinute: s = 0, rangeFromSecond: c = 0, rangeFromType: l } = i;
+	if (o === void 0) return !1;
+	let u = _n(o, s, c, l, a), d = _n(e, t, n, r, a);
+	return u !== null && d !== null && d < u;
+}, yn = (e, t, n, r) => vn(parseInt(e, 10), mn, hn, t, n, r), bn = (e, t, n, r, i) => vn(parseInt(t, 10), parseInt(e, 10), hn, n, r, i), xn = (e, t, n, r, i, a) => vn(parseInt(n, 10), parseInt(t, 10), parseInt(e, 10), r, i, a), Y = class {
+	static angleToIndex(e, t, n) {
+		let r = Math.round(e / 30) % 12;
+		if (t === "24h") {
+			if (n) {
+				let e = r + 12;
+				return e === 12 ? 0 : e;
+			}
+			return r === 0 ? 12 : r;
+		}
+		return r === 0 ? 12 : r;
+	}
+	static indexToValue(e, t) {
+		if (t === "24h") return e.toString().padStart(2, "0");
+		let n = e;
+		return n === 0 && (n = 12), n > 12 && (n -= 12), n.toString().padStart(2, "0");
+	}
+	static indexToAngle(e, t) {
+		return t === "24h" ? e >= 12 ? (e - 12) % 12 * 30 : e % 12 * 30 : (e === 0 ? 12 : e) % 12 * 30;
+	}
+	static isDisabled(e, t, n, r, i = !1) {
+		return n ? yn(e, t, n, r) || dt(fn(n, r), {
+			hour: e,
+			type: t || void 0
+		}, i) : !1;
+	}
+	static findNearestValid(e, t, n, r, i = !1, a = 1) {
+		let o = t === "24h" ? 23 : 12;
+		for (let s = 0; s <= o; s++) {
+			let c = s === 0 ? [e] : [e + s, e - s];
+			for (let e of c) {
+				let s = e;
+				s < 0 && (s += o + 1), s > o && (s %= o + 1);
+				let c = this.indexToValue(s, t);
+				if (mt(s, a) && !this.isDisabled(c, n, r, t, i)) return s;
+			}
+		}
+		return e;
+	}
+}, X = class {
+	static angleToIndex(e) {
+		return Math.round(e / 6) % 60;
+	}
+	static indexToValue(e) {
+		return e.toString().padStart(2, "0");
+	}
+	static indexToAngle(e) {
+		return e % 60 * 6;
+	}
+	static isDisabled(e, t, n, r, i, a = !1) {
+		return r ? bn(e, t, n, r, i) || ut(fn(r, i), {
+			hour: t,
+			minutes: e,
+			type: n || void 0
+		}, a) : !1;
+	}
+	static isUnitDisabled(e, t, n) {
+		let { hour: r, minute: i, amPm: a, disabledTime: o, clockType: s, showSeconds: c } = n;
+		return e === "minutes" ? this.isDisabled(t, r, a, o, s, c) : o ? xn(t, i, r, a, o, s) || lt(fn(o, s), {
+			hour: r,
+			minutes: i,
+			seconds: t,
+			type: a || void 0
+		}) : !1;
+	}
+	static findNearestValidIndex(e, t, n) {
+		for (let r = 0; r < 60; r++) {
+			let i = r === 0 ? [e] : [e + r, e - r];
+			for (let e of i) {
+				let r = e;
+				if (r < 0 && (r += 60), r >= 60 && (r %= 60), !this.isUnitDisabled(t, this.indexToValue(r), n)) return r;
+			}
+		}
+		return e;
+	}
+}, Z = class {
+	static normalizeAngle(e) {
+		let t = e % 360;
+		return t < 0 && (t += 360), t;
+	}
+	static calculateRawAngle(e, t) {
+		let n = e.x - t.x, r = e.y - t.y, i = Math.atan2(r, n) * 180 / Math.PI + 90;
+		return this.normalizeAngle(i);
+	}
+	static snapToIncrement(e, t) {
+		let n = Math.round(e / t) * t;
+		return this.normalizeAngle(n);
+	}
+	static calculateDistance(e, t) {
+		let n = e.x - t.x, r = e.y - t.y;
+		return Math.sqrt(n * n + r * r);
+	}
+	static isInnerCircle(e, t) {
+		return e < t * .75;
+	}
+	static calculateShortestPath(e, t) {
+		let n = this.normalizeAngle(e), r = this.normalizeAngle(t) - n, i = r >= 0 ? r : r + 360, a = r <= 0 ? r : r - 360;
+		return e + (Math.abs(i) < Math.abs(a) ? i : a);
+	}
+}, Sn = class {
+	config;
+	currentAngle = 0;
+	tipsCache = /* @__PURE__ */ new Map();
+	cachedDimensions = /* @__PURE__ */ new Map();
+	snapTimeout = null;
+	sweep = null;
+	constructor(e) {
+		this.config = e;
+	}
+	getCachedDimensions(e) {
+		let t = this.cachedDimensions.get(e);
+		if (!t) {
+			let n = (e.offsetWidth - 32) / 2;
+			t = {
+				width: n,
+				height: (e.offsetHeight - 32) / 2,
+				radius: n - 9
+			}, this.cachedDimensions.set(e, t);
+		}
+		return t;
+	}
+	setHandAngle(e) {
+		this.cancelSweep();
+		let t = Z.calculateShortestPath(this.currentAngle, e);
+		Math.abs(this.currentAngle - t) < .01 || (this.currentAngle = t, this.config.clockHand.style.transform = `rotateZ(${t}deg)`);
+	}
+	animateToAngle(e) {
+		let t = Z.calculateShortestPath(this.currentAngle, e);
+		if (this.currentAngle = t, T()) {
+			this.config.clockHand.style.transform = `rotateZ(${t}deg)`;
+			return;
+		}
+		this.clearSnapTimeout(), this.config.clockHand.classList.add("tp-ui-tips-animation"), this.config.clockHand.style.transform = `rotateZ(${t}deg)`, this.snapTimeout = setTimeout(() => {
+			this.snapTimeout = null, this.config.clockHand.classList.remove("tp-ui-tips-animation");
+		}, m.TIPS_ANIMATION);
+	}
+	clearSnapTimeout() {
+		this.snapTimeout !== null && (clearTimeout(this.snapTimeout), this.snapTimeout = null);
+	}
+	setActiveValue(e) {
+		let t = Number(e);
+		[this.config.tipsWrapper, this.config.tipsWrapperFor24h].forEach((n) => {
+			n?.querySelectorAll(".tp-ui-value-tips, .tp-ui-value-tips-24h").forEach((n) => {
+				g(n, "active", n.textContent === e || Number(n.textContent) === t);
+			});
+		});
+	}
+	followHand(e, t) {
+		this.cancelSweep();
+		let n = this.config.clockHand;
+		if (T() || !n.classList.contains("tp-ui-tips-animation")) {
+			this.setActiveValue(t);
+			return;
+		}
+		let r = 0, i = () => {
+			let { a: t, b: a } = new DOMMatrix(getComputedStyle(n).transform);
+			this.setActiveValue(e(Math.atan2(a, t) * 180 / Math.PI)), r = requestAnimationFrame(i);
+		}, a = setTimeout(() => {
+			this.cancelSweep(), this.setActiveValue(t);
+		}, m.TIPS_ANIMATION);
+		this.sweep = () => {
+			cancelAnimationFrame(r), clearTimeout(a);
+		}, r = requestAnimationFrame(i);
+	}
+	cancelSweep() {
+		this.sweep?.(), this.sweep = null;
+	}
+	renderTips(e, n, r, i, a, o = !0, s, c = "", l = "12", u = "00") {
+		if (t() === !1) return;
+		let d = s || this.config.tipsWrapper, f = {
+			hour: l,
+			minute: u,
+			amPm: c,
+			disabledTime: i,
+			clockType: a,
+			showSeconds: this.config.showSeconds
+		};
+		o && (d.innerHTML = "", this.tipsCache.clear());
+		let { width: p, height: m, radius: h } = this.getCachedDimensions(d), g = document.createDocumentFragment(), _ = `${n}-${this.config.theme || "default"}`;
+		e.forEach((t, i) => {
+			let o = `${_}-${t}`, s = this.tipsCache.get(o);
+			s || (s = this.createTip(t, n, a), this.tipsCache.set(o, s));
+			let { wrapper: c, tip: l } = s;
+			this.updateTipState(c, l, t, r, f);
+			let u = i * (360 / e.length) * (Math.PI / 180);
+			c.style.left = `${p + Math.sin(u) * h}px`, c.style.bottom = `${m + Math.cos(u) * h}px`, g.appendChild(c);
+		}), d.appendChild(g);
+	}
+	createTip(e, n, r) {
+		if (t() === !1) {
+			let e = {};
+			return {
+				wrapper: e,
+				tip: e
+			};
+		}
+		let i = document.createElement("span"), a = document.createElement("span");
+		a.textContent = e, a.tabIndex = -1;
+		let o = r === "24h" && n.includes("24") ? "tp-ui-value-tips-24h" : "tp-ui-value-tips";
+		return a.classList.add(o), i.classList.add(n), i.appendChild(a), {
+			wrapper: i,
+			tip: a
+		};
+	}
+	updateTipState(e, t, n, r, i) {
+		let a = this.checkIfDisabled(n, r, i);
+		g(e, "tp-ui-tips-disabled", a), g(t, "tp-ui-tips-disabled", a);
+	}
+	checkIfDisabled(e, t, n) {
+		let { amPm: r, disabledTime: i, clockType: a, showSeconds: o } = n;
+		return i ? t === "hours" ? Y.isDisabled(e, r, i, a, o) : X.isUnitDisabled(t, e, n) : !1;
+	}
+	setCircle24hMode(e) {
+		g(this.config.circle, "tp-ui-circle-hand-24h", e), g(this.config.clockHand, "tp-ui-clock-hand-24h", e);
+	}
+	destroy() {
+		this.cancelSweep(), this.clearSnapTimeout(), this.tipsCache.clear(), this.cachedDimensions.clear();
+	}
+}, Q = class {
+	static processPointerInput(e) {
+		let t = Z.calculateRawAngle(e.pointerPosition, e.clockCenter);
+		return e.mode === "hours" ? this.processHours(t, e) : this.processSixty(t, e, e.mode);
+	}
+	static processHours(e, t) {
+		let n = Z.snapToIncrement(e, t.incrementHours * 30), r = Z.calculateDistance(t.pointerPosition, t.clockCenter), i = t.clockType === "24h" && Z.isInnerCircle(r, t.clockRadius), a = Y.angleToIndex(n, t.clockType, i), o = Y.indexToValue(a, t.clockType), s = Y.isDisabled(o, t.amPm, t.disabledTime, t.clockType, t.showSeconds);
+		return s && (a = Y.findNearestValid(a, t.clockType, t.amPm, t.disabledTime, t.showSeconds, t.incrementHours)), {
+			angle: t.smoothHourSnap === !1 ? Y.indexToAngle(a, t.clockType) : e,
+			value: Y.indexToValue(a, t.clockType),
+			index: a,
+			isValid: !s,
+			isInnerCircle: t.clockType === "24h" ? i : void 0
+		};
+	}
+	static processSixty(e, t, n) {
+		let r = n === "seconds" ? t.incrementSeconds ?? 1 : t.incrementMinutes, i = Z.snapToIncrement(e, r * 6), a = X.angleToIndex(i), o = {
+			hour: t.currentHour || "00",
+			minute: t.currentMinute || "00",
+			amPm: t.amPm,
+			disabledTime: t.disabledTime,
+			clockType: t.clockType,
+			showSeconds: t.showSeconds
+		}, s = X.isUnitDisabled(n, X.indexToValue(a), o);
+		return s && (a = X.findNearestValidIndex(a, n, o)), {
+			angle: X.indexToAngle(a),
+			value: X.indexToValue(a),
+			index: a,
+			isValid: !s
+		};
+	}
+	static valueToAngle(e, t, n) {
+		let r = parseInt(e, 10);
+		return t === "hours" ? Y.indexToAngle(r, n) : X.indexToAngle(r);
+	}
+}, Cn = class {
+	state;
+	renderer;
+	clockType;
+	disabledTime;
+	incrementHours;
+	incrementMinutes;
+	incrementSeconds;
+	smoothHourSnap;
+	showSeconds;
+	isDragging = !1;
+	callbacks;
+	lastProcessedX = null;
+	lastProcessedY = null;
+	appliedInDrag = !1;
+	sixtyUnits = {
+		minutes: {
+			value: "minute",
+			angle: "minuteAngle",
+			notify: () => this.callbacks.onMinuteChange
+		},
+		seconds: {
+			value: "second",
+			angle: "secondAngle",
+			notify: () => this.callbacks.onSecondChange
+		}
+	};
+	constructor(e, t, n, r, i = 1, a = 1, o = !0, s = {}, c = 1, l = !1) {
+		this.renderer = e, this.state = { ...t }, this.clockType = n, this.disabledTime = r, this.incrementHours = i, this.incrementMinutes = a, this.incrementSeconds = c, this.smoothHourSnap = o, this.showSeconds = l, this.callbacks = s;
+	}
+	handlePointerMove(e, t, n) {
+		if (this.isDragging = !0, this.lastProcessedX === e.x && this.lastProcessedY === e.y) return this.appliedInDrag;
+		this.lastProcessedX = e.x, this.lastProcessedY = e.y;
+		let r = this.state.mode, i = {
+			pointerPosition: e,
+			clockCenter: t,
+			clockRadius: n,
+			mode: r,
+			clockType: this.clockType,
+			amPm: this.state.amPm,
+			disabledTime: this.disabledTime,
+			incrementHours: this.incrementHours,
+			incrementMinutes: this.incrementMinutes,
+			incrementSeconds: this.incrementSeconds,
+			smoothHourSnap: this.smoothHourSnap,
+			currentHour: this.state.hour,
+			currentMinute: this.state.minute,
+			showSeconds: this.showSeconds
+		}, a = Q.processPointerInput(i);
+		if (!a.isValid) return !1;
+		if (r === "hours") {
+			let e = this.state.hour;
+			this.state.hour = a.value, this.state.hourAngle = a.angle, this.clockType === "24h" && a.isInnerCircle !== void 0 && this.renderer.setCircle24hMode(a.isInnerCircle), this.callbacks.onHourChange && e !== a.value && this.callbacks.onHourChange(a.value);
+		} else {
+			let e = this.writeSixty(r, a.value, a.angle), t = this.sixtyUnits[r].notify();
+			t && e !== a.value && t(a.value);
+		}
+		return this.renderer.setHandAngle(a.angle), this.renderer.setActiveValue(a.value), this.appliedInDrag = !0, !0;
+	}
+	handlePointerUp() {
+		this.isDragging = !1, this.appliedInDrag = !1, this.lastProcessedX = null, this.lastProcessedY = null;
+	}
+	snapToNearestHour() {
+		if (this.state.mode !== "hours") return;
+		let e = Q.valueToAngle(this.state.hour, "hours", this.clockType);
+		this.state.hourAngle = e, this.renderer.animateToAngle(e);
+	}
+	switchMode(e) {
+		this.state.mode = e, this.renderer.setCircle24hMode(this.isInnerFace(e, this.getValue(e))), this.renderer.setHandAngle(this.getAngle(e));
+	}
+	followHand(e) {
+		let t = this.getValue(e), n = this.isInnerFace(e, t);
+		this.renderer.followHand((t) => {
+			let r = Z.snapToIncrement(t, 30);
+			return e === "hours" ? Y.indexToValue(Y.angleToIndex(r, this.clockType, n), this.clockType) : X.indexToValue(X.angleToIndex(r));
+		}, t);
+	}
+	setValue(e, t) {
+		let n = Q.valueToAngle(t, e, this.clockType);
+		e === "hours" ? (this.state.hour = t, this.state.hourAngle = n) : this.writeSixty(e, t, n), this.state.mode === e && (this.renderer.setCircle24hMode(this.isInnerFace(e, t)), this.renderer.setHandAngle(n), this.renderer.setActiveValue(t));
+	}
+	setAmPm(e) {
+		this.state.amPm = e;
+	}
+	getState() {
+		return { ...this.state };
+	}
+	getValue(e) {
+		return e === "hours" ? this.state.hour : this.state[this.sixtyUnits[e].value];
+	}
+	getHour() {
+		return this.state.hour;
+	}
+	getMinute() {
+		return this.state.minute;
+	}
+	getSecond() {
+		return this.state.second;
+	}
+	getAmPm() {
+		return this.state.amPm;
+	}
+	updateDisabledTime(e) {
+		this.disabledTime = e;
+	}
+	destroy() {
+		this.renderer.destroy();
+	}
+	getAngle(e) {
+		return e === "hours" ? this.state.hourAngle : this.state[this.sixtyUnits[e].angle];
+	}
+	writeSixty(e, t, n) {
+		let r = this.sixtyUnits[e], i = this.state[r.value];
+		return this.state[r.value] = t, this.state[r.angle] = n, i;
+	}
+	isInnerFace(e, t) {
+		if (e !== "hours" || this.clockType !== "24h") return !1;
+		let n = parseInt(t, 10);
+		return n === 0 || n >= 13;
+	}
+}, wn = class {
+	controller;
+	clockFace;
+	isActive = !1;
+	isBlocked = !1;
+	config;
+	cachedRect = null;
+	cachedCenter = null;
+	cachedRadius = null;
+	rafId = null;
+	hadValidSelection = !1;
+	constructor(e, t, n = {}) {
+		this.controller = e, this.clockFace = t, this.config = n;
+	}
+	attach() {
+		this.clockFace.addEventListener("mousedown", this.handlePointerDown), this.clockFace.addEventListener("touchstart", this.handlePointerDown, { passive: !1 });
+	}
+	detach() {
+		this.clockFace.removeEventListener("mousedown", this.handlePointerDown), this.clockFace.removeEventListener("touchstart", this.handlePointerDown), this.removeGlobalListeners(), this.cancelPendingFrame(), this.isActive = !1;
+	}
+	block() {
+		this.isBlocked = !0;
+	}
+	unblock() {
+		this.isBlocked = !1;
+	}
+	handlePointerDown = (t) => {
+		e() || this.isBlocked || this.isDisabledTarget(t.target) || (t.preventDefault(), this.isActive = !0, this.hadValidSelection = !1, this.cachedRect = this.clockFace.getBoundingClientRect(), this.cachedCenter = this.getClockCenter(), this.cachedRadius = this.getClockRadius(), this.processPointerEvent(t), document.addEventListener("mousemove", this.handlePointerMove), document.addEventListener("touchmove", this.handlePointerMove, { passive: !1 }), document.addEventListener("mouseup", this.handlePointerUp), document.addEventListener("touchend", this.handlePointerUp));
+	};
+	handlePointerMove = (e) => {
+		!this.isActive || this.isBlocked || this.isDisabledTarget(this.getTargetElement(e)) || (e.preventDefault(), this.rafId === null && (this.rafId = requestAnimationFrame(() => {
+			this.rafId = null, this.processPointerEvent(e);
+		})));
+	};
+	handlePointerUp = () => {
+		if (!this.isActive) return;
+		this.cancelPendingFrame(), this.isActive = !1, this.cachedRect = null, this.cachedCenter = null, this.cachedRadius = null, this.controller.handlePointerUp();
+		let { autoSwitchToMinutes: e, autoSwitchToSeconds: t, isMobileView: n, smoothHourSnap: r, hourElement: i, minutesElement: a, secondsElement: o } = this.config;
+		r && i?.classList.contains("active") && this.controller.snapToNearestHour(), this.removeGlobalListeners(), this.hadValidSelection && (e && i?.classList.contains("active") && !n ? this.activate(i, a) : a?.classList.contains("active") && o ? t !== !1 && !n && this.activate(a, o) : this.isLastUnitActive() && this.config.onMinuteCommit && this.config.onMinuteCommit());
+	};
+	activate(e, t) {
+		t?.click(), t?.focus(), e.blur();
+	}
+	isLastUnitActive() {
+		let { minutesElement: e, secondsElement: t } = this.config;
+		return !!(t ?? e)?.classList.contains("active");
+	}
+	processPointerEvent(e) {
+		let t = this.getPointerPosition(e), n = this.cachedCenter || this.getClockCenter(), r = this.cachedRadius || this.getClockRadius();
+		this.controller.handlePointerMove(t, n, r) !== !1 && (this.hadValidSelection = !0);
+	}
+	isDisabledTarget(e) {
+		return !!e?.closest?.(".tp-ui-tips-disabled");
+	}
+	getPointerPosition(e) {
+		let t = this.cachedRect || this.clockFace.getBoundingClientRect();
+		if ("touches" in e) {
+			let n = e.touches[0] || e.changedTouches[0];
+			return {
+				x: n.clientX - t.left,
+				y: n.clientY - t.top
+			};
+		}
+		return {
+			x: e.clientX - t.left,
+			y: e.clientY - t.top
+		};
+	}
+	getTargetElement(t) {
+		if ("touches" in t) {
+			let n = t.touches[0] || t.changedTouches[0];
+			if (n && !e()) return document.elementFromPoint(n.clientX, n.clientY);
+		}
+		return t.target;
+	}
+	getClockCenter() {
+		let e = this.clockFace.offsetWidth, t = this.clockFace.offsetHeight;
+		return {
+			x: e / 2,
+			y: t / 2
+		};
+	}
+	getClockRadius() {
+		return this.clockFace.offsetWidth / 2;
+	}
+	cancelPendingFrame() {
+		this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null);
+	}
+	removeGlobalListeners() {
+		t() !== !1 && (document.removeEventListener("mousemove", this.handlePointerMove), document.removeEventListener("touchmove", this.handlePointerMove), document.removeEventListener("mouseup", this.handlePointerUp), document.removeEventListener("touchend", this.handlePointerUp));
+	}
+}, Tn = class {
+	renderer;
+	controller;
+	dragHandlers;
+	clockType;
+	disabledTime;
+	tipsWrapper;
+	tipsWrapperFor24h;
+	constructor(e) {
+		this.clockType = e.clockType, this.disabledTime = e.disabledTime, this.tipsWrapper = e.tipsWrapper, this.tipsWrapperFor24h = e.tipsWrapperFor24h;
+		let t = {
+			clockFace: e.clockFace,
+			tipsWrapper: e.tipsWrapper,
+			tipsWrapperFor24h: e.tipsWrapperFor24h,
+			clockHand: e.clockHand,
+			circle: e.circle,
+			theme: e.theme,
+			showSeconds: e.showSeconds
+		};
+		this.renderer = new Sn(t);
+		let n = e.initialSecond || "00", r = {
+			hour: e.initialHour,
+			minute: e.initialMinute,
+			second: n,
+			amPm: e.initialAmPm,
+			hourAngle: Q.valueToAngle(e.initialHour, "hours", e.clockType),
+			minuteAngle: Q.valueToAngle(e.initialMinute, "minutes", e.clockType),
+			secondAngle: Q.valueToAngle(n, "seconds", e.clockType),
+			mode: "hours"
+		}, i = {
+			onHourChange: e.onHourChange,
+			onMinuteChange: e.onMinuteChange,
+			onSecondChange: e.onSecondChange
+		};
+		this.controller = new Cn(this.renderer, r, e.clockType, e.disabledTime, e.incrementHours || 1, e.incrementMinutes || 1, e.smoothHourSnap ?? !0, i, e.incrementSeconds || 1, e.showSeconds ?? !1), this.dragHandlers = new wn(this.controller, e.clockFace, e.dragConfig || {});
+	}
+	initialize() {
+		this.dragHandlers.attach(), this.switchToHours();
+	}
+	switchToHours() {
+		this.controller.switchMode("hours"), this.clockType === "24h" && this.tipsWrapperFor24h && this.tipsWrapperFor24h.classList.remove("none"), this.renderHourTips(), this.controller.followHand("hours");
+	}
+	switchToMinutes() {
+		this.switchToSixty("minutes");
+	}
+	switchToSeconds() {
+		this.switchToSixty("seconds");
+	}
+	setHour(e) {
+		this.controller.setValue("hours", e);
+	}
+	setMinute(e) {
+		this.controller.setValue("minutes", e);
+	}
+	setSecond(e) {
+		this.controller.setValue("seconds", e);
+	}
+	setValueIfShown(e, t) {
+		let n = this.controller.getState().mode === e;
+		return n && this.controller.setValue(e, t), n;
+	}
+	setAmPm(e) {
+		this.controller.setAmPm(e), this.refreshFace();
+	}
+	syncValue(e) {
+		this.controller.setValue("hours", e.hour), this.controller.setValue("minutes", e.minute), e.second && this.controller.setValue("seconds", e.second), e.amPm && this.clockType === "12h" && this.controller.setAmPm(e.amPm), this.refreshFace();
+	}
+	refreshFace() {
+		let { mode: e } = this.controller.getState();
+		e === "hours" ? this.switchToHours() : this.switchToSixty(e);
+	}
+	getHour() {
+		return this.controller.getHour();
+	}
+	getMinute() {
+		return this.controller.getMinute();
+	}
+	getSecond() {
+		return this.controller.getSecond();
+	}
+	getAmPm() {
+		return this.controller.getAmPm();
+	}
+	updateDisabledTime(e) {
+		this.disabledTime = e, this.controller.updateDisabledTime(e);
+		let { mode: t } = this.controller.getState();
+		t === "hours" ? this.renderHourTips() : this.renderSixtyTips(t);
+	}
+	switchToSixty(e) {
+		this.controller.switchMode(e), this.tipsWrapperFor24h && this.tipsWrapperFor24h.classList.add("none"), this.renderSixtyTips(e), this.controller.followHand(e);
+	}
+	renderHourTips() {
+		let e = this.controller.getState().amPm;
+		this.clockType === "24h" ? (this.renderer.renderTips(me, "tp-ui-hour-time-12", "hours", this.disabledTime, this.clockType, !0, this.tipsWrapper, e), this.tipsWrapperFor24h && this.renderer.renderTips(pe, "tp-ui-hour-time-24", "hours", this.disabledTime, this.clockType, !0, this.tipsWrapperFor24h, e)) : this.renderer.renderTips(me, "tp-ui-hour-time-12", "hours", this.disabledTime, this.clockType, !0, void 0, e);
+	}
+	renderSixtyTips(e) {
+		let { amPm: t, hour: n, minute: r } = this.controller.getState();
+		this.renderer.renderTips(he, "tp-ui-minutes-time", e, this.disabledTime, this.clockType, !0, void 0, t, n, r);
+	}
+	destroy() {
+		this.dragHandlers.detach(), this.controller.destroy();
+	}
+	blockInteractions() {
+		this.dragHandlers.block();
+	}
+	unblockInteractions() {
+		this.dragHandlers.unblock();
+	}
+}, En = class {
+	core;
+	emitter;
+	clockSystem = null;
+	constructor(e, t) {
+		this.core = e, this.emitter = t;
+	}
+	getClockSystem() {
+		return this.clockSystem;
+	}
+	initialize() {
+		this.destroy();
+		let e = this.core.getClockFace(), t = this.core.getClockHand(), n = this.core.getCircle();
+		if (!e || !t || !n) return;
+		let { clock: r } = this.core.options, i = r.type === "24h", a = this.core.getTipsWrapper();
+		if (!a) return;
+		let o = r.showSeconds === !0, s = this.core.getHour(), c = this.core.getMinutes(), l = o ? this.core.getSeconds() : null, u = {
+			clockFace: e,
+			tipsWrapper: a,
+			tipsWrapperFor24h: i && this.core.getTipsWrapperFor24h() || void 0,
+			clockHand: t,
+			circle: n,
+			clockType: r.type || "12h",
+			disabledTime: this.convertDisabledTime(),
+			initialHour: s?.value || "12",
+			initialMinute: c?.value || "00",
+			initialSecond: l?.value || "00",
+			initialAmPm: this.getAmPmValue(),
+			theme: this.core.options.ui.theme,
+			incrementHours: r.incrementHours || 1,
+			incrementMinutes: r.incrementMinutes || 1,
+			incrementSeconds: r.incrementSeconds || 1,
+			smoothHourSnap: r.smoothHourSnap ?? !0,
+			showSeconds: o,
+			timepicker: null,
+			dragConfig: {
+				autoSwitchToMinutes: r.autoSwitchToMinutes,
+				autoSwitchToSeconds: r.autoSwitchToSeconds,
+				isMobileView: this.core.isMobileView,
+				smoothHourSnap: r.smoothHourSnap ?? !0,
+				hourElement: s,
+				minutesElement: c,
+				secondsElement: l,
+				onMinuteCommit: () => {
+					let e = K(this.core);
+					this.emitter.emit("range:minute:commit", {
+						...e,
+						hour: e.hour ?? "12",
+						minutes: e.minutes ?? "00"
+					});
+				}
+			},
+			onHourChange: (e) => this.reflectClockValue("hour", e),
+			onMinuteChange: (e) => this.reflectClockValue("minutes", e),
+			onSecondChange: (e) => this.reflectClockValue("seconds", e)
+		};
+		this.clockSystem = new Tn(u), this.clockSystem.initialize();
+	}
+	convertDisabledTime() {
+		let e = this.core.disabledTime?.value;
+		if (!e) return null;
+		let t;
+		return e.intervals && (t = Array.isArray(e.intervals) ? e.intervals : [e.intervals]), {
+			hours: e.hours,
+			minutes: e.minutes,
+			seconds: e.seconds,
+			isInterval: e.isInterval,
+			intervals: t,
+			clockType: e.clockType
+		};
+	}
+	getAmPmValue() {
+		if (this.core.options.clock.type === "24h") return "";
+		let e = this.core.getActiveType();
+		if (e) return e;
+		let t = this.core.getAM();
+		return this.core.options.range?.enabled === !0 ? t?.classList.contains("active") ? "AM" : "" : t?.classList.contains("active") ? "AM" : "PM";
+	}
+	reflectClockValue(e, t) {
+		S(W(this.core, e), t), _t(this.core, e), this.emitter.emit("update", K(this.core));
+	}
+	destroy() {
+		this.clockSystem &&= (this.clockSystem.destroy(), null);
+	}
+}, Dn = class {
+	core;
+	constructor(e) {
+		this.core = e;
+	}
+	setOnStartCSSClassesIfClockType24h() {
+		if (this.core.options.clock.type !== "24h") return;
+		let e = this.core.getInput()?.value.split(":")[0];
+		if (!e) return;
+		let t = Number(e);
+		(t > 12 || t === 0) && (this.core.getCircle()?.classList.add("tp-ui-circle-hand-24h"), this.core.getClockHand()?.classList.add("tp-ui-clock-hand-24h"));
+	}
+	setClassActiveToHourOnOpen() {
+		this.core.options.ui.mobile || this.core.isMobileView || this.core.getHour()?.classList.add(Vt);
+	}
+}, On = {
+	minutes: {
+		set: "setMinute",
+		show: "switchToMinutes"
+	},
+	seconds: {
+		set: "setSecond",
+		show: "switchToSeconds"
+	}
+}, kn = class {
+	getClockSystem;
+	getAmPmValue;
+	getClockType;
+	constructor(e, t, n) {
+		this.getClockSystem = e, this.getAmPmValue = t, this.getClockType = n;
+	}
+	setMinutesToClock(e) {
+		this.setSixtyToClock("minutes", e);
+	}
+	setSecondsToClock(e) {
+		this.setSixtyToClock("seconds", e);
+	}
+	setHoursToClock(e) {
+		let t = this.getClockSystem();
+		t && (e && t.setHour(e), t.switchToHours());
+	}
+	updateAmPm() {
+		let e = this.getClockSystem();
+		if (!e || this.getClockType() === "24h") return;
+		let t = this.getAmPmValue();
+		t !== "" && e.setAmPm(t);
+	}
+	setSixtyToClock(e, t) {
+		let n = this.getClockSystem();
+		if (!n) return;
+		let r = On[e];
+		t && n[r.set](t), n[r.show]();
+	}
+}, An = class {
+	systemInitializer;
+	styleHandler;
+	timeHandler;
+	eventHandler;
+	constructor(e, t) {
+		this.systemInitializer = new En(e, t), this.styleHandler = new Dn(e), this.timeHandler = new kn(() => this.systemInitializer.getClockSystem(), () => this.systemInitializer.getAmPmValue(), () => e.options.clock.type || "12h"), this.eventHandler = new un(t, () => this.systemInitializer.getClockSystem(), (e) => this.timeHandler.setHoursToClock(e), (e) => this.timeHandler.setMinutesToClock(e), () => this.timeHandler.updateAmPm(), () => this.systemInitializer.convertDisabledTime(), (e) => this.timeHandler.setSecondsToClock(e)), this.eventHandler.setup();
+	}
+	initializeClockSystem() {
+		this.systemInitializer.initialize();
+	}
+	destroyClockSystem() {
+		this.systemInitializer.destroy();
+	}
+	setOnStartCSSClassesIfClockType24h() {
+		this.styleHandler.setOnStartCSSClassesIfClockType24h();
+	}
+	setClassActiveToHourOnOpen = () => {
+		this.styleHandler.setClassActiveToHourOnOpen();
+	};
+	syncClockValue(e, t, n, r) {
+		let i = this.systemInitializer.getClockSystem();
+		if (!i) return !1;
+		let a = n === "AM" || n === "PM" ? n : "";
+		return i.syncValue({
+			hour: e,
+			minute: t,
+			second: r,
+			amPm: a
+		}), !0;
+	}
+	destroy() {
+		this.destroyClockSystem();
+	}
+}, jn = {
+	hour: "12",
+	minutes: "00",
+	seconds: "00"
+}, Mn = class {
+	core;
+	emitter;
+	cleanupHandlers = [];
+	wasCleared = !1;
+	constructor(e, t) {
+		this.core = e, this.emitter = t;
+	}
+	init() {
+		if (!this.core.options.ui.clearButton) return;
+		let e = this.getClearButton();
+		e && (this.cleanupHandlers.push(w(e, () => {
+			this.core.isDestroyed || this.handleClearClick();
+		})), this.setupInternalEventListeners(), this.updateClearButtonState());
+	}
+	setupInternalEventListeners() {
+		let e = () => this.updateClearButtonState();
+		Kt(this.emitter, this.cleanupHandlers, "update", e), Kt(this.emitter, this.cleanupHandlers, "open", e), U.forEach((t) => {
+			Kt(this.emitter, this.cleanupHandlers, H[t].event, () => {
+				e(), this.reenableConfirmIfCleared();
+			});
+		});
+	}
+	handleClearClick() {
+		let e = this.core.getInput()?.value || null;
+		this.clearTimeValue(), this.resetClockToNeutral(), C(this.core.getOkButton(), !0), this.wasCleared = !0, h(this.core.getModalElement(), this.core.options.labels.announceCleared), this.emitter.emit("clear", { previousValue: e }), this.emitter.emit("update", {
+			hour: void 0,
+			minutes: void 0,
+			type: void 0
+		});
+	}
+	clearTimeValue() {
+		let e = this.core.options.clearBehavior?.clearInput !== !1, t = this.core.getInput();
+		t && e && (t.value = ""), this.core.setDegreesHours(null), this.core.setDegreesMinutes(null), this.core.setDegreesSeconds(null);
+	}
+	resetClockToNeutral() {
+		let e = this.core.options.clock.type === "12h" ? "PM" : void 0;
+		U.forEach((e) => {
+			S(W(this.core, e), jn[e]);
+		});
+		let t = this.core.getClockHand();
+		if (t) {
+			let e = t.style.transition;
+			t.style.transition = "none", t.style.transform = "rotateZ(0deg)", t.offsetHeight, requestAnimationFrame(() => {
+				t.style.transition = e;
+			});
+		}
+		this.removeActiveStates(), this.core.getHour()?.click(), e && b(this.core.getAM(), this.core.getPM(), e), this.emitter.emit("animation:clock", {});
+	}
+	removeActiveStates() {
+		this.core.getAllValueTips().forEach((e) => g(e, "active", !1));
+	}
+	updateClearButtonState() {
+		let e = this.getClearButton();
+		if (!e) return;
+		let t = !!this.core.getInput()?.value.trim(), n = this.core.options.clock.type, r = this.core.getHour()?.value || "", i = this.core.getMinutes()?.value || "", a = this.core.getSeconds()?.value || "", o = this.core.getActiveType() ?? "", s = r !== "" || i !== "" || a !== "", c = r === jn.hour && i === jn.minutes && (a === "" || a === jn.seconds) && (n !== "12h" || o === "PM");
+		C(e, !(t || s && !c));
+	}
+	reenableConfirmIfCleared() {
+		if (!this.wasCleared) return;
+		let e = this.core.getOkButton();
+		e && (C(e, !1), this.wasCleared = !1);
+	}
+	getClearButton() {
+		return this.core.getModalElement()?.querySelector(".tp-ui-clear-btn") || null;
+	}
+	detach() {
+		J(this.cleanupHandlers);
+	}
+	destroy() {
+		this.detach();
+	}
+}, Nn = class {
+	animation;
+	modal;
+	config;
+	theme;
+	validation;
+	events;
+	clock;
+	clearButton;
+	plugins = /* @__PURE__ */ new Map();
+	constructor(e, t) {
+		this.animation = new le(e, t), this.modal = new ze(e, t), this.config = new zt(e, t), this.theme = new Ht(e, t), this.validation = new Gt(e, t), this.events = new cn(e, t), this.clock = new An(e, t), this.clearButton = new Mn(e, t), E.getAll().forEach((n) => {
+			let r = n.factory(e, t);
+			this.plugins.set(n.name, r);
+		});
+	}
+	getPlugin(e) {
+		return this.plugins.get(e);
+	}
+	destroy() {
+		this.animation.destroy(), this.modal.destroy(), this.config.destroy(), this.theme.destroy(), this.validation.destroy(), this.events.destroy(), this.clock.destroy(), this.clearButton.destroy(), this.plugins.forEach((e) => e.destroy()), this.plugins.clear();
+	}
+}, Pn = "is-pressed", Fn = "is-rippling", In = /* @__PURE__ */ new WeakSet(), Ln = (e) => e instanceof Element ? e.closest("[data-md3-ripple]") : null, Rn = (e) => {
+	Ln(e.target)?.classList.remove(Pn);
+}, zn = [
+	["pointerdown", (e) => {
+		let { pointerType: t, button: n, clientX: r, clientY: i } = e, a = Ln(e.target);
+		if (!a || te(a) || t === "mouse" && n !== 0) return;
+		a.classList.remove(Fn);
+		let { left: o, top: s, width: c, height: l } = a.getBoundingClientRect();
+		a.style.setProperty("--ripple-x", `${r - o}px`), a.style.setProperty("--ripple-y", `${i - s}px`), a.style.setProperty("--ripple-size", `${Math.max(c, l) * 2}px`), a.classList.add(Pn), a.addEventListener("pointerleave", Rn, { once: !0 }), T() || requestAnimationFrame(() => a.classList.add(Fn));
+	}],
+	["pointerup", Rn],
+	["pointercancel", Rn],
+	["animationend", (e) => {
+		e.animationName === "tp-ripple-fade" && Ln(e.target)?.classList.remove(Fn);
+	}]
+], Bn = (e) => {
+	if (In.has(e)) return () => {};
+	In.add(e), zn.forEach(([t, n]) => e.addEventListener(t, n));
+	let t = !0;
+	return () => {
+		t && (t = !1, In.delete(e), zn.forEach(([t, n]) => e.removeEventListener(t, n)));
+	};
+}, Vn = [
+	["onOpen", "open"],
+	["onShow", "show"],
+	["onCancel", "cancel"],
+	["onConfirm", "confirm"],
+	["onUpdate", "update"],
+	["onSelectHour", "select:hour"],
+	["onSelectMinute", "select:minute"],
+	["onSelectSecond", "select:second"],
+	["onSelectAM", "select:am"],
+	["onSelectPM", "select:pm"],
+	["onSelectPeriod", "select:period"],
+	["onSwitchView", "switch:view"],
+	["onSwitchFace", "switch:face"],
+	["onError", "error"],
+	["onTimezoneChange", "timezone:change"],
+	["onRangeConfirm", "range:confirm"],
+	["onRangeSwitch", "range:switch"],
+	["onRangeValidation", "range:validation"],
+	["onWheelScrollStart", "wheel:scroll:start"],
+	["onWheelScrollEnd", "wheel:scroll:end"],
+	["onClear", "clear"]
+], Hn = [
+	{
+		needed: De,
+		name: "wheel",
+		plugin: "WheelPlugin"
+	},
+	{
+		needed: (e) => !!e.range?.enabled,
+		name: "range",
+		plugin: "RangePlugin"
+	},
+	{
+		needed: (e) => !!e.timezone?.enabled,
+		name: "timezone",
+		plugin: "TimezonePlugin"
+	}
+];
+function Un(e, t) {
+	for (let [n, r] of Vn) t.on(r, (t) => {
+		let r = e.options.callbacks[n];
+		typeof r == "function" && r(t);
+	});
+}
+function Wn(e, t) {
+	for (let n of Hn) n.needed(e.options) && !E.has(n.name) && t.emit("error", { error: `${n.plugin} is not registered. Import and register it: PluginRegistry.register(${n.plugin})` });
+}
+var Gn = class {
+	core;
+	managers;
+	emitter;
+	unmountTimeouts = [];
+	rippleCleanup = () => {};
+	isCommitting = !1;
+	isRendering = !1;
+	isRerenderPending = !1;
+	constructor(e, t, n) {
+		this.core = e, this.managers = t, this.emitter = n;
+	}
+	init() {
+		if (!this.core.isDestroyed && !this.core.isInitialized) {
+			Un(this.core, this.emitter);
+			try {
+				this.managers.config.updateInputValueWithCurrentTimeOnStart(), this.managers.validation.checkDisabledValuesOnStart();
+			} catch (e) {
+				this.core.setIsDestroyed(!0), this.reportError(e);
+				return;
+			}
+			this.managers.theme.setTimepickerClassToElement(), this.managers.theme.setInputClassToInputElement(), this.managers.theme.setDataOpenToInputIfDoesntExistInWrapper(), this.managers.theme.setClassTopOpenElement(), this.managers.config.getDisableTime(), j(this.core.options) || this.managers.events.handleOpenOnClick(), this.managers.events.handleOpenOnEnterFocus(), this.core.setIsInitialized(!0);
+		}
+	}
+	applyOptions(e) {
+		let t = this.core.options;
+		this.core.updateOptions(e);
+		try {
+			this.managers.validation.checkDisabledValuesOnStart(), this.managers.config.getDisableTime();
+		} catch (e) {
+			return this.core.setOptions(t), this.reportError(e), !1;
+		}
+		return this.managers.config.checkMobileOption(), this.managers.config.syncInputFormat(t), !0;
+	}
+	reportError(e) {
+		this.emitter.emit("error", { error: e instanceof Error ? e.message : String(e) });
+	}
+	mount() {
+		this.core.isDestroyed || this.core.isOpen || (this.core.isInitialized || this.init(), this.eventsBundle());
+	}
+	rerender() {
+		if (this.isRendering) {
+			this.isRerenderPending = !0;
+			return;
+		}
+		let e = this.managers.modal.getFocusedControlSelector();
+		this.core.setIsOpen(!1), this.releaseOpenView(), this.core.setIsModalRemove(!0), this.eventsBundle(!0), e !== null && this.managers.modal.restoreFocus(e);
+	}
+	discardSelection() {
+		if (j(this.core.options)) {
+			this.rerender(), this.core.getCancelButton()?.focus();
+			return;
+		}
+		this.unmount();
+	}
+	closeUnlessInline() {
+		j(this.core.options) || this.unmount();
+	}
+	unmount(e, t = !1) {
+		if (this.isCommitting) return;
+		t && this.commitSelection(), this.deactivate();
+		let n = () => {
+			this.closeModal(), e && e();
+		}, { delayHandler: r } = this.core.options.behavior;
+		r ? this.unmountTimeouts.push(setTimeout(n, r)) : n();
+	}
+	deactivate() {
+		this.core.setIsOpen(!1), this.releaseOpenView();
+	}
+	releaseOpenView() {
+		this.detachOpenHandlers(), this.managers.clock.destroyClockSystem(), this.managers.getPlugin("wheel")?.detachPopover?.();
+	}
+	commitSelection() {
+		this.core.isOpen && (this.isCommitting = !0, this.core.getOkButton()?.click(), this.isCommitting = !1);
+	}
+	closeModal() {
+		this.core.setIsMobileView(!!this.core.options.ui.mobile), this.core.setIsTouchMouseMove(!1), this.unmountTimeouts.push(setTimeout(() => {
+			this.managers.modal.unlockScroll(), this.core.options.behavior.focusInputAfterClose && this.core.getInput()?.focus(), this.releaseRipple(), this.core.getModalElement()?.remove(), this.core.setIsModalRemove(!0), this.core.getOpenElement().forEach((e) => e?.classList.remove("disabled"));
+		}, this.managers.animation.removeAnimationToClose()));
+	}
+	destroy(e) {
+		if (this.core.isDestroyed) return;
+		this.clearUnmountTimeouts();
+		let { keepInputValue: t = !1, callback: n } = typeof e == "function" ? { callback: e } : e || {}, r = this.core.getInput(), i = t ? r?.value : null;
+		this.releaseRipple(), this.core.getModalElement()?.remove(), this.core.getOpenElement()?.forEach((e) => {
+			e && e.classList.remove("disabled", "tp-ui-open-element");
+		}), r && (r.classList.remove("tp-ui-invalid-format", "tp-ui-input"), r.removeAttribute("data-open"), r.removeAttribute("data-owner-id"), t && i && (r.value = i));
+		let a = this.core.element;
+		a && (a.removeAttribute("data-owner-id"), a.removeAttribute("data-open"), this.core.options.ui.cssClass && a.classList.remove(this.core.options.ui.cssClass)), a?.querySelectorAll(".tp-ui-invalid-text")?.forEach((e) => e.remove()), this.core.reset(), this.managers.destroy(), this.emitter.clear(), this.managers.modal.unlockScroll(), n && n();
+	}
+	eventsBundle(e = !1) {
+		if (this.core.isDestroyed || !this.core.isModalRemove) return;
+		this.isRendering = !0, this.clearUnmountTimeouts(), this.detachOpenHandlers(), this.core.setIsOpen(!0), this.core.setIsModalRemove(!1), this.disableOpenElements(), this.setupModal(), this.setupValidation(), this.applyExpandedState(), this.managers.modal.setFlexEndToFooterIfNoKeyboardIcon(), this.applyWrapperCssClass(), e && this.managers.animation.setAnimationToOpen(!0), this.managers.config.getInputValueOnOpenAndSet(!e);
+		let t = De(this.core.options) && E.has("wheel");
+		Wn(this.core, this.emitter), this.revealClockFace(t, e), this.initClockOrWheel(t), this.initOptionalPlugins(t), this.bindEventHandlers(t), this.initRipple(), A(this.core.options) && this.managers.getPlugin("wheel")?.attachPopover?.(), e || (this.managers.animation.setAnimationToOpen(), this.managers.modal.setInitialFocus()), this.isRendering = !1, this.runPendingRerender(e);
+	}
+	runPendingRerender(e) {
+		let t = this.isRerenderPending;
+		this.isRerenderPending = !1, t && !e && this.core.isOpen && this.rerender();
+	}
+	setupValidation() {
+		this.managers.validation.setErrorHandler();
+	}
+	detachOpenHandlers() {
+		this.managers.events.detach(), this.managers.clearButton.detach();
+	}
+	disableOpenElements() {
+		j(this.core.options) || (this.core.getOpenElement().forEach((e) => e?.classList.add("disabled")), A(this.core.options) || this.core.getInput()?.blur());
+	}
+	setupModal() {
+		this.managers.modal.setScrollbarOrNot(), this.managers.modal.setModalTemplate(), this.managers.modal.setNormalizeClass(), this.managers.modal.removeBackdrop();
+	}
+	applyExpandedState() {
+		if (this.core.isMobileView) {
+			this.managers.config.updateClockFaceAccessibility(!0);
+			return;
+		}
+		this.core.getModalElement()?.querySelectorAll("*").forEach((e) => {
+			e.classList.contains("tp-ui-select-time") || e.classList.add("expanded");
+		});
+	}
+	applyWrapperCssClass() {
+		let { cssClass: e } = this.core.options.ui;
+		e && this.core.getWrapper()?.classList.add(e);
+	}
+	initClockOrWheel(e) {
+		if (e) {
+			let e = this.managers.getPlugin("wheel");
+			e && e.init();
+		} else this.managers.clock.initializeClockSystem(), this.managers.clock.setOnStartCSSClassesIfClockType24h(), this.managers.clock.setClassActiveToHourOnOpen();
+	}
+	initOptionalPlugins(e) {
+		let t = this.managers.getPlugin("timezone");
+		t && t.init();
+		let n = this.managers.getPlugin("range");
+		n && !e && n.init();
+	}
+	bindEventHandlers(e) {
+		this.managers.events.handleCancelButton(), this.managers.events.handleOkButton(), this.managers.clearButton.init(), e || (this.managers.events.handleHourEvents(), this.managers.events.handleMinutesEvents(), this.core.options.clock.showSeconds && this.managers.events.handleSecondsEvents()), this.managers.events.handleKeyboardInput(), this.managers.events.handlePointerModality(), this.core.options.ui.enableSwitchIcon && !e && this.managers.events.handleSwitchViewButton(), this.core.options.clock.type !== "24h" && !Oe(this.core.options) && (this.managers.events.handleAmClick(), this.managers.events.handlePmClick()), this.core.options.behavior.focusTrap && this.managers.events.focusTrapHandler(), j(this.core.options) || (this.managers.events.handleEscClick(), A(this.core.options) || e && this.core.options.wheel?.ignoreOutsideClick || this.managers.events.handleBackdropClick());
+	}
+	initRipple() {
+		let e = this.core.getModalElement();
+		e && (this.rippleCleanup(), this.rippleCleanup = Bn(e));
+	}
+	revealClockFace(e, t) {
+		let n = e ? null : this.core.getClockFace();
+		n && (t ? n.classList.add("scale-in") : typeof requestAnimationFrame < "u" && requestAnimationFrame(() => {
+			requestAnimationFrame(() => {
+				n.classList.add("scale-in");
+			});
+		}));
+	}
+	releaseRipple() {
+		this.rippleCleanup(), this.rippleCleanup = () => {};
+	}
+	clearUnmountTimeouts() {
+		this.unmountTimeouts.forEach(clearTimeout), this.unmountTimeouts = [];
+	}
+}, Kn = class {
+	events = /* @__PURE__ */ new Map();
+	on(e, t) {
+		this.events.has(e) || this.events.set(e, /* @__PURE__ */ new Set()), this.events.get(e).add(t);
+	}
+	once(e, t) {
+		let n = ((r) => {
+			t(r), this.events.get(e)?.delete(n);
+		});
+		n.__originalHandler = t, this.on(e, n);
+	}
+	off(e, t) {
+		if (!t) {
+			this.events.delete(e);
+			return;
+		}
+		let n = this.events.get(e);
+		n && n.forEach((e) => {
+			(e === t || e.__originalHandler === t) && n.delete(e);
+		});
+	}
+	emit(e, t) {
+		let n = this.events.get(e);
+		n && [...n].forEach((e) => {
+			e(t);
+		});
+	}
+	clear() {
+		this.events.clear();
+	}
+	hasListeners(e) {
+		return (this.events.get(e)?.size ?? 0) > 0;
+	}
+}, qn = (e) => e.replace(/[^0-9:APMapm\s]/g, ""), Jn = {
+	"12h": "Invalid 12h format. Expected HH:MM AM/PM",
+	"24h": "Invalid 24h format. Expected HH:MM"
+}, Yn = {
+	"12h": "24h",
+	"24h": "12h"
+}, Xn = (e) => ({
+	...e,
+	type: e.type ?? "AM"
+});
+function Zn(e, t) {
+	let n = k(e.options), r = F(t, n);
+	if (r) {
+		let e = n.showSeconds || Ue(t) ? I(r, n) : t;
+		return {
+			parsed: Xn(r),
+			inputText: e
+		};
+	}
+	let i = Yn[n.clockType], a = F(t, {
+		...n,
+		clockType: i
+	});
+	if (!a) return null;
+	let o = Ke(a, i, n);
+	return {
+		parsed: Xn(o),
+		inputText: I(o, n)
+	};
+}
+function Qn(e) {
+	return { error: Jn[O(e.options)] };
+}
+var $n = (e, t) => !e || t === void 0 ? !1 : (S(e, t), !0);
+function er(e, t) {
+	$n(e.getHour(), t.hour) && e.setDegreesHours(Number(t.hour) * 30), $n(e.getMinutes(), t.minutes) && e.setDegreesMinutes(Number(t.minutes) * 6), $n(e.getSeconds(), t.seconds) && e.setDegreesSeconds(Number(t.seconds) * 6);
+}
+function tr(e, t) {
+	e.setDegreesHours(Number(t.hour) * 30), e.setDegreesMinutes(Number(t.minutes) * 6), t.seconds !== void 0 && e.setDegreesSeconds(Number(t.seconds) * 6);
+}
+function nr(e, t) {
+	e.options.clock.type !== "24h" && b(e.getAM(), e.getPM(), t === "AM" ? "AM" : "PM");
+}
+function rr(e, t, n) {
+	if (De(e.options)) {
+		t.getPlugin("wheel")?.scrollToValue?.(n.hour, n.minutes, n.type, n.seconds);
+		return;
+	}
+	let r = O(e.options) === "24h" ? void 0 : n.type;
+	if (t.clock.syncClockValue(n.hour, n.minutes, r, n.seconds)) return;
+	let i = e.getClockHand();
+	i && (i.style.transform = `rotateZ(${e.degreesHours || 0}deg)`);
+}
+var $ = /* @__PURE__ */ new Map(), ir = class {
+	core;
+	managers;
+	lifecycle;
+	emitter;
+	constructor(t, n) {
+		if (e()) throw Error("TimepickerUI requires browser environment");
+		let r = this.resolveRootElement(t);
+		if (!r) throw Error("Input element not found");
+		let i = n?.behavior?.id, a = i || `tp-ui-${Pt()}`, o = f(n || {});
+		if (o.ui.inline?.enabled && typeof n?.behavior?.focusTrap > "u" && (o.behavior.focusTrap = !1), o.ui.inline?.enabled) {
+			let { container: e, containerId: t } = o.ui.inline;
+			if (!e && !t) throw Error("inline.container is required when inline mode is enabled");
+			if (!Ae(o.ui.inline)) throw Error("Inline container not found");
+		}
+		this.emitter = new Kn(), this.core = new p(r, o, a, i);
+		let s = this.core.getInput();
+		if (s) {
+			let { type: e, showSeconds: t } = o.clock;
+			tr(this.core, R(s, e, void 0, void 0, !!t));
+		}
+		this.managers = new Nn(this.core, this.emitter), this.lifecycle = new Gn(this.core, this.managers, this.emitter), this.managers.config.checkMobileOption(), this.managers.config.preventClockTypeByCurrentTime(), this.setupInternalEventListeners(), $.set(this.core.instanceId, this);
+	}
+	setupInternalEventListeners() {
+		this.emitter.on("open:request", () => {
+			this.core.isDestroyed || this.lifecycle.mount();
+		}), this.emitter.on("cancel", () => {
+			this.core.isDestroyed || this.lifecycle.discardSelection();
+		}), this.emitter.on("confirm", (e) => {
+			if (!this.core.isDestroyed) {
+				if (this.core.options.range?.enabled) return;
+				this.writeInputValue(e), e.autoCommit || this.lifecycle.closeUnlessInline();
+			}
+		}), this.emitter.on("update", (e) => {
+			if (this.core.isDestroyed || this.core.options.range?.enabled) return;
+			let { inline: t } = this.core.options.ui;
+			!t?.enabled || !t.autoUpdate || this.writeInputValue(e);
+		}), this.emitter.on("range:confirm", (e) => {
+			if (this.core.isDestroyed) return;
+			let t = this.core.getInput();
+			t && (t.value = `${e.from} - ${e.to}`), this.lifecycle.closeUnlessInline();
+		}), this.emitter.on("select:am", () => this.emitter.emit("select:period", { type: "AM" })), this.emitter.on("select:pm", () => this.emitter.emit("select:period", { type: "PM" }));
+	}
+	writeInputValue(e) {
+		!e.hour || !e.minutes || this.setInputText(I(e, k(this.core.options)));
+	}
+	setInputText(e) {
+		let t = this.core.getInput();
+		t && (t.value = e, this.managers.validation.removeErrorHandler());
+	}
+	create() {
+		this.lifecycle.init(), this.core.options.ui.inline?.enabled && this.lifecycle.mount();
+	}
+	open(e) {
+		this.lifecycle.mount(), e && e();
+	}
+	close(e, t) {
+		if (e) {
+			this.lifecycle.unmount(t, !0);
+			return;
+		}
+		this.lifecycle.unmount(), t && t();
+	}
+	destroy(e) {
+		$.delete(this.core.instanceId), this.lifecycle.destroy(e);
+	}
+	update(e, t) {
+		this.core.isDestroyed || this.lifecycle.applyOptions(e.options) && (this.core.isOpen && this.lifecycle.rerender(), e.create && this.create(), t && t());
+	}
+	setOptions(e) {
+		this.update({ options: e });
+	}
+	getValue() {
+		if (this.core.isDestroyed) return {
+			hour: "",
+			minutes: "",
+			type: void 0,
+			time: "",
+			degreesHours: null,
+			degreesMinutes: null
+		};
+		let e = k(this.core.options), t = {
+			hour: "12",
+			minutes: "00",
+			seconds: e.showSeconds ? "00" : void 0,
+			type: e.clockType === "24h" ? void 0 : "AM"
+		}, n = this.core.getModalElement(), r = this.core.getInput(), i = t;
+		n && this.core.isOpen ? i = this.readOpenValue(e.clockType, t) : r && (i = R(r, this.core.options.clock.type, void 0, void 0, e.showSeconds));
+		let { degreesHours: a, degreesMinutes: o } = n || r ? Je(i) : {
+			degreesHours: null,
+			degreesMinutes: null
+		}, s = {
+			hour: i.hour,
+			minutes: i.minutes,
+			type: i.type,
+			time: I(i, e),
+			degreesHours: a,
+			degreesMinutes: o
+		};
+		return e.showSeconds && (s.seconds = i.seconds ?? t.seconds), s;
+	}
+	readOpenValue(e, t) {
+		let n = (t) => {
+			if (e !== "24h") return t ?? "AM";
+		};
+		if (Oe(this.core.options)) {
+			let e = this.managers.getPlugin("wheel")?.getSelection?.();
+			return e ? {
+				hour: e.hour,
+				minutes: e.minutes,
+				seconds: e.seconds ?? t.seconds,
+				type: n(e.type)
+			} : t;
+		}
+		return {
+			hour: this.core.getHour()?.value || t.hour,
+			minutes: this.core.getMinutes()?.value || t.minutes,
+			seconds: this.core.getSeconds()?.value || t.seconds,
+			type: n(this.core.getActiveType())
+		};
+	}
+	setValue(e, t = !0) {
+		if (this.core.isDestroyed || typeof e != "string" || !e.trim() || !this.core.isInitialized && (this.create(), this.core.isDestroyed)) return;
+		let n = Zn(this.core, qn(e.trim()));
+		if (!n) {
+			this.emitter.emit("error", Qn(this.core));
+			return;
+		}
+		let { parsed: r, inputText: i } = n;
+		er(this.core, r), nr(this.core, r.type), t && this.setInputText(i), rr(this.core, this.managers, r);
+	}
+	getElement() {
+		return this.core.element;
+	}
+	get instanceId() {
+		return this.core.instanceId;
+	}
+	get options() {
+		return this.core.options;
+	}
+	get isInitialized() {
+		return this.core.isInitialized;
+	}
+	get isDestroyed() {
+		return this.core.isDestroyed;
+	}
+	get hour() {
+		return this.core.getHour();
+	}
+	get minutes() {
+		return this.core.getMinutes();
+	}
+	get okButton() {
+		return this.core.getOkButton();
+	}
+	get cancelButton() {
+		return this.core.getCancelButton();
+	}
+	get clockHand() {
+		return this.core.getClockHand();
+	}
+	on(e, t) {
+		this.core.isDestroyed || this.emitter.on(e, t);
+	}
+	once(e, t) {
+		this.core.isDestroyed || this.emitter.once(e, t);
+	}
+	off(e, t) {
+		this.core.isDestroyed || this.emitter.off(e, t);
+	}
+	resolveRootElement(e) {
+		if (t() === !1) return null;
+		let n = typeof e == "string" ? document.querySelector(e) : e;
+		if (!(n instanceof HTMLElement)) return null;
+		if (n.tagName !== "INPUT") return n.querySelector("input") ? (n.classList.add("tp-ui"), n) : null;
+		let r = n.parentElement;
+		if (r?.classList.contains("tp-ui")) return r;
+		let i = document.createElement("div");
+		return i.className = "tp-ui", n.before(i), i.appendChild(n), i;
+	}
+	static getById(e) {
+		return $.get(e);
+	}
+	static getAllInstances() {
+		return Array.from($.values());
+	}
+	static isAvailable(t) {
+		return e() ? !1 : typeof t == "string" ? document.querySelector(t) !== null : t instanceof HTMLElement && document.contains(t);
+	}
+	static destroyAll() {
+		Array.from($.values()).forEach((e) => e.destroy()), $.clear();
+	}
+};
+//#endregion
+export { E as PluginRegistry, ir as TimepickerUI };