@vcmap/ui 6.0.0-rc.1 → 6.0.0-rc.3

package/dist/assets/cesium/Workers/{chunk-PCJWUS4M.js → chunk-FYYT5EVH.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.109.3
+ * Version 1.119.1
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,17 +25,17 @@
 
 import {
   Math_default
-} from "./chunk-N3JIFFX2.js";
+} from "./chunk-BPY4HDAK.js";
 import {
   defaultValue_default
-} from "./chunk-WXTV4ATB.js";
+} from "./chunk-6DH5PLFD.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-4MFFIWUA.js";
+} from "./chunk-VD6G7UPU.js";
 import {
   defined_default
-} from "./chunk-6BTKZDRG.js";
+} from "./chunk-F7IEM66T.js";
 
 // packages/engine/Source/Core/Cartesian3.js
 function Cartesian3(x, y, z) {
@@ -396,7 +396,7 @@ Cartesian3.fromDegrees = function(longitude, latitude, height, ellipsoid, result
 };
 var scratchN = new Cartesian3();
 var scratchK = new Cartesian3();
-var wgs84RadiiSquared = new Cartesian3(
+Cartesian3._ellipsoidRadiiSquared = new Cartesian3(
   6378137 * 6378137,
   6378137 * 6378137,
   6356752314245179e-9 * 6356752314245179e-9
@@ -405,7 +405,7 @@ Cartesian3.fromRadians = function(longitude, latitude, height, ellipsoid, result
   Check_default.typeOf.number("longitude", longitude);
   Check_default.typeOf.number("latitude", latitude);
   height = defaultValue_default(height, 0);
-  const radiiSquared = defined_default(ellipsoid) ? ellipsoid.radiiSquared : wgs84RadiiSquared;
+  const radiiSquared = !defined_default(ellipsoid) ? Cartesian3._ellipsoidRadiiSquared : ellipsoid.radiiSquared;
   const cosLatitude = Math.cos(latitude);
   scratchN.x = cosLatitude * Math.cos(longitude);
   scratchN.y = cosLatitude * Math.sin(longitude);
@@ -667,21 +667,21 @@ Cartographic.fromDegrees = function(longitude, latitude, height, result) {
 var cartesianToCartographicN = new Cartesian3_default();
 var cartesianToCartographicP = new Cartesian3_default();
 var cartesianToCartographicH = new Cartesian3_default();
-var wgs84OneOverRadii = new Cartesian3_default(
+Cartographic._ellipsoidOneOverRadii = new Cartesian3_default(
   1 / 6378137,
   1 / 6378137,
   1 / 6356752314245179e-9
 );
-var wgs84OneOverRadiiSquared = new Cartesian3_default(
+Cartographic._ellipsoidOneOverRadiiSquared = new Cartesian3_default(
   1 / (6378137 * 6378137),
   1 / (6378137 * 6378137),
   1 / (6356752314245179e-9 * 6356752314245179e-9)
 );
-var wgs84CenterToleranceSquared = Math_default.EPSILON1;
+Cartographic._ellipsoidCenterToleranceSquared = Math_default.EPSILON1;
 Cartographic.fromCartesian = function(cartesian, ellipsoid, result) {
-  const oneOverRadii = defined_default(ellipsoid) ? ellipsoid.oneOverRadii : wgs84OneOverRadii;
-  const oneOverRadiiSquared = defined_default(ellipsoid) ? ellipsoid.oneOverRadiiSquared : wgs84OneOverRadiiSquared;
-  const centerToleranceSquared = defined_default(ellipsoid) ? ellipsoid._centerToleranceSquared : wgs84CenterToleranceSquared;
+  const oneOverRadii = defined_default(ellipsoid) ? ellipsoid.oneOverRadii : Cartographic._ellipsoidOneOverRadii;
+  const oneOverRadiiSquared = defined_default(ellipsoid) ? ellipsoid.oneOverRadiiSquared : Cartographic._ellipsoidOneOverRadiiSquared;
+  const centerToleranceSquared = defined_default(ellipsoid) ? ellipsoid._centerToleranceSquared : Cartographic._ellipsoidCenterToleranceSquared;
   const p = scaleToGeodeticSurface_default(
     cartesian,
     oneOverRadii,
@@ -758,6 +758,302 @@ Cartographic.prototype.toString = function() {
 };
 var Cartographic_default = Cartographic;
 
+// packages/engine/Source/Core/Cartesian2.js
+function Cartesian2(x, y) {
+  this.x = defaultValue_default(x, 0);
+  this.y = defaultValue_default(y, 0);
+}
+Cartesian2.fromElements = function(x, y, result) {
+  if (!defined_default(result)) {
+    return new Cartesian2(x, y);
+  }
+  result.x = x;
+  result.y = y;
+  return result;
+};
+Cartesian2.clone = function(cartesian, result) {
+  if (!defined_default(cartesian)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new Cartesian2(cartesian.x, cartesian.y);
+  }
+  result.x = cartesian.x;
+  result.y = cartesian.y;
+  return result;
+};
+Cartesian2.fromCartesian3 = Cartesian2.clone;
+Cartesian2.fromCartesian4 = Cartesian2.clone;
+Cartesian2.packedLength = 2;
+Cartesian2.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  array[startingIndex++] = value.x;
+  array[startingIndex] = value.y;
+  return array;
+};
+Cartesian2.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  if (!defined_default(result)) {
+    result = new Cartesian2();
+  }
+  result.x = array[startingIndex++];
+  result.y = array[startingIndex];
+  return result;
+};
+Cartesian2.packArray = function(array, result) {
+  Check_default.defined("array", array);
+  const length = array.length;
+  const resultLength = length * 2;
+  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 * 2 elements"
+    );
+  } else if (result.length !== resultLength) {
+    result.length = resultLength;
+  }
+  for (let i = 0; i < length; ++i) {
+    Cartesian2.pack(array[i], result, i * 2);
+  }
+  return result;
+};
+Cartesian2.unpackArray = function(array, result) {
+  Check_default.defined("array", array);
+  Check_default.typeOf.number.greaterThanOrEquals("array.length", array.length, 2);
+  if (array.length % 2 !== 0) {
+    throw new DeveloperError_default("array length must be a multiple of 2.");
+  }
+  const length = array.length;
+  if (!defined_default(result)) {
+    result = new Array(length / 2);
+  } else {
+    result.length = length / 2;
+  }
+  for (let i = 0; i < length; i += 2) {
+    const index = i / 2;
+    result[index] = Cartesian2.unpack(array, i, result[index]);
+  }
+  return result;
+};
+Cartesian2.fromArray = Cartesian2.unpack;
+Cartesian2.maximumComponent = function(cartesian) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  return Math.max(cartesian.x, cartesian.y);
+};
+Cartesian2.minimumComponent = function(cartesian) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  return Math.min(cartesian.x, cartesian.y);
+};
+Cartesian2.minimumByComponent = function(first, second, result) {
+  Check_default.typeOf.object("first", first);
+  Check_default.typeOf.object("second", second);
+  Check_default.typeOf.object("result", result);
+  result.x = Math.min(first.x, second.x);
+  result.y = Math.min(first.y, second.y);
+  return result;
+};
+Cartesian2.maximumByComponent = function(first, second, result) {
+  Check_default.typeOf.object("first", first);
+  Check_default.typeOf.object("second", second);
+  Check_default.typeOf.object("result", result);
+  result.x = Math.max(first.x, second.x);
+  result.y = Math.max(first.y, second.y);
+  return result;
+};
+Cartesian2.clamp = function(value, min, max, result) {
+  Check_default.typeOf.object("value", value);
+  Check_default.typeOf.object("min", min);
+  Check_default.typeOf.object("max", max);
+  Check_default.typeOf.object("result", result);
+  const x = Math_default.clamp(value.x, min.x, max.x);
+  const y = Math_default.clamp(value.y, min.y, max.y);
+  result.x = x;
+  result.y = y;
+  return result;
+};
+Cartesian2.magnitudeSquared = function(cartesian) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  return cartesian.x * cartesian.x + cartesian.y * cartesian.y;
+};
+Cartesian2.magnitude = function(cartesian) {
+  return Math.sqrt(Cartesian2.magnitudeSquared(cartesian));
+};
+var distanceScratch2 = new Cartesian2();
+Cartesian2.distance = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Cartesian2.subtract(left, right, distanceScratch2);
+  return Cartesian2.magnitude(distanceScratch2);
+};
+Cartesian2.distanceSquared = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Cartesian2.subtract(left, right, distanceScratch2);
+  return Cartesian2.magnitudeSquared(distanceScratch2);
+};
+Cartesian2.normalize = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  const magnitude = Cartesian2.magnitude(cartesian);
+  result.x = cartesian.x / magnitude;
+  result.y = cartesian.y / magnitude;
+  if (isNaN(result.x) || isNaN(result.y)) {
+    throw new DeveloperError_default("normalized result is not a number");
+  }
+  return result;
+};
+Cartesian2.dot = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  return left.x * right.x + left.y * right.y;
+};
+Cartesian2.cross = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  return left.x * right.y - left.y * right.x;
+};
+Cartesian2.multiplyComponents = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result.x = left.x * right.x;
+  result.y = left.y * right.y;
+  return result;
+};
+Cartesian2.divideComponents = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result.x = left.x / right.x;
+  result.y = left.y / right.y;
+  return result;
+};
+Cartesian2.add = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result.x = left.x + right.x;
+  result.y = left.y + right.y;
+  return result;
+};
+Cartesian2.subtract = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Check_default.typeOf.object("result", result);
+  result.x = left.x - right.x;
+  result.y = left.y - right.y;
+  return result;
+};
+Cartesian2.multiplyByScalar = function(cartesian, scalar, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.number("scalar", scalar);
+  Check_default.typeOf.object("result", result);
+  result.x = cartesian.x * scalar;
+  result.y = cartesian.y * scalar;
+  return result;
+};
+Cartesian2.divideByScalar = function(cartesian, scalar, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.number("scalar", scalar);
+  Check_default.typeOf.object("result", result);
+  result.x = cartesian.x / scalar;
+  result.y = cartesian.y / scalar;
+  return result;
+};
+Cartesian2.negate = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  result.x = -cartesian.x;
+  result.y = -cartesian.y;
+  return result;
+};
+Cartesian2.abs = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  result.x = Math.abs(cartesian.x);
+  result.y = Math.abs(cartesian.y);
+  return result;
+};
+var lerpScratch2 = new Cartesian2();
+Cartesian2.lerp = function(start, end, t, result) {
+  Check_default.typeOf.object("start", start);
+  Check_default.typeOf.object("end", end);
+  Check_default.typeOf.number("t", t);
+  Check_default.typeOf.object("result", result);
+  Cartesian2.multiplyByScalar(end, t, lerpScratch2);
+  result = Cartesian2.multiplyByScalar(start, 1 - t, result);
+  return Cartesian2.add(lerpScratch2, result, result);
+};
+var angleBetweenScratch3 = new Cartesian2();
+var angleBetweenScratch22 = new Cartesian2();
+Cartesian2.angleBetween = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  Cartesian2.normalize(left, angleBetweenScratch3);
+  Cartesian2.normalize(right, angleBetweenScratch22);
+  return Math_default.acosClamped(
+    Cartesian2.dot(angleBetweenScratch3, angleBetweenScratch22)
+  );
+};
+var mostOrthogonalAxisScratch2 = new Cartesian2();
+Cartesian2.mostOrthogonalAxis = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  Check_default.typeOf.object("result", result);
+  const f = Cartesian2.normalize(cartesian, mostOrthogonalAxisScratch2);
+  Cartesian2.abs(f, f);
+  if (f.x <= f.y) {
+    result = Cartesian2.clone(Cartesian2.UNIT_X, result);
+  } else {
+    result = Cartesian2.clone(Cartesian2.UNIT_Y, result);
+  }
+  return result;
+};
+Cartesian2.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y;
+};
+Cartesian2.equalsArray = function(cartesian, array, offset) {
+  return cartesian.x === array[offset] && cartesian.y === array[offset + 1];
+};
+Cartesian2.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
+  return left === right || defined_default(left) && defined_default(right) && Math_default.equalsEpsilon(
+    left.x,
+    right.x,
+    relativeEpsilon,
+    absoluteEpsilon
+  ) && Math_default.equalsEpsilon(
+    left.y,
+    right.y,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+Cartesian2.ZERO = Object.freeze(new Cartesian2(0, 0));
+Cartesian2.ONE = Object.freeze(new Cartesian2(1, 1));
+Cartesian2.UNIT_X = Object.freeze(new Cartesian2(1, 0));
+Cartesian2.UNIT_Y = Object.freeze(new Cartesian2(0, 1));
+Cartesian2.prototype.clone = function(result) {
+  return Cartesian2.clone(this, result);
+};
+Cartesian2.prototype.equals = function(right) {
+  return Cartesian2.equals(this, right);
+};
+Cartesian2.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
+  return Cartesian2.equalsEpsilon(
+    this,
+    right,
+    relativeEpsilon,
+    absoluteEpsilon
+  );
+};
+Cartesian2.prototype.toString = function() {
+  return `(${this.x}, ${this.y})`;
+};
+var Cartesian2_default = Cartesian2;
+
 // packages/engine/Source/Core/Ellipsoid.js
 function initialize(ellipsoid, x, y, z) {
   x = defaultValue_default(x, 0);
@@ -920,6 +1216,35 @@ Ellipsoid.MOON = Object.freeze(
     Math_default.LUNAR_RADIUS
   )
 );
