@loaders.gl/tile-converter 4.0.0-alpha.13 → 4.0.0-alpha.14

package/dist/dist.min.js

@@ -2173,15 +2173,15 @@ var require_vector3 = __commonJS({
     }
     var ORIGIN = [0, 0, 0];
     var ZERO2;
-    var Vector323 = function(_Vector) {
-      (0, _inherits2.default)(Vector324, _Vector);
-      var _super = _createSuper(Vector324);
-      function Vector324() {
+    var Vector324 = function(_Vector) {
+      (0, _inherits2.default)(Vector325, _Vector);
+      var _super = _createSuper(Vector325);
+      function Vector325() {
         var _this;
         var x = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
         var y = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
         var z = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
-        (0, _classCallCheck2.default)(this, Vector324);
+        (0, _classCallCheck2.default)(this, Vector325);
         _this = _super.call(this, -0, -0, -0);
         if (arguments.length === 1 && (0, _common.isArray)(x)) {
           _this.copy(x);
@@ -2197,7 +2197,7 @@ var require_vector3 = __commonJS({
         }
         return _this;
       }
-      (0, _createClass2.default)(Vector324, [{
+      (0, _createClass2.default)(Vector325, [{
         key: "set",
         value: function set(x, y, z) {
           this[0] = x;
@@ -2318,15 +2318,15 @@ var require_vector3 = __commonJS({
         key: "ZERO",
         get: function get() {
           if (!ZERO2) {
-            ZERO2 = new Vector324(0, 0, 0);
+            ZERO2 = new Vector325(0, 0, 0);
             Object.freeze(ZERO2);
           }
           return ZERO2;
         }
       }]);
-      return Vector324;
+      return Vector325;
     }(_vector.default);
-    exports.default = Vector323;
+    exports.default = Vector324;
   }
 });
 
@@ -5290,12 +5290,12 @@ var require_matrix4 = __commonJS({
     var DEFAULT_NEAR = 0.1;
     var DEFAULT_FAR = 500;
     var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-    var Matrix412 = function(_Matrix) {
-      (0, _inherits2.default)(Matrix413, _Matrix);
-      var _super = _createSuper(Matrix413);
-      function Matrix413(array) {
+    var Matrix413 = function(_Matrix) {
+      (0, _inherits2.default)(Matrix414, _Matrix);
+      var _super = _createSuper(Matrix414);
+      function Matrix414(array) {
         var _this;
-        (0, _classCallCheck2.default)(this, Matrix413);
+        (0, _classCallCheck2.default)(this, Matrix414);
         _this = _super.call(this, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);
         if (arguments.length === 1 && Array.isArray(array)) {
           _this.copy(array);
@@ -5304,7 +5304,7 @@ var require_matrix4 = __commonJS({
         }
         return _this;
       }
-      (0, _createClass2.default)(Matrix413, [{
+      (0, _createClass2.default)(Matrix414, [{
         key: "ELEMENTS",
         get: function get() {
           return 16;
@@ -5685,21 +5685,21 @@ var require_matrix4 = __commonJS({
           return getZeroMatrix();
         }
       }]);
-      return Matrix413;
+      return Matrix414;
     }(_matrix.default);
-    exports.default = Matrix412;
+    exports.default = Matrix413;
     var ZERO2;
     var IDENTITY;
     function getZeroMatrix() {
       if (!ZERO2) {
-        ZERO2 = new Matrix412([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+        ZERO2 = new Matrix413([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
         Object.freeze(ZERO2);
       }
       return ZERO2;
     }
     function getIdentityMatrix() {
       if (!IDENTITY) {
-        IDENTITY = new Matrix412();
+        IDENTITY = new Matrix413();
         Object.freeze(IDENTITY);
       }
       return IDENTITY;
@@ -7848,7 +7848,7 @@ var require_type_utils = __commonJS({
     function identity(x) {
       return x;
     }
-    var scratchVector7 = new _core.Vector3();
+    var scratchVector8 = new _core.Vector3();
     function fromCartographic(cartographic) {
       var result = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
       var map = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : identity;
@@ -7902,7 +7902,7 @@ var require_type_utils = __commonJS({
       if (!vector) {
         return false;
       }
-      scratchVector7.from(vector);
+      scratchVector8.from(vector);
       var oneOverRadiiSquared = _constants.WGS84_CONSTANTS.oneOverRadiiSquared, centerToleranceSquared = _constants.WGS84_CONSTANTS.centerToleranceSquared;
       var x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];
       var y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];
@@ -7921,16 +7921,16 @@ var require_scale_to_geodetic_surface = __commonJS({
     });
     exports.default = scaleToGeodeticSurface;
     var _core = require_es5();
-    var scratchVector7 = new _core.Vector3();
+    var scratchVector8 = new _core.Vector3();
     var scaleToGeodeticSurfaceIntersection = new _core.Vector3();
     var scaleToGeodeticSurfaceGradient = new _core.Vector3();
     function scaleToGeodeticSurface(cartesian, ellipsoid) {
       var result = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
       var oneOverRadii = ellipsoid.oneOverRadii, oneOverRadiiSquared = ellipsoid.oneOverRadiiSquared, centerToleranceSquared = ellipsoid.centerToleranceSquared;
-      scratchVector7.from(cartesian);
-      var positionX = scratchVector7.x;
-      var positionY = scratchVector7.y;
-      var positionZ = scratchVector7.z;
+      scratchVector8.from(cartesian);
+      var positionX = scratchVector8.x;
+      var positionY = scratchVector8.y;
+      var positionZ = scratchVector8.z;
       var oneOverRadiiX = oneOverRadii.x;
       var oneOverRadiiY = oneOverRadii.y;
       var oneOverRadiiZ = oneOverRadii.z;
@@ -7952,7 +7952,7 @@ var require_scale_to_geodetic_surface = __commonJS({
       var oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
       var gradient = scaleToGeodeticSurfaceGradient;
       gradient.set(intersection.x * oneOverRadiiSquaredX * 2, intersection.y * oneOverRadiiSquaredY * 2, intersection.z * oneOverRadiiSquaredZ * 2);
-      var lambda = (1 - ratio) * scratchVector7.len() / (0.5 * gradient.len());
+      var lambda = (1 - ratio) * scratchVector8.len() / (0.5 * gradient.len());
       var correction = 0;
       var xMultiplier;
       var yMultiplier;
@@ -7974,7 +7974,7 @@ var require_scale_to_geodetic_surface = __commonJS({
         var derivative = -2 * denominator;
         correction = func / derivative;
       } while (Math.abs(func) > _core._MathUtils.EPSILON12);
-      return scratchVector7.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
+      return scratchVector8.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
     }
   }
 });
@@ -8161,18 +8161,18 @@ var require_ellipsoid = __commonJS({
       }
       return newObj;
     }
-    var scratchVector7 = new _core.Vector3();
+    var scratchVector8 = new _core.Vector3();
     var scratchNormal2 = new _core.Vector3();
     var scratchK = new _core.Vector3();
     var scratchPosition3 = new _core.Vector3();
     var scratchHeight = new _core.Vector3();
     var scratchCartesian = new _core.Vector3();
-    var Ellipsoid16 = function() {
-      function Ellipsoid17() {
+    var Ellipsoid17 = function() {
+      function Ellipsoid18() {
         var x = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
         var y = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
         var z = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
-        (0, _classCallCheck2.default)(this, Ellipsoid17);
+        (0, _classCallCheck2.default)(this, Ellipsoid18);
         (0, _defineProperty2.default)(this, "radii", void 0);
         (0, _defineProperty2.default)(this, "radiiSquared", void 0);
         (0, _defineProperty2.default)(this, "radiiToTheFourth", void 0);
@@ -8197,7 +8197,7 @@ var require_ellipsoid = __commonJS({
         }
         Object.freeze(this);
       }
-      (0, _createClass2.default)(Ellipsoid17, [{
+      (0, _createClass2.default)(Ellipsoid18, [{
         key: "equals",
         value: function equals2(right) {
           return this === right || Boolean(right && this.radii.equals(right.radii));
@@ -8255,7 +8255,7 @@ var require_ellipsoid = __commonJS({
         key: "geocentricSurfaceNormal",
         value: function geocentricSurfaceNormal(cartesian) {
           var result = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [0, 0, 0];
-          return scratchVector7.from(cartesian).normalize().to(result);
+          return scratchVector8.from(cartesian).normalize().to(result);
         }
       }, {
         key: "geodeticSurfaceNormalCartographic",
@@ -8265,14 +8265,14 @@ var require_ellipsoid = __commonJS({
           var longitude = cartographicVectorRadians[0];
           var latitude = cartographicVectorRadians[1];
           var cosLatitude = Math.cos(latitude);
-          scratchVector7.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();
-          return scratchVector7.to(result);
+          scratchVector8.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();
+          return scratchVector8.to(result);
         }
       }, {
         key: "geodeticSurfaceNormal",
         value: function geodeticSurfaceNormal(cartesian) {
           var result = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [0, 0, 0];
-          return scratchVector7.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
+          return scratchVector8.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
         }
       }, {
         key: "scaleToGeodeticSurface",
@@ -8318,10 +8318,10 @@ var require_ellipsoid = __commonJS({
           return scratchPosition3.set(0, 0, z).to(result);
         }
       }]);
-      return Ellipsoid17;
+      return Ellipsoid18;
     }();
-    exports.default = Ellipsoid16;
-    (0, _defineProperty2.default)(Ellipsoid16, "WGS84", new Ellipsoid16(_constants.WGS84_RADIUS_X, _constants.WGS84_RADIUS_Y, _constants.WGS84_RADIUS_Z));
+    exports.default = Ellipsoid17;
+    (0, _defineProperty2.default)(Ellipsoid17, "WGS84", new Ellipsoid17(_constants.WGS84_RADIUS_X, _constants.WGS84_RADIUS_Y, _constants.WGS84_RADIUS_Z));
   }
 });
 
@@ -8381,7 +8381,7 @@ var require_axis_aligned_bounding_box = __commonJS({
     var _defineProperty2 = _interopRequireDefault(require_defineProperty());
     var _core = require_es5();
     var _constants = require_constants2();
-    var scratchVector7 = new _core.Vector3();
+    var scratchVector8 = new _core.Vector3();
     var scratchNormal2 = new _core.Vector3();
     var AxisAlignedBoundingBox = function() {
       function AxisAlignedBoundingBox2() {
@@ -8393,7 +8393,7 @@ var require_axis_aligned_bounding_box = __commonJS({
         (0, _defineProperty2.default)(this, "halfDiagonal", void 0);
         (0, _defineProperty2.default)(this, "minimum", void 0);
         (0, _defineProperty2.default)(this, "maximum", void 0);
-        center = center || scratchVector7.copy(minimum).add(maximum).scale(0.5);
+        center = center || scratchVector8.copy(minimum).add(maximum).scale(0.5);
         this.center = new _core.Vector3(center);
         this.halfDiagonal = new _core.Vector3(maximum).subtract(this.center);
         this.minimum = new _core.Vector3(minimum);
@@ -8441,7 +8441,7 @@ var require_axis_aligned_bounding_box = __commonJS({
       }, {
         key: "distanceSquaredTo",
         value: function distanceSquaredTo(point) {
-          var offset = scratchVector7.from(point).subtract(this.center);
+          var offset = scratchVector8.from(point).subtract(this.center);
           var halfDiagonal = this.halfDiagonal;
           var distanceSquared = 0;
           var d;
@@ -8520,7 +8520,7 @@ var require_bounding_sphere = __commonJS({
       }
       return newObj;
     }
-    var scratchVector7 = new _core.Vector3();
+    var scratchVector8 = new _core.Vector3();
     var scratchVector23 = new _core.Vector3();
     var BoundingSphere5 = function() {
       function BoundingSphere6() {
@@ -8543,7 +8543,7 @@ var require_bounding_sphere = __commonJS({
       }, {
         key: "fromCornerPoints",
         value: function fromCornerPoints(corner, oppositeCorner) {
-          oppositeCorner = scratchVector7.from(oppositeCorner);
+          oppositeCorner = scratchVector8.from(oppositeCorner);
           this.center = new _core.Vector3().from(corner).add(oppositeCorner).scale(0.5);
           this.radius = this.center.distance(oppositeCorner);
           return this;
@@ -8565,7 +8565,7 @@ var require_bounding_sphere = __commonJS({
           var leftRadius = this.radius;
           var rightCenter = boundingSphere.center;
           var rightRadius = boundingSphere.radius;
-          var toRightCenter = scratchVector7.copy(rightCenter).subtract(leftCenter);
+          var toRightCenter = scratchVector8.copy(rightCenter).subtract(leftCenter);
           var centerSeparation = toRightCenter.magnitude();
           if (leftRadius >= centerSeparation + rightRadius) {
             return this.clone();
@@ -8582,7 +8582,7 @@ var require_bounding_sphere = __commonJS({
       }, {
         key: "expand",
         value: function expand(point) {
-          var scratchPoint2 = scratchVector7.from(point);
+          var scratchPoint2 = scratchVector8.from(point);
           var radius = scratchPoint2.subtract(this.center).magnitude();
           if (radius > this.radius) {
             this.radius = radius;
@@ -8593,7 +8593,7 @@ var require_bounding_sphere = __commonJS({
         key: "transform",
         value: function transform11(_transform) {
           this.center.transform(_transform);
-          var scale = mat4.getScaling(scratchVector7, _transform);
+          var scale = mat4.getScaling(scratchVector8, _transform);
           this.radius = Math.max(scale[0], Math.max(scale[1], scale[2])) * this.radius;
           return this;
         }
@@ -8606,7 +8606,7 @@ var require_bounding_sphere = __commonJS({
       }, {
         key: "distanceTo",
         value: function distanceTo(point) {
-          var scratchPoint2 = scratchVector7.from(point);
+          var scratchPoint2 = scratchVector8.from(point);
           var delta = scratchPoint2.subtract(this.center);
           return Math.max(0, delta.len() - this.radius);
         }
@@ -47432,6 +47432,54 @@ function copyToArray(source, target, targetOffset) {
   return targetOffset + padToNBytes(sourceArray.byteLength, 4);
 }
 
+// ../loader-utils/src/lib/binary-utils/dataview-copy-utils.ts
+function padStringToByteAlignment(string, byteAlignment) {
+  const length = string.length;
+  const paddedLength = Math.ceil(length / byteAlignment) * byteAlignment;
+  const padding = paddedLength - length;
+  let whitespace = "";
+  for (let i = 0; i < padding; ++i) {
+    whitespace += " ";
+  }
+  return string + whitespace;
+}
+function copyStringToDataView(dataView, byteOffset, string, byteLength) {
+  if (dataView) {
+    for (let i = 0; i < byteLength; i++) {
+      dataView.setUint8(byteOffset + i, string.charCodeAt(i));
+    }
+  }
+  return byteOffset + byteLength;
+}
+function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
+  if (dataView) {
+    for (let i = 0; i < byteLength; i++) {
+      dataView.setUint8(byteOffset + i, binary[i]);
+    }
+  }
+  return byteOffset + byteLength;
+}
+function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
+  const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);
+  const padLength = paddedLength - sourceBuffer.byteLength;
+  if (dataView) {
+    const targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
+    const sourceArray = new Uint8Array(sourceBuffer);
+    targetArray.set(sourceArray);
+    for (let i = 0; i < padLength; ++i) {
+      dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 32);
+    }
+  }
+  byteOffset += paddedLength;
+  return byteOffset;
+}
+function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
+  const textEncoder = new TextEncoder();
+  const stringBuffer = textEncoder.encode(string);
+  byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
+  return byteOffset;
+}
+
 // ../loader-utils/src/lib/iterators/async-iteration.ts
 async function concatenateArrayBuffersAsync(asyncIterator) {
   const arrayBuffers = [];
@@ -49487,6 +49535,12 @@ async function encode(data, writer, options) {
   }
   throw new Error("Writer could not encode data");
 }
+function encodeSync(data, writer, options) {
+  if (writer.encodeSync) {
+    return writer.encodeSync(data, options);
+  }
+  throw new Error("Writer could not synchronously encode data");
+}
 function encodeInBatches(data, writer, options) {
   if (writer.encodeInBatches) {
     const dataIterator = getIterator(data);
@@ -51741,6 +51795,12 @@ var TILE3D_TYPE = {
   GLTF: "glTF"
 };
 var TILE3D_TYPES = Object.keys(TILE3D_TYPE);
+var MAGIC_ARRAY = {
+  BATCHED_MODEL: [98, 51, 100, 109],
+  INSTANCED_MODEL: [105, 51, 100, 109],
+  POINT_CLOUD: [112, 110, 116, 115],
+  COMPOSITE: [99, 109, 112, 116]
+};
 
 // ../3d-tiles/src/lib/parsers/helpers/parse-utils.ts
 function getStringFromArrayBuffer(arrayBuffer, byteOffset, byteLength) {
@@ -56798,6 +56858,87 @@ async function parse3(arrayBuffer, options = {}, context) {
   return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);
 }
 
+// ../gltf/src/lib/encoders/encode-glb.ts
+var MAGIC_glTF2 = 1179937895;
+var MAGIC_JSON = 1313821514;
+var MAGIC_BIN = 5130562;
+var LE = true;
+function encodeGLBSync(glb, dataView, byteOffset = 0, options = {}) {
+  const { magic = MAGIC_glTF2, version: version2 = 2, json = {}, binary } = glb;
+  const byteOffsetStart = byteOffset;
+  if (dataView) {
+    dataView.setUint32(byteOffset + 0, magic, LE);
+    dataView.setUint32(byteOffset + 4, version2, LE);
+    dataView.setUint32(byteOffset + 8, 0, LE);
+  }
+  const byteOffsetFileLength = byteOffset + 8;
+  byteOffset += 12;
+  const byteOffsetJsonHeader = byteOffset;
+  if (dataView) {
+    dataView.setUint32(byteOffset + 0, 0, LE);
+    dataView.setUint32(byteOffset + 4, MAGIC_JSON, LE);
+  }
+  byteOffset += 8;
+  const jsonString = JSON.stringify(json);
+  byteOffset = copyPaddedStringToDataView(dataView, byteOffset, jsonString, 4);
+  if (dataView) {
+    const jsonByteLength = byteOffset - byteOffsetJsonHeader - 8;
+    dataView.setUint32(byteOffsetJsonHeader + 0, jsonByteLength, LE);
+  }
+  if (binary) {
+    const byteOffsetBinHeader = byteOffset;
+    if (dataView) {
+      dataView.setUint32(byteOffset + 0, 0, LE);
+      dataView.setUint32(byteOffset + 4, MAGIC_BIN, LE);
+    }
+    byteOffset += 8;
+    byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, binary, 4);
+    if (dataView) {
+      const binByteLength = byteOffset - byteOffsetBinHeader - 8;
+      dataView.setUint32(byteOffsetBinHeader + 0, binByteLength, LE);
+    }
+  }
+  if (dataView) {
+    const fileByteLength = byteOffset - byteOffsetStart;
+    dataView.setUint32(byteOffsetFileLength, fileByteLength, LE);
+  }
+  return byteOffset;
+}
+
+// ../gltf/src/lib/encoders/encode-gltf.ts
+function encodeGLTFSync(gltf, arrayBuffer, byteOffset, options) {
+  convertBuffersToBase64(gltf);
+  return encodeGLBSync(gltf, arrayBuffer, byteOffset, options);
+}
+function convertBuffersToBase64(gltf, { firstBuffer = 0 } = {}) {
+  if (gltf.buffers && gltf.buffers.length > firstBuffer) {
+    throw new Error("encodeGLTF: multiple buffers not yet implemented");
+  }
+}
+
+// ../gltf/src/gltf-writer.ts
+var GLTFWriter = {
+  name: "glTF",
+  id: "gltf",
+  module: "gltf",
+  version: VERSION8,
+  extensions: ["glb"],
+  mimeTypes: ["model/gltf-binary"],
+  binary: true,
+  encodeSync: encodeSync2,
+  options: {
+    gltf: {}
+  }
+};
+function encodeSync2(gltf, options = {}) {
+  const { byteOffset = 0 } = options;
+  const byteLength = encodeGLTFSync(gltf, null, byteOffset, options);
+  const arrayBuffer = new ArrayBuffer(byteLength);
+  const dataView = new DataView(arrayBuffer);
+  encodeGLTFSync(gltf, dataView, byteOffset, options);
+  return arrayBuffer;
+}
+
 // ../gltf/src/lib/api/post-process-gltf.ts
 var COMPONENTS2 = {
   SCALAR: 1,
@@ -59236,7 +59377,7 @@ function getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme) {
 }
 async function parseImplicitTiles(params) {
   const {
-    options,
+    implicitOptions,
     parentData = {
       mortonIndex: 0,
       x: 0,
@@ -59251,7 +59392,8 @@ async function parseImplicitTiles(params) {
       y: 0,
       z: 0
     },
-    s2VolumeBox
+    s2VolumeBox,
+    loaderOptions
   } = params;
   let { subtree, level = 0 } = params;
   const {
@@ -59261,30 +59403,38 @@ async function parseImplicitTiles(params) {
     contentUrlTemplate,
     subtreesUriTemplate,
     basePath
-  } = options;
+  } = implicitOptions;
   const tile = { children: [], lodMetricValue: 0, contentUrl: "" };
+  if (!maximumLevel) {
+    dist_default2.once(`Missing 'maximumLevel' or 'availableLevels' property. The subtree ${contentUrlTemplate} won't be loaded...`);
+    return tile;
+  }
+  const lev = level + globalData.level;
+  if (lev > maximumLevel) {
+    return tile;
+  }
   const childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
+  const bitsPerTile = Math.log2(childrenPerTile);
   const childX = childIndex & 1;
   const childY = childIndex >> 1 & 1;
   const childZ = childIndex >> 2 & 1;
   const levelOffset = (childrenPerTile ** level - 1) / (childrenPerTile - 1);
-  let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex);
+  let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex, bitsPerTile);
   let tileAvailabilityIndex = levelOffset + childTileMortonIndex;
-  let childTileX = concatBits(parentData.x, childX);
-  let childTileY = concatBits(parentData.y, childY);
-  let childTileZ = concatBits(parentData.z, childZ);
+  let childTileX = concatBits(parentData.x, childX, 1);
+  let childTileY = concatBits(parentData.y, childY, 1);
+  let childTileZ = concatBits(parentData.z, childZ, 1);
   let isChildSubtreeAvailable = false;
-  if (level + 1 > subtreeLevels) {
+  if (level >= subtreeLevels) {
     isChildSubtreeAvailable = getAvailabilityResult(subtree.childSubtreeAvailability, childTileMortonIndex);
   }
-  const x = concatBits(globalData.x, childTileX);
-  const y = concatBits(globalData.y, childTileY);
-  const z = concatBits(globalData.z, childTileZ);
-  const lev = level + globalData.level;
+  const x = concatBits(globalData.x, childTileX, level * bitsPerTile);
+  const y = concatBits(globalData.y, childTileY, level * bitsPerTile);
+  const z = concatBits(globalData.z, childTileZ, level * bitsPerTile);
   if (isChildSubtreeAvailable) {
     const subtreePath = `${basePath}/${subtreesUriTemplate}`;
     const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
-    const childSubtree = await load(childSubtreeUrl, Tile3DSubtreeLoader);
+    const childSubtree = await load(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
     subtree = childSubtree;
     globalData.mortonIndex = childTileMortonIndex;
     globalData.x = childTileX;
@@ -59299,7 +59449,7 @@ async function parseImplicitTiles(params) {
     level = 0;
   }
   const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
-  if (!isTileAvailable || level > maximumLevel) {
+  if (!isTileAvailable) {
     return tile;
   }
   const isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
@@ -59312,17 +59462,18 @@ async function parseImplicitTiles(params) {
     const childS2VolumeBox = getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme);
     const childTileParsed = await parseImplicitTiles({
       subtree,
-      options,
+      implicitOptions,
+      loaderOptions,
       parentData: pData,
       childIndex: index,
       level: childTileLevel,
-      globalData,
+      globalData: { ...globalData },
       s2VolumeBox: childS2VolumeBox
     });
     if (childTileParsed.contentUrl || childTileParsed.children.length) {
       const globalLevel = lev + 1;
       const childCoordinates = { childTileX, childTileY, childTileZ };
-      const formattedTile = formatTileData(childTileParsed, globalLevel, childCoordinates, options, s2VolumeBox);
+      const formattedTile = formatTileData(childTileParsed, globalLevel, childCoordinates, implicitOptions, s2VolumeBox);
       tile.children.push(formattedTile);
     }
   }
@@ -59397,8 +59548,8 @@ function calculateBoundingVolumeForChildTile(level, rootBoundingVolume, childCoo
   }
   throw new Error(`Unsupported bounding volume type ${rootBoundingVolume}`);
 }
-function concatBits(first, second) {
-  return parseInt(first.toString(2) + second.toString(2), 2);
+function concatBits(higher, lower, shift) {
+  return (higher << shift) + lower;
 }
 function replaceContentUrlTemplate(templateUrl, level, x, y, z) {
   const mapUrl = generateMapUrl({ level, x, y, z });
@@ -59515,6 +59666,7 @@ async function normalizeImplicitTileHeaders(tile, tileset, basePath, implicitTil
   const {
     subdivisionScheme,
     maximumLevel,
+    availableLevels,
     subtreeLevels,
     subtrees: { uri: subtreesUriTemplate }
   } = implicitTilingExtension;
@@ -59536,7 +59688,7 @@ async function normalizeImplicitTileHeaders(tile, tileset, basePath, implicitTil
     subtreesUriTemplate,
     subdivisionScheme,
     subtreeLevels,
-    maximumLevel,
+    maximumLevel: Number.isFinite(availableLevels) ? availableLevels - 1 : maximumLevel,
     refine,
     basePath,
     lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
@@ -59545,15 +59697,16 @@ async function normalizeImplicitTileHeaders(tile, tileset, basePath, implicitTil
     getTileType,
     getRefine
   };
-  return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions);
+  return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions, options);
 }
-async function normalizeImplicitTileData(tile, basePath, rootSubtree, options) {
+async function normalizeImplicitTileData(tile, basePath, rootSubtree, implicitOptions, loaderOptions) {
   if (!tile) {
     return null;
   }
   const { children, contentUrl } = await parseImplicitTiles({
     subtree: rootSubtree,
-    options
+    implicitOptions,
+    loaderOptions
   });
   let tileContentUrl;
   let tileContent = null;
@@ -59720,6 +59873,177 @@ var CesiumIonLoader = {
   }
 };
 
+// ../3d-tiles/src/lib/encoders/helpers/encode-3d-tile-header.ts
+function encode3DTileHeader(tile, dataView, byteOffset) {
+  const HEADER_SIZE = 12;
+  if (!dataView) {
+    return byteOffset + HEADER_SIZE;
+  }
+  const { magic, version: version2 = 1, byteLength = 12 } = tile;
+  assert2(Array.isArray(magic) && Number.isFinite(version2) && Number.isFinite(byteLength));
+  dataView.setUint8(byteOffset + 0, magic[0]);
+  dataView.setUint8(byteOffset + 1, magic[1]);
+  dataView.setUint8(byteOffset + 2, magic[2]);
+  dataView.setUint8(byteOffset + 3, magic[3]);
+  dataView.setUint32(byteOffset + 4, version2, true);
+  dataView.setUint32(byteOffset + 8, byteLength, true);
+  byteOffset += HEADER_SIZE;
+  return byteOffset;
+}
+function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {
+  if (!dataView) {
+    return;
+  }
+  dataView.setUint32(byteOffsetTileStart + 8, byteLength, true);
+}
+
+// ../3d-tiles/src/lib/encoders/encode-3d-tile-composite.ts
+function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile2) {
+  tile = { magic: MAGIC_ARRAY.COMPOSITE, tiles: [], ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset += encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(byteOffset, tile.tiles.length, true);
+  }
+  byteOffset += 4;
+  for (let i = 0; i < tile.tiles.length; ++i) {
+    byteOffset += encode3DTile2(tile.tiles[i], dataView, byteOffset, options);
+  }
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../3d-tiles/src/lib/encoders/encode-3d-tile-batched-model.ts
+function encodeBatchedModel3DTile(tile, dataView, byteOffset, options) {
+  const { featuresLength = 0, batchTable } = tile;
+  const featureTableJson = {
+    BATCH_LENGTH: featuresLength
+  };
+  const featureTableJsonString = JSON.stringify(featureTableJson);
+  const batchTableJsonString = batchTable ? JSON.stringify(batchTable) : "";
+  const featureTableJsonByteLength = padToNBytes(featureTableJsonString.length, 8);
+  const batchTableJsonByteLength = batchTableJsonString ? padToNBytes(batchTableJsonString.length, 8) : 0;
+  tile = { magic: MAGIC_ARRAY.BATCHED_MODEL, ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset = encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(12, featureTableJsonByteLength, true);
+    dataView.setUint32(16, 0, true);
+    dataView.setUint32(20, batchTableJsonByteLength, true);
+    dataView.setUint32(24, 0, true);
+  }
+  byteOffset += 16;
+  byteOffset = copyPaddedStringToDataView(dataView, byteOffset, featureTableJsonString, 8);
+  if (batchTable) {
+    byteOffset = copyPaddedStringToDataView(dataView, byteOffset, batchTableJsonString, 8);
+  }
+  const gltfEncoded = tile.gltfEncoded;
+  if (gltfEncoded) {
+    byteOffset = copyBinaryToDataView(dataView, byteOffset, gltfEncoded, gltfEncoded.byteLength);
+  }
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../3d-tiles/src/lib/encoders/encode-3d-tile-instanced-model.ts
+function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {
+  const { featuresLength = 1, gltfFormat = 1, gltfUri = "" } = tile;
+  const gltfUriByteLength = gltfUri.length;
+  const featureTableJson = {
+    INSTANCES_LENGTH: featuresLength,
+    POSITION: new Array(featuresLength * 3).fill(0)
+  };
+  const featureTableJsonString = JSON.stringify(featureTableJson);
+  const featureTableJsonByteLength = featureTableJsonString.length;
+  tile = { magic: MAGIC_ARRAY.INSTANCED_MODEL, ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset = encode3DTileHeader(tile, dataView, 0);
+  if (dataView) {
+    dataView.setUint32(12, featureTableJsonByteLength, true);
+    dataView.setUint32(16, 0, true);
+    dataView.setUint32(20, 0, true);
+    dataView.setUint32(24, 0, true);
+    dataView.setUint32(28, gltfFormat, true);
+  }
+  byteOffset += 20;
+  byteOffset += copyStringToDataView(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
+  byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../3d-tiles/src/lib/encoders/encode-3d-tile-point-cloud.ts
+var DEFAULT_FEATURE_TABLE_JSON = {
+  POINTS_LENGTH: 1,
+  POSITIONS: {
+    byteOffset: 0
+  }
+};
+function encodePointCloud3DTile(tile, dataView, byteOffset, options) {
+  const { featureTableJson = DEFAULT_FEATURE_TABLE_JSON } = tile;
+  let featureTableJsonString = JSON.stringify(featureTableJson);
+  featureTableJsonString = padStringToByteAlignment(featureTableJsonString, 4);
+  const { featureTableJsonByteLength = featureTableJsonString.length } = tile;
+  const featureTableBinary = new ArrayBuffer(12);
+  const featureTableBinaryByteLength = featureTableBinary.byteLength;
+  tile = { magic: MAGIC_ARRAY.POINT_CLOUD, ...tile };
+  const byteOffsetStart = byteOffset;
+  byteOffset += encode3DTileHeader(tile, dataView, 0);
+  if (dataView) {
+    dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true);
+    dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true);
+    dataView.setUint32(byteOffset + 8, 0, true);
+    dataView.setUint32(byteOffset + 12, 0, true);
+  }
+  byteOffset += 16;
+  byteOffset += copyStringToDataView(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
+  byteOffset += copyBinaryToDataView(dataView, byteOffset, featureTableBinary, featureTableBinaryByteLength);
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+
+// ../3d-tiles/src/lib/encoders/encode-3d-tile.ts
+function encode3DTile(tile, options) {
+  const byteLength = encode3DTileToDataView(tile, null, 0, options);
+  const arrayBuffer = new ArrayBuffer(byteLength);
+  const dataView = new DataView(arrayBuffer);
+  encode3DTileToDataView(tile, dataView, 0, options);
+  return arrayBuffer;
+}
+function encode3DTileToDataView(tile, dataView, byteOffset, options) {
+  assert2(typeof tile.type === "string");
+  switch (tile.type) {
+    case TILE3D_TYPE.COMPOSITE:
+      return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);
+    case TILE3D_TYPE.POINT_CLOUD:
+      return encodePointCloud3DTile(tile, dataView, byteOffset, options);
+    case TILE3D_TYPE.BATCHED_3D_MODEL:
+      return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);
+    case TILE3D_TYPE.INSTANCED_3D_MODEL:
+      return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);
+    default:
+      throw new Error("3D Tiles: unknown tile type");
+  }
+}
+
+// ../3d-tiles/src/tile-3d-writer.ts
+var Tile3DWriter = {
+  name: "3D Tile",
+  id: "3d-tiles",
+  module: "3d-tiles",
+  version: VERSION6,
+  extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
+  mimeTypes: ["application/octet-stream"],
+  encodeSync: encodeSync3,
+  binary: true,
+  options: {
+    ["3d-tiles"]: {}
+  }
+};
+function encodeSync3(tile, options) {
+  return encode3DTile(tile, options);
+}
+
 // src/i3s-converter/i3s-converter.ts
 var import_path8 = __toModule(require("path"));
 
@@ -62300,18 +62624,6 @@ var WriteQueue = class extends Queue {
   }
 };
 
-// src/i3s-attributes-worker.ts
-var VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-var I3SAttributesWorker = {
-  id: "i3s-attributes",
-  name: "I3S Attributes Worker",
-  module: "tile-converter",
-  version: VERSION14,
-  options: {
-    useCartesianPositions: false
-  }
-};
-
 // src/constants.ts
 var BROWSER_ERROR_MESSAGE = "Tile converter does not work in browser, only in node js environment";
 
@@ -63322,20 +63634,16 @@ var I3SConverter = class {
     console.log(`Loading workers source...`);
     if (this.options.draco) {
       const url = getWorkerURL(DracoWriterWorker, { ...getGlobalLoaderOptions() });
-      const sourceResponse2 = await fetchFile(url);
-      const source2 = await sourceResponse2.text();
-      this.workerSource.draco = source2;
+      const sourceResponse = await fetchFile(url);
+      const source = await sourceResponse.text();
+      this.workerSource.draco = source;
     }
     if (this.generateTextures) {
       const url = getWorkerURL(KTX2BasisWriterWorker, { ...getGlobalLoaderOptions() });
-      const sourceResponse2 = await fetchFile(url);
-      const source2 = await sourceResponse2.text();
-      this.workerSource.ktx2 = source2;
-    }
-    const i3sAttributesWorkerUrl = getWorkerURL(I3SAttributesWorker, { ...getGlobalLoaderOptions() });
-    const sourceResponse = await fetchFile(i3sAttributesWorkerUrl);
-    const source = await sourceResponse.text();
-    this.workerSource.I3SAttributes = source;
+      const sourceResponse = await fetchFile(url);
+      const source = await sourceResponse.text();
+      this.workerSource.ktx2 = source;
+    }
     console.log(`Loading workers source completed!`);
   }
 };
@@ -63346,7 +63654,7 @@ var import_process3 = __toModule(require("process"));
 var import_json_map_transform10 = __toModule(require_json_map_transform());
 
 // ../i3s/src/lib/parsers/constants.ts
-var import_constants10 = __toModule(require_es55());
+var import_constants15 = __toModule(require_es55());
 
 // ../i3s/src/types.ts
 var DATA_TYPE;
@@ -63385,11 +63693,11 @@ function getConstructorForDataFormat(dataType) {
   }
 }
 var GL_TYPE_MAP = {
-  UInt8: import_constants10.default.UNSIGNED_BYTE,
-  UInt16: import_constants10.default.UNSIGNED_SHORT,
-  Float32: import_constants10.default.FLOAT,
-  UInt32: import_constants10.default.UNSIGNED_INT,
-  UInt64: import_constants10.default.DOUBLE
+  UInt8: import_constants15.default.UNSIGNED_BYTE,
+  UInt16: import_constants15.default.UNSIGNED_SHORT,
+  Float32: import_constants15.default.FLOAT,
+  UInt32: import_constants15.default.UNSIGNED_INT,
+  UInt64: import_constants15.default.DOUBLE
 };
 function sizeOf(dataType) {
   switch (dataType) {
@@ -63508,12 +63816,12 @@ function parseStringsAttribute(arrayBuffer) {
 }
 
 // ../i3s/src/i3s-attribute-loader.ts
-var VERSION15 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 var I3SAttributeLoader = {
   name: "I3S Attribute",
   id: "i3s-attribute",
   module: "i3s",
-  version: VERSION15,
+  version: VERSION14,
   mimeTypes: ["application/binary"],
   parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
   extensions: ["bin"],
@@ -63971,13 +64279,13 @@ function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
 }
 
 // ../i3s/src/i3s-content-loader.ts
-var VERSION16 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+var VERSION15 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
 var I3SContentLoader = {
   name: "I3S Content (Indexed Scene Layers)",
   id: "i3s-content",
   module: "i3s",
   worker: true,
-  version: VERSION16,
+  version: VERSION15,
   mimeTypes: ["application/octet-stream"],
   parse: parse6,
   extensions: ["bin"],
@@ -64000,7 +64308,7 @@ var import_culling8 = __toModule(require_es53());
 var import_geospatial14 = __toModule(require_es52());
 
 // ../i3s/src/i3s-node-page-loader.ts
-var VERSION17 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION16 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 async function parseNodePage(data, options) {
   return JSON.parse(new TextDecoder().decode(data));
 }
@@ -64008,7 +64316,7 @@ var I3SNodePageLoader = {
   name: "I3S Node Page",
   id: "i3s-node-page",
   module: "i3s",
-  version: VERSION17,
+  version: VERSION16,
   mimeTypes: ["application/json"],
   parse: parseNodePage,
   extensions: ["json"],
@@ -64260,7 +64568,7 @@ async function normalizeTilesetData(tileset, options, context) {
 }
 
 // ../i3s/src/i3s-loader.ts
-var VERSION18 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION17 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 var TILESET_REGEX = /layers\/[0-9]+$/;
 var TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
 var SLPK_HEX = "504b0304";
@@ -64269,7 +64577,7 @@ var I3SLoader = {
   name: "I3S (Indexed Scene Layers)",
   id: "i3s",
   module: "i3s",
-  version: VERSION18,
+  version: VERSION17,
   mimeTypes: ["application/octet-stream"],
   parse: parseI3S,
   extensions: ["bin"],
@@ -64394,20 +64702,226 @@ var TILESET = () => ({
   }
 });
 
-// src/3d-tiles-attributes-worker.ts
-var VERSION19 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-var Tile3dAttributesWorker = {
-  id: "3d-tiles-attributes",
-  name: "3DTiles Attributes Worker",
-  module: "tile-converter",
-  version: VERSION19,
-  options: {
-    featureAttributes: null
+// src/3d-tiles-converter/helpers/b3dm-converter.ts
+var import_core40 = __toModule(require_es5());
+var import_geospatial16 = __toModule(require_es52());
+
+// src/3d-tiles-converter/helpers/texture-atlas.ts
+function convertTextureAtlas(texCoords, uvRegions) {
+  const convertedTexCoords = new Float32Array(texCoords.length);
+  const normalisedRegions = normalizeRegions(uvRegions);
+  for (let index = 0; index < texCoords.length; index += 2) {
+    const uv = texCoords.subarray(index, index + 2);
+    const regions = normalisedRegions.slice(index * 2, index * 2 + 4);
+    const fractatedUV = fract([uv[0], uv[1]]);
+    const subtracted = [regions[2] - regions[0], regions[3] - regions[1]];
+    const multiplicationResult = [fractatedUV[0] * subtracted[0], fractatedUV[1] * subtracted[1]];
+    const convertedUV = [
+      multiplicationResult[0] + regions[0],
+      multiplicationResult[1] + regions[1]
+    ];
+    convertedTexCoords[index] = convertedUV[0];
+    convertedTexCoords[index + 1] = convertedUV[1];
+  }
+  return convertedTexCoords;
+}
+function fract(uv) {
+  return [uv[0] - Math.floor(uv[0]), uv[1] - Math.floor(uv[1])];
+}
+function normalizeRegions(regions) {
+  const MAX_UINT_16_VALUE = 65535;
+  const normalizedRegions = [];
+  for (let index = 0; index < regions.length; index++) {
+    normalizedRegions[index] = regions[index] / MAX_UINT_16_VALUE;
+  }
+  return normalizedRegions;
+}
+
+// src/3d-tiles-converter/helpers/b3dm-converter.ts
+var Z_UP_TO_Y_UP_MATRIX = new import_core40.Matrix4([1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]);
+var scratchVector7 = new import_core40.Vector3();
+var B3dmConverter = class {
+  async convert(i3sAttributesData, featureAttributes = null) {
+    const gltf = await this.buildGltf(i3sAttributesData, featureAttributes);
+    const b3dm = encodeSync({
+      gltfEncoded: new Uint8Array(gltf),
+      type: "b3dm",
+      featuresLength: this._getFeaturesLength(featureAttributes),
+      batchTable: featureAttributes
+    }, Tile3DWriter);
+    return b3dm;
+  }
+  async buildGltf(i3sAttributesData, featureAttributes) {
+    const { tileContent, textureFormat } = i3sAttributesData;
+    const {
+      material,
+      attributes,
+      indices: originalIndices,
+      cartesianOrigin,
+      cartographicOrigin,
+      modelMatrix
+    } = tileContent;
+    const gltfBuilder = new GLTFScenegraph();
+    const textureIndex = await this._addI3sTextureToGltf(tileContent, textureFormat, gltfBuilder);
+    const pbrMaterialInfo = this._convertI3sMaterialToGltfMaterial(material, textureIndex);
+    const materialIndex = gltfBuilder.addMaterial(pbrMaterialInfo);
+    const positions = attributes.positions;
+    const positionsValue = positions.value;
+    if (attributes.uvRegions && attributes.texCoords) {
+      attributes.texCoords.value = convertTextureAtlas(attributes.texCoords.value, attributes.uvRegions.value);
+    }
+    attributes.positions.value = this._normalizePositions(positionsValue, cartesianOrigin, cartographicOrigin, modelMatrix);
+    this._createBatchIds(tileContent, featureAttributes);
+    if (attributes.normals && !this._checkNormals(attributes.normals.value)) {
+      delete attributes.normals;
+    }
+    const indices = originalIndices || generateSyntheticIndices(positionsValue.length / positions.size);
+    const meshIndex = gltfBuilder.addMesh({
+      attributes,
+      indices,
+      material: materialIndex,
+      mode: 4
+    });
+    const transformMatrix = this._generateTransformMatrix(cartesianOrigin);
+    const nodeIndex = gltfBuilder.addNode({ meshIndex, matrix: transformMatrix });
+    const sceneIndex = gltfBuilder.addScene({ nodeIndices: [nodeIndex] });
+    gltfBuilder.setDefaultScene(sceneIndex);
+    gltfBuilder.createBinaryChunk();
+    const gltfBuffer = encodeSync(gltfBuilder.gltf, GLTFWriter);
+    return gltfBuffer;
+  }
+  async _addI3sTextureToGltf(tileContent, textureFormat, gltfBuilder) {
+    const { texture, material, attributes } = tileContent;
+    let textureIndex = null;
+    let selectedTexture = texture;
+    if (!texture && material) {
+      selectedTexture = material.pbrMetallicRoughness && material.pbrMetallicRoughness.baseColorTexture && material.pbrMetallicRoughness.baseColorTexture.texture.source.image;
+    }
+    if (selectedTexture) {
+      const mimeType = this._deduceMimeTypeFromFormat(textureFormat);
+      const imageIndex = gltfBuilder.addImage(selectedTexture, mimeType);
+      textureIndex = gltfBuilder.addTexture({ imageIndex });
+      delete attributes.colors;
+    }
+    return textureIndex;
+  }
+  _normalizePositions(positionsValue, cartesianOrigin, cartographicOrigin, modelMatrix) {
+    const newPositionsValue = new Float32Array(positionsValue.length);
+    for (let index = 0; index < positionsValue.length; index += 3) {
+      const vertex = positionsValue.subarray(index, index + 3);
+      const cartesianOriginVector = new import_core40.Vector3(cartesianOrigin);
+      let vertexVector = new import_core40.Vector3(Array.from(vertex)).transform(modelMatrix).add(cartographicOrigin);
+      import_geospatial16.Ellipsoid.WGS84.cartographicToCartesian(vertexVector, scratchVector7);
+      vertexVector = scratchVector7.subtract(cartesianOriginVector);
+      newPositionsValue.set(vertexVector, index);
+    }
+    return newPositionsValue;
+  }
+  _generateTransformMatrix(cartesianOrigin) {
+    const translateOriginMatrix = new import_core40.Matrix4().translate(cartesianOrigin);
+    const result = translateOriginMatrix.multiplyLeft(Z_UP_TO_Y_UP_MATRIX);
+    return result;
+  }
+  _createBatchIds(i3sContent, featureAttributes) {
+    const { featureIds } = i3sContent;
+    const { OBJECTID: objectIds } = featureAttributes || {};
+    if (!featureIds || !objectIds) {
+      return;
+    }
+    for (let i = 0; i < featureIds.length; i++) {
+      const featureId = featureIds[i];
+      const batchId = objectIds.indexOf(featureId);
+      featureIds[i] = batchId;
+    }
+    i3sContent.attributes._BATCHID = {
+      size: 1,
+      byteOffset: 0,
+      value: featureIds
+    };
+  }
+  _deduceMimeTypeFromFormat(format) {
+    switch (format) {
+      case "jpg":
+        return "image/jpeg";
+      case "png":
+        return "image/png";
+      case "ktx2":
+        return "image/ktx2";
+      default:
+        console.warn(`Unexpected texture format in I3S: ${format}`);
+        return "image/jpeg";
+    }
+  }
+  _convertI3sMaterialToGltfMaterial(material, textureIndex) {
+    const isTextureIndexExists = textureIndex !== null;
+    if (!material) {
+      material = {
+        alphaMode: "OPAQUE",
+        doubleSided: false,
+        pbrMetallicRoughness: {
+          metallicFactor: 0,
+          roughnessFactor: 1
+        }
+      };
+      if (isTextureIndexExists) {
+        material.pbrMetallicRoughness.baseColorTexture = {
+          index: textureIndex,
+          texCoord: 0
+        };
+      } else {
+        material.pbrMetallicRoughness.baseColorFactor = [1, 1, 1, 1];
+      }
+      return material;
+    }
+    if (textureIndex !== null) {
+      material = this._setGltfTexture(material, textureIndex);
+    }
+    return material;
+  }
+  _setGltfTexture(materialDefinition, textureIndex) {
+    const material = {
+      ...materialDefinition,
+      pbrMetallicRoughness: { ...materialDefinition.pbrMetallicRoughness }
+    };
+    if (materialDefinition.pbrMetallicRoughness && materialDefinition.pbrMetallicRoughness.baseColorTexture) {
+      material.pbrMetallicRoughness.baseColorTexture = {
+        index: textureIndex,
+        texCoord: 0
+      };
+    } else if (materialDefinition.emissiveTexture) {
+      material.emissiveTexture = {
+        index: textureIndex,
+        texCoord: 0
+      };
+    } else if (materialDefinition.pbrMetallicRoughness && materialDefinition.pbrMetallicRoughness.metallicRoughnessTexture) {
+      material.pbrMetallicRoughness.metallicRoughnessTexture = {
+        index: textureIndex,
+        texCoord: 0
+      };
+    } else if (materialDefinition.normalTexture) {
+      material.normalTexture = {
+        index: textureIndex,
+        texCoord: 0
+      };
+    } else if (materialDefinition.occlusionTexture) {
+      material.occlusionTexture = {
+        index: textureIndex,
+        texCoord: 0
+      };
+    }
+    return material;
+  }
+  _getFeaturesLength(attributes) {
+    if (!attributes) {
+      return 0;
+    }
+    const firstKey = Object.keys(attributes)[0];
+    return firstKey ? attributes[firstKey].length : 0;
+  }
+  _checkNormals(normals) {
+    return normals.find((value) => value);
   }
 };
-function transform3DTilesAttributesOnWorker(i3sAttributesData, options) {
-  return processOnWorker(Tile3dAttributesWorker, i3sAttributesData, options);
-}
 
 // src/3d-tiles-converter/3d-tiles-converter.ts
 var I3S = "I3S";
@@ -64434,13 +64948,15 @@ var Tiles3DConverter = class {
     console.log("Loading egm file...");
     this.geoidHeightModel = await load(egmFilePath, PGMLoader);
     console.log("Loading egm file completed!");
-    await this.loadWorkers();
     const sourceTilesetJson = await load(inputUrl, I3SLoader, {});
     this.sourceTileset = new Tileset3D(sourceTilesetJson, {
       loadOptions: {
         _nodeWorkers: true,
         reuseWorkers: true,
-        i3s: { coordinateSystem: COORDINATE_SYSTEM.LNGLAT_OFFSETS, decodeTextures: false }
+        i3s: { coordinateSystem: COORDINATE_SYSTEM.LNGLAT_OFFSETS, decodeTextures: false },
+        "i3s-content": {
+          workerUrl: "./modules/i3s/dist/i3s-content-worker-node.js"
+        }
       }
     });
     await this.sourceTileset.tilesetInitializationPromise;
@@ -64493,10 +65009,8 @@ var Tiles3DConverter = class {
         tileContent: sourceChild.content,
         textureFormat: sourceChild?.header?.textureFormat
       };
-      const b3dm = await transform3DTilesAttributesOnWorker(i3sAttributesData, {
-        source: this.workerSource.tile3dWorkerSource,
-        featureAttributes
-      });
+      const b3dmConverter = new B3dmConverter();
+      const b3dm = await b3dmConverter.convert(i3sAttributesData, featureAttributes);
       child.content = {
         uri: `${sourceChild.id}.b3dm`,
         boundingVolume
@@ -64598,14 +65112,6 @@ var Tiles3DConverter = class {
     console.log(`File(s) size: `, filesSize, " bytes");
     console.log(`------------------------------------------------`);
   }
-  async loadWorkers() {
-    console.log(`Loading workers source...`);
-    const tile3dAttributesWorkerUrl = getWorkerURL(Tile3dAttributesWorker, { ...getGlobalLoaderOptions() });
-    const sourceResponse = await fetchFile(tile3dAttributesWorkerUrl);
-    const source = await sourceResponse.text();
-    this.workerSource.tile3dWorkerSource = source;
-    console.log(`Loading workers source completed!`);
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {