@vicacha-devs/strapi-plugin-calendar 0.0.0-stage → 1.0.0

package/dist/admin/index-USqxqyAm.js

@@ -0,0 +1,3216 @@
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import { Flex, Box, Typography, Badge, Button, SingleSelect, SingleSelectOption, Field, Checkbox, DatePicker, NumberInput } from "@strapi/design-system";
+import { NavLink } from "react-router-dom";
+import allLocales from "@fullcalendar/core/locales-all";
+import dayGridPlugin from "@fullcalendar/daygrid";
+import interactionPlugin from "@fullcalendar/interaction";
+import listPlugin from "@fullcalendar/list";
+import multiMonthPlugin from "@fullcalendar/multimonth";
+import FullCalendar from "@fullcalendar/react";
+import timeGridPlugin from "@fullcalendar/timegrid";
+import { useMemo, useCallback, useState, useEffect, useRef } from "react";
+import { useTheme } from "styled-components";
+import { useFetchClient } from "@strapi/strapi/admin";
+import { useIntl } from "react-intl";
+import { Calendar } from "@strapi/icons";
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+function freezeOptions(items) {
+  return Object.freeze(items.map((item) => Object.freeze({ ...item })));
+}
+freezeOptions([
+  { value: "es", label: "es — Español (Spanish)" },
+  { value: "en", label: "en — English" },
+  { value: "ar", label: "ar — العربية (Arabic)" },
+  { value: "tr", label: "tr — Türkçe (Turkish)" },
+  { value: "fr", label: "fr — Français (French)" },
+  { value: "de", label: "de — Deutsch (German)" },
+  { value: "pt", label: "pt — Português (Portuguese)" },
+  { value: "it", label: "it — Italiano (Italian)" },
+  { value: "nl", label: "nl — Nederlands (Dutch)" },
+  { value: "pl", label: "pl — Polski (Polish)" },
+  { value: "ru", label: "ru — Русский (Russian)" },
+  { value: "id", label: "id — Bahasa Indonesia" },
+  { value: "ur", label: "ur — اردو (Urdu)" },
+  { value: "zh", label: "zh — 中文 (Chinese)" }
+]);
+freezeOptions([
+  {
+    value: "islamic-umalqura",
+    label: "islamic-umalqura (Hijri Umm al-Qura)"
+  },
+  { value: "islamic-civil", label: "islamic-civil (Tabular Islamic Civil)" },
+  { value: "islamic-tbla", label: "islamic-tbla (Tabular Astronomical)" },
+  { value: "hebrew", label: "hebrew (Hebrew)" },
+  { value: "persian", label: "persian (Solar Hijri)" },
+  { value: "none", label: "none (Gregorian Only)" }
+]);
+const VALID_LOCALE_RE = /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,4}$/;
+function isTranslationRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function extractDictionary(loaded) {
+  if (!isTranslationRecord(loaded)) {
+    return void 0;
+  }
+  if ("default" in loaded) {
+    return isTranslationRecord(loaded.default) ? loaded.default : void 0;
+  }
+  return loaded;
+}
+function getLookupCandidates(locale, fallbackToLanguage) {
+  const trimmed = locale.trim();
+  if (!VALID_LOCALE_RE.test(trimmed)) {
+    return [];
+  }
+  if (!fallbackToLanguage || !trimmed.includes("-")) {
+    return [trimmed];
+  }
+  const base = trimmed.split("-")[0];
+  return base && base !== trimmed ? [trimmed, base] : [trimmed];
+}
+function prefixPluginTranslations(trad, pluginId, options) {
+  const normalizedPluginId = typeof pluginId === "string" ? pluginId.trim() : "";
+  if (!normalizedPluginId) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  const result = {};
+  if (options?.baseTranslations) {
+    for (const [key, value] of Object.entries(options.baseTranslations)) {
+      if (typeof value === "string") {
+        result[key] = value;
+      }
+    }
+  }
+  const prefix = `${normalizedPluginId}.`;
+  const explicitPrefixed = [];
+  for (const [key, value] of Object.entries(trad)) {
+    if (typeof value !== "string") {
+      continue;
+    }
+    if (options?.keepUnprefixed) {
+      result[key] = value;
+    }
+    if (key.startsWith(prefix)) {
+      explicitPrefixed.push([key, value]);
+    } else {
+      result[`${prefix}${key}`] = value;
+    }
+  }
+  for (const [key, value] of explicitPrefixed) {
+    result[key] = value;
+  }
+  return result;
+}
+function createRegisterTrads(options) {
+  const { pluginId, defaultLocales = ["en", "es", "ar", "tr"], supportedLocales, keepUnprefixed = true, fallbackToLanguageCode = true, loadTranslation, translations, getBaseTranslations, onLoaded } = options;
+  const normalizedPluginId = typeof pluginId === "string" ? pluginId.trim() : "";
+  if (!normalizedPluginId) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  const supportedSet = supportedLocales ? new Set(supportedLocales) : void 0;
+  const effectiveDefaults = supportedSet ? defaultLocales.filter((loc) => getLookupCandidates(loc, fallbackToLanguageCode).some((candidate) => supportedSet.has(candidate))) : defaultLocales;
+  return async function registerTrads({ locales = [] } = {}) {
+    const allLocales2 = effectiveDefaults.length > 0 ? Array.from(/* @__PURE__ */ new Set([...locales, ...effectiveDefaults])) : Array.from(new Set(locales));
+    return Promise.all(allLocales2.map(async (locale) => {
+      const candidates = getLookupCandidates(locale, fallbackToLanguageCode);
+      if (candidates.length === 0) {
+        return { data: {}, locale };
+      }
+      if (supportedSet && !candidates.some((candidate) => supportedSet.has(candidate))) {
+        return { data: {}, locale };
+      }
+      let rawData;
+      for (const candidate of candidates) {
+        if (translations && Object.hasOwn(translations, candidate)) {
+          rawData = extractDictionary(translations[candidate]);
+          if (rawData) {
+            break;
+          }
+        }
+        if (loadTranslation) {
+          try {
+            const loaded = await loadTranslation(candidate);
+            rawData = extractDictionary(loaded);
+            if (rawData) {
+              break;
+            }
+          } catch {
+          }
+        }
+      }
+      const baseTranslations = getBaseTranslations?.(locale);
+      const hasBase = Boolean(baseTranslations) && Object.keys(baseTranslations).length > 0;
+      if (!rawData && !hasBase) {
+        return { data: {}, locale };
+      }
+      const prefixed = prefixPluginTranslations(rawData ?? {}, normalizedPluginId, {
+        keepUnprefixed,
+        baseTranslations
+      });
+      onLoaded?.(locale, prefixed);
+      return { data: prefixed, locale };
+    }));
+  };
+}
+const PLUGIN_ID = "calendar";
+const RTL_LANGUAGE_PREFIXES = /* @__PURE__ */ new Set([
+  "ar",
+  "he",
+  "iw",
+  "fa",
+  "ur",
+  "ps",
+  "sd",
+  "ug",
+  "yi"
+]);
+const SUPPORTED_CALENDAR_LOCALES = [
+  {
+    code: "en",
+    label: "English",
+    nativeName: "English",
+    direction: "ltr",
+    week: { dow: 0, doy: 4 },
+    buttonText: {
+      prev: "Prev",
+      next: "Next",
+      today: "Today",
+      year: "Year",
+      month: "Month",
+      week: "Week",
+      day: "Day",
+      list: "Agenda"
+    },
+    weekText: "Wk",
+    allDayText: "all-day",
+    moreLinkText: "more",
+    noEventsText: "No events to display"
+  },
+  {
+    code: "es",
+    label: "Spanish",
+    nativeName: "Español",
+    direction: "ltr",
+    week: { dow: 1, doy: 4 },
+    buttonText: {
+      prev: "Ant",
+      next: "Sig",
+      today: "Hoy",
+      year: "Año",
+      month: "Mes",
+      week: "Semana",
+      day: "Día",
+      list: "Agenda"
+    },
+    weekText: "Sm",
+    allDayText: "todo el día",
+    moreLinkText: "más",
+    noEventsText: "No hay eventos para mostrar"
+  },
+  {
+    code: "fr",
+    label: "French",
+    nativeName: "Français",
+    direction: "ltr",
+    week: { dow: 1, doy: 4 },
+    buttonText: {
+      prev: "Préc",
+      next: "Suiv",
+      today: "Aujourd'hui",
+      year: "Année",
+      month: "Mois",
+      week: "Semaine",
+      day: "Jour",
+      list: "Planning"
+    },
+    weekText: "Sem.",
+    allDayText: "toute la journée",
+    moreLinkText: "en plus",
+    noEventsText: "Aucun événement à afficher"
+  },
+  {
+    code: "de",
+    label: "German",
+    nativeName: "Deutsch",
+    direction: "ltr",
+    week: { dow: 1, doy: 4 },
+    buttonText: {
+      prev: "Zurück",
+      next: "Weiter",
+      today: "Heute",
+      year: "Jahr",
+      month: "Monat",
+      week: "Woche",
+      day: "Tag",
+      list: "Terminübersicht"
+    },
+    weekText: "KW",
+    allDayText: "ganztägig",
+    moreLinkText: "weitere",
+    noEventsText: "Keine Ereignisse anzuzeigen"
+  },
+  {
+    code: "pt",
+    label: "Portuguese",
+    nativeName: "Português",
+    direction: "ltr",
+    week: { dow: 0, doy: 4 },
+    buttonText: {
+      prev: "Ant",
+      next: "Próx",
+      today: "Hoje",
+      year: "Ano",
+      month: "Mês",
+      week: "Semana",
+      day: "Dia",
+      list: "Agenda"
+    },
+    weekText: "Sem",
+    allDayText: "dia inteiro",
+    moreLinkText: "mais",
+    noEventsText: "Não há eventos para mostrar"
+  },
+  {
+    code: "it",
+    label: "Italian",
+    nativeName: "Italiano",
+    direction: "ltr",
+    week: { dow: 1, doy: 4 },
+    buttonText: {
+      prev: "Prec",
+      next: "Succ",
+      today: "Oggi",
+      year: "Anno",
+      month: "Mese",
+      week: "Settimana",
+      day: "Giorno",
+      list: "Agenda"
+    },
+    weekText: "Set",
+    allDayText: "tutto il giorno",
+    moreLinkText: "altri",
+    noEventsText: "Non ci sono eventi da visualizzare"
+  },
+  {
+    code: "nl",
+    label: "Dutch",
+    nativeName: "Nederlands",
+    direction: "ltr",
+    week: { dow: 1, doy: 4 },
+    buttonText: {
+      prev: "Vorige",
+      next: "Volgende",
+      today: "Vandaag",
+      year: "Jaar",
+      month: "Maand",
+      week: "Week",
+      day: "Dag",
+      list: "Lijst"
+    },
+    weekText: "Wk",
+    allDayText: "hele dag",
+    moreLinkText: "extra",
+    noEventsText: "Geen evenementen om te laten zien"
+  },
+  {
+    code: "pl",
+    label: "Polish",
+    nativeName: "Polski",
+    direction: "ltr",
+    week: { dow: 1, doy: 4 },
+    buttonText: {
+      prev: "Poprzedni",
+      next: "Następny",
+      today: "Dziś",
+      year: "Rok",
+      month: "Miesiąc",
+      week: "Tydzień",
+      day: "Dzień",
+      list: "Plan dnia"
+    },
+    weekText: "Tydz",
+    allDayText: "cały dzień",
+    moreLinkText: "więcej",
+    noEventsText: "Brak wydarzeń do wyświetlenia"
+  },
+  {
+    code: "tr",
+    label: "Turkish",
+    nativeName: "Türkçe",
+    direction: "ltr",
+    week: { dow: 1, doy: 7 },
+    buttonText: {
+      prev: "geri",
+      next: "ileri",
+      today: "bugün",
+      year: "Yıl",
+      month: "Ay",
+      week: "Hafta",
+      day: "Gün",
+      list: "Ajanda"
+    },
+    weekText: "Hf",
+    allDayText: "tüm gün",
+    moreLinkText: "daha fazla",
+    noEventsText: "Gösterilecek etkinlik yok"
+  },
+  {
+    code: "ar",
+    label: "Arabic",
+    nativeName: "العربية",
+    direction: "rtl",
+    week: { dow: 6, doy: 12 },
+    buttonText: {
+      prev: "السابق",
+      next: "التالي",
+      today: "اليوم",
+      year: "سنة",
+      month: "شهر",
+      week: "أسبوع",
+      day: "يوم",
+      list: "أجندة"
+    },
+    weekText: "أسبوع",
+    allDayText: "اليوم كله",
+    moreLinkText: "أخرى",
+    noEventsText: "أي أحداث لعرض"
+  }
+];
+function normalizeLocaleCode(locale) {
+  if (!locale || typeof locale !== "string") {
+    return "en";
+  }
+  const cleaned = locale.trim().toLowerCase().replace("_", "-");
+  if (!cleaned || cleaned === "auto") {
+    return "en";
+  }
+  const exact = SUPPORTED_CALENDAR_LOCALES.find((l) => l.code === cleaned);
+  if (exact) {
+    return exact.code;
+  }
+  const baseLang = cleaned.split("-")[0];
+  const baseMatch = SUPPORTED_CALENDAR_LOCALES.find((l) => l.code === baseLang);
+  return baseMatch ? baseMatch.code : baseLang || "en";
+}
+function isRtlLocale(locale) {
+  const normalized = normalizeLocaleCode(locale);
+  const baseLang = normalized.split("-")[0];
+  return RTL_LANGUAGE_PREFIXES.has(baseLang);
+}
+function getLocalizedCalendarBundle(locale) {
+  const code = normalizeLocaleCode(locale);
+  return SUPPORTED_CALENDAR_LOCALES.find((l) => l.code === code) ?? SUPPORTED_CALENDAR_LOCALES[0];
+}
+function resolveFullCalendarLocale(uiLocale, defaultLocaleSetting, runtimeOverrideLocale) {
+  if (runtimeOverrideLocale && runtimeOverrideLocale !== "auto" && runtimeOverrideLocale.trim()) {
+    return normalizeLocaleCode(runtimeOverrideLocale);
+  }
+  if (defaultLocaleSetting && defaultLocaleSetting !== "auto" && defaultLocaleSetting.trim()) {
+    return normalizeLocaleCode(defaultLocaleSetting);
+  }
+  return normalizeLocaleCode(uiLocale || "en");
+}
+function resolveCalendarDirection(locale, directionSetting) {
+  if (directionSetting === "ltr" || directionSetting === "rtl") {
+    return directionSetting;
+  }
+  return isRtlLocale(locale) ? "rtl" : "ltr";
+}
+function resolveLocaleFirstDay(locale, configuredFirstDay) {
+  if (typeof configuredFirstDay === "number" && configuredFirstDay >= 0 && configuredFirstDay <= 6) {
+    return configuredFirstDay;
+  }
+  const bundle = getLocalizedCalendarBundle(locale);
+  return bundle.week.dow;
+}
+function buildFullCalendarTimeFormat(timeFormat24h = true) {
+  if (timeFormat24h) {
+    return {
+      hour: "2-digit",
+      minute: "2-digit",
+      meridiem: false,
+      hour12: false
+    };
+  }
+  return {
+    hour: "numeric",
+    minute: "2-digit",
+    meridiem: "short",
+    hour12: true
+  };
+}
+const SUPPORTED_INTL_CALENDARS = [
+  { id: "gregory", intlCalendar: "gregory", defaultLabel: "Gregorian" },
+  { id: "iso8601", intlCalendar: "iso8601", defaultLabel: "ISO 8601" },
+  {
+    id: "islamic-umalqura",
+    intlCalendar: "islamic-umalqura",
+    defaultLabel: "Hijri (Umm al-Qura)"
+  },
+  {
+    id: "islamic-civil",
+    intlCalendar: "islamic-civil",
+    defaultLabel: "Hijri (Civil)"
+  },
+  {
+    id: "islamic-tbla",
+    intlCalendar: "islamic-tbla",
+    defaultLabel: "Hijri (Tabular)"
+  },
+  { id: "hebrew", intlCalendar: "hebrew", defaultLabel: "Hebrew" },
+  {
+    id: "persian",
+    intlCalendar: "persian",
+    defaultLabel: "Persian (Solar Hijri)"
+  },
+  { id: "buddhist", intlCalendar: "buddhist", defaultLabel: "Buddhist" },
+  { id: "japanese", intlCalendar: "japanese", defaultLabel: "Japanese" },
+  { id: "chinese", intlCalendar: "chinese", defaultLabel: "Chinese Lunar" },
+  { id: "indian", intlCalendar: "indian", defaultLabel: "Indian National" },
+  { id: "coptic", intlCalendar: "coptic", defaultLabel: "Coptic" },
+  { id: "ethiopic", intlCalendar: "ethiopic", defaultLabel: "Ethiopic" }
+];
+const customFormatters = /* @__PURE__ */ new Map();
+function applyDayOffset(date, dayOffset) {
+  if (!dayOffset || !Number.isFinite(dayOffset)) {
+    return date;
+  }
+  const offsetDays = Math.trunc(dayOffset);
+  return new Date(date.getTime() + offsetDays * 864e5);
+}
+const intlFormatterCache = /* @__PURE__ */ new Map();
+function getCachedIntlFormatter(locale, options) {
+  const key = `${locale}|${options.year ?? ""}|${options.month ?? ""}|${options.day ?? ""}|${options.timeZone ?? "UTC"}`;
+  let fmt = intlFormatterCache.get(key);
+  if (!fmt) {
+    if (intlFormatterCache.size >= 200) {
+      const oldestKey = intlFormatterCache.keys().next().value;
+      if (oldestKey !== void 0) intlFormatterCache.delete(oldestKey);
+    }
+    fmt = new Intl.DateTimeFormat(locale, options);
+    intlFormatterCache.set(key, fmt);
+  }
+  return fmt;
+}
+function resolveCalendarLocaleTag(systemLocale, fallbackLocale) {
+  const rawLocale = systemLocale && systemLocale !== "auto" ? systemLocale : fallbackLocale && fallbackLocale !== "auto" ? fallbackLocale : "en";
+  return rawLocale.split("-u-")[0];
+}
+function tryFormatWithCustomFormatter(effectiveDate, system, effectiveLocale, compact) {
+  const customFn = customFormatters.get(system.id) ?? customFormatters.get(system.intlCalendar);
+  if (!customFn) return null;
+  try {
+    return customFn(effectiveDate, {
+      locale: effectiveLocale,
+      system,
+      compact
+    });
+  } catch {
+    return null;
+  }
+}
+function formatWithIntlFallback(effectiveDate, isoOrDateKey, intlLocale, compact) {
+  try {
+    const formatter = getCachedIntlFormatter(
+      intlLocale,
+      compact ? { day: "numeric", month: "short", timeZone: "UTC" } : { day: "numeric", month: "long", year: "numeric", timeZone: "UTC" }
+    );
+    return formatter.format(effectiveDate);
+  } catch {
+    try {
+      const fallback = getCachedIntlFormatter("en-u-ca-gregory", {
+        day: "numeric",
+        month: "short",
+        year: "numeric",
+        timeZone: "UTC"
+      });
+      return fallback.format(effectiveDate);
+    } catch {
+      return isoOrDateKey.slice(0, 10);
+    }
+  }
+}
+function formatDateInCalendarSystem(isoOrDateKey, system, locale = "en", options) {
+  const rawDate = /^\d{4}-\d{2}-\d{2}$/.test(isoOrDateKey) ? /* @__PURE__ */ new Date(`${isoOrDateKey}T12:00:00.000Z`) : new Date(isoOrDateKey);
+  if (Number.isNaN(rawDate.getTime())) {
+    return "";
+  }
+  const effectiveDate = applyDayOffset(rawDate, system.dayOffset);
+  const effectiveLocale = resolveCalendarLocaleTag(system.locale, locale);
+  const compact = Boolean(options?.compact);
+  const customResult = tryFormatWithCustomFormatter(
+    effectiveDate,
+    system,
+    effectiveLocale,
+    compact
+  );
+  if (customResult !== null) {
+    return customResult;
+  }
+  const calendarTag = (system.intlCalendar || "gregory").trim();
+  return formatWithIntlFallback(
+    effectiveDate,
+    isoOrDateKey,
+    `${effectiveLocale}-u-ca-${calendarTag}`,
+    compact
+  );
+}
+const FALLBACK_RECURRENCE_PRESETS = [
+  { id: "daily", label: "Daily", rrule: "FREQ=DAILY;INTERVAL=1" },
+  {
+    id: "weekly-mon",
+    label: "Weekly on Mondays",
+    rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=MO"
+  },
+  {
+    id: "weekly-tue",
+    label: "Weekly on Tuesdays",
+    rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=TU"
+  },
+  {
+    id: "weekly-wed",
+    label: "Weekly on Wednesdays",
+    rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=WE"
+  },
+  {
+    id: "weekly-thu",
+    label: "Weekly on Thursdays",
+    rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=TH"
+  },
+  {
+    id: "weekly-fri",
+    label: "Weekly on Fridays",
+    rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=FR"
+  },
+  {
+    id: "weekly-sat",
+    label: "Weekly on Saturdays",
+    rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=SA"
+  },
+  {
+    id: "weekly-sun",
+    label: "Weekly on Sundays",
+    rrule: "FREQ=WEEKLY;INTERVAL=1;BYDAY=SU"
+  },
+  { id: "monthly", label: "Monthly", rrule: "FREQ=MONTHLY;INTERVAL=1" },
+  { id: "yearly", label: "Yearly", rrule: "FREQ=YEARLY;INTERVAL=1" }
+];
+const WEEKDAYS$1 = [
+  { code: "MO", label: "Mon", fullName: "Monday", jsDay: 1 },
+  { code: "TU", label: "Tue", fullName: "Tuesday", jsDay: 2 },
+  { code: "WE", label: "Wed", fullName: "Wednesday", jsDay: 3 },
+  { code: "TH", label: "Thu", fullName: "Thursday", jsDay: 4 },
+  { code: "FR", label: "Fri", fullName: "Friday", jsDay: 5 },
+  { code: "SA", label: "Sat", fullName: "Saturday", jsDay: 6 },
+  { code: "SU", label: "Sun", fullName: "Sunday", jsDay: 0 }
+];
+function parseOptionalStartDate(startDate) {
+  if (typeof startDate === "string" && startDate.trim()) {
+    const d = new Date(startDate);
+    return Number.isNaN(d.getTime()) ? void 0 : d;
+  }
+  if (startDate instanceof Date && !Number.isNaN(startDate.getTime())) {
+    return startDate;
+  }
+  return void 0;
+}
+function buildOrderedRecurrencePresets(recurrencePresets, startDate) {
+  const byRRule = /* @__PURE__ */ new Map();
+  for (const def of FALLBACK_RECURRENCE_PRESETS) {
+    byRRule.set(def.rrule, def);
+  }
+  for (const p of recurrencePresets) {
+    if (p?.rrule) byRRule.set(p.rrule, p);
+  }
+  const parsedDate = parseOptionalStartDate(startDate);
+  const activeWeekday = parsedDate ? WEEKDAYS$1.find((w) => w.jsDay === parsedDate.getDay()) : void 0;
+  const result = [];
+  if (activeWeekday) {
+    const activeWeeklyRRule = `FREQ=WEEKLY;INTERVAL=1;BYDAY=${activeWeekday.code}`;
+    result.push({
+      id: `every-${activeWeekday.code.toLowerCase()}`,
+      label: `Every ${activeWeekday.fullName}`,
+      rrule: activeWeeklyRRule
+    });
+    byRRule.delete(activeWeeklyRRule);
+  }
+  for (const coreRRule of [
+    "FREQ=DAILY;INTERVAL=1",
+    "FREQ=MONTHLY;INTERVAL=1",
+    "FREQ=YEARLY;INTERVAL=1"
+  ]) {
+    const preset = byRRule.get(coreRRule);
+    if (preset) {
+      result.push(preset);
+      byRRule.delete(coreRRule);
+    }
+  }
+  for (const preset of byRRule.values()) {
+    result.push(preset);
+  }
+  return result;
+}
+const VALID_WEEKDAY_CODES = new Set(WEEKDAYS$1.map((w) => w.code));
+function extractByDays(rrule) {
+  const match = rrule.match(/BYDAY=([A-Z,]+)/i);
+  if (!match?.[1]) return [];
+  return match[1].toUpperCase().split(",").map((d) => d.trim()).filter((d) => VALID_WEEKDAY_CODES.has(d));
+}
+function formatCategoryLabel(category) {
+  const trimmed = category.trim();
+  if (!trimmed) return "";
+  return trimmed.split(/[\s_-]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function parseDateTimePickerValue(raw) {
+  if (!raw || !raw.trim()) return void 0;
+  const trimmed = raw.trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    const [y, m, d] = trimmed.split("-").map(Number);
+    const localDt = new Date(y, m - 1, d, 9, 0, 0, 0);
+    return Number.isNaN(localDt.getTime()) ? void 0 : localDt;
+  }
+  const dt = new Date(trimmed);
+  return Number.isNaN(dt.getTime()) ? void 0 : dt;
+}
+function formatLocalYmd(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function alignStartDateToWeekday(startStr, targetCode) {
+  if (!startStr) return startStr;
+  const target = WEEKDAYS$1.find((w) => w.code === targetCode);
+  if (!target) return startStr;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(startStr)) {
+    const dt2 = /* @__PURE__ */ new Date(`${startStr}T00:00:00.000Z`);
+    if (Number.isNaN(dt2.getTime())) return startStr;
+    const currentDay2 = dt2.getUTCDay();
+    const diff2 = (target.jsDay - currentDay2 + 7) % 7;
+    if (diff2 === 0) return startStr;
+    dt2.setUTCDate(dt2.getUTCDate() + diff2);
+    return dt2.toISOString().slice(0, 10);
+  }
+  const dt = new Date(startStr);
+  if (Number.isNaN(dt.getTime())) return startStr;
+  const currentDay = dt.getDay();
+  const diff = (target.jsDay - currentDay + 7) % 7;
+  if (diff === 0) return startStr;
+  dt.setDate(dt.getDate() + diff);
+  return dt.toISOString();
+}
+function buildInitialDateWindow() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getUTCFullYear();
+  return {
+    from: new Date(Date.UTC(y, 0, 1, 0, 0, 0)).toISOString(),
+    to: new Date(Date.UTC(y, 11, 31, 23, 59, 59)).toISOString()
+  };
+}
+function expandDateWindowToYear(currentStart, fromIso, toIso) {
+  const year = currentStart.getUTCFullYear();
+  const yearStart = new Date(Date.UTC(year, 0, 1, 0, 0, 0)).toISOString();
+  const yearEnd = new Date(Date.UTC(year, 11, 31, 23, 59, 59)).toISOString();
+  return {
+    from: fromIso < yearStart ? fromIso : yearStart,
+    to: toIso > yearEnd ? toIso : yearEnd
+  };
+}
+function matchLoadedSourceId(loadedSources, sourceFilter) {
+  if (!sourceFilter || sourceFilter === "all") return null;
+  if (loadedSources.some((s) => s.id === sourceFilter)) return sourceFilter;
+  const matched = loadedSources.find(
+    (s) => s.uid === sourceFilter || sourceFilter === "events" && (s.id.includes("event") || s.uid.includes("event")) || sourceFilter === "bookings" && (s.id.includes("booking") || s.uid.includes("booking"))
+  );
+  return matched ? matched.id : null;
+}
+function normalizeSelectedEndSlot(startStr, endStr) {
+  if (!endStr) return "";
+  if (/^\d{4}-\d{2}-\d{2}$/.test(startStr) && /^\d{4}-\d{2}-\d{2}$/.test(endStr)) {
+    const startMs = (/* @__PURE__ */ new Date(`${startStr}T00:00:00.000Z`)).getTime();
+    const endMs = (/* @__PURE__ */ new Date(`${endStr}T00:00:00.000Z`)).getTime();
+    if (!Number.isNaN(startMs) && !Number.isNaN(endMs) && endMs - startMs <= 864e5) {
+      return "";
+    }
+  }
+  return endStr;
+}
+function resolveActiveSecondaryCalendars(secondaryLangMode, configuredCalendars) {
+  if (secondaryLangMode === "off") {
+    return [];
+  }
+  const configured = (configuredCalendars ?? []).filter((c) => c.enabled);
+  if (configured.length > 0) {
+    return configured;
+  }
+  const hijriMatch = SUPPORTED_INTL_CALENDARS.find(
+    (c) => c.id === "islamic-umalqura"
+  );
+  return hijriMatch ? [
+    {
+      id: "hijri",
+      label: hijriMatch.defaultLabel,
+      intlCalendar: hijriMatch.intlCalendar,
+      enabled: true
+    }
+  ] : [];
+}
+function filterVisibleOccurrences(occurrences, sourceFilter) {
+  if (sourceFilter === "all") return occurrences;
+  return occurrences.filter(
+    (occ) => occ.sourceId === sourceFilter || occ.uid === sourceFilter || sourceFilter === "events" && (occ.sourceId.includes("event") || occ.uid.includes("event")) || sourceFilter === "bookings" && (occ.sourceId.includes("booking") || occ.uid.includes("booking"))
+  );
+}
+function computeSourceCounts(occurrences, sources) {
+  const counts = {};
+  for (const src of sources ?? []) {
+    counts[src.id] = 0;
+  }
+  for (const occ of occurrences) {
+    counts[occ.sourceId] = (counts[occ.sourceId] ?? 0) + 1;
+  }
+  return counts;
+}
+function buildSecondaryHeaderLabel(activeSecondaryCalendars, anchorDate, effectiveLocale, secondaryLangMode) {
+  if (activeSecondaryCalendars.length === 0 || secondaryLangMode === "off")
+    return "";
+  const anchorIso = anchorDate.toISOString().slice(0, 10);
+  const targetLoc = secondaryLangMode === "ar" ? "ar-SA" : effectiveLocale;
+  return activeSecondaryCalendars.map((sys) => {
+    const formatted = formatDateInCalendarSystem(
+      anchorIso,
+      { ...sys, locale: targetLoc },
+      targetLoc,
+      { compact: false }
+    );
+    return formatted ? `${sys.label}: ${formatted}` : "";
+  }).filter(Boolean).join(" • ");
+}
+function buildEnabledCalendarViews(settings, effectiveLocale) {
+  const b = getLocalizedCalendarBundle(effectiveLocale).buttonText;
+  const list = [];
+  if (settings?.monthView !== false)
+    list.push({ mode: "dayGridMonth", label: b.month });
+  if (settings?.weekView !== false)
+    list.push({ mode: "timeGridWeek", label: b.week });
+  if (settings?.dayView !== false)
+    list.push({ mode: "timeGridDay", label: b.day });
+  if (settings?.agendaView !== false)
+    list.push({ mode: "listMonth", label: b.list });
+  if (settings?.yearView !== false)
+    list.push({ mode: "multiMonthYear", label: b.year });
+  return list;
+}
+function toExclusiveAllDayEnd(startDate, endDate) {
+  const sDay = startDate.slice(0, 10);
+  const eDay = (endDate || startDate).slice(0, 10);
+  const baseDay = eDay >= sDay ? eDay : sDay;
+  const dt = /* @__PURE__ */ new Date(`${baseDay}T00:00:00.000Z`);
+  if (Number.isNaN(dt.getTime())) return endDate || startDate;
+  dt.setUTCDate(dt.getUTCDate() + 1);
+  return dt.toISOString().slice(0, 10);
+}
+function mapOccurrencesToFullCalendarEvents(occurrences, primaryColor) {
+  const fallbackColor = primaryColor || "#0284C7";
+  return occurrences.map((occ) => ({
+    id: occ.occurrenceId,
+    title: occ.title,
+    start: occ.allDay ? occ.startDate.slice(0, 10) : occ.startDate,
+    end: occ.allDay ? toExclusiveAllDayEnd(occ.startDate, occ.endDate) : occ.endDate,
+    allDay: occ.allDay,
+    backgroundColor: occ.color || fallbackColor,
+    borderColor: occ.color || fallbackColor,
+    extendedProps: { occurrence: occ }
+  }));
+}
+function addSourceCategoryKeys(cats, src, sourceFilter) {
+  if (src.enabled === false || sourceFilter && src.id !== sourceFilter)
+    return;
+  for (const key of Object.keys(src.categoryColors ?? {})) {
+    if (key) cats.add(key);
+  }
+}
+function collectAvailableCategories(sources, sourceFilter, visibleOccurrences) {
+  const cats = /* @__PURE__ */ new Set();
+  for (const src of sources ?? []) {
+    addSourceCategoryKeys(cats, src, sourceFilter);
+  }
+  for (const occ of visibleOccurrences) {
+    if (occ.category) cats.add(occ.category);
+  }
+  return Array.from(cats);
+}
+function computeStartEndIsoPair(quickStart, quickEnd) {
+  const startIso = quickStart.includes("T") ? new Date(quickStart).toISOString() : `${quickStart}T10:00:00.000Z`;
+  const hasValidEnd = Boolean(quickEnd) && !Number.isNaN(new Date(quickEnd).getTime());
+  const endIso = hasValidEnd ? new Date(quickEnd).toISOString() : new Date(new Date(startIso).getTime() + 36e5).toISOString();
+  return { startIso, endIso };
+}
+function buildQuickCreateRequestPayload(args) {
+  const { startIso, endIso } = computeStartEndIsoPair(
+    args.quickStart,
+    args.quickEnd
+  );
+  const targetSource = args.quickSourceId || (args.sourceFilter !== "all" ? args.sourceFilter : void 0);
+  return {
+    sourceId: targetSource,
+    title: args.quickTitle.trim(),
+    startDate: startIso,
+    endDate: endIso,
+    location: args.quickLocation.trim() || void 0,
+    category: args.quickCategory,
+    rrule: args.quickRRule || void 0,
+    customerName: args.quickCustomerName.trim() || void 0,
+    customerEmail: args.quickCustomerEmail.trim() || void 0,
+    partySize: args.quickPartySize || 1
+  };
+}
+function resolveActiveContentLocale(fallbackLocale) {
+  if (typeof window !== "undefined") {
+    const urlLoc = new URLSearchParams(window.location.search).get(
+      "plugins[i18n][locale]"
+    );
+    if (urlLoc) return urlLoc;
+  }
+  return fallbackLocale || "en";
+}
+function formatPluginMessageWithUrlLocale(pluginId, id, defaultMessage, formatMessage) {
+  const fullKey = `${pluginId}.${id}`;
+  if (typeof window !== "undefined") {
+    const urlLoc = new URLSearchParams(window.location.search).get(
+      "plugins[i18n][locale]"
+    );
+    const globalMessages = globalThis.__CM_I18N_MESSAGES__;
+    const override = urlLoc ? globalMessages?.[urlLoc]?.[fullKey] : void 0;
+    if (override) return override;
+  }
+  return formatMessage({ id: fullKey, defaultMessage });
+}
+const QuickCreateButtons = ({ showCreateButton, enabledSources, t, onOpenQuickCreate }) => {
+  if (!showCreateButton) return null;
+  if (enabledSources.length > 1) {
+    return /* @__PURE__ */ jsx(Fragment, { children: enabledSources.map((src, idx) => /* @__PURE__ */ jsxs(
+      Button,
+      {
+        variant: idx === 0 ? "default" : "secondary",
+        size: "S",
+        onClick: () => onOpenQuickCreate(src.id),
+        children: [
+          "+ ",
+          src.label
+        ]
+      },
+      src.id
+    )) });
+  }
+  return /* @__PURE__ */ jsxs(
+    Button,
+    {
+      variant: "default",
+      size: "S",
+      onClick: () => onOpenQuickCreate(enabledSources[0]?.id),
+      children: [
+        "+ ",
+        t("calendar.quickCreate", "New Entry")
+      ]
+    }
+  );
+};
+const CalendarToolbar = ({
+  t,
+  effectiveLocale,
+  effectiveDirection,
+  secondaryLangMode,
+  monthLabel,
+  secondaryHeaderLabel,
+  loading,
+  settings,
+  totalOccurrences,
+  sourceCounts,
+  sourceFilter,
+  onSourceFilterChange,
+  categoryFilter,
+  onCategoryFilterChange,
+  availableCategories,
+  viewMode,
+  enabledViews,
+  onViewChange,
+  onNavigate,
+  onOpenQuickCreate
+}) => {
+  const localeBundle = getLocalizedCalendarBundle(effectiveLocale);
+  const isRtl = effectiveDirection === "rtl";
+  const enabledSources = (settings?.sources ?? []).filter(
+    (src) => src.enabled !== false
+  );
+  const showSecondaryBadge = Boolean(
+    secondaryHeaderLabel && secondaryLangMode !== "off"
+  );
+  return /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 4, children: [
+    /* @__PURE__ */ jsxs(
+      Flex,
+      {
+        justifyContent: "space-between",
+        alignItems: "center",
+        wrap: "wrap",
+        gap: 3,
+        children: [
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "alpha", fontWeight: "bold", children: t("calendar.title", "Calendar & Scheduler") }),
+            /* @__PURE__ */ jsx(Box, { paddingTop: 1, children: /* @__PURE__ */ jsxs(Flex, { gap: 2, alignItems: "center", wrap: "wrap", children: [
+              /* @__PURE__ */ jsx(
+                Typography,
+                {
+                  variant: "delta",
+                  fontWeight: "bold",
+                  textColor: "neutral800",
+                  style: { textTransform: "uppercase", letterSpacing: "0.03em" },
+                  children: monthLabel.toUpperCase()
+                }
+              ),
+              showSecondaryBadge && /* @__PURE__ */ jsx(Badge, { backgroundColor: "secondary100", textColor: "secondary700", children: secondaryHeaderLabel }),
+              /* @__PURE__ */ jsxs(Badge, { backgroundColor: "neutral150", textColor: "neutral700", children: [
+                localeBundle.nativeName,
+                " (",
+                effectiveDirection.toUpperCase(),
+                ")"
+              ] }),
+              loading && /* @__PURE__ */ jsx(Typography, { variant: "pi", textColor: "neutral500", children: t("calendar.loading", "Syncing...") })
+            ] }) })
+          ] }),
+          /* @__PURE__ */ jsxs(Flex, { gap: 2, wrap: "wrap", children: [
+            /* @__PURE__ */ jsx(
+              QuickCreateButtons,
+              {
+                showCreateButton: settings?.showCreateButton !== false,
+                enabledSources,
+                t,
+                onOpenQuickCreate
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "secondary",
+                size: "S",
+                tag: "a",
+                href: "/api/calendar/feed.ics",
+                target: "_blank",
+                rel: "noopener noreferrer",
+                children: t("calendar.downloadIcsFeed", "iCal Feed (.ics)")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "tertiary",
+                size: "S",
+                tag: NavLink,
+                to: `/settings/${PLUGIN_ID}`,
+                children: t("calendar.settings", "Settings")
+              }
+            )
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(Box, { padding: 3, background: "neutral0", hasRadius: true, shadow: "filterShadow", children: /* @__PURE__ */ jsxs(
+      Flex,
+      {
+        justifyContent: "space-between",
+        alignItems: "center",
+        wrap: "wrap",
+        gap: 3,
+        children: [
+          /* @__PURE__ */ jsxs(Flex, { gap: 2, alignItems: "center", wrap: "wrap", children: [
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                variant: "tertiary",
+                size: "S",
+                onClick: () => onNavigate("prev"),
+                children: [
+                  isRtl ? "→" : "←",
+                  " ",
+                  localeBundle.buttonText.prev
+                ]
+              }
+            ),
+            settings?.showTodayButton !== false && /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "secondary",
+                size: "S",
+                onClick: () => onNavigate("today"),
+                children: localeBundle.buttonText.today
+              }
+            ),
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                variant: "tertiary",
+                size: "S",
+                onClick: () => onNavigate("next"),
+                children: [
+                  localeBundle.buttonText.next,
+                  " ",
+                  isRtl ? "←" : "→"
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Flex, { gap: 2, wrap: "wrap", alignItems: "center", children: [
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                size: "S",
+                variant: sourceFilter === "all" ? "default" : "tertiary",
+                onClick: () => onSourceFilterChange("all"),
+                children: [
+                  t("calendar.allSources", "All Sources"),
+                  " (",
+                  totalOccurrences,
+                  ")"
+                ]
+              }
+            ),
+            (settings?.sources ?? []).map((src) => {
+              const srcCount = sourceCounts?.[src.id] ?? 0;
+              return /* @__PURE__ */ jsxs(
+                Button,
+                {
+                  size: "S",
+                  variant: sourceFilter === src.id ? "default" : "tertiary",
+                  onClick: () => onSourceFilterChange(src.id),
+                  children: [
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        style: {
+                          display: "inline-block",
+                          width: 8,
+                          height: 8,
+                          borderRadius: "50%",
+                          background: src.color,
+                          marginRight: 6
+                        }
+                      }
+                    ),
+                    src.label,
+                    " (",
+                    srcCount,
+                    ")"
+                  ]
+                },
+                src.id
+              );
+            }),
+            /* @__PURE__ */ jsx(Box, { style: { minWidth: 175, maxWidth: 220 }, children: /* @__PURE__ */ jsxs(
+              SingleSelect,
+              {
+                size: "S",
+                "aria-label": t("calendar.toolbar.category", "Category Filter"),
+                placeholder: t("placeholder.all_categories", "All Categories"),
+                value: categoryFilter,
+                onChange: (val) => onCategoryFilterChange(String(val)),
+                children: [
+                  /* @__PURE__ */ jsx(SingleSelectOption, { value: "all", children: t("calendar.allCategories", "All Categories") }),
+                  availableCategories.map((cat) => /* @__PURE__ */ jsx(SingleSelectOption, { value: cat, children: formatCategoryLabel(cat) }, cat))
+                ]
+              }
+            ) })
+          ] }),
+          /* @__PURE__ */ jsx(Flex, { gap: 1, wrap: "wrap", children: enabledViews.map((v) => /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "S",
+              variant: viewMode === v.mode ? "default" : "tertiary",
+              onClick: () => onViewChange(v.mode),
+              children: v.label
+            },
+            v.mode
+          )) })
+        ]
+      }
+    ) })
+  ] });
+};
+const CALENDAR_COLOR_PALETTES = {
+  default: {
+    id: "default",
+    label: "Theme Default",
+    lightPrimary: "#0284C7",
+    darkPrimary: "#38BDF8",
+    lightHeaderBg: "#E0F2FE",
+    lightHeaderText: "#0C4A6E",
+    lightTodayBg: "#F0F9FF",
+    lightBadgeBg: "#E0F2FE",
+    lightBadgeText: "#0369A1",
+    lightBadgeBorder: "#7DD3FC",
+    darkHeaderBg: "#1E293B",
+    darkHeaderText: "#E2E8F0",
+    darkTodayBg: "#172554",
+    darkBadgeBg: "#1E293B",
+    darkBadgeText: "#7DD3FC",
+    darkBadgeBorder: "#0369A1"
+  },
+  purple: {
+    id: "purple",
+    label: "Monarch Purple",
+    lightPrimary: "#6750A4",
+    darkPrimary: "#D0BCFF",
+    lightHeaderBg: "#F3EDF7",
+    lightHeaderText: "#381E72",
+    lightTodayBg: "#F7F2FA",
+    lightBadgeBg: "#EADDFF",
+    lightBadgeText: "#4F378B",
+    lightBadgeBorder: "#D0BCFF",
+    darkHeaderBg: "#211F26",
+    darkHeaderText: "#E6E0E9",
+    darkTodayBg: "#2B223C",
+    darkBadgeBg: "#381E72",
+    darkBadgeText: "#EADDFF",
+    darkBadgeBorder: "#4F378B"
+  },
+  blue: {
+    id: "blue",
+    label: "Forma / Pulse Blue",
+    lightPrimary: "#0F6CBD",
+    darkPrimary: "#60A5FA",
+    lightHeaderBg: "#EFF6FC",
+    lightHeaderText: "#0A4478",
+    lightTodayBg: "#F0F7FF",
+    lightBadgeBg: "#DBEAFE",
+    lightBadgeText: "#1E40AF",
+    lightBadgeBorder: "#93C5FD",
+    darkHeaderBg: "#172130",
+    darkHeaderText: "#DBEAFE",
+    darkTodayBg: "#172554",
+    darkBadgeBg: "#1E3A8A",
+    darkBadgeText: "#BFDBFE",
+    darkBadgeBorder: "#2563EB"
+  },
+  indigo: {
+    id: "indigo",
+    label: "Breezy Indigo",
+    lightPrimary: "#4F46E5",
+    darkPrimary: "#818CF8",
+    lightHeaderBg: "#EEF2FF",
+    lightHeaderText: "#312E81",
+    lightTodayBg: "#EEF2FF",
+    lightBadgeBg: "#E0E7FF",
+    lightBadgeText: "#3730A3",
+    lightBadgeBorder: "#A5B4FC",
+    darkHeaderBg: "#1E1B4B",
+    darkHeaderText: "#E0E7FF",
+    darkTodayBg: "#1E1B4B",
+    darkBadgeBg: "#312E81",
+    darkBadgeText: "#C7D2FE",
+    darkBadgeBorder: "#4F46E5"
+  },
+  emerald: {
+    id: "emerald",
+    label: "Emerald Green",
+    lightPrimary: "#059669",
+    darkPrimary: "#34D399",
+    lightHeaderBg: "#ECFDF5",
+    lightHeaderText: "#065F46",
+    lightTodayBg: "#F0FDF4",
+    lightBadgeBg: "#D1FAE5",
+    lightBadgeText: "#065F46",
+    lightBadgeBorder: "#6EE7B7",
+    darkHeaderBg: "#064E3B",
+    darkHeaderText: "#D1FAE5",
+    darkTodayBg: "#064E3B",
+    darkBadgeBg: "#065F46",
+    darkBadgeText: "#A7F3D0",
+    darkBadgeBorder: "#059669"
+  },
+  rose: {
+    id: "rose",
+    label: "Pulse Rose",
+    lightPrimary: "#E11D48",
+    darkPrimary: "#FB7185",
+    lightHeaderBg: "#FFF1F2",
+    lightHeaderText: "#881337",
+    lightTodayBg: "#FFF1F2",
+    lightBadgeBg: "#FFE4E6",
+    lightBadgeText: "#9F1239",
+    lightBadgeBorder: "#FDA4AF",
+    darkHeaderBg: "#3B0A19",
+    darkHeaderText: "#FFE4E6",
+    darkTodayBg: "#4C0519",
+    darkBadgeBg: "#881337",
+    darkBadgeText: "#FECDD3",
+    darkBadgeBorder: "#E11D48"
+  },
+  amber: {
+    id: "amber",
+    label: "Monarch Amber",
+    lightPrimary: "#D97706",
+    darkPrimary: "#FBBF24",
+    lightHeaderBg: "#FFFBEB",
+    lightHeaderText: "#78350F",
+    lightTodayBg: "#FEF3C7",
+    lightBadgeBg: "#FEF3C7",
+    lightBadgeText: "#92400E",
+    lightBadgeBorder: "#FCD34D",
+    darkHeaderBg: "#3B2506",
+    darkHeaderText: "#FEF3C7",
+    darkTodayBg: "#451A03",
+    darkBadgeBg: "#78350F",
+    darkBadgeText: "#FDE68A",
+    darkBadgeBorder: "#D97706"
+  }
+};
+function detectFromHexLuminance(strapiNeutral0) {
+  if (typeof strapiNeutral0 !== "string" || !strapiNeutral0.startsWith("#")) {
+    return null;
+  }
+  const hex = strapiNeutral0.slice(1).trim();
+  const r = hex.length === 3 ? Number.parseInt(hex[0] + hex[0], 16) : Number.parseInt(hex.slice(0, 2), 16);
+  if (Number.isNaN(r)) return null;
+  return r < 128 ? "dark" : "light";
+}
+function detectFromBrowserEnvironment() {
+  if (typeof window === "undefined") return "light";
+  try {
+    const storedTheme = window.localStorage?.getItem("STRAPI_THEME");
+    if (storedTheme === "dark" || storedTheme === "light") {
+      return storedTheme;
+    }
+  } catch {
+  }
+  return window.matchMedia?.("(prefers-color-scheme: dark)")?.matches ? "dark" : "light";
+}
+function detectEffectiveColorScheme(colorScheme = "auto", strapiNeutral0) {
+  if (colorScheme === "dark" || colorScheme === "light") {
+    return colorScheme;
+  }
+  return detectFromHexLuminance(strapiNeutral0) ?? detectFromBrowserEnvironment();
+}
+const CALENDAR_THEME_PRESETS = {
+  breeze: {
+    id: "breeze",
+    label: "Breezy (Modern Default)",
+    description: "FullCalendar Breezy style — airy sky & slate grid, soft-tinted event pills, and rounded-lg container",
+    category: "modern",
+    fontFamily: "'Inter Variable', Inter, system-ui, sans-serif",
+    containerRadius: "10px",
+    containerShadow: "0 1px 3px rgba(15, 23, 42, 0.06)",
+    eventRadius: "6px",
+    eventStyle: "tinted",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#0284C7",
+    headerBg: "#F8FAFC",
+    headerText: "#0F172A",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F8FAFC",
+    cellHoverBg: "#F0F9FF",
+    cellText: "#111827",
+    cellMutedText: "#6B7280",
+    borderColor: "#E5E7EB",
+    todayBg: "#F0F9FF",
+    todayBorder: "#0284C7",
+    todayNumberBg: "#0284C7",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#E0F2FE",
+    badgeText: "#0369A1",
+    badgeBorder: "#7DD3FC"
+  },
+  monarch: {
+    id: "monarch",
+    label: "Monarch (Material 3)",
+    description: "FullCalendar Monarch style — pill-shaped headers, centered day badges, tonal surfaces & rounded-xl frame",
+    category: "modern",
+    fontFamily: "'Roboto Variable', Roboto, system-ui, sans-serif",
+    containerRadius: "14px",
+    containerShadow: "0 2px 8px rgba(103, 80, 164, 0.08)",
+    eventRadius: "6px",
+    eventStyle: "solid",
+    dayNumberAlign: "center",
+    todayHeaderAccent: "pill",
+    primaryColor: "#6750A4",
+    headerBg: "#F7F2FA",
+    headerText: "#1D1B20",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#FAF8FC",
+    cellHoverBg: "#F3EDF7",
+    cellText: "#0C090C",
+    cellMutedText: "#79747E",
+    borderColor: "#DEDCE1",
+    todayBg: "#F7F2FA",
+    todayBorder: "#6750A4",
+    todayNumberBg: "#895264",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#EADDFF",
+    badgeText: "#4F378B",
+    badgeBorder: "#D0BCFF"
+  },
+  forma: {
+    id: "forma",
+    label: "Forma (Fluent Enterprise)",
+    description: "FullCalendar Forma style — architectural 6px left-accent event bars, top-accent Today bar & crisp 4px corners",
+    category: "modern",
+    fontFamily: "'Noto Sans Variable', 'Noto Sans', system-ui, sans-serif",
+    containerRadius: "4px",
+    containerShadow: "0 1px 2px rgba(0, 0, 0, 0.06)",
+    eventRadius: "3px",
+    eventStyle: "accent-bar",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "top-bar",
+    primaryColor: "#0F6CBD",
+    headerBg: "#FFFFFF",
+    headerText: "#030712",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F9FAFB",
+    cellHoverBg: "#EFF6FC",
+    cellText: "#030712",
+    cellMutedText: "#6B7280",
+    borderColor: "#E0E0E0",
+    todayBg: "#F5F9FF",
+    todayBorder: "#0F6CBD",
+    todayNumberBg: "#0F6CBD",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#EFF6FC",
+    badgeText: "#0F6CBD",
+    badgeBorder: "#B4D6FA"
+  },
+  pulse: {
+    id: "pulse",
+    label: "Pulse (Apple / macOS)",
+    description: "FullCalendar Pulse style — right-aligned day numbers, crimson Today circle, elevated controls & dotted minor slots",
+    category: "modern",
+    fontFamily: "ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, sans-serif",
+    containerRadius: "8px",
+    containerShadow: "0 1px 3px rgba(0, 0, 0, 0.12)",
+    eventRadius: "6px",
+    eventStyle: "solid",
+    dayNumberAlign: "end",
+    todayHeaderAccent: "pill",
+    primaryColor: "#117AFF",
+    headerBg: "#FFFFFF",
+    headerText: "#232D3E",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F9FAFB",
+    cellHoverBg: "#F0F7FF",
+    cellText: "#232D3E",
+    cellMutedText: "#545C6C",
+    borderColor: "#E5E7EB",
+    todayBg: "#FFF5F5",
+    todayBorder: "#FD453B",
+    todayNumberBg: "#FD453B",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#EFF6FF",
+    badgeText: "#1D4ED8",
+    badgeBorder: "#BFDBFE"
+  },
+  classic: {
+    id: "classic",
+    label: "Classic (FullCalendar Standard)",
+    description: "Traditional FullCalendar v6/v7 studio grid with slate headers, warm yellow Today cell tint & solid events",
+    category: "modern",
+    fontFamily: "ui-sans-serif, system-ui, sans-serif",
+    containerRadius: "6px",
+    containerShadow: "none",
+    eventRadius: "4px",
+    eventStyle: "solid",
+    dayNumberAlign: "end",
+    todayHeaderAccent: "tint",
+    primaryColor: "#3788D8",
+    headerBg: "#F8FAFC",
+    headerText: "#1E293B",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F8FAFC",
+    cellHoverBg: "#F1F5F9",
+    cellText: "#030712",
+    cellMutedText: "#6B7280",
+    borderColor: "#DDDDDD",
+    todayBg: "#FEFCE8",
+    todayBorder: "#EAB308",
+    todayNumberBg: "#334155",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#F1F5F9",
+    badgeText: "#334155",
+    badgeBorder: "#CBD5E1"
+  },
+  shadcn: {
+    id: "shadcn",
+    label: "Shadcn UI (Zinc Minimal)",
+    description: "Design-system theme matching Shadcn UI — ultra-clean 1px zinc borders, monochrome primary & tinted badges",
+    category: "design-system",
+    fontFamily: "'Inter Variable', Inter, system-ui, sans-serif",
+    containerRadius: "8px",
+    containerShadow: "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
+    eventRadius: "5px",
+    eventStyle: "tinted",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#18181B",
+    headerBg: "#FAFAFA",
+    headerText: "#09090B",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#FAFAFA",
+    cellHoverBg: "#F4F4F5",
+    cellText: "#09090B",
+    cellMutedText: "#71717A",
+    borderColor: "#E4E4E7",
+    todayBg: "#F4F4F5",
+    todayBorder: "#18181B",
+    todayNumberBg: "#18181B",
+    todayNumberText: "#FAFAFA",
+    badgeBg: "#F4F4F5",
+    badgeText: "#18181B",
+    badgeBorder: "#D4D4D8"
+  },
+  mui: {
+    id: "mui",
+    label: "Material UI (MUI Paper)",
+    description: "Design-system theme matching Material UI — Paper surface elevation, Roboto uppercase headers & Material blue",
+    category: "design-system",
+    fontFamily: "'Roboto Variable', Roboto, Helvetica, Arial, sans-serif",
+    containerRadius: "8px",
+    containerShadow: "0px 2px 4px -1px rgba(0,0,0,0.08), 0px 4px 5px 0px rgba(0,0,0,0.05)",
+    eventRadius: "4px",
+    eventStyle: "solid",
+    dayNumberAlign: "center",
+    todayHeaderAccent: "pill",
+    primaryColor: "#1976D2",
+    headerBg: "#F5F7FA",
+    headerText: "#1E293B",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#FAFAFA",
+    cellHoverBg: "#E3F2FD",
+    cellText: "#212121",
+    cellMutedText: "#757575",
+    borderColor: "#E0E0E0",
+    todayBg: "#E3F2FD",
+    todayBorder: "#1976D2",
+    todayNumberBg: "#1976D2",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#E3F2FD",
+    badgeText: "#1565C0",
+    badgeBorder: "#90CAF9"
+  },
+  emerald: {
+    id: "emerald",
+    label: "Emerald Mosque",
+    description: "Lush emerald & teal palette inspired by traditional Islamic architecture",
+    category: "heritage",
+    fontFamily: "'Inter Variable', Inter, system-ui, sans-serif",
+    containerRadius: "10px",
+    containerShadow: "0 1px 3px rgba(13, 148, 136, 0.08)",
+    eventRadius: "6px",
+    eventStyle: "solid",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#0D9488",
+    headerBg: "#CCFBF1",
+    headerText: "#115E59",
+    cellBg: "#FFFFFF",
+    cellAltBg: "#F0FDFA",
+    cellHoverBg: "#CCFBF1",
+    cellText: "#0F172A",
+    cellMutedText: "#475569",
+    borderColor: "#99F6E4",
+    todayBg: "#F0FDFA",
+    todayBorder: "#0D9488",
+    todayNumberBg: "#0D9488",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#CCFBF1",
+    badgeText: "#0F766E",
+    badgeBorder: "#5EEAD4"
+  },
+  sand: {
+    id: "sand",
+    label: "Warm Sand & Gold",
+    description: "Warm parchment & amber tones for high-comfort reading",
+    category: "heritage",
+    fontFamily: "'Noto Sans Variable', 'Noto Sans', system-ui, sans-serif",
+    containerRadius: "10px",
+    containerShadow: "0 1px 3px rgba(180, 83, 9, 0.08)",
+    eventRadius: "6px",
+    eventStyle: "solid",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#B45309",
+    headerBg: "#FEF3C7",
+    headerText: "#78350F",
+    cellBg: "#FFFBEB",
+    cellAltBg: "#FEF9C3",
+    cellHoverBg: "#FEF3C7",
+    cellText: "#1C1917",
+    cellMutedText: "#78716C",
+    borderColor: "#FDE68A",
+    todayBg: "#FEF3C7",
+    todayBorder: "#D97706",
+    todayNumberBg: "#B45309",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#FEF3C7",
+    badgeText: "#92400E",
+    badgeBorder: "#FCD34D"
+  },
+  midnight: {
+    id: "midnight",
+    label: "Midnight Slate",
+    description: "Deep dark-mode slate grid with luminous sky accents",
+    category: "heritage",
+    fontFamily: "'Inter Variable', Inter, system-ui, sans-serif",
+    containerRadius: "10px",
+    containerShadow: "0 4px 12px rgba(2, 6, 23, 0.35)",
+    eventRadius: "6px",
+    eventStyle: "tinted",
+    dayNumberAlign: "start",
+    todayHeaderAccent: "pill",
+    primaryColor: "#38BDF8",
+    headerBg: "#1E293B",
+    headerText: "#E2E8F0",
+    cellBg: "#0F172A",
+    cellAltBg: "#162032",
+    cellHoverBg: "#1E293B",
+    cellText: "#F8FAFC",
+    cellMutedText: "#94A3B8",
+    borderColor: "#334155",
+    todayBg: "#172554",
+    todayBorder: "#38BDF8",
+    todayNumberBg: "#0284C7",
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#1E293B",
+    badgeText: "#7DD3FC",
+    badgeBorder: "#0369A1"
+  }
+};
+function applyDarkSurfaceOverride(base, themeKey) {
+  return {
+    ...base,
+    headerBg: themeKey === "monarch" ? "#141218" : "#111827",
+    headerText: "#F3F4F6",
+    cellBg: "#030712",
+    cellAltBg: "#0B0F19",
+    cellHoverBg: "#1F2937",
+    cellText: "#F9FAFB",
+    cellMutedText: "#9CA3AF",
+    borderColor: themeKey === "forma" ? "#2A2A2A" : "#1F2937",
+    todayBg: "#172554",
+    todayBorder: base.primaryColor,
+    todayNumberBg: base.primaryColor,
+    todayNumberText: "#FFFFFF",
+    badgeBg: "#1E293B",
+    badgeText: "#E2E8F0",
+    badgeBorder: "#334155"
+  };
+}
+function selectPaletteColors(palette, isDark) {
+  if (isDark) {
+    return {
+      primary: palette.darkPrimary,
+      headerBg: palette.darkHeaderBg,
+      headerText: palette.darkHeaderText,
+      todayBg: palette.darkTodayBg,
+      badgeBg: palette.darkBadgeBg,
+      badgeText: palette.darkBadgeText,
+      badgeBorder: palette.darkBadgeBorder
+    };
+  }
+  return {
+    primary: palette.lightPrimary,
+    headerBg: palette.lightHeaderBg,
+    headerText: palette.lightHeaderText,
+    todayBg: palette.lightTodayBg,
+    badgeBg: palette.lightBadgeBg,
+    badgeText: palette.lightBadgeText,
+    badgeBorder: palette.lightBadgeBorder
+  };
+}
+function applyPaletteOverride(resolved, paletteKey, isDark) {
+  const palette = CALENDAR_COLOR_PALETTES[paletteKey];
+  if (!palette) return resolved;
+  const c = selectPaletteColors(palette, isDark);
+  return {
+    ...resolved,
+    primaryColor: c.primary,
+    headerBg: c.headerBg,
+    headerText: c.headerText,
+    todayBg: c.todayBg,
+    todayBorder: c.primary,
+    todayNumberBg: c.primary,
+    todayNumberText: isDark && paletteKey === "purple" ? "#381E72" : "#FFFFFF",
+    badgeBg: c.badgeBg,
+    badgeText: c.badgeText,
+    badgeBorder: c.badgeBorder
+  };
+}
+function resolveCalendarTheme(themeKey = "breeze", colorScheme = "auto", paletteKey = "default", strapiNeutral0) {
+  const base = CALENDAR_THEME_PRESETS[themeKey] ?? CALENDAR_THEME_PRESETS.breeze;
+  const effectiveScheme = detectEffectiveColorScheme(
+    colorScheme,
+    strapiNeutral0
+  );
+  const isDark = effectiveScheme === "dark" || themeKey === "midnight";
+  const surfaced = isDark && themeKey !== "midnight" ? applyDarkSurfaceOverride(base, themeKey) : { ...base };
+  return paletteKey !== "default" ? applyPaletteOverride(surfaced, paletteKey, isDark) : surfaced;
+}
+function buildEventStyleCss(scope, activeTheme, evtRadius) {
+  if (activeTheme.eventStyle === "tinted") {
+    return `
+      ${scope} .fc-daygrid-event,
+      ${scope} .fc-timegrid-event {
+        border-radius: ${evtRadius} !important;
+        border-width: 1px !important;
+        border-style: solid !important;
+        background: color-mix(in oklab, var(--fc-event-bg-color, ${activeTheme.primaryColor}) 20%, ${activeTheme.cellBg}) !important;
+        border-color: color-mix(in oklab, var(--fc-event-bg-color, ${activeTheme.primaryColor}) 45%, ${activeTheme.borderColor}) !important;
+        color: color-mix(in oklab, var(--fc-event-bg-color, ${activeTheme.primaryColor}) 72%, ${activeTheme.cellText}) !important;
+        box-shadow: none !important;
+      }
+      ${scope} .fc-daygrid-event .fc-event-main,
+      ${scope} .fc-timegrid-event .fc-event-main,
+      ${scope} .fc-daygrid-event .vicacha-fc-event-inner,
+      ${scope} .fc-timegrid-event .vicacha-fc-event-inner {
+        color: color-mix(in oklab, var(--fc-event-bg-color, ${activeTheme.primaryColor}) 75%, ${activeTheme.cellText}) !important;
+      }
+    `;
+  }
+  if (activeTheme.eventStyle === "accent-bar") {
+    return `
+      ${scope} .fc-daygrid-event,
+      ${scope} .fc-timegrid-event {
+        border-radius: ${evtRadius} !important;
+        border-top: 1px solid color-mix(in oklab, var(--fc-event-bg-color, ${activeTheme.primaryColor}) 32%, transparent) !important;
+        border-bottom: 1px solid color-mix(in oklab, var(--fc-event-bg-color, ${activeTheme.primaryColor}) 32%, transparent) !important;
+        border-inline-end: 1px solid color-mix(in oklab, var(--fc-event-bg-color, ${activeTheme.primaryColor}) 32%, transparent) !important;
+        border-inline-start: 6px solid var(--fc-event-bg-color, ${activeTheme.primaryColor}) !important;
+        background: color-mix(in oklab, var(--fc-event-bg-color, ${activeTheme.primaryColor}) 24%, ${activeTheme.cellBg}) !important;
+        color: ${activeTheme.cellText} !important;
+        box-shadow: none !important;
+      }
+      ${scope} .fc-daygrid-event .fc-event-main,
+      ${scope} .fc-timegrid-event .fc-event-main,
+      ${scope} .fc-daygrid-event .vicacha-fc-event-inner,
+      ${scope} .fc-timegrid-event .vicacha-fc-event-inner {
+        color: ${activeTheme.cellText} !important;
+      }
+    `;
+  }
+  return `
+    ${scope} .fc-daygrid-event,
+    ${scope} .fc-timegrid-event {
+      border-radius: ${evtRadius} !important;
+      box-shadow: 0 1px 2px rgba(0, 0, 0, 0.08) !important;
+    }
+  `;
+}
+function buildTodayCellCss(scope, activeTheme) {
+  if (activeTheme.todayHeaderAccent === "top-bar") {
+    return `
+      ${scope} .fc-daygrid-day.fc-day-today {
+        background: ${activeTheme.todayBg} !important;
+        box-shadow: inset 0 4px 0 0 ${activeTheme.todayBorder} !important;
+      }
+      ${scope} .fc-col-header-cell.fc-day-today {
+        box-shadow: inset 0 4px 0 0 ${activeTheme.todayBorder} !important;
+      }
+    `;
+  }
+  if (activeTheme.id === "monarch" || activeTheme.id === "pulse") {
+    return `
+      ${scope} .fc-daygrid-day.fc-day-today {
+        background: ${activeTheme.todayBg} !important;
+      }
+    `;
+  }
+  return `
+    ${scope} .fc-daygrid-day.fc-day-today {
+      background: ${activeTheme.todayBg} !important;
+      box-shadow: inset 0 0 0 2px ${activeTheme.todayBorder} !important;
+    }
+  `;
+}
+function buildInteractiveCursorCss(scope, allowCreate) {
+  if (!allowCreate) return "";
+  return `
+    ${scope} .fc-daygrid-day,
+    ${scope} .fc-timegrid-slot-lane {
+      cursor: pointer;
+    }
+    ${scope} .vicacha-fc-day-quick-add {
+      opacity: 0;
+      transition: opacity 0.15s ease, transform 0.15s ease;
+    }
+    ${scope} .fc-daygrid-day:hover .vicacha-fc-day-quick-add {
+      opacity: 1;
+    }
+  `;
+}
+function resolveThemeDefaults(activeTheme) {
+  return {
+    radius: activeTheme.containerRadius ?? "10px",
+    shadow: activeTheme.containerShadow ?? "none",
+    evtRadius: activeTheme.eventRadius ?? "6px",
+    fontFamily: activeTheme.fontFamily ?? "'Inter Variable', Inter, system-ui, sans-serif"
+  };
+}
+function resolveThemeVariantTokens(activeTheme) {
+  const isForma = activeTheme.id === "forma";
+  return {
+    nowColor: activeTheme.id === "pulse" ? "#EF4444" : activeTheme.primaryColor,
+    headerPad: activeTheme.id === "monarch" ? "12px 4px" : "10px 4px",
+    headerWeight: activeTheme.id === "pulse" ? 600 : 700,
+    headerTransform: isForma ? "none" : "uppercase",
+    headerTracking: isForma ? "0" : "0.04em",
+    listDayBorder: isForma ? `border-inline-start: 4px solid ${activeTheme.primaryColor} !important;` : "",
+    weekNumRadius: isForma ? "2px" : "5px"
+  };
+}
+function buildCalendarThemeCss(rawTheme, allowCreate = true) {
+  const safePrimary = /^#[0-9a-fA-F]{3,8}$/.test(rawTheme.primaryColor ?? "") ? rawTheme.primaryColor : "#0284C7";
+  const activeTheme = { ...rawTheme, primaryColor: safePrimary };
+  const scope = `.vicacha-fc-container.vicacha-fc-theme-${activeTheme.id}`;
+  const defaults = resolveThemeDefaults(activeTheme);
+  const variants = resolveThemeVariantTokens(activeTheme);
+  const eventRules = buildEventStyleCss(scope, activeTheme, defaults.evtRadius);
+  const todayCellRule = buildTodayCellCss(scope, activeTheme);
+  const interactiveCursorRule = buildInteractiveCursorCss(scope, allowCreate);
+  return `
+    ${scope} {
+      --fc-border-color: ${activeTheme.borderColor};
+      --fc-page-bg-color: ${activeTheme.cellBg};
+      --fc-neutral-bg-color: ${activeTheme.cellAltBg};
+      --fc-today-bg-color: ${activeTheme.todayBg};
+      --fc-highlight-color: ${activeTheme.cellHoverBg};
+      --fc-now-indicator-color: ${variants.nowColor};
+      font-family: ${defaults.fontFamily};
+      background: ${activeTheme.cellBg};
+      color: ${activeTheme.cellText};
+      border-radius: ${defaults.radius};
+      border: 1px solid ${activeTheme.borderColor};
+      box-shadow: ${defaults.shadow};
+      overflow: hidden;
+    }
+    ${scope} .fc-theme-standard th,
+    ${scope} .fc-col-header-cell {
+      background: ${activeTheme.headerBg} !important;
+      color: ${activeTheme.headerText} !important;
+      border-color: ${activeTheme.borderColor} !important;
+      padding: ${variants.headerPad} !important;
+    }
+    ${scope} .fc-col-header-cell-cushion {
+      color: ${activeTheme.headerText} !important;
+      font-weight: ${variants.headerWeight} !important;
+      font-size: 12px !important;
+      text-transform: ${variants.headerTransform} !important;
+      letter-spacing: ${variants.headerTracking} !important;
+      text-decoration: none !important;
+    }
+    ${scope} .fc-daygrid-day {
+      background: ${activeTheme.cellBg} !important;
+      color: ${activeTheme.cellText} !important;
+      border-color: ${activeTheme.borderColor} !important;
+      transition: background-color 0.15s ease;
+    }
+    ${scope} .fc-daygrid-day:hover {
+      background: ${activeTheme.cellHoverBg} !important;
+    }
+    ${scope} .fc-daygrid-day.fc-day-other {
+      background: ${activeTheme.cellAltBg} !important;
+      opacity: 0.72;
+    }
+    ${todayCellRule}
+    ${eventRules}
+    ${interactiveCursorRule}
+    ${scope} .fc-daygrid-day-top {
+      flex-direction: row !important;
+      width: 100% !important;
+      padding: 4px 4px 2px !important;
+      box-sizing: border-box !important;
+    }
+    ${scope} .fc-daygrid-day-number {
+      width: 100% !important;
+      min-width: 0 !important;
+      padding: 0 !important;
+      color: ${activeTheme.cellText} !important;
+      text-decoration: none !important;
+    }
+    ${scope} .fc-daygrid-day-frame {
+      min-height: 92px !important;
+      padding: 2px !important;
+      box-sizing: border-box !important;
+    }
+    ${scope} .fc-daygrid-more-link {
+      font-size: 11px !important;
+      font-weight: 700 !important;
+      color: ${activeTheme.primaryColor} !important;
+      padding: 1px 4px !important;
+      text-decoration: none !important;
+    }
+    ${scope} .fc-timegrid-slot,
+    ${scope} .fc-timegrid-axis,
+    ${scope} .fc-scrollgrid {
+      border-color: ${activeTheme.borderColor} !important;
+      color: ${activeTheme.cellText} !important;
+      background: ${activeTheme.cellBg} !important;
+    }
+    ${scope} .fc-timegrid-slot-minor {
+      border-top-style: dotted !important;
+    }
+    ${scope} .fc-timegrid-slot-label-cushion,
+    ${scope} .fc-list-day-text,
+    ${scope} .fc-list-day-side-text {
+      color: ${activeTheme.headerText} !important;
+      font-weight: 600 !important;
+      text-decoration: none !important;
+    }
+    ${scope} .fc-list-day-cushion {
+      background: ${activeTheme.headerBg} !important;
+      ${variants.listDayBorder}
+    }
+    ${scope} .fc-list-event td {
+      background: ${activeTheme.cellBg} !important;
+      color: ${activeTheme.cellText} !important;
+      border-color: ${activeTheme.borderColor} !important;
+    }
+    ${scope} .fc-list-empty {
+      background: ${activeTheme.cellAltBg} !important;
+      color: ${activeTheme.cellMutedText} !important;
+    }
+    ${scope} .fc-multimonth {
+      border: none !important;
+      padding: 12px !important;
+      gap: 14px !important;
+      box-sizing: border-box !important;
+      background: ${activeTheme.cellAltBg} !important;
+    }
+    ${scope} .fc-multimonth-month {
+      background: ${activeTheme.cellBg} !important;
+      color: ${activeTheme.cellText} !important;
+      border: 1px solid ${activeTheme.borderColor} !important;
+      border-radius: ${defaults.radius} !important;
+      box-sizing: border-box !important;
+      overflow: hidden !important;
+      padding: 0 !important;
+    }
+    ${scope} .fc-multimonth-month[style*="33.3"] {
+      width: calc((100% - 28px) / 3) !important;
+      flex: 0 0 calc((100% - 28px) / 3) !important;
+    }
+    ${scope} .fc-multimonth-month[style*="50%"] {
+      width: calc((100% - 14px) / 2) !important;
+      flex: 0 0 calc((100% - 14px) / 2) !important;
+    }
+    ${scope} .fc-multimonth-month[style*="25%"] {
+      width: calc((100% - 42px) / 4) !important;
+      flex: 0 0 calc((100% - 42px) / 4) !important;
+    }
+    ${scope} .fc-multimonth-month[style*="100%"] {
+      width: 100% !important;
+      flex: 0 0 100% !important;
+    }
+    ${scope} .fc-multimonth-header-table th,
+    ${scope} .fc-multimonth-month .fc-col-header-cell {
+      padding: 6px 2px !important;
+    }
+    ${scope} .fc-multimonth-month .fc-col-header-cell-cushion {
+      font-size: 10.5px !important;
+      letter-spacing: 0.02em !important;
+    }
+    ${scope} .fc-multimonth-month .fc-daygrid-day-frame {
+      min-height: 46px !important;
+      padding: 1px !important;
+    }
+    ${scope} .fc-multimonth-month .fc-daygrid-day-top {
+      padding: 2px 2px 1px !important;
+    }
+    ${scope} .fc-multimonth-title {
+      color: ${activeTheme.headerText} !important;
+      background: ${activeTheme.headerBg} !important;
+      border-bottom: 1px solid ${activeTheme.borderColor} !important;
+      font-size: 13px !important;
+      font-weight: 700 !important;
+      padding: 10px 12px !important;
+      text-transform: uppercase !important;
+      letter-spacing: 0.06em !important;
+    }
+    ${scope} .fc-daygrid-week-number {
+      background: ${activeTheme.badgeBg} !important;
+      color: ${activeTheme.badgeText} !important;
+      border-radius: ${variants.weekNumRadius} !important;
+      font-size: 10px !important;
+      font-weight: 600 !important;
+      padding: 1px 5px !important;
+      margin: 2px 4px !important;
+      opacity: 0.85;
+    }
+    @media (max-width: 1100px) {
+      ${scope} .vicacha-fc-day-quick-add {
+        display: none !important;
+      }
+      ${scope} .vicacha-fc-secondary-badge {
+        font-size: 9.5px !important;
+        padding: 0 5px !important;
+      }
+      ${scope} .fc-daygrid-day-frame {
+        min-height: 76px !important;
+      }
+    }
+    @media (max-width: 768px) {
+      ${scope} .vicacha-fc-secondary-badge {
+        display: none !important;
+      }
+      ${scope} .fc-daygrid-day-frame {
+        min-height: 58px !important;
+      }
+      ${scope} .fc-multimonth {
+        padding: 6px !important;
+        gap: 10px !important;
+      }
+    }
+  `;
+}
+function computeSecondaryBadges(dateKey, effectiveSecondaryLang, localeCode, activeSecondaryCalendars) {
+  if (effectiveSecondaryLang === "off") return [];
+  const targetLoc = effectiveSecondaryLang === "ar" ? "ar-SA" : localeCode;
+  return activeSecondaryCalendars.map((sys) => {
+    const sysLocale = effectiveSecondaryLang === "ar" ? "ar-SA" : sys.locale || targetLoc;
+    return formatDateInCalendarSystem(
+      dateKey,
+      { ...sys, locale: sysLocale },
+      targetLoc,
+      {
+        compact: true
+      }
+    );
+  }).filter(Boolean);
+}
+function buildDayHeaderStyle(activeTheme, isCompactYear, hasSecondaryBadges, allowCreate) {
+  const isEndAligned = activeTheme.dayNumberAlign === "end";
+  const isCenterAligned = activeTheme.dayNumberAlign === "center";
+  const justifyCenter = isCompactYear || isCenterAligned && !hasSecondaryBadges;
+  return {
+    display: "flex",
+    flexDirection: isEndAligned ? "row-reverse" : "row",
+    flexWrap: isCompactYear ? "nowrap" : "wrap",
+    justifyContent: justifyCenter ? "center" : "space-between",
+    alignItems: "center",
+    width: "100%",
+    minWidth: 0,
+    overflow: "hidden",
+    gap: isCompactYear ? 2 : 4,
+    padding: isCompactYear ? "1px 2px" : "2px 4px",
+    cursor: allowCreate ? "pointer" : "default"
+  };
+}
+function buildDayNumberBadgeStyle(activeTheme, isCompactYear, isToday) {
+  const fontSize = isCompactYear ? 12 : activeTheme.id === "monarch" ? 13.5 : 13;
+  const size = isCompactYear ? 22 : 26;
+  const borderRadius = activeTheme.id === "forma" && !isToday ? "3px" : "999px";
+  return {
+    fontWeight: 700,
+    fontSize,
+    lineHeight: 1.2,
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    minWidth: size,
+    height: size,
+    flexShrink: 0,
+    borderRadius,
+    padding: isCompactYear ? "0 4px" : "0 6px",
+    background: isToday ? activeTheme.todayNumberBg : "transparent",
+    color: isToday ? activeTheme.todayNumberText : activeTheme.cellText
+  };
+}
+const DayCellMetaBadges = ({
+  secondarySummary,
+  effectiveSecondaryLang,
+  activeTheme,
+  allowCreate
+}) => /* @__PURE__ */ jsxs(
+  "span",
+  {
+    className: "vicacha-fc-day-meta",
+    style: {
+      display: "inline-flex",
+      alignItems: "center",
+      gap: 4,
+      minWidth: 0,
+      maxWidth: "100%"
+    },
+    children: [
+      secondarySummary && /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "vicacha-fc-secondary-badge",
+          dir: effectiveSecondaryLang === "ar" ? "rtl" : "auto",
+          style: {
+            fontSize: 10.5,
+            background: activeTheme.badgeBg,
+            color: activeTheme.badgeText,
+            border: `1px solid ${activeTheme.badgeBorder}`,
+            borderRadius: activeTheme.id === "forma" ? "4px" : "999px",
+            padding: "1px 6px",
+            fontWeight: 600,
+            whiteSpace: "nowrap",
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            maxWidth: "100%",
+            lineHeight: 1.3
+          },
+          children: secondarySummary
+        }
+      ),
+      allowCreate && /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "vicacha-fc-day-quick-add",
+          style: {
+            display: "inline-flex",
+            alignItems: "center",
+            justifyContent: "center",
+            width: 18,
+            height: 18,
+            flexShrink: 0,
+            borderRadius: "999px",
+            background: activeTheme.primaryColor,
+            color: "#FFFFFF",
+            fontSize: 12,
+            fontWeight: 700,
+            lineHeight: 1
+          },
+          children: "+"
+        }
+      )
+    ]
+  }
+);
+const FULLCALENDAR_PLUGINS = [
+  dayGridPlugin,
+  timeGridPlugin,
+  listPlugin,
+  multiMonthPlugin,
+  interactionPlugin
+];
+const VIEW_SPECIFIC_OPTIONS = {
+  dayGridMonth: { dayMaxEventRows: 3 },
+  listMonth: { type: "list", duration: { years: 1 } },
+  multiMonthYear: {
+    type: "multiMonth",
+    duration: { years: 1 },
+    multiMonthMaxColumns: 3,
+    multiMonthMinWidth: 300,
+    dayMaxEventRows: 2,
+    weekNumbers: false
+  },
+  multiMonthYearStacked: {
+    type: "multiMonth",
+    duration: { years: 1 },
+    multiMonthMaxColumns: 1,
+    dayMaxEventRows: 3
+  },
+  dayGridYear: {
+    type: "dayGrid",
+    duration: { years: 1 },
+    dayMaxEventRows: 3
+  }
+};
+const ALL_CALENDAR_LOCALES = (() => {
+  const builtInMap = /* @__PURE__ */ new Map();
+  if (Array.isArray(allLocales)) {
+    for (const loc of allLocales) {
+      if (loc && loc.code) {
+        builtInMap.set(loc.code.toLowerCase(), loc);
+      }
+    }
+  }
+  for (const customLoc of SUPPORTED_CALENDAR_LOCALES) {
+    builtInMap.set(customLoc.code.toLowerCase(), customLoc);
+  }
+  return Array.from(builtInMap.values());
+})();
+function renderEventContent(eventArg) {
+  const occ = eventArg.event.extendedProps?.occurrence;
+  const isCompactYear = eventArg.view?.type === "multiMonthYear";
+  const tooltip = [eventArg.timeText, eventArg.event.title].filter(Boolean).join(" • ");
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "vicacha-fc-event-inner",
+      title: tooltip,
+      style: {
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap",
+        padding: isCompactYear ? "1px 4px" : "2px 6px",
+        fontSize: isCompactYear ? 11 : 12,
+        fontWeight: 600,
+        lineHeight: 1.3
+      },
+      children: [
+        occ?.isRecurring ? "↻ " : "",
+        !isCompactYear && eventArg.timeText ? /* @__PURE__ */ jsxs("b", { className: "vicacha-fc-event-time", children: [
+          eventArg.timeText,
+          " "
+        ] }) : null,
+        /* @__PURE__ */ jsx("span", { className: "vicacha-fc-event-title", children: eventArg.event.title })
+      ]
+    }
+  );
+}
+function resolveVisualKeys(props) {
+  const { settings } = props;
+  return {
+    activeThemeKey: props.theme ?? settings?.theme ?? "breeze",
+    configuredColorScheme: props.colorScheme ?? settings?.colorScheme ?? "auto",
+    activePaletteKey: props.themePalette ?? settings?.themePalette ?? "default",
+    effectiveSecondaryLang: props.secondaryCalendarLanguage ?? settings?.secondaryCalendarLanguage ?? "local",
+    allowCreate: settings?.showCreateButton !== false
+  };
+}
+function buildCalendarGridConfig(settings) {
+  return {
+    initialView: settings?.defaultView || "dayGridMonth",
+    weekNumbers: settings?.weekNumbers ?? false,
+    weekNumberCalculation: settings?.weekNumberCalculation ?? "ISO",
+    weekends: settings?.showWeekends ?? true,
+    slotMinTime: settings?.startHour || "07:00:00",
+    slotMaxTime: settings?.endHour || "21:00:00",
+    slotDuration: settings?.slotDuration || "00:30:00",
+    businessHours: settings?.businessHours || true
+  };
+}
+const FullCalendarCanvas = (props) => {
+  const {
+    calendarRef,
+    locale,
+    direction,
+    settings,
+    events,
+    activeSecondaryCalendars,
+    onDatesSet,
+    onSelectSlot,
+    onSelectOccurrence,
+    onDropOrResizeOccurrence
+  } = props;
+  const styledTheme = useTheme();
+  const strapiNeutral0 = styledTheme?.colors?.neutral0;
+  const localeBundle = useMemo(
+    () => getLocalizedCalendarBundle(locale),
+    [locale]
+  );
+  const {
+    activeThemeKey,
+    configuredColorScheme,
+    activePaletteKey,
+    effectiveSecondaryLang,
+    allowCreate
+  } = resolveVisualKeys(props);
+  const activeColorScheme = detectEffectiveColorScheme(
+    configuredColorScheme,
+    strapiNeutral0
+  );
+  const activeTheme = useMemo(
+    () => resolveCalendarTheme(
+      activeThemeKey,
+      activeColorScheme,
+      activePaletteKey,
+      strapiNeutral0
+    ),
+    [activeThemeKey, activeColorScheme, activePaletteKey, strapiNeutral0]
+  );
+  const effectiveDirection = useMemo(
+    () => direction ?? resolveCalendarDirection(locale, settings?.direction),
+    [direction, locale, settings?.direction]
+  );
+  const effectiveFirstDay = useMemo(
+    () => resolveLocaleFirstDay(locale, settings?.firstDayOfWeek),
+    [locale, settings?.firstDayOfWeek]
+  );
+  const timeFormat = useMemo(
+    () => buildFullCalendarTimeFormat(settings?.timeFormat24h ?? true),
+    [settings?.timeFormat24h]
+  );
+  const gridConfig = useMemo(
+    () => buildCalendarGridConfig(settings),
+    [settings]
+  );
+  const handleDatesSet = useCallback(
+    (dateInfo) => {
+      onDatesSet(
+        dateInfo.view.currentStart,
+        dateInfo.start.toISOString(),
+        dateInfo.end.toISOString()
+      );
+    },
+    [onDatesSet]
+  );
+  const handleDateClick = useCallback(
+    (clickInfo) => {
+      if (allowCreate) onSelectSlot(clickInfo.dateStr, "");
+    },
+    [allowCreate, onSelectSlot]
+  );
+  const handleSelect = useCallback(
+    (selectInfo) => {
+      if (allowCreate) onSelectSlot(selectInfo.startStr, selectInfo.endStr);
+    },
+    [allowCreate, onSelectSlot]
+  );
+  const handleEventClick = useCallback(
+    (clickInfo) => {
+      const occ = clickInfo.event.extendedProps?.occurrence;
+      if (occ) onSelectOccurrence(occ);
+    },
+    [onSelectOccurrence]
+  );
+  const handleEventDropOrResize = useCallback(
+    (arg) => {
+      const occ = arg.event.extendedProps?.occurrence;
+      if (!occ || !arg.event.start) return;
+      const startIso = arg.event.allDay ? `${arg.event.start.toISOString().slice(0, 10)}T00:00:00.000Z` : arg.event.start.toISOString();
+      let endIso = arg.event.end?.toISOString();
+      if (arg.event.allDay && arg.event.end) {
+        const inclusiveEnd = new Date(arg.event.end.getTime() - 864e5);
+        endIso = `${inclusiveEnd.toISOString().slice(0, 10)}T23:59:59.000Z`;
+      }
+      onDropOrResizeOccurrence(occ, startIso, endIso);
+    },
+    [onDropOrResizeOccurrence]
+  );
+  const renderDayCellContent = useCallback(
+    (cellArg) => {
+      const dateKey = cellArg.date.toISOString().slice(0, 10);
+      const secondaryBadges = computeSecondaryBadges(
+        dateKey,
+        effectiveSecondaryLang,
+        localeBundle.code,
+        activeSecondaryCalendars
+      );
+      const cleanDayNumber = cellArg.dayNumberText.replace(/[^\d٠-٩]/g, "") || cellArg.dayNumberText;
+      const isCompactYear = cellArg.view?.type === "multiMonthYear";
+      const secondarySummary = secondaryBadges.join(" · ");
+      const tooltipParts = [
+        dateKey,
+        secondarySummary,
+        allowCreate ? "+" : ""
+      ].filter(Boolean);
+      return /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "vicacha-fc-day-header",
+          onClick: (e) => {
+            if (allowCreate) {
+              e.stopPropagation();
+              onSelectSlot(dateKey, "");
+            }
+          },
+          title: tooltipParts.join(" • "),
+          style: buildDayHeaderStyle(
+            activeTheme,
+            isCompactYear,
+            secondaryBadges.length > 0,
+            allowCreate
+          ),
+          children: [
+            /* @__PURE__ */ jsx(
+              "span",
+              {
+                style: buildDayNumberBadgeStyle(
+                  activeTheme,
+                  isCompactYear,
+                  Boolean(cellArg.isToday)
+                ),
+                children: cleanDayNumber
+              }
+            ),
+            !isCompactYear && /* @__PURE__ */ jsx(
+              DayCellMetaBadges,
+              {
+                secondarySummary,
+                effectiveSecondaryLang,
+                activeTheme,
+                allowCreate
+              }
+            )
+          ]
+        }
+      );
+    },
+    [
+      activeSecondaryCalendars,
+      activeTheme,
+      allowCreate,
+      effectiveSecondaryLang,
+      localeBundle.code,
+      onSelectSlot
+    ]
+  );
+  const themeCss = useMemo(
+    () => buildCalendarThemeCss(activeTheme, allowCreate),
+    [activeTheme, allowCreate]
+  );
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      background: "neutral0",
+      hasRadius: true,
+      shadow: "tableShadow",
+      padding: 4,
+      style: { direction: effectiveDirection },
+      children: [
+        /* @__PURE__ */ jsx("style", { children: themeCss }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: `vicacha-fc-container vicacha-fc-theme-${activeTheme.id}`,
+            "data-color-scheme": activeColorScheme,
+            children: /* @__PURE__ */ jsx(
+              FullCalendar,
+              {
+                ref: calendarRef,
+                plugins: FULLCALENDAR_PLUGINS,
+                views: VIEW_SPECIFIC_OPTIONS,
+                initialView: gridConfig.initialView,
+                headerToolbar: false,
+                locales: ALL_CALENDAR_LOCALES,
+                locale: localeBundle.code,
+                direction: effectiveDirection,
+                firstDay: effectiveFirstDay,
+                weekNumbers: gridConfig.weekNumbers,
+                weekNumberCalculation: gridConfig.weekNumberCalculation,
+                weekText: localeBundle.weekText,
+                allDayText: localeBundle.allDayText,
+                moreLinkText: localeBundle.moreLinkText,
+                noEventsText: localeBundle.noEventsText,
+                buttonText: localeBundle.buttonText,
+                eventTimeFormat: timeFormat,
+                slotLabelFormat: timeFormat,
+                weekends: gridConfig.weekends,
+                slotMinTime: gridConfig.slotMinTime,
+                slotMaxTime: gridConfig.slotMaxTime,
+                slotDuration: gridConfig.slotDuration,
+                businessHours: gridConfig.businessHours,
+                nowIndicator: true,
+                editable: true,
+                selectable: allowCreate,
+                selectMirror: true,
+                dayMaxEvents: true,
+                height: "auto",
+                events,
+                datesSet: handleDatesSet,
+                dateClick: handleDateClick,
+                select: handleSelect,
+                eventClick: handleEventClick,
+                eventDrop: handleEventDropOrResize,
+                eventResize: handleEventDropOrResize,
+                dayCellContent: renderDayCellContent,
+                eventContent: renderEventContent
+              }
+            )
+          }
+        )
+      ]
+    }
+  );
+};
+function resolveSidePanelStartDate(docRecord, mappedStartField) {
+  const candidates = [
+    ...mappedStartField ? [mappedStartField] : [],
+    "startDate",
+    "preferredDate",
+    "date",
+    "checkIn"
+  ];
+  for (const key of candidates) {
+    const val = docRecord[key];
+    if (typeof val === "string" && val) return val;
+  }
+  return "";
+}
+const CalendarSidePanel = (props) => {
+  const { formatMessage, locale } = useIntl();
+  const { get } = useFetchClient();
+  const [settings, setSettings] = useState(null);
+  const model = props.model ?? "";
+  const docRecord = props.document ?? {};
+  const documentId = props.documentId ?? (typeof docRecord.documentId === "string" ? docRecord.documentId : "");
+  const matchedSource = useMemo(
+    () => settings?.sources?.find((s) => s.uid === model && s.enabled),
+    [settings?.sources, model]
+  );
+  const rawStartDate = resolveSidePanelStartDate(
+    docRecord,
+    matchedSource?.fields.startDate
+  );
+  const activeLocale = resolveActiveContentLocale(locale);
+  const rruleField = matchedSource?.fields.rrule || "recurrence";
+  const hasScheduleFields = Boolean(rawStartDate || docRecord[rruleField]);
+  useEffect(() => {
+    if (!hasScheduleFields || !documentId) return;
+    let mounted = true;
+    get(`/${PLUGIN_ID}/settings`).then((res) => {
+      if (mounted && res?.data?.data) {
+        setSettings(res.data.data);
+      }
+    }).catch(() => {
+    });
+    return () => {
+      mounted = false;
+    };
+  }, [model, get, hasScheduleFields, documentId]);
+  const computedAlternateDates = useMemo(() => {
+    if (!rawStartDate || !settings?.secondaryCalendars) {
+      return [];
+    }
+    return settings.secondaryCalendars.filter((sys) => sys.enabled).map((sys) => {
+      const rawFieldVal = sys.overrideField ? docRecord[sys.overrideField] : void 0;
+      const overrideVal = typeof rawFieldVal === "string" ? rawFieldVal.trim() : "";
+      const formatted = overrideVal || formatDateInCalendarSystem(rawStartDate, sys, activeLocale, {
+        compact: false
+      });
+      return {
+        id: sys.id,
+        label: sys.label,
+        formatted,
+        isOverridden: Boolean(overrideVal)
+      };
+    }).filter((item) => Boolean(item.formatted));
+  }, [rawStartDate, settings?.secondaryCalendars, docRecord, activeLocale]);
+  if (!hasScheduleFields || !documentId) {
+    return null;
+  }
+  const t = (id, defaultMessage) => formatPluginMessageWithUrlLocale(
+    PLUGIN_ID,
+    id,
+    defaultMessage,
+    formatMessage
+  );
+  const icsUrl = `/api/calendar/${encodeURIComponent(documentId)}/invite.ics`;
+  return {
+    title: t("sidePanel.title", "Calendar & Schedule"),
+    content: /* @__PURE__ */ jsx(Box, { paddingTop: 2, paddingBottom: 2, children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 3, children: [
+      computedAlternateDates.length > 0 && /* @__PURE__ */ jsxs(Box, { padding: 3, background: "neutral100", hasRadius: true, children: [
+        /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: t(
+          "sidePanel.secondaryCalendars",
+          "Alternative Calendar Dates"
+        ) }),
+        /* @__PURE__ */ jsx(
+          Flex,
+          {
+            direction: "column",
+            alignItems: "stretch",
+            gap: 1,
+            paddingTop: 2,
+            children: computedAlternateDates.map((alt) => /* @__PURE__ */ jsxs(
+              Flex,
+              {
+                justifyContent: "space-between",
+                alignItems: "center",
+                children: [
+                  /* @__PURE__ */ jsxs(Typography, { variant: "pi", textColor: "neutral600", children: [
+                    alt.label,
+                    ":"
+                  ] }),
+                  /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", children: alt.formatted })
+                ]
+              },
+              alt.id
+            ))
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 2, children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "secondary",
+            size: "S",
+            tag: "a",
+            href: icsUrl,
+            target: "_blank",
+            rel: "noopener noreferrer",
+            children: t("sidePanel.downloadIcs", "Download .ics Invite")
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "tertiary",
+            size: "S",
+            tag: NavLink,
+            to: `/plugins/${PLUGIN_ID}?documentId=${encodeURIComponent(documentId)}`,
+            children: t("sidePanel.openCalendar", "Open in Calendar View")
+          }
+        )
+      ] })
+    ] }) })
+  };
+};
+const Initializer = ({ setPlugin }) => {
+  const ref = useRef(setPlugin);
+  useEffect(() => {
+    ref.current?.(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const PluginIcon = () => /* @__PURE__ */ jsx(Calendar, {});
+const VALID_FREQUENCIES = [
+  "NONE",
+  "DAILY",
+  "WEEKLY",
+  "MONTHLY",
+  "YEARLY"
+];
+const JS_DAY_TO_RRULE_DAY = [
+  "SU",
+  "MO",
+  "TU",
+  "WE",
+  "TH",
+  "FR",
+  "SA"
+];
+const DAY_LABELS = {
+  MO: "Mon",
+  TU: "Tue",
+  WE: "Wed",
+  TH: "Thu",
+  FR: "Fri",
+  SA: "Sat",
+  SU: "Sun"
+};
+const FREQ_UNITS = {
+  NONE: ["", "days"],
+  DAILY: ["Every day", "days"],
+  WEEKLY: ["Every week", "weeks"],
+  MONTHLY: ["Every month", "months"],
+  YEARLY: ["Every year", "years"]
+};
+function parseBoundedInt(val, min, max) {
+  const n = Number.parseInt(val, 10);
+  return Number.isFinite(n) && n >= min && n <= max ? n : void 0;
+}
+function parseUntilDate(val) {
+  if (/^\d{8}(?:T\d{6}Z?)?$/.test(val)) {
+    return `${val.slice(0, 4)}-${val.slice(4, 6)}-${val.slice(6, 8)}`;
+  }
+  return /^\d{4}-\d{2}-\d{2}/.test(val) ? val.slice(0, 10) : void 0;
+}
+function parseByDayList(val) {
+  return val.split(",").map((d) => d.trim().slice(-2)).filter((d) => JS_DAY_TO_RRULE_DAY.includes(d));
+}
+const intAssigner = (key, min, max) => (p, v) => {
+  const n = parseBoundedInt(v, min, max);
+  if (n !== void 0) p[key] = n;
+};
+const RRULE_PART_ASSIGNERS = {
+  RSCALE: (p, v) => {
+    if (v) p.rscale = v.toLowerCase();
+  },
+  FREQ: (p, v) => {
+    if (VALID_FREQUENCIES.includes(v)) {
+      p.freq = v;
+    }
+  },
+  INTERVAL: intAssigner("interval", 1, 365),
+  BYDAY: (p, v) => {
+    p.byDay = parseByDayList(v);
+  },
+  BYMONTH: intAssigner("byMonth", 1, 13),
+  BYMONTHDAY: intAssigner("byMonthDay", 1, 31),
+  COUNT: intAssigner("count", 1, 1e3),
+  UNTIL: (p, v) => {
+    const u = parseUntilDate(v);
+    if (u !== void 0) p.until = u;
+  }
+};
+function parseRRule(rawRule) {
+  const defaultParsed = { freq: "NONE", interval: 1, byDay: [] };
+  if (!rawRule || typeof rawRule !== "string") return defaultParsed;
+  const cleaned = rawRule.trim().replace(/^RRULE:/i, "");
+  if (!cleaned) return defaultParsed;
+  const parsed = { ...defaultParsed };
+  for (const part of cleaned.split(";")) {
+    const [rawKey, rawVal] = part.split("=");
+    if (!rawKey || !rawVal) continue;
+    RRULE_PART_ASSIGNERS[rawKey.trim().toUpperCase()]?.(
+      parsed,
+      rawVal.trim().toUpperCase()
+    );
+  }
+  return parsed;
+}
+function buildRRule(parsed) {
+  if (!parsed || parsed.freq === "NONE") return "";
+  const rscale = parsed.rscale;
+  const segments = [];
+  if (rscale && rscale !== "gregory" && rscale !== "iso8601") {
+    segments.push(`RSCALE=${rscale.toUpperCase()}`);
+  }
+  segments.push(
+    `FREQ=${parsed.freq}`,
+    `INTERVAL=${Math.max(1, Math.floor(parsed.interval || 1))}`
+  );
+  if (parsed.freq === "WEEKLY" && Array.isArray(parsed.byDay)) {
+    const validDays = parsed.byDay.filter(
+      (d) => JS_DAY_TO_RRULE_DAY.includes(d)
+    );
+    if (validDays.length > 0) segments.push(`BYDAY=${validDays.join(",")}`);
+  }
+  if (parsed.freq === "YEARLY" && typeof parsed.byMonth === "number" && parsed.byMonth >= 1 && parsed.byMonth <= 13) {
+    segments.push(`BYMONTH=${Math.floor(parsed.byMonth)}`);
+  }
+  if ((parsed.freq === "MONTHLY" || parsed.freq === "YEARLY") && typeof parsed.byMonthDay === "number" && parsed.byMonthDay >= 1 && parsed.byMonthDay <= 31) {
+    segments.push(`BYMONTHDAY=${Math.floor(parsed.byMonthDay)}`);
+  }
+  if (typeof parsed.count === "number" && parsed.count >= 1) {
+    segments.push(`COUNT=${Math.floor(parsed.count)}`);
+  } else if (parsed.until && /^\d{4}-\d{2}-\d{2}$/.test(parsed.until)) {
+    segments.push(`UNTIL=${parsed.until.replace(/-/g, "")}T235959Z`);
+  }
+  return segments.join(";");
+}
+function formatRRuleSuffix(parsed) {
+  if (parsed.freq === "WEEKLY" && parsed.byDay.length > 0) {
+    return ` on ${parsed.byDay.map((d) => DAY_LABELS[d]).join(", ")}`;
+  }
+  if (parsed.freq === "YEARLY" && parsed.byMonth && parsed.byMonthDay) {
+    return ` on month ${parsed.byMonth}, day ${parsed.byMonthDay}`;
+  }
+  if (parsed.freq === "MONTHLY" && parsed.byMonthDay) {
+    return ` on day ${parsed.byMonthDay}`;
+  }
+  return "";
+}
+function describeRRule(rawRule) {
+  const parsed = parseRRule(rawRule);
+  if (parsed.freq === "NONE") return "Does not repeat (Single occurrence)";
+  const rscalePrefix = parsed.rscale && parsed.rscale !== "gregory" ? `[${parsed.rscale.toUpperCase()}] ` : "";
+  const [singular, plural] = FREQ_UNITS[parsed.freq] || ["Every year", "years"];
+  const intervalText = parsed.interval === 1 ? singular : `Every ${parsed.interval} ${plural}`;
+  const limit = parsed.count ? `, ${parsed.count} times` : parsed.until ? `, until ${parsed.until}` : "";
+  return `${rscalePrefix}${intervalText}${formatRRuleSuffix(parsed)}${limit}`;
+}
+function normalizeRRuleObject(obj, defaultTimezone) {
+  const rrule = typeof obj.rrule === "string" ? obj.rrule : "";
+  const parsed = parseRRule(rrule);
+  const timezone = typeof obj.timezone === "string" && obj.timezone ? obj.timezone : defaultTimezone;
+  const rscale = typeof obj.rscale === "string" ? obj.rscale : parsed.rscale;
+  const exdates = Array.isArray(obj.exdates) ? obj.exdates.filter((d) => typeof d === "string") : [];
+  const overrides = obj.overrides && typeof obj.overrides === "object" ? obj.overrides : {};
+  return {
+    rrule,
+    timezone,
+    rscale,
+    allDay: Boolean(obj.allDay),
+    exdates,
+    overrides
+  };
+}
+function parseRRuleFieldValue(raw, defaultTimezone = "UTC") {
+  const fallback = normalizeRRuleObject({}, defaultTimezone);
+  if (!raw) return fallback;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        const obj = JSON.parse(trimmed);
+        return normalizeRRuleObject(obj, defaultTimezone);
+      } catch {
+        return fallback;
+      }
+    }
+    const parsed = parseRRule(trimmed);
+    return { ...fallback, rrule: trimmed, rscale: parsed.rscale };
+  }
+  return typeof raw === "object" ? normalizeRRuleObject(raw, defaultTimezone) : fallback;
+}
+const WEEKDAYS = [
+  { code: "MO", label: "Mon" },
+  { code: "TU", label: "Tue" },
+  { code: "WE", label: "Wed" },
+  { code: "TH", label: "Thu" },
+  { code: "FR", label: "Fri" },
+  { code: "SA", label: "Sat" },
+  { code: "SU", label: "Sun" }
+];
+const COMMON_TIMEZONES = "UTC,America/Bogota,America/New_York,America/Mexico_City,America/Sao_Paulo,Europe/Madrid,Europe/London,Europe/Paris,Europe/Berlin,Europe/Amsterdam,Europe/Istanbul,Asia/Riyadh,Asia/Dubai".split(
+  ","
+);
+const FREQ_OPTIONS = [
+  ["NONE", "rrule.freq.none", "Does not repeat (Single Entry)"],
+  ["DAILY", "rrule.freq.daily", "Daily"],
+  ["WEEKLY", "rrule.freq.weekly", "Weekly"],
+  ["MONTHLY", "rrule.freq.monthly", "Monthly"],
+  ["YEARLY", "rrule.freq.yearly", "Yearly"]
+];
+const END_OPTIONS = [
+  ["never", "rrule.ends.never", "Never (Ongoing)"],
+  ["until", "rrule.ends.until", "On Specific Date (UNTIL)"],
+  ["count", "rrule.ends.count", "After N Occurrences (COUNT)"]
+];
+const REMOVE_BTN_STYLE = {
+  border: "none",
+  background: "transparent",
+  cursor: "pointer"
+};
+function applyEndModeChange(mode, updateRule) {
+  if (mode === "never") {
+    updateRule({ count: void 0, until: void 0 });
+  } else if (mode === "count") {
+    updateRule({ count: 10, until: void 0 });
+  } else if (mode === "until") {
+    const nextYear = /* @__PURE__ */ new Date();
+    nextYear.setUTCFullYear(nextYear.getUTCFullYear() + 1);
+    updateRule({
+      until: nextYear.toISOString().slice(0, 10),
+      count: void 0
+    });
+  }
+}
+const RRuleInput = ({
+  name,
+  value,
+  onChange,
+  disabled = false,
+  error,
+  label,
+  required = false,
+  hint
+}) => {
+  const { formatMessage } = useIntl();
+  const t = (id, defaultMessage) => formatPluginMessageWithUrlLocale(
+    PLUGIN_ID,
+    id,
+    defaultMessage,
+    formatMessage
+  );
+  const fieldValue = useMemo(() => parseRRuleFieldValue(value, "UTC"), [value]);
+  const parsedRule = useMemo(
+    () => parseRRule(fieldValue.rrule),
+    [fieldValue.rrule]
+  );
+  const [newExdate, setNewExdate] = useState("");
+  const isRepeating = parsedRule.freq !== "NONE";
+  const endMode = parsedRule.until ? "until" : parsedRule.count ? "count" : "never";
+  const emitChange = (next) => {
+    onChange({ target: { name, value: next, type: "json" } });
+  };
+  const updateRule = (patch) => {
+    const merged = { ...parsedRule, ...patch };
+    emitChange({
+      ...fieldValue,
+      rrule: buildRRule(merged),
+      rscale: merged.rscale
+    });
+  };
+  const toggleWeekday = (day) => {
+    const nextDays = parsedRule.byDay.includes(day) ? parsedRule.byDay.filter((d) => d !== day) : [...parsedRule.byDay, day];
+    updateRule({ byDay: nextDays });
+  };
+  const handleAddExdate = () => {
+    const clean = newExdate.trim();
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(clean)) return;
+    const current = fieldValue.exdates ?? [];
+    if (!current.includes(clean)) {
+      emitChange({ ...fieldValue, exdates: [...current, clean].sort() });
+    }
+    setNewExdate("");
+  };
+  const handleRemoveExdate = (dateToRemove) => {
+    emitChange({
+      ...fieldValue,
+      exdates: (fieldValue.exdates ?? []).filter((d) => d !== dateToRemove)
+    });
+  };
+  const renderSelect = (style, labelText, placeholderText, val, options, onSelect) => /* @__PURE__ */ jsx(Box, { style, children: /* @__PURE__ */ jsxs(Field.Root, { children: [
+    /* @__PURE__ */ jsx(Field.Label, { children: labelText }),
+    /* @__PURE__ */ jsx(
+      SingleSelect,
+      {
+        disabled,
+        placeholder: placeholderText,
+        value: val,
+        onChange: onSelect,
+        children: options.map(([optVal, optLabel]) => /* @__PURE__ */ jsx(SingleSelectOption, { value: optVal, children: optLabel }, optVal))
+      }
+    )
+  ] }) });
+  const renderNumber = (width, labelText, placeholderText, val, onValChange) => /* @__PURE__ */ jsx(Box, { style: { width }, children: /* @__PURE__ */ jsxs(Field.Root, { children: [
+    /* @__PURE__ */ jsx(Field.Label, { children: labelText }),
+    /* @__PURE__ */ jsx(
+      NumberInput,
+      {
+        disabled,
+        placeholder: placeholderText,
+        value: val,
+        onValueChange: onValChange
+      }
+    )
+  ] }) });
+  const exdatesList = fieldValue.exdates ?? [];
+  const summaryText = !isRepeating ? t("rrule.freq.none", "Does not repeat (Single Entry)") : describeRRule(fieldValue.rrule);
+  return /* @__PURE__ */ jsx(Field.Root, { name, error, hint, required, children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 3, children: [
+    label && /* @__PURE__ */ jsx(Field.Label, { children: label }),
+    /* @__PURE__ */ jsx(
+      Box,
+      {
+        padding: 4,
+        background: "neutral100",
+        borderColor: "neutral200",
+        hasRadius: true,
+        children: /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "stretch", gap: 4, children: [
+          /* @__PURE__ */ jsxs(
+            Flex,
+            {
+              justifyContent: "space-between",
+              alignItems: "center",
+              wrap: "wrap",
+              gap: 2,
+              children: [
+                /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: t("rrule.summaryLabel", "Recurrence Summary") }),
+                /* @__PURE__ */ jsx(Badge, { backgroundColor: "primary100", textColor: "primary700", children: summaryText })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs(Flex, { gap: 3, wrap: "wrap", children: [
+            renderSelect(
+              { flex: 1, minWidth: 170 },
+              t("rrule.frequency", "Repeat Frequency"),
+              t(
+                "placeholder.select_repeat_frequency",
+                "Select repeat frequency"
+              ),
+              parsedRule.freq,
+              FREQ_OPTIONS.map(([v, id, def]) => [v, t(id, def)]),
+              (val) => updateRule({
+                freq: val,
+                byDay: val === "WEEKLY" ? ["FR"] : []
+              })
+            ),
+            isRepeating && renderNumber(
+              130,
+              t("rrule.interval", "Every (Interval)"),
+              t("placeholder.1", "1"),
+              parsedRule.interval,
+              (val) => updateRule({ interval: val && val >= 1 ? val : 1 })
+            ),
+            isRepeating && renderSelect(
+              { flex: 1, minWidth: 190 },
+              t("rrule.rscale", "Calendar Scale (RSCALE)"),
+              t(
+                "placeholder.select_calendar_scale",
+                "Select calendar scale"
+              ),
+              parsedRule.rscale || "gregory",
+              SUPPORTED_INTL_CALENDARS.map((c) => [
+                c.intlCalendar,
+                c.defaultLabel
+              ]),
+              (val) => updateRule({ rscale: val === "gregory" ? void 0 : val })
+            ),
+            renderSelect(
+              { flex: 1, minWidth: 180 },
+              t("rrule.timezone", "Timezone"),
+              t("placeholder.select_timezone", "Select timezone"),
+              fieldValue.timezone || "UTC",
+              COMMON_TIMEZONES.map((tz) => [tz, tz]),
+              (tz) => emitChange({ ...fieldValue, timezone: String(tz) })
+            )
+          ] }),
+          /* @__PURE__ */ jsx(
+            Checkbox,
+            {
+              disabled,
+              checked: Boolean(fieldValue.allDay),
+              onCheckedChange: (checked) => emitChange({ ...fieldValue, allDay: Boolean(checked) }),
+              children: t("rrule.allDay", "All-day entry")
+            }
+          ),
+          parsedRule.freq === "WEEKLY" && /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Typography, { variant: "pi", fontWeight: "bold", children: t("rrule.byDay", "Repeat on Weekdays") }),
+            /* @__PURE__ */ jsx(Flex, { gap: 2, paddingTop: 2, wrap: "wrap", children: WEEKDAYS.map((day) => {
+              const active = parsedRule.byDay.includes(day.code);
+              return /* @__PURE__ */ jsx(
+                Button,
+                {
+                  size: "S",
+                  variant: active ? "default" : "tertiary",
+                  disabled,
+                  onClick: () => toggleWeekday(day.code),
+                  children: t(`weekday.${day.code.toLowerCase()}`, day.label)
+                },
+                day.code
+              );
+            }) })
+          ] }),
+          (parsedRule.freq === "MONTHLY" || parsedRule.freq === "YEARLY") && /* @__PURE__ */ jsxs(Flex, { gap: 3, wrap: "wrap", children: [
+            parsedRule.freq === "YEARLY" && renderNumber(
+              160,
+              t("rrule.byMonth", "Month (1-12)"),
+              t("placeholder.1", "1"),
+              parsedRule.byMonth ?? 1,
+              (val) => {
+                const maxMonth = parsedRule.rscale && parsedRule.rscale !== "gregory" && parsedRule.rscale !== "iso8601" ? 13 : 12;
+                updateRule({
+                  byMonth: val && val >= 1 && val <= maxMonth ? Math.floor(val) : void 0
+                });
+              }
+            ),
+            renderNumber(
+              160,
+              t("rrule.byMonthDay", "Day of Month (1-31)"),
+              t("placeholder.1", "1"),
+              parsedRule.byMonthDay ?? 1,
+              (val) => updateRule({
+                byMonthDay: val && val >= 1 && val <= 31 ? Math.floor(val) : void 0
+              })
+            )
+          ] }),
+          isRepeating && /* @__PURE__ */ jsxs(Flex, { gap: 3, wrap: "wrap", alignItems: "flex-end", children: [
+            renderSelect(
+              { width: 180 },
+              t("rrule.ends", "Series Ends"),
+              t(
+                "placeholder.select_series_end_mode",
+                "Select series end mode"
+              ),
+              endMode,
+              END_OPTIONS.map(([v, id, def]) => [v, t(id, def)]),
+              (mode) => applyEndModeChange(mode, updateRule)
+            ),
+            endMode === "until" && /* @__PURE__ */ jsx(Box, { style: { width: 200 }, children: /* @__PURE__ */ jsxs(Field.Root, { children: [
+              /* @__PURE__ */ jsx(Field.Label, { children: t("rrule.untilDate", "Until Date (YYYY-MM-DD)") }),
+              /* @__PURE__ */ jsx(
+                DatePicker,
+                {
+                  disabled,
+                  value: parseDateTimePickerValue(parsedRule.until),
+                  clearLabel: t("common.clear", "Clear"),
+                  onChange: (d) => updateRule({
+                    until: d ? formatLocalYmd(d) : void 0
+                  }),
+                  onClear: () => updateRule({ until: void 0 })
+                }
+              )
+            ] }) }),
+            endMode === "count" && renderNumber(
+              180,
+              t("rrule.occurrenceCount", "Max Occurrences"),
+              t("placeholder.10", "10"),
+              parsedRule.count ?? 10,
+              (val) => updateRule({
+                count: val && val >= 1 ? Math.floor(val) : 1
+              })
+            )
+          ] }),
+          isRepeating && /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsxs(Flex, { gap: 2, paddingTop: 1, wrap: "wrap", alignItems: "flex-end", children: [
+              /* @__PURE__ */ jsx(Box, { style: { width: 240 }, children: /* @__PURE__ */ jsxs(Field.Root, { children: [
+                /* @__PURE__ */ jsx(Field.Label, { children: t(
+                  "rrule.exdates",
+                  "Excluded Dates (Holiday / Exception Dates)"
+                ) }),
+                /* @__PURE__ */ jsx(
+                  DatePicker,
+                  {
+                    disabled,
+                    value: parseDateTimePickerValue(newExdate),
+                    clearLabel: t("common.clear", "Clear"),
+                    onChange: (d) => setNewExdate(d ? formatLocalYmd(d) : ""),
+                    onClear: () => setNewExdate("")
+                  }
+                )
+              ] }) }),
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  variant: "secondary",
+                  size: "S",
+                  disabled,
+                  onClick: handleAddExdate,
+                  children: t("rrule.addExdate", "Add Excluded Date")
+                }
+              )
+            ] }),
+            exdatesList.length > 0 && /* @__PURE__ */ jsx(Flex, { gap: 2, paddingTop: 2, wrap: "wrap", children: exdatesList.map((dt) => /* @__PURE__ */ jsxs(
+              Badge,
+              {
+                backgroundColor: "neutral200",
+                textColor: "neutral800",
+                children: [
+                  dt,
+                  " ",
+                  /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: () => handleRemoveExdate(dt),
+                      style: REMOVE_BTN_STYLE,
+                      "aria-label": `Remove ${dt}`,
+                      children: "×"
+                    }
+                  )
+                ]
+              },
+              dt
+            )) })
+          ] })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx(Field.Error, {}),
+    /* @__PURE__ */ jsx(Field.Hint, {})
+  ] }) });
+};
+const RRuleInput$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  RRuleInput
+}, Symbol.toStringTag, { value: "Module" }));
+const rruleCustomField = {
+  name: "rrule",
+  pluginId: PLUGIN_ID,
+  type: "json",
+  intlLabel: {
+    id: `${PLUGIN_ID}.rrule.field.label`,
+    defaultMessage: "Recurrence Schedule (RRULE / RSCALE)"
+  },
+  intlDescription: {
+    id: `${PLUGIN_ID}.rrule.field.description`,
+    defaultMessage: "Configure RFC 5545 & RFC 7529 recurring schedules, non-Gregorian calendar recurrence, excluded dates, and per-occurrence overrides."
+  },
+  icon: PluginIcon,
+  components: {
+    Input: async () => Promise.resolve().then(() => RRuleInput$1).then((module) => ({
+      default: module.RRuleInput
+    }))
+  }
+};
+const SUPPORTED_LOCALES = [
+  "en",
+  "es",
+  "fr",
+  "de",
+  "pt",
+  "it",
+  "nl",
+  "pl",
+  "tr",
+  "ar"
+];
+const index = {
+  register(app) {
+    app.customFields.register(rruleCustomField);
+    app.addMenuLink({
+      to: `plugins/${PLUGIN_ID}`,
+      icon: PluginIcon,
+      intlLabel: {
+        id: `${PLUGIN_ID}.plugin.name`,
+        defaultMessage: "Calendar"
+      },
+      permissions: [],
+      Component: () => import("./CalendarPage-Dq6YfSXF.js").then((mod) => ({
+        default: mod.CalendarPage
+      }))
+    });
+    const calendarSettingsSection = {
+      id: PLUGIN_ID,
+      intlLabel: {
+        id: `${PLUGIN_ID}.settings.section`,
+        defaultMessage: "Calendar, Events & Bookings"
+      }
+    };
+    const calendarSettingsLink = {
+      intlLabel: {
+        id: `${PLUGIN_ID}.settings.general`,
+        defaultMessage: "Calendar & Scheduler"
+      },
+      id: `${PLUGIN_ID}-settings`,
+      to: `${PLUGIN_ID}`,
+      Component: () => import("./SettingsPage-7SecVQEi.js").then((mod) => ({
+        default: mod.SettingsPage
+      })),
+      permissions: []
+    };
+    try {
+      if (typeof app.addSettingsLink === "function") {
+        app.addSettingsLink(calendarSettingsSection.id, calendarSettingsLink);
+      } else {
+        app.createSettingSection(calendarSettingsSection, [
+          calendarSettingsLink
+        ]);
+      }
+    } catch {
+      app.createSettingSection(calendarSettingsSection, [calendarSettingsLink]);
+    }
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+  },
+  bootstrap(app) {
+    const cmPlugin = app.getPlugin("content-manager");
+    if (cmPlugin?.apis?.addEditViewSidePanel) {
+      cmPlugin.apis.addEditViewSidePanel([CalendarSidePanel]);
+    }
+  },
+  registerTrads: createRegisterTrads({
+    pluginId: PLUGIN_ID,
+    defaultLocales: SUPPORTED_LOCALES,
+    loadTranslation: (locale) => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/ar.json": () => import("./ar-O6QL_nJZ.js"), "./translations/de.json": () => import("./de-BpDxjctz.js"), "./translations/en.json": () => import("./en-BoRq-9QD.js"), "./translations/es.json": () => import("./es-BZ7WX8Ev.js"), "./translations/fr.json": () => import("./fr-BnDr9DC8.js"), "./translations/it.json": () => import("./it-DkdUInap.js"), "./translations/nl.json": () => import("./nl-C2NFORLS.js"), "./translations/pl.json": () => import("./pl-mv5eXA8W.js"), "./translations/pt.json": () => import("./pt-WpvZGj3b.js"), "./translations/tr.json": () => import("./tr-BhZKvFoK.js") }), `./translations/${locale}.json`, 3)
+  })
+};
+export {
+  SUPPORTED_INTL_CALENDARS as A,
+  CalendarSidePanel as B,
+  CalendarToolbar as C,
+  SUPPORTED_LOCALES as D,
+  index as E,
+  FALLBACK_RECURRENCE_PRESETS as F,
+  PLUGIN_ID as P,
+  RRuleInput as R,
+  SUPPORTED_CALENDAR_LOCALES as S,
+  WEEKDAYS$1 as W,
+  formatLocalYmd as a,
+  buildOrderedRecurrencePresets as b,
+  alignStartDateToWeekday as c,
+  describeRRule as d,
+  extractByDays as e,
+  formatCategoryLabel as f,
+  buildInitialDateWindow as g,
+  resolveCalendarDirection as h,
+  computeSourceCounts as i,
+  filterVisibleOccurrences as j,
+  collectAvailableCategories as k,
+  resolveActiveSecondaryCalendars as l,
+  matchLoadedSourceId as m,
+  mapOccurrencesToFullCalendarEvents as n,
+  buildSecondaryHeaderLabel as o,
+  parseDateTimePickerValue as p,
+  buildEnabledCalendarViews as q,
+  resolveFullCalendarLocale as r,
+  FullCalendarCanvas as s,
+  buildQuickCreateRequestPayload as t,
+  normalizeSelectedEndSlot as u,
+  expandDateWindowToYear as v,
+  detectEffectiveColorScheme as w,
+  CALENDAR_COLOR_PALETTES as x,
+  CALENDAR_THEME_PRESETS as y,
+  resolveCalendarTheme as z
+};