@galacean/effects-core 2.0.0-alpha.26 → 2.0.0-alpha.27

package/dist/index.mjs

@@ -3,7 +3,7 @@
  * Description: Galacean Effects runtime core for the web
  * Author: Ant Group CO., Ltd.
  * Contributors: 燃然,飂兮,十弦,云垣,茂安,意绮
- * Version: v2.0.0-alpha.26
+ * Version: v2.0.0-alpha.27
  */
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
@@ -3997,13 +3997,29 @@ var RenderFace;
     RenderFace["Front"] = "Front";
 })(RenderFace || (RenderFace = {}));
 
-var END_BEHAVIOR_DESTROY = 0;
-var END_BEHAVIOR_PAUSE = 1;
-var END_BEHAVIOR_FORWARD = 2;
-var END_BEHAVIOR_PAUSE_AND_DESTROY = 3;
-var END_BEHAVIOR_FREEZE = 4;
-var END_BEHAVIOR_RESTART = 5;
-var END_BEHAVIOR_DESTROY_CHILDREN = 6;
+/**
+ * 销毁
+ */ var END_BEHAVIOR_DESTROY = 0;
+/**
+ * 暂停
+ * @deprecated since 2.0 - use `END_BEHAVIOR_FREEZE` instead
+ */ var END_BEHAVIOR_PAUSE = 1;
+/**
+ * 无限播放
+ */ var END_BEHAVIOR_FORWARD = 2;
+/**
+ * 销毁并保留最后一帧
+ * @deprecated since 2.0
+ */ var END_BEHAVIOR_PAUSE_AND_DESTROY = 3;
+/**
+ * 冻结
+ */ var END_BEHAVIOR_FREEZE = 4;
+/**
+ * 重播
+ */ var END_BEHAVIOR_RESTART = 5;
+/**
+ *
+ */ var END_BEHAVIOR_DESTROY_CHILDREN = 6;
 var CAMERA_CLIP_MODE_VERTICAL = 1;
 var CAMERA_CLIP_MODE_NORMAL = 0;
 var MESSAGE_ITEM_PHRASE_BEGIN = 2;
@@ -4018,29 +4034,6 @@ var CameraClipMode;
      * 剪裁左右
      */ CameraClipMode[CameraClipMode["landscape"] = 0] = "landscape";
 })(CameraClipMode || (CameraClipMode = {}));
