@rtzh/engine 0.0.7 → 0.0.9

package/Build/Workers/chunk-5WAMP6Z4.js

@@ -0,0 +1,299 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.9
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  Matrix2_default,
+  Quaternion_default,
+  Rectangle_default,
+  Transforms_default
+} from "./chunk-5IOA3NCI.js";
+import {
+  Matrix4_default
+} from "./chunk-K2PUGKEO.js";
+import {
+  WebGLConstants_default
+} from "./chunk-WZJEAPEP.js";
+import {
+  Cartesian2_default,
+  Cartographic_default
+} from "./chunk-SPPYSEH2.js";
+import {
+  Cartesian3_default,
+  Frozen_default,
+  Matrix3_default
+} from "./chunk-CR6BZUQC.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-JM4TFRYQ.js";
+import {
+  defined_default
+} from "./chunk-L33HPENB.js";
+
+// packages/engine/Source/Core/GeometryType.js
+var GeometryType = {
+  NONE: 0,
+  TRIANGLES: 1,
+  LINES: 2,
+  POLYLINES: 3
+};
+var GeometryType_default = Object.freeze(GeometryType);
+
+// packages/engine/Source/Core/PrimitiveType.js
+var PrimitiveType = {
+  /**
+   * Points primitive where each vertex (or index) is a separate point.
+   *
+   * @type {number}
+   * @constant
+   */
+  POINTS: WebGLConstants_default.POINTS,
+  /**
+   * Lines primitive where each two vertices (or indices) is a line segment.  Line segments are not necessarily connected.
+   *
+   * @type {number}
+   * @constant
+   */
+  LINES: WebGLConstants_default.LINES,
+  /**
+   * Line loop primitive where each vertex (or index) after the first connects a line to
+   * the previous vertex, and the last vertex implicitly connects to the first.
+   *
+   * @type {number}
+   * @constant
+   */
+  LINE_LOOP: WebGLConstants_default.LINE_LOOP,
+  /**
+   * Line strip primitive where each vertex (or index) after the first connects a line to the previous vertex.
+   *
+   * @type {number}
+   * @constant
+   */
+  LINE_STRIP: WebGLConstants_default.LINE_STRIP,
+  /**
+   * Triangles primitive where each three vertices (or indices) is a triangle.  Triangles do not necessarily share edges.
+   *
+   * @type {number}
+   * @constant
+   */
+  TRIANGLES: WebGLConstants_default.TRIANGLES,
+  /**
+   * Triangle strip primitive where each vertex (or index) after the first two connect to
+   * the previous two vertices forming a triangle.  For example, this can be used to model a wall.
+   *
+   * @type {number}
+   * @constant
+   */
+  TRIANGLE_STRIP: WebGLConstants_default.TRIANGLE_STRIP,
+  /**
+   * Triangle fan primitive where each vertex (or index) after the first two connect to
+   * the previous vertex and the first vertex forming a triangle.  For example, this can be used
+   * to model a cone or circle.
+   *
+   * @type {number}
+   * @constant
+   */
+  TRIANGLE_FAN: WebGLConstants_default.TRIANGLE_FAN
+};
+PrimitiveType.isLines = function(primitiveType) {
+  return primitiveType === PrimitiveType.LINES || primitiveType === PrimitiveType.LINE_LOOP || primitiveType === PrimitiveType.LINE_STRIP;
+};
+PrimitiveType.isTriangles = function(primitiveType) {
+  return primitiveType === PrimitiveType.TRIANGLES || primitiveType === PrimitiveType.TRIANGLE_STRIP || primitiveType === PrimitiveType.TRIANGLE_FAN;
+};
+PrimitiveType.validate = function(primitiveType) {
+  return primitiveType === PrimitiveType.POINTS || primitiveType === PrimitiveType.LINES || primitiveType === PrimitiveType.LINE_LOOP || primitiveType === PrimitiveType.LINE_STRIP || primitiveType === PrimitiveType.TRIANGLES || primitiveType === PrimitiveType.TRIANGLE_STRIP || primitiveType === PrimitiveType.TRIANGLE_FAN;
+};
+var PrimitiveType_default = Object.freeze(PrimitiveType);
+
+// packages/engine/Source/Core/Geometry.js
+function Geometry(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  Check_default.typeOf.object("options.attributes", options.attributes);
+  this.attributes = options.attributes;
+  this.indices = options.indices;
+  this.primitiveType = options.primitiveType ?? PrimitiveType_default.TRIANGLES;
+  this.boundingSphere = options.boundingSphere;
+  this.geometryType = options.geometryType ?? GeometryType_default.NONE;
+  this.boundingSphereCV = options.boundingSphereCV;
+  this.offsetAttribute = options.offsetAttribute;
+}
+Geometry.computeNumberOfVertices = function(geometry) {
+  Check_default.typeOf.object("geometry", geometry);
+  let numberOfVertices = -1;
+  for (const property in geometry.attributes) {
+    if (geometry.attributes.hasOwnProperty(property) && defined_default(geometry.attributes[property]) && defined_default(geometry.attributes[property].values)) {
+      const attribute = geometry.attributes[property];
+      const num = attribute.values.length / attribute.componentsPerAttribute;
+      if (numberOfVertices !== num && numberOfVertices !== -1) {
+        throw new DeveloperError_default(
+          "All attribute lists must have the same number of attributes."
+        );
+      }
+      numberOfVertices = num;
+    }
+  }
+  return numberOfVertices;
+};
+var rectangleCenterScratch = new Cartographic_default();
+var enuCenterScratch = new Cartesian3_default();
+var fixedFrameToEnuScratch = new Matrix4_default();
+var boundingRectanglePointsCartographicScratch = [
+  new Cartographic_default(),
+  new Cartographic_default(),
+  new Cartographic_default()
+];
+var boundingRectanglePointsEnuScratch = [
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default()
+];
+var points2DScratch = [new Cartesian2_default(), new Cartesian2_default(), new Cartesian2_default()];
+var pointEnuScratch = new Cartesian3_default();
+var enuRotationScratch = new Quaternion_default();
+var enuRotationMatrixScratch = new Matrix4_default();
+var rotation2DScratch = new Matrix2_default();
+Geometry._textureCoordinateRotationPoints = function(positions, stRotation, ellipsoid, boundingRectangle) {
+  let i;
+  const rectangleCenter = Rectangle_default.center(
+    boundingRectangle,
+    rectangleCenterScratch
+  );
+  const enuCenter = Cartographic_default.toCartesian(
+    rectangleCenter,
+    ellipsoid,
+    enuCenterScratch
+  );
+  const enuToFixedFrame = Transforms_default.eastNorthUpToFixedFrame(
+    enuCenter,
+    ellipsoid,
+    fixedFrameToEnuScratch
+  );
+  const fixedFrameToEnu = Matrix4_default.inverse(
+    enuToFixedFrame,
+    fixedFrameToEnuScratch
+  );
+  const boundingPointsEnu = boundingRectanglePointsEnuScratch;
+  const boundingPointsCarto = boundingRectanglePointsCartographicScratch;
+  boundingPointsCarto[0].longitude = boundingRectangle.west;
+  boundingPointsCarto[0].latitude = boundingRectangle.south;
+  boundingPointsCarto[1].longitude = boundingRectangle.west;
+  boundingPointsCarto[1].latitude = boundingRectangle.north;
+  boundingPointsCarto[2].longitude = boundingRectangle.east;
+  boundingPointsCarto[2].latitude = boundingRectangle.south;
+  let posEnu = pointEnuScratch;
+  for (i = 0; i < 3; i++) {
+    Cartographic_default.toCartesian(boundingPointsCarto[i], ellipsoid, posEnu);
+    posEnu = Matrix4_default.multiplyByPointAsVector(fixedFrameToEnu, posEnu, posEnu);
+    boundingPointsEnu[i].x = posEnu.x;
+    boundingPointsEnu[i].y = posEnu.y;
+  }
+  const rotation = Quaternion_default.fromAxisAngle(
+    Cartesian3_default.UNIT_Z,
+    -stRotation,
+    enuRotationScratch
+  );
+  const textureMatrix = Matrix3_default.fromQuaternion(
+    rotation,
+    enuRotationMatrixScratch
+  );
+  const positionsLength = positions.length;
+  let enuMinX = Number.POSITIVE_INFINITY;
+  let enuMinY = Number.POSITIVE_INFINITY;
+  let enuMaxX = Number.NEGATIVE_INFINITY;
+  let enuMaxY = Number.NEGATIVE_INFINITY;
+  for (i = 0; i < positionsLength; i++) {
+    posEnu = Matrix4_default.multiplyByPointAsVector(
+      fixedFrameToEnu,
+      positions[i],
+      posEnu
+    );
+    posEnu = Matrix3_default.multiplyByVector(textureMatrix, posEnu, posEnu);
+    enuMinX = Math.min(enuMinX, posEnu.x);
+    enuMinY = Math.min(enuMinY, posEnu.y);
+    enuMaxX = Math.max(enuMaxX, posEnu.x);
+    enuMaxY = Math.max(enuMaxY, posEnu.y);
+  }
+  const toDesiredInComputed = Matrix2_default.fromRotation(
+    stRotation,
+    rotation2DScratch
+  );
+  const points2D = points2DScratch;
+  points2D[0].x = enuMinX;
+  points2D[0].y = enuMinY;
+  points2D[1].x = enuMinX;
+  points2D[1].y = enuMaxY;
+  points2D[2].x = enuMaxX;
+  points2D[2].y = enuMinY;
+  const boundingEnuMin = boundingPointsEnu[0];
+  const boundingPointsWidth = boundingPointsEnu[2].x - boundingEnuMin.x;
+  const boundingPointsHeight = boundingPointsEnu[1].y - boundingEnuMin.y;
+  for (i = 0; i < 3; i++) {
+    const point2D = points2D[i];
+    Matrix2_default.multiplyByVector(toDesiredInComputed, point2D, point2D);
+    point2D.x = (point2D.x - boundingEnuMin.x) / boundingPointsWidth;
+    point2D.y = (point2D.y - boundingEnuMin.y) / boundingPointsHeight;
+  }
+  const minXYCorner = points2D[0];
+  const maxYCorner = points2D[1];
+  const maxXCorner = points2D[2];
+  const result = new Array(6);
+  Cartesian2_default.pack(minXYCorner, result);
+  Cartesian2_default.pack(maxYCorner, result, 2);
+  Cartesian2_default.pack(maxXCorner, result, 4);
+  return result;
+};
+var Geometry_default = Geometry;
+
+// packages/engine/Source/Core/GeometryAttribute.js
+function GeometryAttribute(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  if (!defined_default(options.componentDatatype)) {
+    throw new DeveloperError_default("options.componentDatatype is required.");
+  }
+  if (!defined_default(options.componentsPerAttribute)) {
+    throw new DeveloperError_default("options.componentsPerAttribute is required.");
+  }
+  if (options.componentsPerAttribute < 1 || options.componentsPerAttribute > 4) {
+    throw new DeveloperError_default(
+      "options.componentsPerAttribute must be between 1 and 4."
+    );
+  }
+  if (!defined_default(options.values)) {
+    throw new DeveloperError_default("options.values is required.");
+  }
+  this.componentDatatype = options.componentDatatype;
+  this.componentsPerAttribute = options.componentsPerAttribute;
+  this.normalize = options.normalize ?? false;
+  this.values = options.values;
+}
+var GeometryAttribute_default = GeometryAttribute;
+
+export {
+  GeometryType_default,
+  PrimitiveType_default,
+  Geometry_default,
+  GeometryAttribute_default
+};