+Ellipsoid._default = Ellipsoid.WGS84;
+Object.defineProperties(Ellipsoid, {
+  /**
+   * The default ellipsoid used when not otherwise specified.
+   * @memberof Ellipsoid
+   * @type {Ellipsoid}
+   * @example
+   * Cesium.Ellipsoid.default = Cesium.Ellipsoid.MOON;
+   *
+   * // Apollo 11 landing site
+   * const position = Cesium.Cartesian3.fromRadians(
+   *   0.67416,
+   *   23.47315,
+   * );
+   */
+  default: {
+    get: function() {
+      return Ellipsoid._default;
+    },
+    set: function(value) {
+      Check_default.typeOf.object("value", value);
+      Ellipsoid._default = value;
+      Cartesian3_default._ellipsoidRadiiSquared = value.radiiSquared;
+      Cartographic_default._ellipsoidOneOverRadii = value.oneOverRadii;
+      Cartographic_default._ellipsoidOneOverRadiiSquared = value.oneOverRadiiSquared;
+      Cartographic_default._ellipsoidCenterToleranceSquared = value._centerToleranceSquared;
+    }
+  }
+});
 Ellipsoid.prototype.clone = function(result) {
   return Ellipsoid.clone(this, result);
 };
@@ -955,6 +1280,10 @@ Ellipsoid.prototype.geodeticSurfaceNormalCartographic = function(cartographic, r
   return Cartesian3_default.normalize(result, result);
 };
 Ellipsoid.prototype.geodeticSurfaceNormal = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  if (isNaN(cartesian.x) || isNaN(cartesian.y) || isNaN(cartesian.z)) {
+    throw new DeveloperError_default("cartesian has a NaN component");
+  }
   if (Cartesian3_default.equalsEpsilon(cartesian, Cartesian3_default.ZERO, Math_default.EPSILON14)) {
     return void 0;
   }
