@cesium/engine 3.0.2 → 4.0.0

package/Build/Workers/createSphereGeometry.js

@@ -1,123 +1,117 @@
-define(['./defaultValue-fe22d8c0', './Matrix3-41c58dde', './Check-6ede7e26', './EllipsoidGeometry-07e99d2d', './VertexFormat-030f11ff', './Math-0a2ac845', './Transforms-b527bb09', './Matrix2-e1298525', './RuntimeError-ef395448', './combine-d9581036', './ComponentDatatype-cf1fa08e', './WebGLConstants-0b1ce7ba', './GeometryAttribute-a5b6275b', './GeometryAttributes-ad136444', './GeometryOffsetAttribute-9ad0019c', './IndexDatatype-2643aa47'], (function (defaultValue, Matrix3, Check, EllipsoidGeometry, VertexFormat, Math, Transforms, Matrix2, RuntimeError, combine, ComponentDatatype, WebGLConstants, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, IndexDatatype) { 'use strict';
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.109
+ *
+ * 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.
+ */
 
-  /**
-   * A description of a sphere centered at the origin.
-   *
-   * @alias SphereGeometry
-   * @constructor
-   *
-   * @param {object} [options] Object with the following properties:
-   * @param {number} [options.radius=1.0] The radius of the sphere.
-   * @param {number} [options.stackPartitions=64] The number of times to partition the ellipsoid into stacks.
-   * @param {number} [options.slicePartitions=64] The number of times to partition the ellipsoid into radial slices.
-   * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
-   *
-   * @exception {DeveloperError} options.slicePartitions cannot be less than three.
-   * @exception {DeveloperError} options.stackPartitions cannot be less than three.
-   *
-   * @see SphereGeometry#createGeometry
-   *
-   * @example
-   * const sphere = new Cesium.SphereGeometry({
-   *   radius : 100.0,
-   *   vertexFormat : Cesium.VertexFormat.POSITION_ONLY
-   * });
-   * const geometry = Cesium.SphereGeometry.createGeometry(sphere);
-   */
-  function SphereGeometry(options) {
-    const radius = defaultValue.defaultValue(options.radius, 1.0);
-    const radii = new Matrix3.Cartesian3(radius, radius, radius);
-    const ellipsoidOptions = {
-      radii: radii,
-      stackPartitions: options.stackPartitions,
-      slicePartitions: options.slicePartitions,
-      vertexFormat: options.vertexFormat,
-    };
+import {
+  EllipsoidGeometry_default
+} from "./chunk-TVYIHH4V.js";
+import "./chunk-A6EA6KIE.js";
+import {
+  VertexFormat_default
+} from "./chunk-2NLMZNJI.js";
+import "./chunk-TF5D2H7B.js";
+import "./chunk-N5MMDSD2.js";
+import "./chunk-UGZGTV5K.js";
+import "./chunk-5U4UHRZ2.js";
+import "./chunk-FE2XG3SS.js";
+import "./chunk-PW5CA4MJ.js";
+import "./chunk-KAFF2QX3.js";
+import {
+  Cartesian3_default
+} from "./chunk-XJCTFTBM.js";
+import "./chunk-PWDYKCNC.js";
+import "./chunk-527JG4D7.js";
+import "./chunk-FVDTKX3F.js";
+import {
+  defaultValue_default
+} from "./chunk-BT6YIL2N.js";
+import {
+  Check_default
+} from "./chunk-UN7AK64D.js";
+import {
+  defined_default
+} from "./chunk-QVJ6IRKV.js";
 
-    this._ellipsoidGeometry = new EllipsoidGeometry.EllipsoidGeometry(ellipsoidOptions);
-    this._workerName = "createSphereGeometry";
-  }
-
-  /**
-   * The number of elements used to pack the object into an array.
-   * @type {number}
-   */
-  SphereGeometry.packedLength = EllipsoidGeometry.EllipsoidGeometry.packedLength;
-
-  /**
-   * Stores the provided instance into the provided array.
-   *
-   * @param {SphereGeometry} value The value to pack.
-   * @param {number[]} array The array to pack into.
-   * @param {number} [startingIndex=0] The index into the array at which to start packing the elements.
-   *
-   * @returns {number[]} The array that was packed into
-   */
-  SphereGeometry.pack = function (value, array, startingIndex) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.typeOf.object("value", value);
-    //>>includeEnd('debug');
-
-    return EllipsoidGeometry.EllipsoidGeometry.pack(value._ellipsoidGeometry, array, startingIndex);
+// packages/engine/Source/Core/SphereGeometry.js
+function SphereGeometry(options) {
+  const radius = defaultValue_default(options.radius, 1);
+  const radii = new Cartesian3_default(radius, radius, radius);
+  const ellipsoidOptions = {
+    radii,
+    stackPartitions: options.stackPartitions,
+    slicePartitions: options.slicePartitions,
+    vertexFormat: options.vertexFormat
   };
-
-  const scratchEllipsoidGeometry = new EllipsoidGeometry.EllipsoidGeometry();
-  const scratchOptions = {
-    radius: undefined,
-    radii: new Matrix3.Cartesian3(),
-    vertexFormat: new VertexFormat.VertexFormat(),
-    stackPartitions: undefined,
-    slicePartitions: undefined,
-  };
-
-  /**
-   * Retrieves an instance from a packed array.
-   *
-   * @param {number[]} array The packed array.
-   * @param {number} [startingIndex=0] The starting index of the element to be unpacked.
-   * @param {SphereGeometry} [result] The object into which to store the result.
-   * @returns {SphereGeometry} The modified result parameter or a new SphereGeometry instance if one was not provided.
-   */
-  SphereGeometry.unpack = function (array, startingIndex, result) {
-    const ellipsoidGeometry = EllipsoidGeometry.EllipsoidGeometry.unpack(
-      array,
-      startingIndex,
-      scratchEllipsoidGeometry
-    );
-    scratchOptions.vertexFormat = VertexFormat.VertexFormat.clone(
-      ellipsoidGeometry._vertexFormat,
-      scratchOptions.vertexFormat
-    );
-    scratchOptions.stackPartitions = ellipsoidGeometry._stackPartitions;
-    scratchOptions.slicePartitions = ellipsoidGeometry._slicePartitions;
-
-    if (!defaultValue.defined(result)) {
-      scratchOptions.radius = ellipsoidGeometry._radii.x;
-      return new SphereGeometry(scratchOptions);
-    }
-
-    Matrix3.Cartesian3.clone(ellipsoidGeometry._radii, scratchOptions.radii);
-    result._ellipsoidGeometry = new EllipsoidGeometry.EllipsoidGeometry(scratchOptions);
-    return result;
-  };
-
-  /**
-   * Computes the geometric representation of a sphere, including its vertices, indices, and a bounding sphere.
-   *
-   * @param {SphereGeometry} sphereGeometry A description of the sphere.
-   * @returns {Geometry|undefined} The computed vertices and indices.
-   */
-  SphereGeometry.createGeometry = function (sphereGeometry) {
-    return EllipsoidGeometry.EllipsoidGeometry.createGeometry(sphereGeometry._ellipsoidGeometry);
-  };
-
-  function createSphereGeometry(sphereGeometry, offset) {
-    if (defaultValue.defined(offset)) {
-      sphereGeometry = SphereGeometry.unpack(sphereGeometry, offset);
-    }
-    return SphereGeometry.createGeometry(sphereGeometry);
+  this._ellipsoidGeometry = new EllipsoidGeometry_default(ellipsoidOptions);
+  this._workerName = "createSphereGeometry";
+}
+SphereGeometry.packedLength = EllipsoidGeometry_default.packedLength;
+SphereGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  return EllipsoidGeometry_default.pack(value._ellipsoidGeometry, array, startingIndex);
+};
+var scratchEllipsoidGeometry = new EllipsoidGeometry_default();
+var scratchOptions = {
+  radius: void 0,
+  radii: new Cartesian3_default(),
+  vertexFormat: new VertexFormat_default(),
+  stackPartitions: void 0,
+  slicePartitions: void 0
+};
+SphereGeometry.unpack = function(array, startingIndex, result) {
+  const ellipsoidGeometry = EllipsoidGeometry_default.unpack(
+    array,
+    startingIndex,
+    scratchEllipsoidGeometry
+  );
+  scratchOptions.vertexFormat = VertexFormat_default.clone(
+    ellipsoidGeometry._vertexFormat,
+    scratchOptions.vertexFormat
+  );
+  scratchOptions.stackPartitions = ellipsoidGeometry._stackPartitions;
+  scratchOptions.slicePartitions = ellipsoidGeometry._slicePartitions;
+  if (!defined_default(result)) {
+    scratchOptions.radius = ellipsoidGeometry._radii.x;
+    return new SphereGeometry(scratchOptions);
   }
+  Cartesian3_default.clone(ellipsoidGeometry._radii, scratchOptions.radii);
+  result._ellipsoidGeometry = new EllipsoidGeometry_default(scratchOptions);
+  return result;
+};
+SphereGeometry.createGeometry = function(sphereGeometry) {
+  return EllipsoidGeometry_default.createGeometry(sphereGeometry._ellipsoidGeometry);
+};
+var SphereGeometry_default = SphereGeometry;
 
-  return createSphereGeometry;
-
-}));
+// packages/engine/Source/Workers/createSphereGeometry.js
+function createSphereGeometry(sphereGeometry, offset) {
+  if (defined_default(offset)) {
+    sphereGeometry = SphereGeometry_default.unpack(sphereGeometry, offset);
+  }
+  return SphereGeometry_default.createGeometry(sphereGeometry);
+}
+var createSphereGeometry_default = createSphereGeometry;
+export {
+  createSphereGeometry_default as default
+};

