@gmgis/gm-sdk 1.12.5 → 2.0.2

package/dist/resources/Workers/chunk-GGZJN2TI.js

@@ -1,2717 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.122
- *
- * 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 {
-  AttributeCompression_default
-} from "./chunk-NGPPMXRM.js";
-import {
-  EncodedCartesian3_default
-} from "./chunk-C6YYBQXW.js";
-import {
-  IntersectionTests_default
-} from "./chunk-3Q2L65QU.js";
-import {
-  Plane_default
-} from "./chunk-2ZGOQXYU.js";
-import {
-  IndexDatatype_default
-} from "./chunk-26GA3JAM.js";
-import {
-  GeometryAttribute_default,
-  GeometryType_default,
-  Geometry_default,
-  PrimitiveType_default
-} from "./chunk-GWCFU2SA.js";
-import {
-  BoundingSphere_default,
-  GeographicProjection_default,
-  Intersect_default
-} from "./chunk-VJZB3WAV.js";
-import {
-  Cartesian4_default,
-  Matrix4_default
-} from "./chunk-5PTXS2GO.js";
-import {
-  ComponentDatatype_default
-} from "./chunk-K4GQUNB5.js";
-import {
-  Cartesian2_default,
-  Cartesian3_default,
-  Cartographic_default,
-  Matrix3_default
-} from "./chunk-YFXQECWV.js";
-import {
-  Math_default
-} from "./chunk-XY4BATBS.js";
-import {
-  defaultValue_default
-} from "./chunk-7JO7GPJN.js";
-import {
-  Check_default,
-  DeveloperError_default
-} from "./chunk-AD63PIY6.js";
-import {
-  defined_default
-} from "./chunk-E63IIM5T.js";
-
-// packages/engine/Source/Core/barycentricCoordinates.js
-var scratchCartesian1 = new Cartesian3_default();
-var scratchCartesian2 = new Cartesian3_default();
-var scratchCartesian3 = new Cartesian3_default();
-function barycentricCoordinates(point, p0, p1, p2, result) {
-  Check_default.defined("point", point);
-  Check_default.defined("p0", p0);
-  Check_default.defined("p1", p1);
-  Check_default.defined("p2", p2);
-  if (!defined_default(result)) {
-    result = new Cartesian3_default();
-  }
-  let v02;
-  let v12;
-  let v22;
-  let dot00;
-  let dot01;
-  let dot02;
-  let dot11;
-  let dot12;
-  if (!defined_default(p0.z)) {
-    if (Cartesian2_default.equalsEpsilon(point, p0, Math_default.EPSILON14)) {
-      return Cartesian3_default.clone(Cartesian3_default.UNIT_X, result);
-    }
-    if (Cartesian2_default.equalsEpsilon(point, p1, Math_default.EPSILON14)) {
-      return Cartesian3_default.clone(Cartesian3_default.UNIT_Y, result);
-    }
-    if (Cartesian2_default.equalsEpsilon(point, p2, Math_default.EPSILON14)) {
-      return Cartesian3_default.clone(Cartesian3_default.UNIT_Z, result);
-    }
-    v02 = Cartesian2_default.subtract(p1, p0, scratchCartesian1);
-    v12 = Cartesian2_default.subtract(p2, p0, scratchCartesian2);
-    v22 = Cartesian2_default.subtract(point, p0, scratchCartesian3);
-    dot00 = Cartesian2_default.dot(v02, v02);
-    dot01 = Cartesian2_default.dot(v02, v12);
-    dot02 = Cartesian2_default.dot(v02, v22);
-    dot11 = Cartesian2_default.dot(v12, v12);
-    dot12 = Cartesian2_default.dot(v12, v22);
-  } else {
-    if (Cartesian3_default.equalsEpsilon(point, p0, Math_default.EPSILON14)) {
-      return Cartesian3_default.clone(Cartesian3_default.UNIT_X, result);
-    }
-    if (Cartesian3_default.equalsEpsilon(point, p1, Math_default.EPSILON14)) {
-      return Cartesian3_default.clone(Cartesian3_default.UNIT_Y, result);
-    }
-    if (Cartesian3_default.equalsEpsilon(point, p2, Math_default.EPSILON14)) {
-      return Cartesian3_default.clone(Cartesian3_default.UNIT_Z, result);
-    }
-    v02 = Cartesian3_default.subtract(p1, p0, scratchCartesian1);
-    v12 = Cartesian3_default.subtract(p2, p0, scratchCartesian2);
-    v22 = Cartesian3_default.subtract(point, p0, scratchCartesian3);
-    dot00 = Cartesian3_default.dot(v02, v02);
-    dot01 = Cartesian3_default.dot(v02, v12);
-    dot02 = Cartesian3_default.dot(v02, v22);
-    dot11 = Cartesian3_default.dot(v12, v12);
-    dot12 = Cartesian3_default.dot(v12, v22);
-  }
-  result.y = dot11 * dot02 - dot01 * dot12;
-  result.z = dot00 * dot12 - dot01 * dot02;
-  const q = dot00 * dot11 - dot01 * dot01;
-  if (q === 0) {
-    return void 0;
-  }
-  result.y /= q;
-  result.z /= q;
-  result.x = 1 - result.y - result.z;
-  return result;
-}
-var barycentricCoordinates_default = barycentricCoordinates;
-
-// packages/engine/Source/Core/Tipsify.js
-var Tipsify = {};
-Tipsify.calculateACMR = function(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
-  const indices = options.indices;
-  let maximumIndex = options.maximumIndex;
-  const cacheSize = defaultValue_default(options.cacheSize, 24);
-  if (!defined_default(indices)) {
-    throw new DeveloperError_default("indices is required.");
-  }
-  const numIndices = indices.length;
-  if (numIndices < 3 || numIndices % 3 !== 0) {
-    throw new DeveloperError_default("indices length must be a multiple of three.");
-  }
-  if (maximumIndex <= 0) {
-    throw new DeveloperError_default("maximumIndex must be greater than zero.");
-  }
-  if (cacheSize < 3) {
-    throw new DeveloperError_default("cacheSize must be greater than two.");
-  }
-  if (!defined_default(maximumIndex)) {
-    maximumIndex = 0;
-    let currentIndex = 0;
-    let intoIndices = indices[currentIndex];
-    while (currentIndex < numIndices) {
-      if (intoIndices > maximumIndex) {
-        maximumIndex = intoIndices;
-      }
-      ++currentIndex;
-      intoIndices = indices[currentIndex];
-    }
-  }
-  const vertexTimeStamps = [];
-  for (let i = 0; i < maximumIndex + 1; i++) {
-    vertexTimeStamps[i] = 0;
-  }
-  let s = cacheSize + 1;
-  for (let j = 0; j < numIndices; ++j) {
-    if (s - vertexTimeStamps[indices[j]] > cacheSize) {
-      vertexTimeStamps[indices[j]] = s;
-      ++s;
-    }
-  }
-  return (s - cacheSize + 1) / (numIndices / 3);
-};
-Tipsify.tipsify = function(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
-  const indices = options.indices;
-  const maximumIndex = options.maximumIndex;
-  const cacheSize = defaultValue_default(options.cacheSize, 24);
-  let cursor;
-  function skipDeadEnd(vertices2, deadEnd2, indices2, maximumIndexPlusOne2) {
-    while (deadEnd2.length >= 1) {
-      const d = deadEnd2[deadEnd2.length - 1];
-      deadEnd2.splice(deadEnd2.length - 1, 1);
-      if (vertices2[d].numLiveTriangles > 0) {
-        return d;
-      }
-    }
-    while (cursor < maximumIndexPlusOne2) {
-      if (vertices2[cursor].numLiveTriangles > 0) {
-        ++cursor;
-        return cursor - 1;
-      }
-      ++cursor;
-    }
-    return -1;
-  }
-  function getNextVertex(indices2, cacheSize2, oneRing2, vertices2, s2, deadEnd2, maximumIndexPlusOne2) {
-    let n = -1;
-    let p;
-    let m = -1;
-    let itOneRing = 0;
-    while (itOneRing < oneRing2.length) {
-      const index2 = oneRing2[itOneRing];
-      if (vertices2[index2].numLiveTriangles) {
-        p = 0;
-        if (s2 - vertices2[index2].timeStamp + 2 * vertices2[index2].numLiveTriangles <= cacheSize2) {
-          p = s2 - vertices2[index2].timeStamp;
-        }
-        if (p > m || m === -1) {
-          m = p;
-          n = index2;
-        }
-      }
-      ++itOneRing;
-    }
-    if (n === -1) {
-      return skipDeadEnd(vertices2, deadEnd2, indices2, maximumIndexPlusOne2);
-    }
-    return n;
-  }
-  if (!defined_default(indices)) {
-    throw new DeveloperError_default("indices is required.");
-  }
-  const numIndices = indices.length;
-  if (numIndices < 3 || numIndices % 3 !== 0) {
-    throw new DeveloperError_default("indices length must be a multiple of three.");
-  }
-  if (maximumIndex <= 0) {
-    throw new DeveloperError_default("maximumIndex must be greater than zero.");
-  }
-  if (cacheSize < 3) {
-    throw new DeveloperError_default("cacheSize must be greater than two.");
-  }
-  let maximumIndexPlusOne = 0;
-  let currentIndex = 0;
-  let intoIndices = indices[currentIndex];
-  const endIndex = numIndices;
-  if (defined_default(maximumIndex)) {
-    maximumIndexPlusOne = maximumIndex + 1;
-  } else {
-    while (currentIndex < endIndex) {
-      if (intoIndices > maximumIndexPlusOne) {
-        maximumIndexPlusOne = intoIndices;
-      }
-      ++currentIndex;
-      intoIndices = indices[currentIndex];
-    }
-    if (maximumIndexPlusOne === -1) {
-      return 0;
-    }
-    ++maximumIndexPlusOne;
-  }
-  const vertices = [];
-  let i;
-  for (i = 0; i < maximumIndexPlusOne; i++) {
-    vertices[i] = {
-      numLiveTriangles: 0,
-      timeStamp: 0,
-      vertexTriangles: []
-    };
-  }
-  currentIndex = 0;
-  let triangle = 0;
-  while (currentIndex < endIndex) {
-    vertices[indices[currentIndex]].vertexTriangles.push(triangle);
-    ++vertices[indices[currentIndex]].numLiveTriangles;
-    vertices[indices[currentIndex + 1]].vertexTriangles.push(triangle);
-    ++vertices[indices[currentIndex + 1]].numLiveTriangles;
-    vertices[indices[currentIndex + 2]].vertexTriangles.push(triangle);
-    ++vertices[indices[currentIndex + 2]].numLiveTriangles;
-    ++triangle;
-    currentIndex += 3;
-  }
-  let f = 0;
-  let s = cacheSize + 1;
-  cursor = 1;
-  let oneRing = [];
-  const deadEnd = [];
-  let vertex;
-  let intoVertices;
-  let currentOutputIndex = 0;
-  const outputIndices = [];
-  const numTriangles = numIndices / 3;
-  const triangleEmitted = [];
-  for (i = 0; i < numTriangles; i++) {
-    triangleEmitted[i] = false;
-  }
-  let index;
-  let limit;
-  while (f !== -1) {
-    oneRing = [];
-    intoVertices = vertices[f];
-    limit = intoVertices.vertexTriangles.length;
-    for (let k = 0; k < limit; ++k) {
-      triangle = intoVertices.vertexTriangles[k];
-      if (!triangleEmitted[triangle]) {
-        triangleEmitted[triangle] = true;
-        currentIndex = triangle + triangle + triangle;
-        for (let j = 0; j < 3; ++j) {
-          index = indices[currentIndex];
-          oneRing.push(index);
-          deadEnd.push(index);
-          outputIndices[currentOutputIndex] = index;
-          ++currentOutputIndex;
-          vertex = vertices[index];
-          --vertex.numLiveTriangles;
-          if (s - vertex.timeStamp > cacheSize) {
-            vertex.timeStamp = s;
-            ++s;
-          }
-          ++currentIndex;
-        }
-      }
-    }
-    f = getNextVertex(
-      indices,
-      cacheSize,
-      oneRing,
-      vertices,
-      s,
-      deadEnd,
-      maximumIndexPlusOne
-    );
-  }
-  return outputIndices;
-};
-var Tipsify_default = Tipsify;
-
-// packages/engine/Source/Core/GeometryPipeline.js
-var GeometryPipeline = {};
-function addTriangle(lines, index, i0, i1, i2) {
-  lines[index++] = i0;
-  lines[index++] = i1;
-  lines[index++] = i1;
-  lines[index++] = i2;
-  lines[index++] = i2;
-  lines[index] = i0;
-}
-function trianglesToLines(triangles) {
-  const count = triangles.length;
-  const size = count / 3 * 6;
-  const lines = IndexDatatype_default.createTypedArray(count, size);
-  let index = 0;
-  for (let i = 0; i < count; i += 3, index += 6) {
-    addTriangle(lines, index, triangles[i], triangles[i + 1], triangles[i + 2]);
-  }
-  return lines;
-}
-function triangleStripToLines(triangles) {
-  const count = triangles.length;
-  if (count >= 3) {
-    const size = (count - 2) * 6;
-    const lines = IndexDatatype_default.createTypedArray(count, size);
-    addTriangle(lines, 0, triangles[0], triangles[1], triangles[2]);
-    let index = 6;
-    for (let i = 3; i < count; ++i, index += 6) {
-      addTriangle(
-        lines,
-        index,
-        triangles[i - 1],
-        triangles[i],
-        triangles[i - 2]
-      );
-    }
-    return lines;
-  }
-  return new Uint16Array();
-}
-function triangleFanToLines(triangles) {
-  if (triangles.length > 0) {
-    const count = triangles.length - 1;
-    const size = (count - 1) * 6;
-    const lines = IndexDatatype_default.createTypedArray(count, size);
-    const base = triangles[0];
-    let index = 0;
-    for (let i = 1; i < count; ++i, index += 6) {
-      addTriangle(lines, index, base, triangles[i], triangles[i + 1]);
-    }
-    return lines;
-  }
-  return new Uint16Array();
-}
-GeometryPipeline.toWireframe = function(geometry) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  const indices = geometry.indices;
-  if (defined_default(indices)) {
-    switch (geometry.primitiveType) {
-      case PrimitiveType_default.TRIANGLES:
-        geometry.indices = trianglesToLines(indices);
-        break;
-      case PrimitiveType_default.TRIANGLE_STRIP:
-        geometry.indices = triangleStripToLines(indices);
-        break;
-      case PrimitiveType_default.TRIANGLE_FAN:
-        geometry.indices = triangleFanToLines(indices);
-        break;
-      //>>includeStart('debug', pragmas.debug);
-      default:
-        throw new DeveloperError_default(
-          "geometry.primitiveType must be TRIANGLES, TRIANGLE_STRIP, or TRIANGLE_FAN."
-        );
-    }
-    geometry.primitiveType = PrimitiveType_default.LINES;
-  }
-  return geometry;
-};
-GeometryPipeline.createLineSegmentsForVectors = function(geometry, attributeName, length) {
-  attributeName = defaultValue_default(attributeName, "normal");
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  if (!defined_default(geometry.attributes.position)) {
-    throw new DeveloperError_default("geometry.attributes.position is required.");
-  }
-  if (!defined_default(geometry.attributes[attributeName])) {
-    throw new DeveloperError_default(
-      `geometry.attributes must have an attribute with the same name as the attributeName parameter, ${attributeName}.`
-    );
-  }
-  length = defaultValue_default(length, 1e4);
-  const positions = geometry.attributes.position.values;
-  const vectors = geometry.attributes[attributeName].values;
-  const positionsLength = positions.length;
-  const newPositions = new Float64Array(2 * positionsLength);
-  let j = 0;
-  for (let i = 0; i < positionsLength; i += 3) {
-    newPositions[j++] = positions[i];
-    newPositions[j++] = positions[i + 1];
-    newPositions[j++] = positions[i + 2];
-    newPositions[j++] = positions[i] + vectors[i] * length;
-    newPositions[j++] = positions[i + 1] + vectors[i + 1] * length;
-    newPositions[j++] = positions[i + 2] + vectors[i + 2] * length;
-  }
-  let newBoundingSphere;
-  const bs = geometry.boundingSphere;
-  if (defined_default(bs)) {
-    newBoundingSphere = new BoundingSphere_default(bs.center, bs.radius + length);
-  }
-  return new Geometry_default({
-    attributes: {
-      position: new GeometryAttribute_default({
-        componentDatatype: ComponentDatatype_default.DOUBLE,
-        componentsPerAttribute: 3,
-        values: newPositions
-      })
-    },
-    primitiveType: PrimitiveType_default.LINES,
-    boundingSphere: newBoundingSphere
-  });
-};
-GeometryPipeline.createAttributeLocations = function(geometry) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  const semantics = [
-    "position",
-    "positionHigh",
-    "positionLow",
-    // From VertexFormat.position - after 2D projection and high-precision encoding
-    "position3DHigh",
-    "position3DLow",
-    "position2DHigh",
-    "position2DLow",
-    // From Primitive
-    "pickColor",
-    // From VertexFormat
-    "normal",
-    "st",
-    "tangent",
-    "bitangent",
-    // For shadow volumes
-    "extrudeDirection",
-    // From compressing texture coordinates and normals
-    "compressedAttributes"
-  ];
-  const attributes = geometry.attributes;
-  const indices = {};
-  let j = 0;
-  let i;
-  const len = semantics.length;
-  for (i = 0; i < len; ++i) {
-    const semantic = semantics[i];
-    if (defined_default(attributes[semantic])) {
-      indices[semantic] = j++;
-    }
-  }
-  for (const name in attributes) {
-    if (attributes.hasOwnProperty(name) && !defined_default(indices[name])) {
-      indices[name] = j++;
-    }
-  }
-  return indices;
-};
-GeometryPipeline.reorderForPreVertexCache = function(geometry) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  const numVertices = Geometry_default.computeNumberOfVertices(geometry);
-  const indices = geometry.indices;
-  if (defined_default(indices)) {
-    const indexCrossReferenceOldToNew = new Int32Array(numVertices);
-    for (let i = 0; i < numVertices; i++) {
-      indexCrossReferenceOldToNew[i] = -1;
-    }
-    const indicesIn = indices;
-    const numIndices = indicesIn.length;
-    const indicesOut = IndexDatatype_default.createTypedArray(numVertices, numIndices);
-    let intoIndicesIn = 0;
-    let intoIndicesOut = 0;
-    let nextIndex = 0;
-    let tempIndex;
-    while (intoIndicesIn < numIndices) {
-      tempIndex = indexCrossReferenceOldToNew[indicesIn[intoIndicesIn]];
-      if (tempIndex !== -1) {
-        indicesOut[intoIndicesOut] = tempIndex;
-      } else {
-        tempIndex = indicesIn[intoIndicesIn];
-        indexCrossReferenceOldToNew[tempIndex] = nextIndex;
-        indicesOut[intoIndicesOut] = nextIndex;
-        ++nextIndex;
-      }
-      ++intoIndicesIn;
-      ++intoIndicesOut;
-    }
-    geometry.indices = indicesOut;
-    const attributes = geometry.attributes;
-    for (const property in attributes) {
-      if (attributes.hasOwnProperty(property) && defined_default(attributes[property]) && defined_default(attributes[property].values)) {
-        const attribute = attributes[property];
-        const elementsIn = attribute.values;
-        let intoElementsIn = 0;
-        const numComponents = attribute.componentsPerAttribute;
-        const elementsOut = ComponentDatatype_default.createTypedArray(
-          attribute.componentDatatype,
-          nextIndex * numComponents
-        );
-        while (intoElementsIn < numVertices) {
-          const temp = indexCrossReferenceOldToNew[intoElementsIn];
-          if (temp !== -1) {
-            for (let j = 0; j < numComponents; j++) {
-              elementsOut[numComponents * temp + j] = elementsIn[numComponents * intoElementsIn + j];
-            }
-          }
-          ++intoElementsIn;
-        }
-        attribute.values = elementsOut;
-      }
-    }
-  }
-  return geometry;
-};
-GeometryPipeline.reorderForPostVertexCache = function(geometry, cacheCapacity) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  const indices = geometry.indices;
-  if (geometry.primitiveType === PrimitiveType_default.TRIANGLES && defined_default(indices)) {
-    const numIndices = indices.length;
-    let maximumIndex = 0;
-    for (let j = 0; j < numIndices; j++) {
-      if (indices[j] > maximumIndex) {
-        maximumIndex = indices[j];
-      }
-    }
-    geometry.indices = Tipsify_default.tipsify({
-      indices,
-      maximumIndex,
-      cacheSize: cacheCapacity
-    });
-  }
-  return geometry;
-};
-function copyAttributesDescriptions(attributes) {
-  const newAttributes = {};
-  for (const attribute in attributes) {
-    if (attributes.hasOwnProperty(attribute) && defined_default(attributes[attribute]) && defined_default(attributes[attribute].values)) {
-      const attr = attributes[attribute];
-      newAttributes[attribute] = new GeometryAttribute_default({
-        componentDatatype: attr.componentDatatype,
-        componentsPerAttribute: attr.componentsPerAttribute,
-        normalize: attr.normalize,
-        values: []
-      });
-    }
-  }
-  return newAttributes;
-}
-function copyVertex(destinationAttributes, sourceAttributes, index) {
-  for (const attribute in sourceAttributes) {
-    if (sourceAttributes.hasOwnProperty(attribute) && defined_default(sourceAttributes[attribute]) && defined_default(sourceAttributes[attribute].values)) {
-      const attr = sourceAttributes[attribute];
-      for (let k = 0; k < attr.componentsPerAttribute; ++k) {
-        destinationAttributes[attribute].values.push(
-          attr.values[index * attr.componentsPerAttribute + k]
-        );
-      }
-    }
-  }
-}
-GeometryPipeline.fitToUnsignedShortIndices = function(geometry) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  if (defined_default(geometry.indices) && geometry.primitiveType !== PrimitiveType_default.TRIANGLES && geometry.primitiveType !== PrimitiveType_default.LINES && geometry.primitiveType !== PrimitiveType_default.POINTS) {
-    throw new DeveloperError_default(
-      "geometry.primitiveType must equal to PrimitiveType.TRIANGLES, PrimitiveType.LINES, or PrimitiveType.POINTS."
-    );
-  }
-  const geometries = [];
-  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
-  if (defined_default(geometry.indices) && numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
-    let oldToNewIndex = [];
-    let newIndices = [];
-    let currentIndex = 0;
-    let newAttributes = copyAttributesDescriptions(geometry.attributes);
-    const originalIndices = geometry.indices;
-    const numberOfIndices = originalIndices.length;
-    let indicesPerPrimitive;
-    if (geometry.primitiveType === PrimitiveType_default.TRIANGLES) {
-      indicesPerPrimitive = 3;
-    } else if (geometry.primitiveType === PrimitiveType_default.LINES) {
-      indicesPerPrimitive = 2;
-    } else if (geometry.primitiveType === PrimitiveType_default.POINTS) {
-      indicesPerPrimitive = 1;
-    }
-    for (let j = 0; j < numberOfIndices; j += indicesPerPrimitive) {
-      for (let k = 0; k < indicesPerPrimitive; ++k) {
-        const x = originalIndices[j + k];
-        let i = oldToNewIndex[x];
-        if (!defined_default(i)) {
-          i = currentIndex++;
-          oldToNewIndex[x] = i;
-          copyVertex(newAttributes, geometry.attributes, x);
-        }
-        newIndices.push(i);
-      }
-      if (currentIndex + indicesPerPrimitive >= Math_default.SIXTY_FOUR_KILOBYTES) {
-        geometries.push(
-          new Geometry_default({
-            attributes: newAttributes,
-            indices: newIndices,
-            primitiveType: geometry.primitiveType,
-            boundingSphere: geometry.boundingSphere,
-            boundingSphereCV: geometry.boundingSphereCV
-          })
-        );
-        oldToNewIndex = [];
-        newIndices = [];
-        currentIndex = 0;
-        newAttributes = copyAttributesDescriptions(geometry.attributes);
-      }
-    }
-    if (newIndices.length !== 0) {
-      geometries.push(
-        new Geometry_default({
-          attributes: newAttributes,
-          indices: newIndices,
-          primitiveType: geometry.primitiveType,
-          boundingSphere: geometry.boundingSphere,
-          boundingSphereCV: geometry.boundingSphereCV
-        })
-      );
-    }
-  } else {
-    geometries.push(geometry);
-  }
-  return geometries;
-};
-var scratchProjectTo2DCartesian3 = new Cartesian3_default();
-var scratchProjectTo2DCartographic = new Cartographic_default();
-GeometryPipeline.projectTo2D = function(geometry, attributeName, attributeName3D, attributeName2D, projection) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  if (!defined_default(attributeName)) {
-    throw new DeveloperError_default("attributeName is required.");
-  }
-  if (!defined_default(attributeName3D)) {
-    throw new DeveloperError_default("attributeName3D is required.");
-  }
-  if (!defined_default(attributeName2D)) {
-    throw new DeveloperError_default("attributeName2D is required.");
-  }
-  if (!defined_default(geometry.attributes[attributeName])) {
-    throw new DeveloperError_default(
-      `geometry must have attribute matching the attributeName argument: ${attributeName}.`
-    );
-  }
-  if (geometry.attributes[attributeName].componentDatatype !== ComponentDatatype_default.DOUBLE) {
-    throw new DeveloperError_default(
-      "The attribute componentDatatype must be ComponentDatatype.DOUBLE."
-    );
-  }
-  const attribute = geometry.attributes[attributeName];
-  projection = defined_default(projection) ? projection : new GeographicProjection_default();
-  const ellipsoid = projection.ellipsoid;
-  const values3D = attribute.values;
-  const projectedValues = new Float64Array(values3D.length);
-  let index = 0;
-  for (let i = 0; i < values3D.length; i += 3) {
-    const value = Cartesian3_default.fromArray(
-      values3D,
-      i,
-      scratchProjectTo2DCartesian3
-    );
-    const lonLat = ellipsoid.cartesianToCartographic(
-      value,
-      scratchProjectTo2DCartographic
-    );
-    if (!defined_default(lonLat)) {
-      throw new DeveloperError_default(
-        `Could not project point (${value.x}, ${value.y}, ${value.z}) to 2D.`
-      );
-    }
-    const projectedLonLat = projection.project(
-      lonLat,
-      scratchProjectTo2DCartesian3
-    );
-    projectedValues[index++] = projectedLonLat.x;
-    projectedValues[index++] = projectedLonLat.y;
-    projectedValues[index++] = projectedLonLat.z;
-  }
-  geometry.attributes[attributeName3D] = attribute;
-  geometry.attributes[attributeName2D] = new GeometryAttribute_default({
-    componentDatatype: ComponentDatatype_default.DOUBLE,
-    componentsPerAttribute: 3,
-    values: projectedValues
-  });
-  delete geometry.attributes[attributeName];
-  return geometry;
-};
-var encodedResult = {
-  high: 0,
-  low: 0
-};
-GeometryPipeline.encodeAttribute = function(geometry, attributeName, attributeHighName, attributeLowName) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  if (!defined_default(attributeName)) {
-    throw new DeveloperError_default("attributeName is required.");
-  }
-  if (!defined_default(attributeHighName)) {
-    throw new DeveloperError_default("attributeHighName is required.");
-  }
-  if (!defined_default(attributeLowName)) {
-    throw new DeveloperError_default("attributeLowName is required.");
-  }
-  if (!defined_default(geometry.attributes[attributeName])) {
-    throw new DeveloperError_default(
-      `geometry must have attribute matching the attributeName argument: ${attributeName}.`
-    );
-  }
-  if (geometry.attributes[attributeName].componentDatatype !== ComponentDatatype_default.DOUBLE) {
-    throw new DeveloperError_default(
-      "The attribute componentDatatype must be ComponentDatatype.DOUBLE."
-    );
-  }
-  const attribute = geometry.attributes[attributeName];
-  const values = attribute.values;
-  const length = values.length;
-  const highValues = new Float32Array(length);
-  const lowValues = new Float32Array(length);
-  for (let i = 0; i < length; ++i) {
-    EncodedCartesian3_default.encode(values[i], encodedResult);
-    highValues[i] = encodedResult.high;
-    lowValues[i] = encodedResult.low;
-  }
-  const componentsPerAttribute = attribute.componentsPerAttribute;
-  geometry.attributes[attributeHighName] = new GeometryAttribute_default({
-    componentDatatype: ComponentDatatype_default.FLOAT,
-    componentsPerAttribute,
-    values: highValues
-  });
-  geometry.attributes[attributeLowName] = new GeometryAttribute_default({
-    componentDatatype: ComponentDatatype_default.FLOAT,
-    componentsPerAttribute,
-    values: lowValues
-  });
-  delete geometry.attributes[attributeName];
-  return geometry;
-};
-var scratchCartesian32 = new Cartesian3_default();
-function transformPoint(matrix, attribute) {
-  if (defined_default(attribute)) {
-    const values = attribute.values;
-    const length = values.length;
-    for (let i = 0; i < length; i += 3) {
-      Cartesian3_default.unpack(values, i, scratchCartesian32);
-      Matrix4_default.multiplyByPoint(matrix, scratchCartesian32, scratchCartesian32);
-      Cartesian3_default.pack(scratchCartesian32, values, i);
-    }
-  }
-}
-function transformVector(matrix, attribute) {
-  if (defined_default(attribute)) {
-    const values = attribute.values;
-    const length = values.length;
-    for (let i = 0; i < length; i += 3) {
-      Cartesian3_default.unpack(values, i, scratchCartesian32);
-      Matrix3_default.multiplyByVector(matrix, scratchCartesian32, scratchCartesian32);
-      scratchCartesian32 = Cartesian3_default.normalize(
-        scratchCartesian32,
-        scratchCartesian32
-      );
-      Cartesian3_default.pack(scratchCartesian32, values, i);
-    }
-  }
-}
-var inverseTranspose = new Matrix4_default();
-var normalMatrix = new Matrix3_default();
-GeometryPipeline.transformToWorldCoordinates = function(instance) {
-  if (!defined_default(instance)) {
-    throw new DeveloperError_default("instance is required.");
-  }
-  const modelMatrix = instance.modelMatrix;
-  if (Matrix4_default.equals(modelMatrix, Matrix4_default.IDENTITY)) {
-    return instance;
-  }
-  const attributes = instance.geometry.attributes;
-  transformPoint(modelMatrix, attributes.position);
-  transformPoint(modelMatrix, attributes.prevPosition);
-  transformPoint(modelMatrix, attributes.nextPosition);
-  if (defined_default(attributes.normal) || defined_default(attributes.tangent) || defined_default(attributes.bitangent)) {
-    Matrix4_default.inverse(modelMatrix, inverseTranspose);
-    Matrix4_default.transpose(inverseTranspose, inverseTranspose);
-    Matrix4_default.getMatrix3(inverseTranspose, normalMatrix);
-    transformVector(normalMatrix, attributes.normal);
-    transformVector(normalMatrix, attributes.tangent);
-    transformVector(normalMatrix, attributes.bitangent);
-  }
-  const boundingSphere = instance.geometry.boundingSphere;
-  if (defined_default(boundingSphere)) {
-    instance.geometry.boundingSphere = BoundingSphere_default.transform(
-      boundingSphere,
-      modelMatrix,
-      boundingSphere
-    );
-  }
-  instance.modelMatrix = Matrix4_default.clone(Matrix4_default.IDENTITY);
-  return instance;
-};
-function findAttributesInAllGeometries(instances, propertyName) {
-  const length = instances.length;
-  const attributesInAllGeometries = {};
-  const attributes0 = instances[0][propertyName].attributes;
-  let name;
-  for (name in attributes0) {
-    if (attributes0.hasOwnProperty(name) && defined_default(attributes0[name]) && defined_default(attributes0[name].values)) {
-      const attribute = attributes0[name];
-      let numberOfComponents = attribute.values.length;
-      let inAllGeometries = true;
-      for (let i = 1; i < length; ++i) {
-        const otherAttribute = instances[i][propertyName].attributes[name];
-        if (!defined_default(otherAttribute) || attribute.componentDatatype !== otherAttribute.componentDatatype || attribute.componentsPerAttribute !== otherAttribute.componentsPerAttribute || attribute.normalize !== otherAttribute.normalize) {
-          inAllGeometries = false;
-          break;
-        }
-        numberOfComponents += otherAttribute.values.length;
-      }
-      if (inAllGeometries) {
-        attributesInAllGeometries[name] = new GeometryAttribute_default({
-          componentDatatype: attribute.componentDatatype,
-          componentsPerAttribute: attribute.componentsPerAttribute,
-          normalize: attribute.normalize,
-          values: ComponentDatatype_default.createTypedArray(
-            attribute.componentDatatype,
-            numberOfComponents
-          )
-        });
-      }
-    }
-  }
-  return attributesInAllGeometries;
-}
-var tempScratch = new Cartesian3_default();
-function combineGeometries(instances, propertyName) {
-  const length = instances.length;
-  let name;
-  let i;
-  let j;
-  let k;
-  const m = instances[0].modelMatrix;
-  const haveIndices = defined_default(instances[0][propertyName].indices);
-  const primitiveType = instances[0][propertyName].primitiveType;
-  for (i = 1; i < length; ++i) {
-    if (!Matrix4_default.equals(instances[i].modelMatrix, m)) {
-      throw new DeveloperError_default("All instances must have the same modelMatrix.");
-    }
-    if (defined_default(instances[i][propertyName].indices) !== haveIndices) {
-      throw new DeveloperError_default(
-        "All instance geometries must have an indices or not have one."
-      );
-    }
-    if (instances[i][propertyName].primitiveType !== primitiveType) {
-      throw new DeveloperError_default(
-        "All instance geometries must have the same primitiveType."
-      );
-    }
-  }
-  const attributes = findAttributesInAllGeometries(instances, propertyName);
-  let values;
-  let sourceValues;
-  let sourceValuesLength;
-  for (name in attributes) {
-    if (attributes.hasOwnProperty(name)) {
-      values = attributes[name].values;
-      k = 0;
-      for (i = 0; i < length; ++i) {
-        sourceValues = instances[i][propertyName].attributes[name].values;
-        sourceValuesLength = sourceValues.length;
-        for (j = 0; j < sourceValuesLength; ++j) {
-          values[k++] = sourceValues[j];
-        }
-      }
-    }
-  }
-  let indices;
-  if (haveIndices) {
-    let numberOfIndices = 0;
-    for (i = 0; i < length; ++i) {
-      numberOfIndices += instances[i][propertyName].indices.length;
-    }
-    const numberOfVertices = Geometry_default.computeNumberOfVertices(
-      new Geometry_default({
-        attributes,
-        primitiveType: PrimitiveType_default.POINTS
-      })
-    );
-    const destIndices = IndexDatatype_default.createTypedArray(
-      numberOfVertices,
-      numberOfIndices
-    );
-    let destOffset = 0;
-    let offset = 0;
-    for (i = 0; i < length; ++i) {
-      const sourceIndices = instances[i][propertyName].indices;
-      const sourceIndicesLen = sourceIndices.length;
-      for (k = 0; k < sourceIndicesLen; ++k) {
-        destIndices[destOffset++] = offset + sourceIndices[k];
-      }
-      offset += Geometry_default.computeNumberOfVertices(instances[i][propertyName]);
-    }
-    indices = destIndices;
-  }
-  let center = new Cartesian3_default();
-  let radius = 0;
-  let bs;
-  for (i = 0; i < length; ++i) {
-    bs = instances[i][propertyName].boundingSphere;
-    if (!defined_default(bs)) {
-      center = void 0;
-      break;
-    }
-    Cartesian3_default.add(bs.center, center, center);
-  }
-  if (defined_default(center)) {
-    Cartesian3_default.divideByScalar(center, length, center);
-    for (i = 0; i < length; ++i) {
-      bs = instances[i][propertyName].boundingSphere;
-      const tempRadius = Cartesian3_default.magnitude(
-        Cartesian3_default.subtract(bs.center, center, tempScratch)
-      ) + bs.radius;
-      if (tempRadius > radius) {
-        radius = tempRadius;
-      }
-    }
-  }
-  return new Geometry_default({
-    attributes,
-    indices,
-    primitiveType,
-    boundingSphere: defined_default(center) ? new BoundingSphere_default(center, radius) : void 0
-  });
-}
-GeometryPipeline.combineInstances = function(instances) {
-  if (!defined_default(instances) || instances.length < 1) {
-    throw new DeveloperError_default(
-      "instances is required and must have length greater than zero."
-    );
-  }
-  const instanceGeometry = [];
-  const instanceSplitGeometry = [];
-  const length = instances.length;
-  for (let i = 0; i < length; ++i) {
-    const instance = instances[i];
-    if (defined_default(instance.geometry)) {
-      instanceGeometry.push(instance);
-    } else if (defined_default(instance.westHemisphereGeometry) && defined_default(instance.eastHemisphereGeometry)) {
-      instanceSplitGeometry.push(instance);
-    }
-  }
-  const geometries = [];
-  if (instanceGeometry.length > 0) {
-    geometries.push(combineGeometries(instanceGeometry, "geometry"));
-  }
-  if (instanceSplitGeometry.length > 0) {
-    geometries.push(
-      combineGeometries(instanceSplitGeometry, "westHemisphereGeometry")
-    );
-    geometries.push(
-      combineGeometries(instanceSplitGeometry, "eastHemisphereGeometry")
-    );
-  }
-  return geometries;
-};
-var normal = new Cartesian3_default();
-var v0 = new Cartesian3_default();
-var v1 = new Cartesian3_default();
-var v2 = new Cartesian3_default();
-GeometryPipeline.computeNormal = function(geometry) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  if (!defined_default(geometry.attributes.position) || !defined_default(geometry.attributes.position.values)) {
-    throw new DeveloperError_default(
-      "geometry.attributes.position.values is required."
-    );
-  }
-  if (!defined_default(geometry.indices)) {
-    throw new DeveloperError_default("geometry.indices is required.");
-  }
-  if (geometry.indices.length < 2 || geometry.indices.length % 3 !== 0) {
-    throw new DeveloperError_default(
-      "geometry.indices length must be greater than 0 and be a multiple of 3."
-    );
-  }
-  if (geometry.primitiveType !== PrimitiveType_default.TRIANGLES) {
-    throw new DeveloperError_default(
-      "geometry.primitiveType must be PrimitiveType.TRIANGLES."
-    );
-  }
-  const indices = geometry.indices;
-  const attributes = geometry.attributes;
-  const vertices = attributes.position.values;
-  const numVertices = attributes.position.values.length / 3;
-  const numIndices = indices.length;
-  const normalsPerVertex = new Array(numVertices);
-  const normalsPerTriangle = new Array(numIndices / 3);
-  const normalIndices = new Array(numIndices);
-  let i;
-  for (i = 0; i < numVertices; i++) {
-    normalsPerVertex[i] = {
-      indexOffset: 0,
-      count: 0,
-      currentCount: 0
-    };
-  }
-  let j = 0;
-  for (i = 0; i < numIndices; i += 3) {
-    const i0 = indices[i];
-    const i1 = indices[i + 1];
-    const i2 = indices[i + 2];
-    const i03 = i0 * 3;
-    const i13 = i1 * 3;
-    const i23 = i2 * 3;
-    v0.x = vertices[i03];
-    v0.y = vertices[i03 + 1];
-    v0.z = vertices[i03 + 2];
-    v1.x = vertices[i13];
-    v1.y = vertices[i13 + 1];
-    v1.z = vertices[i13 + 2];
-    v2.x = vertices[i23];
-    v2.y = vertices[i23 + 1];
-    v2.z = vertices[i23 + 2];
-    normalsPerVertex[i0].count++;
-    normalsPerVertex[i1].count++;
-    normalsPerVertex[i2].count++;
-    Cartesian3_default.subtract(v1, v0, v1);
-    Cartesian3_default.subtract(v2, v0, v2);
-    normalsPerTriangle[j] = Cartesian3_default.cross(v1, v2, new Cartesian3_default());
-    j++;
-  }
-  let indexOffset = 0;
-  for (i = 0; i < numVertices; i++) {
-    normalsPerVertex[i].indexOffset += indexOffset;
-    indexOffset += normalsPerVertex[i].count;
-  }
-  j = 0;
-  let vertexNormalData;
-  for (i = 0; i < numIndices; i += 3) {
-    vertexNormalData = normalsPerVertex[indices[i]];
-    let index = vertexNormalData.indexOffset + vertexNormalData.currentCount;
-    normalIndices[index] = j;
-    vertexNormalData.currentCount++;
-    vertexNormalData = normalsPerVertex[indices[i + 1]];
-    index = vertexNormalData.indexOffset + vertexNormalData.currentCount;
-    normalIndices[index] = j;
-    vertexNormalData.currentCount++;
-    vertexNormalData = normalsPerVertex[indices[i + 2]];
-    index = vertexNormalData.indexOffset + vertexNormalData.currentCount;
-    normalIndices[index] = j;
-    vertexNormalData.currentCount++;
-    j++;
-  }
-  const normalValues = new Float32Array(numVertices * 3);
-  for (i = 0; i < numVertices; i++) {
-    const i3 = i * 3;
-    vertexNormalData = normalsPerVertex[i];
-    Cartesian3_default.clone(Cartesian3_default.ZERO, normal);
-    if (vertexNormalData.count > 0) {
-      for (j = 0; j < vertexNormalData.count; j++) {
-        Cartesian3_default.add(
-          normal,
-          normalsPerTriangle[normalIndices[vertexNormalData.indexOffset + j]],
-          normal
-        );
-      }
-      if (Cartesian3_default.equalsEpsilon(Cartesian3_default.ZERO, normal, Math_default.EPSILON10)) {
-        Cartesian3_default.clone(
-          normalsPerTriangle[normalIndices[vertexNormalData.indexOffset]],
-          normal
-        );
-      }
-    }
-    if (Cartesian3_default.equalsEpsilon(Cartesian3_default.ZERO, normal, Math_default.EPSILON10)) {
-      normal.z = 1;
-    }
-    Cartesian3_default.normalize(normal, normal);
-    normalValues[i3] = normal.x;
-    normalValues[i3 + 1] = normal.y;
-    normalValues[i3 + 2] = normal.z;
-  }
-  geometry.attributes.normal = new GeometryAttribute_default({
-    componentDatatype: ComponentDatatype_default.FLOAT,
-    componentsPerAttribute: 3,
-    values: normalValues
-  });
-  return geometry;
-};
-var normalScratch = new Cartesian3_default();
-var normalScale = new Cartesian3_default();
-var tScratch = new Cartesian3_default();
-GeometryPipeline.computeTangentAndBitangent = function(geometry) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  const attributes = geometry.attributes;
-  const indices = geometry.indices;
-  if (!defined_default(attributes.position) || !defined_default(attributes.position.values)) {
-    throw new DeveloperError_default(
-      "geometry.attributes.position.values is required."
-    );
-  }
-  if (!defined_default(attributes.normal) || !defined_default(attributes.normal.values)) {
-    throw new DeveloperError_default("geometry.attributes.normal.values is required.");
-  }
-  if (!defined_default(attributes.st) || !defined_default(attributes.st.values)) {
-    throw new DeveloperError_default("geometry.attributes.st.values is required.");
-  }
-  if (!defined_default(indices)) {
-    throw new DeveloperError_default("geometry.indices is required.");
-  }
-  if (indices.length < 2 || indices.length % 3 !== 0) {
-    throw new DeveloperError_default(
-      "geometry.indices length must be greater than 0 and be a multiple of 3."
-    );
-  }
-  if (geometry.primitiveType !== PrimitiveType_default.TRIANGLES) {
-    throw new DeveloperError_default(
-      "geometry.primitiveType must be PrimitiveType.TRIANGLES."
-    );
-  }
-  const vertices = geometry.attributes.position.values;
-  const normals = geometry.attributes.normal.values;
-  const st = geometry.attributes.st.values;
-  const numVertices = geometry.attributes.position.values.length / 3;
-  const numIndices = indices.length;
-  const tan1 = new Array(numVertices * 3);
-  let i;
-  for (i = 0; i < tan1.length; i++) {
-    tan1[i] = 0;
-  }
-  let i03;
-  let i13;
-  let i23;
-  for (i = 0; i < numIndices; i += 3) {
-    const i0 = indices[i];
-    const i1 = indices[i + 1];
-    const i2 = indices[i + 2];
-    i03 = i0 * 3;
-    i13 = i1 * 3;
-    i23 = i2 * 3;
-    const i02 = i0 * 2;
-    const i12 = i1 * 2;
-    const i22 = i2 * 2;
-    const ux = vertices[i03];
-    const uy = vertices[i03 + 1];
-    const uz = vertices[i03 + 2];
-    const wx = st[i02];
-    const wy = st[i02 + 1];
-    const t1 = st[i12 + 1] - wy;
-    const t2 = st[i22 + 1] - wy;
-    const r = 1 / ((st[i12] - wx) * t2 - (st[i22] - wx) * t1);
-    const sdirx = (t2 * (vertices[i13] - ux) - t1 * (vertices[i23] - ux)) * r;
-    const sdiry = (t2 * (vertices[i13 + 1] - uy) - t1 * (vertices[i23 + 1] - uy)) * r;
-    const sdirz = (t2 * (vertices[i13 + 2] - uz) - t1 * (vertices[i23 + 2] - uz)) * r;
-    tan1[i03] += sdirx;
-    tan1[i03 + 1] += sdiry;
-    tan1[i03 + 2] += sdirz;
-    tan1[i13] += sdirx;
-    tan1[i13 + 1] += sdiry;
-    tan1[i13 + 2] += sdirz;
-    tan1[i23] += sdirx;
-    tan1[i23 + 1] += sdiry;
-    tan1[i23 + 2] += sdirz;
-  }
-  const tangentValues = new Float32Array(numVertices * 3);
-  const bitangentValues = new Float32Array(numVertices * 3);
-  for (i = 0; i < numVertices; i++) {
-    i03 = i * 3;
-    i13 = i03 + 1;
-    i23 = i03 + 2;
-    const n = Cartesian3_default.fromArray(normals, i03, normalScratch);
-    const t = Cartesian3_default.fromArray(tan1, i03, tScratch);
-    const scalar = Cartesian3_default.dot(n, t);
-    Cartesian3_default.multiplyByScalar(n, scalar, normalScale);
-    Cartesian3_default.normalize(Cartesian3_default.subtract(t, normalScale, t), t);
-    tangentValues[i03] = t.x;
-    tangentValues[i13] = t.y;
-    tangentValues[i23] = t.z;
-    Cartesian3_default.normalize(Cartesian3_default.cross(n, t, t), t);
-    bitangentValues[i03] = t.x;
-    bitangentValues[i13] = t.y;
-    bitangentValues[i23] = t.z;
-  }
-  geometry.attributes.tangent = new GeometryAttribute_default({
-    componentDatatype: ComponentDatatype_default.FLOAT,
-    componentsPerAttribute: 3,
-    values: tangentValues
-  });
-  geometry.attributes.bitangent = new GeometryAttribute_default({
-    componentDatatype: ComponentDatatype_default.FLOAT,
-    componentsPerAttribute: 3,
-    values: bitangentValues
-  });
-  return geometry;
-};
-var scratchCartesian22 = new Cartesian2_default();
-var toEncode1 = new Cartesian3_default();
-var toEncode2 = new Cartesian3_default();
-var toEncode3 = new Cartesian3_default();
-var encodeResult2 = new Cartesian2_default();
-GeometryPipeline.compressVertices = function(geometry) {
-  if (!defined_default(geometry)) {
-    throw new DeveloperError_default("geometry is required.");
-  }
-  const extrudeAttribute = geometry.attributes.extrudeDirection;
-  let i;
-  let numVertices;
-  if (defined_default(extrudeAttribute)) {
-    const extrudeDirections = extrudeAttribute.values;
-    numVertices = extrudeDirections.length / 3;
-    const compressedDirections = new Float32Array(numVertices * 2);
-    let i2 = 0;
-    for (i = 0; i < numVertices; ++i) {
-      Cartesian3_default.fromArray(extrudeDirections, i * 3, toEncode1);
-      if (Cartesian3_default.equals(toEncode1, Cartesian3_default.ZERO)) {
-        i2 += 2;
-        continue;
-      }
-      encodeResult2 = AttributeCompression_default.octEncodeInRange(
-        toEncode1,
-        65535,
-        encodeResult2
-      );
-      compressedDirections[i2++] = encodeResult2.x;
-      compressedDirections[i2++] = encodeResult2.y;
-    }
-    geometry.attributes.compressedAttributes = new GeometryAttribute_default({
-      componentDatatype: ComponentDatatype_default.FLOAT,
-      componentsPerAttribute: 2,
-      values: compressedDirections
-    });
-    delete geometry.attributes.extrudeDirection;
-    return geometry;
-  }
-  const normalAttribute = geometry.attributes.normal;
-  const stAttribute = geometry.attributes.st;
-  const hasNormal = defined_default(normalAttribute);
-  const hasSt = defined_default(stAttribute);
-  if (!hasNormal && !hasSt) {
-    return geometry;
-  }
-  const tangentAttribute = geometry.attributes.tangent;
-  const bitangentAttribute = geometry.attributes.bitangent;
-  const hasTangent = defined_default(tangentAttribute);
-  const hasBitangent = defined_default(bitangentAttribute);
-  let normals;
-  let st;
-  let tangents;
-  let bitangents;
-  if (hasNormal) {
-    normals = normalAttribute.values;
-  }
-  if (hasSt) {
-    st = stAttribute.values;
-  }
-  if (hasTangent) {
-    tangents = tangentAttribute.values;
-  }
-  if (hasBitangent) {
-    bitangents = bitangentAttribute.values;
-  }
-  const length = hasNormal ? normals.length : st.length;
-  const numComponents = hasNormal ? 3 : 2;
-  numVertices = length / numComponents;
-  let compressedLength = numVertices;
-  let numCompressedComponents = hasSt && hasNormal ? 2 : 1;
-  numCompressedComponents += hasTangent || hasBitangent ? 1 : 0;
-  compressedLength *= numCompressedComponents;
-  const compressedAttributes = new Float32Array(compressedLength);
-  let normalIndex = 0;
-  for (i = 0; i < numVertices; ++i) {
-    if (hasSt) {
-      Cartesian2_default.fromArray(st, i * 2, scratchCartesian22);
-      compressedAttributes[normalIndex++] = AttributeCompression_default.compressTextureCoordinates(scratchCartesian22);
-    }
-    const index = i * 3;
-    if (hasNormal && defined_default(tangents) && defined_default(bitangents)) {
-      Cartesian3_default.fromArray(normals, index, toEncode1);
-      Cartesian3_default.fromArray(tangents, index, toEncode2);
-      Cartesian3_default.fromArray(bitangents, index, toEncode3);
-      AttributeCompression_default.octPack(
-        toEncode1,
-        toEncode2,
-        toEncode3,
-        scratchCartesian22
-      );
-      compressedAttributes[normalIndex++] = scratchCartesian22.x;
-      compressedAttributes[normalIndex++] = scratchCartesian22.y;
-    } else {
-      if (hasNormal) {
-        Cartesian3_default.fromArray(normals, index, toEncode1);
-        compressedAttributes[normalIndex++] = AttributeCompression_default.octEncodeFloat(toEncode1);
-      }
-      if (hasTangent) {
-        Cartesian3_default.fromArray(tangents, index, toEncode1);
-        compressedAttributes[normalIndex++] = AttributeCompression_default.octEncodeFloat(toEncode1);
-      }
-      if (hasBitangent) {
-        Cartesian3_default.fromArray(bitangents, index, toEncode1);
-        compressedAttributes[normalIndex++] = AttributeCompression_default.octEncodeFloat(toEncode1);
-      }
-    }
-  }
-  geometry.attributes.compressedAttributes = new GeometryAttribute_default({
-    componentDatatype: ComponentDatatype_default.FLOAT,
-    componentsPerAttribute: numCompressedComponents,
-    values: compressedAttributes
-  });
-  if (hasNormal) {
-    delete geometry.attributes.normal;
-  }
-  if (hasSt) {
-    delete geometry.attributes.st;
-  }
-  if (hasBitangent) {
-    delete geometry.attributes.bitangent;
-  }
-  if (hasTangent) {
-    delete geometry.attributes.tangent;
-  }
-  return geometry;
-};
-function indexTriangles(geometry) {
-  if (defined_default(geometry.indices)) {
-    return geometry;
-  }
-  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
-  if (numberOfVertices < 3) {
-    throw new DeveloperError_default("The number of vertices must be at least three.");
-  }
-  if (numberOfVertices % 3 !== 0) {
-    throw new DeveloperError_default(
-      "The number of vertices must be a multiple of three."
-    );
-  }
-  const indices = IndexDatatype_default.createTypedArray(
-    numberOfVertices,
-    numberOfVertices
-  );
-  for (let i = 0; i < numberOfVertices; ++i) {
-    indices[i] = i;
-  }
-  geometry.indices = indices;
-  return geometry;
-}
-function indexTriangleFan(geometry) {
-  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
-  if (numberOfVertices < 3) {
-    throw new DeveloperError_default("The number of vertices must be at least three.");
-  }
-  const indices = IndexDatatype_default.createTypedArray(
-    numberOfVertices,
-    (numberOfVertices - 2) * 3
-  );
-  indices[0] = 1;
-  indices[1] = 0;
-  indices[2] = 2;
-  let indicesIndex = 3;
-  for (let i = 3; i < numberOfVertices; ++i) {
-    indices[indicesIndex++] = i - 1;
-    indices[indicesIndex++] = 0;
-    indices[indicesIndex++] = i;
-  }
-  geometry.indices = indices;
-  geometry.primitiveType = PrimitiveType_default.TRIANGLES;
-  return geometry;
-}
-function indexTriangleStrip(geometry) {
-  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
-  if (numberOfVertices < 3) {
-    throw new DeveloperError_default("The number of vertices must be at least 3.");
-  }
-  const indices = IndexDatatype_default.createTypedArray(
-    numberOfVertices,
-    (numberOfVertices - 2) * 3
-  );
-  indices[0] = 0;
-  indices[1] = 1;
-  indices[2] = 2;
-  if (numberOfVertices > 3) {
-    indices[3] = 0;
-    indices[4] = 2;
-    indices[5] = 3;
-  }
-  let indicesIndex = 6;
-  for (let i = 3; i < numberOfVertices - 1; i += 2) {
-    indices[indicesIndex++] = i;
-    indices[indicesIndex++] = i - 1;
-    indices[indicesIndex++] = i + 1;
-    if (i + 2 < numberOfVertices) {
-      indices[indicesIndex++] = i;
-      indices[indicesIndex++] = i + 1;
-      indices[indicesIndex++] = i + 2;
-    }
-  }
-  geometry.indices = indices;
-  geometry.primitiveType = PrimitiveType_default.TRIANGLES;
-  return geometry;
-}
-function indexLines(geometry) {
-  if (defined_default(geometry.indices)) {
-    return geometry;
-  }
-  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
-  if (numberOfVertices < 2) {
-    throw new DeveloperError_default("The number of vertices must be at least two.");
-  }
-  if (numberOfVertices % 2 !== 0) {
-    throw new DeveloperError_default("The number of vertices must be a multiple of 2.");
-  }
-  const indices = IndexDatatype_default.createTypedArray(
-    numberOfVertices,
-    numberOfVertices
-  );
-  for (let i = 0; i < numberOfVertices; ++i) {
-    indices[i] = i;
-  }
-  geometry.indices = indices;
-  return geometry;
-}
-function indexLineStrip(geometry) {
-  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
-  if (numberOfVertices < 2) {
-    throw new DeveloperError_default("The number of vertices must be at least two.");
-  }
-  const indices = IndexDatatype_default.createTypedArray(
-    numberOfVertices,
-    (numberOfVertices - 1) * 2
-  );
-  indices[0] = 0;
-  indices[1] = 1;
-  let indicesIndex = 2;
-  for (let i = 2; i < numberOfVertices; ++i) {
-    indices[indicesIndex++] = i - 1;
-    indices[indicesIndex++] = i;
-  }
-  geometry.indices = indices;
-  geometry.primitiveType = PrimitiveType_default.LINES;
-  return geometry;
-}
-function indexLineLoop(geometry) {
-  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
-  if (numberOfVertices < 2) {
-    throw new DeveloperError_default("The number of vertices must be at least two.");
-  }
-  const indices = IndexDatatype_default.createTypedArray(
-    numberOfVertices,
-    numberOfVertices * 2
-  );
-  indices[0] = 0;
-  indices[1] = 1;
-  let indicesIndex = 2;
-  for (let i = 2; i < numberOfVertices; ++i) {
-    indices[indicesIndex++] = i - 1;
-    indices[indicesIndex++] = i;
-  }
-  indices[indicesIndex++] = numberOfVertices - 1;
-  indices[indicesIndex] = 0;
-  geometry.indices = indices;
-  geometry.primitiveType = PrimitiveType_default.LINES;
-  return geometry;
-}
-function indexPrimitive(geometry) {
-  switch (geometry.primitiveType) {
-    case PrimitiveType_default.TRIANGLE_FAN:
-      return indexTriangleFan(geometry);
-    case PrimitiveType_default.TRIANGLE_STRIP:
-      return indexTriangleStrip(geometry);
-    case PrimitiveType_default.TRIANGLES:
-      return indexTriangles(geometry);
-    case PrimitiveType_default.LINE_STRIP:
-      return indexLineStrip(geometry);
-    case PrimitiveType_default.LINE_LOOP:
-      return indexLineLoop(geometry);
-    case PrimitiveType_default.LINES:
-      return indexLines(geometry);
-  }
-  return geometry;
-}
-function offsetPointFromXZPlane(p, isBehind) {
-  if (Math.abs(p.y) < Math_default.EPSILON6) {
-    if (isBehind) {
-      p.y = -Math_default.EPSILON6;
-    } else {
-      p.y = Math_default.EPSILON6;
-    }
-  }
-}
-function offsetTriangleFromXZPlane(p0, p1, p2) {
-  if (p0.y !== 0 && p1.y !== 0 && p2.y !== 0) {
-    offsetPointFromXZPlane(p0, p0.y < 0);
-    offsetPointFromXZPlane(p1, p1.y < 0);
-    offsetPointFromXZPlane(p2, p2.y < 0);
-    return;
-  }
-  const p0y = Math.abs(p0.y);
-  const p1y = Math.abs(p1.y);
-  const p2y = Math.abs(p2.y);
-  let sign;
-  if (p0y > p1y) {
-    if (p0y > p2y) {
-      sign = Math_default.sign(p0.y);
-    } else {
-      sign = Math_default.sign(p2.y);
-    }
-  } else if (p1y > p2y) {
-    sign = Math_default.sign(p1.y);
-  } else {
-    sign = Math_default.sign(p2.y);
-  }
-  const isBehind = sign < 0;
-  offsetPointFromXZPlane(p0, isBehind);
-  offsetPointFromXZPlane(p1, isBehind);
-  offsetPointFromXZPlane(p2, isBehind);
-}
-var c3 = new Cartesian3_default();
-function getXZIntersectionOffsetPoints(p, p1, u12, v12) {
-  Cartesian3_default.add(
-    p,
-    Cartesian3_default.multiplyByScalar(
-      Cartesian3_default.subtract(p1, p, c3),
-      p.y / (p.y - p1.y),
-      c3
-    ),
-    u12
-  );
-  Cartesian3_default.clone(u12, v12);
-  offsetPointFromXZPlane(u12, true);
-  offsetPointFromXZPlane(v12, false);
-}
-var u1 = new Cartesian3_default();
-var u2 = new Cartesian3_default();
-var q1 = new Cartesian3_default();
-var q2 = new Cartesian3_default();
-var splitTriangleResult = {
-  positions: new Array(7),
-  indices: new Array(3 * 3)
-};
-function splitTriangle(p0, p1, p2) {
-  if (p0.x >= 0 || p1.x >= 0 || p2.x >= 0) {
-    return void 0;
-  }
-  offsetTriangleFromXZPlane(p0, p1, p2);
-  const p0Behind = p0.y < 0;
-  const p1Behind = p1.y < 0;
-  const p2Behind = p2.y < 0;
-  let numBehind = 0;
-  numBehind += p0Behind ? 1 : 0;
-  numBehind += p1Behind ? 1 : 0;
-  numBehind += p2Behind ? 1 : 0;
-  const indices = splitTriangleResult.indices;
-  if (numBehind === 1) {
-    indices[1] = 3;
-    indices[2] = 4;
-    indices[5] = 6;
-    indices[7] = 6;
-    indices[8] = 5;
-    if (p0Behind) {
-      getXZIntersectionOffsetPoints(p0, p1, u1, q1);
-      getXZIntersectionOffsetPoints(p0, p2, u2, q2);
-      indices[0] = 0;
-      indices[3] = 1;
-      indices[4] = 2;
-      indices[6] = 1;
-    } else if (p1Behind) {
-      getXZIntersectionOffsetPoints(p1, p2, u1, q1);
-      getXZIntersectionOffsetPoints(p1, p0, u2, q2);
-      indices[0] = 1;
-      indices[3] = 2;
-      indices[4] = 0;
-      indices[6] = 2;
-    } else if (p2Behind) {
-      getXZIntersectionOffsetPoints(p2, p0, u1, q1);
-      getXZIntersectionOffsetPoints(p2, p1, u2, q2);
-      indices[0] = 2;
-      indices[3] = 0;
-      indices[4] = 1;
-      indices[6] = 0;
-    }
-  } else if (numBehind === 2) {
-    indices[2] = 4;
-    indices[4] = 4;
-    indices[5] = 3;
-    indices[7] = 5;
-    indices[8] = 6;
-    if (!p0Behind) {
-      getXZIntersectionOffsetPoints(p0, p1, u1, q1);
-      getXZIntersectionOffsetPoints(p0, p2, u2, q2);
-      indices[0] = 1;
-      indices[1] = 2;
-      indices[3] = 1;
-      indices[6] = 0;
-    } else if (!p1Behind) {
-      getXZIntersectionOffsetPoints(p1, p2, u1, q1);
-      getXZIntersectionOffsetPoints(p1, p0, u2, q2);
-      indices[0] = 2;
-      indices[1] = 0;
-      indices[3] = 2;
-      indices[6] = 1;
-    } else if (!p2Behind) {
-      getXZIntersectionOffsetPoints(p2, p0, u1, q1);
-      getXZIntersectionOffsetPoints(p2, p1, u2, q2);
-      indices[0] = 0;
-      indices[1] = 1;
-      indices[3] = 0;
-      indices[6] = 2;
-    }
-  }
-  const positions = splitTriangleResult.positions;
-  positions[0] = p0;
-  positions[1] = p1;
-  positions[2] = p2;
-  positions.length = 3;
-  if (numBehind === 1 || numBehind === 2) {
-    positions[3] = u1;
-    positions[4] = u2;
-    positions[5] = q1;
-    positions[6] = q2;
-    positions.length = 7;
-  }
-  return splitTriangleResult;
-}
-function updateGeometryAfterSplit(geometry, computeBoundingSphere) {
-  const attributes = geometry.attributes;
-  if (attributes.position.values.length === 0) {
-    return void 0;
-  }
-  for (const property in attributes) {
-    if (attributes.hasOwnProperty(property) && defined_default(attributes[property]) && defined_default(attributes[property].values)) {
-      const attribute = attributes[property];
-      attribute.values = ComponentDatatype_default.createTypedArray(
-        attribute.componentDatatype,
-        attribute.values
-      );
-    }
-  }
-  const numberOfVertices = Geometry_default.computeNumberOfVertices(geometry);
-  geometry.indices = IndexDatatype_default.createTypedArray(
-    numberOfVertices,
-    geometry.indices
-  );
-  if (computeBoundingSphere) {
-    geometry.boundingSphere = BoundingSphere_default.fromVertices(
-      attributes.position.values
-    );
-  }
-  return geometry;
-}
-function copyGeometryForSplit(geometry) {
-  const attributes = geometry.attributes;
-  const copiedAttributes = {};
-  for (const property in attributes) {
-    if (attributes.hasOwnProperty(property) && defined_default(attributes[property]) && defined_default(attributes[property].values)) {
-      const attribute = attributes[property];
-      copiedAttributes[property] = new GeometryAttribute_default({
-        componentDatatype: attribute.componentDatatype,
-        componentsPerAttribute: attribute.componentsPerAttribute,
-        normalize: attribute.normalize,
-        values: []
-      });
-    }
-  }
-  return new Geometry_default({
-    attributes: copiedAttributes,
-    indices: [],
-    primitiveType: geometry.primitiveType
-  });
-}
-function updateInstanceAfterSplit(instance, westGeometry, eastGeometry) {
-  const computeBoundingSphere = defined_default(instance.geometry.boundingSphere);
-  westGeometry = updateGeometryAfterSplit(westGeometry, computeBoundingSphere);
-  eastGeometry = updateGeometryAfterSplit(eastGeometry, computeBoundingSphere);
-  if (defined_default(eastGeometry) && !defined_default(westGeometry)) {
-    instance.geometry = eastGeometry;
-  } else if (!defined_default(eastGeometry) && defined_default(westGeometry)) {
-    instance.geometry = westGeometry;
-  } else {
-    instance.westHemisphereGeometry = westGeometry;
-    instance.eastHemisphereGeometry = eastGeometry;
-    instance.geometry = void 0;
-  }
-}
-function generateBarycentricInterpolateFunction(CartesianType, numberOfComponents) {
-  const v0Scratch = new CartesianType();
-  const v1Scratch = new CartesianType();
-  const v2Scratch = new CartesianType();
-  return function(i0, i1, i2, coords, sourceValues, currentValues, insertedIndex, normalize) {
-    const v02 = CartesianType.fromArray(
-      sourceValues,
-      i0 * numberOfComponents,
-      v0Scratch
-    );
-    const v12 = CartesianType.fromArray(
-      sourceValues,
-      i1 * numberOfComponents,
-      v1Scratch
-    );
-    const v22 = CartesianType.fromArray(
-      sourceValues,
-      i2 * numberOfComponents,
-      v2Scratch
-    );
-    CartesianType.multiplyByScalar(v02, coords.x, v02);
-    CartesianType.multiplyByScalar(v12, coords.y, v12);
-    CartesianType.multiplyByScalar(v22, coords.z, v22);
-    const value = CartesianType.add(v02, v12, v02);
-    CartesianType.add(value, v22, value);
-    if (normalize) {
-      CartesianType.normalize(value, value);
-    }
-    CartesianType.pack(
-      value,
-      currentValues,
-      insertedIndex * numberOfComponents
-    );
-  };
-}
-var interpolateAndPackCartesian4 = generateBarycentricInterpolateFunction(
-  Cartesian4_default,
-  4
-);
-var interpolateAndPackCartesian3 = generateBarycentricInterpolateFunction(
-  Cartesian3_default,
-  3
-);
-var interpolateAndPackCartesian2 = generateBarycentricInterpolateFunction(
-  Cartesian2_default,
-  2
-);
-var interpolateAndPackBoolean = function(i0, i1, i2, coords, sourceValues, currentValues, insertedIndex) {
-  const v12 = sourceValues[i0] * coords.x;
-  const v22 = sourceValues[i1] * coords.y;
-  const v3 = sourceValues[i2] * coords.z;
-  currentValues[insertedIndex] = v12 + v22 + v3 > Math_default.EPSILON6 ? 1 : 0;
-};
-var p0Scratch = new Cartesian3_default();
-var p1Scratch = new Cartesian3_default();
-var p2Scratch = new Cartesian3_default();
-var barycentricScratch = new Cartesian3_default();
-function computeTriangleAttributes(i0, i1, i2, point, positions, normals, tangents, bitangents, texCoords, extrudeDirections, applyOffset, currentAttributes, customAttributeNames, customAttributesLength, allAttributes, insertedIndex) {
-  if (!defined_default(normals) && !defined_default(tangents) && !defined_default(bitangents) && !defined_default(texCoords) && !defined_default(extrudeDirections) && customAttributesLength === 0) {
-    return;
-  }
-  const p0 = Cartesian3_default.fromArray(positions, i0 * 3, p0Scratch);
-  const p1 = Cartesian3_default.fromArray(positions, i1 * 3, p1Scratch);
-  const p2 = Cartesian3_default.fromArray(positions, i2 * 3, p2Scratch);
-  const coords = barycentricCoordinates_default(point, p0, p1, p2, barycentricScratch);
-  if (!defined_default(coords)) {
-    return;
-  }
-  if (defined_default(normals)) {
-    interpolateAndPackCartesian3(
-      i0,
-      i1,
-      i2,
-      coords,
-      normals,
-      currentAttributes.normal.values,
-      insertedIndex,
-      true
-    );
-  }
-  if (defined_default(extrudeDirections)) {
-    const d0 = Cartesian3_default.fromArray(extrudeDirections, i0 * 3, p0Scratch);
-    const d1 = Cartesian3_default.fromArray(extrudeDirections, i1 * 3, p1Scratch);
-    const d2 = Cartesian3_default.fromArray(extrudeDirections, i2 * 3, p2Scratch);
-    Cartesian3_default.multiplyByScalar(d0, coords.x, d0);
-    Cartesian3_default.multiplyByScalar(d1, coords.y, d1);
-    Cartesian3_default.multiplyByScalar(d2, coords.z, d2);
-    let direction;
-    if (!Cartesian3_default.equals(d0, Cartesian3_default.ZERO) || !Cartesian3_default.equals(d1, Cartesian3_default.ZERO) || !Cartesian3_default.equals(d2, Cartesian3_default.ZERO)) {
-      direction = Cartesian3_default.add(d0, d1, d0);
-      Cartesian3_default.add(direction, d2, direction);
-      Cartesian3_default.normalize(direction, direction);
-    } else {
-      direction = p0Scratch;
-      direction.x = 0;
-      direction.y = 0;
-      direction.z = 0;
-    }
-    Cartesian3_default.pack(
-      direction,
-      currentAttributes.extrudeDirection.values,
-      insertedIndex * 3
-    );
-  }
-  if (defined_default(applyOffset)) {
-    interpolateAndPackBoolean(
-      i0,
-      i1,
-      i2,
-      coords,
-      applyOffset,
-      currentAttributes.applyOffset.values,
-      insertedIndex
-    );
-  }
-  if (defined_default(tangents)) {
-    interpolateAndPackCartesian3(
-      i0,
-      i1,
-      i2,
-      coords,
-      tangents,
-      currentAttributes.tangent.values,
-      insertedIndex,
-      true
-    );
-  }
-  if (defined_default(bitangents)) {
-    interpolateAndPackCartesian3(
-      i0,
-      i1,
-      i2,
-      coords,
-      bitangents,
-      currentAttributes.bitangent.values,
-      insertedIndex,
-      true
-    );
-  }
-  if (defined_default(texCoords)) {
-    interpolateAndPackCartesian2(
-      i0,
-      i1,
-      i2,
-      coords,
-      texCoords,
-      currentAttributes.st.values,
-      insertedIndex
-    );
-  }
-  if (customAttributesLength > 0) {
-    for (let i = 0; i < customAttributesLength; i++) {
-      const attributeName = customAttributeNames[i];
-      genericInterpolate(
-        i0,
-        i1,
-        i2,
-        coords,
-        insertedIndex,
-        allAttributes[attributeName],
-        currentAttributes[attributeName]
-      );
-    }
-  }
-}
-function genericInterpolate(i0, i1, i2, coords, insertedIndex, sourceAttribute, currentAttribute) {
-  const componentsPerAttribute = sourceAttribute.componentsPerAttribute;
-  const sourceValues = sourceAttribute.values;
-  const currentValues = currentAttribute.values;
-  switch (componentsPerAttribute) {
-    case 4:
-      interpolateAndPackCartesian4(
-        i0,
-        i1,
-        i2,
-        coords,
-        sourceValues,
-        currentValues,
-        insertedIndex,
-        false
-      );
-      break;
-    case 3:
-      interpolateAndPackCartesian3(
-        i0,
-        i1,
-        i2,
-        coords,
-        sourceValues,
-        currentValues,
-        insertedIndex,
-        false
-      );
-      break;
-    case 2:
-      interpolateAndPackCartesian2(
-        i0,
-        i1,
-        i2,
-        coords,
-        sourceValues,
-        currentValues,
-        insertedIndex,
-        false
-      );
-      break;
-    default:
-      currentValues[insertedIndex] = sourceValues[i0] * coords.x + sourceValues[i1] * coords.y + sourceValues[i2] * coords.z;
-  }
-}
-function insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices, currentIndex, point) {
-  const insertIndex = currentAttributes.position.values.length / 3;
-  if (currentIndex !== -1) {
-    const prevIndex = indices[currentIndex];
-    const newIndex = currentIndexMap[prevIndex];
-    if (newIndex === -1) {
-      currentIndexMap[prevIndex] = insertIndex;
-      currentAttributes.position.values.push(point.x, point.y, point.z);
-      currentIndices.push(insertIndex);
-      return insertIndex;
-    }
-    currentIndices.push(newIndex);
-    return newIndex;
-  }
-  currentAttributes.position.values.push(point.x, point.y, point.z);
-  currentIndices.push(insertIndex);
-  return insertIndex;
-}
-var NAMED_ATTRIBUTES = {
-  position: true,
-  normal: true,
-  bitangent: true,
-  tangent: true,
-  st: true,
-  extrudeDirection: true,
-  applyOffset: true
-};
-function splitLongitudeTriangles(instance) {
-  const geometry = instance.geometry;
-  const attributes = geometry.attributes;
-  const positions = attributes.position.values;
-  const normals = defined_default(attributes.normal) ? attributes.normal.values : void 0;
-  const bitangents = defined_default(attributes.bitangent) ? attributes.bitangent.values : void 0;
-  const tangents = defined_default(attributes.tangent) ? attributes.tangent.values : void 0;
-  const texCoords = defined_default(attributes.st) ? attributes.st.values : void 0;
-  const extrudeDirections = defined_default(attributes.extrudeDirection) ? attributes.extrudeDirection.values : void 0;
-  const applyOffset = defined_default(attributes.applyOffset) ? attributes.applyOffset.values : void 0;
-  const indices = geometry.indices;
-  const customAttributeNames = [];
-  for (const attributeName in attributes) {
-    if (attributes.hasOwnProperty(attributeName) && !NAMED_ATTRIBUTES[attributeName] && defined_default(attributes[attributeName])) {
-      customAttributeNames.push(attributeName);
-    }
-  }
-  const customAttributesLength = customAttributeNames.length;
-  const eastGeometry = copyGeometryForSplit(geometry);
-  const westGeometry = copyGeometryForSplit(geometry);
-  let currentAttributes;
-  let currentIndices;
-  let currentIndexMap;
-  let insertedIndex;
-  let i;
-  const westGeometryIndexMap = [];
-  westGeometryIndexMap.length = positions.length / 3;
-  const eastGeometryIndexMap = [];
-  eastGeometryIndexMap.length = positions.length / 3;
-  for (i = 0; i < westGeometryIndexMap.length; ++i) {
-    westGeometryIndexMap[i] = -1;
-    eastGeometryIndexMap[i] = -1;
-  }
-  const len = indices.length;
-  for (i = 0; i < len; i += 3) {
-    const i0 = indices[i];
-    const i1 = indices[i + 1];
-    const i2 = indices[i + 2];
-    let p0 = Cartesian3_default.fromArray(positions, i0 * 3);
-    let p1 = Cartesian3_default.fromArray(positions, i1 * 3);
-    let p2 = Cartesian3_default.fromArray(positions, i2 * 3);
-    const result = splitTriangle(p0, p1, p2);
-    if (defined_default(result) && result.positions.length > 3) {
-      const resultPositions = result.positions;
-      const resultIndices = result.indices;
-      const resultLength = resultIndices.length;
-      for (let j = 0; j < resultLength; ++j) {
-        const resultIndex = resultIndices[j];
-        const point = resultPositions[resultIndex];
-        if (point.y < 0) {
-          currentAttributes = westGeometry.attributes;
-          currentIndices = westGeometry.indices;
-          currentIndexMap = westGeometryIndexMap;
-        } else {
-          currentAttributes = eastGeometry.attributes;
-          currentIndices = eastGeometry.indices;
-          currentIndexMap = eastGeometryIndexMap;
-        }
-        insertedIndex = insertSplitPoint(
-          currentAttributes,
-          currentIndices,
-          currentIndexMap,
-          indices,
-          resultIndex < 3 ? i + resultIndex : -1,
-          point
-        );
-        computeTriangleAttributes(
-          i0,
-          i1,
-          i2,
-          point,
-          positions,
-          normals,
-          tangents,
-          bitangents,
-          texCoords,
-          extrudeDirections,
-          applyOffset,
-          currentAttributes,
-          customAttributeNames,
-          customAttributesLength,
-          attributes,
-          insertedIndex
-        );
-      }
-    } else {
-      if (defined_default(result)) {
-        p0 = result.positions[0];
-        p1 = result.positions[1];
-        p2 = result.positions[2];
-      }
-      if (p0.y < 0) {
-        currentAttributes = westGeometry.attributes;
-        currentIndices = westGeometry.indices;
-        currentIndexMap = westGeometryIndexMap;
-      } else {
-        currentAttributes = eastGeometry.attributes;
-        currentIndices = eastGeometry.indices;
-        currentIndexMap = eastGeometryIndexMap;
-      }
-      insertedIndex = insertSplitPoint(
-        currentAttributes,
-        currentIndices,
-        currentIndexMap,
-        indices,
-        i,
-        p0
-      );
-      computeTriangleAttributes(
-        i0,
-        i1,
-        i2,
-        p0,
-        positions,
-        normals,
-        tangents,
-        bitangents,
-        texCoords,
-        extrudeDirections,
-        applyOffset,
-        currentAttributes,
-        customAttributeNames,
-        customAttributesLength,
-        attributes,
-        insertedIndex
-      );
-      insertedIndex = insertSplitPoint(
-        currentAttributes,
-        currentIndices,
-        currentIndexMap,
-        indices,
-        i + 1,
-        p1
-      );
-      computeTriangleAttributes(
-        i0,
-        i1,
-        i2,
-        p1,
-        positions,
-        normals,
-        tangents,
-        bitangents,
-        texCoords,
-        extrudeDirections,
-        applyOffset,
-        currentAttributes,
-        customAttributeNames,
-        customAttributesLength,
-        attributes,
-        insertedIndex
-      );
-      insertedIndex = insertSplitPoint(
-        currentAttributes,
-        currentIndices,
-        currentIndexMap,
-        indices,
-        i + 2,
-        p2
-      );
-      computeTriangleAttributes(
-        i0,
-        i1,
-        i2,
-        p2,
-        positions,
-        normals,
-        tangents,
-        bitangents,
-        texCoords,
-        extrudeDirections,
-        applyOffset,
-        currentAttributes,
-        customAttributeNames,
-        customAttributesLength,
-        attributes,
-        insertedIndex
-      );
-    }
-  }
-  updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
-}
-var xzPlane = Plane_default.fromPointNormal(Cartesian3_default.ZERO, Cartesian3_default.UNIT_Y);
-var offsetScratch = new Cartesian3_default();
-var offsetPointScratch = new Cartesian3_default();
-function computeLineAttributes(i0, i1, point, positions, insertIndex, currentAttributes, applyOffset) {
-  if (!defined_default(applyOffset)) {
-    return;
-  }
-  const p0 = Cartesian3_default.fromArray(positions, i0 * 3, p0Scratch);
-  if (Cartesian3_default.equalsEpsilon(p0, point, Math_default.EPSILON10)) {
-    currentAttributes.applyOffset.values[insertIndex] = applyOffset[i0];
-  } else {
-    currentAttributes.applyOffset.values[insertIndex] = applyOffset[i1];
-  }
-}
-function splitLongitudeLines(instance) {
-  const geometry = instance.geometry;
-  const attributes = geometry.attributes;
-  const positions = attributes.position.values;
-  const applyOffset = defined_default(attributes.applyOffset) ? attributes.applyOffset.values : void 0;
-  const indices = geometry.indices;
-  const eastGeometry = copyGeometryForSplit(geometry);
-  const westGeometry = copyGeometryForSplit(geometry);
-  let i;
-  const length = indices.length;
-  const westGeometryIndexMap = [];
-  westGeometryIndexMap.length = positions.length / 3;
-  const eastGeometryIndexMap = [];
-  eastGeometryIndexMap.length = positions.length / 3;
-  for (i = 0; i < westGeometryIndexMap.length; ++i) {
-    westGeometryIndexMap[i] = -1;
-    eastGeometryIndexMap[i] = -1;
-  }
-  for (i = 0; i < length; i += 2) {
-    const i0 = indices[i];
-    const i1 = indices[i + 1];
-    const p0 = Cartesian3_default.fromArray(positions, i0 * 3, p0Scratch);
-    const p1 = Cartesian3_default.fromArray(positions, i1 * 3, p1Scratch);
-    let insertIndex;
-    if (Math.abs(p0.y) < Math_default.EPSILON6) {
-      if (p0.y < 0) {
-        p0.y = -Math_default.EPSILON6;
-      } else {
-        p0.y = Math_default.EPSILON6;
-      }
-    }
-    if (Math.abs(p1.y) < Math_default.EPSILON6) {
-      if (p1.y < 0) {
-        p1.y = -Math_default.EPSILON6;
-      } else {
-        p1.y = Math_default.EPSILON6;
-      }
-    }
-    let p0Attributes = eastGeometry.attributes;
-    let p0Indices = eastGeometry.indices;
-    let p0IndexMap = eastGeometryIndexMap;
-    let p1Attributes = westGeometry.attributes;
-    let p1Indices = westGeometry.indices;
-    let p1IndexMap = westGeometryIndexMap;
-    const intersection = IntersectionTests_default.lineSegmentPlane(
-      p0,
-      p1,
-      xzPlane,
-      p2Scratch
-    );
-    if (defined_default(intersection)) {
-      const offset = Cartesian3_default.multiplyByScalar(
-        Cartesian3_default.UNIT_Y,
-        5 * Math_default.EPSILON9,
-        offsetScratch
-      );
-      if (p0.y < 0) {
-        Cartesian3_default.negate(offset, offset);
-        p0Attributes = westGeometry.attributes;
-        p0Indices = westGeometry.indices;
-        p0IndexMap = westGeometryIndexMap;
-        p1Attributes = eastGeometry.attributes;
-        p1Indices = eastGeometry.indices;
-        p1IndexMap = eastGeometryIndexMap;
-      }
-      const offsetPoint = Cartesian3_default.add(
-        intersection,
-        offset,
-        offsetPointScratch
-      );
-      insertIndex = insertSplitPoint(
-        p0Attributes,
-        p0Indices,
-        p0IndexMap,
-        indices,
-        i,
-        p0
-      );
-      computeLineAttributes(
-        i0,
-        i1,
-        p0,
-        positions,
-        insertIndex,
-        p0Attributes,
-        applyOffset
-      );
-      insertIndex = insertSplitPoint(
-        p0Attributes,
-        p0Indices,
-        p0IndexMap,
-        indices,
-        -1,
-        offsetPoint
-      );
-      computeLineAttributes(
-        i0,
-        i1,
-        offsetPoint,
-        positions,
-        insertIndex,
-        p0Attributes,
-        applyOffset
-      );
-      Cartesian3_default.negate(offset, offset);
-      Cartesian3_default.add(intersection, offset, offsetPoint);
-      insertIndex = insertSplitPoint(
-        p1Attributes,
-        p1Indices,
-        p1IndexMap,
-        indices,
-        -1,
-        offsetPoint
-      );
-      computeLineAttributes(
-        i0,
-        i1,
-        offsetPoint,
-        positions,
-        insertIndex,
-        p1Attributes,
-        applyOffset
-      );
-      insertIndex = insertSplitPoint(
-        p1Attributes,
-        p1Indices,
-        p1IndexMap,
-        indices,
-        i + 1,
-        p1
-      );
-      computeLineAttributes(
-        i0,
-        i1,
-        p1,
-        positions,
-        insertIndex,
-        p1Attributes,
-        applyOffset
-      );
-    } else {
-      let currentAttributes;
-      let currentIndices;
-      let currentIndexMap;
-      if (p0.y < 0) {
-        currentAttributes = westGeometry.attributes;
-        currentIndices = westGeometry.indices;
-        currentIndexMap = westGeometryIndexMap;
-      } else {
-        currentAttributes = eastGeometry.attributes;
-        currentIndices = eastGeometry.indices;
-        currentIndexMap = eastGeometryIndexMap;
-      }
-      insertIndex = insertSplitPoint(
-        currentAttributes,
-        currentIndices,
-        currentIndexMap,
-        indices,
-        i,
-        p0
-      );
-      computeLineAttributes(
-        i0,
-        i1,
-        p0,
-        positions,
-        insertIndex,
-        currentAttributes,
-        applyOffset
-      );
-      insertIndex = insertSplitPoint(
-        currentAttributes,
-        currentIndices,
-        currentIndexMap,
-        indices,
-        i + 1,
-        p1
-      );
-      computeLineAttributes(
-        i0,
-        i1,
-        p1,
-        positions,
-        insertIndex,
-        currentAttributes,
-        applyOffset
-      );
-    }
-  }
-  updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
-}
-var cartesian2Scratch0 = new Cartesian2_default();
-var cartesian2Scratch1 = new Cartesian2_default();
-var cartesian3Scratch0 = new Cartesian3_default();
-var cartesian3Scratch2 = new Cartesian3_default();
-var cartesian3Scratch3 = new Cartesian3_default();
-var cartesian3Scratch4 = new Cartesian3_default();
-var cartesian3Scratch5 = new Cartesian3_default();
-var cartesian3Scratch6 = new Cartesian3_default();
-var cartesian4Scratch0 = new Cartesian4_default();
-function updateAdjacencyAfterSplit(geometry) {
-  const attributes = geometry.attributes;
-  const positions = attributes.position.values;
-  const prevPositions = attributes.prevPosition.values;
-  const nextPositions = attributes.nextPosition.values;
-  const length = positions.length;
-  for (let j = 0; j < length; j += 3) {
-    const position = Cartesian3_default.unpack(positions, j, cartesian3Scratch0);
-    if (position.x > 0) {
-      continue;
-    }
-    const prevPosition = Cartesian3_default.unpack(
-      prevPositions,
-      j,
-      cartesian3Scratch2
-    );
-    if (position.y < 0 && prevPosition.y > 0 || position.y > 0 && prevPosition.y < 0) {
-      if (j - 3 > 0) {
-        prevPositions[j] = positions[j - 3];
-        prevPositions[j + 1] = positions[j - 2];
-        prevPositions[j + 2] = positions[j - 1];
-      } else {
-        Cartesian3_default.pack(position, prevPositions, j);
-      }
-    }
-    const nextPosition = Cartesian3_default.unpack(
-      nextPositions,
-      j,
-      cartesian3Scratch3
-    );
-    if (position.y < 0 && nextPosition.y > 0 || position.y > 0 && nextPosition.y < 0) {
-      if (j + 3 < length) {
-        nextPositions[j] = positions[j + 3];
-        nextPositions[j + 1] = positions[j + 4];
-        nextPositions[j + 2] = positions[j + 5];
-      } else {
-        Cartesian3_default.pack(position, nextPositions, j);
-      }
-    }
-  }
-}
-var offsetScalar = 5 * Math_default.EPSILON9;
-var coplanarOffset = Math_default.EPSILON6;
-function splitLongitudePolyline(instance) {
-  const geometry = instance.geometry;
-  const attributes = geometry.attributes;
-  const positions = attributes.position.values;
-  const prevPositions = attributes.prevPosition.values;
-  const nextPositions = attributes.nextPosition.values;
-  const expandAndWidths = attributes.expandAndWidth.values;
-  const texCoords = defined_default(attributes.st) ? attributes.st.values : void 0;
-  const colors = defined_default(attributes.color) ? attributes.color.values : void 0;
-  const eastGeometry = copyGeometryForSplit(geometry);
-  const westGeometry = copyGeometryForSplit(geometry);
-  let i;
-  let j;
-  let index;
-  let intersectionFound = false;
-  const length = positions.length / 3;
-  for (i = 0; i < length; i += 4) {
-    const i0 = i;
-    const i2 = i + 2;
-    const p0 = Cartesian3_default.fromArray(positions, i0 * 3, cartesian3Scratch0);
-    const p2 = Cartesian3_default.fromArray(positions, i2 * 3, cartesian3Scratch2);
-    if (Math.abs(p0.y) < coplanarOffset) {
-      p0.y = coplanarOffset * (p2.y < 0 ? -1 : 1);
-      positions[i * 3 + 1] = p0.y;
-      positions[(i + 1) * 3 + 1] = p0.y;
-      for (j = i0 * 3; j < i0 * 3 + 4 * 3; j += 3) {
-        prevPositions[j] = positions[i * 3];
-        prevPositions[j + 1] = positions[i * 3 + 1];
-        prevPositions[j + 2] = positions[i * 3 + 2];
-      }
-    }
-    if (Math.abs(p2.y) < coplanarOffset) {
-      p2.y = coplanarOffset * (p0.y < 0 ? -1 : 1);
-      positions[(i + 2) * 3 + 1] = p2.y;
-      positions[(i + 3) * 3 + 1] = p2.y;
-      for (j = i0 * 3; j < i0 * 3 + 4 * 3; j += 3) {
-        nextPositions[j] = positions[(i + 2) * 3];
-        nextPositions[j + 1] = positions[(i + 2) * 3 + 1];
-        nextPositions[j + 2] = positions[(i + 2) * 3 + 2];
-      }
-    }
-    let p0Attributes = eastGeometry.attributes;
-    let p0Indices = eastGeometry.indices;
-    let p2Attributes = westGeometry.attributes;
-    let p2Indices = westGeometry.indices;
-    const intersection = IntersectionTests_default.lineSegmentPlane(
-      p0,
-      p2,
-      xzPlane,
-      cartesian3Scratch4
-    );
-    if (defined_default(intersection)) {
-      intersectionFound = true;
-      const offset = Cartesian3_default.multiplyByScalar(
-        Cartesian3_default.UNIT_Y,
-        offsetScalar,
-        cartesian3Scratch5
-      );
-      if (p0.y < 0) {
-        Cartesian3_default.negate(offset, offset);
-        p0Attributes = westGeometry.attributes;
-        p0Indices = westGeometry.indices;
-        p2Attributes = eastGeometry.attributes;
-        p2Indices = eastGeometry.indices;
-      }
-      const offsetPoint = Cartesian3_default.add(
-        intersection,
-        offset,
-        cartesian3Scratch6
-      );
-      p0Attributes.position.values.push(p0.x, p0.y, p0.z, p0.x, p0.y, p0.z);
-      p0Attributes.position.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p0Attributes.position.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p0Attributes.prevPosition.values.push(
-        prevPositions[i0 * 3],
-        prevPositions[i0 * 3 + 1],
-        prevPositions[i0 * 3 + 2]
-      );
-      p0Attributes.prevPosition.values.push(
-        prevPositions[i0 * 3 + 3],
-        prevPositions[i0 * 3 + 4],
-        prevPositions[i0 * 3 + 5]
-      );
-      p0Attributes.prevPosition.values.push(p0.x, p0.y, p0.z, p0.x, p0.y, p0.z);
-      p0Attributes.nextPosition.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p0Attributes.nextPosition.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p0Attributes.nextPosition.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p0Attributes.nextPosition.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      Cartesian3_default.negate(offset, offset);
-      Cartesian3_default.add(intersection, offset, offsetPoint);
-      p2Attributes.position.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p2Attributes.position.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p2Attributes.position.values.push(p2.x, p2.y, p2.z, p2.x, p2.y, p2.z);
-      p2Attributes.prevPosition.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p2Attributes.prevPosition.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p2Attributes.prevPosition.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p2Attributes.prevPosition.values.push(
-        offsetPoint.x,
-        offsetPoint.y,
-        offsetPoint.z
-      );
-      p2Attributes.nextPosition.values.push(p2.x, p2.y, p2.z, p2.x, p2.y, p2.z);
-      p2Attributes.nextPosition.values.push(
-        nextPositions[i2 * 3],
-        nextPositions[i2 * 3 + 1],
-        nextPositions[i2 * 3 + 2]
-      );
-      p2Attributes.nextPosition.values.push(
-        nextPositions[i2 * 3 + 3],
-        nextPositions[i2 * 3 + 4],
-        nextPositions[i2 * 3 + 5]
-      );
-      const ew0 = Cartesian2_default.fromArray(
-        expandAndWidths,
-        i0 * 2,
-        cartesian2Scratch0
-      );
-      const width = Math.abs(ew0.y);
-      p0Attributes.expandAndWidth.values.push(-1, width, 1, width);
-      p0Attributes.expandAndWidth.values.push(-1, -width, 1, -width);
-      p2Attributes.expandAndWidth.values.push(-1, width, 1, width);
-      p2Attributes.expandAndWidth.values.push(-1, -width, 1, -width);
-      let t = Cartesian3_default.magnitudeSquared(
-        Cartesian3_default.subtract(intersection, p0, cartesian3Scratch3)
-      );
-      t /= Cartesian3_default.magnitudeSquared(
-        Cartesian3_default.subtract(p2, p0, cartesian3Scratch3)
-      );
-      if (defined_default(colors)) {
-        const c0 = Cartesian4_default.fromArray(colors, i0 * 4, cartesian4Scratch0);
-        const c2 = Cartesian4_default.fromArray(colors, i2 * 4, cartesian4Scratch0);
-        const r = Math_default.lerp(c0.x, c2.x, t);
-        const g = Math_default.lerp(c0.y, c2.y, t);
-        const b = Math_default.lerp(c0.z, c2.z, t);
-        const a = Math_default.lerp(c0.w, c2.w, t);
-        for (j = i0 * 4; j < i0 * 4 + 2 * 4; ++j) {
-          p0Attributes.color.values.push(colors[j]);
-        }
-        p0Attributes.color.values.push(r, g, b, a);
-        p0Attributes.color.values.push(r, g, b, a);
-        p2Attributes.color.values.push(r, g, b, a);
-        p2Attributes.color.values.push(r, g, b, a);
-        for (j = i2 * 4; j < i2 * 4 + 2 * 4; ++j) {
-          p2Attributes.color.values.push(colors[j]);
-        }
-      }
-      if (defined_default(texCoords)) {
-        const s0 = Cartesian2_default.fromArray(texCoords, i0 * 2, cartesian2Scratch0);
-        const s3 = Cartesian2_default.fromArray(
-          texCoords,
-          (i + 3) * 2,
-          cartesian2Scratch1
-        );
-        const sx = Math_default.lerp(s0.x, s3.x, t);
-        for (j = i0 * 2; j < i0 * 2 + 2 * 2; ++j) {
-          p0Attributes.st.values.push(texCoords[j]);
-        }
-        p0Attributes.st.values.push(sx, s0.y);
-        p0Attributes.st.values.push(sx, s3.y);
-        p2Attributes.st.values.push(sx, s0.y);
-        p2Attributes.st.values.push(sx, s3.y);
-        for (j = i2 * 2; j < i2 * 2 + 2 * 2; ++j) {
-          p2Attributes.st.values.push(texCoords[j]);
-        }
-      }
-      index = p0Attributes.position.values.length / 3 - 4;
-      p0Indices.push(index, index + 2, index + 1);
-      p0Indices.push(index + 1, index + 2, index + 3);
-      index = p2Attributes.position.values.length / 3 - 4;
-      p2Indices.push(index, index + 2, index + 1);
-      p2Indices.push(index + 1, index + 2, index + 3);
-    } else {
-      let currentAttributes;
-      let currentIndices;
-      if (p0.y < 0) {
-        currentAttributes = westGeometry.attributes;
-        currentIndices = westGeometry.indices;
-      } else {
-        currentAttributes = eastGeometry.attributes;
-        currentIndices = eastGeometry.indices;
-      }
-      currentAttributes.position.values.push(p0.x, p0.y, p0.z);
-      currentAttributes.position.values.push(p0.x, p0.y, p0.z);
-      currentAttributes.position.values.push(p2.x, p2.y, p2.z);
-      currentAttributes.position.values.push(p2.x, p2.y, p2.z);
-      for (j = i * 3; j < i * 3 + 4 * 3; ++j) {
-        currentAttributes.prevPosition.values.push(prevPositions[j]);
-        currentAttributes.nextPosition.values.push(nextPositions[j]);
-      }
-      for (j = i * 2; j < i * 2 + 4 * 2; ++j) {
-        currentAttributes.expandAndWidth.values.push(expandAndWidths[j]);
-        if (defined_default(texCoords)) {
-          currentAttributes.st.values.push(texCoords[j]);
-        }
-      }
-      if (defined_default(colors)) {
-        for (j = i * 4; j < i * 4 + 4 * 4; ++j) {
-          currentAttributes.color.values.push(colors[j]);
-        }
-      }
-      index = currentAttributes.position.values.length / 3 - 4;
-      currentIndices.push(index, index + 2, index + 1);
-      currentIndices.push(index + 1, index + 2, index + 3);
-    }
-  }
-  if (intersectionFound) {
-    updateAdjacencyAfterSplit(westGeometry);
-    updateAdjacencyAfterSplit(eastGeometry);
-  }
-  updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
-}
-GeometryPipeline.splitLongitude = function(instance) {
-  if (!defined_default(instance)) {
-    throw new DeveloperError_default("instance is required.");
-  }
-  const geometry = instance.geometry;
-  const boundingSphere = geometry.boundingSphere;
-  if (defined_default(boundingSphere)) {
-    const minX = boundingSphere.center.x - boundingSphere.radius;
-    if (minX > 0 || BoundingSphere_default.intersectPlane(boundingSphere, Plane_default.ORIGIN_ZX_PLANE) !== Intersect_default.INTERSECTING) {
-      return instance;
-    }
-  }
-  if (geometry.geometryType !== GeometryType_default.NONE) {
-    switch (geometry.geometryType) {
-      case GeometryType_default.POLYLINES:
-        splitLongitudePolyline(instance);
-        break;
-      case GeometryType_default.TRIANGLES:
-        splitLongitudeTriangles(instance);
-        break;
-      case GeometryType_default.LINES:
-        splitLongitudeLines(instance);
-        break;
-    }
-  } else {
-    indexPrimitive(geometry);
-    if (geometry.primitiveType === PrimitiveType_default.TRIANGLES) {
-      splitLongitudeTriangles(instance);
-    } else if (geometry.primitiveType === PrimitiveType_default.LINES) {
-      splitLongitudeLines(instance);
-    }
-  }
-  return instance;
-};
-var GeometryPipeline_default = GeometryPipeline;
-
-export {
-  GeometryPipeline_default
-};