@cesium/engine 26.2.0 → 26.3.1-wasm.0

package/Build/Workers/chunk-AUU74SIZ.js

@@ -0,0 +1,2420 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.145.1-wasm.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 {
+  TerrainProvider_default
+} from "./chunk-KOAXSU77.js";
+import {
+  EllipsoidalOccluder_default,
+  TerrainEncoding_default,
+  VerticalExaggeration_default
+} from "./chunk-TF5473GK.js";
+import {
+  WebMercatorProjection_default
+} from "./chunk-SNUWISJO.js";
+import {
+  OrientedBoundingBox_default
+} from "./chunk-MJTLGN63.js";
+import {
+  AttributeCompression_default
+} from "./chunk-UV2YC2Q5.js";
+import {
+  AxisAlignedBoundingBox_default
+} from "./chunk-ROHWZQZ5.js";
+import {
+  IntersectionTests_default,
+  Ray_default
+} from "./chunk-VC6XXI2Z.js";
+import {
+  BoundingSphere_default,
+  Interval_default
+} from "./chunk-ZIM5H2DB.js";
+import {
+  Rectangle_default,
+  Transforms_default,
+  binarySearch_default,
+  buildModuleUrl_default
+} from "./chunk-AEHANE5A.js";
+import {
+  Matrix4_default
+} from "./chunk-OQUOLQTN.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-6XUIECFB.js";
+import {
+  Cartesian2_default,
+  Cartographic_default,
+  Ellipsoid_default,
+  FeatureDetection_default
+} from "./chunk-7ZBJRQQT.js";
+import {
+  Cartesian3_default,
+  Matrix3_default
+} from "./chunk-FVLSQBPH.js";
+import {
+  Event_default,
+  isCrossOriginUrl_default
+} from "./chunk-NYKURYFR.js";
+import {
+  Frozen_default,
+  Math_default
+} from "./chunk-P4SDLSGF.js";
+import {
+  Check_default,
+  RuntimeError_default
+} from "./chunk-PPRK3XQU.js";
+import {
+  DeveloperError_default,
+  TrustedServers_default,
+  __toESM,
+  defined_default,
+  require_URI
+} from "./chunk-YUICDZKO.js";
+
+// packages/engine/Source/Scene/Axis.js
+var Axis = {
+  /**
+   * Denotes the x-axis.
+   *
+   * @type {number}
+   * @constant
+   */
+  X: 0,
+  /**
+   * Denotes the y-axis.
+   *
+   * @type {number}
+   * @constant
+   */
+  Y: 1,
+  /**
+   * Denotes the z-axis.
+   *
+   * @type {number}
+   * @constant
+   */
+  Z: 2
+};
+Axis.Y_UP_TO_Z_UP = Matrix4_default.fromRotationTranslation(
+  // Rotation about PI/2 around the X-axis
+  Matrix3_default.fromArray([1, 0, 0, 0, 0, 1, 0, -1, 0])
+);
+Axis.Z_UP_TO_Y_UP = Matrix4_default.fromRotationTranslation(
+  // Rotation about -PI/2 around the X-axis
+  Matrix3_default.fromArray([1, 0, 0, 0, 0, -1, 0, 1, 0])
+);
+Axis.X_UP_TO_Z_UP = Matrix4_default.fromRotationTranslation(
+  // Rotation about -PI/2 around the Y-axis
+  Matrix3_default.fromArray([0, 0, 1, 0, 1, 0, -1, 0, 0])
+);
+Axis.Z_UP_TO_X_UP = Matrix4_default.fromRotationTranslation(
+  // Rotation about PI/2 around the Y-axis
+  Matrix3_default.fromArray([0, 0, -1, 0, 1, 0, 1, 0, 0])
+);
+Axis.X_UP_TO_Y_UP = Matrix4_default.fromRotationTranslation(
+  // Rotation about PI/2 around the Z-axis
+  Matrix3_default.fromArray([0, 1, 0, -1, 0, 0, 0, 0, 1])
+);
+Axis.Y_UP_TO_X_UP = Matrix4_default.fromRotationTranslation(
+  // Rotation about -PI/2 around the Z-axis
+  Matrix3_default.fromArray([0, -1, 0, 1, 0, 0, 0, 0, 1])
+);
+Axis.fromName = function(name) {
+  Check_default.typeOf.string("name", name);
+  return Axis[name];
+};
+Object.freeze(Axis);
+var Axis_default = Axis;
+
+// packages/engine/Source/Scene/SceneMode.js
+var SceneMode = {
+  /**
+   * Morphing between mode, e.g., 3D to 2D.
+   *
+   * @type {number}
+   * @constant
+   */
+  MORPHING: 0,
+  /**
+   * Columbus View mode.  A 2.5D perspective view where the map is laid out
+   * flat and objects with non-zero height are drawn above it.
+   *
+   * @type {number}
+   * @constant
+   */
+  COLUMBUS_VIEW: 1,
+  /**
+   * 2D mode.  The map is viewed top-down with an orthographic projection.
+   *
+   * @type {number}
+   * @constant
+   */
+  SCENE2D: 2,
+  /**
+   * 3D mode.  A traditional 3D perspective view of the globe.
+   *
+   * @type {number}
+   * @constant
+   */
+  SCENE3D: 3
+};
+SceneMode.getMorphTime = function(value) {
+  if (value === SceneMode.SCENE3D) {
+    return 1;
+  } else if (value === SceneMode.MORPHING) {
+    return void 0;
+  }
+  return 0;
+};
+Object.freeze(SceneMode);
+var SceneMode_default = SceneMode;
+
+// packages/engine/Source/Core/TaskProcessor.js
+var import_urijs = __toESM(require_URI(), 1);
+
+// packages/engine/Source/Core/destroyObject.js
+function returnTrue() {
+  return true;
+}
+function destroyObject(object, message) {
+  message = message ?? "This object was destroyed, i.e., destroy() was called.";
+  function throwOnDestroyed() {
+    throw new DeveloperError_default(message);
+  }
+  for (const key in object) {
+    if (typeof object[key] === "function") {
+      object[key] = throwOnDestroyed;
+    }
+  }
+  object.isDestroyed = returnTrue;
+  return void 0;
+}
+var destroyObject_default = destroyObject;
+
+// packages/engine/Source/Core/WebAssemblyWorkerInitializer.js
+function getWebAssemblyLoaderConfig(workerPath, wasmOptions) {
+  const config = {
+    modulePath: void 0,
+    wasmBinaryFile: void 0
+  };
+  if (!FeatureDetection_default.supportsWebAssembly()) {
+    if (!defined_default(wasmOptions.fallbackModulePath)) {
+      throw new RuntimeError_default(
+        `This browser does not support Web Assembly, and no backup module was provided for ${workerPath}`
+      );
+    }
+    config.modulePath = buildModuleUrl_default(wasmOptions.fallbackModulePath);
+    return config;
+  }
+  config.wasmBinaryFile = buildModuleUrl_default(wasmOptions.wasmBinaryFile);
+  if (defined_default(wasmOptions.modulePath)) {
+    config.modulePath = buildModuleUrl_default(wasmOptions.modulePath);
+  }
+  return config;
+}
+function WebAssemblyWorkerInitializer(workerPath, options) {
+  this._config = defined_default(options) ? getWebAssemblyLoaderConfig(workerPath, options) : void 0;
+  this._worker = void 0;
+  this._pending = void 0;
+  this.promise = void 0;
+}
+WebAssemblyWorkerInitializer.prototype._settle = function(error, result) {
+  const pending = this._pending;
+  if (!defined_default(pending)) {
+    return;
+  }
+  this._pending = void 0;
+  this._worker.removeEventListener("message", pending.listener);
+  if (defined_default(error)) {
+    pending.reject(error);
+  } else {
+    pending.resolve(result);
+  }
+};
+WebAssemblyWorkerInitializer.prototype.initialize = function(worker, canTransferArrayBuffer2, deserializeError) {
+  this._worker = worker;
+  const response = new Promise((resolve, reject) => {
+    const listener = ({ data }) => {
+      if (!defined_default(data) || typeof data !== "object" || !Object.prototype.hasOwnProperty.call(data, "result") && !Object.prototype.hasOwnProperty.call(data, "error")) {
+        this._settle(new RuntimeError_default("Could not configure wasm module"));
+      } else if (defined_default(data.error)) {
+        this._settle(deserializeError(data.error));
+      } else {
+        this._settle(void 0, data.result);
+      }
+    };
+    this._pending = { listener, resolve, reject };
+    worker.addEventListener("message", listener);
+  });
+  this.promise = (async () => {
+    try {
+      const canTransfer = await canTransferArrayBuffer2();
+      if (this._worker === worker && defined_default(this._pending)) {
+        worker.postMessage({
+          canTransferArrayBuffer: canTransfer,
+          baseUrl: buildModuleUrl_default.getCesiumBaseUrl().url,
+          trustedServers: TrustedServers_default.pack(),
+          parameters: { webAssemblyConfig: this._config }
+        });
+      }
+    } catch (error) {
+      if (this._worker === worker) {
+        this._settle(error);
+      }
+    }
+    return response;
+  })();
+  return this.promise;
+};
+WebAssemblyWorkerInitializer.prototype.reset = function(worker, error) {
+  if (this._worker !== worker) {
+    return;
+  }
+  this._settle(error);
+  this._worker = void 0;
+  this.promise = void 0;
+};
+var WebAssemblyWorkerInitializer_default = WebAssemblyWorkerInitializer;
+
+// packages/engine/Source/Core/TaskProcessor.js
+function canTransferArrayBuffer() {
+  if (!defined_default(TaskProcessor._canTransferArrayBuffer)) {
+    const worker = createWorker("transferTypedArrayTest");
+    worker.postMessage = worker.webkitPostMessage ?? worker.postMessage;
+    const value = 99;
+    const array = new Int8Array([value]);
+    let settled = false;
+    let settle;
+    const promise = new Promise((resolve) => {
+      const cleanup = () => {
+        worker.removeEventListener("message", onMessage);
+        worker.removeEventListener("error", onFailure);
+        worker.removeEventListener("messageerror", onFailure);
+        worker.terminate();
+      };
+      settle = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        TaskProcessor._canTransferArrayBuffer = result;
+        resolve(result);
+      };
+      const onMessage = (event) => {
+        const array2 = event.data?.array;
+        settle(defined_default(array2) && array2[0] === value);
+      };
+      const onFailure = () => settle(false);
+      worker.addEventListener("message", onMessage);
+      worker.addEventListener("error", onFailure);
+      worker.addEventListener("messageerror", onFailure);
+    });
+    TaskProcessor._canTransferArrayBuffer = promise;
+    try {
+      worker.postMessage(
+        {
+          array
+        },
+        [array.buffer]
+      );
+    } catch (e) {
+      settle(false);
+      return TaskProcessor._canTransferArrayBuffer;
+    }
+  }
+  return TaskProcessor._canTransferArrayBuffer;
+}
+var taskCompletedEvent = new Event_default();
+function urlFromScript(script) {
+  let blob;
+  try {
+    blob = new Blob([script], {
+      type: "application/javascript"
+    });
+  } catch (e) {
+    const BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
+    const blobBuilder = new BlobBuilder();
+    blobBuilder.append(script);
+    blob = blobBuilder.getBlob("application/javascript");
+  }
+  const URL = window.URL || window.webkitURL;
+  return URL.createObjectURL(blob);
+}
+function createWorker(url) {
+  const uri = new import_urijs.default(url);
+  const isUri = uri.scheme().length !== 0;
+  const moduleID = url.replace(/\.js$/, "");
+  const options = {};
+  let workerPath;
+  let crossOriginUrl;
+  if (isCrossOriginUrl_default(url)) {
+    crossOriginUrl = url;
+  } else if (!isUri) {
+    const moduleAbsoluteUrl = buildModuleUrl_default(
+      `${TaskProcessor._workerModulePrefix}/${moduleID}.js`
+    );
+    if (isCrossOriginUrl_default(moduleAbsoluteUrl)) {
+      crossOriginUrl = moduleAbsoluteUrl;
+    }
+  }
+  if (crossOriginUrl) {
+    const script = `import "${crossOriginUrl}";`;
+    workerPath = urlFromScript(script);
+    options.type = "module";
+    return new Worker(workerPath, options);
+  }
+  if (!isUri && typeof CESIUM_WORKERS !== "undefined") {
+    const script = `
+      importScripts("${urlFromScript(CESIUM_WORKERS)}");
+      CesiumWorkers["${moduleID}"]();
+    `;
+    workerPath = urlFromScript(script);
+    return new Worker(workerPath, options);
+  }
+  workerPath = url;
+  if (!isUri) {
+    workerPath = buildModuleUrl_default(
+      `${TaskProcessor._workerModulePrefix + moduleID}.js`
+    );
+  }
+  if (!FeatureDetection_default.supportsEsmWebWorkers()) {
+    throw new RuntimeError_default(
+      "This browser is not supported. Please update your browser to continue."
+    );
+  }
+  options.type = "module";
+  return new Worker(workerPath, options);
+}
+function TaskProcessor(workerPath, maximumActiveTasks) {
+  this._workerPath = workerPath;
+  this._maximumActiveTasks = maximumActiveTasks ?? Number.POSITIVE_INFINITY;
+  this._activeTasks = 0;
+  this._nextID = 0;
+  this._webAssemblyInitializer = void 0;
+  this._pendingTasks = /* @__PURE__ */ new Map();
+  this._workerFailureHandlers = /* @__PURE__ */ new Map();
+}
+function deserializeWorkerError(serializedError) {
+  let error = serializedError;
+  if (error.name === "RuntimeError") {
+    error = new RuntimeError_default(serializedError.message);
+    error.stack = serializedError.stack;
+  } else if (error.name === "DeveloperError") {
+    error = new DeveloperError_default(serializedError.message);
+    error.stack = serializedError.stack;
+  } else if (error.name === "Error") {
+    error = new Error(serializedError.message);
+    error.stack = serializedError.stack;
+  } else if (defined_default(error.name) && defined_default(error.message)) {
+    error = new Error(`${serializedError.name}: ${serializedError.message}`);
+    error.stack = serializedError.stack;
+  }
+  return error;
+}
+function workerFailureToError(event) {
+  if (defined_default(event.error)) {
+    if (event.error instanceof Error) {
+      return event.error;
+    }
+    if (defined_default(event.error.message)) {
+      const error = new Error(event.error.message);
+      if (defined_default(event.error.name)) {
+        error.name = event.error.name;
+      }
+      if (defined_default(event.error.stack)) {
+        error.stack = event.error.stack;
+      }
+      return error;
+    }
+    return new Error(String(event.error));
+  }
+  return new Error(event.message ?? "Worker failed");
+}
+function removeWorkerFailureHandler(processor, worker) {
+  const handlers = processor._workerFailureHandlers;
+  if (!defined_default(handlers)) {
+    return;
+  }
+  const handler = handlers.get(worker);
+  if (!defined_default(handler)) {
+    return;
+  }
+  worker.removeEventListener("error", handler);
+  worker.removeEventListener("messageerror", handler);
+  handlers.delete(worker);
+}
+function settleTask(processor, id, error, result) {
+  if (!defined_default(processor._pendingTasks)) {
+    return;
+  }
+  const pendingTask = processor._pendingTasks.get(id);
+  if (!defined_default(pendingTask)) {
+    return;
+  }
+  processor._pendingTasks.delete(id);
+  pendingTask.worker.removeEventListener("message", pendingTask.listener);
+  if (defined_default(error)) {
+    taskCompletedEvent.raiseEvent(error);
+    pendingTask.reject(error);
+  } else {
+    taskCompletedEvent.raiseEvent();
+    pendingTask.resolve(result);
+  }
+}
+function cleanupWorker(processor, worker, error) {
+  processor._webAssemblyInitializer?.reset(worker, error);
+  removeWorkerFailureHandler(processor, worker);
+  if (defined_default(error) && defined_default(processor._pendingTasks)) {
+    for (const [id, pendingTask] of Array.from(
+      processor._pendingTasks.entries()
+    )) {
+      if (pendingTask.worker === worker) {
+        settleTask(processor, id, error);
+      }
+    }
+  }
+  worker.terminate();
+  if (processor._worker === worker) {
+    processor._worker = void 0;
+  }
+}
+function handleWorkerFailure(processor, worker, event) {
+  const error = workerFailureToError(event);
+  cleanupWorker(processor, worker, error);
+}
+function createProcessorWorker(processor) {
+  const worker = createWorker(processor._workerPath);
+  const failureHandler = (event) => handleWorkerFailure(processor, worker, event);
+  worker.addEventListener("error", failureHandler);
+  worker.addEventListener("messageerror", failureHandler);
+  processor._workerFailureHandlers.set(worker, failureHandler);
+  return worker;
+}
+async function getWorker(processor) {
+  if (!defined_default(processor._webAssemblyInitializer)) {
+    if (!defined_default(processor._worker)) {
+      processor._worker = createProcessorWorker(processor);
+    }
+    return processor._worker;
+  }
+  await processor.initWebAssemblyModule();
+  return processor._worker;
+}
+var emptyTransferableObjectArray = [];
+async function runTask(processor, parameters, transferableObjects) {
+  const id = processor._nextID++;
+  const worker = defined_default(processor._webAssemblyInitializer) ? await getWorker(processor) : processor._worker;
+  if (processor.isDestroyed()) {
+    throw new RuntimeError_default("TaskProcessor was destroyed.");
+  }
+  const promise = new Promise((resolve, reject) => {
+    const listener = ({ data }) => {
+      if (!defined_default(data) || data.id !== id) {
+        return;
+      }
+      if (defined_default(data.error)) {
+        settleTask(processor, id, deserializeWorkerError(data.error));
+      } else {
+        settleTask(processor, id, void 0, data.result);
+      }
+    };
+    processor._pendingTasks.set(id, {
+      worker,
+      listener,
+      resolve,
+      reject
+    });
+    worker.addEventListener("message", listener);
+  });
+  try {
+    const canTransfer = await Promise.resolve(canTransferArrayBuffer());
+    if (!processor._pendingTasks.has(id)) {
+      return promise;
+    }
+    if (!defined_default(transferableObjects)) {
+      transferableObjects = emptyTransferableObjectArray;
+    } else if (!canTransfer) {
+      transferableObjects.length = 0;
+    }
+    worker.postMessage(
+      {
+        id,
+        baseUrl: buildModuleUrl_default.getCesiumBaseUrl().url,
+        trustedServers: TrustedServers_default.pack(),
+        parameters,
+        canTransferArrayBuffer: canTransfer
+      },
+      transferableObjects
+    );
+  } catch (error) {
+    settleTask(processor, id, error);
+  }
+  return promise;
+}
+async function scheduleTask(processor, parameters, transferableObjects) {
+  ++processor._activeTasks;
+  try {
+    const result = await runTask(processor, parameters, transferableObjects);
+    --processor._activeTasks;
+    return result;
+  } catch (error) {
+    --processor._activeTasks;
+    throw error;
+  }
+}
+TaskProcessor.prototype.scheduleTask = function(parameters, transferableObjects) {
+  if (!defined_default(this._worker)) {
+    if (!defined_default(this._webAssemblyInitializer)) {
+      this._worker = createProcessorWorker(this);
+    }
+  }
+  if (this._activeTasks >= this._maximumActiveTasks) {
+    return void 0;
+  }
+  return scheduleTask(this, parameters, transferableObjects);
+};
+TaskProcessor.prototype.initWebAssemblyModule = async function(webAssemblyOptions) {
+  let initializer = this._webAssemblyInitializer;
+  if (defined_default(initializer?.promise)) {
+    return initializer.promise;
+  }
+  if (defined_default(webAssemblyOptions) || !defined_default(initializer)) {
+    initializer = new WebAssemblyWorkerInitializer_default(
+      this._workerPath,
+      webAssemblyOptions
+    );
+    this._webAssemblyInitializer = initializer;
+  }
+  const worker = this._worker = createProcessorWorker(this);
+  try {
+    return await initializer.initialize(
+      worker,
+      canTransferArrayBuffer,
+      deserializeWorkerError
+    );
+  } catch (error) {
+    if (this._workerFailureHandlers.has(worker)) {
+      cleanupWorker(this, worker, error);
+    }
+    throw error;
+  }
+};
+TaskProcessor.prototype.isDestroyed = function() {
+  return false;
+};
+TaskProcessor.prototype.destroy = function() {
+  const error = new RuntimeError_default("TaskProcessor was destroyed.");
+  for (const worker of this._workerFailureHandlers.keys()) {
+    cleanupWorker(this, worker, error);
+  }
+  return destroyObject_default(this);
+};
+TaskProcessor.taskCompletedEvent = taskCompletedEvent;
+TaskProcessor._defaultWorkerModulePrefix = "Workers/";
+TaskProcessor._workerModulePrefix = TaskProcessor._defaultWorkerModulePrefix;
+TaskProcessor._canTransferArrayBuffer = void 0;
+var TaskProcessor_default = TaskProcessor;
+
+// packages/engine/Source/Core/TerrainPicker.js
+var MAXIMUM_TERRAIN_PICKER_LEVEL = 3;
+var TerrainPicker = class {
+  /**
+   * @param {Float64Array} vertices The terrain mesh's vertex buffer.
+   * @param {Uint8Array|Uint16Array|Uint32Array} indices The terrain mesh's index buffer.
+   * @param {TerrainEncoding} encoding The terrain mesh's vertex encoding.
+   */
+  constructor(vertices, indices, encoding) {
+    Check_default.defined("vertices", vertices);
+    Check_default.defined("indices", indices);
+    Check_default.defined("encoding", encoding);
+    this._vertices = vertices;
+    this._indices = indices;
+    this._encoding = encoding;
+    this._inverseTransform = new Matrix4_default();
+    this._needsRebuild = true;
+    this._rootNode = new TerrainPickerNode();
+  }
+  /**
+   * Indicates whether the terrain picker needs to be rebuilt due to changes in the underlying terrain mesh's vertices or indices.
+   * @type {boolean}
+   */
+  get needsRebuild() {
+    return this._needsRebuild;
+  }
+  set needsRebuild(value) {
+    this._needsRebuild = value;
+  }
+  /**
+   * Determines the point on the mesh where the given ray intersects.
+   * @param {Ray} ray The ray to test.
+   * @param {Matrix4} tileTransform The terrain mesh tile's transform from local space to world space.
+   * @param {Boolean} cullBackFaces Whether to consider back-facing triangles as intersections.
+   * @param {SceneMode} mode The scene mode (2D/3D/Columbus View).
+   * @param {MapProjection} projection The map projection.
+   * @returns {Cartesian3 | undefined} result The intersection point, or undefined if there is no intersection.
+   * @private
+   */
+  rayIntersect(ray, tileTransform, cullBackFaces, mode, projection) {
+    if (this._needsRebuild) {
+      reset(this, tileTransform);
+    }
+    const invTransform = this._inverseTransform;
+    const transformedRay = scratchTransformedRay;
+    transformedRay.origin = Matrix4_default.multiplyByPoint(
+      invTransform,
+      ray.origin,
+      transformedRay.origin
+    );
+    transformedRay.direction = Matrix4_default.multiplyByPointAsVector(
+      invTransform,
+      ray.direction,
+      transformedRay.direction
+    );
+    const intersections = [];
+    getNodesIntersectingRay(this._rootNode, transformedRay, intersections);
+    return findClosestPointInClosestNode(
+      this,
+      intersections,
+      ray,
+      cullBackFaces,
+      mode,
+      projection
+    );
+  }
+};
+var incrementallyBuildTerrainPickerTaskProcessor = new TaskProcessor_default(
+  "incrementallyBuildTerrainPicker"
+);
+var TerrainPickerNode = class _TerrainPickerNode {
+  constructor() {
+    this.x = 0;
+    this.y = 0;
+    this.level = 0;
+    this.aabb = createAABBForNode(this.x, this.y, this.level);
+    this.intersectingTriangles = new Uint32Array(0);
+    this.children = [];
+    this.buildingChildren = false;
+  }
+  /**
+   * Adds a child node to this node.
+   *
+   * @param {number} childIdx The index of the child to add (0-3).
+   */
+  addChild(childIdx) {
+    if (childIdx < 0 || childIdx > 3) {
+      throw new DeveloperError_default(
+        "TerrainPickerNode child index must be between 0 and 3, inclusive."
+      );
+    }
+    const childNode = new _TerrainPickerNode();
+    childNode.x = this.x * 2 + (childIdx & 1);
+    childNode.y = this.y * 2 + (childIdx >> 1 & 1);
+    childNode.level = this.level + 1;
+    childNode.aabb = createAABBForNode(
+      childNode.x,
+      childNode.y,
+      childNode.level
+    );
+    this.children[childIdx] = childNode;
+  }
+};
+var scratchTransformedRay = new Ray_default();
+var scratchTrianglePoints = [
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default()
+];
+function reset(terrainPicker, tileTransform) {
+  Matrix4_default.inverse(tileTransform, terrainPicker._inverseTransform);
+  terrainPicker._needsRebuild = false;
+  const triangleCount = terrainPicker._indices.length / 3;
+  const intersectingTriangles = new Uint32Array(triangleCount);
+  for (let i = 0; i < triangleCount; ++i) {
+    intersectingTriangles[i] = i;
+  }
+  terrainPicker._rootNode.intersectingTriangles = intersectingTriangles;
+  terrainPicker._rootNode.children.length = 0;
+}
+var scratchAABBMin = new Cartesian3_default();
+var scratchAABBMax = new Cartesian3_default();
+function createAABBForNode(x, y, level) {
+  const sizeAtLevel = 1 / Math.pow(2, level);
+  const aabbMin = Cartesian3_default.fromElements(
+    x * sizeAtLevel - 0.5,
+    y * sizeAtLevel - 0.5,
+    -0.5,
+    scratchAABBMin
+  );
+  const aabbMax = Cartesian3_default.fromElements(
+    (x + 1) * sizeAtLevel - 0.5,
+    (y + 1) * sizeAtLevel - 0.5,
+    0.5,
+    scratchAABBMax
+  );
+  return AxisAlignedBoundingBox_default.fromCorners(aabbMin, aabbMax);
+}
+function packTriangleBuffers(trianglePositionsBuffer, triangleIndicesBuffer, trianglePositions, triangleIndex, bufferIndex) {
+  Cartesian3_default.pack(
+    trianglePositions[0],
+    // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+    trianglePositionsBuffer,
+    9 * bufferIndex
+  );
+  Cartesian3_default.pack(
+    trianglePositions[1],
+    // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+    trianglePositionsBuffer,
+    9 * bufferIndex + 3
+  );
+  Cartesian3_default.pack(
+    trianglePositions[2],
+    // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+    trianglePositionsBuffer,
+    9 * bufferIndex + 6
+  );
+  triangleIndicesBuffer[bufferIndex] = triangleIndex;
+}
+var scratchInterval = new Interval_default();
+function getNodesIntersectingRay(currentNode, ray, intersectingNodes) {
+  const interval = IntersectionTests_default.rayAxisAlignedBoundingBox(
+    ray,
+    currentNode.aabb,
+    scratchInterval
+  );
+  if (!defined_default(interval)) {
+    return;
+  }
+  const isLeaf = !currentNode.children.length || currentNode.buildingChildren;
+  if (isLeaf) {
+    intersectingNodes.push({
+      node: currentNode,
+      interval: new Interval_default(interval.start, interval.stop)
+    });
+    return;
+  }
+  for (let i = 0; i < currentNode.children.length; i++) {
+    getNodesIntersectingRay(currentNode.children[i], ray, intersectingNodes);
+  }
+}
+function findClosestPointInClosestNode(terrainPicker, intersections, ray, cullBackFaces, mode, projection) {
+  const sortedIntersections = intersections.sort(function(a, b) {
+    return a.interval.start - b.interval.start;
+  });
+  let minT = Number.MAX_VALUE;
+  for (let i = 0; i < sortedIntersections.length; i++) {
+    const intersection = sortedIntersections[i];
+    const intersectionResult = getClosestTriangleInNode(
+      terrainPicker,
+      ray,
+      intersection.node,
+      cullBackFaces,
+      mode,
+      projection
+    );
+    minT = Math.min(intersectionResult, minT);
+    if (minT !== Number.MAX_VALUE) {
+      break;
+    }
+  }
+  if (minT !== Number.MAX_VALUE) {
+    return Ray_default.getPoint(ray, minT);
+  }
+  return void 0;
+}
+function getClosestTriangleInNode(terrainPicker, ray, node, cullBackFaces, mode, projection) {
+  let result = Number.MAX_VALUE;
+  const encoding = terrainPicker._encoding;
+  const indices = terrainPicker._indices;
+  const vertices = terrainPicker._vertices;
+  const triangleCount = node.intersectingTriangles.length;
+  const isMaxLevel = node.level >= MAXIMUM_TERRAIN_PICKER_LEVEL;
+  const shouldBuildChildren = !isMaxLevel && !node.buildingChildren;
+  let trianglePositions;
+  let triangleIndices;
+  if (shouldBuildChildren) {
+    trianglePositions = new Float64Array(triangleCount * 9);
+    triangleIndices = new Uint32Array(triangleCount);
+  }
+  for (let i = 0; i < triangleCount; i++) {
+    const triIndex = node.intersectingTriangles[i];
+    const v0 = getVertexPosition(
+      encoding,
+      mode,
+      projection,
+      ray,
+      vertices,
+      indices[3 * triIndex],
+      scratchTrianglePoints[0]
+    );
+    const v1 = getVertexPosition(
+      encoding,
+      mode,
+      projection,
+      ray,
+      vertices,
+      indices[3 * triIndex + 1],
+      scratchTrianglePoints[1]
+    );
+    const v2 = getVertexPosition(
+      encoding,
+      mode,
+      projection,
+      ray,
+      vertices,
+      indices[3 * triIndex + 2],
+      scratchTrianglePoints[2]
+    );
+    const triT = IntersectionTests_default.rayTriangleParametric(
+      ray,
+      v0,
+      v1,
+      v2,
+      cullBackFaces
+    );
+    if (defined_default(triT) && triT < result && triT >= 0) {
+      result = triT;
+    }
+    if (shouldBuildChildren) {
+      packTriangleBuffers(
+        trianglePositions,
+        triangleIndices,
+        scratchTrianglePoints,
+        triIndex,
+        i
+      );
+    }
+  }
+  if (shouldBuildChildren) {
+    for (let childIdx = 0; childIdx < 4; childIdx++) {
+      node.addChild(childIdx);
+    }
+    addTrianglesToChildrenNodes(
+      terrainPicker._inverseTransform,
+      node,
+      triangleIndices,
+      trianglePositions
+    );
+  }
+  return result;
+}
+var scratchCartographic = new Cartographic_default();
+function getVertexPosition(encoding, mode, projection, ray, vertices, index, result) {
+  let position = encoding.getExaggeratedPosition(vertices, index, result);
+  if (mode === SceneMode_default.SCENE3D) {
+    return position;
+  }
+  const ellipsoid = projection.ellipsoid;
+  const positionCartographic = ellipsoid.cartesianToCartographic(
+    position,
+    scratchCartographic
+  );
+  position = projection.project(positionCartographic, result);
+  position = Cartesian3_default.fromElements(
+    position.z,
+    position.x,
+    position.y,
+    result
+  );
+  const worldWidth = Math_default.TWO_PI * projection.ellipsoid.maximumRadius;
+  const k = Math.round((ray.origin.y - position.y) / worldWidth);
+  position.y += k * worldWidth;
+  return position;
+}
+async function addTrianglesToChildrenNodes(inverseTransform, node, triangleIndices, trianglePositions) {
+  node.buildingChildren = true;
+  const inverseTransformPacked = new Float64Array(16);
+  Matrix4_default.pack(inverseTransform, inverseTransformPacked, 0);
+  const aabbArray = new Float64Array(6 * 4);
+  for (let i = 0; i < 4; i++) {
+    Cartesian3_default.pack(node.children[i].aabb.minimum, aabbArray, i * 6);
+    Cartesian3_default.pack(node.children[i].aabb.maximum, aabbArray, i * 6 + 3);
+  }
+  const parameters = {
+    aabbs: aabbArray,
+    inverseTransform: inverseTransformPacked,
+    triangleIndices,
+    trianglePositions
+  };
+  const transferableObjects = [
+    aabbArray.buffer,
+    inverseTransformPacked.buffer,
+    triangleIndices.buffer,
+    trianglePositions.buffer
+  ];
+  const incrementallyBuildTerrainPickerPromise = incrementallyBuildTerrainPickerTaskProcessor.scheduleTask(
+    parameters,
+    transferableObjects
+  );
+  if (!defined_default(incrementallyBuildTerrainPickerPromise)) {
+    node.buildingChildren = false;
+    return;
+  }
+  const result = (
+    /** @type {{intersectingTrianglesArrays: ArrayBuffer[]}} */
+    await incrementallyBuildTerrainPickerPromise
+  );
+  result.intersectingTrianglesArrays.forEach((buffer, index) => {
+    if (defined_default(node.children[index])) {
+      node.children[index].intersectingTriangles = new Uint32Array(buffer);
+    }
+  });
+  node.intersectingTriangles = new Uint32Array(0);
+  node.buildingChildren = false;
+}
+var TerrainPicker_default = TerrainPicker;
+
+// packages/engine/Source/Core/TerrainMesh.js
+function TerrainMesh(center, vertices, indices, indexCountWithoutSkirts, vertexCountWithoutSkirts, minimumHeight, maximumHeight, rectangle, boundingSphere3D, occludeePointInScaledSpace, vertexStride, orientedBoundingBox, encoding, westIndicesSouthToNorth, southIndicesEastToWest, eastIndicesNorthToSouth, northIndicesWestToEast) {
+  this.center = center;
+  this.vertices = vertices;
+  this.stride = vertexStride ?? 6;
+  this.indices = indices;
+  this.indexCountWithoutSkirts = indexCountWithoutSkirts;
+  this.vertexCountWithoutSkirts = vertexCountWithoutSkirts;
+  this.minimumHeight = minimumHeight;
+  this.maximumHeight = maximumHeight;
+  this.rectangle = rectangle;
+  this.boundingSphere3D = boundingSphere3D;
+  this.occludeePointInScaledSpace = occludeePointInScaledSpace;
+  this.orientedBoundingBox = orientedBoundingBox;
+  this.encoding = encoding;
+  this.westIndicesSouthToNorth = westIndicesSouthToNorth;
+  this.southIndicesEastToWest = southIndicesEastToWest;
+  this.eastIndicesNorthToSouth = eastIndicesNorthToSouth;
+  this.northIndicesWestToEast = northIndicesWestToEast;
+  this._transform = new Matrix4_default();
+  this._lastPickSceneMode = void 0;
+  this._terrainPicker = new TerrainPicker_default(vertices, indices, encoding);
+}
+TerrainMesh.prototype.getTransform = function(mode, projection) {
+  if (this._lastPickSceneMode === mode) {
+    return this._transform;
+  }
+  this._terrainPicker.needsRebuild = true;
+  if (!defined_default(mode) || mode === SceneMode_default.SCENE3D) {
+    return computeTransform(this, this._transform);
+  }
+  return computeTransform2D(this, projection, this._transform);
+};
+function computeTransform(mesh, result) {
+  const exaggeration = mesh.encoding.exaggeration;
+  const exaggerationRelativeHeight = mesh.encoding.exaggerationRelativeHeight;
+  const exaggeratedMinHeight = VerticalExaggeration_default.getHeight(
+    mesh.minimumHeight,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const exaggeratedMaxHeight = VerticalExaggeration_default.getHeight(
+    mesh.maximumHeight,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const obb = OrientedBoundingBox_default.fromRectangle(
+    mesh.rectangle,
+    exaggeratedMinHeight,
+    exaggeratedMaxHeight,
+    Ellipsoid_default.default,
+    mesh.orientedBoundingBox
+  );
+  OrientedBoundingBox_default.computeTransformation(obb, result);
+  const zScale = Matrix4_default.getScale(result, scratchScale).z;
+  if (zScale <= Math_default.EPSILON16) {
+    scratchScale.z = 1;
+    Matrix4_default.setScale(result, scratchScale, result);
+  }
+  return result;
+}
+var scratchSWCartesian = new Cartesian3_default();
+var scratchNECartesian = new Cartesian3_default();
+var scratchSWCartographic = new Cartographic_default();
+var scratchNECartographic = new Cartographic_default();
+var scratchScale2D = new Cartesian3_default();
+var scratchCenter2D = new Cartesian3_default();
+var scratchScale = new Cartesian3_default();
+function computeTransform2D(mesh, projection, result) {
+  const exaggeration = mesh.encoding.exaggeration;
+  const exaggerationRelativeHeight = mesh.encoding.exaggerationRelativeHeight;
+  const exaggeratedMinHeight = VerticalExaggeration_default.getHeight(
+    mesh.minimumHeight,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const exaggeratedMaxHeight = VerticalExaggeration_default.getHeight(
+    mesh.maximumHeight,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const southwest = projection.project(
+    Cartographic_default.fromRadians(
+      mesh.rectangle.west,
+      mesh.rectangle.south,
+      0,
+      scratchSWCartographic
+    ),
+    scratchSWCartesian
+  );
+  const northeast = projection.project(
+    Cartographic_default.fromRadians(
+      mesh.rectangle.east,
+      mesh.rectangle.north,
+      0,
+      scratchNECartographic
+    ),
+    scratchNECartesian
+  );
+  const heightRange = exaggeratedMaxHeight - exaggeratedMinHeight;
+  const scale = Cartesian3_default.fromElements(
+    northeast.x - southwest.x,
+    northeast.y - southwest.y,
+    heightRange > 0 ? heightRange : 1,
+    // Avoid zero scale
+    scratchScale2D
+  );
+  const center = Cartesian3_default.fromElements(
+    southwest.x + scale.x * 0.5,
+    southwest.y + scale.y * 0.5,
+    exaggeratedMinHeight + scale.z * 0.5,
+    scratchCenter2D
+  );
+  Matrix4_default.fromTranslation(center, result);
+  Matrix4_default.setScale(result, scale, result);
+  Matrix4_default.multiply(Transforms_default.SWIZZLE_3D_TO_2D_MATRIX, result, result);
+  return result;
+}
+TerrainMesh.prototype.pick = function(ray, cullBackFaces, mode, projection) {
+  const intersection = this._terrainPicker.rayIntersect(
+    ray,
+    this.getTransform(mode, projection),
+    cullBackFaces,
+    mode,
+    projection
+  );
+  this._lastPickSceneMode = mode;
+  return intersection;
+};
+TerrainMesh.prototype.updateExaggeration = function(exaggeration, exaggerationRelativeHeight) {
+  this._terrainPicker._vertices = this.vertices;
+  this._terrainPicker.needsRebuild = true;
+  this._lastPickSceneMode = void 0;
+};
+TerrainMesh.prototype.updateSceneMode = function(mode) {
+  this._terrainPicker.needsRebuild = true;
+  this._lastPickSceneMode = void 0;
+};
+var TerrainMesh_default = TerrainMesh;
+
+// packages/engine/Source/Core/Cesium3DTilesTerrainGeometryProcessor.js
+var Cesium3DTilesTerrainGeometryProcessor = {};
+var scratchGltfInfo = {
+  positions: void 0,
+  normals: void 0,
+  indices: void 0,
+  edgeIndicesWest: void 0,
+  edgeIndicesSouth: void 0,
+  edgeIndicesEast: void 0,
+  edgeIndicesNorth: void 0
+};
+var scratchCenterCartographic = new Cartographic_default();
+var scratchCenterCartesian = new Cartesian3_default();
+var scratchEnuToEcef = new Matrix4_default();
+var scratchEcefToEnu = new Matrix4_default();
+var scratchTilesetTransform = new Matrix4_default();
+var scratchMinimumPositionENU = new Cartesian3_default();
+var scratchMaximumPositionENU = new Cartesian3_default();
+var scratchPosLocal = new Cartesian3_default();
+var scratchPosEcef = new Cartesian3_default();
+var scratchCartographic2 = new Cartographic_default();
+var scratchUV = new Cartesian2_default();
+var scratchNormal = new Cartesian3_default();
+var scratchNormalOct = new Cartesian2_default();
+var scratchGeodeticSurfaceNormal = new Cartesian3_default();
+var scratchPosEnu = new Cartesian3_default();
+var sortedEdgeCompare = function(a, b) {
+  return a - b;
+};
+Cesium3DTilesTerrainGeometryProcessor.createMesh = async function(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  const {
+    exaggeration = 1,
+    exaggerationRelativeHeight = 0,
+    hasVertexNormals,
+    hasWebMercatorT,
+    gltf,
+    minimumHeight,
+    maximumHeight,
+    skirtHeight
+  } = options;
+  Check_default.typeOf.object("options.ellipsoid", options.ellipsoid);
+  Check_default.typeOf.object("options.rectangle", options.rectangle);
+  Check_default.typeOf.bool("options.hasVertexNormals", hasVertexNormals);
+  Check_default.typeOf.bool("options.hasWebMercatorT", hasWebMercatorT);
+  Check_default.typeOf.object("options.gltf", gltf);
+  Check_default.typeOf.number("options.minimumHeight", minimumHeight);
+  Check_default.typeOf.number("options.maximumHeight", maximumHeight);
+  Check_default.typeOf.object("options.boundingSphere", options.boundingSphere);
+  Check_default.typeOf.object(
+    "options.orientedBoundingBox",
+    options.orientedBoundingBox
+  );
+  Check_default.typeOf.object(
+    "options.horizonOcclusionPoint",
+    options.horizonOcclusionPoint
+  );
+  Check_default.typeOf.number("options.skirtHeight", skirtHeight);
+  const hasExaggeration = exaggeration !== 1;
+  const hasGeodeticSurfaceNormals = hasExaggeration;
+  const boundingSphere = BoundingSphere_default.clone(
+    options.boundingSphere,
+    new BoundingSphere_default()
+  );
+  const orientedBoundingBox = OrientedBoundingBox_default.clone(
+    options.orientedBoundingBox,
+    new OrientedBoundingBox_default()
+  );
+  const horizonOcclusionPoint = Cartesian3_default.clone(
+    options.horizonOcclusionPoint,
+    new Cartesian3_default()
+  );
+  const ellipsoid = Ellipsoid_default.clone(options.ellipsoid, new Ellipsoid_default());
+  const rectangle = Rectangle_default.clone(options.rectangle, new Rectangle_default());
+  const hasMeshOptCompression = gltf.extensionsRequired !== void 0 && gltf.extensionsRequired.indexOf("EXT_meshopt_compression") !== -1;
+  if (hasMeshOptCompression) {
+    Check_default.typeOf.object("options.meshoptDecoder", options.meshoptDecoder);
+  }
+  const tileMinLongitude = rectangle.west;
+  const tileMinLatitude = rectangle.south;
+  const tileMaxLatitude = rectangle.north;
+  const tileLengthLongitude = rectangle.width;
+  const tileLengthLatitude = rectangle.height;
+  const approximateCenterCartographic = Rectangle_default.center(
+    rectangle,
+    scratchCenterCartographic
+  );
+  approximateCenterCartographic.height = 0.5 * (minimumHeight + maximumHeight);
+  const approximateCenterPosition = Cartographic_default.toCartesian(
+    approximateCenterCartographic,
+    ellipsoid,
+    scratchCenterCartesian
+  );
+  const enuToEcef = Transforms_default.eastNorthUpToFixedFrame(
+    approximateCenterPosition,
+    ellipsoid,
+    scratchEnuToEcef
+  );
+  const ecefToEnu = Matrix4_default.inverseTransformation(enuToEcef, scratchEcefToEnu);
+  let tilesetTransform = Matrix4_default.unpack(
+    gltf.nodes[0].matrix,
+    0,
+    scratchTilesetTransform
+  );
+  tilesetTransform = Matrix4_default.multiply(
+    Axis_default.Y_UP_TO_Z_UP,
+    tilesetTransform,
+    tilesetTransform
+  );
+  const gltfInfo = decodeGltf(
+    gltf,
+    hasVertexNormals,
+    options.meshoptDecoder,
+    scratchGltfInfo
+  );
+  const skirtVertexCount = TerrainProvider_default.getSkirtVertexCount(
+    gltfInfo.edgeIndicesWest,
+    gltfInfo.edgeIndicesSouth,
+    gltfInfo.edgeIndicesEast,
+    gltfInfo.edgeIndicesNorth
+  );
+  const positionsLocalWithoutSkirts = gltfInfo.positions;
+  const normalsWithoutSkirts = gltfInfo.normals;
+  const indicesWithoutSkirts = gltfInfo.indices;
+  const vertexCountWithoutSkirts = positionsLocalWithoutSkirts.length / 3;
+  const vertexCountWithSkirts = vertexCountWithoutSkirts + skirtVertexCount;
+  const indexCountWithoutSkirts = indicesWithoutSkirts.length;
+  const skirtIndexCount = TerrainProvider_default.getSkirtIndexCountWithFilledCorners(skirtVertexCount);
+  const SizedIndexTypeWithSkirts = vertexCountWithSkirts <= 65535 ? Uint16Array : Uint32Array;
+  const indexBufferWithSkirts = new SizedIndexTypeWithSkirts(
+    indexCountWithoutSkirts + skirtIndexCount
+  );
+  indexBufferWithSkirts.set(indicesWithoutSkirts);
+  const westIndices = new SizedIndexTypeWithSkirts(gltfInfo.edgeIndicesWest);
+  const southIndices = new SizedIndexTypeWithSkirts(gltfInfo.edgeIndicesSouth);
+  const eastIndices = new SizedIndexTypeWithSkirts(gltfInfo.edgeIndicesEast);
+  const northIndices = new SizedIndexTypeWithSkirts(gltfInfo.edgeIndicesNorth);
+  const sortedWestIndices = new SizedIndexTypeWithSkirts(westIndices).sort();
+  const sortedSouthIndices = new SizedIndexTypeWithSkirts(southIndices).sort();
+  const sortedEastIndices = new SizedIndexTypeWithSkirts(eastIndices).sort();
+  const sortedNorthIndices = new SizedIndexTypeWithSkirts(northIndices).sort();
+  const southMercatorAngle = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(tileMinLatitude);
+  const northMercatorAngle = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(tileMaxLatitude);
+  const oneOverMercatorHeight = 1 / (northMercatorAngle - southMercatorAngle);
+  let minPosEnu = Cartesian3_default.fromElements(
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    scratchMinimumPositionENU
+  );
+  let maxPosEnu = Cartesian3_default.fromElements(
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    scratchMaximumPositionENU
+  );
+  const tempTerrainEncoding = new TerrainEncoding_default(
+    boundingSphere.center,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    hasVertexNormals,
+    hasWebMercatorT,
+    hasGeodeticSurfaceNormals,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const tempBufferStride = tempTerrainEncoding.stride;
+  const tempBuffer = new Float32Array(vertexCountWithSkirts * tempBufferStride);
+  let tempBufferOffset = 0;
+  for (let i = 0; i < vertexCountWithoutSkirts; i++) {
+    const posLocal = Cartesian3_default.unpack(
+      positionsLocalWithoutSkirts,
+      i * 3,
+      scratchPosLocal
+    );
+    const posECEF = Matrix4_default.multiplyByPoint(
+      tilesetTransform,
+      posLocal,
+      scratchPosEcef
+    );
+    const cartographic = Cartographic_default.fromCartesian(
+      posECEF,
+      ellipsoid,
+      scratchCartographic2
+    );
+    const { longitude, latitude, height } = cartographic;
+    let u = (longitude - tileMinLongitude) / tileLengthLongitude;
+    let v = (latitude - tileMinLatitude) / tileLengthLatitude;
+    u = Math_default.clamp(u, 0, 1);
+    v = Math_default.clamp(v, 0, 1);
+    if (binarySearch_default(sortedWestIndices, i, sortedEdgeCompare) >= 0) {
+      u = 0;
+    } else if (binarySearch_default(sortedEastIndices, i, sortedEdgeCompare) >= 0) {
+      u = 1;
+    }
+    if (binarySearch_default(sortedSouthIndices, i, sortedEdgeCompare) >= 0) {
+      v = 0;
+    } else if (binarySearch_default(sortedNorthIndices, i, sortedEdgeCompare) >= 0) {
+      v = 1;
+    }
+    const uv = Cartesian2_default.fromElements(u, v, scratchUV);
+    let normalOct;
+    if (hasVertexNormals) {
+      let normal = Cartesian3_default.unpack(
+        normalsWithoutSkirts,
+        i * 3,
+        scratchNormal
+      );
+      normal = Matrix4_default.multiplyByPointAsVector(
+        tilesetTransform,
+        normal,
+        scratchNormal
+      );
+      normal = Cartesian3_default.normalize(normal, scratchNormal);
+      normalOct = AttributeCompression_default.octEncode(normal, scratchNormalOct);
+    }
+    let webMercatorT;
+    if (hasWebMercatorT) {
+      const mercatorAngle = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(latitude);
+      webMercatorT = (mercatorAngle - southMercatorAngle) * oneOverMercatorHeight;
+    }
+    let geodeticSurfaceNormal;
+    if (hasGeodeticSurfaceNormals) {
+      geodeticSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
+        posECEF,
+        scratchGeodeticSurfaceNormal
+      );
+    }
+    tempBufferOffset = tempTerrainEncoding.encode(
+      tempBuffer,
+      tempBufferOffset,
+      posECEF,
+      uv,
+      height,
+      normalOct,
+      webMercatorT,
+      geodeticSurfaceNormal
+    );
+    const posEnu = Matrix4_default.multiplyByPoint(ecefToEnu, posECEF, scratchPosEnu);
+    minPosEnu = Cartesian3_default.minimumByComponent(posEnu, minPosEnu, minPosEnu);
+    maxPosEnu = Cartesian3_default.maximumByComponent(posEnu, maxPosEnu, maxPosEnu);
+  }
+  const mesh = new TerrainMesh_default(
+    Cartesian3_default.clone(tempTerrainEncoding.center, new Cartesian3_default()),
+    tempBuffer,
+    indexBufferWithSkirts,
+    indexCountWithoutSkirts,
+    vertexCountWithoutSkirts,
+    minimumHeight,
+    maximumHeight,
+    rectangle,
+    BoundingSphere_default.clone(boundingSphere, new BoundingSphere_default()),
+    Cartesian3_default.clone(horizonOcclusionPoint, new Cartesian3_default()),
+    tempBufferStride,
+    OrientedBoundingBox_default.clone(orientedBoundingBox, new OrientedBoundingBox_default()),
+    tempTerrainEncoding,
+    westIndices,
+    southIndices,
+    eastIndices,
+    northIndices
+  );
+  addSkirtsToMesh(
+    mesh,
+    rectangle,
+    ellipsoid,
+    minPosEnu,
+    maxPosEnu,
+    enuToEcef,
+    ecefToEnu,
+    skirtHeight
+  );
+  return Promise.resolve(mesh);
+};
+var scratchMinUV = new Cartesian2_default();
+var scratchMaxUV = new Cartesian2_default();
+var scratchPolygonIndices = new Array(6);
+var scratchUvA = new Cartesian2_default();
+var scratchUvB = new Cartesian2_default();
+var scratchUvC = new Cartesian2_default();
+var scratchNormalA = new Cartesian3_default();
+var scratchNormalB = new Cartesian3_default();
+var scratchNormalC = new Cartesian3_default();
+var scratchCenterCartographicUpsample = new Cartographic_default();
+var scratchCenterCartesianUpsample = new Cartesian3_default();
+var scratchCartographicSkirt = new Cartographic_default();
+var scratchCartographicUpsample = new Cartographic_default();
+var scratchPosEcefSkirt = new Cartesian3_default();
+var scratchPosEcefUpsample = new Cartesian3_default();
+var scratchPosEnuSkirt = new Cartesian3_default();
+var scratchPosEnuUpsample = new Cartesian3_default();
+var scratchMinimumPositionENUSkirt = new Cartesian3_default();
+var scratchMaximumPositionENUSkirt = new Cartesian3_default();
+var scratchMinimumPositionENUUpsample = new Cartesian3_default();
+var scratchMaximumPositionENUUpsample = new Cartesian3_default();
+var scratchEnuToEcefUpsample = new Matrix4_default();
+var scratchEcefToEnuUpsample = new Matrix4_default();
+var scratchUVSkirt = new Cartesian2_default();
+var scratchUVUpsample = new Cartesian2_default();
+var scratchHorizonOcclusionPoint = new Cartesian3_default();
+var scratchBoundingSphere = new BoundingSphere_default();
+var scratchOrientedBoundingBox = new OrientedBoundingBox_default();
+var scratchAABBEnuSkirt = new AxisAlignedBoundingBox_default();
+var scratchNormalUpsample = new Cartesian3_default();
+var scratchNormalOctSkirt = new Cartesian2_default();
+var scratchNormalOctUpsample = new Cartesian2_default();
+var scratchGeodeticSurfaceNormalSkirt = new Cartesian3_default();
+var scratchGeodeticSurfaceNormalUpsample = new Cartesian3_default();
+function decodePositions(gltf, meshoptDecoder) {
+  const primitive = gltf.meshes[0].primitives[0];
+  const accessor = gltf.accessors[primitive.attributes["POSITION"]];
+  const bufferView = gltf.bufferViews[accessor.bufferView];
+  const positionCount = accessor.count;
+  const bufferViewMeshOpt = bufferView.extensions ? bufferView.extensions["EXT_meshopt_compression"] : void 0;
+  if (bufferViewMeshOpt === void 0) {
+    const buffer2 = gltf.buffers[bufferView.buffer].extras._pipeline.source;
+    return new Float32Array(
+      buffer2.buffer,
+      buffer2.byteOffset + // offset from the start of the glb
+      (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0),
+      positionCount * 3
+    );
+  }
+  const buffer = gltf.buffers[bufferViewMeshOpt.buffer].extras._pipeline.source;
+  const compressedBuffer = new Uint8Array(
+    buffer.buffer,
+    buffer.byteOffset + // offset from the start of the glb
+    (bufferViewMeshOpt.byteOffset ?? 0) + (accessor.byteOffset ?? 0),
+    bufferViewMeshOpt.byteLength
+  );
+  const positionByteLength = bufferViewMeshOpt.byteStride;
+  const PositionType = positionByteLength === 4 ? Uint8Array : Uint16Array;
+  const positionsResult = new PositionType(positionCount * 4);
+  meshoptDecoder.decodeVertexBuffer(
+    new Uint8Array(positionsResult.buffer),
+    positionCount,
+    positionByteLength,
+    compressedBuffer
+  );
+  const positionStorageValueMax = (1 << positionsResult.BYTES_PER_ELEMENT * 8) - 1;
+  const positions = new Float32Array(positionCount * 3);
+  for (let p = 0; p < positionCount; p++) {
+    positions[p * 3 + 0] = positionsResult[p * 4 + 0] / positionStorageValueMax;
+    positions[p * 3 + 1] = positionsResult[p * 4 + 1] / positionStorageValueMax;
+    positions[p * 3 + 2] = positionsResult[p * 4 + 2] / positionStorageValueMax;
+  }
+  return positions;
+}
+function decodeNormals(gltf, meshoptDecoder) {
+  const primitive = gltf.meshes[0].primitives[0];
+  const accessor = gltf.accessors[primitive.attributes["NORMAL"]];
+  const bufferView = gltf.bufferViews[accessor.bufferView];
+  const normalCount = accessor.count;
+  const bufferViewMeshOpt = bufferView.extensions ? bufferView.extensions["EXT_meshopt_compression"] : void 0;
+  if (bufferViewMeshOpt === void 0) {
+    const buffer2 = gltf.buffers[bufferView.buffer].extras._pipeline.source;
+    return new Float32Array(
+      buffer2.buffer,
+      buffer2.byteOffset + // offset from the start of the glb
+      (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0),
+      normalCount * 3
+    );
+  }
+  const buffer = gltf.buffers[bufferViewMeshOpt.buffer].extras._pipeline.source;
+  const compressedBuffer = new Uint8Array(
+    buffer.buffer,
+    buffer.byteOffset + // offset from the start of the glb
+    (bufferViewMeshOpt.byteOffset ?? 0) + (accessor.byteOffset ?? 0),
+    bufferViewMeshOpt.byteLength
+  );
+  const normalByteLength = bufferViewMeshOpt.byteStride;
+  const normalsResult = new Int8Array(normalCount * normalByteLength);
+  meshoptDecoder.decodeVertexBuffer(
+    new Uint8Array(normalsResult.buffer),
+    normalCount,
+    normalByteLength,
+    compressedBuffer
+  );
+  const normals = new Float32Array(normalCount * 3);
+  for (let i = 0; i < normalCount; i++) {
+    let octX = Math.max(normalsResult[i * 4 + 0] / 127, -1);
+    let octY = Math.max(normalsResult[i * 4 + 1] / 127, -1);
+    const octZ = 1 - (Math.abs(octX) + Math.abs(octY));
+    if (octZ < 0) {
+      const oldX = octX;
+      const oldY = octY;
+      octX = (1 - Math.abs(oldY)) * Math_default.signNotZero(oldX);
+      octY = (1 - Math.abs(oldX)) * Math_default.signNotZero(oldY);
+    }
+    let normal = scratchNormal;
+    normal.x = octX;
+    normal.y = octY;
+    normal.z = octZ;
+    normal = Cartesian3_default.normalize(normal, scratchNormal);
+    normals[i * 3 + 0] = normal.x;
+    normals[i * 3 + 1] = normal.y;
+    normals[i * 3 + 2] = normal.z;
+  }
+  return normals;
+}
+function decodeIndices(gltf, meshoptDecoder) {
+  const primitive = gltf.meshes[0].primitives[0];
+  const accessor = gltf.accessors[primitive.indices];
+  const bufferView = gltf.bufferViews[accessor.bufferView];
+  const indexCount = accessor.count;
+  const SizedIndexType = accessor.componentType === ComponentDatatype_default.UNSIGNED_SHORT ? Uint16Array : Uint32Array;
+  const bufferViewMeshOpt = bufferView.extensions ? bufferView.extensions["EXT_meshopt_compression"] : void 0;
+  if (bufferViewMeshOpt === void 0) {
+    const buffer2 = gltf.buffers[bufferView.buffer].extras._pipeline.source;
+    return new SizedIndexType(
+      buffer2.buffer,
+      buffer2.byteOffset + // offset from the glb
+      (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0),
+      indexCount
+    );
+  }
+  const buffer = gltf.buffers[bufferViewMeshOpt.buffer].extras._pipeline.source;
+  const compressedBuffer = new Uint8Array(
+    buffer.buffer,
+    buffer.byteOffset + // offset from the start of the glb
+    (bufferViewMeshOpt.byteOffset ?? 0) + (accessor.byteOffset ?? 0),
+    bufferViewMeshOpt.byteLength
+  );
+  const indices = new SizedIndexType(indexCount);
+  meshoptDecoder.decodeIndexBuffer(
+    new Uint8Array(indices.buffer),
+    indexCount,
+    bufferViewMeshOpt.byteStride,
+    compressedBuffer
+  );
+  return indices;
+}
+function decodeEdgeIndices(gltf, name, meshoptDecoder) {
+  const primitive = gltf.meshes[0].primitives[0];
+  const accessor = gltf.accessors[primitive.extensions.CESIUM_tile_edges[name]];
+  const bufferView = gltf.bufferViews[accessor.bufferView];
+  const indexCount = accessor.count;
+  const SizedIndexType = accessor.componentType === ComponentDatatype_default.UNSIGNED_SHORT ? Uint16Array : Uint32Array;
+  const bufferViewMeshOpt = bufferView.extensions ? bufferView.extensions["EXT_meshopt_compression"] : void 0;
+  if (bufferViewMeshOpt === void 0) {
+    const buffer2 = gltf.buffers[bufferView.buffer].extras._pipeline.source;
+    return new SizedIndexType(
+      buffer2.buffer,
+      buffer2.byteOffset + // offset from the glb
+      (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0),
+      indexCount
+    );
+  }
+  const buffer = gltf.buffers[bufferViewMeshOpt.buffer].extras._pipeline.source;
+  const compressedBuffer = new Uint8Array(
+    buffer.buffer,
+    buffer.byteOffset + // offset from the start of the glb
+    (bufferViewMeshOpt.byteOffset ?? 0) + (accessor.byteOffset ?? 0),
+    bufferViewMeshOpt.byteLength
+  );
+  const indices = new SizedIndexType(indexCount);
+  const indexByteLength = bufferViewMeshOpt.byteStride;
+  meshoptDecoder.decodeIndexSequence(
+    new Uint8Array(indices.buffer),
+    indexCount,
+    indexByteLength,
+    compressedBuffer
+  );
+  return indices;
+}
+function decodeGltf(gltf, hasNormals, meshoptDecoder, result) {
+  result.positions = decodePositions(gltf, meshoptDecoder);
+  result.normals = hasNormals ? decodeNormals(gltf, meshoptDecoder) : void 0;
+  result.indices = decodeIndices(gltf, meshoptDecoder);
+  result.edgeIndicesWest = decodeEdgeIndices(gltf, "left", meshoptDecoder);
+  result.edgeIndicesSouth = decodeEdgeIndices(gltf, "bottom", meshoptDecoder);
+  result.edgeIndicesEast = decodeEdgeIndices(gltf, "right", meshoptDecoder);
+  result.edgeIndicesNorth = decodeEdgeIndices(gltf, "top", meshoptDecoder);
+  return result;
+}
+Cesium3DTilesTerrainGeometryProcessor.upsampleMesh = function(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  const {
+    isEastChild,
+    isNorthChild,
+    parentMinimumHeight,
+    parentMaximumHeight,
+    skirtHeight
+  } = options;
+  Check_default.typeOf.bool("options.isEastChild", isEastChild);
+  Check_default.typeOf.bool("options.isNorthChild", isNorthChild);
+  Check_default.typeOf.object("options.parentVertices", options.parentVertices);
+  Check_default.typeOf.object("options.parentIndices", options.parentIndices);
+  Check_default.typeOf.number(
+    "options.parentVertexCountWithoutSkirts",
+    options.parentVertexCountWithoutSkirts
+  );
+  Check_default.typeOf.number(
+    "options.parentIndexCountWithoutSkirts",
+    options.parentIndexCountWithoutSkirts
+  );
+  Check_default.typeOf.number("options.parentMinimumHeight", parentMinimumHeight);
+  Check_default.typeOf.number("options.parentMaximumHeight", parentMaximumHeight);
+  Check_default.typeOf.object("options.parentEncoding", options.parentEncoding);
+  Check_default.typeOf.object("options.rectangle", options.rectangle);
+  Check_default.typeOf.number("options.skirtHeight", skirtHeight);
+  Check_default.typeOf.object("options.ellipsoid", options.ellipsoid);
+  const indexCount = options.parentIndexCountWithoutSkirts;
+  const indices = options.parentIndices;
+  const vertexCount = options.parentVertexCountWithoutSkirts;
+  const vertexBuffer = options.parentVertices;
+  const encoding = TerrainEncoding_default.clone(
+    options.parentEncoding,
+    new TerrainEncoding_default()
+  );
+  const hasVertexNormals = encoding.hasVertexNormals;
+  const hasWebMercatorT = encoding.hasWebMercatorT;
+  const exaggeration = encoding.exaggeration;
+  const exaggerationRelativeHeight = encoding.exaggerationRelativeHeight;
+  const hasExaggeration = exaggeration !== 1;
+  const hasGeodeticSurfaceNormals = hasExaggeration;
+  const upsampleRectangle = Rectangle_default.clone(options.rectangle, new Rectangle_default());
+  const ellipsoid = Ellipsoid_default.clone(options.ellipsoid);
+  const upsampledTriIDs = [];
+  const upsampledUVs = [];
+  const upsampledBarys = [];
+  const upsampledIndices = [];
+  const upsampledWestIndices = [];
+  const upsampledSouthIndices = [];
+  const upsampledEastIndices = [];
+  const upsampledNorthIndices = [];
+  clipTileFromQuadrant(
+    isEastChild,
+    isNorthChild,
+    indexCount,
+    indices,
+    vertexCount,
+    vertexBuffer,
+    encoding,
+    upsampledIndices,
+    upsampledWestIndices,
+    upsampledSouthIndices,
+    upsampledEastIndices,
+    upsampledNorthIndices,
+    upsampledTriIDs,
+    upsampledBarys,
+    upsampledUVs
+  );
+  const approximateCenterCartographic = Rectangle_default.center(
+    upsampleRectangle,
+    scratchCenterCartographicUpsample
+  );
+  approximateCenterCartographic.height = 0.5 * (parentMinimumHeight + parentMaximumHeight);
+  const approximateCenterPosition = Cartographic_default.toCartesian(
+    approximateCenterCartographic,
+    ellipsoid,
+    scratchCenterCartesianUpsample
+  );
+  const upsampledVertexCountWithoutSkirts = upsampledTriIDs.length;
+  const upsampledTerrainEncoding = new TerrainEncoding_default(
+    approximateCenterPosition,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    hasVertexNormals,
+    hasWebMercatorT,
+    hasGeodeticSurfaceNormals,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const upsampledVertexBufferStride = upsampledTerrainEncoding.stride;
+  const upsampledSkirtVertexCount = TerrainProvider_default.getSkirtVertexCount(
+    upsampledWestIndices,
+    upsampledSouthIndices,
+    upsampledEastIndices,
+    upsampledNorthIndices
+  );
+  const upsampledVertexCountWithSkirts = upsampledVertexCountWithoutSkirts + upsampledSkirtVertexCount;
+  const upsampledIndexCountWithoutSkirts = upsampledIndices.length;
+  const upsampledSkirtIndexCount = TerrainProvider_default.getSkirtIndexCountWithFilledCorners(
+    upsampledSkirtVertexCount
+  );
+  const upsampledIndexCountWithSkirts = upsampledIndexCountWithoutSkirts + upsampledSkirtIndexCount;
+  const SizedIndexTypeWithSkirts = upsampledVertexCountWithSkirts <= 65535 ? Uint16Array : Uint32Array;
+  const upsampledIndexBuffer = new SizedIndexTypeWithSkirts(
+    upsampledIndexCountWithSkirts
+  );
+  upsampledIndexBuffer.set(upsampledIndices);
+  const upsampledWestIndicesBuffer = new SizedIndexTypeWithSkirts(
+    upsampledWestIndices
+  );
+  const upsampledSouthIndicesBuffer = new SizedIndexTypeWithSkirts(
+    upsampledSouthIndices
+  );
+  const upsampledEastIndicesBuffer = new SizedIndexTypeWithSkirts(
+    upsampledEastIndices
+  );
+  const upsampledNorthIndicesBuffer = new SizedIndexTypeWithSkirts(
+    upsampledNorthIndices
+  );
+  const upsampledVertexBuffer = new Float32Array(
+    upsampledVertexCountWithSkirts * upsampledVertexBufferStride
+  );
+  let upsampledVertexBufferOffset = 0;
+  const enuToEcef = Transforms_default.eastNorthUpToFixedFrame(
+    approximateCenterPosition,
+    ellipsoid,
+    scratchEnuToEcefUpsample
+  );
+  const ecefToEnu = Matrix4_default.inverseTransformation(
+    enuToEcef,
+    scratchEcefToEnuUpsample
+  );
+  const minimumLongitude = upsampleRectangle.west;
+  const maximumLongitude = upsampleRectangle.east;
+  const minimumLatitude = upsampleRectangle.south;
+  const maximumLatitude = upsampleRectangle.north;
+  const southMercatorAngle = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(minimumLatitude);
+  const northMercatorAngle = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(maximumLatitude);
+  const oneOverMercatorHeight = 1 / (northMercatorAngle - southMercatorAngle);
+  let minimumHeight = Number.POSITIVE_INFINITY;
+  let maximumHeight = Number.NEGATIVE_INFINITY;
+  let minPosEnu = Cartesian3_default.fromElements(
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    scratchMinimumPositionENUUpsample
+  );
+  let maxPosEnu = Cartesian3_default.fromElements(
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    scratchMaximumPositionENUUpsample
+  );
+  for (let i = 0; i < upsampledVertexCountWithoutSkirts; i++) {
+    const triId = upsampledTriIDs[i];
+    const indexA = indices[triId * 3 + 0];
+    const indexB = indices[triId * 3 + 1];
+    const indexC = indices[triId * 3 + 2];
+    const uv = scratchUVUpsample;
+    uv.x = upsampledUVs[i * 2 + 0];
+    uv.y = upsampledUVs[i * 2 + 1];
+    const u = uv.x;
+    const v = uv.y;
+    const baryA = upsampledBarys[i * 2 + 0];
+    const baryB = upsampledBarys[i * 2 + 1];
+    const baryC = 1 - baryA - baryB;
+    const heightA = encoding.decodeHeight(vertexBuffer, indexA);
+    const heightB = encoding.decodeHeight(vertexBuffer, indexB);
+    const heightC = encoding.decodeHeight(vertexBuffer, indexC);
+    const height = heightA * baryA + heightB * baryB + heightC * baryC;
+    minimumHeight = Math.min(height, minimumHeight);
+    maximumHeight = Math.max(height, maximumHeight);
+    const lon = Math_default.lerp(minimumLongitude, maximumLongitude, u);
+    const lat = Math_default.lerp(minimumLatitude, maximumLatitude, v);
+    const carto = Cartographic_default.fromRadians(
+      lon,
+      lat,
+      height,
+      scratchCartographicUpsample
+    );
+    const position = Cartographic_default.toCartesian(
+      carto,
+      ellipsoid,
+      scratchPosEcefUpsample
+    );
+    const posEnu = Matrix4_default.multiplyByPoint(
+      ecefToEnu,
+      position,
+      scratchPosEnuUpsample
+    );
+    minPosEnu = Cartesian3_default.minimumByComponent(posEnu, minPosEnu, minPosEnu);
+    maxPosEnu = Cartesian3_default.maximumByComponent(posEnu, maxPosEnu, maxPosEnu);
+    let normalOct;
+    if (hasVertexNormals) {
+      const normalA = encoding.decodeNormal(
+        vertexBuffer,
+        indexA,
+        scratchNormalA
+      );
+      const normalB = encoding.decodeNormal(
+        vertexBuffer,
+        indexB,
+        scratchNormalB
+      );
+      const normalC = encoding.decodeNormal(
+        vertexBuffer,
+        indexC,
+        scratchNormalC
+      );
+      let normal = Cartesian3_default.fromElements(
+        normalA.x * baryA + normalB.x * baryB + normalC.x * baryC,
+        normalA.y * baryA + normalB.y * baryB + normalC.y * baryC,
+        normalA.z * baryA + normalB.z * baryB + normalC.z * baryC,
+        scratchNormalUpsample
+      );
+      normal = Cartesian3_default.normalize(normal, scratchNormalUpsample);
+      normalOct = AttributeCompression_default.octEncode(
+        normal,
+        scratchNormalOctUpsample
+      );
+    }
+    let webMercatorT;
+    if (hasWebMercatorT) {
+      const mercatorAngle = WebMercatorProjection_default.geodeticLatitudeToMercatorAngle(lat);
+      webMercatorT = (mercatorAngle - southMercatorAngle) * oneOverMercatorHeight;
+    }
+    let geodeticSurfaceNormal;
+    if (hasGeodeticSurfaceNormals) {
+      geodeticSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
+        position,
+        scratchGeodeticSurfaceNormalUpsample
+      );
+    }
+    upsampledVertexBufferOffset = upsampledTerrainEncoding.encode(
+      upsampledVertexBuffer,
+      upsampledVertexBufferOffset,
+      position,
+      uv,
+      height,
+      normalOct,
+      webMercatorT,
+      geodeticSurfaceNormal
+    );
+  }
+  const orientedBoundingBox = OrientedBoundingBox_default.fromRectangle(
+    upsampleRectangle,
+    minimumHeight,
+    maximumHeight,
+    ellipsoid,
+    scratchOrientedBoundingBox
+  );
+  const boundingSphere = BoundingSphere_default.fromVertices(
+    upsampledVertexBuffer,
+    upsampledTerrainEncoding.center,
+    upsampledVertexBufferStride,
+    scratchBoundingSphere
+  );
+  const occluder = new EllipsoidalOccluder_default(ellipsoid);
+  const horizonOcclusionPoint = occluder.computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid(
+    upsampledTerrainEncoding.center,
+    // vector from ellipsoid center to horizon occlusion point
+    upsampledVertexBuffer,
+    upsampledVertexBufferStride,
+    upsampledTerrainEncoding.center,
+    minimumHeight,
+    scratchHorizonOcclusionPoint
+  );
+  const upsampledMesh = new TerrainMesh_default(
+    Cartesian3_default.clone(upsampledTerrainEncoding.center, new Cartesian3_default()),
+    upsampledVertexBuffer,
+    upsampledIndexBuffer,
+    upsampledIndexCountWithoutSkirts,
+    upsampledVertexCountWithoutSkirts,
+    minimumHeight,
+    maximumHeight,
+    upsampleRectangle,
+    BoundingSphere_default.clone(boundingSphere),
+    Cartesian3_default.clone(horizonOcclusionPoint),
+    upsampledVertexBufferStride,
+    OrientedBoundingBox_default.clone(orientedBoundingBox),
+    upsampledTerrainEncoding,
+    upsampledWestIndicesBuffer,
+    upsampledSouthIndicesBuffer,
+    upsampledEastIndicesBuffer,
+    upsampledNorthIndicesBuffer
+  );
+  addSkirtsToMesh(
+    upsampledMesh,
+    upsampleRectangle,
+    ellipsoid,
+    minPosEnu,
+    maxPosEnu,
+    enuToEcef,
+    ecefToEnu,
+    skirtHeight
+  );
+  return upsampledMesh;
+};
+function addSkirtsToMesh(mesh, rectangle, ellipsoid, enuMinimum, enuMaximum, enuToEcef, ecefToEnu, skirtHeight) {
+  const { encoding } = mesh;
+  const vertexStride = encoding.stride;
+  const vertexBuffer = mesh.vertices;
+  const {
+    hasVertexNormals,
+    hasWebMercatorT,
+    exaggeration,
+    exaggerationRelativeHeight
+  } = encoding;
+  const hasExaggeration = exaggeration !== 1;
+  const hasGeodeticSurfaceNormals = hasExaggeration;
+  const vertexCountWithoutSkirts = mesh.vertexCountWithoutSkirts;
+  let vertexBufferOffset = vertexCountWithoutSkirts * vertexStride;
+  const vertexCountWithSkirts = vertexBuffer.length / vertexStride;
+  const skirtVertexCount = vertexCountWithSkirts - vertexCountWithoutSkirts;
+  const indices = mesh.indices;
+  const indexCountWithoutSkirts = mesh.indexCountWithoutSkirts;
+  const westIndices = mesh.westIndicesSouthToNorth;
+  const southIndices = mesh.southIndicesEastToWest;
+  const eastIndices = mesh.eastIndicesNorthToSouth;
+  const northIndices = mesh.northIndicesWestToEast;
+  TerrainProvider_default.addSkirtIndicesWithFilledCorners(
+    westIndices,
+    southIndices,
+    eastIndices,
+    northIndices,
+    vertexCountWithoutSkirts,
+    indices,
+    indexCountWithoutSkirts
+  );
+  const westOffset = 0;
+  const southOffset = westOffset + westIndices.length;
+  const eastOffset = southOffset + southIndices.length;
+  const northOffset = eastOffset + eastIndices.length;
+  const edges = [westIndices, southIndices, eastIndices, northIndices];
+  const edgeIndexOffset = [westOffset, southOffset, eastOffset, northOffset];
+  const edgeLongitudeSign = [-1, 0, 1, 0];
+  const edgeLatitudeSign = [0, -1, 0, 1];
+  const minimumPositionENUWithSkirts = Cartesian3_default.clone(
+    enuMinimum,
+    scratchMinimumPositionENUSkirt
+  );
+  const maximumPositionENUWithSkirts = Cartesian3_default.clone(
+    enuMaximum,
+    scratchMaximumPositionENUSkirt
+  );
+  const maximumHeight = mesh.maximumHeight;
+  const minimumHeightWithSkirts = mesh.minimumHeight - skirtHeight;
+  for (let skirtId = 0; skirtId < skirtVertexCount; skirtId++) {
+    let side;
+    for (side = 0; side < 3; side++) {
+      if (skirtId < edgeIndexOffset[side + 1]) {
+        break;
+      }
+    }
+    const vertexIndex = edges[side][skirtId - edgeIndexOffset[side]];
+    const uv = encoding.decodeTextureCoordinates(
+      vertexBuffer,
+      vertexIndex,
+      scratchUVSkirt
+    );
+    const skirtLonLatOffsetPercent = 1e-4;
+    const longitudeT = uv.x + edgeLongitudeSign[side] * skirtLonLatOffsetPercent;
+    const latitudeT = uv.y + edgeLatitudeSign[side] * skirtLonLatOffsetPercent;
+    const longitude = Math_default.lerp(
+      rectangle.west,
+      rectangle.east,
+      longitudeT
+    );
+    const latitude = Math_default.clamp(
+      Math_default.lerp(rectangle.south, rectangle.north, latitudeT),
+      -Math_default.PI_OVER_TWO,
+      +Math_default.PI_OVER_TWO
+    );
+    const vertHeight = encoding.decodeHeight(vertexBuffer, vertexIndex);
+    const height = vertHeight - skirtHeight;
+    const cartographic = Cartographic_default.fromRadians(
+      longitude,
+      latitude,
+      height,
+      scratchCartographicSkirt
+    );
+    const positionEcef = Cartographic_default.toCartesian(
+      cartographic,
+      ellipsoid,
+      scratchPosEcefSkirt
+    );
+    let normalOct;
+    if (hasVertexNormals) {
+      normalOct = encoding.getOctEncodedNormal(
+        vertexBuffer,
+        vertexIndex,
+        scratchNormalOctSkirt
+      );
+    }
+    let webMercatorT;
+    if (hasWebMercatorT) {
+      webMercatorT = encoding.decodeWebMercatorT(vertexBuffer, vertexIndex);
+    }
+    let geodeticSurfaceNormal;
+    if (hasGeodeticSurfaceNormals) {
+      geodeticSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
+        positionEcef,
+        scratchGeodeticSurfaceNormalSkirt
+      );
+    }
+    vertexBufferOffset = encoding.encode(
+      vertexBuffer,
+      vertexBufferOffset,
+      positionEcef,
+      uv,
+      height,
+      normalOct,
+      webMercatorT,
+      geodeticSurfaceNormal
+    );
+    const positionENU = Matrix4_default.multiplyByPoint(
+      ecefToEnu,
+      positionEcef,
+      scratchPosEnuSkirt
+    );
+    Cartesian3_default.minimumByComponent(
+      positionENU,
+      minimumPositionENUWithSkirts,
+      minimumPositionENUWithSkirts
+    );
+    Cartesian3_default.maximumByComponent(
+      positionENU,
+      maximumPositionENUWithSkirts,
+      maximumPositionENUWithSkirts
+    );
+  }
+  const aabbEnuWithSkirts = AxisAlignedBoundingBox_default.fromCorners(
+    minimumPositionENUWithSkirts,
+    maximumPositionENUWithSkirts,
+    scratchAABBEnuSkirt
+  );
+  const encodingWithSkirts = new TerrainEncoding_default(
+    encoding.center,
+    aabbEnuWithSkirts,
+    minimumHeightWithSkirts,
+    maximumHeight,
+    enuToEcef,
+    encoding.hasVertexNormals,
+    encoding.hasWebMercatorT,
+    hasGeodeticSurfaceNormals,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  if (encoding.quantization !== encodingWithSkirts.quantization) {
+    const finalEncoding = encodingWithSkirts;
+    const finalVertexStride = finalEncoding.stride;
+    const finalVertexBuffer = new Float32Array(
+      vertexCountWithSkirts * finalVertexStride
+    );
+    let finalVertexBufferOffset = 0;
+    for (let i = 0; i < vertexCountWithSkirts; i++) {
+      finalVertexBufferOffset = finalEncoding.encode(
+        finalVertexBuffer,
+        finalVertexBufferOffset,
+        encoding.decodePosition(vertexBuffer, i, scratchPosEcefSkirt),
+        encoding.decodeTextureCoordinates(vertexBuffer, i, scratchUVSkirt),
+        encoding.decodeHeight(vertexBuffer, i),
+        encoding.hasVertexNormals ? encoding.getOctEncodedNormal(vertexBuffer, i, scratchNormalOctSkirt) : void 0,
+        encoding.hasWebMercatorT ? encoding.decodeWebMercatorT(vertexBuffer, i) : void 0,
+        encoding.hasGeodeticSurfaceNormals ? encoding.decodeGeodeticSurfaceNormal(
+          vertexBuffer,
+          i,
+          scratchGeodeticSurfaceNormalSkirt
+        ) : void 0
+      );
+    }
+    mesh.vertices = finalVertexBuffer;
+    mesh.stride = finalVertexStride;
+    mesh.encoding = finalEncoding;
+  }
+  return mesh;
+}
+var EDGE_ID_LEFT = 0;
+var EDGE_ID_TOP = 1;
+var EDGE_ID_RIGHT = 2;
+var EDGE_ID_BOTTOM = 3;
+var EDGE_COUNT = 4;
+var scratchIntersection = new Cartesian3_default();
+var scratchInBarys = [
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default()
+];
+var scratchInPoints = [
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default()
+];
+var scratchOutBarys = [
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default()
+];
+var scratchOutPoints = [
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default()
+];
+function inside(boxMinimum, boxMaximum, edgeId, p) {
+  switch (edgeId) {
+    case EDGE_ID_LEFT:
+      return Math_default.sign(p.x - boxMinimum.x);
+    case EDGE_ID_RIGHT:
+      return Math_default.sign(boxMaximum.x - p.x);
+    case EDGE_ID_BOTTOM:
+      return Math_default.sign(p.y - boxMinimum.y);
+    default:
+      return Math_default.sign(boxMaximum.y - p.y);
+  }
+}
+function intersect(boxMinimum, boxMaximum, edgeId, a, b, result) {
+  let t, intersectX, intersectY;
+  switch (edgeId) {
+    case EDGE_ID_LEFT:
+      t = (boxMinimum.x - a.x) / (b.x - a.x);
+      intersectX = boxMinimum.x;
+      intersectY = a.y + (b.y - a.y) * t;
+      break;
+    case EDGE_ID_RIGHT:
+      t = (boxMaximum.x - a.x) / (b.x - a.x);
+      intersectX = boxMaximum.x;
+      intersectY = a.y + (b.y - a.y) * t;
+      break;
+    case EDGE_ID_BOTTOM:
+      t = (boxMinimum.y - a.y) / (b.y - a.y);
+      intersectX = a.x + (b.x - a.x) * t;
+      intersectY = boxMinimum.y;
+      break;
+    default:
+      t = (boxMaximum.y - a.y) / (b.y - a.y);
+      intersectX = a.x + (b.x - a.x) * t;
+      intersectY = boxMaximum.y;
+      break;
+  }
+  return Cartesian3_default.fromElements(intersectX, intersectY, t, result);
+}
+var scratchPolygon = {
+  length: 0,
+  coordinates: [
+    new Cartesian2_default(),
+    new Cartesian2_default(),
+    new Cartesian2_default(),
+    new Cartesian2_default(),
+    new Cartesian2_default(),
+    new Cartesian2_default()
+  ],
+  barycentricCoordinates: [
+    new Cartesian3_default(),
+    new Cartesian3_default(),
+    new Cartesian3_default(),
+    new Cartesian3_default(),
+    new Cartesian3_default(),
+    new Cartesian3_default()
+  ]
+};
+function clipTriangleAgainstBoxEdgeRange(edgeStart, edgeCount, boxMinimum, boxMaximum, p0, p1, p2, result) {
+  let inputLength;
+  let inputPoints = scratchInPoints;
+  let inputBarys = scratchInBarys;
+  let outputLength = 3;
+  let outputPoints = scratchOutPoints;
+  Cartesian2_default.clone(p0, outputPoints[0]);
+  Cartesian2_default.clone(p1, outputPoints[1]);
+  Cartesian2_default.clone(p2, outputPoints[2]);
+  let outputBarys = scratchOutBarys;
+  Cartesian3_default.fromElements(1, 0, 0, outputBarys[0]);
+  Cartesian3_default.fromElements(0, 1, 0, outputBarys[1]);
+  Cartesian3_default.fromElements(0, 0, 1, outputBarys[2]);
+  for (let e = 0; e < edgeCount; e++) {
+    const edgeId = (edgeStart + e) % EDGE_COUNT;
+    const tempPoints = inputPoints;
+    const tempBarys = inputBarys;
+    inputPoints = outputPoints;
+    inputBarys = outputBarys;
+    inputLength = outputLength;
+    outputPoints = tempPoints;
+    outputBarys = tempBarys;
+    outputLength = 0;
+    const prevIdx = inputLength - 1;
+    let prevPoint = inputPoints[prevIdx];
+    let prevBary = inputBarys[prevIdx];
+    let prevInside = inside(boxMinimum, boxMaximum, edgeId, prevPoint);
+    for (let currIdx = 0; currIdx < inputLength; currIdx++) {
+      const currPoint = inputPoints[currIdx];
+      const currBary = inputBarys[currIdx];
+      const currInside = inside(boxMinimum, boxMaximum, edgeId, currPoint);
+      if (prevInside * currInside === -1) {
+        const intersection = intersect(
+          boxMinimum,
+          boxMaximum,
+          edgeId,
+          prevPoint,
+          currPoint,
+          scratchIntersection
+        );
+        const { x, y, z: t } = intersection;
+        const tInv = 1 - t;
+        const baryA = prevBary.x * tInv + currBary.x * t;
+        const baryB = prevBary.y * tInv + currBary.y * t;
+        const baryC = prevBary.z * tInv + currBary.z * t;
+        Cartesian2_default.fromElements(x, y, outputPoints[outputLength]);
+        Cartesian3_default.fromElements(baryA, baryB, baryC, outputBarys[outputLength]);
+        outputLength++;
+      }
+      if (currInside >= 0) {
+        Cartesian2_default.clone(currPoint, outputPoints[outputLength]);
+        Cartesian3_default.clone(currBary, outputBarys[outputLength]);
+        outputLength++;
+      }
+      prevPoint = currPoint;
+      prevBary = currBary;
+      prevInside = currInside;
+    }
+    if (outputLength === 0) {
+      break;
+    }
+  }
+  result.length = outputLength;
+  for (let i = 0; i < outputLength; i++) {
+    Cartesian2_default.clone(outputPoints[i], result.coordinates[i]);
+    Cartesian3_default.clone(outputBarys[i], result.barycentricCoordinates[i]);
+  }
+  return result;
+}
+function clipTriangleFromQuadrant(isEastChild, isNorthChild, boxMinimum, boxMaximum, p0, p1, p2, result) {
+  const edgeStart = isEastChild ? isNorthChild ? EDGE_ID_BOTTOM : EDGE_ID_LEFT : isNorthChild ? EDGE_ID_RIGHT : EDGE_ID_TOP;
+  return clipTriangleAgainstBoxEdgeRange(
+    edgeStart,
+    2,
+    boxMinimum,
+    boxMaximum,
+    p0,
+    p1,
+    p2,
+    result
+  );
+}
+var lookUpTableBaryToPrim = [
+  [],
+  // 000
+  [0],
+  // 001
+  [1],
+  // 010
+  [0, 1],
+  // 011
+  [2],
+  // 100
+  [0, 2],
+  // 101
+  [1, 2],
+  // 110
+  [0, 1, 2]
+  // 111
+];
+function clipTileFromQuadrant(isEastChild, isNorthChild, indexCount, indices, vertexCount, vertices, vertexEncoding, resultIndices, resultWestIndices, resultSouthIndices, resultEastIndices, resultNorthIndices, resultTriIds, resultBary, resultUVs) {
+  const upsampledVertexMap = {};
+  const minU = isEastChild ? 0.5 : 0;
+  const maxU = isEastChild ? 1 : 0.5;
+  const minV = isNorthChild ? 0.5 : 0;
+  const maxV = isNorthChild ? 1 : 0.5;
+  const minUV = scratchMinUV;
+  minUV.x = minU;
+  minUV.y = minV;
+  const maxUV = scratchMaxUV;
+  maxUV.x = maxU;
+  maxUV.y = maxV;
+  let upsampledVertexCount = 0;
+  for (let i = 0; i < indexCount; i += 3) {
+    const indexA = indices[i + 0];
+    const indexB = indices[i + 1];
+    const indexC = indices[i + 2];
+    const uvA = vertexEncoding.decodeTextureCoordinates(
+      vertices,
+      indexA,
+      scratchUvA
+    );
+    const uvB = vertexEncoding.decodeTextureCoordinates(
+      vertices,
+      indexB,
+      scratchUvB
+    );
+    const uvC = vertexEncoding.decodeTextureCoordinates(
+      vertices,
+      indexC,
+      scratchUvC
+    );
+    const clippedPolygon = clipTriangleFromQuadrant(
+      isEastChild,
+      isNorthChild,
+      minUV,
+      maxUV,
+      uvA,
+      uvB,
+      uvC,
+      scratchPolygon
+    );
+    const clippedPolygonLength = clippedPolygon.length;
+    if (clippedPolygonLength < 3) {
+      continue;
+    }
+    const polygonUpsampledIndices = scratchPolygonIndices;
+    for (let p = 0; p < clippedPolygonLength; p++) {
+      const polygonBary = clippedPolygon.barycentricCoordinates[p];
+      const bA = polygonBary.x;
+      const bB = polygonBary.y;
+      const bC = polygonBary.z;
+      const baryId = Math.ceil(bA) | Math.ceil(bB) << 1 | Math.ceil(bC) << 2;
+      const primitiveIds = lookUpTableBaryToPrim[baryId];
+      let upsampledIndex;
+      let isNewVertex = false;
+      if (primitiveIds.length === 1) {
+        const pointPrimitiveId = primitiveIds[0];
+        const pointIndex = indices[i + pointPrimitiveId];
+        const pointKey = pointIndex;
+        upsampledIndex = upsampledVertexMap[pointKey];
+        if (upsampledIndex === void 0) {
+          isNewVertex = true;
+          upsampledIndex = upsampledVertexCount++;
+          upsampledVertexMap[pointKey] = upsampledIndex;
+        }
+      } else if (primitiveIds.length === 2) {
+        const edgePrimitiveIdA = primitiveIds[0];
+        const edgePrimitiveIdB = primitiveIds[1];
+        const edgeIndexA = indices[i + edgePrimitiveIdA];
+        const edgeIndexB = indices[i + edgePrimitiveIdB];
+        const prevBary = clippedPolygon.barycentricCoordinates[(p + clippedPolygonLength - 1) % clippedPolygonLength];
+        const prevBaryId = Math.ceil(prevBary.x) | Math.ceil(prevBary.y) << 1 | Math.ceil(prevBary.z) << 2;
+        const sameEdge = baryId === prevBaryId;
+        const minIndex = Math.min(edgeIndexA, edgeIndexB);
+        const maxIndex = Math.max(edgeIndexA, edgeIndexB);
+        const baseKey = vertexCount + 2 * (minIndex * vertexCount + maxIndex);
+        const firstKey = baseKey + 0;
+        const secondKey = baseKey + 1;
+        const firstEntry = upsampledVertexMap[firstKey];
+        const secondEntry = upsampledVertexMap[secondKey];
+        const useFirst = !sameEdge === (firstEntry === void 0 || secondEntry === void 0);
+        upsampledIndex = useFirst ? firstEntry : secondEntry;
+        if (upsampledIndex === void 0) {
+          isNewVertex = true;
+          upsampledIndex = upsampledVertexCount++;
+          const edgeKey = useFirst ? firstKey : secondKey;
+          upsampledVertexMap[edgeKey] = upsampledIndex;
+        }
+      } else {
+        isNewVertex = true;
+        upsampledIndex = upsampledVertexCount++;
+      }
+      polygonUpsampledIndices[p] = upsampledIndex;
+      if (isNewVertex) {
+        const triId = i / 3;
+        resultTriIds.push(triId);
+        const polygonUV = clippedPolygon.coordinates[p];
+        const u = (polygonUV.x - minU) / (maxU - minU);
+        const v = (polygonUV.y - minV) / (maxV - minV);
+        resultUVs.push(u, v);
+        resultBary.push(bA, bB);
+        if (u === 0) {
+          resultWestIndices.push(upsampledIndex);
+        } else if (u === 1) {
+          resultEastIndices.push(upsampledIndex);
+        }
+        if (v === 0) {
+          resultSouthIndices.push(upsampledIndex);
+        } else if (v === 1) {
+          resultNorthIndices.push(upsampledIndex);
+        }
+      }
+    }
+    const ui0 = polygonUpsampledIndices[0];
+    let ui1 = polygonUpsampledIndices[1];
+    let ui2 = polygonUpsampledIndices[2];
+    resultIndices.push(ui0, ui1, ui2);
+    for (let j = 3; j < clippedPolygonLength; j++) {
+      ui1 = ui2;
+      ui2 = polygonUpsampledIndices[j];
+      resultIndices.push(ui0, ui1, ui2);
+    }
+  }
+  resultWestIndices.sort(function(a, b) {
+    return resultUVs[a * 2 + 1] - resultUVs[b * 2 + 1];
+  });
+  resultSouthIndices.sort(function(a, b) {
+    return resultUVs[b * 2 + 0] - resultUVs[a * 2 + 0];
+  });
+  resultEastIndices.sort(function(a, b) {
+    return resultUVs[b * 2 + 1] - resultUVs[a * 2 + 1];
+  });
+  resultNorthIndices.sort(function(a, b) {
+    return resultUVs[a * 2 + 0] - resultUVs[b * 2 + 0];
+  });
+}
+var Cesium3DTilesTerrainGeometryProcessor_default = Cesium3DTilesTerrainGeometryProcessor;
+
+export {
+  Cesium3DTilesTerrainGeometryProcessor_default
+};