package/Build/Workers/createSphereOutlineGeometry.js

@@ -1,126 +1,117 @@
-define(['./defaultValue-fe22d8c0', './Matrix3-41c58dde', './Check-6ede7e26', './EllipsoidOutlineGeometry-ba5c7ee2', './Math-0a2ac845', './Transforms-b527bb09', './Matrix2-e1298525', './RuntimeError-ef395448', './combine-d9581036', './ComponentDatatype-cf1fa08e', './WebGLConstants-0b1ce7ba', './GeometryAttribute-a5b6275b', './GeometryAttributes-ad136444', './GeometryOffsetAttribute-9ad0019c', './IndexDatatype-2643aa47'], (function (defaultValue, Matrix3, Check, EllipsoidOutlineGeometry, Math, Transforms, Matrix2, RuntimeError, combine, ComponentDatatype, WebGLConstants, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, IndexDatatype) { 'use strict';
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.109
+ *
+ * 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.
+ */
 
-  /**
-   * A description of the outline of a sphere.
-   *
-   * @alias SphereOutlineGeometry
-   * @constructor
-   *
-   * @param {object} [options] Object with the following properties:
-   * @param {number} [options.radius=1.0] The radius of the sphere.
-   * @param {number} [options.stackPartitions=10] The count of stacks for the sphere (1 greater than the number of parallel lines).
-   * @param {number} [options.slicePartitions=8] The count of slices for the sphere (Equal to the number of radial lines).
-   * @param {number} [options.subdivisions=200] The number of points per line, determining the granularity of the curvature .
-   *
-   * @exception {DeveloperError} options.stackPartitions must be greater than or equal to one.
-   * @exception {DeveloperError} options.slicePartitions must be greater than or equal to zero.
-   * @exception {DeveloperError} options.subdivisions must be greater than or equal to zero.
-   *
-   * @example
-   * const sphere = new Cesium.SphereOutlineGeometry({
-   *   radius : 100.0,
-   *   stackPartitions : 6,
-   *   slicePartitions: 5
-   * });
-   * const geometry = Cesium.SphereOutlineGeometry.createGeometry(sphere);
-   */
-  function SphereOutlineGeometry(options) {
-    const radius = defaultValue.defaultValue(options.radius, 1.0);
-    const radii = new Matrix3.Cartesian3(radius, radius, radius);
-    const ellipsoidOptions = {
-      radii: radii,
-      stackPartitions: options.stackPartitions,
-      slicePartitions: options.slicePartitions,
-      subdivisions: options.subdivisions,
-    };
+import {
+  EllipsoidOutlineGeometry_default
+} from "./chunk-4VWUFKYW.js";
+import "./chunk-A6EA6KIE.js";
+import "./chunk-TF5D2H7B.js";
+import "./chunk-N5MMDSD2.js";
+import "./chunk-UGZGTV5K.js";
+import "./chunk-5U4UHRZ2.js";
+import "./chunk-FE2XG3SS.js";
+import "./chunk-PW5CA4MJ.js";
+import "./chunk-KAFF2QX3.js";
+import {
+  Cartesian3_default
+} from "./chunk-XJCTFTBM.js";
+import "./chunk-PWDYKCNC.js";
+import "./chunk-527JG4D7.js";
+import "./chunk-FVDTKX3F.js";
+import {
+  defaultValue_default
+} from "./chunk-BT6YIL2N.js";
+import {
+  Check_default
+} from "./chunk-UN7AK64D.js";
+import {
+  defined_default
+} from "./chunk-QVJ6IRKV.js";
 
-    this._ellipsoidGeometry = new EllipsoidOutlineGeometry.EllipsoidOutlineGeometry(ellipsoidOptions);
-    this._workerName = "createSphereOutlineGeometry";
-  }
-
-  /**
-   * The number of elements used to pack the object into an array.
-   * @type {number}
-   */
-  SphereOutlineGeometry.packedLength = EllipsoidOutlineGeometry.EllipsoidOutlineGeometry.packedLength;
-
-  /**
-   * Stores the provided instance into the provided array.
-   *
-   * @param {SphereOutlineGeometry} value The value to pack.
-   * @param {number[]} array The array to pack into.
-   * @param {number} [startingIndex=0] The index into the array at which to start packing the elements.
-   *
-   * @returns {number[]} The array that was packed into
-   */
-  SphereOutlineGeometry.pack = function (value, array, startingIndex) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.typeOf.object("value", value);
-    //>>includeEnd('debug');
-
-    return EllipsoidOutlineGeometry.EllipsoidOutlineGeometry.pack(
-      value._ellipsoidGeometry,
-      array,
-      startingIndex
-    );
+// packages/engine/Source/Core/SphereOutlineGeometry.js
+function SphereOutlineGeometry(options) {
+  const radius = defaultValue_default(options.radius, 1);
+  const radii = new Cartesian3_default(radius, radius, radius);
+  const ellipsoidOptions = {
+    radii,
+    stackPartitions: options.stackPartitions,
+    slicePartitions: options.slicePartitions,
+    subdivisions: options.subdivisions
   };
-
-  const scratchEllipsoidGeometry = new EllipsoidOutlineGeometry.EllipsoidOutlineGeometry();
-  const scratchOptions = {
-    radius: undefined,
-    radii: new Matrix3.Cartesian3(),
-    stackPartitions: undefined,
-    slicePartitions: undefined,
-    subdivisions: undefined,
-  };
-
-  /**
-   * Retrieves an instance from a packed array.
-   *
-   * @param {number[]} array The packed array.
-   * @param {number} [startingIndex=0] The starting index of the element to be unpacked.
-   * @param {SphereOutlineGeometry} [result] The object into which to store the result.
-   * @returns {SphereOutlineGeometry} The modified result parameter or a new SphereOutlineGeometry instance if one was not provided.
-   */
-  SphereOutlineGeometry.unpack = function (array, startingIndex, result) {
-    const ellipsoidGeometry = EllipsoidOutlineGeometry.EllipsoidOutlineGeometry.unpack(
-      array,
-      startingIndex,
-      scratchEllipsoidGeometry
-    );
-    scratchOptions.stackPartitions = ellipsoidGeometry._stackPartitions;
-    scratchOptions.slicePartitions = ellipsoidGeometry._slicePartitions;
-    scratchOptions.subdivisions = ellipsoidGeometry._subdivisions;
-
-    if (!defaultValue.defined(result)) {
-      scratchOptions.radius = ellipsoidGeometry._radii.x;
-      return new SphereOutlineGeometry(scratchOptions);
-    }
-
-    Matrix3.Cartesian3.clone(ellipsoidGeometry._radii, scratchOptions.radii);
-    result._ellipsoidGeometry = new EllipsoidOutlineGeometry.EllipsoidOutlineGeometry(scratchOptions);
-    return result;
-  };
-
-  /**
-   * Computes the geometric representation of an outline of a sphere, including its vertices, indices, and a bounding sphere.
-   *
-   * @param {SphereOutlineGeometry} sphereGeometry A description of the sphere outline.
-   * @returns {Geometry|undefined} The computed vertices and indices.
-   */
-  SphereOutlineGeometry.createGeometry = function (sphereGeometry) {
-    return EllipsoidOutlineGeometry.EllipsoidOutlineGeometry.createGeometry(
-      sphereGeometry._ellipsoidGeometry
-    );
-  };
-
-  function createSphereOutlineGeometry(sphereGeometry, offset) {
-    if (defaultValue.defined(offset)) {
-      sphereGeometry = SphereOutlineGeometry.unpack(sphereGeometry, offset);
-    }
-    return SphereOutlineGeometry.createGeometry(sphereGeometry);
+  this._ellipsoidGeometry = new EllipsoidOutlineGeometry_default(ellipsoidOptions);
+  this._workerName = "createSphereOutlineGeometry";
+}
+SphereOutlineGeometry.packedLength = EllipsoidOutlineGeometry_default.packedLength;
+SphereOutlineGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  return EllipsoidOutlineGeometry_default.pack(
+    value._ellipsoidGeometry,
+    array,
+    startingIndex
+  );
+};
+var scratchEllipsoidGeometry = new EllipsoidOutlineGeometry_default();
+var scratchOptions = {
+  radius: void 0,
+  radii: new Cartesian3_default(),
+  stackPartitions: void 0,
+  slicePartitions: void 0,
+  subdivisions: void 0
+};
+SphereOutlineGeometry.unpack = function(array, startingIndex, result) {
+  const ellipsoidGeometry = EllipsoidOutlineGeometry_default.unpack(
+    array,
+    startingIndex,
+    scratchEllipsoidGeometry
+  );
+  scratchOptions.stackPartitions = ellipsoidGeometry._stackPartitions;
+  scratchOptions.slicePartitions = ellipsoidGeometry._slicePartitions;
+  scratchOptions.subdivisions = ellipsoidGeometry._subdivisions;
+  if (!defined_default(result)) {
+    scratchOptions.radius = ellipsoidGeometry._radii.x;
+    return new SphereOutlineGeometry(scratchOptions);
   }
+  Cartesian3_default.clone(ellipsoidGeometry._radii, scratchOptions.radii);
+  result._ellipsoidGeometry = new EllipsoidOutlineGeometry_default(scratchOptions);
+  return result;
+};
+SphereOutlineGeometry.createGeometry = function(sphereGeometry) {
+  return EllipsoidOutlineGeometry_default.createGeometry(
+    sphereGeometry._ellipsoidGeometry
+  );
+};
+var SphereOutlineGeometry_default = SphereOutlineGeometry;
 
-  return createSphereOutlineGeometry;
-
-}));
+// packages/engine/Source/Workers/createSphereOutlineGeometry.js
+function createSphereOutlineGeometry(sphereGeometry, offset) {
+  if (defined_default(offset)) {
+    sphereGeometry = SphereOutlineGeometry_default.unpack(sphereGeometry, offset);
+  }
+  return SphereOutlineGeometry_default.createGeometry(sphereGeometry);
+}
+var createSphereOutlineGeometry_default = createSphereOutlineGeometry;
+export {
+  createSphereOutlineGeometry_default as default
+};

