@cesium/engine 24.0.0 → 26.0.0

package/Source/Core/JulianDate.js

@@ -195,603 +195,627 @@ const iso8601ErrorMessage = "Invalid ISO 8601 date.";
  * part of the date in separate components.  In order to be safe for arithmetic and represent
  * leap seconds, the date is always stored in the International Atomic Time standard
  * {@link TimeStandard.TAI}.
- * @alias JulianDate
- * @constructor
- *
- * @param {number} [julianDayNumber=0.0] The Julian Day Number representing the number of whole days.  Fractional days will also be handled correctly.
- * @param {number} [secondsOfDay=0.0] The number of seconds into the current Julian Day Number.  Fractional seconds, negative seconds and seconds greater than a day will be handled correctly.
- * @param {TimeStandard} [timeStandard=TimeStandard.UTC] The time standard in which the first two parameters are defined.
  */
-function JulianDate(julianDayNumber, secondsOfDay, timeStandard) {
+class JulianDate {
   /**
-   * Gets or sets the number of whole days.
-   * @type {number}
+   * @param {number} [julianDayNumber=0.0] The Julian Day Number representing the number of whole days.  Fractional days will also be handled correctly.
+   * @param {number} [secondsOfDay=0.0] The number of seconds into the current Julian Day Number.  Fractional seconds, negative seconds and seconds greater than a day will be handled correctly.
+   * @param {TimeStandard} [timeStandard=TimeStandard.UTC] The time standard in which the first two parameters are defined.
    */
-  this.dayNumber = undefined;
+  constructor(julianDayNumber, secondsOfDay, timeStandard) {
+    /**
+     * Gets or sets the number of whole days.
+     * @type {number}
+     */
+    this.dayNumber = undefined;
+
+    /**
+     * Gets or sets the number of seconds into the current day.
+     * @type {number}
+     */
+    this.secondsOfDay = undefined;
+
+    julianDayNumber = julianDayNumber ?? 0.0;
+    secondsOfDay = secondsOfDay ?? 0.0;
+    timeStandard = timeStandard ?? TimeStandard.UTC;
+
+    //If julianDayNumber is fractional, make it an integer and add the number of seconds the fraction represented.
+    const wholeDays = julianDayNumber | 0;
+    secondsOfDay =
+      secondsOfDay +
+      (julianDayNumber - wholeDays) * TimeConstants.SECONDS_PER_DAY;
+
+    setComponents(wholeDays, secondsOfDay, this);
+
+    if (timeStandard === TimeStandard.UTC) {
+      convertUtcToTai(this);
+    }
+  }
 
   /**
-   * Gets or sets the number of seconds into the current day.
-   * @type {number}
+   * Creates a new instance from a GregorianDate.
+   *
+   * @param {GregorianDate} date A GregorianDate.
+   * @param {JulianDate} [result] An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
+   *
+   * @exception {DeveloperError} date must be a valid GregorianDate.
    */
-  this.secondsOfDay = undefined;
-
-  julianDayNumber = julianDayNumber ?? 0.0;
-  secondsOfDay = secondsOfDay ?? 0.0;
-  timeStandard = timeStandard ?? TimeStandard.UTC;
-
-  //If julianDayNumber is fractional, make it an integer and add the number of seconds the fraction represented.
-  const wholeDays = julianDayNumber | 0;
-  secondsOfDay =
-    secondsOfDay +
-    (julianDayNumber - wholeDays) * TimeConstants.SECONDS_PER_DAY;
-
-  setComponents(wholeDays, secondsOfDay, this);
-
-  if (timeStandard === TimeStandard.UTC) {
-    convertUtcToTai(this);
-  }
-}
+  static fromGregorianDate(date, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!(date instanceof GregorianDate)) {
+      throw new DeveloperError("date must be a valid GregorianDate.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Creates a new instance from a GregorianDate.
- *
- * @param {GregorianDate} date A GregorianDate.
- * @param {JulianDate} [result] An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
- *
- * @exception {DeveloperError} date must be a valid GregorianDate.
- */
-JulianDate.fromGregorianDate = function (date, result) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!(date instanceof GregorianDate)) {
-    throw new DeveloperError("date must be a valid GregorianDate.");
-  }
-  //>>includeEnd('debug');
-
-  const components = computeJulianDateComponents(
-    date.year,
-    date.month,
-    date.day,
-    date.hour,
-    date.minute,
-    date.second,
-    date.millisecond,
-  );
-  if (!defined(result)) {
-    return new JulianDate(components[0], components[1], TimeStandard.UTC);
+    const components = computeJulianDateComponents(
+      date.year,
+      date.month,
+      date.day,
+      date.hour,
+      date.minute,
+      date.second,
+      date.millisecond,
+    );
+    if (!defined(result)) {
+      return new JulianDate(components[0], components[1], TimeStandard.UTC);
+    }
+    setComponents(components[0], components[1], result);
+    convertUtcToTai(result);
+    return result;
   }
-  setComponents(components[0], components[1], result);
-  convertUtcToTai(result);
-  return result;
-};
 
-/**
- * Creates a new instance from a JavaScript Date.
- *
- * @param {Date} date A JavaScript Date.
- * @param {JulianDate} [result] An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
- *
- * @exception {DeveloperError} date must be a valid JavaScript Date.
- */
-JulianDate.fromDate = function (date, result) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!(date instanceof Date) || isNaN(date.getTime())) {
-    throw new DeveloperError("date must be a valid JavaScript Date.");
-  }
-  //>>includeEnd('debug');
-
-  const components = computeJulianDateComponents(
-    date.getUTCFullYear(),
-    date.getUTCMonth() + 1,
-    date.getUTCDate(),
-    date.getUTCHours(),
-    date.getUTCMinutes(),
-    date.getUTCSeconds(),
-    date.getUTCMilliseconds(),
-  );
-  if (!defined(result)) {
-    return new JulianDate(components[0], components[1], TimeStandard.UTC);
-  }
-  setComponents(components[0], components[1], result);
-  convertUtcToTai(result);
-  return result;
-};
+  /**
+   * Creates a new instance from a JavaScript Date.
+   *
+   * @param {Date} date A JavaScript Date.
+   * @param {JulianDate} [result] An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
+   *
+   * @exception {DeveloperError} date must be a valid JavaScript Date.
+   */
+  static fromDate(date, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!(date instanceof Date) || isNaN(date.getTime())) {
+      throw new DeveloperError("date must be a valid JavaScript Date.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Creates a new instance from a from an {@link http://en.wikipedia.org/wiki/ISO_8601|ISO 8601} date.
- * This method is superior to <code>Date.parse</code> because it will handle all valid formats defined by the ISO 8601
- * specification, including leap seconds and sub-millisecond times, which discarded by most JavaScript implementations.
- *
- * @param {string} iso8601String An ISO 8601 date.
- * @param {JulianDate} [result] An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
- *
- * @exception {DeveloperError} Invalid ISO 8601 date.
- */
-JulianDate.fromIso8601 = function (iso8601String, result) {
-  //>>includeStart('debug', pragmas.debug);
-  if (typeof iso8601String !== "string") {
-    throw new DeveloperError(iso8601ErrorMessage);
-  }
-  //>>includeEnd('debug');
-
-  //Comma and decimal point both indicate a fractional number according to ISO 8601,
-  //start out by blanket replacing , with . which is the only valid such symbol in JS.
-  iso8601String = iso8601String.replace(",", ".");
-
-  //Split the string into its date and time components, denoted by a mandatory T
-  let tokens = iso8601String.split("T");
-  let year;
-  let month = 1;
-  let day = 1;
-  let hour = 0;
-  let minute = 0;
-  let second = 0;
-  let millisecond = 0;
-
-  //Lacking a time is okay, but a missing date is illegal.
-  const date = tokens[0];
-  const time = tokens[1];
-  let tmp;
-  let inLeapYear;
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(date)) {
-    throw new DeveloperError(iso8601ErrorMessage);
+    const components = computeJulianDateComponents(
+      date.getUTCFullYear(),
+      date.getUTCMonth() + 1,
+      date.getUTCDate(),
+      date.getUTCHours(),
+      date.getUTCMinutes(),
+      date.getUTCSeconds(),
+      date.getUTCMilliseconds(),
+    );
+    if (!defined(result)) {
+      return new JulianDate(components[0], components[1], TimeStandard.UTC);
+    }
+    setComponents(components[0], components[1], result);
+    convertUtcToTai(result);
+    return result;
   }
 
-  let dashCount;
-  //>>includeEnd('debug');
+  /**
+   * Creates a new instance from a from an {@link http://en.wikipedia.org/wiki/ISO_8601|ISO 8601} date.
+   * This method is superior to <code>Date.parse</code> because it will handle all valid formats defined by the ISO 8601
+   * specification, including leap seconds and sub-millisecond times, which discarded by most JavaScript implementations.
+   *
+   * @param {string} iso8601String An ISO 8601 date.
+   * @param {JulianDate} [result] An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
+   *
+   * @exception {DeveloperError} Invalid ISO 8601 date.
+   */
+  static fromIso8601(iso8601String, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (typeof iso8601String !== "string") {
+      throw new DeveloperError(iso8601ErrorMessage);
+    }
+    //>>includeEnd('debug');
 
-  //First match the date against possible regular expressions.
-  tokens = date.match(matchCalendarDate);
-  if (tokens !== null) {
+    //Comma and decimal point both indicate a fractional number according to ISO 8601,
+    //start out by blanket replacing , with . which is the only valid such symbol in JS.
+    iso8601String = iso8601String.replace(",", ".");
+
+    //Split the string into its date and time components, denoted by a mandatory T
+    let tokens = iso8601String.split("T");
+    let year;
+    let month = 1;
+    let day = 1;
+    let hour = 0;
+    let minute = 0;
+    let second = 0;
+    let millisecond = 0;
+
+    //Lacking a time is okay, but a missing date is illegal.
+    const date = tokens[0];
+    const time = tokens[1];
+    let tmp;
+    let inLeapYear;
     //>>includeStart('debug', pragmas.debug);
-    dashCount = date.split("-").length - 1;
-    if (dashCount > 0 && dashCount !== 2) {
+    if (!defined(date)) {
       throw new DeveloperError(iso8601ErrorMessage);
     }
+
+    let dashCount;
     //>>includeEnd('debug');
-    year = +tokens[1];
-    month = +tokens[2];
-    day = +tokens[3];
-  } else {
-    tokens = date.match(matchCalendarMonth);
+
+    //First match the date against possible regular expressions.
+    tokens = date.match(matchCalendarDate);
     if (tokens !== null) {
+      //>>includeStart('debug', pragmas.debug);
+      dashCount = date.split("-").length - 1;
+      if (dashCount > 0 && dashCount !== 2) {
+        throw new DeveloperError(iso8601ErrorMessage);
+      }
+      //>>includeEnd('debug');
       year = +tokens[1];
       month = +tokens[2];
+      day = +tokens[3];
     } else {
-      tokens = date.match(matchCalendarYear);
+      tokens = date.match(matchCalendarMonth);
       if (tokens !== null) {
         year = +tokens[1];
+        month = +tokens[2];
       } else {
-        //Not a year/month/day so it must be an ordinal date.
-        let dayOfYear;
-        tokens = date.match(matchOrdinalDate);
+        tokens = date.match(matchCalendarYear);
         if (tokens !== null) {
           year = +tokens[1];
-          dayOfYear = +tokens[2];
-          inLeapYear = isLeapYear(year);
-
-          //This validation is only applicable for this format.
-          //>>includeStart('debug', pragmas.debug);
-          if (
-            dayOfYear < 1 ||
-            (inLeapYear && dayOfYear > 366) ||
-            (!inLeapYear && dayOfYear > 365)
-          ) {
-            throw new DeveloperError(iso8601ErrorMessage);
-          }
-          //>>includeEnd('debug');
         } else {
-          tokens = date.match(matchWeekDate);
+          //Not a year/month/day so it must be an ordinal date.
+          let dayOfYear;
+          tokens = date.match(matchOrdinalDate);
           if (tokens !== null) {
-            //ISO week date to ordinal date from
-            //http://en.wikipedia.org/w/index.php?title=ISO_week_date&oldid=474176775
             year = +tokens[1];
-            const weekNumber = +tokens[2];
-            const dayOfWeek = +tokens[3] || 0;
+            dayOfYear = +tokens[2];
+            inLeapYear = isLeapYear(year);
 
+            //This validation is only applicable for this format.
             //>>includeStart('debug', pragmas.debug);
-            dashCount = date.split("-").length - 1;
             if (
-              dashCount > 0 &&
-              ((!defined(tokens[3]) && dashCount !== 1) ||
-                (defined(tokens[3]) && dashCount !== 2))
+              dayOfYear < 1 ||
+              (inLeapYear && dayOfYear > 366) ||
+              (!inLeapYear && dayOfYear > 365)
             ) {
               throw new DeveloperError(iso8601ErrorMessage);
             }
             //>>includeEnd('debug');
-
-            const january4 = new Date(Date.UTC(year, 0, 4));
-            dayOfYear = weekNumber * 7 + dayOfWeek - january4.getUTCDay() - 3;
           } else {
-            //None of our regular expressions succeeded in parsing the date properly.
-            //>>includeStart('debug', pragmas.debug);
-            throw new DeveloperError(iso8601ErrorMessage);
-            //>>includeEnd('debug');
+            tokens = date.match(matchWeekDate);
+            if (tokens !== null) {
+              //ISO week date to ordinal date from
+              //http://en.wikipedia.org/w/index.php?title=ISO_week_date&oldid=474176775
+              year = +tokens[1];
+              const weekNumber = +tokens[2];
+              const dayOfWeek = +tokens[3] || 0;
+
+              //>>includeStart('debug', pragmas.debug);
+              dashCount = date.split("-").length - 1;
+              if (
+                dashCount > 0 &&
+                ((!defined(tokens[3]) && dashCount !== 1) ||
+                  (defined(tokens[3]) && dashCount !== 2))
+              ) {
+                throw new DeveloperError(iso8601ErrorMessage);
+              }
+              //>>includeEnd('debug');
+
+              const january4 = new Date(Date.UTC(year, 0, 4));
+              dayOfYear = weekNumber * 7 + dayOfWeek - january4.getUTCDay() - 3;
+            } else {
+              //None of our regular expressions succeeded in parsing the date properly.
+              //>>includeStart('debug', pragmas.debug);
+              throw new DeveloperError(iso8601ErrorMessage);
+              //>>includeEnd('debug');
+            }
           }
+          //Split an ordinal date into month/day.
+          tmp = new Date(Date.UTC(year, 0, 1));
+          tmp.setUTCDate(dayOfYear);
+          month = tmp.getUTCMonth() + 1;
+          day = tmp.getUTCDate();
         }
-        //Split an ordinal date into month/day.
-        tmp = new Date(Date.UTC(year, 0, 1));
-        tmp.setUTCDate(dayOfYear);
-        month = tmp.getUTCMonth() + 1;
-        day = tmp.getUTCDate();
       }
     }
-  }
-
-  //Now that we have all of the date components, validate them to make sure nothing is out of range.
-  inLeapYear = isLeapYear(year);
-  //>>includeStart('debug', pragmas.debug);
-  if (
-    month < 1 ||
-    month > 12 ||
-    day < 1 ||
-    ((month !== 2 || !inLeapYear) && day > daysInMonth[month - 1]) ||
-    (inLeapYear && month === 2 && day > daysInLeapFebruary)
-  ) {
-    throw new DeveloperError(iso8601ErrorMessage);
-  }
-  //>>includeEnd('debug');
 
-  //Now move onto the time string, which is much simpler.
-  //If no time is specified, it is considered the beginning of the day, UTC to match Javascript's implementation.
-  let offsetIndex;
-  if (defined(time)) {
-    tokens = time.match(matchHoursMinutesSeconds);
-    if (tokens !== null) {
-      //>>includeStart('debug', pragmas.debug);
-      dashCount = time.split(":").length - 1;
-      if (dashCount > 0 && dashCount !== 2 && dashCount !== 3) {
-        throw new DeveloperError(iso8601ErrorMessage);
-      }
-      //>>includeEnd('debug');
+    //Now that we have all of the date components, validate them to make sure nothing is out of range.
+    inLeapYear = isLeapYear(year);
+    //>>includeStart('debug', pragmas.debug);
+    if (
+      month < 1 ||
+      month > 12 ||
+      day < 1 ||
+      ((month !== 2 || !inLeapYear) && day > daysInMonth[month - 1]) ||
+      (inLeapYear && month === 2 && day > daysInLeapFebruary)
+    ) {
+      throw new DeveloperError(iso8601ErrorMessage);
+    }
+    //>>includeEnd('debug');
 
-      hour = +tokens[1];
-      minute = +tokens[2];
-      second = +tokens[3];
-      millisecond = +(tokens[4] || 0) * 1000.0;
-      offsetIndex = 5;
-    } else {
-      tokens = time.match(matchHoursMinutes);
+    //Now move onto the time string, which is much simpler.
+    //If no time is specified, it is considered the beginning of the day, UTC to match Javascript's implementation.
+    let offsetIndex;
+    if (defined(time)) {
+      tokens = time.match(matchHoursMinutesSeconds);
       if (tokens !== null) {
         //>>includeStart('debug', pragmas.debug);
         dashCount = time.split(":").length - 1;
-        if (dashCount > 2) {
+        if (dashCount > 0 && dashCount !== 2 && dashCount !== 3) {
           throw new DeveloperError(iso8601ErrorMessage);
         }
         //>>includeEnd('debug');
 
         hour = +tokens[1];
         minute = +tokens[2];
-        second = +(tokens[3] || 0) * 60.0;
-        offsetIndex = 4;
+        second = +tokens[3];
+        millisecond = +(tokens[4] || 0) * 1000.0;
+        offsetIndex = 5;
       } else {
-        tokens = time.match(matchHours);
+        tokens = time.match(matchHoursMinutes);
         if (tokens !== null) {
-          hour = +tokens[1];
-          minute = +(tokens[2] || 0) * 60.0;
-          offsetIndex = 3;
-        } else {
           //>>includeStart('debug', pragmas.debug);
-          throw new DeveloperError(iso8601ErrorMessage);
+          dashCount = time.split(":").length - 1;
+          if (dashCount > 2) {
+            throw new DeveloperError(iso8601ErrorMessage);
+          }
           //>>includeEnd('debug');
+
+          hour = +tokens[1];
+          minute = +tokens[2];
+          second = +(tokens[3] || 0) * 60.0;
+          offsetIndex = 4;
+        } else {
+          tokens = time.match(matchHours);
+          if (tokens !== null) {
+            hour = +tokens[1];
+            minute = +(tokens[2] || 0) * 60.0;
+            offsetIndex = 3;
+          } else {
+            //>>includeStart('debug', pragmas.debug);
+            throw new DeveloperError(iso8601ErrorMessage);
+            //>>includeEnd('debug');
+          }
         }
       }
-    }
 
-    //Validate that all values are in proper range.  Minutes and hours have special cases at 60 and 24.
-    //>>includeStart('debug', pragmas.debug);
-    if (
-      minute >= 60 ||
-      second >= 61 ||
-      hour > 24 ||
-      (hour === 24 && (minute > 0 || second > 0 || millisecond > 0))
-    ) {
-      throw new DeveloperError(iso8601ErrorMessage);
+      //Validate that all values are in proper range.  Minutes and hours have special cases at 60 and 24.
+      //>>includeStart('debug', pragmas.debug);
+      if (
+        minute >= 60 ||
+        second >= 61 ||
+        hour > 24 ||
+        (hour === 24 && (minute > 0 || second > 0 || millisecond > 0))
+      ) {
+        throw new DeveloperError(iso8601ErrorMessage);
+      }
+      //>>includeEnd('debug');
+
+      //Check the UTC offset value, if no value exists, use local time
+      //a Z indicates UTC, + or - are offsets.
+      const offset = tokens[offsetIndex];
+      const offsetHours = +tokens[offsetIndex + 1];
+      const offsetMinutes = +(tokens[offsetIndex + 2] || 0);
+      switch (offset) {
+        case "+":
+          hour = hour - offsetHours;
+          minute = minute - offsetMinutes;
+          break;
+        case "-":
+          hour = hour + offsetHours;
+          minute = minute + offsetMinutes;
+          break;
+        case "Z":
+          break;
+        default:
+          minute =
+            minute +
+            new Date(
+              Date.UTC(year, month - 1, day, hour, minute),
+            ).getTimezoneOffset();
+          break;
+      }
     }
-    //>>includeEnd('debug');
 
-    //Check the UTC offset value, if no value exists, use local time
-    //a Z indicates UTC, + or - are offsets.
-    const offset = tokens[offsetIndex];
-    const offsetHours = +tokens[offsetIndex + 1];
-    const offsetMinutes = +(tokens[offsetIndex + 2] || 0);
-    switch (offset) {
-      case "+":
-        hour = hour - offsetHours;
-        minute = minute - offsetMinutes;
-        break;
-      case "-":
-        hour = hour + offsetHours;
-        minute = minute + offsetMinutes;
-        break;
-      case "Z":
-        break;
-      default:
-        minute =
-          minute +
-          new Date(
-            Date.UTC(year, month - 1, day, hour, minute),
-          ).getTimezoneOffset();
-        break;
+    //ISO8601 denotes a leap second by any time having a seconds component of 60 seconds.
+    //If that's the case, we need to temporarily subtract a second in order to build a UTC date.
+    //Then we add it back in after converting to TAI.
+    const isLeapSecond = second === 60;
+    if (isLeapSecond) {
+      second--;
     }
-  }
 
-  //ISO8601 denotes a leap second by any time having a seconds component of 60 seconds.
-  //If that's the case, we need to temporarily subtract a second in order to build a UTC date.
-  //Then we add it back in after converting to TAI.
-  const isLeapSecond = second === 60;
-  if (isLeapSecond) {
-    second--;
-  }
+    //Even if we successfully parsed the string into its components, after applying UTC offset or
+    //special cases like 24:00:00 denoting midnight, we need to normalize the data appropriately.
 
-  //Even if we successfully parsed the string into its components, after applying UTC offset or
-  //special cases like 24:00:00 denoting midnight, we need to normalize the data appropriately.
+    //milliseconds can never be greater than 1000, and seconds can't be above 60, so we start with minutes
+    while (minute >= 60) {
+      minute -= 60;
+      hour++;
+    }
 
-  //milliseconds can never be greater than 1000, and seconds can't be above 60, so we start with minutes
-  while (minute >= 60) {
-    minute -= 60;
-    hour++;
-  }
+    while (hour >= 24) {
+      hour -= 24;
+      day++;
+    }
 
-  while (hour >= 24) {
-    hour -= 24;
-    day++;
-  }
+    tmp =
+      inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
+    while (day > tmp) {
+      day -= tmp;
+      month++;
 
-  tmp = inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
-  while (day > tmp) {
-    day -= tmp;
-    month++;
+      if (month > 12) {
+        month -= 12;
+        year++;
+      }
 
-    if (month > 12) {
-      month -= 12;
-      year++;
+      tmp =
+        inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
     }
 
-    tmp =
-      inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
-  }
+    //If UTC offset is at the beginning/end of the day, minutes can be negative.
+    while (minute < 0) {
+      minute += 60;
+      hour--;
+    }
 
-  //If UTC offset is at the beginning/end of the day, minutes can be negative.
-  while (minute < 0) {
-    minute += 60;
-    hour--;
-  }
+    while (hour < 0) {
+      hour += 24;
+      day--;
+    }
 
-  while (hour < 0) {
-    hour += 24;
-    day--;
-  }
+    while (day < 1) {
+      month--;
+      if (month < 1) {
+        month += 12;
+        year--;
+      }
 
-  while (day < 1) {
-    month--;
-    if (month < 1) {
-      month += 12;
-      year--;
+      tmp =
+        inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
+      day += tmp;
     }
 
-    tmp =
-      inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
-    day += tmp;
-  }
+    //Now create the JulianDate components from the Gregorian date and actually create our instance.
+    const components = computeJulianDateComponents(
+      year,
+      month,
+      day,
+      hour,
+      minute,
+      second,
+      millisecond,
+    );
 
-  //Now create the JulianDate components from the Gregorian date and actually create our instance.
-  const components = computeJulianDateComponents(
-    year,
-    month,
-    day,
-    hour,
-    minute,
-    second,
-    millisecond,
-  );
+    if (!defined(result)) {
+      result = new JulianDate(components[0], components[1], TimeStandard.UTC);
+    } else {
+      setComponents(components[0], components[1], result);
+      convertUtcToTai(result);
+    }
 
-  if (!defined(result)) {
-    result = new JulianDate(components[0], components[1], TimeStandard.UTC);
-  } else {
-    setComponents(components[0], components[1], result);
-    convertUtcToTai(result);
+    //If we were on a leap second, add it back.
+    if (isLeapSecond) {
+      JulianDate.addSeconds(result, 1, result);
+    }
+
+    return result;
   }
 
-  //If we were on a leap second, add it back.
-  if (isLeapSecond) {
-    JulianDate.addSeconds(result, 1, result);
+  /**
+   * Creates a new instance that represents the current system time.
+   * This is equivalent to calling <code>JulianDate.fromDate(new Date());</code>.
+   *
+   * @param {JulianDate} [result] An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
+   */
+  static now(result) {
+    return JulianDate.fromDate(new Date(), result);
   }
 
-  return result;
-};
+  /**
+   * Creates a {@link GregorianDate} from the provided instance.
+   *
+   * @param {JulianDate} julianDate The date to be converted.
+   * @param {GregorianDate} [result] An existing instance to use for the result.
+   * @returns {GregorianDate} The modified result parameter or a new instance if none was provided.
+   */
+  static toGregorianDate(julianDate, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(julianDate)) {
+      throw new DeveloperError("julianDate is required.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Creates a new instance that represents the current system time.
- * This is equivalent to calling <code>JulianDate.fromDate(new Date());</code>.
- *
- * @param {JulianDate} [result] An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
- */
-JulianDate.now = function (result) {
-  return JulianDate.fromDate(new Date(), result);
-};
+    let isLeapSecond = false;
+    let thisUtc = convertTaiToUtc(julianDate, toGregorianDateScratch);
+    if (!defined(thisUtc)) {
+      //Conversion to UTC will fail if we are during a leap second.
+      //If that's the case, subtract a second and convert again.
+      //JavaScript doesn't support leap seconds, so this results in second 59 being repeated twice.
+      JulianDate.addSeconds(julianDate, -1, toGregorianDateScratch);
+      thisUtc = convertTaiToUtc(toGregorianDateScratch, toGregorianDateScratch);
+      isLeapSecond = true;
+    }
 
-const toGregorianDateScratch = new JulianDate(0, 0, TimeStandard.TAI);
+    let julianDayNumber = thisUtc.dayNumber;
+    const secondsOfDay = thisUtc.secondsOfDay;
 
-/**
- * Creates a {@link GregorianDate} from the provided instance.
- *
- * @param {JulianDate} julianDate The date to be converted.
- * @param {GregorianDate} [result] An existing instance to use for the result.
- * @returns {GregorianDate} The modified result parameter or a new instance if none was provided.
- */
-JulianDate.toGregorianDate = function (julianDate, result) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(julianDate)) {
-    throw new DeveloperError("julianDate is required.");
-  }
-  //>>includeEnd('debug');
-
-  let isLeapSecond = false;
-  let thisUtc = convertTaiToUtc(julianDate, toGregorianDateScratch);
-  if (!defined(thisUtc)) {
-    //Conversion to UTC will fail if we are during a leap second.
-    //If that's the case, subtract a second and convert again.
-    //JavaScript doesn't support leap seconds, so this results in second 59 being repeated twice.
-    JulianDate.addSeconds(julianDate, -1, toGregorianDateScratch);
-    thisUtc = convertTaiToUtc(toGregorianDateScratch, toGregorianDateScratch);
-    isLeapSecond = true;
-  }
+    if (secondsOfDay >= 43200.0) {
+      julianDayNumber += 1;
+    }
 
-  let julianDayNumber = thisUtc.dayNumber;
-  const secondsOfDay = thisUtc.secondsOfDay;
+    // Algorithm from page 604 of the Explanatory Supplement to the
+    // Astronomical Almanac (Seidelmann 1992).
+    let L = (julianDayNumber + 68569) | 0;
+    const N = ((4 * L) / 146097) | 0;
+    L = (L - (((146097 * N + 3) / 4) | 0)) | 0;
+    const I = ((4000 * (L + 1)) / 1461001) | 0;
+    L = (L - (((1461 * I) / 4) | 0) + 31) | 0;
+    const J = ((80 * L) / 2447) | 0;
+    const day = (L - (((2447 * J) / 80) | 0)) | 0;
+    L = (J / 11) | 0;
+    const month = (J + 2 - 12 * L) | 0;
+    const year = (100 * (N - 49) + I + L) | 0;
+
+    let hour = (secondsOfDay / TimeConstants.SECONDS_PER_HOUR) | 0;
+    let remainingSeconds = secondsOfDay - hour * TimeConstants.SECONDS_PER_HOUR;
+    const minute = (remainingSeconds / TimeConstants.SECONDS_PER_MINUTE) | 0;
+    remainingSeconds =
+      remainingSeconds - minute * TimeConstants.SECONDS_PER_MINUTE;
+    let second = remainingSeconds | 0;
+    const millisecond =
+      (remainingSeconds - second) / TimeConstants.SECONDS_PER_MILLISECOND;
+
+    // JulianDates are noon-based
+    hour += 12;
+    if (hour > 23) {
+      hour -= 24;
+    }
 
-  if (secondsOfDay >= 43200.0) {
-    julianDayNumber += 1;
-  }
+    //If we were on a leap second, add it back.
+    if (isLeapSecond) {
+      second += 1;
+    }
 
-  // Algorithm from page 604 of the Explanatory Supplement to the
-  // Astronomical Almanac (Seidelmann 1992).
-  let L = (julianDayNumber + 68569) | 0;
-  const N = ((4 * L) / 146097) | 0;
-  L = (L - (((146097 * N + 3) / 4) | 0)) | 0;
-  const I = ((4000 * (L + 1)) / 1461001) | 0;
-  L = (L - (((1461 * I) / 4) | 0) + 31) | 0;
-  const J = ((80 * L) / 2447) | 0;
-  const day = (L - (((2447 * J) / 80) | 0)) | 0;
-  L = (J / 11) | 0;
-  const month = (J + 2 - 12 * L) | 0;
-  const year = (100 * (N - 49) + I + L) | 0;
-
-  let hour = (secondsOfDay / TimeConstants.SECONDS_PER_HOUR) | 0;
-  let remainingSeconds = secondsOfDay - hour * TimeConstants.SECONDS_PER_HOUR;
-  const minute = (remainingSeconds / TimeConstants.SECONDS_PER_MINUTE) | 0;
-  remainingSeconds =
-    remainingSeconds - minute * TimeConstants.SECONDS_PER_MINUTE;
-  let second = remainingSeconds | 0;
-  const millisecond =
-    (remainingSeconds - second) / TimeConstants.SECONDS_PER_MILLISECOND;
+    if (!defined(result)) {
+      return new GregorianDate(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        millisecond,
+        isLeapSecond,
+      );
+    }
 
-  // JulianDates are noon-based
-  hour += 12;
-  if (hour > 23) {
-    hour -= 24;
+    result.year = year;
+    result.month = month;
+    result.day = day;
+    result.hour = hour;
+    result.minute = minute;
+    result.second = second;
+    result.millisecond = millisecond;
+    result.isLeapSecond = isLeapSecond;
+    return result;
   }
 
-  //If we were on a leap second, add it back.
-  if (isLeapSecond) {
-    second += 1;
-  }
+  /**
+   * Creates a JavaScript Date from the provided instance.
+   * Since JavaScript dates are only accurate to the nearest millisecond and
+   * cannot represent a leap second, consider using {@link JulianDate.toGregorianDate} instead.
+   * If the provided JulianDate is during a leap second, the previous second is used.
+   *
+   * @param {JulianDate} julianDate The date to be converted.
+   * @returns {Date} A new instance representing the provided date.
+   */
+  static toDate(julianDate) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(julianDate)) {
+      throw new DeveloperError("julianDate is required.");
+    }
+    //>>includeEnd('debug');
 
-  if (!defined(result)) {
-    return new GregorianDate(
-      year,
-      month,
-      day,
-      hour,
-      minute,
-      second,
-      millisecond,
-      isLeapSecond,
+    const gDate = JulianDate.toGregorianDate(julianDate, gregorianDateScratch);
+    let second = gDate.second;
+    if (gDate.isLeapSecond) {
+      second -= 1;
+    }
+    return new Date(
+      Date.UTC(
+        gDate.year,
+        gDate.month - 1,
+        gDate.day,
+        gDate.hour,
+        gDate.minute,
+        second,
+        gDate.millisecond,
+      ),
     );
   }
 
-  result.year = year;
-  result.month = month;
-  result.day = day;
-  result.hour = hour;
-  result.minute = minute;
-  result.second = second;
-  result.millisecond = millisecond;
-  result.isLeapSecond = isLeapSecond;
-  return result;
-};
+  /**
+   * Creates an ISO8601 representation of the provided date.
+   *
+   * @param {JulianDate} julianDate The date to be converted.
+   * @param {number} [precision] The number of fractional digits used to represent the seconds component.  By default, the most precise representation is used.
+   * @returns {string} The ISO8601 representation of the provided date.
+   */
+  static toIso8601(julianDate, precision) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(julianDate)) {
+      throw new DeveloperError("julianDate is required.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Creates a JavaScript Date from the provided instance.
- * Since JavaScript dates are only accurate to the nearest millisecond and
- * cannot represent a leap second, consider using {@link JulianDate.toGregorianDate} instead.
- * If the provided JulianDate is during a leap second, the previous second is used.
- *
- * @param {JulianDate} julianDate The date to be converted.
- * @returns {Date} A new instance representing the provided date.
- */
-JulianDate.toDate = function (julianDate) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(julianDate)) {
-    throw new DeveloperError("julianDate is required.");
-  }
-  //>>includeEnd('debug');
+    const gDate = JulianDate.toGregorianDate(julianDate, gregorianDateScratch);
+    let year = gDate.year;
+    let month = gDate.month;
+    let day = gDate.day;
+    let hour = gDate.hour;
+    const minute = gDate.minute;
+    const second = gDate.second;
+    const millisecond = gDate.millisecond;
+
+    // special case - Iso8601.MAXIMUM_VALUE produces a string which we can't parse unless we adjust.
+    // 10000-01-01T00:00:00 is the same instant as 9999-12-31T24:00:00
+    if (
+      year === 10000 &&
+      month === 1 &&
+      day === 1 &&
+      hour === 0 &&
+      minute === 0 &&
+      second === 0 &&
+      millisecond === 0
+    ) {
+      year = 9999;
+      month = 12;
+      day = 31;
+      hour = 24;
+    }
 
-  const gDate = JulianDate.toGregorianDate(julianDate, gregorianDateScratch);
-  let second = gDate.second;
-  if (gDate.isLeapSecond) {
-    second -= 1;
-  }
-  return new Date(
-    Date.UTC(
-      gDate.year,
-      gDate.month - 1,
-      gDate.day,
-      gDate.hour,
-      gDate.minute,
-      second,
-      gDate.millisecond,
-    ),
-  );
-};
+    let millisecondStr;
+
+    if (!defined(precision) && millisecond !== 0) {
+      // Forces milliseconds into a number with at least 3 digits.
+      const millisecondHundreds = millisecond * 0.01;
+      // Below 1e-6, toString returns scientific notation, so it should be replaced by toFixed with appropriate number of digits.
+      // 20 digits is a trade-off choice guided by JavaScript's Number representation accuracy (15-17 decimal digits for most numbers).
+      // Using toFixed(20) ensures capturing enough precision while avoiding inaccuracies due to floating-point limitations.
+      millisecondStr =
+        millisecondHundreds < 1e-6
+          ? millisecondHundreds.toFixed(20).replace(".", "").replace(/0+$/, "")
+          : millisecondHundreds.toString().replace(".", "");
+      return `${year.toString().padStart(4, "0")}-${month
+        .toString()
+        .padStart(2, "0")}-${day.toString().padStart(2, "0")}T${hour
+        .toString()
+        .padStart(2, "0")}:${minute.toString().padStart(2, "0")}:${second
+        .toString()
+        .padStart(2, "0")}.${millisecondStr}Z`;
+    }
 
-/**
- * Creates an ISO8601 representation of the provided date.
- *
- * @param {JulianDate} julianDate The date to be converted.
- * @param {number} [precision] The number of fractional digits used to represent the seconds component.  By default, the most precise representation is used.
- * @returns {string} The ISO8601 representation of the provided date.
- */
-JulianDate.toIso8601 = function (julianDate, precision) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(julianDate)) {
-    throw new DeveloperError("julianDate is required.");
-  }
-  //>>includeEnd('debug');
-
-  const gDate = JulianDate.toGregorianDate(julianDate, gregorianDateScratch);
-  let year = gDate.year;
-  let month = gDate.month;
-  let day = gDate.day;
-  let hour = gDate.hour;
-  const minute = gDate.minute;
-  const second = gDate.second;
-  const millisecond = gDate.millisecond;
-
-  // special case - Iso8601.MAXIMUM_VALUE produces a string which we can't parse unless we adjust.
-  // 10000-01-01T00:00:00 is the same instant as 9999-12-31T24:00:00
-  if (
-    year === 10000 &&
-    month === 1 &&
-    day === 1 &&
-    hour === 0 &&
-    minute === 0 &&
-    second === 0 &&
-    millisecond === 0
-  ) {
-    year = 9999;
-    month = 12;
-    day = 31;
-    hour = 24;
-  }
+    //Precision is either 0 or milliseconds is 0 with undefined precision, in either case, leave off milliseconds entirely
+    if (!defined(precision) || precision === 0) {
+      return `${year.toString().padStart(4, "0")}-${month
+        .toString()
+        .padStart(2, "0")}-${day.toString().padStart(2, "0")}T${hour
+        .toString()
+        .padStart(2, "0")}:${minute
+        .toString()
+        .padStart(2, "0")}:${second.toString().padStart(2, "0")}Z`;
+    }
 
-  let millisecondStr;
-
-  if (!defined(precision) && millisecond !== 0) {
-    // Forces milliseconds into a number with at least 3 digits.
-    const millisecondHundreds = millisecond * 0.01;
-    // Below 1e-6, toString returns scientific notation, so it should be replaced by toFixed with appropriate number of digits.
-    // 20 digits is a trade-off choice guided by JavaScript's Number representation accuracy (15-17 decimal digits for most numbers).
-    // Using toFixed(20) ensures capturing enough precision while avoiding inaccuracies due to floating-point limitations.
-    millisecondStr =
-      millisecondHundreds < 1e-6
-        ? millisecondHundreds.toFixed(20).replace(".", "").replace(/0+$/, "")
-        : millisecondHundreds.toString().replace(".", "");
+    //Forces milliseconds into a number with at least 3 digits to whatever the specified precision is.
+    millisecondStr = (millisecond * 0.01)
+      .toFixed(precision)
+      .replace(".", "")
+      .slice(0, precision);
     return `${year.toString().padStart(4, "0")}-${month
       .toString()
       .padStart(2, "0")}-${day.toString().padStart(2, "0")}T${hour
@@ -801,395 +825,373 @@ JulianDate.toIso8601 = function (julianDate, precision) {
       .padStart(2, "0")}.${millisecondStr}Z`;
   }
 
-  //Precision is either 0 or milliseconds is 0 with undefined precision, in either case, leave off milliseconds entirely
-  if (!defined(precision) || precision === 0) {
-    return `${year.toString().padStart(4, "0")}-${month
-      .toString()
-      .padStart(2, "0")}-${day.toString().padStart(2, "0")}T${hour
-      .toString()
-      .padStart(2, "0")}:${minute
-      .toString()
-      .padStart(2, "0")}:${second.toString().padStart(2, "0")}Z`;
+  /**
+   * Duplicates a JulianDate instance.
+   *
+   * @param {JulianDate} julianDate The date to duplicate.
+   * @param {JulianDate} [result] An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter or a new instance if none was provided. Returns undefined if julianDate is undefined.
+   */
+  static clone(julianDate, result) {
+    if (!defined(julianDate)) {
+      return undefined;
+    }
+    if (!defined(result)) {
+      return new JulianDate(
+        julianDate.dayNumber,
+        julianDate.secondsOfDay,
+        TimeStandard.TAI,
+      );
+    }
+    result.dayNumber = julianDate.dayNumber;
+    result.secondsOfDay = julianDate.secondsOfDay;
+    return result;
   }
 
-  //Forces milliseconds into a number with at least 3 digits to whatever the specified precision is.
-  millisecondStr = (millisecond * 0.01)
-    .toFixed(precision)
-    .replace(".", "")
-    .slice(0, precision);
-  return `${year.toString().padStart(4, "0")}-${month
-    .toString()
-    .padStart(2, "0")}-${day.toString().padStart(2, "0")}T${hour
-    .toString()
-    .padStart(2, "0")}:${minute.toString().padStart(2, "0")}:${second
-    .toString()
-    .padStart(2, "0")}.${millisecondStr}Z`;
-};
+  /**
+   * Compares two instances.
+   *
+   * @param {JulianDate} left The first instance.
+   * @param {JulianDate} right The second instance.
+   * @returns {number} A negative value if left is less than right, a positive value if left is greater than right, or zero if left and right are equal.
+   */
+  static compare(left, right) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(left)) {
+      throw new DeveloperError("left is required.");
+    }
+    if (!defined(right)) {
+      throw new DeveloperError("right is required.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Duplicates a JulianDate instance.
- *
- * @param {JulianDate} julianDate The date to duplicate.
- * @param {JulianDate} [result] An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter or a new instance if none was provided. Returns undefined if julianDate is undefined.
- */
-JulianDate.clone = function (julianDate, result) {
-  if (!defined(julianDate)) {
-    return undefined;
+    const julianDayNumberDifference = left.dayNumber - right.dayNumber;
+    if (julianDayNumberDifference !== 0) {
+      return julianDayNumberDifference;
+    }
+    return left.secondsOfDay - right.secondsOfDay;
   }
-  if (!defined(result)) {
-    return new JulianDate(
-      julianDate.dayNumber,
-      julianDate.secondsOfDay,
-      TimeStandard.TAI,
+
+  /**
+   * Compares two instances and returns <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {JulianDate} [left] The first instance.
+   * @param {JulianDate} [right] The second instance.
+   * @returns {boolean} <code>true</code> if the dates are equal; otherwise, <code>false</code>.
+   */
+  static equals(left, right) {
+    return (
+      left === right ||
+      (defined(left) &&
+        defined(right) &&
+        left.dayNumber === right.dayNumber &&
+        left.secondsOfDay === right.secondsOfDay)
     );
   }
-  result.dayNumber = julianDate.dayNumber;
-  result.secondsOfDay = julianDate.secondsOfDay;
-  return result;
-};
 
-/**
- * Compares two instances.
- *
- * @param {JulianDate} left The first instance.
- * @param {JulianDate} right The second instance.
- * @returns {number} A negative value if left is less than right, a positive value if left is greater than right, or zero if left and right are equal.
- */
-JulianDate.compare = function (left, right) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(left)) {
-    throw new DeveloperError("left is required.");
-  }
-  if (!defined(right)) {
-    throw new DeveloperError("right is required.");
+  /**
+   * Compares two instances and returns <code>true</code> if they are within <code>epsilon</code> seconds of
+   * each other.  That is, in order for the dates to be considered equal (and for
+   * this function to return <code>true</code>), the absolute value of the difference between them, in
+   * seconds, must be less than <code>epsilon</code>.
+   *
+   * @param {JulianDate} [left] The first instance.
+   * @param {JulianDate} [right] The second instance.
+   * @param {number} [epsilon=0] The maximum number of seconds that should separate the two instances.
+   * @returns {boolean} <code>true</code> if the two dates are within <code>epsilon</code> seconds of each other; otherwise <code>false</code>.
+   */
+  static equalsEpsilon(left, right, epsilon) {
+    epsilon = epsilon ?? 0;
+
+    return (
+      left === right ||
+      (defined(left) &&
+        defined(right) &&
+        Math.abs(JulianDate.secondsDifference(left, right)) <= epsilon)
+    );
   }
-  //>>includeEnd('debug');
 
-  const julianDayNumberDifference = left.dayNumber - right.dayNumber;
-  if (julianDayNumberDifference !== 0) {
-    return julianDayNumberDifference;
+  /**
+   * Computes the total number of whole and fractional days represented by the provided instance.
+   *
+   * @param {JulianDate} julianDate The date.
+   * @returns {number} The Julian date as single floating point number.
+   */
+  static totalDays(julianDate) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(julianDate)) {
+      throw new DeveloperError("julianDate is required.");
+    }
+    //>>includeEnd('debug');
+    return (
+      julianDate.dayNumber +
+      julianDate.secondsOfDay / TimeConstants.SECONDS_PER_DAY
+    );
   }
-  return left.secondsOfDay - right.secondsOfDay;
-};
-
-/**
- * Compares two instances and returns <code>true</code> if they are equal, <code>false</code> otherwise.
- *
- * @param {JulianDate} [left] The first instance.
- * @param {JulianDate} [right] The second instance.
- * @returns {boolean} <code>true</code> if the dates are equal; otherwise, <code>false</code>.
- */
-JulianDate.equals = function (left, right) {
-  return (
-    left === right ||
-    (defined(left) &&
-      defined(right) &&
-      left.dayNumber === right.dayNumber &&
-      left.secondsOfDay === right.secondsOfDay)
-  );
-};
-
-/**
- * Compares two instances and returns <code>true</code> if they are within <code>epsilon</code> seconds of
- * each other.  That is, in order for the dates to be considered equal (and for
- * this function to return <code>true</code>), the absolute value of the difference between them, in
- * seconds, must be less than <code>epsilon</code>.
- *
- * @param {JulianDate} [left] The first instance.
- * @param {JulianDate} [right] The second instance.
- * @param {number} [epsilon=0] The maximum number of seconds that should separate the two instances.
- * @returns {boolean} <code>true</code> if the two dates are within <code>epsilon</code> seconds of each other; otherwise <code>false</code>.
- */
-JulianDate.equalsEpsilon = function (left, right, epsilon) {
-  epsilon = epsilon ?? 0;
-
-  return (
-    left === right ||
-    (defined(left) &&
-      defined(right) &&
-      Math.abs(JulianDate.secondsDifference(left, right)) <= epsilon)
-  );
-};
 
-/**
- * Computes the total number of whole and fractional days represented by the provided instance.
- *
- * @param {JulianDate} julianDate The date.
- * @returns {number} The Julian date as single floating point number.
- */
-JulianDate.totalDays = function (julianDate) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(julianDate)) {
-    throw new DeveloperError("julianDate is required.");
-  }
-  //>>includeEnd('debug');
-  return (
-    julianDate.dayNumber +
-    julianDate.secondsOfDay / TimeConstants.SECONDS_PER_DAY
-  );
-};
+  /**
+   * Computes the difference in seconds between the provided instance.
+   *
+   * @param {JulianDate} left The first instance.
+   * @param {JulianDate} right The second instance.
+   * @returns {number} The difference, in seconds, when subtracting <code>right</code> from <code>left</code>.
+   */
+  static secondsDifference(left, right) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(left)) {
+      throw new DeveloperError("left is required.");
+    }
+    if (!defined(right)) {
+      throw new DeveloperError("right is required.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Computes the difference in seconds between the provided instance.
- *
- * @param {JulianDate} left The first instance.
- * @param {JulianDate} right The second instance.
- * @returns {number} The difference, in seconds, when subtracting <code>right</code> from <code>left</code>.
- */
-JulianDate.secondsDifference = function (left, right) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(left)) {
-    throw new DeveloperError("left is required.");
-  }
-  if (!defined(right)) {
-    throw new DeveloperError("right is required.");
+    const dayDifference =
+      (left.dayNumber - right.dayNumber) * TimeConstants.SECONDS_PER_DAY;
+    return dayDifference + (left.secondsOfDay - right.secondsOfDay);
   }
-  //>>includeEnd('debug');
 
-  const dayDifference =
-    (left.dayNumber - right.dayNumber) * TimeConstants.SECONDS_PER_DAY;
-  return dayDifference + (left.secondsOfDay - right.secondsOfDay);
-};
+  /**
+   * Computes the difference in days between the provided instance.
+   *
+   * @param {JulianDate} left The first instance.
+   * @param {JulianDate} right The second instance.
+   * @returns {number} The difference, in days, when subtracting <code>right</code> from <code>left</code>.
+   */
+  static daysDifference(left, right) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(left)) {
+      throw new DeveloperError("left is required.");
+    }
+    if (!defined(right)) {
+      throw new DeveloperError("right is required.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Computes the difference in days between the provided instance.
- *
- * @param {JulianDate} left The first instance.
- * @param {JulianDate} right The second instance.
- * @returns {number} The difference, in days, when subtracting <code>right</code> from <code>left</code>.
- */
-JulianDate.daysDifference = function (left, right) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(left)) {
-    throw new DeveloperError("left is required.");
-  }
-  if (!defined(right)) {
-    throw new DeveloperError("right is required.");
+    const dayDifference = left.dayNumber - right.dayNumber;
+    const secondDifference =
+      (left.secondsOfDay - right.secondsOfDay) / TimeConstants.SECONDS_PER_DAY;
+    return dayDifference + secondDifference;
   }
-  //>>includeEnd('debug');
 
-  const dayDifference = left.dayNumber - right.dayNumber;
-  const secondDifference =
-    (left.secondsOfDay - right.secondsOfDay) / TimeConstants.SECONDS_PER_DAY;
-  return dayDifference + secondDifference;
-};
-
-/**
- * Computes the number of seconds the provided instance is ahead of UTC.
- *
- * @param {JulianDate} julianDate The date.
- * @returns {number} The number of seconds the provided instance is ahead of UTC
- */
-JulianDate.computeTaiMinusUtc = function (julianDate) {
-  binarySearchScratchLeapSecond.julianDate = julianDate;
-  const leapSeconds = JulianDate.leapSeconds;
-  let index = binarySearch(
-    leapSeconds,
-    binarySearchScratchLeapSecond,
-    compareLeapSecondDates,
-  );
-  if (index < 0) {
-    index = ~index;
-    --index;
+  /**
+   * Computes the number of seconds the provided instance is ahead of UTC.
+   *
+   * @param {JulianDate} julianDate The date.
+   * @returns {number} The number of seconds the provided instance is ahead of UTC
+   */
+  static computeTaiMinusUtc(julianDate) {
+    binarySearchScratchLeapSecond.julianDate = julianDate;
+    const leapSeconds = JulianDate.leapSeconds;
+    let index = binarySearch(
+      leapSeconds,
+      binarySearchScratchLeapSecond,
+      compareLeapSecondDates,
+    );
     if (index < 0) {
-      index = 0;
+      index = ~index;
+      --index;
+      if (index < 0) {
+        index = 0;
+      }
     }
+    return leapSeconds[index].offset;
   }
-  return leapSeconds[index].offset;
-};
 
-/**
- * Adds the provided number of seconds to the provided date instance.
- *
- * @param {JulianDate} julianDate The date.
- * @param {number} seconds The number of seconds to add or subtract.
- * @param {JulianDate} result An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter.
- */
-JulianDate.addSeconds = function (julianDate, seconds, result) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(julianDate)) {
-    throw new DeveloperError("julianDate is required.");
-  }
-  if (!defined(seconds)) {
-    throw new DeveloperError("seconds is required.");
-  }
-  if (!defined(result)) {
-    throw new DeveloperError("result is required.");
+  /**
+   * Adds the provided number of seconds to the provided date instance.
+   *
+   * @param {JulianDate} julianDate The date.
+   * @param {number} seconds The number of seconds to add or subtract.
+   * @param {JulianDate} result An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter.
+   */
+  static addSeconds(julianDate, seconds, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(julianDate)) {
+      throw new DeveloperError("julianDate is required.");
+    }
+    if (!defined(seconds)) {
+      throw new DeveloperError("seconds is required.");
+    }
+    if (!defined(result)) {
+      throw new DeveloperError("result is required.");
+    }
+    //>>includeEnd('debug');
+
+    return setComponents(
+      julianDate.dayNumber,
+      julianDate.secondsOfDay + seconds,
+      result,
+    );
   }
-  //>>includeEnd('debug');
 
-  return setComponents(
-    julianDate.dayNumber,
-    julianDate.secondsOfDay + seconds,
-    result,
-  );
-};
+  /**
+   * Adds the provided number of minutes to the provided date instance.
+   *
+   * @param {JulianDate} julianDate The date.
+   * @param {number} minutes The number of minutes to add or subtract.
+   * @param {JulianDate} result An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter.
+   */
+  static addMinutes(julianDate, minutes, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(julianDate)) {
+      throw new DeveloperError("julianDate is required.");
+    }
+    if (!defined(minutes)) {
+      throw new DeveloperError("minutes is required.");
+    }
+    if (!defined(result)) {
+      throw new DeveloperError("result is required.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Adds the provided number of minutes to the provided date instance.
- *
- * @param {JulianDate} julianDate The date.
- * @param {number} minutes The number of minutes to add or subtract.
- * @param {JulianDate} result An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter.
- */
-JulianDate.addMinutes = function (julianDate, minutes, result) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(julianDate)) {
-    throw new DeveloperError("julianDate is required.");
-  }
-  if (!defined(minutes)) {
-    throw new DeveloperError("minutes is required.");
+    const newSecondsOfDay =
+      julianDate.secondsOfDay + minutes * TimeConstants.SECONDS_PER_MINUTE;
+    return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
   }
-  if (!defined(result)) {
-    throw new DeveloperError("result is required.");
-  }
-  //>>includeEnd('debug');
 
-  const newSecondsOfDay =
-    julianDate.secondsOfDay + minutes * TimeConstants.SECONDS_PER_MINUTE;
-  return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
-};
+  /**
+   * Adds the provided number of hours to the provided date instance.
+   *
+   * @param {JulianDate} julianDate The date.
+   * @param {number} hours The number of hours to add or subtract.
+   * @param {JulianDate} result An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter.
+   */
+  static addHours(julianDate, hours, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(julianDate)) {
+      throw new DeveloperError("julianDate is required.");
+    }
+    if (!defined(hours)) {
+      throw new DeveloperError("hours is required.");
+    }
+    if (!defined(result)) {
+      throw new DeveloperError("result is required.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Adds the provided number of hours to the provided date instance.
- *
- * @param {JulianDate} julianDate The date.
- * @param {number} hours The number of hours to add or subtract.
- * @param {JulianDate} result An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter.
- */
-JulianDate.addHours = function (julianDate, hours, result) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(julianDate)) {
-    throw new DeveloperError("julianDate is required.");
-  }
-  if (!defined(hours)) {
-    throw new DeveloperError("hours is required.");
-  }
-  if (!defined(result)) {
-    throw new DeveloperError("result is required.");
+    const newSecondsOfDay =
+      julianDate.secondsOfDay + hours * TimeConstants.SECONDS_PER_HOUR;
+    return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
   }
-  //>>includeEnd('debug');
 
-  const newSecondsOfDay =
-    julianDate.secondsOfDay + hours * TimeConstants.SECONDS_PER_HOUR;
-  return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
-};
+  /**
+   * Adds the provided number of days to the provided date instance.
+   *
+   * @param {JulianDate} julianDate The date.
+   * @param {number} days The number of days to add or subtract.
+   * @param {JulianDate} result An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter.
+   */
+  static addDays(julianDate, days, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(julianDate)) {
+      throw new DeveloperError("julianDate is required.");
+    }
+    if (!defined(days)) {
+      throw new DeveloperError("days is required.");
+    }
+    if (!defined(result)) {
+      throw new DeveloperError("result is required.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Adds the provided number of days to the provided date instance.
- *
- * @param {JulianDate} julianDate The date.
- * @param {number} days The number of days to add or subtract.
- * @param {JulianDate} result An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter.
- */
-JulianDate.addDays = function (julianDate, days, result) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(julianDate)) {
-    throw new DeveloperError("julianDate is required.");
-  }
-  if (!defined(days)) {
-    throw new DeveloperError("days is required.");
-  }
-  if (!defined(result)) {
-    throw new DeveloperError("result is required.");
+    const newJulianDayNumber = julianDate.dayNumber + days;
+    return setComponents(newJulianDayNumber, julianDate.secondsOfDay, result);
   }
-  //>>includeEnd('debug');
 
-  const newJulianDayNumber = julianDate.dayNumber + days;
-  return setComponents(newJulianDayNumber, julianDate.secondsOfDay, result);
-};
+  /**
+   * Compares the provided instances and returns <code>true</code> if <code>left</code> is earlier than <code>right</code>, <code>false</code> otherwise.
+   *
+   * @param {JulianDate} left The first instance.
+   * @param {JulianDate} right The second instance.
+   * @returns {boolean} <code>true</code> if <code>left</code> is earlier than <code>right</code>, <code>false</code> otherwise.
+   */
+  static lessThan(left, right) {
+    return JulianDate.compare(left, right) < 0;
+  }
 
-/**
- * Compares the provided instances and returns <code>true</code> if <code>left</code> is earlier than <code>right</code>, <code>false</code> otherwise.
- *
- * @param {JulianDate} left The first instance.
- * @param {JulianDate} right The second instance.
- * @returns {boolean} <code>true</code> if <code>left</code> is earlier than <code>right</code>, <code>false</code> otherwise.
- */
-JulianDate.lessThan = function (left, right) {
-  return JulianDate.compare(left, right) < 0;
-};
+  /**
+   * Compares the provided instances and returns <code>true</code> if <code>left</code> is earlier than or equal to <code>right</code>, <code>false</code> otherwise.
+   *
+   * @param {JulianDate} left The first instance.
+   * @param {JulianDate} right The second instance.
+   * @returns {boolean} <code>true</code> if <code>left</code> is earlier than or equal to <code>right</code>, <code>false</code> otherwise.
+   */
+  static lessThanOrEquals(left, right) {
+    return JulianDate.compare(left, right) <= 0;
+  }
 
-/**
- * Compares the provided instances and returns <code>true</code> if <code>left</code> is earlier than or equal to <code>right</code>, <code>false</code> otherwise.
- *
- * @param {JulianDate} left The first instance.
- * @param {JulianDate} right The second instance.
- * @returns {boolean} <code>true</code> if <code>left</code> is earlier than or equal to <code>right</code>, <code>false</code> otherwise.
- */
-JulianDate.lessThanOrEquals = function (left, right) {
-  return JulianDate.compare(left, right) <= 0;
-};
+  /**
+   * Compares the provided instances and returns <code>true</code> if <code>left</code> is later than <code>right</code>, <code>false</code> otherwise.
+   *
+   * @param {JulianDate} left The first instance.
+   * @param {JulianDate} right The second instance.
+   * @returns {boolean} <code>true</code> if <code>left</code> is later than <code>right</code>, <code>false</code> otherwise.
+   */
+  static greaterThan(left, right) {
+    return JulianDate.compare(left, right) > 0;
+  }
 
-/**
- * Compares the provided instances and returns <code>true</code> if <code>left</code> is later than <code>right</code>, <code>false</code> otherwise.
- *
- * @param {JulianDate} left The first instance.
- * @param {JulianDate} right The second instance.
- * @returns {boolean} <code>true</code> if <code>left</code> is later than <code>right</code>, <code>false</code> otherwise.
- */
-JulianDate.greaterThan = function (left, right) {
-  return JulianDate.compare(left, right) > 0;
-};
+  /**
+   * Compares the provided instances and returns <code>true</code> if <code>left</code> is later than or equal to <code>right</code>, <code>false</code> otherwise.
+   *
+   * @param {JulianDate} left The first instance.
+   * @param {JulianDate} right The second instance.
+   * @returns {boolean} <code>true</code> if <code>left</code> is later than or equal to <code>right</code>, <code>false</code> otherwise.
+   */
+  static greaterThanOrEquals(left, right) {
+    return JulianDate.compare(left, right) >= 0;
+  }
 
-/**
- * Compares the provided instances and returns <code>true</code> if <code>left</code> is later than or equal to <code>right</code>, <code>false</code> otherwise.
- *
- * @param {JulianDate} left The first instance.
- * @param {JulianDate} right The second instance.
- * @returns {boolean} <code>true</code> if <code>left</code> is later than or equal to <code>right</code>, <code>false</code> otherwise.
- */
-JulianDate.greaterThanOrEquals = function (left, right) {
-  return JulianDate.compare(left, right) >= 0;
-};
+  /**
+   * Duplicates this instance.
+   *
+   * @param {JulianDate} [result] An existing instance to use for the result.
+   * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
+   */
+  clone(result) {
+    return JulianDate.clone(this, result);
+  }
 
-/**
- * Duplicates this instance.
- *
- * @param {JulianDate} [result] An existing instance to use for the result.
- * @returns {JulianDate} The modified result parameter or a new instance if none was provided.
- */
-JulianDate.prototype.clone = function (result) {
-  return JulianDate.clone(this, result);
-};
+  /**
+   * Compares this and the provided instance and returns <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {JulianDate} [right] The second instance.
+   * @returns {boolean} <code>true</code> if the dates are equal; otherwise, <code>false</code>.
+   */
+  equals(right) {
+    return JulianDate.equals(this, right);
+  }
 
-/**
- * Compares this and the provided instance and returns <code>true</code> if they are equal, <code>false</code> otherwise.
- *
- * @param {JulianDate} [right] The second instance.
- * @returns {boolean} <code>true</code> if the dates are equal; otherwise, <code>false</code>.
- */
-JulianDate.prototype.equals = function (right) {
-  return JulianDate.equals(this, right);
-};
+  /**
+   * Compares this and the provided instance and returns <code>true</code> if they are within <code>epsilon</code> seconds of
+   * each other.  That is, in order for the dates to be considered equal (and for
+   * this function to return <code>true</code>), the absolute value of the difference between them, in
+   * seconds, must be less than <code>epsilon</code>.
+   *
+   * @param {JulianDate} [right] The second instance.
+   * @param {number} [epsilon=0] The maximum number of seconds that should separate the two instances.
+   * @returns {boolean} <code>true</code> if the two dates are within <code>epsilon</code> seconds of each other; otherwise <code>false</code>.
+   */
+  equalsEpsilon(right, epsilon) {
+    return JulianDate.equalsEpsilon(this, right, epsilon);
+  }
 
-/**
- * Compares this and the provided instance and returns <code>true</code> if they are within <code>epsilon</code> seconds of
- * each other.  That is, in order for the dates to be considered equal (and for
- * this function to return <code>true</code>), the absolute value of the difference between them, in
- * seconds, must be less than <code>epsilon</code>.
- *
- * @param {JulianDate} [right] The second instance.
- * @param {number} [epsilon=0] The maximum number of seconds that should separate the two instances.
- * @returns {boolean} <code>true</code> if the two dates are within <code>epsilon</code> seconds of each other; otherwise <code>false</code>.
- */
-JulianDate.prototype.equalsEpsilon = function (right, epsilon) {
-  return JulianDate.equalsEpsilon(this, right, epsilon);
-};
+  /**
+   * Creates a string representing this date in ISO8601 format.
+   *
+   * @returns {string} A string representing this date in ISO8601 format.
+   */
+  toString() {
+    return JulianDate.toIso8601(this);
+  }
+}
 
-/**
- * Creates a string representing this date in ISO8601 format.
- *
- * @returns {string} A string representing this date in ISO8601 format.
- */
-JulianDate.prototype.toString = function () {
-  return JulianDate.toIso8601(this);
-};
+const toGregorianDateScratch = new JulianDate(0, 0, TimeStandard.TAI);
 
 /**
  * Gets or sets the list of leap seconds used throughout Cesium.