@cesium/engine 24.0.0 → 25.0.0

package/Build/Workers/{chunk-YJZGW74L.js → chunk-WUBKZFF6.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.140.0
+ * Version 1.141.0
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -26,34 +26,34 @@
 import {
   Cartesian4_default,
   Matrix4_default
-} from "./chunk-HKUES6UG.js";
+} from "./chunk-QXNQQYPV.js";
 import {
   RuntimeError_default
-} from "./chunk-EDXL4W76.js";
+} from "./chunk-3TKLDHV3.js";
 import {
   Cartesian2_default,
   Cartographic_default,
   Ellipsoid_default,
   FeatureDetection_default
-} from "./chunk-GOQBUCXH.js";
+} from "./chunk-ND3NTTOF.js";
 import {
   Cartesian3_default,
   Frozen_default,
   Matrix3_default
-} from "./chunk-ZBZRTRJB.js";
+} from "./chunk-QO2CGXMP.js";
 import {
   Math_default
-} from "./chunk-5GXYJQ2K.js";
+} from "./chunk-DYT5NR6P.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-VLDEUTOP.js";
+} from "./chunk-CZ23Y3RM.js";
 import {
   __commonJS,
   __require,
   __toESM,
   defined_default
-} from "./chunk-AJLTU6PF.js";
+} from "./chunk-DH26SNAB.js";
 
 // node_modules/urijs/src/punycode.js
 var require_punycode = __commonJS({
@@ -2747,7 +2747,8 @@ var TimeConstants = {
    */
   MODIFIED_JULIAN_DATE_DIFFERENCE: 24000005e-1
 };
-var TimeConstants_default = Object.freeze(TimeConstants);
+Object.freeze(TimeConstants);
+var TimeConstants_default = TimeConstants;
 
 // packages/engine/Source/Core/TimeStandard.js
 var TimeStandard = {
@@ -2771,7 +2772,8 @@ var TimeStandard = {
    */
   TAI: 1
 };
-var TimeStandard_default = Object.freeze(TimeStandard);
+Object.freeze(TimeStandard);
+var TimeStandard_default = TimeStandard;
 
 // packages/engine/Source/Core/JulianDate.js
 var gregorianDateScratch = new GregorianDate_default();
@@ -2885,527 +2887,738 @@ var matchHours = /^(\d{2})(\.\d+)?/.source + utcOffset.source;
 var matchHoursMinutes = /^(\d{2}):?(\d{2})(\.\d+)?/.source + utcOffset.source;
 var matchHoursMinutesSeconds = /^(\d{2}):?(\d{2}):?(\d{2})(\.\d+)?/.source + utcOffset.source;
 var iso8601ErrorMessage = "Invalid ISO 8601 date.";
-function JulianDate(julianDayNumber, secondsOfDay, timeStandard) {
-  this.dayNumber = void 0;
-  this.secondsOfDay = void 0;
-  julianDayNumber = julianDayNumber ?? 0;
-  secondsOfDay = secondsOfDay ?? 0;
-  timeStandard = timeStandard ?? TimeStandard_default.UTC;
-  const wholeDays = julianDayNumber | 0;
-  secondsOfDay = secondsOfDay + (julianDayNumber - wholeDays) * TimeConstants_default.SECONDS_PER_DAY;
-  setComponents(wholeDays, secondsOfDay, this);
-  if (timeStandard === TimeStandard_default.UTC) {
-    convertUtcToTai(this);
-  }
-}
-JulianDate.fromGregorianDate = function(date, result) {
-  if (!(date instanceof GregorianDate_default)) {
-    throw new DeveloperError_default("date must be a valid GregorianDate.");
-  }
-  const components = computeJulianDateComponents(
-    date.year,
-    date.month,
-    date.day,
-    date.hour,
-    date.minute,
-    date.second,
-    date.millisecond
-  );
-  if (!defined_default(result)) {
-    return new JulianDate(components[0], components[1], TimeStandard_default.UTC);
+var JulianDate = class _JulianDate {
+  /**
+   * @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.
+   */
+  constructor(julianDayNumber, secondsOfDay, timeStandard) {
+    this.dayNumber = void 0;
+    this.secondsOfDay = void 0;
+    julianDayNumber = julianDayNumber ?? 0;
+    secondsOfDay = secondsOfDay ?? 0;
+    timeStandard = timeStandard ?? TimeStandard_default.UTC;
+    const wholeDays = julianDayNumber | 0;
+    secondsOfDay = secondsOfDay + (julianDayNumber - wholeDays) * TimeConstants_default.SECONDS_PER_DAY;
+    setComponents(wholeDays, secondsOfDay, this);
+    if (timeStandard === TimeStandard_default.UTC) {
+      convertUtcToTai(this);
+    }
   }
-  setComponents(components[0], components[1], result);
-  convertUtcToTai(result);
-  return result;
-};
-JulianDate.fromDate = function(date, result) {
-  if (!(date instanceof Date) || isNaN(date.getTime())) {
-    throw new DeveloperError_default("date must be a valid JavaScript Date.");
-  }
-  const components = computeJulianDateComponents(
-    date.getUTCFullYear(),
-    date.getUTCMonth() + 1,
-    date.getUTCDate(),
-    date.getUTCHours(),
-    date.getUTCMinutes(),
-    date.getUTCSeconds(),
-    date.getUTCMilliseconds()
-  );
-  if (!defined_default(result)) {
-    return new JulianDate(components[0], components[1], TimeStandard_default.UTC);
+  /**
+   * 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.
+   */
+  static fromGregorianDate(date, result) {
+    if (!(date instanceof GregorianDate_default)) {
+      throw new DeveloperError_default("date must be a valid GregorianDate.");
+    }
+    const components = computeJulianDateComponents(
+      date.year,
+      date.month,
+      date.day,
+      date.hour,
+      date.minute,
+      date.second,
+      date.millisecond
+    );
+    if (!defined_default(result)) {
+      return new _JulianDate(components[0], components[1], TimeStandard_default.UTC);
+    }
+    setComponents(components[0], components[1], result);
+    convertUtcToTai(result);
+    return result;
   }
-  setComponents(components[0], components[1], result);
-  convertUtcToTai(result);
-  return result;
-};
-JulianDate.fromIso8601 = function(iso8601String, result) {
-  if (typeof iso8601String !== "string") {
-    throw new DeveloperError_default(iso8601ErrorMessage);
-  }
-  iso8601String = iso8601String.replace(",", ".");
-  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;
-  const date = tokens[0];
-  const time = tokens[1];
-  let tmp;
-  let inLeapYear;
-  if (!defined_default(date)) {
-    throw new DeveloperError_default(iso8601ErrorMessage);
+  /**
+   * 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) {
+    if (!(date instanceof Date) || isNaN(date.getTime())) {
+      throw new DeveloperError_default("date must be a valid JavaScript Date.");
+    }
+    const components = computeJulianDateComponents(
+      date.getUTCFullYear(),
+      date.getUTCMonth() + 1,
+      date.getUTCDate(),
+      date.getUTCHours(),
+      date.getUTCMinutes(),
+      date.getUTCSeconds(),
+      date.getUTCMilliseconds()
+    );
+    if (!defined_default(result)) {
+      return new _JulianDate(components[0], components[1], TimeStandard_default.UTC);
+    }
+    setComponents(components[0], components[1], result);
+    convertUtcToTai(result);
+    return result;
   }
-  let dashCount;
-  tokens = date.match(matchCalendarDate);
-  if (tokens !== null) {
-    dashCount = date.split("-").length - 1;
-    if (dashCount > 0 && dashCount !== 2) {
+  /**
+   * 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) {
+    if (typeof iso8601String !== "string") {
       throw new DeveloperError_default(iso8601ErrorMessage);
     }
-    year = +tokens[1];
-    month = +tokens[2];
-    day = +tokens[3];
-  } else {
-    tokens = date.match(matchCalendarMonth);
+    iso8601String = iso8601String.replace(",", ".");
+    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;
+    const date = tokens[0];
+    const time = tokens[1];
+    let tmp;
+    let inLeapYear;
+    if (!defined_default(date)) {
+      throw new DeveloperError_default(iso8601ErrorMessage);
+    }
+    let dashCount;
+    tokens = date.match(matchCalendarDate);
     if (tokens !== null) {
+      dashCount = date.split("-").length - 1;
+      if (dashCount > 0 && dashCount !== 2) {
+        throw new DeveloperError_default(iso8601ErrorMessage);
+      }
       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 {
-        let dayOfYear;
-        tokens = date.match(matchOrdinalDate);
+        tokens = date.match(matchCalendarYear);
         if (tokens !== null) {
           year = +tokens[1];
-          dayOfYear = +tokens[2];
-          inLeapYear = isLeapYear_default(year);
-          if (dayOfYear < 1 || inLeapYear && dayOfYear > 366 || !inLeapYear && dayOfYear > 365) {
-            throw new DeveloperError_default(iso8601ErrorMessage);
-          }
         } else {
-          tokens = date.match(matchWeekDate);
+          let dayOfYear;
+          tokens = date.match(matchOrdinalDate);
           if (tokens !== null) {
             year = +tokens[1];
-            const weekNumber = +tokens[2];
-            const dayOfWeek = +tokens[3] || 0;
-            dashCount = date.split("-").length - 1;
-            if (dashCount > 0 && (!defined_default(tokens[3]) && dashCount !== 1 || defined_default(tokens[3]) && dashCount !== 2)) {
+            dayOfYear = +tokens[2];
+            inLeapYear = isLeapYear_default(year);
+            if (dayOfYear < 1 || inLeapYear && dayOfYear > 366 || !inLeapYear && dayOfYear > 365) {
               throw new DeveloperError_default(iso8601ErrorMessage);
             }
-            const january4 = new Date(Date.UTC(year, 0, 4));
-            dayOfYear = weekNumber * 7 + dayOfWeek - january4.getUTCDay() - 3;
           } else {
-            throw new DeveloperError_default(iso8601ErrorMessage);
+            tokens = date.match(matchWeekDate);
+            if (tokens !== null) {
+              year = +tokens[1];
+              const weekNumber = +tokens[2];
+              const dayOfWeek = +tokens[3] || 0;
+              dashCount = date.split("-").length - 1;
+              if (dashCount > 0 && (!defined_default(tokens[3]) && dashCount !== 1 || defined_default(tokens[3]) && dashCount !== 2)) {
+                throw new DeveloperError_default(iso8601ErrorMessage);
+              }
+              const january4 = new Date(Date.UTC(year, 0, 4));
+              dayOfYear = weekNumber * 7 + dayOfWeek - january4.getUTCDay() - 3;
+            } else {
+              throw new DeveloperError_default(iso8601ErrorMessage);
+            }
           }
+          tmp = new Date(Date.UTC(year, 0, 1));
+          tmp.setUTCDate(dayOfYear);
+          month = tmp.getUTCMonth() + 1;
+          day = tmp.getUTCDate();
         }
-        tmp = new Date(Date.UTC(year, 0, 1));
-        tmp.setUTCDate(dayOfYear);
-        month = tmp.getUTCMonth() + 1;
-        day = tmp.getUTCDate();
       }
     }
-  }
-  inLeapYear = isLeapYear_default(year);
-  if (month < 1 || month > 12 || day < 1 || (month !== 2 || !inLeapYear) && day > daysInMonth[month - 1] || inLeapYear && month === 2 && day > daysInLeapFebruary) {
-    throw new DeveloperError_default(iso8601ErrorMessage);
-  }
-  let offsetIndex;
-  if (defined_default(time)) {
-    tokens = time.match(matchHoursMinutesSeconds);
-    if (tokens !== null) {
-      dashCount = time.split(":").length - 1;
-      if (dashCount > 0 && dashCount !== 2 && dashCount !== 3) {
-        throw new DeveloperError_default(iso8601ErrorMessage);
-      }
-      hour = +tokens[1];
-      minute = +tokens[2];
-      second = +tokens[3];
-      millisecond = +(tokens[4] || 0) * 1e3;
-      offsetIndex = 5;
-    } else {
-      tokens = time.match(matchHoursMinutes);
+    inLeapYear = isLeapYear_default(year);
+    if (month < 1 || month > 12 || day < 1 || (month !== 2 || !inLeapYear) && day > daysInMonth[month - 1] || inLeapYear && month === 2 && day > daysInLeapFebruary) {
+      throw new DeveloperError_default(iso8601ErrorMessage);
+    }
+    let offsetIndex;
+    if (defined_default(time)) {
+      tokens = time.match(matchHoursMinutesSeconds);
       if (tokens !== null) {
         dashCount = time.split(":").length - 1;
-        if (dashCount > 2) {
+        if (dashCount > 0 && dashCount !== 2 && dashCount !== 3) {
           throw new DeveloperError_default(iso8601ErrorMessage);
         }
         hour = +tokens[1];
         minute = +tokens[2];
-        second = +(tokens[3] || 0) * 60;
-        offsetIndex = 4;
+        second = +tokens[3];
+        millisecond = +(tokens[4] || 0) * 1e3;
+        offsetIndex = 5;
       } else {
-        tokens = time.match(matchHours);
+        tokens = time.match(matchHoursMinutes);
         if (tokens !== null) {
+          dashCount = time.split(":").length - 1;
+          if (dashCount > 2) {
+            throw new DeveloperError_default(iso8601ErrorMessage);
+          }
           hour = +tokens[1];
-          minute = +(tokens[2] || 0) * 60;
-          offsetIndex = 3;
+          minute = +tokens[2];
+          second = +(tokens[3] || 0) * 60;
+          offsetIndex = 4;
         } else {
-          throw new DeveloperError_default(iso8601ErrorMessage);
+          tokens = time.match(matchHours);
+          if (tokens !== null) {
+            hour = +tokens[1];
+            minute = +(tokens[2] || 0) * 60;
+            offsetIndex = 3;
+          } else {
+            throw new DeveloperError_default(iso8601ErrorMessage);
+          }
         }
       }
+      if (minute >= 60 || second >= 61 || hour > 24 || hour === 24 && (minute > 0 || second > 0 || millisecond > 0)) {
+        throw new DeveloperError_default(iso8601ErrorMessage);
+      }
+      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;
+      }
     }
-    if (minute >= 60 || second >= 61 || hour > 24 || hour === 24 && (minute > 0 || second > 0 || millisecond > 0)) {
-      throw new DeveloperError_default(iso8601ErrorMessage);
+    const isLeapSecond = second === 60;
+    if (isLeapSecond) {
+      second--;
     }
-    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;
+    while (minute >= 60) {
+      minute -= 60;
+      hour++;
     }
-  }
-  const isLeapSecond = second === 60;
-  if (isLeapSecond) {
-    second--;
-  }
-  while (minute >= 60) {
-    minute -= 60;
-    hour++;
-  }
-  while (hour >= 24) {
-    hour -= 24;
-    day++;
-  }
-  tmp = inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
-  while (day > tmp) {
-    day -= tmp;
-    month++;
-    if (month > 12) {
-      month -= 12;
-      year++;
+    while (hour >= 24) {
+      hour -= 24;
+      day++;
     }
     tmp = inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
-  }
-  while (minute < 0) {
-    minute += 60;
-    hour--;
-  }
-  while (hour < 0) {
-    hour += 24;
-    day--;
-  }
-  while (day < 1) {
-    month--;
-    if (month < 1) {
-      month += 12;
-      year--;
+    while (day > tmp) {
+      day -= tmp;
+      month++;
+      if (month > 12) {
+        month -= 12;
+        year++;
+      }
+      tmp = inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
     }
-    tmp = inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
-    day += tmp;
-  }
-  const components = computeJulianDateComponents(
-    year,
-    month,
-    day,
-    hour,
-    minute,
-    second,
-    millisecond
-  );
-  if (!defined_default(result)) {
-    result = new JulianDate(components[0], components[1], TimeStandard_default.UTC);
-  } else {
-    setComponents(components[0], components[1], result);
-    convertUtcToTai(result);
-  }
-  if (isLeapSecond) {
-    JulianDate.addSeconds(result, 1, result);
-  }
-  return result;
-};
-JulianDate.now = function(result) {
-  return JulianDate.fromDate(/* @__PURE__ */ new Date(), result);
-};
-var toGregorianDateScratch = new JulianDate(0, 0, TimeStandard_default.TAI);
-JulianDate.toGregorianDate = function(julianDate, result) {
-  if (!defined_default(julianDate)) {
-    throw new DeveloperError_default("julianDate is required.");
-  }
-  let isLeapSecond = false;
-  let thisUtc = convertTaiToUtc(julianDate, toGregorianDateScratch);
-  if (!defined_default(thisUtc)) {
-    JulianDate.addSeconds(julianDate, -1, toGregorianDateScratch);
-    thisUtc = convertTaiToUtc(toGregorianDateScratch, toGregorianDateScratch);
-    isLeapSecond = true;
-  }
-  let julianDayNumber = thisUtc.dayNumber;
-  const secondsOfDay = thisUtc.secondsOfDay;
-  if (secondsOfDay >= 43200) {
-    julianDayNumber += 1;
-  }
-  let L = julianDayNumber + 68569 | 0;
-  const N = 4 * L / 146097 | 0;
-  L = L - ((146097 * N + 3) / 4 | 0) | 0;
-  const I = 4e3 * (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_default.SECONDS_PER_HOUR | 0;
-  let remainingSeconds = secondsOfDay - hour * TimeConstants_default.SECONDS_PER_HOUR;
-  const minute = remainingSeconds / TimeConstants_default.SECONDS_PER_MINUTE | 0;
-  remainingSeconds = remainingSeconds - minute * TimeConstants_default.SECONDS_PER_MINUTE;
-  let second = remainingSeconds | 0;
-  const millisecond = (remainingSeconds - second) / TimeConstants_default.SECONDS_PER_MILLISECOND;
-  hour += 12;
-  if (hour > 23) {
-    hour -= 24;
-  }
-  if (isLeapSecond) {
-    second += 1;
-  }
-  if (!defined_default(result)) {
-    return new GregorianDate_default(
+    while (minute < 0) {
+      minute += 60;
+      hour--;
+    }
+    while (hour < 0) {
+      hour += 24;
+      day--;
+    }
+    while (day < 1) {
+      month--;
+      if (month < 1) {
+        month += 12;
+        year--;
+      }
+      tmp = inLeapYear && month === 2 ? daysInLeapFebruary : daysInMonth[month - 1];
+      day += tmp;
+    }
+    const components = computeJulianDateComponents(
       year,
       month,
       day,
       hour,
       minute,
       second,
-      millisecond,
-      isLeapSecond
+      millisecond
     );
+    if (!defined_default(result)) {
+      result = new _JulianDate(components[0], components[1], TimeStandard_default.UTC);
+    } else {
+      setComponents(components[0], components[1], result);
+      convertUtcToTai(result);
+    }
+    if (isLeapSecond) {
+      _JulianDate.addSeconds(result, 1, result);
+    }
+    return result;
   }
-  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;
-};
-JulianDate.toDate = function(julianDate) {
-  if (!defined_default(julianDate)) {
-    throw new DeveloperError_default("julianDate is required.");
-  }
-  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
-    )
-  );
-};
-JulianDate.toIso8601 = function(julianDate, precision) {
-  if (!defined_default(julianDate)) {
-    throw new DeveloperError_default("julianDate is required.");
-  }
-  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;
-  if (year === 1e4 && month === 1 && day === 1 && hour === 0 && minute === 0 && second === 0 && millisecond === 0) {
-    year = 9999;
-    month = 12;
-    day = 31;
-    hour = 24;
-  }
-  let millisecondStr;
-  if (!defined_default(precision) && millisecond !== 0) {
-    const millisecondHundreds = millisecond * 0.01;
-    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`;
-  }
-  if (!defined_default(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`;
+  /**
+   * 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(/* @__PURE__ */ new Date(), result);
   }
-  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`;
-};
-JulianDate.clone = function(julianDate, result) {
-  if (!defined_default(julianDate)) {
-    return void 0;
+  /**
+   * 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) {
+    if (!defined_default(julianDate)) {
+      throw new DeveloperError_default("julianDate is required.");
+    }
+    let isLeapSecond = false;
+    let thisUtc = convertTaiToUtc(julianDate, toGregorianDateScratch);
+    if (!defined_default(thisUtc)) {
+      _JulianDate.addSeconds(julianDate, -1, toGregorianDateScratch);
+      thisUtc = convertTaiToUtc(toGregorianDateScratch, toGregorianDateScratch);
+      isLeapSecond = true;
+    }
+    let julianDayNumber = thisUtc.dayNumber;
+    const secondsOfDay = thisUtc.secondsOfDay;
+    if (secondsOfDay >= 43200) {
+      julianDayNumber += 1;
+    }
+    let L = julianDayNumber + 68569 | 0;
+    const N = 4 * L / 146097 | 0;
+    L = L - ((146097 * N + 3) / 4 | 0) | 0;
+    const I = 4e3 * (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_default.SECONDS_PER_HOUR | 0;
+    let remainingSeconds = secondsOfDay - hour * TimeConstants_default.SECONDS_PER_HOUR;
+    const minute = remainingSeconds / TimeConstants_default.SECONDS_PER_MINUTE | 0;
+    remainingSeconds = remainingSeconds - minute * TimeConstants_default.SECONDS_PER_MINUTE;
+    let second = remainingSeconds | 0;
+    const millisecond = (remainingSeconds - second) / TimeConstants_default.SECONDS_PER_MILLISECOND;
+    hour += 12;
+    if (hour > 23) {
+      hour -= 24;
+    }
+    if (isLeapSecond) {
+      second += 1;
+    }
+    if (!defined_default(result)) {
+      return new GregorianDate_default(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        millisecond,
+        isLeapSecond
+      );
+    }
+    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 (!defined_default(result)) {
-    return new JulianDate(
-      julianDate.dayNumber,
-      julianDate.secondsOfDay,
-      TimeStandard_default.TAI
+  /**
+   * 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) {
+    if (!defined_default(julianDate)) {
+      throw new DeveloperError_default("julianDate is required.");
+    }
+    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.dayNumber = julianDate.dayNumber;
-  result.secondsOfDay = julianDate.secondsOfDay;
-  return result;
-};
-JulianDate.compare = function(left, right) {
-  if (!defined_default(left)) {
-    throw new DeveloperError_default("left is required.");
+  /**
+   * 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) {
+    if (!defined_default(julianDate)) {
+      throw new DeveloperError_default("julianDate is required.");
+    }
+    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;
+    if (year === 1e4 && month === 1 && day === 1 && hour === 0 && minute === 0 && second === 0 && millisecond === 0) {
+      year = 9999;
+      month = 12;
+      day = 31;
+      hour = 24;
+    }
+    let millisecondStr;
+    if (!defined_default(precision) && millisecond !== 0) {
+      const millisecondHundreds = millisecond * 0.01;
+      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`;
+    }
+    if (!defined_default(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`;
+    }
+    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`;
   }
-  if (!defined_default(right)) {
-    throw new DeveloperError_default("right is required.");
+  /**
+   * 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_default(julianDate)) {
+      return void 0;
+    }
+    if (!defined_default(result)) {
+      return new _JulianDate(
+        julianDate.dayNumber,
+        julianDate.secondsOfDay,
+        TimeStandard_default.TAI
+      );
+    }
+    result.dayNumber = julianDate.dayNumber;
+    result.secondsOfDay = julianDate.secondsOfDay;
+    return result;
   }
-  const julianDayNumberDifference = left.dayNumber - right.dayNumber;
-  if (julianDayNumberDifference !== 0) {
-    return julianDayNumberDifference;
+  /**
+   * 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) {
+    if (!defined_default(left)) {
+      throw new DeveloperError_default("left is required.");
+    }
+    if (!defined_default(right)) {
+      throw new DeveloperError_default("right is required.");
+    }
+    const julianDayNumberDifference = left.dayNumber - right.dayNumber;
+    if (julianDayNumberDifference !== 0) {
+      return julianDayNumberDifference;
+    }
+    return left.secondsOfDay - right.secondsOfDay;
   }
-  return left.secondsOfDay - right.secondsOfDay;
-};
-JulianDate.equals = function(left, right) {
-  return left === right || defined_default(left) && defined_default(right) && left.dayNumber === right.dayNumber && left.secondsOfDay === right.secondsOfDay;
-};
-JulianDate.equalsEpsilon = function(left, right, epsilon) {
-  epsilon = epsilon ?? 0;
-  return left === right || defined_default(left) && defined_default(right) && Math.abs(JulianDate.secondsDifference(left, right)) <= epsilon;
-};
-JulianDate.totalDays = function(julianDate) {
-  if (!defined_default(julianDate)) {
-    throw new DeveloperError_default("julianDate is required.");
+  /**
+   * 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_default(left) && defined_default(right) && left.dayNumber === right.dayNumber && left.secondsOfDay === right.secondsOfDay;
   }
-  return julianDate.dayNumber + julianDate.secondsOfDay / TimeConstants_default.SECONDS_PER_DAY;
-};
-JulianDate.secondsDifference = function(left, right) {
-  if (!defined_default(left)) {
-    throw new DeveloperError_default("left 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_default(left) && defined_default(right) && Math.abs(_JulianDate.secondsDifference(left, right)) <= epsilon;
   }
-  if (!defined_default(right)) {
-    throw new DeveloperError_default("right is required.");
+  /**
+   * 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) {
+    if (!defined_default(julianDate)) {
+      throw new DeveloperError_default("julianDate is required.");
+    }
+    return julianDate.dayNumber + julianDate.secondsOfDay / TimeConstants_default.SECONDS_PER_DAY;
   }
-  const dayDifference = (left.dayNumber - right.dayNumber) * TimeConstants_default.SECONDS_PER_DAY;
-  return dayDifference + (left.secondsOfDay - right.secondsOfDay);
-};
-JulianDate.daysDifference = function(left, right) {
-  if (!defined_default(left)) {
-    throw new DeveloperError_default("left is required.");
+  /**
+   * 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) {
+    if (!defined_default(left)) {
+      throw new DeveloperError_default("left is required.");
+    }
+    if (!defined_default(right)) {
+      throw new DeveloperError_default("right is required.");
+    }
+    const dayDifference = (left.dayNumber - right.dayNumber) * TimeConstants_default.SECONDS_PER_DAY;
+    return dayDifference + (left.secondsOfDay - right.secondsOfDay);
   }
-  if (!defined_default(right)) {
-    throw new DeveloperError_default("right is required.");
+  /**
+   * 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) {
+    if (!defined_default(left)) {
+      throw new DeveloperError_default("left is required.");
+    }
+    if (!defined_default(right)) {
+      throw new DeveloperError_default("right is required.");
+    }
+    const dayDifference = left.dayNumber - right.dayNumber;
+    const secondDifference = (left.secondsOfDay - right.secondsOfDay) / TimeConstants_default.SECONDS_PER_DAY;
+    return dayDifference + secondDifference;
   }
-  const dayDifference = left.dayNumber - right.dayNumber;
-  const secondDifference = (left.secondsOfDay - right.secondsOfDay) / TimeConstants_default.SECONDS_PER_DAY;
-  return dayDifference + secondDifference;
-};
-JulianDate.computeTaiMinusUtc = function(julianDate) {
-  binarySearchScratchLeapSecond.julianDate = julianDate;
-  const leapSeconds = JulianDate.leapSeconds;
-  let index = binarySearch_default(
-    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_default(
+      leapSeconds,
+      binarySearchScratchLeapSecond,
+      compareLeapSecondDates
+    );
     if (index < 0) {
-      index = 0;
+      index = ~index;
+      --index;
+      if (index < 0) {
+        index = 0;
+      }
     }
+    return leapSeconds[index].offset;
   }
-  return leapSeconds[index].offset;
-};
-JulianDate.addSeconds = function(julianDate, seconds, result) {
-  if (!defined_default(julianDate)) {
-    throw new DeveloperError_default("julianDate 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) {
+    if (!defined_default(julianDate)) {
+      throw new DeveloperError_default("julianDate is required.");
+    }
+    if (!defined_default(seconds)) {
+      throw new DeveloperError_default("seconds is required.");
+    }
+    if (!defined_default(result)) {
+      throw new DeveloperError_default("result is required.");
+    }
+    return setComponents(
+      julianDate.dayNumber,
+      julianDate.secondsOfDay + seconds,
+      result
+    );
   }
-  if (!defined_default(seconds)) {
-    throw new DeveloperError_default("seconds is required.");
+  /**
+   * 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) {
+    if (!defined_default(julianDate)) {
+      throw new DeveloperError_default("julianDate is required.");
+    }
+    if (!defined_default(minutes)) {
+      throw new DeveloperError_default("minutes is required.");
+    }
+    if (!defined_default(result)) {
+      throw new DeveloperError_default("result is required.");
+    }
+    const newSecondsOfDay = julianDate.secondsOfDay + minutes * TimeConstants_default.SECONDS_PER_MINUTE;
+    return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
   }
-  if (!defined_default(result)) {
-    throw new DeveloperError_default("result is required.");
+  /**
+   * 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) {
+    if (!defined_default(julianDate)) {
+      throw new DeveloperError_default("julianDate is required.");
+    }
+    if (!defined_default(hours)) {
+      throw new DeveloperError_default("hours is required.");
+    }
+    if (!defined_default(result)) {
+      throw new DeveloperError_default("result is required.");
+    }
+    const newSecondsOfDay = julianDate.secondsOfDay + hours * TimeConstants_default.SECONDS_PER_HOUR;
+    return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
   }
-  return setComponents(
-    julianDate.dayNumber,
-    julianDate.secondsOfDay + seconds,
-    result
-  );
-};
-JulianDate.addMinutes = function(julianDate, minutes, result) {
-  if (!defined_default(julianDate)) {
-    throw new DeveloperError_default("julianDate is required.");
+  /**
+   * 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) {
+    if (!defined_default(julianDate)) {
+      throw new DeveloperError_default("julianDate is required.");
+    }
+    if (!defined_default(days)) {
+      throw new DeveloperError_default("days is required.");
+    }
+    if (!defined_default(result)) {
+      throw new DeveloperError_default("result is required.");
+    }
+    const newJulianDayNumber = julianDate.dayNumber + days;
+    return setComponents(newJulianDayNumber, julianDate.secondsOfDay, result);
   }
-  if (!defined_default(minutes)) {
-    throw new DeveloperError_default("minutes is required.");
+  /**
+   * 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;
   }
-  if (!defined_default(result)) {
-    throw new DeveloperError_default("result is required.");
+  /**
+   * 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;
   }
-  const newSecondsOfDay = julianDate.secondsOfDay + minutes * TimeConstants_default.SECONDS_PER_MINUTE;
-  return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
-};
-JulianDate.addHours = function(julianDate, hours, result) {
-  if (!defined_default(julianDate)) {
-    throw new DeveloperError_default("julianDate is required.");
+  /**
+   * 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;
   }
-  if (!defined_default(hours)) {
-    throw new DeveloperError_default("hours is required.");
+  /**
+   * 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;
   }
-  if (!defined_default(result)) {
-    throw new DeveloperError_default("result is required.");
+  /**
+   * 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);
   }
-  const newSecondsOfDay = julianDate.secondsOfDay + hours * TimeConstants_default.SECONDS_PER_HOUR;
-  return setComponents(julianDate.dayNumber, newSecondsOfDay, result);
-};
-JulianDate.addDays = function(julianDate, days, result) {
-  if (!defined_default(julianDate)) {
-    throw new DeveloperError_default("julianDate is required.");
+  /**
+   * 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);
   }
-  if (!defined_default(days)) {
-    throw new DeveloperError_default("days is required.");
+  /**
+   * 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);
   }
-  if (!defined_default(result)) {
-    throw new DeveloperError_default("result is required.");
+  /**
+   * Creates a string representing this date in ISO8601 format.
+   *
+   * @returns {string} A string representing this date in ISO8601 format.
+   */
+  toString() {
+    return _JulianDate.toIso8601(this);
   }
-  const newJulianDayNumber = julianDate.dayNumber + days;
-  return setComponents(newJulianDayNumber, julianDate.secondsOfDay, result);
-};
-JulianDate.lessThan = function(left, right) {
-  return JulianDate.compare(left, right) < 0;
-};
-JulianDate.lessThanOrEquals = function(left, right) {
-  return JulianDate.compare(left, right) <= 0;
-};
-JulianDate.greaterThan = function(left, right) {
-  return JulianDate.compare(left, right) > 0;
-};
-JulianDate.greaterThanOrEquals = function(left, right) {
-  return JulianDate.compare(left, right) >= 0;
-};
-JulianDate.prototype.clone = function(result) {
-  return JulianDate.clone(this, result);
-};
-JulianDate.prototype.equals = function(right) {
-  return JulianDate.equals(this, right);
-};
-JulianDate.prototype.equalsEpsilon = function(right, epsilon) {
-  return JulianDate.equalsEpsilon(this, right, epsilon);
-};
-JulianDate.prototype.toString = function() {
-  return JulianDate.toIso8601(this);
 };
+var toGregorianDateScratch = new JulianDate(0, 0, TimeStandard_default.TAI);
 JulianDate.leapSeconds = [
   new LeapSecond_default(new JulianDate(2441317, 43210, TimeStandard_default.TAI), 10),
   // January 1, 1972 00:00:00 UTC
@@ -3772,7 +3985,8 @@ var RequestState = {
    */
   FAILED: 5
 };
-var RequestState_default = Object.freeze(RequestState);
+Object.freeze(RequestState);
+var RequestState_default = RequestState;
 
 // packages/engine/Source/Core/RequestType.js
 var RequestType = {
@@ -3805,7 +4019,8 @@ var RequestType = {
    */
   OTHER: 3
 };
-var RequestType_default = Object.freeze(RequestType);
+Object.freeze(RequestType);
+var RequestType_default = RequestType;
 
 // packages/engine/Source/Core/Request.js
 function Request(options) {
@@ -4290,8 +4505,10 @@ function cancelRequest(request) {
   ++statistics.numberOfCancelledRequests;
   if (defined_default(request.deferred)) {
     const deferred = request.deferred;
+    deferred.promise.catch(() => {
+    });
     request.deferred = void 0;
-    deferred.reject();
+    deferred.reject(new RuntimeError_default(`Request cancelled: "${request.url}"`));
   }
   if (active) {
     --statistics.numberOfActiveRequests;
@@ -6162,8 +6379,23 @@ Iau2006XysData.prototype.computeXysRadians = function(dayTT, secondTT, result) {
   }
   return result;
 };
+Iau2006XysData.prototype._updateChunkData = function(index, { samples }) {
+  this._chunkDownloadsInProgress[index] = void 0;
+  const samplesPerFile = this._samplesPerXysFile;
+  const startIndex = index * samplesPerFile * 3;
+  for (let i = 0; i < samples.length; ++i) {
+    this._samples[startIndex + i] = samples[i];
+  }
+};
+async function requestXysChunkJson(resource, index, xysData) {
+  try {
+    const chunk = await resource.fetchJson();
+    xysData._updateChunkData(index, chunk);
+  } catch (e) {
+  }
+}
 function requestXysChunk(xysData, chunkIndex) {
-  if (xysData._chunkDownloadsInProgress[chunkIndex]) {
+  if (defined_default(xysData._chunkDownloadsInProgress[chunkIndex])) {
     return xysData._chunkDownloadsInProgress[chunkIndex];
   }
   let chunkUrl;
@@ -6179,15 +6411,7 @@ function requestXysChunk(xysData, chunkIndex) {
       url: buildModuleUrl_default(`Assets/IAU2006_XYS/IAU2006_XYS_${chunkIndex}.json`)
     });
   }
-  const promise = chunkUrl.fetchJson().then(function(chunk) {
-    xysData._chunkDownloadsInProgress[chunkIndex] = false;
-    const samples = xysData._samples;
-    const newSamples = chunk.samples;
-    const startIndex = chunkIndex * xysData._samplesPerXysFile * 3;
-    for (let i = 0, len = newSamples.length; i < len; ++i) {
-      samples[startIndex + i] = newSamples[i];
-    }
-  });
+  const promise = requestXysChunkJson(chunkUrl, chunkIndex, xysData);
   xysData._chunkDownloadsInProgress[chunkIndex] = promise;
   return promise;
 }
@@ -7384,553 +7608,803 @@ Transforms.ellipsoidTo2DModelMatrix = function(projection, center, result) {
 var Transforms_default = Transforms;
 
 // packages/engine/Source/Core/Rectangle.js
-function Rectangle(west, south, east, north) {
-  this.west = west ?? 0;
-  this.south = south ?? 0;
-  this.east = east ?? 0;
-  this.north = north ?? 0;
-}
-Object.defineProperties(Rectangle.prototype, {
+var Rectangle = class _Rectangle {
+  /**
+   * @param {number} [west=0.0] The westernmost longitude, in radians, in the range [-Pi, Pi].
+   * @param {number} [south=0.0] The southernmost latitude, in radians, in the range [-Pi/2, Pi/2].
+   * @param {number} [east=0.0] The easternmost longitude, in radians, in the range [-Pi, Pi].
+   * @param {number} [north=0.0] The northernmost latitude, in radians, in the range [-Pi/2, Pi/2].
+   */
+  constructor(west, south, east, north) {
+    this.west = west ?? 0;
+    this.south = south ?? 0;
+    this.east = east ?? 0;
+    this.north = north ?? 0;
+  }
   /**
    * Gets the width of the rectangle in radians.
-   * @memberof Rectangle.prototype
    * @type {number}
    * @readonly
    */
-  width: {
-    get: function() {
-      return Rectangle.computeWidth(this);
-    }
-  },
+  get width() {
+    return _Rectangle.computeWidth(this);
+  }
   /**
    * Gets the height of the rectangle in radians.
-   * @memberof Rectangle.prototype
    * @type {number}
    * @readonly
    */
-  height: {
-    get: function() {
-      return Rectangle.computeHeight(this);
-    }
-  }
-});
-Rectangle.packedLength = 4;
-Rectangle.pack = function(value, array, startingIndex) {
-  Check_default.typeOf.object("value", value);
-  Check_default.defined("array", array);
-  startingIndex = startingIndex ?? 0;
-  array[startingIndex++] = value.west;
-  array[startingIndex++] = value.south;
-  array[startingIndex++] = value.east;
-  array[startingIndex] = value.north;
-  return array;
-};
-Rectangle.unpack = function(array, startingIndex, result) {
-  Check_default.defined("array", array);
-  startingIndex = startingIndex ?? 0;
-  if (!defined_default(result)) {
-    result = new Rectangle();
-  }
-  result.west = array[startingIndex++];
-  result.south = array[startingIndex++];
-  result.east = array[startingIndex++];
-  result.north = array[startingIndex];
-  return result;
-};
-Rectangle.computeWidth = function(rectangle) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  let east = rectangle.east;
-  const west = rectangle.west;
-  if (east < west) {
-    east += Math_default.TWO_PI;
-  }
-  return east - west;
-};
-Rectangle.computeHeight = function(rectangle) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  return rectangle.north - rectangle.south;
-};
-Rectangle.fromDegrees = function(west, south, east, north, result) {
-  west = Math_default.toRadians(west ?? 0);
-  south = Math_default.toRadians(south ?? 0);
-  east = Math_default.toRadians(east ?? 0);
-  north = Math_default.toRadians(north ?? 0);
-  if (!defined_default(result)) {
-    return new Rectangle(west, south, east, north);
+  get height() {
+    return _Rectangle.computeHeight(this);
   }
-  result.west = west;
-  result.south = south;
-  result.east = east;
-  result.north = north;
-  return result;
-};
-Rectangle.fromRadians = function(west, south, east, north, result) {
-  if (!defined_default(result)) {
-    return new Rectangle(west, south, east, north);
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {Rectangle} value The value to pack.
+   * @param {number[]} array The array to pack into.
+   * @param {number} [startingIndex=0] The index into the array at which to start packing the elements.
+   *
+   * @returns {number[]} The array that was packed into
+   */
+  static pack(value, array, startingIndex) {
+    Check_default.typeOf.object("value", value);
+    Check_default.defined("array", array);
+    startingIndex = startingIndex ?? 0;
+    array[startingIndex++] = value.west;
+    array[startingIndex++] = value.south;
+    array[startingIndex++] = value.east;
+    array[startingIndex] = value.north;
+    return array;
   }
-  result.west = west ?? 0;
-  result.south = south ?? 0;
-  result.east = east ?? 0;
-  result.north = north ?? 0;
-  return result;
-};
-Rectangle.fromCartographicArray = function(cartographics, result) {
-  Check_default.defined("cartographics", cartographics);
-  let west = Number.MAX_VALUE;
-  let east = -Number.MAX_VALUE;
-  let westOverIDL = Number.MAX_VALUE;
-  let eastOverIDL = -Number.MAX_VALUE;
-  let south = Number.MAX_VALUE;
-  let north = -Number.MAX_VALUE;
-  for (let i = 0, len = cartographics.length; i < len; i++) {
-    const position = cartographics[i];
-    west = Math.min(west, position.longitude);
-    east = Math.max(east, position.longitude);
-    south = Math.min(south, position.latitude);
-    north = Math.max(north, position.latitude);
-    const lonAdjusted = position.longitude >= 0 ? position.longitude : position.longitude + Math_default.TWO_PI;
-    westOverIDL = Math.min(westOverIDL, lonAdjusted);
-    eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
-  }
-  if (east - west > eastOverIDL - westOverIDL) {
-    west = westOverIDL;
-    east = eastOverIDL;
-    if (east > Math_default.PI) {
-      east = east - Math_default.TWO_PI;
-    }
-    if (west > Math_default.PI) {
-      west = west - Math_default.TWO_PI;
+  /**
+   * Retrieves an instance from a packed array.
+   *
+   * @param {number[]} array The packed array.
+   * @param {number} [startingIndex=0] The starting index of the element to be unpacked.
+   * @param {Rectangle} [result] The object into which to store the result.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if one was not provided.
+   */
+  static unpack(array, startingIndex, result) {
+    Check_default.defined("array", array);
+    startingIndex = startingIndex ?? 0;
+    if (!defined_default(result)) {
+      result = new _Rectangle();
     }
+    result.west = array[startingIndex++];
+    result.south = array[startingIndex++];
+    result.east = array[startingIndex++];
+    result.north = array[startingIndex];
+    return result;
   }
-  if (!defined_default(result)) {
-    return new Rectangle(west, south, east, north);
-  }
-  result.west = west;
-  result.south = south;
-  result.east = east;
-  result.north = north;
-  return result;
-};
-Rectangle.fromCartesianArray = function(cartesians, ellipsoid, result) {
-  Check_default.defined("cartesians", cartesians);
-  ellipsoid = ellipsoid ?? Ellipsoid_default.default;
-  let west = Number.MAX_VALUE;
-  let east = -Number.MAX_VALUE;
-  let westOverIDL = Number.MAX_VALUE;
-  let eastOverIDL = -Number.MAX_VALUE;
-  let south = Number.MAX_VALUE;
-  let north = -Number.MAX_VALUE;
-  for (let i = 0, len = cartesians.length; i < len; i++) {
-    const position = ellipsoid.cartesianToCartographic(cartesians[i]);
-    west = Math.min(west, position.longitude);
-    east = Math.max(east, position.longitude);
-    south = Math.min(south, position.latitude);
-    north = Math.max(north, position.latitude);
-    const lonAdjusted = position.longitude >= 0 ? position.longitude : position.longitude + Math_default.TWO_PI;
-    westOverIDL = Math.min(westOverIDL, lonAdjusted);
-    eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
-  }
-  if (east - west > eastOverIDL - westOverIDL) {
-    west = westOverIDL;
-    east = eastOverIDL;
-    if (east > Math_default.PI) {
-      east = east - Math_default.TWO_PI;
-    }
-    if (west > Math_default.PI) {
-      west = west - Math_default.TWO_PI;
+  /**
+   * Computes the width of a rectangle in radians.
+   * @param {Rectangle} rectangle The rectangle to compute the width of.
+   * @returns {number} The width.
+   */
+  static computeWidth(rectangle) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    let east = rectangle.east;
+    const west = rectangle.west;
+    if (east < west) {
+      east += Math_default.TWO_PI;
     }
+    return east - west;
   }
-  if (!defined_default(result)) {
-    return new Rectangle(west, south, east, north);
+  /**
+   * Computes the height of a rectangle in radians.
+   * @param {Rectangle} rectangle The rectangle to compute the height of.
+   * @returns {number} The height.
+   */
+  static computeHeight(rectangle) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    return rectangle.north - rectangle.south;
   }
-  result.west = west;
-  result.south = south;
-  result.east = east;
-  result.north = north;
-  return result;
-};
-var fromBoundingSphereMatrixScratch = new Cartesian3_default();
-var fromBoundingSphereEastScratch = new Cartesian3_default();
-var fromBoundingSphereNorthScratch = new Cartesian3_default();
-var fromBoundingSphereWestScratch = new Cartesian3_default();
-var fromBoundingSphereSouthScratch = new Cartesian3_default();
-var fromBoundingSpherePositionsScratch = new Array(5);
-for (let n = 0; n < fromBoundingSpherePositionsScratch.length; ++n) {
-  fromBoundingSpherePositionsScratch[n] = new Cartesian3_default();
-}
-Rectangle.fromBoundingSphere = function(boundingSphere, ellipsoid, result) {
-  Check_default.typeOf.object("boundingSphere", boundingSphere);
-  const center = boundingSphere.center;
-  const radius = boundingSphere.radius;
-  if (!defined_default(ellipsoid)) {
-    ellipsoid = Ellipsoid_default.default;
+  /**
+   * Creates a rectangle given the boundary longitude and latitude in degrees.
+   *
+   * @param {number} [west=0.0] The westernmost longitude in degrees in the range [-180.0, 180.0].
+   * @param {number} [south=0.0] The southernmost latitude in degrees in the range [-90.0, 90.0].
+   * @param {number} [east=0.0] The easternmost longitude in degrees in the range [-180.0, 180.0].
+   * @param {number} [north=0.0] The northernmost latitude in degrees in the range [-90.0, 90.0].
+   * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
+   *
+   * @example
+   * const rectangle = Cesium.Rectangle.fromDegrees(0.0, 20.0, 10.0, 30.0);
+   */
+  static fromDegrees(west, south, east, north, result) {
+    west = Math_default.toRadians(west ?? 0);
+    south = Math_default.toRadians(south ?? 0);
+    east = Math_default.toRadians(east ?? 0);
+    north = Math_default.toRadians(north ?? 0);
+    if (!defined_default(result)) {
+      return new _Rectangle(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
   }
-  if (!defined_default(result)) {
-    result = new Rectangle();
+  /**
+   * Creates a rectangle given the boundary longitude and latitude in radians.
+   *
+   * @param {number} [west=0.0] The westernmost longitude in radians in the range [-Math.PI, Math.PI].
+   * @param {number} [south=0.0] The southernmost latitude in radians in the range [-Math.PI/2, Math.PI/2].
+   * @param {number} [east=0.0] The easternmost longitude in radians in the range [-Math.PI, Math.PI].
+   * @param {number} [north=0.0] The northernmost latitude in radians in the range [-Math.PI/2, Math.PI/2].
+   * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
+   *
+   * @example
+   * const rectangle = Cesium.Rectangle.fromRadians(0.0, Math.PI/4, Math.PI/8, 3*Math.PI/4);
+   */
+  static fromRadians(west, south, east, north, result) {
+    if (!defined_default(result)) {
+      return new _Rectangle(west, south, east, north);
+    }
+    result.west = west ?? 0;
+    result.south = south ?? 0;
+    result.east = east ?? 0;
+    result.north = north ?? 0;
+    return result;
   }
-  if (Cartesian3_default.equals(center, Cartesian3_default.ZERO)) {
-    Rectangle.clone(Rectangle.MAX_VALUE, result);
+  /**
+   * Creates the smallest possible Rectangle that encloses all positions in the provided array.
+   *
+   * @param {Cartographic[]} cartographics The list of Cartographic instances.
+   * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
+   */
+  static fromCartographicArray(cartographics, result) {
+    Check_default.defined("cartographics", cartographics);
+    let west = Number.MAX_VALUE;
+    let east = -Number.MAX_VALUE;
+    let westOverIDL = Number.MAX_VALUE;
+    let eastOverIDL = -Number.MAX_VALUE;
+    let south = Number.MAX_VALUE;
+    let north = -Number.MAX_VALUE;
+    for (let i = 0, len = cartographics.length; i < len; i++) {
+      const position = cartographics[i];
+      west = Math.min(west, position.longitude);
+      east = Math.max(east, position.longitude);
+      south = Math.min(south, position.latitude);
+      north = Math.max(north, position.latitude);
+      const lonAdjusted = position.longitude >= 0 ? position.longitude : position.longitude + Math_default.TWO_PI;
+      westOverIDL = Math.min(westOverIDL, lonAdjusted);
+      eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
+    }
+    if (east - west > eastOverIDL - westOverIDL) {
+      west = westOverIDL;
+      east = eastOverIDL;
+      if (east > Math_default.PI) {
+        east = east - Math_default.TWO_PI;
+      }
+      if (west > Math_default.PI) {
+        west = west - Math_default.TWO_PI;
+      }
+    }
+    if (!defined_default(result)) {
+      return new _Rectangle(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
     return result;
   }
-  const fromENU = Transforms_default.eastNorthUpToFixedFrame(
-    center,
-    ellipsoid,
-    fromBoundingSphereMatrixScratch
-  );
-  const east = Matrix4_default.multiplyByPointAsVector(
-    fromENU,
-    Cartesian3_default.UNIT_X,
-    fromBoundingSphereEastScratch
-  );
-  Cartesian3_default.normalize(east, east);
-  const north = Matrix4_default.multiplyByPointAsVector(
-    fromENU,
-    Cartesian3_default.UNIT_Y,
-    fromBoundingSphereNorthScratch
-  );
-  Cartesian3_default.normalize(north, north);
-  Cartesian3_default.multiplyByScalar(north, radius, north);
-  Cartesian3_default.multiplyByScalar(east, radius, east);
-  const south = Cartesian3_default.negate(north, fromBoundingSphereSouthScratch);
-  const west = Cartesian3_default.negate(east, fromBoundingSphereWestScratch);
-  const positions = fromBoundingSpherePositionsScratch;
-  let corner = positions[0];
-  Cartesian3_default.add(center, north, corner);
-  corner = positions[1];
-  Cartesian3_default.add(center, west, corner);
-  corner = positions[2];
-  Cartesian3_default.add(center, south, corner);
-  corner = positions[3];
-  Cartesian3_default.add(center, east, corner);
-  positions[4] = center;
-  return Rectangle.fromCartesianArray(positions, ellipsoid, result);
-};
-Rectangle.clone = function(rectangle, result) {
-  if (!defined_default(rectangle)) {
-    return void 0;
+  /**
+   * Creates the smallest possible Rectangle that encloses all positions in the provided array.
+   *
+   * @param {Cartesian3[]} cartesians The list of Cartesian instances.
+   * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid the cartesians are on.
+   * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
+   */
+  static fromCartesianArray(cartesians, ellipsoid, result) {
+    Check_default.defined("cartesians", cartesians);
+    ellipsoid = ellipsoid ?? Ellipsoid_default.default;
+    let west = Number.MAX_VALUE;
+    let east = -Number.MAX_VALUE;
+    let westOverIDL = Number.MAX_VALUE;
+    let eastOverIDL = -Number.MAX_VALUE;
+    let south = Number.MAX_VALUE;
+    let north = -Number.MAX_VALUE;
+    for (let i = 0, len = cartesians.length; i < len; i++) {
+      const position = ellipsoid.cartesianToCartographic(cartesians[i]);
+      west = Math.min(west, position.longitude);
+      east = Math.max(east, position.longitude);
+      south = Math.min(south, position.latitude);
+      north = Math.max(north, position.latitude);
+      const lonAdjusted = position.longitude >= 0 ? position.longitude : position.longitude + Math_default.TWO_PI;
+      westOverIDL = Math.min(westOverIDL, lonAdjusted);
+      eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
+    }
+    if (east - west > eastOverIDL - westOverIDL) {
+      west = westOverIDL;
+      east = eastOverIDL;
+      if (east > Math_default.PI) {
+        east = east - Math_default.TWO_PI;
+      }
+      if (west > Math_default.PI) {
+        west = west - Math_default.TWO_PI;
+      }
+    }
+    if (!defined_default(result)) {
+      return new _Rectangle(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
   }
-  if (!defined_default(result)) {
-    return new Rectangle(
-      rectangle.west,
-      rectangle.south,
-      rectangle.east,
-      rectangle.north
+  /**
+   * Create a rectangle from a bounding sphere, ignoring height.
+   *
+   *
+   * @param {BoundingSphere} boundingSphere The bounding sphere.
+   * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid.
+   * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
+   */
+  static fromBoundingSphere(boundingSphere, ellipsoid, result) {
+    Check_default.typeOf.object("boundingSphere", boundingSphere);
+    const center = boundingSphere.center;
+    const radius = boundingSphere.radius;
+    if (!defined_default(ellipsoid)) {
+      ellipsoid = Ellipsoid_default.default;
+    }
+    if (!defined_default(result)) {
+      result = new _Rectangle();
+    }
+    if (Cartesian3_default.equals(center, Cartesian3_default.ZERO)) {
+      _Rectangle.clone(_Rectangle.MAX_VALUE, result);
+      return result;
+    }
+    const fromENU = Transforms_default.eastNorthUpToFixedFrame(
+      center,
+      ellipsoid,
+      fromBoundingSphereMatrixScratch
+    );
+    const east = Matrix4_default.multiplyByPointAsVector(
+      fromENU,
+      Cartesian3_default.UNIT_X,
+      fromBoundingSphereEastScratch
     );
+    Cartesian3_default.normalize(east, east);
+    const north = Matrix4_default.multiplyByPointAsVector(
+      fromENU,
+      Cartesian3_default.UNIT_Y,
+      fromBoundingSphereNorthScratch
+    );
+    Cartesian3_default.normalize(north, north);
+    Cartesian3_default.multiplyByScalar(north, radius, north);
+    Cartesian3_default.multiplyByScalar(east, radius, east);
+    const south = Cartesian3_default.negate(north, fromBoundingSphereSouthScratch);
+    const west = Cartesian3_default.negate(east, fromBoundingSphereWestScratch);
+    const positions = fromBoundingSpherePositionsScratch;
+    let corner = positions[0];
+    Cartesian3_default.add(center, north, corner);
+    corner = positions[1];
+    Cartesian3_default.add(center, west, corner);
+    corner = positions[2];
+    Cartesian3_default.add(center, south, corner);
+    corner = positions[3];
+    Cartesian3_default.add(center, east, corner);
+    positions[4] = center;
+    return _Rectangle.fromCartesianArray(positions, ellipsoid, result);
   }
-  result.west = rectangle.west;
-  result.south = rectangle.south;
-  result.east = rectangle.east;
-  result.north = rectangle.north;
-  return result;
-};
-Rectangle.equalsEpsilon = function(left, right, absoluteEpsilon) {
-  absoluteEpsilon = absoluteEpsilon ?? 0;
-  return left === right || defined_default(left) && defined_default(right) && Math.abs(left.west - right.west) <= absoluteEpsilon && Math.abs(left.south - right.south) <= absoluteEpsilon && Math.abs(left.east - right.east) <= absoluteEpsilon && Math.abs(left.north - right.north) <= absoluteEpsilon;
-};
-Rectangle.prototype.clone = function(result) {
-  return Rectangle.clone(this, result);
-};
-Rectangle.prototype.equals = function(other) {
-  return Rectangle.equals(this, other);
-};
-Rectangle.equals = function(left, right) {
-  return left === right || defined_default(left) && defined_default(right) && left.west === right.west && left.south === right.south && left.east === right.east && left.north === right.north;
-};
-Rectangle.prototype.equalsEpsilon = function(other, epsilon) {
-  return Rectangle.equalsEpsilon(this, other, epsilon);
-};
-Rectangle._validate = function(rectangle) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  const north = rectangle.north;
-  Check_default.typeOf.number.greaterThanOrEquals(
-    "north",
-    north,
-    -Math_default.PI_OVER_TWO
-  );
-  Check_default.typeOf.number.lessThanOrEquals("north", north, Math_default.PI_OVER_TWO);
-  const south = rectangle.south;
-  Check_default.typeOf.number.greaterThanOrEquals(
-    "south",
-    south,
-    -Math_default.PI_OVER_TWO
-  );
-  Check_default.typeOf.number.lessThanOrEquals("south", south, Math_default.PI_OVER_TWO);
-  const west = rectangle.west;
-  Check_default.typeOf.number.greaterThanOrEquals("west", west, -Math.PI);
-  Check_default.typeOf.number.lessThanOrEquals("west", west, Math.PI);
-  const east = rectangle.east;
-  Check_default.typeOf.number.greaterThanOrEquals("east", east, -Math.PI);
-  Check_default.typeOf.number.lessThanOrEquals("east", east, Math.PI);
-};
-Rectangle.southwest = function(rectangle, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  if (!defined_default(result)) {
-    return new Cartographic_default(rectangle.west, rectangle.south);
+  /**
+   * Duplicates a Rectangle.
+   *
+   * @param {Rectangle} rectangle The rectangle to clone.
+   * @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided. (Returns undefined if rectangle is undefined)
+   */
+  static clone(rectangle, result) {
+    if (!defined_default(rectangle)) {
+      return void 0;
+    }
+    if (!defined_default(result)) {
+      return new _Rectangle(
+        rectangle.west,
+        rectangle.south,
+        rectangle.east,
+        rectangle.north
+      );
+    }
+    result.west = rectangle.west;
+    result.south = rectangle.south;
+    result.east = rectangle.east;
+    result.north = rectangle.north;
+    return result;
   }
-  result.longitude = rectangle.west;
-  result.latitude = rectangle.south;
-  result.height = 0;
-  return result;
-};
-Rectangle.northwest = function(rectangle, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  if (!defined_default(result)) {
-    return new Cartographic_default(rectangle.west, rectangle.north);
+  /**
+   * Compares the provided Rectangles componentwise and returns
+   * <code>true</code> if they pass an absolute or relative tolerance test,
+   * <code>false</code> otherwise.
+   *
+   * @param {Rectangle} [left] The first Rectangle.
+   * @param {Rectangle} [right] The second Rectangle.
+   * @param {number} [absoluteEpsilon=0] The absolute epsilon tolerance to use for equality testing.
+   * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+   */
+  static equalsEpsilon(left, right, absoluteEpsilon) {
+    absoluteEpsilon = absoluteEpsilon ?? 0;
+    return left === right || defined_default(left) && defined_default(right) && Math.abs(left.west - right.west) <= absoluteEpsilon && Math.abs(left.south - right.south) <= absoluteEpsilon && Math.abs(left.east - right.east) <= absoluteEpsilon && Math.abs(left.north - right.north) <= absoluteEpsilon;
   }
-  result.longitude = rectangle.west;
-  result.latitude = rectangle.north;
-  result.height = 0;
-  return result;
-};
-Rectangle.northeast = function(rectangle, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  if (!defined_default(result)) {
-    return new Cartographic_default(rectangle.east, rectangle.north);
+  /**
+   * Duplicates this Rectangle.
+   *
+   * @param {Rectangle} [result] The object onto which to store the result.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
+   */
+  clone(result) {
+    return _Rectangle.clone(this, result);
   }
-  result.longitude = rectangle.east;
-  result.latitude = rectangle.north;
-  result.height = 0;
-  return result;
-};
-Rectangle.southeast = function(rectangle, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  if (!defined_default(result)) {
-    return new Cartographic_default(rectangle.east, rectangle.south);
+  /**
+   * Compares the provided Rectangle with this Rectangle componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {Rectangle} [other] The Rectangle to compare.
+   * @returns {boolean} <code>true</code> if the Rectangles are equal, <code>false</code> otherwise.
+   */
+  equals(other) {
+    return _Rectangle.equals(this, other);
   }
-  result.longitude = rectangle.east;
-  result.latitude = rectangle.south;
-  result.height = 0;
-  return result;
-};
-Rectangle.center = function(rectangle, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  let east = rectangle.east;
-  const west = rectangle.west;
-  if (east < west) {
-    east += Math_default.TWO_PI;
+  /**
+   * Compares the provided rectangles and returns <code>true</code> if they are equal,
+   * <code>false</code> otherwise.
+   *
+   * @param {Rectangle} [left] The first Rectangle.
+   * @param {Rectangle} [right] The second Rectangle.
+   * @returns {boolean} <code>true</code> if left and right are equal; otherwise <code>false</code>.
+   */
+  static equals(left, right) {
+    return left === right || defined_default(left) && defined_default(right) && left.west === right.west && left.south === right.south && left.east === right.east && left.north === right.north;
   }
-  const longitude = Math_default.negativePiToPi((west + east) * 0.5);
-  const latitude = (rectangle.south + rectangle.north) * 0.5;
-  if (!defined_default(result)) {
-    return new Cartographic_default(longitude, latitude);
+  /**
+   * Compares the provided Rectangle with this Rectangle componentwise and returns
+   * <code>true</code> if they are within the provided epsilon,
+   * <code>false</code> otherwise.
+   *
+   * @param {Rectangle} [other] The Rectangle to compare.
+   * @param {number} [epsilon=0] The epsilon to use for equality testing.
+   * @returns {boolean} <code>true</code> if the Rectangles are within the provided epsilon, <code>false</code> otherwise.
+   */
+  equalsEpsilon(other, epsilon) {
+    return _Rectangle.equalsEpsilon(this, other, epsilon);
   }
-  result.longitude = longitude;
-  result.latitude = latitude;
-  result.height = 0;
-  return result;
-};
-Rectangle.intersection = function(rectangle, otherRectangle, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  Check_default.typeOf.object("otherRectangle", otherRectangle);
-  let rectangleEast = rectangle.east;
-  let rectangleWest = rectangle.west;
-  let otherRectangleEast = otherRectangle.east;
-  let otherRectangleWest = otherRectangle.west;
-  if (rectangleEast < rectangleWest && otherRectangleEast > 0) {
-    rectangleEast += Math_default.TWO_PI;
-  } else if (otherRectangleEast < otherRectangleWest && rectangleEast > 0) {
-    otherRectangleEast += Math_default.TWO_PI;
-  }
-  if (rectangleEast < rectangleWest && otherRectangleWest < 0) {
-    otherRectangleWest += Math_default.TWO_PI;
-  } else if (otherRectangleEast < otherRectangleWest && rectangleWest < 0) {
-    rectangleWest += Math_default.TWO_PI;
-  }
-  const west = Math_default.negativePiToPi(
-    Math.max(rectangleWest, otherRectangleWest)
-  );
-  const east = Math_default.negativePiToPi(
-    Math.min(rectangleEast, otherRectangleEast)
-  );
-  if ((rectangle.west < rectangle.east || otherRectangle.west < otherRectangle.east) && east <= west) {
-    return void 0;
+  /**
+   * Checks a Rectangle's properties and throws if they are not in valid ranges.
+   *
+   * @param {Rectangle} rectangle The rectangle to validate
+   *
+   * @exception {DeveloperError} <code>north</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
+   * @exception {DeveloperError} <code>south</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
+   * @exception {DeveloperError} <code>east</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
+   * @exception {DeveloperError} <code>west</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
+   * @private
+   */
+  static _validate(rectangle) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    const north = rectangle.north;
+    Check_default.typeOf.number.greaterThanOrEquals(
+      "north",
+      north,
+      -Math_default.PI_OVER_TWO
+    );
+    Check_default.typeOf.number.lessThanOrEquals(
+      "north",
+      north,
+      Math_default.PI_OVER_TWO
+    );
+    const south = rectangle.south;
+    Check_default.typeOf.number.greaterThanOrEquals(
+      "south",
+      south,
+      -Math_default.PI_OVER_TWO
+    );
+    Check_default.typeOf.number.lessThanOrEquals(
+      "south",
+      south,
+      Math_default.PI_OVER_TWO
+    );
+    const west = rectangle.west;
+    Check_default.typeOf.number.greaterThanOrEquals("west", west, -Math.PI);
+    Check_default.typeOf.number.lessThanOrEquals("west", west, Math.PI);
+    const east = rectangle.east;
+    Check_default.typeOf.number.greaterThanOrEquals("east", east, -Math.PI);
+    Check_default.typeOf.number.lessThanOrEquals("east", east, Math.PI);
   }
-  const south = Math.max(rectangle.south, otherRectangle.south);
-  const north = Math.min(rectangle.north, otherRectangle.north);
-  if (south >= north) {
-    return void 0;
+  /**
+   * Computes the southwest corner of a rectangle.
+   *
+   * @param {Rectangle} rectangle The rectangle for which to find the corner
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
+   */
+  static southwest(rectangle, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    if (!defined_default(result)) {
+      return new Cartographic_default(rectangle.west, rectangle.south);
+    }
+    result.longitude = rectangle.west;
+    result.latitude = rectangle.south;
+    result.height = 0;
+    return result;
   }
-  if (!defined_default(result)) {
-    return new Rectangle(west, south, east, north);
+  /**
+   * Computes the northwest corner of a rectangle.
+   *
+   * @param {Rectangle} rectangle The rectangle for which to find the corner
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
+   */
+  static northwest(rectangle, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    if (!defined_default(result)) {
+      return new Cartographic_default(rectangle.west, rectangle.north);
+    }
+    result.longitude = rectangle.west;
+    result.latitude = rectangle.north;
+    result.height = 0;
+    return result;
   }
-  result.west = west;
-  result.south = south;
-  result.east = east;
-  result.north = north;
-  return result;
-};
-Rectangle.simpleIntersection = function(rectangle, otherRectangle, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  Check_default.typeOf.object("otherRectangle", otherRectangle);
-  const west = Math.max(rectangle.west, otherRectangle.west);
-  const south = Math.max(rectangle.south, otherRectangle.south);
-  const east = Math.min(rectangle.east, otherRectangle.east);
-  const north = Math.min(rectangle.north, otherRectangle.north);
-  if (south >= north || west >= east) {
-    return void 0;
+  /**
+   * Computes the northeast corner of a rectangle.
+   *
+   * @param {Rectangle} rectangle The rectangle for which to find the corner
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
+   */
+  static northeast(rectangle, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    if (!defined_default(result)) {
+      return new Cartographic_default(rectangle.east, rectangle.north);
+    }
+    result.longitude = rectangle.east;
+    result.latitude = rectangle.north;
+    result.height = 0;
+    return result;
   }
-  if (!defined_default(result)) {
-    return new Rectangle(west, south, east, north);
+  /**
+   * Computes the southeast corner of a rectangle.
+   *
+   * @param {Rectangle} rectangle The rectangle for which to find the corner
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
+   */
+  static southeast(rectangle, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    if (!defined_default(result)) {
+      return new Cartographic_default(rectangle.east, rectangle.south);
+    }
+    result.longitude = rectangle.east;
+    result.latitude = rectangle.south;
+    result.height = 0;
+    return result;
   }
-  result.west = west;
-  result.south = south;
-  result.east = east;
-  result.north = north;
-  return result;
-};
-Rectangle.union = function(rectangle, otherRectangle, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  Check_default.typeOf.object("otherRectangle", otherRectangle);
-  if (!defined_default(result)) {
-    result = new Rectangle();
-  }
-  let rectangleEast = rectangle.east;
-  let rectangleWest = rectangle.west;
-  let otherRectangleEast = otherRectangle.east;
-  let otherRectangleWest = otherRectangle.west;
-  if (rectangleEast < rectangleWest && otherRectangleEast > 0) {
-    rectangleEast += Math_default.TWO_PI;
-  } else if (otherRectangleEast < otherRectangleWest && rectangleEast > 0) {
-    otherRectangleEast += Math_default.TWO_PI;
-  }
-  if (rectangleEast < rectangleWest && otherRectangleWest < 0) {
-    otherRectangleWest += Math_default.TWO_PI;
-  } else if (otherRectangleEast < otherRectangleWest && rectangleWest < 0) {
-    rectangleWest += Math_default.TWO_PI;
-  }
-  const west = Math_default.negativePiToPi(
-    Math.min(rectangleWest, otherRectangleWest)
-  );
-  const east = Math_default.negativePiToPi(
-    Math.max(rectangleEast, otherRectangleEast)
-  );
-  result.west = west;
-  result.south = Math.min(rectangle.south, otherRectangle.south);
-  result.east = east;
-  result.north = Math.max(rectangle.north, otherRectangle.north);
-  return result;
-};
-Rectangle.expand = function(rectangle, cartographic, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  Check_default.typeOf.object("cartographic", cartographic);
-  if (!defined_default(result)) {
-    result = new Rectangle();
+  /**
+   * Computes the center of a rectangle.
+   *
+   * @param {Rectangle} rectangle The rectangle for which to find the center
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
+   */
+  static center(rectangle, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    let east = rectangle.east;
+    const west = rectangle.west;
+    if (east < west) {
+      east += Math_default.TWO_PI;
+    }
+    const longitude = Math_default.negativePiToPi((west + east) * 0.5);
+    const latitude = (rectangle.south + rectangle.north) * 0.5;
+    if (!defined_default(result)) {
+      return new Cartographic_default(longitude, latitude);
+    }
+    result.longitude = longitude;
+    result.latitude = latitude;
+    result.height = 0;
+    return result;
   }
-  result.west = Math.min(rectangle.west, cartographic.longitude);
-  result.south = Math.min(rectangle.south, cartographic.latitude);
-  result.east = Math.max(rectangle.east, cartographic.longitude);
-  result.north = Math.max(rectangle.north, cartographic.latitude);
-  return result;
-};
-Rectangle.contains = function(rectangle, cartographic) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  Check_default.typeOf.object("cartographic", cartographic);
-  let longitude = cartographic.longitude;
-  const latitude = cartographic.latitude;
-  const west = rectangle.west;
-  let east = rectangle.east;
-  if (east < west) {
-    east += Math_default.TWO_PI;
-    if (longitude < 0) {
-      longitude += Math_default.TWO_PI;
+  /**
+   * Computes the intersection of two rectangles.  This function assumes that the rectangle's coordinates are
+   * latitude and longitude in radians and produces a correct intersection, taking into account the fact that
+   * the same angle can be represented with multiple values as well as the wrapping of longitude at the
+   * anti-meridian.  For a simple intersection that ignores these factors and can be used with projected
+   * coordinates, see {@link Rectangle.simpleIntersection}.
+   *
+   * @param {Rectangle} rectangle On rectangle to find an intersection
+   * @param {Rectangle} otherRectangle Another rectangle to find an intersection
+   * @param {Rectangle} [result] The object onto which to store the result.
+   * @returns {Rectangle|undefined} The modified result parameter, a new Rectangle instance if none was provided or undefined if there is no intersection.
+   */
+  static intersection(rectangle, otherRectangle, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    Check_default.typeOf.object("otherRectangle", otherRectangle);
+    let rectangleEast = rectangle.east;
+    let rectangleWest = rectangle.west;
+    let otherRectangleEast = otherRectangle.east;
+    let otherRectangleWest = otherRectangle.west;
+    if (rectangleEast < rectangleWest && otherRectangleEast > 0) {
+      rectangleEast += Math_default.TWO_PI;
+    } else if (otherRectangleEast < otherRectangleWest && rectangleEast > 0) {
+      otherRectangleEast += Math_default.TWO_PI;
+    }
+    if (rectangleEast < rectangleWest && otherRectangleWest < 0) {
+      otherRectangleWest += Math_default.TWO_PI;
+    } else if (otherRectangleEast < otherRectangleWest && rectangleWest < 0) {
+      rectangleWest += Math_default.TWO_PI;
     }
+    const west = Math_default.negativePiToPi(
+      Math.max(rectangleWest, otherRectangleWest)
+    );
+    const east = Math_default.negativePiToPi(
+      Math.min(rectangleEast, otherRectangleEast)
+    );
+    if ((rectangle.west < rectangle.east || otherRectangle.west < otherRectangle.east) && east <= west) {
+      return void 0;
+    }
+    const south = Math.max(rectangle.south, otherRectangle.south);
+    const north = Math.min(rectangle.north, otherRectangle.north);
+    if (south >= north) {
+      return void 0;
+    }
+    if (!defined_default(result)) {
+      return new _Rectangle(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
   }
-  return (longitude > west || Math_default.equalsEpsilon(longitude, west, Math_default.EPSILON14)) && (longitude < east || Math_default.equalsEpsilon(longitude, east, Math_default.EPSILON14)) && latitude >= rectangle.south && latitude <= rectangle.north;
-};
-var subsampleLlaScratch = new Cartographic_default();
-Rectangle.subsample = function(rectangle, ellipsoid, surfaceHeight, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  ellipsoid = ellipsoid ?? Ellipsoid_default.default;
-  surfaceHeight = surfaceHeight ?? 0;
-  if (!defined_default(result)) {
-    result = [];
-  }
-  let length = 0;
-  const north = rectangle.north;
-  const south = rectangle.south;
-  const east = rectangle.east;
-  const west = rectangle.west;
-  const lla = subsampleLlaScratch;
-  lla.height = surfaceHeight;
-  lla.longitude = west;
-  lla.latitude = north;
-  result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
-  length++;
-  lla.longitude = east;
-  result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
-  length++;
-  lla.latitude = south;
-  result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
-  length++;
-  lla.longitude = west;
-  result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
-  length++;
-  if (north < 0) {
-    lla.latitude = north;
-  } else if (south > 0) {
-    lla.latitude = south;
-  } else {
-    lla.latitude = 0;
+  /**
+   * Computes a simple intersection of two rectangles.  Unlike {@link Rectangle.intersection}, this function
+   * does not attempt to put the angular coordinates into a consistent range or to account for crossing the
+   * anti-meridian.  As such, it can be used for rectangles where the coordinates are not simply latitude
+   * and longitude (i.e. projected coordinates).
+   *
+   * @param {Rectangle} rectangle On rectangle to find an intersection
+   * @param {Rectangle} otherRectangle Another rectangle to find an intersection
+   * @param {Rectangle} [result] The object onto which to store the result.
+   * @returns {Rectangle|undefined} The modified result parameter, a new Rectangle instance if none was provided or undefined if there is no intersection.
+   */
+  static simpleIntersection(rectangle, otherRectangle, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    Check_default.typeOf.object("otherRectangle", otherRectangle);
+    const west = Math.max(rectangle.west, otherRectangle.west);
+    const south = Math.max(rectangle.south, otherRectangle.south);
+    const east = Math.min(rectangle.east, otherRectangle.east);
+    const north = Math.min(rectangle.north, otherRectangle.north);
+    if (south >= north || west >= east) {
+      return void 0;
+    }
+    if (!defined_default(result)) {
+      return new _Rectangle(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
   }
-  for (let i = 1; i < 8; ++i) {
-    lla.longitude = -Math.PI + i * Math_default.PI_OVER_TWO;
-    if (Rectangle.contains(rectangle, lla)) {
-      result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
-      length++;
+  /**
+   * Computes a rectangle that is the union of two rectangles.
+   *
+   * @param {Rectangle} rectangle A rectangle to enclose in rectangle.
+   * @param {Rectangle} otherRectangle A rectangle to enclose in a rectangle.
+   * @param {Rectangle} [result] The object onto which to store the result.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
+   */
+  static union(rectangle, otherRectangle, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    Check_default.typeOf.object("otherRectangle", otherRectangle);
+    if (!defined_default(result)) {
+      result = new _Rectangle();
+    }
+    let rectangleEast = rectangle.east;
+    let rectangleWest = rectangle.west;
+    let otherRectangleEast = otherRectangle.east;
+    let otherRectangleWest = otherRectangle.west;
+    if (rectangleEast < rectangleWest && otherRectangleEast > 0) {
+      rectangleEast += Math_default.TWO_PI;
+    } else if (otherRectangleEast < otherRectangleWest && rectangleEast > 0) {
+      otherRectangleEast += Math_default.TWO_PI;
+    }
+    if (rectangleEast < rectangleWest && otherRectangleWest < 0) {
+      otherRectangleWest += Math_default.TWO_PI;
+    } else if (otherRectangleEast < otherRectangleWest && rectangleWest < 0) {
+      rectangleWest += Math_default.TWO_PI;
+    }
+    const west = Math_default.negativePiToPi(
+      Math.min(rectangleWest, otherRectangleWest)
+    );
+    const east = Math_default.negativePiToPi(
+      Math.max(rectangleEast, otherRectangleEast)
+    );
+    result.west = west;
+    result.south = Math.min(rectangle.south, otherRectangle.south);
+    result.east = east;
+    result.north = Math.max(rectangle.north, otherRectangle.north);
+    return result;
+  }
+  /**
+   * Computes a rectangle by enlarging the provided rectangle until it contains the provided cartographic.
+   *
+   * @param {Rectangle} rectangle A rectangle to expand.
+   * @param {Cartographic} cartographic A cartographic to enclose in a rectangle.
+   * @param {Rectangle} [result] The object onto which to store the result.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if one was not provided.
+   */
+  static expand(rectangle, cartographic, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    Check_default.typeOf.object("cartographic", cartographic);
+    if (!defined_default(result)) {
+      result = new _Rectangle();
+    }
+    result.west = Math.min(rectangle.west, cartographic.longitude);
+    result.south = Math.min(rectangle.south, cartographic.latitude);
+    result.east = Math.max(rectangle.east, cartographic.longitude);
+    result.north = Math.max(rectangle.north, cartographic.latitude);
+    return result;
+  }
+  /**
+   * Returns true if the cartographic is on or inside the rectangle, false otherwise.
+   *
+   * @param {Rectangle} rectangle The rectangle
+   * @param {Cartographic} cartographic The cartographic to test.
+   * @returns {boolean} true if the provided cartographic is inside the rectangle, false otherwise.
+   */
+  static contains(rectangle, cartographic) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    Check_default.typeOf.object("cartographic", cartographic);
+    let longitude = cartographic.longitude;
+    const latitude = cartographic.latitude;
+    const west = rectangle.west;
+    let east = rectangle.east;
+    if (east < west) {
+      east += Math_default.TWO_PI;
+      if (longitude < 0) {
+        longitude += Math_default.TWO_PI;
+      }
     }
+    return (longitude > west || Math_default.equalsEpsilon(longitude, west, Math_default.EPSILON14)) && (longitude < east || Math_default.equalsEpsilon(longitude, east, Math_default.EPSILON14)) && latitude >= rectangle.south && latitude <= rectangle.north;
   }
-  if (lla.latitude === 0) {
+  /**
+   * Samples a rectangle so that it includes a list of Cartesian points suitable for passing to
+   * {@link BoundingSphere#fromPoints}.  Sampling is necessary to account
+   * for rectangles that cover the poles or cross the equator.
+   *
+   * @param {Rectangle} rectangle The rectangle to subsample.
+   * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid to use.
+   * @param {number} [surfaceHeight=0.0] The height of the rectangle above the ellipsoid.
+   * @param {Cartesian3[]} [result] The array of Cartesians onto which to store the result.
+   * @returns {Cartesian3[]} The modified result parameter or a new Array of Cartesians instances if none was provided.
+   */
+  static subsample(rectangle, ellipsoid, surfaceHeight, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    ellipsoid = ellipsoid ?? Ellipsoid_default.default;
+    surfaceHeight = surfaceHeight ?? 0;
+    if (!defined_default(result)) {
+      result = [];
+    }
+    let length = 0;
+    const north = rectangle.north;
+    const south = rectangle.south;
+    const east = rectangle.east;
+    const west = rectangle.west;
+    const lla = subsampleLlaScratch;
+    lla.height = surfaceHeight;
     lla.longitude = west;
+    lla.latitude = north;
     result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
     length++;
     lla.longitude = east;
     result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
     length++;
+    lla.latitude = south;
+    result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
+    length++;
+    lla.longitude = west;
+    result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
+    length++;
+    if (north < 0) {
+      lla.latitude = north;
+    } else if (south > 0) {
+      lla.latitude = south;
+    } else {
+      lla.latitude = 0;
+    }
+    for (let i = 1; i < 8; ++i) {
+      lla.longitude = -Math.PI + i * Math_default.PI_OVER_TWO;
+      if (_Rectangle.contains(rectangle, lla)) {
+        result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
+        length++;
+      }
+    }
+    if (lla.latitude === 0) {
+      lla.longitude = west;
+      result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
+      length++;
+      lla.longitude = east;
+      result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
+      length++;
+    }
+    result.length = length;
+    return result;
   }
-  result.length = length;
-  return result;
-};
-Rectangle.subsection = function(rectangle, westLerp, southLerp, eastLerp, northLerp, result) {
-  Check_default.typeOf.object("rectangle", rectangle);
-  Check_default.typeOf.number.greaterThanOrEquals("westLerp", westLerp, 0);
-  Check_default.typeOf.number.lessThanOrEquals("westLerp", westLerp, 1);
-  Check_default.typeOf.number.greaterThanOrEquals("southLerp", southLerp, 0);
-  Check_default.typeOf.number.lessThanOrEquals("southLerp", southLerp, 1);
-  Check_default.typeOf.number.greaterThanOrEquals("eastLerp", eastLerp, 0);
-  Check_default.typeOf.number.lessThanOrEquals("eastLerp", eastLerp, 1);
-  Check_default.typeOf.number.greaterThanOrEquals("northLerp", northLerp, 0);
-  Check_default.typeOf.number.lessThanOrEquals("northLerp", northLerp, 1);
-  Check_default.typeOf.number.lessThanOrEquals("westLerp", westLerp, eastLerp);
-  Check_default.typeOf.number.lessThanOrEquals("southLerp", southLerp, northLerp);
-  if (!defined_default(result)) {
-    result = new Rectangle();
-  }
-  if (rectangle.west <= rectangle.east) {
-    const width = rectangle.east - rectangle.west;
-    result.west = rectangle.west + westLerp * width;
-    result.east = rectangle.west + eastLerp * width;
-  } else {
-    const width = Math_default.TWO_PI + rectangle.east - rectangle.west;
-    result.west = Math_default.negativePiToPi(rectangle.west + westLerp * width);
-    result.east = Math_default.negativePiToPi(rectangle.west + eastLerp * width);
-  }
-  const height = rectangle.north - rectangle.south;
-  result.south = rectangle.south + southLerp * height;
-  result.north = rectangle.south + northLerp * height;
-  if (westLerp === 1) {
-    result.west = rectangle.east;
-  }
-  if (eastLerp === 1) {
-    result.east = rectangle.east;
-  }
-  if (southLerp === 1) {
-    result.south = rectangle.north;
-  }
-  if (northLerp === 1) {
-    result.north = rectangle.north;
+  /**
+   * Computes a subsection of a rectangle from normalized coordinates in the range [0.0, 1.0].
+   *
+   * @param {Rectangle} rectangle The rectangle to subsection.
+   * @param {number} westLerp The west interpolation factor in the range [0.0, 1.0]. Must be less than or equal to eastLerp.
+   * @param {number} southLerp The south interpolation factor in the range [0.0, 1.0]. Must be less than or equal to northLerp.
+   * @param {number} eastLerp The east interpolation factor in the range [0.0, 1.0]. Must be greater than or equal to westLerp.
+   * @param {number} northLerp The north interpolation factor in the range [0.0, 1.0]. Must be greater than or equal to southLerp.
+   * @param {Rectangle} [result] The object onto which to store the result.
+   * @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
+   */
+  static subsection(rectangle, westLerp, southLerp, eastLerp, northLerp, result) {
+    Check_default.typeOf.object("rectangle", rectangle);
+    Check_default.typeOf.number.greaterThanOrEquals("westLerp", westLerp, 0);
+    Check_default.typeOf.number.lessThanOrEquals("westLerp", westLerp, 1);
+    Check_default.typeOf.number.greaterThanOrEquals("southLerp", southLerp, 0);
+    Check_default.typeOf.number.lessThanOrEquals("southLerp", southLerp, 1);
+    Check_default.typeOf.number.greaterThanOrEquals("eastLerp", eastLerp, 0);
+    Check_default.typeOf.number.lessThanOrEquals("eastLerp", eastLerp, 1);
+    Check_default.typeOf.number.greaterThanOrEquals("northLerp", northLerp, 0);
+    Check_default.typeOf.number.lessThanOrEquals("northLerp", northLerp, 1);
+    Check_default.typeOf.number.lessThanOrEquals("westLerp", westLerp, eastLerp);
+    Check_default.typeOf.number.lessThanOrEquals("southLerp", southLerp, northLerp);
+    if (!defined_default(result)) {
+      result = new _Rectangle();
+    }
+    if (rectangle.west <= rectangle.east) {
+      const width = rectangle.east - rectangle.west;
+      result.west = rectangle.west + westLerp * width;
+      result.east = rectangle.west + eastLerp * width;
+    } else {
+      const width = Math_default.TWO_PI + rectangle.east - rectangle.west;
+      result.west = Math_default.negativePiToPi(
+        rectangle.west + westLerp * width
+      );
+      result.east = Math_default.negativePiToPi(
+        rectangle.west + eastLerp * width
+      );
+    }
+    const height = rectangle.north - rectangle.south;
+    result.south = rectangle.south + southLerp * height;
+    result.north = rectangle.south + northLerp * height;
+    if (westLerp === 1) {
+      result.west = rectangle.east;
+    }
+    if (eastLerp === 1) {
+      result.east = rectangle.east;
+    }
+    if (southLerp === 1) {
+      result.south = rectangle.north;
+    }
+    if (northLerp === 1) {
+      result.north = rectangle.north;
+    }
+    return result;
   }
-  return result;
 };
+Rectangle.packedLength = 4;
+var fromBoundingSphereMatrixScratch = new Matrix4_default();
+var fromBoundingSphereEastScratch = new Cartesian3_default();
+var fromBoundingSphereNorthScratch = new Cartesian3_default();
+var fromBoundingSphereWestScratch = new Cartesian3_default();
+var fromBoundingSphereSouthScratch = new Cartesian3_default();
+var fromBoundingSpherePositionsScratch = new Array(5);
+for (let n = 0; n < fromBoundingSpherePositionsScratch.length; ++n) {
+  fromBoundingSpherePositionsScratch[n] = new Cartesian3_default();
+}
+var subsampleLlaScratch = new Cartographic_default();
 Rectangle.MAX_VALUE = Object.freeze(
   new Rectangle(
     -Math.PI,
@@ -7942,413 +8416,803 @@ Rectangle.MAX_VALUE = Object.freeze(
 var Rectangle_default = Rectangle;
 
 // packages/engine/Source/Core/Matrix2.js
-function Matrix2(column0Row0, column1Row0, column0Row1, column1Row1) {
-  this[0] = column0Row0 ?? 0;
-  this[1] = column0Row1 ?? 0;
-  this[2] = column1Row0 ?? 0;
-  this[3] = column1Row1 ?? 0;
-}
-Matrix2.packedLength = 4;
-Matrix2.pack = function(value, array, startingIndex) {
-  Check_default.typeOf.object("value", value);
-  Check_default.defined("array", array);
-  startingIndex = startingIndex ?? 0;
-  array[startingIndex++] = value[0];
-  array[startingIndex++] = value[1];
-  array[startingIndex++] = value[2];
-  array[startingIndex++] = value[3];
-  return array;
-};
-Matrix2.unpack = function(array, startingIndex, result) {
-  Check_default.defined("array", array);
-  startingIndex = startingIndex ?? 0;
-  if (!defined_default(result)) {
-    result = new Matrix2();
+var Matrix2 = class _Matrix2 {
+  /**
+   * @param {number} [column0Row0=0.0] The value for column 0, row 0.
+   * @param {number} [column1Row0=0.0] The value for column 1, row 0.
+   * @param {number} [column0Row1=0.0] The value for column 0, row 1.
+   * @param {number} [column1Row1=0.0] The value for column 1, row 1.
+   */
+  constructor(column0Row0, column1Row0, column0Row1, column1Row1) {
+    this[0] = column0Row0 ?? 0;
+    this[1] = column0Row1 ?? 0;
+    this[2] = column1Row0 ?? 0;
+    this[3] = column1Row1 ?? 0;
   }
-  result[0] = array[startingIndex++];
-  result[1] = array[startingIndex++];
-  result[2] = array[startingIndex++];
-  result[3] = array[startingIndex++];
-  return result;
-};
-Matrix2.packArray = function(array, result) {
-  Check_default.defined("array", array);
-  const length = array.length;
-  const resultLength = length * 4;
-  if (!defined_default(result)) {
-    result = new Array(resultLength);
-  } else if (!Array.isArray(result) && result.length !== resultLength) {
-    throw new DeveloperError_default(
-      "If result is a typed array, it must have exactly array.length * 4 elements"
-    );
-  } else if (result.length !== resultLength) {
-    result.length = resultLength;
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {Matrix2} value The value to pack.
+   * @param {number[]} array The array to pack into.
+   * @param {number} [startingIndex=0] The index into the array at which to start packing the elements.
+   *
+   * @returns {number[]} The array that was packed into
+   */
+  static pack(value, array, startingIndex) {
+    Check_default.typeOf.object("value", value);
+    Check_default.defined("array", array);
+    startingIndex = startingIndex ?? 0;
+    array[startingIndex++] = value[0];
+    array[startingIndex++] = value[1];
+    array[startingIndex++] = value[2];
+    array[startingIndex++] = value[3];
+    return array;
   }
-  for (let i = 0; i < length; ++i) {
-    Matrix2.pack(array[i], result, i * 4);
+  /**
+   * Retrieves an instance from a packed array.
+   *
+   * @param {number[]} array The packed array.
+   * @param {number} [startingIndex=0] The starting index of the element to be unpacked.
+   * @param {Matrix2} [result] The object into which to store the result.
+   * @returns {Matrix2} The modified result parameter or a new Matrix2 instance if one was not provided.
+   */
+  static unpack(array, startingIndex, result) {
+    Check_default.defined("array", array);
+    startingIndex = startingIndex ?? 0;
+    if (!defined_default(result)) {
+      result = new _Matrix2();
+    }
+    result[0] = array[startingIndex++];
+    result[1] = array[startingIndex++];
+    result[2] = array[startingIndex++];
+    result[3] = array[startingIndex++];
+    return result;
   }
-  return result;
-};
-Matrix2.unpackArray = function(array, result) {
-  Check_default.defined("array", array);
-  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 4);
-  if (array.length % 4 !== 0) {
-    throw new DeveloperError_default("array length must be a multiple of 4.");
+  /**
+   * Flattens an array of Matrix2s into an array of components. The components
+   * are stored in column-major order.
+   *
+   * @param {Matrix2[]} array The array of matrices to pack.
+   * @param {number[]} [result] The array onto which to store the result. If this is a typed array, it must have array.length * 4 components, else a {@link DeveloperError} will be thrown. If it is a regular array, it will be resized to have (array.length * 4) elements.
+   * @returns {number[]} The packed array.
+   */
+  static packArray(array, result) {
+    Check_default.defined("array", array);
+    const length = array.length;
+    const resultLength = length * 4;
+    if (!defined_default(result)) {
+      result = new Array(resultLength);
+    } else if (!Array.isArray(result) && result.length !== resultLength) {
+      throw new DeveloperError_default(
+        "If result is a typed array, it must have exactly array.length * 4 elements"
+      );
+    } else if (result.length !== resultLength) {
+      result.length = resultLength;
+    }
+    for (let i = 0; i < length; ++i) {
+      _Matrix2.pack(array[i], result, i * 4);
+    }
+    return result;
   }
-  const length = array.length;
-  if (!defined_default(result)) {
-    result = new Array(length / 4);
-  } else {
-    result.length = length / 4;
+  /**
+   * Unpacks an array of column-major matrix components into an array of Matrix2s.
+   *
+   * @param {number[]} array The array of components to unpack.
+   * @param {Matrix2[]} [result] The array onto which to store the result.
+   * @returns {Matrix2[]} The unpacked array.
+   */
+  static unpackArray(array, result) {
+    Check_default.defined("array", array);
+    Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 4);
+    if (array.length % 4 !== 0) {
+      throw new DeveloperError_default("array length must be a multiple of 4.");
+    }
+    const length = array.length;
+    if (!defined_default(result)) {
+      result = new Array(length / 4);
+    } else {
+      result.length = length / 4;
+    }
+    for (let i = 0; i < length; i += 4) {
+      const index = i / 4;
+      result[index] = _Matrix2.unpack(array, i, result[index]);
+    }
+    return result;
   }
-  for (let i = 0; i < length; i += 4) {
-    const index = i / 4;
-    result[index] = Matrix2.unpack(array, i, result[index]);
+  /**
+   * Duplicates a Matrix2 instance.
+   *
+   * @param {Matrix2} matrix The matrix to duplicate.
+   * @param {Matrix2} [result] The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter or a new Matrix2 instance if one was not provided. (Returns undefined if matrix is undefined)
+   */
+  static clone(matrix, result) {
+    if (!defined_default(matrix)) {
+      return void 0;
+    }
+    if (!defined_default(result)) {
+      return new _Matrix2(matrix[0], matrix[2], matrix[1], matrix[3]);
+    }
+    result[0] = matrix[0];
+    result[1] = matrix[1];
+    result[2] = matrix[2];
+    result[3] = matrix[3];
+    return result;
   }
-  return result;
-};
-Matrix2.clone = function(matrix, result) {
-  if (!defined_default(matrix)) {
-    return void 0;
+  /**
+   * Creates a Matrix2 instance from a column-major order array.
+   *
+   * @param {number[]} values The column-major order array.
+   * @param {Matrix2} [result] The object in which the result will be stored, if undefined a new instance will be created.
+   * @returns {Matrix2} The modified result parameter, or a new Matrix2 instance if one was not provided.
+   */
+  static fromColumnMajorArray(values, result) {
+    Check_default.defined("values", values);
+    return _Matrix2.clone(values, result);
   }
-  if (!defined_default(result)) {
-    return new Matrix2(matrix[0], matrix[2], matrix[1], matrix[3]);
+  /**
+   * Creates a Matrix2 instance from a row-major order array.
+   * The resulting matrix will be in column-major order.
+   *
+   * @param {number[]} values The row-major order array.
+   * @param {Matrix2} [result] The object in which the result will be stored, if undefined a new instance will be created.
+   * @returns {Matrix2} The modified result parameter, or a new Matrix2 instance if one was not provided.
+   */
+  static fromRowMajorArray(values, result) {
+    Check_default.defined("values", values);
+    if (!defined_default(result)) {
+      return new _Matrix2(values[0], values[1], values[2], values[3]);
+    }
+    result[0] = values[0];
+    result[1] = values[2];
+    result[2] = values[1];
+    result[3] = values[3];
+    return result;
   }
-  result[0] = matrix[0];
-  result[1] = matrix[1];
-  result[2] = matrix[2];
-  result[3] = matrix[3];
-  return result;
-};
-Matrix2.fromArray = Matrix2.unpack;
-Matrix2.fromColumnMajorArray = function(values, result) {
-  Check_default.defined("values", values);
-  return Matrix2.clone(values, result);
-};
-Matrix2.fromRowMajorArray = function(values, result) {
-  Check_default.defined("values", values);
-  if (!defined_default(result)) {
-    return new Matrix2(values[0], values[1], values[2], values[3]);
+  /**
+   * Computes a Matrix2 instance representing a non-uniform scale.
+   *
+   * @param {Cartesian2} scale The x and y scale factors.
+   * @param {Matrix2} [result] The object in which the result will be stored, if undefined a new instance will be created.
+   * @returns {Matrix2} The modified result parameter, or a new Matrix2 instance if one was not provided.
+   *
+   * @example
+   * // Creates
+   * //   [7.0, 0.0]
+   * //   [0.0, 8.0]
+   * const m = Cesium.Matrix2.fromScale(new Cesium.Cartesian2(7.0, 8.0));
+   */
+  static fromScale(scale, result) {
+    Check_default.typeOf.object("scale", scale);
+    if (!defined_default(result)) {
+      return new _Matrix2(scale.x, 0, 0, scale.y);
+    }
+    result[0] = scale.x;
+    result[1] = 0;
+    result[2] = 0;
+    result[3] = scale.y;
+    return result;
   }
-  result[0] = values[0];
-  result[1] = values[2];
-  result[2] = values[1];
-  result[3] = values[3];
-  return result;
-};
-Matrix2.fromScale = function(scale, result) {
-  Check_default.typeOf.object("scale", scale);
-  if (!defined_default(result)) {
-    return new Matrix2(scale.x, 0, 0, scale.y);
+  /**
+   * Computes a Matrix2 instance representing a uniform scale.
+   *
+   * @param {number} scale The uniform scale factor.
+   * @param {Matrix2} [result] The object in which the result will be stored, if undefined a new instance will be created.
+   * @returns {Matrix2} The modified result parameter, or a new Matrix2 instance if one was not provided.
+   *
+   * @example
+   * // Creates
+   * //   [2.0, 0.0]
+   * //   [0.0, 2.0]
+   * const m = Cesium.Matrix2.fromUniformScale(2.0);
+   */
+  static fromUniformScale(scale, result) {
+    Check_default.typeOf.number("scale", scale);
+    if (!defined_default(result)) {
+      return new _Matrix2(scale, 0, 0, scale);
+    }
+    result[0] = scale;
+    result[1] = 0;
+    result[2] = 0;
+    result[3] = scale;
+    return result;
   }
-  result[0] = scale.x;
-  result[1] = 0;
-  result[2] = 0;
-  result[3] = scale.y;
-  return result;
-};
-Matrix2.fromUniformScale = function(scale, result) {
-  Check_default.typeOf.number("scale", scale);
-  if (!defined_default(result)) {
-    return new Matrix2(scale, 0, 0, scale);
+  /**
+   * Creates a rotation matrix.
+   *
+   * @param {number} angle The angle, in radians, of the rotation.  Positive angles are counterclockwise.
+   * @param {Matrix2} [result] The object in which the result will be stored, if undefined a new instance will be created.
+   * @returns {Matrix2} The modified result parameter, or a new Matrix2 instance if one was not provided.
+   *
+   * @example
+   * // Rotate a point 45 degrees counterclockwise.
+   * const p = new Cesium.Cartesian2(5, 6);
+   * const m = Cesium.Matrix2.fromRotation(Cesium.Math.toRadians(45.0));
+   * const rotated = Cesium.Matrix2.multiplyByVector(m, p, new Cesium.Cartesian2());
+   */
+  static fromRotation(angle, result) {
+    Check_default.typeOf.number("angle", angle);
+    const cosAngle = Math.cos(angle);
+    const sinAngle = Math.sin(angle);
+    if (!defined_default(result)) {
+      return new _Matrix2(cosAngle, -sinAngle, sinAngle, cosAngle);
+    }
+    result[0] = cosAngle;
+    result[1] = sinAngle;
+    result[2] = -sinAngle;
+    result[3] = cosAngle;
+    return result;
   }
-  result[0] = scale;
-  result[1] = 0;
-  result[2] = 0;
-  result[3] = scale;
-  return result;
-};
-Matrix2.fromRotation = function(angle, result) {
-  Check_default.typeOf.number("angle", angle);
-  const cosAngle = Math.cos(angle);
-  const sinAngle = Math.sin(angle);
-  if (!defined_default(result)) {
-    return new Matrix2(cosAngle, -sinAngle, sinAngle, cosAngle);
+  /**
+   * Creates an Array from the provided Matrix2 instance.
+   * The array will be in column-major order.
+   *
+   * @param {Matrix2} matrix The matrix to use..
+   * @param {number[]} [result] The Array onto which to store the result.
+   * @returns {number[]} The modified Array parameter or a new Array instance if one was not provided.
+   */
+  static toArray(matrix, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    if (!defined_default(result)) {
+      return [matrix[0], matrix[1], matrix[2], matrix[3]];
+    }
+    result[0] = matrix[0];
+    result[1] = matrix[1];
+    result[2] = matrix[2];
+    result[3] = matrix[3];
+    return result;
   }
-  result[0] = cosAngle;
-  result[1] = sinAngle;
-  result[2] = -sinAngle;
-  result[3] = cosAngle;
-  return result;
-};
-Matrix2.toArray = function(matrix, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  if (!defined_default(result)) {
-    return [matrix[0], matrix[1], matrix[2], matrix[3]];
+  /**
+   * Computes the array index of the element at the provided row and column.
+   *
+   * @param {number} row The zero-based index of the row.
+   * @param {number} column The zero-based index of the column.
+   * @returns {number} The index of the element at the provided row and column.
+   *
+   * @exception {DeveloperError} row must be 0 or 1.
+   * @exception {DeveloperError} column must be 0 or 1.
+   *
+   * @example
+   * const myMatrix = new Cesium.Matrix2();
+   * const column1Row0Index = Cesium.Matrix2.getElementIndex(1, 0);
+   * const column1Row0 = myMatrix[column1Row0Index]
+   * myMatrix[column1Row0Index] = 10.0;
+   */
+  static getElementIndex(column, row) {
+    Check_default.typeOf.number.greaterThanOrEquals("row", row, 0);
+    Check_default.typeOf.number.lessThanOrEquals("row", row, 1);
+    Check_default.typeOf.number.greaterThanOrEquals("column", column, 0);
+    Check_default.typeOf.number.lessThanOrEquals("column", column, 1);
+    return column * 2 + row;
+  }
+  /**
+   * Retrieves a copy of the matrix column at the provided index as a Cartesian2 instance.
+   *
+   * @param {Matrix2} matrix The matrix to use.
+   * @param {number} index The zero-based index of the column to retrieve.
+   * @param {Cartesian2} result The object onto which to store the result.
+   * @returns {Cartesian2} The modified result parameter.
+   *
+   * @exception {DeveloperError} index must be 0 or 1.
+   */
+  static getColumn(matrix, index, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
+    Check_default.typeOf.number.lessThanOrEquals("index", index, 1);
+    Check_default.typeOf.object("result", result);
+    const startIndex = index * 2;
+    const x = matrix[startIndex];
+    const y = matrix[startIndex + 1];
+    result.x = x;
+    result.y = y;
+    return result;
+  }
+  /**
+   * Computes a new matrix that replaces the specified column in the provided matrix with the provided Cartesian2 instance.
+   *
+   * @param {Matrix2} matrix The matrix to use.
+   * @param {number} index The zero-based index of the column to set.
+   * @param {Cartesian2} cartesian The Cartesian whose values will be assigned to the specified column.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   *
+   * @exception {DeveloperError} index must be 0 or 1.
+   */
+  static setColumn(matrix, index, cartesian, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
+    Check_default.typeOf.number.lessThanOrEquals("index", index, 1);
+    Check_default.typeOf.object("cartesian", cartesian);
+    Check_default.typeOf.object("result", result);
+    result = _Matrix2.clone(matrix, result);
+    const startIndex = index * 2;
+    result[startIndex] = cartesian.x;
+    result[startIndex + 1] = cartesian.y;
+    return result;
+  }
+  /**
+   * Retrieves a copy of the matrix row at the provided index as a Cartesian2 instance.
+   *
+   * @param {Matrix2} matrix The matrix to use.
+   * @param {number} index The zero-based index of the row to retrieve.
+   * @param {Cartesian2} result The object onto which to store the result.
+   * @returns {Cartesian2} The modified result parameter.
+   *
+   * @exception {DeveloperError} index must be 0 or 1.
+   */
+  static getRow(matrix, index, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
+    Check_default.typeOf.number.lessThanOrEquals("index", index, 1);
+    Check_default.typeOf.object("result", result);
+    const x = matrix[index];
+    const y = matrix[index + 2];
+    result.x = x;
+    result.y = y;
+    return result;
+  }
+  /**
+   * Computes a new matrix that replaces the specified row in the provided matrix with the provided Cartesian2 instance.
+   *
+   * @param {Matrix2} matrix The matrix to use.
+   * @param {number} index The zero-based index of the row to set.
+   * @param {Cartesian2} cartesian The Cartesian whose values will be assigned to the specified row.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   *
+   * @exception {DeveloperError} index must be 0 or 1.
+   */
+  static setRow(matrix, index, cartesian, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
+    Check_default.typeOf.number.lessThanOrEquals("index", index, 1);
+    Check_default.typeOf.object("cartesian", cartesian);
+    Check_default.typeOf.object("result", result);
+    result = _Matrix2.clone(matrix, result);
+    result[index] = cartesian.x;
+    result[index + 2] = cartesian.y;
+    return result;
+  }
+  /**
+   * Computes a new matrix that replaces the scale with the provided scale.
+   * This assumes the matrix is an affine transformation.
+   *
+   * @param {Matrix2} matrix The matrix to use.
+   * @param {Cartesian2} scale The scale that replaces the scale of the provided matrix.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   *
+   * @see Matrix2.setUniformScale
+   * @see Matrix2.fromScale
+   * @see Matrix2.fromUniformScale
+   * @see Matrix2.multiplyByScale
+   * @see Matrix2.multiplyByUniformScale
+   * @see Matrix2.getScale
+   */
+  static setScale(matrix, scale, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.object("scale", scale);
+    Check_default.typeOf.object("result", result);
+    const existingScale = _Matrix2.getScale(matrix, scaleScratch1);
+    const scaleRatioX = scale.x / existingScale.x;
+    const scaleRatioY = scale.y / existingScale.y;
+    result[0] = matrix[0] * scaleRatioX;
+    result[1] = matrix[1] * scaleRatioX;
+    result[2] = matrix[2] * scaleRatioY;
+    result[3] = matrix[3] * scaleRatioY;
+    return result;
+  }
+  /**
+   * Computes a new matrix that replaces the scale with the provided uniform scale.
+   * This assumes the matrix is an affine transformation.
+   *
+   * @param {Matrix2} matrix The matrix to use.
+   * @param {number} scale The uniform scale that replaces the scale of the provided matrix.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   *
+   * @see Matrix2.setScale
+   * @see Matrix2.fromScale
+   * @see Matrix2.fromUniformScale
+   * @see Matrix2.multiplyByScale
+   * @see Matrix2.multiplyByUniformScale
+   * @see Matrix2.getScale
+   */
+  static setUniformScale(matrix, scale, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.number("scale", scale);
+    Check_default.typeOf.object("result", result);
+    const existingScale = _Matrix2.getScale(matrix, scaleScratch2);
+    const scaleRatioX = scale / existingScale.x;
+    const scaleRatioY = scale / existingScale.y;
+    result[0] = matrix[0] * scaleRatioX;
+    result[1] = matrix[1] * scaleRatioX;
+    result[2] = matrix[2] * scaleRatioY;
+    result[3] = matrix[3] * scaleRatioY;
+    return result;
+  }
+  /**
+   * Extracts the non-uniform scale assuming the matrix is an affine transformation.
+   *
+   * @param {Matrix2} matrix The matrix.
+   * @param {Cartesian2} result The object onto which to store the result.
+   * @returns {Cartesian2} The modified result parameter.
+   *
+   * @see Matrix2.multiplyByScale
+   * @see Matrix2.multiplyByUniformScale
+   * @see Matrix2.fromScale
+   * @see Matrix2.fromUniformScale
+   * @see Matrix2.setScale
+   * @see Matrix2.setUniformScale
+   */
+  static getScale(matrix, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.object("result", result);
+    result.x = Cartesian2_default.magnitude(
+      Cartesian2_default.fromElements(matrix[0], matrix[1], scratchColumn)
+    );
+    result.y = Cartesian2_default.magnitude(
+      Cartesian2_default.fromElements(matrix[2], matrix[3], scratchColumn)
+    );
+    return result;
+  }
+  /**
+   * Computes the maximum scale assuming the matrix is an affine transformation.
+   * The maximum scale is the maximum length of the column vectors.
+   *
+   * @param {Matrix2} matrix The matrix.
+   * @returns {number} The maximum scale.
+   */
+  static getMaximumScale(matrix) {
+    _Matrix2.getScale(matrix, scaleScratch3);
+    return Cartesian2_default.maximumComponent(scaleScratch3);
+  }
+  /**
+   * Sets the rotation assuming the matrix is an affine transformation.
+   *
+   * @param {Matrix2} matrix The matrix.
+   * @param {Matrix2} rotation The rotation matrix.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   *
+   * @see Matrix2.fromRotation
+   * @see Matrix2.getRotation
+   */
+  static setRotation(matrix, rotation, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.object("result", result);
+    const scale = _Matrix2.getScale(matrix, scaleScratch4);
+    result[0] = rotation[0] * scale.x;
+    result[1] = rotation[1] * scale.x;
+    result[2] = rotation[2] * scale.y;
+    result[3] = rotation[3] * scale.y;
+    return result;
+  }
+  /**
+   * Extracts the rotation matrix assuming the matrix is an affine transformation.
+   *
+   * @param {Matrix2} matrix The matrix.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   *
+   * @see Matrix2.setRotation
+   * @see Matrix2.fromRotation
+   */
+  static getRotation(matrix, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.object("result", result);
+    const scale = _Matrix2.getScale(matrix, scaleScratch5);
+    result[0] = matrix[0] / scale.x;
+    result[1] = matrix[1] / scale.x;
+    result[2] = matrix[2] / scale.y;
+    result[3] = matrix[3] / scale.y;
+    return result;
+  }
+  /**
+   * Computes the product of two matrices.
+   *
+   * @param {Matrix2} left The first matrix.
+   * @param {Matrix2} right The second matrix.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   */
+  static multiply(left, right, result) {
+    Check_default.typeOf.object("left", left);
+    Check_default.typeOf.object("right", right);
+    Check_default.typeOf.object("result", result);
+    const column0Row0 = left[0] * right[0] + left[2] * right[1];
+    const column1Row0 = left[0] * right[2] + left[2] * right[3];
+    const column0Row1 = left[1] * right[0] + left[3] * right[1];
+    const column1Row1 = left[1] * right[2] + left[3] * right[3];
+    result[0] = column0Row0;
+    result[1] = column0Row1;
+    result[2] = column1Row0;
+    result[3] = column1Row1;
+    return result;
+  }
+  /**
+   * Computes the sum of two matrices.
+   *
+   * @param {Matrix2} left The first matrix.
+   * @param {Matrix2} right The second matrix.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   */
+  static add(left, right, result) {
+    Check_default.typeOf.object("left", left);
+    Check_default.typeOf.object("right", right);
+    Check_default.typeOf.object("result", result);
+    result[0] = left[0] + right[0];
+    result[1] = left[1] + right[1];
+    result[2] = left[2] + right[2];
+    result[3] = left[3] + right[3];
+    return result;
+  }
+  /**
+   * Computes the difference of two matrices.
+   *
+   * @param {Matrix2} left The first matrix.
+   * @param {Matrix2} right The second matrix.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   */
+  static subtract(left, right, result) {
+    Check_default.typeOf.object("left", left);
+    Check_default.typeOf.object("right", right);
+    Check_default.typeOf.object("result", result);
+    result[0] = left[0] - right[0];
+    result[1] = left[1] - right[1];
+    result[2] = left[2] - right[2];
+    result[3] = left[3] - right[3];
+    return result;
+  }
+  /**
+   * Computes the product of a matrix and a column vector.
+   *
+   * @param {Matrix2} matrix The matrix.
+   * @param {Cartesian2} cartesian The column.
+   * @param {Cartesian2} result The object onto which to store the result.
+   * @returns {Cartesian2} The modified result parameter.
+   */
+  static multiplyByVector(matrix, cartesian, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.object("cartesian", cartesian);
+    Check_default.typeOf.object("result", result);
+    const x = matrix[0] * cartesian.x + matrix[2] * cartesian.y;
+    const y = matrix[1] * cartesian.x + matrix[3] * cartesian.y;
+    result.x = x;
+    result.y = y;
+    return result;
+  }
+  /**
+   * Computes the product of a matrix and a scalar.
+   *
+   * @param {Matrix2} matrix The matrix.
+   * @param {number} scalar The number to multiply by.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   */
+  static multiplyByScalar(matrix, scalar, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.number("scalar", scalar);
+    Check_default.typeOf.object("result", result);
+    result[0] = matrix[0] * scalar;
+    result[1] = matrix[1] * scalar;
+    result[2] = matrix[2] * scalar;
+    result[3] = matrix[3] * scalar;
+    return result;
+  }
+  /**
+   * Computes the product of a matrix times a (non-uniform) scale, as if the scale were a scale matrix.
+   *
+   * @param {Matrix2} matrix The matrix on the left-hand side.
+   * @param {Cartesian2} scale The non-uniform scale on the right-hand side.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   *
+   *
+   * @example
+   * // Instead of Cesium.Matrix2.multiply(m, Cesium.Matrix2.fromScale(scale), m);
+   * Cesium.Matrix2.multiplyByScale(m, scale, m);
+   *
+   * @see Matrix2.multiplyByUniformScale
+   * @see Matrix2.fromScale
+   * @see Matrix2.fromUniformScale
+   * @see Matrix2.setScale
+   * @see Matrix2.setUniformScale
+   * @see Matrix2.getScale
+   */
+  static multiplyByScale(matrix, scale, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.object("scale", scale);
+    Check_default.typeOf.object("result", result);
+    result[0] = matrix[0] * scale.x;
+    result[1] = matrix[1] * scale.x;
+    result[2] = matrix[2] * scale.y;
+    result[3] = matrix[3] * scale.y;
+    return result;
+  }
+  /**
+   * Computes the product of a matrix times a uniform scale, as if the scale were a scale matrix.
+   *
+   * @param {Matrix2} matrix The matrix on the left-hand side.
+   * @param {number} scale The uniform scale on the right-hand side.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   *
+   * @example
+   * // Instead of Cesium.Matrix2.multiply(m, Cesium.Matrix2.fromUniformScale(scale), m);
+   * Cesium.Matrix2.multiplyByUniformScale(m, scale, m);
+   *
+   * @see Matrix2.multiplyByScale
+   * @see Matrix2.fromScale
+   * @see Matrix2.fromUniformScale
+   * @see Matrix2.setScale
+   * @see Matrix2.setUniformScale
+   * @see Matrix2.getScale
+   */
+  static multiplyByUniformScale(matrix, scale, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.number("scale", scale);
+    Check_default.typeOf.object("result", result);
+    result[0] = matrix[0] * scale;
+    result[1] = matrix[1] * scale;
+    result[2] = matrix[2] * scale;
+    result[3] = matrix[3] * scale;
+    return result;
+  }
+  /**
+   * Creates a negated copy of the provided matrix.
+   *
+   * @param {Matrix2} matrix The matrix to negate.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   */
+  static negate(matrix, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.object("result", result);
+    result[0] = -matrix[0];
+    result[1] = -matrix[1];
+    result[2] = -matrix[2];
+    result[3] = -matrix[3];
+    return result;
+  }
+  /**
+   * Computes the transpose of the provided matrix.
+   *
+   * @param {Matrix2} matrix The matrix to transpose.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   */
+  static transpose(matrix, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.object("result", result);
+    const column0Row0 = matrix[0];
+    const column0Row1 = matrix[2];
+    const column1Row0 = matrix[1];
+    const column1Row1 = matrix[3];
+    result[0] = column0Row0;
+    result[1] = column0Row1;
+    result[2] = column1Row0;
+    result[3] = column1Row1;
+    return result;
+  }
+  /**
+   * Computes a matrix, which contains the absolute (unsigned) values of the provided matrix's elements.
+   *
+   * @param {Matrix2} matrix The matrix with signed elements.
+   * @param {Matrix2} result The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter.
+   */
+  static abs(matrix, result) {
+    Check_default.typeOf.object("matrix", matrix);
+    Check_default.typeOf.object("result", result);
+    result[0] = Math.abs(matrix[0]);
+    result[1] = Math.abs(matrix[1]);
+    result[2] = Math.abs(matrix[2]);
+    result[3] = Math.abs(matrix[3]);
+    return result;
+  }
+  /**
+   * Compares the provided matrices componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {Matrix2} [left] The first matrix.
+   * @param {Matrix2} [right] The second matrix.
+   * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+   */
+  static equals(left, right) {
+    return left === right || defined_default(left) && defined_default(right) && left[0] === right[0] && left[1] === right[1] && left[2] === right[2] && left[3] === right[3];
+  }
+  /**
+   * Compares provided matrix and array, starting from a given array offset.
+   *
+   * @param {Matrix2} matrix
+   * @param {number[]} array
+   * @param {number} offset
+   * @private
+   */
+  static equalsArray(matrix, array, offset) {
+    return matrix[0] === array[offset] && matrix[1] === array[offset + 1] && matrix[2] === array[offset + 2] && matrix[3] === array[offset + 3];
+  }
+  /**
+   * Compares the provided matrices componentwise and returns
+   * <code>true</code> if they are within the provided epsilon,
+   * <code>false</code> otherwise.
+   *
+   * @param {Matrix2} [left] The first matrix.
+   * @param {Matrix2} [right] The second matrix.
+   * @param {number} [epsilon=0] The epsilon to use for equality testing.
+   * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+   */
+  static equalsEpsilon(left, right, epsilon) {
+    epsilon = epsilon ?? 0;
+    return left === right || defined_default(left) && defined_default(right) && Math.abs(left[0] - right[0]) <= epsilon && Math.abs(left[1] - right[1]) <= epsilon && Math.abs(left[2] - right[2]) <= epsilon && Math.abs(left[3] - right[3]) <= epsilon;
   }
-  result[0] = matrix[0];
-  result[1] = matrix[1];
-  result[2] = matrix[2];
-  result[3] = matrix[3];
-  return result;
-};
-Matrix2.getElementIndex = function(column, row) {
-  Check_default.typeOf.number.greaterThanOrEquals("row", row, 0);
-  Check_default.typeOf.number.lessThanOrEquals("row", row, 1);
-  Check_default.typeOf.number.greaterThanOrEquals("column", column, 0);
-  Check_default.typeOf.number.lessThanOrEquals("column", column, 1);
-  return column * 2 + row;
-};
-Matrix2.getColumn = function(matrix, index, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
-  Check_default.typeOf.number.lessThanOrEquals("index", index, 1);
-  Check_default.typeOf.object("result", result);
-  const startIndex = index * 2;
-  const x = matrix[startIndex];
-  const y = matrix[startIndex + 1];
-  result.x = x;
-  result.y = y;
-  return result;
-};
-Matrix2.setColumn = function(matrix, index, cartesian, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
-  Check_default.typeOf.number.lessThanOrEquals("index", index, 1);
-  Check_default.typeOf.object("cartesian", cartesian);
-  Check_default.typeOf.object("result", result);
-  result = Matrix2.clone(matrix, result);
-  const startIndex = index * 2;
-  result[startIndex] = cartesian.x;
-  result[startIndex + 1] = cartesian.y;
-  return result;
-};
-Matrix2.getRow = function(matrix, index, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
-  Check_default.typeOf.number.lessThanOrEquals("index", index, 1);
-  Check_default.typeOf.object("result", result);
-  const x = matrix[index];
-  const y = matrix[index + 2];
-  result.x = x;
-  result.y = y;
-  return result;
-};
-Matrix2.setRow = function(matrix, index, cartesian, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
-  Check_default.typeOf.number.lessThanOrEquals("index", index, 1);
-  Check_default.typeOf.object("cartesian", cartesian);
-  Check_default.typeOf.object("result", result);
-  result = Matrix2.clone(matrix, result);
-  result[index] = cartesian.x;
-  result[index + 2] = cartesian.y;
-  return result;
-};
-var scaleScratch1 = new Cartesian2_default();
-Matrix2.setScale = function(matrix, scale, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.object("scale", scale);
-  Check_default.typeOf.object("result", result);
-  const existingScale = Matrix2.getScale(matrix, scaleScratch1);
-  const scaleRatioX = scale.x / existingScale.x;
-  const scaleRatioY = scale.y / existingScale.y;
-  result[0] = matrix[0] * scaleRatioX;
-  result[1] = matrix[1] * scaleRatioX;
-  result[2] = matrix[2] * scaleRatioY;
-  result[3] = matrix[3] * scaleRatioY;
-  return result;
-};
-var scaleScratch2 = new Cartesian2_default();
-Matrix2.setUniformScale = function(matrix, scale, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.number("scale", scale);
-  Check_default.typeOf.object("result", result);
-  const existingScale = Matrix2.getScale(matrix, scaleScratch2);
-  const scaleRatioX = scale / existingScale.x;
-  const scaleRatioY = scale / existingScale.y;
-  result[0] = matrix[0] * scaleRatioX;
-  result[1] = matrix[1] * scaleRatioX;
-  result[2] = matrix[2] * scaleRatioY;
-  result[3] = matrix[3] * scaleRatioY;
-  return result;
-};
-var scratchColumn = new Cartesian2_default();
-Matrix2.getScale = function(matrix, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.object("result", result);
-  result.x = Cartesian2_default.magnitude(
-    Cartesian2_default.fromElements(matrix[0], matrix[1], scratchColumn)
-  );
-  result.y = Cartesian2_default.magnitude(
-    Cartesian2_default.fromElements(matrix[2], matrix[3], scratchColumn)
-  );
-  return result;
-};
-var scaleScratch3 = new Cartesian2_default();
-Matrix2.getMaximumScale = function(matrix) {
-  Matrix2.getScale(matrix, scaleScratch3);
-  return Cartesian2_default.maximumComponent(scaleScratch3);
-};
-var scaleScratch4 = new Cartesian2_default();
-Matrix2.setRotation = function(matrix, rotation, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.object("result", result);
-  const scale = Matrix2.getScale(matrix, scaleScratch4);
-  result[0] = rotation[0] * scale.x;
-  result[1] = rotation[1] * scale.x;
-  result[2] = rotation[2] * scale.y;
-  result[3] = rotation[3] * scale.y;
-  return result;
-};
-var scaleScratch5 = new Cartesian2_default();
-Matrix2.getRotation = function(matrix, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.object("result", result);
-  const scale = Matrix2.getScale(matrix, scaleScratch5);
-  result[0] = matrix[0] / scale.x;
-  result[1] = matrix[1] / scale.x;
-  result[2] = matrix[2] / scale.y;
-  result[3] = matrix[3] / scale.y;
-  return result;
-};
-Matrix2.multiply = function(left, right, result) {
-  Check_default.typeOf.object("left", left);
-  Check_default.typeOf.object("right", right);
-  Check_default.typeOf.object("result", result);
-  const column0Row0 = left[0] * right[0] + left[2] * right[1];
-  const column1Row0 = left[0] * right[2] + left[2] * right[3];
-  const column0Row1 = left[1] * right[0] + left[3] * right[1];
-  const column1Row1 = left[1] * right[2] + left[3] * right[3];
-  result[0] = column0Row0;
-  result[1] = column0Row1;
-  result[2] = column1Row0;
-  result[3] = column1Row1;
-  return result;
-};
-Matrix2.add = function(left, right, result) {
-  Check_default.typeOf.object("left", left);
-  Check_default.typeOf.object("right", right);
-  Check_default.typeOf.object("result", result);
-  result[0] = left[0] + right[0];
-  result[1] = left[1] + right[1];
-  result[2] = left[2] + right[2];
-  result[3] = left[3] + right[3];
-  return result;
-};
-Matrix2.subtract = function(left, right, result) {
-  Check_default.typeOf.object("left", left);
-  Check_default.typeOf.object("right", right);
-  Check_default.typeOf.object("result", result);
-  result[0] = left[0] - right[0];
-  result[1] = left[1] - right[1];
-  result[2] = left[2] - right[2];
-  result[3] = left[3] - right[3];
-  return result;
-};
-Matrix2.multiplyByVector = function(matrix, cartesian, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.object("cartesian", cartesian);
-  Check_default.typeOf.object("result", result);
-  const x = matrix[0] * cartesian.x + matrix[2] * cartesian.y;
-  const y = matrix[1] * cartesian.x + matrix[3] * cartesian.y;
-  result.x = x;
-  result.y = y;
-  return result;
-};
-Matrix2.multiplyByScalar = function(matrix, scalar, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.number("scalar", scalar);
-  Check_default.typeOf.object("result", result);
-  result[0] = matrix[0] * scalar;
-  result[1] = matrix[1] * scalar;
-  result[2] = matrix[2] * scalar;
-  result[3] = matrix[3] * scalar;
-  return result;
-};
-Matrix2.multiplyByScale = function(matrix, scale, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.object("scale", scale);
-  Check_default.typeOf.object("result", result);
-  result[0] = matrix[0] * scale.x;
-  result[1] = matrix[1] * scale.x;
-  result[2] = matrix[2] * scale.y;
-  result[3] = matrix[3] * scale.y;
-  return result;
-};
-Matrix2.multiplyByUniformScale = function(matrix, scale, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.number("scale", scale);
-  Check_default.typeOf.object("result", result);
-  result[0] = matrix[0] * scale;
-  result[1] = matrix[1] * scale;
-  result[2] = matrix[2] * scale;
-  result[3] = matrix[3] * scale;
-  return result;
-};
-Matrix2.negate = function(matrix, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.object("result", result);
-  result[0] = -matrix[0];
-  result[1] = -matrix[1];
-  result[2] = -matrix[2];
-  result[3] = -matrix[3];
-  return result;
-};
-Matrix2.transpose = function(matrix, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.object("result", result);
-  const column0Row0 = matrix[0];
-  const column0Row1 = matrix[2];
-  const column1Row0 = matrix[1];
-  const column1Row1 = matrix[3];
-  result[0] = column0Row0;
-  result[1] = column0Row1;
-  result[2] = column1Row0;
-  result[3] = column1Row1;
-  return result;
-};
-Matrix2.abs = function(matrix, result) {
-  Check_default.typeOf.object("matrix", matrix);
-  Check_default.typeOf.object("result", result);
-  result[0] = Math.abs(matrix[0]);
-  result[1] = Math.abs(matrix[1]);
-  result[2] = Math.abs(matrix[2]);
-  result[3] = Math.abs(matrix[3]);
-  return result;
-};
-Matrix2.equals = function(left, right) {
-  return left === right || defined_default(left) && defined_default(right) && left[0] === right[0] && left[1] === right[1] && left[2] === right[2] && left[3] === right[3];
-};
-Matrix2.equalsArray = function(matrix, array, offset) {
-  return matrix[0] === array[offset] && matrix[1] === array[offset + 1] && matrix[2] === array[offset + 2] && matrix[3] === array[offset + 3];
-};
-Matrix2.equalsEpsilon = function(left, right, epsilon) {
-  epsilon = epsilon ?? 0;
-  return left === right || defined_default(left) && defined_default(right) && Math.abs(left[0] - right[0]) <= epsilon && Math.abs(left[1] - right[1]) <= epsilon && Math.abs(left[2] - right[2]) <= epsilon && Math.abs(left[3] - right[3]) <= epsilon;
-};
-Matrix2.IDENTITY = Object.freeze(new Matrix2(1, 0, 0, 1));
-Matrix2.ZERO = Object.freeze(new Matrix2(0, 0, 0, 0));
-Matrix2.COLUMN0ROW0 = 0;
-Matrix2.COLUMN0ROW1 = 1;
-Matrix2.COLUMN1ROW0 = 2;
-Matrix2.COLUMN1ROW1 = 3;
-Object.defineProperties(Matrix2.prototype, {
   /**
    * Gets the number of items in the collection.
-   * @memberof Matrix2.prototype
    *
    * @type {number}
    */
-  length: {
-    get: function() {
-      return Matrix2.packedLength;
-    }
+  get length() {
+    return _Matrix2.packedLength;
   }
-});
-Matrix2.prototype.clone = function(result) {
-  return Matrix2.clone(this, result);
-};
-Matrix2.prototype.equals = function(right) {
-  return Matrix2.equals(this, right);
-};
-Matrix2.prototype.equalsEpsilon = function(right, epsilon) {
-  return Matrix2.equalsEpsilon(this, right, epsilon);
-};
-Matrix2.prototype.toString = function() {
-  return `(${this[0]}, ${this[2]})
+  /**
+   * Duplicates the provided Matrix2 instance.
+   *
+   * @param {Matrix2} [result] The object onto which to store the result.
+   * @returns {Matrix2} The modified result parameter or a new Matrix2 instance if one was not provided.
+   */
+  clone(result) {
+    return _Matrix2.clone(this, result);
+  }
+  /**
+   * Compares this matrix to the provided matrix componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {Matrix2} [right] The right hand side matrix.
+   * @returns {boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+   */
+  equals(right) {
+    return _Matrix2.equals(this, right);
+  }
+  /**
+   * Compares this matrix to the provided matrix componentwise and returns
+   * <code>true</code> if they are within the provided epsilon,
+   * <code>false</code> otherwise.
+   *
+   * @param {Matrix2} [right] The right hand side matrix.
+   * @param {number} [epsilon=0] The epsilon to use for equality testing.
+   * @returns {boolean} <code>true</code> if they are within the provided epsilon, <code>false</code> otherwise.
+   */
+  equalsEpsilon(right, epsilon) {
+    return _Matrix2.equalsEpsilon(this, right, epsilon);
+  }
+  /**
+   * Creates a string representing this Matrix with each row being
+   * on a separate line and in the format '(column0, column1)'.
+   *
+   * @returns {string} A string representing the provided Matrix with each row being on a separate line and in the format '(column0, column1)'.
+   */
+  toString() {
+    return `(${this[0]}, ${this[2]})
 (${this[1]}, ${this[3]})`;
+  }
 };
+Matrix2.packedLength = 4;
+Matrix2.fromArray = Matrix2.unpack;
+Matrix2.IDENTITY = Object.freeze(new Matrix2(1, 0, 0, 1));
+Matrix2.ZERO = Object.freeze(new Matrix2(0, 0, 0, 0));
+Matrix2.COLUMN0ROW0 = 0;
+Matrix2.COLUMN0ROW1 = 1;
+Matrix2.COLUMN1ROW0 = 2;
+Matrix2.COLUMN1ROW1 = 3;
+var scaleScratch1 = new Cartesian2_default();
+var scaleScratch2 = new Cartesian2_default();
+var scratchColumn = new Cartesian2_default();
+var scaleScratch3 = new Cartesian2_default();
+var scaleScratch4 = new Cartesian2_default();
+var scaleScratch5 = new Cartesian2_default();
 var Matrix2_default = Matrix2;
 
 export {