@cesium/engine 10.1.0 → 11.1.0

package/Build/Workers/chunk-OAPA2RTG.js

@@ -1,239 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.120
- *
- * 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 {
-  GeographicProjection_default
-} from "./chunk-ELI4BUOT.js";
-import {
-  Matrix2_default,
-  Rectangle_default
-} from "./chunk-OXALEQPI.js";
-import {
-  Cartesian3_default,
-  Cartographic_default,
-  Ellipsoid_default
-} from "./chunk-T6LPN7RI.js";
-import {
-  Math_default
-} from "./chunk-R4OIEIPE.js";
-import {
-  DeveloperError_default
-} from "./chunk-TGY6H6N6.js";
-import {
-  defined_default
-} from "./chunk-N4QEHO3U.js";
-
-// packages/engine/Source/Core/RectangleGeometryLibrary.js
-var cos = Math.cos;
-var sin = Math.sin;
-var sqrt = Math.sqrt;
-var RectangleGeometryLibrary = {};
-RectangleGeometryLibrary.computePosition = function(computedOptions, ellipsoid, computeST, row, col, position, st) {
-  const radiiSquared = ellipsoid.radiiSquared;
-  const nwCorner = computedOptions.nwCorner;
-  const rectangle = computedOptions.boundingRectangle;
-  let stLatitude = nwCorner.latitude - computedOptions.granYCos * row + col * computedOptions.granXSin;
-  const cosLatitude = cos(stLatitude);
-  const nZ = sin(stLatitude);
-  const kZ = radiiSquared.z * nZ;
-  let stLongitude = nwCorner.longitude + row * computedOptions.granYSin + col * computedOptions.granXCos;
-  const nX = cosLatitude * cos(stLongitude);
-  const nY = cosLatitude * sin(stLongitude);
-  const kX = radiiSquared.x * nX;
-  const kY = radiiSquared.y * nY;
-  const gamma = sqrt(kX * nX + kY * nY + kZ * nZ);
-  position.x = kX / gamma;
-  position.y = kY / gamma;
-  position.z = kZ / gamma;
-  if (computeST) {
-    const stNwCorner = computedOptions.stNwCorner;
-    if (defined_default(stNwCorner)) {
-      stLatitude = stNwCorner.latitude - computedOptions.stGranYCos * row + col * computedOptions.stGranXSin;
-      stLongitude = stNwCorner.longitude + row * computedOptions.stGranYSin + col * computedOptions.stGranXCos;
-      st.x = (stLongitude - computedOptions.stWest) * computedOptions.lonScalar;
-      st.y = (stLatitude - computedOptions.stSouth) * computedOptions.latScalar;
-    } else {
-      st.x = (stLongitude - rectangle.west) * computedOptions.lonScalar;
-      st.y = (stLatitude - rectangle.south) * computedOptions.latScalar;
-    }
-  }
-};
-var rotationMatrixScratch = new Matrix2_default();
-var nwCartesian = new Cartesian3_default();
-var centerScratch = new Cartographic_default();
-var centerCartesian = new Cartesian3_default();
-var proj = new GeographicProjection_default();
-function getRotationOptions(nwCorner, rotation, granularityX, granularityY, center, width, height) {
-  const cosRotation = Math.cos(rotation);
-  const granYCos = granularityY * cosRotation;
-  const granXCos = granularityX * cosRotation;
-  const sinRotation = Math.sin(rotation);
-  const granYSin = granularityY * sinRotation;
-  const granXSin = granularityX * sinRotation;
-  proj._ellipsoid = Ellipsoid_default.default;
-  nwCartesian = proj.project(nwCorner, nwCartesian);
-  nwCartesian = Cartesian3_default.subtract(nwCartesian, centerCartesian, nwCartesian);
-  const rotationMatrix = Matrix2_default.fromRotation(rotation, rotationMatrixScratch);
-  nwCartesian = Matrix2_default.multiplyByVector(
-    rotationMatrix,
-    nwCartesian,
-    nwCartesian
-  );
-  nwCartesian = Cartesian3_default.add(nwCartesian, centerCartesian, nwCartesian);
-  nwCorner = proj.unproject(nwCartesian, nwCorner);
-  width -= 1;
-  height -= 1;
-  const latitude = nwCorner.latitude;
-  const latitude0 = latitude + width * granXSin;
-  const latitude1 = latitude - granYCos * height;
-  const latitude2 = latitude - granYCos * height + width * granXSin;
-  const north = Math.max(latitude, latitude0, latitude1, latitude2);
-  const south = Math.min(latitude, latitude0, latitude1, latitude2);
-  const longitude = nwCorner.longitude;
-  const longitude0 = longitude + width * granXCos;
-  const longitude1 = longitude + height * granYSin;
-  const longitude2 = longitude + height * granYSin + width * granXCos;
-  const east = Math.max(longitude, longitude0, longitude1, longitude2);
-  const west = Math.min(longitude, longitude0, longitude1, longitude2);
-  return {
-    north,
-    south,
-    east,
-    west,
-    granYCos,
-    granYSin,
-    granXCos,
-    granXSin,
-    nwCorner
-  };
-}
-RectangleGeometryLibrary.computeOptions = function(rectangle, granularity, rotation, stRotation, boundingRectangleScratch, nwCornerResult, stNwCornerResult) {
-  let east = rectangle.east;
-  let west = rectangle.west;
-  let north = rectangle.north;
-  let south = rectangle.south;
-  let northCap = false;
-  let southCap = false;
-  if (north === Math_default.PI_OVER_TWO) {
-    northCap = true;
-  }
-  if (south === -Math_default.PI_OVER_TWO) {
-    southCap = true;
-  }
-  let dx;
-  const dy = north - south;
-  if (west > east) {
-    dx = Math_default.TWO_PI - west + east;
-  } else {
-    dx = east - west;
-  }
-  const width = Math.ceil(dx / granularity) + 1;
-  const height = Math.ceil(dy / granularity) + 1;
-  const granularityX = dx / (width - 1);
-  const granularityY = dy / (height - 1);
-  const nwCorner = Rectangle_default.northwest(rectangle, nwCornerResult);
-  const center = Rectangle_default.center(rectangle, centerScratch);
-  if (rotation !== 0 || stRotation !== 0) {
-    if (center.longitude < nwCorner.longitude) {
-      center.longitude += Math_default.TWO_PI;
-    }
-    proj._ellipsoid = Ellipsoid_default.default;
-    centerCartesian = proj.project(center, centerCartesian);
-  }
-  const granYCos = granularityY;
-  const granXCos = granularityX;
-  const granYSin = 0;
-  const granXSin = 0;
-  const boundingRectangle = Rectangle_default.clone(
-    rectangle,
-    boundingRectangleScratch
-  );
-  const computedOptions = {
-    granYCos,
-    granYSin,
-    granXCos,
-    granXSin,
-    nwCorner,
-    boundingRectangle,
-    width,
-    height,
-    northCap,
-    southCap
-  };
-  if (rotation !== 0) {
-    const rotationOptions = getRotationOptions(
-      nwCorner,
-      rotation,
-      granularityX,
-      granularityY,
-      center,
-      width,
-      height
-    );
-    north = rotationOptions.north;
-    south = rotationOptions.south;
-    east = rotationOptions.east;
-    west = rotationOptions.west;
-    if (north < -Math_default.PI_OVER_TWO || north > Math_default.PI_OVER_TWO || south < -Math_default.PI_OVER_TWO || south > Math_default.PI_OVER_TWO) {
-      throw new DeveloperError_default(
-        "Rotated rectangle is invalid.  It crosses over either the north or south pole."
-      );
-    }
-    computedOptions.granYCos = rotationOptions.granYCos;
-    computedOptions.granYSin = rotationOptions.granYSin;
-    computedOptions.granXCos = rotationOptions.granXCos;
-    computedOptions.granXSin = rotationOptions.granXSin;
-    boundingRectangle.north = north;
-    boundingRectangle.south = south;
-    boundingRectangle.east = east;
-    boundingRectangle.west = west;
-  }
-  if (stRotation !== 0) {
-    rotation = rotation - stRotation;
-    const stNwCorner = Rectangle_default.northwest(boundingRectangle, stNwCornerResult);
-    const stRotationOptions = getRotationOptions(
-      stNwCorner,
-      rotation,
-      granularityX,
-      granularityY,
-      center,
-      width,
-      height
-    );
-    computedOptions.stGranYCos = stRotationOptions.granYCos;
-    computedOptions.stGranXCos = stRotationOptions.granXCos;
-    computedOptions.stGranYSin = stRotationOptions.granYSin;
-    computedOptions.stGranXSin = stRotationOptions.granXSin;
-    computedOptions.stNwCorner = stNwCorner;
-    computedOptions.stWest = stRotationOptions.west;
-    computedOptions.stSouth = stRotationOptions.south;
-  }
-  return computedOptions;
-};
-var RectangleGeometryLibrary_default = RectangleGeometryLibrary;
-
-export {
-  RectangleGeometryLibrary_default
-};

