@galacean/engine-xr 0.0.0-experimental-2.0-skill.0 → 0.0.0-experimental-2.0-migrate.7

package/dist/browser.js

@@ -1122,32 +1122,552 @@
         /** The normal of the hit point. */ this.normal = new engine.Vector3();
     };
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    function __decorate(decorators, target, key, desc) {
-      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-      return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
+    /* @minVersion 7.20.0 */
 
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-      var e = new Error(message);
-      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
+    /**
+      Enums are used in this file, but not assigned to vars to avoid non-hoistable values
+
+      CONSTRUCTOR = 0;
+      PUBLIC = 1;
+      PRIVATE = 2;
+
+      FIELD = 0;
+      ACCESSOR = 1;
+      METHOD = 2;
+      GETTER = 3;
+      SETTER = 4;
+
+      STATIC = 5;
+
+      CLASS = 10; // only used in assertValidReturnValue
+    */
+
+    function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+        function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+            return function addInitializer(initializer) {
+                assertNotFinished(decoratorFinishedRef, "addInitializer");
+                assertCallable(initializer, "An initializer");
+                initializers.push(initializer);
+            };
+        }
+
+        function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+            var kindStr;
+
+            switch (kind) {
+                case 1 /* ACCESSOR */:
+                    kindStr = "accessor";
+                    break;
+                case 2 /* METHOD */:
+                    kindStr = "method";
+                    break;
+                case 3 /* GETTER */:
+                    kindStr = "getter";
+                    break;
+                case 4 /* SETTER */:
+                    kindStr = "setter";
+                    break;
+                default:
+                    kindStr = "field";
+            }
+
+            var ctx = { kind: kindStr, name: isPrivate ? "#" + name : name, static: isStatic, private: isPrivate, metadata: metadata };
+
+            var decoratorFinishedRef = { v: false };
+
+            ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+
+            var get, set;
+            if (kind === 0 /* FIELD */) {
+                if (isPrivate) {
+                    get = desc.get;
+                    set = desc.set;
+                } else {
+                    get = function() {
+                        return this[name];
+                    };
+                    set = function(v) {
+                        this[name] = v;
+                    };
+                }
+            } else if (kind === 2 /* METHOD */) {
+                get = function() {
+                    return desc.value;
+                };
+            } else {
+                // replace with values that will go through the final getter and setter
+                if (kind === 1 /* ACCESSOR */ || kind === 3 /* GETTER */) {
+                    get = function() {
+                        return desc.get.call(this);
+                    };
+                }
+
+                if (kind === 1 /* ACCESSOR */ || kind === 4 /* SETTER */) {
+                    set = function(v) {
+                        desc.set.call(this, v);
+                    };
+                }
+            }
+            ctx.access = get && set ? { get: get, set: set } : get ? { get: get } : { set: set };
+
+            try {
+                return dec(value, ctx);
+            } finally {
+                decoratorFinishedRef.v = true;
+            }
+        }
+
+        function assertNotFinished(decoratorFinishedRef, fnName) {
+            if (decoratorFinishedRef.v) {
+                throw new Error("attempted to call " + fnName + " after decoration was finished");
+            }
+        }
+
+        function assertCallable(fn, hint) {
+            if (typeof fn !== "function") {
+                throw new TypeError(hint + " must be a function");
+            }
+        }
+
+        function assertValidReturnValue(kind, value) {
+            var type = typeof value;
+
+            if (kind === 1 /* ACCESSOR */) {
+                if (type !== "object" || value === null) {
+                    throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+                }
+                if (value.get !== undefined) {
+                    assertCallable(value.get, "accessor.get");
+                }
+                if (value.set !== undefined) {
+                    assertCallable(value.set, "accessor.set");
+                }
+                if (value.init !== undefined) {
+                    assertCallable(value.init, "accessor.init");
+                }
+            } else if (type !== "function") {
+                var hint;
+                if (kind === 0 /* FIELD */) {
+                    hint = "field";
+                } else if (kind === 10 /* CLASS */) {
+                    hint = "class";
+                } else {
+                    hint = "method";
+                }
+                throw new TypeError(hint + " decorators must return a function or void 0");
+            }
+        }
+
+        function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+            var decs = decInfo[0];
+
+            var desc, init, value;
+
+            if (isPrivate) {
+                if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {
+                    desc = { get: decInfo[3], set: decInfo[4] };
+                } else if (kind === 3 /* GETTER */) {
+                    desc = { get: decInfo[3] };
+                } else if (kind === 4 /* SETTER */) {
+                    desc = { set: decInfo[3] };
+                } else {
+                    desc = { value: decInfo[3] };
+                }
+            } else if (kind !== 0 /* FIELD */) {
+                desc = Object.getOwnPropertyDescriptor(base, name);
+            }
+
+            if (kind === 1 /* ACCESSOR */) {
+                value = { get: desc.get, set: desc.set };
+            } else if (kind === 2 /* METHOD */) {
+                value = desc.value;
+            } else if (kind === 3 /* GETTER */) {
+                value = desc.get;
+            } else if (kind === 4 /* SETTER */) {
+                value = desc.set;
+            }
+
+            var newValue, get, set;
+
+            if (typeof decs === "function") {
+                newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+
+                if (newValue !== void 0) {
+                    assertValidReturnValue(kind, newValue);
+
+                    if (kind === 0 /* FIELD */) {
+                        init = newValue;
+                    } else if (kind === 1 /* ACCESSOR */) {
+                        init = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+
+                        value = { get: get, set: set };
+                    } else {
+                        value = newValue;
+                    }
+                }
+            } else {
+                for (var i = decs.length - 1; i >= 0; i--) {
+                    var dec = decs[i];
+
+                    newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+
+                    if (newValue !== void 0) {
+                        assertValidReturnValue(kind, newValue);
+                        var newInit;
+
+                        if (kind === 0 /* FIELD */) {
+                            newInit = newValue;
+                        } else if (kind === 1 /* ACCESSOR */) {
+                            newInit = newValue.init;
+                            get = newValue.get || value.get;
+                            set = newValue.set || value.set;
+
+                            value = { get: get, set: set };
+                        } else {
+                            value = newValue;
+                        }
+
+                        if (newInit !== void 0) {
+                            if (init === void 0) {
+                                init = newInit;
+                            } else if (typeof init === "function") {
+                                init = [init, newInit];
+                            } else {
+                                init.push(newInit);
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {
+                if (init === void 0) {
+                    // If the initializer was void 0, sub in a dummy initializer
+                    init = function(instance, init) {
+                        return init;
+                    };
+                } else if (typeof init !== "function") {
+                    var ownInitializers = init;
+
+                    init = function(instance, init) {
+                        var value = init;
+
+                        for (var i = 0; i < ownInitializers.length; i++) value = ownInitializers[i].call(instance, value);
+
+                        return value;
+                    };
+                } else {
+                    var originalInitializer = init;
+
+                    init = function(instance, init) {
+                        return originalInitializer.call(instance, init);
+                    };
+                }
+
+                ret.push(init);
+            }
+
+            if (kind !== 0 /* FIELD */) {
+                if (kind === 1 /* ACCESSOR */) {
+                    desc.get = value.get;
+                    desc.set = value.set;
+                } else if (kind === 2 /* METHOD */) {
+                    desc.value = value;
+                } else if (kind === 3 /* GETTER */) {
+                    desc.get = value;
+                } else if (kind === 4 /* SETTER */) {
+                    desc.set = value;
+                }
+
+                if (isPrivate) {
+                    if (kind === 1 /* ACCESSOR */) {
+                        ret.push(function(instance, args) {
+                            return value.get.call(instance, args);
+                        });
+                        ret.push(function(instance, args) {
+                            return value.set.call(instance, args);
+                        });
+                    } else if (kind === 2 /* METHOD */) {
+                        ret.push(value);
+                    } else {
+                        ret.push(function(instance, args) {
+                            return value.call(instance, args);
+                        });
+                    }
+                } else {
+                    Object.defineProperty(base, name, desc);
+                }
+            }
+        }
+
+        function applyMemberDecs(Class, decInfos, metadata) {
+            var ret = [];
+            var protoInitializers;
+            var staticInitializers;
+
+            var existingProtoNonFields = new Map();
+            var existingStaticNonFields = new Map();
+
+            for (var i = 0; i < decInfos.length; i++) {
+                var decInfo = decInfos[i];
+
+                // skip computed property names
+                if (!Array.isArray(decInfo)) continue;
+
+                var kind = decInfo[1];
+                var name = decInfo[2];
+                var isPrivate = decInfo.length > 3;
+
+                var isStatic = kind >= 5; /* STATIC */
+                var base;
+                var initializers;
+
+                if (isStatic) {
+                    base = Class;
+                    kind = kind - 5 /* STATIC */;
+                    // initialize staticInitializers when we see a non-field static member
+                    staticInitializers = staticInitializers || [];
+                    initializers = staticInitializers;
+                } else {
+                    base = Class.prototype;
+                    // initialize protoInitializers when we see a non-field member
+                    protoInitializers = protoInitializers || [];
+                    initializers = protoInitializers;
+                }
+
+                if (kind !== 0 /* FIELD */ && !isPrivate) {
+                    var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+
+                    var existingKind = existingNonFields.get(name) || 0;
+
+                    if (existingKind === true || (existingKind === 3 /* GETTER */ && kind !== 4) /* SETTER */ || (existingKind === 4 /* SETTER */ && kind !== 3) /* GETTER */) {
+                        throw new Error(
+                            "Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "
+                                + name
+                        );
+                    } else if (!existingKind && kind > 2 /* METHOD */) {
+                        existingNonFields.set(name, kind);
+                    } else {
+                        existingNonFields.set(name, true);
+                    }
+                }
+
+                applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+            }
+
+            pushInitializers(ret, protoInitializers);
+            pushInitializers(ret, staticInitializers);
+            return ret;
+        }
+
+        function pushInitializers(ret, initializers) {
+            if (initializers) {
+                ret.push(function(instance) {
+                    for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+                    return instance;
+                });
+            }
+        }
+
+        function applyClassDecs(targetClass, classDecs, metadata) {
+            if (classDecs.length > 0) {
+                var initializers = [];
+                var newClass = targetClass;
+                var name = targetClass.name;
+
+                for (var i = classDecs.length - 1; i >= 0; i--) {
+                    var decoratorFinishedRef = { v: false };
+
+                    try {
+                        var nextNewClass = classDecs[i](newClass, { kind: "class", name: name, addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef), metadata });
+                    } finally {
+                        decoratorFinishedRef.v = true;
+                    }
+
+                    if (nextNewClass !== undefined) {
+                        assertValidReturnValue(10, /* CLASS */ nextNewClass);
+                        newClass = nextNewClass;
+                    }
+                }
+
+                return [defineMetadata(newClass, metadata), function() {
+                    for (var i = 0; i < initializers.length; i++) initializers[i].call(newClass);
+                }];
+            }
+            // The transformer will not emit assignment when there are no class decorators,
+            // so we don't have to return an empty array here.
+        }
+
+        function defineMetadata(Class, metadata) {
+            return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: true, enumerable: true, value: metadata });
+        }
+
+        /**
+        Basic usage:
+
+        applyDecs(
+          Class,
+          [
+            // member decorators
+            [
+              dec,                // dec or array of decs
+              0,                  // kind of value being decorated
+              'prop',             // name of public prop on class containing the value being decorated,
+              '#p',               // the name of the private property (if is private, void 0 otherwise),
+            ]
+          ],
+          [
+            // class decorators
+            dec1, dec2
+          ]
+        )
+        ```
+
+        Fully transpiled example:
+
+        ```js
+        @dec
+        class Class {
+          @dec
+          a = 123;
+
+          @dec
+          #a = 123;
+
+          @dec
+          @dec2
+          accessor b = 123;
+
+          @dec
+          accessor #b = 123;
+
+          @dec
+          c() { console.log('c'); }
+
+          @dec
+          #c() { console.log('privC'); }
+
+          @dec
+          get d() { console.log('d'); }
+
+          @dec
+          get #d() { console.log('privD'); }
+
+          @dec
+          set e(v) { console.log('e'); }
+
+          @dec
+          set #e(v) { console.log('privE'); }
+        }
+
+
+        // becomes
+        let initializeInstance;
+        let initializeClass;
+
+        let initA;
+        let initPrivA;
+
+        let initB;
+        let initPrivB, getPrivB, setPrivB;
+
+        let privC;
+        let privD;
+        let privE;
+
+        let Class;
+        class _Class {
+          static {
+            let ret = applyDecs(
+              this,
+              [
+                [dec, 0, 'a'],
+                [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],
+                [[dec, dec2], 1, 'b'],
+                [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],
+                [dec, 2, 'c'],
+                [dec, 2, 'c', () => console.log('privC')],
+                [dec, 3, 'd'],
+                [dec, 3, 'd', () => console.log('privD')],
+                [dec, 4, 'e'],
+                [dec, 4, 'e', () => console.log('privE')],
+              ],
+              [
+                dec
+              ]
+            )
+
+            initA = ret[0];
+
+            initPrivA = ret[1];
+
+            initB = ret[2];
+
+            initPrivB = ret[3];
+            getPrivB = ret[4];
+            setPrivB = ret[5];
+
+            privC = ret[6];
+
+            privD = ret[7];
+
+            privE = ret[8];
+
+            initializeInstance = ret[9];
+
+            Class = ret[10]
+
+            initializeClass = ret[11];
+          }
+
+          a = (initializeInstance(this), initA(this, 123));
+
+          #a = initPrivA(this, 123);
+
+          #bData = initB(this, 123);
+          get b() { return this.#bData }
+          set b(v) { this.#bData = v }
+
+          #privBData = initPrivB(this, 123);
+          get #b() { return getPrivB(this); }
+          set #b(v) { setPrivB(this, v); }
+
+          c() { console.log('c'); }
+
+          #c(...args) { return privC(this, ...args) }
+
+          get d() { console.log('d'); }
+
+          get #d() { return privD(this); }
+
+          set e(v) { console.log('e'); }
+
+          set #e(v) { privE(this, v); }
+        }
+
+        initializeClass(Class);
+       */
+
+        _apply_decs_2203_r = function(targetClass, memberDecs, classDecs, parentClass) {
+            if (parentClass !== void 0) {
+                var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+            }
+            var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+            var e = applyMemberDecs(targetClass, memberDecs, metadata);
+            if (!classDecs.length) defineMetadata(targetClass, metadata);
+            return {
+                e: e,
+                // Lazily apply class decorations so that member init locals can be properly bound.
+                get c() {
+                    return applyClassDecs(targetClass, classDecs, metadata);
+                }
+            };
+        };
+
+        return _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass);
+    }
 
     /**
      * Enumerates modes of plane in XR.
@@ -1196,12 +1716,15 @@
         return XRTrackedPlane;
     }(XRTracked);
 
-    exports.XRPlaneTracking = /*#__PURE__*/ function(XRTrackableFeature1) {
-        _inherits(XRPlaneTracking, XRTrackableFeature1);
+    var _dec$5, _initClass$5, _XRTrackableFeature$2;
+    exports.XRPlaneTracking = void 0;
+    _dec$5 = registerXRFeature(XRFeatureType.PlaneTracking);
+    var XRPlaneTracking = /*#__PURE__*/ function(_superClass) {
+        _inherits(XRPlaneTracking, _superClass);
         function XRPlaneTracking(xrManager, detectionMode) {
             if (detectionMode === void 0) detectionMode = XRPlaneMode.EveryThing;
             var _this;
-            _this = XRTrackableFeature1.call(this, xrManager, XRFeatureType.PlaneTracking, detectionMode) || this;
+            _this = _superClass.call(this, xrManager, XRFeatureType.PlaneTracking, detectionMode) || this;
             _this._addRequestTracking(new XRRequestPlane(detectionMode));
             return _this;
         }
@@ -1230,16 +1753,21 @@
             }
         ]);
         return XRPlaneTracking;