package/Build/Workers/chunk-6F4HKBHD.js

@@ -0,0 +1,352 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.9
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-SPPYSEH2.js";
+import {
+  Cartesian3_default
+} from "./chunk-CR6BZUQC.js";
+import {
+  Math_default
+} from "./chunk-4SZJ3KRD.js";
+import {
+  Check_default
+} from "./chunk-JM4TFRYQ.js";
+import {
+  defined_default
+} from "./chunk-L33HPENB.js";
+
+// packages/engine/Source/Core/EllipsoidGeodesic.js
+function setConstants(ellipsoidGeodesic) {
+  const uSquared = ellipsoidGeodesic._uSquared;
+  const a = ellipsoidGeodesic._ellipsoid.maximumRadius;
+  const b = ellipsoidGeodesic._ellipsoid.minimumRadius;
+  const f = (a - b) / a;
+  const cosineHeading = Math.cos(ellipsoidGeodesic._startHeading);
+  const sineHeading = Math.sin(ellipsoidGeodesic._startHeading);
+  const tanU = (1 - f) * Math.tan(ellipsoidGeodesic._start.latitude);
+  const cosineU = 1 / Math.sqrt(1 + tanU * tanU);
+  const sineU = cosineU * tanU;
+  const sigma = Math.atan2(tanU, cosineHeading);
+  const sineAlpha = cosineU * sineHeading;
+  const sineSquaredAlpha = sineAlpha * sineAlpha;
+  const cosineSquaredAlpha = 1 - sineSquaredAlpha;
+  const cosineAlpha = Math.sqrt(cosineSquaredAlpha);
+  const u2Over4 = uSquared / 4;
+  const u4Over16 = u2Over4 * u2Over4;
+  const u6Over64 = u4Over16 * u2Over4;
+  const u8Over256 = u4Over16 * u4Over16;
+  const a0 = 1 + u2Over4 - 3 * u4Over16 / 4 + 5 * u6Over64 / 4 - 175 * u8Over256 / 64;
+  const a1 = 1 - u2Over4 + 15 * u4Over16 / 8 - 35 * u6Over64 / 8;
+  const a2 = 1 - 3 * u2Over4 + 35 * u4Over16 / 4;
+  const a3 = 1 - 5 * u2Over4;
+  const distanceRatio = a0 * sigma - a1 * Math.sin(2 * sigma) * u2Over4 / 2 - a2 * Math.sin(4 * sigma) * u4Over16 / 16 - a3 * Math.sin(6 * sigma) * u6Over64 / 48 - Math.sin(8 * sigma) * 5 * u8Over256 / 512;
+  const constants = ellipsoidGeodesic._constants;
+  constants.a = a;
+  constants.b = b;
+  constants.f = f;
+  constants.cosineHeading = cosineHeading;
+  constants.sineHeading = sineHeading;
+  constants.tanU = tanU;
+  constants.cosineU = cosineU;
+  constants.sineU = sineU;
+  constants.sigma = sigma;
+  constants.sineAlpha = sineAlpha;
+  constants.sineSquaredAlpha = sineSquaredAlpha;
+  constants.cosineSquaredAlpha = cosineSquaredAlpha;
+  constants.cosineAlpha = cosineAlpha;
+  constants.u2Over4 = u2Over4;
+  constants.u4Over16 = u4Over16;
+  constants.u6Over64 = u6Over64;
+  constants.u8Over256 = u8Over256;
+  constants.a0 = a0;
+  constants.a1 = a1;
+  constants.a2 = a2;
+  constants.a3 = a3;
+  constants.distanceRatio = distanceRatio;
+}
+function computeC(f, cosineSquaredAlpha) {
+  return f * cosineSquaredAlpha * (4 + f * (4 - 3 * cosineSquaredAlpha)) / 16;
+}
+function computeDeltaLambda(f, sineAlpha, cosineSquaredAlpha, sigma, sineSigma, cosineSigma, cosineTwiceSigmaMidpoint) {
+  const C = computeC(f, cosineSquaredAlpha);
+  return (1 - C) * f * sineAlpha * (sigma + C * sineSigma * (cosineTwiceSigmaMidpoint + C * cosineSigma * (2 * cosineTwiceSigmaMidpoint * cosineTwiceSigmaMidpoint - 1)));
+}
+function vincentyInverseFormula(ellipsoidGeodesic, major, minor, firstLongitude, firstLatitude, secondLongitude, secondLatitude) {
+  const eff = (major - minor) / major;
+  const l = secondLongitude - firstLongitude;
+  const u1 = Math.atan((1 - eff) * Math.tan(firstLatitude));
+  const u2 = Math.atan((1 - eff) * Math.tan(secondLatitude));
+  const cosineU1 = Math.cos(u1);
+  const sineU1 = Math.sin(u1);
+  const cosineU2 = Math.cos(u2);
+  const sineU2 = Math.sin(u2);
+  const cc = cosineU1 * cosineU2;
+  const cs = cosineU1 * sineU2;
+  const ss = sineU1 * sineU2;
+  const sc = sineU1 * cosineU2;
+  let lambda = l;
+  let lambdaDot = Math_default.TWO_PI;
+  let cosineLambda = Math.cos(lambda);
+  let sineLambda = Math.sin(lambda);
+  let sigma;
+  let cosineSigma;
+  let sineSigma;
+  let cosineSquaredAlpha;
+  let cosineTwiceSigmaMidpoint;
+  do {
+    cosineLambda = Math.cos(lambda);
+    sineLambda = Math.sin(lambda);
+    const temp = cs - sc * cosineLambda;
+    sineSigma = Math.sqrt(
+      cosineU2 * cosineU2 * sineLambda * sineLambda + temp * temp
+    );
+    cosineSigma = ss + cc * cosineLambda;
+    sigma = Math.atan2(sineSigma, cosineSigma);
+    let sineAlpha;
+    if (sineSigma === 0) {
+      sineAlpha = 0;
+      cosineSquaredAlpha = 1;
+    } else {
+      sineAlpha = cc * sineLambda / sineSigma;
+      cosineSquaredAlpha = 1 - sineAlpha * sineAlpha;
+    }
+    lambdaDot = lambda;
+    cosineTwiceSigmaMidpoint = cosineSigma - 2 * ss / cosineSquaredAlpha;
+    if (!isFinite(cosineTwiceSigmaMidpoint)) {
+      cosineTwiceSigmaMidpoint = 0;
+    }
+    lambda = l + computeDeltaLambda(
+      eff,
+      sineAlpha,
+      cosineSquaredAlpha,
+      sigma,
+      sineSigma,
+      cosineSigma,
+      cosineTwiceSigmaMidpoint
+    );
+  } while (Math.abs(lambda - lambdaDot) > Math_default.EPSILON12);
+  const uSquared = cosineSquaredAlpha * (major * major - minor * minor) / (minor * minor);
+  const A = 1 + uSquared * (4096 + uSquared * (uSquared * (320 - 175 * uSquared) - 768)) / 16384;
+  const B = uSquared * (256 + uSquared * (uSquared * (74 - 47 * uSquared) - 128)) / 1024;
+  const cosineSquaredTwiceSigmaMidpoint = cosineTwiceSigmaMidpoint * cosineTwiceSigmaMidpoint;
+  const deltaSigma = B * sineSigma * (cosineTwiceSigmaMidpoint + B * (cosineSigma * (2 * cosineSquaredTwiceSigmaMidpoint - 1) - B * cosineTwiceSigmaMidpoint * (4 * sineSigma * sineSigma - 3) * (4 * cosineSquaredTwiceSigmaMidpoint - 3) / 6) / 4);
+  const distance = minor * A * (sigma - deltaSigma);
+  const startHeading = Math.atan2(
+    cosineU2 * sineLambda,
+    cs - sc * cosineLambda
+  );
+  const endHeading = Math.atan2(cosineU1 * sineLambda, cs * cosineLambda - sc);
+  ellipsoidGeodesic._distance = distance;
+  ellipsoidGeodesic._startHeading = startHeading;
+  ellipsoidGeodesic._endHeading = endHeading;
+  ellipsoidGeodesic._uSquared = uSquared;
+}
+var scratchCart1 = new Cartesian3_default();
+var scratchCart2 = new Cartesian3_default();
+function computeProperties(ellipsoidGeodesic, start, end, ellipsoid) {
+  const firstCartesian = Cartesian3_default.normalize(
+    ellipsoid.cartographicToCartesian(start, scratchCart2),
+    scratchCart1
+  );
+  const lastCartesian = Cartesian3_default.normalize(
+    ellipsoid.cartographicToCartesian(end, scratchCart2),
+    scratchCart2
+  );
+  Check_default.typeOf.number.greaterThanOrEquals(
+    "value",
+    Math.abs(
+      Math.abs(Cartesian3_default.angleBetween(firstCartesian, lastCartesian)) - Math.PI
+    ),
+    0.0125
+  );
+  vincentyInverseFormula(
+    ellipsoidGeodesic,
+    ellipsoid.maximumRadius,
+    ellipsoid.minimumRadius,
+    start.longitude,
+    start.latitude,
+    end.longitude,
+    end.latitude
+  );
+  ellipsoidGeodesic._start = Cartographic_default.clone(
+    start,
+    ellipsoidGeodesic._start
+  );
+  ellipsoidGeodesic._end = Cartographic_default.clone(end, ellipsoidGeodesic._end);
+  ellipsoidGeodesic._start.height = 0;
+  ellipsoidGeodesic._end.height = 0;
+  setConstants(ellipsoidGeodesic);
+}
+function EllipsoidGeodesic(start, end, ellipsoid) {
+  const e = ellipsoid ?? Ellipsoid_default.default;
+  this._ellipsoid = e;
+  this._start = new Cartographic_default();
+  this._end = new Cartographic_default();
+  this._constants = {};
+  this._startHeading = void 0;
+  this._endHeading = void 0;
+  this._distance = void 0;
+  this._uSquared = void 0;
+  if (defined_default(start) && defined_default(end)) {
+    computeProperties(this, start, end, e);
+  }
+}
+Object.defineProperties(EllipsoidGeodesic.prototype, {
+  /**
+   * Gets the ellipsoid.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {Ellipsoid}
+   * @readonly
+   */
+  ellipsoid: {
+    get: function() {
+      return this._ellipsoid;
+    }
+  },
+  /**
+   * Gets the surface distance between the start and end point
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {number}
+   * @readonly
+   */
+  surfaceDistance: {
+    get: function() {
+      Check_default.defined("distance", this._distance);
+      return this._distance;
+    }
+  },
+  /**
+   * Gets the initial planetodetic point on the path.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {Cartographic}
+   * @readonly
+   */
+  start: {
+    get: function() {
+      return this._start;
+    }
+  },
+  /**
+   * Gets the final planetodetic point on the path.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {Cartographic}
+   * @readonly
+   */
+  end: {
+    get: function() {
+      return this._end;
+    }
+  },
+  /**
+   * Gets the heading at the initial point.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {number}
+   * @readonly
+   */
+  startHeading: {
+    get: function() {
+      Check_default.defined("distance", this._distance);
+      return this._startHeading;
+    }
+  },
+  /**
+   * Gets the heading at the final point.
+   * @memberof EllipsoidGeodesic.prototype
+   * @type {number}
+   * @readonly
+   */
+  endHeading: {
+    get: function() {
+      Check_default.defined("distance", this._distance);
+      return this._endHeading;
+    }
+  }
+});
+EllipsoidGeodesic.prototype.setEndPoints = function(start, end) {
+  Check_default.defined("start", start);
+  Check_default.defined("end", end);
+  computeProperties(this, start, end, this._ellipsoid);
+};
+EllipsoidGeodesic.prototype.interpolateUsingFraction = function(fraction, result) {
+  return this.interpolateUsingSurfaceDistance(
+    this._distance * fraction,
+    result
+  );
+};
+EllipsoidGeodesic.prototype.interpolateUsingSurfaceDistance = function(distance, result) {
+  Check_default.defined("distance", this._distance);
+  const constants = this._constants;
+  const s = constants.distanceRatio + distance / constants.b;
+  const cosine2S = Math.cos(2 * s);
+  const cosine4S = Math.cos(4 * s);
+  const cosine6S = Math.cos(6 * s);
+  const sine2S = Math.sin(2 * s);
+  const sine4S = Math.sin(4 * s);
+  const sine6S = Math.sin(6 * s);
+  const sine8S = Math.sin(8 * s);
+  const s2 = s * s;
+  const s3 = s * s2;
+  const u8Over256 = constants.u8Over256;
+  const u2Over4 = constants.u2Over4;
+  const u6Over64 = constants.u6Over64;
+  const u4Over16 = constants.u4Over16;
+  let sigma = 2 * s3 * u8Over256 * cosine2S / 3 + s * (1 - u2Over4 + 7 * u4Over16 / 4 - 15 * u6Over64 / 4 + 579 * u8Over256 / 64 - (u4Over16 - 15 * u6Over64 / 4 + 187 * u8Over256 / 16) * cosine2S - (5 * u6Over64 / 4 - 115 * u8Over256 / 16) * cosine4S - 29 * u8Over256 * cosine6S / 16) + (u2Over4 / 2 - u4Over16 + 71 * u6Over64 / 32 - 85 * u8Over256 / 16) * sine2S + (5 * u4Over16 / 16 - 5 * u6Over64 / 4 + 383 * u8Over256 / 96) * sine4S - s2 * ((u6Over64 - 11 * u8Over256 / 2) * sine2S + 5 * u8Over256 * sine4S / 2) + (29 * u6Over64 / 96 - 29 * u8Over256 / 16) * sine6S + 539 * u8Over256 * sine8S / 1536;
+  const theta = Math.asin(Math.sin(sigma) * constants.cosineAlpha);
+  const latitude = Math.atan(constants.a / constants.b * Math.tan(theta));
+  sigma = sigma - constants.sigma;
+  const cosineTwiceSigmaMidpoint = Math.cos(2 * constants.sigma + sigma);
+  const sineSigma = Math.sin(sigma);
+  const cosineSigma = Math.cos(sigma);
+  const cc = constants.cosineU * cosineSigma;
+  const ss = constants.sineU * sineSigma;
+  const lambda = Math.atan2(
+    sineSigma * constants.sineHeading,
+    cc - ss * constants.cosineHeading
+  );
+  const l = lambda - computeDeltaLambda(
+    constants.f,
+    constants.sineAlpha,
+    constants.cosineSquaredAlpha,
+    sigma,
+    sineSigma,
+    cosineSigma,
+    cosineTwiceSigmaMidpoint
+  );
+  if (defined_default(result)) {
+    result.longitude = this._start.longitude + l;
+    result.latitude = latitude;
+    result.height = 0;
+    return result;
+  }
+  return new Cartographic_default(this._start.longitude + l, latitude, 0);
+};
+var EllipsoidGeodesic_default = EllipsoidGeodesic;
+
+export {
+  EllipsoidGeodesic_default
+};