@hztxi/cesium-engine 25.0.4 → 25.0.6

package/Build/Workers/chunk-OODXPB45.js

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.6
+ *
+ * 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 {
+  Math_default
+} from "./chunk-MKR6YCMG.js";
+
+// packages/engine/Source/Core/CylinderGeometryLibrary.js
+var CylinderGeometryLibrary = {};
+CylinderGeometryLibrary.computePositions = function(length, topRadius, bottomRadius, slices, fill) {
+  const topZ = length * 0.5;
+  const bottomZ = -topZ;
+  const twoSlice = slices + slices;
+  const size = fill ? 2 * twoSlice : twoSlice;
+  const positions = new Float64Array(size * 3);
+  let i;
+  let index = 0;
+  let tbIndex = 0;
+  const bottomOffset = fill ? twoSlice * 3 : 0;
+  const topOffset = fill ? (twoSlice + slices) * 3 : slices * 3;
+  for (i = 0; i < slices; i++) {
+    const angle = i / slices * Math_default.TWO_PI;
+    const x = Math.cos(angle);
+    const y = Math.sin(angle);
+    const bottomX = x * bottomRadius;
+    const bottomY = y * bottomRadius;
+    const topX = x * topRadius;
+    const topY = y * topRadius;
+    positions[tbIndex + bottomOffset] = bottomX;
+    positions[tbIndex + bottomOffset + 1] = bottomY;
+    positions[tbIndex + bottomOffset + 2] = bottomZ;
+    positions[tbIndex + topOffset] = topX;
+    positions[tbIndex + topOffset + 1] = topY;
+    positions[tbIndex + topOffset + 2] = topZ;
+    tbIndex += 3;
+    if (fill) {
+      positions[index++] = bottomX;
+      positions[index++] = bottomY;
+      positions[index++] = bottomZ;
+      positions[index++] = topX;
+      positions[index++] = topY;
+      positions[index++] = topZ;
+    }
+  }
+  return positions;
+};
+var CylinderGeometryLibrary_default = CylinderGeometryLibrary;
+
+export {
+  CylinderGeometryLibrary_default
+};

package/Build/Workers/chunk-OXZ5J3JW.js

