@loaders.gl/gltf 4.3.0-alpha.6 → 4.3.0-alpha.8

package/dist/dist.dev.js

@@ -57,6 +57,8 @@ var __exports__ = (() => {
     GLTFScenegraph: () => GLTFScenegraph,
     GLTFWriter: () => GLTFWriter,
     _getMemoryUsageGLTF: () => getMemoryUsageGLTF,
+    createExtMeshFeatures: () => createExtMeshFeatures,
+    createExtStructuralMetadata: () => createExtStructuralMetadata,
     postProcessGLTF: () => postProcessGLTF
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
@@ -64,7 +66,9 @@ var __exports__ = (() => {
   // src/lib/extensions/EXT_mesh_features.ts
   var EXT_mesh_features_exports = {};
   __export(EXT_mesh_features_exports, {
+    createExtMeshFeatures: () => createExtMeshFeatures,
     decode: () => decode,
+    encode: () => encode,
     name: () => name
   });
 
@@ -1337,7 +1341,6 @@ var __exports__ = (() => {
     }
     /** Pack the binary chunk */
     createBinaryChunk() {
-      this.gltf.buffers = [];
       const totalByteLength = this.byteLength;
       const arrayBuffer = new ArrayBuffer(totalByteLength);
       const targetArray = new Uint8Array(arrayBuffer);
@@ -1352,6 +1355,7 @@ var __exports__ = (() => {
       }
       this.gltf.binary = arrayBuffer;
       this.sourceBuffers = [arrayBuffer];
+      this.gltf.buffers = [{ arrayBuffer, byteOffset: 0, byteLength: arrayBuffer.byteLength }];
     }
     // PRIVATE
     _removeStringFromArray(array, string) {
@@ -1657,6 +1661,12 @@ var __exports__ = (() => {
     const scenegraph = new GLTFScenegraph(gltfData);
     decodeExtMeshFeatures(scenegraph, options);
   }
+  function encode(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    encodeExtMeshFeatures(scenegraph, options);
+    scenegraph.createBinaryChunk();
+    return scenegraph.gltf;
+  }
   function decodeExtMeshFeatures(scenegraph, options) {
     const json = scenegraph.gltf.json;
     if (!json.meshes) {
@@ -1691,11 +1701,86 @@ var __exports__ = (() => {
       featureId.data = featureIdData;
     }
   }
+  function encodeExtMeshFeatures(scenegraph, options) {
+    const meshes = scenegraph.gltf.json.meshes;
+    if (!meshes) {
+      return;
+    }
+    for (const mesh of meshes) {
+      for (const primitive of mesh.primitives) {
+        encodeExtMeshFeaturesForPrimitive(scenegraph, primitive);
+      }
+    }
+  }
+  function createExtMeshFeatures(scenegraph, primitive, featureIdArray, propertyTableIndex) {
+    if (!primitive.extensions) {
+      primitive.extensions = {};
+    }
+    let extension = primitive.extensions[EXT_MESH_FEATURES_NAME];
+    if (!extension) {
+      extension = { featureIds: [] };
+      primitive.extensions[EXT_MESH_FEATURES_NAME] = extension;
+    }
+    const { featureIds } = extension;
+    const featureId = {
+      featureCount: featureIdArray.length,
+      propertyTable: propertyTableIndex,
+      data: featureIdArray
+    };
+    featureIds.push(featureId);
+    scenegraph.addObjectExtension(primitive, EXT_MESH_FEATURES_NAME, extension);
+  }
+  function encodeExtMeshFeaturesForPrimitive(scenegraph, primitive) {
+    const extension = primitive.extensions?.[EXT_MESH_FEATURES_NAME];
+    if (!extension) {
+      return;
+    }
+    const featureIds = extension.featureIds;
+    featureIds.forEach((featureId, elementIndex) => {
+      if (featureId.data) {
+        const { accessorKey, index } = createAccessorKey(primitive.attributes);
+        const typedArray = new Uint32Array(featureId.data);
+        featureIds[elementIndex] = {
+          featureCount: typedArray.length,
+          propertyTable: featureId.propertyTable,
+          attribute: index
+        };
+        scenegraph.gltf.buffers.push({
+          arrayBuffer: typedArray.buffer,
+          byteOffset: typedArray.byteOffset,
+          byteLength: typedArray.byteLength
+        });
+        const bufferViewIndex = scenegraph.addBufferView(typedArray);
+        const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+          size: 1,
+          componentType: getComponentTypeFromArray(typedArray),
+          count: typedArray.length
+        });
+        primitive.attributes[accessorKey] = accessorIndex;
+      }
+    });
+  }
+  function createAccessorKey(attributes) {
+    const prefix = "_FEATURE_ID_";
+    const attrs = Object.keys(attributes).filter((item) => item.indexOf(prefix) === 0);
+    let max = -1;
+    for (const a of attrs) {
+      const n = Number(a.substring(prefix.length));
+      if (n > max) {
+        max = n;
+      }
+    }
+    max++;
+    const accessorKey = `${prefix}${max}`;
+    return { accessorKey, index: max };
+  }
 
   // src/lib/extensions/EXT_structural_metadata.ts
   var EXT_structural_metadata_exports = {};
   __export(EXT_structural_metadata_exports, {
+    createExtStructuralMetadata: () => createExtStructuralMetadata,
     decode: () => decode2,
+    encode: () => encode2,
     name: () => name2
   });
   var EXT_STRUCTURAL_METADATA_NAME = "EXT_structural_metadata";
@@ -1704,6 +1789,12 @@ var __exports__ = (() => {
     const scenegraph = new GLTFScenegraph(gltfData);
     decodeExtStructuralMetadata(scenegraph, options);
   }
+  function encode2(gltfData, options) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    encodeExtStructuralMetadata(scenegraph, options);
+    scenegraph.createBinaryChunk();
+    return scenegraph.gltf;
+  }
   function decodeExtStructuralMetadata(scenegraph, options) {
     if (!options.gltf?.loadBuffers) {
       return;
@@ -2036,6 +2127,161 @@ var __exports__ = (() => {
     }
     return null;
   }
+  var SCHEMA_CLASS_ID_DEFAULT = "schemaClassId";
+  function encodeExtStructuralMetadata(scenegraph, options) {
+    const extension = scenegraph.getExtension(
+      EXT_STRUCTURAL_METADATA_NAME
+    );
+    if (!extension) {
+      return;
+    }
+    if (extension.propertyTables) {
+      for (const table of extension.propertyTables) {
+        const classId = table.class;
+        const schemaClass = extension.schema?.classes?.[classId];
+        if (table.properties && schemaClass) {
+          encodeProperties(table, schemaClass, scenegraph);
+        }
+      }
+    }
+  }
+  function encodeProperties(table, schemaClass, scenegraph) {
+    for (const propertyName in table.properties) {
+      const data = table.properties[propertyName].data;
+      if (data) {
+        const classProperty = schemaClass.properties[propertyName];
+        if (classProperty) {
+          const tableProperty = createPropertyTableProperty(
+            data,
+            classProperty,
+            scenegraph
+          );
+          table.properties[propertyName] = tableProperty;
+        }
+      }
+    }
+  }
+  function createExtStructuralMetadata(scenegraph, propertyAttributes, classId = SCHEMA_CLASS_ID_DEFAULT) {
+    let extension = scenegraph.getExtension(
+      EXT_STRUCTURAL_METADATA_NAME
+    );
+    if (!extension) {
+      extension = scenegraph.addExtension(EXT_STRUCTURAL_METADATA_NAME);
+    }
+    extension.schema = createSchema(propertyAttributes, classId, extension.schema);
+    const table = createPropertyTable(propertyAttributes, classId, extension.schema);
+    if (!extension.propertyTables) {
+      extension.propertyTables = [];
+    }
+    return extension.propertyTables.push(table) - 1;
+  }
+  function createSchema(propertyAttributes, classId, schemaToUpdate) {
+    const schema = schemaToUpdate ?? {
+      id: "schema_id"
+    };
+    const schemaClass = {
+      properties: {}
+    };
+    for (const attribute of propertyAttributes) {
+      const classProperty = {
+        type: attribute.elementType,
+        componentType: attribute.componentType
+      };
+      schemaClass.properties[attribute.name] = classProperty;
+    }
+    schema.classes = {};
+    schema.classes[classId] = schemaClass;
+    return schema;
+  }
+  function createPropertyTable(propertyAttributes, classId, schema) {
+    const table = {
+      class: classId,
+      count: 0
+    };
+    let count = 0;
+    const schemaClass = schema.classes?.[classId];
+    for (const attribute of propertyAttributes) {
+      if (count === 0) {
+        count = attribute.values.length;
+      }
+      if (count !== attribute.values.length && attribute.values.length) {
+        throw new Error("Illegal values in attributes");
+      }
+      const classProperty = schemaClass?.properties[attribute.name];
+      if (classProperty) {
+        if (!table.properties) {
+          table.properties = {};
+        }
+        table.properties[attribute.name] = { values: 0, data: attribute.values };
+      }
+    }
+    table.count = count;
+    return table;
+  }
+  function createPropertyTableProperty(values, classProperty, scenegraph) {
+    const prop = { values: 0 };
+    if (classProperty.type === "STRING") {
+      const { stringData, stringOffsets } = createPropertyDataString(values);
+      prop.stringOffsets = createBufferView(stringOffsets, scenegraph);
+      prop.values = createBufferView(stringData, scenegraph);
+    } else if (classProperty.type === "SCALAR" && classProperty.componentType) {
+      const data = createPropertyDataScalar(values, classProperty.componentType);
+      prop.values = createBufferView(data, scenegraph);
+    }
+    return prop;
+  }
+  var COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR = {
+    INT8: Int8Array,
+    UINT8: Uint8Array,
+    INT16: Int16Array,
+    UINT16: Uint16Array,
+    INT32: Int32Array,
+    UINT32: Uint32Array,
+    INT64: Int32Array,
+    UINT64: Uint32Array,
+    FLOAT32: Float32Array,
+    FLOAT64: Float64Array
+  };
+  function createPropertyDataScalar(array, componentType) {
+    const numberArray = [];
+    for (const value of array) {
+      numberArray.push(Number(value));
+    }
+    const Construct = COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR[componentType];
+    if (!Construct) {
+      throw new Error("Illegal component type");
+    }
+    return new Construct(numberArray);
+  }
+  function createPropertyDataString(strings) {
+    const utf8Encode = new TextEncoder();
+    const arr = [];
+    let len = 0;
+    for (const str of strings) {
+      const uint8Array = utf8Encode.encode(str);
+      len += uint8Array.length;
+      arr.push(uint8Array);
+    }
+    const strArray = new Uint8Array(len);
+    const strOffsets = [];
+    let offset = 0;
+    for (const str of arr) {
+      strArray.set(str, offset);
+      strOffsets.push(offset);
+      offset += str.length;
+    }
+    strOffsets.push(offset);
+    const stringOffsetsTypedArray = new Uint32Array(strOffsets);
+    return { stringData: strArray, stringOffsets: stringOffsetsTypedArray };
+  }
+  function createBufferView(typedArray, scenegraph) {
+    scenegraph.gltf.buffers.push({
+      arrayBuffer: typedArray.buffer,
+      byteOffset: typedArray.byteOffset,
+      byteLength: typedArray.byteLength
+    });
+    return scenegraph.addBufferView(typedArray);
+  }
 
   // src/lib/extensions/deprecated/EXT_feature_metadata.ts
   var EXT_feature_metadata_exports = {};
@@ -3165,7 +3411,7 @@ var __exports__ = (() => {
   var KHR_draco_mesh_compression_exports = {};
   __export(KHR_draco_mesh_compression_exports, {
     decode: () => decode6,
-    encode: () => encode,
+    encode: () => encode3,
     name: () => name7,
     preprocess: () => preprocess3
   });
@@ -3946,7 +4192,7 @@ var __exports__ = (() => {
     await Promise.all(promises);
     scenegraph.removeExtension(KHR_DRACO_MESH_COMPRESSION);
   }
-  function encode(gltfData, options = {}) {
+  function encode3(gltfData, options = {}) {
     const scenegraph = new GLTFScenegraph(gltfData);
     for (const mesh of scenegraph.json.meshes || []) {
       compressMesh(mesh, options);
@@ -4043,17 +4289,11 @@ var __exports__ = (() => {
     printRowMajor: true,
     _cartographicRadians: false
   };
-  globalThis.mathgl = globalThis.mathgl || {
-    config: {
-      ...DEFAULT_CONFIG
-    }
-  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
   var config = globalThis.mathgl.config;
-  function formatValue(value, {
-    precision = config.precision
-  } = {}) {
+  function formatValue(value, { precision = config.precision } = {}) {
     value = round(value);
-    return "".concat(parseFloat(value.toPrecision(precision)));
+    return `${parseFloat(value.toPrecision(precision))}`;
   }
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
@@ -4097,28 +4337,12 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  function _extendableBuiltin(cls) {
-    function ExtendableBuiltin() {
-      var instance = Reflect.construct(cls, Array.from(arguments));
-      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-      return instance;
-    }
-    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-      constructor: {
-        value: cls,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(ExtendableBuiltin, cls);
-    } else {
-      ExtendableBuiltin.__proto__ = cls;
-    }
-    return ExtendableBuiltin;
-  }
-  var MathArray = class extends _extendableBuiltin(Array) {
+  var MathArray = class extends Array {
+    // Common methods
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
     clone() {
       return new this.constructor().copy(this);
     }
@@ -4138,7 +4362,10 @@ var __exports__ = (() => {
       return targetObject;
     }
     from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
+        // @ts-ignore
+        this.fromObject(arrayOrObject)
+      );
     }
     to(arrayOrObject) {
       if (arrayOrObject === this) {
@@ -4149,18 +4376,20 @@ var __exports__ = (() => {
     toTarget(target) {
       return target ? this.to(target) : this;
     }
+    /** @deprecated */
     toFloat32Array() {
       return new Float32Array(this);
     }
     toString() {
       return this.formatString(config);
     }
+    /** Formats string according to options */
     formatString(opts) {
       let string = "";
       for (let i = 0; i < this.ELEMENTS; ++i) {
         string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
       }
-      return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+      return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
     }
     equals(array) {
       if (!array || this.length !== array.length) {
@@ -4184,6 +4413,8 @@ var __exports__ = (() => {
       }
       return true;
     }
+    // Modifiers
+    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -4201,12 +4432,14 @@ var __exports__ = (() => {
       }
       return this.check();
     }
+    /** Minimal */
     min(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(vector[i], this[i]);
       }
       return this.check();
     }
+    /** Maximal */
     max(vector) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.max(vector[i], this[i]);
@@ -4247,18 +4480,25 @@ var __exports__ = (() => {
       }
       return this.check();
     }
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
     multiplyByScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    // Debug checks
+    /** Throws an error if array length is incorrect or contains illegal values */
     check() {
       if (config.debug && !this.validate()) {
-        throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+        throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
       }
       return this;
     }
+    /** Returns false if the array length is incorrect or contains illegal values */
     validate() {
       let valid = this.length === this.ELEMENTS;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -4266,39 +4506,48 @@ var __exports__ = (() => {
       }
       return valid;
     }
+    // three.js compatibility
+    /** @deprecated */
     sub(a) {
       return this.subtract(a);
     }
+    /** @deprecated */
     setScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = a;
       }
       return this.check();
     }
+    /** @deprecated */
     addScalar(a) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] += a;
       }
       return this.check();
     }
+    /** @deprecated */
     subScalar(a) {
       return this.addScalar(-a);
     }
+    /** @deprecated */
     multiplyScalar(scalar) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] *= scalar;
       }
       return this.check();
     }
+    /** @deprecated */
     divideScalar(a) {
       return this.multiplyByScalar(1 / a);
     }
+    /** @deprecated */
     clampScalar(min, max) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(Math.max(this[i], min), max);
       }
       return this.check();
     }
+    /** @deprecated */
     get elements() {
       return this;
     }
@@ -4318,13 +4567,13 @@ var __exports__ = (() => {
   }
   function checkNumber(value) {
     if (!Number.isFinite(value)) {
-      throw new Error("Invalid number ".concat(JSON.stringify(value)));
+      throw new Error(`Invalid number ${JSON.stringify(value)}`);
     }
     return value;
   }
   function checkVector(v, length, callerName = "") {
     if (config.debug && !validateVector(v, length)) {
-      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
+      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
     }
     return v;
   }
@@ -4332,12 +4581,13 @@ var __exports__ = (() => {
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
   function assert4(condition, message) {
     if (!condition) {
-      throw new Error("math.gl assertion ".concat(message));
+      throw new Error(`math.gl assertion ${message}`);
     }
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/vector.js
   var Vector = class extends MathArray {
+    // ACCESSORS
     get x() {
       return this[0];
     }
@@ -4350,12 +4600,24 @@ var __exports__ = (() => {
     set y(value) {
       this[1] = checkNumber(value);
     }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     *
+     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+     * Instead we provide `len` and `magnitude`
+     */
     len() {
       return Math.sqrt(this.lengthSquared());
     }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     */
     magnitude() {
       return this.len();
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     lengthSquared() {
       let length = 0;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -4363,6 +4625,9 @@ var __exports__ = (() => {
       }
       return length;
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     magnitudeSquared() {
       return this.lengthSquared();
     }
@@ -4384,6 +4649,7 @@ var __exports__ = (() => {
       }
       return checkNumber(product);
     }
+    // MODIFIERS
     normalize() {
       const length = this.magnitude();
       if (length !== 0) {
@@ -4409,6 +4675,7 @@ var __exports__ = (() => {
       }
       return this.check();
     }
+    // THREE.js compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -4682,6 +4949,12 @@ var __exports__ = (() => {
       }
       return ZERO;
     }
+    /**
+     * @class
+     * @param x
+     * @param y
+     * @param z
+     */
     constructor(x = 0, y = 0, z = 0) {
       super(-0, -0, -0);
       if (arguments.length === 1 && isArray(x)) {
@@ -4726,6 +4999,7 @@ var __exports__ = (() => {
       object.z = this[2];
       return object;
     }
+    // Getters/setters
     get ELEMENTS() {
       return 3;
     }
@@ -4735,41 +5009,38 @@ var __exports__ = (() => {
     set z(value) {
       this[2] = checkNumber(value);
     }
+    // ACCESSORS
     angle(vector) {
       return angle(this, vector);
     }
+    // MODIFIERS
     cross(vector) {
       cross(this, this, vector);
       return this.check();
     }
-    rotateX({
-      radians,
-      origin = ORIGIN
-    }) {
+    rotateX({ radians, origin = ORIGIN }) {
       rotateX(this, this, origin, radians);
       return this.check();
     }
-    rotateY({
-      radians,
-      origin = ORIGIN
-    }) {
+    rotateY({ radians, origin = ORIGIN }) {
       rotateY(this, this, origin, radians);
       return this.check();
     }
-    rotateZ({
-      radians,
-      origin = ORIGIN
-    }) {
+    rotateZ({ radians, origin = ORIGIN }) {
       rotateZ(this, this, origin, radians);
       return this.check();
     }
+    // Transforms
+    // transforms as point (4th component is implicitly 1)
     transform(matrix4) {
       return this.transformAsPoint(matrix4);
     }
+    // transforms as point (4th component is implicitly 1)
     transformAsPoint(matrix4) {
       transformMat4(this, this, matrix4);
       return this.check();
     }
+    // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)
     transformAsVector(matrix4) {
       vec3_transformMat4AsVector(this, this, matrix4);
       return this.check();
@@ -4790,19 +5061,29 @@ var __exports__ = (() => {
 
   // ../../node_modules/@math.gl/core/dist/classes/base/matrix.js
   var Matrix = class extends MathArray {
+    // fromObject(object) {
+    //   const array = object.elements;
+    //   return this.fromRowMajor(array);
+    // }
+    // toObject(object) {
+    //   const array = object.elements;
+    //   this.toRowMajor(array);
+    //   return object;
+    // }
+    // TODO better override formatString?
     toString() {
       let string = "[";
       if (config.printRowMajor) {
         string += "row-major:";
         for (let row = 0; row < this.RANK; ++row) {
           for (let col = 0; col < this.RANK; ++col) {
-            string += " ".concat(this[col * this.RANK + row]);
+            string += ` ${this[col * this.RANK + row]}`;
           }
         }
       } else {
         string += "column-major:";
         for (let i = 0; i < this.ELEMENTS; ++i) {
-          string += " ".concat(this[i]);
+          string += ` ${this[i]}`;
         }
       }
       string += "]";
@@ -4811,9 +5092,11 @@ var __exports__ = (() => {
     getElementIndex(row, col) {
       return col * this.RANK + row;
     }
+    // By default assumes row major indices
     getElement(row, col) {
       return this[col * this.RANK + row];
     }
+    // By default assumes row major indices
     setElement(row, col, value) {
       this[col * this.RANK + row] = checkNumber(value);
       return this;
@@ -5071,16 +5354,30 @@ var __exports__ = (() => {
       this[8] = array[8];
       return this.check();
     }
+    // Constructors
     identity() {
       return this.copy(IDENTITY_MATRIX);
     }
+    /**
+     *
+     * @param object
+     * @returns self
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     fromObject(object) {
       return this.check();
     }
+    /** Calculates a 3x3 matrix from the given quaternion
+     * q quat  Quaternion to create matrix from
+     */
     fromQuaternion(q) {
       fromQuat(this, q);
       return this.check();
     }
+    /**
+     * accepts column major order, stores in column major order
+     */
+    // eslint-disable-next-line max-params
     set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {
       this[0] = m00;
       this[1] = m10;
@@ -5093,6 +5390,10 @@ var __exports__ = (() => {
       this[8] = m22;
       return this.check();
     }
+    /**
+     * accepts row major order, stores as column major
+     */
+    // eslint-disable-next-line max-params
     setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
       this[0] = m00;
       this[1] = m10;
@@ -5105,17 +5406,21 @@ var __exports__ = (() => {
       this[8] = m22;
       return this.check();
     }
+    // Accessors
     determinant() {
       return determinant(this);
     }
+    // Modifiers
     transpose() {
       transpose(this, this);
       return this.check();
     }
+    /** Invert a matrix. Note that this can fail if the matrix is not invertible */
     invert() {
       invert(this, this);
       return this.check();
     }
+    // Operations
     multiplyLeft(a) {
       multiply(this, a, this);
       return this.check();
@@ -5140,6 +5445,7 @@ var __exports__ = (() => {
       translate(this, this, vec);
       return this.check();
     }
+    // Transforms
     transform(vector, result) {
       let out;
       switch (vector.length) {
@@ -5158,12 +5464,15 @@ var __exports__ = (() => {
       checkVector(out, vector.length);
       return out;
     }
+    /** @deprecated */
     transformVector(vector, result) {
       return this.transform(vector, result);
     }
+    /** @deprecated */
     transformVector2(vector, result) {
       return this.transform(vector, result);
     }
+    /** @deprecated */
     transformVector3(vector, result) {
       return this.transform(vector, result);
     }
@@ -5342,7 +5651,7 @@ var __exports__ = (() => {
   var KHR_lights_punctual_exports = {};
   __export(KHR_lights_punctual_exports, {
     decode: () => decode8,
-    encode: () => encode2,
+    encode: () => encode4,
     name: () => name9
   });
   var KHR_LIGHTS_PUNCTUAL = "KHR_lights_punctual";
@@ -5363,7 +5672,7 @@ var __exports__ = (() => {
       gltfScenegraph.removeObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
     }
   }
-  async function encode2(gltfData) {
+  async function encode4(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     if (json.lights) {
@@ -5385,7 +5694,7 @@ var __exports__ = (() => {
   var KHR_materials_unlit_exports = {};
   __export(KHR_materials_unlit_exports, {
     decode: () => decode9,
-    encode: () => encode3,
+    encode: () => encode5,
     name: () => name10
   });
   var KHR_MATERIALS_UNLIT = "KHR_materials_unlit";
@@ -5402,7 +5711,7 @@ var __exports__ = (() => {
     }
     gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
   }
-  function encode3(gltfData) {
+  function encode5(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     if (gltfScenegraph.materials) {
@@ -5420,7 +5729,7 @@ var __exports__ = (() => {
   var KHR_techniques_webgl_exports = {};
   __export(KHR_techniques_webgl_exports, {
     decode: () => decode10,
-    encode: () => encode4,
+    encode: () => encode6,
     name: () => name11
   });
   var KHR_TECHNIQUES_WEBGL = "KHR_techniques_webgl";
@@ -5447,7 +5756,7 @@ var __exports__ = (() => {
       gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
     }
   }
-  async function encode4(gltfData, options) {
+  async function encode6(gltfData, options) {
   }
   function resolveTechniques(techniquesExtension, gltfScenegraph) {
     const { programs = [], shaders = [], techniques = [] } = techniquesExtension;
@@ -5504,6 +5813,7 @@ var __exports__ = (() => {
     KHR_texture_transform_exports,
     EXT_feature_metadata_exports
   ];
+  var EXTENSIONS_ENCODING = [EXT_structural_metadata_exports, EXT_mesh_features_exports];
   function preprocessExtensions(gltf, options = {}, context) {
     const extensions = EXTENSIONS2.filter((extension) => useExtension(extension.name, options));
     for (const extension of extensions) {
@@ -5516,6 +5826,12 @@ var __exports__ = (() => {
       await extension.decode?.(gltf, options, context);
     }
   }
+  function encodeExtensions(gltf, options = {}) {
+    for (const extension of EXTENSIONS_ENCODING) {
+      gltf = extension.encode?.(gltf, options) ?? gltf;
+    }
+    return gltf;
+  }
   function useExtension(extensionName, options) {
     const excludes = options?.gltf?.excludeExtensions || {};
     const exclude = extensionName in excludes && !excludes[extensionName];
@@ -5972,11 +6288,11 @@ var __exports__ = (() => {
 
   // src/lib/encoders/encode-gltf.ts
   function encodeGLTFSync(gltf, arrayBuffer, byteOffset, options) {
-    convertBuffersToBase64(gltf);
+    validateGltf(gltf);
     return encodeGLBSync(gltf, arrayBuffer, byteOffset, options);
   }
-  function convertBuffersToBase64(gltf, { firstBuffer = 0 } = {}) {
-    if (gltf.buffers && gltf.buffers.length > firstBuffer) {
+  function validateGltf(gltf) {
+    if (gltf.buffers && gltf.buffers.length > 1) {
       throw new Error("encodeGLTF: multiple buffers not yet implemented");
     }
   }
@@ -6002,10 +6318,11 @@ var __exports__ = (() => {
   };
   function encodeSync(gltf, options = {}) {
     const { byteOffset = 0 } = options;
-    const byteLength = encodeGLTFSync(gltf, null, byteOffset, options);
+    const gltfToEncode = encodeExtensions(gltf);
+    const byteLength = encodeGLTFSync(gltfToEncode, null, byteOffset, options);
     const arrayBuffer = new ArrayBuffer(byteLength);
     const dataView = new DataView(arrayBuffer);
-    encodeGLTFSync(gltf, dataView, byteOffset, options);
+    encodeGLTFSync(gltfToEncode, dataView, byteOffset, options);
     return arrayBuffer;
   }
 
@@ -6055,7 +6372,7 @@ var __exports__ = (() => {
     encodeSync: encodeSync2
   };
   function encodeSync2(glb, options) {
-    const { byteOffset = 0 } = options;
+    const { byteOffset = 0 } = options ?? {};
     const byteLength = encodeGLBSync(glb, null, byteOffset, options);
     const arrayBuffer = new ArrayBuffer(byteLength);
     const dataView = new DataView(arrayBuffer);