-    }(XRTrackableFeature);
-    exports.XRPlaneTracking = __decorate([
-        registerXRFeature(XRFeatureType.PlaneTracking)
-    ], exports.XRPlaneTracking);
-
-    exports.XRHitTest = /*#__PURE__*/ function(XRFeature) {
-        _inherits(XRHitTest, XRFeature);
+    }(_XRTrackableFeature$2 = XRTrackableFeature);
+    var ref$4, ref1$4;
+    ref$4 = _apply_decs_2203_r(XRPlaneTracking, [], [
+        _dec$5
+    ], _XRTrackableFeature$2), ref1$4 = ref$4.c, exports.XRPlaneTracking = ref1$4[0], _initClass$5 = ref1$4[1];
+    _initClass$5();
+
+    var _dec$4, _initClass$4, _XRFeature;
+    exports.XRHitTest = void 0;
+    _dec$4 = registerXRFeature(XRFeatureType.HitTest);
+    var XRHitTest = /*#__PURE__*/ function(_superClass) {
+        _inherits(XRHitTest, _superClass);
         function XRHitTest(xrManager) {
             var _this;
-            _this = XRFeature.call(this, xrManager, XRFeatureType.HitTest) || this, _this._tempRay = new engine.Ray(), _this._tempPlane = new engine.Plane(), _this._tempVec2 = new engine.Vector2(), _this._tempVec30 = new engine.Vector3(), _this._tempVec31 = new engine.Vector3(), _this._tempVec32 = new engine.Vector3(), _this._tempVec33 = new engine.Vector3(), _this._tempVec34 = new engine.Vector3(), _this._tempVec35 = new engine.Vector3();
+            _this = _superClass.call(this, xrManager, XRFeatureType.HitTest) || this, _this._tempRay = new engine.Ray(), _this._tempPlane = new engine.Plane(), _this._tempVec2 = new engine.Vector2(), _this._tempVec30 = new engine.Vector3(), _this._tempVec31 = new engine.Vector3(), _this._tempVec32 = new engine.Vector3(), _this._tempVec33 = new engine.Vector3(), _this._tempVec34 = new engine.Vector3(), _this._tempVec35 = new engine.Vector3();
             return _this;
         }
         var _proto = XRHitTest.prototype;
@@ -1330,10 +1858,12 @@
             return true;
         };
         return XRHitTest;