@@ -0,0 +1,368 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.6
+ *
+ * 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 {
+  GeometryOffsetAttribute_default
+} from "./chunk-26OYTC24.js";
+import {
+  IndexDatatype_default
+} from "./chunk-HEY4IOS3.js";
+import {
+  GeometryAttributes_default
+} from "./chunk-C342XITR.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default,
+  PrimitiveType_default
+} from "./chunk-HRWFO57T.js";
+import {
+  BoundingSphere_default
+} from "./chunk-37WL527K.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-QBSWSTHY.js";
+import {
+  Ellipsoid_default
+} from "./chunk-S3XHL7GO.js";
+import {
+  Cartesian3_default,
+  Frozen_default
+} from "./chunk-VETQOADR.js";
+import {
+  Math_default
+} from "./chunk-MKR6YCMG.js";
+import {
+  DeveloperError_default
+} from "./chunk-UTAWMCSE.js";
+import {
+  defined_default
+} from "./chunk-HTCLVUBZ.js";
+
+// packages/engine/Source/Core/EllipsoidOutlineGeometry.js
+var defaultRadii = new Cartesian3_default(1, 1, 1);
+var cos = Math.cos;
+var sin = Math.sin;
+function EllipsoidOutlineGeometry(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  const radii = options.radii ?? defaultRadii;
+  const innerRadii = options.innerRadii ?? radii;
+  const minimumClock = options.minimumClock ?? 0;
+  const maximumClock = options.maximumClock ?? Math_default.TWO_PI;
+  const minimumCone = options.minimumCone ?? 0;
+  const maximumCone = options.maximumCone ?? Math_default.PI;
+  const stackPartitions = Math.round(options.stackPartitions ?? 10);
+  const slicePartitions = Math.round(options.slicePartitions ?? 8);
+  const subdivisions = Math.round(options.subdivisions ?? 128);
+  if (stackPartitions < 1) {
+    throw new DeveloperError_default("options.stackPartitions cannot be less than 1");
+  }
+  if (slicePartitions < 0) {
+    throw new DeveloperError_default("options.slicePartitions cannot be less than 0");
+  }
+  if (subdivisions < 0) {
+    throw new DeveloperError_default(
+      "options.subdivisions must be greater than or equal to zero."
+    );
+  }
+  if (defined_default(options.offsetAttribute) && options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+    throw new DeveloperError_default(
+      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
+    );
+  }
+  this._radii = Cartesian3_default.clone(radii);
+  this._innerRadii = Cartesian3_default.clone(innerRadii);
+  this._minimumClock = minimumClock;
+  this._maximumClock = maximumClock;
+  this._minimumCone = minimumCone;
+  this._maximumCone = maximumCone;
+  this._stackPartitions = stackPartitions;
+  this._slicePartitions = slicePartitions;
+  this._subdivisions = subdivisions;
+  this._offsetAttribute = options.offsetAttribute;
+  this._workerName = "createEllipsoidOutlineGeometry";
+}
+EllipsoidOutlineGeometry.packedLength = 2 * Cartesian3_default.packedLength + 8;
+EllipsoidOutlineGeometry.pack = function(value, array, startingIndex) {
+  if (!defined_default(value)) {
+    throw new DeveloperError_default("value is required");
+  }
+  if (!defined_default(array)) {
+    throw new DeveloperError_default("array is required");
+  }
+  startingIndex = startingIndex ?? 0;
+  Cartesian3_default.pack(value._radii, array, startingIndex);
+  startingIndex += Cartesian3_default.packedLength;
+  Cartesian3_default.pack(value._innerRadii, array, startingIndex);
+  startingIndex += Cartesian3_default.packedLength;
+  array[startingIndex++] = value._minimumClock;
+  array[startingIndex++] = value._maximumClock;
+  array[startingIndex++] = value._minimumCone;
+  array[startingIndex++] = value._maximumCone;
+  array[startingIndex++] = value._stackPartitions;
+  array[startingIndex++] = value._slicePartitions;
+  array[startingIndex++] = value._subdivisions;
+  array[startingIndex] = value._offsetAttribute ?? -1;
+  return array;
+};
+var scratchRadii = new Cartesian3_default();
+var scratchInnerRadii = new Cartesian3_default();
+var scratchOptions = {
+  radii: scratchRadii,
+  innerRadii: scratchInnerRadii,
+  minimumClock: void 0,
+  maximumClock: void 0,
+  minimumCone: void 0,
+  maximumCone: void 0,
+  stackPartitions: void 0,
+  slicePartitions: void 0,
+  subdivisions: void 0,
+  offsetAttribute: void 0
+};
+EllipsoidOutlineGeometry.unpack = function(array, startingIndex, result) {
+  if (!defined_default(array)) {
+    throw new DeveloperError_default("array is required");
+  }
+  startingIndex = startingIndex ?? 0;
+  const radii = Cartesian3_default.unpack(array, startingIndex, scratchRadii);
+  startingIndex += Cartesian3_default.packedLength;
+  const innerRadii = Cartesian3_default.unpack(array, startingIndex, scratchInnerRadii);
+  startingIndex += Cartesian3_default.packedLength;
+  const minimumClock = array[startingIndex++];
+  const maximumClock = array[startingIndex++];
+  const minimumCone = array[startingIndex++];
+  const maximumCone = array[startingIndex++];
+  const stackPartitions = array[startingIndex++];
+  const slicePartitions = array[startingIndex++];
+  const subdivisions = array[startingIndex++];
+  const offsetAttribute = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.minimumClock = minimumClock;
+    scratchOptions.maximumClock = maximumClock;
+    scratchOptions.minimumCone = minimumCone;
+    scratchOptions.maximumCone = maximumCone;
+    scratchOptions.stackPartitions = stackPartitions;
+    scratchOptions.slicePartitions = slicePartitions;
+    scratchOptions.subdivisions = subdivisions;
+    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+    return new EllipsoidOutlineGeometry(scratchOptions);
+  }
+  result._radii = Cartesian3_default.clone(radii, result._radii);
+  result._innerRadii = Cartesian3_default.clone(innerRadii, result._innerRadii);
+  result._minimumClock = minimumClock;
+  result._maximumClock = maximumClock;
+  result._minimumCone = minimumCone;
+  result._maximumCone = maximumCone;
+  result._stackPartitions = stackPartitions;
+  result._slicePartitions = slicePartitions;
+  result._subdivisions = subdivisions;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  return result;
+};
+EllipsoidOutlineGeometry.createGeometry = function(ellipsoidGeometry) {
+  const radii = ellipsoidGeometry._radii;
+  if (radii.x <= 0 || radii.y <= 0 || radii.z <= 0) {
+    return;
+  }
+  const innerRadii = ellipsoidGeometry._innerRadii;
+  if (innerRadii.x <= 0 || innerRadii.y <= 0 || innerRadii.z <= 0) {
+    return;
+  }
+  const minimumClock = ellipsoidGeometry._minimumClock;
+  const maximumClock = ellipsoidGeometry._maximumClock;
+  const minimumCone = ellipsoidGeometry._minimumCone;
+  const maximumCone = ellipsoidGeometry._maximumCone;
+  const subdivisions = ellipsoidGeometry._subdivisions;
+  const ellipsoid = Ellipsoid_default.fromCartesian3(radii);
+  let slicePartitions = ellipsoidGeometry._slicePartitions + 1;
+  let stackPartitions = ellipsoidGeometry._stackPartitions + 1;
+  slicePartitions = Math.round(
+    slicePartitions * Math.abs(maximumClock - minimumClock) / Math_default.TWO_PI
+  );
+  stackPartitions = Math.round(
+    stackPartitions * Math.abs(maximumCone - minimumCone) / Math_default.PI
+  );
+  if (slicePartitions < 2) {
+    slicePartitions = 2;
+  }
+  if (stackPartitions < 2) {
+    stackPartitions = 2;
+  }
+  let extraIndices = 0;
+  let vertexMultiplier = 1;
+  const hasInnerSurface = innerRadii.x !== radii.x || innerRadii.y !== radii.y || innerRadii.z !== radii.z;
+  let isTopOpen = false;
+  let isBotOpen = false;
+  if (hasInnerSurface) {
+    vertexMultiplier = 2;
+    if (minimumCone > 0) {
+      isTopOpen = true;
+      extraIndices += slicePartitions;
+    }
+    if (maximumCone < Math.PI) {
+      isBotOpen = true;
+      extraIndices += slicePartitions;
+    }
+  }
+  const vertexCount = subdivisions * vertexMultiplier * (stackPartitions + slicePartitions);
+  const positions = new Float64Array(vertexCount * 3);
+  const numIndices = 2 * (vertexCount + extraIndices - (slicePartitions + stackPartitions) * vertexMultiplier);
+  const indices = IndexDatatype_default.createTypedArray(vertexCount, numIndices);
+  let i;
+  let j;
+  let theta;
+  let phi;
+  let index = 0;
+  const sinPhi = new Array(stackPartitions);
+  const cosPhi = new Array(stackPartitions);
+  for (i = 0; i < stackPartitions; i++) {
+    phi = minimumCone + i * (maximumCone - minimumCone) / (stackPartitions - 1);
+    sinPhi[i] = sin(phi);
+    cosPhi[i] = cos(phi);
+  }
+  const sinTheta = new Array(subdivisions);
+  const cosTheta = new Array(subdivisions);
+  for (i = 0; i < subdivisions; i++) {
+    theta = minimumClock + i * (maximumClock - minimumClock) / (subdivisions - 1);
+    sinTheta[i] = sin(theta);
+    cosTheta[i] = cos(theta);
+  }
+  for (i = 0; i < stackPartitions; i++) {
+    for (j = 0; j < subdivisions; j++) {
+      positions[index++] = radii.x * sinPhi[i] * cosTheta[j];
+      positions[index++] = radii.y * sinPhi[i] * sinTheta[j];
+      positions[index++] = radii.z * cosPhi[i];
+    }
+  }
+  if (hasInnerSurface) {
+    for (i = 0; i < stackPartitions; i++) {
+      for (j = 0; j < subdivisions; j++) {
+        positions[index++] = innerRadii.x * sinPhi[i] * cosTheta[j];
+        positions[index++] = innerRadii.y * sinPhi[i] * sinTheta[j];
+        positions[index++] = innerRadii.z * cosPhi[i];
+      }
+    }
+  }
+  sinPhi.length = subdivisions;
+  cosPhi.length = subdivisions;
+  for (i = 0; i < subdivisions; i++) {
+    phi = minimumCone + i * (maximumCone - minimumCone) / (subdivisions - 1);
+    sinPhi[i] = sin(phi);
+    cosPhi[i] = cos(phi);
+  }
+  sinTheta.length = slicePartitions;
+  cosTheta.length = slicePartitions;
+  for (i = 0; i < slicePartitions; i++) {
+    theta = minimumClock + i * (maximumClock - minimumClock) / (slicePartitions - 1);
+    sinTheta[i] = sin(theta);
+    cosTheta[i] = cos(theta);
+  }
+  for (i = 0; i < subdivisions; i++) {
+    for (j = 0; j < slicePartitions; j++) {
+      positions[index++] = radii.x * sinPhi[i] * cosTheta[j];
+      positions[index++] = radii.y * sinPhi[i] * sinTheta[j];
+      positions[index++] = radii.z * cosPhi[i];
+    }
+  }
+  if (hasInnerSurface) {
+    for (i = 0; i < subdivisions; i++) {
+      for (j = 0; j < slicePartitions; j++) {
+        positions[index++] = innerRadii.x * sinPhi[i] * cosTheta[j];
+        positions[index++] = innerRadii.y * sinPhi[i] * sinTheta[j];
+        positions[index++] = innerRadii.z * cosPhi[i];
+      }
+    }
+  }
+  index = 0;
+  for (i = 0; i < stackPartitions * vertexMultiplier; i++) {
+    const topOffset = i * subdivisions;
+    for (j = 0; j < subdivisions - 1; j++) {
+      indices[index++] = topOffset + j;
+      indices[index++] = topOffset + j + 1;
+    }
+  }
+  let offset = stackPartitions * subdivisions * vertexMultiplier;
+  for (i = 0; i < slicePartitions; i++) {
+    for (j = 0; j < subdivisions - 1; j++) {
+      indices[index++] = offset + i + j * slicePartitions;
+      indices[index++] = offset + i + (j + 1) * slicePartitions;
+    }
+  }
+  if (hasInnerSurface) {
+    offset = stackPartitions * subdivisions * vertexMultiplier + slicePartitions * subdivisions;
+    for (i = 0; i < slicePartitions; i++) {
+      for (j = 0; j < subdivisions - 1; j++) {
+        indices[index++] = offset + i + j * slicePartitions;
+        indices[index++] = offset + i + (j + 1) * slicePartitions;
+      }
+    }
+  }
+  if (hasInnerSurface) {
+    let outerOffset = stackPartitions * subdivisions * vertexMultiplier;
+    let innerOffset = outerOffset + subdivisions * slicePartitions;
+    if (isTopOpen) {
+      for (i = 0; i < slicePartitions; i++) {
+        indices[index++] = outerOffset + i;
+        indices[index++] = innerOffset + i;
+      }
+    }
+    if (isBotOpen) {
+      outerOffset += subdivisions * slicePartitions - slicePartitions;
+      innerOffset += subdivisions * slicePartitions - slicePartitions;
+      for (i = 0; i < slicePartitions; i++) {
+        indices[index++] = outerOffset + i;
+        indices[index++] = innerOffset + i;
+      }
+    }
+  }
+  const attributes = new GeometryAttributes_default({
+    position: new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.DOUBLE,
+      componentsPerAttribute: 3,
+      values: positions
+    })
+  });
+  if (defined_default(ellipsoidGeometry._offsetAttribute)) {
+    const length = positions.length;
+    const offsetValue = ellipsoidGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+    const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+    attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: applyOffset
+    });
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.LINES,
+    boundingSphere: BoundingSphere_default.fromEllipsoid(ellipsoid),
+    offsetAttribute: ellipsoidGeometry._offsetAttribute
+  });
+};
+var EllipsoidOutlineGeometry_default = EllipsoidOutlineGeometry;
+
+export {
+  EllipsoidOutlineGeometry_default
+};