package/Build/Workers/chunk-OE4MCOC7.js

@@ -1,421 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.120
- *
- * 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 {
-  EllipsoidGeodesic_default
-} from "./chunk-6D66DPRV.js";
-import {
-  EllipsoidRhumbLine_default
-} from "./chunk-BY3E4ONI.js";
-import {
-  IntersectionTests_default
-} from "./chunk-TF776XCO.js";
-import {
-  Plane_default
-} from "./chunk-A5CODJ4M.js";
-import {
-  Matrix4_default
-} from "./chunk-OXALEQPI.js";
-import {
-  Cartesian3_default,
-  Cartographic_default,
-  Ellipsoid_default
-} from "./chunk-T6LPN7RI.js";
-import {
-  Math_default
-} from "./chunk-R4OIEIPE.js";
-import {
-  defaultValue_default
-} from "./chunk-BAVI3ZS2.js";
-import {
-  DeveloperError_default
-} from "./chunk-TGY6H6N6.js";
-import {
-  defined_default
-} from "./chunk-N4QEHO3U.js";
-
-// packages/engine/Source/Core/PolylinePipeline.js
-var PolylinePipeline = {};
-PolylinePipeline.numberOfPoints = function(p0, p1, minDistance) {
-  const distance = Cartesian3_default.distance(p0, p1);
-  return Math.ceil(distance / minDistance);
-};
-PolylinePipeline.numberOfPointsRhumbLine = function(p0, p1, granularity) {
-  const radiansDistanceSquared = Math.pow(p0.longitude - p1.longitude, 2) + Math.pow(p0.latitude - p1.latitude, 2);
-  return Math.max(
-    1,
-    Math.ceil(Math.sqrt(radiansDistanceSquared / (granularity * granularity)))
-  );
-};
-var cartoScratch = new Cartographic_default();
-PolylinePipeline.extractHeights = function(positions, ellipsoid) {
-  const length = positions.length;
-  const heights = new Array(length);
-  for (let i = 0; i < length; i++) {
-    const p = positions[i];
-    heights[i] = ellipsoid.cartesianToCartographic(p, cartoScratch).height;
-  }
-  return heights;
-};
-var wrapLongitudeInversMatrix = new Matrix4_default();
-var wrapLongitudeOrigin = new Cartesian3_default();
-var wrapLongitudeXZNormal = new Cartesian3_default();
-var wrapLongitudeXZPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
-var wrapLongitudeYZNormal = new Cartesian3_default();
-var wrapLongitudeYZPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
-var wrapLongitudeIntersection = new Cartesian3_default();
-var wrapLongitudeOffset = new Cartesian3_default();
-var subdivideHeightsScratchArray = [];
-function subdivideHeights(numPoints, h0, h1) {
-  const heights = subdivideHeightsScratchArray;
-  heights.length = numPoints;
-  let i;
-  if (h0 === h1) {
-    for (i = 0; i < numPoints; i++) {
-      heights[i] = h0;
-    }
-    return heights;
-  }
-  const dHeight = h1 - h0;
-  const heightPerVertex = dHeight / numPoints;
-  for (i = 0; i < numPoints; i++) {
-    const h = h0 + i * heightPerVertex;
-    heights[i] = h;
-  }
-  return heights;
-}
-var carto1 = new Cartographic_default();
-var carto2 = new Cartographic_default();
-var cartesian = new Cartesian3_default();
-var scaleFirst = new Cartesian3_default();
-var scaleLast = new Cartesian3_default();
-var ellipsoidGeodesic = new EllipsoidGeodesic_default();
-var ellipsoidRhumb = new EllipsoidRhumbLine_default();
-function generateCartesianArc(p0, p1, minDistance, ellipsoid, h0, h1, array, offset) {
-  const first = ellipsoid.scaleToGeodeticSurface(p0, scaleFirst);
-  const last = ellipsoid.scaleToGeodeticSurface(p1, scaleLast);
-  const numPoints = PolylinePipeline.numberOfPoints(p0, p1, minDistance);
-  const start = ellipsoid.cartesianToCartographic(first, carto1);
-  const end = ellipsoid.cartesianToCartographic(last, carto2);
-  const heights = subdivideHeights(numPoints, h0, h1);
-  ellipsoidGeodesic.setEndPoints(start, end);
-  const surfaceDistanceBetweenPoints = ellipsoidGeodesic.surfaceDistance / numPoints;
-  let index = offset;
-  start.height = h0;
-  let cart = ellipsoid.cartographicToCartesian(start, cartesian);
-  Cartesian3_default.pack(cart, array, index);
-  index += 3;
-  for (let i = 1; i < numPoints; i++) {
-    const carto = ellipsoidGeodesic.interpolateUsingSurfaceDistance(
-      i * surfaceDistanceBetweenPoints,
-      carto2
-    );
-    carto.height = heights[i];
-    cart = ellipsoid.cartographicToCartesian(carto, cartesian);
-    Cartesian3_default.pack(cart, array, index);
-    index += 3;
-  }
-  return index;
-}
-function generateCartesianRhumbArc(p0, p1, granularity, ellipsoid, h0, h1, array, offset) {
-  const start = ellipsoid.cartesianToCartographic(p0, carto1);
-  const end = ellipsoid.cartesianToCartographic(p1, carto2);
-  const numPoints = PolylinePipeline.numberOfPointsRhumbLine(
-    start,
-    end,
-    granularity
-  );
-  start.height = 0;
-  end.height = 0;
-  const heights = subdivideHeights(numPoints, h0, h1);
-  if (!ellipsoidRhumb.ellipsoid.equals(ellipsoid)) {
-    ellipsoidRhumb = new EllipsoidRhumbLine_default(void 0, void 0, ellipsoid);
-  }
-  ellipsoidRhumb.setEndPoints(start, end);
-  const surfaceDistanceBetweenPoints = ellipsoidRhumb.surfaceDistance / numPoints;
-  let index = offset;
-  start.height = h0;
-  let cart = ellipsoid.cartographicToCartesian(start, cartesian);
-  Cartesian3_default.pack(cart, array, index);
-  index += 3;
-  for (let i = 1; i < numPoints; i++) {
-    const carto = ellipsoidRhumb.interpolateUsingSurfaceDistance(
-      i * surfaceDistanceBetweenPoints,
-      carto2
-    );
-    carto.height = heights[i];
-    cart = ellipsoid.cartographicToCartesian(carto, cartesian);
-    Cartesian3_default.pack(cart, array, index);
-    index += 3;
-  }
-  return index;
-}
-PolylinePipeline.wrapLongitude = function(positions, modelMatrix) {
-  const cartesians = [];
-  const segments = [];
-  if (defined_default(positions) && positions.length > 0) {
-    modelMatrix = defaultValue_default(modelMatrix, Matrix4_default.IDENTITY);
-    const inverseModelMatrix = Matrix4_default.inverseTransformation(
-      modelMatrix,
-      wrapLongitudeInversMatrix
-    );
-    const origin = Matrix4_default.multiplyByPoint(
-      inverseModelMatrix,
-      Cartesian3_default.ZERO,
-      wrapLongitudeOrigin
-    );
-    const xzNormal = Cartesian3_default.normalize(
-      Matrix4_default.multiplyByPointAsVector(
-        inverseModelMatrix,
-        Cartesian3_default.UNIT_Y,
-        wrapLongitudeXZNormal
-      ),
-      wrapLongitudeXZNormal
-    );
-    const xzPlane = Plane_default.fromPointNormal(
-      origin,
-      xzNormal,
-      wrapLongitudeXZPlane
-    );
-    const yzNormal = Cartesian3_default.normalize(
-      Matrix4_default.multiplyByPointAsVector(
-        inverseModelMatrix,
-        Cartesian3_default.UNIT_X,
-        wrapLongitudeYZNormal
-      ),
-      wrapLongitudeYZNormal
-    );
-    const yzPlane = Plane_default.fromPointNormal(
-      origin,
-      yzNormal,
-      wrapLongitudeYZPlane
-    );
-    let count = 1;
-    cartesians.push(Cartesian3_default.clone(positions[0]));
-    let prev = cartesians[0];
-    const length = positions.length;
-    for (let i = 1; i < length; ++i) {
-      const cur = positions[i];
-      if (Plane_default.getPointDistance(yzPlane, prev) < 0 || Plane_default.getPointDistance(yzPlane, cur) < 0) {
-        const intersection = IntersectionTests_default.lineSegmentPlane(
-          prev,
-          cur,
-          xzPlane,
-          wrapLongitudeIntersection
-        );
-        if (defined_default(intersection)) {
-          const offset = Cartesian3_default.multiplyByScalar(
-            xzNormal,
-            5e-9,
-            wrapLongitudeOffset
-          );
-          if (Plane_default.getPointDistance(xzPlane, prev) < 0) {
-            Cartesian3_default.negate(offset, offset);
-          }
-          cartesians.push(
-            Cartesian3_default.add(intersection, offset, new Cartesian3_default())
-          );
-          segments.push(count + 1);
-          Cartesian3_default.negate(offset, offset);
-          cartesians.push(
-            Cartesian3_default.add(intersection, offset, new Cartesian3_default())
-          );
-          count = 1;
-        }
-      }
-      cartesians.push(Cartesian3_default.clone(positions[i]));
-      count++;
-      prev = cur;
-    }
-    segments.push(count);
-  }
-  return {
-    positions: cartesians,
-    lengths: segments
-  };
-};
-PolylinePipeline.generateArc = function(options) {
-  if (!defined_default(options)) {
-    options = {};
-  }
-  const positions = options.positions;
-  if (!defined_default(positions)) {
-    throw new DeveloperError_default("options.positions is required.");
-  }
-  const length = positions.length;
-  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.default);
-  let height = defaultValue_default(options.height, 0);
-  const hasHeightArray = Array.isArray(height);
-  if (length < 1) {
-    return [];
-  } else if (length === 1) {
-    const p = ellipsoid.scaleToGeodeticSurface(positions[0], scaleFirst);
-    height = hasHeightArray ? height[0] : height;
-    if (height !== 0) {
-      const n = ellipsoid.geodeticSurfaceNormal(p, cartesian);
-      Cartesian3_default.multiplyByScalar(n, height, n);
-      Cartesian3_default.add(p, n, p);
-    }
-    return [p.x, p.y, p.z];
-  }
-  let minDistance = options.minDistance;
-  if (!defined_default(minDistance)) {
-    const granularity = defaultValue_default(
-      options.granularity,
-      Math_default.RADIANS_PER_DEGREE
-    );
-    minDistance = Math_default.chordLength(granularity, ellipsoid.maximumRadius);
-  }
-  let numPoints = 0;
-  let i;
-  for (i = 0; i < length - 1; i++) {
-    numPoints += PolylinePipeline.numberOfPoints(
-      positions[i],
-      positions[i + 1],
-      minDistance
-    );
-  }
-  const arrayLength = (numPoints + 1) * 3;
-  const newPositions = new Array(arrayLength);
-  let offset = 0;
-  for (i = 0; i < length - 1; i++) {
-    const p0 = positions[i];
-    const p1 = positions[i + 1];
-    const h0 = hasHeightArray ? height[i] : height;
-    const h1 = hasHeightArray ? height[i + 1] : height;
-    offset = generateCartesianArc(
-      p0,
-      p1,
-      minDistance,
-      ellipsoid,
-      h0,
-      h1,
-      newPositions,
-      offset
-    );
-  }
-  subdivideHeightsScratchArray.length = 0;
-  const lastPoint = positions[length - 1];
-  const carto = ellipsoid.cartesianToCartographic(lastPoint, carto1);
-  carto.height = hasHeightArray ? height[length - 1] : height;
-  const cart = ellipsoid.cartographicToCartesian(carto, cartesian);
-  Cartesian3_default.pack(cart, newPositions, arrayLength - 3);
-  return newPositions;
-};
-var scratchCartographic0 = new Cartographic_default();
-var scratchCartographic1 = new Cartographic_default();
-PolylinePipeline.generateRhumbArc = function(options) {
-  if (!defined_default(options)) {
-    options = {};
-  }
-  const positions = options.positions;
-  if (!defined_default(positions)) {
-    throw new DeveloperError_default("options.positions is required.");
-  }
-  const length = positions.length;
-  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.default);
-  let height = defaultValue_default(options.height, 0);
-  const hasHeightArray = Array.isArray(height);
-  if (length < 1) {
-    return [];
-  } else if (length === 1) {
-    const p = ellipsoid.scaleToGeodeticSurface(positions[0], scaleFirst);
-    height = hasHeightArray ? height[0] : height;
-    if (height !== 0) {
-      const n = ellipsoid.geodeticSurfaceNormal(p, cartesian);
-      Cartesian3_default.multiplyByScalar(n, height, n);
-      Cartesian3_default.add(p, n, p);
-    }
-    return [p.x, p.y, p.z];
-  }
-  const granularity = defaultValue_default(
-    options.granularity,
-    Math_default.RADIANS_PER_DEGREE
-  );
-  let numPoints = 0;
-  let i;
-  let c0 = ellipsoid.cartesianToCartographic(
-    positions[0],
-    scratchCartographic0
-  );
-  let c1;
-  for (i = 0; i < length - 1; i++) {
-    c1 = ellipsoid.cartesianToCartographic(
-      positions[i + 1],
-      scratchCartographic1
-    );
-    numPoints += PolylinePipeline.numberOfPointsRhumbLine(c0, c1, granularity);
-    c0 = Cartographic_default.clone(c1, scratchCartographic0);
-  }
-  const arrayLength = (numPoints + 1) * 3;
-  const newPositions = new Array(arrayLength);
-  let offset = 0;
-  for (i = 0; i < length - 1; i++) {
-    const p0 = positions[i];
-    const p1 = positions[i + 1];
-    const h0 = hasHeightArray ? height[i] : height;
-    const h1 = hasHeightArray ? height[i + 1] : height;
-    offset = generateCartesianRhumbArc(
-      p0,
-      p1,
-      granularity,
-      ellipsoid,
-      h0,
-      h1,
-      newPositions,
-      offset
-    );
-  }
-  subdivideHeightsScratchArray.length = 0;
-  const lastPoint = positions[length - 1];
-  const carto = ellipsoid.cartesianToCartographic(lastPoint, carto1);
-  carto.height = hasHeightArray ? height[length - 1] : height;
-  const cart = ellipsoid.cartographicToCartesian(carto, cartesian);
-  Cartesian3_default.pack(cart, newPositions, arrayLength - 3);
-  return newPositions;
-};
-PolylinePipeline.generateCartesianArc = function(options) {
-  const numberArray = PolylinePipeline.generateArc(options);
-  const size = numberArray.length / 3;
-  const newPositions = new Array(size);
-  for (let i = 0; i < size; i++) {
-    newPositions[i] = Cartesian3_default.unpack(numberArray, i * 3);
-  }
-  return newPositions;
-};
-PolylinePipeline.generateCartesianRhumbArc = function(options) {
-  const numberArray = PolylinePipeline.generateRhumbArc(options);
-  const size = numberArray.length / 3;
-  const newPositions = new Array(size);
-  for (let i = 0; i < size; i++) {
-    newPositions[i] = Cartesian3_default.unpack(numberArray, i * 3);
-  }
-  return newPositions;
-};
-var PolylinePipeline_default = PolylinePipeline;
-
-export {
-  PolylinePipeline_default
-};