@cesium/engine 26.1.0 → 26.2.0

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

@@ -0,0 +1,519 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.143.0
+ *
+ * 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 {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-6YR6JBMY.js";
+import {
+  __commonJS,
+  __toESM,
+  defined_default
+} from "./chunk-AHWAZRBV.js";
+
+// node_modules/mersenne-twister/src/mersenne-twister.js
+var require_mersenne_twister = __commonJS({
+  "node_modules/mersenne-twister/src/mersenne-twister.js"(exports, module) {
+    var MersenneTwister2 = function(seed) {
+      if (seed == void 0) {
+        seed = (/* @__PURE__ */ new Date()).getTime();
+      }
+      this.N = 624;
+      this.M = 397;
+      this.MATRIX_A = 2567483615;
+      this.UPPER_MASK = 2147483648;
+      this.LOWER_MASK = 2147483647;
+      this.mt = new Array(this.N);
+      this.mti = this.N + 1;
+      if (seed.constructor == Array) {
+        this.init_by_array(seed, seed.length);
+      } else {
+        this.init_seed(seed);
+      }
+    };
+    MersenneTwister2.prototype.init_seed = function(s) {
+      this.mt[0] = s >>> 0;
+      for (this.mti = 1; this.mti < this.N; this.mti++) {
+        var s = this.mt[this.mti - 1] ^ this.mt[this.mti - 1] >>> 30;
+        this.mt[this.mti] = (((s & 4294901760) >>> 16) * 1812433253 << 16) + (s & 65535) * 1812433253 + this.mti;
+        this.mt[this.mti] >>>= 0;
+      }
+    };
+    MersenneTwister2.prototype.init_by_array = function(init_key, key_length) {
+      var i, j, k;
+      this.init_seed(19650218);
+      i = 1;
+      j = 0;
+      k = this.N > key_length ? this.N : key_length;
+      for (; k; k--) {
+        var s = this.mt[i - 1] ^ this.mt[i - 1] >>> 30;
+        this.mt[i] = (this.mt[i] ^ (((s & 4294901760) >>> 16) * 1664525 << 16) + (s & 65535) * 1664525) + init_key[j] + j;
+        this.mt[i] >>>= 0;
+        i++;
+        j++;
+        if (i >= this.N) {
+          this.mt[0] = this.mt[this.N - 1];
+          i = 1;
+        }
+        if (j >= key_length) j = 0;
+      }
+      for (k = this.N - 1; k; k--) {
+        var s = this.mt[i - 1] ^ this.mt[i - 1] >>> 30;
+        this.mt[i] = (this.mt[i] ^ (((s & 4294901760) >>> 16) * 1566083941 << 16) + (s & 65535) * 1566083941) - i;
+        this.mt[i] >>>= 0;
+        i++;
+        if (i >= this.N) {
+          this.mt[0] = this.mt[this.N - 1];
+          i = 1;
+        }
+      }
+      this.mt[0] = 2147483648;
+    };
+    MersenneTwister2.prototype.random_int = function() {
+      var y;
+      var mag01 = new Array(0, this.MATRIX_A);
+      if (this.mti >= this.N) {
+        var kk;
+        if (this.mti == this.N + 1)
+          this.init_seed(5489);
+        for (kk = 0; kk < this.N - this.M; kk++) {
+          y = this.mt[kk] & this.UPPER_MASK | this.mt[kk + 1] & this.LOWER_MASK;
+          this.mt[kk] = this.mt[kk + this.M] ^ y >>> 1 ^ mag01[y & 1];
+        }
+        for (; kk < this.N - 1; kk++) {
+          y = this.mt[kk] & this.UPPER_MASK | this.mt[kk + 1] & this.LOWER_MASK;
+          this.mt[kk] = this.mt[kk + (this.M - this.N)] ^ y >>> 1 ^ mag01[y & 1];
+        }
+        y = this.mt[this.N - 1] & this.UPPER_MASK | this.mt[0] & this.LOWER_MASK;
+        this.mt[this.N - 1] = this.mt[this.M - 1] ^ y >>> 1 ^ mag01[y & 1];
+        this.mti = 0;
+      }
+      y = this.mt[this.mti++];
+      y ^= y >>> 11;
+      y ^= y << 7 & 2636928640;
+      y ^= y << 15 & 4022730752;
+      y ^= y >>> 18;
+      return y >>> 0;
+    };
+    MersenneTwister2.prototype.random_int31 = function() {
+      return this.random_int() >>> 1;
+    };
+    MersenneTwister2.prototype.random_incl = function() {
+      return this.random_int() * (1 / 4294967295);
+    };
+    MersenneTwister2.prototype.random = function() {
+      return this.random_int() * (1 / 4294967296);
+    };
+    MersenneTwister2.prototype.random_excl = function() {
+      return (this.random_int() + 0.5) * (1 / 4294967296);
+    };
+    MersenneTwister2.prototype.random_long = function() {
+      var a = this.random_int() >>> 5, b = this.random_int() >>> 6;
+      return (a * 67108864 + b) * (1 / 9007199254740992);
+    };
+    module.exports = MersenneTwister2;
+  }
+});
+
+// packages/engine/Source/Core/Math.js
+var import_mersenne_twister = __toESM(require_mersenne_twister(), 1);
+var CesiumMath = {};
+CesiumMath.EPSILON1 = 0.1;
+CesiumMath.EPSILON2 = 0.01;
+CesiumMath.EPSILON3 = 1e-3;
+CesiumMath.EPSILON4 = 1e-4;
+CesiumMath.EPSILON5 = 1e-5;
+CesiumMath.EPSILON6 = 1e-6;
+CesiumMath.EPSILON7 = 1e-7;
+CesiumMath.EPSILON8 = 1e-8;
+CesiumMath.EPSILON9 = 1e-9;
+CesiumMath.EPSILON10 = 1e-10;
+CesiumMath.EPSILON11 = 1e-11;
+CesiumMath.EPSILON12 = 1e-12;
+CesiumMath.EPSILON13 = 1e-13;
+CesiumMath.EPSILON14 = 1e-14;
+CesiumMath.EPSILON15 = 1e-15;
+CesiumMath.EPSILON16 = 1e-16;
+CesiumMath.EPSILON17 = 1e-17;
+CesiumMath.EPSILON18 = 1e-18;
+CesiumMath.EPSILON19 = 1e-19;
+CesiumMath.EPSILON20 = 1e-20;
+CesiumMath.EPSILON21 = 1e-21;
+CesiumMath.GRAVITATIONALPARAMETER = 3986004418e5;
+CesiumMath.SOLAR_RADIUS = 6955e5;
+CesiumMath.LUNAR_RADIUS = 1737400;
+CesiumMath.SIXTY_FOUR_KILOBYTES = 64 * 1024;
+CesiumMath.FOUR_GIGABYTES = 4 * 1024 * 1024 * 1024;
+CesiumMath.sign = Math.sign ?? function sign(value) {
+  value = +value;
+  if (value === 0 || value !== value) {
+    return value;
+  }
+  return value > 0 ? 1 : -1;
+};
+CesiumMath.signNotZero = function(value) {
+  return value < 0 ? -1 : 1;
+};
+CesiumMath.toSNorm = function(value, rangeMaximum) {
+  rangeMaximum = rangeMaximum ?? 255;
+  return Math.round(
+    (CesiumMath.clamp(value, -1, 1) * 0.5 + 0.5) * rangeMaximum
+  );
+};
+CesiumMath.fromSNorm = function(value, rangeMaximum) {
+  rangeMaximum = rangeMaximum ?? 255;
+  return CesiumMath.clamp(value, 0, rangeMaximum) / rangeMaximum * 2 - 1;
+};
+CesiumMath.normalize = function(value, rangeMinimum, rangeMaximum) {
+  rangeMaximum = Math.max(rangeMaximum - rangeMinimum, 0);
+  return rangeMaximum === 0 ? 0 : CesiumMath.clamp((value - rangeMinimum) / rangeMaximum, 0, 1);
+};
+CesiumMath.sinh = Math.sinh ?? function sinh(value) {
+  return (Math.exp(value) - Math.exp(-value)) / 2;
+};
+CesiumMath.cosh = Math.cosh ?? function cosh(value) {
+  return (Math.exp(value) + Math.exp(-value)) / 2;
+};
+CesiumMath.lerp = function(p, q, time) {
+  return (1 - time) * p + time * q;
+};
+CesiumMath.smoothDamp = function(p, q, velocity, deltaTime = 0, maximumSpeed = Number.POSITIVE_INFINITY, smoothTime = 1e-4, result = {}) {
+  Check_default.typeOf.number("p", p);
+  Check_default.typeOf.number("q", q);
+  Check_default.typeOf.number("velocity", velocity);
+  Check_default.typeOf.number.greaterThanOrEquals("deltaTime", deltaTime, 0);
+  Check_default.typeOf.number.greaterThanOrEquals("maximumSpeed", maximumSpeed, 0);
+  Check_default.typeOf.number.greaterThanOrEquals("smoothTime", smoothTime, 1e-4);
+  Check_default.typeOf.object("result", result);
+  smoothTime = Math.max(1e-4, smoothTime);
+  const omega = 2 / smoothTime;
+  const x = omega * deltaTime;
+  const exp = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x);
+  const maxChange = maximumSpeed * smoothTime;
+  let change = p - q;
+  change = CesiumMath.clamp(change, -maxChange, maxChange);
+  const target = p - change;
+  const temp = (velocity + omega * change) * deltaTime;
+  velocity = (velocity - omega * temp) * exp;
+  result.value = target + (change + temp) * exp;
+  result.velocity = velocity;
+  return result;
+};
+CesiumMath.PI = Math.PI;
+CesiumMath.ONE_OVER_PI = 1 / Math.PI;
+CesiumMath.PI_OVER_TWO = Math.PI / 2;
+CesiumMath.PI_OVER_THREE = Math.PI / 3;
+CesiumMath.PI_OVER_FOUR = Math.PI / 4;
+CesiumMath.PI_OVER_SIX = Math.PI / 6;
+CesiumMath.THREE_PI_OVER_TWO = 3 * Math.PI / 2;
+CesiumMath.TWO_PI = 2 * Math.PI;
+CesiumMath.ONE_OVER_TWO_PI = 1 / (2 * Math.PI);
+CesiumMath.RADIANS_PER_DEGREE = Math.PI / 180;
+CesiumMath.DEGREES_PER_RADIAN = 180 / Math.PI;
+CesiumMath.RADIANS_PER_ARCSECOND = CesiumMath.RADIANS_PER_DEGREE / 3600;
+CesiumMath.toRadians = function(degrees) {
+  if (!defined_default(degrees)) {
+    throw new DeveloperError_default("degrees is required.");
+  }
+  return degrees * CesiumMath.RADIANS_PER_DEGREE;
+};
+CesiumMath.toDegrees = function(radians) {
+  if (!defined_default(radians)) {
+    throw new DeveloperError_default("radians is required.");
+  }
+  return radians * CesiumMath.DEGREES_PER_RADIAN;
+};
+CesiumMath.convertLongitudeRange = function(angle) {
+  if (!defined_default(angle)) {
+    throw new DeveloperError_default("angle is required.");
+  }
+  const twoPi = CesiumMath.TWO_PI;
+  const simplified = angle - Math.floor(angle / twoPi) * twoPi;
+  if (simplified < -Math.PI) {
+    return simplified + twoPi;
+  }
+  if (simplified >= Math.PI) {
+    return simplified - twoPi;
+  }
+  return simplified;
+};
+CesiumMath.clampToLatitudeRange = function(angle) {
+  if (!defined_default(angle)) {
+    throw new DeveloperError_default("angle is required.");
+  }
+  return CesiumMath.clamp(
+    angle,
+    -1 * CesiumMath.PI_OVER_TWO,
+    CesiumMath.PI_OVER_TWO
+  );
+};
+CesiumMath.negativePiToPi = function(angle) {
+  if (!defined_default(angle)) {
+    throw new DeveloperError_default("angle is required.");
+  }
+  if (angle >= -CesiumMath.PI && angle <= CesiumMath.PI) {
+    return angle;
+  }
+  return CesiumMath.zeroToTwoPi(angle + CesiumMath.PI) - CesiumMath.PI;
+};
+CesiumMath.zeroToTwoPi = function(angle) {
+  if (!defined_default(angle)) {
+    throw new DeveloperError_default("angle is required.");
+  }
+  if (angle >= 0 && angle <= CesiumMath.TWO_PI) {
+    return angle;
+  }
+  const mod = CesiumMath.mod(angle, CesiumMath.TWO_PI);
+  if (Math.abs(mod) < CesiumMath.EPSILON14 && Math.abs(angle) > CesiumMath.EPSILON14) {
+    return CesiumMath.TWO_PI;
+  }
+  return mod;
+};
+CesiumMath.mod = function(m, n) {
+  if (!defined_default(m)) {
+    throw new DeveloperError_default("m is required.");
+  }
+  if (!defined_default(n)) {
+    throw new DeveloperError_default("n is required.");
+  }
+  if (n === 0) {
+    throw new DeveloperError_default("divisor cannot be 0.");
+  }
+  if (CesiumMath.sign(m) === CesiumMath.sign(n) && Math.abs(m) < Math.abs(n)) {
+    return m;
+  }
+  return (m % n + n) % n;
+};
+CesiumMath.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
+  if (!defined_default(left)) {
+    throw new DeveloperError_default("left is required.");
+  }
+  if (!defined_default(right)) {
+    throw new DeveloperError_default("right is required.");
+  }
+  relativeEpsilon = relativeEpsilon ?? 0;
+  absoluteEpsilon = absoluteEpsilon ?? relativeEpsilon;
+  const absDiff = Math.abs(left - right);
+  return absDiff <= absoluteEpsilon || absDiff <= relativeEpsilon * Math.max(Math.abs(left), Math.abs(right));
+};
+CesiumMath.lessThan = function(left, right, absoluteEpsilon) {
+  if (!defined_default(left)) {
+    throw new DeveloperError_default("first is required.");
+  }
+  if (!defined_default(right)) {
+    throw new DeveloperError_default("second is required.");
+  }
+  if (!defined_default(absoluteEpsilon)) {
+    throw new DeveloperError_default("absoluteEpsilon is required.");
+  }
+  return left - right < -absoluteEpsilon;
+};
+CesiumMath.lessThanOrEquals = function(left, right, absoluteEpsilon) {
+  if (!defined_default(left)) {
+    throw new DeveloperError_default("first is required.");
+  }
+  if (!defined_default(right)) {
+    throw new DeveloperError_default("second is required.");
+  }
+  if (!defined_default(absoluteEpsilon)) {
+    throw new DeveloperError_default("absoluteEpsilon is required.");
+  }
+  return left - right < absoluteEpsilon;
+};
+CesiumMath.greaterThan = function(left, right, absoluteEpsilon) {
+  if (!defined_default(left)) {
+    throw new DeveloperError_default("first is required.");
+  }
+  if (!defined_default(right)) {
+    throw new DeveloperError_default("second is required.");
+  }
+  if (!defined_default(absoluteEpsilon)) {
+    throw new DeveloperError_default("absoluteEpsilon is required.");
+  }
+  return left - right > absoluteEpsilon;
+};
+CesiumMath.greaterThanOrEquals = function(left, right, absoluteEpsilon) {
+  if (!defined_default(left)) {
+    throw new DeveloperError_default("first is required.");
+  }
+  if (!defined_default(right)) {
+    throw new DeveloperError_default("second is required.");
+  }
+  if (!defined_default(absoluteEpsilon)) {
+    throw new DeveloperError_default("absoluteEpsilon is required.");
+  }
+  return left - right > -absoluteEpsilon;
+};
+var factorials = [1];
+CesiumMath.factorial = function(n) {
+  if (typeof n !== "number" || n < 0) {
+    throw new DeveloperError_default(
+      "A number greater than or equal to 0 is required."
+    );
+  }
+  const length = factorials.length;
+  if (n >= length) {
+    let sum = factorials[length - 1];
+    for (let i = length; i <= n; i++) {
+      const next = sum * i;
+      factorials.push(next);
+      sum = next;
+    }
+  }
+  return factorials[n];
+};
+CesiumMath.incrementWrap = function(n, maximumValue, minimumValue) {
+  minimumValue = minimumValue ?? 0;
+  if (!defined_default(n)) {
+    throw new DeveloperError_default("n is required.");
+  }
+  if (maximumValue <= minimumValue) {
+    throw new DeveloperError_default("maximumValue must be greater than minimumValue.");
+  }
+  ++n;
+  if (n > maximumValue) {
+    n = minimumValue;
+  }
+  return n;
+};
+CesiumMath.isPowerOfTwo = function(n) {
+  if (typeof n !== "number" || n < 0 || n > 4294967295) {
+    throw new DeveloperError_default("A number between 0 and (2^32)-1 is required.");
+  }
+  return n !== 0 && (n & n - 1) === 0;
+};
+CesiumMath.nextPowerOfTwo = function(n) {
+  if (typeof n !== "number" || n < 0 || n > 2147483648) {
+    throw new DeveloperError_default("A number between 0 and 2^31 is required.");
+  }
+  --n;
+  n |= n >> 1;
+  n |= n >> 2;
+  n |= n >> 4;
+  n |= n >> 8;
+  n |= n >> 16;
+  ++n;
+  return n;
+};
+CesiumMath.previousPowerOfTwo = function(n) {
+  if (typeof n !== "number" || n < 0 || n > 4294967295) {
+    throw new DeveloperError_default("A number between 0 and (2^32)-1 is required.");
+  }
+  n |= n >> 1;
+  n |= n >> 2;
+  n |= n >> 4;
+  n |= n >> 8;
+  n |= n >> 16;
+  n |= n >> 32;
+  n = (n >>> 0) - (n >>> 1);
+  return n;
+};
+CesiumMath.clamp = function(value, min, max) {
+  Check_default.typeOf.number("value", value);
+  Check_default.typeOf.number("min", min);
+  Check_default.typeOf.number("max", max);
+  return value < min ? min : value > max ? max : value;
+};
+var randomNumberGenerator = new import_mersenne_twister.default();
+CesiumMath.setRandomNumberSeed = function(seed) {
+  if (!defined_default(seed)) {
+    throw new DeveloperError_default("seed is required.");
+  }
+  randomNumberGenerator = new import_mersenne_twister.default(seed);
+};
+CesiumMath.nextRandomNumber = function() {
+  return randomNumberGenerator.random();
+};
+CesiumMath.randomBetween = function(min, max) {
+  return CesiumMath.nextRandomNumber() * (max - min) + min;
+};
+CesiumMath.acosClamped = function(value) {
+  if (!defined_default(value)) {
+    throw new DeveloperError_default("value is required.");
+  }
+  return Math.acos(CesiumMath.clamp(value, -1, 1));
+};
+CesiumMath.asinClamped = function(value) {
+  if (!defined_default(value)) {
+    throw new DeveloperError_default("value is required.");
+  }
+  return Math.asin(CesiumMath.clamp(value, -1, 1));
+};
+CesiumMath.chordLength = function(angle, radius) {
+  if (!defined_default(angle)) {
+    throw new DeveloperError_default("angle is required.");
+  }
+  if (!defined_default(radius)) {
+    throw new DeveloperError_default("radius is required.");
+  }
+  return 2 * radius * Math.sin(angle * 0.5);
+};
+CesiumMath.logBase = function(number, base) {
+  if (!defined_default(number)) {
+    throw new DeveloperError_default("number is required.");
+  }
+  if (!defined_default(base)) {
+    throw new DeveloperError_default("base is required.");
+  }
+  return Math.log(number) / Math.log(base);
+};
+CesiumMath.cbrt = Math.cbrt ?? function cbrt(number) {
+  const result = Math.pow(Math.abs(number), 1 / 3);
+  return number < 0 ? -result : result;
+};
+CesiumMath.log2 = Math.log2 ?? function log2(number) {
+  return Math.log(number) * Math.LOG2E;
+};
+CesiumMath.fog = function(distanceToCamera, density) {
+  const scalar = distanceToCamera * density;
+  return 1 - Math.exp(-(scalar * scalar));
+};
+CesiumMath.fastApproximateAtan = function(x) {
+  Check_default.typeOf.number("x", x);
+  return x * (-0.1784 * Math.abs(x) - 0.0663 * x * x + 1.0301);
+};
+CesiumMath.fastApproximateAtan2 = function(x, y) {
+  Check_default.typeOf.number("x", x);
+  Check_default.typeOf.number("y", y);
+  let opposite;
+  let t = Math.abs(x);
+  opposite = Math.abs(y);
+  const adjacent = Math.max(t, opposite);
+  opposite = Math.min(t, opposite);
+  const oppositeOverAdjacent = opposite / adjacent;
+  if (isNaN(oppositeOverAdjacent)) {
+    throw new DeveloperError_default("either x or y must be nonzero");
+  }
+  t = CesiumMath.fastApproximateAtan(oppositeOverAdjacent);
+  t = Math.abs(y) > Math.abs(x) ? CesiumMath.PI_OVER_TWO - t : t;
+  t = x < 0 ? CesiumMath.PI - t : t;
+  t = y < 0 ? -t : t;
+  return t;
+};
+var Math_default = CesiumMath;
+
+export {
+  Math_default
+};

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