package/Build/Workers/chunk-QBSWSTHY.js

@@ -0,0 +1,257 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.6
+ *
+ * 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 {
+  WebGLConstants_default
+} from "./chunk-I2Q7XDRA.js";
+import {
+  DeveloperError_default
+} from "./chunk-UTAWMCSE.js";
+import {
+  defined_default
+} from "./chunk-HTCLVUBZ.js";
+
+// packages/engine/Source/Core/ComponentDatatype.js
+var ComponentDatatype = {
+  /**
+   * 8-bit signed byte corresponding to <code>gl.BYTE</code> and the type
+   * of an element in <code>Int8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  BYTE: WebGLConstants_default.BYTE,
+  /**
+   * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
+   * of an element in <code>Uint8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
+  /**
+   * 16-bit signed short corresponding to <code>SHORT</code> and the type
+   * of an element in <code>Int16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  SHORT: WebGLConstants_default.SHORT,
+  /**
+   * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
+   * of an element in <code>Uint16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
+  /**
+   * 32-bit signed int corresponding to <code>INT</code> and the type
+   * of an element in <code>Int32Array</code>.
+   *
+   * @memberOf ComponentDatatype
+   *
+   * @type {number}
+   * @constant
+   */
+  INT: WebGLConstants_default.INT,
+  /**
+   * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
+   * of an element in <code>Uint32Array</code>.
+   *
+   * @memberOf ComponentDatatype
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT,
+  /**
+   * 32-bit floating-point corresponding to <code>FLOAT</code> and the type
+   * of an element in <code>Float32Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  FLOAT: WebGLConstants_default.FLOAT,
+  /**
+   * 64-bit floating-point corresponding to <code>gl.DOUBLE</code> (in Desktop OpenGL;
+   * this is not supported in WebGL, and is emulated in Cesium via {@link GeometryPipeline.encodeAttribute})
+   * and the type of an element in <code>Float64Array</code>.
+   *
+   * @memberOf ComponentDatatype
+   *
+   * @type {number}
+   * @constant
+   * @default 0x140A
+   */
+  DOUBLE: WebGLConstants_default.DOUBLE
+};
+ComponentDatatype.getSizeInBytes = function(componentDatatype) {
+  if (!defined_default(componentDatatype)) {
+    throw new DeveloperError_default("value is required.");
+  }
+  switch (componentDatatype) {
+    case ComponentDatatype.BYTE:
+      return Int8Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return Uint8Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.SHORT:
+      return Int16Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return Uint16Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.INT:
+      return Int32Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.UNSIGNED_INT:
+      return Uint32Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.FLOAT:
+      return Float32Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.DOUBLE:
+      return Float64Array.BYTES_PER_ELEMENT;
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default("componentDatatype is not a valid value.");
+  }
+};
+ComponentDatatype.fromTypedArray = function(array) {
+  if (array instanceof Int8Array) {
+    return ComponentDatatype.BYTE;
+  }
+  if (array instanceof Uint8Array) {
+    return ComponentDatatype.UNSIGNED_BYTE;
+  }
+  if (array instanceof Int16Array) {
+    return ComponentDatatype.SHORT;
+  }
+  if (array instanceof Uint16Array) {
+    return ComponentDatatype.UNSIGNED_SHORT;
+  }
+  if (array instanceof Int32Array) {
+    return ComponentDatatype.INT;
+  }
+  if (array instanceof Uint32Array) {
+    return ComponentDatatype.UNSIGNED_INT;
+  }
+  if (array instanceof Float32Array) {
+    return ComponentDatatype.FLOAT;
+  }
+  if (array instanceof Float64Array) {
+    return ComponentDatatype.DOUBLE;
+  }
+  throw new DeveloperError_default(
+    "array must be an Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, or Float64Array."
+  );
+};
+ComponentDatatype.validate = function(componentDatatype) {
+  return defined_default(componentDatatype) && (componentDatatype === ComponentDatatype.BYTE || componentDatatype === ComponentDatatype.UNSIGNED_BYTE || componentDatatype === ComponentDatatype.SHORT || componentDatatype === ComponentDatatype.UNSIGNED_SHORT || componentDatatype === ComponentDatatype.INT || componentDatatype === ComponentDatatype.UNSIGNED_INT || componentDatatype === ComponentDatatype.FLOAT || componentDatatype === ComponentDatatype.DOUBLE);
+};
+ComponentDatatype.createTypedArray = function(componentDatatype, valuesOrLength) {
+  if (!defined_default(componentDatatype)) {
+    throw new DeveloperError_default("componentDatatype is required.");
+  }
+  if (!defined_default(valuesOrLength)) {
+    throw new DeveloperError_default("valuesOrLength is required.");
+  }
+  switch (componentDatatype) {
+    case ComponentDatatype.BYTE:
+      return new Int8Array(valuesOrLength);
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return new Uint8Array(valuesOrLength);
+    case ComponentDatatype.SHORT:
+      return new Int16Array(valuesOrLength);
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return new Uint16Array(valuesOrLength);
+    case ComponentDatatype.INT:
+      return new Int32Array(valuesOrLength);
+    case ComponentDatatype.UNSIGNED_INT:
+      return new Uint32Array(valuesOrLength);
+    case ComponentDatatype.FLOAT:
+      return new Float32Array(valuesOrLength);
+    case ComponentDatatype.DOUBLE:
+      return new Float64Array(valuesOrLength);
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default("componentDatatype is not a valid value.");
+  }
+};
+ComponentDatatype.createArrayBufferView = function(componentDatatype, buffer, byteOffset, length) {
+  if (!defined_default(componentDatatype)) {
+    throw new DeveloperError_default("componentDatatype is required.");
+  }
+  if (!defined_default(buffer)) {
+    throw new DeveloperError_default("buffer is required.");
+  }
+  byteOffset = byteOffset ?? 0;
+  length = length ?? (buffer.byteLength - byteOffset) / ComponentDatatype.getSizeInBytes(componentDatatype);
+  switch (componentDatatype) {
+    case ComponentDatatype.BYTE:
+      return new Int8Array(buffer, byteOffset, length);
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return new Uint8Array(buffer, byteOffset, length);
+    case ComponentDatatype.SHORT:
+      return new Int16Array(buffer, byteOffset, length);
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return new Uint16Array(buffer, byteOffset, length);
+    case ComponentDatatype.INT:
+      return new Int32Array(buffer, byteOffset, length);
+    case ComponentDatatype.UNSIGNED_INT:
+      return new Uint32Array(buffer, byteOffset, length);
+    case ComponentDatatype.FLOAT:
+      return new Float32Array(buffer, byteOffset, length);
+    case ComponentDatatype.DOUBLE:
+      return new Float64Array(buffer, byteOffset, length);
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default("componentDatatype is not a valid value.");
+  }
+};
+ComponentDatatype.fromName = function(name) {
+  switch (name) {
+    case "BYTE":
+      return ComponentDatatype.BYTE;
+    case "UNSIGNED_BYTE":
+      return ComponentDatatype.UNSIGNED_BYTE;
+    case "SHORT":
+      return ComponentDatatype.SHORT;
+    case "UNSIGNED_SHORT":
+      return ComponentDatatype.UNSIGNED_SHORT;
+    case "INT":
+      return ComponentDatatype.INT;
+    case "UNSIGNED_INT":
+      return ComponentDatatype.UNSIGNED_INT;
+    case "FLOAT":
+      return ComponentDatatype.FLOAT;
+    case "DOUBLE":
+      return ComponentDatatype.DOUBLE;
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default("name is not a valid value.");
+  }
+};
+Object.freeze(ComponentDatatype);
+var ComponentDatatype_default = ComponentDatatype;
+
+export {
+  ComponentDatatype_default
+};