-    }(XRFeature);
-    exports.XRHitTest = __decorate([
-        registerXRFeature(XRFeatureType.HitTest)
-    ], exports.XRHitTest);
+    }(_XRFeature = XRFeature);
+    var ref$3, ref1$3;
+    ref$3 = _apply_decs_2203_r(XRHitTest, [], [
+        _dec$4
+    ], _XRFeature), ref1$3 = ref$3.c, exports.XRHitTest = ref1$3[0], _initClass$4 = ref1$3[1];
+    _initClass$4();
 
     /**
      * The anchor in XR space.
@@ -1357,11 +1887,14 @@
         return XRRequestAnchor;
     }(XRRequestTracking);
 
-    exports.XRAnchorTracking = /*#__PURE__*/ function(XRTrackableFeature1) {
-        _inherits(XRAnchorTracking, XRTrackableFeature1);
+    var _dec$3, _initClass$3, _XRTrackableFeature$1;
+    exports.XRAnchorTracking = void 0;
+    _dec$3 = registerXRFeature(XRFeatureType.AnchorTracking);
+    var XRAnchorTracking = /*#__PURE__*/ function(_superClass) {
+        _inherits(XRAnchorTracking, _superClass);
         function XRAnchorTracking(xrManager) {
             var _this;
-            _this = XRTrackableFeature1.call(this, xrManager, XRFeatureType.AnchorTracking) || this, _this._anchors = [];
+            _this = _superClass.call(this, xrManager, XRFeatureType.AnchorTracking) || this, _this._anchors = [];
             return _this;
         }
         var _proto = XRAnchorTracking.prototype;
@@ -1429,10 +1962,12 @@
             }
         ]);
         return XRAnchorTracking;
