deeptwins-cesium-engine 0.0.37 → 0.0.39

package/Build/Workers/chunk-IE4WZF5B.js

@@ -0,0 +1,220 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.37
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  GeographicProjection_default,
+  Intersect_default
+} from "./chunk-LFYSBTBW.js";
+import {
+  Rectangle_default
+} from "./chunk-X2PKPXPZ.js";
+import {
+  Cartesian2_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-O3PMNFMM.js";
+import {
+  defaultValue_default
+} from "./chunk-XATYJMDJ.js";
+import {
+  Check_default
+} from "./chunk-ZQ7S66XP.js";
+import {
+  defined_default
+} from "./chunk-5C4JSXR6.js";
+
+// packages/engine/Source/Core/BoundingRectangle.js
+function BoundingRectangle(x, y, width, height) {
+  this.x = defaultValue_default(x, 0);
+  this.y = defaultValue_default(y, 0);
+  this.width = defaultValue_default(width, 0);
+  this.height = defaultValue_default(height, 0);
+}
+BoundingRectangle.packedLength = 4;
+BoundingRectangle.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  array[startingIndex++] = value.x;
+  array[startingIndex++] = value.y;
+  array[startingIndex++] = value.width;
+  array[startingIndex] = value.height;
+  return array;
+};
+BoundingRectangle.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  result.x = array[startingIndex++];
+  result.y = array[startingIndex++];
+  result.width = array[startingIndex++];
+  result.height = array[startingIndex];
+  return result;
+};
+BoundingRectangle.fromPoints = function(positions, result) {
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  if (!defined_default(positions) || positions.length === 0) {
+    result.x = 0;
+    result.y = 0;
+    result.width = 0;
+    result.height = 0;
+    return result;
+  }
+  const length = positions.length;
+  let minimumX = positions[0].x;
+  let minimumY = positions[0].y;
+  let maximumX = positions[0].x;
+  let maximumY = positions[0].y;
+  for (let i = 1; i < length; i++) {
+    const p = positions[i];
+    const x = p.x;
+    const y = p.y;
+    minimumX = Math.min(x, minimumX);
+    maximumX = Math.max(x, maximumX);
+    minimumY = Math.min(y, minimumY);
+    maximumY = Math.max(y, maximumY);
+  }
+  result.x = minimumX;
+  result.y = minimumY;
+  result.width = maximumX - minimumX;
+  result.height = maximumY - minimumY;
+  return result;
+};
+var defaultProjection = new GeographicProjection_default();
+var fromRectangleLowerLeft = new Cartographic_default();
+var fromRectangleUpperRight = new Cartographic_default();
+BoundingRectangle.fromRectangle = function(rectangle, projection, result) {
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  if (!defined_default(rectangle)) {
+    result.x = 0;
+    result.y = 0;
+    result.width = 0;
+    result.height = 0;
+    return result;
+  }
+  defaultProjection._ellipsoid = Ellipsoid_default.default;
+  projection = defaultValue_default(projection, defaultProjection);
+  const lowerLeft = projection.project(
+    Rectangle_default.southwest(rectangle, fromRectangleLowerLeft)
+  );
+  const upperRight = projection.project(
+    Rectangle_default.northeast(rectangle, fromRectangleUpperRight)
+  );
+  Cartesian2_default.subtract(upperRight, lowerLeft, upperRight);
+  result.x = lowerLeft.x;
+  result.y = lowerLeft.y;
+  result.width = upperRight.x;
+  result.height = upperRight.y;
+  return result;
+};
+BoundingRectangle.clone = function(rectangle, result) {
+  if (!defined_default(rectangle)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new BoundingRectangle(
+      rectangle.x,
+      rectangle.y,
+      rectangle.width,
+      rectangle.height
+    );
+  }
+  result.x = rectangle.x;
+  result.y = rectangle.y;
+  result.width = rectangle.width;
+  result.height = rectangle.height;
+  return result;
+};
+BoundingRectangle.union = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  const lowerLeftX = Math.min(left.x, right.x);
+  const lowerLeftY = Math.min(left.y, right.y);
+  const upperRightX = Math.max(left.x + left.width, right.x + right.width);
+  const upperRightY = Math.max(left.y + left.height, right.y + right.height);
+  result.x = lowerLeftX;
+  result.y = lowerLeftY;
+  result.width = upperRightX - lowerLeftX;
+  result.height = upperRightY - lowerLeftY;
+  return result;
+};
+BoundingRectangle.expand = function(rectangle, point, result) {
+  Check_default.typeOf.object("rectangle", rectangle);
+  Check_default.typeOf.object("point", point);
+  result = BoundingRectangle.clone(rectangle, result);
+  const width = point.x - result.x;
+  const height = point.y - result.y;
+  if (width > result.width) {
+    result.width = width;
+  } else if (width < 0) {
+    result.width -= width;
+    result.x = point.x;
+  }
+  if (height > result.height) {
+    result.height = height;
+  } else if (height < 0) {
+    result.height -= height;
+    result.y = point.y;
+  }
+  return result;
+};
+BoundingRectangle.intersect = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  const leftX = left.x;
+  const leftY = left.y;
+  const rightX = right.x;
+  const rightY = right.y;
+  if (!(leftX > rightX + right.width || leftX + left.width < rightX || leftY + left.height < rightY || leftY > rightY + right.height)) {
+    return Intersect_default.INTERSECTING;
+  }
+  return Intersect_default.OUTSIDE;
+};
+BoundingRectangle.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y && left.width === right.width && left.height === right.height;
+};
+BoundingRectangle.prototype.clone = function(result) {
+  return BoundingRectangle.clone(this, result);
+};
+BoundingRectangle.prototype.intersect = function(right) {
+  return BoundingRectangle.intersect(this, right);
+};
+BoundingRectangle.prototype.equals = function(right) {
+  return BoundingRectangle.equals(this, right);
+};
+var BoundingRectangle_default = BoundingRectangle;
+
+export {
+  BoundingRectangle_default
+};

