@hztxi/cesium-engine 25.0.2 → 25.0.3

package/Build/Workers/createMvtTile.js

@@ -0,0 +1,1815 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.144.0
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  createTaskProcessorWorker_default
+} from "./chunk-UUXWWJI7.js";
+import {
+  WebMercatorProjection_default
+} from "./chunk-JTSSQ3RH.js";
+import {
+  oneTimeWarning_default
+} from "./chunk-DLHFYNG6.js";
+import {
+  PolygonPipeline_default
+} from "./chunk-2PFSIZOR.js";
+import "./chunk-K724BR5O.js";
+import {
+  PrimitiveType_default
+} from "./chunk-DHCQSFRN.js";
+import {
+  Matrix2_default,
+  Rectangle_default
+} from "./chunk-GDHSPLWC.js";
+import {
+  Cartesian4_default,
+  Matrix4_default
+} from "./chunk-ZSWY7UNG.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-6KWWDFT4.js";
+import {
+  WebGLConstants_default
+} from "./chunk-YGFVAGYF.js";
+import {
+  RuntimeError_default
+} from "./chunk-VDX4SJKV.js";
+import {
+  Cartesian2_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-UT7YX565.js";
+import {
+  Cartesian3_default,
+  Frozen_default,
+  Matrix3_default
+} from "./chunk-76HD3HYN.js";
+import "./chunk-TA3PH4Q7.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-UDKEO3UF.js";
+import {
+  __publicField,
+  defined_default
+} from "./chunk-NYQSZLRF.js";
+
+// packages/engine/Source/Core/WebMercatorTilingScheme.js
+var southwestScratch = new Cartographic_default();
+var northeastScratch = new Cartographic_default();
+var southwestCartesianScratch = new Cartesian3_default();
+var northeastCartesianScratch = new Cartesian3_default();
+var WebMercatorTilingScheme = class {
+  /**
+   * @param {object} [options] Object with the following properties:
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.default] The ellipsoid whose surface is being tiled. Defaults to
+   * the default ellipsoid.
+   * @param {number} [options.numberOfLevelZeroTilesX=1] The number of tiles in the X direction at level zero of
+   *        the tile tree.
+   * @param {number} [options.numberOfLevelZeroTilesY=1] The number of tiles in the Y direction at level zero of
+   *        the tile tree.
+   * @param {Cartesian2} [options.rectangleSouthwestInMeters] The southwest corner of the rectangle covered by the
+   *        tiling scheme, in meters.  If this parameter or rectangleNortheastInMeters is not specified, the entire
+   *        globe is covered in the longitude direction and an equal distance is covered in the latitude
+   *        direction, resulting in a square projection.
+   * @param {Cartesian2} [options.rectangleNortheastInMeters] The northeast corner of the rectangle covered by the
+   *        tiling scheme, in meters.  If this parameter or rectangleSouthwestInMeters is not specified, the entire
+   *        globe is covered in the longitude direction and an equal distance is covered in the latitude
+   *        direction, resulting in a square projection.
+   */
+  constructor(options) {
+    /**
+     * @type {Cartesian2}
+     * @private
+     */
+    __publicField(this, "_rectangleSouthwestInMeters");
+    /**
+     * @type {Cartesian2}
+     * @private
+     */
+    __publicField(this, "_rectangleNortheastInMeters");
+    options = options ?? Frozen_default.EMPTY_OBJECT;
+    this._ellipsoid = options.ellipsoid ?? Ellipsoid_default.default;
+    this._numberOfLevelZeroTilesX = options.numberOfLevelZeroTilesX ?? 1;
+    this._numberOfLevelZeroTilesY = options.numberOfLevelZeroTilesY ?? 1;
+    this._projection = new WebMercatorProjection_default(this._ellipsoid);
+    if (defined_default(options.rectangleSouthwestInMeters) && defined_default(options.rectangleNortheastInMeters)) {
+      this._rectangleSouthwestInMeters = options.rectangleSouthwestInMeters;
+      this._rectangleNortheastInMeters = options.rectangleNortheastInMeters;
+    } else {
+      const semimajorAxisTimesPi = this._ellipsoid.maximumRadius * Math.PI;
+      this._rectangleSouthwestInMeters = new Cartesian2_default(
+        -semimajorAxisTimesPi,
+        -semimajorAxisTimesPi
+      );
+      this._rectangleNortheastInMeters = new Cartesian2_default(
+        semimajorAxisTimesPi,
+        semimajorAxisTimesPi
+      );
+    }
+    let { x, y } = this._rectangleSouthwestInMeters;
+    Cartesian3_default.fromElements(x, y, 0, southwestCartesianScratch);
+    this._projection.unproject(southwestCartesianScratch, southwestScratch);
+    ({ x, y } = this._rectangleNortheastInMeters);
+    Cartesian3_default.fromElements(x, y, 0, northeastCartesianScratch);
+    this._projection.unproject(northeastCartesianScratch, northeastScratch);
+    this._rectangle = new Rectangle_default(
+      southwestScratch.longitude,
+      southwestScratch.latitude,
+      northeastScratch.longitude,
+      northeastScratch.latitude
+    );
+  }
+  /**
+   * Gets the ellipsoid that is tiled by this tiling scheme.
+   * @type {Ellipsoid}
+   */
+  get ellipsoid() {
+    return this._ellipsoid;
+  }
+  /**
+   * Gets the rectangle, in radians, covered by this tiling scheme.
+   * @type {Rectangle}
+   */
+  get rectangle() {
+    return this._rectangle;
+  }
+  /**
+   * Gets the map projection used by this tiling scheme.
+   * @type {MapProjection}
+   */
+  get projection() {
+    return this._projection;
+  }
+  /**
+   * Gets the total number of tiles in the X direction at a specified level-of-detail.
+   *
+   * @param {number} level The level-of-detail.
+   * @returns {number} The number of tiles in the X direction at the given level.
+   */
+  getNumberOfXTilesAtLevel(level) {
+    return this._numberOfLevelZeroTilesX << level;
+  }
+  /**
+   * Gets the total number of tiles in the Y direction at a specified level-of-detail.
+   *
+   * @param {number} level The level-of-detail.
+   * @returns {number} The number of tiles in the Y direction at the given level.
+   */
+  getNumberOfYTilesAtLevel(level) {
+    return this._numberOfLevelZeroTilesY << level;
+  }
+  /**
+   * Transforms a rectangle specified in geodetic radians to the native coordinate system
+   * of this tiling scheme.
+   *
+   * @param {Rectangle} rectangle The rectangle to transform.
+   * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Rectangle} The specified 'result', or a new object containing the native rectangle if 'result'
+   *          is undefined.
+   */
+  rectangleToNativeRectangle(rectangle, result) {
+    const projection = this._projection;
+    const southwest = projection.project(Rectangle_default.southwest(rectangle));
+    const northeast = projection.project(Rectangle_default.northeast(rectangle));
+    if (!defined_default(result)) {
+      return new Rectangle_default(southwest.x, southwest.y, northeast.x, northeast.y);
+    }
+    result.west = southwest.x;
+    result.south = southwest.y;
+    result.east = northeast.x;
+    result.north = northeast.y;
+    return result;
+  }
+  /**
+   * Converts tile x, y coordinates and level to a rectangle expressed in the native coordinates
+   * of the tiling scheme.
+   *
+   * @param {number} x The integer x coordinate of the tile.
+   * @param {number} y The integer y coordinate of the tile.
+   * @param {number} level The tile level-of-detail.  Zero is the least detailed.
+   * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Rectangle} The specified 'result', or a new object containing the rectangle
+   *          if 'result' is undefined.
+   */
+  tileXYToNativeRectangle(x, y, level, result) {
+    const xTiles = this.getNumberOfXTilesAtLevel(level);
+    const yTiles = this.getNumberOfYTilesAtLevel(level);
+    const xTileWidth = (this._rectangleNortheastInMeters.x - this._rectangleSouthwestInMeters.x) / xTiles;
+    const west = this._rectangleSouthwestInMeters.x + x * xTileWidth;
+    const east = this._rectangleSouthwestInMeters.x + (x + 1) * xTileWidth;
+    const yTileHeight = (this._rectangleNortheastInMeters.y - this._rectangleSouthwestInMeters.y) / yTiles;
+    const north = this._rectangleNortheastInMeters.y - y * yTileHeight;
+    const south = this._rectangleNortheastInMeters.y - (y + 1) * yTileHeight;
+    if (!defined_default(result)) {
+      return new Rectangle_default(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
+  }
+  /**
+   * Converts tile x, y coordinates and level to a cartographic rectangle in radians.
+   *
+   * @param {number} x The integer x coordinate of the tile.
+   * @param {number} y The integer y coordinate of the tile.
+   * @param {number} level The tile level-of-detail.  Zero is the least detailed.
+   * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Rectangle} The specified 'result', or a new object containing the rectangle
+   *          if 'result' is undefined.
+   */
+  tileXYToRectangle(x, y, level, result) {
+    const nativeRectangle = this.tileXYToNativeRectangle(x, y, level, result);
+    const projection = this._projection;
+    const southwest = projection.unproject(
+      new Cartesian3_default(nativeRectangle.west, nativeRectangle.south)
+    );
+    const northeast = projection.unproject(
+      new Cartesian3_default(nativeRectangle.east, nativeRectangle.north)
+    );
+    nativeRectangle.west = southwest.longitude;
+    nativeRectangle.south = southwest.latitude;
+    nativeRectangle.east = northeast.longitude;
+    nativeRectangle.north = northeast.latitude;
+    return nativeRectangle;
+  }
+  /**
+   * Calculates the tile x, y coordinates of the tile containing
+   * a given cartographic position.
+   *
+   * @param {Cartographic} position The position.
+   * @param {number} level The tile level-of-detail.  Zero is the least detailed.
+   * @param {Cartesian2} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Cartesian2} The specified 'result', or a new object containing the tile x, y coordinates
+   *          if 'result' is undefined.
+   */
+  positionToTileXY(position, level, result) {
+    const rectangle = this._rectangle;
+    if (!Rectangle_default.contains(rectangle, position)) {
+      return void 0;
+    }
+    const xTiles = this.getNumberOfXTilesAtLevel(level);
+    const yTiles = this.getNumberOfYTilesAtLevel(level);
+    const overallWidth = this._rectangleNortheastInMeters.x - this._rectangleSouthwestInMeters.x;
+    const xTileWidth = overallWidth / xTiles;
+    const overallHeight = this._rectangleNortheastInMeters.y - this._rectangleSouthwestInMeters.y;
+    const yTileHeight = overallHeight / yTiles;
+    const projection = this._projection;
+    const webMercatorPosition = projection.project(position);
+    const distanceFromWest = webMercatorPosition.x - this._rectangleSouthwestInMeters.x;
+    const distanceFromNorth = this._rectangleNortheastInMeters.y - webMercatorPosition.y;
+    let xTileCoordinate = distanceFromWest / xTileWidth | 0;
+    if (xTileCoordinate >= xTiles) {
+      xTileCoordinate = xTiles - 1;
+    }
+    let yTileCoordinate = distanceFromNorth / yTileHeight | 0;
+    if (yTileCoordinate >= yTiles) {
+      yTileCoordinate = yTiles - 1;
+    }
+    if (!defined_default(result)) {
+      return new Cartesian2_default(xTileCoordinate, yTileCoordinate);
+    }
+    result.x = xTileCoordinate;
+    result.y = yTileCoordinate;
+    return result;
+  }
+};
+var WebMercatorTilingScheme_default = WebMercatorTilingScheme;
+
+// packages/engine/Source/Scene/MetadataType.js
+var MetadataType = {
+  /**
+   * A single component
+   *
+   * @type {string}
+   * @constant
+   */
+  SCALAR: "SCALAR",
+  /**
+   * A vector with two components
+   *
+   * @type {string}
+   * @constant
+   */
+  VEC2: "VEC2",
+  /**
+   * A vector with three components
+   *
+   * @type {string}
+   * @constant
+   */
+  VEC3: "VEC3",
+  /**
+   * A vector with four components
+   *
+   * @type {string}
+   * @constant
+   */
+  VEC4: "VEC4",
+  /**
+   * A 2x2 matrix, stored in column-major format.
+   *
+   * @type {string}
+   * @constant
+   */
+  MAT2: "MAT2",
+  /**
+   * A 3x3 matrix, stored in column-major format.
+   *
+   * @type {string}
+   * @constant
+   */
+  MAT3: "MAT3",
+  /**
+   * A 4x4 matrix, stored in column-major format.
+   *
+   * @type {string}
+   * @constant
+   */
+  MAT4: "MAT4",
+  /**
+   * A boolean (true/false) value
+   *
+   * @type {string}
+   * @constant
+   */
+  BOOLEAN: "BOOLEAN",
+  /**
+   * A UTF-8 encoded string value
+   *
+   * @type {string}
+   * @constant
+   */
+  STRING: "STRING",
+  /**
+   * An enumerated value. This type is used in conjunction with a {@link MetadataEnum} to describe the valid values.
+   *
+   * @see MetadataEnum
+   *
+   * @type {string}
+   * @constant
+   */
+  ENUM: "ENUM"
+};
+MetadataType.isVectorType = function(type) {
+  Check_default.typeOf.string("type", type);
+  switch (type) {
+    case MetadataType.VEC2:
+    case MetadataType.VEC3:
+    case MetadataType.VEC4:
+      return true;
+    default:
+      return false;
+  }
+};
+MetadataType.isMatrixType = function(type) {
+  Check_default.typeOf.string("type", type);
+  switch (type) {
+    case MetadataType.MAT2:
+    case MetadataType.MAT3:
+    case MetadataType.MAT4:
+      return true;
+    default:
+      return false;
+  }
+};
+MetadataType.getComponentCount = function(type) {
+  Check_default.typeOf.string("type", type);
+  switch (type) {
+    case MetadataType.SCALAR:
+    case MetadataType.STRING:
+    case MetadataType.ENUM:
+    case MetadataType.BOOLEAN:
+      return 1;
+    case MetadataType.VEC2:
+      return 2;
+    case MetadataType.VEC3:
+      return 3;
+    case MetadataType.VEC4:
+      return 4;
+    case MetadataType.MAT2:
+      return 4;
+    case MetadataType.MAT3:
+      return 9;
+    case MetadataType.MAT4:
+      return 16;
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default(`Invalid metadata type ${type}`);
+  }
+};
+MetadataType.getMathType = function(type) {
+  switch (type) {
+    case MetadataType.VEC2:
+      return Cartesian2_default;
+    case MetadataType.VEC3:
+      return Cartesian3_default;
+    case MetadataType.VEC4:
+      return Cartesian4_default;
+    case MetadataType.MAT2:
+      return Matrix2_default;
+    case MetadataType.MAT3:
+      return Matrix3_default;
+    case MetadataType.MAT4:
+      return Matrix4_default;
+    default:
+      return void 0;
+  }
+};
+Object.freeze(MetadataType);
+var MetadataType_default = MetadataType;
+
+// packages/engine/Source/Scene/buildVectorGltfFromMVT.js
+var DEFAULT_HEIGHT = 0;
+var scratchWorld = new Cartesian3_default();
+var scratchLocal = new Cartesian3_default();
+var tilingScheme = new WebMercatorTilingScheme_default();
+function buildVectorGltfFromMVT(decoded, tileCoordinates, options) {
+  const tileX = tileCoordinates.tileX;
+  const tileY = tileCoordinates.tileY;
+  const tileZ = tileCoordinates.tileZ;
+  const featureIdProperty = options?.featureIdProperty;
+  const tileRect = tilingScheme.tileXYToRectangle(tileX, tileY, tileZ);
+  const tileCenter = Rectangle_default.center(tileRect);
+  const origin = Cartesian3_default.fromRadians(
+    tileCenter.longitude,
+    tileCenter.latitude,
+    0
+  );
+  const MAX_INT_U32 = 4294967295;
+  const nullFeatureId = MAX_INT_U32;
+  const primitiveRestartIndex = MAX_INT_U32;
+  const featureIdLookup = /* @__PURE__ */ new Map();
+  const featureProperties = /* @__PURE__ */ new Map();
+  const bufferViews = [];
+  const accessors = [];
+  const chunks = [];
+  let byteLength = 0;
+  function addPadding() {
+    const padding = (4 - byteLength % 4) % 4;
+    if (padding > 0) {
+      chunks.push(new Uint8Array(padding));
+      byteLength += padding;
+    }
+  }
+  function addBufferView(typedArray, target) {
+    addPadding();
+    const byteOffset = byteLength;
+    chunks.push(
+      new Uint8Array(
+        typedArray.buffer,
+        typedArray.byteOffset,
+        typedArray.byteLength
+      )
+    );
+    byteLength += typedArray.byteLength;
+    const bufferViewIndex = bufferViews.length;
+    bufferViews.push({
+      buffer: 0,
+      byteOffset,
+      byteLength: typedArray.byteLength,
+      target
+    });
+    return bufferViewIndex;
+  }
+  function addAccessor(typedArray, options2) {
+    const bufferView = addBufferView(typedArray, options2.target);
+    const componentCount = (
+      /** @type {*} */
+      MetadataType_default.getComponentCount(
+        options2.type
+      )
+    );
+    const accessor = (
+      /** @type {*} */
+      {
+        bufferView,
+        byteOffset: 0,
+        componentType: options2.componentType,
+        count: typedArray.length / componentCount,
+        type: options2.type
+      }
+    );
+    if (defined_default(options2.min)) {
+      accessor.min = options2.min;
+    }
+    if (defined_default(options2.max)) {
+      accessor.max = options2.max;
+    }
+    const accessorIndex = accessors.length;
+    accessors.push(accessor);
+    return accessorIndex;
+  }
+  function computeMinMax(positions) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < positions.length; i += 3) {
+      const x = positions[i];
+      const y = positions[i + 1];
+      const z = positions[i + 2];
+      if (x < minX) {
+        minX = x;
+      }
+      if (y < minY) {
+        minY = y;
+      }
+      if (z < minZ) {
+        minZ = z;
+      }
+      if (x > maxX) {
+        maxX = x;
+      }
+      if (y > maxY) {
+        maxY = y;
+      }
+      if (z > maxZ) {
+        maxZ = z;
+      }
+    }
+    return {
+      min: [minX, minY, minZ],
+      max: [maxX, maxY, maxZ]
+    };
+  }
+  function addFeatureIdsToPrimitive(attributes, extensions, featureIdValues) {
+    if (featureIdValues.length === 0) {
+      return;
+    }
+    const featureIds = new Uint32Array(featureIdValues);
+    const featureAccessor = addAccessor(featureIds, {
+      type: "SCALAR",
+      componentType: ComponentDatatype_default.UNSIGNED_INT,
+      target: WebGLConstants_default.ARRAY_BUFFER
+    });
+    attributes._FEATURE_ID_0 = featureAccessor;
+    const featureIdDef = {
+      featureCount: featureIdLookup.size,
+      nullFeatureId,
+      attribute: 0
+    };
+    if (featureProperties.size > 0) {
+      featureIdDef.propertyTable = 0;
+    }
+    extensions.EXT_mesh_features = {
+      featureIds: [featureIdDef]
+    };
+  }
+  function addMetadataBufferView(bytes, alignment) {
+    alignment = alignment ?? 4;
+    const pad = (alignment - byteLength % alignment) % alignment;
+    if (pad > 0) {
+      chunks.push(new Uint8Array(pad));
+      byteLength += pad;
+    }
+    const byteOffset = byteLength;
+    chunks.push(bytes);
+    byteLength += bytes.byteLength;
+    const bufferViewIndex = bufferViews.length;
+    bufferViews.push({
+      buffer: 0,
+      byteOffset,
+      byteLength: bytes.byteLength
+    });
+    return bufferViewIndex;
+  }
+  function buildStructuralMetadata() {
+    if (featureProperties.size === 0) {
+      return void 0;
+    }
+    const propertyTypes = /* @__PURE__ */ new Map();
+    for (const props of featureProperties.values()) {
+      for (const [key, value] of Object.entries(props)) {
+        if (!defined_default(value)) {
+          continue;
+        }
+        const jsType = typeof value;
+        let metaType;
+        if (jsType === "string") {
+          metaType = "STRING";
+        } else if (jsType === "number") {
+          metaType = "SCALAR";
+        } else if (jsType === "boolean") {
+          metaType = "BOOLEAN";
+        } else {
+          metaType = "STRING";
+        }
+        const existing = propertyTypes.get(key);
+        if (!defined_default(existing)) {
+          propertyTypes.set(key, metaType);
+        } else if (existing !== metaType) {
+          propertyTypes.set(key, "STRING");
+        }
+      }
+    }
+    if (propertyTypes.size === 0) {
+      return void 0;
+    }
+    const classProperties = {};
+    for (const [name, type] of propertyTypes) {
+      if (type === "SCALAR") {
+        classProperties[name] = {
+          type: "SCALAR",
+          componentType: "FLOAT64"
+        };
+      } else if (type === "BOOLEAN") {
+        classProperties[name] = {
+          type: "BOOLEAN"
+        };
+      } else {
+        classProperties[name] = {
+          type: "STRING"
+        };
+      }
+    }
+    const tableProperties = {};
+    const count = featureIdLookup.size;
+    for (const [name, type] of propertyTypes) {
+      if (type === "SCALAR") {
+        const values = new Float64Array(count);
+        for (let i = 0; i < count; i++) {
+          const props = featureProperties.get(i);
+          const raw = props?.[name];
+          values[i] = typeof raw === "number" && Number.isFinite(raw) ? raw : NaN;
+        }
+        const bvIndex = addMetadataBufferView(
+          new Uint8Array(values.buffer, values.byteOffset, values.byteLength),
+          8
+        );
+        tableProperties[name] = { values: bvIndex };
+      } else if (type === "BOOLEAN") {
+        const byteCount = Math.ceil(count / 8);
+        const values = new Uint8Array(byteCount);
+        for (let i = 0; i < count; i++) {
+          const props = featureProperties.get(i);
+          const raw = props?.[name];
+          if (raw) {
+            values[i >> 3] |= 1 << (i & 7);
+          }
+        }
+        const bvIndex = addMetadataBufferView(values);
+        tableProperties[name] = { values: bvIndex };
+      } else {
+        const encoder = new TextEncoder();
+        const stringParts = [];
+        const offsets = new Uint32Array(count + 1);
+        let totalBytes = 0;
+        for (let i = 0; i < count; i++) {
+          offsets[i] = totalBytes;
+          const props = featureProperties.get(i);
+          const raw = props?.[name];
+          let str;
+          if (raw === null || raw === void 0) {
+            str = "";
+          } else if (typeof raw === "string") {
+            str = raw;
+          } else {
+            str = String(raw);
+          }
+          const encoded = encoder.encode(str);
+          stringParts.push(encoded);
+          totalBytes += encoded.byteLength;
+        }
+        offsets[count] = totalBytes;
+        const valuesBuffer = new Uint8Array(totalBytes);
+        let writeOffset = 0;
+        for (const part of stringParts) {
+          valuesBuffer.set(part, writeOffset);
+          writeOffset += part.byteLength;
+        }
+        const valuesBv = addMetadataBufferView(valuesBuffer);
+        const offsetsBv = addMetadataBufferView(
+          new Uint8Array(
+            offsets.buffer,
+            offsets.byteOffset,
+            offsets.byteLength
+          )
+        );
+        tableProperties[name] = {
+          values: valuesBv,
+          stringOffsets: offsetsBv,
+          stringOffsetType: "UINT32"
+        };
+      }
+    }
+    return {
+      schema: {
+        classes: {
+          mvt_feature: {
+            properties: classProperties
+          }
+        }
+      },
+      propertyTables: [
+        {
+          class: "mvt_feature",
+          count,
+          properties: tableProperties
+        }
+      ]
+    };
+  }
+  const meshes = [];
+  const nodes = [];
+  const translation = [origin.x, origin.y, origin.z];
+  for (const layer of decoded.layers) {
+    const extent = layer.extent;
+    const pointPositions = [];
+    const pointFeatureIds = [];
+    const linePositions = [];
+    const lineFeatureIds = [];
+    const lineIndices = [];
+    let lineCount = 0;
+    const polygonPositions = [];
+    const polygonFeatureIds = [];
+    const polygonIndices = [];
+    const polygonAttributeOffsets = [];
+    const polygonIndicesOffsets = [];
+    const polygonHoleCounts = [];
+    const polygonHoleOffsets = [];
+    let polygonCount = 0;
+    for (const feature of layer.features) {
+      const currentFeatureId = defined_default(featureIdProperty) ? mapFeatureIdFromProperty(
+        feature,
+        featureIdProperty,
+        featureIdLookup
+      ) ?? nullFeatureId : getOrAssignAutoFeatureId(feature, featureIdLookup);
+      if (currentFeatureId !== nullFeatureId && !featureProperties.has(currentFeatureId)) {
+        const props = Object.assign({}, feature.properties);
+        props["_layer"] = layer.name ?? "";
+        featureProperties.set(currentFeatureId, props);
+      }
+      if (feature.type === "Point") {
+        const points = (
+          /** @type {VectorTilePoint[]} */
+          feature.geometry
+        );
+        for (const point of points) {
+          appendTilePointAsLocalPosition(
+            point,
+            tileX,
+            tileY,
+            tileZ,
+            extent,
+            DEFAULT_HEIGHT,
+            origin,
+            pointPositions
+          );
+          pointFeatureIds.push(currentFeatureId);
+        }
+        continue;
+      }
+      if (feature.type === "LineString") {
+        const lines = (
+          /** @type {VectorTilePoint[][]} */
+          feature.geometry
+        );
+        for (const line of lines) {
+          const lineStart = linePositions.length / 3;
+          for (const point of line) {
+            appendTilePointAsLocalPosition(
+              point,
+              tileX,
+              tileY,
+              tileZ,
+              extent,
+              DEFAULT_HEIGHT,
+              origin,
+              linePositions
+            );
+            lineFeatureIds.push(currentFeatureId);
+          }
+          for (let i = 0; i < line.length; i++) {
+            lineIndices.push(lineStart + i);
+          }
+          lineIndices.push(primitiveRestartIndex);
+          lineCount++;
+        }
+        continue;
+      }
+      if (feature.type === "Polygon") {
+        const rawRings = (
+          /** @type {VectorTilePoint[][]} */
+          feature.geometry
+        );
+        const groups = groupPolygonRings(rawRings);
+        for (const group of groups) {
+          const rings = [group.outerRing, ...group.holes];
+          const positions2D = [];
+          const polygonPositionComponents = [];
+          const holeOffsets = [];
+          let vertexOffset = 0;
+          for (let ringIndex = 0; ringIndex < rings.length; ringIndex++) {
+            const ring = rings[ringIndex];
+            if (ringIndex > 0) {
+              holeOffsets.push(vertexOffset);
+            }
+            for (const point of ring) {
+              positions2D.push(new Cartesian2_default(point.x, point.y));
+              appendTilePointAsLocalPosition(
+                point,
+                tileX,
+                tileY,
+                tileZ,
+                extent,
+                DEFAULT_HEIGHT,
+                origin,
+                polygonPositionComponents
+              );
+              vertexOffset++;
+            }
+          }
+          if (positions2D.length < 3) {
+            continue;
+          }
+          const triangles = PolygonPipeline_default.triangulate(
+            positions2D,
+            holeOffsets.length > 0 ? holeOffsets : void 0
+          );
+          if (!defined_default(triangles) || triangles.length === 0) {
+            oneTimeWarning_default(
+              "buildVectorGltfFromMVT-triangulation-failed",
+              "Polygon triangulation failed; skipping polygon."
+            );
+            continue;
+          }
+          const globalVertexStart = polygonPositions.length / 3;
+          const globalIndexStart = polygonIndices.length;
+          polygonAttributeOffsets.push(globalVertexStart);
+          polygonIndicesOffsets.push(globalIndexStart);
+          polygonHoleCounts.push(holeOffsets.length);
+          for (let i = 0; i < holeOffsets.length; i++) {
+            polygonHoleOffsets.push(globalVertexStart + holeOffsets[i]);
+          }
+          for (let i = 0; i < polygonPositionComponents.length; i++) {
+            polygonPositions.push(polygonPositionComponents[i]);
+          }
+          for (let i = 0; i < polygonPositionComponents.length / 3; i++) {
+            polygonFeatureIds.push(currentFeatureId);
+          }
+          for (let i = 0; i < triangles.length; i++) {
+            polygonIndices.push(triangles[i] + globalVertexStart);
+          }
+          polygonCount++;
+        }
+      }
+    }
+    if (pointPositions.length === 0 && linePositions.length === 0 && polygonPositions.length === 0) {
+      continue;
+    }
+    if (lineIndices.length > 0 && lineIndices[lineIndices.length - 1] === primitiveRestartIndex) {
+      lineIndices.pop();
+    }
+    const primitives = [];
+    if (pointPositions.length > 0) {
+      const positions = new Float32Array(pointPositions);
+      const minMax = computeMinMax(positions);
+      const positionAccessor = addAccessor(positions, {
+        type: "VEC3",
+        componentType: ComponentDatatype_default.FLOAT,
+        target: WebGLConstants_default.ARRAY_BUFFER,
+        min: minMax.min,
+        max: minMax.max
+      });
+      const attributes = (
+        /** @type {*} */
+        {
+          POSITION: positionAccessor
+        }
+      );
+      const extensions = (
+        /** @type {*} */
+        {
+          CESIUM_mesh_vector: {
+            vector: true,
+            count: positions.length / 3
+          }
+        }
+      );
+      addFeatureIdsToPrimitive(attributes, extensions, pointFeatureIds);
+      primitives.push({
+        mode: PrimitiveType_default.POINTS,
+        attributes,
+        extensions
+      });
+    }
+    if (linePositions.length > 0 && lineIndices.length > 1) {
+      const positions = new Float32Array(linePositions);
+      const indices = new Uint32Array(lineIndices);
+      const minMax = computeMinMax(positions);
+      const positionAccessor = addAccessor(positions, {
+        type: "VEC3",
+        componentType: ComponentDatatype_default.FLOAT,
+        target: WebGLConstants_default.ARRAY_BUFFER,
+        min: minMax.min,
+        max: minMax.max
+      });
+      const indicesAccessor = addAccessor(indices, {
+        type: "SCALAR",
+        componentType: ComponentDatatype_default.UNSIGNED_INT,
+        target: WebGLConstants_default.ELEMENT_ARRAY_BUFFER
+      });
+      const attributes = (
+        /** @type {*} */
+        {
+          POSITION: positionAccessor
+        }
+      );
+      const extensions = (
+        /** @type {*} */
+        {
+          CESIUM_mesh_vector: {
+            vector: true,
+            count: lineCount
+          }
+        }
+      );
+      addFeatureIdsToPrimitive(attributes, extensions, lineFeatureIds);
+      primitives.push({
+        mode: PrimitiveType_default.LINE_STRIP,
+        indices: indicesAccessor,
+        attributes,
+        extensions
+      });
+    }
+    if (polygonPositions.length > 0 && polygonIndices.length >= 3) {
+      const positions = new Float32Array(polygonPositions);
+      const indices = new Uint32Array(polygonIndices);
+      const attributeOffsets = new Uint32Array(polygonAttributeOffsets);
+      const indicesOffsets = new Uint32Array(polygonIndicesOffsets);
+      const hasPolygonHoles = polygonHoleOffsets.length > 0;
+      const holeCounts = hasPolygonHoles ? new Uint32Array(polygonHoleCounts) : void 0;
+      const holeOffsets = hasPolygonHoles ? new Uint32Array(polygonHoleOffsets) : void 0;
+      const minMax = computeMinMax(positions);
+      const positionAccessor = addAccessor(positions, {
+        type: "VEC3",
+        componentType: ComponentDatatype_default.FLOAT,
+        target: WebGLConstants_default.ARRAY_BUFFER,
+        min: minMax.min,
+        max: minMax.max
+      });
+      const indicesAccessor = addAccessor(indices, {
+        type: "SCALAR",
+        componentType: ComponentDatatype_default.UNSIGNED_INT,
+        target: WebGLConstants_default.ELEMENT_ARRAY_BUFFER
+      });
+      const attributeOffsetsAccessor = addAccessor(attributeOffsets, {
+        type: "SCALAR",
+        componentType: ComponentDatatype_default.UNSIGNED_INT,
+        target: WebGLConstants_default.ARRAY_BUFFER
+      });
+      const indicesOffsetsAccessor = addAccessor(indicesOffsets, {
+        type: "SCALAR",
+        componentType: ComponentDatatype_default.UNSIGNED_INT,
+        target: WebGLConstants_default.ARRAY_BUFFER
+      });
+      const holeCountsAccessor = defined_default(holeCounts) ? addAccessor(holeCounts, {
+        type: "SCALAR",
+        componentType: ComponentDatatype_default.UNSIGNED_INT,
+        target: WebGLConstants_default.ARRAY_BUFFER
+      }) : void 0;
+      const holeOffsetsAccessor = defined_default(holeOffsets) ? addAccessor(holeOffsets, {
+        type: "SCALAR",
+        componentType: ComponentDatatype_default.UNSIGNED_INT,
+        target: WebGLConstants_default.ARRAY_BUFFER
+      }) : void 0;
+      const attributes = (
+        /** @type {*} */
+        {
+          POSITION: positionAccessor
+        }
+      );
+      const extensions = (
+        /** @type {*} */
+        {
+          CESIUM_mesh_vector: {
+            vector: true,
+            count: polygonCount,
+            polygonAttributeOffsets: attributeOffsetsAccessor,
+            polygonIndicesOffsets: indicesOffsetsAccessor
+          }
+        }
+      );
+      if (hasPolygonHoles) {
+        extensions.CESIUM_mesh_vector.polygonHoleCounts = holeCountsAccessor;
+        extensions.CESIUM_mesh_vector.polygonHoleOffsets = holeOffsetsAccessor;
+      }
+      addFeatureIdsToPrimitive(attributes, extensions, polygonFeatureIds);
+      primitives.push({
+        mode: PrimitiveType_default.TRIANGLES,
+        indices: indicesAccessor,
+        attributes,
+        extensions
+      });
+    }
+    if (primitives.length === 0) {
+      continue;
+    }
+    const meshIndex = meshes.length;
+    meshes.push({ primitives });
+    nodes.push({
+      name: layer.name,
+      mesh: meshIndex,
+      translation
+    });
+  }
+  if (nodes.length === 0) {
+    return void 0;
+  }
+  const structuralMetadata = buildStructuralMetadata();
+  const binaryChunk = concatChunks(chunks, byteLength);
+  const extensionsUsed = ["CESIUM_mesh_vector"];
+  if (featureIdLookup.size > 0) {
+    extensionsUsed.push("EXT_mesh_features");
+  }
+  if (defined_default(structuralMetadata)) {
+    extensionsUsed.push("EXT_structural_metadata");
+  }
+  const nodeIndices = nodes.map((_, i) => i);
+  const gltfJson = {
+    asset: {
+      version: "2.0"
+    },
+    extensionsUsed,
+    scene: 0,
+    scenes: [
+      {
+        nodes: nodeIndices
+      }
+    ],
+    nodes,
+    meshes,
+    accessors,
+    bufferViews,
+    buffers: [
+      {
+        byteLength: binaryChunk.byteLength
+      }
+    ],
+    extensions: (
+      /** @type {Object|undefined} */
+      void 0
+    )
+  };
+  if (defined_default(structuralMetadata)) {
+    gltfJson.extensions = {
+      EXT_structural_metadata: structuralMetadata
+    };
+  }
+  return buildGlb(gltfJson, binaryChunk);
+}
+function getOrAssignAutoFeatureId(feature, featureIdLookup) {
+  let id = featureIdLookup.get(feature);
+  if (!defined_default(id)) {
+    id = featureIdLookup.size;
+    featureIdLookup.set(feature, id);
+  }
+  return id;
+}
+function mapFeatureIdFromProperty(feature, featureIdProperty, featureIdLookup) {
+  const properties = feature.properties;
+  if (!defined_default(properties)) {
+    return void 0;
+  }
+  const propertyValue = (
+    /** @type {*} */
+    properties[featureIdProperty]
+  );
+  if (!defined_default(propertyValue)) {
+    return void 0;
+  }
+  if (typeof propertyValue !== "string" && typeof propertyValue !== "number" && typeof propertyValue !== "boolean") {
+    return void 0;
+  }
+  if (typeof propertyValue === "number" && !Number.isFinite(propertyValue)) {
+    return void 0;
+  }
+  const mapKey = `${typeof propertyValue}:${propertyValue}`;
+  let mappedFeatureId = featureIdLookup.get(mapKey);
+  if (defined_default(mappedFeatureId)) {
+    return mappedFeatureId;
+  }
+  mappedFeatureId = featureIdLookup.size;
+  featureIdLookup.set(mapKey, mappedFeatureId);
+  return mappedFeatureId;
+}
+function groupPolygonRings(rawRings) {
+  const groups = [];
+  for (const rawRing of rawRings) {
+    const ring = stripClosingVertex(rawRing);
+    if (ring.length < 3) {
+      continue;
+    }
+    const area = ringSignedArea(ring);
+    if (area <= 0) {
+      groups.push({ outerRing: ring, holes: [] });
+    } else if (groups.length > 0) {
+      groups[groups.length - 1].holes.push(ring);
+    }
+  }
+  return groups;
+}
+function ringSignedArea(ring) {
+  let area = 0;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    area += (ring[j].x + ring[i].x) * (ring[j].y - ring[i].y);
+  }
+  return area / 2;
+}
+function stripClosingVertex(ring) {
+  if (ring.length > 1 && ring[0].x === ring[ring.length - 1].x && ring[0].y === ring[ring.length - 1].y) {
+    return ring.slice(0, ring.length - 1);
+  }
+  return ring;
+}
+function appendTilePointAsLocalPosition(point, tileX, tileY, tileZ, extent, height, origin, out) {
+  const n = 1 << tileZ;
+  const u = (tileX + point.x / extent) / n;
+  const v = (tileY + point.y / extent) / n;
+  const lon = u * 2 * Math.PI - Math.PI;
+  const lat = Math.atan(Math.sinh(Math.PI * (1 - 2 * v)));
+  Cartesian3_default.fromRadians(lon, lat, height, void 0, scratchWorld);
+  Cartesian3_default.subtract(scratchWorld, origin, scratchLocal);
+  out.push(scratchLocal.x, scratchLocal.y, scratchLocal.z);
+}
+function buildGlb(gltfJson, binaryChunk) {
+  const GLB_MAGIC = 1179937895;
+  const GLB_VERSION = 2;
+  const CHUNK_TYPE_JSON = 1313821514;
+  const CHUNK_TYPE_BIN = 5130562;
+  const jsonBytes = new TextEncoder().encode(JSON.stringify(gltfJson));
+  const jsonPaddedLength = Math.ceil(jsonBytes.length / 4) * 4;
+  const jsonChunk = new Uint8Array(jsonPaddedLength);
+  jsonChunk.fill(32);
+  jsonChunk.set(jsonBytes);
+  const binPaddedLength = Math.ceil(binaryChunk.byteLength / 4) * 4;
+  const binChunk = new Uint8Array(binPaddedLength);
+  binChunk.set(binaryChunk);
+  const totalLength = 12 + // header
+  8 + jsonPaddedLength + // JSON chunk header + data
+  8 + binPaddedLength;
+  const glb = new Uint8Array(totalLength);
+  const view = new DataView(glb.buffer);
+  let offset = 0;
+  view.setUint32(offset, GLB_MAGIC, true);
+  offset += 4;
+  view.setUint32(offset, GLB_VERSION, true);
+  offset += 4;
+  view.setUint32(offset, totalLength, true);
+  offset += 4;
+  view.setUint32(offset, jsonPaddedLength, true);
+  offset += 4;
+  view.setUint32(offset, CHUNK_TYPE_JSON, true);
+  offset += 4;
+  glb.set(jsonChunk, offset);
+  offset += jsonPaddedLength;
+  view.setUint32(offset, binPaddedLength, true);
+  offset += 4;
+  view.setUint32(offset, CHUNK_TYPE_BIN, true);
+  offset += 4;
+  glb.set(binChunk, offset);
+  return glb;
+}
+function concatChunks(chunks, totalByteLength) {
+  const out = new Uint8Array(totalByteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+var buildVectorGltfFromMVT_default = buildVectorGltfFromMVT;
+
+// packages/engine/Source/Scene/decodeMVT.js
+var textDecoder = new TextDecoder();
+var GeomType = {
+  UNKNOWN: 0,
+  POINT: 1,
+  LINESTRING: 2,
+  POLYGON: 3
+};
+var TileField = {
+  LAYERS: 3
+};
+var LayerField = {
+  NAME: 1,
+  FEATURES: 2,
+  KEYS: 3,
+  VALUES: 4,
+  EXTENT: 5
+};
+var FeatureField = {
+  ID: 1,
+  TAGS: 2,
+  TYPE: 3,
+  GEOMETRY: 4
+};
+var GeoVisLayerField = {
+  VALUES: 1,
+  FEATURES: 2,
+  NAME: 3,
+  KEYS: 4,
+  EXTENT: 5
+};
+var GeoVisFeatureField = {
+  TYPE: 1,
+  GEOMETRY: 2,
+  TAGS: 3
+};
+var ValueField = {
+  STRING: 1,
+  FLOAT: 2,
+  DOUBLE: 3,
+  INT64: 4,
+  UINT64: 5,
+  SINT64: 6,
+  BOOL: 7
+};
+var geomTypeName = ["Unknown", "Point", "LineString", "Polygon"];
+function decodeMVT(arrayBuffer, format = "mvt") {
+  const bytes = new Uint8Array(arrayBuffer);
+  if (format === "geovis") {
+    return decodeGeoVisMVT(bytes);
+  }
+  const layers = [];
+  let pos = 0;
+  while (pos < bytes.length) {
+    const tag = readTag(bytes, pos, bytes.length);
+    const fieldNumber = tag.fieldNumber;
+    const wireType = tag.wireType;
+    pos = tag.newPos;
+    if (fieldNumber === TileField.LAYERS && wireType === 2) {
+      const layerLength = readVarintLength(bytes, pos, bytes.length);
+      pos = layerLength.newPos;
+      const layerEnd = advanceByLength(
+        pos,
+        layerLength.value,
+        bytes.length,
+        "layer"
+      );
+      layers.push(decodeLayer(bytes, pos, layerEnd));
+      pos = layerEnd;
+    } else {
+      pos = skipField(bytes, pos, wireType, bytes.length);
+    }
+  }
+  return { layers };
+}
+function decodeGeoVisMVT(bytes) {
+  const layers = [];
+  let pos = 0;
+  while (pos < bytes.length) {
+    const tag = readTag(bytes, pos, bytes.length);
+    pos = tag.newPos;
+    if (tag.fieldNumber !== TileField.LAYERS || tag.wireType !== 2) {
+      pos = skipField(bytes, pos, tag.wireType, bytes.length);
+      continue;
+    }
+    const layerLength = readVarintLength(bytes, pos, bytes.length);
+    pos = layerLength.newPos;
+    const layerEnd = advanceByLength(
+      pos,
+      layerLength.value,
+      bytes.length,
+      "GeoVis layer"
+    );
+    layers.push(decodeGeoVisLayer(bytes, pos, layerEnd));
+    pos = layerEnd;
+  }
+  return { layers };
+}
+function decodeGeoVisLayer(bytes, start, end) {
+  let pos = start;
+  let name = "";
+  let extent = 4096;
+  const keys = [];
+  const values = [];
+  const rawFeatures = [];
+  while (pos < end) {
+    const tag = readTag(bytes, pos, end);
+    pos = tag.newPos;
+    if (tag.wireType === 2) {
+      const length = readVarintLength(bytes, pos, end);
+      pos = length.newPos;
+      const fieldEnd = advanceByLength(
+        pos,
+        length.value,
+        end,
+        "GeoVis layer field"
+      );
+      if (tag.fieldNumber === GeoVisLayerField.VALUES) {
+        values.push(decodeValue(bytes, pos, fieldEnd));
+      } else if (tag.fieldNumber === GeoVisLayerField.FEATURES) {
+        rawFeatures.push({ start: pos, end: fieldEnd });
+      } else if (tag.fieldNumber === GeoVisLayerField.NAME) {
+        name = readString(bytes, pos, fieldEnd - pos);
+      } else if (tag.fieldNumber === GeoVisLayerField.KEYS) {
+        keys.push(readString(bytes, pos, fieldEnd - pos));
+      }
+      pos = fieldEnd;
+    } else if (tag.fieldNumber === GeoVisLayerField.EXTENT && tag.wireType === 0) {
+      const value = readVarint32(bytes, pos, end);
+      extent = value.value;
+      pos = value.newPos;
+    } else {
+      pos = skipField(bytes, pos, tag.wireType, end);
+    }
+  }
+  const features = rawFeatures.map(
+    ({ start: featureStart, end: featureEnd }) => decodeGeoVisFeature(bytes, featureStart, featureEnd, keys, values)
+  );
+  return { name, extent, features };
+}
+function decodeGeoVisFeature(bytes, start, end, keys, values) {
+  let pos = start;
+  let geomType = GeomType.UNKNOWN;
+  const tags = [];
+  const geometryCommands = [];
+  while (pos < end) {
+    const tag = readTag(bytes, pos, end);
+    pos = tag.newPos;
+    if (tag.wireType === 0 && tag.fieldNumber === GeoVisFeatureField.TYPE) {
+      const value = readVarint32(bytes, pos, end);
+      geomType = value.value - 1;
+      pos = value.newPos;
+    } else if (tag.wireType === 2) {
+      const length = readVarintLength(bytes, pos, end);
+      pos = length.newPos;
+      const fieldEnd = advanceByLength(
+        pos,
+        length.value,
+        end,
+        "GeoVis feature field"
+      );
+      const target = tag.fieldNumber === GeoVisFeatureField.GEOMETRY ? geometryCommands : tag.fieldNumber === GeoVisFeatureField.TAGS ? tags : void 0;
+      if (target !== void 0) {
+        while (pos < fieldEnd) {
+          const value = readVarint32(bytes, pos, fieldEnd);
+          target.push(value.value);
+          pos = value.newPos;
+        }
+      }
+      pos = fieldEnd;
+    } else {
+      pos = skipField(bytes, pos, tag.wireType, end);
+    }
+  }
+  const properties = {};
+  for (let i = 0; i < tags.length - 1; i += 2) {
+    const key = keys[tags[i]];
+    const value = values[tags[i + 1]];
+    if (typeof key === "string" && value !== void 0) {
+      properties[key] = value;
+    }
+  }
+  return {
+    id: void 0,
+    type: (
+      /** @type {"Point"|"LineString"|"Polygon"|"Unknown"} */
+      geomTypeName[geomType] ?? "Unknown"
+    ),
+    geometry: decodeGeometry(
+      geomType,
+      normalizeGeoVisGeometry(geometryCommands)
+    ),
+    properties
+  };
+}
+function normalizeGeoVisGeometry(commands) {
+  const normalized = [];
+  let pos = 0;
+  while (pos < commands.length) {
+    const command = commands[pos++];
+    const count = command >>> 3;
+    const commandId = command & 7;
+    let mvtCommandId;
+    if (commandId === 4) {
+      mvtCommandId = 1;
+    } else if (commandId === 3) {
+      mvtCommandId = 2;
+    } else if (commandId === 7) {
+      mvtCommandId = 7;
+    } else {
+      return [];
+    }
+    normalized.push(count << 3 | mvtCommandId);
+    if (mvtCommandId === 7) {
+      continue;
+    }
+    const coordinateCount = count * 2;
+    if (pos + coordinateCount > commands.length) {
+      return [];
+    }
+    for (let i = 0; i < coordinateCount; i++) {
+      normalized.push(commands[pos++]);
+    }
+  }
+  return normalized;
+}
+function decodeLayer(bytes, start, end) {
+  let pos = start;
+  let name = "";
+  let extent = 4096;
+  const keys = [];
+  const values = [];
+  const rawFeatures = [];
+  while (pos < end) {
+    const tag = readTag(bytes, pos, end);
+    const fieldNumber = tag.fieldNumber;
+    const wireType = tag.wireType;
+    pos = tag.newPos;
+    if (fieldNumber === LayerField.NAME && wireType === 2) {
+      const length = readVarintLength(bytes, pos, end);
+      pos = length.newPos;
+      const stringEnd = advanceByLength(pos, length.value, end, "layer name");
+      name = readString(bytes, pos, length.value);
+      pos = stringEnd;
+    } else if (fieldNumber === LayerField.FEATURES && wireType === 2) {
+      const length = readVarintLength(bytes, pos, end);
+      pos = length.newPos;
+      const featureEnd = advanceByLength(pos, length.value, end, "feature");
+      rawFeatures.push({ start: pos, end: featureEnd });
+      pos = featureEnd;
+    } else if (fieldNumber === LayerField.KEYS && wireType === 2) {
+      const length = readVarintLength(bytes, pos, end);
+      pos = length.newPos;
+      const stringEnd = advanceByLength(pos, length.value, end, "key");
+      keys.push(readString(bytes, pos, length.value));
+      pos = stringEnd;
+    } else if (fieldNumber === LayerField.VALUES && wireType === 2) {
+      const length = readVarintLength(bytes, pos, end);
+      pos = length.newPos;
+      const valueEnd = advanceByLength(pos, length.value, end, "value");
+      const value = decodeValue(bytes, pos, valueEnd);
+      values.push(value);
+      pos = valueEnd;
+    } else if (fieldNumber === LayerField.EXTENT && wireType === 0) {
+      const value = readVarint32(bytes, pos, end);
+      extent = value.value;
+      pos = value.newPos;
+    } else {
+      pos = skipField(bytes, pos, wireType, end);
+    }
+  }
+  const features = rawFeatures.map(
+    ({ start: featureStart, end: featureEnd }) => decodeFeature(bytes, featureStart, featureEnd, keys, values)
+  );
+  return { name, extent, features };
+}
+function decodeFeature(bytes, start, end, keys, values) {
+  let pos = start;
+  let id;
+  let geomType = GeomType.UNKNOWN;
+  const tags = [];
+  const geometryCommands = [];
+  while (pos < end) {
+    const tag = readTag(bytes, pos, end);
+    const fieldNumber = tag.fieldNumber;
+    const wireType = tag.wireType;
+    pos = tag.newPos;
+    if (fieldNumber === FeatureField.ID && wireType === 0) {
+      const value = readBigVarint(bytes, pos, end);
+      id = value.value;
+      pos = value.newPos;
+    } else if (fieldNumber === FeatureField.TYPE && wireType === 0) {
+      const value = readVarint32(bytes, pos, end);
+      geomType = value.value;
+      pos = value.newPos;
+    } else if (fieldNumber === FeatureField.TAGS && wireType === 2) {
+      const length = readVarintLength(bytes, pos, end);
+      pos = length.newPos;
+      const tagEnd = advanceByLength(pos, length.value, end, "feature tags");
+      while (pos < tagEnd) {
+        const value = readVarint32(bytes, pos, tagEnd);
+        tags.push(value.value);
+        pos = value.newPos;
+      }
+    } else if (fieldNumber === FeatureField.GEOMETRY && wireType === 2) {
+      const length = readVarintLength(bytes, pos, end);
+      pos = length.newPos;
+      const geometryEnd = advanceByLength(
+        pos,
+        length.value,
+        end,
+        "feature geometry"
+      );
+      while (pos < geometryEnd) {
+        const value = readVarint32(bytes, pos, geometryEnd);
+        geometryCommands.push(value.value);
+        pos = value.newPos;
+      }
+    } else {
+      pos = skipField(bytes, pos, wireType, end);
+    }
+  }
+  const properties = {};
+  for (let i = 0; i < tags.length - 1; i += 2) {
+    const key = keys[tags[i]];
+    const value = values[tags[i + 1]];
+    if (typeof key !== "string" || value === void 0) {
+      continue;
+    }
+    properties[key] = value;
+  }
+  const geometry = decodeGeometry(geomType, geometryCommands);
+  return {
+    id,
+    type: (
+      /** @type {"Point"|"LineString"|"Polygon"|"Unknown"} */
+      geomTypeName[geomType] ?? "Unknown"
+    ),
+    geometry,
+    properties
+  };
+}
+function decodeGeometry(geomType, cmds) {
+  let i = 0;
+  let x = 0;
+  let y = 0;
+  if (geomType === GeomType.POINT) {
+    const points = [];
+    while (i < cmds.length) {
+      const cmd = cmds[i++];
+      const cmdId = cmd & 7;
+      const count = cmd >> 3;
+      if (cmdId === 1) {
+        for (let c = 0; c < count; c++) {
+          x += zigzag(cmds[i++]);
+          y += zigzag(cmds[i++]);
+          points.push({ x, y });
+        }
+      }
+    }
+    return points;
+  }
+  if (geomType === GeomType.LINESTRING) {
+    const lines = [];
+    let current = null;
+    while (i < cmds.length) {
+      const cmd = cmds[i++];
+      const cmdId = cmd & 7;
+      const count = cmd >> 3;
+      if (cmdId === 1) {
+        if (current !== null) {
+          lines.push(current);
+        }
+        current = [];
+        x += zigzag(cmds[i++]);
+        y += zigzag(cmds[i++]);
+        current.push({ x, y });
+      } else if (cmdId === 2) {
+        for (let c = 0; c < count; c++) {
+          x += zigzag(cmds[i++]);
+          y += zigzag(cmds[i++]);
+          current.push({ x, y });
+        }
+      }
+    }
+    if (current !== null) {
+      lines.push(current);
+    }
+    return lines;
+  }
+  if (geomType === GeomType.POLYGON) {
+    const rings = [];
+    let current = null;
+    while (i < cmds.length) {
+      const cmd = cmds[i++];
+      const cmdId = cmd & 7;
+      const count = cmd >> 3;
+      if (cmdId === 1) {
+        if (current !== null) {
+          rings.push(current);
+        }
+        current = [];
+        x += zigzag(cmds[i++]);
+        y += zigzag(cmds[i++]);
+        current.push({ x, y });
+      } else if (cmdId === 2) {
+        for (let c = 0; c < count; c++) {
+          x += zigzag(cmds[i++]);
+          y += zigzag(cmds[i++]);
+          current.push({ x, y });
+        }
+      } else if (cmdId === 7) {
+        if (current !== null && current.length > 0) {
+          current.push({ x: current[0].x, y: current[0].y });
+          rings.push(current);
+          current = null;
+        }
+      }
+    }
+    if (current !== null) {
+      rings.push(current);
+    }
+    return rings;
+  }
+  return [];
+}
+function decodeValue(bytes, start, end) {
+  let pos = start;
+  while (pos < end) {
+    const tag = readTag(bytes, pos, end);
+    const fieldNumber = tag.fieldNumber;
+    const wireType = tag.wireType;
+    pos = tag.newPos;
+    if (fieldNumber === ValueField.STRING && wireType === 2) {
+      const length = readVarintLength(bytes, pos, end);
+      pos = length.newPos;
+      const stringEnd = advanceByLength(pos, length.value, end, "string value");
+      return readString(bytes, pos, stringEnd - pos);
+    } else if (fieldNumber === ValueField.FLOAT && wireType === 5) {
+      advanceByLength(pos, 4, end, "float value");
+      const v = new DataView(
+        bytes.buffer,
+        bytes.byteOffset + pos,
+        4
+      ).getFloat32(0, true);
+      return v;
+    } else if (fieldNumber === ValueField.DOUBLE && wireType === 1) {
+      advanceByLength(pos, 8, end, "double value");
+      const v = new DataView(
+        bytes.buffer,
+        bytes.byteOffset + pos,
+        8
+      ).getFloat64(0, true);
+      return v;
+    } else if (fieldNumber === ValueField.INT64 && wireType === 0) {
+      const value = readBigVarint(bytes, pos, end);
+      return toSafeNumber(value.value);
+    } else if (fieldNumber === ValueField.UINT64 && wireType === 0) {
+      const value = readBigVarint(bytes, pos, end);
+      return toSafeNumber(value.value);
+    } else if (fieldNumber === ValueField.SINT64 && wireType === 0) {
+      const value = readBigVarint(bytes, pos, end);
+      return toSafeNumber(zigzagBigInt(value.value));
+    } else if (fieldNumber === ValueField.BOOL && wireType === 0) {
+      const value = readVarint32(bytes, pos, end);
+      return value.value !== 0;
+    }
+    pos = skipField(bytes, pos, wireType, end);
+  }
+  return void 0;
+}
+function readTag(bytes, pos, limit) {
+  const value = readVarint32(bytes, pos, limit);
+  return {
+    fieldNumber: value.value >>> 3,
+    wireType: value.value & 7,
+    newPos: value.newPos
+  };
+}
+function readVarint32(bytes, pos, limit) {
+  const value = readBigVarint(bytes, pos, limit, 5);
+  if (value.value > 0xffffffffn) {
+    throw new RuntimeError_default("Invalid MVT uint32 varint.");
+  }
+  return {
+    value: Number(value.value),
+    newPos: value.newPos
+  };
+}
+function readVarintLength(bytes, pos, limit) {
+  const value = readBigVarint(bytes, pos, limit);
+  if (value.value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new RuntimeError_default("Invalid MVT length varint.");
+  }
+  return {
+    value: Number(value.value),
+    newPos: value.newPos
+  };
+}
+function readBigVarint(bytes, pos, limit, maxBytes) {
+  let result = 0n;
+  let shift = 0n;
+  let byteCount = 0;
+  const byteLimit = maxBytes ?? 10;
+  while (true) {
+    if (pos >= limit || pos >= bytes.length) {
+      throw new RuntimeError_default("Invalid MVT: truncated varint.");
+    }
+    const byte = bytes[pos++];
+    result |= BigInt(byte & 127) << shift;
+    byteCount++;
+    if ((byte & 128) === 0) {
+      break;
+    }
+    if (byteCount >= byteLimit) {
+      throw new RuntimeError_default("Invalid MVT: varint is too long.");
+    }
+    shift += 7n;
+  }
+  return {
+    value: result,
+    newPos: pos
+  };
+}
+function readString(bytes, pos, len) {
+  const end = advanceByLength(pos, len, bytes.length, "string");
+  return textDecoder.decode(bytes.subarray(pos, end));
+}
+function advanceByLength(pos, length, limit, fieldName) {
+  if (!Number.isFinite(length) || length < 0) {
+    throw new RuntimeError_default(`Invalid MVT ${fieldName}: invalid length.`);
+  }
+  const end = pos + length;
+  if (!Number.isFinite(end) || end < pos || end > limit) {
+    throw new RuntimeError_default(
+      `Invalid MVT ${fieldName}: length exceeds available bytes.`
+    );
+  }
+  return end;
+}
+function skipField(bytes, pos, wireType, limit) {
+  if (wireType === 0) {
+    return readBigVarint(bytes, pos, limit).newPos;
+  } else if (wireType === 1) {
+    return advanceByLength(pos, 8, limit, "fixed64 field");
+  } else if (wireType === 2) {
+    const length = readVarintLength(bytes, pos, limit);
+    return advanceByLength(
+      length.newPos,
+      length.value,
+      limit,
+      "length-delimited field"
+    );
+  } else if (wireType === 5) {
+    return advanceByLength(pos, 4, limit, "fixed32 field");
+  }
+  throw new RuntimeError_default(`Unsupported protobuf wire type: ${wireType}`);
+}
+function zigzag(n) {
+  return n >>> 1 ^ -(n & 1);
+}
+function zigzagBigInt(n) {
+  return n >> 1n ^ -(n & 1n);
+}
+function toSafeNumber(value) {
+  if (value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER)) {
+    return Number(value);
+  }
+  return value;
+}
+var decodeMVT_default = decodeMVT;
+
+// packages/engine/Source/Workers/createMvtTile.js
+function hasRenderableFeatures(decodedTile) {
+  for (const layer of decodedTile.layers) {
+    for (const feature of layer.features) {
+      if ((feature.type === "Point" || feature.type === "LineString" || feature.type === "Polygon") && feature.geometry.length > 0) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function createMvtTile(parameters, transferableObjects) {
+  const decodedTile = decodeMVT_default(parameters.arrayBuffer, parameters.format);
+  const glb = parameters.buildGeometry !== false ? buildVectorGltfFromMVT_default(decodedTile, parameters.tileCoordinates, {
+    featureIdProperty: parameters.featureIdProperty
+  }) : void 0;
+  if (glb !== void 0) {
+    transferableObjects.push(glb.buffer);
+  }
+  return {
+    glb: glb?.buffer,
+    hasFeatures: hasRenderableFeatures(decodedTile),
+    decodedTile: parameters.includeDecodedTile ? decodedTile : void 0
+  };
+}
+var createMvtTile_default = createTaskProcessorWorker_default(createMvtTile);
+export {
+  createMvtTile_default as default
+};