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

package/dist/shared/index.cjs

@@ -0,0 +1,1612 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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 registerCalendarSystemFormatter(calendarId, formatter) {
+  if (!calendarId || typeof formatter !== "function") {
+    throw new Error("Both calendarId and formatter function are required.");
+  }
+  customFormatters.set(calendarId, formatter);
+}
+function unregisterCalendarSystemFormatter(calendarId) {
+  customFormatters.delete(calendarId);
+}
+function getRegisteredCalendarFormatters() {
+  return customFormatters;
+}
+function applyDayOffset(date, dayOffset) {
+  if (!dayOffset || !Number.isFinite(dayOffset)) {
+    return date;
+  }
+  const offsetDays = Math.trunc(dayOffset);
+  return new Date(date.getTime() + offsetDays * 864e5);
+}
+function parseDigits(raw) {
+  const n = Number.parseInt(raw.replace(/[^0-9]/g, ""), 10);
+  return Number.isFinite(n) ? n : 0;
+}
+const INTL_PART_FIELD_MAP = {
+  year: "year",
+  relatedYear: "year",
+  month: "month",
+  day: "day"
+};
+function parseIntlPartsToYmd(parts) {
+  const ymd = { year: 0, month: 0, day: 0 };
+  for (const part of parts) {
+    const key = INTL_PART_FIELD_MAP[String(part.type)];
+    if (!key) continue;
+    const val = parseDigits(part.value);
+    if (val > 0) ymd[key] = val;
+  }
+  return ymd.month >= 1 && ymd.day >= 1 ? ymd : null;
+}
+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 extractCalendarParts(date, intlCalendar, dayOffset = 0) {
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  const effectiveDate = applyDayOffset(date, dayOffset);
+  const calendarTag = (intlCalendar || "gregory").trim().toLowerCase();
+  try {
+    const formatter = getCachedIntlFormatter(`en-u-ca-${calendarTag}-nu-latn`, {
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      timeZone: "UTC"
+    });
+    const parsed = parseIntlPartsToYmd(formatter.formatToParts(effectiveDate));
+    if (parsed) return parsed;
+  } catch {
+  }
+  return {
+    year: effectiveDate.getUTCFullYear(),
+    month: effectiveDate.getUTCMonth() + 1,
+    day: effectiveDate.getUTCDate()
+  };
+}
+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
+  );
+}
+function readTrimmedString(val) {
+  return typeof val === "string" ? val.trim() : "";
+}
+function extractDocAltDatesMap(doc) {
+  if (doc.alternateDates && typeof doc.alternateDates === "object" && !Array.isArray(doc.alternateDates)) {
+    return doc.alternateDates;
+  }
+  return null;
+}
+function resolveSystemOverrideText(sys, doc, sourceAltFields, docAltDatesMap) {
+  const fieldName = sourceAltFields[sys.id] || sys.overrideField;
+  const rawFieldOverride = fieldName ? readTrimmedString(doc[fieldName]) : "";
+  const rawJsonOverride = docAltDatesMap ? readTrimmedString(docAltDatesMap[sys.id]) : "";
+  return rawFieldOverride || rawJsonOverride;
+}
+function buildSingleSecondaryCalendarEntry(args) {
+  const {
+    sys,
+    occurrenceDate,
+    rawDateObj,
+    isBaseOccurrence,
+    doc,
+    sourceAltFields,
+    docAltDatesMap,
+    locale
+  } = args;
+  const rawOverride = resolveSystemOverrideText(
+    sys,
+    doc,
+    sourceAltFields,
+    docAltDatesMap
+  );
+  const parts = extractCalendarParts(
+    rawDateObj,
+    sys.intlCalendar,
+    sys.dayOffset ?? 0
+  );
+  const label = sys.label || sys.id;
+  if (rawOverride && isBaseOccurrence) {
+    return {
+      calendarId: sys.id,
+      label,
+      formatted: rawOverride,
+      compact: rawOverride,
+      intlCalendar: sys.intlCalendar,
+      year: parts?.year,
+      month: parts?.month,
+      day: parts?.day,
+      isOverridden: true
+    };
+  }
+  const formatted = formatDateInCalendarSystem(occurrenceDate, sys, locale, {
+    compact: false
+  });
+  if (!formatted) return null;
+  const compact = formatDateInCalendarSystem(occurrenceDate, sys, locale, {
+    compact: true
+  });
+  return {
+    calendarId: sys.id,
+    label,
+    formatted,
+    compact: compact || formatted,
+    intlCalendar: sys.intlCalendar,
+    year: parts?.year,
+    month: parts?.month,
+    day: parts?.day,
+    isOverridden: false
+  };
+}
+function appendDirectSourceFieldOverrides(result, sourceAltFields, doc) {
+  for (const [calendarId, fieldName] of Object.entries(sourceAltFields)) {
+    if (result[calendarId] || !fieldName) continue;
+    const rawVal = readTrimmedString(doc[fieldName]);
+    if (rawVal) {
+      result[calendarId] = {
+        calendarId,
+        label: calendarId,
+        formatted: rawVal,
+        compact: rawVal,
+        isOverridden: true
+      };
+    }
+  }
+}
+function appendJsonMapOverrides(result, docAltDatesMap) {
+  for (const [calendarId, val] of Object.entries(docAltDatesMap)) {
+    if (result[calendarId]) continue;
+    const trimmed = readTrimmedString(val);
+    if (trimmed) {
+      result[calendarId] = {
+        calendarId,
+        label: calendarId,
+        formatted: trimmed,
+        compact: trimmed,
+        isOverridden: true
+      };
+    }
+  }
+}
+function populateSecondarySystems(args) {
+  for (const sys of args.secondaryCalendars) {
+    if (!sys?.enabled || !sys.id) continue;
+    const entry = buildSingleSecondaryCalendarEntry({ ...args, sys });
+    if (entry) args.result[sys.id] = entry;
+  }
+}
+function resolveOccurrenceAlternateDates(params) {
+  const { occurrenceDate, baseDateKey, isRecurring, doc, source } = params;
+  const result = {};
+  const sourceAltFields = source.fields.alternateDateFields ?? {};
+  const isBaseOccurrence = !isRecurring || occurrenceDate === baseDateKey;
+  const docAltDatesMap = extractDocAltDatesMap(doc);
+  populateSecondarySystems({
+    result,
+    secondaryCalendars: params.secondaryCalendars ?? [],
+    occurrenceDate,
+    rawDateObj: /* @__PURE__ */ new Date(`${occurrenceDate}T12:00:00.000Z`),
+    isBaseOccurrence,
+    doc,
+    sourceAltFields,
+    docAltDatesMap,
+    locale: params.locale ?? "en"
+  });
+  if (isBaseOccurrence) {
+    appendDirectSourceFieldOverrides(result, sourceAltFields, doc);
+    if (docAltDatesMap) appendJsonMapOverrides(result, docAltDatesMap);
+  }
+  return result;
+}
+function escapeIcsText(value) {
+  if (!value) return "";
+  return String(value).replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\r?\n/g, "\\n");
+}
+const utf8Encoder = new TextEncoder();
+function foldIcsLine(line) {
+  if (utf8Encoder.encode(line).byteLength <= 75) {
+    return line;
+  }
+  const chunks = [];
+  let current = "";
+  let currentBytes = 0;
+  for (const codePoint of line) {
+    const cpBytes = utf8Encoder.encode(codePoint).byteLength;
+    if (currentBytes + cpBytes > 75) {
+      chunks.push(current);
+      current = ` ${codePoint}`;
+      currentBytes = 1 + cpBytes;
+    } else {
+      current += codePoint;
+      currentBytes += cpBytes;
+    }
+  }
+  if (current) {
+    chunks.push(current);
+  }
+  return chunks.join("\r\n");
+}
+const pad = (n) => String(n).padStart(2, "0");
+function toIcsTimestamp(iso, allDay = false) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) {
+    return "19700101T000000Z";
+  }
+  const y = date.getUTCFullYear();
+  const m = pad(date.getUTCMonth() + 1);
+  const d = pad(date.getUTCDate());
+  if (allDay) {
+    return `${y}${m}${d}`;
+  }
+  const hh = pad(date.getUTCHours());
+  const mm = pad(date.getUTCMinutes());
+  const ss = pad(date.getUTCSeconds());
+  return `${y}${m}${d}T${hh}${mm}${ss}Z`;
+}
+function toExclusiveAllDayEndStamp(startIso, endIso) {
+  const startDate = new Date(startIso);
+  const endDate = new Date(endIso);
+  if (Number.isNaN(startDate.getTime())) {
+    return "19700102";
+  }
+  const startMidnight = Date.UTC(
+    startDate.getUTCFullYear(),
+    startDate.getUTCMonth(),
+    startDate.getUTCDate()
+  );
+  const endMidnight = Number.isNaN(endDate.getTime()) ? startMidnight : Date.UTC(
+    endDate.getUTCFullYear(),
+    endDate.getUTCMonth(),
+    endDate.getUTCDate()
+  );
+  const isAlreadyExclusiveMidnight = !Number.isNaN(endDate.getTime()) && endMidnight > startMidnight && endDate.getUTCHours() === 0 && endDate.getUTCMinutes() === 0 && endDate.getUTCSeconds() === 0;
+  const exclusiveDate = new Date(
+    isAlreadyExclusiveMidnight ? endMidnight : Math.max(startMidnight, endMidnight) + 864e5
+  );
+  return toIcsTimestamp(exclusiveDate.toISOString(), true);
+}
+function buildCalendarLinks(params) {
+  const startStamp = toIcsTimestamp(params.startDate, params.allDay);
+  const endStamp = params.allDay ? toExclusiveAllDayEndStamp(params.startDate, params.endDate) : toIcsTimestamp(params.endDate, false);
+  const googleParams = new URLSearchParams({
+    action: "TEMPLATE",
+    text: params.title,
+    dates: `${startStamp}/${endStamp}`
+  });
+  if (params.summary) googleParams.set("details", params.summary);
+  if (params.location) googleParams.set("location", params.location);
+  const outlookParams = new URLSearchParams({
+    path: "/calendar/action/compose",
+    rru: "addevent",
+    subject: params.title,
+    startdt: params.startDate,
+    enddt: params.endDate
+  });
+  if (params.summary) outlookParams.set("body", params.summary);
+  if (params.location) outlookParams.set("location", params.location);
+  const yahooParams = new URLSearchParams({
+    v: "60",
+    title: params.title,
+    st: startStamp,
+    et: endStamp
+  });
+  if (params.summary) yahooParams.set("desc", params.summary);
+  if (params.location) yahooParams.set("in_loc", params.location);
+  const querySuffix = params.occurrenceDate ? `?occurrenceDate=${encodeURIComponent(params.occurrenceDate)}` : "";
+  return {
+    google: `https://calendar.google.com/calendar/render?${googleParams.toString()}`,
+    outlook: `https://outlook.live.com/calendar/0/deeplink/compose?${outlookParams.toString()}`,
+    yahoo: `https://calendar.yahoo.com/?${yahooParams.toString()}`,
+    icsPath: `/api/calendar/${encodeURIComponent(params.documentId)}/invite.ics${querySuffix}`
+  };
+}
+function generateIcsCalendar(params) {
+  const nowStamp = toIcsTimestamp((/* @__PURE__ */ new Date()).toISOString());
+  const lines = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Vicacha Devs//Strapi Plugin Calendar//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    `X-WR-CALNAME:${escapeIcsText(params.calendarTitle)}`,
+    `X-WR-TIMEZONE:${escapeIcsText(params.timezone)}`
+  ];
+  for (const occ of params.occurrences) {
+    lines.push("BEGIN:VEVENT");
+    lines.push(`UID:${escapeIcsText(occ.occurrenceId)}@strapi-plugin-calendar`);
+    lines.push(`DTSTAMP:${nowStamp}`);
+    if (occ.allDay) {
+      lines.push(`DTSTART;VALUE=DATE:${toIcsTimestamp(occ.startDate, true)}`);
+      lines.push(
+        `DTEND;VALUE=DATE:${toExclusiveAllDayEndStamp(occ.startDate, occ.endDate)}`
+      );
+    } else {
+      lines.push(`DTSTART:${toIcsTimestamp(occ.startDate, false)}`);
+      lines.push(`DTEND:${toIcsTimestamp(occ.endDate, false)}`);
+    }
+    lines.push(`SUMMARY:${escapeIcsText(occ.title)}`);
+    if (occ.summary) {
+      lines.push(`DESCRIPTION:${escapeIcsText(occ.summary)}`);
+    }
+    if (occ.location) {
+      lines.push(`LOCATION:${escapeIcsText(occ.location)}`);
+    }
+    if (occ.category) {
+      lines.push(`CATEGORIES:${escapeIcsText(occ.category)}`);
+    }
+    if (occ.alternateDates) {
+      for (const alt of Object.values(occ.alternateDates)) {
+        const safeCalId = alt.calendarId.replace(/[^A-Za-z0-9-]/g, "").toUpperCase();
+        if (!safeCalId) continue;
+        lines.push(`X-ALT-DATE-${safeCalId}:${escapeIcsText(alt.formatted)}`);
+      }
+    }
+    const icsStatus = occ.status === "cancelled" ? "CANCELLED" : occ.status === "postponed" ? "TENTATIVE" : "CONFIRMED";
+    lines.push(`STATUS:${icsStatus}`);
+    lines.push("END:VEVENT");
+  }
+  lines.push("END:VCALENDAR");
+  return `${lines.map(foldIcsLine).join("\r\n")}\r
+`;
+}
+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 PLUGIN_ID = "calendar";
+const RRULE_CUSTOM_FIELD_UID = "plugin::calendar.rrule";
+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 toDateKeyUTC = (date) => date.toISOString().slice(0, 10);
+function buildEffectiveSlot(candidateDate, dateKey, ctx, isRecurring) {
+  if (ctx.exdatesSet.has(dateKey)) return null;
+  const override = ctx.overridesMap[dateKey];
+  if (override?.cancelled) return null;
+  const effStart = override?.startDate ? new Date(override.startDate) : candidateDate;
+  const effEnd = override?.endDate ? new Date(override.endDate) : new Date(effStart.getTime() + ctx.durationMs);
+  if (effEnd.getTime() < ctx.winStartMs || effStart.getTime() > ctx.winEndMs)
+    return null;
+  return {
+    occurrenceDate: dateKey,
+    startDate: effStart.toISOString(),
+    endDate: effEnd.toISOString(),
+    isRecurring,
+    isOverridden: Boolean(override),
+    ...isRecurring ? { rscale: ctx.effectiveRScale } : {},
+    override
+  };
+}
+function matchesNonGregorianFrequency(candidateDate, ctx) {
+  const calParts = extractCalendarParts(candidateDate, ctx.effectiveRScale);
+  if (!calParts || !ctx.baseParts) return false;
+  const interval = Math.max(1, ctx.parsed.interval);
+  if (ctx.parsed.freq === "MONTHLY") {
+    const monthsDiff = (calParts.year - ctx.baseParts.year) * 12 + (calParts.month - ctx.baseParts.month);
+    return monthsDiff >= 0 && monthsDiff % interval === 0 && calParts.day === ctx.targetDayOfMonth;
+  }
+  const yearsDiff = calParts.year - ctx.baseParts.year;
+  return yearsDiff >= 0 && yearsDiff % interval === 0 && calParts.month === ctx.targetMonth && calParts.day === ctx.targetDayOfMonth;
+}
+function matchesGregorianFrequency(candidateDate, dayOffset, ctx) {
+  const { freq, interval } = ctx.parsed;
+  if (freq === "DAILY") return dayOffset % interval === 0;
+  if (freq === "WEEKLY") {
+    const rruleDay = JS_DAY_TO_RRULE_DAY[candidateDate.getUTCDay()];
+    const startWeekDay = (ctx.startObj.getUTCDay() + 6) % 7;
+    const weekIdx = Math.floor((dayOffset + startWeekDay) / 7);
+    return weekIdx % interval === 0 && ctx.targetWeekdays.includes(rruleDay);
+  }
+  if (freq === "MONTHLY") {
+    const monthsDiff = (candidateDate.getUTCFullYear() - ctx.startObj.getUTCFullYear()) * 12 + (candidateDate.getUTCMonth() - ctx.startObj.getUTCMonth());
+    return monthsDiff >= 0 && monthsDiff % interval === 0 && candidateDate.getUTCDate() === ctx.targetDayOfMonth;
+  }
+  const yearsDiff = candidateDate.getUTCFullYear() - ctx.startObj.getUTCFullYear();
+  return yearsDiff >= 0 && yearsDiff % interval === 0 && candidateDate.getUTCMonth() + 1 === ctx.targetMonth && candidateDate.getUTCDate() === ctx.targetDayOfMonth;
+}
+function matchesCandidateRule(candidateDate, dayOffset, ctx) {
+  const isMonthOrYear = ctx.parsed.freq === "MONTHLY" || ctx.parsed.freq === "YEARLY";
+  if (ctx.isNonGregorianRScale && ctx.effectiveRScale && isMonthOrYear) {
+    return matchesNonGregorianFrequency(candidateDate, ctx);
+  }
+  return matchesGregorianFrequency(candidateDate, dayOffset, ctx);
+}
+function resolveEndDate(startObj, baseEndDate) {
+  if (baseEndDate) {
+    const parsedEnd = new Date(baseEndDate);
+    if (!Number.isNaN(parsedEnd.getTime())) return parsedEnd;
+  }
+  return new Date(startObj.getTime() + 60 * 60 * 1e3);
+}
+function resolveCalendarTargets(startObj, parsed, effectiveRScale) {
+  const isNonGregorianRScale = Boolean(effectiveRScale) && effectiveRScale !== "gregory" && effectiveRScale !== "iso8601";
+  const baseParts = isNonGregorianRScale && effectiveRScale ? extractCalendarParts(startObj, effectiveRScale) : null;
+  const targetMonth = parsed.byMonth ?? (baseParts ? baseParts.month : startObj.getUTCMonth() + 1);
+  const targetDayOfMonth = parsed.byMonthDay ?? (baseParts ? baseParts.day : startObj.getUTCDate());
+  const targetWeekdays = parsed.byDay.length > 0 ? parsed.byDay : [JS_DAY_TO_RRULE_DAY[startObj.getUTCDay()]];
+  return {
+    isNonGregorianRScale,
+    baseParts,
+    targetMonth,
+    targetDayOfMonth,
+    targetWeekdays
+  };
+}
+function createSlotContext(params) {
+  const { startObj, baseEndDate, recurrence, windowStart, windowEnd } = params;
+  const endObj = resolveEndDate(startObj, baseEndDate);
+  const parsed = parseRRule(recurrence?.rrule);
+  const effectiveRScale = recurrence?.rscale || parsed.rscale;
+  const targets = resolveCalendarTargets(startObj, parsed, effectiveRScale);
+  const untilMs = parsed.until ? (/* @__PURE__ */ new Date(`${parsed.until}T23:59:59.999Z`)).getTime() : Number.POSITIVE_INFINITY;
+  return {
+    startObj,
+    durationMs: Math.max(0, endObj.getTime() - startObj.getTime()),
+    winStartMs: new Date(windowStart).getTime(),
+    winEndMs: new Date(windowEnd).getTime(),
+    untilMs,
+    maxCount: parsed.count ?? params.maxOccurrences,
+    maxOccurrences: params.maxOccurrences,
+    parsed,
+    exdatesSet: new Set(recurrence?.exdates ?? []),
+    overridesMap: recurrence?.overrides ?? {},
+    effectiveRScale,
+    ...targets,
+    anchorMidnightMs: Date.UTC(
+      startObj.getUTCFullYear(),
+      startObj.getUTCMonth(),
+      startObj.getUTCDate()
+    ),
+    timeOffsetMs: startObj.getUTCHours() * 36e5 + startObj.getUTCMinutes() * 6e4 + startObj.getUTCSeconds() * 1e3
+  };
+}
+function scanRecurringSlots(ctx) {
+  const results = [];
+  let generatedCount = 0;
+  const daysToWinEnd = Math.ceil((ctx.winEndMs - ctx.anchorMidnightMs) / 864e5) + 1;
+  const maxDayOffset = Math.min(Math.max(daysToWinEnd, 0), 36500);
+  const startDayOffset = ctx.parsed.count === void 0 && !ctx.isNonGregorianRScale ? Math.max(
+    0,
+    Math.floor(
+      (ctx.winStartMs - ctx.durationMs - ctx.anchorMidnightMs) / 864e5
+    ) - 1
+  ) : 0;
+  for (let dayOffset = startDayOffset; dayOffset <= maxDayOffset; dayOffset++) {
+    if (generatedCount >= ctx.maxCount || results.length >= ctx.maxOccurrences)
+      break;
+    const candidateDate = new Date(
+      ctx.anchorMidnightMs + dayOffset * 864e5 + ctx.timeOffsetMs
+    );
+    const candidateMs = candidateDate.getTime();
+    if (candidateMs > ctx.untilMs || candidateMs > ctx.winEndMs) break;
+    if (!matchesCandidateRule(candidateDate, dayOffset, ctx)) continue;
+    generatedCount++;
+    const slot = buildEffectiveSlot(
+      candidateDate,
+      toDateKeyUTC(candidateDate),
+      ctx,
+      true
+    );
+    if (slot) results.push(slot);
+  }
+  return results;
+}
+function expandRuleSlots(params) {
+  const startObj = new Date(params.baseStartDate);
+  if (Number.isNaN(startObj.getTime())) return [];
+  const ctx = createSlotContext({
+    ...params,
+    startObj,
+    maxOccurrences: params.maxOccurrences ?? 366
+  });
+  if (ctx.parsed.freq === "NONE") {
+    const slot = buildEffectiveSlot(
+      startObj,
+      toDateKeyUTC(startObj),
+      ctx,
+      false
+    );
+    return slot ? [slot] : [];
+  }
+  return scanRecurringSlots(ctx);
+}
+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;
+}
+exports.CALENDAR_COLOR_PALETTES = CALENDAR_COLOR_PALETTES;
+exports.CALENDAR_THEME_PRESETS = CALENDAR_THEME_PRESETS;
+exports.PLUGIN_ID = PLUGIN_ID;
+exports.RRULE_CUSTOM_FIELD_UID = RRULE_CUSTOM_FIELD_UID;
+exports.SUPPORTED_CALENDAR_LOCALES = SUPPORTED_CALENDAR_LOCALES;
+exports.SUPPORTED_INTL_CALENDARS = SUPPORTED_INTL_CALENDARS;
+exports.applyDayOffset = applyDayOffset;
+exports.buildCalendarLinks = buildCalendarLinks;
+exports.buildFullCalendarTimeFormat = buildFullCalendarTimeFormat;
+exports.buildRRule = buildRRule;
+exports.describeRRule = describeRRule;
+exports.detectEffectiveColorScheme = detectEffectiveColorScheme;
+exports.expandRuleSlots = expandRuleSlots;
+exports.extractCalendarParts = extractCalendarParts;
+exports.foldIcsLine = foldIcsLine;
+exports.formatDateInCalendarSystem = formatDateInCalendarSystem;
+exports.generateIcsCalendar = generateIcsCalendar;
+exports.getLocalizedCalendarBundle = getLocalizedCalendarBundle;
+exports.getRegisteredCalendarFormatters = getRegisteredCalendarFormatters;
+exports.isRtlLocale = isRtlLocale;
+exports.normalizeLocaleCode = normalizeLocaleCode;
+exports.parseRRule = parseRRule;
+exports.parseRRuleFieldValue = parseRRuleFieldValue;
+exports.registerCalendarSystemFormatter = registerCalendarSystemFormatter;
+exports.resolveCalendarDirection = resolveCalendarDirection;
+exports.resolveCalendarTheme = resolveCalendarTheme;
+exports.resolveFullCalendarLocale = resolveFullCalendarLocale;
+exports.resolveLocaleFirstDay = resolveLocaleFirstDay;
+exports.resolveOccurrenceAlternateDates = resolveOccurrenceAlternateDates;
+exports.toIcsTimestamp = toIcsTimestamp;
+exports.unregisterCalendarSystemFormatter = unregisterCalendarSystemFormatter;