@@ -0,0 +1,140 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.144.0
+ *
+ * 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-YGFVAGYF.js";
+import {
+  Math_default
+} from "./chunk-ACTVJHSP.js";
+import {
+  DeveloperError_default
+} from "./chunk-XLQZNQ4Z.js";
+import {
+  defined_default
+} from "./chunk-PCL3Y7H5.js";
+
+// packages/engine/Source/Core/IndexDatatype.js
+var IndexDatatype = {
+  /**
+   * 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 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 unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
+   * of an element in <code>Uint32Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT
+};
+IndexDatatype.getSizeInBytes = function(indexDatatype) {
+  switch (indexDatatype) {
+    case IndexDatatype.UNSIGNED_BYTE:
+      return Uint8Array.BYTES_PER_ELEMENT;
+    case IndexDatatype.UNSIGNED_SHORT:
+      return Uint16Array.BYTES_PER_ELEMENT;
+    case IndexDatatype.UNSIGNED_INT:
+      return Uint32Array.BYTES_PER_ELEMENT;
+  }
+  throw new DeveloperError_default(
+    "indexDatatype is required and must be a valid IndexDatatype constant."
+  );
+};
+IndexDatatype.fromSizeInBytes = function(sizeInBytes) {
+  switch (sizeInBytes) {
+    case 2:
+      return IndexDatatype.UNSIGNED_SHORT;
+    case 4:
+      return IndexDatatype.UNSIGNED_INT;
+    case 1:
+      return IndexDatatype.UNSIGNED_BYTE;
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default(
+        "Size in bytes cannot be mapped to an IndexDatatype"
+      );
+  }
+};
+IndexDatatype.validate = function(indexDatatype) {
+  return defined_default(indexDatatype) && (indexDatatype === IndexDatatype.UNSIGNED_BYTE || indexDatatype === IndexDatatype.UNSIGNED_SHORT || indexDatatype === IndexDatatype.UNSIGNED_INT);
+};
+IndexDatatype.createTypedArray = function(numberOfVertices, indicesLengthOrArray) {
+  if (!defined_default(numberOfVertices)) {
+    throw new DeveloperError_default("numberOfVertices is required.");
+  }
+  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
+    return new Uint32Array(indicesLengthOrArray);
+  }
+  return new Uint16Array(indicesLengthOrArray);
+};
+IndexDatatype.createTypedArrayFromArrayBuffer = function(numberOfVertices, sourceArray, byteOffset, length) {
+  if (!defined_default(numberOfVertices)) {
+    throw new DeveloperError_default("numberOfVertices is required.");
+  }
+  if (!defined_default(sourceArray)) {
+    throw new DeveloperError_default("sourceArray is required.");
+  }
+  if (!defined_default(byteOffset)) {
+    throw new DeveloperError_default("byteOffset is required.");
+  }
+  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
+    return new Uint32Array(sourceArray, byteOffset, length);
+  }
+  return new Uint16Array(sourceArray, byteOffset, length);
+};
+IndexDatatype.fromTypedArray = function(array) {
+  if (array instanceof Uint8Array) {
+    return IndexDatatype.UNSIGNED_BYTE;
+  }
+  if (array instanceof Uint16Array) {
+    return IndexDatatype.UNSIGNED_SHORT;
+  }
+  if (array instanceof Uint32Array) {
+    return IndexDatatype.UNSIGNED_INT;
+  }
+  throw new DeveloperError_default(
+    "array must be a Uint8Array, Uint16Array, or Uint32Array."
+  );
+};
+Object.freeze(IndexDatatype);
+var IndexDatatype_default = IndexDatatype;
+
+export {
+  IndexDatatype_default
+};