package/Build/Workers/chunk-IXVT26OF.js

@@ -0,0 +1,163 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.38
+ *
+ * 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 {
+  defined_default
+} from "./chunk-P76UBIMX.js";
+
+// packages/engine/Source/Core/DeveloperError.js
+function DeveloperError(message) {
+  this.name = "DeveloperError";
+  this.message = message;
+  let stack;
+  try {
+    throw new Error();
+  } catch (e) {
+    stack = e.stack;
+  }
+  this.stack = stack;
+}
+if (defined_default(Object.create)) {
+  DeveloperError.prototype = Object.create(Error.prototype);
+  DeveloperError.prototype.constructor = DeveloperError;
+}
+DeveloperError.prototype.toString = function() {
+  let str = `${this.name}: ${this.message}`;
+  if (defined_default(this.stack)) {
+    str += `
+${this.stack.toString()}`;
+  }
+  return str;
+};
+DeveloperError.throwInstantiationError = function() {
+  throw new DeveloperError(
+    "This function defines an interface and should not be called directly."
+  );
+};
+var DeveloperError_default = DeveloperError;
+
+// packages/engine/Source/Core/Check.js
+var Check = {};
+Check.typeOf = {};
+function getUndefinedErrorMessage(name) {
+  return `${name} is required, actual value was undefined`;
+}
+function getFailedTypeErrorMessage(actual, expected, name) {
+  return `Expected ${name} to be typeof ${expected}, actual typeof was ${actual}`;
+}
+Check.defined = function(name, test) {
+  if (!defined_default(test)) {
+    throw new DeveloperError_default(getUndefinedErrorMessage(name));
+  }
+};
+Check.typeOf.func = function(name, test) {
+  if (typeof test !== "function") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "function", name)
+    );
+  }
+};
+Check.typeOf.string = function(name, test) {
+  if (typeof test !== "string") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "string", name)
+    );
+  }
+};
+Check.typeOf.number = function(name, test) {
+  if (typeof test !== "number") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "number", name)
+    );
+  }
+};
+Check.typeOf.number.lessThan = function(name, test, limit) {
+  Check.typeOf.number(name, test);
+  if (test >= limit) {
+    throw new DeveloperError_default(
+      `Expected ${name} to be less than ${limit}, actual value was ${test}`
+    );
+  }
+};
+Check.typeOf.number.lessThanOrEquals = function(name, test, limit) {
+  Check.typeOf.number(name, test);
+  if (test > limit) {
+    throw new DeveloperError_default(
+      `Expected ${name} to be less than or equal to ${limit}, actual value was ${test}`
+    );
+  }
+};
+Check.typeOf.number.greaterThan = function(name, test, limit) {
+  Check.typeOf.number(name, test);
+  if (test <= limit) {
+    throw new DeveloperError_default(
+      `Expected ${name} to be greater than ${limit}, actual value was ${test}`
+    );
+  }
+};
+Check.typeOf.number.greaterThanOrEquals = function(name, test, limit) {
+  Check.typeOf.number(name, test);
+  if (test < limit) {
+    throw new DeveloperError_default(
+      `Expected ${name} to be greater than or equal to ${limit}, actual value was ${test}`
+    );
+  }
+};
+Check.typeOf.object = function(name, test) {
+  if (typeof test !== "object") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "object", name)
+    );
+  }
+};
+Check.typeOf.bool = function(name, test) {
+  if (typeof test !== "boolean") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "boolean", name)
+    );
+  }
+};
+Check.typeOf.bigint = function(name, test) {
+  if (typeof test !== "bigint") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "bigint", name)
+    );
+  }
+};
+Check.typeOf.number.equals = function(name1, name2, test1, test2) {
+  Check.typeOf.number(name1, test1);
+  Check.typeOf.number(name2, test2);
+  if (test1 !== test2) {
+    throw new DeveloperError_default(
+      `${name1} must be equal to ${name2}, the actual values are ${test1} and ${test2}`
+    );
+  }
+};
+var Check_default = Check;
+
+export {
+  DeveloperError_default,
+  Check_default
+};

