diff --git a/src/@types/calendar.d.ts b/src/@types/calendar.d.ts
index f389190..ec44552 100644
--- a/src/@types/calendar.d.ts
+++ b/src/@types/calendar.d.ts
@@ -1,7 +1,7 @@
 import { Moon } from ".";
-import { FcEvent, FcEventCategory } from ".";
+import { CalEvent, CalEventCategory } from ".";
 
-export interface FcDate {
+export interface CalDate {
     day: number;
     month: number;
     year: number;
@@ -12,9 +12,9 @@ export interface Calendar {
     name: string;
     description: string;
     static: StaticCalendarData;
-    current: FcDate;
-    events: FcEvent[];
-    categories: FcEventCategory[];
+    current: CalDate;
+    events: CalEvent[];
+    categories: CalEventCategory[];
     date?: number;
     displayWeeks?: boolean;
     autoParse: boolean;
@@ -39,7 +39,7 @@ export interface StaticCalendarData {
     years?: Year[];
 }
 
-export interface FcDate {
+export interface CalDate {
     year: number;
     month: number;
     day: number;
@@ -133,7 +133,7 @@ export interface Era {
     restart: boolean;
     endsYear: boolean;
     event: boolean;
-    start: FcDate;
+    start: CalDate;
     eventDescription?: string;
     eventCategory?: string;
 }
diff --git a/src/@types/event.d.ts b/src/@types/event.d.ts
index 4952feb..6890877 100644
--- a/src/@types/event.d.ts
+++ b/src/@types/event.d.ts
@@ -1,24 +1,24 @@
 import { Nullable } from ".";
 
-export interface FcEventSort {
+export interface CalEventSort {
     timestamp: number;
     order: string;
 }
-export interface FcEventDate {
+export interface CalEventDate {
     year: Nullable<number>,
     month: Nullable<number>,
     day: Nullable<number>
 }
 
-export interface FcEvent {
+export interface CalEvent {
     name: string;
     description: string;
-    date: FcEventDate;
-    end?: FcEventDate;
+    date: CalEventDate;
+    end?: CalEventDate;
     id: string;
     note: string;
     category: string;
-    sort: FcEventSort;
+    sort: CalEventSort;
     formulas?: EventFormula[];
     img?: string;
 }
@@ -30,14 +30,14 @@ interface FormulaInterval {
     timespan: "days";
 }
 
-export interface ColorEvent extends FcEvent {
+export interface ColorEvent extends CalEvent {
     color: string;
 }
 
-export interface FcEventCategory {
+export interface CalEventCategory {
     name: string;
     color: string;
     id: string;
 }
 
-export interface FcEventCondition {}
+export interface CalEventCondition {}
diff --git a/src/api/api.ts b/src/api/api.ts
index 8a4181a..87ae759 100644
--- a/src/api/api.ts
+++ b/src/api/api.ts
@@ -1 +1,31 @@
-export class API {}
+import type { Calendar, CalDate, CalEvent } from "src/@types";
+import { CalendarStore } from "src/stores/calendar.store";
+import { get } from "svelte/store";
+
+export class API {
+    #store: CalendarStore;
+    #object: Calendar;
+    constructor(store: CalendarStore) {
+        this.#store = store;
+    }
+
+    /**
+     * Transform a day, month, year definition into a CalDate
+     * @param day Day number
+     * @param month Month number (0 indexed)
+     * @param year Year number
+     * @returns {CalDate}
+     */
+    getDate(day: number, month: number, year: number): CalDate {
+        return { day, month, year };
+    }
+
+    /** Get all events for the loaded calendar. */
+    getEvents(): CalEvent[] {
+        return get(this.#store.eventCache.entities);
+    }
+    /** Get all events on a specific date. */
+    getEventsOnDay(day: CalDate): CalEvent[] {
+        return get(this.#store.eventCache.getItemsOrRecalculate(day));
+    }
+}
diff --git a/src/calendar/event-modal.ts b/src/calendar/event-modal.ts
index 59a06f2..a5edfb7 100644
--- a/src/calendar/event-modal.ts
+++ b/src/calendar/event-modal.ts
@@ -1,10 +1,10 @@
 import { MarkdownRenderer } from "obsidian";
-import type { FcEvent } from "src/@types";
+import type { CalEvent } from "src/@types";
 import type FantasyCalendar from "src/main";
 import { CalendariumModal } from "src/settings/modals/modal";
 
 export class ViewEventModal extends CalendariumModal {
-    constructor(public event: FcEvent, public plugin: FantasyCalendar) {
+    constructor(public event: CalEvent, public plugin: FantasyCalendar) {
         super(plugin.app);
         this.containerEl.addClass("fantasy-calendar-view-event");
     }
diff --git a/src/calendar/ui/Day/Day.svelte b/src/calendar/ui/Day/Day.svelte
index a75ab0e..d4798cb 100644
--- a/src/calendar/ui/Day/Day.svelte
+++ b/src/calendar/ui/Day/Day.svelte
@@ -3,7 +3,7 @@
     import { getTypedContext } from "../../view";
     import Dots from "../Events/Dots.svelte";
     import { Menu, TFile } from "obsidian";
-    import type { DayOrLeapDay, FcEvent } from "src/@types";
+    import type { DayOrLeapDay, CalEvent } from "src/@types";
     import Moon from "../Moon.svelte";
     import { ViewState } from "src/stores/calendar.store";
     import Flags from "../Events/Flags.svelte";
@@ -80,7 +80,7 @@
                 });
             })
         );
-        let notes: { event: FcEvent; file: TFile }[] = [];
+        let notes: { event: CalEvent; file: TFile }[] = [];
         for (const event of $events) {
             if (!event.note) continue;
             const file = app.vault.getAbstractFileByPath(event.note);
@@ -189,4 +189,9 @@
     .opened {
         border: 2px solid var(--background-modifier-border);
     }
+
+    /* .moon-container {
+        display: flex;
+        flex-flow: row;
+    } */
 </style>
diff --git a/src/calendar/ui/Day/DayView.svelte b/src/calendar/ui/Day/DayView.svelte
index eceb188..39bc8b7 100644
--- a/src/calendar/ui/Day/DayView.svelte
+++ b/src/calendar/ui/Day/DayView.svelte
@@ -20,11 +20,11 @@
     $: daysBeforeMonth = displayedMonth.daysBefore;
     $: daysBeforeDay = $daysBeforeMonth + $viewing.day;
     $: events = store.eventCache.getItemsOrRecalculate($viewing);
+    $: console.log("🚀 ~ file: DayView.svelte:23 ~ events:", $events);
     $: moons = store.moonCache.getItemsOrRecalculate($viewing);
     $: displayDayNumber = $ephemeral.displayDayNumber;
     $: displayMoons = $ephemeral.displayMoons;
 
-    const dispatch = createEventDispatcher();
 
     const close = (node: HTMLElement) => {
         new ExtraButtonComponent(node).setIcon("cross").setTooltip("Close");
diff --git a/src/calendar/ui/Events/Dots.svelte b/src/calendar/ui/Events/Dots.svelte
index 0834990..8e3ff6d 100644
--- a/src/calendar/ui/Events/Dots.svelte
+++ b/src/calendar/ui/Events/Dots.svelte
@@ -1,14 +1,14 @@
 <script lang="ts">
     import { getTypedContext } from "../../view";
     import Dot from "./Dot.svelte";
-    import type { FcEvent, FcEventCategory } from "src/@types";
+    import type { CalEvent, CalEventCategory } from "src/@types";
 
-    export let events: FcEvent[] = [];
+    export let events: CalEvent[] = [];
 
     const store = getTypedContext("store");
     const { categories } = $store;
 
-    const color = (event: FcEvent) => {
+    const color = (event: CalEvent) => {
         return $categories.find((c) => c.id == event.category)?.color;
     };
     $: overflow = Math.max(events.length - 2, 0);
diff --git a/src/calendar/ui/Events/Flag.svelte b/src/calendar/ui/Events/Flag.svelte
index 600e916..9dd703c 100644
--- a/src/calendar/ui/Events/Flag.svelte
+++ b/src/calendar/ui/Events/Flag.svelte
@@ -3,15 +3,15 @@
 <script lang="ts">
     import { Platform, TFile, setIcon } from "obsidian";
 
-    import type { FcDate, FcEvent, FcEventCategory } from "src/@types";
+    import type { CalDate, CalEvent, CalEventCategory } from "src/@types";
     import { DEFAULT_CATEGORY_COLOR } from "src/utils/constants";
     import { createEventDispatcher } from "svelte";
     import { getTypedContext } from "../../view";
     import { ViewEventModal } from "../../event-modal";
     const dispatch = createEventDispatcher();
 
-    export let event: FcEvent;
-    export let date: FcDate;
+    export let event: CalEvent;
+    export let date: CalDate;
 
     const plugin = getTypedContext("plugin");
 
@@ -42,7 +42,7 @@
         }
     }
 
-    export let categories: FcEventCategory[];
+    export let categories: CalEventCategory[];
 
     let color =
         categories.find((c) => c.id == event.category)?.color ??
diff --git a/src/calendar/ui/Events/Flags.svelte b/src/calendar/ui/Events/Flags.svelte
index a804d00..2412c3b 100644
--- a/src/calendar/ui/Events/Flags.svelte
+++ b/src/calendar/ui/Events/Flags.svelte
@@ -1,22 +1,27 @@
 <script lang="ts">
     import Flag from "./Flag.svelte";
-    import type { FcDate, FcEvent } from "src/@types";
+    import type { CalDate, CalEvent } from "src/@types";
     import { getTypedContext } from "../../view";
     import { sortEventList } from "src/utils/functions";
     import { onMount } from "svelte";
 
-    export let events: FcEvent[] = [];
+    export let events: CalEvent[] = [];
     export let dayView: boolean = false;
-    export let date: FcDate;
+    export let date: CalDate;
 
     const store = getTypedContext("store");
     const { categories } = $store;
 
+    let height: number;
+    let target: Element;
+
     $: events = sortEventList([...events]);
+    console.log("🚀 ~ file: Flags.svelte:19 ~ events:", events);
+
     let overflow: number = 0;
     let previousHeight = 0;
 
-    const addEvents = (height: number, target: Element) => {
+    const addEvents = () => {
         if (events.length && target) {
             if (
                 !dayView &&
@@ -46,7 +51,7 @@
                             (a, b) => b.getBoundingClientRect().height + a,
                             0
                         );
-                    if (remaining < 0) {
+                    if (remaining < 0 && height != 0) {
                         target.lastElementChild.detach();
                         overflow = events.length - events.indexOf(event);
                         break;
@@ -60,29 +65,26 @@
     };
 
     let container: HTMLElement;
-    const observer = new ResizeObserver((entries) =>
-        addEvents(entries[0].contentRect?.height, entries[0]?.target)
-    );
+    const observer = new ResizeObserver((entries) => {
+        height = entries[0].contentRect?.height;
+        target = entries[0]?.target;
+    });
+    $: {
+        console.log(
+            "🚀 ~ file: Flags.svelte:74 ~ dayView || (height != undefined && target)) && events:",
+            (dayView || (height != undefined && target)) && events
+        );
+        if ((dayView || (height != undefined && target)) && events) {
+            addEvents();
+        }
+    }
     onMount(() => {
         observer.observe(container);
     });
 </script>
 
 <div class="flags-container">
-    {#key events}
-        <div class="flag-container" bind:this={container} />
-        <!-- {#each events.slice(0, 3) as event}
-                <Flag
-                    {event}
-                    categories={$categories}
-                    {dayView}
-                    {date}
-                    on:event-click
-                    on:event-mouseover
-                    on:event-context
-                />
-            {/each} -->
-    {/key}
+    <div class="flag-container" bind:this={container} />
     <div class="overflow">
         {#if overflow > 0}
             <span>+{overflow}</span>
diff --git a/src/calendar/ui/Month/Month.svelte b/src/calendar/ui/Month/Month.svelte
index d66344a..a69243a 100644
--- a/src/calendar/ui/Month/Month.svelte
+++ b/src/calendar/ui/Month/Month.svelte
@@ -51,6 +51,9 @@
     .month-container {
         height: min-content;
     }
+    .month-container.full {
+        height: 100%;
+    }
 
     .month-header {
         margin: 0;
@@ -63,7 +66,7 @@
             var(--calendar-row-size)
         );
     }
-    .full {
+    .full .month {
         height: 100%;
     }
 </style>
diff --git a/src/events/event.helper.ts b/src/events/event.helper.ts
index 6cfb92f..547248c 100644
--- a/src/events/event.helper.ts
+++ b/src/events/event.helper.ts
@@ -3,17 +3,17 @@ import { nanoid, wrap } from "../utils/functions";
 const { DOMParser } = require("xmldom");
 import type {
     Calendar,
-    FcEvent,
-    FcEventCategory,
-    FcEventDate,
-    FcEventSort,
+    CalEvent,
+    CalEventCategory,
+    CalEventDate,
+    CalEventSort,
     LeapDay,
     Nullable
 } from "../@types";
 
 const inlineDateSpans: RegExp = /<(span|div)[\s\S]*?<\/(span|div)>/g;
 
-export type FcEventCallback = (fcEvent: FcEvent) => void;
+export type CalEventCallback = (fcEvent: CalEvent) => void;
 
 export interface InputDate {
     year?: any,
@@ -59,7 +59,7 @@ export class CalEventHelper {
         data: string,
         file: { path: string; basename: string },
         frontmatter: FrontMatterCache,
-        publish: FcEventCallback
+        publish: CalEventCallback
     ) {
         let fcCategory: string;
         console.log("#### parse file for events", frontmatter);
@@ -91,8 +91,8 @@ export class CalEventHelper {
     parseFrontmatterEvent(
         frontmatter: FrontMatterCache,
         file: { path: string; basename: string },
-        publish: FcEventCallback,
-        category?: FcEventCategory
+        publish: CalEventCallback,
+        category?: CalEventCategory
     ) {
         const dateField = "fc-date" in frontmatter ? "fc-date" : "fc-start";
         let date = frontmatter[dateField]
@@ -121,8 +121,8 @@ export class CalEventHelper {
     parseInlineEvents(
         contents: string,
         file: { path: string; basename: string },
-        publish: FcEventCallback,
-        category?: FcEventCategory
+        publish: CalEventCallback,
+        category?: CalEventCategory
     ) {
         const domparser = new DOMParser();
         // span or div with attributes:
@@ -154,9 +154,9 @@ export class CalEventHelper {
                 continue; // span must contain a date
             }
             // parse date strings, will return with all elements present: year, month, day, hour/order
-            let date = this.parseFcDateString(element.dataset.date, file);
+            let date = this.parseCalDateString(element.dataset.date, file);
             let end = element.dataset.end
-                    ? this.parseFcDateString(element.dataset.end, file)
+                    ? this.parseCalDateString(element.dataset.end, file)
                     : undefined;
 
             if (element.dataset.class) {
@@ -186,7 +186,7 @@ export class CalEventHelper {
 
     parseFilenameDate(file: { path: string; basename: string }): ParseDate {
         // TODO: Filename formatter for this calendar?
-        return this.parseFcDateString(file.basename, file);
+        return this.parseCalDateString(file.basename, file);
     }
 
     parseFrontmatterDate(
@@ -194,7 +194,7 @@ export class CalEventHelper {
         file: { path: string; basename: string }
     ): ParseDate {
         if (typeof date === "string") {
-            return this.parseFcDateString(date, file);
+            return this.parseCalDateString(date, file);
         }
 
         // replace any missing segments with '*'
@@ -223,7 +223,7 @@ export class CalEventHelper {
      * @param file Source file
      * @returns ParseDate instance
      */
-    parseFcDateString(
+    parseCalDateString(
         datestring: string,
         file: { path: string; basename: string }
     ): ParseDate {
@@ -250,7 +250,7 @@ export class CalEventHelper {
      * for the given event date (will not include an order suffix)
      * @returns
      */
-    toFcDateString(date: FcEventDate): string {
+    toCalDateString(date: CalEventDate): string {
         return this.formatString
                 .replace(/[Yy]+/g, `${date.year}`)
                 .replace(/[Mm]{3,}/g, toMonthString(date.month, this.calendar))
@@ -346,7 +346,7 @@ export class CalEventHelper {
         };
     }
 
-    parsedToTimestamp(date: ParseDate): FcEventSort {
+    parsedToTimestamp(date: ParseDate): CalEventSort {
         // put repeating events off to the side
         if (date.year == null || date.month == null || date.day == null) {
             return {
@@ -363,7 +363,7 @@ export class CalEventHelper {
         };
     }
 
-    timestampForFcEvent(event: Partial<FcEvent>, old?: FcEventSort): FcEventSort {
+    timestampForCalEvent(event: Partial<CalEvent>, old?: CalEventSort): CalEventSort {
         if (!old && event.sort) {
             return event.sort;
         }
diff --git a/src/settings/creator/Utilities/DateWithValidation.svelte b/src/settings/creator/Utilities/DateWithValidation.svelte
index cb0ffa7..a59047e 100644
--- a/src/settings/creator/Utilities/DateWithValidation.svelte
+++ b/src/settings/creator/Utilities/DateWithValidation.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-    import type { Calendar, FcDate } from "src/@types";
+    import type { Calendar, CalDate } from "src/@types";
 
     import { getContext } from "svelte";
     import {
diff --git a/src/settings/creator/stores/calendar.ts b/src/settings/creator/stores/calendar.ts
index bc2fc06..193fb7e 100644
--- a/src/settings/creator/stores/calendar.ts
+++ b/src/settings/creator/stores/calendar.ts
@@ -1,10 +1,10 @@
 import { prepareFuzzySearch } from "obsidian";
 import type {
     Calendar,
-    FcDate,
+    CalDate,
     Day,
-    FcEvent,
-    FcEventCategory,
+    CalEvent,
+    CalEventCategory,
     LeapDay,
     Month,
     Moon,
@@ -100,13 +100,13 @@ function createStore(
         update,
         currentStore: {
             subscribe: currentStore.subscribe,
-            set: (data: FcDate) => {
+            set: (data: CalDate) => {
                 update((calendar) => {
                     calendar.current = { ...data };
                     return calendar;
                 });
             },
-            update: (data: FcDate) =>
+            update: (data: CalDate) =>
                 update((calendar) => {
                     calendar.current = { ...data };
                     return calendar;
@@ -129,7 +129,7 @@ function createStore(
         },
 
         /** Setters */
-        setCurrentDate: (date: FcDate) =>
+        setCurrentDate: (date: CalDate) =>
             update((cal) => {
                 cal.current = { ...date };
                 return cal;
@@ -265,17 +265,17 @@ function createStore(
                     return a.date.day - b.date.day;
                 })
             ),
-            set: (events: FcEvent[]) =>
+            set: (events: CalEvent[]) =>
                 update((data) => {
                     data.events = [...events];
                     return data;
                 }),
-            add: (event: FcEvent) =>
+            add: (event: CalEvent) =>
                 update((data) => {
                     data.events.push({ ...event });
                     return data;
                 }),
-            update: (id: string, event: FcEvent) =>
+            update: (id: string, event: CalEvent) =>
                 update((data) => {
                     const index = data.events.findIndex((e) => e.id === id);
 
@@ -290,17 +290,17 @@ function createStore(
         },
         categoryStore: {
             subscribe: categoryStore.subscribe,
-            set: (categories: FcEventCategory[]) =>
+            set: (categories: CalEventCategory[]) =>
                 update((data) => {
                     data.categories = [...categories];
                     return data;
                 }),
-            add: (category: FcEventCategory) =>
+            add: (category: CalEventCategory) =>
                 update((data) => {
                     data.categories.push({ ...category });
                     return data;
                 }),
-            update: (id: string, category: FcEventCategory) =>
+            update: (id: string, category: CalEventCategory) =>
                 update((data) => {
                     const index = data.categories.findIndex((e) => e.id === id);
 
diff --git a/src/settings/import/importer.ts b/src/settings/import/importer.ts
index f7a582c..ac82664 100644
--- a/src/settings/import/importer.ts
+++ b/src/settings/import/importer.ts
@@ -1,8 +1,8 @@
 import type {
     Calendar,
     Era,
-    FcEvent,
-    FcEventCategory,
+    CalEvent,
+    CalEventCategory,
     LeapDay,
     Month,
     Moon,
@@ -157,9 +157,9 @@ export default class Import {
                     data.dynamic_data.timespan ?? dynamicData.month;
             }
 
-            const events: FcEvent[] = [];
+            const events: CalEvent[] = [];
 
-            const existingCategories: Map<string, FcEventCategory> = new Map();
+            const existingCategories: Map<string, CalEventCategory> = new Map();
             if ("categories" in data) {
                 for (let category of data.categories) {
                     const name = category.name;
diff --git a/src/settings/modals/event/EventCreator.svelte b/src/settings/modals/event/EventCreator.svelte
index 3bda7d3..78304a9 100644
--- a/src/settings/modals/event/EventCreator.svelte
+++ b/src/settings/modals/event/EventCreator.svelte
@@ -1,12 +1,12 @@
 <script lang="ts">
-    import type { Calendar, FcEvent } from "src/@types";
+    import type { Calendar, CalEvent } from "src/@types";
     import type Calendarium from "src/main";
 
     import { TextComponent, TFile } from "obsidian";
     import PathSuggestionModal from "src/suggester/path";
     import { nanoid } from "src/utils/functions";
 
-    export let event: FcEvent;
+    export let event: CalEvent;
     export let calendar: Calendar;
     export let plugin: Calendarium;
 
diff --git a/src/settings/modals/event/event.ts b/src/settings/modals/event/event.ts
index 6e0b5ed..f95a736 100644
--- a/src/settings/modals/event/event.ts
+++ b/src/settings/modals/event/event.ts
@@ -8,7 +8,7 @@ import {
     TextAreaComponent,
     TFile,
 } from "obsidian";
-import type { Calendar, FcEvent } from "../../../@types";
+import type { Calendar, CalEvent } from "../../../@types";
 
 import { dateString, nanoid } from "../../../utils/functions";
 
@@ -23,7 +23,7 @@ import { CalEventHelper } from "src/events/event.helper";
 
 export class CreateEventModal extends CalendariumModal {
     saved = false;
-    event: FcEvent = {
+    event: CalEvent = {
         name: null,
         description: null,
         date: {
@@ -54,7 +54,7 @@ export class CreateEventModal extends CalendariumModal {
     constructor(
         public plugin: Calendarium,
         public calendar: Calendar,
-        event?: FcEvent,
+        event?: CalEvent,
         date?: { month: number; day: number; year: number }
     ) {
         super(plugin.app);
@@ -104,7 +104,7 @@ export class CreateEventModal extends CalendariumModal {
                         );
 
                         // refresh timestamp for date change
-                        this.event.sort = helper.timestampForFcEvent(
+                        this.event.sort = helper.timestampForCalEvent(
                             this.event,
                             this.event.sort
                         );
@@ -166,13 +166,13 @@ export class CreateEventModal extends CalendariumModal {
 
                             const frontmatter = [
                                 `fc-calendar: ${this.calendar.name}`,
-                                `fc-date: ${helper.toFcDateString(
+                                `fc-date: ${helper.toCalDateString(
                                     this.event.date
                                 )}`,
                             ];
                             if (this.event.end) {
                                 frontmatter.push(
-                                    `fc-end: ${helper.toFcDateString(
+                                    `fc-end: ${helper.toCalDateString(
                                         this.event.end
                                     )}`
                                 );
diff --git a/src/stores/cache/entity-cache.ts b/src/stores/cache/entity-cache.ts
index aa292d5..1ee77e3 100644
--- a/src/stores/cache/entity-cache.ts
+++ b/src/stores/cache/entity-cache.ts
@@ -1,4 +1,4 @@
-import type { FcDate } from "src/@types";
+import type { CalDate } from "src/@types";
 import { Readable, Writable, derived, get, writable } from "svelte/store";
 
 abstract class CacheItem<T> {
@@ -53,7 +53,7 @@ export abstract class EntityCache<T> {
     abstract getMonthCache(month: number, year: number): MonthCache<T>;
     abstract getDayCache(day: number, month: number, year: number): DayCache<T>;
 
-    public invalidate(date: FcDate) {
+    public invalidate(date: CalDate) {
         if (!this.cache.has(date.year)) return;
         const year = this.cache.get(date.year);
         year.dirty.set(true);
@@ -66,7 +66,7 @@ export abstract class EntityCache<T> {
         const day = month.cache.get(date.day);
         day.dirty.set(true);
     }
-    public getItemsOrRecalculate(date: FcDate): Readable<T[]> {
+    public getItemsOrRecalculate(date: CalDate): Readable<T[]> {
         const { day, month, year } = date;
         if (!this.cache.has(year)) {
             this.cache.set(year, this.getYearCache(year));
diff --git a/src/stores/cache/event-cache.ts b/src/stores/cache/event-cache.ts
index 0bd78ac..57e8d9e 100644
--- a/src/stores/cache/event-cache.ts
+++ b/src/stores/cache/event-cache.ts
@@ -1,9 +1,9 @@
-import type { FcEvent } from "src/@types";
+import type { CalEvent } from "src/@types";
 import { DayCache, EntityCache, MonthCache, YearCache } from "./entity-cache";
 import { Readable, derived, get, writable } from "svelte/store";
 
-class YearEventCache extends YearCache<FcEvent> {
-    update([events, dirty]: [FcEvent[], boolean]) {
+class YearEventCache extends YearCache<CalEvent> {
+    update([events, dirty]: [CalEvent[], boolean]) {
         if (dirty && events) {
             this.derived = events.filter((event) => {
                 const date = { ...event.date };
@@ -33,8 +33,8 @@ class YearEventCache extends YearCache<FcEvent> {
         return this.derived;
     }
 }
-class MonthEventCache extends MonthCache<FcEvent> {
-    update([events, dirty]: [FcEvent[], boolean]) {
+class MonthEventCache extends MonthCache<CalEvent> {
+    update([events, dirty]: [CalEvent[], boolean]) {
         if (dirty && events) {
             this.derived = events.filter((event) => {
                 const date = { ...event.date };
@@ -80,8 +80,8 @@ class MonthEventCache extends MonthCache<FcEvent> {
         return this.derived;
     }
 }
-class DayEventCache extends DayCache<FcEvent> {
-    update([events, dirty]: [FcEvent[], boolean]) {
+class DayEventCache extends DayCache<CalEvent> {
+    update([events, dirty]: [CalEvent[], boolean]) {
         if (dirty && events) {
             this.derived = events.filter((event) => {
                 if (
@@ -97,17 +97,17 @@ class DayEventCache extends DayCache<FcEvent> {
     }
 }
 
-export class EventCache extends EntityCache<FcEvent> {
-    getYearCache(year: number): YearCache<FcEvent> {
+export class EventCache extends EntityCache<CalEvent> {
+    getYearCache(year: number): YearCache<CalEvent> {
         if (this.cache.has(year)) return this.cache.get(year);
         return new YearEventCache(year, this.entities);
     }
-    getMonthCache(month: number, year: number): MonthCache<FcEvent> {
+    getMonthCache(month: number, year: number): MonthCache<CalEvent> {
         const yearCache = this.getYearCache(year);
         if (yearCache.cache.has(month)) return yearCache.cache.get(month);
         return new MonthEventCache(month, year, yearCache.entities);
     }
-    getDayCache(day: number, month: number, year: number): DayCache<FcEvent> {
+    getDayCache(day: number, month: number, year: number): DayCache<CalEvent> {
         const monthCache = this.getMonthCache(month, year);
         if (monthCache.cache.has(day)) return monthCache.cache.get(day);
         return new DayEventCache(day, month, year, monthCache.entities);
diff --git a/src/stores/calendar.store.ts b/src/stores/calendar.store.ts
index fec24b7..06563b2 100644
--- a/src/stores/calendar.store.ts
+++ b/src/stores/calendar.store.ts
@@ -1,4 +1,4 @@
-import type { Calendar, FcDate, MoonState } from "src/@types";
+import type { Calendar, CalDate, MoonState } from "src/@types";
 import { Readable, Writable, derived, get, writable } from "svelte/store";
 import { YearCalculatorCache, YearStoreCache } from "./years.store";
 import { dateString, wrap } from "src/utils/functions";
@@ -63,14 +63,14 @@ export function createCalendarStore(calendar: Calendar, plugin: Calendarium) {
         currentDisplay: derived([current, store], ([current, calendar]) => {
             return dateString(current, calendar);
         }),
-        setCurrentDate: (date: FcDate) =>
+        setCurrentDate: (date: CalDate) =>
             store.update((cal) => {
                 cal.current = { ...date };
                 return cal;
             }),
         updateCalendar: (calendar: Calendar) => update((cal) => calendar),
         eventCache,
-        addEvent: (date: FcDate) => {
+        addEvent: (date: CalDate) => {
             const modal = new CreateEventModal(plugin, calendar, null, date);
 
             modal.onClose = async () => {
@@ -115,8 +115,8 @@ export interface EphemeralState {
     displayMoons: boolean;
     displayWeeks: boolean;
     displayDayNumber: boolean;
-    displaying: FcDate;
-    viewing: FcDate;
+    displaying: CalDate;
+    viewing: CalDate;
 }
 export function getEphemeralStore(
     store: Writable<Calendar>,
@@ -125,7 +125,7 @@ export function getEphemeralStore(
     yearCalculator: YearStoreCache
 ) {
     const displaying = writable({ ...base.current });
-    const viewing = writable<FcDate | null>();
+    const viewing = writable<CalDate | null>();
 
     const displayMoons = writable(base.static.displayMoons);
     const displayDayNumber = writable(base.static.displayDayNumber);
@@ -173,7 +173,7 @@ export function getEphemeralStore(
         //Displayed Date
         displaying,
         goToToday: () => displaying.set({ ...base.current }),
-        displayDate: (date: FcDate = base.current) =>
+        displayDate: (date: CalDate = base.current) =>
             displaying.set({ ...date }),
         displayingDisplay: derived(
             [displaying, store],
@@ -397,7 +397,7 @@ function createStaticStore(store: Writable<Calendar>) {
     };
 }
 
-function incrementMonth(date: FcDate, yearCalculator: YearStoreCache) {
+function incrementMonth(date: CalDate, yearCalculator: YearStoreCache) {
     const next = { ...date };
     const year = yearCalculator.getYearFromCache(date.year);
     const months = get(year.months);
@@ -409,7 +409,7 @@ function incrementMonth(date: FcDate, yearCalculator: YearStoreCache) {
     }
     return next;
 }
-function decrementMonth(date: FcDate, yearCalculator: YearStoreCache) {
+function decrementMonth(date: CalDate, yearCalculator: YearStoreCache) {
     const next = { ...date };
     if (next.month == 0) {
         next.year = next.year - 1;
@@ -422,7 +422,7 @@ function decrementMonth(date: FcDate, yearCalculator: YearStoreCache) {
     return next;
 }
 
-function incrementDay(date: FcDate, yearCalculator: YearStoreCache) {
+function incrementDay(date: CalDate, yearCalculator: YearStoreCache) {
     let next = { ...date };
     const days = get(
         yearCalculator.getYearFromCache(next.year).getMonthFromCache(next.month)
@@ -436,7 +436,7 @@ function incrementDay(date: FcDate, yearCalculator: YearStoreCache) {
     }
     return next;
 }
-function decrementDay(date: FcDate, yearCalculator: YearStoreCache) {
+function decrementDay(date: CalDate, yearCalculator: YearStoreCache) {
     let next = { ...date };
 
     if (next.day - 1 <= 0) {
diff --git a/src/stores/date.store.ts b/src/stores/date.store.ts
index 69d0fc9..6c202f2 100644
--- a/src/stores/date.store.ts
+++ b/src/stores/date.store.ts
@@ -1,7 +1,7 @@
-import { Calendar, FcDate } from "src/@types";
+import { Calendar, CalDate } from "src/@types";
 import { YearStoreCache } from "./years.store";
 
 
-export function getDateStore(date: FcDate, base: Calendar, yearCalculator: YearStoreCache) {
+export function getDateStore(date: CalDate, base: Calendar, yearCalculator: YearStoreCache) {
 
 }   
\ No newline at end of file
diff --git a/src/stores/utils.ts b/src/stores/utils.ts
index 2df3c96..e2e49b2 100644
--- a/src/stores/utils.ts
+++ b/src/stores/utils.ts
@@ -1,6 +1,6 @@
-import { FcDate } from "src/@types";
+import { CalDate } from "src/@types";
 
-export function hash(date: Partial<FcDate>, max: number) {
+export function hash(date: Partial<CalDate>, max: number) {
     if (date.year == null || date.month == null || date.day == null)
         return null;
     const months = `${this.data.months.length}`.length;
diff --git a/src/stores/years.store.ts b/src/stores/years.store.ts
index 4b973e2..f0b6035 100644
--- a/src/stores/years.store.ts
+++ b/src/stores/years.store.ts
@@ -1,6 +1,6 @@
 import { derived, get } from "svelte/store";
 import { StaticStore } from "./calendar.store";
-import type { FcEvent, LeapDay, Month, Week } from "src/@types";
+import type { CalEvent, LeapDay, Month, Week } from "src/@types";
 import { wrap } from "../utils/functions";
 import { MonthStore } from "./month.store";
 
diff --git a/src/utils/functions.ts b/src/utils/functions.ts
index c59b9ab..fc96961 100644
--- a/src/utils/functions.ts
+++ b/src/utils/functions.ts
@@ -1,4 +1,4 @@
-import type { Calendar, FcDate, FcEvent, LeapDay, Month } from "../@types";
+import type { Calendar, CalDate, CalEvent, LeapDay, Month } from "../@types";
 
 export function daysBetween(date1: Date, date2: Date) {
     const d1 = window.moment(date1);
@@ -78,7 +78,7 @@ export function ordinal(i: number) {
     }
     return i + "th";
 }
-export function dateString(date: FcDate, calendar: Calendar, end?: FcDate) {
+export function dateString(date: CalDate, calendar: Calendar, end?: CalDate) {
     if (!date || date.day == undefined) {
         return "";
     }
@@ -170,7 +170,7 @@ export function isValidYear(year: number, calendar: Calendar) {
     return true;
 }
 
-export function areDatesEqual(date: FcDate, date2: FcDate) {
+export function areDatesEqual(date: CalDate, date2: CalDate) {
     if (date.day != date2.day) return false;
     if (
         date.month != date2.month &&
@@ -187,7 +187,7 @@ export function areDatesEqual(date: FcDate, date2: FcDate) {
     return true;
 }
 
-export function sortEventList(list: FcEvent[]): FcEvent[] {
+export function sortEventList(list: CalEvent[]): CalEvent[] {
     return list.sort((a, b) => {
         if (!("sort" in a) || !("sort" in b)) return 0;
         if (a.sort?.timestamp === b.sort?.timestamp) {
diff --git a/src/watcher/watcher.ts b/src/watcher/watcher.ts
index 6763845..66bc643 100644
--- a/src/watcher/watcher.ts
+++ b/src/watcher/watcher.ts
@@ -8,7 +8,7 @@ import {
     getAllTags,
     FuzzySuggestModal
 } from "obsidian";
-import type { Calendar, FcEvent } from "src/@types";
+import type { Calendar, CalEvent } from "src/@types";
 import type Calendarium from "src/main";
 //have to ignore until i fix typing issue
 //@ts-expect-error
@@ -319,7 +319,7 @@ export class Watcher extends Component {
         }
         this.startParsing([...folders]);
     }
-    addToTree(calendar: Calendar, event: FcEvent) {
+    addToTree(calendar: Calendar, event: CalEvent) {
         if (!this.tree.has(calendar.id)) {
             this.tree.set(calendar.id, new Set());
         }
diff --git a/src/watcher/watcher.worker.ts b/src/watcher/watcher.worker.ts
index 4374be7..b44418b 100644
--- a/src/watcher/watcher.worker.ts
+++ b/src/watcher/watcher.worker.ts
@@ -1,5 +1,5 @@
 import type { CachedMetadata, FrontMatterCache } from "obsidian";
-import type { Calendar, FcEvent, Nullable } from "src/@types";
+import type { Calendar, CalEvent, Nullable } from "src/@types";
 import { CalEventHelper } from "src/events/event.helper";
 
 export interface QueueMessage {
@@ -34,14 +34,14 @@ export interface UpdateEventMessage {
     type: "update";
     id: string;
     index: number;
-    event: FcEvent;
-    original: FcEvent;
+    event: CalEvent;
+    original: CalEvent;
 }
 export interface DeleteEventMessage {
     type: "delete";
     id: string;
     index: number;
-    event: FcEvent;
+    event: CalEvent;
 }
 
 export interface SaveMessage {
@@ -215,7 +215,7 @@ class Parser {
         let fEvents = 0;
         let tEvents = 0;
 
-        eventHelper.parseFrontmatterEvent(frontmatter, file, (event: FcEvent) => {
+        eventHelper.parseFrontmatterEvent(frontmatter, file, (event: CalEvent) => {
             ctx.postMessage<UpdateEventMessage>({
                 type: "update",
                 id: eventHelper.calendar.id,
@@ -231,7 +231,7 @@ class Parser {
             allTags &&
             allTags.includes(eventHelper.calendar.inlineEventTag)
         ) {
-            eventHelper.parseInlineEvents(data, file, (event: FcEvent) => {
+            eventHelper.parseInlineEvents(data, file, (event: CalEvent) => {
                 ctx.postMessage<UpdateEventMessage>({
                     type: "update",
                     id: eventHelper.calendar.id,
diff --git a/test/event.parseAltFormat.test.ts b/test/event.parseAltFormat.test.ts
index 664b485..9624e37 100644
--- a/test/event.parseAltFormat.test.ts
+++ b/test/event.parseAltFormat.test.ts
@@ -1,4 +1,4 @@
-import { FcEventDate } from "../src/@types";
+import { CalEventDate } from "../src/@types";
 import { CalEventHelper } from "../src/events/event.helper";
 import { PRESET_CALENDARS } from "../src/utils/presets";
 
@@ -11,7 +11,7 @@ const file = {
     basename: "basename"
 }
 
-const input: FcEventDate = {
+const input: CalEventDate = {
     year: 1400,
     month: 1,
     day: 28
@@ -21,45 +21,45 @@ test("YYYY-MM-DD", () => {
     const YMD = new CalEventHelper(GREGORIAN, true, 'YYYY-MM-DD');
     const datestring = '1400-02-28';
     expect(YMD.formatDigest).toEqual('YMD');
-    expect(YMD.toFcDateString(input)).toEqual(datestring);
-    expect(YMD.parseFcDateString(datestring, file)).toEqual(expect.objectContaining(input));
+    expect(YMD.toCalDateString(input)).toEqual(datestring);
+    expect(YMD.parseCalDateString(datestring, file)).toEqual(expect.objectContaining(input));
 });
 test("YYYY-MMM-DD", () => {
     const YMD = new CalEventHelper(GREGORIAN, true, 'YYYY-MMM-DD');
     const datestring = '1400-February-28';
     expect(YMD.formatDigest).toEqual('YMD');
-    expect(YMD.toFcDateString(input)).toEqual(datestring);
-    expect(YMD.parseFcDateString(datestring, file)).toEqual(expect.objectContaining(input));
+    expect(YMD.toCalDateString(input)).toEqual(datestring);
+    expect(YMD.parseCalDateString(datestring, file)).toEqual(expect.objectContaining(input));
 });
 
 test("M-D-Y", () => {
     const MDY = new CalEventHelper(GREGORIAN, true, 'M-D-Y');
     const datestring = "2-28-1400";
     expect(MDY.formatDigest).toEqual('MDY');
-    expect(MDY.toFcDateString(input)).toEqual(datestring);
-    expect(MDY.parseFcDateString(datestring, file)).toEqual(expect.objectContaining(input));
+    expect(MDY.toCalDateString(input)).toEqual(datestring);
+    expect(MDY.parseCalDateString(datestring, file)).toEqual(expect.objectContaining(input));
 });
 
 test("MM-D-Y", () => {
     const MDY = new CalEventHelper(GREGORIAN, true, 'MM-D-Y');
     const datestring = "02-28-1400";
     expect(MDY.formatDigest).toEqual('MDY');
-    expect(MDY.toFcDateString(input)).toEqual(datestring);
-    expect(MDY.parseFcDateString(datestring, file)).toEqual(expect.objectContaining(input));
+    expect(MDY.toCalDateString(input)).toEqual(datestring);
+    expect(MDY.parseCalDateString(datestring, file)).toEqual(expect.objectContaining(input));
 });
 
 test("DD-M-Y", () => {
     const DMY = new CalEventHelper(GREGORIAN, true, 'DD-M-Y');
     const datestring = "28-2-1400";
     expect(DMY.formatDigest).toEqual('DMY');
-    expect(DMY.toFcDateString(input)).toEqual(datestring);
-    expect(DMY.parseFcDateString(datestring, file)).toEqual(expect.objectContaining(input));
+    expect(DMY.toCalDateString(input)).toEqual(datestring);
+    expect(DMY.parseCalDateString(datestring, file)).toEqual(expect.objectContaining(input));
 });
 
 test("DD-MMM-Y", () => {
     const DMY = new CalEventHelper(GREGORIAN, true, 'DD-MMM-Y');
     const datestring = "28-February-1400";
     expect(DMY.formatDigest).toEqual('DMY');
-    expect(DMY.toFcDateString(input)).toEqual(datestring);
-    expect(DMY.parseFcDateString(datestring, file)).toEqual(expect.objectContaining(input));
+    expect(DMY.toCalDateString(input)).toEqual(datestring);
+    expect(DMY.parseCalDateString(datestring, file)).toEqual(expect.objectContaining(input));
 });
\ No newline at end of file
diff --git a/test/event.parseFcString.gregorian.test.ts b/test/event.parseFcString.gregorian.test.ts
index a4cdb65..078cf6b 100644
--- a/test/event.parseFcString.gregorian.test.ts
+++ b/test/event.parseFcString.gregorian.test.ts
@@ -1,4 +1,4 @@
-import { FcEvent } from "../src/@types";
+import { CalEvent } from "../src/@types";
 import { CalEventHelper, ParseDate } from "../src/events/event.helper";
 import { sortEventList } from "../src/utils/functions";
 import { PRESET_CALENDARS } from "../src/utils/presets";
@@ -30,11 +30,11 @@ test("Parse January", () => {
         order: ''
     };
     // Mess around with year 0 for fun
-    expect(helper.parseFcDateString("0", file)).toEqual(expected);
-    expect(helper.parseFcDateString("0-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("0-01-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("0-Jan", file)).toEqual(expected);
-    expect(helper.parseFcDateString("0-January-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-01-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-Jan", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-January-01", file)).toEqual(expected);
 });
 test("Parse February", () => {
     const expected: ParseDate = {
@@ -43,14 +43,14 @@ test("Parse February", () => {
         day: 1,
         order: ''
     };
-    expect(helper.parseFcDateString("0-02", file)).toEqual(expected);
-    expect(helper.parseFcDateString("0-02-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("0-Feb", file)).toEqual(expected);
-    expect(helper.parseFcDateString("0-February-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-02", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-02-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-Feb", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-February-01", file)).toEqual(expected);
     // brought into range
-    expect(helper.parseFcDateString("0-02-00", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-02-00", file)).toEqual(expected);
     // Bad day
-    expect(helper.parseFcDateString("1900-Feb-30", file)).toBeNull();
+    expect(helper.parseCalDateString("1900-Feb-30", file)).toBeNull();
 });
 test("Parse February: Leap year", () => {
     const expected: ParseDate = {
@@ -61,22 +61,22 @@ test("Parse February: Leap year", () => {
     };
 
     // Leap years
-    expect(helper.parseFcDateString("1996-February-29", file)).toEqual({
+    expect(helper.parseCalDateString("1996-February-29", file)).toEqual({
         ...expected,
         year: 1996
     });
-    expect(helper.parseFcDateString("1600-February-29", file)).toEqual({
+    expect(helper.parseCalDateString("1600-February-29", file)).toEqual({
         ...expected,
         year: 1600
     });
-    expect(helper.parseFcDateString("2000-February-29", file)).toEqual({
+    expect(helper.parseCalDateString("2000-February-29", file)).toEqual({
         ...expected,
         year: 2000
     });
     // Not leap years
-    expect(helper.parseFcDateString("1700-Feb-29", file)).toBeNull();
-    expect(helper.parseFcDateString("1800-Feb-29", file)).toBeNull();
-    expect(helper.parseFcDateString("1900-Feb-29", file)).toBeNull();
+    expect(helper.parseCalDateString("1700-Feb-29", file)).toBeNull();
+    expect(helper.parseCalDateString("1800-Feb-29", file)).toBeNull();
+    expect(helper.parseCalDateString("1900-Feb-29", file)).toBeNull();
 });
 test("Parse March", () => {
     const expected: ParseDate = {
@@ -86,24 +86,24 @@ test("Parse March", () => {
         order: 'some extra'
     };
     // Mess around with year 0 for fun
-    expect(helper.parseFcDateString("0-03-31-some extra", file)).toEqual(expected);
-    expect(helper.parseFcDateString("0-Mar-31-some extra", file)).toEqual(expected);
-    expect(helper.parseFcDateString("0-March-31-some extra", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-03-31-some extra", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-Mar-31-some extra", file)).toEqual(expected);
+    expect(helper.parseCalDateString("0-March-31-some extra", file)).toEqual(expected);
 });
 
 
 test("Sort Gregorian dates", () => {
     const events = [
-        helper.parseFcDateString("1954-January-01-all the things happened", file), // 0
-        helper.parseFcDateString("1954-January-01-misc", file), // 1
-        helper.parseFcDateString("1954-January-01", file), // 2
-        helper.parseFcDateString("0-February-01-other stuff", file), // 3
-        helper.parseFcDateString("0-February-01-02", file), // 4
-        helper.parseFcDateString("2000-February-29", file), // 5
-        helper.parseFcDateString("0-March-31-some extra", file), // 6
+        helper.parseCalDateString("1954-January-01-all the things happened", file), // 0
+        helper.parseCalDateString("1954-January-01-misc", file), // 1
+        helper.parseCalDateString("1954-January-01", file), // 2
+        helper.parseCalDateString("0-February-01-other stuff", file), // 3
+        helper.parseCalDateString("0-February-01-02", file), // 4
+        helper.parseCalDateString("2000-February-29", file), // 5
+        helper.parseCalDateString("0-March-31-some extra", file), // 6
     ];
 
-    const fcEvents: FcEvent[] = events.map((x) => {
+    const fcEvents: CalEvent[] = events.map((x) => {
         return {
             date: x,
             description: "Test",
diff --git a/test/event.parseFcString.harptos.test.ts b/test/event.parseFcString.harptos.test.ts
index 9a60023..23930d5 100644
--- a/test/event.parseFcString.harptos.test.ts
+++ b/test/event.parseFcString.harptos.test.ts
@@ -1,4 +1,4 @@
-import { FcEvent } from "../src/@types";
+import { CalEvent } from "../src/@types";
 import { CalEventHelper, ParseDate } from "../src/events/event.helper";
 import { sortEventList } from "../src/utils/functions";
 import { PRESET_CALENDARS } from "../src/utils/presets";
@@ -50,11 +50,11 @@ test("Parse Harptos: 1499-01, Hammer", () => {
         day: 1,
         order: ''
     };
-    expect(helper.parseFcDateString("1499", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-01-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Hammer", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Hammer-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-01-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Hammer", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Hammer-01", file)).toEqual(expected);
 });
 //  1 |  2 |  - | Midwinter
 test("Parse Harptos: 1499-02, Midwinter", () => {
@@ -64,12 +64,12 @@ test("Parse Harptos: 1499-02, Midwinter", () => {
         day: 1,
         order: ''
     };
-    expect(helper.parseFcDateString("1499-02", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-02-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Midwinter", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Midwinter-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-02", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-02-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Midwinter", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Midwinter-01", file)).toEqual(expected);
     // Midwinter has only one day...
-    expect(helper.parseFcDateString("1499-02-03", file)).toBeNull();
+    expect(helper.parseCalDateString("1499-02-03", file)).toBeNull();
 });
 //  2 |  3 |  2 | Alturiak
 test("Parse Harptos: 1499-03, Alturiak", () => {
@@ -79,10 +79,10 @@ test("Parse Harptos: 1499-03, Alturiak", () => {
         day: 1,
         order: ''
     };
-    expect(helper.parseFcDateString("1499-03", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-03-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Alturiak", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Alturiak-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-03", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-03-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Alturiak", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Alturiak-01", file)).toEqual(expected);
 });
 //  3 |  4 |  3 | Ches
 //  4 |  5 |  4 | Tarsakh
@@ -94,15 +94,15 @@ test("Parse Harptos: 1499-06, Greengrass", () => {
         day: 1,
         order: ''
     }
-    expect(helper.parseFcDateString("1499-06", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-06-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Greengrass", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Greengrass-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-06", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-06-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Greengrass", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Greengrass-01", file)).toEqual(expected);
 
     const ordered: ParseDate = { ... expected, order: '03' }
-    expect(helper.parseFcDateString("1499-Greengrass-01-03", file)).toEqual(ordered);
+    expect(helper.parseCalDateString("1499-Greengrass-01-03", file)).toEqual(ordered);
     // Greengrass has only one day...
-    expect(helper.parseFcDateString("1499-06-03", file)).toBeNull();
+    expect(helper.parseCalDateString("1499-06-03", file)).toBeNull();
 });
 //  6 |  7 |  5 | Mirtul
 test("Parse Harptos: 1499-06, Mirtul", () => {
@@ -112,10 +112,10 @@ test("Parse Harptos: 1499-06, Mirtul", () => {
         day: 1,
         order: ''
     }
-    expect(helper.parseFcDateString("1499-07", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-07-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Mir", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Mirtul-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-07", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-07-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Mir", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Mirtul-01", file)).toEqual(expected);
 });
 //  7 |  8 |  6 | Kythorn
 //  8 |  9 |  7 | Flamerule
@@ -127,13 +127,13 @@ test("Parse Harptos: 1499-09, Midsummer", () => {
         day: 1,
         order: ''
     }
-    expect(helper.parseFcDateString("1499-10", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-10-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Midsum", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Midsummer-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-10", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-10-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Midsum", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Midsummer-01", file)).toEqual(expected);
 
     const ordered: ParseDate = { ... expected, order: '03' }
-    expect(helper.parseFcDateString("1499-Midsummer-01-03", file)).toEqual(ordered);
+    expect(helper.parseCalDateString("1499-Midsummer-01-03", file)).toEqual(ordered);
 });
 test("Parse Harptos: 1372-Shieldmeet", () => {
     const expected: ParseDate = {
@@ -142,15 +142,15 @@ test("Parse Harptos: 1372-Shieldmeet", () => {
         day: 2,
         order: ''
     }
-    expect(helper.parseFcDateString("1372-10-02", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1372-Shieldmeet", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1372-Shieldmeet-02", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1372-10-02", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1372-Shieldmeet", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1372-Shieldmeet-02", file)).toEqual(expected);
 
     const ordered: ParseDate = { ... expected, order: '03' }
-    expect(helper.parseFcDateString("1372-Shieldmeet-02-03", file)).toEqual(ordered);
+    expect(helper.parseCalDateString("1372-Shieldmeet-02-03", file)).toEqual(ordered);
 
     // Shieldmeet is a leapday (not in 1499)
-    expect(helper.parseFcDateString("1499-10-02", file)).toBeNull();
+    expect(helper.parseCalDateString("1499-10-02", file)).toBeNull();
 });
 // 10 | 11 |  8 | Eleasis
 test("Parse Harptos: 1499-11, Eleasis", () => {
@@ -160,10 +160,10 @@ test("Parse Harptos: 1499-11, Eleasis", () => {
         day: 1,
         order: ''
     }
-    expect(helper.parseFcDateString("1499-11", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-11-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Eleas", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Eleasis-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-11", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-11-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Eleas", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Eleasis-01", file)).toEqual(expected);
 });
 // 11 | 12 |  9 | Eleint
 // 12 | 13 |  - | Highharvestide
@@ -174,10 +174,10 @@ test("Parse Harptos: 1499-13, Highharvestide", () => {
         day: 1,
         order: ''
     }
-    expect(helper.parseFcDateString("1499-13", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-13-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-High", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Highharvestide-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-13", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-13-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-High", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Highharvestide-01", file)).toEqual(expected);
 });
 // 13 | 14 | 10 | Marpenoth
 test("Parse Harptos: 1499-14, Marpenoth", () => {
@@ -187,10 +187,10 @@ test("Parse Harptos: 1499-14, Marpenoth", () => {
         day: 1,
         order: ''
     }
-    expect(helper.parseFcDateString("1499-14", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-14-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Marp", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-Marpenoth-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-14", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-14-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Marp", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-Marpenoth-01", file)).toEqual(expected);
 });
 // 14 | 15 | 11 | Uktar
 // 15 | 16 |  - | Feast of the Moon
@@ -201,33 +201,33 @@ test("Parse Harptos: 1499-15, Feast of the Moon", () => {
         day: 1,
         order: ''
     }
-    expect(helper.parseFcDateString("1499-16", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-16-01", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-The Feast", file)).toEqual(expected);
-    expect(helper.parseFcDateString("1499-The Feast of the Moon-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-16", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-16-01", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-The Feast", file)).toEqual(expected);
+    expect(helper.parseCalDateString("1499-The Feast of the Moon-01", file)).toEqual(expected);
 });
 // 16 | 17 | 12 | Nightal
 
 test("Sort Harptos dates", () => {
     const events = [
-        helper.parseFcDateString("1499-Midsummer-01-02", file), // 0
-        helper.parseFcDateString("1499-Greengrass-01-04", file), // 1
-        helper.parseFcDateString("1499-Hammer-01-03", file), // 2
-        helper.parseFcDateString("1372-Shieldmeet-02-03", file), // 3
-        helper.parseFcDateString("1372-Shieldmeet", file), // 4
-        helper.parseFcDateString("1499-Alturiak", file), // 5
-        helper.parseFcDateString("1499-Alturiak-01", file), // 6
-        helper.parseFcDateString("1499-Greengrass-01-03", file), // 7
-        helper.parseFcDateString("1499-Hammer", file), // 8
-        helper.parseFcDateString("1499-Hammer-01", file), // 9
-        helper.parseFcDateString("1499-Highharvestide-01", file), // 10
-        helper.parseFcDateString("1499-Marpenoth-01", file), // 11
-        helper.parseFcDateString("1499-Midsummer-01-03", file), // 12
-        helper.parseFcDateString("1499-Alturiak-01-whatever", file), // 13
-        helper.parseFcDateString("1499-Alturiak-01-ok?", file), // 14
+        helper.parseCalDateString("1499-Midsummer-01-02", file), // 0
+        helper.parseCalDateString("1499-Greengrass-01-04", file), // 1
+        helper.parseCalDateString("1499-Hammer-01-03", file), // 2
+        helper.parseCalDateString("1372-Shieldmeet-02-03", file), // 3
+        helper.parseCalDateString("1372-Shieldmeet", file), // 4
+        helper.parseCalDateString("1499-Alturiak", file), // 5
+        helper.parseCalDateString("1499-Alturiak-01", file), // 6
+        helper.parseCalDateString("1499-Greengrass-01-03", file), // 7
+        helper.parseCalDateString("1499-Hammer", file), // 8
+        helper.parseCalDateString("1499-Hammer-01", file), // 9
+        helper.parseCalDateString("1499-Highharvestide-01", file), // 10
+        helper.parseCalDateString("1499-Marpenoth-01", file), // 11
+        helper.parseCalDateString("1499-Midsummer-01-03", file), // 12
+        helper.parseCalDateString("1499-Alturiak-01-whatever", file), // 13
+        helper.parseCalDateString("1499-Alturiak-01-ok?", file), // 14
     ];
 
-    const fcEvents: FcEvent[] = events.map((x) => {
+    const fcEvents: CalEvent[] = events.map((x) => {
         return {
             date: x,
             description: "Test",
diff --git a/test/event.parseFunctions.test.ts b/test/event.parseFunctions.test.ts
index fffc772..a705bba 100644
--- a/test/event.parseFunctions.test.ts
+++ b/test/event.parseFunctions.test.ts
@@ -1,5 +1,5 @@
 import { Loc, Pos } from "obsidian";
-import { FcEvent } from "../src/@types";
+import { CalEvent } from "../src/@types";
 import { CalEventHelper, ParseDate } from "../src/events/event.helper";
 import { PRESET_CALENDARS } from "../src/utils/presets";
 
@@ -24,7 +24,7 @@ const position: Pos = {
 }
 
 test("Bad Year", () => {
-    expect(gregorian.parseFcDateString("", file)).toBeNull();
+    expect(gregorian.parseCalDateString("", file)).toBeNull();
 });
 
 test("Timestamp", () => {
@@ -95,7 +95,7 @@ test("parseFrontmatterDate / parseFilenameDate: extra", () => {
 
 test("parseFrontmatterEvent", () => {
     let category = gregorian.calendar.categories[0];
-    let actual: FcEvent[] = [];
+    let actual: CalEvent[] = [];
 
     gregorian.parseFrontmatterEvent({
             "fc-start": "1966-05-23",
@@ -139,7 +139,7 @@ test("parseFrontmatterEvent", () => {
 
 test("parseTimelineEvent", () => {
     let category = gregorian.calendar.categories[0];
-    let actual: FcEvent[] = [];
+    let actual: CalEvent[] = [];
 
     gregorian.parseInlineEvents(
         "<span class='ob-timelines'   \n" +
@@ -186,7 +186,7 @@ test("Repeating events", () => {
         day: null,
         order: ''
     };
-    expect(gregorian.parseFcDateString("*-*-*", file)).toEqual(expected);
+    expect(gregorian.parseCalDateString("*-*-*", file)).toEqual(expected);
 
     expect(gregorian.parseFrontmatterDate({}, file)).toEqual(expected);
 
@@ -203,7 +203,7 @@ test("Repeating events with extra", () => {
         day: null,
         order: '01 some extra flavor'
     };
-    expect(gregorian.parseFcDateString("*-*-*-01 some extra flavor", file)).toEqual(expected);
+    expect(gregorian.parseCalDateString("*-*-*-01 some extra flavor", file)).toEqual(expected);
 
     expect(gregorian.parseFrontmatterDate({
             order: '01 some extra flavor'
@@ -222,7 +222,7 @@ test("Repeating events with extra", () => {
         day: null,
         order: '01 some extra flavor'
     };
-    expect(gregorian.parseFcDateString("*-*-*-01 some extra flavor", file)).toEqual(expected);
+    expect(gregorian.parseCalDateString("*-*-*-01 some extra flavor", file)).toEqual(expected);
 
     expect(gregorian.parseFrontmatterDate({
             order: '01 some extra flavor'