@@ -1096,6 +1425,29 @@ Ellipsoid.prototype.getSurfaceNormalIntersectionWithZAxis = function(position, b
   }
   return result;
 };
+var scratchEndpoint = new Cartesian3_default();
+Ellipsoid.prototype.getLocalCurvature = function(surfacePosition, result) {
+  Check_default.typeOf.object("surfacePosition", surfacePosition);
+  if (!defined_default(result)) {
+    result = new Cartesian2_default();
+  }
+  const primeVerticalEndpoint = this.getSurfaceNormalIntersectionWithZAxis(
+    surfacePosition,
+    0,
+    scratchEndpoint
+  );
+  const primeVerticalRadius = Cartesian3_default.distance(
+    surfacePosition,
+    primeVerticalEndpoint
+  );
+  const radiusRatio = this.minimumRadius * primeVerticalRadius / this.maximumRadius ** 2;
+  const meridionalRadius = primeVerticalRadius * radiusRatio ** 2;
+  return Cartesian2_default.fromElements(
+    1 / primeVerticalRadius,
+    1 / meridionalRadius,
+    result
+  );
+};
 var abscissas = [
   0.14887433898163,
   0.43339539412925,
@@ -2033,9 +2385,473 @@ Matrix3.prototype.toString = function() {
 };
 var Matrix3_default = Matrix3;
 
+// packages/engine/Source/Core/Fullscreen.js
+var _supportsFullscreen;
+var _names = {
+  requestFullscreen: void 0,
+  exitFullscreen: void 0,
+  fullscreenEnabled: void 0,
+  fullscreenElement: void 0,
+  fullscreenchange: void 0,
+  fullscreenerror: void 0
+};
+var Fullscreen = {};
+Object.defineProperties(Fullscreen, {
+  /**
+   * The element that is currently fullscreen, if any.  To simply check if the
+   * browser is in fullscreen mode or not, use {@link Fullscreen#fullscreen}.
+   * @memberof Fullscreen
+   * @type {object}
+   * @readonly
+   */
+  element: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return document[_names.fullscreenElement];
+    }
+  },
+  /**
+   * The name of the event on the document that is fired when fullscreen is
+   * entered or exited.  This event name is intended for use with addEventListener.
+   * In your event handler, to determine if the browser is in fullscreen mode or not,
+   * use {@link Fullscreen#fullscreen}.
+   * @memberof Fullscreen
+   * @type {string}
+   * @readonly
+   */
+  changeEventName: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return _names.fullscreenchange;
+    }
+  },
+  /**
+   * The name of the event that is fired when a fullscreen error
+   * occurs.  This event name is intended for use with addEventListener.
+   * @memberof Fullscreen
+   * @type {string}
+   * @readonly
+   */
+  errorEventName: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return _names.fullscreenerror;
+    }
+  },
+  /**
+   * Determine whether the browser will allow an element to be made fullscreen, or not.
+   * For example, by default, iframes cannot go fullscreen unless the containing page
+   * adds an "allowfullscreen" attribute (or prefixed equivalent).
+   * @memberof Fullscreen
+   * @type {boolean}
+   * @readonly
+   */
+  enabled: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return document[_names.fullscreenEnabled];
+    }
+  },
+  /**
+   * Determines if the browser is currently in fullscreen mode.
+   * @memberof Fullscreen
+   * @type {boolean}
+   * @readonly
+   */
+  fullscreen: {
+    get: function() {
+      if (!Fullscreen.supportsFullscreen()) {
+        return void 0;
+      }
+      return Fullscreen.element !== null;
+    }
+  }
+});
+Fullscreen.supportsFullscreen = function() {
+  if (defined_default(_supportsFullscreen)) {
+    return _supportsFullscreen;
+  }
+  _supportsFullscreen = false;
+  const body = document.body;
+  if (typeof body.requestFullscreen === "function") {
+    _names.requestFullscreen = "requestFullscreen";
+    _names.exitFullscreen = "exitFullscreen";
+    _names.fullscreenEnabled = "fullscreenEnabled";
+    _names.fullscreenElement = "fullscreenElement";
+    _names.fullscreenchange = "fullscreenchange";
+    _names.fullscreenerror = "fullscreenerror";
+    _supportsFullscreen = true;
+    return _supportsFullscreen;
+  }
+  const prefixes = ["webkit", "moz", "o", "ms", "khtml"];
+  let name;
+  for (let i = 0, len = prefixes.length; i < len; ++i) {
+    const prefix = prefixes[i];
+    name = `${prefix}RequestFullscreen`;
+    if (typeof body[name] === "function") {
+      _names.requestFullscreen = name;
+      _supportsFullscreen = true;
+    } else {
+      name = `${prefix}RequestFullScreen`;
+      if (typeof body[name] === "function") {
+        _names.requestFullscreen = name;
+        _supportsFullscreen = true;
+      }
+    }
+    name = `${prefix}ExitFullscreen`;
+    if (typeof document[name] === "function") {
+      _names.exitFullscreen = name;
+    } else {
+      name = `${prefix}CancelFullScreen`;
+      if (typeof document[name] === "function") {
+        _names.exitFullscreen = name;
+      }
+    }
+    name = `${prefix}FullscreenEnabled`;
+    if (document[name] !== void 0) {
+      _names.fullscreenEnabled = name;
+    } else {
+      name = `${prefix}FullScreenEnabled`;
+      if (document[name] !== void 0) {
+        _names.fullscreenEnabled = name;
+      }
+    }
+    name = `${prefix}FullscreenElement`;
+    if (document[name] !== void 0) {
+      _names.fullscreenElement = name;
+    } else {
+      name = `${prefix}FullScreenElement`;
+      if (document[name] !== void 0) {
+        _names.fullscreenElement = name;
+      }
+    }
+    name = `${prefix}fullscreenchange`;
+    if (document[`on${name}`] !== void 0) {
+      if (prefix === "ms") {
+        name = "MSFullscreenChange";
+      }
+      _names.fullscreenchange = name;
+    }
+    name = `${prefix}fullscreenerror`;
+    if (document[`on${name}`] !== void 0) {
+      if (prefix === "ms") {
+        name = "MSFullscreenError";
+      }
+      _names.fullscreenerror = name;
+    }
+  }
+  return _supportsFullscreen;
+};
+Fullscreen.requestFullscreen = function(element, vrDevice) {
+  if (!Fullscreen.supportsFullscreen()) {
+    return;
+  }
+  element[_names.requestFullscreen]({ vrDisplay: vrDevice });
+};
+Fullscreen.exitFullscreen = function() {
+  if (!Fullscreen.supportsFullscreen()) {
+    return;
+  }
+  document[_names.exitFullscreen]();
+};
+Fullscreen._names = _names;
+var Fullscreen_default = Fullscreen;
+
+// packages/engine/Source/Core/FeatureDetection.js
+var theNavigator;
+if (typeof navigator !== "undefined") {
+  theNavigator = navigator;
+} else {
+  theNavigator = {};
+}
+function extractVersion(versionString) {
+  const parts = versionString.split(".");
+  for (let i = 0, len = parts.length; i < len; ++i) {
+    parts[i] = parseInt(parts[i], 10);
+  }
+  return parts;
+}
+var isChromeResult;
+var chromeVersionResult;
+function isChrome() {
+  if (!defined_default(isChromeResult)) {
+    isChromeResult = false;
+    if (!isEdge()) {
+      const fields = / Chrome\/([\.0-9]+)/.exec(theNavigator.userAgent);
+      if (fields !== null) {
+        isChromeResult = true;
+        chromeVersionResult = extractVersion(fields[1]);
+      }
+    }
+  }
+  return isChromeResult;
+}
+function chromeVersion() {
+  return isChrome() && chromeVersionResult;
+}
+var isSafariResult;
+var safariVersionResult;
+function isSafari() {
+  if (!defined_default(isSafariResult)) {
+    isSafariResult = false;
+    if (!isChrome() && !isEdge() && / Safari\/[\.0-9]+/.test(theNavigator.userAgent)) {
+      const fields = / Version\/([\.0-9]+)/.exec(theNavigator.userAgent);
+      if (fields !== null) {
+        isSafariResult = true;
+        safariVersionResult = extractVersion(fields[1]);
+      }
+    }
+  }
+  return isSafariResult;
+}
+function safariVersion() {
+  return isSafari() && safariVersionResult;
+}
+var isWebkitResult;
+var webkitVersionResult;
+function isWebkit() {
+  if (!defined_default(isWebkitResult)) {
+    isWebkitResult = false;
+    const fields = / AppleWebKit\/([\.0-9]+)(\+?)/.exec(theNavigator.userAgent);
+    if (fields !== null) {
+      isWebkitResult = true;
+      webkitVersionResult = extractVersion(fields[1]);
+      webkitVersionResult.isNightly = !!fields[2];
+    }
+  }
+  return isWebkitResult;
+}
+function webkitVersion() {
+  return isWebkit() && webkitVersionResult;
+}
+var isInternetExplorerResult;
+var internetExplorerVersionResult;
+function isInternetExplorer() {
+  if (!defined_default(isInternetExplorerResult)) {
+    isInternetExplorerResult = false;
+    let fields;
+    if (theNavigator.appName === "Microsoft Internet Explorer") {
+      fields = /MSIE ([0-9]{1,}[\.0-9]{0,})/.exec(theNavigator.userAgent);
+      if (fields !== null) {
+        isInternetExplorerResult = true;
+        internetExplorerVersionResult = extractVersion(fields[1]);
+      }
+    } else if (theNavigator.appName === "Netscape") {
+      fields = /Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/.exec(
+        theNavigator.userAgent
+      );
+      if (fields !== null) {
+        isInternetExplorerResult = true;
+        internetExplorerVersionResult = extractVersion(fields[1]);
+      }
+    }
+  }
+  return isInternetExplorerResult;
+}
+function internetExplorerVersion() {
+  return isInternetExplorer() && internetExplorerVersionResult;
+}
+var isEdgeResult;
+var edgeVersionResult;
+function isEdge() {
+  if (!defined_default(isEdgeResult)) {
+    isEdgeResult = false;
+    const fields = / Edg\/([\.0-9]+)/.exec(theNavigator.userAgent);
+    if (fields !== null) {
+      isEdgeResult = true;
+      edgeVersionResult = extractVersion(fields[1]);
+    }
+  }
+  return isEdgeResult;
+}
+function edgeVersion() {
+  return isEdge() && edgeVersionResult;
+}
+var isFirefoxResult;
+var firefoxVersionResult;
+function isFirefox() {
+  if (!defined_default(isFirefoxResult)) {
+    isFirefoxResult = false;
+    const fields = /Firefox\/([\.0-9]+)/.exec(theNavigator.userAgent);
+    if (fields !== null) {
+      isFirefoxResult = true;
+      firefoxVersionResult = extractVersion(fields[1]);
+    }
+  }
+  return isFirefoxResult;
+}
+var isWindowsResult;
+function isWindows() {
+  if (!defined_default(isWindowsResult)) {
+    isWindowsResult = /Windows/i.test(theNavigator.appVersion);
+  }
+  return isWindowsResult;
+}
+var isIPadOrIOSResult;
+function isIPadOrIOS() {
+  if (!defined_default(isIPadOrIOSResult)) {
+    isIPadOrIOSResult = navigator.platform === "iPhone" || navigator.platform === "iPod" || navigator.platform === "iPad";
+  }
+  return isIPadOrIOSResult;
+}
+function firefoxVersion() {
+  return isFirefox() && firefoxVersionResult;
+}
+var hasPointerEvents;
+function supportsPointerEvents() {
+  if (!defined_default(hasPointerEvents)) {
+    hasPointerEvents = typeof PointerEvent !== "undefined" && (!defined_default(theNavigator.pointerEnabled) || theNavigator.pointerEnabled);
+  }
+  return hasPointerEvents;
+}
+var imageRenderingValueResult;
+var supportsImageRenderingPixelatedResult;
+function supportsImageRenderingPixelated() {
+  if (!defined_default(supportsImageRenderingPixelatedResult)) {
+    const canvas = document.createElement("canvas");
+    canvas.setAttribute(
+      "style",
+      "image-rendering: -moz-crisp-edges;image-rendering: pixelated;"
+    );
+    const tmp = canvas.style.imageRendering;
+    supportsImageRenderingPixelatedResult = defined_default(tmp) && tmp !== "";
+    if (supportsImageRenderingPixelatedResult) {
+      imageRenderingValueResult = tmp;
+    }
+  }
+  return supportsImageRenderingPixelatedResult;
+}
+function imageRenderingValue() {
+  return supportsImageRenderingPixelated() ? imageRenderingValueResult : void 0;
+}
+function supportsWebP() {
+  if (!supportsWebP.initialized) {
+    throw new DeveloperError_default(
+      "You must call FeatureDetection.supportsWebP.initialize and wait for the promise to resolve before calling FeatureDetection.supportsWebP"
+    );
+  }
+  return supportsWebP._result;
+}
+supportsWebP._promise = void 0;
+supportsWebP._result = void 0;
+supportsWebP.initialize = function() {
+  if (defined_default(supportsWebP._promise)) {
+    return supportsWebP._promise;
+  }
+  supportsWebP._promise = new Promise((resolve) => {
+    const image = new Image();
+    image.onload = function() {
+      supportsWebP._result = image.width > 0 && image.height > 0;
+      resolve(supportsWebP._result);
+    };
+    image.onerror = function() {
+      supportsWebP._result = false;
+      resolve(supportsWebP._result);
+    };
+    image.src = "data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA";
+  });
+  return supportsWebP._promise;
+};
+Object.defineProperties(supportsWebP, {
+  initialized: {
+    get: function() {
+      return defined_default(supportsWebP._result);
+    }
+  }
+});
+var typedArrayTypes = [];
+if (typeof ArrayBuffer !== "undefined") {
+  typedArrayTypes.push(
+    Int8Array,
+    Uint8Array,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array
+  );
+  if (typeof Uint8ClampedArray !== "undefined") {
+    typedArrayTypes.push(Uint8ClampedArray);
+  }
+  if (typeof Uint8ClampedArray !== "undefined") {
+    typedArrayTypes.push(Uint8ClampedArray);
+  }
+  if (typeof BigInt64Array !== "undefined") {
+    typedArrayTypes.push(BigInt64Array);
+  }
+  if (typeof BigUint64Array !== "undefined") {
+    typedArrayTypes.push(BigUint64Array);
+  }
+}
+var FeatureDetection = {
+  isChrome,
+  chromeVersion,
+  isSafari,
+  safariVersion,
+  isWebkit,
+  webkitVersion,
+  isInternetExplorer,
+  internetExplorerVersion,
+  isEdge,
+  edgeVersion,
+  isFirefox,
+  firefoxVersion,
+  isWindows,
+  isIPadOrIOS,
+  hardwareConcurrency: defaultValue_default(theNavigator.hardwareConcurrency, 3),
+  supportsPointerEvents,
+  supportsImageRenderingPixelated,
+  supportsWebP,
+  imageRenderingValue,
+  typedArrayTypes
+};
+FeatureDetection.supportsBasis = function(scene) {
+  return FeatureDetection.supportsWebAssembly() && scene.context.supportsBasis;
+};
+FeatureDetection.supportsFullscreen = function() {
+  return Fullscreen_default.supportsFullscreen();
+};
+FeatureDetection.supportsTypedArrays = function() {
+  return typeof ArrayBuffer !== "undefined";
+};
+FeatureDetection.supportsBigInt64Array = function() {
+  return typeof BigInt64Array !== "undefined";
+};
+FeatureDetection.supportsBigUint64Array = function() {
+  return typeof BigUint64Array !== "undefined";
+};
+FeatureDetection.supportsBigInt = function() {
+  return typeof BigInt !== "undefined";
+};
+FeatureDetection.supportsWebWorkers = function() {
+  return typeof Worker !== "undefined";
+};
+FeatureDetection.supportsWebAssembly = function() {
+  return typeof WebAssembly !== "undefined";
+};
+FeatureDetection.supportsWebgl2 = function(scene) {
+  Check_default.defined("scene", scene);
+  return scene.context.webgl2;
+};
+FeatureDetection.supportsEsmWebWorkers = function() {
+  return !isFirefox() || parseInt(firefoxVersionResult) >= 114;
+};
+var FeatureDetection_default = FeatureDetection;
+
 export {
   Cartesian3_default,
   Cartographic_default,
+  Cartesian2_default,
   Ellipsoid_default,
-  Matrix3_default
+  Matrix3_default,
+  FeatureDetection_default
 };