-/**
- * 结束行为
- */ var CompositionEndBehavior;
-(function(CompositionEndBehavior) {
-    /**
-     * 销毁
-     */ CompositionEndBehavior[CompositionEndBehavior["destroy"] = 0] = "destroy";
-    /**
-     * 暂停
-     */ CompositionEndBehavior[CompositionEndBehavior["pause"] = 1] = "pause";
-    /**
-     * 重播
-     */ CompositionEndBehavior[CompositionEndBehavior["restart"] = 5] = "restart";
-    /**
-     * 无限播放
-     */ CompositionEndBehavior[CompositionEndBehavior["forward"] = 2] = "forward";
-    /**
-     * 销毁并保留最后一帧
-     */ CompositionEndBehavior[CompositionEndBehavior["pause_destroy"] = 3] = "pause_destroy";
-    /**
-     * 冻结
-     */ CompositionEndBehavior[CompositionEndBehavior["freeze"] = 4] = "freeze";
-})(CompositionEndBehavior || (CompositionEndBehavior = {}));
 
 /**
  * 动态换图类型
@@ -4121,12 +4114,23 @@ var CameraClipMode;
     BezierKeyframeType[BezierKeyframeType["LINE_OUT"] = 6] = "LINE_OUT";
 })(BezierKeyframeType || (BezierKeyframeType = {}));
 
-var ItemEndBehavior;
-(function(ItemEndBehavior) {
-    ItemEndBehavior[ItemEndBehavior["destroy"] = 0] = "destroy";
-    ItemEndBehavior[ItemEndBehavior["loop"] = 5] = "loop";
-    ItemEndBehavior[ItemEndBehavior["freeze"] = 4] = "freeze";
-})(ItemEndBehavior || (ItemEndBehavior = {}));
+/**
+ * 结束行为
+ */ var EndBehavior;
+(function(EndBehavior) {
+    /**
+     * 销毁
+     */ EndBehavior[EndBehavior["destroy"] = 0] = "destroy";
+    /**
+     * 重播
+     */ EndBehavior[EndBehavior["restart"] = 5] = "restart";
+    /**
+     * 无限播放
+     */ EndBehavior[EndBehavior["forward"] = 2] = "forward";
+    /**
+     * 冻结
+     */ EndBehavior[EndBehavior["freeze"] = 4] = "freeze";
+})(EndBehavior || (EndBehavior = {}));
 var ParentItemEndBehavior;
 (function(ParentItemEndBehavior) {
     ParentItemEndBehavior[ParentItemEndBehavior["destroyChildren"] = 6] = "destroyChildren";
@@ -4451,7 +4455,6 @@ var index$1 = /*#__PURE__*/Object.freeze({
     get RenderType () { return RenderType; },
     get RenderFace () { return RenderFace; },
     get CameraClipMode () { return CameraClipMode; },
-    get CompositionEndBehavior () { return CompositionEndBehavior; },
     get BackgroundType () { return BackgroundType; },
     END_BEHAVIOR_DESTROY: END_BEHAVIOR_DESTROY,
     END_BEHAVIOR_PAUSE: END_BEHAVIOR_PAUSE,
@@ -4466,7 +4469,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
     MESSAGE_ITEM_PHRASE_END: MESSAGE_ITEM_PHRASE_END,
     get ValueType () { return ValueType; },
     get BezierKeyframeType () { return BezierKeyframeType; },
-    get ItemEndBehavior () { return ItemEndBehavior; },
+    get EndBehavior () { return EndBehavior; },
     get ParentItemEndBehavior () { return ParentItemEndBehavior; },
     get ParticleInteractionBehavior () { return ParticleInteractionBehavior; },
     get ShapeArcMode () { return ShapeArcMode; },
@@ -16616,7 +16619,7 @@ var ParticleSystem = /*#__PURE__*/ function(Component) {
                             }
                         }
                     }
-                } else if (this.item.endBehavior === ItemEndBehavior.loop) {
+                } else if (this.item.endBehavior === EndBehavior.restart) {
                     updateTrail();
                     this.loopStartTime = now - duration;
                     this.lastEmitTime -= duration;
@@ -16635,12 +16638,12 @@ var ParticleSystem = /*#__PURE__*/ function(Component) {
                     this.ended = true;
                     this.onEnd(this);
                     var endBehavior = this.item.endBehavior;
-                    if (endBehavior === ItemEndBehavior.freeze) {
+                    if (endBehavior === EndBehavior.freeze) {
                         this.frozen = true;
                     }
                 }
-            } else if (this.item.endBehavior !== ItemEndBehavior.loop) {
-                if (ItemEndBehavior.destroy === this.item.endBehavior) {
+            } else if (this.item.endBehavior !== EndBehavior.restart) {
+                if (EndBehavior.destroy === this.item.endBehavior) {
                     var node = link.last;
                     if (node && node.content[0] < this.lastUpdate) {
                         this.destroyed = true;
@@ -18720,9 +18723,9 @@ var AnimationClipPlayable = /*#__PURE__*/ function(Playable) {
         var localTime = time - this.start;
         var duration = this.duration;
         if (localTime - duration > 0.001) {
-            if (this.endBehavior === ItemEndBehavior.loop) {
+            if (this.endBehavior === EndBehavior.restart) {
                 localTime = localTime % duration;
-            } else if (this.endBehavior === ItemEndBehavior.freeze) {
+            } else if (this.endBehavior === EndBehavior.freeze) {
                 localTime = Math.min(duration, localTime);
             }
         }
@@ -18848,7 +18851,7 @@ var RuntimeClip = /*#__PURE__*/ function() {
         var ended = false;
         var started = false;
         var boundObject = this.track.binding;
-        if (localTime > clip.start + clip.duration + 0.001 && clip.endBehavior === ItemEndBehavior.destroy) {
+        if (localTime > clip.start + clip.duration + 0.001 && clip.endBehavior === EndBehavior.destroy) {
             if (_instanceof1(boundObject, VFXItem) && VFXItem.isParticle(boundObject) && this.particleSystem && !this.particleSystem.destroyed) {
                 weight = 1.0;
             } else {
@@ -19156,7 +19159,7 @@ function compareTracks(a, b) {
         this.resolveBindings();
         this.timelinePlayable = this.timelineAsset.createPlayable(this.graph);
         // 重播不销毁元素
-        if (this.item.endBehavior !== ItemEndBehavior.destroy) {
+        if (this.item.endBehavior !== EndBehavior.destroy) {
             this.setReusable(true);
         }
     };
@@ -19223,7 +19226,7 @@ function compareTracks(a, b) {
                     compositionComponent.refId = refId;
                     item.transform.parentTransform = this.transform;
                     this.item.composition.refContent.push(item);
-                    if (item.endBehavior === ItemEndBehavior.loop) {
+                    if (item.endBehavior === EndBehavior.restart) {
                         this.item.composition.autoRefTex = false;
                     }
                     compositionComponent.createContent();
@@ -22205,8 +22208,8 @@ function getStandardCameraContent(model) {
     json.compositions.forEach(function(composition) {
         composition.items.forEach(function(item) {
             if (item.type === ItemType.null) {
-                if (item.endBehavior === ItemEndBehavior.destroy) {
-                    item.endBehavior = ItemEndBehavior.freeze;
+                if (item.endBehavior === EndBehavior.destroy) {
+                    item.endBehavior = EndBehavior.freeze;
                 }
             }
         });
@@ -22225,7 +22228,7 @@ function getStandardCameraContent(model) {
     json.compositions.forEach(function(composition) {
         composition.items.forEach(function(item) {
             if (item.type === ItemType.mesh || item.type === ItemType.light) {
-                item.endBehavior = item.endBehavior === 1 ? ItemEndBehavior.destroy : item.endBehavior;
+                item.endBehavior = item.endBehavior === 1 ? EndBehavior.destroy : item.endBehavior;
             }
         });
     });
@@ -22237,7 +22240,11 @@ function getStandardCameraContent(model) {
     var _loop = function() {
         var composition = _step1.value;
         // composition 的 endBehavior 兼容
-        if (composition.endBehavior === CompositionEndBehavior.pause_destroy || composition.endBehavior === CompositionEndBehavior.pause) {
+        if (// @ts-expect-error
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+        composition.endBehavior === END_BEHAVIOR_PAUSE_AND_DESTROY || // @ts-expect-error
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+        composition.endBehavior === END_BEHAVIOR_PAUSE) {
             composition.endBehavior = END_BEHAVIOR_FREEZE;
         }
         // 过滤掉滤镜元素
@@ -23024,13 +23031,13 @@ function getStandardItem(item, opt) {
         var looping = (_originContent_options = originContent.options) == null ? void 0 : _originContent_options.looping;
         if (looping) {
             if (Array.isArray(looping)) {
-                endBehavior = looping[1] ? ItemEndBehavior.loop : ItemEndBehavior.destroy;
+                endBehavior = looping[1] ? EndBehavior.restart : EndBehavior.destroy;
             } else {
-                endBehavior = ItemEndBehavior.loop;
+                endBehavior = EndBehavior.restart;
             }
         } else {
             var _originContent_options1;
-            endBehavior = endBehavior || (originContent == null ? void 0 : (_originContent_options1 = originContent.options) == null ? void 0 : _originContent_options1.endBehavior) || ItemEndBehavior.destroy;
+            endBehavior = endBehavior || (originContent == null ? void 0 : (_originContent_options1 = originContent.options) == null ? void 0 : _originContent_options1.endBehavior) || EndBehavior.destroy;
         }
         if (originContent.options.renderLevel) {
             renderLevel = originContent.options.renderLevel;
@@ -24375,7 +24382,7 @@ var listOrder = 0;
             id: id,
             duration: duration,
             name: name,
-            endBehavior: isNaN(endBehavior) ? END_BEHAVIOR_PAUSE : endBehavior,
+            endBehavior: isNaN(endBehavior) ? EndBehavior.freeze : endBehavior,
             // looping,
             items: items,
             camera: camera,
@@ -24559,7 +24566,7 @@ var listOrder = 0;
         };
         this.reusable = reusable;
         this.speed = speed;
-        this.autoRefTex = !this.keepResource && imageUsage && this.rootItem.endBehavior !== ItemEndBehavior.loop;
+        this.autoRefTex = !this.keepResource && imageUsage && this.rootItem.endBehavior !== EndBehavior.restart;
         this.name = sourceContent.name;
         this.pluginSystem = pluginSystem;
         this.pluginSystem.initializeComposition(this, scene);
@@ -24759,7 +24766,7 @@ var listOrder = 0;
    * @returns 重新播放合成标志位
    */ _proto.shouldRestart = function shouldRestart() {
         var _this_rootItem = this.rootItem, ended = _this_rootItem.ended, endBehavior = _this_rootItem.endBehavior;
-        return ended && endBehavior === ItemEndBehavior.loop;
+        return ended && endBehavior === EndBehavior.restart;
     };
     /**
    * 是否合成需要销毁
@@ -24812,9 +24819,9 @@ var listOrder = 0;
         var localTime = time - this.rootItem.start;
         var duration = this.rootItem.duration;
         if (localTime - duration > 0.001) {
-            if (this.rootItem.endBehavior === ItemEndBehavior.loop) {
+            if (this.rootItem.endBehavior === EndBehavior.restart) {
                 localTime = localTime % duration;
-            } else if (this.rootItem.endBehavior === ItemEndBehavior.freeze) {
+            } else if (this.rootItem.endBehavior === EndBehavior.freeze) {
                 localTime = Math.min(duration, localTime);
             }
         }
@@ -24865,7 +24872,7 @@ var listOrder = 0;
         for(var _iterator2 = _create_for_of_iterator_helper_loose(item.children), _step2; !(_step2 = _iterator2()).done;){
             var child = _step2.value;
             if (VFXItem.isComposition(child)) {
-                if (child.ended && child.endBehavior === ItemEndBehavior.loop) {
+                if (child.ended && child.endBehavior === EndBehavior.restart) {
                     child.ended = false;
                     // TODO K帧动画在元素重建后需要 tick ，否则会导致元素位置和 k 帧第一帧位置不一致
                     this.callUpdate(child, 0);
@@ -25076,7 +25083,7 @@ var listOrder = 0;
         var _this = this;
         // 预合成元素销毁时销毁其中的item
         if (item.type == ItemType.composition) {
-            if (item.endBehavior !== ItemEndBehavior.freeze) {
+            if (item.endBehavior !== EndBehavior.freeze) {
                 var contentItems = item.getComponent(CompositionComponent).items;
                 contentItems.forEach(function(it) {
                     return _this.pluginSystem.plugins.forEach(function(loader) {
@@ -25335,6 +25342,1567 @@ var listOrder = 0;
     return Composition;
 }();
 
+var SIZEOF_SHORT = 2;
+var SIZEOF_INT = 4;
+var FILE_IDENTIFIER_LENGTH = 4;
+var SIZE_PREFIX_LENGTH = 4;
+
+var int32 = new Int32Array(2);
+var float32 = new Float32Array(int32.buffer);
+var float64 = new Float64Array(int32.buffer);
+var isLittleEndian = new Uint16Array(new Uint8Array([
+    1,
+    0
+]).buffer)[0] === 1;
+
+var Encoding;
+(function(Encoding) {
+    Encoding[Encoding["UTF8_BYTES"] = 1] = "UTF8_BYTES";
+    Encoding[Encoding["UTF16_STRING"] = 2] = "UTF16_STRING";
+})(Encoding || (Encoding = {}));
+
+var ByteBuffer = /*#__PURE__*/ function() {
+    function ByteBuffer(bytes_) {
+        this.bytes_ = bytes_;
+        this.position_ = 0;
+        this.text_decoder_ = new TextDecoder();
+    }
+    var _proto = ByteBuffer.prototype;
+    _proto.clear = function clear() {
+        this.position_ = 0;
+    };
+    /**
+     * Get the underlying `Uint8Array`.
+     */ _proto.bytes = function bytes() {
+        return this.bytes_;
+    };
+    /**
+     * Get the buffer's position.
+     */ _proto.position = function position() {
+        return this.position_;
+    };
+    /**
+     * Set the buffer's position.
+     */ _proto.setPosition = function setPosition(position) {
+        this.position_ = position;
+    };
+    /**
+     * Get the buffer's capacity.
+     */ _proto.capacity = function capacity() {
+        return this.bytes_.length;
+    };
+    _proto.readInt8 = function readInt8(offset) {
+        return this.readUint8(offset) << 24 >> 24;
+    };
+    _proto.readUint8 = function readUint8(offset) {
+        return this.bytes_[offset];
+    };
+    _proto.readInt16 = function readInt16(offset) {
+        return this.readUint16(offset) << 16 >> 16;
+    };
+    _proto.readUint16 = function readUint16(offset) {
+        return this.bytes_[offset] | this.bytes_[offset + 1] << 8;
+    };
+    _proto.readInt32 = function readInt32(offset) {
+        return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;
+    };
+    _proto.readUint32 = function readUint32(offset) {
+        return this.readInt32(offset) >>> 0;
+    };
+    _proto.readInt64 = function readInt64(offset) {
+        return BigInt.asIntN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+    };
+    _proto.readUint64 = function readUint64(offset) {
+        return BigInt.asUintN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+    };
+    _proto.readFloat32 = function readFloat32(offset) {
+        int32[0] = this.readInt32(offset);
+        return float32[0];
+    };
+    _proto.readFloat64 = function readFloat64(offset) {
+        int32[isLittleEndian ? 0 : 1] = this.readInt32(offset);
+        int32[isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);
+        return float64[0];
+    };
+    _proto.writeInt8 = function writeInt8(offset, value) {
+        this.bytes_[offset] = value;
+    };
+    _proto.writeUint8 = function writeUint8(offset, value) {
+        this.bytes_[offset] = value;
+    };
+    _proto.writeInt16 = function writeInt16(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+    };
+    _proto.writeUint16 = function writeUint16(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+    };
+    _proto.writeInt32 = function writeInt32(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+        this.bytes_[offset + 2] = value >> 16;
+        this.bytes_[offset + 3] = value >> 24;
+    };
+    _proto.writeUint32 = function writeUint32(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+        this.bytes_[offset + 2] = value >> 16;
+        this.bytes_[offset + 3] = value >> 24;
+    };
+    _proto.writeInt64 = function writeInt64(offset, value) {
+        this.writeInt32(offset, Number(BigInt.asIntN(32, value)));
+        this.writeInt32(offset + 4, Number(BigInt.asIntN(32, value >> BigInt(32))));
+    };
+    _proto.writeUint64 = function writeUint64(offset, value) {
+        this.writeUint32(offset, Number(BigInt.asUintN(32, value)));
+        this.writeUint32(offset + 4, Number(BigInt.asUintN(32, value >> BigInt(32))));
+    };
+    _proto.writeFloat32 = function writeFloat32(offset, value) {
+        float32[0] = value;
+        this.writeInt32(offset, int32[0]);
+    };
+    _proto.writeFloat64 = function writeFloat64(offset, value) {
+        float64[0] = value;
+        this.writeInt32(offset, int32[isLittleEndian ? 0 : 1]);
+        this.writeInt32(offset + 4, int32[isLittleEndian ? 1 : 0]);
+    };
+    /**
+     * Return the file identifier.   Behavior is undefined for FlatBuffers whose
+     * schema does not include a file_identifier (likely points at padding or the
+     * start of a the root vtable).
+     */ _proto.getBufferIdentifier = function getBufferIdentifier() {
+        if (this.bytes_.length < this.position_ + SIZEOF_INT + FILE_IDENTIFIER_LENGTH) {
+            throw new Error("FlatBuffers: ByteBuffer is too short to contain an identifier.");
+        }
+        var result = "";
+        for(var i = 0; i < FILE_IDENTIFIER_LENGTH; i++){
+            result += String.fromCharCode(this.readInt8(this.position_ + SIZEOF_INT + i));
+        }
+        return result;
+    };
+    /**
+     * Look up a field in the vtable, return an offset into the object, or 0 if the
+     * field is not present.
+     */ _proto.__offset = function __offset(bb_pos, vtable_offset) {
+        var vtable = bb_pos - this.readInt32(bb_pos);
+        return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
+    };
+    /**
+     * Initialize any Table-derived type to point to the union at the given offset.
+     */ _proto.__union = function __union(t, offset) {
+        t.bb_pos = offset + this.readInt32(offset);
+        t.bb = this;
+        return t;
+    };
+    /**
+     * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
+     * This allocates a new string and converts to wide chars upon each access.
+     *
+     * To avoid the conversion to string, pass Encoding.UTF8_BYTES as the
+     * "optionalEncoding" argument. This is useful for avoiding conversion when
+     * the data will just be packaged back up in another FlatBuffer later on.
+     *
+     * @param offset
+     * @param opt_encoding Defaults to UTF16_STRING
+     */ _proto.__string = function __string(offset, opt_encoding) {
+        offset += this.readInt32(offset);
+        var length = this.readInt32(offset);
+        offset += SIZEOF_INT;
+        var utf8bytes = this.bytes_.subarray(offset, offset + length);
+        if (opt_encoding === Encoding.UTF8_BYTES) return utf8bytes;
+        else return this.text_decoder_.decode(utf8bytes);
+    };
+    /**
+     * Handle unions that can contain string as its member, if a Table-derived type then initialize it,
+     * if a string then return a new one
+     *
+     * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this
+     * makes the behaviour of __union_with_string different compared to __union
+     */ _proto.__union_with_string = function __union_with_string(o, offset) {
+        if (typeof o === "string") {
+            return this.__string(offset);
+        }
+        return this.__union(o, offset);
+    };
+    /**
+     * Retrieve the relative offset stored at "offset"
+     */ _proto.__indirect = function __indirect(offset) {
+        return offset + this.readInt32(offset);
+    };
+    /**
+     * Get the start of data of a vector whose offset is stored at "offset" in this object.
+     */ _proto.__vector = function __vector(offset) {
+        return offset + this.readInt32(offset) + SIZEOF_INT; // data starts after the length
+    };
+    /**
+     * Get the length of a vector whose offset is stored at "offset" in this object.
+     */ _proto.__vector_len = function __vector_len(offset) {
+        return this.readInt32(offset + this.readInt32(offset));
+    };
+    _proto.__has_identifier = function __has_identifier(ident) {
+        if (ident.length != FILE_IDENTIFIER_LENGTH) {
+            throw new Error("FlatBuffers: file identifier must be length " + FILE_IDENTIFIER_LENGTH);
+        }
+        for(var i = 0; i < FILE_IDENTIFIER_LENGTH; i++){
+            if (ident.charCodeAt(i) != this.readInt8(this.position() + SIZEOF_INT + i)) {
+                return false;
+            }
+        }
+        return true;
+    };
+    /**
+     * A helper function for generating list for obj api
+     */ _proto.createScalarList = function createScalarList(listAccessor, listLength) {
+        var ret = [];
+        for(var i = 0; i < listLength; ++i){
+            var val = listAccessor(i);
+            if (val !== null) {
+                ret.push(val);
+            }
+        }
+        return ret;
+    };
+    /**
+     * A helper function for generating list for obj api
+     * @param listAccessor function that accepts an index and return data at that index
+     * @param listLength listLength
+     * @param res result list
+     */ _proto.createObjList = function createObjList(listAccessor, listLength) {
+        var ret = [];
+        for(var i = 0; i < listLength; ++i){
+            var val = listAccessor(i);
+            if (val !== null) {
+                ret.push(val.unpack());
+            }
+        }
+        return ret;
+    };
+    /**
+     * Create and allocate a new ByteBuffer with a given size.
+     */ ByteBuffer.allocate = function allocate(byte_size) {
+        return new ByteBuffer(new Uint8Array(byte_size));
+    };
+    return ByteBuffer;
+}();
+
+var Builder = /*#__PURE__*/ function() {
+    function Builder(opt_initial_size) {
+        /** Minimum alignment encountered so far. */ this.minalign = 1;
+        /** The vtable for the current table. */ this.vtable = null;
+        /** The amount of fields we're actually using. */ this.vtable_in_use = 0;
+        /** Whether we are currently serializing a table. */ this.isNested = false;
+        /** Starting offset of the current struct/table. */ this.object_start = 0;
+        /** List of offsets of all vtables. */ this.vtables = [];
+        /** For the current vector being built. */ this.vector_num_elems = 0;
+        /** False omits default values from the serialized data */ this.force_defaults = false;
+        this.string_maps = null;
+        this.text_encoder = new TextEncoder();
+        var initial_size;
+        if (!opt_initial_size) {
+            initial_size = 1024;
+        } else {
+            initial_size = opt_initial_size;
+        }
+        /**
+         * @type {ByteBuffer}
+         * @private
+         */ this.bb = ByteBuffer.allocate(initial_size);
+        this.space = initial_size;
+    }
+    var _proto = Builder.prototype;
+    _proto.clear = function clear() {
+        this.bb.clear();
+        this.space = this.bb.capacity();
+        this.minalign = 1;
+        this.vtable = null;
+        this.vtable_in_use = 0;
+        this.isNested = false;
+        this.object_start = 0;
+        this.vtables = [];
+        this.vector_num_elems = 0;
+        this.force_defaults = false;
+        this.string_maps = null;
+    };
+    /**
+     * In order to save space, fields that are set to their default value
+     * don't get serialized into the buffer. Forcing defaults provides a
+     * way to manually disable this optimization.
+     *
+     * @param forceDefaults true always serializes default values
+     */ _proto.forceDefaults = function forceDefaults(forceDefaults) {
+        this.force_defaults = forceDefaults;
+    };
+    /**
+     * Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+     * called finish(). The actual data starts at the ByteBuffer's current position,
+     * not necessarily at 0.
+     */ _proto.dataBuffer = function dataBuffer() {
+        return this.bb;
+    };
+    /**
+     * Get the bytes representing the FlatBuffer. Only call this after you've
+     * called finish().
+     */ _proto.asUint8Array = function asUint8Array() {
+        return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
+    };
+    /**
+     * Prepare to write an element of `size` after `additional_bytes` have been
+     * written, e.g. if you write a string, you need to align such the int length
+     * field is aligned to 4 bytes, and the string data follows it directly. If all
+     * you need to do is alignment, `additional_bytes` will be 0.
+     *
+     * @param size This is the of the new element to write
+     * @param additional_bytes The padding size
+     */ _proto.prep = function prep(size, additional_bytes) {
+        // Track the biggest thing we've ever aligned to.
+        if (size > this.minalign) {
+            this.minalign = size;
+        }
+        // Find the amount of alignment needed such that `size` is properly
+        // aligned after `additional_bytes`
+        var align_size = ~(this.bb.capacity() - this.space + additional_bytes) + 1 & size - 1;
+        // Reallocate the buffer if needed.
+        while(this.space < align_size + size + additional_bytes){
+            var old_buf_size = this.bb.capacity();
+            this.bb = Builder.growByteBuffer(this.bb);
+            this.space += this.bb.capacity() - old_buf_size;
+        }
+        this.pad(align_size);
+    };
+    _proto.pad = function pad(byte_size) {
+        for(var i = 0; i < byte_size; i++){
+            this.bb.writeInt8(--this.space, 0);
+        }
+    };
+    _proto.writeInt8 = function writeInt8(value) {
+        this.bb.writeInt8(this.space -= 1, value);
+    };
+    _proto.writeInt16 = function writeInt16(value) {
+        this.bb.writeInt16(this.space -= 2, value);
+    };
+    _proto.writeInt32 = function writeInt32(value) {
+        this.bb.writeInt32(this.space -= 4, value);
+    };
+    _proto.writeInt64 = function writeInt64(value) {
+        this.bb.writeInt64(this.space -= 8, value);
+    };
+    _proto.writeFloat32 = function writeFloat32(value) {
+        this.bb.writeFloat32(this.space -= 4, value);
+    };
+    _proto.writeFloat64 = function writeFloat64(value) {
+        this.bb.writeFloat64(this.space -= 8, value);
+    };
+    /**
+     * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int8` to add the buffer.
+     */ _proto.addInt8 = function addInt8(value) {
+        this.prep(1, 0);
+        this.writeInt8(value);
+    };
+    /**
+     * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int16` to add the buffer.
+     */ _proto.addInt16 = function addInt16(value) {
+        this.prep(2, 0);
+        this.writeInt16(value);
+    };
+    /**
+     * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int32` to add the buffer.
+     */ _proto.addInt32 = function addInt32(value) {
+        this.prep(4, 0);
+        this.writeInt32(value);
+    };
+    /**
+     * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int64` to add the buffer.
+     */ _proto.addInt64 = function addInt64(value) {
+        this.prep(8, 0);
+        this.writeInt64(value);
+    };
+    /**
+     * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `float32` to add the buffer.
+     */ _proto.addFloat32 = function addFloat32(value) {
+        this.prep(4, 0);
+        this.writeFloat32(value);
+    };
+    /**
+     * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `float64` to add the buffer.
+     */ _proto.addFloat64 = function addFloat64(value) {
+        this.prep(8, 0);
+        this.writeFloat64(value);
+    };
+    _proto.addFieldInt8 = function addFieldInt8(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addInt8(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldInt16 = function addFieldInt16(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addInt16(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldInt32 = function addFieldInt32(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addInt32(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldInt64 = function addFieldInt64(voffset, value, defaultValue) {
+        if (this.force_defaults || value !== defaultValue) {
+            this.addInt64(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldFloat32 = function addFieldFloat32(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addFloat32(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldFloat64 = function addFieldFloat64(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addFloat64(value);
+            this.slot(voffset);
+        }
+    };
+    _proto.addFieldOffset = function addFieldOffset(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+            this.addOffset(value);
+            this.slot(voffset);
+        }
+    };
+    /**
+     * Structs are stored inline, so nothing additional is being added. `d` is always 0.
+     */ _proto.addFieldStruct = function addFieldStruct(voffset, value, defaultValue) {
+        if (value != defaultValue) {
+            this.nested(value);
+            this.slot(voffset);
+        }
+    };
+    /**
+     * Structures are always stored inline, they need to be created right
+     * where they're used.  You'll get this assertion failure if you
+     * created it elsewhere.
+     */ _proto.nested = function nested(obj) {
+        if (obj != this.offset()) {
+            throw new TypeError("FlatBuffers: struct must be serialized inline.");
+        }
+    };
+    /**
+     * Should not be creating any other object, string or vector
+     * while an object is being constructed
+     */ _proto.notNested = function notNested() {
+        if (this.isNested) {
+            throw new TypeError("FlatBuffers: object serialization must not be nested.");
+        }
+    };
+    /**
+     * Set the current vtable at `voffset` to the current location in the buffer.
+     */ _proto.slot = function slot(voffset) {
+        if (this.vtable !== null) this.vtable[voffset] = this.offset();
+    };
+    /**
+     * @returns Offset relative to the end of the buffer.
+     */ _proto.offset = function offset() {
+        return this.bb.capacity() - this.space;
+    };
+    /**
+     * Adds on offset, relative to where it will be written.
+     *
+     * @param offset The offset to add.
+     */ _proto.addOffset = function addOffset(offset) {
+        this.prep(SIZEOF_INT, 0); // Ensure alignment is already done.
+        this.writeInt32(this.offset() - offset + SIZEOF_INT);
+    };
+    /**
+     * Start encoding a new object in the buffer.  Users will not usually need to
+     * call this directly. The FlatBuffers compiler will generate helper methods
+     * that call this method internally.
+     */ _proto.startObject = function startObject(numfields) {
+        this.notNested();
+        if (this.vtable == null) {
+            this.vtable = [];
+        }
+        this.vtable_in_use = numfields;
+        for(var i = 0; i < numfields; i++){
+            this.vtable[i] = 0; // This will push additional elements as needed
+        }
+        this.isNested = true;
+        this.object_start = this.offset();
+    };
+    /**
+     * Finish off writing the object that is under construction.
+     *
+     * @returns The offset to the object inside `dataBuffer`
+     */ _proto.endObject = function endObject() {
+        if (this.vtable == null || !this.isNested) {
+            throw new Error("FlatBuffers: endObject called without startObject");
+        }
+        this.addInt32(0);
+        var vtableloc = this.offset();
+        // Trim trailing zeroes.
+        var i = this.vtable_in_use - 1;
+        // eslint-disable-next-line no-empty
+        for(; i >= 0 && this.vtable[i] == 0; i--){}
+        var trimmed_size = i + 1;
+        // Write out the current vtable.
+        for(; i >= 0; i--){
+            // Offset relative to the start of the table.
+            this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);
+        }
+        var standard_fields = 2; // The fields below:
+        this.addInt16(vtableloc - this.object_start);
+        var len = (trimmed_size + standard_fields) * SIZEOF_SHORT;
+        this.addInt16(len);
+        // Search for an existing vtable that matches the current one.
+        var existing_vtable = 0;
+        var vt1 = this.space;
+        outer_loop: for(i = 0; i < this.vtables.length; i++){
+            var vt2 = this.bb.capacity() - this.vtables[i];
+            if (len == this.bb.readInt16(vt2)) {
+                for(var j = SIZEOF_SHORT; j < len; j += SIZEOF_SHORT){
+                    if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) {
+                        continue outer_loop;
+                    }
+                }
+                existing_vtable = this.vtables[i];
+                break;
+            }
+        }
+        if (existing_vtable) {
+            // Found a match:
+            // Remove the current vtable.
+            this.space = this.bb.capacity() - vtableloc;
+            // Point table to existing vtable.
+            this.bb.writeInt32(this.space, existing_vtable - vtableloc);
+        } else {
+            // No match:
+            // Add the location of the current vtable to the list of vtables.
+            this.vtables.push(this.offset());
+            // Point table to current vtable.
+            this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);
+        }
+        this.isNested = false;
+        return vtableloc;
+    };
+    /**
+     * Finalize a buffer, poiting to the given `root_table`.
+     */ _proto.finish = function finish(root_table, opt_file_identifier, opt_size_prefix) {
+        var size_prefix = opt_size_prefix ? SIZE_PREFIX_LENGTH : 0;
+        if (opt_file_identifier) {
+            var file_identifier = opt_file_identifier;
+            this.prep(this.minalign, SIZEOF_INT + FILE_IDENTIFIER_LENGTH + size_prefix);
+            if (file_identifier.length != FILE_IDENTIFIER_LENGTH) {
+                throw new TypeError("FlatBuffers: file identifier must be length " + FILE_IDENTIFIER_LENGTH);
+            }
+            for(var i = FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--){
+                this.writeInt8(file_identifier.charCodeAt(i));
+            }
+        }
+        this.prep(this.minalign, SIZEOF_INT + size_prefix);
+        this.addOffset(root_table);
+        if (size_prefix) {
+            this.addInt32(this.bb.capacity() - this.space);
+        }
+        this.bb.setPosition(this.space);
+    };
+    /**
+     * Finalize a size prefixed buffer, pointing to the given `root_table`.
+     */ _proto.finishSizePrefixed = function finishSizePrefixed(root_table, opt_file_identifier) {
+        this.finish(root_table, opt_file_identifier, true);
+    };
+    /**
+     * This checks a required field has been set in a given table that has
+     * just been constructed.
+     */ _proto.requiredField = function requiredField(table, field) {
+        var table_start = this.bb.capacity() - table;
+        var vtable_start = table_start - this.bb.readInt32(table_start);
+        var ok = field < this.bb.readInt16(vtable_start) && this.bb.readInt16(vtable_start + field) != 0;
+        // If this fails, the caller will show what field needs to be set.
+        if (!ok) {
+            throw new TypeError("FlatBuffers: field " + field + " must be set");
+        }
+    };
+    /**
+     * Start a new array/vector of objects.  Users usually will not call
+     * this directly. The FlatBuffers compiler will create a start/end
+     * method for vector types in generated code.
+     *
+     * @param elem_size The size of each element in the array
+     * @param num_elems The number of elements in the array
+     * @param alignment The alignment of the array
+     */ _proto.startVector = function startVector(elem_size, num_elems, alignment) {
+        this.notNested();
+        this.vector_num_elems = num_elems;
+        this.prep(SIZEOF_INT, elem_size * num_elems);
+        this.prep(alignment, elem_size * num_elems); // Just in case alignment > int.
+    };
+    /**
+     * Finish off the creation of an array and all its elements. The array must be
+     * created with `startVector`.
+     *
+     * @returns The offset at which the newly created array
+     * starts.
+     */ _proto.endVector = function endVector() {
+        this.writeInt32(this.vector_num_elems);
+        return this.offset();
+    };
+    /**
+     * Encode the string `s` in the buffer using UTF-8. If the string passed has
+     * already been seen, we return the offset of the already written string
+     *
+     * @param s The string to encode
+     * @return The offset in the buffer where the encoded string starts
+     */ _proto.createSharedString = function createSharedString(s) {
+        if (!s) {
+            return 0;
+        }
+        if (!this.string_maps) {
+            this.string_maps = new Map();
+        }
+        if (this.string_maps.has(s)) {
+            return this.string_maps.get(s);
+        }
+        var offset = this.createString(s);
+        this.string_maps.set(s, offset);
+        return offset;
+    };
+    /**
+     * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
+     * instead of a string, it is assumed to contain valid UTF-8 encoded data.
+     *
+     * @param s The string to encode
+     * @return The offset in the buffer where the encoded string starts
+     */ _proto.createString = function createString(s) {
+        if (s === null || s === undefined) {
+            return 0;
+        }
+        var utf8;
+        if (_instanceof1(s, Uint8Array)) {
+            utf8 = s;
+        } else {
+            utf8 = this.text_encoder.encode(s);
+        }
+        this.addInt8(0);
+        this.startVector(1, utf8.length, 1);
+        this.bb.setPosition(this.space -= utf8.length);
+        this.bb.bytes().set(utf8, this.space);
+        return this.endVector();
+    };
+    /**
+     * Create a byte vector.
+     *
+     * @param v The bytes to add
+     * @returns The offset in the buffer where the byte vector starts
+     */ _proto.createByteVector = function createByteVector(v) {
+        if (v === null || v === undefined) {
+            return 0;
+        }
+        this.startVector(1, v.length, 1);
+        this.bb.setPosition(this.space -= v.length);
+        this.bb.bytes().set(v, this.space);
+        return this.endVector();
+    };
+    /**
+     * A helper function to pack an object
+     *
+     * @returns offset of obj
+     */ _proto.createObjectOffset = function createObjectOffset(obj) {
+        if (obj === null) {
+            return 0;
+        }
+        if (typeof obj === "string") {
+            return this.createString(obj);
+        } else {
+            return obj.pack(this);
+        }
+    };
+    /**
+     * A helper function to pack a list of object
+     *
+     * @returns list of offsets of each non null object
+     */ _proto.createObjectOffsetList = function createObjectOffsetList(list) {
+        var ret = [];
+        for(var i = 0; i < list.length; ++i){
+            var val = list[i];
+            if (val !== null) {
+                ret.push(this.createObjectOffset(val));
+            } else {
+                throw new TypeError("FlatBuffers: Argument for createObjectOffsetList cannot contain null.");
+            }
+        }
+        return ret;
+    };
+    _proto.createStructOffsetList = function createStructOffsetList(list, startFunc) {
+        startFunc(this, list.length);
+        this.createObjectOffsetList(list.slice().reverse());
+        return this.endVector();
+    };
+    /**
+     * Doubles the size of the backing ByteBuffer and copies the old data towards
+     * the end of the new buffer (since we build the buffer backwards).
+     *
+     * @param bb The current buffer with the existing data
+     * @returns A new byte buffer with the old data copied
+     * to it. The data is located at the end of the buffer.
+     *
+     * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass
+     * it a uint8Array we need to suppress the type check:
+     * @suppress {checkTypes}
+     */ Builder.growByteBuffer = function growByteBuffer(bb) {
+        var old_buf_size = bb.capacity();
+        // Ensure we don't grow beyond what fits in an int.
+        if (old_buf_size & 0xC0000000) {
+            throw new Error("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+        }
+        var new_buf_size = old_buf_size << 1;
+        var nbb = ByteBuffer.allocate(new_buf_size);
+        nbb.setPosition(new_buf_size - old_buf_size);
+        nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);
+        return nbb;
+    };
+    return Builder;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBEffectsObjectData = /*#__PURE__*/ function() {
+    function FBEffectsObjectData() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBEffectsObjectData.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.dataType = function dataType(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.data = function data(index) {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    };
+    _proto.dataLength = function dataLength() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.dataArray = function dataArray() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    };
+    _proto.unpack = function unpack() {
+        return new FBEffectsObjectDataT(this.dataType(), this.bb.createScalarList(this.data.bind(this), this.dataLength()));
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.dataType = this.dataType();
+        _o.data = this.bb.createScalarList(this.data.bind(this), this.dataLength());
+    };
+    FBEffectsObjectData.getRootAsFBEffectsObjectData = function getRootAsFBEffectsObjectData(bb, obj) {
+        return (obj || new FBEffectsObjectData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBEffectsObjectData.getSizePrefixedRootAsFBEffectsObjectData = function getSizePrefixedRootAsFBEffectsObjectData(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBEffectsObjectData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBEffectsObjectData.startFBEffectsObjectData = function startFBEffectsObjectData(builder) {
+        builder.startObject(2);
+    };
+    FBEffectsObjectData.addDataType = function addDataType(builder, dataTypeOffset) {
+        builder.addFieldOffset(0, dataTypeOffset, 0);
+    };
+    FBEffectsObjectData.addData = function addData(builder, dataOffset) {
+        builder.addFieldOffset(1, dataOffset, 0);
+    };
+    FBEffectsObjectData.createDataVector = function createDataVector(builder, data) {
+        builder.startVector(1, data.length, 1);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addInt8(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBEffectsObjectData.startDataVector = function startDataVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
+    };
+    FBEffectsObjectData.endFBEffectsObjectData = function endFBEffectsObjectData(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBEffectsObjectData.createFBEffectsObjectData = function createFBEffectsObjectData(builder, dataTypeOffset, dataOffset) {
+        FBEffectsObjectData.startFBEffectsObjectData(builder);
+        FBEffectsObjectData.addDataType(builder, dataTypeOffset);
+        FBEffectsObjectData.addData(builder, dataOffset);
+        return FBEffectsObjectData.endFBEffectsObjectData(builder);
+    };
+    return FBEffectsObjectData;
+}();
+var FBEffectsObjectDataT = /*#__PURE__*/ function() {
+    function FBEffectsObjectDataT(dataType, data) {
+        if (dataType === void 0) dataType = null;
+        if (data === void 0) data = [];
+        this.dataType = dataType;
+        this.data = data;
+    }
+    var _proto = FBEffectsObjectDataT.prototype;
+    _proto.pack = function pack(builder) {
+        var dataType = this.dataType !== null ? builder.createString(this.dataType) : 0;
+        var data = FBEffectsObjectData.createDataVector(builder, this.data);
+        return FBEffectsObjectData.createFBEffectsObjectData(builder, dataType, data);
+    };
+    return FBEffectsObjectDataT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBEffectsPackageData = /*#__PURE__*/ function() {
+    function FBEffectsPackageData() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBEffectsPackageData.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.exportObjects = function exportObjects(index, obj) {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new FBEffectsObjectData()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    };
+    _proto.exportObjectsLength = function exportObjectsLength() {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.unpack = function unpack() {
+        return new FBEffectsPackageDataT(this.bb.createObjList(this.exportObjects.bind(this), this.exportObjectsLength()));
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.exportObjects = this.bb.createObjList(this.exportObjects.bind(this), this.exportObjectsLength());
+    };
+    FBEffectsPackageData.getRootAsFBEffectsPackageData = function getRootAsFBEffectsPackageData(bb, obj) {
+        return (obj || new FBEffectsPackageData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBEffectsPackageData.getSizePrefixedRootAsFBEffectsPackageData = function getSizePrefixedRootAsFBEffectsPackageData(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBEffectsPackageData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBEffectsPackageData.startFBEffectsPackageData = function startFBEffectsPackageData(builder) {
+        builder.startObject(1);
+    };
+    FBEffectsPackageData.addExportObjects = function addExportObjects(builder, exportObjectsOffset) {
+        builder.addFieldOffset(0, exportObjectsOffset, 0);
+    };
+    FBEffectsPackageData.createExportObjectsVector = function createExportObjectsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBEffectsPackageData.startExportObjectsVector = function startExportObjectsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBEffectsPackageData.endFBEffectsPackageData = function endFBEffectsPackageData(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBEffectsPackageData.finishFBEffectsPackageDataBuffer = function finishFBEffectsPackageDataBuffer(builder, offset) {
+        builder.finish(offset);
+    };
+    FBEffectsPackageData.finishSizePrefixedFBEffectsPackageDataBuffer = function finishSizePrefixedFBEffectsPackageDataBuffer(builder, offset) {
+        builder.finish(offset, undefined, true);
+    };
+    FBEffectsPackageData.createFBEffectsPackageData = function createFBEffectsPackageData(builder, exportObjectsOffset) {
+        FBEffectsPackageData.startFBEffectsPackageData(builder);
+        FBEffectsPackageData.addExportObjects(builder, exportObjectsOffset);
+        return FBEffectsPackageData.endFBEffectsPackageData(builder);
+    };
+    return FBEffectsPackageData;
+}();
+var FBEffectsPackageDataT = /*#__PURE__*/ function() {
+    function FBEffectsPackageDataT(exportObjects) {
+        if (exportObjects === void 0) exportObjects = [];
+        this.exportObjects = exportObjects;
+    }
+    var _proto = FBEffectsPackageDataT.prototype;
+    _proto.pack = function pack(builder) {
+        var exportObjects = FBEffectsPackageData.createExportObjectsVector(builder, builder.createObjectOffsetList(this.exportObjects));
+        return FBEffectsPackageData.createFBEffectsPackageData(builder, exportObjects);
+    };
+    return FBEffectsPackageDataT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBSubMesh = /*#__PURE__*/ function() {
+    function FBSubMesh() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBSubMesh.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.offset = function offset() {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.indexCount = function indexCount() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.vertexCount = function vertexCount() {
+        var offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.unpack = function unpack() {
+        return new FBSubMeshT(this.offset(), this.indexCount(), this.vertexCount());
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.offset = this.offset();
+        _o.indexCount = this.indexCount();
+        _o.vertexCount = this.vertexCount();
+    };
+    FBSubMesh.getRootAsFBSubMesh = function getRootAsFBSubMesh(bb, obj) {
+        return (obj || new FBSubMesh()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBSubMesh.getSizePrefixedRootAsFBSubMesh = function getSizePrefixedRootAsFBSubMesh(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBSubMesh()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBSubMesh.startFBSubMesh = function startFBSubMesh(builder) {
+        builder.startObject(3);
+    };
+    FBSubMesh.addOffset = function addOffset(builder, offset) {
+        builder.addFieldInt32(0, offset, 0);
+    };
+    FBSubMesh.addIndexCount = function addIndexCount(builder, indexCount) {
+        builder.addFieldInt32(1, indexCount, 0);
+    };
+    FBSubMesh.addVertexCount = function addVertexCount(builder, vertexCount) {
+        builder.addFieldInt32(2, vertexCount, 0);
+    };
+    FBSubMesh.endFBSubMesh = function endFBSubMesh(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBSubMesh.createFBSubMesh = function createFBSubMesh(builder, offset, indexCount, vertexCount) {
+        FBSubMesh.startFBSubMesh(builder);
+        FBSubMesh.addOffset(builder, offset);
+        FBSubMesh.addIndexCount(builder, indexCount);
+        FBSubMesh.addVertexCount(builder, vertexCount);
+        return FBSubMesh.endFBSubMesh(builder);
+    };
+    return FBSubMesh;
+}();
+var FBSubMeshT = /*#__PURE__*/ function() {
+    function FBSubMeshT(offset, indexCount, vertexCount) {
+        if (offset === void 0) offset = 0;
+        if (indexCount === void 0) indexCount = 0;
+        if (vertexCount === void 0) vertexCount = 0;
+        this.offset = offset;
+        this.indexCount = indexCount;
+        this.vertexCount = vertexCount;
+    }
+    var _proto = FBSubMeshT.prototype;
+    _proto.pack = function pack(builder) {
+        return FBSubMesh.createFBSubMesh(builder, this.offset, this.indexCount, this.vertexCount);
+    };
+    return FBSubMeshT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBVertexChannel = /*#__PURE__*/ function() {
+    function FBVertexChannel() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBVertexChannel.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.semantic = function semantic(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.offset = function offset() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.format = function format() {
+        var offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.dimension = function dimension() {
+        var offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.normalize = function normalize() {
+        var offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    };
+    _proto.unpack = function unpack() {
+        return new FBVertexChannelT(this.semantic(), this.offset(), this.format(), this.dimension(), this.normalize());
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.semantic = this.semantic();
+        _o.offset = this.offset();
+        _o.format = this.format();
+        _o.dimension = this.dimension();
+        _o.normalize = this.normalize();
+    };
+    FBVertexChannel.getRootAsFBVertexChannel = function getRootAsFBVertexChannel(bb, obj) {
+        return (obj || new FBVertexChannel()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBVertexChannel.getSizePrefixedRootAsFBVertexChannel = function getSizePrefixedRootAsFBVertexChannel(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBVertexChannel()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBVertexChannel.startFBVertexChannel = function startFBVertexChannel(builder) {
+        builder.startObject(5);
+    };
+    FBVertexChannel.addSemantic = function addSemantic(builder, semanticOffset) {
+        builder.addFieldOffset(0, semanticOffset, 0);
+    };
+    FBVertexChannel.addOffset = function addOffset(builder, offset) {
+        builder.addFieldInt32(1, offset, 0);
+    };
+    FBVertexChannel.addFormat = function addFormat(builder, format) {
+        builder.addFieldInt32(2, format, 0);
+    };
+    FBVertexChannel.addDimension = function addDimension(builder, dimension) {
+        builder.addFieldInt32(3, dimension, 0);
+    };
+    FBVertexChannel.addNormalize = function addNormalize(builder, normalize) {
+        builder.addFieldInt8(4, +normalize, +false);
+    };
+    FBVertexChannel.endFBVertexChannel = function endFBVertexChannel(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBVertexChannel.createFBVertexChannel = function createFBVertexChannel(builder, semanticOffset, offset, format, dimension, normalize) {
+        FBVertexChannel.startFBVertexChannel(builder);
+        FBVertexChannel.addSemantic(builder, semanticOffset);
+        FBVertexChannel.addOffset(builder, offset);
+        FBVertexChannel.addFormat(builder, format);
+        FBVertexChannel.addDimension(builder, dimension);
+        FBVertexChannel.addNormalize(builder, normalize);
+        return FBVertexChannel.endFBVertexChannel(builder);
+    };
+    return FBVertexChannel;
+}();
+var FBVertexChannelT = /*#__PURE__*/ function() {
+    function FBVertexChannelT(semantic, offset, format, dimension, normalize) {
+        if (semantic === void 0) semantic = null;
+        if (offset === void 0) offset = 0;
+        if (format === void 0) format = 0;
+        if (dimension === void 0) dimension = 0;
+        if (normalize === void 0) normalize = false;
+        this.semantic = semantic;
+        this.offset = offset;
+        this.format = format;
+        this.dimension = dimension;
+        this.normalize = normalize;
+    }
+    var _proto = FBVertexChannelT.prototype;
+    _proto.pack = function pack(builder) {
+        var semantic = this.semantic !== null ? builder.createString(this.semantic) : 0;
+        return FBVertexChannel.createFBVertexChannel(builder, semantic, this.offset, this.format, this.dimension, this.normalize);
+    };
+    return FBVertexChannelT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBVertexData = /*#__PURE__*/ function() {
+    function FBVertexData() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBVertexData.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.vertexCount = function vertexCount() {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.channels = function channels(index, obj) {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new FBVertexChannel()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    };
+    _proto.channelsLength = function channelsLength() {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.unpack = function unpack() {
+        return new FBVertexDataT(this.vertexCount(), this.bb.createObjList(this.channels.bind(this), this.channelsLength()));
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.vertexCount = this.vertexCount();
+        _o.channels = this.bb.createObjList(this.channels.bind(this), this.channelsLength());
+    };
+    FBVertexData.getRootAsFBVertexData = function getRootAsFBVertexData(bb, obj) {
+        return (obj || new FBVertexData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBVertexData.getSizePrefixedRootAsFBVertexData = function getSizePrefixedRootAsFBVertexData(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBVertexData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBVertexData.startFBVertexData = function startFBVertexData(builder) {
+        builder.startObject(2);
+    };
+    FBVertexData.addVertexCount = function addVertexCount(builder, vertexCount) {
+        builder.addFieldInt32(0, vertexCount, 0);
+    };
+    FBVertexData.addChannels = function addChannels(builder, channelsOffset) {
+        builder.addFieldOffset(1, channelsOffset, 0);
+    };
+    FBVertexData.createChannelsVector = function createChannelsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBVertexData.startChannelsVector = function startChannelsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBVertexData.endFBVertexData = function endFBVertexData(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    FBVertexData.createFBVertexData = function createFBVertexData(builder, vertexCount, channelsOffset) {
+        FBVertexData.startFBVertexData(builder);
+        FBVertexData.addVertexCount(builder, vertexCount);
+        FBVertexData.addChannels(builder, channelsOffset);
+        return FBVertexData.endFBVertexData(builder);
+    };
+    return FBVertexData;
+}();
+var FBVertexDataT = /*#__PURE__*/ function() {
+    function FBVertexDataT(vertexCount, channels) {
+        if (vertexCount === void 0) vertexCount = 0;
+        if (channels === void 0) channels = [];
+        this.vertexCount = vertexCount;
+        this.channels = channels;
+    }
+    var _proto = FBVertexDataT.prototype;
+    _proto.pack = function pack(builder) {
+        var channels = FBVertexData.createChannelsVector(builder, builder.createObjectOffsetList(this.channels));
+        return FBVertexData.createFBVertexData(builder, this.vertexCount, channels);
+    };
+    return FBVertexDataT;
+}();
+
+// automatically generated by the FlatBuffers compiler, do not modify
+var FBGeometryData = /*#__PURE__*/ function() {
+    function FBGeometryData() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    var _proto = FBGeometryData.prototype;
+    _proto.__init = function __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    };
+    _proto.id = function id(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.name = function name(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.vertexData = function vertexData(obj) {
+        var offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? (obj || new FBVertexData()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    };
+    _proto.indexFormat = function indexFormat() {
+        var offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.indexOffset = function indexOffset() {
+        var offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.subMeshes = function subMeshes(index, obj) {
+        var offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? (obj || new FBSubMesh()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    };
+    _proto.subMeshesLength = function subMeshesLength() {
+        var offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.mode = function mode() {
+        var offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    };
+    _proto.buffer = function buffer(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.binaryData = function binaryData(index) {
+        var offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    };
+    _proto.binaryDataLength = function binaryDataLength() {
+        var offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.binaryDataArray = function binaryDataArray() {
+        var offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    };
+    _proto.boneNames = function boneNames(index, optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+    };
+    _proto.boneNamesLength = function boneNamesLength() {
+        var offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.rootBoneName = function rootBoneName(optionalEncoding) {
+        var offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    };
+    _proto.inverseBindMatrices = function inverseBindMatrices(index) {
+        var offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
+    };
+    _proto.inverseBindMatricesLength = function inverseBindMatricesLength() {
+        var offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    };
+    _proto.inverseBindMatricesArray = function inverseBindMatricesArray() {
+        var offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    };
+    _proto.unpack = function unpack() {
+        return new FBGeometryDataT(this.id(), this.name(), this.vertexData() !== null ? this.vertexData().unpack() : null, this.indexFormat(), this.indexOffset(), this.bb.createObjList(this.subMeshes.bind(this), this.subMeshesLength()), this.mode(), this.buffer(), this.bb.createScalarList(this.binaryData.bind(this), this.binaryDataLength()), this.bb.createScalarList(this.boneNames.bind(this), this.boneNamesLength()), this.rootBoneName(), this.bb.createScalarList(this.inverseBindMatrices.bind(this), this.inverseBindMatricesLength()));
+    };
+    _proto.unpackTo = function unpackTo(_o) {
+        _o.id = this.id();
+        _o.name = this.name();
+        _o.vertexData = this.vertexData() !== null ? this.vertexData().unpack() : null;
+        _o.indexFormat = this.indexFormat();
+        _o.indexOffset = this.indexOffset();
+        _o.subMeshes = this.bb.createObjList(this.subMeshes.bind(this), this.subMeshesLength());
+        _o.mode = this.mode();
+        _o.buffer = this.buffer();
+        _o.binaryData = this.bb.createScalarList(this.binaryData.bind(this), this.binaryDataLength());
+        _o.boneNames = this.bb.createScalarList(this.boneNames.bind(this), this.boneNamesLength());
+        _o.rootBoneName = this.rootBoneName();
+        _o.inverseBindMatrices = this.bb.createScalarList(this.inverseBindMatrices.bind(this), this.inverseBindMatricesLength());
+    };
+    FBGeometryData.getRootAsFBGeometryData = function getRootAsFBGeometryData(bb, obj) {
+        return (obj || new FBGeometryData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBGeometryData.getSizePrefixedRootAsFBGeometryData = function getSizePrefixedRootAsFBGeometryData(bb, obj) {
+        bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
+        return (obj || new FBGeometryData()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    };
+    FBGeometryData.startFBGeometryData = function startFBGeometryData(builder) {
+        builder.startObject(12);
+    };
+    FBGeometryData.addId = function addId(builder, idOffset) {
+        builder.addFieldOffset(0, idOffset, 0);
+    };
+    FBGeometryData.addName = function addName(builder, nameOffset) {
+        builder.addFieldOffset(1, nameOffset, 0);
+    };
+    FBGeometryData.addVertexData = function addVertexData(builder, vertexDataOffset) {
+        builder.addFieldOffset(2, vertexDataOffset, 0);
+    };
+    FBGeometryData.addIndexFormat = function addIndexFormat(builder, indexFormat) {
+        builder.addFieldInt32(3, indexFormat, 0);
+    };
+    FBGeometryData.addIndexOffset = function addIndexOffset(builder, indexOffset) {
+        builder.addFieldInt32(4, indexOffset, 0);
+    };
+    FBGeometryData.addSubMeshes = function addSubMeshes(builder, subMeshesOffset) {
+        builder.addFieldOffset(5, subMeshesOffset, 0);
+    };
+    FBGeometryData.createSubMeshesVector = function createSubMeshesVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBGeometryData.startSubMeshesVector = function startSubMeshesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBGeometryData.addMode = function addMode(builder, mode) {
+        builder.addFieldInt32(6, mode, 0);
+    };
+    FBGeometryData.addBuffer = function addBuffer(builder, bufferOffset) {
+        builder.addFieldOffset(7, bufferOffset, 0);
+    };
+    FBGeometryData.addBinaryData = function addBinaryData(builder, binaryDataOffset) {
+        builder.addFieldOffset(8, binaryDataOffset, 0);
+    };
+    FBGeometryData.createBinaryDataVector = function createBinaryDataVector(builder, data) {
+        builder.startVector(1, data.length, 1);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addInt8(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBGeometryData.startBinaryDataVector = function startBinaryDataVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
+    };
+    FBGeometryData.addBoneNames = function addBoneNames(builder, boneNamesOffset) {
+        builder.addFieldOffset(9, boneNamesOffset, 0);
+    };
+    FBGeometryData.createBoneNamesVector = function createBoneNamesVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBGeometryData.startBoneNamesVector = function startBoneNamesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBGeometryData.addRootBoneName = function addRootBoneName(builder, rootBoneNameOffset) {
+        builder.addFieldOffset(10, rootBoneNameOffset, 0);
+    };
+    FBGeometryData.addInverseBindMatrices = function addInverseBindMatrices(builder, inverseBindMatricesOffset) {
+        builder.addFieldOffset(11, inverseBindMatricesOffset, 0);
+    };
+    FBGeometryData.createInverseBindMatricesVector = function createInverseBindMatricesVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for(var i = data.length - 1; i >= 0; i--){
+            builder.addFloat32(data[i]);
+        }
+        return builder.endVector();
+    };
+    FBGeometryData.startInverseBindMatricesVector = function startInverseBindMatricesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    };
+    FBGeometryData.endFBGeometryData = function endFBGeometryData(builder) {
+        var offset = builder.endObject();
+        return offset;
+    };
+    return FBGeometryData;
+}();
+var FBGeometryDataT = /*#__PURE__*/ function() {
+    function FBGeometryDataT(id, name, vertexData, indexFormat, indexOffset, subMeshes, mode, buffer, binaryData, boneNames, rootBoneName, inverseBindMatrices) {
+        if (id === void 0) id = null;
+        if (name === void 0) name = null;
+        if (vertexData === void 0) vertexData = null;
+        if (indexFormat === void 0) indexFormat = 0;
+        if (indexOffset === void 0) indexOffset = 0;
+        if (subMeshes === void 0) subMeshes = [];
+        if (mode === void 0) mode = 0;
+        if (buffer === void 0) buffer = null;
+        if (binaryData === void 0) binaryData = [];
+        if (boneNames === void 0) boneNames = [];
+        if (rootBoneName === void 0) rootBoneName = null;
+        if (inverseBindMatrices === void 0) inverseBindMatrices = [];
+        this.id = id;
+        this.name = name;
+        this.vertexData = vertexData;
+        this.indexFormat = indexFormat;
+        this.indexOffset = indexOffset;
+        this.subMeshes = subMeshes;
+        this.mode = mode;
+        this.buffer = buffer;
+        this.binaryData = binaryData;
+        this.boneNames = boneNames;
+        this.rootBoneName = rootBoneName;
+        this.inverseBindMatrices = inverseBindMatrices;
+    }
+    var _proto = FBGeometryDataT.prototype;
+    _proto.pack = function pack(builder) {
+        var id = this.id !== null ? builder.createString(this.id) : 0;
+        var name = this.name !== null ? builder.createString(this.name) : 0;
+        var vertexData = this.vertexData !== null ? this.vertexData.pack(builder) : 0;
+        var subMeshes = FBGeometryData.createSubMeshesVector(builder, builder.createObjectOffsetList(this.subMeshes));
+        var buffer = this.buffer !== null ? builder.createString(this.buffer) : 0;
+        var binaryData = FBGeometryData.createBinaryDataVector(builder, this.binaryData);
+        var boneNames = FBGeometryData.createBoneNamesVector(builder, builder.createObjectOffsetList(this.boneNames));
+        var rootBoneName = this.rootBoneName !== null ? builder.createString(this.rootBoneName) : 0;
+        var inverseBindMatrices = FBGeometryData.createInverseBindMatricesVector(builder, this.inverseBindMatrices);
+        FBGeometryData.startFBGeometryData(builder);
+        FBGeometryData.addId(builder, id);
+        FBGeometryData.addName(builder, name);
+        FBGeometryData.addVertexData(builder, vertexData);
+        FBGeometryData.addIndexFormat(builder, this.indexFormat);
+        FBGeometryData.addIndexOffset(builder, this.indexOffset);
+        FBGeometryData.addSubMeshes(builder, subMeshes);
+        FBGeometryData.addMode(builder, this.mode);
+        FBGeometryData.addBuffer(builder, buffer);
+        FBGeometryData.addBinaryData(builder, binaryData);
+        FBGeometryData.addBoneNames(builder, boneNames);
+        FBGeometryData.addRootBoneName(builder, rootBoneName);
+        FBGeometryData.addInverseBindMatrices(builder, inverseBindMatrices);
+        return FBGeometryData.endFBGeometryData(builder);
+    };
+    return FBGeometryDataT;
+}();
+
+var EffectsPackage = /*#__PURE__*/ function() {
+    function EffectsPackage() {
+        this.exportObjectDatas = [];
+    }
+    var _proto = EffectsPackage.prototype;
+    _proto.addData = function addData(effectsObjectData) {
+        this.exportObjectDatas.push(effectsObjectData);
+    };
+    _proto.serializeToBinary = function serializeToBinary() {
+        var fbb = new Builder(1);
+        var effectsPackage = new FBEffectsPackageDataT();
+        var exportObjects = [];
+        for(var _iterator = _create_for_of_iterator_helper_loose(this.exportObjectDatas), _step; !(_step = _iterator()).done;){
+            var effectsObjectData = _step.value;
+            var fbEffectsObjectData = void 0;
+            if (effectsObjectData.dataType === DataType.Geometry) {
+                fbEffectsObjectData = new FBEffectsObjectDataT("Geometry", this.geometryDataToBinary(effectsObjectData));
+            }
+            if (!fbEffectsObjectData) {
+                continue;
+            }
+            exportObjects.push(fbEffectsObjectData);
+        }
+        effectsPackage.exportObjects = exportObjects;
+        FBEffectsPackageData.finishFBEffectsPackageDataBuffer(fbb, effectsPackage.pack(fbb));
+        var buffer = fbb.asUint8Array(); // Of type `Uint8Array`.
+        return buffer;
+    };
+    _proto.deserializeFromBinary = function deserializeFromBinary(buffer) {
+        var buf = new ByteBuffer(buffer);
+        var fbEffectsPackage = FBEffectsPackageData.getRootAsFBEffectsPackageData(buf);
+        for(var i = 0; i < fbEffectsPackage.exportObjectsLength(); i++){
+            var fbEffectsObjectData = fbEffectsPackage.exportObjects(i);
+            if (!fbEffectsObjectData) {
+                continue;
+            }
+            var dataBuffer = fbEffectsObjectData.dataArray();
+            var dataType = fbEffectsObjectData.dataType();
+            if (!dataBuffer) {
+                continue;
+            }
+            var effectsObjectData = void 0;
+            if (dataType === DataType.Geometry) {
+                effectsObjectData = this.binaryToGeometryData(dataBuffer);
+            }
+            if (!effectsObjectData) {
+                continue;
+            }
+            this.exportObjectDatas.push(effectsObjectData);
+        }
+    };
+    _proto.geometryDataToBinary = function geometryDataToBinary(geometryData) {
+        var fbb = new Builder(1);
+        var fbGeometryData = new FBGeometryDataT();
+        fbGeometryData.indexFormat = geometryData.indexFormat;
+        fbGeometryData.indexOffset = geometryData.indexOffset;
+        fbGeometryData.mode = geometryData.mode;
+        fbGeometryData.id = geometryData.id;
+        var _geometryData_boneNames;
+        fbGeometryData.boneNames = (_geometryData_boneNames = geometryData.boneNames) != null ? _geometryData_boneNames : [];
+        var _geometryData_rootBoneName;
+        fbGeometryData.rootBoneName = (_geometryData_rootBoneName = geometryData.rootBoneName) != null ? _geometryData_rootBoneName : "";
+        var _geometryData_inverseBindMatrices;
+        fbGeometryData.inverseBindMatrices = (_geometryData_inverseBindMatrices = geometryData.inverseBindMatrices) != null ? _geometryData_inverseBindMatrices : [];
+        var _geometryData_binaryData;
+        fbGeometryData.binaryData = (_geometryData_binaryData = geometryData.binaryData) != null ? _geometryData_binaryData : [];
+        var fbVertexdata = new FBVertexDataT();
+        fbVertexdata.vertexCount = geometryData.vertexData.vertexCount;
+        fbVertexdata.channels = [];
+        for(var _iterator = _create_for_of_iterator_helper_loose(geometryData.vertexData.channels), _step; !(_step = _iterator()).done;){
+            var channel = _step.value;
+            var fbChannel = new FBVertexChannelT(channel.semantic, channel.offset, channel.format, channel.dimension, channel.normalize);
+            fbVertexdata.channels.push(fbChannel);
+        }
+        fbGeometryData.vertexData = fbVertexdata;
+        var fbSubMeshes = [];
+        for(var _iterator1 = _create_for_of_iterator_helper_loose(geometryData.subMeshes), _step1; !(_step1 = _iterator1()).done;){
+            var subMesh = _step1.value;
+            var fbSubMesh = new FBSubMeshT(subMesh.offset, subMesh.indexCount, subMesh.vertexCount);
+            fbSubMeshes.push(fbSubMesh);
+        }
+        fbGeometryData.subMeshes = fbSubMeshes;
+        FBEffectsPackageData.finishFBEffectsPackageDataBuffer(fbb, fbGeometryData.pack(fbb));
+        var buffer = fbb.asUint8Array(); // Of type `Uint8Array`.
+        return buffer;
+    };
+    _proto.binaryToGeometryData = function binaryToGeometryData(buffer) {
+        var buf = new ByteBuffer(buffer);
+        var fbGeometryData = FBGeometryData.getRootAsFBGeometryData(buf);
+        var vertexData = {
+            vertexCount: 0,
+            channels: []
+        };
+        var fbVertexData = fbGeometryData.vertexData();
+        if (fbVertexData) {
+            vertexData.vertexCount = fbVertexData.vertexCount();
+            for(var i = 0; i < fbVertexData.channelsLength(); i++){
+                var channel = fbVertexData.channels(i);
+                if (!channel) {
+                    continue;
+                }
+                var _channel_semantic;
+                var vertexChannel = {
+                    semantic: (_channel_semantic = channel.semantic()) != null ? _channel_semantic : "",
+                    offset: channel.offset(),
+                    format: channel.format(),
+                    dimension: channel.dimension()
+                };
+                vertexData.channels.push(vertexChannel);
+            }
+        }
+        var subMeshes = [];
+        for(var i1 = 0; i1 < fbGeometryData.subMeshesLength(); i1++){
+            var fbSubMesh = fbGeometryData.subMeshes(i1);
+            if (!fbSubMesh) {
+                continue;
+            }
+            var subMesh = {
+                offset: fbSubMesh.offset(),
+                vertexCount: fbSubMesh.vertexCount()
+            };
+            subMeshes.push(subMesh);
+        }
+        var boneNames = [];
+        for(var i2 = 0; i2 < fbGeometryData.boneNamesLength(); i2++){
+            var boneName = fbGeometryData.boneNames(i2);
+            boneNames.push(boneName);
+        }
+        var inverseBindMatricesArray = fbGeometryData.inverseBindMatricesArray();
+        var _fbGeometryData_buffer, _fbGeometryData_rootBoneName, _fbGeometryData_binaryDataArray, _fbGeometryData_id;
+        var geometryData = {
+            vertexData: vertexData,
+            indexFormat: fbGeometryData.indexFormat(),
+            indexOffset: fbGeometryData.indexOffset(),
+            subMeshes: subMeshes,
+            mode: fbGeometryData.mode(),
+            buffer: (_fbGeometryData_buffer = fbGeometryData.buffer()) != null ? _fbGeometryData_buffer : "",
+            boneNames: boneNames,
+            rootBoneName: (_fbGeometryData_rootBoneName = fbGeometryData.rootBoneName()) != null ? _fbGeometryData_rootBoneName : "",
+            inverseBindMatrices: inverseBindMatricesArray ? Array.from(inverseBindMatricesArray) : undefined,
+            binaryData: (_fbGeometryData_binaryDataArray = fbGeometryData.binaryDataArray()) != null ? _fbGeometryData_binaryDataArray : undefined,
+            id: (_fbGeometryData_id = fbGeometryData.id()) != null ? _fbGeometryData_id : "",
+            dataType: DataType.Geometry
+        };
+        return geometryData;
+    };
+    return EffectsPackage;
+}();
+
 /**
  * Engine 基类，负责维护所有 GPU 资源的管理及销毁
  */ var Engine = /*#__PURE__*/ function() {
@@ -25408,16 +26976,23 @@ var listOrder = 0;
         for(var i = 0; i < bins.length; i++){
             var binaryData = bins[i];
             var binaryBuffer = scene.bins[i];
-            //@ts-expect-error
-            binaryData.buffer = binaryBuffer;
-            //@ts-expect-error
-            if (binaryData.id) {
+            if (binaryData.dataType === DataType.BinaryAsset) {
                 //@ts-expect-error
-                this.addEffectsObjectData(binaryData);
+                binaryData.buffer = binaryBuffer;
+                if (binaryData.id) {
+                    this.addEffectsObjectData(binaryData);
+                }
+            } else {
+                var effectsPackage = new EffectsPackage();
+                effectsPackage.deserializeFromBinary(new Uint8Array(binaryBuffer));
+                for(var _iterator7 = _create_for_of_iterator_helper_loose(effectsPackage.exportObjectDatas), _step7; !(_step7 = _iterator7()).done;){
+                    var effectsObjectData = _step7.value;
+                    this.addEffectsObjectData(effectsObjectData);
+                }
             }
         }
-        for(var _iterator7 = _create_for_of_iterator_helper_loose(textureOptions), _step7; !(_step7 = _iterator7()).done;){
-            var textureData = _step7.value;
+        for(var _iterator8 = _create_for_of_iterator_helper_loose(textureOptions), _step8; !(_step8 = _iterator8()).done;){
+            var textureData = _step8.value;
             this.addEffectsObjectData(textureData);
         }
     };
@@ -25727,8 +27302,8 @@ registerPlugin("sprite", SpriteLoader, VFXItem, true);
 registerPlugin("particle", ParticleLoader, VFXItem, true);
 registerPlugin("cal", CalculateLoader, VFXItem, true);
 registerPlugin("interact", InteractLoader, VFXItem, true);
-var version = "2.0.0-alpha.26";
+var version = "2.0.0-alpha.27";
 logger.info("Core version: " + version + ".");
 
-export { AbstractPlugin, ActivationPlayable, ActivationPlayableAsset, ActivationTrack, AnimationClip, AnimationClipPlayable, AssetLoader, AssetManager, BYTES_TYPE_MAP, Behaviour, BezierCurve, BezierCurvePath, BezierCurveQuat, BinaryAsset, COMPRESSED_TEXTURE, COPY_FRAGMENT_SHADER, COPY_MESH_SHADER_ID, COPY_VERTEX_SHADER, CalculateLoader, Camera, CameraController, CameraVFXItemLoader, Component, Composition, CompositionComponent, CompositionSourceManager, DEFAULT_FONTS, Database, DestroyOptions, Downloader, EFFECTS_COPY_MESH_NAME, EVENT_TYPE_CLICK, EVENT_TYPE_TOUCH_END, EVENT_TYPE_TOUCH_MOVE, EVENT_TYPE_TOUCH_START, EffectComponent, EffectsObject, Engine, EventSystem, FilterMode, Float16ArrayWrapper, Framebuffer, GLSLVersion, GPUCapability, Geometry, GlobalUniforms, GradientValue, HELP_LINK, HitTestType, InteractComponent, InteractLoader, InteractMesh, Item, ItemBehaviour, KTXTexture, LineSegments, LinearValue, Material, MaterialDataBlock, MaterialRenderType, Mesh, ObjectBindingTrack, OrderType, PLAYER_OPTIONS_ENV_EDITOR, POST_PROCESS_SETTINGS, ParticleBehaviourPlayable, ParticleBehaviourPlayableAsset, ParticleLoader, ParticleMesh, ParticleSystem, ParticleSystemRenderer, PassTextureCache, PathSegments, PluginSystem, RENDER_PASS_NAME_PREFIX, RENDER_PREFER_LOOKUP_TEXTURE, RUNTIME_ENV, RandomSetValue, RandomValue, RandomVectorValue, RenderFrame, RenderPass, RenderPassAttachmentStorageType, RenderPassDestroyAttachmentType, RenderPassPriorityNormal, RenderPassPriorityPostprocess, RenderPassPriorityPrepare, RenderTargetHandle, RenderTextureFormat, Renderbuffer, Renderer, RendererComponent, RuntimeClip, SEMANTIC_MAIN_PRE_COLOR_ATTACHMENT_0, SEMANTIC_MAIN_PRE_COLOR_ATTACHMENT_SIZE_0, SEMANTIC_PRE_COLOR_ATTACHMENT_0, SEMANTIC_PRE_COLOR_ATTACHMENT_SIZE_0, SPRITE_VERTEX_STRIDE, SemanticMap, SerializationHelper, Shader, ShaderCompileResultStatus, ShaderType, ShaderVariant, SpriteColorPlayable, SpriteColorPlayableAsset, SpriteColorTrack, SpriteComponent, SpriteLoader, StaticValue, SubCompositionPlayableAsset, SubCompositionTrack, TEMPLATE_USE_OFFSCREEN_CANVAS, TextComponent, TextComponentBase, TextLayout, TextLoader, TextStyle, Texture, TextureFactory, TextureLoadAction, TextureSourceType, TextureStoreAction, Ticker, TimelineAsset, TimelineClip, TimelinePlayable, TrackAsset, TrackSortWrapper, TrackType, Transform, TransformAnimationPlayable, TransformPlayableAsset, TransformTrack, VFXItem, ValueGetter, addByOrder, addItem, addItemWithOrder, applyMixins, assertExist, asserts, base64ToFile, blend, calculateTranslation, canvasPool, colorGradingFrag, colorStopsFromGradient, colorToArr$1 as colorToArr, combineImageTemplate, compatible_frag as compatibleFrag, compatible_vert as compatibleVert, createCopyShader, createGLContext, createKeyFrameMeta, createShaderWithMacros, createShape, createVFXItem, createValueGetter, decimalEqual, defaultGlobalVolume, defaultPlugins, deserializeMipmapTexture, earcut, effectsClass, effectsClassStore, enlargeBuffer, ensureFixedNumber, ensureVec3, findPreviousRenderPass, gaussianDown_frag as gaussianDownFrag, gaussianDownHFrag, gaussianDownVFrag, gaussianUpFrag, generateEmptyTypedArray, generateGUID, generateHalfFloatTexture, generateTransparentTexture, generateWhiteTexture, getBackgroundImage, getColorFromGradientStops, getConfig, getDefaultTemplateCanvasPool, getDefaultTextureFactory, getGeometryByShape, getGeometryTriangles, getImageItemRenderInfo, getKTXTextureOptions, getKeyFrameMetaByRawValue, getMergedStore, getParticleMeshShader, getPixelRatio, getPreMultiAlpha, getStandardComposition, getStandardImage, getStandardItem, getStandardJSON, getTextureSize, glContext, glType2VertexFormatType, gpuTimer, imageDataFromColor, imageDataFromGradient, initErrors, initGLContext, integrate, interpolateColor, isAlipayMiniApp, isAndroid, isArray, isCanvas, isFunction, isIOS, isObject, isSceneJSON, isSceneURL, isSceneWithOptions, isSimulatorCellPhone, isString, isUniformStruct, isUniformStructArray, isValidFontFamily, isWebGL2, itemFrag, itemFrameFrag, itemVert, loadBinary, loadBlob, loadImage, loadMedia, loadVideo, loadWebPOptional, logger, index as math, maxSpriteMeshItemCount, modifyMaxKeyframeShader, nearestPowerOfTwo, noop, normalizeColor, numberToFix, parsePercent$1 as parsePercent, particleFrag, particleOriginTranslateMap$1 as particleOriginTranslateMap, particleUniformTypeMap, particleVert, pluginLoaderMap, pointOnLine, randomInRange, registerPlugin, removeItem, rotateVec2, screenMeshVert, serialize, setBlendMode, setConfig, setDefaultTextureFactory, setMaskMode, setMaxSpriteMeshItemCount, setRayFromCamera, setSideMode, setSpriteMeshMaxItemCountByGPU, sortByOrder, index$1 as spec, spriteMeshShaderFromFilter, spriteMeshShaderFromRenderInfo, spriteMeshShaderIdFromRenderInfo, thresholdFrag, throwDestroyedError, trailVert, translatePoint, trianglesFromRect, unregisterPlugin, valIfUndefined, value, valueDefine, vecAssign, vecFill, vecMulCombine, vecNormalize, version, vertexFormatType2GLType };
+export { AbstractPlugin, ActivationPlayable, ActivationPlayableAsset, ActivationTrack, AnimationClip, AnimationClipPlayable, AssetLoader, AssetManager, BYTES_TYPE_MAP, Behaviour, BezierCurve, BezierCurvePath, BezierCurveQuat, BinaryAsset, COMPRESSED_TEXTURE, COPY_FRAGMENT_SHADER, COPY_MESH_SHADER_ID, COPY_VERTEX_SHADER, CalculateLoader, Camera, CameraController, CameraVFXItemLoader, Component, Composition, CompositionComponent, CompositionSourceManager, DEFAULT_FONTS, Database, DestroyOptions, Downloader, EFFECTS_COPY_MESH_NAME, EVENT_TYPE_CLICK, EVENT_TYPE_TOUCH_END, EVENT_TYPE_TOUCH_MOVE, EVENT_TYPE_TOUCH_START, EffectComponent, EffectsObject, EffectsPackage, Engine, EventSystem, FilterMode, Float16ArrayWrapper, Framebuffer, GLSLVersion, GPUCapability, Geometry, GlobalUniforms, GradientValue, HELP_LINK, HitTestType, InteractComponent, InteractLoader, InteractMesh, Item, ItemBehaviour, KTXTexture, LineSegments, LinearValue, Material, MaterialDataBlock, MaterialRenderType, Mesh, ObjectBindingTrack, OrderType, PLAYER_OPTIONS_ENV_EDITOR, POST_PROCESS_SETTINGS, ParticleBehaviourPlayable, ParticleBehaviourPlayableAsset, ParticleLoader, ParticleMesh, ParticleSystem, ParticleSystemRenderer, PassTextureCache, PathSegments, PluginSystem, RENDER_PASS_NAME_PREFIX, RENDER_PREFER_LOOKUP_TEXTURE, RUNTIME_ENV, RandomSetValue, RandomValue, RandomVectorValue, RenderFrame, RenderPass, RenderPassAttachmentStorageType, RenderPassDestroyAttachmentType, RenderPassPriorityNormal, RenderPassPriorityPostprocess, RenderPassPriorityPrepare, RenderTargetHandle, RenderTextureFormat, Renderbuffer, Renderer, RendererComponent, RuntimeClip, SEMANTIC_MAIN_PRE_COLOR_ATTACHMENT_0, SEMANTIC_MAIN_PRE_COLOR_ATTACHMENT_SIZE_0, SEMANTIC_PRE_COLOR_ATTACHMENT_0, SEMANTIC_PRE_COLOR_ATTACHMENT_SIZE_0, SPRITE_VERTEX_STRIDE, SemanticMap, SerializationHelper, Shader, ShaderCompileResultStatus, ShaderType, ShaderVariant, SpriteColorPlayable, SpriteColorPlayableAsset, SpriteColorTrack, SpriteComponent, SpriteLoader, StaticValue, SubCompositionPlayableAsset, SubCompositionTrack, TEMPLATE_USE_OFFSCREEN_CANVAS, TextComponent, TextComponentBase, TextLayout, TextLoader, TextStyle, Texture, TextureFactory, TextureLoadAction, TextureSourceType, TextureStoreAction, Ticker, TimelineAsset, TimelineClip, TimelinePlayable, TrackAsset, TrackSortWrapper, TrackType, Transform, TransformAnimationPlayable, TransformPlayableAsset, TransformTrack, VFXItem, ValueGetter, addByOrder, addItem, addItemWithOrder, applyMixins, assertExist, asserts, base64ToFile, blend, calculateTranslation, canvasPool, colorGradingFrag, colorStopsFromGradient, colorToArr$1 as colorToArr, combineImageTemplate, compatible_frag as compatibleFrag, compatible_vert as compatibleVert, createCopyShader, createGLContext, createKeyFrameMeta, createShaderWithMacros, createShape, createVFXItem, createValueGetter, decimalEqual, defaultGlobalVolume, defaultPlugins, deserializeMipmapTexture, earcut, effectsClass, effectsClassStore, enlargeBuffer, ensureFixedNumber, ensureVec3, findPreviousRenderPass, gaussianDown_frag as gaussianDownFrag, gaussianDownHFrag, gaussianDownVFrag, gaussianUpFrag, generateEmptyTypedArray, generateGUID, generateHalfFloatTexture, generateTransparentTexture, generateWhiteTexture, getBackgroundImage, getColorFromGradientStops, getConfig, getDefaultTemplateCanvasPool, getDefaultTextureFactory, getGeometryByShape, getGeometryTriangles, getImageItemRenderInfo, getKTXTextureOptions, getKeyFrameMetaByRawValue, getMergedStore, getParticleMeshShader, getPixelRatio, getPreMultiAlpha, getStandardComposition, getStandardImage, getStandardItem, getStandardJSON, getTextureSize, glContext, glType2VertexFormatType, gpuTimer, imageDataFromColor, imageDataFromGradient, initErrors, initGLContext, integrate, interpolateColor, isAlipayMiniApp, isAndroid, isArray, isCanvas, isFunction, isIOS, isObject, isSceneJSON, isSceneURL, isSceneWithOptions, isSimulatorCellPhone, isString, isUniformStruct, isUniformStructArray, isValidFontFamily, isWebGL2, itemFrag, itemFrameFrag, itemVert, loadBinary, loadBlob, loadImage, loadMedia, loadVideo, loadWebPOptional, logger, index as math, maxSpriteMeshItemCount, modifyMaxKeyframeShader, nearestPowerOfTwo, noop, normalizeColor, numberToFix, parsePercent$1 as parsePercent, particleFrag, particleOriginTranslateMap$1 as particleOriginTranslateMap, particleUniformTypeMap, particleVert, pluginLoaderMap, pointOnLine, randomInRange, registerPlugin, removeItem, rotateVec2, screenMeshVert, serialize, setBlendMode, setConfig, setDefaultTextureFactory, setMaskMode, setMaxSpriteMeshItemCount, setRayFromCamera, setSideMode, setSpriteMeshMaxItemCountByGPU, sortByOrder, index$1 as spec, spriteMeshShaderFromFilter, spriteMeshShaderFromRenderInfo, spriteMeshShaderIdFromRenderInfo, thresholdFrag, throwDestroyedError, trailVert, translatePoint, trianglesFromRect, unregisterPlugin, valIfUndefined, value, valueDefine, vecAssign, vecFill, vecMulCombine, vecNormalize, version, vertexFormatType2GLType };
 //# sourceMappingURL=index.mjs.map