diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 9742d6a..42b701a 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -46,14 +46,16 @@ git push -u origin your-branch-name
 
 ## Guidelines
 
-- Use HTML syntax instead of XHTML syntax.
-- Use LF line returns instead of CRLF or CR whenever possible.
+- Use `Array<T>` for typing arrays instead of `T[]`.
+- Use `error` for error catching and `event` for event handling, do not use `e`.
 - Use CSS variables instead of direct values.
+- Use LF line returns instead of CRLF or CR whenever possible, or ensure you have the correct git configurations.
+- Use HTML syntax instead of XHTML syntax.
 - Background color schemes should follow those of the existing `:root` elements.
 - Prefer aria-labels for accessibility over direct `<label>` tags.
 - New files or folders should be organized in the same fashion as the existing structure.
 
 ## Resources
 
-- [TypeScript Style Guide](https://google.github.io/styleguide/tsguide.html)
-- [Docs](https://developer.mozilla.org/en-US/)
+- [TypeScript Docs](https://www.typescriptlang.org/docs/)
+- [More Docs](https://developer.mozilla.org/en-US/)
diff --git a/src/calendar.ts b/src/calendar.ts
index 323a8e1..2af8654 100644
--- a/src/calendar.ts
+++ b/src/calendar.ts
@@ -10,8 +10,8 @@
 interface DayInfo {
   date: string;
   hasSchool: boolean;
-  timeSlot: string;
-  status: string;
+  timeSlot: "Regular" | "Early Dismissal";
+  status: "Normal School Day" | "No School" | "Early Dismissal";
   holidays: Array<string>;
   dayInfo: Array<string>;
 }
@@ -20,15 +20,36 @@ interface CalendarObject {
   [date: string]: DayInfo;
 }
 
+interface DayInfoStruct {
+  daystatus: string;
+  feature: Array<string>;
+  event: Array<string>;
+}
+
+type FixedTime = readonly [number, number];
+type SchoolTimeAsDateStruct = [number, number, number, number, number];
+type TimeUnitType = "day" | "hour" | "minute" | "second";
+type SchoolDateTuple = [number, number, number, number, number];
+type TermEndSpecification = [number, number, number, number, number];
+
+class CalendarError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CalendarError";
+  }
+}
+
 export default class Calendar {
-  public calendar!: CalendarObject;
+  public _calendar!: CalendarObject;
+  public _lastDay!: number | null;
   private dbPath: string;
-  private earlyDismissalTime: Array<number>;
-  private regularSchoolDayTime: Array<number>;
+  private earlyDismissalTime: FixedTime;
+  private regularSchoolDayTime: FixedTime;
   public now: number;
 
   constructor(dbPath: string) {
     this.dbPath = dbPath;
+    // Hardcoded for now, fix later
     // 8:30 to 14:30
     this.earlyDismissalTime = [8.5 * 60 * 60 * 1000, 14.5 * 60 * 60 * 1000];
     // 8:30 to 15:40
@@ -36,25 +57,84 @@ export default class Calendar {
     this.now = Date.now();
   }
 
+  /**
+   * Loads data using fetch from an external JSON file, data
+   * format must match type `dayInfo`.
+   */
   async loadData(): Promise<void> {
     try {
       const response = await fetch(this.dbPath);
       if (!response.ok) {
-        throw new Error("Network response error " + response.statusText);
+        throw new CalendarError("Network response error" + response.statusText);
       }
       this.calendar = await response.json();
+      this.lastDay = this.getLastDay(-1);
     } catch (error) {
-      console.error("There was a problem with the fetch operation:", error);
+      throw new CalendarError("Calendar fetch error.");
     }
   }
 
+  /**
+   * This function must be called with an index to check first
+   * as a parameter, preferably -1. It should only be used once
+   * inside loadDate(), to prevent unnecessary calculation; to
+   * get the last day of school, reference the `this.lastDay`
+   * variable.
+   */
+  getLastDay(indexToCheckFirst: number): number {
+    const day = Object.values(this.calendar).at(indexToCheckFirst);
+    if (!day) {
+      throw new CalendarError("Could not find last school day.");
+    }
+
+    if (day.hasSchool) {
+      const foundDate = new Date(day.date);
+      if (day.timeSlot === "Regular") {
+        foundDate.setMilliseconds(this.regularSchoolDayTime[1]);
+      } else if (day.timeSlot === "Early Dismissal") {
+        foundDate.setMilliseconds(this.earlyDismissalTime[1]);
+      }
+      return foundDate.getTime();
+    } else {
+      return this.getLastDay(--indexToCheckFirst);
+    }
+  }
+
+  // Check whether calendar has been loaded.
+  get calendar(): CalendarObject {
+    if (!this._calendar) {
+      throw new CalendarError("No calendar loaded, did you forget to call loadData()?");
+    }
+    return this._calendar;
+  }
+
+  private set calendar(data: CalendarObject) {
+    this._calendar = data;
+  }
+
+  get lastDay(): number {
+    if (!this._lastDay) {
+      throw new CalendarError(
+        "Last day of school not found, this may be due to failing to load a valid calendar."
+      );
+    }
+    return this._lastDay;
+  }
+
+  private set lastDay(data: number) {
+    this._lastDay = data;
+  }
+
+  /**
+   * This method should only be used in debugging and not in production code.
+   */
   getRaw() {
     console.log(this.calendar);
   }
 
-  strftime(timeStamp: number) {
+  strftime(timeStamp: number): string {
     const date = new Date(timeStamp);
-    const year = date.getFullYear();
+    const year = String(date.getFullYear());
     const month = String(date.getMonth() + 1).padStart(2, "0");
     const day = String(date.getDate()).padStart(2, "0");
     return `${year}-${month}-${day}`;
@@ -65,21 +145,21 @@ export default class Calendar {
     this.now = Date.now();
   }
 
-  contains(schoolDate: number) {
+  contains(schoolDate: number): boolean {
     try {
       this.getDateAt(this.strftime(schoolDate));
       return true;
-    } catch (RangeError) {
+    } catch (e) {
       return false;
     }
   }
 
-  getAbsoluteTimeTo(timeStamp: number) {
-    const absTime: number = timeStamp - this.now;
+  getAbsoluteTimeTo(timeStamp: number): number {
+    const absTime = timeStamp - this.now;
     return absTime;
   }
 
-  getDayInfo(dateStamp: string) {
+  getDayInfo(dateStamp: string): DayInfoStruct {
     return {
       daystatus: this.calendar[dateStamp]["status"],
       feature: this.calendar[dateStamp]["holidays"],
@@ -87,7 +167,7 @@ export default class Calendar {
     };
   }
 
-  floorTimestamp(timeUnit: string, timeStamp: number) {
+  floorTimestamp(timeUnit: TimeUnitType, timeStamp: number): number {
     const timeObj = new Date(timeStamp);
     if (timeUnit === "second") {
       timeObj.setMilliseconds(0);
@@ -104,31 +184,27 @@ export default class Calendar {
       timeObj.setMinutes(0);
       timeObj.setHours(0);
     } else {
-      throw new TypeError(`Unknown time measurement unit ${timeUnit}`);
+      throw new CalendarError(`Unknown time measurement unit ${timeUnit}`);
     }
     return timeObj.getTime();
   }
 
-  modTimestamp(timeUnit: string, timeStamp: number) {
+  modTimestamp(timeUnit: TimeUnitType, timeStamp: number): number {
     return timeStamp - this.floorTimestamp(timeUnit, timeStamp);
   }
 
-  getPercentCompletion(startingTimeStamp: number, endingTimeStamp: number) {
-    const timeToElapse: number = endingTimeStamp - startingTimeStamp;
+  getPercentCompletion(startingTimeStamp: number, endingTimeStamp: number): number {
+    const timeToElapse = endingTimeStamp - startingTimeStamp;
 
     // Basic safety test
     if (timeToElapse < 0) {
-      throw new RangeError(`Invalid range ${startingTimeStamp}-${endingTimeStamp}`);
+      throw new CalendarError(`Invalid range ${startingTimeStamp} - ${endingTimeStamp}`);
     }
 
     if (startingTimeStamp > this.now) return 0;
     if (endingTimeStamp < this.now) return 1;
 
-    // Borrow the this.now variable to force a full school time calculation.
-    // Bad practice, fix later.
-    const temp = this.now;
-    const schoolTimeToElapse: number = this.getSchoolTimeTo(endingTimeStamp);
-    this.now = temp;
+    const schoolTimeToElapse = this.getSchoolTimeTo(endingTimeStamp, startingTimeStamp);
 
     if (this.contains(this.now)) {
       // Use schoolTime
@@ -141,11 +217,18 @@ export default class Calendar {
     }
   }
 
-  getSchoolTimeTo(timeStamp: number) {
-    const currentDate: string = this.strftime(this.now);
-    const endingDate: string = this.strftime(timeStamp);
-    const hoursAfterMidnight: number = this.modTimestamp("day", this.now);
-    const hoursLastDay: number = this.modTimestamp("day", timeStamp);
+  /**
+   * This method takes two arguments, the timeStamp parameter represents the target
+   * to which the school time to will be calculated, the second parameter, which is
+   * optional, represents the time where the function should take as it's starting
+   * time. Please take note that the FIRST parameter is the ending time, and the
+   * SECOND is the starting time.
+   */
+  getSchoolTimeTo(timeStamp: number, startingTime: number = this.now): number {
+    const currentDate = this.strftime(startingTime);
+    const endingDate = this.strftime(timeStamp);
+    const millisecondsAfterMidnight = this.modTimestamp("day", startingTime);
+    const millisecondsLastDay = this.modTimestamp("day", timeStamp);
 
     let milliSeconds: number = 0;
 
@@ -169,17 +252,17 @@ export default class Calendar {
       if (this.calendar[currentDate].timeSlot === "Regular") {
         // If there is school right now
         if (
-          this.regularSchoolDayTime[0] <= hoursAfterMidnight &&
-          hoursAfterMidnight < this.regularSchoolDayTime[1]
+          this.regularSchoolDayTime[0] <= millisecondsAfterMidnight &&
+          millisecondsAfterMidnight < this.regularSchoolDayTime[1]
         ) {
           // Subtract one day since it was already calculated above
           milliSeconds -= this.regularSchoolDayTime[1] - this.regularSchoolDayTime[0];
           // Add on the time that is still remaining today
-          milliSeconds += this.regularSchoolDayTime[1] - hoursAfterMidnight;
-        } else if (hoursAfterMidnight < this.regularSchoolDayTime[0]) {
+          milliSeconds += this.regularSchoolDayTime[1] - millisecondsAfterMidnight;
+        } else if (millisecondsAfterMidnight < this.regularSchoolDayTime[0]) {
           // Extra day already calculated
           // Do nothing
-        } else if (hoursAfterMidnight >= this.regularSchoolDayTime[1]) {
+        } else if (millisecondsAfterMidnight >= this.regularSchoolDayTime[1]) {
           // Subtract extra counted day
           milliSeconds -= this.regularSchoolDayTime[1] - this.regularSchoolDayTime[0];
         }
@@ -188,15 +271,15 @@ export default class Calendar {
       // Same thing as above except for early dismissal
       if (this.calendar[currentDate].timeSlot === "Early Dismissal") {
         if (
-          this.earlyDismissalTime[0] <= hoursAfterMidnight &&
-          hoursAfterMidnight < this.earlyDismissalTime[1]
+          this.earlyDismissalTime[0] <= millisecondsAfterMidnight &&
+          millisecondsAfterMidnight < this.earlyDismissalTime[1]
         ) {
           // Subtract one day
           milliSeconds -= this.earlyDismissalTime[1] - this.earlyDismissalTime[0];
-          milliSeconds += this.earlyDismissalTime[1] - hoursAfterMidnight;
-        } else if (hoursAfterMidnight < this.earlyDismissalTime[0]) {
+          milliSeconds += this.earlyDismissalTime[1] - millisecondsAfterMidnight;
+        } else if (millisecondsAfterMidnight < this.earlyDismissalTime[0]) {
           // Do nothing
-        } else if (hoursAfterMidnight >= this.earlyDismissalTime[1]) {
+        } else if (millisecondsAfterMidnight >= this.earlyDismissalTime[1]) {
           // Subtract extra counted day
           milliSeconds -= this.earlyDismissalTime[1] - this.earlyDismissalTime[0];
         }
@@ -208,17 +291,17 @@ export default class Calendar {
       if (this.calendar[endingDate].timeSlot === "Regular") {
         // If there is school right now
         if (
-          this.regularSchoolDayTime[0] <= hoursLastDay &&
-          hoursLastDay < this.regularSchoolDayTime[1]
+          this.regularSchoolDayTime[0] <= millisecondsLastDay &&
+          millisecondsLastDay < this.regularSchoolDayTime[1]
         ) {
           // Subtract one day since it was already calculated above
           milliSeconds -= this.regularSchoolDayTime[1] - this.regularSchoolDayTime[0];
           // Add on the time that has passed today
-          milliSeconds += hoursLastDay - this.regularSchoolDayTime[0];
-        } else if (hoursLastDay < this.regularSchoolDayTime[0]) {
+          milliSeconds += millisecondsLastDay - this.regularSchoolDayTime[0];
+        } else if (millisecondsLastDay < this.regularSchoolDayTime[0]) {
           // Subtract extra counted day
           milliSeconds -= this.regularSchoolDayTime[1] - this.regularSchoolDayTime[0];
-        } else if (hoursLastDay >= this.regularSchoolDayTime[1]) {
+        } else if (millisecondsLastDay >= this.regularSchoolDayTime[1]) {
           // Extra day already calculated
           // Do nothing
         }
@@ -227,16 +310,16 @@ export default class Calendar {
       // Same thing as above except for early dismissal
       if (this.calendar[endingDate].timeSlot === "Early Dismissal") {
         if (
-          this.earlyDismissalTime[0] <= hoursLastDay &&
-          hoursLastDay < this.earlyDismissalTime[1]
+          this.earlyDismissalTime[0] <= millisecondsLastDay &&
+          millisecondsLastDay < this.earlyDismissalTime[1]
         ) {
           // Subtract one day
           milliSeconds -= this.earlyDismissalTime[1] - this.earlyDismissalTime[0];
-          milliSeconds += hoursLastDay - this.earlyDismissalTime[0];
-        } else if (hoursLastDay < this.earlyDismissalTime[0]) {
+          milliSeconds += millisecondsLastDay - this.earlyDismissalTime[0];
+        } else if (millisecondsLastDay < this.earlyDismissalTime[0]) {
           // Subtract extra counted day
           milliSeconds -= this.earlyDismissalTime[1] - this.earlyDismissalTime[0];
-        } else if (hoursLastDay >= this.earlyDismissalTime[1]) {
+        } else if (millisecondsLastDay >= this.earlyDismissalTime[1]) {
           // Do nothing
         }
       }
@@ -249,7 +332,7 @@ export default class Calendar {
    * only full dates, it should be updated in the
    * future to support more accurate timing.
    */
-  getSchoolTimeAsDate(endingTimeStamp: number) {
+  getSchoolTimeAsDate(endingTimeStamp: number): SchoolTimeAsDateStruct {
     let endDate = new Date(endingTimeStamp);
     const endingDateObj = this.getDateAt(this.strftime(endingTimeStamp));
 
@@ -266,12 +349,11 @@ export default class Calendar {
 
     const endingDate = this.strftime(endDate.getTime());
 
-    type schoolDateTuple = [number, number, number, number, number];
-    let schoolDateRemaining: schoolDateTuple = [0, 0, 0, 0, 0];
+    let schoolDateRemaining: SchoolDateTuple = [0, 0, 0, 0, 0];
     let milliseconds: number = 0;
 
-    const currentDate: string = this.strftime(this.now);
-    const hoursAfterMidnight: number = this.modTimestamp("day", this.now);
+    const currentDate = this.strftime(this.now);
+    const hoursAfterMidnight = this.modTimestamp("day", this.now);
 
     for (const date in this.calendar) {
       // The current date should not be counted but the ending Date should be
@@ -332,24 +414,120 @@ export default class Calendar {
     return schoolDateRemaining;
   }
 
-  getDateAt(dateStamp: string) {
+  findNextWeekend(): number {
+    const currentDate = new Date(this.now);
+    const currentWeekday = currentDate.getDay();
+    const tempEnd = new Date(this.floorTimestamp("day", this.now));
+
+    if (currentWeekday === 6 || currentWeekday === 0) {
+      return this.now;
+    } else {
+      const daysToAdd = 6 - currentDate.getDay();
+      tempEnd.setDate(tempEnd.getDate() + daysToAdd);
+    }
+
+    return this.schoolTimeify(tempEnd).getTime();
+  }
+
+  getDayOfTheWeek(date: DayInfo): number {
+    const d = new Date(date.date);
+    return d.getDay();
+  }
+
+  findNextLongWeekend(): number {
+    const day = Object.values(this.calendar).find((_day, index, array) => {
+      // Use indexes for consistency
+      const first = array[index];
+      const second = array[index + 1];
+      const third = array[index + 2];
+      if (!second || !third) return false;
+      const schoolNotExists = !first.hasSchool && !second?.hasSchool && !third?.hasSchool;
+      const onWeekend =
+        (this.getDayOfTheWeek(first) === 6 && this.getDayOfTheWeek(second) === 0) ||
+        (this.getDayOfTheWeek(second) === 6 && this.getDayOfTheWeek(third) === 0);
+
+      const dateNow = new Date(this.now);
+      const dateCandidate = new Date(first.date);
+
+      const inTheFuture = dateCandidate > dateNow;
+
+      return schoolNotExists && onWeekend && inTheFuture;
+    });
+
+    if (!day) {
+      const previousFoundDay = new Date(this.lastDay);
+      return previousFoundDay.getTime();
+    }
+    const previousFoundDay = new Date(day.date);
+    return this.schoolTimeify(previousFoundDay).getTime();
+  }
+
+  /**
+   * Takes a date object as an input and returns a modified date object
+   * that has hours and minutes set to the end school time of either
+   * late start or early dismissal.
+   */
+  schoolTimeify(dateObj: Date): Date {
+    // Rollback to previous day
+    dateObj.setDate(dateObj.getDate() - 1);
+    const stamp = this.strftime(dateObj.getTime());
+
+    if (this.calendar[stamp].hasSchool) {
+      if (this.calendar[stamp].timeSlot === "Regular") {
+        dateObj.setMilliseconds(this.regularSchoolDayTime[1]);
+      } else if (this.calendar[stamp].timeSlot === "Early Dismissal") {
+        dateObj.setMilliseconds(this.earlyDismissalTime[1]);
+      }
+    } else {
+      dateObj.setHours(24);
+    }
+
+    return dateObj;
+  }
+
+  findNextNoSchool(): number {
+    const day = Object.values(this.calendar).find((day) => {
+      const dateNow = new Date(this.now);
+      const dateCandidate = new Date(day.date);
+      const inTheFuture = dateCandidate > dateNow;
+      return !day.hasSchool && inTheFuture;
+    });
+
+    if (!day) {
+      const previousFoundDay = new Date(this.lastDay);
+      return previousFoundDay.getTime();
+    }
+    const foundDate = new Date(day.date);
+    return this.schoolTimeify(foundDate).getTime();
+  }
+
+  /**
+   * Takes any number of arrays of numbers as an argument,
+   * each array must have exactly 5 numbers, to be passed on
+   * to a Date object constructor, they must be valid dates.
+   * and arranged in chronological order.
+   */
+  findEndTerm(...termEnds: Array<TermEndSpecification>): number {
+    let termEndDates: Array<Date> = [];
+    for (const arr of termEnds) {
+      const date = new Date(...arr);
+      termEndDates.push(date);
+    }
+
+    for (const date of termEndDates) {
+      // First term that has not passed
+      if (date.getTime() - this.now > 0) {
+        return date.getTime();
+      }
+    }
+
+    return this.now;
+  }
+
+  getDateAt(dateStamp: string): DayInfo {
     if (!this.calendar[dateStamp]) {
       throw new RangeError(`Calendar does not contain ${dateStamp}.`);
     }
     return this.calendar[dateStamp];
   }
 }
-
-/*
-async function start() {
-  const cal = new Calendar("calendar.json", 0, 0);
-  await cal.loadData();
-  const tempdate = new Date(2026, 8, 22, 18, 0);
-  const tempnow = new Date(2026, 8, 22, 9, 0);
-  cal.now = tempnow.getTime();
-  console.log(cal.getSchoolTimeTo(tempdate.getTime()));
-  console.log(cal.getAbsoluteTimeTo(tempdate.getTime()));
-}
-
-start();
-*/
diff --git a/src/dom.ts b/src/dom.ts
index 647ff54..65fed7e 100644
--- a/src/dom.ts
+++ b/src/dom.ts
@@ -1,6 +1,5 @@
 import "./styles.css";
 import "./themes.css";
-
 import Calendar from "./calendar";
 
 const welcomeText =
@@ -24,26 +23,35 @@ const schoolTimeContainer = document.getElementById(
 ) as HTMLDivElement | null;
 const dayInfoContainer = document.getElementById("day-information") as HTMLDivElement | null;
 
-const timeToggleButton = document.getElementById("time-toggle") as HTMLElement | null;
-const timeMenu = document.getElementById("time-menu") as HTMLElement | null;
+const timeToggleButton = document.getElementById("time-toggle");
+const timeMenu = document.getElementById("time-menu");
 
-const settingsButton = document.getElementById("settings-button") as HTMLElement | null;
-const settingsMenu = document.getElementById("settings") as HTMLElement | null;
+const settingsButton = document.getElementById("settings-button");
+const settingsMenu = document.getElementById("settings");
 
 let schoolTimeRemaining: number | null;
 let totalTimeRemaining: number;
 let schoolDates: Array<number> | null;
 
 let calendar = new Calendar("./calendars/gci.json");
-let endDate = new Date(2027, 5, 21, 15, 40);
-// let startingDate = new Date(2026, 8, 9, 8, 30);
-let startingDate = new Date(Date.now());
+let endDate: Date = new Date(2027, 5, 21, 15, 40);
 
-let finish: boolean = false;
+// When school starts, uncomment
+// let startingDate: Date = new Date(2026, 8, 9, 8, 30);
+let startingDate: Date = new Date(Date.now());
 let causeOfDeath: string;
 
 const lastMessage = document.getElementById("last-message") as HTMLDivElement | null;
 
+type DateArgs = [number, number, number, number, number];
+
+const termEnds: Array<DateArgs> = [
+  [2026, 10, 18, 15, 40],
+  [2027, 1, 5, 15, 40],
+  [2027, 3, 13, 15, 40],
+  [2027, 5, 21, 15, 40],
+];
+
 async function start() {
   // Welcome
   console.log(
@@ -66,9 +74,8 @@ async function start() {
   handleCalendars();
 
   updateDOM();
-  const mainloopId = setInterval(() => {
+  setInterval(() => {
     if (checkFinish()) {
-      // clearInterval(mainloopId);
       triggerFinish();
     } else {
       updateDOM();
@@ -105,7 +112,7 @@ function handleTime() {
     return;
   }
 
-  timeToggleButton.addEventListener("click", (e) => {
+  timeToggleButton.addEventListener("click", () => {
     if (timeMenu.hidden) {
       timeMenu.hidden = false;
       timeToggleButton.classList.add("open");
@@ -115,9 +122,9 @@ function handleTime() {
     }
   });
 
-  document.addEventListener("click", (e) => {
+  document.addEventListener("click", (event) => {
     // Stop tsc from complaining
-    const target = e.target as Node;
+    const target = event.target as Node;
     if (!timeMenu.contains(target) && !timeToggleButton.contains(target)) {
       timeMenu.hidden = true;
       timeToggleButton.classList.remove("open");
@@ -150,19 +157,19 @@ function getPreferredDates(value: string) {
       causeOfDeath = "Winter Break";
       break;
     case "noschool":
-      findNextNoSchool();
+      endDate = new Date(calendar.findNextNoSchool());
       causeOfDeath = "No School Right Now";
       break;
     case "weekend":
-      findNextWeekend();
+      endDate = new Date(calendar.findNextWeekend());
       causeOfDeath = "Weekend";
       break;
     case "lweekend":
-      findNextLongWeekend();
+      endDate = new Date(calendar.findNextLongWeekend());
       causeOfDeath = "Long Weekend";
       break;
     case "term":
-      findEndTerm();
+      endDate = new Date(calendar.findEndTerm(...termEnds));
       causeOfDeath = "🎉School Has Ended🎉";
       break;
     case "start":
@@ -180,7 +187,7 @@ function handleSettings() {
     return;
   }
 
-  settingsButton.addEventListener("click", (e) => {
+  settingsButton.addEventListener("click", () => {
     if (settingsMenu.hidden) {
       settingsMenu.hidden = false;
       settingsButton.classList.add("open");
@@ -190,9 +197,9 @@ function handleSettings() {
     }
   });
 
-  document.addEventListener("click", (e) => {
+  document.addEventListener("click", (event) => {
     // Stop tsc from complaining
-    const target = e.target as Node;
+    const target = event.target as Node;
     if (!settingsMenu.contains(target) && !settingsButton.contains(target)) {
       settingsMenu.hidden = true;
       settingsButton.classList.remove("open");
@@ -209,7 +216,7 @@ function handleThemes() {
     return;
   }
 
-  themeButton.addEventListener("click", (e) => {
+  themeButton.addEventListener("click", () => {
     if (themeMenu.hidden) {
       themeMenu.hidden = false;
       themeButton.classList.add("open");
@@ -219,9 +226,9 @@ function handleThemes() {
     }
   });
 
-  document.addEventListener("click", (e) => {
+  document.addEventListener("click", (event) => {
     // Stop tsc from complaining
-    const target = e.target as Node;
+    const target = event.target as Node;
     if (!themeMenu.contains(target) && !themeButton.contains(target)) {
       themeMenu.hidden = true;
       themeButton.classList.remove("open");
@@ -250,7 +257,7 @@ function handleCalendars() {
     return;
   }
 
-  calendarButton.addEventListener("click", (e) => {
+  calendarButton.addEventListener("click", () => {
     if (calendarMenu.hidden) {
       calendarMenu.hidden = false;
       calendarButton.classList.add("open");
@@ -260,9 +267,9 @@ function handleCalendars() {
     }
   });
 
-  document.addEventListener("click", (e) => {
+  document.addEventListener("click", (event) => {
     // Stop tsc from complaining
-    const target = e.target as Node;
+    const target = event.target as Node;
     if (!calendarMenu.contains(target) && !calendarButton.contains(target)) {
       calendarMenu.hidden = true;
       calendarButton.classList.remove("open");
@@ -299,154 +306,8 @@ async function setPreferredCalendars(value: string) {
   localStorage.setItem("calendar", value);
 }
 
-function findEndTerm() {
-  type DateArgs = [number, number, number, number, number];
-
-  const termEnds: DateArgs[] = [
-    [2026, 10, 18, 15, 40],
-    [2027, 1, 5, 15, 40],
-    [2027, 3, 13, 15, 40],
-    [2027, 5, 21, 15, 40],
-  ];
-  let termEndDates: Date[] = [];
-  for (const arr of termEnds) {
-    const date = new Date(...arr);
-    termEndDates.push(date);
-  }
-
-  // Get current term
-  for (const date of termEndDates) {
-    // First term that has not passed
-    if (date.getTime() - calendar.now > 0) {
-      endDate = new Date(date.getTime());
-      return;
-    }
-  }
-
-  endDate = new Date(calendar.now);
-}
-
-function findNextWeekend() {
-  const currentDate = new Date(calendar.now);
-  const currentWeekday = currentDate.getDay();
-  const tempEnd = new Date(
-    currentDate.getFullYear(),
-    currentDate.getMonth(),
-    currentDate.getDate()
-  );
-
-  if (currentWeekday === 6 || currentWeekday === 0) {
-    endDate = new Date(calendar.now);
-  } else {
-    const daysToAdd = 6 - currentDate.getDay();
-    tempEnd.setDate(tempEnd.getDate() + daysToAdd);
-  }
-
-  // Rollback to previous day
-  tempEnd.setDate(tempEnd.getDate() - 1);
-  const stamp: string = calendar.strftime(tempEnd.getTime());
-
-  if (calendar.calendar[stamp].hasSchool) {
-    if (calendar.calendar[stamp].timeSlot === "Regular") {
-      tempEnd.setHours(15, 40);
-    } else if (calendar.calendar[stamp].timeSlot === "Early Dismissal") {
-      tempEnd.setHours(14, 30);
-    }
-  } else {
-    tempEnd.setHours(24);
-  }
-
-  endDate = tempEnd;
-}
-
-function findNextLongWeekend() {
-  for (const day in calendar.calendar) {
-    if (day < calendar.strftime(calendar.now)) {
-      continue;
-    } else {
-      let date = new Date(day);
-      const next3Days = [
-        calendar.strftime(date.getTime()),
-        calendar.strftime(date.setTime(date.getTime() + 24 * 60 * 60 * 1000)),
-        calendar.strftime(date.setTime(date.getTime() + 24 * 60 * 60 * 1000)),
-      ];
-
-      date = new Date(day);
-      let next3Weekdays = [date.getDay()];
-
-      date.setTime(date.getTime() + 24 * 60 * 60 * 1000);
-      next3Weekdays.push(date.getDay());
-
-      date.setTime(date.getTime() + 24 * 60 * 60 * 1000);
-      next3Weekdays.push(date.getDay());
-
-      if (
-        !calendar.calendar[next3Days[0]].hasSchool &&
-        !calendar.calendar[next3Days[1]].hasSchool &&
-        !calendar.calendar[next3Days[2]].hasSchool &&
-        ((next3Weekdays[0] === 6 && next3Weekdays[1] === 0) ||
-          (next3Weekdays[1] === 6 && next3Weekdays[2] === 0))
-      ) {
-        const previousDay = new Date(day);
-        previousDay.setTime(previousDay.getTime() - 24 * 60 * 60 * 1000);
-        const previousDayStamp = calendar.strftime(previousDay.getTime());
-
-        if (!calendar.contains(previousDay.getTime())) {
-          endDate = new Date(calendar.now);
-          return;
-        }
-
-        if (calendar.calendar[previousDayStamp].hasSchool) {
-          if (calendar.calendar[previousDayStamp].timeSlot === "Regular") {
-            previousDay.setHours(15, 40);
-          } else if (calendar.calendar[previousDayStamp].timeSlot === "Early Dismissal") {
-            previousDay.setHours(14, 30);
-          }
-        } else {
-          previousDay.setHours(24);
-        }
-
-        endDate = new Date(previousDay.getTime());
-        return;
-      }
-    }
-  }
-}
-
-function findNextNoSchool() {
-  for (const day in calendar.calendar) {
-    if (day < calendar.strftime(calendar.now)) {
-      continue;
-    } else {
-      if (!calendar.calendar[day].hasSchool) {
-        const previousDay = new Date(day);
-        const previousDayStamp = calendar.strftime(previousDay.getTime());
-
-        if (!calendar.contains(previousDay.getTime())) {
-          endDate = new Date(calendar.now);
-          return;
-        }
-
-        if (calendar.calendar[previousDayStamp].hasSchool) {
-          if (calendar.calendar[previousDayStamp].timeSlot === "Regular") {
-            previousDay.setHours(15, 40);
-          } else if (calendar.calendar[previousDayStamp].timeSlot === "Early Dismissal") {
-            previousDay.setHours(14, 30);
-          }
-        } else {
-          endDate = new Date(calendar.now);
-          return;
-        }
-
-        endDate = new Date(previousDay.getTime());
-        return;
-      }
-    }
-  }
-}
-
 function triggerFinish() {
-  finish = true;
+  // Finished
   if (!container || !lastMessage) return;
   container.hidden = true;
   lastMessage.textContent = causeOfDeath;
@@ -454,7 +315,7 @@ function triggerFinish() {
 }
 
 function undoFinish() {
-  finish = false;
+  // Not finished
   if (!container || !lastMessage) return;
   container.hidden = false;
   lastMessage.hidden = true;
@@ -483,8 +344,8 @@ function updateTimer() {
   try {
     schoolTimeRemaining = calendar.getSchoolTimeTo(endDate.getTime());
     schoolDates = calendar.getSchoolTimeAsDate(endDate.getTime());
-  } catch (e) {
-    console.error(e);
+  } catch (error) {
+    console.error(error);
     schoolTimeRemaining = null;
     schoolDates = null;
   }
@@ -517,32 +378,14 @@ function populateAbsoluteTimes(schoolTimeRemaining: number | null) {
   absoluteTimes[3].textContent = String(schoolTimeRemaining / 1000);
 }
 
-function populateSchoolTimes(schoolTimeRemaining: number) {
-  // See calendar.ts for function usage
-  schoolTimes[0].textContent = String(
-    calendar.floorTimestamp("day", schoolTimeRemaining) / 1000 / 60 / 60 / 24
-  );
-  schoolTimes[1].textContent = String(
-    calendar.floorTimestamp("hour", schoolTimeRemaining) / 1000 / 60 / 60
-  );
-  schoolTimes[2].textContent = String(
-    calendar.modTimestamp("minute", schoolTimeRemaining) / 1000 / 60
-  );
-  schoolTimes[3].textContent = String(calendar.modTimestamp("second", schoolTimeRemaining) / 1000);
-}
-
 function populateTotalTimes(timeRemaining: number) {
-  // See calendar.ts for function usage
-
   // Worst code I have ever written, MUST fix later
-  const daysLeft: number = Math.floor(timeRemaining / 1000 / 60 / 60 / 24);
-  const hoursLeft: number = Math.floor(
-    (timeRemaining - daysLeft * 1000 * 60 * 60 * 24) / 1000 / 60 / 60
-  );
-  const minutesLeft: number = Math.floor(
+  const daysLeft = Math.floor(timeRemaining / 1000 / 60 / 60 / 24);
+  const hoursLeft = Math.floor((timeRemaining - daysLeft * 1000 * 60 * 60 * 24) / 1000 / 60 / 60);
+  const minutesLeft = Math.floor(
     (timeRemaining - daysLeft * 1000 * 60 * 60 * 24 - hoursLeft * 1000 * 60 * 60) / 1000 / 60
   );
-  const secondsLeft: number = Math.floor(
+  const secondsLeft = Math.floor(
     (timeRemaining -
       daysLeft * 1000 * 60 * 60 * 24 -
       hoursLeft * 1000 * 60 * 60 -
@@ -580,18 +423,15 @@ function populateSchoolDates(schoolDates: Array<number> | null) {
 function updateProgressBar() {
   const start = startingDate;
 
-  // Uncomment when school actually starts
-  // const start = new Date(2026, 8, 9, 8, 30);
-
   const end = endDate;
   let fractionPercentage: number;
   try {
     fractionPercentage = calendar.getPercentCompletion(start.getTime(), end.getTime());
-  } catch (e) {
+  } catch (error) {
     return;
   }
 
-  const percentFinished: string = `${fractionPercentage * 100}%`;
+  const percentFinished = `${fractionPercentage * 100}%`;
 
   if (progressBar) {
     progressBar.style.width = percentFinished;