package/Build/Workers/chunk-IYRRJ6HP.js

@@ -0,0 +1,262 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.38
+ *
+ * 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-ACV745U5.js";
+import {
+  defaultValue_default
+} from "./chunk-UBCK7AIW.js";
+import {
+  DeveloperError_default
+} from "./chunk-IXVT26OF.js";
+import {
+  defined_default
+} from "./chunk-P76UBIMX.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 = defaultValue_default(byteOffset, 0);
+  length = defaultValue_default(
+    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.");
+  }
+};
+var ComponentDatatype_default = Object.freeze(ComponentDatatype);
+
+export {
+  ComponentDatatype_default
+};

package/Build/Workers/chunk-JGB65JJZ.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.38
+ *
+ * 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 {
+  defined_default
+} from "./chunk-P76UBIMX.js";
+
+// packages/engine/Source/Core/RuntimeError.js
+function RuntimeError(message) {
+  this.name = "RuntimeError";
+  this.message = message;
+  let stack;
+  try {
+    throw new Error();
+  } catch (e) {
+    stack = e.stack;
+  }
+  this.stack = stack;
+}
+if (defined_default(Object.create)) {
+  RuntimeError.prototype = Object.create(Error.prototype);
+  RuntimeError.prototype.constructor = RuntimeError;
+}
+RuntimeError.prototype.toString = function() {
+  let str = `${this.name}: ${this.message}`;
+  if (defined_default(this.stack)) {
+    str += `
+${this.stack.toString()}`;
+  }
+  return str;
+};
+var RuntimeError_default = RuntimeError;
+
+export {
+  RuntimeError_default
+};