package/Build/Workers/createTaskProcessorWorker.js

@@ -1,127 +1,32 @@
-define(['./defaultValue-fe22d8c0'], (function (defaultValue) { 'use strict';
-
-  /**
-   * Formats an error object into a String.  If available, uses name, message, and stack
-   * properties, otherwise, falls back on toString().
-   *
-   * @function
-   *
-   * @param {*} object The item to find in the array.
-   * @returns {string} A string containing the formatted error.
-   */
-  function formatError(object) {
-    let result;
-
-    const name = object.name;
-    const message = object.message;
-    if (defaultValue.defined(name) && defaultValue.defined(message)) {
-      result = `${name}: ${message}`;
-    } else {
-      result = object.toString();
-    }
-
-    const stack = object.stack;
-    if (defaultValue.defined(stack)) {
-      result += `\n${stack}`;
-    }
-
-    return result;
-  }
-
-  // createXXXGeometry functions may return Geometry or a Promise that resolves to Geometry
-  // if the function requires access to ApproximateTerrainHeights.
-  // For fully synchronous functions, just wrapping the function call in a Promise doesn't
-  // handle errors correctly, hence try-catch
-  function callAndWrap(workerFunction, parameters, transferableObjects) {
-    let resultOrPromise;
-    try {
-      resultOrPromise = workerFunction(parameters, transferableObjects);
-      return resultOrPromise; // errors handled by Promise
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-
-  /**
-   * Creates an adapter function to allow a calculation function to operate as a Web Worker,
-   * paired with TaskProcessor, to receive tasks and return results.
-   *
-   * @function createTaskProcessorWorker
-   *
-   * @param {createTaskProcessorWorker.WorkerFunction} workerFunction The calculation function,
-   *        which takes parameters and returns a result.
-   * @returns {createTaskProcessorWorker.TaskProcessorWorkerFunction} A function that adapts the
-   *          calculation function to work as a Web Worker onmessage listener with TaskProcessor.
-   *
-   *
-   * @example
-   * function doCalculation(parameters, transferableObjects) {
-   *   // calculate some result using the inputs in parameters
-   *   return result;
-   * }
-   *
-   * return Cesium.createTaskProcessorWorker(doCalculation);
-   * // the resulting function is compatible with TaskProcessor
-   *
-   * @see TaskProcessor
-   * @see {@link http://www.w3.org/TR/workers/|Web Workers}
-   * @see {@link http://www.w3.org/TR/html5/common-dom-interfaces.html#transferable-objects|Transferable objects}
-   */
-  function createTaskProcessorWorker(workerFunction) {
-    let postMessage;
-
-    return function (event) {
-      const data = event.data;
-
-      const transferableObjects = [];
-      const responseMessage = {
-        id: data.id,
-        result: undefined,
-        error: undefined,
-      };
-
-      return Promise.resolve(
-        callAndWrap(workerFunction, data.parameters, transferableObjects)
-      )
-        .then(function (result) {
-          responseMessage.result = result;
-        })
-        .catch(function (e) {
-          if (e instanceof Error) {
-            // Errors can't be posted in a message, copy the properties
-            responseMessage.error = {
-              name: e.name,
-              message: e.message,
-              stack: e.stack,
-            };
-          } else {
-            responseMessage.error = e;
-          }
-        })
-        .finally(function () {
-          if (!defaultValue.defined(postMessage)) {
-            postMessage = defaultValue.defaultValue(self.webkitPostMessage, self.postMessage);
-          }
-
-          if (!data.canTransferArrayBuffer) {
-            transferableObjects.length = 0;
-          }
-
-          try {
-            postMessage(responseMessage, transferableObjects);
-          } catch (e) {
-            // something went wrong trying to post the message, post a simpler
-            // error that we can be sure will be cloneable
-            responseMessage.result = undefined;
-            responseMessage.error = `postMessage failed with error: ${formatError(
-            e
-          )}\n  with responseMessage: ${JSON.stringify(responseMessage)}`;
-            postMessage(responseMessage);
-          }
-        });
-    };
-  }
-
-  return createTaskProcessorWorker;
-
-}));
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.109
+ *
+ * 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 {
+  createTaskProcessorWorker_default
+} from "./chunk-U5LKG6LX.js";
+import "./chunk-QVJ6IRKV.js";
+export {
+  createTaskProcessorWorker_default as default
+};