-    }(XRTrackableFeature);
-    exports.XRAnchorTracking = __decorate([
-        registerXRFeature(XRFeatureType.AnchorTracking)
-    ], exports.XRAnchorTracking);
+    }(_XRTrackableFeature$1 = XRTrackableFeature);
+    var ref$2, ref1$2;
+    ref$2 = _apply_decs_2203_r(XRAnchorTracking, [], [
+        _dec$3
+    ], _XRTrackableFeature$1), ref1$2 = ref$2.c, exports.XRAnchorTracking = ref1$2[0], _initClass$3 = ref1$2[1];
+    _initClass$3();
 
     /**
      * The request image in XR space.
@@ -1456,11 +1991,14 @@
         return XRTrackedImage;
     }(XRTracked);
 
-    exports.XRImageTracking = /*#__PURE__*/ function(XRTrackableFeature1) {
-        _inherits(XRImageTracking, XRTrackableFeature1);
+    var _dec$2, _initClass$2, _XRTrackableFeature;
+    exports.XRImageTracking = void 0;
+    _dec$2 = registerXRFeature(XRFeatureType.ImageTracking);
+    var XRImageTracking = /*#__PURE__*/ function(_superClass) {
+        _inherits(XRImageTracking, _superClass);
         function XRImageTracking(xrManager, trackingImages) {
             var _this;
-            _this = XRTrackableFeature1.call(this, xrManager, XRFeatureType.ImageTracking, trackingImages) || this;
+            _this = _superClass.call(this, xrManager, XRFeatureType.ImageTracking, trackingImages) || this;
             _this._trackingImages = trackingImages;
             var imageLength = trackingImages ? trackingImages.length : 0;
             if (imageLength > 0) {
@@ -1497,10 +2035,12 @@
             }
         ]);
         return XRImageTracking;
-    }(XRTrackableFeature);
-    exports.XRImageTracking = __decorate([
-        registerXRFeature(XRFeatureType.ImageTracking)
-    ], exports.XRImageTracking);
+    }(_XRTrackableFeature = XRTrackableFeature);
+    var ref$1, ref1$1;
+    ref$1 = _apply_decs_2203_r(XRImageTracking, [], [
+        _dec$2
+    ], _XRTrackableFeature), ref1$1 = ref$1.c, exports.XRImageTracking = ref1$1[0], _initClass$2 = ref1$1[1];
+    _initClass$2();
 
     /**
      *  A reference image is an image to look for in the physical environment.
@@ -1510,26 +2050,45 @@
         this.physicalWidth = physicalWidth;
     };
 
-    exports.XRReferenceImageDecoder = /*#__PURE__*/ function() {
-        function XRReferenceImageDecoder() {}
-        XRReferenceImageDecoder.decode = function decode(engine$1, bufferReader) {
-            return new engine.AssetPromise(function(resolve, reject) {
-                var physicalWidth = bufferReader.nextFloat32();
-                bufferReader.nextUint8();
-                var img = new Image();
-                img.onload = function() {
-                    resolve(new XRReferenceImage("", img, physicalWidth));
-                };
-                img.src = URL.createObjectURL(new window.Blob([
-                    bufferReader.nextImagesData(1)[0]
-                ]));
-            });
-        };
-        return XRReferenceImageDecoder;
-    }();
-    exports.XRReferenceImageDecoder = __decorate([
-        engine.decoder("XRReferenceImage")
-    ], exports.XRReferenceImageDecoder);
+    function _identity(x) {
+        return x;
+    }
+
+    var _class;
+    var _dec$1, _initClass$1;
+    exports.XRReferenceImageDecoder = void 0;
+    _dec$1 = engine.decoder("XRReferenceImage");
+    new (_class = /*#__PURE__*/ function(_identity) {
+        _inherits(_class, _identity);
+        function _class() {
+            var _this;
+            _this = _identity.apply(this, arguments) || this, _initClass$1();
+            return _this;
+        }
+        return _class;
+    }(_identity), function() {
+        var XRReferenceImageDecoder = /*#__PURE__*/ function() {
+            function XRReferenceImageDecoder() {}
+            XRReferenceImageDecoder.decode = function decode(engine$1, bufferReader) {
+                return new engine.AssetPromise(function(resolve, reject) {
+                    var physicalWidth = bufferReader.nextFloat32();
+                    bufferReader.nextUint8();
+                    var img = new Image();
+                    img.onload = function() {
+                        resolve(new XRReferenceImage("", img, physicalWidth));
+                    };
+                    img.src = URL.createObjectURL(new window.Blob([
+                        bufferReader.nextImagesData(1)[0]
+                    ]));
+                });
+            };
+            return XRReferenceImageDecoder;
+        }();
+        var ref, ref1;
+        ref = _apply_decs_2203_r(XRReferenceImageDecoder, [], [
+            _dec$1
+        ]), ref1 = ref.c, exports.XRReferenceImageDecoder = ref1[0], _initClass$1 = ref1[1];
+    }(), _class)();
 
     function _extends() {
         _extends = Object.assign || function assign(target) {
@@ -1544,10 +2103,13 @@
         return _extends.apply(this, arguments);
     }
 
-    exports.XRReferenceImageLoader = /*#__PURE__*/ function(Loader) {
-        _inherits(XRReferenceImageLoader, Loader);
+    var _dec, _initClass, _Loader;
+    exports.XRReferenceImageLoader = void 0;
+    _dec = engine.resourceLoader("XRReferenceImage", []);
+    var XRReferenceImageLoader = /*#__PURE__*/ function(_superClass) {
+        _inherits(XRReferenceImageLoader, _superClass);
         function XRReferenceImageLoader() {
-            return Loader.apply(this, arguments) || this;
+            return _superClass.apply(this, arguments) || this;
         }
         var _proto = XRReferenceImageLoader.prototype;
         _proto.load = function load(item, resourceManager) {
@@ -1563,10 +2125,12 @@
             });
         };
         return XRReferenceImageLoader;
-    }(engine.Loader);
-    exports.XRReferenceImageLoader = __decorate([
-        engine.resourceLoader("XRReferenceImage", [])
-    ], exports.XRReferenceImageLoader);
+    }(_Loader = engine.Loader);
+    var ref, ref1;
+    ref = _apply_decs_2203_r(XRReferenceImageLoader, [], [
+        _dec
+    ], _Loader), ref1 = ref.c, exports.XRReferenceImageLoader = ref1[0], _initClass = ref1[1];
+    _initClass();
 
     exports.TrackableType = TrackableType;
     exports.XRAnchor = XRAnchor;