/**
* Name: Metaverse
* Date: 2022/4/12
* Author: https://www.4dkankan.com
* Copyright © 2022 4DAGE Co., Ltd. All rights reserved.
* Licensed under the GLP license
*/
(function (factory) {
  typeof define === 'function' && define.amd ? define(factory) :
  factory();
})((function () { 'use strict';

  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
    try {
      var info = gen[key](arg);
      var value = info.value;
    } catch (error) {
      reject(error);
      return;
    }

    if (info.done) {
      resolve(value);
    } else {
      Promise.resolve(value).then(_next, _throw);
    }
  }

  function _asyncToGenerator(fn) {
    return function () {
      var self = this,
          args = arguments;
      return new Promise(function (resolve, reject) {
        var gen = fn.apply(self, args);

        function _next(value) {
          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
        }

        function _throw(err) {
          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
        }

        _next(undefined);
      });
    };
  }

  function createCommonjsModule(fn) {
    var module = { exports: {} };
  	return fn(module, module.exports), module.exports;
  }

  /**
   * Copyright (c) 2014-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   */

  var runtime_1 = createCommonjsModule(function (module) {
  var runtime = (function (exports) {

    var Op = Object.prototype;
    var hasOwn = Op.hasOwnProperty;
    var undefined$1; // More compressible than void 0.
    var $Symbol = typeof Symbol === "function" ? Symbol : {};
    var iteratorSymbol = $Symbol.iterator || "@@iterator";
    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";

    function define(obj, key, value) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
      return obj[key];
    }
    try {
      // IE 8 has a broken Object.defineProperty that only works on DOM objects.
      define({}, "");
    } catch (err) {
      define = function(obj, key, value) {
        return obj[key] = value;
      };
    }

    function wrap(innerFn, outerFn, self, tryLocsList) {
      // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
      var generator = Object.create(protoGenerator.prototype);
      var context = new Context(tryLocsList || []);

      // The ._invoke method unifies the implementations of the .next,
      // .throw, and .return methods.
      generator._invoke = makeInvokeMethod(innerFn, self, context);

      return generator;
    }
    exports.wrap = wrap;

    // Try/catch helper to minimize deoptimizations. Returns a completion
    // record like context.tryEntries[i].completion. This interface could
    // have been (and was previously) designed to take a closure to be
    // invoked without arguments, but in all the cases we care about we
    // already have an existing method we want to call, so there's no need
    // to create a new function object. We can even get away with assuming
    // the method takes exactly one argument, since that happens to be true
    // in every case, so we don't have to touch the arguments object. The
    // only additional allocation required is the completion record, which
    // has a stable shape and so hopefully should be cheap to allocate.
    function tryCatch(fn, obj, arg) {
      try {
        return { type: "normal", arg: fn.call(obj, arg) };
      } catch (err) {
        return { type: "throw", arg: err };
      }
    }

    var GenStateSuspendedStart = "suspendedStart";
    var GenStateSuspendedYield = "suspendedYield";
    var GenStateExecuting = "executing";
    var GenStateCompleted = "completed";

    // Returning this object from the innerFn has the same effect as
    // breaking out of the dispatch switch statement.
    var ContinueSentinel = {};

    // Dummy constructor functions that we use as the .constructor and
    // .constructor.prototype properties for functions that return Generator
    // objects. For full spec compliance, you may wish to configure your
    // minifier not to mangle the names of these two functions.
    function Generator() {}
    function GeneratorFunction() {}
    function GeneratorFunctionPrototype() {}

    // This is a polyfill for %IteratorPrototype% for environments that
    // don't natively support it.
    var IteratorPrototype = {};
    define(IteratorPrototype, iteratorSymbol, function () {
      return this;
    });

    var getProto = Object.getPrototypeOf;
    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
    if (NativeIteratorPrototype &&
        NativeIteratorPrototype !== Op &&
        hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
      // This environment has a native %IteratorPrototype%; use it instead
      // of the polyfill.
      IteratorPrototype = NativeIteratorPrototype;
    }

    var Gp = GeneratorFunctionPrototype.prototype =
      Generator.prototype = Object.create(IteratorPrototype);
    GeneratorFunction.prototype = GeneratorFunctionPrototype;
    define(Gp, "constructor", GeneratorFunctionPrototype);
    define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
    GeneratorFunction.displayName = define(
      GeneratorFunctionPrototype,
      toStringTagSymbol,
      "GeneratorFunction"
    );

    // Helper for defining the .next, .throw, and .return methods of the
    // Iterator interface in terms of a single ._invoke method.
    function defineIteratorMethods(prototype) {
      ["next", "throw", "return"].forEach(function(method) {
        define(prototype, method, function(arg) {
          return this._invoke(method, arg);
        });
      });
    }

    exports.isGeneratorFunction = function(genFun) {
      var ctor = typeof genFun === "function" && genFun.constructor;
      return ctor
        ? ctor === GeneratorFunction ||
          // For the native GeneratorFunction constructor, the best we can
          // do is to check its .name property.
          (ctor.displayName || ctor.name) === "GeneratorFunction"
        : false;
    };

    exports.mark = function(genFun) {
      if (Object.setPrototypeOf) {
        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
      } else {
        genFun.__proto__ = GeneratorFunctionPrototype;
        define(genFun, toStringTagSymbol, "GeneratorFunction");
      }
      genFun.prototype = Object.create(Gp);
      return genFun;
    };

    // Within the body of any async function, `await x` is transformed to
    // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
    // `hasOwn.call(value, "__await")` to determine if the yielded value is
    // meant to be awaited.
    exports.awrap = function(arg) {
      return { __await: arg };
    };

    function AsyncIterator(generator, PromiseImpl) {
      function invoke(method, arg, resolve, reject) {
        var record = tryCatch(generator[method], generator, arg);
        if (record.type === "throw") {
          reject(record.arg);
        } else {
          var result = record.arg;
          var value = result.value;
          if (value &&
              typeof value === "object" &&
              hasOwn.call(value, "__await")) {
            return PromiseImpl.resolve(value.__await).then(function(value) {
              invoke("next", value, resolve, reject);
            }, function(err) {
              invoke("throw", err, resolve, reject);
            });
          }

          return PromiseImpl.resolve(value).then(function(unwrapped) {
            // When a yielded Promise is resolved, its final value becomes
            // the .value of the Promise<{value,done}> result for the
            // current iteration.
            result.value = unwrapped;
            resolve(result);
          }, function(error) {
            // If a rejected Promise was yielded, throw the rejection back
            // into the async generator function so it can be handled there.
            return invoke("throw", error, resolve, reject);
          });
        }
      }

      var previousPromise;

      function enqueue(method, arg) {
        function callInvokeWithMethodAndArg() {
          return new PromiseImpl(function(resolve, reject) {
            invoke(method, arg, resolve, reject);
          });
        }

        return previousPromise =
          // If enqueue has been called before, then we want to wait until
          // all previous Promises have been resolved before calling invoke,
          // so that results are always delivered in the correct order. If
          // enqueue has not been called before, then it is important to
          // call invoke immediately, without waiting on a callback to fire,
          // so that the async generator function has the opportunity to do
          // any necessary setup in a predictable way. This predictability
          // is why the Promise constructor synchronously invokes its
          // executor callback, and why async functions synchronously
          // execute code before the first await. Since we implement simple
          // async functions in terms of async generators, it is especially
          // important to get this right, even though it requires care.
          previousPromise ? previousPromise.then(
            callInvokeWithMethodAndArg,
            // Avoid propagating failures to Promises returned by later
            // invocations of the iterator.
            callInvokeWithMethodAndArg
          ) : callInvokeWithMethodAndArg();
      }

      // Define the unified helper method that is used to implement .next,
      // .throw, and .return (see defineIteratorMethods).
      this._invoke = enqueue;
    }

    defineIteratorMethods(AsyncIterator.prototype);
    define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
      return this;
    });
    exports.AsyncIterator = AsyncIterator;

    // Note that simple async functions are implemented on top of
    // AsyncIterator objects; they just return a Promise for the value of
    // the final result produced by the iterator.
    exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
      if (PromiseImpl === void 0) PromiseImpl = Promise;

      var iter = new AsyncIterator(
        wrap(innerFn, outerFn, self, tryLocsList),
        PromiseImpl
      );

      return exports.isGeneratorFunction(outerFn)
        ? iter // If outerFn is a generator, return the full iterator.
        : iter.next().then(function(result) {
            return result.done ? result.value : iter.next();
          });
    };

    function makeInvokeMethod(innerFn, self, context) {
      var state = GenStateSuspendedStart;

      return function invoke(method, arg) {
        if (state === GenStateExecuting) {
          throw new Error("Generator is already running");
        }

        if (state === GenStateCompleted) {
          if (method === "throw") {
            throw arg;
          }

          // Be forgiving, per 25.3.3.3.3 of the spec:
          // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
          return doneResult();
        }

        context.method = method;
        context.arg = arg;

        while (true) {
          var delegate = context.delegate;
          if (delegate) {
            var delegateResult = maybeInvokeDelegate(delegate, context);
            if (delegateResult) {
              if (delegateResult === ContinueSentinel) continue;
              return delegateResult;
            }
          }

          if (context.method === "next") {
            // Setting context._sent for legacy support of Babel's
            // function.sent implementation.
            context.sent = context._sent = context.arg;

          } else if (context.method === "throw") {
            if (state === GenStateSuspendedStart) {
              state = GenStateCompleted;
              throw context.arg;
            }

            context.dispatchException(context.arg);

          } else if (context.method === "return") {
            context.abrupt("return", context.arg);
          }

          state = GenStateExecuting;

          var record = tryCatch(innerFn, self, context);
          if (record.type === "normal") {
            // If an exception is thrown from innerFn, we leave state ===
            // GenStateExecuting and loop back for another invocation.
            state = context.done
              ? GenStateCompleted
              : GenStateSuspendedYield;

            if (record.arg === ContinueSentinel) {
              continue;
            }

            return {
              value: record.arg,
              done: context.done
            };

          } else if (record.type === "throw") {
            state = GenStateCompleted;
            // Dispatch the exception by looping back around to the
            // context.dispatchException(context.arg) call above.
            context.method = "throw";
            context.arg = record.arg;
          }
        }
      };
    }

    // Call delegate.iterator[context.method](context.arg) and handle the
    // result, either by returning a { value, done } result from the
    // delegate iterator, or by modifying context.method and context.arg,
    // setting context.delegate to null, and returning the ContinueSentinel.
    function maybeInvokeDelegate(delegate, context) {
      var method = delegate.iterator[context.method];
      if (method === undefined$1) {
        // A .throw or .return when the delegate iterator has no .throw
        // method always terminates the yield* loop.
        context.delegate = null;

        if (context.method === "throw") {
          // Note: ["return"] must be used for ES3 parsing compatibility.
          if (delegate.iterator["return"]) {
            // If the delegate iterator has a return method, give it a
            // chance to clean up.
            context.method = "return";
            context.arg = undefined$1;
            maybeInvokeDelegate(delegate, context);

            if (context.method === "throw") {
              // If maybeInvokeDelegate(context) changed context.method from
              // "return" to "throw", let that override the TypeError below.
              return ContinueSentinel;
            }
          }

          context.method = "throw";
          context.arg = new TypeError(
            "The iterator does not provide a 'throw' method");
        }

        return ContinueSentinel;
      }

      var record = tryCatch(method, delegate.iterator, context.arg);

      if (record.type === "throw") {
        context.method = "throw";
        context.arg = record.arg;
        context.delegate = null;
        return ContinueSentinel;
      }

      var info = record.arg;

      if (! info) {
        context.method = "throw";
        context.arg = new TypeError("iterator result is not an object");
        context.delegate = null;
        return ContinueSentinel;
      }

      if (info.done) {
        // Assign the result of the finished delegate to the temporary
        // variable specified by delegate.resultName (see delegateYield).
        context[delegate.resultName] = info.value;

        // Resume execution at the desired location (see delegateYield).
        context.next = delegate.nextLoc;

        // If context.method was "throw" but the delegate handled the
        // exception, let the outer generator proceed normally. If
        // context.method was "next", forget context.arg since it has been
        // "consumed" by the delegate iterator. If context.method was
        // "return", allow the original .return call to continue in the
        // outer generator.
        if (context.method !== "return") {
          context.method = "next";
          context.arg = undefined$1;
        }

      } else {
        // Re-yield the result returned by the delegate method.
        return info;
      }

      // The delegate iterator is finished, so forget it and continue with
      // the outer generator.
      context.delegate = null;
      return ContinueSentinel;
    }

    // Define Generator.prototype.{next,throw,return} in terms of the
    // unified ._invoke helper method.
    defineIteratorMethods(Gp);

    define(Gp, toStringTagSymbol, "Generator");

    // A Generator should always return itself as the iterator object when the
    // @@iterator function is called on it. Some browsers' implementations of the
    // iterator prototype chain incorrectly implement this, causing the Generator
    // object to not be returned from this call. This ensures that doesn't happen.
    // See https://github.com/facebook/regenerator/issues/274 for more details.
    define(Gp, iteratorSymbol, function() {
      return this;
    });

    define(Gp, "toString", function() {
      return "[object Generator]";
    });

    function pushTryEntry(locs) {
      var entry = { tryLoc: locs[0] };

      if (1 in locs) {
        entry.catchLoc = locs[1];
      }

      if (2 in locs) {
        entry.finallyLoc = locs[2];
        entry.afterLoc = locs[3];
      }

      this.tryEntries.push(entry);
    }

    function resetTryEntry(entry) {
      var record = entry.completion || {};
      record.type = "normal";
      delete record.arg;
      entry.completion = record;
    }

    function Context(tryLocsList) {
      // The root entry object (effectively a try statement without a catch
      // or a finally block) gives us a place to store values thrown from
      // locations where there is no enclosing try statement.
      this.tryEntries = [{ tryLoc: "root" }];
      tryLocsList.forEach(pushTryEntry, this);
      this.reset(true);
    }

    exports.keys = function(object) {
      var keys = [];
      for (var key in object) {
        keys.push(key);
      }
      keys.reverse();

      // Rather than returning an object with a next method, we keep
      // things simple and return the next function itself.
      return function next() {
        while (keys.length) {
          var key = keys.pop();
          if (key in object) {
            next.value = key;
            next.done = false;
            return next;
          }
        }

        // To avoid creating an additional object, we just hang the .value
        // and .done properties off the next function object itself. This
        // also ensures that the minifier will not anonymize the function.
        next.done = true;
        return next;
      };
    };

    function values(iterable) {
      if (iterable) {
        var iteratorMethod = iterable[iteratorSymbol];
        if (iteratorMethod) {
          return iteratorMethod.call(iterable);
        }

        if (typeof iterable.next === "function") {
          return iterable;
        }

        if (!isNaN(iterable.length)) {
          var i = -1, next = function next() {
            while (++i < iterable.length) {
              if (hasOwn.call(iterable, i)) {
                next.value = iterable[i];
                next.done = false;
                return next;
              }
            }

            next.value = undefined$1;
            next.done = true;

            return next;
          };

          return next.next = next;
        }
      }

      // Return an iterator with no values.
      return { next: doneResult };
    }
    exports.values = values;

    function doneResult() {
      return { value: undefined$1, done: true };
    }

    Context.prototype = {
      constructor: Context,

      reset: function(skipTempReset) {
        this.prev = 0;
        this.next = 0;
        // Resetting context._sent for legacy support of Babel's
        // function.sent implementation.
        this.sent = this._sent = undefined$1;
        this.done = false;
        this.delegate = null;

        this.method = "next";
        this.arg = undefined$1;

        this.tryEntries.forEach(resetTryEntry);

        if (!skipTempReset) {
          for (var name in this) {
            // Not sure about the optimal order of these conditions:
            if (name.charAt(0) === "t" &&
                hasOwn.call(this, name) &&
                !isNaN(+name.slice(1))) {
              this[name] = undefined$1;
            }
          }
        }
      },

      stop: function() {
        this.done = true;

        var rootEntry = this.tryEntries[0];
        var rootRecord = rootEntry.completion;
        if (rootRecord.type === "throw") {
          throw rootRecord.arg;
        }

        return this.rval;
      },

      dispatchException: function(exception) {
        if (this.done) {
          throw exception;
        }

        var context = this;
        function handle(loc, caught) {
          record.type = "throw";
          record.arg = exception;
          context.next = loc;

          if (caught) {
            // If the dispatched exception was caught by a catch block,
            // then let that catch block handle the exception normally.
            context.method = "next";
            context.arg = undefined$1;
          }

          return !! caught;
        }

        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          var record = entry.completion;

          if (entry.tryLoc === "root") {
            // Exception thrown outside of any try block that could handle
            // it, so set the completion value of the entire function to
            // throw the exception.
            return handle("end");
          }

          if (entry.tryLoc <= this.prev) {
            var hasCatch = hasOwn.call(entry, "catchLoc");
            var hasFinally = hasOwn.call(entry, "finallyLoc");

            if (hasCatch && hasFinally) {
              if (this.prev < entry.catchLoc) {
                return handle(entry.catchLoc, true);
              } else if (this.prev < entry.finallyLoc) {
                return handle(entry.finallyLoc);
              }

            } else if (hasCatch) {
              if (this.prev < entry.catchLoc) {
                return handle(entry.catchLoc, true);
              }

            } else if (hasFinally) {
              if (this.prev < entry.finallyLoc) {
                return handle(entry.finallyLoc);
              }

            } else {
              throw new Error("try statement without catch or finally");
            }
          }
        }
      },

      abrupt: function(type, arg) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.tryLoc <= this.prev &&
              hasOwn.call(entry, "finallyLoc") &&
              this.prev < entry.finallyLoc) {
            var finallyEntry = entry;
            break;
          }
        }

        if (finallyEntry &&
            (type === "break" ||
             type === "continue") &&
            finallyEntry.tryLoc <= arg &&
            arg <= finallyEntry.finallyLoc) {
          // Ignore the finally entry if control is not jumping to a
          // location outside the try/catch block.
          finallyEntry = null;
        }

        var record = finallyEntry ? finallyEntry.completion : {};
        record.type = type;
        record.arg = arg;

        if (finallyEntry) {
          this.method = "next";
          this.next = finallyEntry.finallyLoc;
          return ContinueSentinel;
        }

        return this.complete(record);
      },

      complete: function(record, afterLoc) {
        if (record.type === "throw") {
          throw record.arg;
        }

        if (record.type === "break" ||
            record.type === "continue") {
          this.next = record.arg;
        } else if (record.type === "return") {
          this.rval = this.arg = record.arg;
          this.method = "return";
          this.next = "end";
        } else if (record.type === "normal" && afterLoc) {
          this.next = afterLoc;
        }

        return ContinueSentinel;
      },

      finish: function(finallyLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.finallyLoc === finallyLoc) {
            this.complete(entry.completion, entry.afterLoc);
            resetTryEntry(entry);
            return ContinueSentinel;
          }
        }
      },

      "catch": function(tryLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.tryLoc === tryLoc) {
            var record = entry.completion;
            if (record.type === "throw") {
              var thrown = record.arg;
              resetTryEntry(entry);
            }
            return thrown;
          }
        }

        // The context.catch method must only be called with a location
        // argument that corresponds to a known catch block.
        throw new Error("illegal catch attempt");
      },

      delegateYield: function(iterable, resultName, nextLoc) {
        this.delegate = {
          iterator: values(iterable),
          resultName: resultName,
          nextLoc: nextLoc
        };

        if (this.method === "next") {
          // Deliberately forget the last sent value so that we don't
          // accidentally pass it on to the delegate.
          this.arg = undefined$1;
        }

        return ContinueSentinel;
      }
    };

    // Regardless of whether this script is executing as a CommonJS module
    // or not, return the runtime object so that we can declare the variable
    // regeneratorRuntime in the outer scope, which allows this module to be
    // injected easily by `bin/regenerator --include-runtime script.js`.
    return exports;

  }(
    // If this script is executing as a CommonJS module, use module.exports
    // as the regeneratorRuntime namespace. Otherwise create a new empty
    // object. Either way, the resulting object will be used to initialize
    // the regeneratorRuntime variable at the top of this file.
    module.exports 
  ));

  try {
    regeneratorRuntime = runtime;
  } catch (accidentalStrictMode) {
    // This module should not be running in strict mode, so the above
    // assignment should always work unless something is misconfigured. Just
    // in case runtime.js accidentally runs in strict mode, in modern engines
    // we can explicitly access globalThis. In older engines we can escape
    // strict mode using a global Function call. This could conceivably fail
    // if a Content Security Policy forbids using Function, but in that case
    // the proper solution is to fix the accidental strict mode problem. If
    // you've misconfigured your bundler to force strict mode and applied a
    // CSP to forbid Function, and you're not willing to fix either of those
    // problems, please detail your unique predicament in a GitHub issue.
    if (typeof globalThis === "object") {
      globalThis.regeneratorRuntime = runtime;
    } else {
      Function("r", "regeneratorRuntime = r")(runtime);
    }
  }
  });

  var regenerator = runtime_1;

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    Object.defineProperty(Constructor, "prototype", {
      writable: false
    });
    return Constructor;
  }

  var Codes = {
    Success: 0,
    Param: 1001,
    Internal: 1002,
    Timeout: 1003,
    Authentication: 1004,
    TokenExpired: 1005,
    Unsupported: 1006,
    InitNetworkTimeout: 1007,
    InitDecoderTimeout: 1008,
    InitConfigTimeout: 1009,
    InitEngineTimeout: 1010,
    InitEngine: 1011,
    ActionBlocked: 1012,
    PreloadCanceled: 1013,
    FrequencyLimit: 1014,
    UsersUpperLimit: 2e3,
    RoomsUpperLimit: 2001,
    ServerParam: 2002,
    LackOfToken: 2003,
    LoginFailed: 2004,
    VerifyServiceDown: 2005,
    CreateSessionFailed: 2006,
    RtcConnection: 2008,
    DoActionFailed: 2009,
    StateSyncFailed: 2010,
    BroadcastFailed: 2011,
    DataAbnormal: 2012,
    GetOnVehicle: 2015,
    RepeatLogin: 2017,
    RoomDoseNotExist: 2018,
    TicketExpire: 2019,
    ServerRateLimit: 2020,
    DoActionBlocked: 2333,
    ActionMaybeDelay: 2334,
    ActionResponseTimeout: 2999
  };

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    Object.defineProperty(subClass, "prototype", {
      writable: false
    });
    if (superClass) _setPrototypeOf(subClass, superClass);
  }

  function _typeof(obj) {
    "@babel/helpers - typeof";

    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    }, _typeof(obj);
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (_typeof(call) === "object" || typeof call === "function")) {
      return call;
    } else if (call !== void 0) {
      throw new TypeError("Derived constructors may only return object or undefined");
    }

    return _assertThisInitialized(self);
  }

  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  function _isNativeFunction(fn) {
    return Function.toString.call(fn).indexOf("[native code]") !== -1;
  }

  function _isNativeReflectConstruct$R() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function _construct(Parent, args, Class) {
    if (_isNativeReflectConstruct$R()) {
      _construct = Reflect.construct;
    } else {
      _construct = function _construct(Parent, args, Class) {
        var a = [null];
        a.push.apply(a, args);
        var Constructor = Function.bind.apply(Parent, a);
        var instance = new Constructor();
        if (Class) _setPrototypeOf(instance, Class.prototype);
        return instance;
      };
    }

    return _construct.apply(null, arguments);
  }

  function _wrapNativeSuper(Class) {
    var _cache = typeof Map === "function" ? new Map() : undefined;

    _wrapNativeSuper = function _wrapNativeSuper(Class) {
      if (Class === null || !_isNativeFunction(Class)) return Class;

      if (typeof Class !== "function") {
        throw new TypeError("Super expression must either be null or a function");
      }

      if (typeof _cache !== "undefined") {
        if (_cache.has(Class)) return _cache.get(Class);

        _cache.set(Class, Wrapper);
      }

      function Wrapper() {
        return _construct(Class, arguments, _getPrototypeOf(this).constructor);
      }

      Wrapper.prototype = Object.create(Class.prototype, {
        constructor: {
          value: Wrapper,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      return _setPrototypeOf(Wrapper, Class);
    };

    return _wrapNativeSuper(Class);
  }

  function _createSuper$Q(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$Q(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$Q() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var XverseError = /*#__PURE__*/function (_Error) {
    _inherits(XverseError, _Error);

    var _super = _createSuper$Q(XverseError);

    function XverseError(e, t) {
      var _this;

      _classCallCheck(this, XverseError);

      _this = _super.call(this, t);
      _this.code = e;
      return _this;
    }

    _createClass(XverseError, [{
      key: "toJSON",
      value: function toJSON() {
        return {
          code: this.code,
          message: this.message
        };
      }
    }, {
      key: "toString",
      value: function toString() {
        if (Object(this) !== this) throw new TypeError();
        var t = this.name;
        t = t === void 0 ? "Error" : String(t);
        var r = this.message;
        r = r === void 0 ? "" : String(r);
        var n = this.code;
        return r = n === void 0 ? r : n + "," + r, t === "" ? r : r === "" ? t : t + ": " + r;
      }
    }]);

    return XverseError;
  }( /*#__PURE__*/_wrapNativeSuper(Error));

  function _createSuper$P(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$P(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$P() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var ParamError$1 = /*#__PURE__*/function (_XverseError) {
    _inherits(ParamError, _XverseError);

    var _super = _createSuper$P(ParamError);

    function ParamError(e) {
      _classCallCheck(this, ParamError);

      return _super.call(this, 1001, e || "\u53C2\u6570\u9519\u8BEF");
    }

    return _createClass(ParamError);
  }(XverseError);

  function _createSuper$O(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$O(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$O() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var InternalError = /*#__PURE__*/function (_XverseError) {
    _inherits(InternalError, _XverseError);

    var _super = _createSuper$O(InternalError);

    function InternalError(e) {
      _classCallCheck(this, InternalError);

      return _super.call(this, 1002, e || "\u5185\u90E8\u9519\u8BEF");
    }

    return _createClass(InternalError);
  }(XverseError);

  function _createSuper$N(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$N(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$N() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var TimeoutError = /*#__PURE__*/function (_XverseError) {
    _inherits(TimeoutError, _XverseError);

    var _super = _createSuper$N(TimeoutError);

    function TimeoutError(e) {
      _classCallCheck(this, TimeoutError);

      return _super.call(this, 1003, e || "\u8D85\u65F6");
    }

    return _createClass(TimeoutError);
  }(XverseError);

  function _createSuper$M(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$M(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$M() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var AuthenticationError$1 = /*#__PURE__*/function (_XverseError) {
    _inherits(AuthenticationError, _XverseError);

    var _super = _createSuper$M(AuthenticationError);

    function AuthenticationError(e) {
      _classCallCheck(this, AuthenticationError);

      return _super.call(this, 1004, e || "\u9274\u6743\u5931\u8D25");
    }

    return _createClass(AuthenticationError);
  }(XverseError);

  function _createSuper$L(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$L(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$L() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var TokenExpiredError$1 = /*#__PURE__*/function (_XverseError) {
    _inherits(TokenExpiredError, _XverseError);

    var _super = _createSuper$L(TokenExpiredError);

    function TokenExpiredError(e) {
      _classCallCheck(this, TokenExpiredError);

      return _super.call(this, 1005, e || "Token \u5DF2\u8FC7\u671F");
    }

    return _createClass(TokenExpiredError);
  }(XverseError);

  function _createSuper$K(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$K(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$K() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var UnsupportedError$1 = /*#__PURE__*/function (_XverseError) {
    _inherits(UnsupportedError, _XverseError);

    var _super = _createSuper$K(UnsupportedError);

    function UnsupportedError(e) {
      _classCallCheck(this, UnsupportedError);

      return _super.call(this, 1006, e || "\u624B\u673A\u7CFB\u7EDF\u4E0D\u652F\u6301XVerse");
    }

    return _createClass(UnsupportedError);
  }(XverseError);

  function _createSuper$J(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$J(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$J() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var InitNetworkTimeoutError = /*#__PURE__*/function (_XverseError) {
    _inherits(InitNetworkTimeoutError, _XverseError);

    var _super = _createSuper$J(InitNetworkTimeoutError);

    function InitNetworkTimeoutError(e) {
      _classCallCheck(this, InitNetworkTimeoutError);

      return _super.call(this, 1007, e || "\u7F51\u7EDC\u521D\u59CB\u5316\u8D85\u65F6");
    }

    return _createClass(InitNetworkTimeoutError);
  }(XverseError);

  function _createSuper$I(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$I(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$I() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var InitDecoderTimeoutError = /*#__PURE__*/function (_XverseError) {
    _inherits(InitDecoderTimeoutError, _XverseError);

    var _super = _createSuper$I(InitDecoderTimeoutError);

    function InitDecoderTimeoutError(e) {
      _classCallCheck(this, InitDecoderTimeoutError);

      return _super.call(this, 1008, e || "Decoder \u521D\u59CB\u5316\u8D85\u65F6");
    }

    return _createClass(InitDecoderTimeoutError);
  }(XverseError);

  function _createSuper$H(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$H(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$H() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var InitConfigTimeoutError = /*#__PURE__*/function (_XverseError) {
    _inherits(InitConfigTimeoutError, _XverseError);

    var _super = _createSuper$H(InitConfigTimeoutError);

    function InitConfigTimeoutError(e) {
      _classCallCheck(this, InitConfigTimeoutError);

      return _super.call(this, 1009, e || "\u914D\u7F6E\u521D\u59CB\u5316\u8D85\u65F6");
    }

    return _createClass(InitConfigTimeoutError);
  }(XverseError);

  function _createSuper$G(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$G(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$G() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var InitEngineTimeoutError = /*#__PURE__*/function (_XverseError) {
    _inherits(InitEngineTimeoutError, _XverseError);

    var _super = _createSuper$G(InitEngineTimeoutError);

    function InitEngineTimeoutError(e) {
      _classCallCheck(this, InitEngineTimeoutError);

      return _super.call(this, 1010, e || "\u5F15\u64CE\u521D\u59CB\u5316\u8D85\u65F6");
    }

    return _createClass(InitEngineTimeoutError);
  }(XverseError);

  function _createSuper$F(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$F(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$F() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var InitEngineError = /*#__PURE__*/function (_XverseError) {
    _inherits(InitEngineError, _XverseError);

    var _super = _createSuper$F(InitEngineError);

    function InitEngineError(e) {
      _classCallCheck(this, InitEngineError);

      return _super.call(this, 1011, e || "\u5F15\u64CE\u521D\u59CB\u5316\u9519\u8BEF");
    }

    return _createClass(InitEngineError);
  }(XverseError);

  function _createSuper$E(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$E(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$E() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var ActionBlockedError = /*#__PURE__*/function (_XverseError) {
    _inherits(ActionBlockedError, _XverseError);

    var _super = _createSuper$E(ActionBlockedError);

    function ActionBlockedError(e) {
      _classCallCheck(this, ActionBlockedError);

      return _super.call(this, 1012, e || "\u52A8\u4F5C\u88AB\u5C4F\u853D");
    }

    return _createClass(ActionBlockedError);
  }(XverseError);

  function _createSuper$D(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$D(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$D() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var PreloadCanceledError$1 = /*#__PURE__*/function (_XverseError) {
    _inherits(PreloadCanceledError, _XverseError);

    var _super = _createSuper$D(PreloadCanceledError);

    function PreloadCanceledError(e) {
      _classCallCheck(this, PreloadCanceledError);

      return _super.call(this, 1013, e || "\u9884\u52A0\u8F7D\u88AB\u53D6\u6D88");
    }

    return _createClass(PreloadCanceledError);
  }(XverseError);

  function _createSuper$C(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$C(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$C() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var FrequencyLimitError$1 = /*#__PURE__*/function (_XverseError) {
    _inherits(FrequencyLimitError, _XverseError);

    var _super = _createSuper$C(FrequencyLimitError);

    function FrequencyLimitError(e) {
      _classCallCheck(this, FrequencyLimitError);

      return _super.call(this, 1014, e || "\u9891\u7387\u9650\u5236");
    }

    return _createClass(FrequencyLimitError);
  }(XverseError);

  function _createSuper$B(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$B(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$B() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var UsersUpperLimitError = /*#__PURE__*/function (_XverseError) {
    _inherits(UsersUpperLimitError, _XverseError);

    var _super = _createSuper$B(UsersUpperLimitError);

    function UsersUpperLimitError(e) {
      _classCallCheck(this, UsersUpperLimitError);

      return _super.call(this, 2e3, e || "\u76F4\u64AD\u95F4\u4EBA\u6570\u5DF2\u6EE1");
    }

    return _createClass(UsersUpperLimitError);
  }(XverseError);

  function _createSuper$A(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$A(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$A() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var RoomsUpperLimitError = /*#__PURE__*/function (_XverseError) {
    _inherits(RoomsUpperLimitError, _XverseError);

    var _super = _createSuper$A(RoomsUpperLimitError);

    function RoomsUpperLimitError(e) {
      _classCallCheck(this, RoomsUpperLimitError);

      return _super.call(this, 2001, e || "\u623F\u95F4\u5230\u8FBE\u4E0A\u9650");
    }

    return _createClass(RoomsUpperLimitError);
  }(XverseError);

  function _createSuper$z(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$z(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$z() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var ServerParamError = /*#__PURE__*/function (_XverseError) {
    _inherits(ServerParamError, _XverseError);

    var _super = _createSuper$z(ServerParamError);

    function ServerParamError(e) {
      _classCallCheck(this, ServerParamError);

      return _super.call(this, 2002, e || "\u670D\u52A1\u5668\u53C2\u6570\u9519\u8BEF");
    }

    return _createClass(ServerParamError);
  }(XverseError);

  function _createSuper$y(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$y(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$y() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var LackOfTokenError = /*#__PURE__*/function (_XverseError) {
    _inherits(LackOfTokenError, _XverseError);

    var _super = _createSuper$y(LackOfTokenError);

    function LackOfTokenError(e) {
      _classCallCheck(this, LackOfTokenError);

      return _super.call(this, 2003, e || "\u7F3A\u5C11 Token");
    }

    return _createClass(LackOfTokenError);
  }(XverseError);

  function _createSuper$x(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$x(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$x() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var LoginFailedError = /*#__PURE__*/function (_XverseError) {
    _inherits(LoginFailedError, _XverseError);

    var _super = _createSuper$x(LoginFailedError);

    function LoginFailedError(e) {
      _classCallCheck(this, LoginFailedError);

      return _super.call(this, 2004, e || "\u8FDB\u5165\u623F\u95F4\u5931\u8D25");
    }

    return _createClass(LoginFailedError);
  }(XverseError);

  function _createSuper$w(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$w(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$w() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var VerifyServiceDownError = /*#__PURE__*/function (_XverseError) {
    _inherits(VerifyServiceDownError, _XverseError);

    var _super = _createSuper$w(VerifyServiceDownError);

    function VerifyServiceDownError(e) {
      _classCallCheck(this, VerifyServiceDownError);

      return _super.call(this, 2005, e || "\u9274\u6743\u670D\u52A1\u5F02\u5E38");
    }

    return _createClass(VerifyServiceDownError);
  }(XverseError);

  function _createSuper$v(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$v(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$v() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var CreateSessionFailedError = /*#__PURE__*/function (_XverseError) {
    _inherits(CreateSessionFailedError, _XverseError);

    var _super = _createSuper$v(CreateSessionFailedError);

    function CreateSessionFailedError(e) {
      _classCallCheck(this, CreateSessionFailedError);

      return _super.call(this, 2006, e || "\u521B\u5EFA session \u5931\u8D25");
    }

    return _createClass(CreateSessionFailedError);
  }(XverseError);

  function _createSuper$u(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$u(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$u() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var RtcConnectionError = /*#__PURE__*/function (_XverseError) {
    _inherits(RtcConnectionError, _XverseError);

    var _super = _createSuper$u(RtcConnectionError);

    function RtcConnectionError(e) {
      _classCallCheck(this, RtcConnectionError);

      return _super.call(this, 2008, e || "RTC\u5EFA\u8054\u5931\u8D25");
    }

    return _createClass(RtcConnectionError);
  }(XverseError);

  function _createSuper$t(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$t(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$t() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var DoActionFailedError = /*#__PURE__*/function (_XverseError) {
    _inherits(DoActionFailedError, _XverseError);

    var _super = _createSuper$t(DoActionFailedError);

    function DoActionFailedError(e) {
      _classCallCheck(this, DoActionFailedError);

      return _super.call(this, 2009, e || "\u52A8\u4F5C\u6267\u884C\u5931\u8D25");
    }

    return _createClass(DoActionFailedError);
  }(XverseError);

  function _createSuper$s(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$s(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$s() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var StateSyncFailedError = /*#__PURE__*/function (_XverseError) {
    _inherits(StateSyncFailedError, _XverseError);

    var _super = _createSuper$s(StateSyncFailedError);

    function StateSyncFailedError(e) {
      _classCallCheck(this, StateSyncFailedError);

      return _super.call(this, 2010, e || "\u72B6\u6001\u540C\u6B65\u5931\u8D25");
    }

    return _createClass(StateSyncFailedError);
  }(XverseError);

  function _createSuper$r(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$r(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$r() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var BroadcastFailedError = /*#__PURE__*/function (_XverseError) {
    _inherits(BroadcastFailedError, _XverseError);

    var _super = _createSuper$r(BroadcastFailedError);

    function BroadcastFailedError(e) {
      _classCallCheck(this, BroadcastFailedError);

      return _super.call(this, 2011, e || "\u5E7F\u64AD\u63A5\u53E3\u63A5\u53E3\u5F02\u5E38");
    }

    return _createClass(BroadcastFailedError);
  }(XverseError);

  function _createSuper$q(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$q(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$q() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var DataAbnormalError = /*#__PURE__*/function (_XverseError) {
    _inherits(DataAbnormalError, _XverseError);

    var _super = _createSuper$q(DataAbnormalError);

    function DataAbnormalError(e) {
      _classCallCheck(this, DataAbnormalError);

      return _super.call(this, 2012, e || "\u6570\u636E\u5F02\u5E38");
    }

    return _createClass(DataAbnormalError);
  }(XverseError);

  function _createSuper$p(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$p(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$p() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var GetOnVehicleError = /*#__PURE__*/function (_XverseError) {
    _inherits(GetOnVehicleError, _XverseError);

    var _super = _createSuper$p(GetOnVehicleError);

    function GetOnVehicleError(e) {
      _classCallCheck(this, GetOnVehicleError);

      return _super.call(this, 2015, e || "\u4E0A\u8F7D\u5177\u5931\u8D25\u9700\u8981\u9884\u7EA6");
    }

    return _createClass(GetOnVehicleError);
  }(XverseError);

  function _createSuper$o(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$o(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$o() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var RepeatLoginError = /*#__PURE__*/function (_XverseError) {
    _inherits(RepeatLoginError, _XverseError);

    var _super = _createSuper$o(RepeatLoginError);

    function RepeatLoginError(e) {
      _classCallCheck(this, RepeatLoginError);

      return _super.call(this, 2017, e || "\u5F02\u5730\u767B\u5F55");
    }

    return _createClass(RepeatLoginError);
  }(XverseError);

  function _createSuper$n(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$n(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$n() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var RoomDoseNotExistError = /*#__PURE__*/function (_XverseError) {
    _inherits(RoomDoseNotExistError, _XverseError);

    var _super = _createSuper$n(RoomDoseNotExistError);

    function RoomDoseNotExistError(e) {
      _classCallCheck(this, RoomDoseNotExistError);

      return _super.call(this, 2018, e || "\u6307\u5B9A\u623F\u95F4\u4E0D\u5B58\u5728");
    }

    return _createClass(RoomDoseNotExistError);
  }(XverseError);

  function _createSuper$m(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$m(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$m() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var TicketExpireError = /*#__PURE__*/function (_XverseError) {
    _inherits(TicketExpireError, _XverseError);

    var _super = _createSuper$m(TicketExpireError);

    function TicketExpireError(e) {
      _classCallCheck(this, TicketExpireError);

      return _super.call(this, 2019, e || "\u7968\u636E\u8FC7\u671F");
    }

    return _createClass(TicketExpireError);
  }(XverseError);

  function _createSuper$l(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$l(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$l() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var ServerRateLimitError = /*#__PURE__*/function (_XverseError) {
    _inherits(ServerRateLimitError, _XverseError);

    var _super = _createSuper$l(ServerRateLimitError);

    function ServerRateLimitError(e) {
      _classCallCheck(this, ServerRateLimitError);

      return _super.call(this, 2020, e || "\u670D\u52A1\u7AEF\u9891\u7387\u9650\u5236");
    }

    return _createClass(ServerRateLimitError);
  }(XverseError);

  function _createSuper$k(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$k(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$k() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var DoActionBlockedError = /*#__PURE__*/function (_XverseError) {
    _inherits(DoActionBlockedError, _XverseError);

    var _super = _createSuper$k(DoActionBlockedError);

    function DoActionBlockedError(e) {
      _classCallCheck(this, DoActionBlockedError);

      return _super.call(this, 2333, e || "\u52A8\u4F5C\u88AB\u5C4F\u853D");
    }

    return _createClass(DoActionBlockedError);
  }(XverseError);

  function _createSuper$j(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$j(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$j() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var ActionMaybeDelayError = /*#__PURE__*/function (_XverseError) {
    _inherits(ActionMaybeDelayError, _XverseError);

    var _super = _createSuper$j(ActionMaybeDelayError);

    function ActionMaybeDelayError(e) {
      _classCallCheck(this, ActionMaybeDelayError);

      return _super.call(this, 2334, e || "\u52A8\u4F5C\u53EF\u80FD\u5EF6\u8FDF\u6267\u884C");
    }

    return _createClass(ActionMaybeDelayError);
  }(XverseError);

  function _createSuper$i(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$i(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$i() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var ActionResponseTimeoutError$1 = /*#__PURE__*/function (_XverseError) {
    _inherits(ActionResponseTimeoutError, _XverseError);

    var _super = _createSuper$i(ActionResponseTimeoutError);

    function ActionResponseTimeoutError(e) {
      _classCallCheck(this, ActionResponseTimeoutError);

      return _super.call(this, 2999, e || "action\u56DE\u5305\u8D85\u65F6");
    }

    return _createClass(ActionResponseTimeoutError);
  }(XverseError);

  var CodeErrorMap = {
    1001: ParamError$1,
    1002: InternalError,
    1003: TimeoutError,
    1004: AuthenticationError$1,
    1005: TokenExpiredError$1,
    1006: UnsupportedError$1,
    1007: InitNetworkTimeoutError,
    1008: InitDecoderTimeoutError,
    1009: InitConfigTimeoutError,
    1010: InitEngineTimeoutError,
    1011: InitEngineError,
    1012: ActionBlockedError,
    1013: PreloadCanceledError$1,
    1014: FrequencyLimitError$1,
    2e3: UsersUpperLimitError,
    2001: RoomsUpperLimitError,
    2002: ServerParamError,
    2003: LackOfTokenError,
    2004: LoginFailedError,
    2005: VerifyServiceDownError,
    2006: CreateSessionFailedError,
    2008: RtcConnectionError,
    2009: DoActionFailedError,
    2010: StateSyncFailedError,
    2011: BroadcastFailedError,
    2012: DataAbnormalError,
    2015: GetOnVehicleError,
    2017: RepeatLoginError,
    2018: RoomDoseNotExistError,
    2019: TicketExpireError,
    2020: ServerRateLimitError,
    2333: DoActionBlockedError,
    2334: ActionMaybeDelayError,
    2999: ActionResponseTimeoutError$1
  };

  var util = {
    uuid() {
      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (i) {
        var e = Math.random() * 16 | 0;
        return (i === "x" ? e : e & 3 | 8).toString(16);
      });
    },

    getFormattedDate(i) {
      var e = i.getMonth() + 1,
          t = i.getDate(),
          r = i.getHours(),
          n = i.getMinutes(),
          o = i.getSeconds(),
          a = i.getMilliseconds(),
          s = (e < 10 ? "0" : "") + e,
          l = (t < 10 ? "0" : "") + t,
          u = (r < 10 ? "0" : "") + r,
          c = (n < 10 ? "0" : "") + n,
          h = (o < 10 ? "0" : "") + o;
      return i.getFullYear() + "-" + s + "-" + l + " " + u + ":" + c + ":" + h + "." + a;
    },

    createInstance(i) {
      var e = new Axios(i),
          t = bind(Axios.prototype.request, e);
      return utils.extend(t, Axios.prototype, e), utils.extend(t, e), t.create = function (n) {
        return createInstance(mergeConfig(i, n));
      }, t;
    },

    mapLimit(i, e, t) {
      return new Promise(function (r, n) {
        var o = i.length;
        var a = e - 1,
            s = 0;

        var l = function l(u) {
          u.forEach(function (c) {
            t(c).then(function () {
              if (s++, s === o) {
                r();
                return;
              }

              a++;
              var h = i[a];
              h && l([h]);
            }, function (h) {
              n(h);
            });
          });
        };

        l(i.slice(0, e));
      });
    },

    isWebAssemblySupported() {
      try {
        if (typeof WebAssembly == "object" && typeof WebAssembly.instantiate == "function") {
          var i = new WebAssembly.Module(Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0));
          if (i instanceof WebAssembly.Module) return new WebAssembly.Instance(i) instanceof WebAssembly.Instance;
        }
      } catch (_unused) {}

      return console.log("wasm is not supported"), !1;
    },

    isSupported() {
      return typeof RTCPeerConnection == "function" && this.isWebAssemblySupported();
    },

    objectParseFloat(i) {
      var e = {};
      return i && Object.keys(i).forEach(function (t) {
        e[t] = parseFloat(i[t]);
      }), e;
    },

    getRandomItem(i) {
      i.length === 0 ? null : i[Math.floor(Math.random() * i.length)];
    },

    getErrorByCode(i) {
      if (i === Codes.Success) return InternalError;
      var e = CodeErrorMap[i];
      return e || console.warn("unkown code", i), e || InternalError;
    },

    getDistance(i, e) {
      var t = i.x,
          r = i.y,
          n = i.z,
          o = e.x,
          a = e.y,
          s = e.z;
      return Math.sqrt(Math.pow(Math.abs(t - o), 2) + Math.pow(Math.abs(r - a), 2) + Math.pow(Math.abs(n - s), 2));
    }

  };

  function _createSuper$h(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$h(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$h() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var Reporter = /*#__PURE__*/function (_EventEmitter) {
    _inherits(Reporter, _EventEmitter);

    var _super = _createSuper$h(Reporter);

    function Reporter() {
      var _this;

      _classCallCheck(this, Reporter);

      _this = _super.call(this);
      _this._header = {};
      _this._body = {};
      _this._queue = [];
      _this._disabled = !1;
      _this._interval = null;
      _this._reportUrl = null;

      _this.isDocumentLoaded = function () {
        return document.readyState === "complete";
      };

      _this._header.logModuleId = REPORT_MODULE_TYPE, _this._header.url = location.href, _this._header.enviroment = ENV, _this._header.networkType = window.navigator.connection ? window.navigator.connection.type : "unknown", _this._interval = window.setInterval(function () {
        _this._flushReport();
      }, 10 * 1e3);
      return _this;
    }

    _createClass(Reporter, [{
      key: "disable",
      value: function disable() {
        this._disabled = !0, this._interval && window.clearInterval(this._interval);
      }
    }, {
      key: "updateHeader",
      value: function updateHeader(e) {
        Object.assign(this._header, e);
      }
    }, {
      key: "updateBody",
      value: function updateBody(e) {
        Object.assign(this._body, e);
      }
    }, {
      key: "updateReportUrl",
      value: function updateReportUrl(e) {
        this._reportUrl = e;
      }
    }, {
      key: "report",
      value: function report(e, t, r) {
        var _this2 = this;

        if (this._disabled) return;
        r || (r = {});
        var _r = r,
            n = _r.immediate,
            o = _r.sampleRate;
        if (o && o > Math.random()) return;
        this.updateBody({
          logTime: util.getFormattedDate(new Date()),
          logTimestamp: Date.now()
        });

        var a = function a(s) {
          var l = oe(le(oe({}, _this2._body), {
            type: e
          }), s);
          _this2._queue.push(l), e === "measurement" && _this2.emit("report", s);
        };

        Array.isArray(t) ? t.forEach(function (s) {
          return a(s);
        }) : a(t), (n || this._queue.length >= REPORT_NUM_PER_REQUEST) && this._flushReport();
      }
    }, {
      key: "_flushReport",
      value: function _flushReport() {
        if (this._disabled || !this._queue.length || !this.isDocumentLoaded()) return;
        var e = {
          header: this._header,
          body: this._queue.splice(0, REPORT_NUM_PER_REQUEST)
        };

        this._post(e);
      }
    }, {
      key: "_post",
      value: function _post(e) {
        var t = this._reportUrl || REPORT_URL.DEV;
        return new Promise(function (r, n) {
          var o = new XMLHttpRequest();
          o.open("POST", t), o.setRequestHeader("Content-Type", "application/json");

          try {
            o.send(JSON.stringify(e));
          } catch (a) {
            console.error(a);
          }

          o.addEventListener("readystatechange", function () {
            if (o.readyState == 4) return o.status == 200 ? r(o) : n("Unable to send log");
          });
        });
      }
    }]);

    return Reporter;
  }(EventEmitter);
  var reporter$1 = new Reporter();

  function _arrayLikeToArray$7(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }

  function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return _arrayLikeToArray$7(arr);
  }

  function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
  }

  function _unsupportedIterableToArray$7(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray$7(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$7(o, minLen);
  }

  function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$7(arr) || _nonIterableSpread();
  }

  var Logger = /*#__PURE__*/function () {
    function Logger(e) {
      _classCallCheck(this, Logger);

      this.level = 3;
      this.module = e;
    }

    _createClass(Logger, [{
      key: "setLevel",
      value: function setLevel(e) {
        this.level = e;
      }
    }, {
      key: "atleast",
      value: function atleast(e) {
        return e >= this.level && e >= this.level;
      }
    }, {
      key: "print",
      value: function print(e, t) {
        for (var _len = arguments.length, r = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
          r[_key - 2] = arguments[_key];
        }

        if (this.atleast(t)) {
          var _console$n;

          var n = e == "debug" ? "info" : e,
              o = this.prefix(e);

          (_console$n = console[n]).call.apply(_console$n, [null, o].concat(r));
        }

        if (e !== "debug" && e !== "info") {
          var _n = r.map(function (o) {
            if (o instanceof Object) try {
              return JSON.stringify(o);
            } catch (_unused) {
              return o;
            } else return o;
          }).join(",");

          reporter$1.report("log", {
            message: _n,
            level: e,
            module: this.module
          });
        }
      }
    }, {
      key: "debug",
      value: function debug() {
        for (var _len2 = arguments.length, e = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          e[_key2] = arguments[_key2];
        }

        return this.print.apply(this, ["debug", 1].concat(e));
      }
    }, {
      key: "info",
      value: function info() {
        for (var _len3 = arguments.length, e = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
          e[_key3] = arguments[_key3];
        }

        return this.print.apply(this, ["info", 2].concat(e));
      }
    }, {
      key: "infoAndReportLog",
      value: function infoAndReportLog(e) {
        for (var _len4 = arguments.length, t = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
          t[_key4 - 1] = arguments[_key4];
        }

        var r = e.reportOptions;
        delete e.reportOptions, reporter$1.report("log", e, r), t.length || (t = [e.message]), this.debug.apply(this, _toConsumableArray(t));
      }
    }, {
      key: "infoAndReportMeasurement",
      value: function infoAndReportMeasurement(e) {
        for (var _len5 = arguments.length, t = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
          t[_key5 - 1] = arguments[_key5];
        }

        var n;
        var r = e.reportOptions;

        if (e.startTime) {
          var o = Date.now();
          e.value === void 0 && (e.endTime = o), e.value === void 0 && (e.value = o - e.startTime);
        }

        if (e.error ? e.code = ((n = e.error) == null ? void 0 : n.code) || Codes.Internal : e.code = Codes.Success, reporter$1.report("measurement", e, r), t.length || (t = [e]), e.level === 4 || e.error) {
          this.error.apply(this, _toConsumableArray(t));
          return;
        }

        this.warn.apply(this, _toConsumableArray(t));
      }
    }, {
      key: "warn",
      value: function warn() {
        for (var _len6 = arguments.length, e = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
          e[_key6] = arguments[_key6];
        }

        return this.print.apply(this, ["warn", 3].concat(e));
      }
    }, {
      key: "error",
      value: function error() {
        for (var _len7 = arguments.length, e = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
          e[_key7] = arguments[_key7];
        }

        return this.print.apply(this, ["error", 4].concat(e));
      }
    }, {
      key: "prefix",
      value: function prefix(e) {
        return "[".concat(this.module, "][").concat(e, "] ").concat(util.getFormattedDate(new Date()), ":");
      }
    }], [{
      key: "setLevel",
      value: function setLevel(e) {
        this.level = e;
      }
    }]);

    return Logger;
  }();
  var logger$1 = new Logger();

  var AxiosCanceler = /*#__PURE__*/function () {
    function AxiosCanceler() {
      _classCallCheck(this, AxiosCanceler);

      this.pendingMap = new Map();
    }

    _createClass(AxiosCanceler, [{
      key: "addPending",
      value: function addPending(e) {
        var _this = this;

        return new axios.CancelToken(function (t) {
          _this.pendingMap.has(e) || _this.pendingMap.set(e, t);
        });
      }
    }, {
      key: "removeAllPending",
      value: function removeAllPending() {
        this.pendingMap.forEach(function (e) {
          e && isFunction(e) && e();
        }), this.pendingMap.clear();
      }
    }, {
      key: "removePending",
      value: function removePending(e) {
        if (this.pendingMap.has(e)) {
          var t = this.pendingMap.get(e);
          t && t(e), this.pendingMap.delete(e);
        }
      }
    }, {
      key: "removeCancelToken",
      value: function removeCancelToken(e) {
        this.pendingMap.has(e) && this.pendingMap.delete(e);
      }
    }, {
      key: "reset",
      value: function reset() {
        this.pendingMap = new Map();
      }
    }]);

    return AxiosCanceler;
  }();

  function _createSuper$g(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$g(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$g() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var Http1 = /*#__PURE__*/function (_EventEmitter) {
    _inherits(Http1, _EventEmitter);

    var _super = _createSuper$g(Http1);

    function Http1() {
      var _this;

      _classCallCheck(this, Http1);

      _this = _super.call(this);
      _this.instatnce = axios.create(), _this.canceler = new AxiosCanceler();
      return _this;
    }

    _createClass(Http1, [{
      key: "requestConstant",
      value: function requestConstant() {
        return {
          x_nounce: this.randomString(),
          x_timestamp: new Date().getTime(),
          x_os: "web"
        };
      }
    }, {
      key: "requestParams",
      value: function requestParams(e) {
        return oe({}, e.params);
      }
    }, {
      key: "get",
      value: function get(e) {
        return this.request(le(oe({}, e), {
          method: "GET"
        }));
      }
    }, {
      key: "post",
      value: function post(e) {
        return this.request(le(oe({}, e), {
          method: "POST"
        }));
      }
    }, {
      key: "request",
      value: function request(e) {
        var _this2 = this;

        var t = e.url,
            _e$timeout = e.timeout,
            r = _e$timeout === void 0 ? 1e4 : _e$timeout,
            n = e.method,
            o = e.key,
            a = e.beforeRequest,
            s = e.responseType,
            l = e.data;
        var _e$retry = e.retry,
            u = _e$retry === void 0 ? 0 : _e$retry;
        var c = this.patchUrl(t),
            h = this.canceler.addPending(t);
        a && isFunction(a) && a(e);
        var f = this.requestParams(e);
        var d = {
          url: c,
          method: n,
          timeout: r,
          cancelToken: h,
          responseType: s,
          params: f
        };
        n === "POST" && (d = oe({
          data: l
        }, d));

        var _ = Date.now(),
            g = function g() {
          return _this2.instatnce.request(d).then(function (m) {
            return o && logger$1.infoAndReportMeasurement({
              metric: "http",
              startTime: _,
              extra: t,
              group: "http",
              tag: o
            }), _this2.canceler.removeCancelToken(t), m;
          }).catch(function (m) {
            var v = axios.isCancel(m);
            return u > 0 && !v ? (u--, logger$1.warn("request ".concat(t, " retry, left retry count"), u), g()) : (logger$1.infoAndReportMeasurement({
              metric: "http",
              startTime: _,
              error: m,
              extra: {
                url: t,
                isCanceled: v
              },
              tag: o,
              group: "http"
            }), _this2.canceler.removeCancelToken(t), Promise.reject(m));
          });
        };

        return g();
      }
    }, {
      key: "patchUrl",
      value: function patchUrl(e) {
        return e;
      }
    }, {
      key: "randomString",
      value: function randomString() {
        var e = "";
        var t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
            r = t.length;

        for (var n = 0; n < 8; n++) {
          e += t.charAt(Math.floor(Math.random() * r));
        }

        return e;
      }
    }]);

    return Http1;
  }(EventEmitter);

  var http1 = new Http1();

  var ModelManager = /*#__PURE__*/function () {
    function ModelManager(e, t) {
      _classCallCheck(this, ModelManager);

      this.avatarModelList = [];
      this.skinList = [];
      this.applicationConfig = null;
      this.config = null;
      this.appId = e, this.releaseId = t;
    }

    _createClass(ModelManager, [{
      key: "findSkinConfig",
      value: function () {
        var _findSkinConfig = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var t, n;
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  t = null;
                  _context.next = 3;
                  return this.getSkinsList();

                case 3:
                  t = (this.skinList = _context.sent).find(function (n) {
                    return n.id === e;
                  });

                  if (!t) {
                    _context.next = 6;
                    break;
                  }

                  return _context.abrupt("return", t);

                case 6:
                  n = "skin is invalid: skinId: ".concat(e);
                  return _context.abrupt("return", Promise.reject(new ParamError(n)));

                case 8:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function findSkinConfig(_x) {
          return _findSkinConfig.apply(this, arguments);
        }

        return findSkinConfig;
      }()
    }, {
      key: "findRoute",
      value: function () {
        var _findRoute = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(e, t) {
          var n, o;
          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  _context2.next = 2;
                  return this.findSkinConfig(e);

                case 2:
                  n = _context2.sent.routeList.find(function (o) {
                    return o.pathName === t;
                  });

                  if (n) {
                    _context2.next = 6;
                    break;
                  }

                  o = "find path failed: skinId: ".concat(e, ", pathName: ").concat(t);
                  return _context2.abrupt("return", Promise.reject(new ParamError(o)));

                case 6:
                  return _context2.abrupt("return", (logger$1.debug("find route success", n), n));

                case 7:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this);
        }));

        function findRoute(_x2, _x3) {
          return _findRoute.apply(this, arguments);
        }

        return findRoute;
      }()
    }, {
      key: "findAssetList",
      value: function () {
        var _findAssetList = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(e) {
          var r, n;
          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  _context3.next = 2;
                  return this.findSkinConfig(e);

                case 2:
                  r = _context3.sent.assetList;

                  if (r) {
                    _context3.next = 6;
                    break;
                  }

                  n = "find path failed: skinId: ".concat(e);
                  return _context3.abrupt("return", Promise.reject(new ParamError(n)));

                case 6:
                  return _context3.abrupt("return", (logger$1.debug("find route success", r), r));

                case 7:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, this);
        }));

        function findAssetList(_x4) {
          return _findAssetList.apply(this, arguments);
        }

        return findAssetList;
      }()
    }, {
      key: "findAsset",
      value: function () {
        var _findAsset = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(e, t) {
          var r,
              n,
              o,
              a,
              _args4 = arguments;
          return regenerator.wrap(function _callee4$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  r = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : "id";
                  _context4.next = 3;
                  return this.findSkinConfig(e);

                case 3:
                  n = _context4.sent;

                  if (!Array.isArray(t)) {
                    _context4.next = 6;
                    break;
                  }

                  return _context4.abrupt("return", t.map(function (a) {
                    return n.models.find(function (s) {
                      return s[r] === a;
                    });
                  }).filter(Boolean));

                case 6:
                  o = n.models.find(function (a) {
                    return a[r] === t;
                  });

                  if (o) {
                    _context4.next = 10;
                    break;
                  }

                  a = "find asset failed: skinId: ".concat(e, ", keyValue: ").concat(t);
                  return _context4.abrupt("return", Promise.reject(new ParamError(a)));

                case 10:
                  return _context4.abrupt("return", (logger$1.debug("find asset success", o), o));

                case 11:
                case "end":
                  return _context4.stop();
              }
            }
          }, _callee4, this);
        }));

        function findAsset(_x5, _x6) {
          return _findAsset.apply(this, arguments);
        }

        return findAsset;
      }()
    }, {
      key: "findPoint",
      value: function () {
        var _findPoint = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5(e, t) {
          var n, o;
          return regenerator.wrap(function _callee5$(_context5) {
            while (1) {
              switch (_context5.prev = _context5.next) {
                case 0:
                  _context5.next = 2;
                  return this.findSkinConfig(e);

                case 2:
                  n = _context5.sent.pointList.find(function (o) {
                    return o.id === t;
                  });

                  if (n) {
                    _context5.next = 6;
                    break;
                  }

                  o = "find point failed: skinId: ".concat(e, ", id: ").concat(t);
                  return _context5.abrupt("return", Promise.reject(new ParamError(o)));

                case 6:
                  return _context5.abrupt("return", (logger$1.debug("find point success", n), n));

                case 7:
                case "end":
                  return _context5.stop();
              }
            }
          }, _callee5, this);
        }));

        function findPoint(_x7, _x8) {
          return _findPoint.apply(this, arguments);
        }

        return findPoint;
      }()
    }, {
      key: "requestConfig",
      value: function () {
        var _requestConfig = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee6() {
          var t, r, _ref, n, o;

          return regenerator.wrap(function _callee6$(_context6) {
            while (1) {
              switch (_context6.prev = _context6.next) {
                case 0:
                  if (!this.config) {
                    _context6.next = 2;
                    break;
                  }

                  return _context6.abrupt("return", this.config);

                case 2:
                  // let e = `https://static.xverse.cn/console/config/${this.appId}/config.json`;
                  // this.releaseId && (e = `https://static.xverse.cn/console/config/${this.appId}/${this.releaseId}/config.json`);
                  // const t = Xverse.USE_TME_CDN ? "https://static.xverse.cn/tmeland/config/tme_config.json" : e;
                  t = './assets/config.json';
                  _context6.prev = 3;
                  _context6.next = 6;
                  return http1.get({
                    url: "".concat(t, "?t=").concat(Date.now()),
                    key: "config",
                    timeout: 6e3,
                    retry: 2
                  });

                case 6:
                  r = _context6.sent;
                  _ref = r.data.data || {}, n = _ref.config, o = _ref.preload;

                  if (n) {
                    _context6.next = 10;
                    break;
                  }

                  throw new Error("config data parse error" + r.data);

                case 10:
                  return _context6.abrupt("return", (this.config = {
                    config: n,
                    preload: o
                  }, logger$1.debug("get config success", this.config), this.config));

                case 13:
                  _context6.prev = 13;
                  _context6.t0 = _context6["catch"](3);
                  return _context6.abrupt("return", Promise.reject(_context6.t0));

                case 16:
                case "end":
                  return _context6.stop();
              }
            }
          }, _callee6, this, [[3, 13]]);
        }));

        function requestConfig() {
          return _requestConfig.apply(this, arguments);
        }

        return requestConfig;
      }()
    }, {
      key: "getApplicationConfig",
      value: function () {
        var _getApplicationConfig = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee7() {
          var e;
          return regenerator.wrap(function _callee7$(_context7) {
            while (1) {
              switch (_context7.prev = _context7.next) {
                case 0:
                  if (!this.applicationConfig) {
                    _context7.next = 2;
                    break;
                  }

                  return _context7.abrupt("return", this.applicationConfig);

                case 2:
                  _context7.prev = 2;
                  _context7.next = 5;
                  return this.requestConfig();

                case 5:
                  e = _context7.sent;
                  return _context7.abrupt("return", (this.applicationConfig = e.config, this.applicationConfig));

                case 9:
                  _context7.prev = 9;
                  _context7.t0 = _context7["catch"](2);
                  return _context7.abrupt("return", Promise.reject(_context7.t0));

                case 12:
                case "end":
                  return _context7.stop();
              }
            }
          }, _callee7, this, [[2, 9]]);
        }));

        function getApplicationConfig() {
          return _getApplicationConfig.apply(this, arguments);
        }

        return getApplicationConfig;
      }()
    }, {
      key: "getAvatarModelList",
      value: function () {
        var _getAvatarModelList = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee8() {
          var _yield$this$getApplic, e;

          return regenerator.wrap(function _callee8$(_context8) {
            while (1) {
              switch (_context8.prev = _context8.next) {
                case 0:
                  if (!this.avatarModelList.length) {
                    _context8.next = 2;
                    break;
                  }

                  return _context8.abrupt("return", this.avatarModelList);

                case 2:
                  _context8.prev = 2;
                  _context8.next = 5;
                  return this.getApplicationConfig();

                case 5:
                  _yield$this$getApplic = _context8.sent;
                  e = _yield$this$getApplic.avatars;
                  return _context8.abrupt("return", (this.avatarModelList = e.map(function (t) {
                    return {
                      name: t.name,
                      id: t.id,
                      modelUrl: t.url,
                      gender: t.gender,
                      components: t.components
                    };
                  }), this.avatarModelList));

                case 10:
                  _context8.prev = 10;
                  _context8.t0 = _context8["catch"](2);
                  return _context8.abrupt("return", (logger$1.error(_context8.t0), []));

                case 13:
                case "end":
                  return _context8.stop();
              }
            }
          }, _callee8, this, [[2, 10]]);
        }));

        function getAvatarModelList() {
          return _getAvatarModelList.apply(this, arguments);
        }

        return getAvatarModelList;
      }()
    }, {
      key: "getSkinsList",
      value: function () {
        var _getSkinsList = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee9() {
          var _yield$this$getApplic2, e;

          return regenerator.wrap(function _callee9$(_context9) {
            while (1) {
              switch (_context9.prev = _context9.next) {
                case 0:
                  if (!this.skinList.length) {
                    _context9.next = 2;
                    break;
                  }

                  return _context9.abrupt("return", this.skinList);

                case 2:
                  _context9.prev = 2;
                  _context9.next = 5;
                  return this.getApplicationConfig();

                case 5:
                  _yield$this$getApplic2 = _context9.sent;
                  e = _yield$this$getApplic2.skins;
                  return _context9.abrupt("return", (this.skinList = e.map(function (t) {
                    var r;
                    return {
                      name: t.name,
                      dataVersion: t.id + t.versionId,
                      id: t.id,
                      fov: parseInt(t.fov || 90),
                      models: t.assetList.map(function (n) {
                        var o = n.assetId,
                            a = n.url,
                            s = n.thumbnailUrl,
                            l = n.typeName,
                            u = n.className;
                        return {
                          id: o,
                          modelUrl: a,
                          name: n.name,
                          thumbnailUrl: s,
                          typeName: l,
                          className: u === "\u4F4E\u6A21" ? "\u7C97\u6A21" : u
                        };
                      }),
                      routeList: (r = t.routeList) == null ? void 0 : r.map(function (n) {
                        var o = n.areaName,
                            a = n.attitude,
                            s = n.id,
                            l = n.pathName,
                            u = n.step,
                            c = n.birthPointList;
                        return {
                          areaName: o,
                          attitude: a,
                          id: s,
                          pathName: l,
                          step: u,
                          birthPointList: c.map(function (h) {
                            return {
                              camera: h.camera && {
                                position: util.objectParseFloat(h.camera.position),
                                angle: util.objectParseFloat(h.camera.rotation)
                              },
                              player: h.player && {
                                position: util.objectParseFloat(h.player.position),
                                angle: util.objectParseFloat(h.player.rotation)
                              }
                            };
                          })
                        };
                      }),
                      pointList: t.pointList.map(function (n) {
                        return le(oe({}, n), {
                          position: util.objectParseFloat(n.position),
                          rotation: util.objectParseFloat(n.rotation)
                        });
                      }),
                      versionId: t.versionId,
                      isEnable: t.isEnable,
                      assetList: t.assetList,
                      visibleRules: t.visibleRules,
                      animationList: t.animationList
                    };
                  }), this.skinList));

                case 10:
                  _context9.prev = 10;
                  _context9.t0 = _context9["catch"](2);
                  return _context9.abrupt("return", (logger$1.error(_context9.t0), []));

                case 13:
                case "end":
                  return _context9.stop();
              }
            }
          }, _callee9, this, [[2, 10]]);
        }));

        function getSkinsList() {
          return _getSkinsList.apply(this, arguments);
        }

        return getSkinsList;
      }()
    }, {
      key: "getBreathPointTextrueList",
      value: function () {
        var _getBreathPointTextrueList = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee10() {
          return regenerator.wrap(function _callee10$(_context10) {
            while (1) {
              switch (_context10.prev = _context10.next) {
                case 0:
                  return _context10.abrupt("return", [{
                    url: TEXTURE_URL
                  }]);

                case 1:
                case "end":
                  return _context10.stop();
              }
            }
          }, _callee10);
        }));

        function getBreathPointTextrueList() {
          return _getBreathPointTextrueList.apply(this, arguments);
        }

        return getBreathPointTextrueList;
      }()
    }], [{
      key: "getInstance",
      value: function getInstance(e, t) {
        //getInstance(e, t) {
        return this.instance || (this.instance = new ModelManager(e, t)), this.instance;
      }
    }, {
      key: "findModels",
      value: function findModels(e, t, r) {
        //findModels(e, t, r) {
        return e.filter(function (o) {
          return o.typeName === t && o.className === r;
        });
      }
    }, {
      key: "findModel",
      value: function findModel(e, t, r) {
        //findModel(e, t, r) {
        var n = e.filter(function (o) {
          return o.typeName === t && o.className === r;
        })[0];
        return n || null;
      }
    }]);

    return ModelManager;
  }();
  // export { modelManager };

  var JoyStick = /*#__PURE__*/function () {
    function JoyStick(e) {
      _classCallCheck(this, JoyStick);

      this._zone = document.createElement("div");
      this._joystick = null;
      this._room = e;
    }

    _createClass(JoyStick, [{
      key: "init",
      value: function init(e) {
        var _this = this;

        var _e$interval = e.interval,
            t = _e$interval === void 0 ? 33 : _e$interval,
            _e$triggerDistance = e.triggerDistance,
            r = _e$triggerDistance === void 0 ? 25 : _e$triggerDistance,
            _e$style = e.style,
            n = _e$style === void 0 ? {
          left: 0,
          bottom: 0
        } : _e$style,
            o = function o(u, c) {
          _this._room.actionsHandler.joystick({
            degree: Math.floor(u),
            level: Math.floor(c / 5)
          });
        },
            a = this._zone;

        document.body.appendChild(a), a.style.position = "absolute", a.style.width = "200px", a.style.height = "200px", a.style.left = String(n.left), a.style.bottom = String(n.bottom), a.style.zIndex = "999", a.style.userSelect = "none", a.style.webkitUserSelect = "none", this._joystick = nipplejs.create({
          zone: a,
          mode: "static",
          position: {
            left: "50%",
            top: "50%"
          },
          color: "white"
        });
        var s, l;
        return this._joystick.on("move", function (u, c) {
          s = c;
        }), this._joystick.on("start", function () {
          l = window.setInterval(function () {
            s && s.distance > r && o && o(s.angle.degree, s.distance);
          }, t);
        }), this._joystick.on("end", function () {
          l && window.clearInterval(l), l = void 0;
        }), this._joystick;
      }
    }, {
      key: "show",
      value: function show() {
        if (!this._joystick) throw new Error("joystick is not created");
        this._zone.style.display = "block";
      }
    }, {
      key: "hide",
      value: function hide() {
        if (!this._joystick) throw new Error("joystick is not created");
        this._zone.style.display = "none";
      }
    }]);

    return JoyStick;
  }();

  var CoreBroadcastType$1 = {
    PlayAnimation: 'PlayAnimation'
  };

  var AvatarGroup = {
    Npc: 'npc',
    User: 'user'
  };

  var MessageHandleType$1 = {
    MHT_Undefined: 0,
    MHT_RoomMulticast: 1,
    MHT_FollowListMulticast: 2,
    MHT_CustomTargetSync: 3
  };

  var Broadcast$1 = /*#__PURE__*/function () {
    function Broadcast(e, t) {
      _classCallCheck(this, Broadcast);

      this.room = e;
      this.handlers = [];
      this.init(t);
    }

    _createClass(Broadcast, [{
      key: "init",
      value: function init(t) {
        this.handlers.push(t);
      }
    }, {
      key: "handleBroadcast",
      value: function () {
        var _handleBroadcast = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  _context.prev = 1;
                  JSON.parse(e.broadcastAction.data);
                  _context.next = 9;
                  break;

                case 5:
                  _context.prev = 5;
                  _context.t0 = _context["catch"](1);
                  logger$1.error(_context.t0);
                  return _context.abrupt("return");

                case 9:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, null, [[1, 5]]);
        }));

        function handleBroadcast(_x) {
          return _handleBroadcast.apply(this, arguments);
        }

        return handleBroadcast;
      }()
    }, {
      key: "broadcast",
      value: function broadcast(e) {
        var t = e.data,
            _e$msgType = e.msgType,
            r = _e$msgType === void 0 ? MessageHandleType$1.MHT_FollowListMulticast : _e$msgType,
            n = e.targetUserIds;
        return this.room.actionsHandler.broadcast({
          data: t,
          msgType: r,
          targetUserIds: n
        });
      }
    }]);

    return Broadcast;
  }();

  var XAvatarLoader = /*#__PURE__*/function () {
    function XAvatarLoader() {
      _classCallCheck(this, XAvatarLoader);

      E(this, "containers", new Map());
      E(this, "meshes", new Map());
      E(this, "animations", new Map());
      E(this, "aniPath", new Map());
      E(this, "binPath", new Map());
      E(this, "texPath", new Map());
      E(this, "matPath", new Map());
      E(this, "mshPath", new Map());
      E(this, "rootPath", new Map());
      E(this, "meshTexList", new Map());
      E(this, "_enableIdb", !0);
      E(this, "_mappings", new Map());
      E(this, "_sharedTex", new Map());
      E(this, "avaliableAnimation", new Map());
      E(this, "enableShareTexture", !0);
      E(this, "enableShareAnimation", !0);
      E(this, "fillEmptyLod", !0);
      var e = new BABYLON.GLTFFileLoader();
      BABYLON.SceneLoader.RegisterPlugin(e), e.preprocessUrlAsync = function (t) {
        var r = avatarLoader._mappings.get(t);

        return r ? Promise.resolve(r) : Promise.resolve(t);
      };
    }

    _createClass(XAvatarLoader, [{
      key: "getParsedUrl",
      value: function getParsedUrl(e, t, r) {
        var _this = this;
        return new Promise(function (o, a) {
          if (!r || r.indexOf(".zip") === -1) return o(r);

          var s = _this.rootPath.get(r);

          if (s) return o(s);
          {
            var l = ".zip",
                u = r.replace(l, "") + COMPONENT_LIST_PREFIX;
            e.urlTransformer(u, !0).then(function (c) {
              if (!c) return a("Loading Failed");
              new Response(c).json().then(function (h) {
                var _, g, m, v, y, b, T;

                var f = r.replace(l, ""),
                    d = f + ((_ = h == null ? void 0 : h.components) == null ? void 0 : _.url.replace("./", ""));

                if (_this.rootPath.set(r, d), h.components ? (h.components.url && _this.mshPath.set(t, f + "/" + ((g = h == null ? void 0 : h.components) == null ? void 0 : g.url.replace("./", ""))), h.components.url_lod2 && _this.mshPath.set(t + "_" + avatarSetting.lod[1].level, f + "/" + ((m = h == null ? void 0 : h.components) == null ? void 0 : m.url_lod2.replace("./", ""))), h.components.url_lod4 && _this.mshPath.set(t + "_" + avatarSetting.lod[2].level, f + "/" + ((v = h == null ? void 0 : h.components) == null ? void 0 : v.url_lod4.replace("./", "")))) : (h.meshes.url && _this.mshPath.set(t, f + "/" + ((y = h == null ? void 0 : h.meshes) == null ? void 0 : y.url.replace("./", ""))), h.meshes.url_lod2 && _this.mshPath.set(t + "_" + avatarSetting.lod[1].level, f + "/" + ((b = h == null ? void 0 : h.meshes) == null ? void 0 : b.url_lod2.replace("./", ""))), h.meshes.url_lod4 && _this.mshPath.set(t + "_" + avatarSetting.lod[2].level, f + "/" + ((T = h == null ? void 0 : h.meshes) == null ? void 0 : T.url_lod4.replace("./", "")))), h.materials && h.materials.forEach(function (C) {
                  var A = f + "/" + C.url;

                  _this.matPath.set(C.name, A);
                }), h.bin) {
                  var C = f + "/" + h.bin.url;

                  _this.binPath.set(t, C);

                  var A = f + "/" + h.bin.url_lod2;

                  _this.binPath.set(t + "_" + avatarSetting.lod[1].level, A);

                  var S = f + "/" + h.bin.url_lod4;

                  _this.binPath.set(t + "_" + avatarSetting.lod[2].level, S);
                }

                return h.textures && h.textures.forEach(function (C) {
                  var A = f + "/" + C.url;

                  _this.texPath.set(C.url, A);

                  var S = _this.meshTexList.get(h.components.url);

                  C.type === "png" && (S ? S.find(function (P) {
                    return P === C.name;
                  }) || S.push(C.url) : _this.meshTexList.set(t, [C.name]));
                }), o(d);
              }).catch(function (h) {
                logger$1.error("[Engine] parse json file error,".concat(h));
              });
            }).catch(function (c) {
              logger$1.error("[Engine] ulrtransform error, cannot find resource in db,".concat(c));
            });
          }
        });
      }
    }, {
      key: "parse",
      value: function () {
        var _parse = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e, t) {
          var _this2 = this;

          var r;
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  r = [];
                  t.forEach(function (n) {
                    _this2._setAnimationList(n.id, n.animations), r.push(_this2.getParsedUrl(e, n.id, n.url)), n.components.forEach(function (o) {
                      o.units.forEach(function (a) {
                        r.push(_this2.getParsedUrl(e, a.name, a.url));
                      });
                    });
                  });
                  _context.next = 4;
                  return Promise.all(r);

                case 4:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee);
        }));

        function parse(_x, _x2) {
          return _parse.apply(this, arguments);
        }

        return parse;
      }()
    }, {
      key: "_setAnimationList",
      value: function _setAnimationList(e, t) {
        var _this3 = this;

        t ? t.forEach(function (r) {
          _this3.aniPath.set(e + "_" + r.name, r.url);
        }) : logger$1.error("[Engine] no animation list exist, please check config for details");
      }
    }, {
      key: "disposeContainer",
      value: function disposeContainer() {
        var _this4 = this;

        this.containers.forEach(function (e, t) {
          e.xReferenceCount < 1 && (_this4.enableShareTexture && e.textures.length > 0 && e.textures[0].xReferenceCount != null && (e.textures[0].xReferenceCount--, e.textures = []), e.dispose(), _this4.containers.delete(t));
        }), this._sharedTex.forEach(function (e, t) {
          e.xReferenceCount == 0 && (e.dispose(), _this4._sharedTex.delete(t));
        });
      }
    }, {
      key: "enableIdb",
      set: function set(e) {
        this._enableIdb = e;
      }
    }, {
      key: "getGlbPath",
      value: function getGlbPath(e) {
        return this.aniPath.get(e + ".glb");
      }
    }, {
      key: "getGltfPath",
      value: function getGltfPath(e) {
        return this.mshPath.get(e + ".gltf");
      }
    }, {
      key: "getPngUrl",
      value: function getPngUrl(e) {
        return this.texPath.get(e + ".png");
      }
    }, {
      key: "getMeshUrl",
      value: function getMeshUrl(e) {
        return this.mshPath.get(e);
      }
    }, {
      key: "_getSourceKey",
      value: function _getSourceKey(e, t) {
        return t && avatarSetting.lod[t] ? e + avatarSetting.lod[t].fileName.split(".")[0] : e;
      }
    }, {
      key: "_getAnimPath",
      value: function _getAnimPath(e, t) {
        var r = this.aniPath.get(t + "_animations_" + t.split("_")[1]);
        return r || (r = this.aniPath.get(t + "_" + e)), r;
      }
    }, {
      key: "load",
      value: function load(e, t, r, n) {
        var _this5 = this;

        return new Promise(function (o, a) {
          _this5.loadGlb(e, t, r).then(function (s) {
            return s ? o(s) : a("[Engine] container load failed");
          }).catch(function () {
            return a("[Engine] container load failed");
          });
        });
      }
    }, {
      key: "_searchAnimation",
      value: function _searchAnimation(e, t) {
        var r;
        return this.containers.forEach(function (n, o) {
          var a = t.split("_")[0];
          o.indexOf(a) != -1 && o.indexOf(e) != -1 && (r = n);
        }), r;
      }
    }, {
      key: "loadAnimRes",
      value: function loadAnimRes(e, t, r) {
        var _this6 = this;

        return new Promise(function (n, o) {
          var a = _this6._getAnimPath(t, r),
              s = getAnimationKey(t, r);

          if (a && _this6.containers.get(a)) return n(_this6.containers.get(a));
          if (a) _this6._loadGlbFromBlob(e, s, a).then(function (l) {
            return l.animationGroups.length == 0 ? (_this6.containers.delete(s), l.dispose(), Promise.reject("container does not contains animation data")) : n(l);
          });else return o("no such url");
        });
      }
    }, {
      key: "loadGlb",
      value: function loadGlb(e, t, r) {
        var n = this.getMeshUrl(this._getSourceKey(t, r));
        return !n && this.fillEmptyLod && (r = 0, n = this.getMeshUrl(this._getSourceKey(t, r))), n && this.containers.get(n) ? Promise.resolve(this.containers.get(n)) : n ? this._enableIdb ? Promise.resolve(this._loadGlbFromBlob(e, this._getSourceKey(t, r), n)) : Promise.resolve(this._loadGlbFromUrl(e, this._getSourceKey(t, r), n)) : Promise.reject("no such url");
      }
    }, {
      key: "loadGltf",
      value: function loadGltf(e, t, r, n) {
        var o = this._getSourceKey(t, r || 0);

        var a = this.getGltfPath(o);
        return !a && this.fillEmptyLod && (a = this.getGltfPath(t)), a && this.containers.get(a) ? Promise.resolve(this.containers.get(a)) : this._enableIdb ? this._loadGltfFromBlob(e, t, r, n) : a ? this._loadGltfFromUrl(e, t, a.replace(t + ".gltf", "")) : Promise.reject();
      }
    }, {
      key: "loadSubsequence",
      value: function loadSubsequence() {}
    }, {
      key: "loadVAT",
      value: function loadVAT() {}
    }, {
      key: "getResourceName",
      value: function getResourceName(e) {
        return this.meshTexList.get(e);
      }
    }, {
      key: "_loadGltfFromUrl",
      value: function _loadGltfFromUrl(e, t, r) {
        return BABYLON.SceneLoader.LoadAssetContainerAsync(r, t + ".gltf", e.Scene, null, ".gltf");
      }
    }, {
      key: "_loadGlbFromBlob",
      value: function _loadGlbFromBlob(e, t, r) {
        var _this7 = this;

        return new Promise(function (n, o) {
          e.urlTransformer(r).then(function (a) {
            BABYLON.SceneLoader.LoadAssetContainerAsync("", a, e.Scene, null, ".glb").then(function (s) {
              if (s) {
                if (_this7.enableShareTexture && s.textures.length > 0) {
                  var l = t.indexOf("_lod") != -1 ? t.slice(0, -5) : t,
                      u = _this7._sharedTex.get(l);

                  u ? (s.meshes[1].material._albedoTexture = u, s.textures.forEach(function (c) {
                    c.dispose();
                  }), s.textures = [u], u.xReferenceCount++) : (_this7._sharedTex.set(l, s.textures[0]), s.textures[0].xReferenceCount = 1);
                }

                return s.addAllToScene(), s.xReferenceCount = 0, s.meshes.forEach(function (l) {
                  l.setEnabled(!1);
                }), _this7.containers.set(r, s), n(s);
              } else o("glb file load failed");
            });
          });
        });
      }
    }, {
      key: "_loadGlbFromUrl",
      value: function _loadGlbFromUrl(e, t, r) {
        var _this8 = this;

        return new Promise(function (n, o) {
          BABYLON.SceneLoader.LoadAssetContainerAsync("", r, e.Scene, null, ".glb").then(function (a) {
            if (a) {
              if (a.addAllToScene(), a.meshes.forEach(function (s) {
                s.setEnabled(!1);
              }), _this8.enableShareTexture && a.textures.length > 0) {
                var s = t.indexOf("_lod") != -1 ? t.slice(0, -5) : t,
                    l = _this8._sharedTex.get(s);

                l ? (a.meshes[1].material._albedoTexture = l, a.textures.forEach(function (u) {
                  u.dispose();
                }), a.textures = [l], l.xReferenceCount++) : (_this8._sharedTex.set(s, a.textures[0]), a.textures[0].xReferenceCount = 1);
              }

              return a.xReferenceCount = 0, _this8.containers.set(r, a), n(a);
            } else o("glb file load failed");
          });
        });
      }
    }, {
      key: "_loadGltfFromBlob",
      value: function _loadGltfFromBlob(e, t, r, n) {
        var _this9 = this;

        return new Promise(function (o, a) {
          var s = [];

          var l = _this9._getSourceKey(t, r),
              u = _this9.getGltfPath(l);

          if (!u && _this9.fillEmptyLod && (r = 0, l = _this9._getSourceKey(t, r), u = _this9.getGltfPath(l)), !u) return a("[Engine] gltf path incorrect ".concat(l, ",cancel."));

          var c = _this9.mshPath.get(l + ".gltf");

          if (!c) return a("cannot find asset mshPath");

          var h = _this9.binPath.get(l + ".bin");

          if (!h) return a("cannot find asset binPath");

          if (!n) {
            var _ = _this9.meshTexList.get(t);

            if (!_ || _.length == 0) return a("cannot find texture");
            n = _[0];
          }

          var f = _this9.texPath.get(n + ".png");

          if (!f) return a();

          var d = _this9.texPath.get(n + "-astc.ktx");

          if (!d) return a();
          s.push(_this9._blobMapping(e, c)), s.push(_this9._blobMapping(e, h)), s.push(_this9._blobMapping(e, f)), s.push(_this9._blobMapping(e, d)), Promise.all(s).then(function () {
            var _ = u.replace(l + ".gltf", "");

            BABYLON.SceneLoader.LoadAssetContainerAsync(_, l + ".gltf", e.Scene, null, ".gltf").then(function (g) {
              var v;
              _this9.containers.set(u, g), g.addAllToScene(), g.meshes.forEach(function (y) {
                y.setEnabled(!1);
              });

              var m = _this9._sharedTex.get(t);

              m ? ((v = g.meshes[1].material._albedoTexture) == null || v.dispose(), g.meshes[1].material._albedoTexture = m) : _this9._sharedTex.set(t, g.meshes[1].material._albedoTexture), o(g);
            });
          });
        });
      }
    }, {
      key: "_blobMapping",
      value: function _blobMapping(e, t) {
        var _this10 = this;

        return new Promise(function (r, n) {
          e.urlTransformer(t).then(function (o) {
            return o ? (_this10._mappings.set(t, o), r(t)) : n("[Engine] url urlTransformer parse error ".concat(t));
          });
        });
      }
    }]);

    return XAvatarLoader;
  }();
  var avatarLoader = new XAvatarLoader();

  var SyncEventType = {
    Reset: 0,
    Appear: 1,
    Disappear: 2,
    Move: 3,
    ChangeRenderInfo: 4,
    KeepAlive: 5,
    Rotate: 6,
    ET_RemoveVisitor: 7
  };

  var GetStateTypes = {
    Default: 0,
    Event: 1
  };

  var EAvatarRelationRank = {
    Self: 0,
    Npc: 1,
    Friend: 2,
    Stranger: 3,
    Robot: 4,
    Unknown: 5
  };

  var Person = {
    Third: 0,
    First: 1
  };

  var MotionType = {
    Walk: 'walk',
    Run: 'run',
    Fly: 'fly'
  };

  var Queue = /*#__PURE__*/function () {
    function Queue() {
      _classCallCheck(this, Queue);

      E(this, "queue", []);
      E(this, "currentAction");
    }

    _createClass(Queue, [{
      key: "append",
      value: function () {
        var _append = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var t, r;
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  if (!(this.queue.length === 0 || ((t = this.currentAction) == null ? void 0 : t.type) === e.type && this.queue.length === 1)) {
                    _context.next = 7;
                    break;
                  }

                  this.queue = [];
                  this.queue.push(e);
                  _context.next = 5;
                  return this.go();

                case 5:
                  _context.next = 8;
                  break;

                case 7:
                  ((r = this.queue[this.queue.length - 1]) == null ? void 0 : r.type) === e.type && this.queue.pop(), this.queue.push(e);

                case 8:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function append(_x) {
          return _append.apply(this, arguments);
        }

        return append;
      }()
    }, {
      key: "go",
      value: function () {
        var _go = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2() {
          var e;
          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  if (!(this.queue.length !== 0)) {
                    _context2.next = 9;
                    break;
                  }

                  e = this.queue[0];
                  this.currentAction = e;
                  _context2.next = 5;
                  return e.action();

                case 5:
                  this.currentAction = void 0;
                  this.queue.splice(0, 1);
                  _context2.next = 9;
                  return this.go();

                case 9:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this);
        }));

        function go() {
          return _go.apply(this, arguments);
        }

        return go;
      }()
    }, {
      key: "reject",
      value: function () {
        var _reject = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3() {
          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  this.queue = [];

                case 1:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, this);
        }));

        function reject() {
          return _reject.apply(this, arguments);
        }

        return reject;
      }()
    }]);

    return Queue;
  }();

  function _createForOfIteratorHelper$6(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$6(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

  function _unsupportedIterableToArray$6(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$6(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$6(o, minLen); }

  function _arrayLikeToArray$6(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

  function _createSuper$f(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$f(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$f() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var XverseAvatar = /*#__PURE__*/function (_EventEmitter) {
    _inherits(XverseAvatar, _EventEmitter);

    var _super = _createSuper$f(XverseAvatar);

    function XverseAvatar(_ref) {
      var _this;

      var e = _ref.userId,
          t = _ref.isHost,
          r = _ref.room,
          n = _ref.avatarId,
          o = _ref.isSelf,
          _ref$group = _ref.group,
          a = _ref$group === void 0 ? AvatarGroup.Npc : _ref$group;

      _classCallCheck(this, XverseAvatar);

      _this = _super.call(this);
      E(_assertThisInitialized(_this), "xAvatar");
      E(_assertThisInitialized(_this), "_isHost", !1);
      E(_assertThisInitialized(_this), "_room");
      E(_assertThisInitialized(_this), "_withModel", !1);
      E(_assertThisInitialized(_this), "_userId");
      E(_assertThisInitialized(_this), "group", AvatarGroup.User);
      E(_assertThisInitialized(_this), "state", "idle");
      E(_assertThisInitialized(_this), "isLoading", !0);
      E(_assertThisInitialized(_this), "_isMoving", !1);
      E(_assertThisInitialized(_this), "_isRotating", !1);
      E(_assertThisInitialized(_this), "_failed", !1);
      E(_assertThisInitialized(_this), "disconnected", !1);
      E(_assertThisInitialized(_this), "_avatarId");
      E(_assertThisInitialized(_this), "prioritySync", !1);
      E(_assertThisInitialized(_this), "priority", EAvatarRelationRank.Stranger);
      E(_assertThisInitialized(_this), "_avatarModel");
      E(_assertThisInitialized(_this), "_motionType", MotionType.Walk);
      E(_assertThisInitialized(_this), "isSelf", !1);
      E(_assertThisInitialized(_this), "_lastAnimTraceId", "");
      E(_assertThisInitialized(_this), "statusSyncQueue", new Queue());
      E(_assertThisInitialized(_this), "extraInfo", {});
      E(_assertThisInitialized(_this), "setPosition", function (e) {
        var t;
        !_this._room.signal.isUpdatedYUV || (t = _this.xAvatar) == null || t.setPosition(positionPrecisionProtect(e));
      });
      E(_assertThisInitialized(_this), "setRotation", function (e) {
        var t;
        !_this._room.signal.isUpdatedYUV || (t = _this.xAvatar) == null || t.setRotation(rotationPrecisionProtect(e));
      });
      E(_assertThisInitialized(_this), "stopAnimation", function () {
        var e, t;
        (t = (e = _this.xAvatar) == null ? void 0 : e.controller) == null || t.stopAnimation();
      });
      E(_assertThisInitialized(_this), "_playAnimation", /*#__PURE__*/function () {
        var _ref2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var t,
              r,
              o,
              n,
              _a,
              _args = arguments;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  t = _args.length > 1 && _args[1] !== undefined ? _args[1] : !0;
                  r = _args.length > 2 && _args[2] !== undefined ? _args[2] : !1;

                  if (_this._room.signal.isUpdatedYUV) {
                    _context.next = 4;
                    break;
                  }

                  return _context.abrupt("return");

                case 4:
                  if (!(_this.state !== "idle" && !r)) {
                    _context.next = 6;
                    break;
                  }

                  return _context.abrupt("return", (logger$1.debug("_playAnimation", "state is not idle"), Promise.resolve("_playAnimation, state is not idle")));

                case 6:
                  n = Date.now();
                  _context.prev = 7;

                  if ((o = _this.xAvatar) != null && o.controller) {
                    _context.next = 10;
                    break;
                  }

                  return _context.abrupt("return", Promise.reject(new InternalError("[avatar: ".concat(_this.userId, "] Play animation failed: ").concat(e, ", no controller"))));

                case 10:
                  _this.isSelf && setTimeout(function () {
                    logger$1.infoAndReportMeasurement({
                      tag: e,
                      startTime: n,
                      value: 0,
                      metric: "playAnimationStart"
                    });
                  });
                  _a = util.uuid();
                  _this._lastAnimTraceId = _a;
                  _context.next = 15;
                  return _this.xAvatar.controller.playAnimation(e, t);

                case 15:
                  _a === _this._lastAnimTraceId && !_this.isMoving && !t && e !== "Idle" && _this.xAvatar.controller.playAnimation("Idle", t).catch(function (s) {
                    logger$1.error("[avatar: ".concat(_this.userId, "] Play animation failed [force idle]"), s);
                  });
                  _this.isSelf && logger$1.infoAndReportMeasurement({
                    tag: e,
                    startTime: n,
                    extra: {
                      loop: t
                    },
                    metric: "playAnimationEnd"
                  });
                  _context.next = 22;
                  break;

                case 19:
                  _context.prev = 19;
                  _context.t0 = _context["catch"](7);
                  return _context.abrupt("return", (logger$1.error("[avatar: ".concat(_this.userId, "] Play animation failed: ").concat(e), _context.t0), _this.isSelf && logger$1.infoAndReportMeasurement({
                    tag: e,
                    startTime: n,
                    metric: "playAnimationEnd",
                    error: _context.t0,
                    extra: {
                      loop: t
                    }
                  }), Promise.reject(_context.t0)));

                case 22:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, null, [[7, 19]]);
        }));

        return function (_x) {
          return _ref2.apply(this, arguments);
        };
      }());
      E(_assertThisInitialized(_this), "changeComponents", /*#__PURE__*/function () {
        var _ref3 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(e) {
          var _ref4, t, _ref4$endAnimation, r, n, o;

          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  _ref4 = e || {}, t = _ref4.mode, _ref4$endAnimation = _ref4.endAnimation, r = _ref4$endAnimation === void 0 ? "" : _ref4$endAnimation, n = JSON.parse(JSON.stringify(e.avatarComponents));
                  o = avatarComponentsValidate(n, _this._avatarModel);
                  return _context2.abrupt("return", (!ChangeComponentsMode[t] && !o && (o = new ParamError("changeComponents failed, mode: ".concat(t, " is invalid"))), o ? (logger$1.error(o), Promise.reject(o)) : _this._changeComponents({
                    avatarComponents: n,
                    mode: t,
                    endAnimation: r
                  }).then(function () {
                    _this.isSelf && t !== ChangeComponentsMode.Preview && _this.avatarComponentsSync(_this.avatarComponents);
                  })));

                case 3:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2);
        }));

        return function (_x2) {
          return _ref3.apply(this, arguments);
        };
      }());
      E(_assertThisInitialized(_this), "_changeComponents", /*#__PURE__*/function () {
        var _ref5 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(e) {
          var o, _ref6, _ref6$avatarComponent, t, r, n, _a2, s, l, _iterator, _step, u, c, h, f, d;

          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  _ref6 = e || {}, _ref6$avatarComponent = _ref6.avatarComponents, t = _ref6$avatarComponent === void 0 ? [] : _ref6$avatarComponent, r = _ref6.mode, n = Date.now();
                  _context3.prev = 1;

                  if (_this.xAvatar) {
                    _context3.next = 4;
                    break;
                  }

                  return _context3.abrupt("return", Promise.reject(new InternalError("changeComponents failed, without instance: xAvatar")));

                case 4:
                  _context3.next = 6;
                  return avatarComponentsModify(_this._avatarModel, t);

                case 6:
                  _a2 = _context3.sent;
                  s = [];
                  _context3.next = 10;
                  return avatarComponentsParser(_this._avatarModel, _a2, _this.avatarComponents);

                case 10:
                  l = _context3.sent;

                  if (!(l.length === 0)) {
                    _context3.next = 13;
                    break;
                  }

                  return _context3.abrupt("return", _this.avatarComponents);

                case 13:
                  _context3.next = 15;
                  return _this.beforeChangeComponentsHook(e);

                case 15:
                  _iterator = _createForOfIteratorHelper$6(l);

                  try {
                    for (_iterator.s(); !(_step = _iterator.n()).done;) {
                      u = _step.value;
                      c = u.id, h = u.type, f = u.url, d = u.suitComb;
                      s.push((o = _this.xAvatar) == null ? void 0 : o.addComponent(c, h, f, d));
                    }
                  } catch (err) {
                    _iterator.e(err);
                  } finally {
                    _iterator.f();
                  }

                  _context3.next = 19;
                  return Promise.all(s);

                case 19:
                  _this.emit("componentsChanged", {
                    components: _this.avatarComponents,
                    mode: r
                  });

                  _this.isSelf && logger$1.infoAndReportMeasurement({
                    tag: "changeComponents",
                    startTime: n,
                    metric: "changeComponents",
                    extra: {
                      inputComponents: t,
                      finalComponents: _this.avatarComponents,
                      mode: ChangeComponentsMode[r]
                    }
                  });
                  return _context3.abrupt("return", _this.avatarComponents);

                case 24:
                  _context3.prev = 24;
                  _context3.t0 = _context3["catch"](1);
                  return _context3.abrupt("return", (_this.isSelf && logger$1.infoAndReportMeasurement({
                    tag: "changeComponents",
                    startTime: n,
                    metric: "changeComponents",
                    error: _context3.t0,
                    extra: {
                      inputComponents: t,
                      finalComponents: _this.avatarComponents,
                      mode: ChangeComponentsMode[r]
                    }
                  }), Promise.reject(_context3.t0)));

                case 27:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, null, [[1, 24]]);
        }));

        return function (_x3) {
          return _ref5.apply(this, arguments);
        };
      }());
      E(_assertThisInitialized(_this), "avatarComponentsSync", function (e) {
        e = e.map(function (t) {
          return {
            type: t.type,
            id: t.id
          };
        }), _this._room.actionsHandler.avatarComponentsSync(e);
      });
      E(_assertThisInitialized(_this), "hide", function () {
        var e;
        if ((e = _this.xAvatar) != null && e.hide()) return Promise.resolve("avatar: ".concat(_this.userId, " hide success"));
        {
          var _t = "avatar: ".concat(_this.userId, " hide failed ").concat(!_this.xAvatar && "without instance: xAvatar");

          return logger$1.warn(_t), Promise.reject(_t);
        }
      });
      E(_assertThisInitialized(_this), "show", function () {
        var e;
        if ((e = _this.xAvatar) != null && e.show()) return Promise.resolve("avatar: ".concat(_this.userId, " show success"));
        {
          var _t2 = "avatar: ".concat(_this.userId, " show failed ").concat(!_this.xAvatar && "without instance: xAvatar");

          return logger$1.warn(_t2), Promise.reject(_t2);
        }
      });
      E(_assertThisInitialized(_this), "sayTimer");
      _this._userId = e, _this._room = r, _this.isSelf = o || !1, _this._withModel = !!n, _this._isHost = t || !1, _this._avatarId = n, _this.group = a, _this._room.modelManager.getAvatarModelList().then(function (s) {
        var l = s.find(function (u) {
          return u.id === n;
        });
        l && (_this._avatarModel = l);
      });
      return _this;
    }

    _createClass(XverseAvatar, [{
      key: "avatarId",
      get: function get() {
        return this._avatarId;
      }
    }, {
      key: "isRender",
      get: function get() {
        var e;
        return !!((e = this.xAvatar) != null && e.isRender);
      }
    }, {
      key: "isHidden",
      get: function get() {
        var e;
        return !!((e = this.xAvatar) != null && e.isHide);
      }
    }, {
      key: "motionType",
      get: function get() {
        return this._motionType;
      },
      set: function set(e) {
        this._motionType = e;
      }
    }, {
      key: "nickname",
      get: function get() {
        var e;
        return (e = this.xAvatar) == null ? void 0 : e.nickName;
      }
    }, {
      key: "words",
      get: function get() {
        var e;
        return (e = this.xAvatar) == null ? void 0 : e.words;
      }
    }, {
      key: "isHost",
      get: function get() {
        return this._isHost;
      }
    }, {
      key: "failed",
      get: function get() {
        return this._failed;
      }
    }, {
      key: "scale",
      get: function get() {
        var e;
        return (e = this.xAvatar) == null ? void 0 : e.scale;
      }
    }, {
      key: "animations",
      get: function get() {
        var e;
        return !this.xAvatar || !this.xAvatar.controller ? [] : ((e = this.xAvatar) == null ? void 0 : e.getAvaliableAnimations()) || [];
      }
    }, {
      key: "position",
      get: function get() {
        var e;
        return (e = this.xAvatar) == null ? void 0 : e.position;
      }
    }, {
      key: "rotation",
      get: function get() {
        var e;
        return (e = this.xAvatar) == null ? void 0 : e.rotation;
      }
    }, {
      key: "pose",
      get: function get() {
        return {
          position: this.position,
          angle: this.rotation
        };
      }
    }, {
      key: "id",
      get: function get() {
        return this.userId;
      }
    }, {
      key: "isMoving",
      get: function get() {
        return this._isMoving;
      },
      set: function set(e) {
        this._isMoving = e, this.state = e ? "moving" : "idle";
      }
    }, {
      key: "isRotating",
      get: function get() {
        return this._isRotating;
      },
      set: function set(e) {
        this._isRotating = e, this.state = e ? "rotating" : "idle";
      }
    }, {
      key: "withModel",
      get: function get() {
        return this._withModel;
      }
    }, {
      key: "avatarComponents",
      get: function get() {
        var e;
        return JSON.parse(JSON.stringify(((e = this.xAvatar) == null ? void 0 : e.clothesList) || []));
      }
    }, {
      key: "userId",
      get: function get() {
        return this._userId;
      }
    }, {
      key: "removeWhenDisconnected",
      get: function get() {
        return this.extraInfo && this.extraInfo.removeWhenDisconnected !== void 0 ? this.extraInfo.removeWhenDisconnected : !0;
      }
    }, {
      key: "setConnectionStatus",
      value: function setConnectionStatus(e) {
        this.disconnected !== e && (this.disconnected = e, e ? this.emit("disconnected") : this.emit("reconnected"), logger$1.warn("avatar ".concat(this.userId, " status changed, disconnected:"), e));
      }
    }, {
      key: "setScale",
      value: function setScale(e) {
        var t;
        (t = this.xAvatar) == null || t.setScale(e > 0 ? e : 1);
      }
    }, {
      key: "playAnimation",
      value: function () {
        var _playAnimation = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(e) {
          var _this2 = this;

          var _ref7, t, r, n, o;

          return regenerator.wrap(function _callee4$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  _ref7 = e || {}, t = _ref7.animationName, r = _ref7.loop, n = _ref7.extra;

                  if (!this.isSelf) {
                    _context4.next = 13;
                    break;
                  }

                  if (!this.isMoving) {
                    _context4.next = 11;
                    break;
                  }

                  _context4.prev = 3;
                  _context4.next = 6;
                  return this.stopMoving();

                case 6:
                  _context4.next = 11;
                  break;

                case 8:
                  _context4.prev = 8;
                  _context4.t0 = _context4["catch"](3);
                  return _context4.abrupt("return", (logger$1.error("stopMoving error before playAnimation ".concat(t), _context4.t0), Promise.reject("stopMoving error before playAnimation ".concat(t))));

                case 11:
                  o = {
                    info: {
                      userId: this.userId,
                      animation: t,
                      loop: r,
                      extra: encodeURIComponent(n || "")
                    },
                    broadcastType: CoreBroadcastType.PlayAnimation
                  };

                  this._room.avatarManager.broadcast.broadcast({
                    data: o
                  });

                case 13:
                  return _context4.abrupt("return", (this.emit("animationStart", {
                    animationName: t,
                    extra: safeDecodeURIComponent(n || "")
                  }), this._playAnimation(t, r).then(function () {
                    _this2.emit("animationEnd", {
                      animationName: t,
                      extra: safeDecodeURIComponent(n || "")
                    });
                  })));

                case 14:
                case "end":
                  return _context4.stop();
              }
            }
          }, _callee4, this, [[3, 8]]);
        }));

        function playAnimation(_x4) {
          return _playAnimation.apply(this, arguments);
        }

        return playAnimation;
      }()
    }, {
      key: "beforeChangeComponentsHook",
      value: function () {
        var _beforeChangeComponentsHook = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5(e) {
          return regenerator.wrap(function _callee5$(_context5) {
            while (1) {
              switch (_context5.prev = _context5.next) {
                case 0:
                case "end":
                  return _context5.stop();
              }
            }
          }, _callee5);
        }));

        function beforeChangeComponentsHook(_x5) {
          return _beforeChangeComponentsHook.apply(this, arguments);
        }

        return beforeChangeComponentsHook;
      }()
    }, {
      key: "turnTo",
      value: function turnTo(e) {
        var _this3 = this;

        if (this._room.viewMode === "observer") {
          this._room.sceneManager.cameraComponent.MainCamera.setTarget(ue4Position2Xverse(e.point));

          return;
        }

        return this._room.actionsHandler.turnTo(e).then(function () {
          _this3.emit("viewChanged", {
            extra: (e == null ? void 0 : e.extra) || ""
          });
        });
      }
    }, {
      key: "moveTo",
      value: function () {
        var _moveTo = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee6(e) {
          var _ref8, t, _ref8$extra, r, a, o;

          return regenerator.wrap(function _callee6$(_context6) {
            while (1) {
              switch (_context6.prev = _context6.next) {
                case 0:
                  _ref8 = e || {}, t = _ref8.point, _ref8$extra = _ref8.extra, r = _ref8$extra === void 0 ? "" : _ref8$extra;

                  if (this.position) {
                    _context6.next = 3;
                    break;
                  }

                  return _context6.abrupt("return", Promise.reject(new ParamError("avatar position is empty")));

                case 3:
                  if (!(typeof r != "string" || typeof r == "string" && r.length > 64)) {
                    _context6.next = 6;
                    break;
                  }

                  a = "extra shoud be string which length less than 64";
                  return _context6.abrupt("return", (logger$1.warn(a), Promise.reject(new ParamError(a))));

                case 6:
                  o = util.getDistance(this.position, t) / 100 > 100 ? MotionType.Run : MotionType.Walk;
                  return _context6.abrupt("return", this._room.actionsHandler.moveTo({
                    point: t,
                    motionType: o,
                    extra: r
                  }));

                case 8:
                case "end":
                  return _context6.stop();
              }
            }
          }, _callee6, this);
        }));

        function moveTo(_x6) {
          return _moveTo.apply(this, arguments);
        }

        return moveTo;
      }()
    }, {
      key: "stopMoving",
      value: function () {
        var _stopMoving = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee7() {
          return regenerator.wrap(function _callee7$(_context7) {
            while (1) {
              switch (_context7.prev = _context7.next) {
                case 0:
                  return _context7.abrupt("return", this._room.actionsHandler.stopMoving());

                case 1:
                case "end":
                  return _context7.stop();
              }
            }
          }, _callee7, this);
        }));

        function stopMoving() {
          return _stopMoving.apply(this, arguments);
        }

        return stopMoving;
      }()
    }, {
      key: "rotateTo",
      value: function rotateTo(e) {
        return this._room.actionsHandler.rotateTo(e);
      }
    }, {
      key: "setRayCast",
      value: function setRayCast(e) {
        this.xAvatar && (this.xAvatar.isRayCastEnable = e);
      }
    }, {
      key: "say",
      value: function say(e, t) {
        var _this4 = this;

        if (this.sayTimer && window.clearTimeout(this.sayTimer), !this.xAvatar) {
          logger$1.error("say failed, without instance: xAvatar");
          return;
        }

        this.xAvatar.say(e, {
          scale: this.xAvatar.scale,
          isUser: this.group === AvatarGroup.User
        }), !(t === void 0 || t <= 0) && (this.sayTimer = window.setTimeout(function () {
          _this4.silent();
        }, t));
      }
    }, {
      key: "silent",
      value: function silent() {
        var e;

        if (!this.xAvatar) {
          logger$1.error("silent failed, without instance: xAvatar");
          return;
        }

        (e = this.xAvatar) == null || e.silent();
      }
    }, {
      key: "setMotionType",
      value: function setMotionType(_ref9) {
        var _this5 = this;

        var _ref9$type = _ref9.type,
            e = _ref9$type === void 0 ? MotionType.Walk : _ref9$type;
        return this.motionType === e ? Promise.resolve() : this._room.actionsHandler.setMotionType(e).then(function () {
          _this5._motionType = e;
        });
      }
    }, {
      key: "setNickname",
      value: function setNickname(e) {
        return this._room.actionsHandler.setNickName(encodeURIComponent(e));
      }
    }, {
      key: "_setNickname",
      value: function _setNickname(e) {
        var r, n;
        if (!e) return;
        var t = safeDecodeURIComponent(e);
        ((r = this.xAvatar) == null ? void 0 : r.nickName) !== t && (this.isSelf && (this._room.updateCurrentNetworkOptions({
          nickname: t
        }), this._room.options.nickname = t), (n = this.xAvatar) == null || n.setNickName(t, {
          scale: this.xAvatar.scale
        }));
      }
    }, {
      key: "_move",
      value: function _move(e) {
        var s;

        var _ref10 = e || {},
            t = _ref10.start,
            r = _ref10.end,
            n = _ref10.walkSpeed,
            _ref10$moveAnimation = _ref10.moveAnimation,
            o = _ref10$moveAnimation === void 0 ? "Walking" : _ref10$moveAnimation,
            _ref10$inter = _ref10.inter,
            a = _ref10$inter === void 0 ? [] : _ref10$inter;

        return (s = this.xAvatar) == null ? void 0 : s.move(t, r, n, o, a);
      }
    }, {
      key: "setPickBoxScale",
      value: function setPickBoxScale() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
        return this.xAvatar ? (this.xAvatar.setPickBoxScale(e), !0) : (logger$1.error("setPickBoxScale failed, without instance: xAvatar"), !1);
      }
    }, {
      key: "transfer",
      value: function transfer(e) {
        var t = e.player,
            r = e.camera,
            n = e.areaName,
            o = e.attitude,
            a = e.pathName;
        return this._room.actionsHandler.transfer({
          renderType: RenderType.RotationVideo,
          player: t,
          camera: r,
          areaName: n,
          attitude: o,
          pathName: a,
          tag: "transfer"
        });
      }
    }, {
      key: "avatarLoadedHook",
      value: function avatarLoadedHook() {}
    }, {
      key: "avatarStartMovingHook",
      value: function avatarStartMovingHook() {}
    }, {
      key: "avatarStopMovingHook",
      value: function avatarStopMovingHook() {}
    }, {
      key: "statusSync",
      value: function () {
        var _statusSync = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee8(e) {
          var _this6 = this;

          var t, r, n, _e$event$rotateEvent, o, s, _o, _a3, _s;

          return regenerator.wrap(function _callee8$(_context8) {
            while (1) {
              switch (_context8.prev = _context8.next) {
                case 0:
                  _context8.prev = 0;

                  if (!((t = e.event) != null && t.rotateEvent)) {
                    _context8.next = 10;
                    break;
                  }

                  _e$event$rotateEvent = e.event.rotateEvent, o = _e$event$rotateEvent.angle, s = this.motionType === MotionType.Run ? "Running" : "Walking";
                  _context8.t0 = this.rotation;

                  if (!_context8.t0) {
                    _context8.next = 10;
                    break;
                  }

                  this.rotation.yaw = this.rotation.yaw % 360;
                  o.yaw - this.rotation.yaw > 180 && (o.yaw = 180 - o.yaw);
                  this.isRotating = !0;
                  _context8.next = 10;
                  return this.xAvatar.rotateTo(o, this.rotation, s).then(function () {
                    _this6._playAnimation("Idle", !0), _this6.isRotating = !1;
                  });

                case 10:
                  if (!(e.event && (((r = e.event) == null ? void 0 : r.points.length) || 0) > 1 && !this.isSelf)) {
                    _context8.next = 17;
                    break;
                  }

                  this.isMoving = !0, e.playerState.attitude && (this._motionType = e.playerState.attitude);
                  _o = this.motionType === MotionType.Run ? "Running" : "Walking", _a3 = this._room.skin.routeList.find(function (l) {
                    return l.areaName === _this6._room.currentState.areaName;
                  }), _s = ((_a3 == null ? void 0 : _a3.step) || 7.5) * 30 * (25 / 30);
                  _context8.t1 = this.position;

                  if (!_context8.t1) {
                    _context8.next = 17;
                    break;
                  }

                  _context8.next = 17;
                  return this._move({
                    start: this.position,
                    end: e.event.points[e.event.points.length - 1],
                    walkSpeed: _s,
                    moveAnimation: _o,
                    inter: (n = e.event) == null ? void 0 : n.points.slice(0, -1)
                  }).then(function () {
                    _this6.isMoving = !1;
                  });

                case 17:
                  _context8.next = 22;
                  break;

                case 19:
                  _context8.prev = 19;
                  _context8.t2 = _context8["catch"](0);
                  return _context8.abrupt("return");

                case 22:
                case "end":
                  return _context8.stop();
              }
            }
          }, _callee8, this, [[0, 19]]);
        }));

        function statusSync(_x7) {
          return _statusSync.apply(this, arguments);
        }

        return statusSync;
      }()
    }]);

    return XverseAvatar;
  }(EventEmitter);

  function _createSuper$e(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$e(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$e() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var XverseAvatarManager = /*#__PURE__*/function (_EventEmitter) {
    _inherits(XverseAvatarManager, _EventEmitter);

    var _super = _createSuper$e(XverseAvatarManager);

    function XverseAvatarManager(e) {
      var _this;

      _classCallCheck(this, XverseAvatarManager);

      _this = _super.call(this);
      _this.xAvatarManager = null;
      _this.avatars = new Map();
      _this.syncAvatarsLength = 0;
      _this._room = e;

      _this._usersStatistics();

      _this.broadcast = _this.setupBroadcast();
      e.on("skinChanged", function () {
        _this.avatars.forEach(function (t) {
          t.disconnected && _this.removeAvatar(t.userId, !0);
        });
      });
      return _this;
    }

    _createClass(XverseAvatarManager, [{
      key: "setupBroadcast",
      value: function setupBroadcast() {
        var _this2 = this;

        return new Broadcast$1(this._room, /*#__PURE__*/function () {
          var _ref = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
            var t, r, n, o, a, _r$loop, s, l;

            return regenerator.wrap(function _callee$(_context) {
              while (1) {
                switch (_context.prev = _context.next) {
                  case 0:
                    t = e.broadcastType, r = e.info;

                    if (!(t !== CoreBroadcastType$1.PlayAnimation)) {
                      _context.next = 3;
                      break;
                    }

                    return _context.abrupt("return");

                  case 3:
                    n = r.userId, o = r.animation, a = r.extra, _r$loop = r.loop, s = _r$loop === void 0 ? !1 : _r$loop, l = _this2.avatars.get(n);
                    _context.t0 = l && !l.isSelf;

                    if (!_context.t0) {
                      _context.next = 10;
                      break;
                    }

                    l.emit("animationStart", {
                      animationName: o,
                      extra: decodeURIComponent(a)
                    });
                    _context.next = 9;
                    return l == null ? void 0 : l._playAnimation(o, s);

                  case 9:
                    l.emit("animationEnd", {
                      animationName: o,
                      extra: decodeURIComponent(a)
                    });

                  case 10:
                  case "end":
                    return _context.stop();
                }
              }
            }, _callee);
          }));

          return function (_x) {
            return _ref.apply(this, arguments);
          };
        }());
      }
    }, {
      key: "hideAll",
      value: function hideAll() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : !0;
        this.xAvatarManager.hideAll(e);
      }
    }, {
      key: "showAll",
      value: function showAll() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : !0;
        this.xAvatarManager.showAll(e);
      }
    }, {
      key: "init",
      value: function () {
        var _init = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2() {
          var e, t;
          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  this.xAvatarManager = this._room.sceneManager.avatarComponent;
                  _context2.prev = 1;
                  _context2.next = 4;
                  return this._room.modelManager.getApplicationConfig();

                case 4:
                  e = _context2.sent;
                  t = e.avatars;

                  if (!t) {
                    _context2.next = 10;
                    break;
                  }

                  _context2.next = 9;
                  return avatarLoader.parse(this._room.sceneManager, t);

                case 9:
                  return _context2.abrupt("return");

                case 10:
                  return _context2.abrupt("return", Promise.reject("cannot find avatar config list"));

                case 13:
                  _context2.prev = 13;
                  _context2.t0 = _context2["catch"](1);
                  return _context2.abrupt("return", (logger$1.error(_context2.t0), Promise.reject("avatar mananger init error!")));

                case 16:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this, [[1, 13]]);
        }));

        function init() {
          return _init.apply(this, arguments);
        }

        return init;
      }()
    }, {
      key: "handleAvatar",
      value: function () {
        var _handleAvatar2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(e) {
          var _this3 = this;

          var r, t, n, o, _n, a;

          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  if (!(this._room.viewMode === "simple" || !this._room.joined || !e.newUserStates)) {
                    _context3.next = 2;
                    break;
                  }

                  return _context3.abrupt("return");

                case 2:
                  t = e.newUserStates;

                  if (((r = this._room._userAvatar) == null ? void 0 : r.isMoving) && this._room._userAvatar.motionType === MotionType.Run) {
                    n = t.filter(function (a) {
                      return a.userId === _this3._room.userId;
                    }), o = t.filter(function (a) {
                      return a.userId !== _this3._room.userId;
                    }).slice(0, 2);
                    t = n.concat(o);
                  }

                  if (e.getStateType === GetStateTypes.Event) {
                    this.syncAvatarsLength = (t || []).length;
                    _n = this._room.avatars.filter(function (s) {
                      return s.group == AvatarGroup.User;
                    });

                    _n.filter(function (s) {
                      return !(t != null && t.find(function (l) {
                        return l.userId == s.userId;
                      }));
                    }).forEach(function (s) {
                      _this3.removeAvatar(s.userId);
                    });

                    a = t.filter(function (s) {
                      return !_n.find(function (l) {
                        return l.userId == s.userId;
                      });
                    });

                    this._handleAvatar(a);
                  }

                  this._handleAvatar(t);

                case 6:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, this);
        }));

        function handleAvatar(_x2) {
          return _handleAvatar2.apply(this, arguments);
        }

        return handleAvatar;
      }()
    }, {
      key: "_handleAvatar",
      value: function () {
        var _handleAvatar3 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(e) {
          var _this4 = this;

          return regenerator.wrap(function _callee4$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  e == null || e.forEach(function (t) {
                    var n, o, a, s, l, u, c, h, f;
                    var r = _this4._room.userId === t.userId;

                    if (((n = t.event) == null ? void 0 : n.type) === SyncEventType.ET_RemoveVisitor) {
                      var d = (a = (o = t.event) == null ? void 0 : o.removeVisitorEvent) == null ? void 0 : a.removeVisitorEvent,
                          _ = JSON.parse(safeDecodeURIComponent(((l = (s = t.event) == null ? void 0 : s.removeVisitorEvent) == null ? void 0 : l.extraInfo) || "")),
                          g = _.code,
                          m = _.msg;

                      d === RemoveVisitorType.RVT_ChangeToObserver ? _this4._room.audienceViewModeHook() : d === RemoveVisitorType.RVT_MoveOutOfTheRoom && _this4._room.leave(), _this4._room.emit("visitorStatusChanged", {
                        code: g,
                        msg: m
                      });
                    }

                    if (t.event && [SyncEventType.Appear, SyncEventType.Reset].includes(t.event.type) || !t.event) {
                      var _d = _this4.avatars.get(t.userId);

                      if (t.playerState.avatarId && (_d == null ? void 0 : _d.avatarId) !== t.playerState.avatarId && (_d = void 0, _this4.removeAvatar(t.userId)), _d) {
                        if (_d.disconnected && _d.setConnectionStatus(!1), (u = t.event) != null && u.id && _this4._room.actionsHandler.confirmEvent(t.event.id), t.playerState.nickName && (_d == null || _d._setNickname(t.playerState.nickName)), t.playerState.avatarComponents && !_d.isSelf && _d.xAvatar) {
                          var _2 = safeParseComponents(t.playerState.avatarComponents);

                          _d._changeComponents({
                            avatarComponents: _2,
                            mode: ChangeComponentsMode.Preview
                          });
                        }
                      } else {
                        var _t$playerState$player = t.playerState.player,
                            _3 = _t$playerState$player.position,
                            _g = _t$playerState$player.angle,
                            _m = t.playerState.avatarId,
                            v = t.playerState.prioritySync,
                            y = safelyJsonParse(t.playerState.extra);
                        if (!_m) return;

                        var b = safeParseComponents(t.playerState.avatarComponents),
                            T = safeDecodeURIComponent(t.playerState.nickName),
                            C = _this4.calculatePriority(t.userId, y);

                        _this4.addAvatar({
                          userId: t.userId,
                          isHost: t.playerState.isHost,
                          nickname: T,
                          avatarPosition: _3,
                          avatarRotation: _g,
                          avatarScale: t.playerState.avatarSize,
                          avatarId: _m,
                          avatarComponents: t.playerState.person === Person.First ? [] : b,
                          priority: C,
                          group: AvatarGroup.User,
                          prioritySync: v,
                          extraInfo: y
                        }).then(function () {
                          var A;
                          (A = t.event) != null && A.id && _this4._room.actionsHandler.confirmEvent(t.event.id), _this4.updateAvatarPositionAndRotation(t), r && (_this4.xAvatarManager.setMainAvatar(t.userId), _this4._room.emit("userAvatarLoaded"), logger$1.info("userAvatarLoaded"));
                        }).catch(function (A) {
                          r && (_this4.xAvatarManager.setMainAvatar(t.userId), _this4._room.emit("userAvatarFailed", {
                            error: A
                          }), logger$1.error("userAvatarFailed", A));
                        });
                      }
                    }

                    if (t.event && SyncEventType.Disappear === t.event.type && ((c = t == null ? void 0 : t.event) != null && c.id && _this4._room.actionsHandler.confirmEvent(t.event.id), _this4.removeAvatar(t.userId)), t.event && [SyncEventType.Move, SyncEventType.ChangeRenderInfo].includes(t.event.type) || !t.event) {
                      (h = t == null ? void 0 : t.event) != null && h.id && _this4._room.actionsHandler.confirmEvent(t.event.id);

                      var _d2 = _this4.avatars.get(t.userId);

                      _d2 && _d2.withModel && !_d2.isLoading && _this4.updateAvatarPositionAndRotation(t);
                    }

                    if (!r && ((f = t.event) == null ? void 0 : f.type) === SyncEventType.Rotate) {
                      var _d3 = _this4.avatars.get(t.userId);

                      _d3.statusSyncQueue.append({
                        type: QueueType.Rotate,
                        action: function action() {
                          return _d3.statusSync(t);
                        }
                      });
                    }
                  });

                case 1:
                case "end":
                  return _context4.stop();
              }
            }
          }, _callee4);
        }));

        function _handleAvatar(_x3) {
          return _handleAvatar3.apply(this, arguments);
        }

        return _handleAvatar;
      }()
    }, {
      key: "calculatePriority",
      value: function calculatePriority(e, t) {
        var n;
        return e === this._room.userId ? EAvatarRelationRank.Self : (n = this._room.options.firends) != null && n.includes(e) ? EAvatarRelationRank.Friend : EAvatarRelationRank.Stranger;
      }
    }, {
      key: "updateAvatarPositionAndRotation",
      value: function updateAvatarPositionAndRotation(e) {
        var t, r;

        if ((t = e == null ? void 0 : e.playerState) != null && t.player) {
          var _e$playerState$player = e.playerState.player,
              n = _e$playerState$player.position,
              o = _e$playerState$player.angle;
          var a = this.avatars.get(e.userId);
          if (!a) return;

          if (n = positionPrecisionProtect(n), o = rotationPrecisionProtect(o), a.isSelf && !this._room.networkController.rtcp.workers.inPanoMode && (a.setPosition(n), a.setRotation(o)), e.event && (((r = e.event) == null ? void 0 : r.points.length) || 0) > 1 && !a.isSelf && a.statusSyncQueue.append({
            type: QueueType.Move,
            action: function action() {
              return a.statusSync(e);
            }
          }), e.renderInfo && a.isSelf) {
            var _e$renderInfo = e.renderInfo,
                s = _e$renderInfo.isMoving,
                l = _e$renderInfo.isRotating;

            this._updateAvatarMovingStatus({
              id: e.userId,
              isMoving: !!s,
              isRotating: !!l
            });
          }
        }
      }
    }, {
      key: "addAvatar",
      value: function () {
        var _addAvatar = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5(e) {
          var t, r, n, o, a, s, _e$avatarComponents, l, u, _e$group, c, _e$avatarScale, h, f, d, _, g, v, y, b, T, C;

          return regenerator.wrap(function _callee5$(_context5) {
            while (1) {
              switch (_context5.prev = _context5.next) {
                case 0:
                  t = e.userId, r = e.isHost, n = e.avatarPosition, o = e.avatarId, a = e.avatarRotation, s = e.nickname, _e$avatarComponents = e.avatarComponents, l = _e$avatarComponents === void 0 ? [] : _e$avatarComponents, u = e.priority, _e$group = e.group, c = _e$group === void 0 ? AvatarGroup.Npc : _e$group, _e$avatarScale = e.avatarScale, h = _e$avatarScale === void 0 ? DEFAULT_AVATAR_SCALE : _e$avatarScale, f = e.extraInfo, d = e.prioritySync, _ = t === this._room.userId;
                  g = this.avatars.get(t);

                  if (!g) {
                    _context5.next = 4;
                    break;
                  }

                  return _context5.abrupt("return", Promise.resolve(g));

                case 4:
                  if (!(g = new XverseAvatarManager.subAvatar({
                    userId: t,
                    isHost: r,
                    isSelf: _,
                    room: this._room,
                    avatarComponents: l,
                    avatarId: o,
                    nickname: s,
                    group: c
                  }), this.avatars.set(t, g), !g.withModel)) {
                    _context5.next = 6;
                    break;
                  }

                  return _context5.abrupt("return", (g.isLoading = !1, g.avatarLoadedHook(), this._room.emit("avatarChanged", {
                    avatars: this._room.avatars
                  }), g));

                case 6:
                  _context5.next = 8;
                  return this._room.modelManager.getAvatarModelList();

                case 8:
                  v = _context5.sent.find(function (b) {
                    return b.id === o;
                  });
                  y = Date.now();

                  if (v) {
                    _context5.next = 12;
                    break;
                  }

                  return _context5.abrupt("return", (this._room.emit("avatarChanged", {
                    avatars: this._room.avatars
                  }), this.avatars.delete(t), Promise.reject("no such avatar model with id: ".concat(o))));

                case 12:
                  _context5.prev = 12;
                  _context5.next = 15;
                  return avatarComponentsModify(v, l);

                case 15:
                  b = _context5.sent;
                  b = b.filter(function (A) {
                    return A.type != "pendant";
                  });
                  _context5.next = 19;
                  return avatarComponentsParser(v, b);

                case 19:
                  T = _context5.sent;
                  _context5.next = 22;
                  return this.xAvatarManager.loadAvatar({
                    id: t,
                    avatarType: o,
                    priority: u,
                    avatarManager: this.xAvatarManager,
                    assets: T,
                    status: {
                      avatarPosition: n,
                      avatarRotation: a,
                      avatarScale: h
                    }
                  })._timeout(8e3, new TimeoutError("loadAvatar timeout(8s)"));

                case 22:
                  C = _context5.sent;
                  return _context5.abrupt("return", (C.setPickBoxScale(t === this._room.userId ? 0 : 1), g.xAvatar = C, g.setScale(h), g.extraInfo = f, g.priority = u, g.isLoading = !1, g.prioritySync = !!d, g._playAnimation("Idle", !0, !0), g.avatarLoadedHook(), this._room.emit("avatarChanged", {
                    avatars: this._room.avatars
                  }), s && g._setNickname(s), t === this._room.userId && (logger$1.infoAndReportMeasurement({
                    metric: "avatarLoadDuration",
                    startTime: y,
                    group: "costs"
                  }), logger$1.infoAndReportMeasurement({
                    metric: "avatarLoadAt",
                    startTime: this._room._startTime,
                    group: "costs"
                  })), g));

                case 26:
                  _context5.prev = 26;
                  _context5.t0 = _context5["catch"](12);
                  return _context5.abrupt("return", (g.isLoading = !1, this._room.emit("avatarChanged", {
                    avatars: this._room.avatars
                  }), logger$1.error(_context5.t0), Promise.reject(_context5.t0)));

                case 29:
                case "end":
                  return _context5.stop();
              }
            }
          }, _callee5, this, [[12, 26]]);
        }));

        function addAvatar(_x4) {
          return _addAvatar.apply(this, arguments);
        }

        return addAvatar;
      }()
    }, {
      key: "removeAvatar",
      value: function removeAvatar(e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
        var r = this.avatars.get(e);

        if (!!r) {
          if (r.removeWhenDisconnected || t) {
            r.xAvatar && this.xAvatarManager.deleteAvatar(r.xAvatar), this.avatars.delete(e), this._room.emit("avatarChanged", {
              avatars: this._room.avatars
            });
            return;
          }

          r.setConnectionStatus(!0);
        }
      }
    }, {
      key: "clearOtherUsers",
      value: function clearOtherUsers() {
        var _this5 = this;

        this.avatars.forEach(function (e) {
          !e.isSelf && e.group === AvatarGroup.User && _this5.removeAvatar(e.userId);
        });
      }
    }, {
      key: "_updateAvatarMovingStatus",
      value: function () {
        var _updateAvatarMovingStatus2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee6(e) {
          var t, r, n, o, a, _a;

          return regenerator.wrap(function _callee6$(_context6) {
            while (1) {
              switch (_context6.prev = _context6.next) {
                case 0:
                  t = e.id, r = e.isMoving, n = e.isRotating, o = this.avatars.get(t);

                  if (!!o) {
                    if (o.isRotating !== n) {
                      o.isRotating = n;
                      a = "Idle";
                      n && (a = "Walking", o.motionType === MotionType.Run && (a = "Running")), o._playAnimation(a, !0, !0), logger$1.infoAndReportMeasurement({
                        startTime: Date.now(),
                        value: 0,
                        metric: n ? "userAvatarStartRotating" : "userAvatarStopRotating",
                        extra: {
                          motionType: o.motionType,
                          moveToExtra: this._room.moveToExtra
                        }
                      });
                    }

                    if (o.isMoving !== r) {
                      o.isMoving = r;
                      _a = "Idle";
                      r && (_a = "Walking", o.motionType === MotionType.Run && (_a = "Running")), r ? (o.avatarStartMovingHook(), o.emit("startMoving", {
                        target: o,
                        extra: this._room.moveToExtra
                      })) : (o.avatarStopMovingHook(), o.emit("stopMoving", {
                        target: o,
                        extra: this._room.moveToExtra
                      })), o._playAnimation(_a, !0, !0), logger$1.infoAndReportMeasurement({
                        startTime: Date.now(),
                        value: 0,
                        metric: r ? "userAvatarStartMoving" : "userAvatarStopMoving",
                        extra: {
                          motionType: o.motionType,
                          moveToExtra: this._room.moveToExtra
                        }
                      });
                    }
                  }

                case 2:
                case "end":
                  return _context6.stop();
              }
            }
          }, _callee6, this);
        }));

        function _updateAvatarMovingStatus(_x5) {
          return _updateAvatarMovingStatus2.apply(this, arguments);
        }

        return _updateAvatarMovingStatus;
      }()
    }, {
      key: "_usersStatistics",
      value: function _usersStatistics() {
        var _this6 = this;

        this.on("userAvatarLoaded", function () {
          window.setInterval(function () {
            var e = _this6._room.avatars.filter(function (r) {
              return r.group === AvatarGroup.User;
            }).length || 0,
                t = _this6._room.avatars.filter(function (r) {
              return r.group === AvatarGroup.User && r.isRender;
            }).length || 0;

            _this6._room.stats.assign({
              userNum: e,
              syncUserNum: _this6.syncAvatarsLength,
              renderedUserNum: t
            });
          }, 3e3);
        });
      }
    }]);

    return XverseAvatarManager;
  }(EventEmitter);
  E(XverseAvatarManager, "subAvatar", XverseAvatar);

  var PathManager = /*#__PURE__*/function () {
    function PathManager() {
      _classCallCheck(this, PathManager);

      this.currentArea = '';
      this.currentPathName = '';
      this.currentAttitude = '';
      this.speed = 0;
    }

    _createClass(PathManager, [{
      key: "getSpeed",
      value: function getSpeed(e) {
        var t = {
          guangchang: {
            [MotionType.Walk]: 17,
            [MotionType.Run]: 51
          },
          tower: {
            [MotionType.Walk]: 12.5,
            [MotionType.Run]: 25
          },
          zhiboting: {
            [MotionType.Walk]: 12.5,
            [MotionType.Run]: 25
          },
          youxiting: {
            [MotionType.Walk]: 12.5,
            [MotionType.Run]: 25
          },
          diqing: {
            [MotionType.Walk]: 12.5,
            [MotionType.Run]: 25
          }
        },
            r = t[this.currentArea] || t.guangchang;
        return this.speed = r[e] * 30, this.speed;
      }
    }]);

    return PathManager;
  }();

  var CameraStates = {
    Normal: 0,
    ItemView: 1,
    CGView: 2,
    PathView: 3
  };

  var EImageQuality = {
    low: 0,
    mid: 1,
    high: 2
  };

  var Actions = {
    Clicking: 1,
    PlayCG: 6,
    Back: 7,
    ChangeRoom: 8,
    ChangeSkin: 13,
    Joystick: 15,
    Transfer: 18,
    GetOnVehicle: 22,
    GetOffVehicle: 23,
    StopMoving: 34,
    UnaryActionLine: 1e3,
    Init: 1001,
    Exit: 1002,
    SetIFrameInfo: 1003,
    GetNeighborPoints: 1004,
    ReserveSeat: 1005,
    GetReserveStatus: 1006,
    ChangeNickname: 1007,
    ChangeBitRateInfo: 1008,
    Echo: 1009,
    SetPlayerState: 1010,
    TurnTo: 1011,
    TurnToFace: 1012,
    RotateTo: 1013,
    Rotation: 1014,
    CameraTurnTo: 1015,
    ConfirmEvent: 1016,
    Broadcast: 1017,
    NotifyActionLine: 2e4,
    AudienceChangeToVisitor: 1020,
    VisitorChangeToAudience: 1021,
    RemoveVisitor: 1022,
    GetUserWithAvatar: 1023
  };

  function _createSuper$d(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$d(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$d() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var Camera = /*#__PURE__*/function (_EventEmitter) {
    _inherits(Camera, _EventEmitter);

    var _super = _createSuper$d(Camera);

    function Camera(e) {
      var _this;

      _classCallCheck(this, Camera);

      _this = _super.call(this);
      _this.initialFov = 0;
      _this._state = CameraStates.Normal;
      _this._person = Person.Third;
      _this._cameraFollowing = !0;
      _this._room = e;
      return _this;
    }

    _createClass(Camera, [{
      key: "checkPointOnLeftOrRight",
      value: function checkPointOnLeftOrRight(e) {
        var t = ue4Position2Xverse(e);
        if (!t || this.checkPointInView(e)) return;
        var o = this._room.scene.activeCamera;
        if (!o) return;
        var a = [o.target.x, o.target.y, o.target.z],
            s = [o.position.x, o.position.y, o.position.z],
            l = t.x,
            u = t.y,
            c = t.z,
            h = calNormVector(s, a),
            f = calNormVector(s, [l, u, c]);
        return vectorCrossMulti(h, f) < 0 ? Direction.Right : Direction.Left;
      }
    }, {
      key: "checkPointInView",
      value: function checkPointInView(e, t, r) {
        var n = ue4Position2Xverse({
          x: e,
          y: t,
          z: r
        });
        if (!n) return !1;

        for (var o = 0; o < 6; o++) {
          if (this._room.scene.frustumPlanes[o].dotCoordinate(n) < 0) return !1;
        }

        return !0;
      }
    }, {
      key: "person",
      get: function get() {
        return this._person;
      }
    }, {
      key: "state",
      get: function get() {
        return this._state;
      }
    }, {
      key: "pose",
      get: function get() {
        return this._room.currentClickingState.camera;
      }
    }, {
      key: "cameraFollowing",
      get: function get() {
        return this._cameraFollowing;
      },
      set: function set(e) {
        logger$1.info("cameraFollowing setter", e), this.setCameraFollowing({
          isFollowHost: e
        });
      }
    }, {
      key: "setCameraFollowing",
      value: function setCameraFollowing(_ref) {
        _ref.isFollowHost;
      }
    }, {
      key: "handleRenderInfo",
      value: function handleRenderInfo(e) {
        var t = e.renderInfo.cameraStateType,
            r = this._room.sceneManager;
        if (t !== this._state && (this._state = t, logger$1.debug("camera._state changed to", CameraStates[t]), t === CameraStates.CGView ? (r.cameraComponent.switchToCgCamera(), r.staticmeshComponent.getCgMesh().show()) : (r.cameraComponent.switchToMainCamera(), r.staticmeshComponent.getCgMesh().hide()), this.emit("stateChanged", {
          state: t
        })), this._room.isHost) return;
        var n = e.playerState.isFollowHost;
        !!n !== this._cameraFollowing && (this._cameraFollowing = !!n, this.emit("cameraFollowingChanged", {
          cameraFollowing: !!n
        }));
      }
    }, {
      key: "setCameraState",
      value: function setCameraState(_ref2) {
        var e = _ref2.state;

        if (this._state === e) {
          logger$1.warn("You are already in ".concat(CameraStates[e], " camera state"));
          return;
        }

        e === CameraStates.Normal || this._state === CameraStates.ItemView && logger$1.warn("CloseUp camera state can only be triggerd by room internally");
      }
    }, {
      key: "turnToFace",
      value: function turnToFace(_ref3) {
        var _ref3$extra = _ref3.extra,
            e = _ref3$extra === void 0 ? "" : _ref3$extra,
            _ref3$offset = _ref3.offset,
            t = _ref3$offset === void 0 ? 0 : _ref3$offset;
        var r = {
          action_type: Actions.TurnToFace,
          turn_to_face_action: {
            offset: t
          }
        };
        return this.emit("viewChanged", {
          extra: e
        }), this._room.actionsHandler.sendData({
          data: r
        });
      }
    }, {
      key: "isInDefaultView",
      value: function isInDefaultView() {
        if (!this._room.isHost) {
          logger$1.warn("It is recommended to call the function on the host side");
          return;
        }

        if (!this._room._currentClickingState) return logger$1.error("CurrentState should not be empty"), !1;
        var _this$_room$_currentC = this._room._currentClickingState,
            e = _this$_room$_currentC.camera,
            t = _this$_room$_currentC.player;
        return Math.abs(t.angle.yaw - 180 - e.angle.yaw) % 360 <= 4;
      }
    }, {
      key: "screenShot",
      value: function () {
        var _screenShot = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(_ref4) {
          var e, _ref4$autoSave, t, r, n, o;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  e = _ref4.name, _ref4$autoSave = _ref4.autoSave, t = _ref4$autoSave === void 0 ? !1 : _ref4$autoSave;
                  r = this._room.scene.getEngine(), n = this._room.scene.activeCamera;
                  _context.prev = 2;

                  this._room.sceneManager.setImageQuality(EImageQuality.high);

                  _context.next = 6;
                  return CreateScreenshotAsync(r, n, {
                    precision: 1
                  });

                case 6:
                  o = _context.sent;
                  return _context.abrupt("return", (this._room.sceneManager.setImageQuality(EImageQuality.low), t === !0 && downloadFileByBase64(o, e), Promise.resolve(o)));

                case 10:
                  _context.prev = 10;
                  _context.t0 = _context["catch"](2);
                  return _context.abrupt("return", (this._room.sceneManager.setImageQuality(EImageQuality.low), Promise.reject(_context.t0)));

                case 13:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this, [[2, 10]]);
        }));

        function screenShot(_x) {
          return _screenShot.apply(this, arguments);
        }

        return screenShot;
      }()
    }, {
      key: "changeToFirstPerson",
      value: function changeToFirstPerson(e, t, r) {
        var _this2 = this;

        var n = e.camera,
            o = e.player,
            a = e.attitude,
            s = e.areaName,
            l = e.pathName;
        return this._room.actionsHandler.requestPanorama({
          camera: n,
          player: o,
          attitude: a,
          areaName: s,
          pathName: l
        }, t, r).then(function () {
          _this2._room.networkController.rtcp.workers.changePanoMode(!0);

          var _ref5 = o || {},
              u = _ref5.position,
              c = _ref5.angle;

          _this2._room.sceneManager.cameraComponent.changeToFirstPersonView({
            position: u,
            rotation: c
          });
        });
      }
    }, {
      key: "setPerson",
      value: function setPerson(e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
          camera: this._room._currentClickingState.camera,
          player: this._room._currentClickingState.player
        };
        var r = Date.now();
        return this._setPerson(e, t).then(function (n) {
          return logger$1.infoAndReportMeasurement({
            tag: Person[e],
            startTime: r,
            metric: "setPerson"
          }), n;
        }).catch(function (n) {
          return logger$1.infoAndReportMeasurement({
            tag: Person[e],
            startTime: r,
            metric: "setPerson",
            error: n
          }), Promise.reject(n);
        });
      }
    }, {
      key: "_setPerson",
      value: function _setPerson(e) {
        var _this3 = this;

        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
          camera: this._room._currentClickingState.camera,
          player: this._room._currentClickingState.player
        };
        return e !== Person.First && e !== Person.Third ? Promise.reject("invalid person " + e) : !t.camera || !t.player ? Promise.reject(new ParamError("wrong camera or player")) : e === Person.First ? this._room.panorama.access({
          camera: t.camera,
          player: t.player,
          tag: "setPerson"
        }).then(function () {
          var o, a;
          _this3._person = e, (o = _this3._room._userAvatar) == null || o.hide();

          var _ref6 = ((a = _this3._room.currentClickingState) == null ? void 0 : a.camera) || {},
              r = _ref6.position,
              n = _ref6.angle;

          !r || !n || _this3._room.sceneManager.cameraComponent.changeToFirstPersonView({
            position: r,
            rotation: n
          });
        }) : this._room.panorama.exit({
          camera: t.camera,
          player: t.player
        }).then(function () {
          var r, n;
          _this3._person = e, (r = _this3._room._userAvatar) != null && r.xAvatar && ((n = _this3._room._userAvatar) == null || n.xAvatar.show());
        });
      }
    }, {
      key: "setCameraPose",
      value: function setCameraPose(e) {
        this._room.sceneManager.cameraComponent.setCameraPose({
          position: e.position,
          rotation: e.angle
        });
      }
    }, {
      key: "setMainCameraRotationLimit",
      value: function setMainCameraRotationLimit(e) {
        var t = e.limitAxis,
            r = e.limitRotation;

        this._room.sceneManager.cameraComponent.setMainCameraRotationLimit(t, r);
      }
    }]);

    return Camera;
  }(EventEmitter);

  function _createSuper$c(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$c(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$c() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var numberFormat = new Intl.NumberFormat(window.navigator.language, {
    maximumFractionDigits: 0
  });

  var Stats = /*#__PURE__*/function (_EventEmitter) {
    _inherits(Stats, _EventEmitter);

    var _super = _createSuper$c(Stats);

    function Stats(e) {
      var _this;

      _classCallCheck(this, Stats);

      _this = _super.call(this);
      _this._netInterval = null;
      _this._disabled = !1;
      _this._show = !1;
      _this._aggregatedStats = {};
      _this._displayElement = null;
      _this._extraStats = {};
      _this._networkSamples = [];
      _this.externalStats = null;
      _this.constructedTime = null;
      _this.room = e, _this.constructedTime = Date.now(), _this._interval = window.setInterval(function () {
        var t, r, n;
        _this._disabled || _this.onStats((n = (r = (t = e.networkController) == null ? void 0 : t.rtcp) == null ? void 0 : r.workers) == null ? void 0 : n.uploadDataToServer());
      }, 1e3), _this._netInterval = window.setInterval(function () {
        _this.getIsWeakNet();
      }, NET_INTERVAL * 1e3);
      return _this;
    }

    _createClass(Stats, [{
      key: "isShow",
      get: function get() {
        return this._show;
      }
    }, {
      key: "assign",
      value: function assign(e) {
        Object.assign(this._extraStats, e), ((e == null ? void 0 : e.hb) || (e == null ? void 0 : e.rtt)) && this.startStatsNetSamples();
      }
    }, {
      key: "appendExternalStats",
      value: function appendExternalStats(e) {
        var _this2 = this;

        var t = {};

        if (!e || typeof e != "object") {
          console.warn("appendExternalStats should be plain object");
          return;
        }

        Object.keys(e).forEach(function (r) {
          Object.prototype.hasOwnProperty.call(_this2._aggregatedStats, r) ? console.warn("".concat(r, " is duplicate with internal stats")) : t[r] = e[r];
        }), !(Object.keys(t).length > 10) && (this.externalStats = t);
      }
    }, {
      key: "getRtt",
      value: function getRtt() {
        var e = this._extraStats.rtt;
        return typeof e != "number" ? 0 : e > 999 ? 999 : e;
      }
    }, {
      key: "enable",
      value: function enable() {
        this._disabled = !1;
      }
    }, {
      key: "disable",
      value: function disable() {
        this._disabled = !0;
      }
    }, {
      key: "disableNet",
      value: function disableNet() {
        this._netInterval && window.clearInterval(this._netInterval);
      }
    }, {
      key: "show",
      value: function show() {
        this._show = !0, this._render();
      }
    }, {
      key: "hide",
      value: function hide() {
        this._show = !1, this._displayElement && document.body.removeChild(this._displayElement), this._displayElement = null;
      }
    }, {
      key: "getIsWeakNet",
      value: function getIsWeakNet() {
        var _this3 = this;

        var e = !1;
        var t = this._networkSamples.length - 1;
        if (t < 0) return;
        var r = this._networkSamples[t].time,
            n = this._networkSamples[0].time,
            o = r - n,
            a = 1e3 * (DURATION - 2);
        if (o < a) return;

        var s = this._networkSamples.map(function (g) {
          return _this3.isNetDelay(g, "rtt");
        }),
            l = this._networkSamples.map(function (g) {
          return _this3.isNetDelay(g, "hb");
        }),
            u = s.reduce(function (g, m) {
          return g + m;
        }, 0),
            c = l.reduce(function (g, m) {
          return g + m;
        }, 0),
            h = Math.floor(u / this._networkSamples.length) * 100,
            f = Math.floor(c / this._networkSamples.length) * 100,
            d = 70;

        (h >= d || f >= d) && (e = !0);

        var _ = this.room.viewMode === "observer" || this.room.viewMode === "serverless";

        e && !_ && (logger$1.infoAndReportMeasurement({
          metric: "weakNetwork",
          startTime: Date.now(),
          extra: {
            msg: this._networkSamples.slice(20),
            netDelayRTTValues: u,
            netDelayHBValues: c
          }
        }), this.emit("weakNetwork"));
      }
    }, {
      key: "startStatsNetSamples",
      value: function startStatsNetSamples() {
        var _this$_extraStats = this._extraStats,
            e = _this$_extraStats.rtt,
            t = _this$_extraStats.hb;

        if (e || t) {
          var r = {
            rtt: e,
            hb: t,
            time: new Date().getTime()
          };

          this._networkSamples.push(r);

          var n = this._networkSamples.length - 1;
          if (n < 0) return;
          var o = this._networkSamples[n].time,
              a = 1e3 * DURATION;
          this._networkSamples = this._networkSamples.filter(function (s) {
            return s.time > o - a;
          });
        }
      }
    }, {
      key: "isNetDelay",
      value: function isNetDelay(e, t) {
        return t === "rtt" ? e.rtt > RTT_MAX_VALUE ? 1 : 0 : t === "hb" && e.hb > HB_MAX_VALUE ? 1 : 0;
      }
    }, {
      key: "getPreciesTimer",
      value: function getPreciesTimer(e, t) {
        var r = t * 1e3,
            n = new Date().getTime();
        var o = 0;
        o++;
        var a = new Date().getTime() - (n + o * 1e3),
            s = r - a,
            l = setTimeout(function () {
          clearTimeout(l), e();
        }, s);
      }
    }, {
      key: "_render",
      value: function _render() {
        var c, h, f, d, _, g, m, v, y, b, T, C, A, S, P, R, M, x, I, w;

        if (!this._aggregatedStats) return;
        this._displayElement || (this._displayElement = document.createElement("div"), this._displayElement.style.position = "absolute", this._displayElement.style.top = "10px", this._displayElement.style.left = "200px", this._displayElement.style.width = "200px", this._displayElement.style.backgroundColor = "rgba(0,0,0,.5)", this._displayElement.style.color = "white", this._displayElement.style.textAlign = "left", this._displayElement.style.fontSize = "8px", this._displayElement.style.lineHeight = "10px", document.body.appendChild(this._displayElement));
        var e = [],
            t = Date.now() - this.constructedTime,
            r = Math.floor(t / 1e3 % 60),
            n = Math.floor(t / (1e3 * 60) % 60),
            o = Math.floor(t / (1e3 * 60 * 60) % 24),
            a = o < 10 ? "0" + o.toString() : o.toString(),
            s = n < 10 ? "0" + n : n,
            l = r < 10 ? "0" + r : r;
        e.push({
          key: new Date(Math.floor(this._aggregatedStats.timestamp || 0)).toLocaleString("en-GB"),
          value: a + ":" + s + ":" + l
        }), e.push({
          key: "rtt: " + this._extraStats.rtt + " hb: " + this._extraStats.hb,
          value: "FPS: " + this._extraStats.fps + " avatar: " + ((c = this.room._userAvatar) == null ? void 0 : c.state)
        }), e.push({
          key: "SDK: " + Xverse$1.SUB_PACKAGE_VERSION,
          value: "ENGINE:" + VERSION$1 + " uid:" + this._extraStats.userId
        }), e.push({
          key: "\u540C\u6B65/\u6709\u6548/\u663E\u793A\u73A9\u5BB6",
          value: "".concat(this._extraStats.syncUserNum || 0, "/").concat(this._extraStats.userNum || 0, "/").concat(this._extraStats.renderedUserNum || 0)
        }), e.push({
          key: "media/meta bitrate(kbps)",
          value: numberFormat.format(this._aggregatedStats.mediaBitrate || 0) + "/" + numberFormat.format(this._aggregatedStats.metaBitrate || 0)
        }), e.push({
          key: ":----------------Decoding---------------",
          value: ""
        }), e.push({
          key: "-max/avg decodeTime(ms)",
          value: numberFormat.format(this._aggregatedStats.decodeTimeMaxFrame || 0) + "/" + numberFormat.format(this._aggregatedStats.decodeTimePerFrame || 0)
        }), e.push({
          key: "-frmAwait/Lost/Drop",
          value: numberFormat.format(this._aggregatedStats.framesAwait || 0) + "/" + numberFormat.format(this._aggregatedStats.packetsLost || 0) + "/" + numberFormat.format(this._aggregatedStats.packetsDrop || 0) + "/" + numberFormat.format(this._aggregatedStats.updateDropFrame) || 0
        }), e.push({
          key: ":----------------FrameLoop-------------",
          value: ""
        }), e.push({
          key: "interval(max/avg/>40)",
          value: (((h = this._extraStats.maxFrameTime) == null ? void 0 : h.toFixed(1)) || 0) + "/" + (((f = this._extraStats.avgFrameTime) == null ? void 0 : f.toFixed(0)) || 0) + "/" + this._extraStats.engineSloppyCnt
        }), e.push({
          key: "systemStuck",
          value: this._extraStats.systemStuckCnt
        }), e.push({
          key: "--update",
          value: (this._aggregatedStats.maxGraphicTime.toFixed(1) || 0) + "/" + (((d = this._aggregatedStats.averageGraphicTime) == null ? void 0 : d.toFixed(0)) || 0)
        }), e.push({
          key: "--timeout",
          value: (((_ = this._extraStats.maxTimeoutTime) == null ? void 0 : _.toFixed(1)) || 0) + "/" + ((g = this._extraStats.avgTimeoutTime) == null ? void 0 : g.toFixed(0)) || 0
        }), e.push({
          key: "--render",
          value: (((m = this._extraStats.maxRenderFrameTime) == null ? void 0 : m.toFixed(1)) || 0) + "/" + (((v = this._extraStats.renderFrameTime) == null ? void 0 : v.toFixed(0)) || 0)
        }), e.push({
          key: "---anim/regBR/clip(avg ms)",
          value: (this._extraStats.animationTime.toFixed(2) || 0) + " / " + (this._extraStats.registerBeforeRenderTime.toFixed(2) || 0) + " / " + (this._extraStats.meshSelectTime.toFixed(2) || 0)
        }), e.push({
          key: "---anim/regBR/clip(max ms)",
          value: (this._extraStats.maxAnimationTime.toFixed(2) || 0) + " / " + (this._extraStats.maxRegisterBeforeRenderTime.toFixed(2) || 0) + " / " + (this._extraStats.maxMeshSelectTime.toFixed(2) || 0)
        }), e.push({
          key: "---rTR/drC/regAF(avg ms)",
          value: (this._extraStats.renderTargetRenderTime.toFixed(2) || 0) + " / " + (this._extraStats.drawcallTime.toFixed(2) || 0) + " / " + (this._extraStats.registerAfterRenderTime.toFixed(2) || 0)
        }), e.push({
          key: "---rTR/drC/regAF(max ms)",
          value: (this._extraStats.maxRenderTargetRenderTime.toFixed(2) || 0) + " / " + (this._extraStats.maxDrawcallTime.toFixed(2) || 0) + " / " + (this._extraStats.maxRegisterAfterRenderTime.toFixed(2) || 0)
        }), e.push({
          key: "--tri/drC/pati/bones/anim(Num)",
          value: (this._extraStats.triangle || 0) + " / " + (this._extraStats.drawcall.toFixed(0) || 0) + " / " + (this._extraStats.activeParticles.toFixed(0) || 0) + " / " + (this._extraStats.activeBones.toFixed(0) || 0) + " / " + (this._extraStats.activeAnimation.toFixed(0) || 0)
        }), e.push({
          key: "--rootN/mesh/geo/tex/mat(Num)",
          value: (this._extraStats.totalRootNodes.toFixed(0) || 0) + " / " + (this._extraStats.totalMeshes.toFixed(0) || 0) + " / " + (this._extraStats.totalGeometries.toFixed(0) || 0) + " / " + (this._extraStats.totalTextures.toFixed(0) || 0) + " / " + (this._extraStats.totalMaterials.toFixed(0) || 0)
        }), e.push({
          key: "--registerBF/AF(Num)",
          value: (this._extraStats.registerBeforeCount.toFixed(0) || 0) + " / " + (this._extraStats.registerAfterCount.toFixed(0) || 0)
        }), e.push({
          key: ":----------------Rotation-------------------",
          value: ""
        }), e.push({
          key: "Total(ms/miss)",
          value: (((y = this._aggregatedStats.avgOverallTime) == null ? void 0 : y.toFixed(2)) || 0) + "/" + (this._aggregatedStats.responseMissPs + this._aggregatedStats.processMissPs + this._aggregatedStats.displayMissPs)
        }), e.push({
          key: "--rotateRsp",
          value: (((b = this._aggregatedStats.avgResponseTime) == null ? void 0 : b.toFixed(1)) || 0) + "/" + this._aggregatedStats.responseMissPs
        }), e.push({
          key: "--rotateProc",
          value: (((T = this._aggregatedStats.avgProcessTime) == null ? void 0 : T.toFixed(1)) || 0) + "/" + this._aggregatedStats.processMissPs
        }), e.push({
          key: "--rotateShow",
          value: (((C = this._aggregatedStats.avgDisplayTime) == null ? void 0 : C.toFixed(1)) || 0) + "/" + this._aggregatedStats.displayMissPs
        }), ((A = this.room._userAvatar) == null ? void 0 : A.state) == "moving", e.push({
          key: ":----------------Move----------------------",
          value: ""
        }), e.push({
          key: "-startDelay",
          value: (this._aggregatedStats.moveEvent == "MoveTo" ? this._aggregatedStats.moveResponseDelay || 0 : this._aggregatedStats.flyResponseDelay || 0) + "/" + (this._aggregatedStats.moveEvent == "MoveTo" ? this._aggregatedStats.moveProcessDelay || 0 : this._aggregatedStats.flyProcessDelay || 0) + "/" + (this._aggregatedStats.moveEvent == "MoveTo" ? this._aggregatedStats.moveDisplayDelay || 0 : this._aggregatedStats.flyDisplayDelay || 0)
        }), (((S = this.room._userAvatar) == null ? void 0 : S.state) == "moving" || this._aggregatedStats.moveEvent == "GetOnAirship" || this._aggregatedStats.moveEvent == "GetOnVehicle") && e.push({
          key: "-srvInterFrm(max/avg)",
          value: (this._aggregatedStats.maxServerDiff || 0) + "/" + (this._aggregatedStats.avgServerDiff.toFixed(1) || 0)
        }), e.push({
          key: "-interFrameDelay",
          value: "(max/avg/jank)"
        }), e.push({
          key: "--toDisplay",
          value: (this._aggregatedStats.moveEvent == "MoveTo" ? this._aggregatedStats.maxDisplayMoveDiff || 0 : this._aggregatedStats.maxDisplayFlyDiff || 0) + "/" + (this._aggregatedStats.moveEvent == "MoveTo" ? this._aggregatedStats.avgDisplayMoveDiff.toFixed(1) || 0 : this._aggregatedStats.avgDisplayFlyDiff.toFixed(1) || 0) + "/" + (this._aggregatedStats.moveEvent == "MoveTo" ? ((P = this._aggregatedStats.moveDisplayJank) == null ? void 0 : P.toFixed(3)) || 0 : ((R = this._aggregatedStats.flyDisplayJank) == null ? void 0 : R.toFixed(3)) || 0)
        }), e.push({
          key: "--received",
          value: (this._aggregatedStats.moveEvent == "MoveTo" ? this._aggregatedStats.maxResponseMoveDiff || 0 : this._aggregatedStats.maxResponseFlyDiff || 0) + "/" + (this._aggregatedStats.moveEvent == "MoveTo" ? this._aggregatedStats.avgResponseMoveDiff.toFixed(1) || 0 : this._aggregatedStats.avgResponseFlyDiff.toFixed(1) || 0) + "/" + (this._aggregatedStats.moveEvent == "MoveTo" ? ((M = this._aggregatedStats.moveResponseJank) == null ? void 0 : M.toFixed(3)) || 0 : ((x = this._aggregatedStats.flyResponseJank) == null ? void 0 : x.toFixed(3)) || 0)
        }), e.push({
          key: "--decoded",
          value: (this._aggregatedStats.moveEvent == "MoveTo" ? this._aggregatedStats.maxProcessMoveDiff || 0 : this._aggregatedStats.maxProcessFlyDiff || 0) + "/" + (this._aggregatedStats.moveEvent == "MoveTo" ? this._aggregatedStats.avgProcessMoveDiff.toFixed(1) || 0 : this._aggregatedStats.avgProcessFlyDiff.toFixed(1) || 0) + "/" + (this._aggregatedStats.moveEvent == "MoveTo" ? ((I = this._aggregatedStats.moveProcessJank) == null ? void 0 : I.toFixed(3)) || 0 : ((w = this._aggregatedStats.flyProcessJank) == null ? void 0 : w.toFixed(3)) || 0)
        }), e.push({
          key: ":----------------DevInfo-----------------",
          value: ""
        }), e.push({
          key: "sd",
          value: (this._aggregatedStats.sdMoveResponseLongTime.toFixed(1) || 0) + "/" + (this._aggregatedStats.sdMoveProcessLongTime.toFixed(1) || 0) + "/" + (this._aggregatedStats.sdMoveDisplayLongTime.toFixed(1) || 0)
        }), e.push({
          key: "----hardwareInfo",
          value: this._extraStats.hardwareInfo
        });
        var u = "";

        for (var _i = 0, _e = e; _i < _e.length; _i++) {
          var O = _e[_i];
          u += "<div><span>".concat(O.key, "</span>: <span>").concat(O.value, "</span> </div>");
        }

        this._displayElement.innerHTML = u;
      }
    }, {
      key: "onStats",
      value: function onStats(e) {
        var _this4 = this;

        var n;
        if (!e) return;
        var t = {},
            r = this;
        r._aggregatedStats || (r._aggregatedStats = {}), t.timestamp = e.timestamp, t.mediaBytesReceived = e.mediaBytesReceived, t.metaBytesReceived = e.metaBytesReceived, t.packetsLost = e.packetsLost, t.frameHeight = e.frameHeight, t.frameWidth = e.frameWidth, t.framesReceivedUI = e.framesReceived, t.framesReceived = e.framesReceivedWorker, t.framesDecoded = e.framesDecoded, t.framesEmited = e.framesEmited, t.decodeTimePerFrame = e.decodeTimePerFrame, t.decodeTimeMaxFrame = e.decodeTimeMaxFrame, t.packetsDrop = e.packetsDrop, t.framesAwait = e.framesAwait, t.updateDropFrame = e.updateDropFrame, t.firstMediaArraval = e.firstMediaArraval, t.firstYUVDecoded = e.firstYUVDecoded, t.firstRender = e.firstRender, t.returnFrames = e.returnFrames, t.sendOutBuffer = e.sendOutBuffer, t.averageGraphicTime = e.averageGraphicTime, t.maxGraphicTime = e.maxGraphicTime, t.jankTimes = e.jankTimes, t.bigJankTimes = e.bigJankTimes, t.decodeJankTimes = e.decodeJankTimes, t.bigDecodeJankTimes = e.bigDecodeJankTimes, t.serverFrameFast = e.serverFrameFast, t.serverFrameSlow = e.serverFrameSlow, t.clientFrameFast = e.clientFrameFast, t.clientFrameSlow = e.clientFrameSlow, t.rtcMessageReceived = e.rtcMessageReceived, t.rtcBytesReceived = e.rtcBytesReceived, t.receiveIframes = e.receiveIframes, t.decodeIframes = e.decodeIframes, t.avgResponseTime = e.avgResponseTime, t.avgProcessTime = e.avgProcessTime, t.avgDisplayTime = e.avgDisplayTime, t.avgOverallTime = e.avgOverallTime, t.overallTimeCount = e.overallTimeCount, t.responseMiss = e.responseMiss, t.processMiss = e.processMiss, t.displayMiss = e.displayMiss, t.avgResponseMoveDiff = e.avgResponseMoveDiff, t.avgProcessMoveDiff = e.avgProcessMoveDiff, t.avgDisplayMoveDiff = e.avgDisplayMoveDiff, t.maxResponseMoveDiff = e.maxResponseMoveDiff, t.maxProcessMoveDiff = e.maxProcessMoveDiff, t.maxDisplayMoveDiff = e.maxDisplayMoveDiff, t.moveResponseDelay = e.moveResponseDelay, t.moveProcessDelay = e.moveProcessDelay, t.moveDisplayDelay = e.moveDisplayDelay, t.moveResponseJank = e.moveResponseJank, t.moveProcessJank = e.moveProcessJank, t.moveDisplayJank = e.moveDisplayJank, t.avgMetaParseTime = e.avgMetaParseTime, t.maxMetaParseTime = e.maxMetaParseTime, t.moveResponseCounts = e.moveResponseCounts, t.moveProcessCounts = e.moveProcessCounts, t.moveDisplayCounts = e.moveDisplayCounts, t.MoveDisplayCountGood = e.MoveDisplayCountGood, t.MoveDisplayCountWell = e.MoveDisplayCountWell, t.MoveDisplayCountFair = e.MoveDisplayCountFair, t.MoveDisplayCountBad = e.MoveDisplayCountBad, t.MoveDisplayCountRest = e.MoveDisplayCountRest, t.avgServerDiff = e.avgServerDiff, t.maxServerDiff = e.maxServerDiff, t.avgResponseFlyDiff = e.avgResponseFlyDiff, t.avgProcessFlyDiff = e.avgProcessFlyDiff, t.avgDisplayFlyDiff = e.avgDisplayFlyDiff, t.maxResponseFlyDiff = e.maxResponseFlyDiff, t.maxProcessFlyDiff = e.maxProcessFlyDiff, t.maxDisplayFlyDiff = e.maxDisplayFlyDiff, t.flyResponseCounts = e.flyResponseCounts, t.flyProcessCounts = e.flyProcessCounts, t.flyDisplayCounts = e.flyDisplayCounts, t.flyResponseJank = e.flyResponseJank, t.flyProcessJank = e.flyProcessJank, t.flyDisplayJank = e.flyDisplayJank, t.flyResponseDelay = e.flyResponseDelay, t.flyProcessDelay = e.flyProcessDelay, t.flyDisplayDelay = e.flyDisplayDelay, t.moveEvent = e.moveEvent, t.sdMoveResponseLongTime = e.sdMoveResponseLongTime, t.sdMoveProcessLongTime = e.sdMoveProcessLongTime, t.sdMoveDisplayLongTime = e.sdMoveDisplayLongTime, r._aggregatedStats && r._aggregatedStats.timestamp && (t.mediaBitrate = 8 * (t.mediaBytesReceived - r._aggregatedStats.mediaBytesReceived) / 1e3, t.mediaBitrate = Math.round(t.mediaBitrate || 0), t.metaBitrate = 8 * (t.metaBytesReceived - r._aggregatedStats.metaBytesReceived) / 1e3, t.metaBitrate = Math.round(t.metaBitrate || 0), t.rtcMessagePs = t.rtcMessageReceived - r._aggregatedStats.rtcMessageReceived, t.rtcBitrate = 8 * (t.rtcBytesReceived - r._aggregatedStats.rtcBytesReceived) / 1e3, t.rtcBitrate = Math.round(t.rtcBitrate || 0), t.framesEmitedPs = t.framesEmited - r._aggregatedStats.framesEmited, t.framesEmitedPs = Math.round(t.framesEmitedPs || 0), t.framesReceivedPs = t.framesReceived - r._aggregatedStats.framesReceived, t.framesReceivedPs = Math.round(t.framesReceivedPs || 0), t.framesDecodedPs = t.framesDecoded - r._aggregatedStats.framesDecoded, t.framesDecodedPs = Math.round(t.framesDecodedPs || 0), t.returnFramesPs = t.returnFrames - r._aggregatedStats.returnFrames, t.returnFramesPs = Math.round(t.returnFramesPs || 0), t.responseMissPs = t.responseMiss - r._aggregatedStats.responseMiss, t.processMissPs = t.processMiss - r._aggregatedStats.processMiss, t.displayMissPs = t.displayMiss - r._aggregatedStats.displayMiss, t.returnFrames = e.returnFrames), this._show && this._render(), t.registerBeforeRenderTime = this._extraStats.registerBeforeRenderTime, t.registerAfterRenderTime = this._extraStats.registerAfterRenderTime, t.renderTargetRenderTime = this._extraStats.renderTargetRenderTime, t.renderFrameTime = this._extraStats.renderFrameTime, t.maxRenderFrameTime = this._extraStats.maxRenderFrameTime, t.interFrameTime = this._extraStats.interFrameTime, t.animationTime = this._extraStats.animationTime, t.meshSelectTime = this._extraStats.meshSelectTime, t.drawcall = this._extraStats.drawcall, t.drawcallTime = this._extraStats.drawcallTime, t.triangle = this._extraStats.triangle, t.registerAfterCount = this._extraStats.registerAfterCount, t.registerBeforeCount = this._extraStats.registerBeforeCount, t.fps = this._extraStats.fps, t.rtt = this._extraStats.rtt, t.hb = this._extraStats.hb, t.avgFrameTime = this._extraStats.avgFrameTime, t.avgTimeoutTime = this._extraStats.avgTimeoutTime, t.engineSloppyCnt = this._extraStats.engineSloppyCnt, t.systemStuckCnt = this._extraStats.systemStuckCnt, t.avatarState = (n = this.room._userAvatar) == null ? void 0 : n.state, t.maxFrameTime = this._extraStats.maxFrameTime, t.maxTimeoutTime = this._extraStats.maxTimeoutTime, t.activeParticles = this._extraStats.activeParticles, t.activeBones = this._extraStats.activeBones, t.activeAnimation = this._extraStats.activeAnimation, t.totalRootNodes = this._extraStats.totalRootNodes, t.totalGeometries = this._extraStats.totalGeometries, t.totalMeshes = this._extraStats.totalMeshes, t.totalTextures = this._extraStats.totalTextures, t.totalMaterials = this._extraStats.totalMaterials, t.hardwareInfo = this._extraStats.hardwareInfo, t.maxInterFrameTime = this._extraStats.maxInterFrameTime, t.maxDrawcallTime = this._extraStats.maxDrawcallTime, t.maxMeshSelectTime = this._extraStats.maxMeshSelectTime, t.maxAnimationTime = this._extraStats.maxAnimationTime, t.maxRegisterBeforeRenderTime = this._extraStats.maxRegisterBeforeRenderTime, t.maxRegisterAfterRenderTime = this._extraStats.maxRegisterAfterRenderTime, t.maxRenderTargetRenderTime = this._extraStats.maxRenderTargetRenderTime, this.externalStats && Object.keys(this.externalStats || {}).forEach(function (o) {
          t[o] = _this4.externalStats[o];
        }), r._aggregatedStats = t, this.emit("stats", {
          stats: t
        });
      }
    }]);

    return Stats;
  }(EventEmitter);

  function _createSuper$b(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$b(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$b() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var EventsManager = /*#__PURE__*/function (_EventEmitter) {
    _inherits(EventsManager, _EventEmitter);

    var _super = _createSuper$b(EventsManager);

    function EventsManager() {
      var _this;

      _classCallCheck(this, EventsManager);

      _this = _super.apply(this, arguments);
      E(_assertThisInitialized(_this), "events", new Map());
      E(_assertThisInitialized(_this), "specialEvents", new Map());
      return _this;
    }

    _createClass(EventsManager, [{
      key: "remove",
      value: function remove(e, t, r, n) {
        if (this.specialEvents.has(e) && !n && t === Codes.Success) return;
        this.events.get(e) && (this.emit(e, {
          code: t,
          data: r
        }), this.events.delete(e), this.specialEvents.delete(e));
      }
    }, {
      key: "track",
      value: function () {
        var _track = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e, t) {
          var _this2 = this;

          var r, _ref, n, _ref$noReport, o, a, s, l, u, c;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  r = e.traceId;
                  this.emitTraceIdToDecoder(e);
                  _ref = t || {}, n = _ref.sampleRate, _ref$noReport = _ref.noReport, o = _ref$noReport === void 0 ? !1 : _ref$noReport, a = _ref.special;

                  if (!(n && Math.random() > n)) {
                    _context.next = 5;
                    break;
                  }

                  return _context.abrupt("return", Promise.resolve());

                case 5:
                  s = Actions[e.event] + "Action", l = e.tag;
                  this.events.set(r, !0), a && this.specialEvents.set(r, !0);
                  u = Date.now();
                  c = null;
                  return _context.abrupt("return", new Promise(function (h, f) {
                    if (o) return _this2.off(r), _this2.events.delete(r), h(void 0);

                    _this2.on(r, function (_ref2) {
                      var _ = _ref2.code,
                          g = _ref2.data,
                          m = _ref2.msg;
                      if (_ === Codes.Success) h(g), _this2.off(r), logger$1.infoAndReportMeasurement({
                        metric: s,
                        tag: l,
                        extra: e.extra,
                        startTime: u,
                        traceId: r
                      });else {
                        if (_ === Codes.ActionMaybeDelay) return;

                        if (_ === Codes.DoActionBlocked && e.event === Actions.Rotation) {
                          logger$1.debug(s + " response code: " + _);
                          return;
                        }

                        var v = util.getErrorByCode(_),
                            y = new v(m);
                        _this2.off(r), f(y), _this2.emit("actionResponseError", {
                          error: y,
                          event: e,
                          tag: l
                        }), logger$1.infoAndReportMeasurement({
                          metric: s,
                          tag: l,
                          extra: e.extra,
                          error: y,
                          startTime: u,
                          traceId: r
                        });
                      }
                    });

                    var d = e.timeout || 2e3;
                    c = window.setTimeout(function () {
                      if (c && clearTimeout(c), !_this2.events.get(r)) return;

                      var _ = new ActionResponseTimeoutError("".concat(s, " timeout in ").concat(d, "ms"));

                      _this2.emit("actionResponseTimeout", {
                        error: _,
                        event: e,
                        tag: l
                      }), f(_), _this2.events.delete(r), _this2.off(r), logger$1.infoAndReportMeasurement({
                        metric: s,
                        tag: l,
                        extra: e.extra,
                        error: _,
                        startTime: u,
                        traceId: r
                      });
                    }, d);
                  }));

                case 10:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function track(_x, _x2) {
          return _track.apply(this, arguments);
        }

        return track;
      }()
    }, {
      key: "emitTraceIdToDecoder",
      value: function emitTraceIdToDecoder(e) {
        if (e.event === Actions.Rotation || e.event === Actions.Clicking || e.event === Actions.GetOnVehicle || e.event === Actions.GetOffVehicle) {
          var t = {
            [Actions.Rotation]: "Rotation",
            [Actions.GetOnVehicle]: "GetOnVehicle",
            [Actions.GetOffVehicle]: "GetOffVehicle",
            [Actions.Clicking]: "MoveTo"
          };
          this.emit("traceId", {
            traceId: e.traceId,
            timestamp: Date.now(),
            event: t[e.event]
          });
        }
      }
    }]);

    return EventsManager;
  }(EventEmitter);
  var eventsManager = new EventsManager();

  var ClickType = {
    Screen: 0,
    ThreeDimension: 1,
    ThreeDimensionQuick: 2,
    IgnoreView: 3
  };

  var QueueActions = [Actions.Transfer, Actions.ChangeSkin, Actions.GetOnVehicle, Actions.GetOffVehicle];

  var ActionsHandler = /*#__PURE__*/function () {
    function ActionsHandler(e) {
      _classCallCheck(this, ActionsHandler);

      this.currentActiveAction = null;
      this.room = e;
    }

    _createClass(ActionsHandler, [{
      key: "avatarComponentsSync",
      value: function () {
        var _avatarComponentsSync = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var t;
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  t = {
                    action_type: Actions.SetPlayerState,
                    set_player_state_action: {
                      player_state: {
                        avatar_components: JSON.stringify(e)
                      }
                    }
                  };
                  this.sendData({
                    data: t
                  });

                case 2:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function avatarComponentsSync(_x) {
          return _avatarComponentsSync.apply(this, arguments);
        }

        return avatarComponentsSync;
      }()
    }, {
      key: "sendData",
      value: function () {
        var _sendData = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(e) {
          var _this = this;

          var t, _e$sampleRate, r, _e$timeout, n, o, a, s;

          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  _context2.next = 2;
                  return this.beforeSend(e);

                case 2:
                  t = util.uuid();

                  if (!(this.room.networkController.sendRtcData(le(oe({}, e.data), {
                    trace_id: t,
                    user_id: this.room.options.userId
                  })), e.track === !1)) {
                    _context2.next = 5;
                    break;
                  }

                  return _context2.abrupt("return", Promise.resolve(null));

                case 5:
                  _e$sampleRate = e.sampleRate, r = _e$sampleRate === void 0 ? 1 : _e$sampleRate, _e$timeout = e.timeout, n = _e$timeout === void 0 ? 2e3 : _e$timeout, o = e.tag, a = e.data, s = e.special;
                  return _context2.abrupt("return", eventsManager.track({
                    timeout: n,
                    traceId: t,
                    event: a.action_type,
                    tag: o,
                    extra: a
                  }, {
                    special: s,
                    sampleRate: r,
                    noReport: this.room.viewMode === "serverless" || this.room.options.viewMode === "serverless"
                  }).finally(function () {
                    QueueActions.includes(e.data.action_type) && (_this.currentActiveAction = void 0);
                  }));

                case 7:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this);
        }));

        function sendData(_x2) {
          return _sendData.apply(this, arguments);
        }

        return sendData;
      }()
    }, {
      key: "beforeSend",
      value: function () {
        var _beforeSend = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(e) {
          var o, t, r;
          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  t = (o = this.room._userAvatar) == null ? void 0 : o.isMoving, r = e.data.action_type;

                  if (!QueueActions.includes(r)) {
                    _context3.next = 5;
                    break;
                  }

                  if (!this.currentActiveAction) {
                    _context3.next = 4;
                    break;
                  }

                  return _context3.abrupt("return", (logger$1.error("".concat(Actions[this.currentActiveAction], " still pending, reject ").concat(Actions[r])), Promise.reject(new FrequencyLimitError("".concat(Actions[r], " action request frequency limit")))));

                case 4:
                  this.currentActiveAction = r;

                case 5:
                  if (!(t && QueueActions.includes(e.data.action_type))) {
                    _context3.next = 14;
                    break;
                  }

                  _context3.prev = 6;
                  _context3.next = 9;
                  return this.stopMoving();

                case 9:
                  _context3.next = 14;
                  break;

                case 11:
                  _context3.prev = 11;
                  _context3.t0 = _context3["catch"](6);
                  this.currentActiveAction = void 0, logger$1.error("before action stopMoving failed", _context3.t0);

                case 14:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, this, [[6, 11]]);
        }));

        function beforeSend(_x3) {
          return _beforeSend.apply(this, arguments);
        }

        return beforeSend;
      }()
    }, {
      key: "moveTo",
      value: function () {
        var _moveTo = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(e) {
          var t, _e$extra, r, n, o;

          return regenerator.wrap(function _callee4$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  t = e.point, _e$extra = e.extra, r = _e$extra === void 0 ? "" : _e$extra, n = e.motionType, o = {
                    action_type: Actions.Clicking,
                    clicking_action: {
                      clicking_point: t,
                      clicking_type: ClickType.IgnoreView,
                      extra: encodeURIComponent(r),
                      attitude: n
                    },
                    clicking_state: this.room._currentClickingState
                  };
                  return _context4.abrupt("return", this.sendData({
                    data: o
                  }));

                case 2:
                case "end":
                  return _context4.stop();
              }
            }
          }, _callee4, this);
        }));

        function moveTo(_x4) {
          return _moveTo.apply(this, arguments);
        }

        return moveTo;
      }()
    }, {
      key: "transfer",
      value: function transfer(e) {
        var _this2 = this;

        var t = e.renderType,
            r = e.player,
            n = e.camera,
            o = e.areaName,
            a = e.attitude,
            s = e.pathName,
            l = e.person,
            u = e.noMedia,
            c = e.timeout,
            h = e.tag,
            f = e.special,
            d = {
          data: {
            action_type: Actions.Transfer,
            transfer_action: {
              render_type: t,
              player: r,
              camera: n,
              areaName: o,
              attitude: a,
              pathName: s,
              person: {
                type: l
              },
              noMedia: u,
              tiles: [0, 1, 2, 4]
            }
          },
          special: f,
          timeout: c || 4e3,
          tag: h
        };
        return this.sendData(d).then(function (_) {
          return typeof l != "undefined" && _this2.room.updateCurrentNetworkOptions({
            person: l,
            rotationRenderType: t
          }), _;
        });
      }
    }, {
      key: "changeRotationRenderType",
      value: function changeRotationRenderType(e) {
        var t = e.renderType,
            r = e.player,
            n = e.camera,
            o = e.areaName,
            a = e.attitude,
            s = e.pathName;
        return this.transfer({
          renderType: t,
          player: r,
          camera: n,
          areaName: o,
          attitude: a,
          pathName: s,
          tag: "changeToRotationVideo"
        });
      }
    }, {
      key: "requestPanorama",
      value: function requestPanorama(e, t, r) {
        var n = e.camera,
            o = e.player,
            a = e.areaName,
            s = e.attitude,
            l = e.pathName,
            u = e.tag;
        return this.transfer({
          renderType: RenderType.ClientRotationPano,
          player: o,
          camera: n,
          person: Person.First,
          areaName: a,
          attitude: s,
          pathName: l,
          noMedia: t,
          timeout: r,
          tag: u || "requestPanorama",
          special: !t
        });
      }
    }, {
      key: "setMotionType",
      value: function setMotionType(e) {
        return this.transfer({
          attitude: e,
          tag: "setMotionType"
        });
      }
    }, {
      key: "setNickName",
      value: function setNickName(e) {
        var t = {
          action_type: Actions.ChangeNickname,
          change_nickname_action: {
            nickname: e
          }
        };
        return this.sendData({
          data: t
        });
      }
    }, {
      key: "getReserveSeat",
      value: function getReserveSeat(_ref) {
        var e = _ref.routeId,
            t = _ref.name;
        var r = {
          action_type: Actions.ReserveSeat,
          reserve_seat_action: {
            route_id: e,
            name: t
          }
        };
        return this.sendData({
          data: r
        });
      }
    }, {
      key: "getReserveStatus",
      value: function getReserveStatus(_ref2) {
        var e = _ref2.routeId,
            t = _ref2.name,
            r = _ref2.need_detail;
        var n = {
          action_type: Actions.GetReserveStatus,
          get_reserve_status_action: {
            route_id: e,
            name: t,
            need_detail: r
          }
        };
        return this.sendData({
          data: n,
          timeout: 2e3
        }).then(function (o) {
          return o.reserveDetail;
        });
      }
    }, {
      key: "stopMoving",
      value: function stopMoving() {
        var e = {
          action_type: Actions.StopMoving,
          stop_move_action: {}
        };
        return this.sendData({
          data: e
        });
      }
    }, {
      key: "getOnVehicle",
      value: function getOnVehicle(_ref3) {
        var e = _ref3.routeId,
            t = _ref3.name,
            r = _ref3.camera;
        var n = {
          action_type: Actions.GetOnVehicle,
          get_on_vehicle_action: {
            route_id: e,
            name: t,
            camera: r
          }
        };
        return this.sendData({
          data: n
        });
      }
    }, {
      key: "getOffVehicle",
      value: function getOffVehicle(_ref4) {
        var e = _ref4.renderType,
            t = _ref4.player,
            r = _ref4.camera;
        var n = {
          action_type: Actions.GetOffVehicle,
          get_off_vehicle_action: {
            render_type: e,
            player: t,
            camera: r
          }
        };
        return this.sendData({
          data: n
        });
      }
    }, {
      key: "confirmEvent",
      value: function confirmEvent(e) {
        var t = {
          action_type: Actions.ConfirmEvent,
          confirm_event_action: {
            id: e
          }
        };
        return this.sendData({
          data: t,
          track: !1
        });
      }
    }, {
      key: "echo",
      value: function echo(e) {
        var t = {
          action_type: Actions.Echo,
          echo_msg: {
            echoMsg: e
          }
        };
        return this.sendData({
          data: t,
          track: !1
        });
      }
    }, {
      key: "changeSkin",
      value: function () {
        var _changeSkin = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee6(e) {
          var _this3 = this;

          var t, r, n, _e$landingType, o, a, s, l, u, c, h, f, d, _, _e$roomTypeId, g, m, y, v;

          return regenerator.wrap(function _callee6$(_context6) {
            while (1) {
              switch (_context6.prev = _context6.next) {
                case 0:
                  t = e.special === void 0 ? e.renderType === RenderType.ClientRotationPano : e.special, r = e.skinId, n = e.mode, _e$landingType = e.landingType, o = _e$landingType === void 0 ? LandingType.Stay : _e$landingType, a = e.landingPoint, s = e.landingCamera, l = e.renderType, u = e.areaName, c = e.attitude, h = e.pathName, f = e.person, d = e.noMedia, _ = e.timeout, _e$roomTypeId = e.roomTypeId, g = _e$roomTypeId === void 0 ? "" : _e$roomTypeId, m = this.room.skinList.filter(function (y) {
                    return y.id === r;
                  })[0];

                  if (m) {
                    _context6.next = 4;
                    break;
                  }

                  y = "skin ".concat(r, " is invalid");
                  return _context6.abrupt("return", (logger$1.error(y), Promise.reject(new ParamError(y))));

                case 4:
                  v = {
                    action_type: Actions.ChangeSkin,
                    change_skin_action: {
                      skinID: r,
                      mode: n === ChangeMode.Preview ? ChangeMode.Preview : ChangeMode.Confirm,
                      skin_data_version: r + m.versionId,
                      landing_type: o,
                      landing_point: a,
                      landing_camera: s,
                      render_wrapper: {
                        render_type: l
                      },
                      areaName: u,
                      attitude: c,
                      noMedia: d,
                      person: f,
                      pathName: h,
                      roomTypeId: g
                    }
                  };
                  return _context6.abrupt("return", this.sendData({
                    data: v,
                    timeout: _ || 6e3,
                    special: t
                  }).then( /*#__PURE__*/function () {
                    var _ref5 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5(y) {
                      var b, _ref6, T;

                      return regenerator.wrap(function _callee5$(_context5) {
                        while (1) {
                          switch (_context5.prev = _context5.next) {
                            case 0:
                              if (!(l === RenderType.ClientRotationPano && y)) {
                                _context5.next = 8;
                                break;
                              }

                              _context5.next = 3;
                              return _this3.room.modelManager.findRoute(r, h);

                            case 3:
                              b = _context5.sent;
                              _ref6 = util.getRandomItem(b.birthPointList) || {};
                              T = _ref6.camera;
                              _context5.next = 8;
                              return _this3.room.panorama.handleReceivePanorama(y, T);

                            case 8:
                              return _context5.abrupt("return", _this3.handleChangeSkin(e));

                            case 9:
                            case "end":
                              return _context5.stop();
                          }
                        }
                      }, _callee5);
                    }));

                    return function (_x6) {
                      return _ref5.apply(this, arguments);
                    };
                  }()).catch(function (y) {
                    return d ? _this3.handleChangeSkin(e) : Promise.reject(y);
                  }));

                case 6:
                case "end":
                  return _context6.stop();
              }
            }
          }, _callee6, this);
        }));

        function changeSkin(_x5) {
          return _changeSkin.apply(this, arguments);
        }

        return changeSkin;
      }()
    }, {
      key: "handleChangeSkin",
      value: function handleChangeSkin(e) {
        var _this4 = this;

        var t = e.skinId,
            r = e.mode,
            n = e.renderType,
            o = e.areaName,
            a = e.attitude,
            s = e.pathName;
        return this.room.sceneManager.staticmeshComponent.getCgMesh().show(), this.room.sceneManager.cameraComponent.switchToCgCamera(), this.room.engineProxy._updateSkinAssets(t).then(function () {
          _this4.room.sceneManager.staticmeshComponent.getCgMesh().hide(), _this4.room.sceneManager.cameraComponent.switchToMainCamera(), _this4.room.pathManager.currentArea = o, logger$1.info("changeSkin _updateSkinAssets susccss"), _this4.room.updateCurrentNetworkOptions({
            pathName: s,
            attitude: a,
            areaName: o
          }), _this4.room.skinChangedHook(), _this4.room.emit("skinChanged", {
            skin: {
              id: t
            },
            mode: r
          }), n === RenderType.ClientRotationPano && _this4.room.sceneManager.cameraComponent.allowMainCameraController();
        });
      }
    }, {
      key: "rotate",
      value: function rotate(_ref7) {
        var e = _ref7.pitch,
            t = _ref7.yaw;
        var n;
        if (this.room.disableRotate || this.room.isPano || ((n = this.room._userAvatar) == null ? void 0 : n._isChangingComponentsMode)) return;
        var r = {
          action_type: Actions.Rotation,
          rotation_action: {
            vertical_move: e,
            horizontal_move: -t
          }
        };
        this.sendData({
          data: r,
          sampleRate: .02
        });
      }
    }, {
      key: "turnTo",
      value: function turnTo(e) {
        var _ref8 = e || {},
            t = _ref8.point,
            _ref8$timeout = _ref8.timeout,
            r = _ref8$timeout === void 0 ? 2e3 : _ref8$timeout,
            _ref8$offset = _ref8.offset,
            n = _ref8$offset === void 0 ? 8 : _ref8$offset,
            o = {
          action_type: Actions.TurnTo,
          turn_to_action: {
            turn_to_point: t,
            offset: n
          }
        };

        return this.sendData({
          data: o,
          timeout: r
        });
      }
    }, {
      key: "rotateTo",
      value: function rotateTo(e) {
        var _ref9 = e || {},
            t = _ref9.point,
            _ref9$offset = _ref9.offset,
            r = _ref9$offset === void 0 ? 0 : _ref9$offset,
            _ref9$speed = _ref9.speed,
            n = _ref9$speed === void 0 ? 3 : _ref9$speed,
            o = {
          action_type: Actions.RotateTo,
          rotate_to_action: {
            rotate_to_point: t,
            offset: r,
            speed: n
          }
        };

        return this.sendData({
          data: o
        });
      }
    }, {
      key: "broadcast",
      value: function broadcast(e) {
        var t = e.data,
            _e$msgType = e.msgType,
            r = _e$msgType === void 0 ? MessageHandleType.MHT_FollowListMulticast : _e$msgType,
            n = e.targetUserIds;
        if (r === MessageHandleType.MHT_CustomTargetSync && !Array.isArray(n)) return Promise.reject(new ParamError("param targetUserIds is required  when msgType is ".concat(MessageHandleType[r])));
        var o = {
          action_type: Actions.Broadcast,
          broadcast_action: {
            data: JSON.stringify(t),
            user_id: this.room.options.userId,
            msgType: r
          }
        };
        return Array.isArray(n) && r === MessageHandleType.MHT_CustomTargetSync && (o.broadcast_action.target_user_ids = n), this.room.actionsHandler.sendData({
          data: o,
          tag: t.broadcastType
        });
      }
    }, {
      key: "getNeighborPoints",
      value: function getNeighborPoints(e) {
        var t = e.point,
            _e$containSelf = e.containSelf,
            r = _e$containSelf === void 0 ? !1 : _e$containSelf,
            _e$searchRange = e.searchRange,
            n = _e$searchRange === void 0 ? 500 : _e$searchRange,
            o = {
          action_type: Actions.GetNeighborPoints,
          get_neighbor_points_action: {
            point: t,
            level: 1,
            containSelf: r,
            searchRange: n
          }
        };
        return this.sendData({
          data: o
        }).then(function (a) {
          return a.nps;
        });
      }
    }, {
      key: "playCG",
      value: function playCG(e) {
        var t = {
          action_type: Actions.PlayCG,
          play_cg_action: {
            cg_name: e
          }
        };
        return this.sendData({
          data: t
        });
      }
    }, {
      key: "audienceToVisitor",
      value: function audienceToVisitor(e) {
        var t = e.avatarId,
            r = e.avatarComponents,
            n = e.player,
            o = e.camera,
            a = {
          action_type: Actions.AudienceChangeToVisitor,
          audienceChangeToVisitorAction: {
            avatarID: t,
            avatarComponents: r,
            player: n,
            camera: o
          }
        };
        return logger$1.debug("send data: audience to visitor"), this.sendData({
          data: a
        });
      }
    }, {
      key: "visitorToAudience",
      value: function visitorToAudience(e) {
        var t = e.renderType,
            r = e.player,
            n = e.camera,
            o = e.areaName,
            a = e.attitude,
            s = e.pathName,
            l = e.person,
            u = e.noMedia,
            c = {
          action_type: Actions.VisitorChangeToAudience,
          visitorChangeToAudienceAction: {
            transferAction: {
              render_type: t,
              player: r,
              camera: n,
              areaName: o,
              attitude: a,
              pathName: s,
              person: {
                type: l
              },
              noMedia: u,
              tiles: [0, 1, 2, 4]
            }
          }
        };
        return logger$1.debug("send data: visitor to audience"), this.sendData({
          data: c
        });
      }
    }, {
      key: "removeVisitor",
      value: function removeVisitor(e) {
        var t = e.removeType,
            r = e.userIDList,
            _e$extraInfo = e.extraInfo,
            n = _e$extraInfo === void 0 ? "" : _e$extraInfo,
            o = {
          action_type: Actions.RemoveVisitor,
          removeVisitorAction: {
            removeVisitorEvent: t,
            userIDList: r,
            extraInfo: encodeURIComponent(n)
          }
        };
        return logger$1.debug("send data: remove visitor"), this.sendData({
          data: o
        });
      }
    }, {
      key: "getUserWithAvatar",
      value: function getUserWithAvatar(e, t) {
        var r = {
          action_type: Actions.GetUserWithAvatar,
          getUserWithAvatarAction: {
            userType: e,
            roomID: t
          }
        };
        return logger$1.debug("send data: get user with avatar"), this.sendData({
          data: r
        }).then(function (n) {
          return n.userWithAvatarList;
        });
      }
    }, {
      key: "joystick",
      value: function joystick(e) {
        var t = e.degree,
            _e$level = e.level,
            r = _e$level === void 0 ? 1 : _e$level,
            n = util.uuid();
        var o = -t + 90 + 360;
        o >= 360 && (o -= 360);
        var a = {
          action_type: Actions.Joystick,
          dir_action: {
            move_angle: o,
            speed_level: r
          },
          trace_id: n,
          user_id: this.room.options.userId,
          packet_id: n
        };
        return this.sendData({
          data: a,
          track: !1
        });
      }
    }]);

    return ActionsHandler;
  }();

  var ECurrentShaderMode = {
    default: 0,
    video: 1,
    pano: 2
  };

  var PointType = {
    Path: 0,
    Item: 1,
    Closeup: 2,
    NoValidMatched: 3
  };

  var Signal = /*#__PURE__*/function () {
    function Signal(e) {
      _classCallCheck(this, Signal);

      this.signalHandleActived = !0;
      this.isUpdatedYUV = !0;
      this._room = e;
    }

    _createClass(Signal, [{
      key: "handleSignal",
      value: function handleSignal(e) {
        var _this = this;

        var a, s, l;
        if (!this.signalHandleActived) return;
        var t = e.signal,
            r = e.alreadyUpdateYUV;

        if (this.handleActionResponses(t), this._room.handleSignalHook(t), !r) {
          var u = (a = t.newUserStates) == null ? void 0 : a.find(function (c) {
            return c.userId === _this._room.userId;
          });

          if ((u == null ? void 0 : u.renderInfo) && ((s = this._room._userAvatar) == null ? void 0 : s.isMoving)) {
            logger$1.debug("stream stoped, make avatar to stop");
            var _u$renderInfo = u.renderInfo,
                c = _u$renderInfo.isMoving,
                h = _u$renderInfo.isRotating;

            this._room.avatarManager._updateAvatarMovingStatus({
              id: u.userId,
              isMoving: !!c,
              isRotating: !!h
            });
          }

          return;
        }

        this.isUpdatedYUV = r;
        var n = t;

        if (!t) {
          logger$1.warn("metadata signal is empty");
          return;
        }

        if (n.code === Codes.RepeatLogin) {
          this._room.handleRepetLogin();

          return;
        }

        n.code !== void 0 && n.code !== Codes.Success && n.code !== Codes.ActionMaybeDelay && n.code !== Codes.DoActionBlocked && n.code !== Codes.GetOnVehicle && (logger$1.error("signal errcode: ", n), this._room.emit("error", n));
        var o = (l = n.newUserStates) == null ? void 0 : l.find(function (u) {
          return u.userId === _this._room.userId;
        });
        if (n.broadcastAction) try {
          var _u = JSON.parse(n.broadcastAction.data);

          Broadcast.handlers.forEach(function (c) {
            return c(_u);
          });
        } catch (u) {
          logger$1.error(u);
        }

        if (n.newUserStates && n.newUserStates.length > 0 && this._room.avatarManager.handleAvatar(n), o != null && o.playerState) {
          this._room._currentClickingState = o.playerState;
          var _o$playerState = o.playerState,
              _u2 = _o$playerState.pathName,
              _c = _o$playerState.attitude,
              _h = _o$playerState.areaName,
              f = _o$playerState.skinId;

          if (_u2 && (this._room.pathManager.currentPathName = _u2, this._room.updateCurrentState({
            pathName: _u2
          })), f && this.udpateSkinInfo(f), _h && this._room.updateCurrentState({
            areaName: _h
          }), _c) {
            var d = this._room.skin.routeList.find(function (g) {
              return g.areaName === _this._room.currentState.areaName;
            }),
                _ = ((d == null ? void 0 : d.step) || 7.5) * 30;

            this._room.updateCurrentState({
              speed: _,
              attitude: _c
            }), this._room.pathManager.currentAttitude = _c, this._room._userAvatar && (this._room._userAvatar.motionType = _c);
          }

          this._room.sceneManager.getCurrentShaderMode() !== ECurrentShaderMode.pano && !this._room.isPano && o.playerState.camera && this._room.camera.setCameraPose(o.playerState.camera);
        }

        if (o != null && o.renderInfo && this._room.camera.handleRenderInfo(o), n.actionType !== void 0) {
          var _u3 = n.actionType,
              _c2 = n.code,
              _h2 = n.echoMsg,
              _f = n.traceId;
          _u3 === Actions.Echo && _c2 === Codes.Success && this._room.networkController.rtcp.heartbeat.pong(_h2, _f), _c2 !== Codes.Success ? eventsManager.remove(_f, _c2) : [Actions.GetReserveStatus, Actions.Broadcast, Actions.ChangeNickname, Actions.ConfirmEvent, Actions.ReserveSeat, Actions.Rotation, Actions.TurnTo, Actions.RotateTo, Actions.SetPlayerState, Actions.GetNeighborPoints, Actions.TurnToFace, Actions.AudienceChangeToVisitor, Actions.RemoveVisitor, Actions.GetUserWithAvatar].includes(_u3) && eventsManager.remove(_f, _c2, n);
        }
      }
    }, {
      key: "handleActionResponses",
      value: function handleActionResponses(e) {
        var _this2 = this;

        !(e != null && e.actionResponses) || e.actionResponses.length === 0 || e.actionResponses.forEach(function (t) {
          if (t.actionType == null) return;
          var r = t.pointType,
              n = t.extra,
              o = t.actionType,
              a = t.traceId,
              s = t.code,
              l = t.msg;
          o === Actions.GetNeighborPoints ? eventsManager.remove(a, s, t.nps) : o === Actions.GetUserWithAvatar ? eventsManager.remove(a, s, t.userWithAvatarList) : eventsManager.remove(a, s, l), r === PointType.Path && o === Actions.Clicking && (_this2._room.moveToExtra = decodeURIComponent(n));
        });
      }
    }, {
      key: "udpateSkinInfo",
      value: function () {
        var _udpateSkinInfo = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var t;
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  this._room.updateCurrentState({
                    skinId: e
                  });

                  _context.next = 3;
                  return this._room.skinList.find(function (r) {
                    return r.id === e;
                  });

                case 3:
                  t = _context.sent;
                  t && this._room.updateCurrentState({
                    skin: t
                  });

                case 5:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function udpateSkinInfo(_x) {
          return _udpateSkinInfo.apply(this, arguments);
        }

        return udpateSkinInfo;
      }()
    }]);

    return Signal;
  }();

  function _createSuper$a(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$a(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$a() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var XverseEffectManager = /*#__PURE__*/function (_EventEmitter) {
    _inherits(XverseEffectManager, _EventEmitter);

    var _super = _createSuper$a(XverseEffectManager);

    function XverseEffectManager(e) {
      var _this;

      _classCallCheck(this, XverseEffectManager);

      _this = _super.call(this);
      E(_assertThisInitialized(_this), "effects", new Map());
      E(_assertThisInitialized(_this), "room");
      _this.room = e;
      return _this;
    }

    _createClass(XverseEffectManager, [{
      key: "addEffect",
      value: function () {
        var _addEffect = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var o, t, r, _e$type, n, a;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  t = e.jsonPath, r = e.id, _e$type = e.type, n = _e$type === void 0 ? IEffectType.SubSequence : _e$type;
                  _context.prev = 1;
                  this.effects.get(r) && ((o = this.effects.get(r)) == null || o.dispose());
                  a = new Ae.subEffect({
                    id: r,
                    jsonPath: t,
                    type: n,
                    room: this.room
                  });
                  this.effects.set(r, a);
                  _context.next = 7;
                  return a.init();

                case 7:
                  return _context.abrupt("return", a);

                case 10:
                  _context.prev = 10;
                  _context.t0 = _context["catch"](1);
                  return _context.abrupt("return", (this.effects.delete(r), logger$1.error(_context.t0), Promise.reject(_context.t0)));

                case 13:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this, [[1, 10]]);
        }));

        function addEffect(_x) {
          return _addEffect.apply(this, arguments);
        }

        return addEffect;
      }()
    }, {
      key: "clearEffects",
      value: function clearEffects() {
        var _this2 = this;

        this.effects.forEach(function (e) {
          e.dispose(), _this2.effects.delete(e.id);
        });
      }
    }, {
      key: "removeEffect",
      value: function removeEffect(e) {
        var t = this.effects.get(e);
        t == null || t.dispose(), t && this.effects.delete(t.id);
      }
    }]);

    return XverseEffectManager;
  }(EventEmitter);

  var Heartbeat = /*#__PURE__*/function () {
    function Heartbeat(e) {
      var _this = this;

      _classCallCheck(this, Heartbeat);

      E(this, "_interval", null);
      E(this, "ping", function () {
        var e = Date.now().toString();

        _this.handler.ping(e);
      });
      this.handler = e;
    }

    _createClass(Heartbeat, [{
      key: "ping",
      value: function ping() {
        var e = Date.now().toString();
        this.handler.ping(e);
      }
    }, {
      key: "start",
      value: function start() {
        this.stop(), logger$1.debug("Setting ping interval to ".concat(PING_INTERVAL_MS, "ms")), this._interval = window.setInterval(this.ping, PING_INTERVAL_MS);
      }
    }, {
      key: "stop",
      value: function stop() {
        logger$1.debug("stop heartbeat"), this._interval && window.clearInterval(this._interval);
      }
    }, {
      key: "pong",
      value: function pong(e, t) {
        !e || typeof e == "string" && this.handler.pong(Date.now() - Number(e), t);
      }
    }]);

    return Heartbeat;
  }();

  var Timeout$1 = /*#__PURE__*/function () {
    function Timeout(e, t) {
      var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !0;

      _classCallCheck(this, Timeout);

      this._timeout = null;
      this._fn = e, this._delay = t, r && this.start();
    }

    _createClass(Timeout, [{
      key: "delay",
      get: function get() {
        return this._delay;
      }
    }, {
      key: "isSet",
      get: function get() {
        return !!this._timeout;
      }
    }, {
      key: "setDelay",
      value: function setDelay(e) {
        this._delay = e;
      }
    }, {
      key: "start",
      value: function start() {
        var _this = this;

        this.isSet || (this._timeout = window.setTimeout(function () {
          var e = _this._fn;
          _this.clear(), e();
        }, this._delay));
      }
    }, {
      key: "clear",
      value: function clear() {
        window.clearTimeout(this._timeout), this._timeout = void 0;
      }
    }, {
      key: "reset",
      value: function reset() {
        this.clear(), this.start();
      }
    }]);

    return Timeout;
  }();

  function _createSuper$9(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$9(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$9() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var Socket = /*#__PURE__*/function (_EventEmitter) {
    _inherits(Socket, _EventEmitter);

    var _super = _createSuper$9(Socket);

    function Socket(e) {
      var _this;

      _classCallCheck(this, Socket);

      _this = _super.call(this);
      E(_assertThisInitialized(_this), "_ws");
      E(_assertThisInitialized(_this), "_openTimer");
      E(_assertThisInitialized(_this), "connected", !1);
      E(_assertThisInitialized(_this), "_hasTimeout", !1);
      E(_assertThisInitialized(_this), "heartbeat");
      E(_assertThisInitialized(_this), "latency", function (e, t) {
        return _this.send({
          id: "checkLatency",
          data: JSON.stringify(e),
          packet_id: t
        });
      });
      E(_assertThisInitialized(_this), "send", function (e) {
        if (_this.wsNoReady()) return;
        var t = JSON.stringify(e);
        e.id !== "heartbeat" && logger$1.info("send ws frame", t), _this._ws.send(t);
      });
      E(_assertThisInitialized(_this), "startGame", function () {
        var _this$network$room$cu = _this.network.room.currentNetworkOptions,
            e = _this$network$room$cu.roomId,
            t = _this$network$room$cu.userId,
            r = _this$network$room$cu.avatarId,
            n = _this$network$room$cu.skinId,
            o = _this$network$room$cu.role,
            a = _this$network$room$cu.avatarComponents,
            s = _this$network$room$cu.versionId,
            l = _this$network$room$cu.rotationRenderType,
            u = _this$network$room$cu.isAllSync,
            c = _this$network$room$cu.nickname,
            h = _this$network$room$cu.avatarScale,
            f = _this$network$room$cu.appId,
            d = _this$network$room$cu.camera,
            _ = _this$network$room$cu.player,
            g = _this$network$room$cu.firends,
            m = _this$network$room$cu.syncByEvent,
            v = _this$network$room$cu.areaName,
            y = _this$network$room$cu.attitude,
            b = _this$network$room$cu.pathName,
            T = _this$network$room$cu.person,
            _this$network$room$cu2 = _this$network$room$cu.roomTypeId,
            C = _this$network$room$cu2 === void 0 ? "" : _this$network$room$cu2,
            A = _this$network$room$cu.syncToOthers,
            S = _this$network$room$cu.hasAvatar,
            P = _this$network$room$cu.prioritySync,
            _this$network$room$cu3 = _this$network$room$cu.extra,
            R = _this$network$room$cu3 === void 0 ? {} : _this$network$room$cu3,
            M = _this$network$room$cu.removeWhenDisconnected;
        R.removeWhenDisconnected = M;
        var x = {
          id: "start",
          room_id: e,
          user_id: t,
          trace_id: util.uuid(),
          data: JSON.stringify({
            avatar_components: JSON.stringify(a),
            avatar_id: r,
            skin_id: n,
            is_host: o ? o == "host" : !0,
            skin_data_version: n !== void 0 && s !== void 0 ? n + s : void 0,
            rotation_render_type: l,
            is_all_sync: u,
            nick_name: encodeURIComponent(c || ""),
            app_id: f,
            camera: d,
            player: _,
            person: T,
            firends: JSON.stringify(g),
            sync_by_event: m,
            area_name: v,
            path_name: b,
            attitude: y,
            room_type_id: C,
            syncToOthers: A,
            hasAvatar: S,
            avatarSize: h,
            prioritySync: P,
            extra: JSON.stringify(R)
          })
        };
        _this.send(x), logger$1.warn("startGame", le(oe({}, x), {
          data: JSON.parse(x.data)
        }));
      });
      _this.network = e, _this.heartbeat = new Heartbeat({
        ping: function ping(t) {
          var r;

          if (!_this.connected) {
            _this.heartbeat.stop(), (r = e.room.stats) == null || r.assign({
              rtt: 0
            });
            return;
          }

          _this.send({
            id: "heartbeat",
            data: t
          });
        },

        pong(t) {
          var r;
          (r = e.room.stats) == null || r.assign({
            rtt: t
          });
        }

      });
      return _this;
    }

    _createClass(Socket, [{
      key: "connection",
      get: function get() {
        return this._ws;
      }
    }, {
      key: "start",
      value: function start() {
        var _this2 = this;

        this._hasTimeout = !1;
        var e = this.getAddress();
        logger$1.info("connecting to ".concat(e));
        var t = Date.now();
        this._ws = new WebSocket(e), this._openTimer = new Timeout$1(function () {
          var r = "Failed to open websocket in ".concat(DEFAULT_OPEN_TIMEOUT_MS, " ms");
          _this2._hasTimeout = !0, _this2.emit("socketClosed", new InitNetworkTimeoutError(r));
        }, DEFAULT_OPEN_TIMEOUT_MS), this._ws.onopen = function () {
          var r;
          (r = _this2._openTimer) == null || r.clear(), _this2.connected = !0, _this2.heartbeat.start(), _this2.network.room.currentNetworkOptions.reconnect || (logger$1.infoAndReportMeasurement({
            metric: "wsOpenedAt",
            group: "joinRoom",
            startTime: _this2.network.room._startTime
          }), logger$1.infoAndReportMeasurement({
            metric: "wsOpenedCost",
            group: "joinRoom",
            startTime: t
          }));
        }, this.handleWSEvent();
      }
    }, {
      key: "getAddress",
      value: function getAddress() {
        var _this$network$room$cu4 = this.network.room.currentNetworkOptions,
            e = _this$network$room$cu4.wsServerUrl,
            t = _this$network$room$cu4.reconnect,
            r = _this$network$room$cu4.sessionId,
            n = _this$network$room$cu4.token,
            o = _this$network$room$cu4.roomId,
            a = _this$network$room$cu4.userId,
            s = _this$network$room$cu4.pageSession,
            l = this.network.room.skinId;
        var u = e;
        t && (u = u + "?reconnect=true&lastSessionID=".concat(r));
        var c = "userId=".concat(a, "&roomId=").concat(o, "&pageSession=").concat(s) + (this.network.room.isHost ? "&skinId=".concat(l) : "") + (n ? "&token=".concat(n) : "");
        return u = u.indexOf("?") > -1 ? u + "&" + c : u + "?" + c, u;
      }
    }, {
      key: "handleWSEvent",
      value: function handleWSEvent() {
        var _this3 = this;

        var e = this._ws;
        e.addEventListener("error", function (t) {
          _this3.connected = !1, logger$1.error("webscoket error", t), _this3.emit("socketClosed", new InternalError("connect to address error: " + _this3.network.room.currentNetworkOptions.wsServerUrl));
        }), e.addEventListener("close", function (t) {
          _this3.connected = !1, _this3._onClose(t);
        }), e.addEventListener("message", function (t) {
          if (!t || _this3._hasTimeout || !_this3.connected) return;
          var r = null;

          try {
            r = JSON.parse(t.data);
          } catch (o) {
            logger$1.error(o);
            return;
          }

          if (!r) return;
          var n = r.id;
          if (!!n) switch (n !== "heartbeat" && logger$1.info("receive ws frame: ".concat(t.data)), n) {
            case "fail":
              break;

            case "init":
              try {
                var o = r.data.slice(-37, -1);
                reporter$1.updateBody({
                  serverSession: o
                });
              } catch (o) {
                console.error(o);
              }

              _this3.network.rtcp.start();

              break;

            case "heartbeat":
              _this3.heartbeat.pong(r.data);

              break;

            case "offer":
              _this3.network.rtcp.setRemoteDescription(r.data, _this3.network.stream.el);

              break;

            case "ice_candidate":
              _this3.network.rtcp.addCandidate(r.data);

              break;

            case "start":
              _this3.emit("gameRoomAvailable", r);

              break;

            case "error":
              try {
                var _JSON$parse = JSON.parse(r.data),
                    _o = _JSON$parse.Code,
                    a = _JSON$parse.Msg;

                if (_o) {
                  if (_o == 3003) return _this3.emit("socketClosed", new TokenExpiredError());
                  if (authenticationErrorCodes.indexOf(_o) > -1) return _this3.emit("socketClosed", new AuthenticationError("\u9274\u6743\u9519\u8BEF:" + a));
                  {
                    var s = util.getErrorByCode(_o);

                    _this3.emit("socketClosed", new s(a));
                  }
                }
              } catch (o) {
                logger$1.error(o), _this3.emit("socketClosed", new InternalError(r.data));
              }

              break;

            case "checkLatency":
              {
                var _o2 = r.packet_id,
                    _a = r.data.split(",");

                _this3.onLatencyCheck({
                  packetId: _o2,
                  addresses: _a
                });

                break;
              }

            default:
              logger$1.warn("unkown ws message type", n, r);
          }
        });
      }
    }, {
      key: "onLatencyCheck",
      value: function onLatencyCheck(e) {
        var _this4 = this;

        var t = _toConsumableArray(new Set(e.addresses || []));

        Promise.all(t.map(function (r) {
          return {
            [r]: 9999
          };
        })).then(function (r) {
          var n = Object.assign.apply(Object, [{}].concat(_toConsumableArray(r)));

          _this4.latency(n, e.packetId);
        });
      }
    }, {
      key: "wsNoReady",
      value: function wsNoReady() {
        return this._ws.readyState == WebSocket.CLOSED || this._ws.readyState == WebSocket.CLOSING || this._ws.readyState == WebSocket.CONNECTING;
      }
    }, {
      key: "prepareReconnect",
      value: function prepareReconnect() {
        this._close({
          code: WS_CLOSE_RECONNECT,
          reason: "reconnect"
        });
      }
    }, {
      key: "_onClose",
      value: function _onClose(_ref) {
        var e = _ref.code,
            t = _ref.reason;
        this._openTimer && this._openTimer.clear(), logger$1.warn("ws closed: ".concat(e, " ") + t), [WS_CLOSE_RECONNECT, WS_CLOSE_NORMAL].includes(e) || this.emit("socketClosed", new InternalError("Websocket error"));
      }
    }, {
      key: "_close",
      value: function _close(_ref2) {
        var e = _ref2.code,
            t = _ref2.reason;
        var r;
        (r = this._ws) == null || r.close(e, t);
      }
    }, {
      key: "quit",
      value: function quit() {
        this._close({
          code: WS_CLOSE_NORMAL,
          reason: "quit"
        });
      }
    }]);

    return Socket;
  }(EventEmitter);

  function add(i, e) {
    return e == -1 && (e = 0), i + e;
  }

  function max(i, e) {
    return Math.max(i, e);
  }

  function count_sd(i, e) {
    function t(r, n) {
      var o = 0;
      return n == -1 ? o = 0 : o = (n - e) * (n - e), r + o;
    }

    return Math.sqrt(i.reduce(t, 0) / i.reduce(count_valid, 0)) || 0;
  }

  function count_valid(i, e) {
    var t = 0;
    return e != -1 && (t = 1), i + t;
  }

  function count_less(i, e) {
    function t(r, n) {
      var o = 0;
      return n != -1 && n < e && (o = 1), r + o;
    }

    return i.reduce(t, 0);
  }

  var CircularArray = /*#__PURE__*/function () {
    function CircularArray(e, t, r) {
      _classCallCheck(this, CircularArray);

      this.sum = 0, this.incomingSum = 0, this.count = 0, this.incomingCount = 0, this.max = 0, this.incomingMax = 0, this.goodLess = 0, this.wellLess = 0, this.fairLess = 0, this.badLess = 0, this.countLess = !1, this.lessThreshes = [], this.incomingData = [], this.circularData = Array(e).fill(-1), this.circularPtr = 0, this.circularLength = e, t && (this.countLess = !0, this.lessThreshes = r);
    }

    _createClass(CircularArray, [{
      key: "add",
      value: function add(e) {
        this.circularData[this.circularPtr] != -1 ? (this.sum -= this.circularData[this.circularPtr], Math.abs(this.circularData[this.circularPtr] - this.max) < .01 && (this.circularData[this.circularPtr] = -1, this.max = this.getMax(!1))) : this.count += 1, this.sum += e, this.incomingSum += e, this.incomingCount += 1, this.max < e && (this.max = e), this.incomingMax < e && (this.incomingMax = e), this.circularData[this.circularPtr] = e, this.circularPtr = (this.circularPtr + 1) % this.circularLength, this.incomingData.push(e), this.incomingData.length > this.circularLength && (this.clearIncoming(), this.incomingCount = 0, this.incomingSum = 0);
      }
    }, {
      key: "computeAvg",
      value: function computeAvg(e) {
        return e.reduce(add, 0) / e.reduce(count_valid, 0) || 0;
      }
    }, {
      key: "computeMax",
      value: function computeMax(e) {
        return e.reduce(max, 0) || 0;
      }
    }, {
      key: "computeThreshPercent",
      value: function computeThreshPercent(e) {
        if (this.countLess) {
          var t = count_less(e, this.lessThreshes[0]) || 0,
              r = count_less(e, this.lessThreshes[1]) || 0,
              n = count_less(e, this.lessThreshes[2]) || 0,
              o = count_less(e, this.lessThreshes[3]) || 0,
              a = e.reduce(count_valid, 0);
          return [t, r, n, o, a];
        } else return [0, 0, 0, 0, 0];
      }
    }, {
      key: "getAvg",
      value: function getAvg() {
        var e = this.sum / this.count || 0,
            t = this.computeAvg(this.circularData) || 0;
        return Math.abs(e - t) > .01 && console.error("avg value mismatch: ", e, t), this.computeAvg(this.circularData) || 0;
      }
    }, {
      key: "getMax",
      value: function getMax() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : !0;
        var t = this.computeMax(this.circularData) || 0;
        return e && Math.abs(t - this.max) > .01 && console.error("max value mismatch: ", this.max, t), this.computeMax(this.circularData) || 0;
      }
    }, {
      key: "getStandardDeviation",
      value: function getStandardDeviation() {
        return count_sd(this.circularData, this.getAvg());
      }
    }, {
      key: "getThreshPercent",
      value: function getThreshPercent() {
        return this.computeThreshPercent(this.circularData);
      }
    }, {
      key: "getIncomingMax",
      value: function getIncomingMax() {
        return this.computeMax(this.incomingData) || 0;
      }
    }, {
      key: "getIncomingAvg",
      value: function getIncomingAvg() {
        return this.computeAvg(this.incomingData) || 0;
      }
    }, {
      key: "getIncomingStandardDeviation",
      value: function getIncomingStandardDeviation() {
        return count_sd(this.incomingData, this.getIncomingAvg());
      }
    }, {
      key: "getIncomingThreshPercent",
      value: function getIncomingThreshPercent() {
        return this.computeThreshPercent(this.incomingData);
      }
    }, {
      key: "clearFastComputeItem",
      value: function clearFastComputeItem() {
        this.sum = 0, this.incomingSum = 0, this.count = 0, this.incomingCount = 0, this.max = 0, this.incomingMax = 0, this.goodLess = 0, this.wellLess = 0, this.fairLess = 0, this.badLess = 0;
      }
    }, {
      key: "clearIncoming",
      value: function clearIncoming() {
        for (; this.incomingData.length > 0;) {
          this.incomingData.pop();
        }
      }
    }, {
      key: "clear",
      value: function clear() {
        this.circularData.fill(-1), this.circularPtr = 0, this.clearFastComputeItem(), this.clearIncoming();
      }
    }]);

    return CircularArray;
  }();

  function _createForOfIteratorHelper$5(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$5(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

  function _unsupportedIterableToArray$5(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$5(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$5(o, minLen); }

  function _arrayLikeToArray$5(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

  var defaultLogger = {
    info: console.log,
    debug: console.log,
    error: console.error,
    infoAndReportMeasurement: function infoAndReportMeasurement() {}
  };
  var USER_ID = "987412365",
      PAGE_SESSION = "aaabbbccc",
      SERVER_SESSION = "cccbbbaaa",
      COS_PREFIX = "error-bitstreams-auto-uploaded-from-application/",
      FRAME_COMPOSE_LENGTH = 5;

  var Workers = /*#__PURE__*/function () {
    function Workers(e, t) {
      var _this = this;

      _classCallCheck(this, Workers);

      this.rtcp = e, this.cacheSize = 0, this.cacheBuffer = new Uint8Array(262144), this.cacheFrameCnt = 0, this.startReceiveTime = 0, this.cacheFrameComposes = new Array(0), this.cacheSizes = new Array(5).fill(0), this.cacheFrameCnts = new Array(5).fill(-1), this.cacheStartReceiveTimes = new Array(5).fill(0), this.cacheBuffers = [new Uint8Array(262144), new Uint8Array(262144), new Uint8Array(262144), new Uint8Array(262144), new Uint8Array(262144)], this.panoCacheSize = 0, this.panoCacheBuffer = new Uint8Array(2097152), this.cachePanoTileID = 0, this.receivedMedia = 0, this.receivedMedia_worker = 0, this.receivedYUV = 0, this.receivedEmit = 0, this.returnFrames = 0, this.lastReturnFrames = 0, this.lastReceivedEmit = 0, this.mediaBytesReceived = 0, this.metaBytesReceived = 0, this.noWasmBytesReceived = 0, this.rtcBytesReceived = 0, this.rtcMessageReceived = 0, this.packetsDrop = 0, this.framesAwait = 0, this.sendOutBuffer = 0, this.decodeTimePerFrame = 0, this.decodeTimeMaxFrame = 0, this.lastRenderTs = 0, this.JankTimes = 0, this.bigJankTimes = 0, this.DecodeJankTimes = 0, this.bigDecodeJankTimes = 0, this.saveframe = !1, this.SaveMediaStream = !1, this.packetsLost = 0, this.showAllReceivedMetadata = !1, this.firstMediaArraval = 0, this.firstMediaReceived = !1, this.firstYUVDecoded = 0, this.firstRender = 0, this.firstYUVReceived = !1, this.reconnectSignal = !1, this.serverFrameSlow = 0, this.serverFrameFast = 0, this.clientFrameSlow = 0, this.clientFrameFast = 0, this.lastServerTS = 0, this.lastClientTS = 0, this.lastSeq = 0, this.lastIsPureMeta = !1, this.lastHBPacketTs = 0, this.HBPacketInterval = 0, this.lastHBPacketSrvSentTs = 0, this.HBPacketIntervalSrvSent = 0, this.cachedLength = 2, this.cachedStreams = new Array(this.cachedLength), this.cachedMetas = new Array(this.cachedLength), this.cachedPtss = new Array(this.cachedLength), this.cachedRender = Array(this.cachedLength).fill(!1), this.cachedResolution = new Array(this.cachedLength), this.getPtr = 0, this.setPtr = 0, this.receiveIframes = 0, this.decodeIframes = 0, this.prevSenderTs = -1, this.serverSendTimeArray = new CircularArray(120, !1, []), this.inPanoMode = !1, this.PanoStatus = {
        x: 0,
        y: 0,
        z: 0,
        tiles: []
      }, this.DynamicPanoTest = !1, this.PanoMask = new ArrayBuffer(8), this.PanoView = new DataView(this.PanoMask), this.userId_test = "", this.PendingMasks = [], this.traceIdMap = new Map(), this.responseTimeArray = [], this.processTimeArray = [], this.displayTimeArray = [], this.overallTimeArray = [], this.responseMiss = 0, this.processMiss = 0, this.displayMiss = 0, this.updateYUVCircular = new CircularArray(120, !1, []), this.updateDropFrame = 0, this.metaParseAraay = [], this.responseMoveMiss = 0, this.processMoveMiss = 0, this.displayMoveMiss = 0, this.MovingTraceId = "", this.PendingMovingTraceId = "", this.inMovingMode = !1, this.StartMovingTs = 0, this.PendingStartMovingTs = 0, this.moveEvent = "", this.MoveToFrameCnt = 0, this.lastIsMoving = 0, this.MoveResponseDelay = 0, this.MoveProcessDelay = 0, this.MoveDisplayDelay = 0, this.lastMoveResponseTime = 0, this.lastMoveProcessTime = 0, this.lastMoveDisplayTime = 0, this.moveResponseCircular = new CircularArray(120, !0, [STUCK_STAGE_GOOD, STUCK_STAGE_WELL, STUCK_STAGE_FAIR, STUCK_STAGE_BAD]), this.moveProcessCircular = new CircularArray(120, !0, [STUCK_STAGE_GOOD, STUCK_STAGE_WELL, STUCK_STAGE_FAIR, STUCK_STAGE_BAD]), this.moveDisplayCircular = new CircularArray(120, !0, [STUCK_STAGE_GOOD, STUCK_STAGE_WELL, STUCK_STAGE_FAIR, STUCK_STAGE_BAD]), this.moveStartPts = -1, this.frameServerCircular = new CircularArray(120, !1, []), this.srvMetaIntervalCircular = new CircularArray(120, !1, []), this.srvMediaIntervalCircular = new CircularArray(120, !1, []), this.srvHBMetaIntervalCircular = new CircularArray(120, !1, []), this.srvHBMetaIntervalSrvSentCircular = new CircularArray(120, !1, []), this.frameClientCircular = new CircularArray(120, !1, []), this.firstUpdateYUV = !0, this.functionMap = new Map(), this.WASM_VERSION = "WASM-1.1", this.frameHistory = [], this.getVersion = function () {
        return DECODER_VERSION;
      }, this.downloadBlob = function (r, n, o) {
        var a = new Blob([r], {
          type: o
        }),
            s = window.URL.createObjectURL(a);
        _this.downloadURL(s, n), setTimeout(function () {
          return window.URL.revokeObjectURL(s);
        }, 1e3);
      }, this.downloadURL = function (r, n) {
        var o = document.createElement("a");
        o.href = r, o.download = n, document.body.appendChild(o), o.style.display = "none", o.click(), o.remove();
      }, this.Stringify = function (r) {
        var n = "";

        for (var a = 0; a < r.length / 8192; a++) {
          n += String.fromCharCode.apply(null, r.slice(a * 8192, (a + 1) * 8192));
        }

        return n;
      }, this._rtcp = e;
    }

    _createClass(Workers, [{
      key: "registerLogger",
      value: function registerLogger(e) {//defaultLogger = e
      }
    }, {
      key: "registerFunction",
      value: function registerFunction(e, t) {
        this.functionMap.set(e, t);
      }
    }, {
      key: "hasFrmCntInCache",
      value: function hasFrmCntInCache(e) {
        var t = -1;

        for (var r = 0; r < this.cacheFrameComposes.length; r++) {
          this.cacheFrameComposes[r].frameCnt == e && (t = r);
        }

        return t;
      }
    }, {
      key: "requestPanoramaTest",
      value: function requestPanoramaTest(e, t, r, n, o) {
        var a = o,
            s = {
          action_type: 16,
          change_rotation_render_type_action: {
            render_type: 5,
            player: {
              position: {
                x: 0,
                y: 0,
                z: 0
              },
              angle: {
                yaw: 0,
                pitch: 0,
                roll: 0
              }
            },
            camera: {
              position: {
                x: e,
                y: t,
                z: r
              },
              angle: {
                yaw: 0,
                pitch: 0,
                roll: 0
              }
            },
            client_pano_titles_bitmap: n
          },
          trace_id: a,
          user_id: this.userId_test,
          packet_id: a
        };
        defaultLogger.debug("send data: ", s), this._rtcp.sendData(s);
      }
    }, {
      key: "onRotateInPanoMode",
      value: function onRotateInPanoMode(e) {
        var t = e.traceId,
            r = {};
        r.width = 1280, r.height = 720, r.horz_fov = 92, r.angle = {
          yaw: 100,
          pitch: 30
        };
        var n = new ArrayBuffer(8),
            o = new DataView(n);
        getTilesInView(r, n);
        var a = n.slice(0);
        this.PendingMasks.unshift({
          buffer: a,
          angle: r.angle
        }), MaskSetToOne(18, this.PanoView), operateForDataView(o, this.PanoView, o, function (s, l) {
          return s ^ s & l;
        }), this.requestPanoramaTest(0, 0, 0, [o.getUint8(0), o.getUint8(1), o.getUint8(2), o.getUint8(3), o.getUint8(4), o.getUint8(5), o.getUint8(6), o.getUint8(7)], t);
      }
    }, {
      key: "processMetaWithTraceId",
      value: function processMetaWithTraceId(e) {
        var _iterator = _createForOfIteratorHelper$5(e.traceIds),
            _step;

        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var t = _step.value;

            if (this.traceIdMap.has(t)) {
              var r = this.traceIdMap.get(t);
              r != null && (r.receiveTime = Date.now(), r.status = 1);
            }

            if (t == this.PendingMovingTraceId) {
              this.inMovingMode = !0, this.MovingTraceId = this.PendingMovingTraceId, this.StartMovingTs = this.PendingStartMovingTs, this.PendingMovingTraceId = "", this.PendingStartMovingTs = 0, defaultLogger.info("MoveTo TraceId match", this.StartMovingTs, Date.now());

              var _r = Date.now();

              this.lastMoveResponseTime = _r, this.lastMoveProcessTime = _r, this.lastMoveDisplayTime = _r, this.frameServerCircular.clear(), this.frameClientCircular.clear();
            }
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }
      }
    }, {
      key: "onTraceId",
      value: function onTraceId(e) {
        var _this2 = this;
        var r = e.traceId,
            n = e.timestamp,
            o = e.event;

        if (o === "Rotation") {
          var a = {
            traceId: r,
            pts: 0,
            startTime: n,
            receiveTime: 0,
            readyTime: 0,
            displayTime: 0,
            status: 0
          };
          this.traceIdMap.set(r, a);
          var s = setTimeout(function () {
            if (s && clearTimeout(s), _this2.traceIdMap.has(r)) {
              var l = _this2.traceIdMap.get(r);

              switch (l == null ? void 0 : l.status) {
                case 0:
                  {
                    _this2.responseMiss += 1;
                    break;
                  }

                case 1:
                  {
                    _this2.processMiss += 1;
                    var u = l.receiveTime - l.startTime;

                    _this2.responseTimeArray.push(u);

                    break;
                  }

                case 2:
                  {
                    _this2.displayMiss += 1;

                    var _u = l.receiveTime - l.startTime,
                        c = l.readyTime - l.receiveTime;

                    _this2.responseTimeArray.push(_u), _this2.processTimeArray.push(c);
                    break;
                  }

                case 3:
                  defaultLogger.debug("status is 3");
              }
            }
          }, 1e3);
        } else o === "MoveTo" ? (defaultLogger.info("receive moveto traceId ", r, " at timestamp", n), this.PendingMovingTraceId = r, this.PendingStartMovingTs = n, this.moveEvent = o, this.frameServerCircular.clear()) : o === "GetOnAirship" || o === "GetOnVehicle" ? (defaultLogger.info("receive airship traceId ", r, " at timestamp ", n), this.PendingMovingTraceId = r, this.PendingStartMovingTs = n, this.moveEvent = o, this.frameServerCircular.clear()) : (o === "GetOffAirship" || o === "GetOffVehicle") && this.clearMoveArray();
      }
    }, {
      key: "executeFunction",
      value: function executeFunction(e, t) {
        if (this.functionMap.has(e)) {
          var r = this.functionMap.get(e);
          r != null && r(t);
        }
      }
    }, {
      key: "UpdateStats",
      value: function UpdateStats(e) {
        var _this3 = this;

        var t;
        (t = this._rtcp.connection) == null || t.getStats(null).then(function (r) {
          r.forEach(function (n) {
            n.type == "data-channel" && (_this3.rtcMessageReceived = n.messagesReceived - n.messagesSent, _this3.rtcBytesReceived = n.bytesReceived);
          });
        }), this.receivedMedia_worker = e.data.framesReceived, this.receivedYUV = e.data.framesDecoded, this.receivedEmit = e.data.framesRendered, this.mediaBytesReceived = e.data.mediaBytesReceived, this.metaBytesReceived = e.data.metaBytesReceived, this.packetsLost = e.data.packetsLost, this.packetsDrop = e.data.packetsDrop, this.framesAwait = e.data.framesAwait, this.decodeTimePerFrame = e.data.decodeTimePerFrame, this.decodeTimeMaxFrame = e.data.decodeTimeMaxFrame, this.returnFrames = e.data.framesReturned, this.sendOutBuffer = e.data.sendOutBuffer, this.DecodeJankTimes = e.data.JankTimes, this.bigDecodeJankTimes = e.data.bigJankTimes, this.receiveIframes = e.data.receivedIframe, this.decodeIframes = e.data.decodedIframe;
      }
    }, {
      key: "ReceiveDecodeMessage",
      value: function ReceiveDecodeMessage(e) {
        var n;

        if (!this.firstYUVReceived) {
          this.firstYUVDecoded = e.data.yuv_ts;
          var o = this.firstYUVDecoded - this.rtcp.network.room._startTime;
          defaultLogger.infoAndReportMeasurement({
            metric: "firstYUVDecodedAt",
            value: o,
            group: "joinRoom"
          }), this.firstRender = Date.now();
          var a = this.firstYUVDecoded - this.rtcp.network.room._startTime;
          defaultLogger.infoAndReportMeasurement({
            metric: "firstRenderAt",
            value: a,
            group: "joinRoom"
          }), this.firstYUVReceived = !0, this.lastRenderTs = Date.now();
        }

        !this.cachedRender[this.setPtr] && this.cachedMetas[this.setPtr] != null && (this.cachedStreams[this.setPtr] != null && this.cachedStreams[this.setPtr].byteLength != 0 && (e.data.data == null ? (this.executeFunction("stream", {
          stream: this.cachedStreams[this.setPtr],
          width: this.cachedResolution[this.setPtr].width,
          height: this.cachedResolution[this.setPtr].height,
          pts: this.cachedPtss[this.setPtr]
        }), this.executeFunction("signal", {
          signal: this.cachedMetas[this.setPtr],
          pts: this.cachedPtss[this.setPtr],
          alreadyUpdateYUV: !0
        })) : this.updateDropFrame += 1, this.decoderWorker.postMessage({
          t: 2,
          frameCnt: this.cachedPtss[this.setPtr],
          buffer: this.cachedStreams[this.setPtr]
        }, [this.cachedStreams[this.setPtr].buffer])), this.getPtr = (this.getPtr + 1) % this.cachedLength);
        var t = e.data.metadata;

        if ((n = t == null ? void 0 : t.traceIds) != null && n.length) {
          var _iterator2 = _createForOfIteratorHelper$5(t.traceIds),
              _step2;

          try {
            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
              var _o = _step2.value;

              if (this.traceIdMap.has(_o)) {
                var _a = this.traceIdMap.get(_o);

                _a != null && (_a.readyTime = Date.now(), _a.status = 2);
              }
            }
          } catch (err) {
            _iterator2.e(err);
          } finally {
            _iterator2.f();
          }
        }

        if (e.data.pts == this.moveStartPts && (this.MoveProcessDelay = Date.now() - this.StartMovingTs), this.userId_test = this.rtcp.network.room.userId, this.inMovingMode) {
          var _o2 = Date.now(),
              _a2 = _o2 - this.lastMoveProcessTime;

          this.moveProcessCircular.add(_a2), this.lastMoveProcessTime = _o2;
        }

        var r = this.setPtr;
        this.cachedStreams[r] = e.data.data, this.cachedMetas[r] = e.data.metadata, this.cachedPtss[r] = e.data.pts, this.cachedRender[r] = !1, this.cachedResolution[r] = {
          width: e.data.width,
          height: e.data.height
        }, this.setPtr = (this.setPtr + 1) % this.cachedLength;
      }
    }, {
      key: "SendCacheFrameInfo",
      value: function SendCacheFrameInfo(e) {
        var _this4 = this;

        var h, f, d, _, g, m, v;

        var t = e.data.cachedKey,
            r = e.data.metadata,
            n = t,
            o = r,
            a = (d = (f = (h = o.newUserStates) == null ? void 0 : h.find(function (y) {
          return y.userId === _this4.rtcp.network.room.userId;
        })) == null ? void 0 : f.playerState) == null ? void 0 : d.roomTypeId,
            s = this.rtcp.network.room.skinId,
            l = (v = (m = (g = (_ = o.newUserStates) == null ? void 0 : _.find(function (y) {
          return y.userId === _this4._rtcp.network.room.userId;
        })) == null ? void 0 : g.playerState) == null ? void 0 : m.player) == null ? void 0 : v.position,
            u = {
          MsgType: 1,
          FrameCacheMsg: {
            FrameIndex: n,
            RoomTypeId: a,
            SkinID: s,
            Position: l
          }
        };
        var c = "";

        try {
          c = JSON.stringify(u);
        } catch (y) {
          defaultLogger.error(y);
          return;
        }
      }
    }, {
      key: "ReceivePanoramaDecodeMessage",
      value: function ReceivePanoramaDecodeMessage(e) {
        defaultLogger.info("Receive Panorama Image in Workers.ts"), MaskSetToOne(e.data.tileId, this.PanoView);
        var t = 0,
            r;
        var n = this.PendingMasks.length;

        for (t = 0; t < n; t++) {
          var o = this.PendingMasks[t].buffer,
              a = new DataView(o),
              s = new ArrayBuffer(8),
              l = new DataView(s);

          if (operateForDataView(this.PanoView, a, l, function (u, c) {
            return c ^ u & c;
          }), IsAll0(l)) {
            r = this.PendingMasks[t].angle;
            break;
          }
        }

        for (var _o3 = t; _o3 < n; _o3++) {
          this.PendingMasks.pop();
        }

        this.executeFunction("panorama", {
          data: e.data.data,
          tileId: e.data.tileId,
          pos: {
            x: e.data.x,
            y: e.data.y,
            z: e.data.z
          },
          uuid: e.data.uuid,
          finished: !0,
          matchAngle: r
        });
      }
    }, {
      key: "enable_decoder_queue_logging",
      value: function enable_decoder_queue_logging() {
        this.decoderWorker.postMessage({
          t: 100,
          status: !0
        });
      }
    }, {
      key: "disable_decoder_queue_logging",
      value: function disable_decoder_queue_logging() {
        this.decoderWorker.postMessage({
          t: 100,
          status: !1
        });
      }
    }, {
      key: "init",
      value: function () {
        var _init = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
          var _this5 = this;

          var e,
              r,
              n,
              t,
              _args = arguments;
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  e = _args.length > 0 && _args[0] !== undefined ? _args[0] : {
                    width: 1280,
                    height: 720
                  };

                  for (r = 0; r < FRAME_COMPOSE_LENGTH; r++) {
                    n = {
                      buffer: new Uint8Array(2621440),
                      size: 0,
                      startReceiveTime: 0,
                      serverTime: 0,
                      frameCnt: -1
                    };
                    this.cacheFrameComposes.push(n);
                  }

                  t = new Blob([decoder], {
                    type: "application/javascript"
                  });
                  this.decoderWorker = new Worker(URL.createObjectURL(t));
                  this.decoderWorker.postMessage({
                    t: 9,
                    url: WASM_URLS[WASM_Version],
                    jitterLength: DECODER_PASSIVE_JITTER
                  });
                  this.decoderWorker.postMessage({
                    t: 1,
                    config: e
                  });
                  return _context.abrupt("return", new Promise(function (r) {
                    _this5.decoderWorker.onmessage = function (n) {
                      switch (n.data.t) {
                        case 0:
                          _this5.ReceiveDecodeMessage(n);

                          break;

                        case 1:
                          _this5.UpdateStats(n);

                          break;

                        case 2:
                          r();
                          break;

                        case 3:
                          _this5.SendCacheFrameInfo(n);

                          break;

                        case 4:
                          {
                            var o = new Date().toISOString(),
                                a = USER_ID + "-" + PAGE_SESSION + "-" + SERVER_SESSION + "-" + o + ".264";
                            uploadStream(COS_PREFIX + a, n.data.fileObj);
                            break;
                          }

                        case 5:
                          _this5.executeFunction("signal", {
                            signal: n.data.metadata,
                            pts: -1,
                            alreadyUpdateYUV: !1
                          });

                          break;

                        case 6:
                          defaultLogger.infoAndReportMeasurement(n.data), defaultLogger.debug("WASM Ready Cost");
                          break;

                        case 7:
                          _this5.ReceivePanoramaDecodeMessage(n);

                          break;

                        case 8:
                          {
                            var _o4 = {
                              MstType: 0
                            };
                            var _a3 = "";

                            try {
                              _a3 = JSON.stringify(_o4);
                            } catch (l) {
                              defaultLogger.error(l);
                              return;
                            }

                            var s = "wasm:" + _a3;

                            _this5._rtcp.sendStringData(s);

                            break;
                          }

                        case 9:
                          {
                            defaultLogger.info(n.data.printMsg);
                            break;
                          }

                        case 10:
                          {
                            defaultLogger.error(n.data.printMsg), _this5.executeFunction("error", {
                              code: n.data.code,
                              message: n.data.printMsg
                            });
                            break;
                          }

                        default:
                          defaultLogger.error("Receive unknown message event from decoder"), defaultLogger.debug(n.data);
                          break;
                      }
                    };
                  }));

                case 7:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function init() {
          return _init.apply(this, arguments);
        }

        return init;
      }()
    }, {
      key: "UpdateYUV",
      value: function UpdateYUV() {
        var t, r;
        var e = this.getPtr;

        if (this.cachedMetas[e] != null && !this.cachedRender[e]) {
          var n = Date.now();

          if (this.firstUpdateYUV) {
            var h = ((t = this.cachedStreams[e]) == null ? void 0 : t.byteLength) || 0;
            defaultLogger.infoAndReportMeasurement({
              metric: "firstUpdateStreamLength",
              value: h,
              group: "joinRoom"
            }), this.firstUpdateYUV = !1;
          }

          this.cachedStreams[e] != null && this.executeFunction("stream", {
            stream: this.cachedStreams[e],
            width: this.cachedResolution[e].width,
            height: this.cachedResolution[e].height,
            pts: this.cachedPtss[e]
          });
          var o = Date.now();
          this.cachedStreams[e] != null && this.decoderWorker.postMessage({
            t: 2,
            frameCnt: this.cachedPtss[e],
            buffer: this.cachedStreams[e]
          }, [this.cachedStreams[e].buffer]);
          var a = Date.now(),
              s = o - n,
              l = a - o;
          (s > 33 || l > 10) && defaultLogger.debug("[wwwarning] updateYUV takes ", s, " ms, postMessage takes ", l, " ms for index ", this.cachedPtss[e]), o - this.lastRenderTs > 84 && this.JankTimes++, o - this.lastRenderTs > 125 && this.bigJankTimes++, this.lastRenderTs = o;
          var u = o - n;
          this.updateYUVCircular.add(u);
          var c = this.cachedMetas[e];

          if ((r = c == null ? void 0 : c.traceIds) != null && r.length) {
            var _iterator3 = _createForOfIteratorHelper$5(c.traceIds),
                _step3;

            try {
              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
                var _h = _step3.value;

                if (this.traceIdMap.has(_h)) {
                  var f = this.traceIdMap.get(_h);

                  if (f != null) {
                    f.displayTime = Date.now(), f.status = 3;

                    var d = f.receiveTime - f.startTime,
                        _ = f.readyTime - f.receiveTime,
                        g = f.displayTime - f.readyTime,
                        m = f.displayTime - f.startTime;

                    this.responseTimeArray.push(d), this.processTimeArray.push(_), this.displayTimeArray.push(g), this.overallTimeArray.push(m), this.traceIdMap.delete(_h);
                  }
                }
              }
            } catch (err) {
              _iterator3.e(err);
            } finally {
              _iterator3.f();
            }
          }

          if (this.cachedPtss[e] == this.moveStartPts && (this.MoveDisplayDelay = Date.now() - this.StartMovingTs), this.inMovingMode) {
            var _h2 = Date.now(),
                _f = _h2 - this.lastMoveDisplayTime;

            this.moveDisplayCircular.add(_f), this.lastMoveDisplayTime = _h2;
          }

          this.executeFunction("signal", {
            signal: this.cachedMetas[e],
            pts: this.cachedPtss[e],
            alreadyUpdateYUV: !0
          }), this.cachedRender[e] = !0, this.getPtr = (this.getPtr + 1) % this.cachedLength;
        }
      }
    }, {
      key: "unmarshalPano",
      value: function unmarshalPano(e) {
        var t = new DataView(e);
        if (t.getUint32(0) != 1723558763) return !1;
        console.log("Receive Pano Message"), t.getUint16(4);
        var n = t.getUint16(6),
            o = t.getUint32(8),
            a = t.getUint32(12) - (1 << 30) * 2,
            s = t.getUint32(16) - (1 << 30) * 2,
            l = t.getUint32(20) - (1 << 30) * 2,
            u = t.getUint32(24),
            c = new Uint8Array(e).subarray(28, 64),
            h = String.fromCharCode.apply(null, c),
            f = t.getUint32(64),
            d = e.byteLength - n;

        if (d == u) {
          var g = {
            data: new Uint8Array(e).subarray(n),
            mediaLen: u,
            tileId: o,
            uuid: h,
            x: a,
            y: s,
            z: l
          };
          this.decoderWorker.postMessage({
            t: 8,
            data: g
          });
        } else {
          var _ = new Uint8Array(e, n, d);

          if (this.cachePanoTileID == o) {
            if (this.panoCacheBuffer.set(_, f), this.panoCacheSize += d, this.panoCacheSize === u) {
              var m = {
                data: new Uint8Array(this.panoCacheBuffer).slice(0, u),
                mediaLen: u,
                tileId: o,
                uuid: h,
                x: a,
                y: s,
                z: l
              };
              this.decoderWorker.postMessage({
                t: 8,
                data: m
              }), this.panoCacheSize = 0;
            }
          } else this.panoCacheBuffer.set(_, f), this.panoCacheSize = d, this.cachePanoTileID = o;
        }

        return !0;
      }
    }, {
      key: "clearMoveArray",
      value: function clearMoveArray() {
        this.MovingTraceId = "", this.inMovingMode = !1, this.StartMovingTs = 0, this.MoveToFrameCnt = 0, this.MoveResponseDelay = 0, this.MoveProcessDelay = 0, this.MoveDisplayDelay = 0, this.moveStartPts = -1, this.moveResponseCircular.clear(), this.moveProcessCircular.clear(), this.moveDisplayCircular.clear(), this.moveEvent = "";
      }
    }, {
      key: "getIsMoving",
      value: function getIsMoving(e) {
        var t;
        if (typeof e.newUserStates != "undefined") for (var r = 0; r < e.newUserStates.length; r++) {
          var n = e.newUserStates[r];

          if (n.userId == this.rtcp.network.room.userId) {
            t = n.renderInfo.isMoving;
            break;
          }
        }
        return t;
      }
    }, {
      key: "isHeartBeatPacket",
      value: function isHeartBeatPacket(e, t) {
        return new DataView(e).getUint32(0) == 2009889916;
      }
    }, {
      key: "resetSendTimeDiff",
      value: function resetSendTimeDiff() {
        this.prevSenderTs = 0, this.serverSendTimeArray.clear();
      }
    }, {
      key: "calcSendTimeDiff",
      value: function calcSendTimeDiff(e) {
        if (this.prevSenderTs == -1) {
          this.prevSenderTs = e;
          return;
        }

        var t = e - this.prevSenderTs;
        this.serverSendTimeArray.add(t), this.prevSenderTs = e;
      }
    }, {
      key: "unmarshalStream",
      value: function unmarshalStream(e) {
        var _this6 = this;

        var T, C, A, S, P, R, M, x, I, w;
        var t = new DataView(e);
        if (t.getUint32(0) != 1437227610) return !1;
        t.getUint16(4);
        var n = t.getUint16(6),
            o = t.getUint16(8),
            a = o,
            s = t.getUint16(10);
        var l = !1;
        s == 1 && (l = !0);

        var u = t.getUint32(12),
            c = t.getUint32(16),
            h = t.getUint32(20),
            f = t.getUint16(24),
            d = t.getUint16(26),
            _ = t.getUint32(28),
            g = t.getUint32(n - 4),
            m = u + c,
            v = e.byteLength - n,
            y = new Uint8Array(e, n, v);

        this.calcSendTimeDiff(h);
        var b;
        if (this.inPanoMode && (c > 0 || f)) return defaultLogger.error("Stream Protocal Violation: receive illegal stream in Pano mode"), !0;

        if (v === m) {
          this.receivedMedia++;
          var O = new Uint8Array(e).subarray(n);
          h - this.lastServerTS > 60 ? this.serverFrameSlow++ : h - this.lastServerTS < 16 && this.serverFrameFast++;
          var D = Date.now();
          D - this.lastClientTS > 60 ? this.clientFrameSlow++ : D - this.lastClientTS < 16 && this.clientFrameFast++;
          var F = c === 0,
              V = h - this.lastServerTS;
          this.lastServerTS != 0 && ((o + 65536 - this.lastSeq) % 65536 === 1 && this.lastIsPureMeta == F && (F ? this.srvMetaIntervalCircular.add(V) : this.srvMediaIntervalCircular.add(V)), this.frameServerCircular.add(V), this.frameClientCircular.add(D - this.lastClientTS)), this.lastSeq = o, this.lastIsPureMeta = F, this.lastServerTS = h, this.lastClientTS = D;
          var N = O.subarray(0, u),
              L = Date.now(),
              k = JSON.parse(this.Stringify(N)),
              U = Date.now();
          this.showAllReceivedMetadata && console.log(h, D, k), this.metaParseAraay.push(U - L), (T = k.traceIds) != null && T.length && this.processMetaWithTraceId(k), c != 0 && this.moveStartPts == -1 && this.inMovingMode && (this.moveStartPts = o), this.moveStartPts == o && (this.MoveResponseDelay = Date.now() - this.StartMovingTs, console.log("move response delay: ", o, this.moveStartPts, this.MoveResponseDelay));
          var z = this.getIsMoving(k);

          if (this.inMovingMode && z == 0 && this.lastIsMoving == 1 && this.clearMoveArray(), typeof z != "undefined" && (this.lastIsMoving = z), this.inMovingMode) {
            var G = Date.now(),
                W = G - this.lastMoveResponseTime;
            this.moveResponseCircular.add(W), this.lastMoveResponseTime = G;
          }

          (f || d) && (b = (P = (S = (A = (C = k.newUserStates) == null ? void 0 : C.find(function (G) {
            return G.userId === _this6._rtcp.network.room.userId;
          })) == null ? void 0 : A.playerState) == null ? void 0 : S.player) == null ? void 0 : P.position);
          var H = {
            t: 0,
            data: O,
            mediaLen: c,
            metaLen: u,
            metadata: k,
            frameCnt: a,
            server_ts: h,
            isIDR: l,
            cacheRequest: d,
            cached: f,
            cachedKey: _,
            position: b
          };
          if (this.inPanoMode) return this.executeFunction("signal", {
            signal: k,
            pts: -1,
            alreadyUpdateYUV: !0
          }), !0;

          if (this.decoderWorker.postMessage(H, [O.buffer]), !this.firstMediaReceived) {
            this.firstMediaArraval = Date.now();

            var _G = this.firstMediaArraval - this.rtcp.network.room._startTime;

            defaultLogger.infoAndReportMeasurement({
              metric: "firstMediaArravalAt",
              value: _G,
              group: "joinRoom"
            }), this.firstMediaReceived = !0;
          }
        } else {
          var _O = this.hasFrmCntInCache(a);

          if (_O != -1) {
            if (this.cacheFrameComposes[_O].buffer.set(y, g), this.cacheFrameComposes[_O].size += v, this.cacheFrameComposes[_O].size === m) {
              var _D = new Uint8Array(this.cacheFrameComposes[_O].buffer).slice(0, m);

              this.cacheFrameComposes[_O].frameCnt = -1, this.cacheFrameComposes[_O].size = 0, this.cacheFrameComposes[_O].startReceiveTime = 0, this.cacheFrameComposes[_O].serverTime = 0, this.receivedMedia++, h - this.lastServerTS > 60 ? this.serverFrameSlow++ : h - this.lastServerTS < 16 && this.serverFrameFast++;

              var _F = Date.now();

              _F - this.lastClientTS > 60 ? this.clientFrameSlow++ : _F - this.lastClientTS < 16 && this.clientFrameFast++, this.lastServerTS != 0 && (this.frameServerCircular.add(h - this.lastServerTS), this.frameClientCircular.add(_F - this.lastClientTS)), this.lastServerTS = h, this.lastClientTS = _F;

              var _V = _D.subarray(0, u),
                  _N = Date.now(),
                  _L = JSON.parse(this.Stringify(_V)),
                  _k = Date.now();

              this.showAllReceivedMetadata && console.log(h, _F, _L), this.metaParseAraay.push(_k - _N), (R = _L.traceIds) != null && R.length && this.processMetaWithTraceId(_L), c != 0 && this.moveStartPts == -1 && this.inMovingMode && (this.moveStartPts = o), this.moveStartPts == o && (this.MoveResponseDelay = Date.now() - this.StartMovingTs);

              var _U = this.getIsMoving(_L);

              if (this.inMovingMode && _U == 0 && this.lastIsMoving == 1 && this.clearMoveArray(), typeof _U != "undefined" && (this.lastIsMoving = _U), this.inMovingMode) {
                var _H = Date.now(),
                    _G2 = _H - this.lastMoveResponseTime;

                this.moveResponseCircular.add(_G2), this.lastMoveResponseTime = _H;
              }

              (f || d) && (b = (w = (I = (x = (M = _L.newUserStates) == null ? void 0 : M.find(function (H) {
                return H.userId === _this6._rtcp.network.room.userId;
              })) == null ? void 0 : x.playerState) == null ? void 0 : I.player) == null ? void 0 : w.position);
              var _z = {
                t: 0,
                data: _D,
                mediaLen: c,
                metaLen: u,
                metadata: _L,
                frameCnt: a,
                server_ts: h,
                isIDR: l,
                cacheRequest: d,
                cached: f,
                cachedKey: _,
                position: b
              };
              if (this.inPanoMode) return this.executeFunction("signal", {
                signal: _L,
                pts: -1,
                alreadyUpdateYUV: !0
              }), !0;

              if (this.decoderWorker.postMessage(_z, [_D.buffer]), !this.firstMediaReceived) {
                this.firstMediaArraval = Date.now();

                var _H2 = this.firstMediaArraval - this.rtcp.network.room._startTime;

                defaultLogger.infoAndReportMeasurement({
                  metric: "firstMediaArravalAt",
                  value: _H2,
                  group: "joinRoom"
                }), this.firstMediaReceived = !0;
              }
            } else this.cacheFrameComposes[_O].size > m && defaultLogger.debug("I frame exceed, cache size is ", this.cacheSize, ", total size is ", m);
          } else if (_O == -1) {
            var _D2 = this.hasFrmCntInCache(-1);

            if (_D2 == -1) {
              var _F2 = Date.now() + 1e18,
                  _V2 = -1;

              for (var _N2 = 0; _N2 < this.cacheFrameComposes.length; _N2++) {
                this.cacheFrameComposes[_N2].serverTime < _F2 && (_F2 = this.cacheFrameComposes[_N2].serverTime, _V2 = _N2);
              }

              _D2 = _V2;
            }

            this.cacheFrameComposes[_D2].buffer.set(y, g), this.cacheFrameComposes[_D2].size = v, this.cacheFrameComposes[_D2].frameCnt = a, this.cacheFrameComposes[_D2].startReceiveTime = Date.now(), this.cacheFrameComposes[_D2].serverTime = h;
          }
        }

        return !0;
      }
    }, {
      key: "reset",
      value: function reset() {
        defaultLogger.debug("Worker reset is called"), this.cacheFrameCnt = 0, this.receivedMedia = 0, this.reconnectSignal = !0, this.decoderWorker.postMessage({
          t: 4
        });
      }
    }, {
      key: "dataHandleOff",
      value: function dataHandleOff(e) {
        defaultLogger.debug("hhh");
      }
    }, {
      key: "dataHandle",
      value: function dataHandle(e) {
        this.saveframe && (this.decoderWorker.postMessage({
          t: 6
        }), this.saveframe = !1), this.SaveMediaStream && (this.decoderWorker.postMessage({
          t: 7
        }), this.SaveMediaStream = !1);
        var t = new Uint8Array(e);
        if (t.length >= 4 && this.isHeartBeatPacket(t.buffer, t.length) == !0) return;

        if (t.length > 36 && this.unmarshalStream(t.buffer) == !0) {
          this.reconnectSignal && (this.executeFunction("reconnectedFrame", {}), this.reconnectSignal = !1);
          return;
        }

        if (t.length > 20 && this.unmarshalPano(t.buffer) == !0) return;
        this.noWasmBytesReceived += e.byteLength;
        var r = JSON.parse(this.Stringify(t));
        this.executeFunction("signal", {
          signal: r,
          pts: -1,
          alreadyUpdateYUV: !0
        });
      }
    }, {
      key: "changePanoMode",
      value: function changePanoMode(e) {
        this.inPanoMode = e;
      }
    }, {
      key: "uploadDataToServer",
      value: function uploadDataToServer() {
        this.DynamicPanoTest == !0 && (this.onRotateInPanoMode({
          traceId: "b2e1a296-6438-4371-8a31-687beb724ebe"
        }), this.DynamicPanoTest = !1);

        function e(ie, ee) {
          return ee == -1 && (ee = 0), ie + ee;
        }

        function t(ie, ee) {
          return Math.max(ie, ee);
        }

        var r = this.responseTimeArray.reduce(e, 0) / this.responseTimeArray.length || 0,
            n = this.processTimeArray.reduce(e, 0) / this.processTimeArray.length || 0,
            o = this.displayTimeArray.reduce(e, 0) / this.displayTimeArray.length || 0,
            a = this.overallTimeArray.reduce(e, 0) / this.overallTimeArray.length || 0,
            s = this.overallTimeArray.length;
        this.responseTimeArray = [], this.processTimeArray = [], this.displayTimeArray = [], this.overallTimeArray = [];

        var l = this.moveResponseCircular.getThreshPercent(),
            u = l[0],
            c = l[1],
            h = l[2],
            f = l[3],
            d = l[4],
            _ = d - f,
            g = 1 - c / d || 0,
            m = [u, c - u, h - c, f - h, _],
            v = this.moveProcessCircular.getThreshPercent(),
            y = v[0],
            b = v[1],
            T = v[2],
            C = v[3],
            A = v[4],
            S = A - C,
            P = 1 - b / A || 0,
            R = [y, b - y, T - b, C - T, S],
            M = this.moveDisplayCircular.getThreshPercent(),
            x = M[0],
            I = M[1],
            w = M[2],
            O = M[3],
            D = M[4],
            F = D - O,
            V = 1 - I / D || 0,
            N = [x, I - x, w - I, O - w, F],
            L = x,
            k = I - x,
            U = w - I,
            z = O - w,
            H = F,
            G = this.moveResponseCircular.getAvg(),
            W = this.moveProcessCircular.getAvg(),
            j = this.moveDisplayCircular.getAvg(),
            B = this.moveResponseCircular.getMax(),
            X = this.moveProcessCircular.getMax(),
            $ = this.moveDisplayCircular.getMax(),
            Y = this.moveResponseCircular.getStandardDeviation(),
            K = this.moveProcessCircular.getStandardDeviation(),
            Z = this.moveDisplayCircular.getStandardDeviation();

        this.moveResponseCircular.getIncomingAvg(), this.moveProcessCircular.getIncomingAvg(), this.moveDisplayCircular.getIncomingAvg(), this.moveResponseCircular.getIncomingMax(), this.moveProcessCircular.getIncomingMax(), this.moveDisplayCircular.getIncomingMax(), this.moveResponseCircular.clearIncoming(), this.moveProcessCircular.clearIncoming(), this.moveDisplayCircular.clearIncoming();
        var q = this.frameServerCircular.getAvg(),
            J = this.frameServerCircular.getMax();
        this.frameClientCircular.getAvg(), this.frameClientCircular.getMax();
        var Q = this.metaParseAraay.reduce(e, 0) / this.metaParseAraay.length || 0,
            te = this.metaParseAraay.reduce(t, 0);
        this.metaParseAraay = [];
        var re = {
          mediaBytesReceived: this.mediaBytesReceived,
          metaBytesReceived: this.metaBytesReceived,
          packetsLost: this.packetsLost,
          timestamp: Date.now(),
          frameHeight: 1280,
          frameWidth: 720,
          framesReceived: this.receivedMedia,
          framesReceivedWorker: this.receivedMedia_worker,
          framesDecoded: this.receivedYUV,
          framesEmited: this.receivedEmit,
          decodeTimePerFrame: this.decodeTimePerFrame,
          decodeTimeMaxFrame: this.decodeTimeMaxFrame,
          packetsDrop: this.packetsDrop,
          framesAwait: this.framesAwait,
          firstMediaArraval: this.firstMediaArraval,
          firstYUVDecoded: this.firstYUVDecoded,
          firstRender: this.firstRender,
          returnFrames: this.returnFrames,
          sendOutBuffer: this.sendOutBuffer,
          maxGraphicTime: this.updateYUVCircular.getMax(),
          averageGraphicTime: this.updateYUVCircular.getAvg(),
          jankTimes: this.JankTimes,
          bigJankTimes: this.bigJankTimes,
          decodeJankTimes: this.DecodeJankTimes,
          bigDecodeJankTimes: this.bigDecodeJankTimes,
          serverFrameSlow: this.serverFrameSlow,
          serverFrameFast: this.serverFrameFast,
          clientFrameSlow: this.clientFrameSlow,
          clientFrameFast: this.clientFrameFast,
          rtcMessageReceived: this.rtcMessageReceived,
          rtcBytesReceived: this.rtcBytesReceived - this.noWasmBytesReceived,
          receiveIframes: this.receiveIframes,
          decodeIframes: this.decodeIframes,
          avgResponseTime: r,
          avgProcessTime: n,
          avgDisplayTime: o,
          avgOverallTime: a,
          overallTimeCount: s,
          responseMiss: this.responseMiss,
          processMiss: this.processMiss,
          displayMiss: this.displayMiss,
          updateDropFrame: this.updateDropFrame,
          moveEvent: this.moveEvent,
          avgResponseMoveDiff: this.moveEvent == "MoveTo" ? G : 0,
          avgProcessMoveDiff: this.moveEvent == "MoveTo" ? W : 0,
          avgDisplayMoveDiff: this.moveEvent == "MoveTo" ? j : 0,
          maxResponseMoveDiff: this.moveEvent == "MoveTo" ? B : 0,
          maxProcessMoveDiff: this.moveEvent == "MoveTo" ? X : 0,
          maxDisplayMoveDiff: this.moveEvent == "MoveTo" ? $ : 0,
          moveResponseJank: this.moveEvent == "MoveTo" ? g : 0,
          moveProcessJank: this.moveEvent == "MoveTo" ? P : 0,
          moveDisplayJank: this.moveEvent == "MoveTo" ? V : 0,
          moveResponseCounts: this.moveEvent == "MoveTo" ? m.toString() : "0,0,0,0,0",
          moveProcessCounts: this.moveEvent == "MoveTo" ? R.toString() : "0,0,0,0,0",
          moveDisplayCounts: this.moveEvent == "MoveTo" ? N.toString() : "0,0,0,0,0",
          MoveDisplayCountGood: this.moveEvent == "MoveTo" ? L.toString() : "0",
          MoveDisplayCountWell: this.moveEvent == "MoveTo" ? k.toString() : "0",
          MoveDisplayCountFair: this.moveEvent == "MoveTo" ? U.toString() : "0",
          MoveDisplayCountBad: this.moveEvent == "MoveTo" ? z.toString() : "0",
          MoveDisplayCountRest: this.moveEvent == "MoveTo" ? H.toString() : "0",
          moveResponseDelay: this.moveEvent == "MoveTo" ? this.MoveResponseDelay : 0,
          moveProcessDelay: this.moveEvent == "MoveTo" ? this.MoveProcessDelay : 0,
          moveDisplayDelay: this.moveEvent == "MoveTo" ? this.MoveDisplayDelay : 0,
          sdMoveResponseLongTime: Y,
          sdMoveProcessLongTime: K,
          sdMoveDisplayLongTime: Z,
          avgResponseFlyDiff: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? G : 0,
          avgProcessFlyDiff: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? W : 0,
          avgDisplayFlyDiff: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? j : 0,
          maxResponseFlyDiff: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? B : 0,
          maxProcessFlyDiff: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? X : 0,
          maxDisplayFlyDiff: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? $ : 0,
          flyResponseJank: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? g : 0,
          flyProcessJank: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? P : 0,
          flyDisplayJank: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? V : 0,
          flyResponseCounts: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? m.toString() : "0,0,0,0,0",
          flyProcessCounts: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? R.toString() : "0,0,0,0,0",
          flyDisplayCounts: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? N.toString() : "0,0,0,0,0",
          flyResponseDelay: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? this.MoveResponseDelay : 0,
          flyProcessDelay: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? this.MoveProcessDelay : 0,
          flyDisplayDelay: this.moveEvent == "GetOnVehicle" || this.moveEvent == "GetOnAirship" ? this.MoveDisplayDelay : 0,
          avgMetaParseTime: Q,
          maxMetaParseTime: te,
          avgServerDiff: q,
          maxServerDiff: J,
          streamType: WASM_Version
        };
        return this.lastReturnFrames = this.returnFrames, this.lastReceivedEmit = this.receivedEmit, re;
      }
    }]);

    return Workers;
  }();

  function _createSuper$8(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$8(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$8() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var Rtcp = /*#__PURE__*/function (_EventEmitter) {
    _inherits(Rtcp, _EventEmitter);

    var _super = _createSuper$8(Rtcp);

    function Rtcp(e) {
      var _this;

      _classCallCheck(this, Rtcp);

      _this = _super.call(this);
      E(_assertThisInitialized(_this), "connection", null);
      E(_assertThisInitialized(_this), "inputChannel", null);
      E(_assertThisInitialized(_this), "mediaStream");
      E(_assertThisInitialized(_this), "socket");
      E(_assertThisInitialized(_this), "connected", !1);
      E(_assertThisInitialized(_this), "candidates", []);
      E(_assertThisInitialized(_this), "isAnswered", !1);
      E(_assertThisInitialized(_this), "isFlushing", !1);
      E(_assertThisInitialized(_this), "inputReady", !1);
      E(_assertThisInitialized(_this), "workers");
      E(_assertThisInitialized(_this), "actived", !0);
      E(_assertThisInitialized(_this), "heartbeat");
      E(_assertThisInitialized(_this), "onIcecandidate", function (e) {
        if (e.candidate != null) {
          var t = JSON.stringify(e.candidate);
          logger$1.debug("Got ice candidate: ".concat(t)), _this.network.socket.send({
            id: "ice_candidate",
            data: btoa(t)
          });
        }
      });
      E(_assertThisInitialized(_this), "onIcecandidateerror", function (e) {
        logger$1.error("onicecandidateerror", e.errorCode, e.errorText, e);
      });
      E(_assertThisInitialized(_this), "onIceStateChange", function (e) {
        switch (e.target.iceGatheringState) {
          case "gathering":
            logger$1.info("ice gathering");
            break;

          case "complete":
            logger$1.info("Ice gathering completed");
        }
      });
      E(_assertThisInitialized(_this), "onIceConnectionStateChange", function () {
        if (!!_this.connection) switch (logger$1.info("iceConnectionState: ".concat(_this.connection.iceConnectionState)), _this.connection.iceConnectionState) {
          case "connected":
            {
              _this.connected = !0;
              break;
            }

          case "disconnected":
            {
              _this.connected = !1, _this.emit("rtcDisconnected");
              break;
            }

          case "failed":
            {
              _this.emit("rtcDisconnected"), _this.connected = !1;
              break;
            }
        }
      });
      E(_assertThisInitialized(_this), "setRemoteDescription", /*#__PURE__*/function () {
        var _ref = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e, t) {
          var a, s, l, r, n, o, u;
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  if (_this.connection) {
                    _context.next = 2;
                    break;
                  }

                  return _context.abrupt("return");

                case 2:
                  r = JSON.parse(atob(e)), n = new RTCSessionDescription(r);
                  _context.next = 5;
                  return _this.connection.setRemoteDescription(n);

                case 5:
                  _context.next = 7;
                  return _this.connection.createAnswer();

                case 7:
                  o = _context.sent;

                  if (o.sdp = (a = o.sdp) == null ? void 0 : a.replace(/(a=fmtp:111 .*)/g, "$1;stereo=1;sprop-stereo=1"), ((l = (s = o.sdp) == null ? void 0 : s.match(/a=mid:1/g)) == null ? void 0 : l.length) == 2) {
                    u = o.sdp.lastIndexOf("a=mid:1");
                    o.sdp = o.sdp.slice(0, u) + "a=mid:2" + o.sdp.slice(u + 7);
                  }

                  _context.prev = 9;
                  _context.next = 12;
                  return _this.connection.setLocalDescription(o);

                case 12:
                  _context.next = 17;
                  break;

                case 14:
                  _context.prev = 14;
                  _context.t0 = _context["catch"](9);
                  logger$1.error("error", _context.t0);

                case 17:
                  _this.isAnswered = !0, _this.network.rtcp.flushCandidate(), _this.network.socket.send({
                    id: "answer",
                    data: btoa(JSON.stringify(o))
                  }), t.srcObject = _this.mediaStream;

                case 18:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, null, [[9, 14]]);
        }));

        return function (_x, _x2) {
          return _ref.apply(this, arguments);
        };
      }());
      E(_assertThisInitialized(_this), "flushCandidate", function () {
        _this.isFlushing || !_this.isAnswered || (_this.isFlushing = !0, _this.candidates.forEach(function (e) {
          var t = atob(e),
              r = JSON.parse(t);
          if (/172\./.test(r.candidate)) return;
          var n = new RTCIceCandidate(r);
          _this.connection && _this.connection.addIceCandidate(n).then(function () {}, function (o) {
            logger$1.info("add candidate failed", o);
          });
        }), _this.isFlushing = !1);
      });
      E(_assertThisInitialized(_this), "input", function (e) {
        var t;
        !_this.actived || !_this.inputChannel || _this.inputChannel.readyState === "open" && ((t = _this.inputChannel) == null || t.send(e));
      });
      _this.network = e, _this.workers = new Workers(_assertThisInitialized(_this), logger$1), _this.workers.registerLogger(logger$1), _this.workers.registerFunction("data", function (t) {
        _this.emit("data", t);
      }), _this.heartbeat = new Heartbeat({
        ping: function ping(t) {
          e.room.actionsHandler.echo(t);
        },

        pong(t, r) {
          var n;
          r && t > 500 && logger$1.warn("high hb value ".concat(t, ", traceId:") + r), (n = e.room.stats) == null || n.assign({
            hb: t
          });
        }

      });
      return _this;
    }

    _createClass(Rtcp, [{
      key: "start",
      value: function start() {
        var _this2 = this;

        this.connection = new RTCPeerConnection();
        var e = Date.now();
        this.connection.ondatachannel = function (t) {
          logger$1.info("ondatachannel: ".concat(t.channel.label));
          _this2.inputChannel = t.channel;
          _this2.inputChannel.onopen = function () {
            var r;
            logger$1.info("The input channel has opened, id:", (r = _this2.inputChannel) == null ? void 0 : r.id), _this2.inputReady = !0, _this2.emit("rtcConnected"), _this2.network.room.currentNetworkOptions.reconnect || (logger$1.infoAndReportMeasurement({
              metric: "datachannelOpenedAt",
              startTime: _this2.network.room._startTime,
              group: "joinRoom"
            }), logger$1.infoAndReportMeasurement({
              metric: "datachannelOpenedCost",
              startTime: e,
              group: "joinRoom"
            }));
            console.log('this.inputChannel', _this2.inputChannel);
          }, _this2.inputChannel.onclose = function () {
            var r;
            return logger$1.info("The input channel has closed, id:", (r = _this2.inputChannel) == null ? void 0 : r.id);
          }, _this2.inputChannel.onmessage = function (r) {
            // console.log('this.workers',this.workers)
            //console.log('inputChannel',r.data)
            _this2.workers.dataHandle(r.data);
          };
        }, this.connection.oniceconnectionstatechange = this.onIceConnectionStateChange, this.connection.onicegatheringstatechange = this.onIceStateChange, this.connection.onicecandidate = this.onIcecandidate, this.connection.onicecandidateerror = this.onIcecandidateerror, this.network.socket.send({
          id: "init_webrtc",
          data: JSON.stringify({
            is_mobile: !0
          })
        });
      }
    }, {
      key: "addCandidate",
      value: function addCandidate(e) {
        e === "" ? this.network.rtcp.flushCandidate() : this.candidates.push(e);
      }
    }, {
      key: "disconnect",
      value: function disconnect() {
        var e, t, r;
        this.heartbeat.stop(), logger$1.info("ready to close datachannel, id", (e = this.inputChannel) == null ? void 0 : e.id), (t = this.inputChannel) == null || t.close(), (r = this.connection) == null || r.close(), this.connection = null, this.inputChannel = null;
      }
    }, {
      key: "sendStringData",
      value: function sendStringData(e) {
        console.log('e', e);
        this.input(e);
      }
    }, {
      key: "sendData",
      value: function sendData(e) {
        var t = "";

        try {
          t = JSON.stringify(e);
        } catch (r) {
          logger$1.error(r);
          return;
        }

        this.input(t);
      }
    }]);

    return Rtcp;
  }(EventEmitter);

  var NetworkMonitor = /*#__PURE__*/function () {
    function NetworkMonitor(e) {
      _classCallCheck(this, NetworkMonitor);

      this._listener = e;
    }

    _createClass(NetworkMonitor, [{
      key: "isOnline",
      get: function get() {
        var e = window.navigator;
        return typeof e.onLine == "boolean" ? e.onLine : !0;
      }
    }, {
      key: "start",
      value: function start() {
        window.addEventListener("online", this._listener), window.addEventListener("offline", this._listener);
      }
    }, {
      key: "stop",
      value: function stop() {
        window.removeEventListener("online", this._listener), window.removeEventListener("offline", this._listener);
      }
    }]);

    return NetworkMonitor;
  }();

  var Stream = /*#__PURE__*/function () {
    function Stream(e) {
      _classCallCheck(this, Stream);

      this.el = null;
      this._streamPlayTimer = null;

      if (!e) {
        this.el = this.createVideoElement();
        return;
      }

      this.el = e;
    }

    _createClass(Stream, [{
      key: "play",
      value: function play() {
        var _this = this;

        return new Promise(function (e, t) {
          _this._streamPlayTimer = new Timeout(function () {
            t(new InternalError("Stream play timeout"));
          }, 5e3), _this.el && _this.el.play().then(function () {
            var r;
            e(), logger$1.info("Media can autoplay"), (r = _this._streamPlayTimer) == null || r.clear();
          }).catch(function (r) {
            var n;
            logger$1.error("Media Failed to autoplay"), logger$1.error(r), t(new InternalError("Media Failed to autoplay")), (n = _this._streamPlayTimer) == null || n.clear();
          });
        });
      }
    }, {
      key: "createVideoElement",
      value: function createVideoElement() {
        var e = document.createElement("video");
        return e.muted = !0, e.autoplay = !1, e.playsInline = !0, e.setAttribute("autostart", "false"), e.setAttribute("controls", "controls"), e.setAttribute("muted", "true"), e.setAttribute("preload", "auto"), e.setAttribute("hidden", "hidden"), document.body.appendChild(e), e;
      }
    }]);

    return Stream;
  }();

  function _createSuper$7(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$7(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$7() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
  var workerSourceCode = "onmessage = function (event) {\n    const data = event.data\n    if (!data) return\n  \n    if (data.type === 'start') {\n      const startTime = Date.now()\n      const request = new XMLHttpRequest()\n      request.open('GET', data.url)\n      try {\n        request.send()\n      } catch (error) {\n        console.error(error)\n      }\n      request.addEventListener('readystatechange', () => {\n        if (request.readyState == 4) {\n          if (request.status == 200) {\n            postMessage(Date.now() - startTime)\n          }\n        }\n      })\n    }\n  }\n  ";

  var NetworkController = /*#__PURE__*/function (_EventEmitter) {
    _inherits(NetworkController, _EventEmitter);

    var _super = _createSuper$7(NetworkController);

    function NetworkController(e) {
      var _this;

      _classCallCheck(this, NetworkController);

      _this = _super.call(this);
      _this.socket = null;
      _this.rtcp = null;
      _this.stream = null;
      _this._state = 'connecting';
      _this._networkMonitor = null;
      _this.blockedActions = [];
      _this.reconnectCount = 0;
      _this.room = e, _this.socket = new Socket(_assertThisInitialized(_this));
      _this.rtcp = new Rtcp(_assertThisInitialized(_this));
      _this.stream = new Stream();
      _this._networkMonitor = new NetworkMonitor(function () {
        logger$1.info("network changed, online:", _this._networkMonitor.isOnline), _this._state === "disconnected" && _this._networkMonitor.isOnline && (logger$1.info("network back to online, try to reconnect"), _this.reconnect());
      });

      _this.checkNetworkQuality(_this.room.currentNetworkOptions.wsServerUrl);

      _this._networkMonitor.start();

      new VisibilityChangeHandler().subscribe(function (r) {
        var n, o;
        r ? ((o = _this.room.stats) == null || o.disable(), logger$1.infoAndReportMeasurement({
          metric: "pageHide",
          startTime: Date.now()
        })) : ((n = _this.room.stats) == null || n.enable(), logger$1.infoAndReportMeasurement({
          metric: "pageShow",
          startTime: Date.now(),
          extra: {
            state: _this._state
          }
        }), _this._state === "disconnected" && _this.reconnect());
      });
      return _this;
    }

    _createClass(NetworkController, [{
      key: "startGame",
      value: function startGame() {
        var _this2 = this;

        return new Promise(function (e, t) {
          if (!_this2.rtcp.connected) return t(new InternalError("Game cannot load. Please refresh"));
          if (!_this2.rtcp.inputReady) return t(new InternalError("Game is not ready yet. Please wait"));
          _this2.socket.on("gameRoomAvailable", function (r) {
            _this2.setState("connected"), e(r), _this2.rtcp.heartbeat.start();
          }), _this2.socket.on("socketClosed", function (r) {
            t(r);
          }), _this2.socket.startGame();
        });
      }
    }, {
      key: "addBlockedActions",
      value: function addBlockedActions(e) {
        var _this$blockedActions;

        (_this$blockedActions = this.blockedActions).push.apply(_this$blockedActions, _toConsumableArray(e));
      }
    }, {
      key: "removeBlockedActions",
      value: function removeBlockedActions(e) {
        if (!e) {
          this.blockedActions = [];
          return;
        }

        var t = this.blockedActions.indexOf(e);
        this.blockedActions.splice(t, 1);
      }
    }, {
      key: "setState",
      value: function setState(e) {
        this._state !== e && (logger$1.info("Set network state to ", e), this._state = e);
      }
    }, {
      key: "connectAndStart",
      value: function () {
        var _connectAndStart = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  return _context.abrupt("return", this.connect(e).then(this.startGame));

                case 1:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function connectAndStart(_x) {
          return _connectAndStart.apply(this, arguments);
        }

        return connectAndStart;
      }()
    }, {
      key: "connect",
      value: function () {
        var _connect = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2() {
          var _this3 = this;

          var e,
              _args2 = arguments;
          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  e = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : !1;
                  this.room.updateCurrentNetworkOptions({
                    reconnect: e
                  });
                  return _context2.abrupt("return", new Promise(function (t, r) {
                    _this3.rtcp.on("rtcConnected", function () {
                      _this3.setState("connected"), t();
                    }), _this3.rtcp.on("rtcDisconnected", function () {
                      logger$1.info("rtc disconnected"), _this3._state === "connecting" ? (_this3.setState("disconnected"), r(new InternalError("rtc connect failed"))) : (_this3.setState("disconnected"), logger$1.info("rtc disconnected, start to reconnect"), _this3.reconnect());
                    }), _this3.socket.on("socketQuit", function () {
                      logger$1.info("socket quit success"), _this3.setState("closed");
                    }), _this3.socket.on("socketClosed", function (n) {
                      _this3._state === "connecting" && (_this3.setState("disconnected"), r(n)), r(n);
                    }), _this3.socket.start();
                  }));

                case 3:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this);
        }));

        function connect() {
          return _connect.apply(this, arguments);
        }

        return connect;
      }()
    }, {
      key: "reconnect",
      value: function reconnect() {
        var _this4 = this;

        if (this.room.viewMode === "observer") return;
        var e = Date.now();

        if (this.reconnectCount++, this.reconnectCount > MAX_RECONNECT_COUNT) {
          logger$1.error("reconnect failed, reached max reconnect count", MAX_RECONNECT_COUNT), this.reconnectCount = 0, this.emit("stateChanged", {
            state: "disconnected"
          });
          return;
        }

        return logger$1.info("start reconnect, count:", this.reconnectCount), this._reconnect().then(function () {
          logger$1.infoAndReportMeasurement({
            startTime: e,
            metric: "reconnect"
          });
        }).catch(function (t) {
          if (logger$1.infoAndReportMeasurement({
            startTime: e,
            metric: "reconnect",
            error: t
          }), t.code === Codes.RepeatLogin) {
            _this4.room.handleRepetLogin();

            return;
          }

          var r = 1e3;
          logger$1.info("reconnect failed, wait " + r + " ms for next reconnect"), setTimeout(function () {
            _this4.reconnect();
          }, r);
        });
      }
    }, {
      key: "_reconnect",
      value: function _reconnect() {
        var _this5 = this;

        return this._state === "closed" ? (logger$1.warn("connection closed already"), Promise.reject()) : this._state === "connecting" ? (logger$1.warn("connection is already in connecting state"), Promise.reject()) : this._state !== "disconnected" ? Promise.reject() : (this.prepareReconnect(), this._state = "connecting", this.emit("stateChanged", {
          state: "reconnecting",
          count: this.reconnectCount
        }), this.socket.off("gameRoomAvailable"), this.socket.off("socketClosed"), this.rtcp.off("rtcDisconnected"), this.rtcp.off("rtcConnected"), this.connectAndStart(!0).then(function (_ref) {
          var e = _ref.session_id;
          _this5.room.updateCurrentNetworkOptions({
            sessionId: e
          }), reporter.updateBody({
            serverSession: e
          }), logger$1.info("reconnect success"), _this5.setState("connected"), _this5.reconnectCount = 0, _this5.emit("stateChanged", {
            state: "reconnected"
          });
        }));
      }
    }, {
      key: "prepareReconnect",
      value: function prepareReconnect() {
        this.rtcp.disconnect(), this.socket.prepareReconnect(), this.prepareReconnectOptions();
      }
    }, {
      key: "prepareReconnectOptions",
      value: function prepareReconnectOptions() {
        var _ref2 = this.room.currentClickingState || {},
            e = _ref2.camera,
            t = _ref2.player;

        e && t && this.room.updateCurrentNetworkOptions({
          camera: e,
          player: t
        });
      }
    }, {
      key: "sendRtcData",
      value: function sendRtcData(e) {
        if (this.blockedActions.includes(e.action_type)) {
          logger$1.info("action: ".concat(Actions[e.action_type], " was blocked"));
          return;
        }

        this.rtcp.sendData(e);
      }
    }, {
      key: "sendSocketData",
      value: function sendSocketData(e) {
        logger$1.debug("ws send ->", e), this.socket.send(e);
      }
    }, {
      key: "quit",
      value: function quit() {
        var e = util.uuid(),
            t = {
          action_type: Actions.Exit,
          trace_id: e,
          exit_action: {},
          user_id: this.room.options.userId,
          packet_id: e
        };
        this.setState("closed"), this.socket.quit(), this.sendRtcData(t);
      }
    }, {
      key: "checkNetworkQuality",
      value: function checkNetworkQuality(i) {
        var worker = null;
        if (!i) return;
        var e = Date.now();

        if (this.pingOthers("https://www.baidu.com", function (t, r) {
          logger$1.infoAndReportMeasurement({
            metric: "baiduRtt",
            group: "http",
            value: r,
            startTime: e
          });
        }), !worker) {
          var t = new Blob([workerSourceCode], {
            type: "application/javascript"
          });
          worker = new Worker(URL.createObjectURL(t)), worker.onmessage = function (r) {
            logger$1.infoAndReportMeasurement({
              metric: "workerRtt",
              group: "http",
              startTime: e,
              value: r.data
            });
          };
        }
      }
    }, {
      key: "pingOthers",
      value: function pingOthers(i, e) {
        var t = !1;
        var r = new Image();
        r.onload = o, r.onerror = a;
        var n = Date.now();

        function o(l) {
          t = !0, s();
        }

        function a(l) {}

        function s() {
          var l = Date.now() - n;
          if (typeof e == "function") return t ? e(null, l) : (console.error("error loading resource"), e("error", l));
        }

        r.src = i + "/favicon.ico?" + +new Date();
      }
    }]);

    return NetworkController;
  }(EventEmitter);

  var AssetTypeName = {
    Config: 'CONFIG',
    Model: 'MODEL',
    Vedio: 'VEDIO',
    Media: 'MEDIA',
    Effects: 'EFFECTS',
    Gift: 'GIFT',
    Textures: 'TEXTURES'
  };

  var AssetClassName = {
    Effects: '\u7279\u6548',
    Tv: 'TV',
    Lpm: '\u7C97\u6A21',
    Reward: '\u571F\u8C6A\u699C',
    Env: '\u73AF\u5883\u5149',
    Gbq: '\u544A\u767D\u5899',
    BreathPoint: '\u547C\u5438\u70B9',
    Gifts: '\u9001\u793C',
    Panorama: '\u5168\u666F\u56FE',
    GiftBubble: '\u9001\u793C\u6C14\u6CE1',
    SayBubble: '\u804A\u5929\u6C14\u6CE1'
  };

  var LoggerLevels$1 = {
    Debug: 1,
    Info: 2,
    Warn: 3,
    Error: 4,
    Off: 5
  };

  var EShaderMode = {
    default: 0,
    video: 1,
    videoAndPano: 2
  };

  var EFitMode = {
    fill: 'fill',
    contain: 'contain',
    cover: 'cover'
  };

  var BaseTable = /*#__PURE__*/function () {
    function BaseTable(e, t) {
      _classCallCheck(this, BaseTable);

      this.db = null;
      this.isCreatingTable = !1;
      this.hasCleared = !1;
      this.dbName = e, this.dbVersion = t;
    }

    _createClass(BaseTable, [{
      key: "clearDataBase",
      value: function () {
        var _clearDataBase = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var _this = this;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  return _context.abrupt("return", this.hasCleared || (e && (this.hasCleared = !0), !window.indexedDB.databases) ? Promise.resolve() : new Promise(function (t, r) {
                    var n = window.indexedDB.deleteDatabase(_this.dbName);
                    n.onsuccess = function () {
                      t();
                    }, n.onerror = r;
                  }));

                case 1:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function clearDataBase(_x) {
          return _clearDataBase.apply(this, arguments);
        }

        return clearDataBase;
      }()
    }, {
      key: "tableName",
      value: function tableName() {
        throw new Error("Derived class have to override 'tableName', and set a proper table name!");
      }
    }, {
      key: "keyPath",
      value: function keyPath() {
        throw new Error("Derived class have to override 'keyPath', and set a proper index name!");
      }
    }, {
      key: "index",
      value: function index() {
        throw new Error("Derived class have to override 'index', and set a proper index name!");
      }
    }, {
      key: "checkAndOpenDatabase",
      value: function () {
        var _checkAndOpenDatabase = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2() {
          var _this2 = this;

          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  return _context2.abrupt("return", this.db ? Promise.resolve(this.db) : new Promise(function (e, t) {
                    var n = setTimeout(function () {
                      logger$1.info("wait db to open for", 200), _this2.db ? e(_this2.db) : e(_this2.checkAndOpenDatabase()), clearTimeout(n);
                    }, 200);

                    _this2.openDatabase(_this2.dbName, _this2.dbVersion || 1, function () {
                      _this2.db && !_this2.isCreatingTable && e(_this2.db), logger$1.info("successCallback called, this.db: ".concat(!!_this2.db, ", this.isCreatingStore: ").concat(_this2.isCreatingTable)), clearTimeout(n);
                    }, function () {
                      t(new Error("Failed to open database!")), clearTimeout(n);
                    }, function () {
                      _this2.db && e(_this2.db), clearTimeout(n), logger$1.info("successCallback called, this.db: ".concat(!!_this2.db, ", this.isCreatingStore: ").concat(_this2.isCreatingTable));
                    });
                  }));

                case 1:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this);
        }));

        function checkAndOpenDatabase() {
          return _checkAndOpenDatabase.apply(this, arguments);
        }

        return checkAndOpenDatabase;
      }()
    }, {
      key: "openDatabase",
      value: function openDatabase(e, t, r, n, o) {
        var _this3 = this;

        if (this.isCreatingTable) return;
        this.isCreatingTable = !0, logger$1.info(e, t);
        var a = window.indexedDB.open(e, t),
            s = this.tableName();
        a.onsuccess = function (l) {
          _this3.db = a.result, logger$1.info("IndexedDb ".concat(e, " is opened.")), _this3.db.objectStoreNames.contains(s) && (_this3.isCreatingTable = !1), r && r(l);
        }, a.onerror = function (l) {
          var u;
          logger$1.error("Failed to open database", (u = l == null ? void 0 : l.srcElement) == null ? void 0 : u.error), _this3.isCreatingTable = !1, n && n(l), _this3.clearDataBase(!0);
        }, a.onupgradeneeded = function (l) {
          var u = l.target.result,
              c = _this3.index();

          logger$1.info("Creating table ".concat(s, "."));
          var h = u.objectStoreNames.contains(s);
          if (h) h = u.transaction([s], "readwrite").objectStore(s);else {
            var f = _this3.keyPath();

            h = u.createObjectStore(s, {
              keyPath: f
            });
          }
          c.map(function (f) {
            h.createIndex(f, f, {
              unique: !1
            });
          }), _this3.isCreatingTable = !1, logger$1.info("Table ".concat(s, " opened")), o && o(l);
        };
      }
    }, {
      key: "add",
      value: function () {
        var _add = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(e) {
          var t, o;
          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  t = this.tableName();
                  _context3.next = 3;
                  return this.checkAndOpenDatabase();

                case 3:
                  o = _context3.sent.transaction([t], "readwrite").objectStore(t).add(e);
                  return _context3.abrupt("return", new Promise(function (a, s) {
                    o.onsuccess = function (l) {
                      a(l);
                    }, o.onerror = function (l) {
                      var u;
                      logger$1.error((u = l.srcElement) == null ? void 0 : u.error), s(l);
                    };
                  }));

                case 5:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, this);
        }));

        function add(_x2) {
          return _add.apply(this, arguments);
        }

        return add;
      }()
    }, {
      key: "put",
      value: function () {
        var _put = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(e) {
          var t, o;
          return regenerator.wrap(function _callee4$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  t = this.tableName();
                  _context4.next = 3;
                  return this.checkAndOpenDatabase();

                case 3:
                  o = _context4.sent.transaction([t], "readwrite").objectStore(t).put(e);
                  return _context4.abrupt("return", new Promise(function (a, s) {
                    o.onsuccess = function (l) {
                      a(l);
                    }, o.onerror = function (l) {
                      var u;
                      logger$1.error("db put error", (u = l.srcElement) == null ? void 0 : u.error), s(l);
                    };
                  }));

                case 5:
                case "end":
                  return _context4.stop();
              }
            }
          }, _callee4, this);
        }));

        function put(_x3) {
          return _put.apply(this, arguments);
        }

        return put;
      }()
    }, {
      key: "delete",
      value: function _delete(e, t, r) {
        var n = this.tableName();
        this.checkAndOpenDatabase().then(function (o) {
          var s = o.transaction([n], "readwrite").objectStore(n).delete(e);
          s.onsuccess = t, s.onerror = r;
        });
      }
    }, {
      key: "update",
      value: function update() {
        this.checkAndOpenDatabase().then(function (e) {});
      }
    }, {
      key: "getAllKeys",
      value: function () {
        var _getAllKeys = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5() {
          var e, t;
          return regenerator.wrap(function _callee5$(_context5) {
            while (1) {
              switch (_context5.prev = _context5.next) {
                case 0:
                  e = this.tableName();
                  _context5.next = 3;
                  return this.checkAndOpenDatabase();

                case 3:
                  t = _context5.sent;
                  return _context5.abrupt("return", new Promise(function (r, n) {
                    var a = t.transaction([e], "readonly").objectStore(e).getAllKeys();
                    a.onsuccess = function (s) {
                      r(s.target.result);
                    }, a.onerror = function (s) {
                      logger$1.error("db getAllKeys error", s), n(s);
                    };
                  }));

                case 5:
                case "end":
                  return _context5.stop();
              }
            }
          }, _callee5, this);
        }));

        function getAllKeys() {
          return _getAllKeys.apply(this, arguments);
        }

        return getAllKeys;
      }()
    }, {
      key: "query",
      value: function () {
        var _query = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee6(e, t) {
          var r, n;
          return regenerator.wrap(function _callee6$(_context6) {
            while (1) {
              switch (_context6.prev = _context6.next) {
                case 0:
                  r = this.tableName();
                  _context6.next = 3;
                  return this.checkAndOpenDatabase();

                case 3:
                  n = _context6.sent;
                  return _context6.abrupt("return", new Promise(function (o, a) {
                    var u = n.transaction([r], "readonly").objectStore(r).index(e).get(t);
                    u.onsuccess = function (c) {
                      var f;
                      var h = (f = c == null ? void 0 : c.target) == null ? void 0 : f.result;
                      o && o(h);
                    }, u.onerror = function (c) {
                      logger$1.error("db query error", c), a(c);
                    };
                  }));

                case 5:
                case "end":
                  return _context6.stop();
              }
            }
          }, _callee6, this);
        }));

        function query(_x4, _x5) {
          return _query.apply(this, arguments);
        }

        return query;
      }()
    }, {
      key: "sleep",
      value: function () {
        var _sleep = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee7(e) {
          return regenerator.wrap(function _callee7$(_context7) {
            while (1) {
              switch (_context7.prev = _context7.next) {
                case 0:
                  return _context7.abrupt("return", new Promise(function (t) {
                    setTimeout(function () {
                      t("");
                    }, e);
                  }));

                case 1:
                case "end":
                  return _context7.stop();
              }
            }
          }, _callee7);
        }));

        function sleep(_x6) {
          return _sleep.apply(this, arguments);
        }

        return sleep;
      }()
    }]);

    return BaseTable;
  }();

  function _createSuper$6(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$6(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$6() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var ModelTable = /*#__PURE__*/function (_BaseTable) {
    _inherits(ModelTable, _BaseTable);

    var _super = _createSuper$6(ModelTable);

    function ModelTable() {
      _classCallCheck(this, ModelTable);

      return _super.call(this, "XverseDatabase", 1);
    }

    _createClass(ModelTable, [{
      key: "tableName",
      value: function tableName() {
        return "models";
      }
    }, {
      key: "index",
      value: function index() {
        return ["url"];
      }
    }, {
      key: "keyPath",
      value: function keyPath() {
        return "url";
      }
    }]);

    return ModelTable;
  }(BaseTable);

  var modelTable = new ModelTable();

  function _createSuper$5(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$5(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$5() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var isIndexedDbSupported = function isIndexedDbSupported() {
    return (window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB) !== void 0;
  };

  var dataURItoBlob = function dataURItoBlob(i) {
    var e;
    i.split(",")[0].indexOf("base64") >= 0 ? e = atob(i.split(",")[1]) : e = unescape(i.split(",")[1]);
    var t = i.split(",")[0].split(":")[1].split(";")[0],
        r = new Uint8Array(e.length);

    for (var o = 0; o < e.length; o++) {
      r[o] = e.charCodeAt(o);
    }

    return new Blob([r], {
      type: t
    });
  };

  var Http = /*#__PURE__*/function (_EventEmitter) {
    _inherits(Http, _EventEmitter);

    var _super = _createSuper$5(Http);

    function Http() {
      _classCallCheck(this, Http);

      return _super.apply(this, arguments);
    }

    _createClass(Http, [{
      key: "get",
      value: function () {
        var _get = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(_ref) {
          var e, _ref$useIndexedDb, t, _ref$timeout, r, n, _ref$isOutPutObjectUR, o, a, s, l;

          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  e = _ref.url, _ref$useIndexedDb = _ref.useIndexedDb, t = _ref$useIndexedDb === void 0 ? !1 : _ref$useIndexedDb, _ref$timeout = _ref.timeout, r = _ref$timeout === void 0 ? 15e3 : _ref$timeout, n = _ref.key, _ref$isOutPutObjectUR = _ref.isOutPutObjectURL, o = _ref$isOutPutObjectUR === void 0 ? !0 : _ref$isOutPutObjectUR;

                  if (!(Xverse.NO_CACHE !== void 0 && (t = !Xverse.NO_CACHE), t)) {
                    _context2.next = 25;
                    break;
                  }

                  if (!isIndexedDbSupported()) {
                    _context2.next = 22;
                    break;
                  }

                  window.performance.now();
                  a = null;
                  _context2.prev = 5;
                  _context2.next = 8;
                  return modelTable.query("url", e);

                case 8:
                  a = _context2.sent;
                  _context2.next = 14;
                  break;

                case 11:
                  _context2.prev = 11;
                  _context2.t0 = _context2["catch"](5);
                  return _context2.abrupt("return", (logger$1.debug(_context2.t0), logger$1.warn("cache query error", e), Promise.resolve(e)));

                case 14:
                  if (!(a && a.model)) {
                    _context2.next = 19;
                    break;
                  }

                  s = dataURItoBlob(a.model), l = Promise.resolve(o ? URL.createObjectURL(s) : s);
                  return _context2.abrupt("return", (window.performance.now(), l));

                case 19:
                  return _context2.abrupt("return", this.request({
                    url: e,
                    timeout: r,
                    contentType: "blob",
                    key: n
                  }).then( /*#__PURE__*/function () {
                    var _ref2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(s) {
                      var l;
                      return regenerator.wrap(function _callee$(_context) {
                        while (1) {
                          switch (_context.prev = _context.next) {
                            case 0:
                              _context.next = 2;
                              return blobToDataURI(s.response);

                            case 2:
                              l = _context.sent;
                              _context.prev = 3;
                              _context.next = 6;
                              return modelTable.put({
                                url: e,
                                model: l
                              });

                            case 6:
                              _context.next = 11;
                              break;

                            case 8:
                              _context.prev = 8;
                              _context.t0 = _context["catch"](3);
                              logger$1.warn("unable to add data to indexedDB", _context.t0);

                            case 11:
                              return _context.abrupt("return", Promise.resolve(o ? URL.createObjectURL(s.response) : s.response));

                            case 12:
                            case "end":
                              return _context.stop();
                          }
                        }
                      }, _callee, null, [[3, 8]]);
                    }));

                    return function (_x2) {
                      return _ref2.apply(this, arguments);
                    };
                  }()));

                case 20:
                  _context2.next = 23;
                  break;

                case 22:
                  return _context2.abrupt("return", this.request({
                    url: e,
                    timeout: r,
                    contentType: "blob",
                    key: n
                  }).then(function (a) {
                    var s = a.response;
                    return Promise.resolve(o ? URL.createObjectURL(s) : s);
                  }).catch(function (a) {
                    return Promise.reject(a);
                  }));

                case 23:
                  _context2.next = 26;
                  break;

                case 25:
                  return _context2.abrupt("return", this.request({
                    url: e,
                    timeout: r,
                    key: n
                  }).then(function (a) {
                    return a.getResponseHeader("content-type") === "application/json" ? Promise.resolve(JSON.parse(a.responseText)) : Promise.resolve(a.responseText);
                  }));

                case 26:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this, [[5, 11]]);
        }));

        function get(_x) {
          return _get.apply(this, arguments);
        }

        return get;
      }()
    }, {
      key: "request",
      value: function request(e) {
        var _this = this;

        var _e$timeout = e.timeout,
            t = _e$timeout === void 0 ? 3e4 : _e$timeout,
            r = e.contentType;
            e.key;
            var o = e.onRequestStart,
            a = e.url;
        return new Promise(function (s, l) {
          window.performance.now();
          var u = new XMLHttpRequest();
          r && (u.responseType = r), u.timeout = t, u.addEventListener("readystatechange", function () {
            if (u.readyState == 4) {
              if (u.status == 200) return window.performance.now(), _this.emit("loadend", {
                message: "request ".concat(a, " load success")
              }), s(u);
              {
                var c = "Unable to load the request ".concat(a);
                return _this.emit("error", {
                  message: c
                }), logger$1.error(c), l(c);
              }
            }
          }), o && o(u), u.open("GET", a), u.send();
        });
      }
    }]);

    return Http;
  }(EventEmitter); // const http = new Http();

  var Logger1 = /*#__PURE__*/function () {
    function Logger1(e) {
      _classCallCheck(this, Logger1);

      E(this, "module");
      this.module = e;
    }

    _createClass(Logger1, [{
      key: "debug",
      value: function debug() {
        var _Logger1$instance;

        return (_Logger1$instance = Logger1.instance).debug.apply(_Logger1$instance, arguments);
      }
    }, {
      key: "info",
      value: function info() {
        var _Logger1$instance2;

        return (_Logger1$instance2 = Logger1.instance).info.apply(_Logger1$instance2, arguments);
      }
    }, {
      key: "warn",
      value: function warn() {
        var _Logger1$instance3;

        return (_Logger1$instance3 = Logger1.instance).warn.apply(_Logger1$instance3, arguments);
      }
    }, {
      key: "error",
      value: function error() {
        var _Logger1$instance4;

        return (_Logger1$instance4 = Logger1.instance).error.apply(_Logger1$instance4, arguments);
      }
    }], [{
      key: "setLogger",
      value: function setLogger(e) {
        Logger1.instance = e;
      }
    }]);

    return Logger1;
  }();

  var XCameraComponent = /*#__PURE__*/function () {
    function XCameraComponent(e, t, r) {
      var _this = this;

      _classCallCheck(this, XCameraComponent);

      E(this, "maincameraRotLimitObserver", null);
      E(this, "mainCamera");
      E(this, "cgCamera");
      E(this, "saveCameraPose");
      E(this, "_cameraPose");
      E(this, "scene");
      E(this, "canvas");
      E(this, "yuvInfo");
      E(this, "forceKeepVertical", !1);
      E(this, "initCamera", function (e) {
        var _e$maxZ = e.maxZ,
            t = _e$maxZ === void 0 ? 1e4 : _e$maxZ,
            _e$minZ = e.minZ,
            r = _e$minZ === void 0 ? .1 : _e$minZ,
            _e$angularSensibility = e.angularSensibility,
            n = _e$angularSensibility === void 0 ? 2e3 : _e$angularSensibility;
        _this.mainCamera = new BABYLON.FreeCamera("camera_main", new BABYLON.Vector3(0, 1e3, 0), _this.scene), _this.mainCamera.mode = BABYLON.Camera.PERSPECTIVE_CAMERA, _this.mainCamera.speed = .1, _this.mainCamera.angularSensibility = n, _this.mainCamera.setTarget(new BABYLON.Vector3(0, 1010, 0)), _this.mainCamera.minZ = r, _this.mainCamera.fov = Math.PI * _this.yuvInfo.fov / 180, _this.mainCamera.maxZ = t, _this.mainCamera.fovMode = BABYLON.Camera.FOVMODE_HORIZONTAL_FIXED, _this.cgCamera = new BABYLON.FreeCamera("camera_temp", new BABYLON.Vector3(0, 1e3, 0), _this.scene), _this.cgCamera.mode = BABYLON.Camera.PERSPECTIVE_CAMERA, _this.cgCamera.speed = .1, _this.cgCamera.setTarget(new BABYLON.Vector3(0, 1010, 0)), _this.cgCamera.maxZ = t, _this.cgCamera.minZ = r, _this.cgCamera.fovMode = BABYLON.Camera.FOVMODE_HORIZONTAL_FIXED, _this.cameraFovChange(_this.yuvInfo);
      });
      E(this, "cameraFovChange", function (e) {
        _this.yuvInfo = e;
        var t = e.width,
            r = e.height,
            n = _this.canvas.width,
            o = _this.canvas.height,
            a = e.fov;

        if (_this.forceKeepVertical == !0) {
          var s = t / (2 * Math.tan(Math.PI * a / 360)),
              l = 2 * Math.atan(r / (2 * s));
          _this.mainCamera.fov = l, _this.cgCamera.fov = l, _this.mainCamera.fovMode = BABYLON.Camera.FOVMODE_VERTICAL_FIXED, _this.cgCamera.fovMode = BABYLON.Camera.FOVMODE_VERTICAL_FIXED;
        } else if (_this.mainCamera.fovMode = BABYLON.Camera.FOVMODE_HORIZONTAL_FIXED, _this.cgCamera.fovMode = BABYLON.Camera.FOVMODE_HORIZONTAL_FIXED, n / o < t / r && _this.mainCamera.fov) {
          var _s = o,
              _l = n,
              u = _s * t / r / (2 * Math.tan(a * Math.PI / 360)),
              c = 2 * Math.atan(_l / (2 * u));
          _this.mainCamera.fov = c, _this.cgCamera.fov = c;
        } else _this.mainCamera.fov = Math.PI * a / 180, _this.cgCamera.fov = Math.PI * a / 180;
      });
      E(this, "setCameraPose", function (e) {
        var n;
        var t = ue4Position2Xverse(e.position);
        var r = null;
        e.rotation != null && (r = ue4Rotation2Xverse(e.rotation)), _this._cameraPose = {
          position: t
        }, r != null && (_this._cameraPose.rotation = r), _this.scene.activeCamera === _this.mainCamera && !((n = _this.mainCamera) != null && n.isDisposed()) && _this._setCamPositionRotation(_this.mainCamera, _this._cameraPose);
      });
      E(this, "_setCamPositionRotation", function (e, t) {
        var r, n;
        t.position && (e.position = (r = t.position) == null ? void 0 : r.clone()), t.rotation && (e.rotation = (n = t.rotation) == null ? void 0 : n.clone());
      });
      E(this, "switchCamera", function (e) {
        var t;
        (t = _this.scene.activeCamera) == null || t.detachControl(_this.canvas), _this.scene.activeCamera = e;
      });
      E(this, "reCalXYZRot", function (e, t) {
        return e = e % (2 * Math.PI), Math.abs(t - e) >= Math.PI && (e = e - 2 * Math.PI), e;
      });
      E(this, "_moveCam", function (e, t, r, n, o, a, s, l) {
        var u = function u(v, y, b) {
          return v.x = _this.reCalXYZRot(v.x, y.x), v.y = _this.reCalXYZRot(v.y, y.y), v.z = _this.reCalXYZRot(v.z, y.z), new BABYLON.Vector3((y.x - v.x) * b + v.x, (y.y - v.y) * b + v.y, (y.z - v.z) * b + v.z);
        },
            c = function c(v, y, b) {
          return new BABYLON.Vector3((y.x - v.x) * b + v.x, (y.y - v.y) * b + v.y, (y.z - v.z) * b + v.z);
        },
            h = new Animation("myAnimation1", "position", s, Animation.ANIMATIONTYPE_VECTOR3, Animation.ANIMATIONLOOPMODE_CONSTANT);

        var f = [],
            d = t,
            _ = r;

        for (var v = 0; v < a; ++v) {
          f.push({
            frame: v,
            value: c(d, _, v / a)
          });
        }

        f.push({
          frame: f.length,
          value: c(d, _, 1)
        }), h.setKeys(f);
        var g = new Animation("myAnimation2", "rotation", s, Animation.ANIMATIONTYPE_VECTOR3, Animation.ANIMATIONLOOPMODE_CONSTANT);
        f = [], d = n, _ = o;

        for (var _v = 0; _v < a; ++_v) {
          f.push({
            frame: _v,
            value: u(d, _, _v / a)
          });
        }

        f.push({
          frame: f.length,
          value: u(d, _, 1)
        }), g.setKeys(f), e.animations.push(g), e.animations.push(h);

        var m = _this.scene.beginAnimation(e, 0, a, !1);

        m.onAnimationEnd = function () {
          l(), m.stop(), m.animationStarted = !1;
        };
      });
      this.scene = t, this.canvas = e, this.yuvInfo = r.yuvInfo, r.forceKeepVertical != null && (this.forceKeepVertical = r.forceKeepVertical), this.initCamera(r.cameraParam);
    }

    _createClass(XCameraComponent, [{
      key: "MainCamera",
      get: function get() {
        return this.mainCamera;
      }
    }, {
      key: "CgCamera",
      get: function get() {
        return this.cgCamera;
      }
    }, {
      key: "getCameraHorizonFov",
      value: function getCameraHorizonFov() {
        return this.mainCamera.fovMode == BABYLON.Camera.FOVMODE_HORIZONTAL_FIXED ? this.mainCamera.fov : Math.PI * this.yuvInfo.fov / 180;
      }
    }, {
      key: "changeMainCameraRotationDamping",
      value: function changeMainCameraRotationDamping() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2e3;
        this.mainCamera.angularSensibility = e;
      }
    }, {
      key: "removeMainCameraRotationLimit",
      value: function removeMainCameraRotationLimit() {
        this.maincameraRotLimitObserver != null && this.mainCamera.onAfterCheckInputsObservable.remove(this.maincameraRotLimitObserver);
      }
    }, {
      key: "setMainCameraInfo",
      value: function setMainCameraInfo(e) {
        var _e$maxZ2 = e.maxZ,
            t = _e$maxZ2 === void 0 ? 1e4 : _e$maxZ2,
            _e$minZ2 = e.minZ,
            r = _e$minZ2 === void 0 ? .1 : _e$minZ2,
            _e$angularSensibility2 = e.angularSensibility,
            n = _e$angularSensibility2 === void 0 ? 2e3 : _e$angularSensibility2;
        this.mainCamera.maxZ = t, this.mainCamera.minZ = r, this.mainCamera.angularSensibility = n;
      }
    }, {
      key: "getMainCameraInfo",
      value: function getMainCameraInfo() {
        return {
          maxZ: this.mainCamera.maxZ,
          minZ: this.mainCamera.minZ,
          angularSensibility: this.mainCamera.angularSensibility
        };
      }
    }, {
      key: "_limitAngle",
      value: function _limitAngle(e, t) {
        return Math.abs(Math.abs(t[0] - t[1]) - 360) < 1e-6 || (e = (e % 360 + 360) % 360, t[0] = (t[0] % 360 + 360) % 360, t[1] = (t[1] % 360 + 360) % 360, t[0] > t[1] ? e > t[1] && e < t[0] && (Math.abs(e - t[0]) < Math.abs(e - t[1]) ? e = t[0] : e = t[1]) : e < t[0] ? e = t[0] : e > t[1] && (e = t[1])), e;
      }
    }, {
      key: "setMainCameraRotationLimit",
      value: function setMainCameraRotationLimit(e, t) {
        var _this2 = this;

        this.maincameraRotLimitObserver != null && this.removeMainCameraRotationLimit();
        var r = this.mainCamera,
            n = e.yaw,
            o = e.pitch,
            a = e.roll,
            s = t.yaw,
            l = t.pitch,
            u = t.roll;
        if (s < 0 || l < 0 || u < 0) throw new Error("\u76F8\u673A\u65CB\u8F6C\u9650\u5236\u53EA\u80FD\u8BBE\u7F6E\u4E3A\u5927\u4E8E0");
        var c = [o - l, o + l],
            h = [n - s, n + s],
            f = [a - u, a + u];
        this.maincameraRotLimitObserver = r.onAfterCheckInputsObservable.add(function () {
          var _xverseRotation2Ue = xverseRotation2Ue4(r.rotation),
              d = _xverseRotation2Ue.pitch,
              _ = _xverseRotation2Ue.yaw,
              g = _xverseRotation2Ue.roll;

          d = _this2._limitAngle(d, c), _ = _this2._limitAngle(_, h), g = _this2._limitAngle(g, f), r.rotation = ue4Rotation2Xverse({
            pitch: d,
            yaw: _,
            roll: g
          });
        });
      }
    }, {
      key: "setMainCameraRotationLimitByAnchor",
      value: function setMainCameraRotationLimitByAnchor(e, t, r) {
        this.maincameraRotLimitObserver != null && this.removeMainCameraRotationLimit();
        var n = this.mainCamera,
            o = ue4Rotation2Xverse_mesh(t),
            a = ue4Rotation2Xverse_mesh(r);
        a != null && o != null && e.mesh != null && (this.maincameraRotLimitObserver = n.onAfterCheckInputsObservable.add(function () {
          var s = e.mesh.rotation;
          r.yaw > 0 && (n.rotation.y <= s.y - a.y + o.y ? n.rotation.y = s.y - a.y + o.y : n.rotation.y >= s.y + a.y + o.y && (n.rotation.y = s.y + a.y + o.y)), r.pitch > 0 && (n.rotation.x <= s.x - a.x + o.x ? n.rotation.x = s.x - a.x + o.x : n.rotation.x >= s.x + a.x + o.x && (n.rotation.x = s.x + a.x + o.x)), r.roll > 0 && (n.rotation.z <= s.z - a.z + o.z ? n.rotation.z = s.z - a.z + o.z : n.rotation.z >= s.z + a.z + o.z && (n.rotation.z = s.z + a.z + o.z));
        }));
      }
    }, {
      key: "getCameraPose",
      value: function getCameraPose() {
        var e = xversePosition2Ue4({
          x: this.mainCamera.position.x,
          y: this.mainCamera.position.y,
          z: this.mainCamera.position.z
        }),
            t = xverseRotation2Ue4({
          x: this.mainCamera.rotation.x,
          y: this.mainCamera.rotation.y,
          z: this.mainCamera.rotation.z
        });
        return {
          position: e,
          rotation: t
        };
      }
    }, {
      key: "changeCameraFov",
      value: function changeCameraFov(e, t) {
        this.mainCamera.fov = e, t != null && (this.mainCamera.fovMode = t == 0 ? BABYLON.Camera.FOVMODE_HORIZONTAL_FIXED : BABYLON.Camera.FOVMODE_VERTICAL_FIXED);
      }
    }, {
      key: "controlCameraRotation",
      value: function controlCameraRotation(e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : .5;
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : .5;
        var o = {
          pitch: n * t * 180,
          yaw: r * e * 180,
          roll: 0
        };
        this.addRot(o);
      }
    }, {
      key: "addRot",
      value: function addRot(e) {
        var t = this.mainCamera,
            r = ue4Rotation2Xverse_mesh(e);
        r != null && t.rotation.addInPlace(r);
      }
    }, {
      key: "getCameraFov",
      value: function getCameraFov() {
        return this.mainCamera.fov;
      }
    }, {
      key: "allowMainCameraController",
      value: function allowMainCameraController() {
        this.mainCamera.attachControl(this.canvas, !0);
      }
    }, {
      key: "detachMainCameraController",
      value: function detachMainCameraController() {
        this.mainCamera.detachControl(this.canvas);
      }
    }, {
      key: "forceChangeSavedCameraPose",
      value: function forceChangeSavedCameraPose(e) {
        this.saveCameraPose != null && (e.position != null && (this.saveCameraPose.position = ue4Position2Xverse(e.position)), e.rotation != null && (this.saveCameraPose.rotation = ue4Rotation2Xverse(e.rotation)));
      }
    }, {
      key: "changeToFirstPersonView",
      value: function changeToFirstPersonView(e) {
        this.saveCameraPose = {
          position: this.mainCamera.position.clone(),
          rotation: this.mainCamera.rotation.clone()
        }, this.mainCamera.attachControl(this.canvas, !0), e.position != null && (this.mainCamera.position = ue4Position2Xverse(e.position)), e.rotation != null && (this.mainCamera.rotation = ue4Rotation2Xverse(e.rotation));
      }
    }, {
      key: "changeToThirdPersonView",
      value: function changeToThirdPersonView() {
        this.saveCameraPose != null && this.mainCamera != null && (this.mainCamera.position = this.saveCameraPose.position.clone(), this.mainCamera.rotation = this.saveCameraPose.rotation.clone(), this.mainCamera.detachControl(this.canvas));
      }
    }, {
      key: "switchToMainCamera",
      value: function switchToMainCamera() {
        this.switchCamera(this.mainCamera);
      }
    }, {
      key: "switchToCgCamera",
      value: function switchToCgCamera() {
        this.switchCamera(this.cgCamera);
      }
    }, {
      key: "moveMainCamera",
      value: function moveMainCamera(e, t, r, n, o) {
        this._moveCam(this.mainCamera, this.mainCamera.position, e, this.mainCamera.rotation, t, r, n, o);
      }
    }]);

    return XCameraComponent;
  }();

  var EMeshType = {
    XAvatar: 'XAvatar',
    XStaticMesh: 'XStaticMesh',
    XBreathPoint: 'breathpoint',
    Decal: 'decal',
    Cgplane: 'cgplane',
    Tv: 'tv',
    XSubSequence: 'XSubSequence',
    XBillboard: 'XBillboard'
  };

  var XStaticMesh = /*#__PURE__*/function () {
    function XStaticMesh(_ref) {
      var _this = this;

      var e = _ref.id,
          t = _ref.mesh,
          _ref$group = _ref.group,
          r = _ref$group === void 0 ? "default" : _ref$group,
          _ref$lod = _ref.lod,
          n = _ref$lod === void 0 ? 0 : _ref$lod,
          _ref$xtype = _ref.xtype,
          o = _ref$xtype === void 0 ? EMeshType.XStaticMesh : _ref$xtype,
          _ref$skinInfo = _ref.skinInfo,
          a = _ref$skinInfo === void 0 ? "default" : _ref$skinInfo,
          _ref$url = _ref.url,
          s = _ref$url === void 0 ? "" : _ref$url;

      _classCallCheck(this, XStaticMesh);

      E(this, "_mesh");
      E(this, "_id", "-1");
      E(this, "_group");
      E(this, "_lod");
      E(this, "_isMoving", !1);
      E(this, "_isRotating", !1);
      E(this, "_isVisible", !0);
      E(this, "_skinInfo");
      E(this, "setVisibility", function (e, t) {
        Array.isArray(e) ? e.forEach(function (r) {
          _this.setVisibility(r, t);
        }) : e.isAnInstance || (e.visibility = t);
      });
      E(this, "setPickable", function (e, t) {
        Array.isArray(e) ? e.forEach(function (r) {
          _this.setPickable(r, t);
        }) : ("isPickable" in e && (e.isPickable = t), e.setEnabled(t));
      });
      E(this, "hide", function () {
        var e;
        _this._isVisible = !1, _this.mesh && _this.setVisibility(_this.mesh, 0), _this.mesh && _this.setPickable(_this.mesh, !1), (e = _this.mesh) == null || e.getChildMeshes().forEach(function (t) {
          _this.setVisibility(t, 0), _this.setPickable(t, !1);
        });
      });
      E(this, "show", function () {
        var e;
        _this._isVisible = !0, _this.mesh && _this.setVisibility(_this.mesh, 1), _this.mesh && _this.setPickable(_this.mesh, !0), (e = _this.mesh) == null || e.getChildMeshes().forEach(function (t) {
          _this.setVisibility(t, 1), _this.setPickable(t, !0);
        });
      });
      E(this, "attachToAvatar", function (e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
          x: 0,
          y: .5,
          z: 0
        };
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
          yaw: 0,
          pitch: 0,
          roll: 0
        };
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
          x: .35,
          y: .35,
          z: .35
        };
        var o = ue4Scaling2Xverse(n),
            a = ue4Rotation2Xverse(r),
            s = ue4Position2Xverse(t),
            l = _this._mesh;
        e && l ? (e.setParent(l), e.position = s, e.rotation = a, e.scaling = o) : logger$1.error("[Engine] avatar or attachment not found!");
      });
      E(this, "detachFromAvatar", function (e) {
        _this._mesh && e ? _this._mesh.removeChild(e) : logger$1.error("[Engine] avatar not found!");
      });
      this._id = e, this._mesh = t, this._group = r, this._lod = n, this._skinInfo = a, this.unallowMove(), this._mesh.xtype = o, this._mesh.xid = e, this._mesh.xgroup = this._group, this._mesh.xlod = this._lod, this._mesh.xskinInfo = this._skinInfo, this._mesh.xurl = s;
    }

    _createClass(XStaticMesh, [{
      key: "mesh",
      get: function get() {
        return this._mesh;
      }
    }, {
      key: "position",
      get: function get() {
        var o;
        if (!this._mesh) return null;

        var _ref2 = (o = this._mesh) == null ? void 0 : o.position,
            e = _ref2.x,
            t = _ref2.y,
            r = _ref2.z;

        return xversePosition2Ue4({
          x: e,
          y: t,
          z: r
        });
      }
    }, {
      key: "id",
      get: function get() {
        return this._id;
      }
    }, {
      key: "group",
      get: function get() {
        return this._group;
      }
    }, {
      key: "isMoving",
      get: function get() {
        return this._isMoving;
      }
    }, {
      key: "isVisible",
      get: function get() {
        return this._isVisible;
      }
    }, {
      key: "isRotating",
      get: function get() {
        return this._isRotating;
      }
    }, {
      key: "skinInfo",
      get: function get() {
        return this._skinInfo;
      }
    }, {
      key: "allowMove",
      value: function allowMove() {
        this._mesh != null && (this._mesh.getChildMeshes().forEach(function (e) {
          e.unfreezeWorldMatrix();
        }), this._mesh.unfreezeWorldMatrix());
      }
    }, {
      key: "unallowMove",
      value: function unallowMove() {
        this._mesh != null && (this._mesh.getChildMeshes().forEach(function (e) {
          e.freezeWorldMatrix();
        }), this._mesh.freezeWorldMatrix());
      }
    }, {
      key: "getID",
      value: function getID() {
        return this._id;
      }
    }, {
      key: "setPosition",
      value: function setPosition(e) {
        if (this._mesh) {
          var t = ue4Position2Xverse(e);
          this._mesh.position = t;
        } else logger$1.error("[Engine] no root for positioning");
      }
    }, {
      key: "setRotation",
      value: function setRotation(e) {
        var t = ue4Rotation2Xverse_mesh(e);
        this._mesh ? this._mesh.rotation = t : logger$1.error("[Engine] no root for rotating");
      }
    }, {
      key: "setScale",
      value: function setScale(e) {
        this._mesh ? this._mesh.scaling = new BABYLON.Vector3(e, e, -e) : logger$1.error("[Engine] no root for scaling");
      }
    }, {
      key: "disableAvatar",
      value: function disableAvatar() {
        var e;
        (e = this._mesh) == null || e.setEnabled(!1);
      }
    }, {
      key: "enableAvatar",
      value: function enableAvatar() {
        var e;
        (e = this._mesh) == null || e.setEnabled(!0);
      }
    }, {
      key: "togglePickable",
      value: function togglePickable(e) {
        var t;
        (t = this.mesh) == null || t.getChildMeshes().forEach(function (r) {
          "instances" in r && "isPickable" in r && (r.isPickable = e);
        }), this.mesh != null && "isPickable" in this.mesh && (this.mesh.isPickable = e);
      }
    }, {
      key: "setMaterial",
      value: function setMaterial(e) {
        var t;
        (t = this.mesh) == null || t.getChildMeshes().forEach(function (r) {
          "instances" in r && "material" in r && (r.material = e);
        }), this.mesh != null && "material" in this.mesh && (this.mesh.material = e);
      }
    }, {
      key: "dispose",
      value: function dispose() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : !1;
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
        !this.mesh.isDisposed() && this.mesh.dispose(e, t);
      }
    }]);

    return XStaticMesh;
  }();

  function _createSuper$4(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$4(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$4() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var XLowpolyModelError = /*#__PURE__*/function (_XverseError) {
    _inherits(XLowpolyModelError, _XverseError);

    var _super = _createSuper$4(XLowpolyModelError);

    function XLowpolyModelError(e) {
      _classCallCheck(this, XLowpolyModelError);

      return _super.call(this, 5204, e || "[Engine] \u4F20\u5165\u6A21\u578Burl\u9519\u8BEF");
    }

    return _createClass(XLowpolyModelError);
  }(XverseError);

  var XStaticMeshFromOneGltf = /*#__PURE__*/function () {
    function XStaticMeshFromOneGltf(e, t) {
      var _this = this;

      _classCallCheck(this, XStaticMeshFromOneGltf);

      E(this, "_scene");
      E(this, "_url");
      E(this, "_group");
      E(this, "_pickable");
      E(this, "_meshes");
      E(this, "_id");
      E(this, "_lod");
      E(this, "_groupUuid");
      E(this, "_isInScene");
      E(this, "_skinInfo");
      E(this, "loadMesh", function (e, t) {
        var r = _this._meshes.length,
            n = t ? 1 : 0,
            o = _this._url;
        return BABYLON.SceneLoader.LoadAssetContainerAsync("", o, _this._scene, function () {
          _this._scene.blockMaterialDirtyMechanism = !0;
        }, ".glb").then(function (a) {
          for (var s = a.materials.length - 1; s >= 0; --s) {
            a.materials[s].dispose();
          }

          _this._scene.blockMaterialDirtyMechanism = !0;

          for (var _s = 0; _s < a.meshes.length; ++_s) {
            var l = a.meshes[_s];

            if ("instances" in l) {
              "visibility" in l && (l.visibility = 0), "isPickable" in l && (l.isPickable = _this._pickable), e != null && (l.material = e), "hasVertexAlpha" in l && (l.hasVertexAlpha = !1);
              var u = new XStaticMesh({
                id: _this._groupUuid + "-" + Math.random().toString(36).substr(2, 5),
                mesh: l,
                lod: _this._lod,
                group: _this._group,
                url: _this._url,
                xtype: EMeshType.XStaticMesh,
                skinInfo: _this._skinInfo
              });

              _this._meshes.push(u);
            }

            _this._scene.addMesh(l);
          }

          return !0;
        }).then(function () {
          _this._isInScene = !0;

          for (var a = r; a < _this._meshes.length; ++a) {
            _this._meshes[a].mesh.visibility = n;
          }

          return Promise.resolve(!0);
        }).catch(function (a) {
          logger$1.error("[Engine] input gltf mesh uri error! " + a), Promise.reject(new XLowpolyModelError("[Engine] input gltf mesh uri error! " + a));
        });
      });
      this._meshes = [], this._scene = e, this._url = t.url, t.group != null ? this._group = t.group : this._group = "default", t.pick != null ? this._pickable = t.pick : this._pickable = !1, t.id != null ? this._id = t.id : this._id = "default", t.lod != null ? this._lod = t.lod : this._lod = -1, t.skinInfo != null ? this._skinInfo = t.skinInfo : this._skinInfo = "default", this._groupUuid = util.uuid(), this._isInScene = !1;
    }

    _createClass(XStaticMeshFromOneGltf, [{
      key: "isinscene",
      get: function get() {
        return this._isInScene;
      }
    }, {
      key: "groupUuid",
      get: function get() {
        return this._groupUuid;
      }
    }, {
      key: "skinInfo",
      get: function get() {
        return this._skinInfo;
      }
    }, {
      key: "group",
      get: function get() {
        return this._group;
      }
    }, {
      key: "meshes",
      get: function get() {
        return this._meshes;
      }
    }, {
      key: "url",
      get: function get() {
        return this._url;
      }
    }, {
      key: "id",
      get: function get() {
        return this._id;
      }
    }, {
      key: "lod",
      get: function get() {
        return this._lod;
      }
    }, {
      key: "removeFromScene",
      value: function removeFromScene() {
        if (this._isInScene) {
          this._isInScene = !1;

          for (var e = 0, t = this._meshes.length; e < t; ++e) {
            this._meshes[e].mesh != null && this._scene.removeMesh(this._meshes[e].mesh);
          }
        }
      }
    }, {
      key: "addToScene",
      value: function addToScene() {
        if (this._isInScene == !1) {
          this._isInScene = !0;

          for (var e = 0, t = this._meshes.length; e < t; ++e) {
            this._meshes[e].mesh != null && this._scene.addMesh(this._meshes[e].mesh);
          }
        }
      }
    }, {
      key: "toggleVisibility",
      value: function toggleVisibility(e) {
        var t = e ? 1 : 0;

        for (var r = 0, n = this._meshes.length; r < n; ++r) {
          "visibility" in this._meshes[r].mesh && (this._meshes[r].mesh.visibility = t);
        }
      }
    }, {
      key: "togglePickable",
      value: function togglePickable(e) {
        for (var t = 0, r = this._meshes.length; t < r; ++t) {
          "isPickable" in this._meshes[t].mesh && (this._meshes[t].mesh.isPickable = e);
        }
      }
    }, {
      key: "setMaterial",
      value: function setMaterial(e) {
        for (var t = 0, r = this._meshes.length; t < r; ++t) {
          "material" in this._meshes[t].mesh && (this._meshes[t].mesh.material = e);
        }
      }
    }, {
      key: "dispose",
      value: function dispose() {
        for (var e = 0, t = this._meshes.length; e < t; ++e) {
          this._meshes[e].mesh.dispose(!1, !1);
        }
      }
    }]);

    return XStaticMeshFromOneGltf;
  }();

  var XStaticMeshComponent = /*#__PURE__*/function () {
    function XStaticMeshComponent(e) {
      var _this = this;

      _classCallCheck(this, XStaticMeshComponent);

      E(this, "scene");
      E(this, "_staticmeshes");
      E(this, "_lowModel_group");
      E(this, "_CgPlane");
      E(this, "_rootDir");
      E(this, "_abosoluteUrl");
      E(this, "_partMeshSkinInfo");
      E(this, "_meshInfoJson");
      E(this, "_orijson");
      E(this, "_notUsedRegionLists");
      E(this, "_meshInfoKeys");
      E(this, "_currentUpdateRegionCount");
      E(this, "_currentMeshUsedLod");
      E(this, "_currentPartGroup");
      E(this, "_allowRegionUpdate");
      E(this, "_allowRegionForceLod");
      E(this, "_forceLod");
      E(this, "_scenemanager");
      E(this, "regionIdInCamera");
      E(this, "regionIdInCameraConst");
      E(this, "_cameraInRegionId");
      E(this, "_meshVis");
      E(this, "_doMeshVisChangeNumber");
      E(this, "_meshVisTypeName");
      E(this, "_visCheckDurationFrameNumber");
      E(this, "_regionLodRule");
      E(this, "reg_staticmesh_partupdate", function () {
        if (_this._allowRegionUpdate && (_this.scene.getFrameId(), _this._meshUpdateFrame()), _this._allowRegionForceLod) {
          _this.scene.getFrameId() % 2 == 0 && _this.setOneRegionLod(_this._meshInfoKeys[_this._currentUpdateRegionCount % _this._meshInfoKeys.length].toString(), _this._forceLod);
          var t = !0;
          var r = Array.from(_this._currentMeshUsedLod.keys());

          if (r.length > 0) {
            for (var n = 0; n < r.length; ++n) {
              _this._currentMeshUsedLod.get(r[n]) != _this._forceLod && (t = !1);
            }

            t && (_this._allowRegionForceLod = !1);
          }
        }
      });
      E(this, "setMeshInfo", function (e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
        _this._abosoluteUrl != e && (_this._abosoluteUrl.length > 0 && _this.deleteLastRegionMesh(), _this._partMeshSkinInfo = t, _this._abosoluteUrl = e, _this._rootDir = _this._abosoluteUrl.slice(0, -4) + "/", _this.parseJson(_this._rootDir + "meshInfo.json").then(function () {
          _this.startMeshUpdate();
        }));
      });
      E(this, "_meshUpdateFrame", function () {
        {
          var _e = _this._meshInfoKeys[_this._currentUpdateRegionCount % _this._meshInfoKeys.length];
          var t = !0;
          var r = 3;

          if (_this._scenemanager != null && _this._scenemanager.cameraComponent != null) {
            var n = _this._getMainPlayerPosition();

            if (n != null) {
              if (_this._cameraInRegionId >= 0) {
                var a = _this.getRegionIdWhichIncludeCamera(n);

                (_this._cameraInRegionId != a || _this.regionIdInCamera.length == 0) && (_this._cameraInRegionId = a, _this.regionIdInCamera = _this._getNeighborId(_this._cameraInRegionId.toString()), _this.regionIdInCameraConst = _this.regionIdInCamera.slice());

                var s = _this.regionIdInCamera.pop();

                for (; s != null;) {
                  if (_this._notUsedRegionLists.indexOf(s) >= 0) s = _this.regionIdInCamera.pop();else break;
                }

                s != null && (_e = s.toString());
              } else _this._cameraInRegionId = _this.getRegionIdWhichIncludeCamera(n);

              if (_this._currentMeshUsedLod.size == 0 || _this._notUsedRegionLists.indexOf(parseInt(_e)) >= 0) {
                _e = _this._cameraInRegionId.toString();

                var _a = _this._getNeighborId(_e);

                for (; _a.length == 0 && (_e = _this.getNearestRegionIdWithCamera(n).toString()), _this._notUsedRegionLists.indexOf(parseInt(_e)) >= 0;) {
                  _e = _a.pop().toString();
                }
              }

              var o = _this._meshInfoJson[_this._cameraInRegionId.toString()].lod;

              r = 3, _this._cameraInRegionId.toString() == _e ? r = _this._regionLodRule[0] : o[0].indexOf(parseInt(_e)) >= 0 ? r = _this._regionLodRule[1] : o[1].indexOf(parseInt(_e)) >= 0 ? r = _this._regionLodRule[2] : o[2].indexOf(parseInt(_e)) >= 0 ? r = _this._regionLodRule[3] : r = _this._regionLodRule[4];
            }
          }

          _this.setOneRegionLod(_e, r, t), _this.updateRegionNotInLocalNeighbor(), _this.cleanRootNodes();
        }
      });
      E(this, "updateRegionNotInLocalNeighbor", function () {
        Array.from(_this._currentMeshUsedLod.keys()).forEach(function (t) {
          _this.regionIdInCameraConst.indexOf(parseInt(t)) < 0 && _this.setOneRegionLod(t, -1);
        });
      });
      E(this, "cleanRootNodes", function () {
        if (_this.scene.getFrameId() % 3 == 0) {
          var _e2 = [];
          _this.scene.rootNodes.forEach(function (t) {
            (t.getClassName() == "TransformNode" && t.getChildren().length == 0 || t.getClassName() == "Mesh" && t.name == "__root__" && t.getChildren().length == 0) && _e2.push(t);
          }), _e2.forEach(function (t) {
            t.dispose();
          });
        }
      });
      E(this, "setOneRegionLod", function (e, t) {
        _this._currentUpdateRegionCount++;

        var n = _this._calHashCode(_this._rootDir),
            o = "region_" + n + "_" + e;

        if (t < 0) {
          _this._currentMeshUsedLod.has(e) && (_this._currentMeshUsedLod.delete(e), _this._currentPartGroup.delete(o), _this.deleteMeshesByCustomProperty("group", "region_" + n + "_" + e));
          return;
        }

        var a = _this._rootDir + e + "_lod" + t + "_xverse.glb",
            s = _this._currentMeshUsedLod.get(e);

        _this._currentPartGroup.add(o), s != null ? s != t && (_this._currentMeshUsedLod.set(e, t), _this._scenemanager.addNewLowPolyMesh({
          url: a,
          group: "region_" + n + "_" + e,
          pick: !0,
          lod: t,
          skinInfo: _this._partMeshSkinInfo
        }, [{
          group: "region_" + n + "_" + e,
          mode: 0
        }])) : (_this._currentMeshUsedLod.set(e, t), _this._scenemanager.addNewLowPolyMesh({
          url: a,
          group: "region_" + n + "_" + e,
          pick: !0,
          lod: t,
          skinInfo: _this._partMeshSkinInfo
        }));
      });
      E(this, "checkPointInView", function (_ref) {
        var e = _ref.x,
            t = _ref.y,
            r = _ref.z;
        var n = ue4Position2Xverse({
          x: e,
          y: t,
          z: r
        });
        if (!n) return !1;

        for (var o = 0; o < 6; o++) {
          if (_this.scene.frustumPlanes[o].dotCoordinate(n) < 0) return !1;
        }

        return !0;
      });
      E(this, "addNewLowPolyMesh", function (e, t, r) {
        if (!e.url.endsWith("glb") && !e.url.startsWith("blob:")) return e.url.endsWith("zip") ? (_this.setMeshInfo(e.url, e.skinInfo), Promise.resolve(!0)) : (logger$1.error("[Engine] input model path is error! ", e.url), Promise.reject(new XLowpolyModelError("[Engine] input model path is error! " + e.url)));
        {
          var n = e.url;
          return new Promise(function (o, a) {
            return _this._scenemanager.urlTransformer(e.url).then(function (s) {
              e.url = s;
              var l = new XStaticMeshFromOneGltf(_this.scene, e),
                  u = Date.now();
              return new Promise(function (c, h) {
                l.loadMesh(r, !0).then(function (f) {
                  var d = Date.now();

                  if (_this._scenemanager.engineRunTimeStats.timeArray_loadStaticMesh.add(d - u), f == !0) {
                    var _ = _this.getLowModelType(e);

                    var g = 0;
                    if (_this._lowModel_group.has(_) && (g = _this._lowModel_group.get(_).length), r != null && _this._scenemanager.currentShader != null && _this._scenemanager.currentShader.name != r.name && l.setMaterial(_this._scenemanager.currentShader), _this._allowRegionUpdate == !1 && _.startsWith("region_")) l.dispose();else if (_this._staticmeshes.push(l), _this.lowmodelGroupMapAddValue(_, l), t != null && t.length > 0) {
                      var m = [];

                      for (var v = 0; v < t.length; ++v) {
                        m.push(t[v].group), _this.updateLowModelGroup(t[v], _, g);
                      }
                    }
                    _this._scenemanager.engineRunTimeStats.timeArray_updateStaticMesh.add(Date.now() - d), c(!0);
                  } else h(new XLowpolyModelError("[Engine] after lowmodel error!"));
                }).catch(function (f) {
                  logger$1.error("[Engine] load Mesh [" + n + "] error! " + f), h(new XLowpolyModelError("[Engine] load Mesh [".concat(n, "] error! ").concat(f)));
                });
              });
            }).then(function (s) {
              s == !0 ? (logger$1.info("[Engine] load Mesh [".concat(n, "] successfully.")), o(!0)) : a(!1);
            }).catch(function (s) {
              logger$1.error("[Engine] addNewLowPolyMesh [" + n + "] error! " + s), a(new XLowpolyModelError("[Engine] addNewLowPolyMesh [".concat(n, "] error! ").concat(s)));
            });
          });
        }
      });
      E(this, "toggleLowModelVisibility", function (e) {
        var t = e.vis,
            _e$groupName = e.groupName,
            r = _e$groupName === void 0 ? "" : _e$groupName,
            _e$skinInfo = e.skinInfo,
            n = _e$skinInfo === void 0 ? "" : _e$skinInfo;
        _this._meshVis = t, _this._meshVisTypeName = {
          groupName: r,
          skinInfo: n
        }, _this._doMeshVisChangeNumber = 0, r == Te.ALL_MESHES || _this._currentPartGroup.has(r) == !0 || _this._partMeshSkinInfo == n ? t == !1 ? (_this._visCheckDurationFrameNumber = 100, _this.stopMeshUpdate()) : (_this._visCheckDurationFrameNumber = 1, _this.startMeshUpdate()) : _this._visCheckDurationFrameNumber = 1;
      });
      E(this, "reg_staticmesh_visibility", function () {
        if (_this._doMeshVisChangeNumber >= 0) if (_this._doMeshVisChangeNumber < _this._visCheckDurationFrameNumber) {
          if (_this._doMeshVisChangeNumber = _this._doMeshVisChangeNumber + 1, _this._meshVisTypeName.groupName == Te.ALL_MESHES) _this._lowModel_group.forEach(function (e, t) {
            for (var r = 0, n = e.length; r < n; ++r) {
              e[r].toggleVisibility(_this._meshVis);
            }
          });else {
            if (_this._lowModel_group.has(_this._meshVisTypeName.groupName)) for (var _e3 = 0; _e3 < _this._lowModel_group.get(_this._meshVisTypeName.groupName).length; ++_e3) {
              _this._lowModel_group.get(_this._meshVisTypeName.groupName)[_e3].toggleVisibility(_this._meshVis);
            }
            if (_this._meshVisTypeName.skinInfo != "") for (var _e4 = 0; _e4 < _this._staticmeshes.length; ++_e4) {
              _this._staticmeshes[_e4].skinInfo == _this._meshVisTypeName.skinInfo && _this._staticmeshes[_e4].toggleVisibility(_this._meshVis);
            }
          }
        } else _this._meshVis = !0, _this._meshVisTypeName = {
          groupName: "",
          skinInfo: ""
        }, _this._doMeshVisChangeNumber = -1;
      });
      E(this, "_getMeshesByCustomProperty", function (e, t) {
        var r = [];
        return _this._staticmeshes.forEach(function (n) {
          n[e] != null && n[e] == t && (r = r.concat(n.meshes));
        }), r;
      });
      this._lowModel_group = new Map(), this._staticmeshes = [], this._meshInfoJson = null, this._meshInfoKeys = [], this._currentUpdateRegionCount = 0, this._abosoluteUrl = "", this._partMeshSkinInfo = "", this._forceLod = 3, this._allowRegionUpdate = !1, this._allowRegionForceLod = !1, this._currentMeshUsedLod = new Map(), this._currentPartGroup = new Set(), this._scenemanager = e, this.scene = e.Scene, this.regionIdInCamera = [], this.regionIdInCameraConst = [], this._cameraInRegionId = -1, this._rootDir = "", this._meshVis = !0, this._meshVisTypeName = {
        groupName: "",
        skinInfo: ""
      }, this._doMeshVisChangeNumber = -1, this._visCheckDurationFrameNumber = -1, this._regionLodRule = [0, 1, 3, 3, -1], this.initCgLowModel(), this._regionPartLoop();
    }

    _createClass(XStaticMeshComponent, [{
      key: "cameraInRegionId",
      get: function get() {
        return this._cameraInRegionId;
      }
    }, {
      key: "setRegionLodRule",
      value: function setRegionLodRule(e) {
        return e.length != 5 ? !1 : (e.forEach(function (t) {}), this._regionLodRule = e, !0);
      }
    }, {
      key: "lowModel_group",
      get: function get() {
        return this._lowModel_group;
      }
    }, {
      key: "_regionPartLoop",
      value: function _regionPartLoop() {
        this.scene.registerBeforeRender(this.reg_staticmesh_partupdate), this.scene.registerAfterRender(this.reg_staticmesh_visibility);
      }
    }, {
      key: "_globalSearchCameraInWhichRegion",
      value: function _globalSearchCameraInWhichRegion(e, t) {
        var r = -1;

        for (var n = 0; n < t.length; ++n) {
          var o = this._meshInfoJson[t[n].toString()].boundingbox,
              a = o[0],
              s = o[1];

          if (e.x >= a[0] && e.x <= s[0] && e.y >= a[1] && e.y <= s[1] && e.z >= a[2] && e.z <= s[2] || e.x >= s[0] && e.x <= a[0] && e.y >= s[1] && e.y <= a[1] && e.z >= s[2] && e.z <= a[2]) {
            r = parseInt(t[n].toString());
            break;
          }
        }

        return r;
      }
    }, {
      key: "getRegionIdByPosition",
      value: function getRegionIdByPosition(e) {
        return this.getRegionIdWhichIncludeCamera(e);
      }
    }, {
      key: "getRegionIdWhichIncludeCamera",
      value: function getRegionIdWhichIncludeCamera(e) {
        var t = -1;
        if (this._allowRegionUpdate == !1) return t;

        if (this._cameraInRegionId == -1 ? t = this._globalSearchCameraInWhichRegion(e, this._meshInfoKeys) : (t = this._globalSearchCameraInWhichRegion(e, this.regionIdInCameraConst), t == -1 && (t = this._globalSearchCameraInWhichRegion(e, this._meshInfoKeys))), t == -1) {
          var r = 1e7;

          for (var n = 0; n < this._meshInfoKeys.length; ++n) {
            var o = this._meshInfoJson[this._meshInfoKeys[n]].center,
                a = Math.abs(e.x - o[0]) + Math.abs(e.y - o[1]);
            r > a && (r = a, t = parseInt(this._meshInfoKeys[n]));
          }
        }

        return t;
      }
    }, {
      key: "getNearestRegionIdWithCamera",
      value: function getNearestRegionIdWithCamera(e) {
        var t = 1,
            r = 1e7;

        for (var n = 0; n < this._meshInfoKeys.length; ++n) {
          if (this._notUsedRegionLists.indexOf(parseInt(this._meshInfoKeys[n])) >= 0) continue;
          var o = this._meshInfoJson[this._meshInfoKeys[n]].center,
              a = Math.abs(e.x - o[0]) + Math.abs(e.y - o[1]);
          r > a && (r = a, t = parseInt(this._meshInfoKeys[n]));
        }

        return t;
      }
    }, {
      key: "_getNeighborId",
      value: function _getNeighborId(e) {
        var t = this._meshInfoJson[e].lod;
        var r = [];
        var n = Object.keys(t);

        for (var o = n.length - 1; o >= 0; --o) {
          r = r.concat(t[n[o]]);
        }

        return r.push(parseInt(e)), r;
      }
    }, {
      key: "_getMainPlayerPosition",
      value: function _getMainPlayerPosition() {
        var e = this._scenemanager.cameraComponent.getCameraPose().position,
            t = this._scenemanager.avatarComponent.getMainAvatar();

        if (t != null && t != null) {
          var r = t.position;
          if (r != null) return r;
        }

        return e;
      }
    }, {
      key: "_calHashCode",
      value: function _calHashCode(e) {
        return hashCode(e) + "_" + this._partMeshSkinInfo;
      }
    }, {
      key: "forceAllRegionLod",
      value: function forceAllRegionLod() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3;
        e < 0 && (e = 0), e > 3 && (e = 3), this.stopMeshUpdate(), this._allowRegionForceLod = !0, this._forceLod = e;
      }
    }, {
      key: "deleteLastRegionMesh",
      value: function deleteLastRegionMesh() {
        if (this._rootDir != "") {
          var e = this._calHashCode(this._rootDir);

          this._currentMeshUsedLod.clear(), this._currentPartGroup.clear(), this._meshInfoJson = null, this._meshInfoKeys = [], this._currentUpdateRegionCount = 0, this._orijson = null, this._notUsedRegionLists = [], this._partMeshSkinInfo = "", this._abosoluteUrl = "", this.stopMeshUpdate(), this.deleteMeshesByCustomProperty("group", "region_" + e, !0);
        }
      }
    }, {
      key: "startMeshUpdate",
      value: function startMeshUpdate() {
        this._allowRegionUpdate == !1 && this._meshInfoJson != null && this._abosoluteUrl != "" && this._meshInfoKeys.length > 0 && (this._allowRegionUpdate = !0);
      }
    }, {
      key: "stopMeshUpdate",
      value: function stopMeshUpdate() {
        this._allowRegionUpdate = !1;
      }
    }, {
      key: "parseJson",
      value: function parseJson(e) {
        var _this2 = this;

        return new Promise(function (t, r) {
          return _this2._scenemanager.urlTransformer(e).then(function (n) {
            var o = new XMLHttpRequest();
            o.open("get", n), o.send(null), o.onload = function () {
              if (o.status == 200) {
                var a = JSON.parse(o.responseText);
                _this2._orijson = a, _this2._meshInfoJson = _this2._orijson.usedRegion, _this2._notUsedRegionLists = _this2._orijson.notUsedRegion, _this2._meshInfoKeys = Object.keys(_this2._meshInfoJson), logger$1.info("[Engine] parse zip mesh info successful"), t();
              }
            }, o.onerror = function () {
              logger$1.error("[Engine] load zip mesh info json error, (provided by blob): ".concat(n)), r(new XLowpolyJsonError("[Engine] load zip mesh info json error, (provided by blob): ".concat(n)));
            };
          }).catch(function (n) {
            logger$1.error("[Engine] load zip mesh info json error: ".concat(n, ", link:").concat(e)), r(new XLowpolyJsonError("[Engine] load zip mesh info json error: ".concat(n, ", link: ").concat(e)));
          });
        });
      }
    }, {
      key: "initCgLowModel",
      value: function initCgLowModel() {
        var e = BABYLON.MeshBuilder.CreatePlane("CgPlane", {
          size: 400
        });
        e.position = new BABYLON.Vector3(0, 1010, 0), e.rotation = new BABYLON.Vector3(3 * Math.PI / 2, 0, 0), this._CgPlane = new XStaticMesh({
          id: "CgPlane",
          mesh: e,
          xtype: EMeshType.Cgplane
        }), this._CgPlane.hide();
      }
    }, {
      key: "getLowModelType",
      value: function getLowModelType(e) {
        var t = "";
        return e.group != null ? t = e.group : t = "default", t;
      }
    }, {
      key: "lowmodelGroupMapAddValue",
      value: function lowmodelGroupMapAddValue(e, t) {
        var r = this._lowModel_group.get(e);

        r != null ? (r.push(t), this._lowModel_group.set(e, r)) : this._lowModel_group.set(e, [t]);
      }
    }, {
      key: "updateLowModelGroup",
      value: function updateLowModelGroup(e, t, r) {
        var n = r;
        e.group == t || (n = -1), e.mode == 0 ? this.deleteLowModelGroup(e.group, n) : e.mode == 1 ? this.toggleVisibleLowModelGroup(!1, e.group, n) : e.mode == 2 && this.toggleVisibleLowModelGroup(!0, e.group, n);
      }
    }, {
      key: "toggleVisibleLowModelGroup",
      value: function toggleVisibleLowModelGroup(e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;

        if (this._lowModel_group.has(t)) {
          var n = this._lowModel_group.get(t);

          var o = n.length;
          r >= 0 && o >= r && (o = r);

          for (var a = 0; a < o; ++a) {
            n[a].toggleVisibility(e);
          }
        }
      }
    }, {
      key: "deleteLowModelGroup",
      value: function deleteLowModelGroup(e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;

        if (this._lowModel_group.has(e)) {
          var o = this._lowModel_group.get(e);

          var a = o.length;
          t >= 0 && a >= t && (a = t);

          for (var s = 0; s < a; ++s) {
            o[s].dispose();
          }

          t >= 0 ? this._lowModel_group.set(e, this._lowModel_group.get(e).slice(a)) : this._lowModel_group.delete(e);
        }

        var r = this._lowModel_group.get(e),
            n = [];

        r != null && r.length > 0 ? this._staticmeshes.forEach(function (o) {
          if (o.group != e) n.push(o);else for (var _a2 = 0; _a2 < r.length; ++_a2) {
            o.groupUuid == r[_a2].groupUuid && n.push(o);
          }
        }) : this._staticmeshes.forEach(function (o) {
          o.group != e && n.push(o);
        }), this._staticmeshes = n;
      }
    }, {
      key: "deleteMeshesByGroup",
      value: function deleteMeshesByGroup(e) {
        this.deleteLowModelGroup(e);
      }
    }, {
      key: "deleteMeshesById",
      value: function deleteMeshesById(e) {
        this.deleteMeshesByCustomProperty("id", e);
      }
    }, {
      key: "deleteMeshesByLoD",
      value: function deleteMeshesByLoD(e) {
        this.deleteMeshesByCustomProperty("lod", e);
      }
    }, {
      key: "deleteMeshesBySkinInfo",
      value: function deleteMeshesBySkinInfo(e) {
        this.deleteMeshesByCustomProperty("skinInfo", e);
      }
    }, {
      key: "removeMeshesFromSceneByGroup",
      value: function removeMeshesFromSceneByGroup(e) {
        this.removeMeshesFromSceneByCustomProperty("group", e);
      }
    }, {
      key: "removeMeshesFromSceneById",
      value: function removeMeshesFromSceneById(e) {
        this.removeMeshesFromSceneByCustomProperty("id", e);
      }
    }, {
      key: "addMeshesToSceneByGroup",
      value: function addMeshesToSceneByGroup(e) {
        this.addMeshesToSceneByCustomProperty("group", e);
      }
    }, {
      key: "addMeshesToSceneById",
      value: function addMeshesToSceneById(e) {
        this.addMeshesToSceneByCustomProperty("id", e);
      }
    }, {
      key: "removeMeshesFromSceneByCustomProperty",
      value: function removeMeshesFromSceneByCustomProperty(e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !1;

        this._staticmeshes.forEach(function (n) {
          n.isinscene && n[e] != null && (r ? n[e].indexOf(t) < 0 || n.removeFromScene() : n[e] != t || n.removeFromScene());
        });
      }
    }, {
      key: "addMeshesToSceneByCustomProperty",
      value: function addMeshesToSceneByCustomProperty(e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !1;

        this._staticmeshes.forEach(function (n) {
          n.isinscene == !1 && n[e] != null && (r ? n[e].indexOf(t) < 0 || n.addToScene() : n[e] != t || n.addToScene());
        });
      }
    }, {
      key: "deleteMeshesByCustomProperty",
      value: function deleteMeshesByCustomProperty(e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !1;
        var n = [];
        this._staticmeshes.forEach(function (a) {
          a[e] != null && (r ? a[e].indexOf(t) < 0 ? n.push(a) : a.dispose() : a[e] != t ? n.push(a) : a.dispose());
        }), this._staticmeshes = n;
        var o = Array.from(this._lowModel_group.keys());

        for (var a = 0; a < o.length; ++a) {
          var s = o[a],
              l = this._lowModel_group.get(s);

          if (l != null) {
            var u = [];

            for (var c = 0; c < l.length; ++c) {
              l[c][e] != null && (r ? l[c][e].indexOf(t) < 0 && u.push(l[c]) : l[c][e] != t && u.push(l[c]));
            }

            u.length > 0 ? this._lowModel_group.set(s, u) : this._lowModel_group.delete(s);
          }
        }
      }
    }, {
      key: "getMeshes",
      value: function getMeshes() {
        var e = [];

        for (var t = 0; t < this._staticmeshes.length; ++t) {
          e = e.concat(this._staticmeshes[t].meshes);
        }

        return e;
      }
    }, {
      key: "getCgMesh",
      value: function getCgMesh() {
        return this._CgPlane;
      }
    }, {
      key: "getMeshesByGroup",
      value: function getMeshesByGroup() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default";

        var t = this._lowModel_group.get(e);

        if (t != null) {
          var r = [];

          for (var n = 0; n < t.length; ++n) {
            r = r.concat(t[n].meshes);
          }

          return r;
        } else return null;
      }
    }, {
      key: "getMeshesByGroup2",
      value: function getMeshesByGroup2() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default";
        return this._getMeshesByCustomProperty("group", e);
      }
    }]);

    return XStaticMeshComponent;
  }();

  var XVideoRawYUV = /*#__PURE__*/function () {
    function XVideoRawYUV(e, t) {
      var _this = this;

      _classCallCheck(this, XVideoRawYUV);

      E(this, "scene");
      E(this, "_videoRawYUVTexture");
      E(this, "videosResOriArray");
      E(this, "_currentVideoId");
      this.scene = e, this._videoRawYUVTexture = [], this.videosResOriArray = t, this._currentVideoId = -1;

      for (var r = 0; r < t.length; ++r) {
        (function (n) {
          var o = BABYLON.RawTexture.CreateLuminanceTexture(null, t[n].width, t[n].height * 1.5, _this.scene, !1, !0);
          o.name = "videoTex_" + t[n].width + "_" + t[n].height, _this._videoRawYUVTexture.push(o);
        })(r);
      }
    }

    _createClass(XVideoRawYUV, [{
      key: "inRange",
      value: function inRange(e) {
        return e >= 0 && e < this._videoRawYUVTexture.length;
      }
    }, {
      key: "getVideoYUVTex",
      value: function getVideoYUVTex(e) {
        return this.inRange(e) ? this._videoRawYUVTexture[e] : null;
      }
    }, {
      key: "findId",
      value: function findId(e, t) {
        var r = 0;

        for (var n = 0; n < this.videosResOriArray.length; ++n) {
          if (this.videosResOriArray[n].width == e && this.videosResOriArray[n].height == t) {
            r = n;
            break;
          }
        }

        return r;
      }
    }, {
      key: "getCurrentVideoTexId",
      value: function getCurrentVideoTexId() {
        return this._currentVideoId;
      }
    }, {
      key: "setCurrentVideoTexId",
      value: function setCurrentVideoTexId(e) {
        this._currentVideoId = e;
      }
    }]);

    return XVideoRawYUV;
  }();

  var XMaterialComponent = /*#__PURE__*/function () {
    function XMaterialComponent(e, t) {
      var _this = this;

      _classCallCheck(this, XMaterialComponent);

      E(this, "scene");
      E(this, "engine");
      E(this, "yuvInfo");
      E(this, "shaderMode");
      E(this, "_panoInfo");
      E(this, "_dynamic_size");
      E(this, "_dynamic_babylonpose");
      E(this, "_dynamic_textures");
      E(this, "_dynamic_shaders");
      E(this, "_scenemanager");
      E(this, "_videoTexture");
      E(this, "_videoElement");
      E(this, "_lowModelShader");
      E(this, "_defaultShader");
      E(this, "_inputYUV420", !0);
      E(this, "_inputPanoYUV420", !0);
      E(this, "_videoRawYUVTexArray");
      E(this, "_isUpdateYUV", !0);
      E(this, "initMaterial", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
        return regenerator.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                return _context.abrupt("return", new Promise(function (e, t) {
                  _this._initDefaultShader(), _this.shaderMode == 2 ? _this.initDynamicData(_this._panoInfo.dynamicRange, _this._panoInfo.width, _this._panoInfo.height).then(function () {
                    _this._initPureVideoShader(), _this._prepareRender(_this.yuvInfo);
                  }) : _this.shaderMode == 1 ? (_this._initPureVideoShader(), _this._prepareRender(_this.yuvInfo)) : _this.shaderMode == 0, e(!0);
                }));

              case 1:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      })));
      E(this, "_initPureVideoContent", function (e) {
        _this._inputYUV420 ? _this._videoRawYUVTexArray.getVideoYUVTex(0) != null && (_this._lowModelShader.setTexture("texture_video", _this._videoRawYUVTexArray.getVideoYUVTex(0)), _this._lowModelShader.setFloat("isYUV", 1), BABYLON.Texture.WhenAllReady([_this._videoRawYUVTexArray.getVideoYUVTex(0)], function () {
          _this._changePureVideoLowModelShaderCanvasSize(e);
        })) : (_this._videoElement = e.videoElement, _this._videoTexture || (_this._videoTexture = new VideoTexture("InterVideoTexture", _this._videoElement, _this.scene, !0, !1)), BABYLON.Texture.WhenAllReady([_this._videoTexture], function () {
          _this._changePureVideoLowModelShaderCanvasSize({
            width: _this._videoElement.height,
            height: _this._videoElement.width,
            fov: e.fov
          });
        }), _this._lowModelShader.setTexture("texture_video", _this._videoTexture), _this._lowModelShader.setFloat("isYUV", 0));
      });
      E(this, "_changePureVideoLowModelShaderCanvasSize", function (e) {
        var a;
        var t = e.fov || 50,
            r = e.width || 720,
            n = e.height || 1280,
            o = r / (2 * Math.tan(Math.PI * t / 360));
        (a = _this._lowModelShader) == null || a.setVector3("focal_width_height", new BABYLON.Vector3(o, r, n));
      });
      E(this, "updateRawYUVData", function (e, t, r) {
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
        var o, a;

        if (n == -1 && (n = _this.yuvInfo.fov), _this._isUpdateYUV == !0) {
          var s = {
            width: t,
            height: r,
            fov: n
          },
              l = _this._videoRawYUVTexArray.findId(t, r),
              u = _this._videoRawYUVTexArray.getCurrentVideoTexId();

          (u < 0 || l != u || n != _this.yuvInfo.fov) && (_this.yuvInfo.width = t, _this.yuvInfo.height = r, _this.yuvInfo.fov = n, _this._videoRawYUVTexArray.setCurrentVideoTexId(l), _this._changeVideoRes(l), _this._changePureVideoLowModelShaderCanvasSize(s), _this._scenemanager.cameraComponent.cameraFovChange(s), _this._scenemanager.yuvInfo = s), (o = _this._videoRawYUVTexArray.getVideoYUVTex(l)) == null || o.update(e), (a = _this._videoRawYUVTexArray.getVideoYUVTex(l)) == null || a.updateSamplingMode(BABYLON.Texture.BILINEAR_SAMPLINGMODE);
        }
      });
      E(this, "_changeVideoRes", function (e) {
        _this._lowModelShader.setTexture("texture_video", _this._videoRawYUVTexArray.getVideoYUVTex(e));
      });
      E(this, "initDynamicData", function (e, t, r) {
        return new Promise(function (n, o) {
          _this.setDynamicSize(e).then(function (a) {
            if (a) {
              for (var s = 0; s < e; ++s) {
                (function (l) {
                  _this.initDynamicTexture(l, t, r), _this.initDynamicShaders(l).then(function () {
                    _this._updatePanoShaderInput(l);
                  });
                })(s);
              }

              n(!0);
            } else o(new XMaterialError("[Engine] DynamicRoomSize (".concat(e, ") is too small")));
          });
        }).catch(function (n) {
          return logger$1.error("[Engine] ".concat(n));
        });
      });
      E(this, "_initDefaultShader", function () {
        _this._defaultShader == null && (_this._defaultShader = new BABYLON.GridMaterial("GridShader", _this.scene), _this._defaultShader.gridRatio = 50, _this._defaultShader.lineColor = new BABYLON.Color3(0, 0, .5), _this._defaultShader.majorUnitFrequency = 1, _this._defaultShader.mainColor = new BABYLON.Color3(.6, .6, .6), _this._defaultShader.backFaceCulling = !1);
      });
      E(this, "_initPureVideoShader", function () {
        if (_this._lowModelShader == null) {
          var _e = new BABYLON.ShaderMaterial("PureVideoShader", _this.scene, {
            vertexSource: pureVideoVertex,
            fragmentSource: pureVideoFragment
          }, {
            attributes: ["uv", "position", "world0", "world1", "world2", "world3"],
            uniforms: ["view", "projection", "worldViewProjection", "world"],
            defines: ["#define SHADOWFULLFLOAT"]
          });

          _e.setTexture("shadowSampler", null), _e.setMatrix("lightSpaceMatrix", null), _e.setFloat("haveShadowLight", 0), _e.setTexture("texture_video", null), _e.setFloat("isYUV", _this._inputYUV420 ? 1 : 0), _e.setFloat("fireworkLight", 0), _e.setVector3("fireworkLightPosition", new BABYLON.Vector3(0, 0, 0)), _e.setVector3("focal_width_height", new BABYLON.Vector3(772.022491, 720, 1280)), _e.backFaceCulling = !1, _this._lowModelShader = _e;
        }
      });
      E(this, "setDynamicSize", function (e) {
        return new Promise(function (t, r) {
          e >= 1 && e <= 100 ? (_this._dynamic_size = e, t(!0)) : (_this._dynamic_size = 1, t(!1));
        });
      });
      E(this, "_isInDynamicRange", function (e) {
        return e < _this._dynamic_size && e >= 0;
      });
      E(this, "initDynamicTexture", function (e, t, r) {
        _this._isInDynamicRange(e) && (_this._dynamic_textures[e] != null && (_this._dynamic_textures[e].dispose(), _this._dynamic_textures[e] = null), _this._dynamic_textures[e] = new BABYLON.RawTexture(null, t, r * 1.5, BABYLON.Engine.TEXTUREFORMAT_LUMINANCE, _this.scene, !1, !0, BABYLON.Texture.NEAREST_SAMPLINGMODE, BABYLON.Engine.TEXTURETYPE_UNSIGNED_BYTE), _this._dynamic_textures[e].name = "Pano_Dynamic_" + e + "_" + Date.now());
      });
      E(this, "initDynamicShaders", function (e) {
        return logger$1.info("[Engine] Material init dynamic shader."), new Promise(function (t, r) {
          _this._dynamic_shaders[e] != null && _this._dynamic_shaders[e].dispose();
          var n = new BABYLON.ShaderMaterial("Pano_Shader_" + e, _this.scene, {
            vertexSource: panoVertex,
            fragmentSource: panoFragment
          }, {
            attributes: ["uv", "position", "world0", "world1", "world2", "world3"],
            uniforms: ["view", "projection", "worldViewProjection", "world"],
            defines: ["#define SHADOWFULLFLOAT"]
          });
          n.setTexture("texture_pano", null), n.setVector3("centre_pose", new BABYLON.Vector3(0, 0, 0)), n.setFloat("isYUV", _this._inputPanoYUV420 ? 1 : 0), n.setTexture("shadowSampler", null), n.setMatrix("lightSpaceMatrix", null), n.setFloat("haveShadowLight", 0), n.setFloat("fireworkLight", 0), n.setVector3("fireworkLightPosition", new BABYLON.Vector3(0, 0, 0)), n.backFaceCulling = !1, _this._dynamic_shaders[e] = n, t(!0);
        });
      });
      this._scenemanager = e, this.scene = e.Scene, this.engine = this.scene.getEngine(), this.shaderMode = 1, this._dynamic_textures = [], this._dynamic_shaders = [], this._dynamic_babylonpose = [], this._videoRawYUVTexArray = new XVideoRawYUV(this.scene, t.videoResOriArray), this.shaderMode = t.shaderMode, t.yuvInfo != null && (this.yuvInfo = t.yuvInfo), t.panoInfo != null && this.setPanoInfo(t.panoInfo);
    }

    _createClass(XMaterialComponent, [{
      key: "stopYUVUpdate",
      value: function stopYUVUpdate() {
        this._isUpdateYUV = !1;
      }
    }, {
      key: "allowYUVUpdate",
      value: function allowYUVUpdate() {
        this._isUpdateYUV = !0;
      }
    }, {
      key: "setPanoInfo",
      value: function setPanoInfo(e) {
        this._panoInfo = e;
      }
    }, {
      key: "_prepareRender",
      value: function _prepareRender(e) {
        e && (this._initPureVideoContent(e), this._updatePureVideoShaderInput());
      }
    }, {
      key: "getPureVideoShader",
      value: function getPureVideoShader() {
        return this._lowModelShader;
      }
    }, {
      key: "getDefaultShader",
      value: function getDefaultShader() {
        return this._defaultShader;
      }
    }, {
      key: "updatePanoPartYUV",
      value: function updatePanoPartYUV(e, t, r) {
        var n = t.subarray(0, r.width * r.height),
            o = t.subarray(r.width * r.height, r.width * r.height * 1.25),
            a = t.subarray(r.width * r.height * 1.25),
            s = this._panoInfo.width,
            l = this._panoInfo.height;

        if (this._dynamic_textures[e] != null) {
          var u = this._dynamic_textures[e].getInternalTexture();

          if (u != null && u != null) {
            var c = this.engine._getTextureTarget(u);

            this.engine._bindTextureDirectly(c, u, !0), this.engine.updateTextureData(u, n, r.startX, l * 1.5 - r.startY - r.height, r.width, r.height), this.engine.updateTextureData(u, o, r.startX * .5, (l - r.startY - r.height) * .5, r.width * .5 - 1, r.height * .5 - 1), this.engine.updateTextureData(u, a, r.startX * .5 + s * .5, (l - r.startY - r.height) * .5, r.width * .5, r.height * .5), this.engine._bindTextureDirectly(c, null);
          }
        }
      }
    }, {
      key: "changePanoImg",
      value: function changePanoImg(e, t) {
        var _this2 = this;

        if (logger$1.info("[Engine] changePanoImg, id=".concat(e, ", pose=").concat(t.pose.position.x, ",").concat(t.pose.position.y, ",").concat(t.pose.position.z)), !this._isInDynamicRange(e)) return logger$1.error("[Engine] ".concat(e, " is bigger than dynamic size set in PanoInfo")), Promise.reject(new XMaterialError("[Engine] ".concat(e, " is bigger than dynamic size set in PanoInfo")));
        var r = ue4Position2Xverse(t.pose.position);
        return r && (this._dynamic_babylonpose[e] = {
          position: r
        }), new Promise(function (n, o) {
          try {
            typeof t.data == "string" ? (_this2.setPanoYUV420(!1), _this2._dynamic_textures[e].updateURL(t.data, null, function () {
              _this2._dynamic_textures[e].updateSamplingMode(BABYLON.Texture.NEAREST_SAMPLINGMODE);
            })) : (_this2.isPanoYUV420() == !1 && _this2.initDynamicTexture(e, _this2._panoInfo.width, _this2._panoInfo.height), _this2.setPanoYUV420(!0), _this2._dynamic_textures[e].update(t.data), _this2._dynamic_textures[e].updateSamplingMode(BABYLON.Texture.NEAREST_SAMPLINGMODE)), n(_this2);
          } catch (a) {
            o(new XMaterialError("[Engine] ChangePanoImg Error! ".concat(a)));
          }
        }).then(function (n) {
          return t.fov != null && _this2._scenemanager.cameraComponent.changeCameraFov(t.fov * Math.PI / 180), _this2._dynamic_shaders[e].setFloat("isYUV", _this2._inputPanoYUV420 ? 1 : 0), _this2._dynamic_shaders[e].setTexture("texture_pano", _this2._dynamic_textures[e]), _this2._dynamic_shaders[e].setVector3("centre_pose", _this2._dynamic_babylonpose[e].position), !0;
        });
      }
    }, {
      key: "setYUV420",
      value: function setYUV420(e) {
        this._inputYUV420 = e;
      }
    }, {
      key: "isYUV420",
      value: function isYUV420() {
        return this._inputYUV420;
      }
    }, {
      key: "setPanoYUV420",
      value: function setPanoYUV420(e) {
        this._inputPanoYUV420 = e;
      }
    }, {
      key: "isPanoYUV420",
      value: function isPanoYUV420() {
        return this._inputPanoYUV420;
      }
    }, {
      key: "getDynamicShader",
      value: function getDynamicShader(e) {
        return this._dynamic_shaders[e];
      }
    }, {
      key: "_updatePureVideoShaderInput",
      value: function _updatePureVideoShaderInput() {
        var _this3 = this;

        var e, t, r, n, o, a, s, l, u, c;
        if (this.scene.getLightByName("AvatarLight") ? ((e = this._lowModelShader) == null || e.setFloat("haveShadowLight", 1), (n = this._lowModelShader) == null || n.setTexture("shadowSampler", (r = (t = this.scene.getLightByName("AvatarLight")) == null ? void 0 : t.getShadowGenerator()) == null ? void 0 : r.getShadowMapForRendering()), (s = this._lowModelShader) == null || s.setMatrix("lightSpaceMatrix", (a = (o = this.scene.getLightByName("AvatarLight")) == null ? void 0 : o.getShadowGenerator()) == null ? void 0 : a.getTransformMatrix())) : ((l = this._lowModelShader) == null || l.setTexture("shadowSampler", this._videoTexture), (u = this._lowModelShader) == null || u.setMatrix("lightSpaceMatrix", new Matrix()), (c = this._lowModelShader) == null || c.setFloat("haveShadowLight", 0)), this.scene.getLightByName("fireworkLight")) this.scene.registerBeforeRender(function () {
          var h;
          _this3._lowModelShader.setFloat("fireworkLight", _this3.scene.getLightByName("fireworkLight").getScaledIntensity()), _this3._lowModelShader.setVector3("fireworkLightPosition", (h = _this3.scene.getLightByName("fireworkLight")) == null ? void 0 : h.position);
        });else {
          var h = new BABYLON.PointLight("fireworkLight", new BABYLON.Vector3(0, 0, 0), this.scene);
          h.intensity = 0;
        }
      }
    }, {
      key: "_updatePanoShaderInput",
      value: function _updatePanoShaderInput(e) {
        var _this4 = this;

        var t, r, n, o, a, s, l, u, c, h;
        if (this._isInDynamicRange(e)) if (this.scene.getLightByName("AvatarLight") ? ((t = this._dynamic_shaders[e]) == null || t.setFloat("haveShadowLight", 1), (o = this._dynamic_shaders[e]) == null || o.setTexture("shadowSampler", (n = (r = this.scene.getLightByName("AvatarLight")) == null ? void 0 : r.getShadowGenerator()) == null ? void 0 : n.getShadowMapForRendering()), (l = this._dynamic_shaders[e]) == null || l.setMatrix("lightSpaceMatrix", (s = (a = this.scene.getLightByName("AvatarLight")) == null ? void 0 : a.getShadowGenerator()) == null ? void 0 : s.getTransformMatrix())) : ((u = this._dynamic_shaders[e]) == null || u.setTexture("shadowSampler", null), (c = this._dynamic_shaders[e]) == null || c.setMatrix("lightSpaceMatrix", new Matrix()), (h = this._dynamic_shaders[e]) == null || h.setFloat("haveShadowLight", 0)), this.scene.getLightByName("fireworkLight")) this.scene.registerBeforeRender(function () {
          var f;
          _this4._dynamic_shaders[e].setFloat("fireworkLight", _this4.scene.getLightByName("fireworkLight").getScaledIntensity()), _this4._dynamic_shaders[e].setVector3("fireworkLightPosition", (f = _this4.scene.getLightByName("fireworkLight")) == null ? void 0 : f.position);
        });else {
          var f = new BABYLON.PointLight("fireworkLight", new BABYLON.Vector3(0, 0, 0), this.scene);
          f.intensity = 0;
        }
      }
    }]);

    return XMaterialComponent;
  }();

  var XStats = /*#__PURE__*/function () {
    function XStats(e) {
      _classCallCheck(this, XStats);

      E(this, "scene");
      E(this, "sceneInstrumentation");
      E(this, "engineInstrumentation");
      E(this, "caps");
      E(this, "engine");
      E(this, "_canvas");
      E(this, "_osversion");
      E(this, "_scenemanager");
      this._scenemanager = e, this.scene = e.Scene, this._canvas = e.canvas, this.initSceneInstrument();
    }

    _createClass(XStats, [{
      key: "initSceneInstrument",
      value: function initSceneInstrument() {
        this.sceneInstrumentation = new BABYLON.SceneInstrumentation(this.scene), this.sceneInstrumentation.captureCameraRenderTime = !0, this.sceneInstrumentation.captureActiveMeshesEvaluationTime = !0, this.sceneInstrumentation.captureRenderTargetsRenderTime = !0, this.sceneInstrumentation.captureFrameTime = !0, this.sceneInstrumentation.captureRenderTime = !0, this.sceneInstrumentation.captureInterFrameTime = !0, this.sceneInstrumentation.captureParticlesRenderTime = !0, this.sceneInstrumentation.captureSpritesRenderTime = !0, this.sceneInstrumentation.capturePhysicsTime = !0, this.sceneInstrumentation.captureAnimationsTime = !0, this.engineInstrumentation = new BABYLON.EngineInstrumentation(this.scene.getEngine()), this.caps = this.scene.getEngine().getCaps(), this.engine = this.scene.getEngine(), this._osversion = this.osVersion();
      }
    }, {
      key: "getFrameTimeCounter",
      value: function getFrameTimeCounter() {
        return this.sceneInstrumentation.frameTimeCounter.current;
      }
    }, {
      key: "getInterFrameTimeCounter",
      value: function getInterFrameTimeCounter() {
        return this.sceneInstrumentation.interFrameTimeCounter.current;
      }
    }, {
      key: "getActiveMeshEvaluationTime",
      value: function getActiveMeshEvaluationTime() {
        return this.sceneInstrumentation.activeMeshesEvaluationTimeCounter.current;
      }
    }, {
      key: "getDrawCall",
      value: function getDrawCall() {
        return this.sceneInstrumentation.drawCallsCounter.current;
      }
    }, {
      key: "getDrawCallTime",
      value: function getDrawCallTime() {
        return this.sceneInstrumentation.renderTimeCounter.current;
      }
    }, {
      key: "getAnimationTime",
      value: function getAnimationTime() {
        return this.sceneInstrumentation.animationsTimeCounter.current;
      }
    }, {
      key: "getActiveMesh",
      value: function getActiveMesh() {
        return this.scene.getActiveMeshes().length;
      }
    }, {
      key: "getActiveFaces",
      value: function getActiveFaces() {
        return Math.round(this.scene.getActiveIndices() / 3);
      }
    }, {
      key: "getActiveBones",
      value: function getActiveBones() {
        return this.scene.getActiveBones();
      }
    }, {
      key: "getActiveAnimation",
      value: function getActiveAnimation() {
        return this.scene._activeAnimatables.length;
      }
    }, {
      key: "getActiveParticles",
      value: function getActiveParticles() {
        return this.scene.getActiveParticles();
      }
    }, {
      key: "getTotalMaterials",
      value: function getTotalMaterials() {
        return this.scene.materials.length;
      }
    }, {
      key: "getTotalTextures",
      value: function getTotalTextures() {
        return this.scene.textures.length;
      }
    }, {
      key: "getTotalGeometries",
      value: function getTotalGeometries() {
        return this.scene.geometries.length;
      }
    }, {
      key: "getTotalMeshes",
      value: function getTotalMeshes() {
        return this.scene.meshes.length;
      }
    }, {
      key: "getCameraRenderTime",
      value: function getCameraRenderTime() {
        return this.sceneInstrumentation.cameraRenderTimeCounter.current;
      }
    }, {
      key: "getTotalRootNodes",
      value: function getTotalRootNodes() {
        return this.scene.rootNodes.length;
      }
    }, {
      key: "getRenderTargetRenderTime",
      value: function getRenderTargetRenderTime() {
        var e = this.getDrawCallTime(),
            t = this.getActiveMeshEvaluationTime(),
            r = this.getCameraRenderTime() - (t + e);
        return this.getRTT1Time() + r;
      }
    }, {
      key: "getRegisterBeforeRenderTime",
      value: function getRegisterBeforeRenderTime() {
        return this.sceneInstrumentation.registerBeforeTimeCounter.current;
      }
    }, {
      key: "getRegisterAfterRenderTime",
      value: function getRegisterAfterRenderTime() {
        return this.sceneInstrumentation.registerAfterTimeCounter.current;
      }
    }, {
      key: "getRTT1Time",
      value: function getRTT1Time() {
        return this.sceneInstrumentation.getRTT1TimeCounter.current;
      }
    }, {
      key: "getRegisterBeforeRenderObserverLength",
      value: function getRegisterBeforeRenderObserverLength() {
        return this.scene.onBeforeRenderObservable.observers.length;
      }
    }, {
      key: "getRegisterAfterRenderObserverLength",
      value: function getRegisterAfterRenderObserverLength() {
        return this.scene.onAfterRenderObservable.observers.length;
      }
    }, {
      key: "getTotalMeshByType",
      value: function getTotalMeshByType() {
        var e = new Map();
        return this.scene.meshes.forEach(function (t) {
          e.has(t.xtype) ? e.set(t.xtype, e.get(t.xtype) + 1) : e.set(t.xtype, 1);
        }), e;
      }
    }, {
      key: "getHardwareRenderInfo",
      value: function getHardwareRenderInfo() {
        return {
          maxTexturesUnits: this.caps.maxTexturesImageUnits,
          maxVertexTextureImageUnits: this.caps.maxVertexTextureImageUnits,
          maxCombinedTexturesImageUnits: this.caps.maxCombinedTexturesImageUnits,
          maxTextureSize: this.caps.maxTextureSize,
          maxSamples: this.caps.maxSamples,
          maxCubemapTextureSize: this.caps.maxCubemapTextureSize,
          maxRenderTextureSize: this.caps.maxRenderTextureSize,
          maxVertexAttribs: this.caps.maxVertexAttribs,
          maxVaryingVectors: this.caps.maxVaryingVectors,
          maxVertexUniformVectors: this.caps.maxVertexUniformVectors,
          maxFragmentUniformVectors: this.caps.maxFragmentUniformVectors,
          standardDerivatives: this.caps.standardDerivatives,
          supportTextureCompress: {
            s3tc: this.caps.s3tc !== void 0,
            s3tc_srgb: this.caps.s3tc_srgb !== void 0,
            pvrtc: this.caps.pvrtc !== void 0,
            etc1: this.caps.etc1 !== void 0,
            etc2: this.caps.etc2 !== void 0,
            astc: this.caps.astc !== void 0,
            bptc: this.caps.bptc !== void 0
          },
          textureFloat: this.caps.textureFloat,
          vertexArrayObject: this.caps.vertexArrayObject,
          textureAnisotropicFilterExtension: this.caps.textureAnisotropicFilterExtension !== void 0,
          maxAnisotropy: this.caps.maxAnisotropy,
          instancedArrays: this.caps.instancedArrays,
          uintIndices: this.caps.uintIndices,
          highPrecisionShaders: this.caps.highPrecisionShaderSupported,
          fragmentDepth: this.caps.fragmentDepthSupported,
          textureFloatLinearFiltering: this.caps.textureFloatLinearFiltering,
          renderToTextureFloat: this.caps.textureFloatRender,
          textureHalfFloat: this.caps.textureHalfFloat,
          textureHalfFloatLinearFiltering: this.caps.textureHalfFloatLinearFiltering,
          textureHalfFloatRender: this.caps.textureHalfFloatRender,
          textureLOD: this.caps.textureLOD,
          drawBuffersExtension: this.caps.drawBuffersExtension,
          depthTextureExtension: this.caps.depthTextureExtension,
          colorBufferFloat: this.caps.colorBufferFloat,
          supportTimerQuery: this.caps.timerQuery !== void 0,
          canUseTimestampForTimerQuery: this.caps.canUseTimestampForTimerQuery,
          supportOcclusionQuery: this.caps.supportOcclusionQuery,
          multiview: this.caps.multiview,
          oculusMultiview: this.caps.oculusMultiview,
          maxMSAASamples: this.caps.maxMSAASamples,
          blendMinMax: this.caps.blendMinMax,
          canUseGLInstanceID: this.caps.canUseGLInstanceID,
          canUseGLVertexID: this.caps.canUseGLVertexID,
          supportComputeShaders: this.caps.supportComputeShaders,
          supportSRGBBuffers: this.caps.supportSRGBBuffers,
          supportStencil: this.engine.isStencilEnable
        };
      }
    }, {
      key: "getSystemInfo",
      value: function getSystemInfo() {
        return {
          resolution: "real: " + this.engine.getRenderWidth() + "x" + this.engine.getRenderHeight() + "	 cavs: " + this._canvas.clientWidth + "x" + this._canvas.clientHeight,
          hardwareScalingLevel: this.engine.getHardwareScalingLevel().toFixed(2).toString() + "_" + this._scenemanager.initEngineScaleNumber.toFixed(2).toString(),
          driver: this.engine.getGlInfo().renderer,
          vender: this.engine.getGlInfo().vendor,
          version: this.engine.getGlInfo().version,
          os: this._osversion
        };
      }
    }, {
      key: "getFps",
      value: function getFps() {
        var e = this.sceneInstrumentation.frameTimeCounter.lastSecAverage,
            t = this.sceneInstrumentation.interFrameTimeCounter.lastSecAverage;
        return 1e3 / (e + t);
      }
    }, {
      key: "osVersion",
      value: function osVersion() {
        var e = window.navigator.userAgent;
        var t;
        return /iphone|ipad|ipod/gi.test(e) ? t = e.match(/OS (\d+)_(\d+)_?(\d+)?/) : /android/gi.test(e) && (t = e.match(/Android (\d+)/)), t != null && t.length > 0 ? t[0] : null;
      }
    }]);

    return XStats;
  }();

  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function _iterableToArrayLimit(arr, i) {
    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];

    if (_i == null) return;
    var _arr = [];
    var _n = true;
    var _d = false;

    var _s, _e;

    try {
      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$7(arr, i) || _nonIterableRest();
  }

  var BreathPoint = /*#__PURE__*/function () {
    function BreathPoint(e) {
      _classCallCheck(this, BreathPoint);

      E(this, "_staticmesh");
      E(this, "_id");
      E(this, "_mat");
      E(this, "_type");
      E(this, "_maxVisibleRegion");
      E(this, "_skinInfo");
      E(this, "_scene");
      E(this, "_isInScene");
      var t = e.mesh,
          r = e.id,
          n = e.position,
          o = e.rotation,
          a = e.mat,
          _e$type = e.type,
          s = _e$type === void 0 ? "default" : _e$type,
          _e$maxVisibleRegion = e.maxVisibleRegion,
          l = _e$maxVisibleRegion === void 0 ? -1 : _e$maxVisibleRegion,
          u = e.scene,
          _e$skinInfo = e.skinInfo,
          c = _e$skinInfo === void 0 ? "default" : _e$skinInfo;
      this._id = r, t.mesh.position = ue4Position2Xverse(n), t.mesh.rotation = ue4Rotation2Xverse(o), this._staticmesh = t, this._mat = a, this._type = s, this._maxVisibleRegion = l, this._scene = u, this._skinInfo = c, this._isInScene = !0;
    }

    _createClass(BreathPoint, [{
      key: "isInScene",
      get: function get() {
        return this._isInScene;
      }
    }, {
      key: "skinInfo",
      get: function get() {
        return this._skinInfo;
      }
    }, {
      key: "maxvisibleregion",
      get: function get() {
        return this._maxVisibleRegion;
      }
    }, {
      key: "getMesh",
      value: function getMesh() {
        return this._staticmesh;
      }
    }, {
      key: "mesh",
      get: function get() {
        return this._staticmesh.mesh;
      }
    }, {
      key: "toggleVisibility",
      value: function toggleVisibility(e) {
        e == !0 ? this._staticmesh.show() : this._staticmesh.hide();
      }
    }, {
      key: "changePickable",
      value: function changePickable(e) {
        this._staticmesh.mesh.isPickable = e;
      }
    }, {
      key: "removeFromScene",
      value: function removeFromScene() {
        this._isInScene && (this._staticmesh.mesh != null && this._scene.removeMesh(this._staticmesh.mesh), this._isInScene = !1);
      }
    }, {
      key: "addToScene",
      value: function addToScene() {
        this._isInScene == !1 && (this._staticmesh.mesh != null && this._scene.addMesh(this._staticmesh.mesh), this._isInScene = !0);
      }
    }, {
      key: "dispose",
      value: function dispose() {
        var e;
        (e = this._staticmesh.mesh) == null || e.dispose(!1, !1);
      }
    }, {
      key: "position",
      get: function get() {
        return xversePosition2Ue4(this._staticmesh.mesh.position);
      },
      set: function set(e) {
        this._staticmesh.mesh.position = ue4Position2Xverse(e);
      }
    }, {
      key: "rotation",
      get: function get() {
        return xverseRotation2Ue4(this._staticmesh.mesh.rotation);
      },
      set: function set(e) {
        this._staticmesh.mesh.rotation = ue4Rotation2Xverse(e);
      }
    }]);

    return BreathPoint;
  }();

  function _createForOfIteratorHelper$4(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$4(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

  function _unsupportedIterableToArray$4(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$4(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$4(o, minLen); }

  function _arrayLikeToArray$4(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

  var XBreathPointManager = /*#__PURE__*/function () {
    function XBreathPointManager(e) {
      var _this = this;

      _classCallCheck(this, XBreathPointManager);

      E(this, "_scene");
      E(this, "materialMap", new Map());
      E(this, "breathPoints", new Map());
      E(this, "_sceneManager");
      E(this, "_allIds", new Set());
      E(this, "_loopBPKeys", []);
      E(this, "addBreathPoint", /*#__PURE__*/function () {
        var _ref = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var t, r, n, _e$spriteSheet, o, _e$spriteWidthNumber, a, _e$spriteHeightNumber, s, l, _e$rotation, u, _e$size, c, _e$width, h, _e$height, f, _e$fps, d, _e$billboardMode, _, _e$forceLeaveGround, g, _e$type, m, _e$lifeTime, v, _e$backfaceculling, y, _e$maxVisibleRegion, b, _e$skinInfo, T, I, C, _I, _I2, A, _I3, S, P, R, M, x;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  t = [{
                    url: "https://static.xverse.cn/qqktv/texture.png"
                  }];

                  if (!(t.length <= 0)) {
                    _context.next = 4;
                    break;
                  }

                  logger$1.warn("[Engine] BreathPoint get texture list error: textureList.length <= 0"), new XBreathPointError("[Engine] BreathPoint get texture list error!");
                  return _context.abrupt("return");

                case 4:
                  r = t[0], n = e.id, _e$spriteSheet = e.spriteSheet, o = _e$spriteSheet === void 0 ? r.url : _e$spriteSheet, _e$spriteWidthNumber = e.spriteWidthNumber, a = _e$spriteWidthNumber === void 0 ? 20 : _e$spriteWidthNumber, _e$spriteHeightNumber = e.spriteHeightNumber, s = _e$spriteHeightNumber === void 0 ? 1 : _e$spriteHeightNumber, l = e.position, _e$rotation = e.rotation, u = _e$rotation === void 0 ? {
                    pitch: -90,
                    yaw: 270,
                    roll: 0
                  } : _e$rotation, _e$size = e.size, c = _e$size === void 0 ? .6 : _e$size, _e$width = e.width, h = _e$width === void 0 ? -1 : _e$width, _e$height = e.height, f = _e$height === void 0 ? -1 : _e$height, _e$fps = e.fps, d = _e$fps === void 0 ? 30 : _e$fps, _e$billboardMode = e.billboardMode, _ = _e$billboardMode === void 0 ? !1 : _e$billboardMode, _e$forceLeaveGround = e.forceLeaveGround, g = _e$forceLeaveGround === void 0 ? !1 : _e$forceLeaveGround, _e$type = e.type, m = _e$type === void 0 ? "default" : _e$type, _e$lifeTime = e.lifeTime, v = _e$lifeTime === void 0 ? -1 : _e$lifeTime, _e$backfaceculling = e.backfaceculling, y = _e$backfaceculling === void 0 ? !0 : _e$backfaceculling, _e$maxVisibleRegion = e.maxVisibleRegion, b = _e$maxVisibleRegion === void 0 ? -1 : _e$maxVisibleRegion, _e$skinInfo = e.skinInfo, T = _e$skinInfo === void 0 ? "default" : _e$skinInfo;

                  if (!_this.breathPoints.get(n)) {
                    _context.next = 8;
                    break;
                  }

                  logger$1.warn("[Engine] Cannot add breathPoint with an existing id: [" + n + "]"), new XBreathPointError("[Engine] Cannot add breathPoint with an existing id: [" + n + "]");
                  return _context.abrupt("return");

                case 8:
                  if (g) {
                    I = _this.castRay(new BABYLON.Vector3(l.x, l.y, l.z)) * scaleFromUE4toXverse;
                    I != 0 ? l.z = l.z - I + 1 : l.z = l.z + 1;
                  }

                  if (_this.materialMap.get(m)) {
                    _I = _this.materialMap.get(m);
                    _I.count = _I.count + 1, C = _I.mat;
                  } else {
                    _I2 = new BABYLON.Texture(o, _this._scene, !0, !0, BABYLON.Texture.BILINEAR_SAMPLINGMODE, null, function () {
                      logger$1.error("[Engine] Breathpoint create texture error."), new XBreathPointError("[Engine] Breathpoint create texture error.");
                    }, null, !0);
                    _I2.name = "TexBreathPoint_" + n, C = new BABYLON.StandardMaterial("MaterialBreathPoint_".concat(n), _this._scene), C.alpha = 1, C.emissiveTexture = _I2, C.backFaceCulling = y, C.diffuseTexture = _I2, C.diffuseTexture.hasAlpha = !0, C.useAlphaFromDiffuseTexture = !0, _this.materialMap.set(m, {
                      mat: C,
                      count: 1,
                      lastRenderTime: Date.now(),
                      fps: d,
                      spriteWidthNumber: a,
                      spriteHeightNumber: s,
                      spriteSheet: o,
                      texture: _I2
                    });
                  }

                  A = new Array(6);

                  for (_I3 = 0; _I3 < 6; _I3++) {
                    A[_I3] = new BABYLON.Vector4(0, 0, 0, 0);
                  }

                  A[0] = new BABYLON.Vector4(0, 0, 1 / a, 1 / s), A[1] = new BABYLON.Vector4(0, 0, 1 / a, 1 / s);
                  S = {};
                  h > 0 && f > 0 ? S = {
                    width: h,
                    height: f,
                    depth: .01,
                    faceUV: A
                  } : S = {
                    size: c,
                    depth: .01,
                    faceUV: A
                  };
                  P = BABYLON.MeshBuilder.CreateBox(n, S, _this._scene);
                  P.material = C;
                  R = new XStaticMesh({
                    id: n,
                    mesh: P,
                    xtype: EMeshType.XBreathPoint,
                    skinInfo: T
                  });
                  M = u;
                  _ && (P.billboardMode = BABYLON.Mesh.BILLBOARDMODE_ALL, R.allowMove(), M = {
                    pitch: 0,
                    yaw: 270,
                    roll: 0
                  });
                  x = new BreathPoint({
                    type: m,
                    mesh: R,
                    id: n,
                    position: l,
                    rotation: M,
                    mat: C,
                    maxVisibleRegion: b,
                    scene: _this._scene,
                    skinInfo: T
                  });
                  _this.breathPoints.set(n, x), _this._allIds.add(n), v > 0 && setTimeout(function () {
                    _this.clearBreathPoints(n);
                  }, v * 1e3);

                case 22:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee);
        }));

        return function (_x) {
          return _ref.apply(this, arguments);
        };
      }());
      E(this, "reg_breathpoint_update", function () {
        var e = new Date().getTime();

        if (_this.materialMap != null) {
          var _iterator = _createForOfIteratorHelper$4(_this.materialMap),
              _step;

          try {
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
              var _step$value = _slicedToArray(_step.value, 2),
                  t = _step$value[0],
                  r = _step$value[1];

              e - r.lastRenderTime > 1e3 / r.fps && (r.lastRenderTime = e, Math.abs(r.mat.diffuseTexture.uOffset - (1 - 1 / r.spriteWidthNumber)) < 1e-6 ? (r.mat.diffuseTexture.uOffset = 0, Math.abs(r.mat.diffuseTexture.vOffset - (1 - 1 / r.spriteHeightNumber)) < 1e-6 ? r.mat.diffuseTexture.vOffset = 0 : r.mat.diffuseTexture.vOffset += 1 / r.spriteHeightNumber) : r.mat.diffuseTexture.uOffset += 1 / r.spriteWidthNumber);
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }
        }
      });
      E(this, "reg_breathpoint_autovisible", function () {
        if (_this._scene.getFrameId() % 2 == 0) if (_this._loopBPKeys.length == 0) _this._loopBPKeys = Array.from(_this._allIds);else {
          var _e = _this._getMainPlayerPosition();

          for (var t = 0; t < 5 && _this._loopBPKeys.length > 0; ++t) {
            var r = _this._loopBPKeys.pop();

            if (r != null) {
              var n = _this.getBreathPoint(r);

              if (n != null && n.maxvisibleregion >= 0 && n.mesh.visibility == 1) {
                var o = n.mesh.position;
                calcDistance3DVector(_e, o) >= n.maxvisibleregion ? n == null || n.removeFromScene() : n == null || n.addToScene();
              }
            }
          }
        }
      });
      this._sceneManager = e, this._scene = e.Scene, this._scene.registerBeforeRender(this.reg_breathpoint_update), this._scene.registerBeforeRender(this.reg_breathpoint_autovisible);
    }

    _createClass(XBreathPointManager, [{
      key: "setAllBreathPointVisibility",
      value: function setAllBreathPointVisibility(e) {
        var _iterator2 = _createForOfIteratorHelper$4(this.breathPoints.entries()),
            _step2;

        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
            var _step2$value = _slicedToArray(_step2.value, 2),
                t = _step2$value[0],
                r = _step2$value[1];

            r.toggleVisibility(e);
          }
        } catch (err) {
          _iterator2.e(err);
        } finally {
          _iterator2.f();
        }
      }
    }, {
      key: "toggleBPVisibilityBySkinInfo",
      value: function toggleBPVisibilityBySkinInfo(e, t) {
        var _iterator3 = _createForOfIteratorHelper$4(this.breathPoints.entries()),
            _step3;

        try {
          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
            var _step3$value = _slicedToArray(_step3.value, 2),
                r = _step3$value[0],
                n = _step3$value[1];

            n.skinInfo == e && n.toggleVisibility(t);
          }
        } catch (err) {
          _iterator3.e(err);
        } finally {
          _iterator3.f();
        }
      }
    }, {
      key: "toggleBPVisibilityById",
      value: function toggleBPVisibilityById(e, t) {
        var r = this.getBreathPoint(e);
        r != null && r.toggleVisibility(t);
      }
    }, {
      key: "getBreathPointBySkinInfo",
      value: function getBreathPointBySkinInfo(e) {
        var t = [];

        var _iterator4 = _createForOfIteratorHelper$4(this.breathPoints.entries()),
            _step4;

        try {
          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
            var _step4$value = _slicedToArray(_step4.value, 2),
                r = _step4$value[0],
                n = _step4$value[1];

            n.skinInfo == e && t.push(n);
          }
        } catch (err) {
          _iterator4.e(err);
        } finally {
          _iterator4.f();
        }

        return t;
      }
    }, {
      key: "getAllBreathPoint",
      value: function getAllBreathPoint() {
        return this.breathPoints;
      }
    }, {
      key: "getBreathPoint",
      value: function getBreathPoint(e) {
        return this.breathPoints.get(e);
      }
    }, {
      key: "delete",
      value: function _delete(e) {
        var t = this.breathPoints.get(e);

        if (t != null) {
          t.dispose(), this._allIds.delete(e);
          var r = this.materialMap.get(t._type);
          r != null && (r.count = r.count - 1, r.count <= 0 && (r.count = 0, r.texture.dispose(), r.mat.dispose(!0, !0), this.materialMap.delete(t._type))), this.breathPoints.delete(e);
        }
      }
    }, {
      key: "castRay",
      value: function castRay(e) {
        var s;
        e = ue4Position2Xverse({
          x: e.x,
          y: e.y,
          z: e.z
        });
        var t = new BABYLON.Vector3(0, -1, 0),
            r = new BABYLON.Ray(e, t, length),
            n = [],
            o = (s = this._sceneManager) == null ? void 0 : s.getGround({
          x: e.x,
          y: e.y,
          z: e.z
        });
        var a = r.intersectsMeshes(o);

        if (a.length > 0) {
          var l = a[0];

          if (l && l.pickedMesh) {
            var u = l.distance;
            t.y = 1;
            var c = r.intersectsMeshes(n);
            var h = 1e8;

            if (c.length > 0) {
              var f = c[0];
              return f && f.pickedMesh && (h = -f.distance), h == 1e8 ? u : Math.abs(h) < Math.abs(u) ? h : u;
            }
          }
        } else if (t.y = 1, a = r.intersectsMeshes(n), a.length > 0) {
          var _l = a[0];
          if (_l && _l.pickedMesh) return _l.distance;
        }

        return 0;
      }
    }, {
      key: "changePickable",
      value: function changePickable(e) {
        var _iterator5 = _createForOfIteratorHelper$4(this.breathPoints.entries()),
            _step5;

        try {
          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
            var _step5$value = _slicedToArray(_step5.value, 2),
                t = _step5$value[0],
                r = _step5$value[1];

            r.changePickable(e);
          }
        } catch (err) {
          _iterator5.e(err);
        } finally {
          _iterator5.f();
        }
      }
    }, {
      key: "clearBreathPoints",
      value: function clearBreathPoints(e) {
        logger$1.info("[Engine] clearBreathPoints: ".concat(e));

        var _iterator6 = _createForOfIteratorHelper$4(this.breathPoints.entries()),
            _step6;

        try {
          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
            var _step6$value = _slicedToArray(_step6.value, 2),
                t = _step6$value[0],
                r = _step6$value[1];

            (r._type == e || r._id == e) && this.delete(r._id);
          }
        } catch (err) {
          _iterator6.e(err);
        } finally {
          _iterator6.f();
        }
      }
    }, {
      key: "clearBreathPointsBySkinInfo",
      value: function clearBreathPointsBySkinInfo(e) {
        logger$1.info("[Engine] clearBreathPointsBySkinInfo: ".concat(e));

        var _iterator7 = _createForOfIteratorHelper$4(this.breathPoints.entries()),
            _step7;

        try {
          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
            var _step7$value = _slicedToArray(_step7.value, 2),
                t = _step7$value[0],
                r = _step7$value[1];

            r.skinInfo == e && this.delete(r._id);
          }
        } catch (err) {
          _iterator7.e(err);
        } finally {
          _iterator7.f();
        }
      }
    }, {
      key: "clearAllBreathPoints",
      value: function clearAllBreathPoints() {
        logger$1.info("[Engine] ClearAllBreathPoints");

        var _iterator8 = _createForOfIteratorHelper$4(this.breathPoints.entries()),
            _step8;

        try {
          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
            var _step8$value = _slicedToArray(_step8.value, 2),
                e = _step8$value[0],
                t = _step8$value[1];

            this.delete(t._id);
          }
        } catch (err) {
          _iterator8.e(err);
        } finally {
          _iterator8.f();
        }
      }
    }, {
      key: "_getMainPlayerPosition",
      value: function _getMainPlayerPosition() {
        var r;

        var e = this._sceneManager.cameraComponent.MainCamera.position,
            t = this._sceneManager.avatarComponent.getMainAvatar();

        if (t != null && t != null) {
          var n = (r = t == null ? void 0 : t.rootNode) == null ? void 0 : r.position;
          if (n != null) return n;
        }

        return e;
      }
    }, {
      key: "changeBreathPointPose",
      value: function changeBreathPointPose(e, t, r) {
        var n = new BABYLON.Vector3(e.position.x, e.position.y, e.position.z);

        if (this.breathPoints.get(r) != null) {
          logger$1.info("[Engine] changeBreathPointPose, id:".concat(r));
          var o = this.breathPoints.get(r),
              a = o.mesh.position;
          var s = a.subtract(n);
          s = BABYLON.Vector3.Normalize(s);

          var l = BABYLON.Vector3.Distance(a, n),
              u = new Ray(n, s, l),
              c = this._scene.multiPickWithRay(u);

          if (c) {
            for (var h = 0; h < c.length; h++) {
              if (c[h].pickedMesh != null && t.mesh.name.indexOf(c[h].pickedMesh.name) >= 0) {
                var f = c[h].pickedPoint;
                o.mesh.position = n.add(f.subtract(n).scale(.99)), this.breathPoints.set(r, o);
              }
            }
          }
        } else logger$1.warn("[Engine] changeBreathPointPose, id:".concat(r, " is not existing!"));
      }
    }]);

    return XBreathPointManager;
  }();

  function _createForOfIteratorHelper$3(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$3(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

  function _unsupportedIterableToArray$3(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$3(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$3(o, minLen); }

  function _arrayLikeToArray$3(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

  var XDecalManager = /*#__PURE__*/function () {
    function XDecalManager(e) {
      _classCallCheck(this, XDecalManager);

      E(this, "scene");
      E(this, "_decal");
      E(this, "_mat");
      E(this, "_sharedMat");
      E(this, "_scenemanager");
      this._decal = new Map(), this._mat = new Map(), this._sharedMat = new Map(), this._scenemanager = e, this.scene = e.Scene;
    }

    _createClass(XDecalManager, [{
      key: "decals",
      get: function get() {
        return Array.from(this._decal.values());
      }
    }, {
      key: "getMesh",
      value: function getMesh() {
        return this._decal;
      }
    }, {
      key: "addDecal",
      value: function () {
        var _addDecal = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var _this = this;

          var t, r, _e$skinInfo, n;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  t = e.id, r = e.meshPath, _e$skinInfo = e.skinInfo, n = _e$skinInfo === void 0 ? "default" : _e$skinInfo;
                  return _context.abrupt("return", this._decal.get(t) ? (logger.warn("[Engine] Cannot add decal with an existing id: [".concat(t, "], meshPath: ").concat(r, ", skinInfo:").concat(n)), Promise.resolve(!0)) : (logger.info("[Engine] addDecal wiht id:[".concat(t, "], meshPath: ").concat(r, ", skinInfo:").concat(n)), new Promise(function (o, a) {
                    return _this._scenemanager.urlTransformer(r).then(function (s) {
                      return new Promise(function (l, u) {
                        if (_this._decal.get(t)) l(!0);else {
                          var c = new XDecal({
                            id: t,
                            scene: _this.scene,
                            meshPath: s,
                            skinInfo: n
                          });
                          _this._decal.set(t, c), c.loadModel().then(function () {
                            l(!0);
                          }).catch(function (h) {
                            logger.error("[Engine] addDecal Error! id: [".concat(t, "], meshpath:").concat(r, ", skin: ").concat(n, ". ").concat(h)), u(new XDecalError("[Engine] addDecal Error! id: [".concat(t, "], meshpath:").concat(r, ", skin: ").concat(n, ". ").concat(h)));
                          });
                        }
                      });
                    }).then(function (s) {
                      s == !0 ? o(!0) : a(!1);
                    }).catch(function (s) {
                      logger.error("[Engine] Add Decal error! id: [".concat(t, "], meshpath:").concat(r, ", skin:").concat(n, ". ").concat(s)), a(new XDecalError("[Engine] addDecal  error! id: [".concat(t, "], meshpath:").concat(r, ", skin:").concat(n, ". ").concat(s)));
                    });
                  })));

                case 2:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function addDecal(_x) {
          return _addDecal.apply(this, arguments);
        }

        return addDecal;
      }()
    }, {
      key: "setDecalTexture",
      value: function setDecalTexture(e) {
        var _this2 = this;

        var t = e.id,
            r = e.buffer,
            _e$isDynamic = e.isDynamic,
            n = _e$isDynamic === void 0 ? !1 : _e$isDynamic,
            _e$width = e.width,
            o = _e$width === void 0 ? 1100 : _e$width,
            _e$height = e.height,
            a = _e$height === void 0 ? 25 : _e$height,
            _e$slots = e.slots,
            s = _e$slots === void 0 ? 1 : _e$slots,
            _e$visibleSlots = e.visibleSlots,
            l = _e$visibleSlots === void 0 ? 1 : _e$visibleSlots,
            u = !0;
        return logger.info("[Engine] setDecalTexture wiht id:[".concat(t, "]")), new Promise(function (c, h) {
          var f = _this2._decal.get(t);

          if (f != null) {
            if (_this2._mat.get(t) != null) _this2.changeDecalTexture({
              id: t,
              buffer: r,
              isUrl: u,
              isDynamic: n,
              width: o,
              height: a,
              slots: s,
              visibleSlots: l
            }), c(!0);else {
              var d = new XDecalMaterial(t, _this2.scene);
              d.setTexture(r, u, n, o, a, s, l).then(function () {
                f.setMat(d.getMat()), _this2._decal.set(t, f), _this2._mat.set(t, d), c(!0);
              }).catch(function (_) {
                logger.error("[Engine] setDecalTexture Error! " + _), h(new XDecalTextureError("[Engine] decal set texture error! ".concat(_)));
              });
            }
          } else logger.error("[Engine] Error! decal id: [" + t + "] is not find!"), h(new XDecalTextureError("[Engine] decal id: [".concat(t, "] is not find!")));
        });
      }
    }, {
      key: "shareDecal",
      value: function () {
        var _shareDecal = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(e) {
          var _this3 = this;

          var t, r, n, _e$skinInfo2, o;

          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  t = e.idTar, r = e.meshPath, n = e.idSrc, _e$skinInfo2 = e.skinInfo, o = _e$skinInfo2 === void 0 ? "default" : _e$skinInfo2;
                  return _context2.abrupt("return", this._decal.has(n) && !this._decal.has(t) && this._mat.has(n) && !this._mat.has(t) ? (logger.info("[Engine] shareDecal wiht idTar:[".concat(t, "], idSrc:[").concat(n, "], skinInfo: ").concat(o, ", meshPath: ").concat(r)), new Promise(function (a, s) {
                    return _this3._scenemanager.urlTransformer(r).then(function (l) {
                      var u = new XDecal({
                        id: t,
                        scene: _this3.scene,
                        meshPath: l,
                        skinInfo: o
                      }),
                          c = _this3._mat.get(n);

                      c != null && (u.setMat(c.getMat()), u.sourceMatId = n, _this3._decal.set(t, u), _this3.addSharedMatCount(n)), a(!0);
                    }).catch(function (l) {
                      s(new XDecalError("[Engine] decal shareDecal error! ".concat(l)));
                    });
                  })) : (logger.error("[Engine] shareDecal Error. idSrc: [".concat(n, "] not exist! or idTar: [").concat(t, "] exists!")), Promise.reject("[Engine] shareDecal Error. idSrc: [".concat(n, "] not exist! or idTar: [").concat(t, "] exists!"))));

                case 2:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this);
        }));

        function shareDecal(_x2) {
          return _shareDecal.apply(this, arguments);
        }

        return shareDecal;
      }()
    }, {
      key: "changeDecalModel",
      value: function () {
        var _changeDecalModel = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(e) {
          var _this4 = this;

          var t, r, n;
          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  t = e.id, r = e.meshPath, n = this._decal.get(t);
                  return _context3.abrupt("return", new Promise(function (o, a) {
                    return n != null ? (logger.info("[Engine] changeDecalModel id:".concat(t)), n.changeModel(r).then(function () {
                      _this4._decal.set(t, n), o(!0);
                    })) : (logger.warn("[Engine] changeDecalModel id:".concat(t, " is not exist")), a("[Engine] changeDecalModel id:".concat(t, " is not exist")));
                  }));

                case 2:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, this);
        }));

        function changeDecalModel(_x3) {
          return _changeDecalModel.apply(this, arguments);
        }

        return changeDecalModel;
      }()
    }, {
      key: "changeDecalTexture",
      value: function changeDecalTexture(e) {
        var t = e.id,
            r = e.buffer,
            _e$isUrl = e.isUrl,
            n = _e$isUrl === void 0 ? !1 : _e$isUrl,
            _e$isDynamic2 = e.isDynamic,
            o = _e$isDynamic2 === void 0 ? !1 : _e$isDynamic2,
            _e$width2 = e.width,
            a = _e$width2 === void 0 ? 1110 : _e$width2,
            _e$height2 = e.height,
            s = _e$height2 === void 0 ? 25 : _e$height2,
            _e$slots2 = e.slots,
            l = _e$slots2 === void 0 ? 1 : _e$slots2,
            _e$visibleSlots2 = e.visibleSlots,
            u = _e$visibleSlots2 === void 0 ? 1 : _e$visibleSlots2,
            c = this._mat.get(t);

        c != null && this._decal.has(t) ? (c.changeTexture(r, n, o, a, s, l, u), this._mat.set(t, c)) : logger.error("[Engine] changeDecalTexture Error. id:".concat(t, " is not exist"));
      }
    }, {
      key: "deleteDecal",
      value: function deleteDecal(e) {
        var t, r;

        if (this._decal.has(e)) {
          var n = this._decal.get(e);

          n != null && n.cleanMesh(), this._sharedMat.get(e) != null ? this.minusSharedMatCount(e) : this._mat.get(e) != null ? ((t = this._mat.get(e)) == null || t.cleanTexture(), this._mat.delete(e)) : ((r = n.sourceMatId) == null ? void 0 : r.length) > 0 && this.minusSharedMatCount(n.sourceMatId), this._decal.delete(e);
        }
      }
    }, {
      key: "deleteDecalBySkinInfo",
      value: function deleteDecalBySkinInfo(e) {
        var _iterator = _createForOfIteratorHelper$3(this._decal.entries()),
            _step;

        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var _step$value = _slicedToArray(_step.value, 2),
                t = _step$value[0],
                r = _step$value[1];

            r.skinInfo == e && this.deleteDecal(t);
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }
      }
    }, {
      key: "addSharedMatCount",
      value: function addSharedMatCount(e) {
        var t = this._sharedMat.get(e);

        t != null ? this._sharedMat.set(e, t + 1) : this._sharedMat.set(e, 1);
      }
    }, {
      key: "minusSharedMatCount",
      value: function minusSharedMatCount(e) {
        var r;

        var t = this._sharedMat.get(e);

        t != null && (this._sharedMat.set(e, t - 1), t == 0 && (this._sharedMat.delete(e), (r = this._mat.get(e)) == null || r.cleanTexture(), this._mat.delete(e)));
      }
    }, {
      key: "toggle",
      value: function toggle(e, t) {
        var r = this._decal.get(e);

        r == null || r.toggle(t);
      }
    }, {
      key: "toggleDecalBySkinInfo",
      value: function toggleDecalBySkinInfo(e, t) {
        var _iterator2 = _createForOfIteratorHelper$3(this._decal.entries()),
            _step2;

        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
            var _step2$value = _slicedToArray(_step2.value, 2),
                r = _step2$value[0],
                n = _step2$value[1];

            n.skinInfo == e && n.toggle(t);
          }
        } catch (err) {
          _iterator2.e(err);
        } finally {
          _iterator2.f();
        }
      }
    }, {
      key: "updateTexAsWords",
      value: function updateTexAsWords(e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
        var _r$clearArea = r.clearArea,
            n = _r$clearArea === void 0 ? !0 : _r$clearArea,
            _r$w = r.w,
            o = _r$w === void 0 ? 480 : _r$w,
            _r$h = r.h,
            a = _r$h === void 0 ? 480 : _r$h,
            _r$y = r.y,
            s = _r$y === void 0 ? a / 2 : _r$y,
            _r$fontsize = r.fontsize,
            l = _r$fontsize === void 0 ? 70 : _r$fontsize,
            _r$slots = r.slots,
            u = _r$slots === void 0 ? 1 : _r$slots,
            _r$visibleSlots = r.visibleSlots,
            c = _r$visibleSlots === void 0 ? 1 : _r$visibleSlots,
            _r$font = r.font,
            h = _r$font === void 0 ? "black-body" : _r$font,
            _r$color = r.color,
            f = _r$color === void 0 ? "white" : _r$color,
            _r$fontweight = r.fontweight,
            d = _r$fontweight === void 0 ? 100 : _r$fontweight;

        var _r$x = r.x,
            _ = _r$x === void 0 ? o / 2 : _r$x;

        var g = this._mat.get(e);

        if (g) {
          _ == -1 && (_ = (g.getUOffset() + c / u) % 1 * o * u);
          var v = g.getMat().diffuseTexture,
              y = v.getContext();
          n && y.clearRect(_ - o / 2, s - a / 2, o, a), y.textAlign = "center", y.textBaseline = "middle", v.drawText(t, _, s, d + " " + l + "px " + h, f, "transparent", !0), v.hasAlpha = !0, v.update();
        }
      }
    }, {
      key: "updateTexAsImg",
      value: function () {
        var _updateTexAsImg = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(e, t) {
          var _this5 = this;

          var r,
              _r$clearArea2,
              n,
              _r$w2,
              o,
              _r$h2,
              a,
              _r$x2,
              s,
              _r$y2,
              l,
              _r$clearW,
              u,
              _r$clearH,
              c,
              _args4 = arguments;

          return regenerator.wrap(function _callee4$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  r = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : {};
                  _r$clearArea2 = r.clearArea, n = _r$clearArea2 === void 0 ? !0 : _r$clearArea2, _r$w2 = r.w, o = _r$w2 === void 0 ? 480 : _r$w2, _r$h2 = r.h, a = _r$h2 === void 0 ? 480 : _r$h2, _r$x2 = r.x, s = _r$x2 === void 0 ? o / 2 : _r$x2, _r$y2 = r.y, l = _r$y2 === void 0 ? a / 2 : _r$y2, _r$clearW = r.clearW, u = _r$clearW === void 0 ? o : _r$clearW, _r$clearH = r.clearH, c = _r$clearH === void 0 ? a : _r$clearH;
                  return _context4.abrupt("return", t == null || t == null || t == "" ? (logger.error("[Engine] updateTexAsImg Error. id: [".concat(e, "], newBuffer is Null or \"\"!")), Promise.reject(new XDecalError("[Engine] updateTexAsImg Error. id: [".concat(e, "], newBuffer is Null or \"\"!")))) : new Promise(function (h, f) {
                    return _this5._scenemanager.urlTransformer(t).then(function (d) {
                      return new Promise(function (_, g) {
                        var m = _this5._mat.get(e);

                        if (m) {
                          var y = m.getMat().diffuseTexture;

                          if (typeof t == "string") {
                            var b = new Image();
                            b.crossOrigin = "anonymous", b.src = d, b.onload = function () {
                              var T = y.getContext();
                              n && T.clearRect(s - u / 2, l - c / 2, u, c), T.drawImage(b, s - o / 2, l - a / 2, o, a), y.update(), _(!0);
                            }, b.onerror = function () {
                              logger.error("[Engine] updateTexAsImg Error.newImg load error. id: [".concat(e, "], decalMat is Null or undefined!")), g(new XDecalError("[Engine] updateTexAsImg Error. id: [".concat(e, "], decalMat is Null or undefined!")));
                            };
                          } else logger.error("[Engine] updateTexAsImg Error. id: [".concat(e, "], Buffer is not string!")), g(new XDecalError("[Engine] updateTexAsImg Error. id: [".concat(e, "], Buffer is not string!")));
                        } else logger.error("[Engine] updateTexAsImg Error. id: [".concat(e, "], decalMat is Null or undefined!")), g(new XDecalError("[Engine] updateTexAsImg Error. id: [".concat(e, "], decalMat is Null or undefined!")));
                      }).then(function (_) {
                        _ == !0 ? h(!0) : (logger.error("[Engine] updateTexAsImg Error. id: [".concat(e, "] !")), f(new XDecalError("[Engine] updateTexAsImg error! id: [".concat(e, "]"))));
                      }).catch(function (_) {
                        logger.error("[Engine] updateTexAsImg Error. id: [".concat(e, "]. ").concat(_));
                      });
                    });
                  }));

                case 3:
                case "end":
                  return _context4.stop();
              }
            }
          }, _callee4);
        }));

        function updateTexAsImg(_x4, _x5) {
          return _updateTexAsImg.apply(this, arguments);
        }

        return updateTexAsImg;
      }()
    }, {
      key: "startAnime",
      value: function startAnime(e, t) {
        logger.info("[Engine] Decal Start Anime. [".concat(e, "]"));

        var _t$speed = t.speed,
            r = _t$speed === void 0 ? .001 : _t$speed,
            n = t.callback,
            o = this._mat.get(e);

        o ? (o.do_animation(r), n && o.uOffsetObserverable.add(n)) : (logger.error("[Engine] startAnime Error. id: [".concat(e, "] is not exist!")), new XDecalError("[Engine] startAnime Error. id: [".concat(e, "] is not exist!")));
      }
    }]);

    return XDecalManager;
  }();

  var PoolObject = /*#__PURE__*/function () {
    function PoolObject(e, t, r) {
      var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : !0;

      _classCallCheck(this, PoolObject);

      E(this, "data");
      E(this, "nextFree");
      E(this, "previousFree");
      E(this, "free");
      this.data = e, this.nextFree = t, this.previousFree = r, this.free = n;
    }

    _createClass(PoolObject, [{
      key: "dispose",
      value: function dispose() {
        this.data && this.data instanceof BABYLON.Mesh && this.data.dispose(!0, !0), this.previousFree = null, this.nextFree = null, this.data = null;
      }
    }]);

    return PoolObject;
  }();

  var Pool = /*#__PURE__*/function () {
    function Pool(e, t, r, n) {
      _classCallCheck(this, Pool);

      this.lastFree = null;
      this.nextFree = null;
      this._pool = [], this.objCreator = e, this.objReseter = t;

      for (var _len = arguments.length, o = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
        o[_key - 4] = arguments[_key];
      }

      for (var a = 0; a < n; a++) {
        this.addNewObject(this.newPoolObject.apply(this, o));
      }

      this.capacity = r;
    }

    _createClass(Pool, [{
      key: "addNewObject",
      value: function addNewObject(e) {
        return this._pool.push(e), this.release(e), e;
      }
    }, {
      key: "release",
      value: function release(e) {
        e.free = !0, e.nextFree = null, e.previousFree = this.lastFree, this.lastFree ? this.lastFree.nextFree = e : this.nextFree = e, this.lastFree = e, this.objReseter(e);
      }
    }, {
      key: "getFree",
      value: function getFree() {
        var t = this.nextFree ? this.nextFree : this.addNewObject(this.newPoolObject.apply(this, arguments));
        return t.free = !1, this.nextFree = t.nextFree, this.nextFree || (this.lastFree = null), t;
      }
    }, {
      key: "newPoolObject",
      value: function newPoolObject() {
        var t = this.objCreator.apply(this, arguments);
        return new PoolObject(t, this.nextFree, this.lastFree);
      }
    }, {
      key: "releaseAll",
      value: function releaseAll() {
        var _this = this;

        this._pool.forEach(function (e) {
          return _this.release(e);
        });
      }
    }, {
      key: "clean",
      value: function clean() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var r = this.nextFree;
        if (!r) return;
        var n = 0;

        for (; r;) {
          n += 1, r = r.nextFree;
        }

        var o = !1;
        if (n > e && this._pool.length > this.capacity && (o = !0), o) for (r = this.nextFree; r;) {
          r.free = !1, this.nextFree = r.nextFree;

          var a = this._pool.indexOf(r);

          this._pool.splice(a, 1), this.nextFree || (this.lastFree = null), r == null || r.dispose(), r = this.nextFree;
        }
      }
    }]);

    return Pool;
  }();

  var BillboardStatus = {
    SHOW: 1,
    HIDE: 0,
    DISPOSE: -1
  };

  function _createSuper$3(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$3(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$3() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var AvatarAnimationError$1 = /*#__PURE__*/function (_XverseError) {
    _inherits(AvatarAnimationError, _XverseError);

    var _super = _createSuper$3(AvatarAnimationError);

    function AvatarAnimationError(e) {
      _classCallCheck(this, AvatarAnimationError);

      return _super.call(this, 5101, e || "[Engine] \u89D2\u8272\u52A8\u753B\u64AD\u653E\u5931\u8D25");
    }

    return _createClass(AvatarAnimationError);
  }(XverseError);

  function _createForOfIteratorHelper$2(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$2(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

  function _unsupportedIterableToArray$2(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$2(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$2(o, minLen); }

  function _arrayLikeToArray$2(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

  var XAnimationController = /*#__PURE__*/function () {
    function XAnimationController(e) {
      var _this = this;

      _classCallCheck(this, XAnimationController);

      E(this, "iBodyAnim");
      E(this, "animations", []);
      E(this, "defaultAnimation", "Idle");
      E(this, "onPlay", "Idle");
      E(this, "loop", !0);
      E(this, "animationExtras", []);
      E(this, "enableBlend", !1);
      E(this, "enableSkLod", !1);
      E(this, "_boneMap", new Map());
      E(this, "_lodMask", new Map());
      E(this, "activeFaceAnimation");
      E(this, "iFaceAnim");
      E(this, "_scene");
      E(this, "_avatar");
      E(this, "onPlayObservable", new Observable());
      E(this, "postObserver");
      E(this, "playAnimation", function (e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
        var n = arguments.length > 3 ? arguments[3] : undefined;
        var o = arguments.length > 4 ? arguments[4] : undefined;
        var a = arguments.length > 5 ? arguments[5] : undefined;
        return new Promise(function (s, l) {
          if (_this._isPlaying(e, r) || (_this._registerAnimInfo(e, t, r, n, o, a), !_this._isAnimate())) return s(null);
          _this._prerocess(e, t), _this._avatar.avatarManager.loadAnimation(_this._avatar.avatarType, e).then(function (u) {
            if (!u) return l(new AvatarAnimationError$1("animation group does not exist"));

            var c = _this._mappingSkeleton(u);

            if (!c) return l(new AvatarAnimationError$1("mapping animation failed"));
            if (c && _this._isAnimationValid(c)) return c.dispose(), l(new AvatarAnimationError$1("mapping animation failed"));
            if (_this.enableSkLod && _this.skeletonMask(c, r), _this.detachAnimation(r), r == 0 ? _this.iBodyAnim.animGroup = c : r == 1 && (_this.iFaceAnim.animGroup = c), !_this._playAnimation(r)) return l(new AvatarAnimationError$1("[Engine] play animation failed, animtion resource does not match current character"));
            _this._playEffect(), _this.postObserver = c.onAnimationEndObservable.addOnce(function () {
              return _this._postprocess(r), s(null);
            });
          });
        });
      });
      E(this, "stopAnimation", function () {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var t, r, n, o;

        switch (e) {
          case 0:
            _this.iBodyAnim && _this.iBodyAnim.animGroup && ((t = _this.iBodyAnim) == null || t.animGroup.stop());
            break;

          case 1:
            _this.iFaceAnim && _this.iFaceAnim.animGroup && ((r = _this.iFaceAnim) == null || r.animGroup.stop());
            break;

          case 2:
            _this.iBodyAnim && _this.iBodyAnim.animGroup && ((n = _this.iBodyAnim) == null || n.animGroup.stop()), _this.iFaceAnim && _this.iFaceAnim.animGroup && ((o = _this.iFaceAnim) == null || o.animGroup.stop());
            break;
        }
      });
      E(this, "pauseAnimation", function () {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var t, r, n, o;

        switch (e) {
          case 0:
            _this.iBodyAnim && _this.iBodyAnim.animGroup && ((t = _this.iBodyAnim) == null || t.animGroup.pause());
            break;

          case 1:
            _this.iFaceAnim && _this.iFaceAnim.animGroup && ((r = _this.iFaceAnim) == null || r.animGroup.pause());
            break;

          case 2:
            _this.iBodyAnim && _this.iBodyAnim.animGroup && ((n = _this.iBodyAnim) == null || n.animGroup.pause()), _this.iFaceAnim && _this.iFaceAnim.animGroup && ((o = _this.iFaceAnim) == null || o.animGroup.pause());
            break;
        }
      });
      E(this, "resetAnimation", function () {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var t, r, n, o;

        switch (e) {
          case 0:
            _this.iBodyAnim && _this.iBodyAnim.animGroup && ((t = _this.iBodyAnim) == null || t.animGroup.reset());
            break;

          case 1:
            _this.iFaceAnim && _this.iFaceAnim.animGroup && ((r = _this.iFaceAnim) == null || r.animGroup.reset());
            break;

          case 2:
            _this.iBodyAnim && _this.iBodyAnim.animGroup && ((n = _this.iBodyAnim) == null || n.animGroup.reset()), _this.iFaceAnim && _this.iFaceAnim.animGroup && ((o = _this.iFaceAnim) == null || o.animGroup.reset());
            break;
        }
      });
      this._avatar = e, this._scene = e.avatarManager.scene, this.animationExtras.push(action.Cheering.animName), this._boneMap = new Map();
    }

    _createClass(XAnimationController, [{
      key: "_isPlaying",
      value: function _isPlaying(e, t) {
        return t == 0 && this.iBodyAnim != null && this.iBodyAnim.animGroup && e == this.iBodyAnim.name ? !0 : !!(t == 1 && this.iFaceAnim != null && this.iFaceAnim.animGroup && e == this.iFaceAnim.name);
      }
    }, {
      key: "activeAnimation",
      value: function activeAnimation() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var t, r;

        switch (e) {
          case 0:
            return (t = this.iBodyAnim) == null ? void 0 : t.animGroup;

          case 1:
            return (r = this.iFaceAnim) == null ? void 0 : r.animGroup;

          default:
            return;
        }
      }
    }, {
      key: "enableAnimationBlend",
      value: function enableAnimationBlend() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : .1;
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        var r, n, o, a;

        if (t == 0 && ((r = this.iBodyAnim) == null ? void 0 : r.animGroup)) {
          var _iterator = _createForOfIteratorHelper$2((n = this.iBodyAnim) == null ? void 0 : n.animGroup.targetedAnimations),
              _step;

          try {
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
              var s = _step.value;
              s.animation.enableBlending = !0, s.animation.blendingSpeed = e;
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }
        } else if (t == 0 && ((o = this.iFaceAnim) == null ? void 0 : o.animGroup)) {
          var _iterator2 = _createForOfIteratorHelper$2((a = this.iFaceAnim) == null ? void 0 : a.animGroup.targetedAnimations),
              _step2;

          try {
            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
              var _s = _step2.value;
              _s.animation.enableBlending = !0, _s.animation.blendingSpeed = e;
            }
          } catch (err) {
            _iterator2.e(err);
          } finally {
            _iterator2.f();
          }
        }
      }
    }, {
      key: "disableAnimationBlend",
      value: function disableAnimationBlend() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var t, r, n, o;

        if (e == 0 && ((t = this.iBodyAnim) == null ? void 0 : t.animGroup)) {
          var _iterator3 = _createForOfIteratorHelper$2((r = this.iBodyAnim) == null ? void 0 : r.animGroup.targetedAnimations),
              _step3;

          try {
            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
              var a = _step3.value;
              a.animation.enableBlending = !1;
            }
          } catch (err) {
            _iterator3.e(err);
          } finally {
            _iterator3.f();
          }
        } else if (e == 0 && ((n = this.iFaceAnim) == null ? void 0 : n.animGroup)) {
          var _iterator4 = _createForOfIteratorHelper$2((o = this.iFaceAnim) == null ? void 0 : o.animGroup.targetedAnimations),
              _step4;

          try {
            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
              var _a = _step4.value;
              _a.animation.enableBlending = !1;
            }
          } catch (err) {
            _iterator4.e(err);
          } finally {
            _iterator4.f();
          }
        }
      }
    }, {
      key: "skeletonMask",
      value: function skeletonMask(e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

        if (t == 0) {
          var r = this._lodMask.get(this._avatar.distLevel);

          if (r) for (var n = 0; n < e.targetedAnimations.length; ++n) {
            r.includes(e.targetedAnimations[n].target.name) || (e.targetedAnimations.splice(n, 1), n--);
          }
          return !0;
        }

        return !1;
      }
    }, {
      key: "detachAnimation",
      value: function detachAnimation() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 2;
        var t, r;

        switch (e) {
          case 0:
            this.iBodyAnim && this.iBodyAnim.animGroup && (this.iBodyAnim.animGroup._parentContainer.xReferenceCount && this.iBodyAnim.animGroup._parentContainer.xReferenceCount--, this.iBodyAnim.animGroup.stop(), this.iBodyAnim.animGroup.dispose(), this.iBodyAnim.animGroup = void 0);
            break;

          case 1:
            this.iFaceAnim && this.iFaceAnim.animGroup && (this.iFaceAnim.animGroup._parentContainer.xReferenceCount && this.iFaceAnim.animGroup._parentContainer.xReferenceCount--, this.iFaceAnim.animGroup.stop(), this.iFaceAnim.animGroup.dispose(), this.iFaceAnim.animGroup = void 0);
            break;

          case 2:
            this.iBodyAnim && this.iBodyAnim.animGroup && (this.iBodyAnim.animGroup._parentContainer.xReferenceCount && this.iBodyAnim.animGroup._parentContainer.xReferenceCount--, (t = this.iBodyAnim) == null || t.animGroup.stop(), (r = this.iBodyAnim) == null || r.animGroup.dispose(), this.iBodyAnim.animGroup = void 0), this.iFaceAnim && this.iFaceAnim.animGroup && (this.iFaceAnim.animGroup._parentContainer.xReferenceCount && this.iFaceAnim.animGroup._parentContainer.xReferenceCount--, this.iFaceAnim.animGroup.stop(), this.iFaceAnim.animGroup.dispose(), this.iFaceAnim.animGroup = void 0);
            break;
        }
      }
    }, {
      key: "blendAnimation",
      value: function blendAnimation() {}
    }, {
      key: "getAnimation",
      value: function getAnimation(e, t) {
        return avatarLoader.animations.get(getAnimationKey(t, e));
      }
    }, {
      key: "_mappingSkeleton",
      value: function _mappingSkeleton(e) {
        var _this2 = this;

        if (e) {
          var t = e.clone(e.name, function (r) {
            var o, a, s;
            var n = r.name.split(" ").length > 2 ? r.name.split(" ")[2] : r.name;
            if (_this2._boneMap.size === ((o = _this2._avatar.skeleton) == null ? void 0 : o.bones.length)) return _this2._boneMap.get(n);
            {
              var l = (s = (a = _this2._avatar.skeleton) == null ? void 0 : a.bones.find(function (u) {
                return u.name === r.name || u.name === r.name.split(" ")[2];
              })) == null ? void 0 : s.getTransformNode();
              return l && (l.name = n, _this2._boneMap.set(n, l)), l;
            }
          });
          return t._parentContainer = e._parentContainer, t;
        } else return;
      }
    }, {
      key: "removeAnimation",
      value: function removeAnimation(e) {
        var t = avatarLoader.containers.get(e.name);
        t && (t.dispose(), avatarLoader.containers.delete(e.name), avatarLoader.animations.delete(getAnimationKey(e.name, e.skType)));
      }
    }, {
      key: "_setPosition",
      value: function _setPosition(e, t) {
        this._avatar.priority === 0 && this._avatar.isRender && e === this.defaultAnimation && e != this.onPlay && !this._avatar.isSelected && this._avatar.setPosition(this._avatar.position, !0);
      }
    }, {
      key: "_registerAnimInfo",
      value: function _registerAnimInfo(e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
        var n = arguments.length > 3 ? arguments[3] : undefined;
        var o = arguments.length > 4 ? arguments[4] : undefined;
        var a = arguments.length > 5 ? arguments[5] : undefined;
        var s = {
          name: e,
          skType: this._avatar.avatarType,
          loop: t,
          playSpeed: n,
          currentFrame: 0,
          startFrame: o,
          endFrame: a
        };
        r == 0 ? this.iBodyAnim == null ? this.iBodyAnim = s : (this.iBodyAnim.name = e, this.iBodyAnim.skType = this._avatar.avatarType, this.iBodyAnim.loop = t, this.iBodyAnim.playSpeed = n, this.iBodyAnim.currentFrame = 0, this.iBodyAnim.startFrame = o, this.iBodyAnim.endFrame = a) : r == 1 && (this.iFaceAnim == null ? this.iFaceAnim = s : (this.iFaceAnim.name = e, this.iFaceAnim.skType = this._avatar.avatarType, this.iFaceAnim.loop = t, this.iFaceAnim.playSpeed = n, this.iFaceAnim.currentFrame = 0, this.iFaceAnim.startFrame = o, this.iFaceAnim.endFrame = a)), this.onPlay = e, this.loop = t;
      }
    }, {
      key: "_isAnimate",
      value: function _isAnimate() {
        var e;
        return !(!this._avatar.isRender || !this._avatar.skeleton || ((e = this._avatar.rootNode) == null ? void 0 : e.getChildMeshes().length) == 0);
      }
    }, {
      key: "_prerocess",
      value: function _prerocess(e, t) {
        this._avatar.isRayCastEnable && this._setPosition(e, t), this._avatar.priority === 0 && logger$1.info("start play animation: ".concat(e, " on avatar ").concat(this._avatar.id));
      }
    }, {
      key: "_playEffect",
      value: function _playEffect() {
        var _this3 = this;

        this.animationExtras.indexOf(this.iBodyAnim.name) != -1 && action.Cheering.attachPair.forEach(function (t) {
          _this3._avatar.attachExtraProp(t.obj, t.bone, new BABYLON.Vector3(t.offset.x, t.offset.y, t.offset.z), new BABYLON.Vector3(t.rotate.x, t.rotate.y, t.rotate.z)), _this3._avatar.showExtra(t.obj);
        });
      }
    }, {
      key: "_playAnimation",
      value: function _playAnimation() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var t, r;
        return e == 0 && this.iBodyAnim && ((t = this.iBodyAnim) == null ? void 0 : t.animGroup) ? (this.onPlayObservable.notifyObservers(this._scene), this.iBodyAnim.animGroup.start(this.loop, this.iBodyAnim.playSpeed, this.iBodyAnim.startFrame, this.iBodyAnim.endFrame, !1), !0) : e == 1 && this.iFaceAnim && ((r = this.iFaceAnim) == null ? void 0 : r.animGroup) ? (this.iFaceAnim.animGroup.start(this.loop, this.iFaceAnim.playSpeed, this.iFaceAnim.startFrame, this.iFaceAnim.endFrame, !1), !0) : !1;
      }
    }, {
      key: "_postprocess",
      value: function _postprocess(e) {
        var r, n;
        var t;
        e == 0 ? t = (r = this.iBodyAnim) == null ? void 0 : r.name : e == 1 && (t = (n = this.iFaceAnim) == null ? void 0 : n.name), t === action.Cheering.animName && this._avatar.disposeExtra();
      }
    }, {
      key: "_isAnimationValid",
      value: function _isAnimationValid(e) {
        for (var t = 0; t < e.targetedAnimations.length; ++t) {
          if (e.targetedAnimations[t].target) return !1;
        }

        return !0;
      }
    }]);

    return XAnimationController;
  }();

  var XAvatarComopnent = /*#__PURE__*/function () {
    function XAvatarComopnent() {
      _classCallCheck(this, XAvatarComopnent);

      E(this, "resourceIdList", []);
      E(this, "skeleton");
      E(this, "extraProp");
      E(this, "extras", []);
      E(this, "body");
    }

    _createClass(XAvatarComopnent, [{
      key: "addBodyComp",
      value: function addBodyComp(e, t) {
        return !e.rootNode || t.root.getChildMeshes().length === 0 ? (t.isRender = !1, !1) : (this.body = t, this.body.root.parent = e.rootNode, t.isRender = !0, this.body.root.getChildMeshes()[0] && (this.body.root.getChildMeshes()[0].xtype = EMeshType.XAvatar, this.body.root.getChildMeshes()[0].xid = e.id), this.skeleton = t.skeleton, !0);
      }
    }, {
      key: "addClothesComp",
      value: function addClothesComp(e, t) {
        var _this = this;

        return !e.rootNode || !this.skeleton || !t.root ? (t.isRender = !1, !1) : (t.root.xtype = EMeshType.XAvatar, t.root.xid = e.id, t.isRender = !0, t.root.parent = e.rootNode.getChildMeshes()[0], this.resourceIdList.push(t), t.root.skeleton = this.skeleton, t.root.getChildMeshes().forEach(function (r) {
          r.skeleton = _this.skeleton;
        }), !0);
      }
    }, {
      key: "clearClothesComp",
      value: function clearClothesComp(e) {
        e.root.getChildMeshes().forEach(function (t) {
          t.skeleton = null, t.dispose(), t.xid = void 0;
        }), e.root.dispose(), this.resourceIdList = this.resourceIdList.filter(function (t) {
          return t.uId != e.uId;
        });
      }
    }, {
      key: "clearAllClothesComps",
      value: function clearAllClothesComps() {
        this.resourceIdList.forEach(function (e) {
          var t;
          e.root.parent = null, e.root._parentContainer.xReferenceCount && (e.root._parentContainer.xReferenceCount--, e.root._parentContainer = null), e.isRender = !1, e.isSelected = !1, e.root.getChildMeshes().forEach(function (r) {
            r.skeleton = null, r.dispose();
          }), (t = e.root.skeleton) == null || t.dispose(), e.root.dispose();
        }), this.resourceIdList = [];
      }
    }, {
      key: "dispose",
      value: function dispose(e) {
        this.body ? (this.body.root._parentContainer.xReferenceCount && (this.body.root._parentContainer.xReferenceCount--, this.body.root._parentContainer = null), this.clearAllClothesComps(), this.body.isRender = !1, this.body.skeleton.dispose(), this.body.skeleton = null, this.body.root.dispose(), this.body = void 0, this.skeleton && (this.skeleton.dispose(), this.skeleton = void 0)) : logger$1.warn("[Engine] no body to dispose");
      }
    }, {
      key: "changeClothesComp",
      value: function changeClothesComp(e, t, r, n, o) {
        var _this2 = this;

        return new Promise(function (a) {
          if (r === "pendant" || _this2.resourceIdList.some(function (s) {
            return s.name === t;
          })) return a();
          if (e.isHide || !e.isRender) o.concat(r).forEach(function (l) {
            e.clothesList = e.clothesList.filter(function (c) {
              return c.type != l;
            });
            var u = {
              type: r,
              id: t,
              url: n,
              lod: 0
            };
            e.clothesList.push(u);
          }), a();else {
            var s = o.concat(r);
            e.avatarManager.loadDecoration(r, t, 0).then(function (l) {
              if (l) {
                e.attachDecoration(l);
                var u = {
                  type: r,
                  id: t,
                  url: n
                };
                e.clothesList.push(u), l.root.setEnabled(!0), s.forEach(function (c) {
                  var h = _this2.resourceIdList.filter(function (f) {
                    return f.type === c;
                  });

                  if (h.length > 1) {
                    (function () {
                      var f = h.filter(function (d) {
                        return d.name === t;
                      });

                      if (f.length > 1) {
                        var _loop = function _loop(d) {
                          e.detachDecoration(f[d]), e.clothesList = e.clothesList.filter(function (g) {
                            return g.id != f[d].name;
                          });
                          var _ = {
                            type: r,
                            id: t,
                            url: n
                          };
                          e.clothesList.push(_);
                        };

                        for (var d = 1; d < f.length; ++d) {
                          _loop(d);
                        }
                      }
                    })();
                  }

                  h[0] && h[0].name != t && _this2._readyToDetach(e, r) && (e.detachDecoration(h[0]), e.clothesList = e.clothesList.filter(function (f) {
                    return f.id != h[0].name;
                  }));
                });
              }

              return a();
            });
          }
        });
      }
    }, {
      key: "_readyToDetach",
      value: function _readyToDetach(e, t) {
        return !((t == "clothes" || t == "pants") && e.clothesList.filter(function (n) {
          return n.type === "suit";
        }).length == 1 && (!e.clothesList.some(function (n) {
          return n.type === "pants";
        }) || !e.clothesList.some(function (n) {
          return n.type === "clothes";
        })));
      }
    }, {
      key: "addDecoComp",
      value: function addDecoComp(e, t, r, n, o) {
        if (e.isRender) {
          var a = e.avatarManager.extraComps.get(t),
              s = a == null ? void 0 : a.clone(t, void 0);

          if (!a) {
            logger$1.error("\u6CA1\u6709\u5BF9\u5E94\u7684\u7EC4\u4EF6");
            return;
          }

          this.extras.push(s);
          var l = this.skeleton.bones.find(function (u) {
            return u.name === r;
          });
          s.position = n, s.rotation = o, s.attachToBone(l, e.rootNode.getChildMeshes()[0]);
        }
      }
    }, {
      key: "showExtra",
      value: function showExtra(e) {
        this.extras.forEach(function (t) {
          t.name.indexOf(e) > 0 && t.setEnabled(!0);
        });
      }
    }, {
      key: "hideExtra",
      value: function hideExtra(e) {
        this.extras.forEach(function (t) {
          t.name.indexOf(e) > 0 && t.setEnabled(!1);
        });
      }
    }, {
      key: "disposeExtra",
      value: function disposeExtra() {
        this.extras.forEach(function (e) {
          e.dispose();
        }), this.extras = [];
      }
    }]);

    return XAvatarComopnent;
  }();

  var XStateMachine = /*#__PURE__*/function () {
    function XStateMachine(e) {
      _classCallCheck(this, XStateMachine);

      E(this, "state");
      E(this, "isMoving");
      E(this, "isRotating");
      E(this, "_observer");
      E(this, "_movingObserver");
      E(this, "_scene");
      this._scene = e;
    }

    _createClass(XStateMachine, [{
      key: "rotateTo",
      value: function rotateTo(e, t, r, n) {
        var _this = this;

        return new Promise(function (o, a) {
          var h;
          var s = e.avatarManager.scene;
          if (r && e.setRotation(r), t == r) return o();
          e.priority === 0 && logger$1.info("avatar ".concat(e.id, " starts to rotate from ").concat(r, " to ").concat(t));
          var l = 0;
          var u = 1e3 / 25,
              c = calcDistance3DAngle(t, e.rotation) / u;
          _this._movingObserver && s.onBeforeRenderObservable.remove(_this._movingObserver), (h = e.controller) == null || h.playAnimation(n || "Walking", !0), _this._movingObserver = s == null ? void 0 : s.onBeforeRenderObservable.add(function () {
            var f;

            if (l < 1) {
              if (!e.rootNode) return e.setRotation(t), o();
              var d = BABYLON.Vector3.Lerp(e.rootNode.rotation, ue4Rotation2Xverse(t), l);
              e.setRotation(xverseRotation2Ue4(d)), l += u / (c * 1e3);
            } else return s.onBeforeRenderObservable.remove(_this._movingObserver), (f = e.controller) == null || f.playAnimation("Idle", !0), o();
          });
        });
      }
    }, {
      key: "_filterPathPoint",
      value: function _filterPathPoint(e) {
        var t = 0;
        var r = 1e-4;
        if (e.length <= 1) return [];

        for (; t < e.length - 1;) {
          calcDistance3D(e[t], e[t + 1]) < r ? e.splice(t, 1) : t++;
        }

        return e;
      }
    }, {
      key: "moveTo",
      value: function moveTo(e, t, r, n, o, a) {
        var _this2 = this;

        return new Promise(function (s, l) {
          var m;
          var u = e.avatarManager.scene;
          e.priority === 0 && logger$1.info("avatar ".concat(e.id, " starts to move from ").concat(t, " to ").concat(r));
          var c = 0;
          a ? a = a.concat(r) : a = [r], a = _this2._filterPathPoint(a);
          var h = t,
              f = a.shift();
          if (!f) return l("[Engine input path error]");
          var d = calcDistance3D(h, f) / n;

          var _ = 1e3 / 25;

          e.rootNode.lookAt(ue4Position2Xverse(f));
          var g = xverseRotation2Ue4({
            x: e.rootNode.rotation.x,
            y: e.rootNode.rotation.y,
            z: e.rootNode.rotation.z
          });
          g && (g.roll = 0, g.pitch = 0, e.setRotation(g)), _this2._movingObserver && u.onBeforeRenderObservable.remove(_this2._movingObserver), (m = e.controller) == null || m.playAnimation(o, !0), _this2._movingObserver = u == null ? void 0 : u.onBeforeRenderObservable.add(function () {
            var v;

            if (c < 1) {
              var y = BABYLON.Vector3.Lerp(ue4Position2Xverse(h), ue4Position2Xverse(f), c);
              if (e.setPosition(xversePosition2Ue4(y)), !e.rootNode) return e.setPosition(r), s();
              c += _ / (d * 1e3);
            } else if (h = f, f = a.shift(), f) {
              d = calcDistance3D(h, f) / n, e.rootNode.lookAt(ue4Position2Xverse(f));

              var _y = xverseRotation2Ue4({
                x: e.rootNode.rotation.x,
                y: e.rootNode.rotation.y,
                z: e.rootNode.rotation.z
              });

              _y && (_y.roll = 0, _y.pitch = 0, e.setRotation(_y)), c = 0;
            } else return u.onBeforeRenderObservable.remove(_this2._movingObserver), (v = e.controller) == null || v.playAnimation("Idle", !0), s();
          });
        });
      }
    }, {
      key: "lookAt",
      value: function lookAt(e, t, r) {
        return new Promise(function (n) {
          var _, g;

          var o = ue4Position2Xverse(t),
              s = e.rootNode.position.subtract(o).length(),
              l = new BABYLON.Vector3(s * Math.sin(e.rootNode.rotation.y), 0, s * Math.cos(e.rootNode.rotation.y)),
              u = (_ = e.rootNode) == null ? void 0 : _.position.add(l);
          var c = 0;
          var h = r || 1 / 100,
              f = (g = e.rootNode) == null ? void 0 : g.getScene(),
              d = f == null ? void 0 : f.onBeforeRenderObservable.add(function () {
            var y, b;
            var m = (y = e.controller) == null ? void 0 : y.animations.find(function (T) {
              return T.name == "Idle";
            });
            (m == null ? void 0 : m.isPlaying) != !0 && (m == null || m.play());
            var v = BABYLON.Vector3.Lerp(u, o, c);
            c < 1 ? ((b = e.rootNode) == null || b.lookAt(v), c += h) : (d && f.onBeforeRenderObservable.remove(d), n());
          });
        });
      }
    }, {
      key: "sendObjectTo",
      value: function sendObjectTo(e, t, r) {
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 2;
        var o = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 10;
        var a = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {
          x: 0,
          y: 0,
          z: 150
        };
        return new Promise(function (s, l) {
          var u;
          if (!r.loaded) l("Gift has not inited!");else {
            var c = (u = e.rootNode) == null ? void 0 : u.getScene();
            var h = 0;

            var f = 1 / (n * 25),
                d = f,
                _ = o / 100,
                g = 8 * _ * f * f;

            var m = .5 * g / f,
                v = ue4Position2Xverse(e.position);
            var y = ue4Position2Xverse(a),
                b = ue4Position2Xverse(e.position),
                T = c == null ? void 0 : c.onBeforeRenderObservable.add(function () {
              (!t || !e.position || !t.position) && (T && c.onBeforeRenderObservable.remove(T), l("Invalid receiver when shoot gift!")), r.loaded || (T && c.onBeforeRenderObservable.remove(T), s());
              var C = ue4Position2Xverse(t.position),
                  A = new BABYLON.Vector3((C.x - b.x) * f, m, (C.z - b.z) * f);
              m = m - g, h < 1 ? (v = v.add(A), r.setPositionVector(v.add(y)), h += d) : (s(), T && c.onBeforeRenderObservable.remove(T));
            });
          }
        });
      }
    }, {
      key: "roll",
      value: function roll(e, t, r, n) {
        var o, a;
        this._observer && ((o = this._scene) == null || o.onBeforeRenderObservable.remove(this._observer)), t && (r = r != null ? r : 1, n = n != null ? n : 1, this._observer = (a = this._scene) == null ? void 0 : a.onBeforeRenderObservable.add(function () {
          e.rootNode.rotation.y += r * .1 * n, e.rootNode.rotation.y %= Math.PI * 2;
        }));
      }
    }, {
      key: "disposeObsever",
      value: function disposeObsever() {
        this._movingObserver && this._scene.onBeforeRenderObservable.remove(this._movingObserver);
      }
    }]);

    return XStateMachine;
  }();

  var XAvatarBillboardComponent = /*#__PURE__*/function () {
    function XAvatarBillboardComponent(e) {
      var _this = this;

      _classCallCheck(this, XAvatarBillboardComponent);

      E(this, "_nickName", "");
      E(this, "_words", "");
      E(this, "_isNameVisible", !0);
      E(this, "_isBubbleVisible", !0);
      E(this, "_isGiftButtonsVisible", !1);
      E(this, "withinVisualRange", !1);
      E(this, "_bubble");
      E(this, "_nameBoard");
      E(this, "_giftButtons", new Map());
      E(this, "_buttonTex", new Map());
      E(this, "_nameLinesLimit", 2);
      E(this, "_nameLengthPerLine", 16);
      E(this, "_scene");
      E(this, "_pickBbox", null);
      E(this, "bbox");
      E(this, "_height", .26);
      E(this, "_attachmentObservers", new Map());
      E(this, "attachToAvatar", function (e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !1;
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
          x: 0,
          y: 0,
          z: 0
        };
        var o = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : !1;
        var a = arguments.length > 5 ? arguments[5] : undefined;
        var s = arguments.length > 6 ? arguments[6] : undefined;
        var l = e.rootNode;

        if (_this.bbox || e.getBbox(), t && l) {
          var u = a || t.uniqueId;

          var c = _this._attachmentObservers.get(u);

          if (c) if (o) _this._scene.onBeforeRenderObservable.remove(c), _this._attachmentObservers.delete(u);else return;
          var h = ue4Position2Xverse(n);
          r ? (t.setParent(l), t.position = h) : (c = _this._scene.onBeforeRenderObservable.add(function () {
            var f = 0;
            s ? (f = e.rootNode.rotation.y / Math.PI * 180 + 90, e.rootNode.rotation.y && (t.rotation.y = e.rootNode.rotation.y)) : f = e.avatarManager.sceneManager.cameraComponent.getCameraPose().rotation.yaw, f || (f = 0);
            var d = new BABYLON.Vector3(0, _this._height, 0);
            e.controller && e.controller.activeAnimation() && e.controller.activeAnimation().animatables[0] && (_this._height = d.y = (e.controller.activeAnimation().animatables[0].target.position.y * .01 - .66) * e.scale), d.y < .07 * e.scale && (d.y = 0), t.position.x = l.position.x + h.x * Math.sin(f * Math.PI / 180) + h.z * Math.cos(f * Math.PI / 180), t.position.z = l.position.z + h.x * Math.cos(f * Math.PI / 180) - h.z * Math.sin(f * Math.PI / 180), t.position.y = l.position.y + _this.bbox.maximum.y + h.y + d.y;
          }), _this._attachmentObservers.set(u, c));
        } else logger$1.error("avatar or attachment not found!");
      });
      E(this, "detachFromAvatar", function (e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !1;

        var n = _this._attachmentObservers.get(t.uniqueId);

        n && _this._scene.onBeforeRenderObservable.remove(n), e.rootNode ? (t.setEnabled(!1), t.parent = null, r && t.dispose()) : logger$1.error("avatar not found!");
      });
      E(this, "getBbox", function (e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
        var _t$isConst = t.isConst,
            r = _t$isConst === void 0 ? !1 : _t$isConst,
            _t$changeWithAvatar = t.changeWithAvatar,
            n = _t$changeWithAvatar === void 0 ? !1 : _t$changeWithAvatar;
        var _t$localCenter = t.localCenter,
            o = _t$localCenter === void 0 ? {
          x: 0,
          y: 0,
          z: 75
        } : _t$localCenter,
            _t$width = t.width,
            a = _t$width === void 0 ? 1.32 : _t$width,
            _t$height = t.height,
            s = _t$height === void 0 ? 1.5 : _t$height,
            _t$depth = t.depth,
            l = _t$depth === void 0 ? .44 : _t$depth;

        if (n) {
          var u = e.scale;
          o = {
            x: o.x * u,
            y: o.y * u,
            z: o.z * u
          }, a *= u, s *= u, l *= u;
        }

        if (e.rootNode) {
          var _u = new BABYLON.Vector3(0, 0, 0),
              c = new BABYLON.Vector3(0, 0, 0);

          if (r) {
            var f = ue4Position2Xverse(o);
            _u = _u.add(f.add(new BABYLON.Vector3(-a / 2, -s / 2, -l / 2))), c = c.add(f.add(new BABYLON.Vector3(a / 2, s / 2, l / 2)));
          } else if (_u = _u.add(new BABYLON.Vector3(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY)), c = c.add(new BABYLON.Vector3(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY)), e.isRender) {
            e.rootNode.getChildMeshes().forEach(function (_) {
              var g = _.getBoundingInfo().boundingBox.minimum,
                  m = _.getBoundingInfo().boundingBox.maximum;

              _u.x = Math.min(_u.x, g.x), c.x = Math.max(c.x, m.x), _u.y = Math.min(_u.y, g.y), c.y = Math.max(c.y, m.y), _u.z = Math.min(_u.z, g.z), c.z = Math.max(c.z, m.z);
            });

            var _f = c.x - _u.x,
                d = c.z - _u.z;

            _u.x -= e.scale * _f / 2, c.x += e.scale * _f / 2, c.y *= e.scale, _u.z -= e.scale * d / 2, c.z += e.scale * d / 2;
          } else {
            var _f2 = e.avatarManager.getMainAvatar();

            _f2 && _f2.bbComponent.bbox && (_u.x = _f2.bbComponent.bbox.minimum.x, c.x = _f2.bbComponent.bbox.maximum.x, _u.y = _f2.bbComponent.bbox.minimum.y, c.y = _f2.bbComponent.bbox.maximum.y, _u.z = _f2.bbComponent.bbox.minimum.z, c.z = _f2.bbComponent.bbox.maximum.z);
          }

          var h = e.rootNode.computeWorldMatrix(!0);

          if (_this.bbox ? _this.bbox.reConstruct(_u, c, h) : _this.bbox = new BABYLON.BoundingBox(_u, c, h), _this._pickBbox == null) {
            var _f3 = _this.createPickBoundingbox(e, _this.bbox);

            _this.attachToAvatar(e, _f3.data, !1, {
              x: 0,
              y: 0,
              z: 0
            }, !1, "pickbox"), _this._pickBbox = _f3;
          }
        } else logger$1.error("avatar not found!");
      });
      this._scene = e;
    }

    _createClass(XAvatarBillboardComponent, [{
      key: "isNameVisible",
      get: function get() {
        return this._isNameVisible;
      }
    }, {
      key: "isBubbleVisible",
      get: function get() {
        return this._isBubbleVisible;
      }
    }, {
      key: "isGiftButtonsVisible",
      get: function get() {
        return this._isGiftButtonsVisible;
      }
    }, {
      key: "words",
      get: function get() {
        return this._words;
      }
    }, {
      key: "nickName",
      get: function get() {
        return this._nickName;
      }
    }, {
      key: "giftButtons",
      get: function get() {
        return this._giftButtons;
      }
    }, {
      key: "bubble",
      get: function get() {
        return this._bubble;
      }
    }, {
      key: "nameBoard",
      get: function get() {
        return this._nameBoard;
      }
    }, {
      key: "setNicknameStatus",
      value: function setNicknameStatus(e) {
        if (this.nameBoard && this.nameBoard.setStatus(e), e == BillboardStatus.DISPOSE) {
          var t = this._attachmentObservers.get("nickname");

          t && (this._scene.onBeforeRenderObservable.remove(t), this._attachmentObservers.delete("nickname"));
        }
      }
    }, {
      key: "setBubbleStatus",
      value: function setBubbleStatus(e) {
        if (this.bubble && this.bubble.setStatus(e), e == BillboardStatus.DISPOSE) {
          var t = this._attachmentObservers.get("bubble");

          t && (this._scene.onBeforeRenderObservable.remove(t), this._attachmentObservers.delete("bubble"));
        }
      }
    }, {
      key: "setButtonsStatus",
      value: function setButtonsStatus(e) {
        var _this2 = this;

        this.giftButtons && this.giftButtons.size != 0 && this.giftButtons.forEach(function (t) {
          if (t.setStatus(e), e == BillboardStatus.DISPOSE && t.getMesh()) {
            var r = "button_" + t.getMesh().xid,
                n = _this2._attachmentObservers.get(r);

            n && (_this2._scene.onBeforeRenderObservable.remove(n), _this2._attachmentObservers.delete(r));
          }
        });
      }
    }, {
      key: "setGiftButtonsVisible",
      value: function setGiftButtonsVisible(e) {
        this.setButtonsStatus(e ? BillboardStatus.SHOW : BillboardStatus.DISPOSE);
      }
    }, {
      key: "dispose",
      value: function dispose(e) {
        var _this3 = this;

        this._attachmentObservers.forEach(function (t) {
          _this3._scene.onBeforeRenderObservable.remove(t);
        }), this._attachmentObservers.clear(), this.updateBillboardStatus(e, BillboardStatus.DISPOSE), this._buttonTex.clear(), this._pickBbox && (e.avatarManager.bboxMeshPool.release(this._pickBbox), this._pickBbox = null);
      }
    }, {
      key: "updateBillboardStatus",
      value: function updateBillboardStatus(e, t) {
        this.bbox || e.getBbox(), e.isRender ? (e.setBubbleStatus(t), e.setButtonsStatus(t), e.setNicknameStatus(t)) : (e.setBubbleStatus(BillboardStatus.DISPOSE), e.setButtonsStatus(BillboardStatus.DISPOSE), e.enableNickname ? e.setNicknameStatus(t) : e.setNicknameStatus(BillboardStatus.DISPOSE));
      }
    }, {
      key: "disposeBillBoard",
      value: function disposeBillBoard(e) {
        var _this4 = this;

        this._attachmentObservers.forEach(function (t) {
          _this4._scene.onBeforeRenderObservable.remove(t);
        }), this._attachmentObservers.clear(), this.updateBillboardStatus(e, BillboardStatus.DISPOSE), this._buttonTex.clear(), this._pickBbox && (e.avatarManager.bboxMeshPool.release(this._pickBbox), this._pickBbox = null);
      }
    }, {
      key: "setPickBoxScale",
      value: function setPickBoxScale(e) {
        this._pickBbox && this._pickBbox.data && (this._pickBbox.data.scaling = new BABYLON.Vector3(e, e, e));
      }
    }, {
      key: "setIsPickable",
      value: function setIsPickable(e, t) {
        e.rootNode && e.rootNode.getChildMeshes().forEach(function (r) {
          r.isPickable = t;
        }), this._pickBbox && this._pickBbox.data && (this._pickBbox.data.isPickable = t);
      }
    }, {
      key: "initNameboard",
      value: function initNameboard(e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
        this._nameBoard == null && (this._nameBoard = e.avatarManager.sceneManager.billboardComponent.addBillboard("name-" + e.id, !1, !0)), this._nameBoard.init("nickname", t / 300, t / 300);
      }
    }, {
      key: "initBubble",
      value: function initBubble(e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
        this._bubble == null && (this._bubble = e.avatarManager.sceneManager.billboardComponent.addBillboard("bubble-" + e.id, !1, !0)), e.isRender && this._bubble.init("bubble", t / 250, t / 250);
      }
    }, {
      key: "say",
      value: function say(e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._words;

        var _ref = arguments.length > 2 ? arguments[2] : undefined,
            r = _ref.id,
            n = _ref.isUser,
            o = _ref.background,
            _ref$font = _ref.font,
            a = _ref$font === void 0 ? "Arial" : _ref$font,
            _ref$fontsize = _ref.fontsize,
            s = _ref$fontsize === void 0 ? 38 : _ref$fontsize,
            _ref$fontcolor = _ref.fontcolor,
            l = _ref$fontcolor === void 0 ? "#ffffff" : _ref$fontcolor,
            _ref$fontstyle = _ref.fontstyle,
            u = _ref$fontstyle === void 0 ? "bold" : _ref$fontstyle,
            _ref$linesize = _ref.linesize,
            c = _ref$linesize === void 0 ? 22 : _ref$linesize,
            h = _ref.linelimit,
            _ref$offsets = _ref.offsets,
            f = _ref$offsets === void 0 ? {
          x: 0,
          y: 0,
          z: 40
        } : _ref$offsets,
            d = _ref.scale,
            _ref$compensationZ = _ref.compensationZ,
            _ = _ref$compensationZ === void 0 ? 11.2 : _ref$compensationZ,
            _ref$reregistAnyway = _ref.reregistAnyway,
            g = _ref$reregistAnyway === void 0 ? !0 : _ref$reregistAnyway;

        (!this.bubble || this.bubble.getMesh() == null) && e.initBubble(), this._words = t;
        var m;
        n != null && (m = n ? XBillboardManager.userBubbleUrls : XBillboardManager.npcBubbleUrls), this._bubble && (this._bubble.DEFAULT_CONFIGS = {
          id: r,
          isUser: n,
          background: o || m,
          font: a,
          fontsize: s,
          fontcolor: l,
          fontstyle: u,
          linesize: c,
          linelimit: h,
          offsets: f,
          scale: d,
          compensationZ: _,
          reregistAnyway: g
        }, this._bubble.getMesh() && (this._bubble.drawBillboard({
          imageList: o || m
        }, {
          texts: this._words,
          font: a,
          fontsize: s,
          fontcolor: l,
          fontstyle: u,
          linesize: c
        }, {
          offsets: f,
          scale: d,
          compensationZ: _
        }), this.attachToAvatar(e, this._bubble.getMesh(), !1, this._bubble.offsets, g, "bubble"), r && this._bubble.setId(r))), this.setButtonsStatus(BillboardStatus.DISPOSE);
      }
    }, {
      key: "silent",
      value: function silent() {
        this.setBubbleStatus(BillboardStatus.DISPOSE), this._words = "";
      }
    }, {
      key: "setNickName",
      value: function setNickName(e, t, _ref2) {
        var r = _ref2.id,
            n = _ref2.isUser,
            o = _ref2.background,
            _ref2$font = _ref2.font,
            a = _ref2$font === void 0 ? "Arial" : _ref2$font,
            _ref2$fontsize = _ref2.fontsize,
            s = _ref2$fontsize === void 0 ? 40 : _ref2$fontsize,
            _ref2$fontcolor = _ref2.fontcolor,
            l = _ref2$fontcolor === void 0 ? "#ffffff" : _ref2$fontcolor,
            _ref2$fontstyle = _ref2.fontstyle,
            u = _ref2$fontstyle === void 0 ? "bold" : _ref2$fontstyle,
            _ref2$linesize = _ref2.linesize,
            c = _ref2$linesize === void 0 ? 22 : _ref2$linesize,
            h = _ref2.linelimit,
            _ref2$offsets = _ref2.offsets,
            f = _ref2$offsets === void 0 ? {
          x: 0,
          y: 0,
          z: 15
        } : _ref2$offsets,
            d = _ref2.scale,
            _ref2$compensationZ = _ref2.compensationZ,
            _ = _ref2$compensationZ === void 0 ? 0 : _ref2$compensationZ,
            _ref2$reregistAnyway = _ref2.reregistAnyway,
            g = _ref2$reregistAnyway === void 0 ? !1 : _ref2$reregistAnyway;

        this._nickName = t, (!this.nameBoard || this.nameBoard.getMesh() == null) && this.initNameboard(e), this._nameBoard && this._nameBoard.getMesh() && (this._nameBoard.DEFAULT_CONFIGS = {
          id: r,
          isUser: n,
          background: o,
          font: a,
          fontsize: s,
          fontcolor: l,
          fontstyle: u,
          linesize: c,
          linelimit: h,
          offsets: f,
          scale: d,
          compensationZ: _,
          reregistAnyway: g
        }, this._nameBoard.drawBillboard({}, {
          texts: this._nickName,
          font: a,
          fontsize: s,
          fontcolor: l,
          fontstyle: u,
          linesize: c,
          linelimit: h
        }, {
          offsets: f,
          scale: d,
          compensationZ: 0
        }), this.attachToAvatar(e, this._nameBoard.getMesh(), !1, this._nameBoard.offsets, g, "nickname"), r && this._nameBoard.setId(r));
      }
    }, {
      key: "generateButtons",
      value: function generateButtons(e) {
        var _this5 = this;

        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
        var r = arguments.length > 2 ? arguments[2] : undefined;
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 85;
        if (t && (this._buttonTex = t, this.clearButtons()), this._buttonTex.size == 0) return;
        var o = (this._buttonTex.size - 1) / 2;
        this._buttonTex.forEach(function (a, s) {
          var l = _this5._giftButtons.get(s);

          l || (l = e.avatarManager.sceneManager.billboardComponent.addBillboard("button-" + s + e.id, !0, !1), l.init(s, r / 240, r / 240));
          var u = {
            x: r * o * 70,
            y: 0,
            z: r * (n - 20 * (o * o))
          };
          l.drawBillboard({
            imageList: [a]
          }, {}, {
            offsets: u,
            scale: r
          }), _this5.attachToAvatar(e, l.getMesh(), !1, l.offsets, !0, "button_" + s), _this5._giftButtons.set(s, l), o -= 1;
        }), this.setBubbleStatus(BillboardStatus.DISPOSE);
      }
    }, {
      key: "clearButtons",
      value: function clearButtons() {
        this._giftButtons.forEach(function (e) {
          e.dispose();
        }), this._giftButtons.clear();
      }
    }, {
      key: "createPickBoundingbox",
      value: function createPickBoundingbox(e, t) {
        var r = t.extendSize.x * 2,
            n = t.extendSize.y * 2,
            o = t.extendSize.z * 2,
            a = this._scene,
            s = Math.max(r, o),
            l = e.avatarManager.bboxMeshPool.getFree(a, s, n, s),
            u = l.data;
        return u && (u.position = t.centerWorld, u.setEnabled(!1), u.isPickable = !0, u.xtype = EMeshType.XAvatar, u.xid = e.id), l;
      }
    }]);

    return XAvatarBillboardComponent;
  }();

  var castRayOffsetY = .01;
  var castRayTeleportationOffset = 10;

  var XAvatar = /*#__PURE__*/function () {
    function XAvatar(_ref) {
      var _this = this;

      var e = _ref.id,
          t = _ref.avatarType,
          r = _ref.priority,
          n = _ref.avatarManager,
          o = _ref.assets,
          a = _ref.status;

      _classCallCheck(this, XAvatar);

      E(this, "id", "-1");
      E(this, "priority", 0);
      E(this, "isRender", !1);
      E(this, "distLevel", 0);
      E(this, "isInLoadingList", !1);
      E(this, "isHide", !1);
      E(this, "component");
      E(this, "controller");
      E(this, "stateMachine");
      E(this, "bbComponent");
      E(this, "_avatarType");
      E(this, "clothesList", []);
      E(this, "isSelected", !1);
      E(this, "pendingLod", !1);
      E(this, "_previousReceivedPosition", new BABYLON.Vector3(0, 1e4, 0));
      E(this, "_avatarPosition");
      E(this, "_avatarRotation");
      E(this, "_avatarScale");
      E(this, "rootNode");
      E(this, "distToCam", 1e11);
      E(this, "enableNickname", !0);
      E(this, "distance", 1e11);
      E(this, "isCulling", !1);
      E(this, "reslevel", 0);
      E(this, "isInLoadingQueue", !1);
      E(this, "_isRayCastEnable");
      E(this, "_scene");
      E(this, "_avatarManager");
      E(this, "_transparent", 0);
      E(this, "hide", function () {
        return _this.isHide = !0, _this._hide(), !_this.isRender;
      });
      E(this, "_show", function () {
        var e;
        _this.isHide || (_this.setIsPickable(!0), _this.priority == 0 && (_this.rootNode.setEnabled(!0), _this.isRender = !0, _this.avatarManager._updateBillboardStatus(_this, BillboardStatus.SHOW), (e = _this.controller) == null || e.playAnimation(_this.controller.onPlay, _this.controller.loop)));
      });
      E(this, "show", function () {
        return _this.isHide = !1, _this._show(), !!_this.isRender;
      });
      E(this, "setAnimations", function (e) {
        _this.controller.animations = e;
      });
      E(this, "attachToAvatar", function (e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
          x: 0,
          y: 0,
          z: 0
        };
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : !1;
        var o = arguments.length > 4 ? arguments[4] : undefined;
        var a = arguments.length > 5 ? arguments[5] : undefined;
        return _this.bbComponent.attachToAvatar(_this, e, t, r, n, o, a);
      });
      E(this, "detachFromAvatar", function (e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
        return _this.bbComponent.detachFromAvatar(_this, e, t);
      });
      E(this, "getBbox", function () {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        return _this.bbComponent.getBbox(_this, e);
      });
      this.id = e, this._avatarManager = n, this._scene = this.avatarManager.scene, this.clothesList = o, this._avatarType = t, this.priority = r || 0, this.controller = new XAnimationController(this), this.component = new XAvatarComopnent(), this.stateMachine = new XStateMachine(this._scene), this.bbComponent = new XAvatarBillboardComponent(this._scene), this.rootNode = new BABYLON.TransformNode(e, this._avatarManager.scene), this._avatarScale = a.avatarScale == null ? 1 : a.avatarScale, this._avatarRotation = a.avatarRotation == null ? {
        pitch: 0,
        yaw: 0,
        roll: 0
      } : a.avatarRotation, this._avatarPosition = a.avatarPosition == null ? {
        x: 0,
        y: 0,
        z: 0
      } : a.avatarPosition, this.setPosition(this._avatarPosition), this.setRotation(this._avatarRotation), this.setScale(this.scale), this._isRayCastEnable = avatarSetting.isRayCastEnable, this._scene.registerBeforeRender(function () {
        _this.tick();
      });
    }

    _createClass(XAvatar, [{
      key: "tick",
      value: function tick() {
        this.cullingTick();
      }
    }, {
      key: "cullingTick",
      value: function cullingTick() {
        var _this2 = this;

        var e;
        this.isCulling && ((e = this.rootNode) == null || e.getChildMeshes().forEach(function (t) {
          _this2.distToCam < 50 ? t.visibility = 0 : t.visibility = _this2._transparent;
        }));
      }
    }, {
      key: "setTransParentThresh",
      value: function setTransParentThresh(e) {
        this._transparent = e;
      }
    }, {
      key: "isNameVisible",
      get: function get() {
        return this.bbComponent.isNameVisible;
      }
    }, {
      key: "isBubbleVisible",
      get: function get() {
        return this.bbComponent.isBubbleVisible;
      }
    }, {
      key: "isGiftButtonsVisible",
      get: function get() {
        return this.bbComponent.isGiftButtonsVisible;
      }
    }, {
      key: "words",
      get: function get() {
        return this.bbComponent.words;
      }
    }, {
      key: "nickName",
      get: function get() {
        return this.bbComponent.nickName;
      }
    }, {
      key: "giftButtons",
      get: function get() {
        return this.bbComponent.giftButtons;
      }
    }, {
      key: "bubble",
      get: function get() {
        return this.bbComponent.bubble;
      }
    }, {
      key: "nameBoard",
      get: function get() {
        return this.bbComponent.nameBoard;
      }
    }, {
      key: "avatarManager",
      get: function get() {
        return this._avatarManager;
      }
    }, {
      key: "withinVisibleRange",
      set: function set(e) {
        this.bbComponent.withinVisualRange = e;
      }
    }, {
      key: "setNicknameStatus",
      value: function setNicknameStatus(e) {
        return this.bbComponent.setNicknameStatus(e);
      }
    }, {
      key: "setBubbleStatus",
      value: function setBubbleStatus(e) {
        return this.bbComponent.setBubbleStatus(e);
      }
    }, {
      key: "setButtonsStatus",
      value: function setButtonsStatus(e) {
        return this.bbComponent.setBubbleStatus(e);
      }
    }, {
      key: "setGiftButtonsVisible",
      value: function setGiftButtonsVisible(e) {
        return this.bbComponent.setGiftButtonsVisible(e);
      }
    }, {
      key: "avatarType",
      get: function get() {
        return this._avatarType;
      }
    }, {
      key: "attachBody",
      value: function attachBody(e) {
        return this.component.addBodyComp(this, e);
      }
    }, {
      key: "attachDecoration",
      value: function attachDecoration(e) {
        return this.component.addClothesComp(this, e);
      }
    }, {
      key: "detachDecoration",
      value: function detachDecoration(e) {
        return this.component.clearClothesComp(e);
      }
    }, {
      key: "detachDecorationAll",
      value: function detachDecorationAll() {
        return this.component.clearAllClothesComps();
      }
    }, {
      key: "skeleton",
      get: function get() {
        return this.component.skeleton;
      }
    }, {
      key: "position",
      get: function get() {
        return this._avatarPosition;
      }
    }, {
      key: "rotation",
      get: function get() {
        return this._avatarRotation;
      }
    }, {
      key: "scale",
      get: function get() {
        return this._avatarScale;
      }
    }, {
      key: "_hide_culling",
      value: function _hide_culling() {
        this.bbComponent.updateBillboardStatus(this, BillboardStatus.HIDE), this.isCulling = !0;
      }
    }, {
      key: "_show_culling",
      value: function _show_culling() {
        this.isCulling && (this.rootNode && this.rootNode.getChildMeshes().forEach(function (e) {
          e.visibility = 1;
        }), this.bbComponent.updateBillboardStatus(this, BillboardStatus.SHOW), this.isCulling = !1);
      }
    }, {
      key: "_hide",
      value: function _hide() {
        !this.isHide || (this.setIsPickable(!1), this.priority == 0 ? (this.rootNode.setEnabled(!1), this.isRender = !1, this.bbComponent.updateBillboardStatus(this, BillboardStatus.HIDE)) : this.isRender && (this.avatarManager.currentLODUsers[this.distLevel]--, this.removeAvatarFromScene()));
      }
    }, {
      key: "rotate",
      value: function rotate(e, t, r) {
        return this.stateMachine.roll(this, e, t, r);
      }
    }, {
      key: "isRayCastEnable",
      get: function get() {
        return this._isRayCastEnable;
      },
      set: function set(e) {
        this._isRayCastEnable = e;
      }
    }, {
      key: "getAvatarId",
      value: function getAvatarId() {
        return this.id;
      }
    }, {
      key: "getAvaliableAnimations",
      value: function getAvaliableAnimations() {
        var e = avatarLoader.avaliableAnimation.get(this.avatarType);
        return e || [];
      }
    }, {
      key: "setPosition",
      value: function setPosition(e) {
        var _this3 = this;

        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;

        if (this._avatarPosition = e, this.rootNode) {
          var r = ue4Position2Xverse(this._avatarPosition);
          var n = !1;
          this.avatarManager.getMainAvatar() && (this.id != this.avatarManager.getMainAvatar().id || (Math.abs(r.y - this._previousReceivedPosition.y) > castRayOffsetY && (n = !0), r.subtract(this._previousReceivedPosition).length() > castRayTeleportationOffset && (n = !0))), this._isRayCastEnable ? n || t ? this._castRay(e).then(function (o) {
            _this3.rootNode.position = r, _this3.rootNode.position.y -= o;
          }).catch(function (o) {
            Promise.reject(o);
          }) : (this.rootNode.position.x = r.x, this.rootNode.position.z = r.z) : this.rootNode.position = r, this._previousReceivedPosition = r.clone();
        }

        return Promise.resolve(e);
      }
    }, {
      key: "setRotation",
      value: function setRotation(e) {
        if (this._avatarRotation = e, this.rootNode) {
          var t = {
            pitch: e.pitch,
            yaw: e.yaw + 180,
            roll: e.roll
          },
              r = ue4Rotation2Xverse(t);
          this.rootNode.rotation = r;
        }
      }
    }, {
      key: "setAvatarVisible",
      value: function setAvatarVisible(e) {
        this.rootNode && (this.rootNode.setEnabled(e), this.rootNode.getChildMeshes().forEach(function (t) {
          t.setEnabled(e);
        }));
      }
    }, {
      key: "setScale",
      value: function setScale(e) {
        this._avatarScale = e, this.rootNode && (this.rootNode.scaling = new BABYLON.Vector3(e, e, e)), this.bbComponent.bbox && this.getBbox();
      }
    }, {
      key: "_removeAvatarFromScene",
      value: function _removeAvatarFromScene() {
        var e, t;
        this.isRender = !1, (e = this.controller) == null || e.detachAnimation(), this.component.dispose(this), (t = this.avatarManager.sceneManager) == null || t.lightComponent.removeShadow(this);
      }
    }, {
      key: "removeAvatarFromScene",
      value: function removeAvatarFromScene() {
        this._removeAvatarFromScene(), this._disposeBillBoard();
      }
    }, {
      key: "_disposeBillBoard",
      value: function _disposeBillBoard() {
        this.bbComponent.disposeBillBoard(this);
      }
    }, {
      key: "addComponent",
      value: function addComponent(e, t, r, n) {
        return this.component.changeClothesComp(this, e, t, r, n);
      }
    }, {
      key: "_castRay",
      value: function _castRay(e) {
        var _this4 = this;

        return new Promise(function (t, r) {
          var d;
          var n = ue4Position2Xverse(e),
              o = new BABYLON.Vector3(0, -1, 0),
              a = 1.5 * _this4.scale,
              s = 100 * a,
              l = a,
              u = new BABYLON.Vector3(n.x, n.y + l, +n.z),
              c = new BABYLON.Ray(u, o, s),
              h = (d = _this4.avatarManager.sceneManager) == null ? void 0 : d.getGround(e);
          if (!h || h.length <= 0) return logger.warn("\u89D2\u8272 id= ".concat(_this4.id, " \u627E\u4E0D\u5230\u5730\u9762\uFF0C\u5F53\u524D\u9AD8\u5EA6\u4E3A\u4E0B\u53D1\u9AD8\u5EA6")), t(0);
          var f = c.intersectsMeshes(h);
          if (f.length > 0) return t(f[0].distance - l);
          if (o.y = 1, f = c.intersectsMeshes(h), f.length > 0) return t(-(f[0].distance - l));
        });
      }
    }, {
      key: "setPickBoxScale",
      value: function setPickBoxScale(e) {
        return this.bbComponent.setPickBoxScale(e);
      }
    }, {
      key: "setIsPickable",
      value: function setIsPickable(e) {
        return this.bbComponent.setIsPickable(this, e);
      }
    }, {
      key: "createPickBoundingbox",
      value: function createPickBoundingbox(e) {
        return this.bbComponent.createPickBoundingbox(this, e);
      }
    }, {
      key: "scaleBbox",
      value: function scaleBbox(e) {
        this.bbComponent.bbox && this.bbComponent.bbox.scale(e);
      }
    }, {
      key: "rotateTo",
      value: function rotateTo(e, t, r) {
        return this.stateMachine.rotateTo(this, e, t, r);
      }
    }, {
      key: "faceTo",
      value: function faceTo(e, t) {
        return this.stateMachine.lookAt(this, e, t);
      }
    }, {
      key: "removeObserver",
      value: function removeObserver() {
        this.stateMachine.disposeObsever();
      }
    }, {
      key: "move",
      value: function move(e, t, r, n, o) {
        return this.stateMachine.moveTo(this, e, t, r, n, o);
      }
    }, {
      key: "initNameboard",
      value: function initNameboard() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
        return this.bbComponent.initNameboard(this, e);
      }
    }, {
      key: "initBubble",
      value: function initBubble() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
        return this.bbComponent.initBubble(this, e);
      }
    }, {
      key: "say",
      value: function say(e, _ref2) {
        var t = _ref2.id,
            r = _ref2.isUser,
            n = _ref2.background,
            _ref2$font = _ref2.font,
            o = _ref2$font === void 0 ? "Arial" : _ref2$font,
            _ref2$fontsize = _ref2.fontsize,
            a = _ref2$fontsize === void 0 ? 38 : _ref2$fontsize,
            _ref2$fontcolor = _ref2.fontcolor,
            s = _ref2$fontcolor === void 0 ? "#ffffff" : _ref2$fontcolor,
            _ref2$fontstyle = _ref2.fontstyle,
            l = _ref2$fontstyle === void 0 ? "bold" : _ref2$fontstyle,
            _ref2$linesize = _ref2.linesize,
            u = _ref2$linesize === void 0 ? 22 : _ref2$linesize,
            c = _ref2.linelimit,
            _ref2$offsets = _ref2.offsets,
            h = _ref2$offsets === void 0 ? {
          x: 0,
          y: 0,
          z: 40
        } : _ref2$offsets,
            _ref2$scale = _ref2.scale,
            f = _ref2$scale === void 0 ? this._avatarScale : _ref2$scale,
            _ref2$compensationZ = _ref2.compensationZ,
            d = _ref2$compensationZ === void 0 ? 11.2 : _ref2$compensationZ,
            _ref2$reregistAnyway = _ref2.reregistAnyway,
            _ = _ref2$reregistAnyway === void 0 ? !0 : _ref2$reregistAnyway;

        return this.bbComponent.say(this, e, {
          id: t,
          isUser: r,
          background: n,
          font: o,
          fontsize: a,
          fontcolor: s,
          fontstyle: l,
          linesize: u,
          linelimit: c,
          offsets: h,
          scale: f,
          compensationZ: d,
          reregistAnyway: _
        });
      }
    }, {
      key: "silent",
      value: function silent() {
        return this.bbComponent.silent();
      }
    }, {
      key: "setNickName",
      value: function setNickName(e, _ref3) {
        var t = _ref3.id,
            r = _ref3.isUser,
            n = _ref3.background,
            _ref3$font = _ref3.font,
            o = _ref3$font === void 0 ? "Arial" : _ref3$font,
            _ref3$fontsize = _ref3.fontsize,
            a = _ref3$fontsize === void 0 ? 40 : _ref3$fontsize,
            _ref3$fontcolor = _ref3.fontcolor,
            s = _ref3$fontcolor === void 0 ? "#ffffff" : _ref3$fontcolor,
            _ref3$fontstyle = _ref3.fontstyle,
            l = _ref3$fontstyle === void 0 ? "bold" : _ref3$fontstyle,
            _ref3$linesize = _ref3.linesize,
            u = _ref3$linesize === void 0 ? 22 : _ref3$linesize,
            c = _ref3.linelimit,
            _ref3$offsets = _ref3.offsets,
            h = _ref3$offsets === void 0 ? {
          x: 0,
          y: 0,
          z: 15
        } : _ref3$offsets,
            _ref3$scale = _ref3.scale,
            f = _ref3$scale === void 0 ? this._avatarScale : _ref3$scale,
            _ref3$compensationZ = _ref3.compensationZ,
            d = _ref3$compensationZ === void 0 ? 0 : _ref3$compensationZ,
            _ref3$reregistAnyway = _ref3.reregistAnyway,
            _ = _ref3$reregistAnyway === void 0 ? !1 : _ref3$reregistAnyway;

        return this.bbComponent.setNickName(this, e, {
          id: t,
          isUser: r,
          background: n,
          font: o,
          fontsize: a,
          fontcolor: s,
          fontstyle: l,
          linesize: u,
          linelimit: c,
          offsets: h,
          scale: f,
          compensationZ: d,
          reregistAnyway: _
        });
      }
    }, {
      key: "generateButtons",
      value: function generateButtons() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._avatarScale;
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 85;
        return this.bbComponent.generateButtons(this, e, t, r);
      }
    }, {
      key: "clearButtons",
      value: function clearButtons() {
        return this.bbComponent.clearButtons();
      }
    }, {
      key: "attachExtraProp",
      value: function attachExtraProp(e, t, r, n) {
        return this.component.addDecoComp(this, e, t, r, n);
      }
    }, {
      key: "showExtra",
      value: function showExtra(e) {
        return this.component.showExtra(e);
      }
    }, {
      key: "hideExtra",
      value: function hideExtra(e) {
        return this.component.hideExtra(e);
      }
    }, {
      key: "disposeExtra",
      value: function disposeExtra() {
        return this.component.disposeExtra();
      }
    }, {
      key: "getSkeletonPositionByName",
      value: function getSkeletonPositionByName(e) {
        var t;

        if (this.skeleton) {
          var r = this.skeleton.bones.find(function (n) {
            return n.name.replace("Clone of ", "") == e;
          });

          if (r && r.getTransformNode() && ((t = r.getTransformNode()) == null ? void 0 : t.position)) {
            var n = r.getTransformNode().position;
            return xversePosition2Ue4({
              x: n.x,
              y: n.y,
              z: n.z
            });
          }
        }
      }
    }, {
      key: "shootTo",
      value: function shootTo(e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 2;
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 10;
        var o = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {
          x: 0,
          y: 0,
          z: 150
        };
        return this.stateMachine.sendObjectTo(this, e, t, r, n, o);
      }
    }]);

    return XAvatar;
  }();

  function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

  function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }

  function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

  var XAvatarManager = /*#__PURE__*/function () {
    function XAvatarManager(e) {
      var _this = this;

      _classCallCheck(this, XAvatarManager);

      this.characterMap = new Map();
      this.curAnimList = [];
      this.extraComps = new Map();
      this._mainUser = null;
      this._lodSettings = null;
      this.maxBillBoardDist = 0;
      this.maxAvatarNum = 0;
      this.currentLODUsers = [];
      this.bboxMeshPool = null;
      this._distLevels = [];
      this._maxLODUsers = [];
      this._cullingDistance = 0;
      this._maxDistRange = null;
      this._delayTime = 100;
      this._queueLength = -1;
      this._queue = [];
      this._processList = [];
      this._process = null;
      this._updateLoopObserver = null;
      this._avatarInDistance = [];
      this._renderedAvatar = [];
      this._enableNickname = !0;
      this._tickObserver = null;
      this._tickInterval = null;
      this._defaultAnims = null;
      this._tickDispose = 0;
      this._disposeTime = 100;
      this.avatarLoader = avatarLoader;
      this._scene = e.mainScene;
      this._sceneManager = e;
      this.initAvatarMap();

      this._initSettings();

      this._maxDistRange = this._distLevels[this._distLevels.length - 1], this.bboxMeshPool = new Pool(this.createBboxAsset, this.resetBboxAsset, 0, this.maxAvatarNum, this._sceneManager.Scene, 0, 0, 0), this._tickInterval = 250;
      var t = 0;
      this._tickObserver = this._scene.onAfterRenderObservable.add(function () {
        t += 1, t == _this._tickInterval && (_this.tick(), t = 0);
      });
    }

    _createClass(XAvatarManager, [{
      key: "tick",
      value: function tick() {
        this.bboxMeshPool.clean(0);
      }
    }, {
      key: "createBboxAsset",
      value: function createBboxAsset(e, t, r, n) {
        return BABYLON.MeshBuilder.CreateBox("avatarBbox", {
          width: t,
          height: r,
          depth: n
        }, e);
      }
    }, {
      key: "resetBboxAsset",
      value: function resetBboxAsset(e) {
        var t = e.data;
        return t.setEnabled(!1), t.isPickable = !1, e;
      }
    }, {
      key: "_initSettings",
      value: function _initSettings() {
        this._defaultAnims = avatarSetting.defaultIdle, this._lodSettings = avatarSetting.lod, this._distLevels = avatarSetting.lod.map(function (e) {
          return e.dist;
        }), this._maxLODUsers = avatarSetting.lod.map(function (e) {
          return e.quota;
        }), this.currentLODUsers = new Array(this._distLevels.length).fill(0), this.maxAvatarNum = avatarSetting.maxAvatarNum, this.maxBillBoardDist = avatarSetting.maxBillBoardDist, this._cullingDistance = avatarSetting.cullingDistance;
      }
    }, {
      key: "maxRenderNum",
      value: function maxRenderNum() {
        var e = 0;
        return this._maxLODUsers.forEach(function (t) {
          e += t;
        }), e;
      }
    }, {
      key: "curRenderNum",
      value: function curRenderNum() {
        var e = 0;
        return this.currentLODUsers.forEach(function (t) {
          e += t;
        }), e;
      }
    }, {
      key: "setLoDLevels",
      value: function setLoDLevels(e) {
        this._distLevels = e;
      }
    }, {
      key: "cullingDistance",
      get: function get() {
        return this._cullingDistance;
      },
      set: function set(e) {
        this._cullingDistance = e;
      }
    }, {
      key: "getLoDLevels",
      value: function getLoDLevels() {
        return this._distLevels;
      }
    }, {
      key: "setLodUserLimits",
      value: function setLodUserLimits(e, t) {
        this._maxLODUsers.length > e && (this._maxLODUsers[e] = t);
      }
    }, {
      key: "setLodDist",
      value: function setLodDist(e, t) {
        this._distLevels[e] = t;
      }
    }, {
      key: "setMaxDistRange",
      value: function setMaxDistRange(e) {
        this._maxDistRange = e, this._distLevels[this._distLevels.length - 1] = e;
      }
    }, {
      key: "scene",
      get: function get() {
        return this._scene;
      }
    }, {
      key: "setMainAvatar",
      value: function setMainAvatar(e) {
        var t;
        this._mainUser = (t = this.characterMap.get(0)) == null ? void 0 : t.get(e);
      }
    }, {
      key: "getMainAvatar",
      value: function getMainAvatar() {
        return this._mainUser;
      }
    }, {
      key: "enableAllNickname",
      value: function enableAllNickname(e) {
        var _this2 = this;

        return this.characterMap.forEach(function (t, r) {
          r != 0 && t.forEach(function (n, o) {
            _this2._updateBillboardStatus(n, e ? BillboardStatus.SHOW : BillboardStatus.HIDE);
          });
        }), this._enableNickname = e;
      }
    }, {
      key: "getAvatarById",
      value: function getAvatarById(e) {
        var t;
        return this.characterMap.forEach(function (r, n) {
          r.get(e) && (t = r.get(e));
        }), t;
      }
    }, {
      key: "getAvatarNums",
      value: function getAvatarNums() {
        var e = 0;
        return this.characterMap.forEach(function (t, r) {
          e += t.size;
        }), e;
      }
    }, {
      key: "registerAvatar",
      value: function registerAvatar(e) {
        this.characterMap.get(e.priority).set(e.id, e);
      }
    }, {
      key: "unregisterAvatar",
      value: function unregisterAvatar(e) {
        this.characterMap.get(e.priority).delete(e.id);
      }
    }, {
      key: "initAvatarMap",
      value: function initAvatarMap() {
        this.characterMap.set(0, new Map()), this.characterMap.set(1, new Map()), this.characterMap.set(2, new Map()), this.characterMap.set(3, new Map()), this.characterMap.set(4, new Map()), this.characterMap.set(5, new Map());
      }
    }, {
      key: "loadAvatar",
      value: function loadAvatar(_ref) {
        var _this3 = this;

        var e = _ref.id,
            t = _ref.avatarType,
            r = _ref.priority,
            n = _ref.avatarManager,
            o = _ref.assets,
            a = _ref.status;
        return new Promise(function (s, l) {
          if (_this3.getAvatarById(e)) return l(new DuplicateAvatarIDError("[Engine] cannot init avatar with the same id = ".concat(e)));
          if (_this3.getAvatarNums() > _this3.maxAvatarNum) return l(new ExceedMaxAvatarNumError("[Engine] \u8D85\u51FA\u6700\u5927\u89D2\u8272\u9650\u5236 ".concat(_this3.maxAvatarNum)));
          var u = new XAvatar({
            id: e,
            avatarType: t,
            priority: r,
            avatarManager: n,
            assets: o,
            status: a
          });
          if (_this3.registerAvatar(u), r == 0) _this3.setMainAvatar(u.id), _this3.addAvatarToScene(u, 0).then(function (c) {
            return logger$1.debug("[Engine] avatar ".concat(u.id, " has been added to scene")), c ? (_this3._updateBillboardStatus(c, BillboardStatus.SHOW), setTimeout(function () {
              _this3.launchProcessLoadingLoop();
            }, _this3._delayTime), s(c)) : (u.removeAvatarFromScene(), l(new AvatarAssetLoadingError()));
          }).catch(function (c) {
            return u.removeAvatarFromScene(), l(new AvatarAssetLoadingError(c));
          });else return s(u);
        });
      }
    }, {
      key: "deleteAvatar",
      value: function deleteAvatar(e) {
        return e.isRender ? (e.removeAvatarFromScene(), this.currentLODUsers[e.distLevel]--) : e.bbComponent.disposeBillBoard(e), this._processList = this._processList.filter(function (t) {
          return t.id !== e.id;
        }), this.unregisterAvatar(e), e.rootNode && (e.rootNode.dispose(), e.rootNode = void 0), e.bbComponent.bbox && e.bbComponent.bbox.dispose(), e.removeObserver(), e;
      }
    }, {
      key: "_checkLODLevel",
      value: function _checkLODLevel(e) {
        if (e < this._distLevels[0]) return 0;

        for (var t = 1; t < this._distLevels.length; ++t) {
          if (e >= this._distLevels[t - 1] && e < this._distLevels[t]) return t;
        }

        return this._distLevels.length - 1;
      }
    }, {
      key: "sceneManager",
      get: function get() {
        return this._sceneManager;
      }
    }, {
      key: "launchProcessLoadingLoop",
      value: function launchProcessLoadingLoop() {
        this._updateAvatarStatus();
      }
    }, {
      key: "stopProcessLoadingLoop",
      value: function stopProcessLoadingLoop() {
        var e;
        this._updateLoopObserver && ((e = this._scene) == null || e.onBeforeRenderObservable.remove(this._updateLoopObserver));
      }
    }, {
      key: "_distToMain",
      value: function _distToMain(e) {
        var n;
        var t = (n = this._mainUser) == null ? void 0 : n.position,
            r = e.position;

        if (r && t) {
          var o = this.sceneManager.cameraComponent.MainCamera.getFrontPosition(1).subtract(this.sceneManager.cameraComponent.MainCamera.position).normalize(),
              a = e.rootNode.position.subtract(this.sceneManager.cameraComponent.MainCamera.position).normalize();
          var s = 1;

          if (o && a) {
            var l = a.multiply(o);
            s = Math.acos(l.x + l.y + l.z) < this.sceneManager.cameraComponent.MainCamera.fov / 2 ? 1 : 1e11;
          }

          return calcDistance3D(t, r) * s;
        } else return logger$1.warn("user position or camera position is not correct!"), 1e11;
      }
    }, {
      key: "_distToCamera",
      value: function _distToCamera(e) {
        var n;
        var t = (n = this._sceneManager) == null ? void 0 : n.cameraComponent.getCameraPose().position,
            r = e.position;
        return r && t ? calcDistance3D(t, r) : (logger$1.warn("user position or camera position is not correct!"), 1e11);
      }
    }, {
      key: "showAll",
      value: function showAll(e) {
        this.characterMap.forEach(function (t, r) {
          e && r == 0 && t.forEach(function (n, o) {
            n.show();
          }), r != 0 && t.forEach(function (n, o) {
            n.show();
          });
        });
      }
    }, {
      key: "hideAll",
      value: function hideAll(e) {
        this.characterMap.forEach(function (t, r) {
          e && r == 0 && t.forEach(function (n, o) {
            n.hide();
          }), r != 0 && t.forEach(function (n, o) {
            n.hide();
          });
        });
      }
    }, {
      key: "_assemblyAvatar",
      value: function _assemblyAvatar(e, t) {
        var _this4 = this;

        var n, o;
        var r = e.get(avatarSetting.body);

        if (r && !t.attachBody(r)) {
          t.isInLoadingList = !1, e.clear();
          return;
        }

        var _iterator = _createForOfIteratorHelper$1(e),
            _step;

        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var a = _step.value;

            if (a[0] != avatarSetting.body && a[0] != avatarSetting.animations && !t.attachDecoration(a[1])) {
              t.isInLoadingList = !1, t.removeAvatarFromScene(), e.clear();
              return;
            }
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }

        t.isRender = !0, (n = t.controller) == null || n.playAnimation(t.controller.onPlay, t.controller.loop), (o = t.controller) == null || o.onPlayObservable.addOnce(function () {
          var a, s;

          if (!_this4.getAvatarById(t.id)) {
            t.isInLoadingList = !1, t.removeAvatarFromScene(), _this4.currentLODUsers[t.distLevel]--;
            return;
          }

          if (_this4.getAvatarById(t.id).rootNode.getChildMeshes().length < e.size) {
            logger$1.error("this avatar does not have complete components, render failed. current list ".concat((a = _this4.getAvatarById(t.id)) == null ? void 0 : a.clothesList, ",avatar: ").concat(t.id, ",").concat(t.nickName)), t.isInLoadingList = !1, t.removeAvatarFromScene(), _this4.currentLODUsers[t.distLevel]--;
            return;
          }

          t.setIsPickable(!0), t.isInLoadingList = !1, t.setAvatarVisible(!0), (s = _this4._sceneManager) == null || s.lightComponent.setShadow(t), t.getBbox(), t.nameBoard && t.nickName.length > 0 && t.setNickName(t.nickName, t.nameBoard.DEFAULT_CONFIGS), t.bubble && t.words.length > 0 && t.say(t.words, t.bubble.DEFAULT_CONFIGS), logger$1.debug("[Engine] avatar ".concat(t.id, " has been added to scene, current number of users : ").concat(_this4.currentLODUsers));
        });
      }
    }, {
      key: "_disposeUnusedAssets",
      value: function _disposeUnusedAssets() {
        this._tickDispose++, this._tickDispose > this._disposeTime && (avatarLoader.disposeContainer(), this._tickDispose = 0);
      }
    }, {
      key: "_addResourcesToList",
      value: function _addResourcesToList(e, t) {
        var _this5 = this;

        return e.clothesList.forEach(function (r) {
          r.lod = t, _this5._queue.push(r);
        }), this._queue.push({
          type: avatarSetting.animations,
          id: this._defaultAnims
        }), this._queue.push({
          type: avatarSetting.body,
          id: e.avatarType,
          lod: t
        }), !0;
      }
    }, {
      key: "_updateBillboardStatus",
      value: function _updateBillboardStatus(e, t) {
        e.bbComponent.updateBillboardStatus(e, t);
      }
    }, {
      key: "_processLayer",
      value: function _processLayer(e) {
        var _this6 = this;

        var t = this.characterMap.get(e),
            r = [];

        for (t == null || t.forEach(function (n) {
          n.distToCam = _this6._distToCamera(n);
          var o = n.distToCam < _this6._cullingDistance;

          if (n.isRender && (!n.isHide && o ? n._hide_culling() : n._show_culling()), n.priority != 0) {
            n.distance = _this6._distToMain(n);
            var _a = BillboardStatus.SHOW;
            n.distance < _this6._maxDistRange && (o ? _a = BillboardStatus.HIDE : n._show_culling(), _this6._updateBillboardStatus(n, _a)), n.isHide || (n.isInLoadingList ? _this6.currentLODUsers[n.distLevel]++ : r.push(n));
          }
        }), r.sort(function (n, o) {
          return o.distance - n.distance;
        }); r.length > 0 && this.curRenderNum() < this.maxRenderNum();) {
          var n = r.pop();

          var o = this._checkLODLevel(n.distance),
              a = !1;

          for (var s = 0; s < this._maxLODUsers.length; ++s) {
            if (this.currentLODUsers[s] < this._maxLODUsers[s]) {
              o = s, a = !0;
              break;
            }
          }

          if (!a || n.distance > this._maxDistRange) {
            if (n.isRender) {
              n._removeAvatarFromScene();

              var _s = BillboardStatus.HIDE;
              n.distance < this._maxDistRange && (_s = BillboardStatus.SHOW), this._updateBillboardStatus(n, _s);
            }

            break;
          }

          o != n.distLevel ? (n.isRender && (n.pendingLod = !0), n.distLevel = o, this._processList.push(n), n.isInLoadingList = !0) : n.isRender || (this._processList.push(n), n.isInLoadingList = !0), this.currentLODUsers[o]++;
        }

        return this.curRenderNum() >= this.maxRenderNum() && r.forEach(function (n) {
          if (n.isRender) {
            n._removeAvatarFromScene();

            var _o = BillboardStatus.HIDE;
            n.distance < _this6._maxDistRange && (_o = BillboardStatus.SHOW), _this6._updateBillboardStatus(n, _o);
          }
        }), this.curRenderNum() < this.maxRenderNum();
      }
    }, {
      key: "_updateAvatar",
      value: function _updateAvatar() {
        var _this7 = this;

        this.currentLODUsers = [0, 0, 0];
        var e = [5, 4, 3, 2, 1, 0];

        for (; e.length > 0;) {
          var t = e.pop();

          if (!this._processLayer(t)) {
            e.forEach(function (n) {
              var o;
              (o = _this7.characterMap.get(n)) == null || o.forEach(function (a) {
                a.distance = _this7._distToMain(a);
                var s = BillboardStatus.HIDE;
                a.distToCam < _this7._maxDistRange && (s = BillboardStatus.SHOW, a.isRender && a._removeAvatarFromScene()), _this7._updateBillboardStatus(a, s);
              });
            });
            break;
          }
        }
      }
    }, {
      key: "_updateAvatarStatus",
      value: function _updateAvatarStatus() {
        var _this8 = this;

        var e = new Map();
        this._updateLoopObserver = this.scene.onBeforeRenderObservable.add(function () {
          var t;

          if (_this8._disposeUnusedAssets(), !(_this8.getAvatarNums() <= 0)) {
            if (!_this8._process && _this8._processList.length == 0 && _this8._updateAvatar(), !_this8._process && _this8._processList.length > 0) {
              var r = _this8._processList.shift();

              r != _this8._process && !r.isCulling ? _this8._addResourcesToList(r, r.distLevel) ? (_this8._process = r, _this8._queueLength = _this8._queue.length) : (_this8._process = void 0, _this8._queue = [], r.isInLoadingList = !1) : r.isInLoadingList = !1;
            }

            if (e.size === _this8._queueLength && _this8._process) {
              _this8._process.pendingLod && (_this8._process.pendingLod = !1, _this8._process._removeAvatarFromScene());

              var _r = Date.now();

              _this8._assemblyAvatar(e, _this8._process), (t = _this8._sceneManager) == null || t.engineRunTimeStats.timeArray_addAvatarToScene.add(Date.now() - _r), _this8._updateBillboardStatus(_this8._process, BillboardStatus.SHOW), e.clear(), _this8._queue = [], _this8._process.isInLoadingList = !1, _this8._process = void 0, _this8._disposeUnusedAssets();
            }

            _this8._loadResByList(e);
          }
        });
      }
    }, {
      key: "_loadResByList",
      value: function _loadResByList(e) {
        var _this9 = this;

        var t = 0;
        var r = 5;

        if (!this._process) {
          e.clear();
          return;
        }

        var _loop = function _loop() {
          var n = Date.now(),
              o = _this9._queue.pop();

          setTimeout(function () {
            o ? o.type === avatarSetting.body ? _this9.loadBody(o.type, o.id, o.lod).then(function (a) {
              a && e.set(avatarSetting.body, a), t += Date.now() - n;
            }).catch(function (a) {
              _this9._process && (_this9._process.isHide = !0, _this9.currentLODUsers[_this9._process.distLevel]--, e.clear(), _this9._queue = [], _this9._process.isInLoadingList = !1, _this9._process = void 0, t += 100), logger$1.warn("[Engine] body ".concat(o.id, " uri error, type ").concat(o.type, ", avatar has been hided") + a);
            }) : o.type === avatarSetting.animations ? _this9.loadAnimation(_this9._process.avatarType, o.id).then(function (a) {
              a && e.set(avatarSetting.animations, a), t += Date.now() - n;
            }).catch(function (a) {
              _this9._process && (_this9._process.isHide = !0, _this9.currentLODUsers[_this9._process.distLevel]--, e.clear(), _this9._queue = [], _this9._process.isInLoadingList = !1, _this9._process = void 0, t += 100), logger$1.warn("animation  ".concat(o.id, " uri error, type ").concat(o.type, ", avatar has been hided") + a);
            }) : _this9.loadDecoration(o.type, o.id, o.lod).then(function (a) {
              a && e.set(a.type, a), t += Date.now() - n;
            }).catch(function (a) {
              _this9._process && (_this9._process.isHide = !0, _this9.currentLODUsers[_this9._process.distLevel]--, e.clear(), _this9._queue = [], _this9._process.isInLoadingList = !1, _this9._process = void 0, t += 100), logger$1.warn("component ".concat(o.id, " uri error, type ").concat(o.type, ", avatar has been hided") + a);
            }) : t += 100;
          }, 0);
        };

        for (; t < r && this._queue.length > 0;) {
          _loop();
        }
      }
    }, {
      key: "_validateContainer",
      value: function _validateContainer(e) {
        return !e.meshes || e.meshes.length <= 1 ? (logger$1.warn("import container has no valid meshes"), !1) : !e.skeletons || e.skeletons.length == 0 ? (logger$1.warn("import container has no valid skeletons"), !1) : !0;
      }
    }, {
      key: "_getAssetContainer",
      value: function _getAssetContainer(e, t) {
        var _this10 = this;

        return new Promise(function (r, n) {
          var o = _this10._getSourceKey(e, t || 0),
              a = avatarLoader.containers.get(o);

          if (a) return r(a);
          avatarLoader.load(_this10.sceneManager, e, t).then(function (s) {
            return s ? _this10._validateContainer(s) ? (avatarLoader.containers.set(o, s), r(s)) : n(new ContainerLoadingFailedError("[Engine] :: cannot load body type ".concat(e, "."))) : n(new ContainerLoadingFailedError("[Engine] container load failed cannot load body type ".concat(e, ".")));
          }).catch(function (s) {
            return n(new ContainerLoadingFailedError("[Engine] ".concat(s, " :: cannot load body type ").concat(e, ".")));
          });
        });
      }
    }, {
      key: "_clipContainerRes",
      value: function _clipContainerRes(e) {
        e.transformNodes.forEach(function (t) {
          t.dispose();
        }), e.transformNodes = [], e.skeletons.forEach(function (t) {
          t.dispose();
        }), e.skeletons = [];
      }
    }, {
      key: "loadBody",
      value: function loadBody(e, t, r) {
        var _this11 = this;

        return new Promise(function (n, o) {
          return avatarLoader.load(_this11.sceneManager, t, r).then(function (a) {
            if (a) {
              var s = a.instantiateModelsToScene();
              a.xReferenceCount++;
              var l = {
                isRender: !1,
                uId: Math.random(),
                root: s.rootNodes[0],
                skeletonType: e,
                name: t,
                animations: s.animationGroups,
                skeleton: s.skeletons[0],
                lod: r
              };
              return s.rootNodes[0]._parentContainer = a, s.rootNodes[0].setEnabled(!1), n(l);
            } else return o(new ContainerLoadingFailedError("[Engine] container failed instanciates failed"));
          }).catch(function () {
            return o(new ContainerLoadingFailedError("[Engine] body type ".concat(e, " instanciates failed")));
          });
        });
      }
    }, {
      key: "updateAnimationLists",
      value: function updateAnimationLists(e, t) {
        return new Promise(function (r, n) {
          return avatarLoader.avaliableAnimation.set(t, e), r();
        });
      }
    }, {
      key: "loadAnimation",
      value: function loadAnimation(e, t) {
        var _this12 = this;

        return new Promise(function (r, n) {
          return avatarLoader.loadAnimRes(_this12.sceneManager, t, e).then(function (o) {
            if (o) {
              var a;
              var s = _this12.avatarLoader.animations;
              return o.animationGroups.forEach(function (l) {
                l.stop(), l.name === t && (a = l, a.pContainer = o), s.set(getAnimationKey(l.name, e), l);
              }), _this12._clipContainerRes(o), o.xReferenceCount++, r(a);
            } else return n(new ContainerLoadingFailedError("[Engine] container failed instanciates failed"));
          });
        });
      }
    }, {
      key: "loadDecoration",
      value: function loadDecoration(e, t, r) {
        var _this13 = this;

        return new Promise(function (n, o) {
          return avatarLoader.load(_this13.sceneManager, t, r).then(function (a) {
            if (a) {
              _this13._clipContainerRes(a);

              var s = a.meshes[1].clone(a.meshes[1].name, null);

              if (!s) {
                logger$1.warn("[Engine] decoration does not exist!"), n(null);
                return;
              }

              var l = {
                isRender: !1,
                uId: Math.random(),
                root: s,
                type: e,
                name: t,
                isSelected: !1,
                lod: r
              };
              if (a.xReferenceCount++, s._parentContainer = a, a.meshes.length > 1) for (var u = 2; u < a.meshes.length; u++) {
                s.addChild(a.meshes[u].clone(a.meshes[u].name, null));
              }
              s.setEnabled(!1), l.isSelected = !0, n(l);
            } else return o(new ContainerLoadingFailedError("[Engine] container failed, instanciates failed."));
          }).catch(function () {
            return o(new ContainerLoadingFailedError("[Engine] body type ".concat(e, " instanciates failed.")));
          });
        });
      }
    }, {
      key: "_getSourceKey",
      value: function _getSourceKey(e, t) {
        return t && avatarSetting.lod[t] ? e + avatarSetting.lod[t].fileName.split(".")[0] : e;
      }
    }, {
      key: "addAvatarToScene",
      value: function addAvatarToScene(e, t) {
        var _this14 = this;

        var r = Date.now();
        return new Promise(function (n, o) {
          _this14.loadBody(e.avatarType, e.avatarType, t).then(function (a) {
            var s;
            if (!a) return e.isInLoadingList = !1, o(new ContainerLoadingFailedError("[Engine] avatar ".concat(e.id, " instanciates failed")));
            if (e.attachBody(a), a.animations.length > 0) return a.animations.forEach(function (l) {
              l.stop();
            }), e.setAnimations(a.animations), (s = e.controller) == null || s.playAnimation(e.controller.onPlay, !0), e.isRender = !0, e.isInLoadingList = !1, e.setAvatarVisible(!0), n(e);

            _this14.loadAnimation(e.avatarType, _this14._defaultAnims).then(function (l) {
              if (!l) return e.removeAvatarFromScene(), e.isInLoadingList = !1, o(new AvatarAnimationError());
              var u = [];
              e.clothesList.length > 0 && e.clothesList.forEach(function (c) {
                u.push(_this14.loadDecoration(c.type, c.id, t));
              }), Promise.all(u).then(function (c) {
                var d, _, g, m;

                c.forEach(function (v) {
                  if (v && !v.isRender) e.attachDecoration(v);else return e.isInLoadingList = !1, e.removeAvatarFromScene(), o(new AvatarAssetLoadingError());
                }), e.isRender = !0, (d = e.controller) == null || d.playAnimation(e.controller.onPlay, e.controller.loop), e.setAvatarVisible(!0);
                var h = avatarLoader.mshPath.get("meshes/ygb.glb"),
                    f = avatarLoader.matPath.get(avatarResources.ygb.mesh);
                h && f ? _this14.loadExtra(f, h).then(function (v) {
                  var y;
                  e.isRender = !0, e.isInLoadingList = !1, e.distLevel = t, (y = _this14._sceneManager) == null || y.engineRunTimeStats.timeArray_addAvatarToScene.add(Date.now() - r), n(e);
                }) : (e.isRender = !0, e.isInLoadingList = !1, e.distLevel = t, (_ = _this14._sceneManager) == null || _.engineRunTimeStats.timeArray_addAvatarToScene.add(Date.now() - r), n(e)), (g = _this14._sceneManager) == null || g.lightComponent.setShadow(e), e.isInLoadingList = !1, e.distLevel = t, (m = _this14._sceneManager) == null || m.engineRunTimeStats.timeArray_addAvatarToScene.add(Date.now() - r), n(e);
              }).catch(function () {
                return o(new AvatarAssetLoadingError("[Engine] avatar ".concat(e.id, " instanciates failed.")));
              });
            }).catch(function () {
              return o(new AvatarAssetLoadingError("[Engine] avatar ".concat(e.id, " instanciates failed.")));
            });
          }).catch(function () {
            return o(new AvatarAssetLoadingError("[Engine] avatar ".concat(e.id, " instanciates failed.")));
          });
        });
      }
    }, {
      key: "loadExtra",
      value: function loadExtra(e, t) {
        var _this15 = this;

        var r = avatarResources.ygb.name;
        return new Promise(function (n, o) {
          var a;
          (a = _this15.sceneManager) == null || a.urlTransformer(e).then(function (s) {
            BABYLON.SceneLoader.LoadAssetContainerAsync("", s, _this15.scene, null, avatarSetting.fileType).then(function (l) {
              var c;

              _this15.extraComps.set(r, l.meshes[0]);

              var u = new NodeMaterial("material_".concat(r), _this15._scene, {
                emitComments: !1
              });
              (c = _this15.sceneManager) == null || c.urlTransformer(t).then(function (h) {
                u.loadAsync(h).then(function () {
                  l.meshes[2].material.dispose(!0, !0), u.build(!1), l.meshes[2].material = u, n(l.meshes[2]);
                });
              });
            });
          });
        });
      }
    }, {
      key: "getAvatarList",
      value: function getAvatarList() {
        var e = [];
        return this.characterMap.forEach(function (t, r) {
          t.forEach(function (n, o) {
            e.push(n);
          });
        }), e;
      }
    }, {
      key: "_debug_avatar",
      value: function _debug_avatar() {
        var t, r;
        console.error("===>currentLODUsers", this.currentLODUsers), console.error("===>maxLODUsers", this._maxLODUsers), console.error("===>Loddist", this.getLoDLevels()), console.error("===> main character loc", (r = (t = this._mainUser) == null ? void 0 : t.rootNode) == null ? void 0 : r.position);
        var e = 0;
        this.getAvatarList().forEach(function (n) {
          n.isRender && (console.error("avatar id : ".concat(n.id, ",lod ").concat(n.distLevel, ",is Hide ").concat(n.isHide, ", distance ").concat(n.distance, ", is pending ").concat(n.isInLoadingList)), e++);
        }), console.error("========= avatar num", e), console.error("loop:", this._updateLoopObserver ? "on" : "false", "=> process", this._process, "===> comp", this._processList), console.error("===>maxLODUsers", this._maxLODUsers);
      }
    }]);

    return XAvatarManager;
  }();

  var XBillboard = /*#__PURE__*/function () {
    function XBillboard(e) {
      var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
      var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !1;

      _classCallCheck(this, XBillboard);

      E(this, "_mesh", null);
      E(this, "_texture", null);
      E(this, "_scalingFactor", 1);
      E(this, "offsets", null);
      E(this, "_pickable");
      E(this, "_background", null);
      E(this, "_billboardManager");
      E(this, "poolobj", null);
      E(this, "_usePool");
      E(this, "_initMeshScale", new BABYLON.Vector3(1, 1, 1));
      E(this, "_status", -1);
      E(this, "_stageChanged", !1);
      E(this, "DEFAULT_CONFIGS", {});
      this._billboardManager = e, this._pickable = t, this._usePool = r;
    }

    _createClass(XBillboard, [{
      key: "scalingFactor",
      set: function set(e) {
        this._scalingFactor = e;
      }
    }, {
      key: "background",
      set: function set(e) {
        this._background = e;
      }
    }, {
      key: "size",
      get: function get() {
        return -1;
      }
    }, {
      key: "setStatus",
      value: function setStatus(e) {
        e != this._status && (this._stageChanged = !0, this._status = e);
      }
    }, {
      key: "status",
      get: function get() {
        return this._status;
      }
    }, {
      key: "stageChanged",
      get: function get() {
        return this._stageChanged;
      },
      set: function set(e) {
        this._stageChanged = e;
      }
    }, {
      key: "init",
      value: function init() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : .001;
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : .001;
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : !1;
        var o = this._billboardManager.sceneManager.Scene;

        if (this._usePool) {
          var a = this._billboardManager.billboardPool.getFree(o, t, r, n);

          this._mesh = a.data, this._mesh.isPickable = this._pickable, this._mesh.xid = e, this._mesh.xtype = EMeshType.XBillboard, this._texture = this._mesh.material.diffuseTexture, this.poolobj = a;
        } else this._mesh = this._billboardManager.createBillboardAsset(o, n);

        this._mesh.isPickable = this._pickable, this._initMeshScale.x = t * 1e3, this._initMeshScale.y = r * 1e3, this._mesh.xid = e, this._mesh.xtype = EMeshType.XBillboard, this._texture = this._mesh.material.diffuseTexture, this.setStatus(1), this._stageChanged = !0;
      }
    }, {
      key: "dispose",
      value: function dispose() {
        this._usePool ? this.poolobj && (this._billboardManager.billboardPool.release(this.poolobj), this._mesh = null, this._texture = null, this.poolobj = null) : this._mesh && (this._mesh.dispose(!0, !0), this._mesh = null, this._texture = null), this._background = null;
      }
    }, {
      key: "getMesh",
      value: function getMesh() {
        return this._mesh;
      }
    }, {
      key: "updateImage",
      value: function updateImage(e) {
        var _this = this;

        return new Promise(function (t) {
          if (_this._texture == null) {
            logger$1.error("[Engine]Billboard texture not found");
            return;
          }

          var r = _this._mesh,
              n = _this._texture,
              o = _this._scalingFactor,
              a = _this._initMeshScale.x,
              s = _this._initMeshScale.y,
              l = _this._texture.getContext(),
              u = _this._texture.getSize();

          l.clearRect(0, 0, u.width, u.height);
          var c = new Image();
          c.crossOrigin = "anonymous", c.src = e, c.onload = function () {
            var h = c.width * o,
                f = c.height * o;
            r.scaling.x = h * a, r.scaling.y = f * s, n.scaleTo(h, f), l.drawImage(c, 0, 0, h, f), n.hasAlpha = !0, n.update(), t();
          };
        });
      }
    }, {
      key: "show",
      value: function show() {
        this._mesh && (this._mesh.setEnabled(!0), this._mesh.isPickable = this._pickable);
      }
    }, {
      key: "hide",
      value: function hide() {
        this._mesh && (this._mesh.setEnabled(!1), this._mesh.isPickable = !1);
      }
    }, {
      key: "setId",
      value: function setId(e) {
        this._mesh && (this._mesh.xid = e);
      }
    }, {
      key: "setPosition",
      value: function setPosition(e) {
        if (e && this._mesh) {
          var t = ue4Position2Xverse(e);
          this._mesh.position = t;
        }
      }
    }, {
      key: "updateText",
      value: function updateText(e, t) {
        var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !0;
        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
        var o = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 30;
        var a = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : "monospace";
        var s = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : "black";
        var l = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : "bold";
        var u = arguments.length > 8 ? arguments[8] : undefined;

        if (this._texture == null) {
          logger$1.error("[Engine]Billboard texture not found");
          return;
        }

        var c = this._texture,
            h = this._mesh,
            f = this._scalingFactor,
            d = this._initMeshScale.x,
            _ = this._initMeshScale.y;

        if (e != "") {
          var g = this._texture.getContext(),
              m = this._texture.getSize();

          g.clearRect(0, 0, m.width, m.height);
          var v = new Image();

          if (r) {
            t != null ? t ? this._background = this._billboardManager.userBackGroundBlob : this._background = this._billboardManager.npcBackGroundBlob : this._background || (this._background = this._billboardManager.userBackGroundBlob);
            var y = e,
                b = u && u < n.length - 1 ? u : n.length - 1;

            if (this._background) {
              if (b > this._background.length) {
                for (var T = 0; T < b - this._background.length; T++) {
                  n.pop();
                }

                b = n.length - 1, y = e.slice(0, n[b] - 1) + String.fromCharCode(8230);
              }

              v.crossOrigin = "anonymous", v.src = this._background[b - 1], v.onload = function () {
                var T = v.width * f,
                    C = v.height * f;
                h.scaling.x = T * d, h.scaling.y = C * _, c.scaleTo(T, C), g.textAlign = "center", g.textBaseline = "middle", g.drawImage(v, 0, 0, T, C);

                for (var A = 0; A < b; A++) {
                  c.drawText(y.slice(n[0 + A], n[1 + A]), T / 2, C * (A + 1) / (b + 1) + (A - (b - 1) / 2) * f * 10, l + " " + o * f + "px " + a, s, "transparent", !0);
                }

                c.hasAlpha = !0;
              };
            }
          } else {
            var _y = u && u < n.length - 1 ? u : n.length - 1,
                _b = 480 * f,
                _T = 60 * f * _y;

            this._mesh.scaling = new BABYLON.Vector3(_b * d, _T * _, 1), c.scaleTo(_b, _T);
            var C = c.getContext();
            C.textAlign = "center", C.textBaseline = "middle";

            for (var A = 0; A < _y; A++) {
              c.drawText(e.slice(n[0 + A], n[1 + A]), _b / 2 + 2 * f, _T * (A + 1) / (_y + 1) + (A - (_y - 1) / 2) * f * 10 + 2 * f, l + " " + o * f + "px " + a, "#333333", "transparent", !0), c.drawText(e.slice(n[0 + A], n[1 + A]), _b / 2, _T * (A + 1) / (_y + 1) + (A - (_y - 1) / 2) * f * 10, l + " " + o * f + "px " + a, s, "transparent", !0);
            }

            c.hasAlpha = !0;
          }
        } else this.clearText();
      }
    }, {
      key: "drawBillboard",
      value: function drawBillboard(e, t, r) {
        var _this2 = this;

        var m;
        var n = e.imageList,
            o = t.texts,
            _t$font = t.font,
            a = _t$font === void 0 ? "monospace" : _t$font,
            _t$fontsize = t.fontsize,
            s = _t$fontsize === void 0 ? 40 : _t$fontsize,
            _t$fontcolor = t.fontcolor,
            l = _t$fontcolor === void 0 ? "#ffffff" : _t$fontcolor,
            _t$fontstyle = t.fontstyle,
            u = _t$fontstyle === void 0 ? "" : _t$fontstyle,
            _t$linesize = t.linesize,
            c = _t$linesize === void 0 ? 20 : _t$linesize,
            h = t.linelimit,
            f = r.position,
            d = r.offsets,
            _ = r.scale,
            _r$compensationZ = r.compensationZ,
            g = _r$compensationZ === void 0 ? 0 : _r$compensationZ;
        if (this.scalingFactor = _ || 1, d && (this.offsets = {
          x: d.x * this._scalingFactor,
          y: d.y * this._scalingFactor,
          z: d.z * this._scalingFactor
        }), this.offsets || (this.offsets = {
          x: 0,
          y: 0,
          z: 0
        }), this.setPosition(f), n && !o) (m = this._billboardManager.sceneManager) == null || m.urlTransformer(n[0]).then(function (v) {
          _this2.updateImage(v);
        });else if (o && !n) {
          var _getStringBoundaries = getStringBoundaries(o, c, XBillboardManager$1.alphaWidthMap),
              _getStringBoundaries2 = _slicedToArray(_getStringBoundaries, 2),
              v = _getStringBoundaries2[0],
              y = _getStringBoundaries2[1];

          this.offsets.z += this._scalingFactor * g * (y.length - 1), this.updateText(v, void 0, !1, y, s, a, l, u, h);
        } else if (o && n) {
          this.background = n;

          var _getStringBoundaries3 = getStringBoundaries(o, c, XBillboardManager$1.alphaWidthMap),
              _getStringBoundaries4 = _slicedToArray(_getStringBoundaries3, 2),
              _v = _getStringBoundaries4[0],
              _y2 = _getStringBoundaries4[1];

          this.offsets.z += this._scalingFactor * g * (_y2.length - 1), this.updateText(_v, void 0, !0, _y2, s, a, l, u, h);
        }
        this.setStatus(1);
      }
    }, {
      key: "clearText",
      value: function clearText() {
        if (this._texture != null) {
          var e = this._texture.getContext(),
              t = this._texture.getSize();

          e.clearRect(0, 0, t.width, t.height), this._texture.update();
        }
      }
    }]);

    return XBillboard;
  }();

  var texRootDir = "https://app-asset-1258211750.file.myqcloud.com/1/textures/";

  var XBillboardManager$1 = /*#__PURE__*/function () {
    function XBillboardManager(e) {
      var _this = this;

      _classCallCheck(this, XBillboardManager);

      E(this, "billboardMap", new Map());
      E(this, "sceneManager");
      E(this, "billboardPool");
      E(this, "userBackGroundBlob", new Array());
      E(this, "npcBackGroundBlob", new Array());
      E(this, "tickObserver");
      E(this, "tickInterval");
      E(this, "_updateLoopObserver");
      this.sceneManager = e, this.billboardPool = new Pool(this.createBillboardAsset, this.resetBillboardAsset, 0, 60, this.sceneManager.Scene, !1), this.tickInterval = 250;
      var t = 0;
      this.tickObserver = this.sceneManager.Scene.onAfterRenderObservable.add(function () {
        t += 1, t == _this.tickInterval && (_this.tick(), t = 0);
      }), this.launchBillboardStatusLoop();
    }

    _createClass(XBillboardManager, [{
      key: "tick",
      value: function tick() {
        this.billboardPool.clean(0, this.sceneManager.Scene, !1);
      }
    }, {
      key: "createBillboardAsset",
      value: function createBillboardAsset(e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
        var r = BABYLON.MeshBuilder.CreatePlane("billboard-", {
          height: .001,
          width: .001,
          sideOrientation: BABYLON.Mesh.DOUBLESIDE
        }, e);
        r.isPickable = !0, r.setEnabled(!1);
        var n = new BABYLON.DynamicTexture("billboard-tex-", {
          width: .001 + 1,
          height: .001 + 1
        }, e, t, BABYLON.Texture.BILINEAR_SAMPLINGMODE);
        n.hasAlpha = !0;
        var o = new BABYLON.StandardMaterial("billboard-mat-", e);
        return o.diffuseTexture = n, o.emissiveColor = new BABYLON.Color3(.95, .95, .95), o.useAlphaFromDiffuseTexture = !0, r.material = o, r.billboardMode = BABYLON.Mesh.BILLBOARDMODE_Y, r.position.y = 0, r;
      }
    }, {
      key: "resetBillboardAsset",
      value: function resetBillboardAsset(e) {
        var t = e.data;
        return t.setEnabled(!1), t.isPickable = !1, e;
      }
    }, {
      key: "loadBackGroundTexToIDB",
      value: function () {
        var _loadBackGroundTexToIDB = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
          var _this2 = this;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  XBillboardManager.userBubbleUrls.forEach(function (r) {
                    _this2.sceneManager.urlTransformer(r).then(function (n) {
                      _this2.userBackGroundBlob.push(n);
                    });
                  }), XBillboardManager.npcBubbleUrls.forEach(function (r) {
                    _this2.sceneManager.urlTransformer(r).then(function (n) {
                      _this2.npcBackGroundBlob.push(n);
                    });
                  });

                case 1:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee);
        }));

        function loadBackGroundTexToIDB() {
          return _loadBackGroundTexToIDB.apply(this, arguments);
        }

        return loadBackGroundTexToIDB;
      }()
    }, {
      key: "addBillboardToMap",
      value: function addBillboardToMap(e, t) {
        this.billboardMap.set(e, t);
      }
    }, {
      key: "addBillboard",
      value: function addBillboard(e, t, r) {
        var n = this.getBillboard(e);
        return n || (n = new XBillboard(this, t, r), this.addBillboardToMap(e, n)), n;
      }
    }, {
      key: "generateStaticBillboard",
      value: function generateStaticBillboard(e, _ref) {
        var _ref$id = _ref.id,
            t = _ref$id === void 0 ? "billboard" : _ref$id,
            r = _ref.isUser,
            n = _ref.background,
            _ref$font = _ref.font,
            o = _ref$font === void 0 ? "Arial" : _ref$font,
            _ref$fontsize = _ref.fontsize,
            a = _ref$fontsize === void 0 ? 40 : _ref$fontsize,
            _ref$fontcolor = _ref.fontcolor,
            s = _ref$fontcolor === void 0 ? "#ffffff" : _ref$fontcolor,
            _ref$fontstyle = _ref.fontstyle,
            l = _ref$fontstyle === void 0 ? "600" : _ref$fontstyle,
            _ref$linesize = _ref.linesize,
            u = _ref$linesize === void 0 ? 16 : _ref$linesize,
            c = _ref.linelimit,
            _ref$scale = _ref.scale,
            h = _ref$scale === void 0 ? 1 : _ref$scale,
            _ref$width = _ref.width,
            f = _ref$width === void 0 ? .01 : _ref$width,
            _ref$height = _ref.height,
            d = _ref$height === void 0 ? .01 : _ref$height,
            _ref$position = _ref.position,
            _ = _ref$position === void 0 ? {
          x: 0,
          y: 0,
          z: 0
        } : _ref$position;

        var g = this.addBillboard(t, !1, !0);
        g.getMesh() == null && g.init(t, f, d);
        var m;
        r != null && (m = r ? XBillboardManager.userBubbleUrls : XBillboardManager.npcBubbleUrls), g && g.getMesh() && (g.DEFAULT_CONFIGS = {
          id: t,
          isUser: r,
          background: n,
          font: o,
          fontsize: a,
          fontcolor: s,
          fontstyle: l,
          linesize: u,
          linelimit: c,
          scale: h,
          width: f,
          height: d,
          position: _
        }, g.drawBillboard({
          imageList: n || m
        }, {
          texts: e,
          font: o,
          fontsize: a,
          fontcolor: s,
          fontstyle: l,
          linesize: u,
          linelimit: c
        }, {
          position: _,
          scale: h
        }), t && g.setId(t), g.setStatus(BillboardStatus.SHOW));
      }
    }, {
      key: "getBillboard",
      value: function getBillboard(e) {
        return this.billboardMap.get(e);
      }
    }, {
      key: "toggle",
      value: function toggle(e, t) {
        var r;
        (r = this.getBillboard(e)) == null || r.setStatus(t ? BillboardStatus.SHOW : BillboardStatus.HIDE);
      }
    }, {
      key: "removeBillboard",
      value: function removeBillboard(e) {
        var t = this.getBillboard(e);
        t && (t.setStatus(BillboardStatus.DISPOSE), this.billboardMap.delete(e));
      }
    }, {
      key: "launchBillboardStatusLoop",
      value: function launchBillboardStatusLoop() {
        var _this3 = this;

        this._updateLoopObserver = this.sceneManager.Scene.onBeforeRenderObservable.add(function () {
          _this3.billboardMap.size <= 0 || _this3.billboardMap.forEach(function (e) {
            e.stageChanged && (e.status == BillboardStatus.SHOW ? e.show() : e.status == BillboardStatus.HIDE ? e.hide() : (e.hide(), e.dispose()), e.stageChanged = !1);
          });
        });
      }
    }]);

    return XBillboardManager;
  }();
  E(XBillboardManager$1, "alphaWidthMap", new Map()), E(XBillboardManager$1, "userBubbleUrls", [texRootDir + "bubble01.png", texRootDir + "bubble02.png", texRootDir + "bubble03.png"]), E(XBillboardManager$1, "npcBubbleUrls", [texRootDir + "bubble01_npc.png", texRootDir + "bubble02_npc.png", texRootDir + "bubble03_npc.png"]);

  var XLightManager = /*#__PURE__*/function () {
    function XLightManager(e) {
      _classCallCheck(this, XLightManager);

      E(this, "_scene");
      E(this, "_envTexture");
      E(this, "_shadowLight");
      E(this, "_shadowGenerator");
      E(this, "_avatarShadowMeshMap");
      E(this, "_cullingShadowObservers");
      E(this, "sceneManager");
      this.sceneManager = e, this._scene = this.sceneManager.Scene, this._envTexture = null, this.shadowLean = .1;
      var t = new BABYLON.Vector3(this.shadowLean, -1, 0),
          r = 1024;
      this._shadowLight = new BABYLON.DirectionalLight("AvatarLight", t, this._scene), this._shadowLight.shadowMaxZ = 5e3, this._shadowLight.intensity = 0, this.attachLightToCamera(this._shadowLight), this._shadowGenerator = new BABYLON.ShadowGenerator(r, this._shadowLight, !0), this._avatarShadowMeshMap = new Map(), this._cullingShadowObservers = new Map();
    }

    _createClass(XLightManager, [{
      key: "shadowLean",
      set: function set(e) {
        e = Math.min(e, 1), e = Math.max(e, -1), this._shadowLight && (this._shadowLight.direction = new BABYLON.Vector3(e, -1, 0));
      }
    }, {
      key: "setIBL",
      value: function setIBL(e) {
        var _this = this;

        return new Promise(function (t, r) {
          _this.sceneManager.urlTransformer(e).then(function (n) {
            var o;
            if (n == ((o = _this._envTexture) == null ? void 0 : o.url)) return t("env set success");
            _this._envTexture != null && _this.disposeIBL(), _this._envTexture = BABYLON.CubeTexture.CreateFromPrefilteredData(n, _this._scene, ".env"), _this._scene.environmentTexture = _this._envTexture, _this._envTexture.onLoadObservable.addOnce(function () {
              t("env set success"), logger$1.info("env set success");
            });
          }).catch(function () {
            r("env set fail");
          });
        });
      }
    }, {
      key: "disposeIBL",
      value: function disposeIBL() {
        this._envTexture == null ? logger$1.info("env not exist") : (this._envTexture.dispose(), this._envTexture = null, this._scene.environmentTexture = null, logger$1.info("env dispose success"));
      }
    }, {
      key: "removeShadow",
      value: function removeShadow(e) {
        var t;

        if (this._avatarShadowMeshMap.has(e)) {
          this._avatarShadowMeshMap.delete(e), this._cullingShadowObservers.get(e) && (this._scene.onBeforeRenderObservable.remove(this._cullingShadowObservers.get(e)), this._cullingShadowObservers.delete(e));
          var r = e.rootNode;
          r && ((t = this._shadowGenerator) == null || t.removeShadowCaster(r));
        } else return;
      }
    }, {
      key: "setShadow",
      value: function setShadow(e) {
        if (this._avatarShadowMeshMap.has(e)) return;
        e.rootNode && this._avatarShadowMeshMap.set(e, e.rootNode.getChildMeshes());
        var t = 20,
            r = 10,
            n = this.cullingShadow(t, r, e);

        this._cullingShadowObservers.set(e, n);
      }
    }, {
      key: "cullingShadow",
      value: function cullingShadow(e, t, r) {
        var _this2 = this;

        var n = 0;

        var o = function o() {
          var s, l;

          if (n == t) {
            var u = _this2._avatarShadowMeshMap.get(r),
                c = (s = r.rootNode) == null ? void 0 : s.getChildMeshes(),
                h = _this2._scene.activeCamera;

            u == null || u.forEach(function (f) {
              var d;
              (d = _this2._shadowGenerator) == null || d.removeShadowCaster(f, !1);
            }), c == null || c.forEach(function (f) {
              var d;
              (d = _this2._shadowGenerator) == null || d.addShadowCaster(f, !1);
            }), h && r.rootNode && ((l = r.rootNode.position) == null ? void 0 : l.subtract(h.position).length()) > e && (c == null || c.forEach(function (f) {
              var d;
              (d = _this2._shadowGenerator) == null || d.removeShadowCaster(f, !1);
            })), c && _this2._avatarShadowMeshMap.set(r, c), n = 0;
          } else n += 1;
        };

        return this._scene.onBeforeRenderObservable.add(o);
      }
    }, {
      key: "attachLightToCamera",
      value: function attachLightToCamera(e) {
        var _this3 = this;

        var t = e,
            r = 15,
            n = function n() {
          var o = _this3._scene.activeCamera;

          if (o) {
            var a = t.direction,
                s = new BABYLON.Vector3(r * a.x, r * a.y, r * a.z),
                l = o.position;
            t.position = l.subtract(s);
          }
        };

        return t && this._scene.registerBeforeRender(n), n;
      }
    }]);

    return XLightManager;
  }();

  var RunTimeArray = /*#__PURE__*/function () {
    function RunTimeArray() {
      _classCallCheck(this, RunTimeArray);

      E(this, "circularData");
      this.circularData = [];
    }

    _createClass(RunTimeArray, [{
      key: "add",
      value: function add(e) {
        this.circularData.length > 1e3 && this.circularData.shift(), this.circularData.push(e);
      }
    }, {
      key: "getAvg",
      value: function getAvg() {
        var e = 0;

        for (var t = 0; t < this.circularData.length; t++) {
          e += this.circularData[t];
        }

        return {
          sum: e,
          avg: e / this.circularData.length || 0
        };
      }
    }, {
      key: "getMax",
      value: function getMax() {
        var e = 0;

        for (var t = 0; t < this.circularData.length; t++) {
          e < this.circularData[t] && (e = this.circularData[t]);
        }

        return e || 0;
      }
    }, {
      key: "clear",
      value: function clear() {
        this.circularData = [];
      }
    }, {
      key: "getStat",
      value: function getStat() {
        var e = this.getAvg(),
            t = {
          sum: e.sum,
          avg: e.avg,
          max: this.getMax()
        };
        return this.clear(), t;
      }
    }]);

    return RunTimeArray;
  }();

  var XEngineRunTimeStats = /*#__PURE__*/_createClass(function XEngineRunTimeStats() {
    _classCallCheck(this, XEngineRunTimeStats);

    E(this, "timeArray_loadStaticMesh", new RunTimeArray());
    E(this, "timeArray_updateStaticMesh", new RunTimeArray());
    E(this, "timeArray_addAvatarToScene", new RunTimeArray());
  });

  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

  var getAlphaWidthMap = function getAlphaWidthMap(i, e) {
    var t = new BABYLON.DynamicTexture("test", 3, e),
        r = new Map();

    for (var n = 32; n < 127; n++) {
      var o = String.fromCodePoint(n),
          a = 2 + "px " + i;
      t.drawText(o, null, null, a, "#000000", "#ffffff", !0);
      var s = t.getContext();
      s.font = a;
      var l = s.measureText(o).width;
      r.set(n, l);
    }

    return t.dispose(), r;
  };

  var XSceneManager = /*#__PURE__*/function () {
    function XSceneManager(e, t) {
      var _this = this;

      _classCallCheck(this, XSceneManager);

      E(this, "scene");
      E(this, "engine");
      E(this, "canvas");
      E(this, "gl");
      E(this, "_yuvInfo");
      E(this, "cameraParam");
      E(this, "shaderMode");
      E(this, "panoInfo");
      E(this, "_initEngineScaleNumber");
      E(this, "_forceKeepVertical", !1);
      E(this, "_currentShader");
      E(this, "_currentPanoId");
      E(this, "_renderStatusCheckCount", 0);
      E(this, "_renderStatusNotChecktCount", 0);
      E(this, "_nonlinearCanvasResize", !1);
      E(this, "_bChangeEngineSize", !0);
      E(this, "_cameraManager");
      E(this, "_lowpolyManager");
      E(this, "_materialManager");
      E(this, "_statisticManager");
      E(this, "_breathPointManager");
      E(this, "_skytv");
      E(this, "_mv", []);
      E(this, "_decalManager");
      E(this, "_lightManager");
      E(this, "_avatarManager");
      E(this, "urlTransformer");
      E(this, "_billboardManager");
      E(this, "_backgroundImg");
      E(this, "engineRunTimeStats");
      E(this, "uploadHardwareSystemInfo", function () {
        var e = _this.statisticComponent.getHardwareRenderInfo(),
            t = _this.statisticComponent.getSystemInfo(),
            r = {
          driver: t.driver,
          vender: t.vender,
          webgl: t.version,
          os: t.os
        };

        logger$1.warn(JSON.stringify(e)), logger$1.warn(JSON.stringify(r));
      });
      E(this, "addNewLowPolyMesh", /*#__PURE__*/function () {
        var _ref = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e, t) {
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  _context.t0 = _this._currentShader == null;

                  if (!_context.t0) {
                    _context.next = 4;
                    break;
                  }

                  _context.next = 4;
                  return _this.initSceneManager();

                case 4:
                  return _context.abrupt("return", _this._lowpolyManager.addNewLowPolyMesh(e, t, _this._currentShader));

                case 5:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee);
        }));

        return function (_x, _x2) {
          return _ref.apply(this, arguments);
        };
      }());
      E(this, "initSceneManager", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2() {
        return regenerator.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return _this._materialManager.initMaterial();

              case 2:
                return _context2.abrupt("return", _this.applyShader());

              case 3:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2);
      })));
      E(this, "registerAfterRender", function () {
        var e;

        if (_this._forceKeepVertical) {
          var _t = _this.canvas.width,
              _r = _this.canvas.height;
          var _n = 0,
              _o = [[0, 0, 0, 0], [0, 0, 0, 0]];

          if (((e = _this._cameraManager.MainCamera) == null ? void 0 : e.fovMode) === BABYLON.Camera.FOVMODE_HORIZONTAL_FIXED ? (_n = Math.ceil((_r - _this._yuvInfo.height * _t / _this._yuvInfo.width) / 2), _o = [[0, 0, _t, _n], [0, _r - _n, _t, _n]]) : (_n = Math.ceil((_t - _this._yuvInfo.width * _r / _this._yuvInfo.height) / 2), _o = [[0, 0, _n, _r], [_t - _n, 0, _n, _r]]), _n > 0) {
            _this.gl.enable(_this.gl.SCISSOR_TEST);

            for (var a = 0; a < _o.length; ++a) {
              _this.gl.scissor(_o[a][0], _o[a][1], _o[a][2], _o[a][3]), _this.gl.clearColor(0, 0, 0, 1), _this.gl.clear(_this.gl.COLOR_BUFFER_BIT);
            }

            _this.gl.disable(_this.gl.SCISSOR_TEST);
          }
        }
      });
      E(this, "resetRender", function () {
        _this.scene.environmentTexture && (_this.scene.environmentTexture._texture ? _this.lightComponent.setIBL(_this.scene.environmentTexture._texture.url) : _this.scene.environmentTexture.url && _this.lightComponent.setIBL(_this.scene.environmentTexture.url));
      });
      var r = /iphone|ipad/gi.test(window.navigator.userAgent) || t.disableWebGL2,
          n = new BABYLON.Engine(e, !0, {
        preserveDrawingBuffer: !0,
        stencil: !0,
        disableWebGL2Support: r
      }, !0),
          o = new BABYLON.Scene(n);
      this.scene = o, this.engine = n, this.canvas = e, this.scene.clearColor = new BABYLON.Color4(.7, .7, .7, 1), this.engine.getCaps().parallelShaderCompile = void 0, this._initEngineScaleNumber = this.engine.getHardwareScalingLevel(), this.engine.enableOfflineSupport = !1, this.engine.doNotHandleContextLost = !0, this.scene.clearCachedVertexData(), this.scene.cleanCachedTextureBuffer(), this.urlTransformer = t.urlTransformer || function (s) {
        return Promise.resolve(s);
      }, t.logger && Logger1.setLogger(t.logger), this.gl = e.getContext("webgl2", {
        preserveDrawingBuffer: !0
      }) || e.getContext("webgl", {
        preserveDrawingBuffer: !0
      }) || e.getContext("experimental-webgl", {
        preserveDrawingBuffer: !0
      }), this.gl.pixelStorei(this.gl.UNPACK_ALIGNMENT, 1), this._currentPanoId = 0, t.forceKeepVertical != null && (this._forceKeepVertical = t.forceKeepVertical), t.panoInfo != null && (this.panoInfo = t.panoInfo), t.shaderMode != null && (this.shaderMode = t.shaderMode), t.yuvInfo != null ? this._yuvInfo = t.yuvInfo : this._yuvInfo = {
        width: t.videoResOriArray[0].width,
        height: t.videoResOriArray[0].height,
        fov: 50
      }, t.cameraParam != null && (this.cameraParam = t.cameraParam), t.nonlinearCanvasResize != null && (this._nonlinearCanvasResize = t.nonlinearCanvasResize), this._cameraManager = new XCameraComponent(this.canvas, this.scene, {
        cameraParam: this.cameraParam,
        yuvInfo: this._yuvInfo,
        forceKeepVertical: this._forceKeepVertical
      }), this._lowpolyManager = new XStaticMeshComponent(this), this._materialManager = new XMaterialComponent(this, {
        videoResOriArray: t.videoResOriArray,
        yuvInfo: this._yuvInfo,
        panoInfo: this.panoInfo,
        shaderMode: this.shaderMode
      }), this._statisticManager = new XStats(this), this._breathPointManager = new XBreathPointManager(this), this._decalManager = new XDecalManager(this), this._avatarManager = new XAvatarManager(this), this._billboardManager = new XBillboardManager$1(this), this.billboardComponent.loadBackGroundTexToIDB(), this._lightManager = new XLightManager(this), this.postprocessing(), this.initSceneManager(), this.engineRunTimeStats = new XEngineRunTimeStats(), /iphone/gi.test(window.navigator.userAgent) && window.devicePixelRatio && window.devicePixelRatio === 3 && window.screen.width === 375 && window.screen.height === 812 ? this.engine.setHardwareScalingLevel(this._initEngineScaleNumber * 2) : this.engine.setHardwareScalingLevel(this._initEngineScaleNumber * 1.8), this.scene.registerBeforeRender(function () {
        _this._nonlinearCanvasResize && _this._bChangeEngineSize && (_this.setEngineSize(_this._yuvInfo), _this._bChangeEngineSize = !1);
      }), this.scene.registerAfterRender(function () {
        _this._nonlinearCanvasResize || _this.registerAfterRender();
      }), window.addEventListener("resize", function () {
        _this._nonlinearCanvasResize ? _this._bChangeEngineSize = !0 : _this.engine.resize();
      }), XBillboardManager$1.alphaWidthMap = getAlphaWidthMap("Arial", this.scene), this.uploadHardwareSystemInfo();
    }

    _createClass(XSceneManager, [{
      key: "yuvInfo",
      get: function get() {
        return this.getCurrentShaderMode() == 1 ? this._yuvInfo : {
          width: -1,
          height: -1,
          fov: -1
        };
      },
      set: function set(e) {
        this.getCurrentShaderMode() == 1 && (this._yuvInfo = e, this._cameraManager.cameraFovChange(e));
      }
    }, {
      key: "mainScene",
      get: function get() {
        return this.scene;
      }
    }, {
      key: "cameraComponent",
      get: function get() {
        return this._cameraManager;
      }
    }, {
      key: "staticmeshComponent",
      get: function get() {
        return this._lowpolyManager;
      }
    }, {
      key: "materialComponent",
      get: function get() {
        return this._materialManager;
      }
    }, {
      key: "statisticComponent",
      get: function get() {
        return this._statisticManager;
      }
    }, {
      key: "avatarComponent",
      get: function get() {
        return this._avatarManager;
      }
    }, {
      key: "lightComponent",
      get: function get() {
        return this._lightManager;
      }
    }, {
      key: "Engine",
      get: function get() {
        return this.engine;
      }
    }, {
      key: "Scene",
      get: function get() {
        return this.scene;
      }
    }, {
      key: "billboardComponent",
      get: function get() {
        return this._billboardManager;
      }
    }, {
      key: "breathPointComponent",
      get: function get() {
        return this._breathPointManager;
      }
    }, {
      key: "skytvComponent",
      get: function get() {
        return this._skytv;
      }
    }, {
      key: "mvComponent",
      get: function get() {
        return this._mv;
      }
    }, {
      key: "decalComponent",
      get: function get() {
        return this._decalManager;
      }
    }, {
      key: "currentShader",
      get: function get() {
        return this._currentShader;
      }
    }, {
      key: "initEngineScaleNumber",
      get: function get() {
        return this._initEngineScaleNumber;
      }
    }, {
      key: "setImageQuality",
      value: function setImageQuality(e) {
        e == 0 ? (this.engine.setHardwareScalingLevel(this._initEngineScaleNumber * 1.8), logger$1.info("[Engine] change image quality to low, [" + this._initEngineScaleNumber * 1.8 + "]")) : e == 1 ? (this.engine.setHardwareScalingLevel(this._initEngineScaleNumber * 1.5), logger$1.info("[Engine] change image quality to mid, [" + this._initEngineScaleNumber * 1.5 + "]")) : e == 2 && (this.engine.setHardwareScalingLevel(this._initEngineScaleNumber * 1), logger$1.info("[Engine] change image quality to high, [" + this._initEngineScaleNumber * 1 + "]"));
      }
    }, {
      key: "setNonlinearCanvasResize",
      value: function setNonlinearCanvasResize(e) {
        this._nonlinearCanvasResize = e, this._bChangeEngineSize = e, e || this.engine.resize();
      }
    }, {
      key: "setBackgroundColor",
      value: function setBackgroundColor(e) {
        this.scene.clearColor = new Color4(e.r, e.g, e.b, e.a);
      }
    }, {
      key: "setBackgroundImg",
      value: function setBackgroundImg(e) {
        var _this2 = this;

        return this._backgroundImg != null && this._backgroundImg.url == e ? Promise.resolve(!0) : new Promise(function (t, r) {
          _this2.urlTransformer(e).then(function (n) {
            _this2._backgroundImg == null ? _this2._backgroundImg = {
              layer: new Layer("tex_background_" + Date.now(), n, _this2.Scene, !0),
              url: e
            } : _this2._backgroundImg.url != e && _this2._backgroundImg.layer != null && _this2._backgroundImg.layer.texture != null && (_this2._backgroundImg.layer.texture.updateURL(n), _this2._backgroundImg.layer.name = "tex_background_" + Date.now(), _this2._backgroundImg.url = e), t(!0);
          }).catch(function (n) {
            logger$1.error("[Engine] set background image Error: ".concat(n)), r("[Engine] set background image Error: ".concat(n));
          });
        });
      }
    }, {
      key: "cleanTheWholeScene",
      value: function cleanTheWholeScene() {
        var _this3 = this;

        var e = this.scene.getFrameId();
        this.scene.onBeforeRenderObservable.clear(), this.scene.onAfterRenderObservable.clear(), this.scene.clearCachedVertexData(), this.scene.cleanCachedTextureBuffer(), this.scene.registerBeforeRender(function () {
          _this3.scene.getFrameId() - e > 5 && _this3.scene.dispose();
        });
      }
    }, {
      key: "getAreaAvatar",
      value: function getAreaAvatar(e, t) {
        var r = [];
        return this._avatarManager.getAvatarList().forEach(function (n) {
          var o = e,
              a = n.position;
          a && o && calcDistance3D(o, a) < t && r.push(n.id);
        }), r;
      }
    }, {
      key: "setEngineSize",
      value: function setEngineSize(e) {
        var t = e.width,
            r = e.height,
            n = this.canvas.width;
        this.canvas.height, this.engine.setSize(Math.round(n), Math.round(n * (r / t)));
      }
    }, {
      key: "getCurrentShaderMode",
      value: function getCurrentShaderMode() {
        return this._currentShader === this._materialManager.getDefaultShader() ? 0 : this._currentShader === this._materialManager.getPureVideoShader() ? 1 : 2;
      }
    }, {
      key: "addSkyTV",
      value: function addSkyTV(e, t) {
        return this._skytv = new XTelevision(this.scene, e, this, t), this._skytv;
      }
    }, {
      key: "addMv",
      value: function addMv(e, t) {
        this._mv.push(new XTelevision(this.scene, e, this, t));
      }
    }, {
      key: "addMeshInfo",
      value: function addMeshInfo(e) {
        this._lowpolyManager.setMeshInfo(e);
      }
    }, {
      key: "applyShader",
      value: function applyShader() {
        var _this4 = this;

        return new Promise(function (e, t) {
          _this4.shaderMode == EShaderMode.videoAndPano || _this4.shaderMode == EShaderMode.video ? _this4.changeVideoShaderForLowModel() : _this4.shaderMode == EShaderMode.default && _this4.changeDefaultShaderForLowModel(), e(!0);
        });
      }
    }, {
      key: "changeHardwareScaling",
      value: function changeHardwareScaling(e) {
        e < 1 ? e = 1 : e > 2.5 && (e = 2.5), this._bChangeEngineSize = !0, this.engine.setHardwareScalingLevel(this._initEngineScaleNumber * e);
      }
    }, {
      key: "getCurrentUsedPanoId",
      value: function getCurrentUsedPanoId() {
        return this._currentPanoId;
      }
    }, {
      key: "render",
      value: function render() {
        try {
          this.scene.render();
        } catch (e) {
          throw logger$1.error("[Engine] Render Error: ".concat(e)), e;
        }
      }
    }, {
      key: "isReadyToRender",
      value: function isReadyToRender(e) {
        var _e$checkMesh = e.checkMesh,
            t = _e$checkMesh === void 0 ? !0 : _e$checkMesh,
            _e$checkEffect = e.checkEffect,
            r = _e$checkEffect === void 0 ? !1 : _e$checkEffect,
            _e$checkPostProgress = e.checkPostProgress,
            n = _e$checkPostProgress === void 0 ? !1 : _e$checkPostProgress,
            _e$checkParticle = e.checkParticle,
            o = _e$checkParticle === void 0 ? !1 : _e$checkParticle,
            _e$checkAnimation = e.checkAnimation,
            a = _e$checkAnimation === void 0 ? !1 : _e$checkAnimation;
            e.materialNameWhiteLists;
        if (this.scene._isDisposed) return logger$1.error("[Engine] this.scene._isDisposed== false "), !1;
        var l;
        var u = this.scene.getEngine();
        if (r && !u.areAllEffectsReady()) return logger$1.error("[Engine] engine.areAllEffectsReady == false"), !1;
        if (a && this.scene._pendingData.length > 0) return logger$1.error("[Engine] scene._pendingData.length > 0 && animation error"), !1;

        if (t) {
          for (l = 0; l < this.scene.meshes.length; l++) {
            var c = this.scene.meshes[l];
            if (!c.isEnabled() || !c.subMeshes || c.subMeshes.length === 0 || c != null && c.material != null && !(c.material.name.startsWith("Pure") || c.material.name.startsWith("Pano"))) continue;
            if (!c.isReady(!0)) return logger$1.error("[Engine] scene. mesh isReady == false, mesh name:".concat(c.name, ", mesh xtype: ").concat(c == null ? void 0 : c.xtype, ", mesh xgroup: ").concat(c == null ? void 0 : c.xgroup, ", mesh xskinInfo: ").concat(c == null ? void 0 : c.xskinInfo)), !1;
            var h = c.hasThinInstances || c.getClassName() === "InstancedMesh" || c.getClassName() === "InstancedLinesMesh" || u.getCaps().instancedArrays && c.instances.length > 0;

            var _iterator = _createForOfIteratorHelper(this.scene._isReadyForMeshStage),
                _step;

            try {
              for (_iterator.s(); !(_step = _iterator.n()).done;) {
                var f = _step.value;
                if (!f.action(c, h)) return logger$1.error("[Engine] scene._isReadyForMeshStage == false, mesh name:".concat(c.name, ", mesh xtype: ").concat(c == null ? void 0 : c.xtype, ", mesh xgroup: ").concat(c == null ? void 0 : c.xgroup, ", mesh xskinInfo: ").concat(c == null ? void 0 : c.xskinInfo)), !1;
              }
            } catch (err) {
              _iterator.e(err);
            } finally {
              _iterator.f();
            }
          }

          for (l = 0; l < this.scene.geometries.length; l++) {
            if (this.scene.geometries[l].delayLoadState === 2) return logger$1.error("[Engine] geometry.delayLoadState === 2"), !1;
          }
        }

        if (n) {
          if (this.scene.activeCameras && this.scene.activeCameras.length > 0) {
            var _iterator2 = _createForOfIteratorHelper(this.scene.activeCameras),
                _step2;

            try {
              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
                var _c = _step2.value;
                if (!_c.isReady(!0)) return logger$1.error("[Engine] camera not ready === false, ", _c.name), !1;
              }
            } catch (err) {
              _iterator2.e(err);
            } finally {
              _iterator2.f();
            }
          } else if (this.scene.activeCamera && !this.scene.activeCamera.isReady(!0)) return logger$1.error("[Engine] activeCamera ready === false, ", this.scene.activeCamera.name), !1;
        }

        if (o) {
          var _iterator3 = _createForOfIteratorHelper(this.scene.particleSystems),
              _step3;

          try {
            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
              var _c2 = _step3.value;
              if (!_c2.isReady()) return logger$1.error("[Engine] particleSystem ready === false, ", _c2.name), !1;
            }
          } catch (err) {
            _iterator3.e(err);
          } finally {
            _iterator3.f();
          }
        }

        return !0;
      }
    }, {
      key: "changePanoShaderForLowModel",
      value: function changePanoShaderForLowModel(e) {
        var _this5 = this;

        return logger$1.info("[Engine] changePanoShaderForLowModel: ".concat(e)), this._materialManager.allowYUVUpdate(), new Promise(function (t, r) {
          _this5._materialManager._isInDynamicRange(e) == !1 && r(!1), _this5._currentPanoId = e, _this5._currentShader = _this5._materialManager.getDynamicShader(e), _this5.changeShaderForLowModel().then(function () {
            t(!0);
          });
        });
      }
    }, {
      key: "changeVideoShaderForLowModel",
      value: function changeVideoShaderForLowModel() {
        return logger$1.info("[Engine] changeVideoShaderForLowModel"), this._currentShader = this._materialManager.getPureVideoShader(), this._materialManager.allowYUVUpdate(), this.changeShaderForLowModel();
      }
    }, {
      key: "changeDefaultShaderForLowModel",
      value: function changeDefaultShaderForLowModel() {
        return logger$1.info("[Engine] changeDefaultShaderForLowModel"), this._currentShader = this._materialManager.getDefaultShader(), this._materialManager.stopYUVUpdate(), this.changeShaderForLowModel();
      }
    }, {
      key: "changeShaderForLowModel",
      value: function changeShaderForLowModel() {
        var _this6 = this;

        return new Promise(function (e, t) {
          _this6._lowpolyManager.getMeshes().forEach(function (r) {
            r.setMaterial(_this6._currentShader);
          }), _this6._lowpolyManager.getCgMesh().mesh.material = _this6._currentShader, e(!0);
        });
      }
    }, {
      key: "setIBL",
      value: function setIBL(e) {
        this._lightManager.setIBL(e);
      }
    }, {
      key: "postprocessing",
      value: function postprocessing() {
        var e = new BABYLON.DefaultRenderingPipeline("default", !0, this.scene);
        e.imageProcessingEnabled = !1, e.bloomEnabled = !0, e.bloomThreshold = 1, e.bloomWeight = 1, e.bloomKernel = 64, e.bloomScale = .1;
      }
    }, {
      key: "getGround",
      value: function getGround(e) {
        var t = this._lowpolyManager.getMeshes(),
            r = [];

        return t.forEach(function (n) {
          n.mesh.name.indexOf("SM_Stage") >= 0 && r.push(n.mesh);
        }), this.Scene.meshes.forEach(function (n) {
          n.name.split("_")[0] === "ground" && r.push(n);
        }), r;
      }
    }]);

    return XSceneManager;
  }();

  var http = new Http();

  var urlMap = new Map(),
      urlTransformer = /*#__PURE__*/function () {
    var _ref2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(i) {
      var e,
          _args2 = arguments;
      return regenerator.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              e = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : !1;
              return _context2.abrupt("return", typeof i != "string" ? (console.warn("url transformer error", i), i) : i.startsWith("blob:") ? i : e ? http.get({
                url: i,
                useIndexedDb: !0,
                key: "url",
                isOutPutObjectURL: !1
              }) : urlMap.has(i) ? urlMap.get(i) : http.get({
                url: i,
                useIndexedDb: !0,
                key: "url"
              }).then(function (t) {
                return urlMap.set(i, t), t;
              }));

            case 2:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2);
    }));

    return function urlTransformer(_x2) {
      return _ref2.apply(this, arguments);
    };
  }();

  var sceneManager;

  function getSceneManager(i, e) {
    return sceneManager || (sceneManager = new XSceneManager(i, e)), sceneManager;
  }

  var EngineProxy = /*#__PURE__*/function () {
    function EngineProxy(e) {
      var _this = this;

      _classCallCheck(this, EngineProxy);

      E(this, "_tvs", []);
      E(this, "isRenderFirstFrame", !1);
      E(this, "_idleTime", 0);
      E(this, "renderTimer");
      E(this, "lightManager");
      E(this, "_checkSceneNotReadyCount", 0);
      E(this, "_checkSceneDurationFrameNum", 0);
      E(this, "_checkSceneFrameCount", 0);
      E(this, "timeoutCircularArray", new CircularArray(120, !1, []));
      E(this, "frameCircularArray", new CircularArray(120, !1, []));
      E(this, "interFrameCircularArray", new CircularArray(120, !1, []));
      E(this, "drawCallCntCircularArray", new CircularArray(120, !1, []));
      E(this, "activeFacesCircularArray", new CircularArray(120, !1, []));
      E(this, "renderTimeCircularArray", new CircularArray(120, !1, []));
      E(this, "drawCallTimeCircularArray", new CircularArray(120, !1, []));
      E(this, "animationCircularArray", new CircularArray(120, !1, []));
      E(this, "meshSelectCircularArray", new CircularArray(120, !1, []));
      E(this, "renderTargetCircularArray", new CircularArray(120, !1, []));
      E(this, "regBeforeRenderCircularArray", new CircularArray(120, !1, []));
      E(this, "regAfterRenderCircularArray", new CircularArray(120, !1, []));
      E(this, "renderCnt", 0);
      E(this, "renderErrorCount", 0);
      E(this, "engineSloppyCnt", 0);
      E(this, "systemStuckCnt", 0);
      E(this, "frameRenderNumber", 0);
      E(this, "_setFPS", function (e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 25;
        logger$1.info("Set fps to", t);
        var r = t > 60 ? 60 : t < 24 ? 24 : t;
        e.Engine.stopRenderLoop();
        var n = 1e3 / r;
        var o = Date.now(),
            a = Date.now(),
            s = n,
            l = 1;

        var u = function u() {
          var T;
          var c = Date.now(),
              h = c - o,
              f = c - a;
          a = c, _this.frameCircularArray.add(f), h - s > n && (_this.systemStuckCnt += 1);
          var d = h / s;
          l = .9 * l + .1 * d;

          var _ = Date.now();

          var g = 0,
              m = 0;

          if (_this.room.isUpdatedRawYUVData || _this.room.isPano) {
            if (_this.isRenderFirstFrame = !0, _this._checkSceneDurationFrameNum > 0) _this._checkSceneFrameCount++, _this.room.sceneManager.isReadyToRender({}) && _this._checkSceneDurationFrameNum--, _this._checkSceneFrameCount > EngineProxy._CHECK_DURATION && (_this._checkSceneDurationFrameNum = EngineProxy._CHECK_DURATION, _this._checkSceneFrameCount = 0, _this._checkSceneNotReadyCount++, (_this._checkSceneNotReadyCount == 1 || _this._checkSceneNotReadyCount % 100 == 0) && logger$1.error("[SDK] Scene not ready, skip render. loop: ".concat(_this._checkSceneNotReadyCount)), _this._checkSceneNotReadyCount > 10 && (logger$1.error("[SDK] Scene not ready, reload later"), _this.room.proxyEvents("renderError", {
              error: new Error("[SDK] Scene not ready, skip render and reload.")
            })), _this.room.stats.assign({
              renderErrorCount: _this._checkSceneNotReadyCount
            }), logger$1.infoAndReportMeasurement({
              value: 0,
              startTime: Date.now(),
              metric: "renderError",
              error: new Error("[SDK] Scene not ready, skip render and reload."),
              reportOptions: {
                sampleRate: .1
              }
            }));else try {
              e.render();
            } catch (C) {
              _this.renderErrorCount++, _this.renderErrorCount > 10 && _this.room.proxyEvents("renderError", {
                error: C
              }), _this.room.stats.assign({
                renderErrorCount: _this.renderErrorCount
              }), logger$1.infoAndReportMeasurement({
                value: 0,
                startTime: Date.now(),
                metric: "renderError",
                error: C,
                reportOptions: {
                  sampleRate: .1
                }
              });
            }
            g = Date.now() - _, _this.frameRenderNumber < 1e3 && _this.frameRenderNumber++, _this.room.networkController.rtcp.workers.UpdateYUV(), m = Date.now() - _ - g;
          }

          _this.isRenderFirstFrame || _this.room.networkController.rtcp.workers.UpdateYUV();

          var y = Date.now() - _;

          o = c + y, s = Math.min(Math.max((n - y) / l, 5), 200), y > n && (s = 10, _this.engineSloppyCnt += 1), _this._idleTime = s;
          var b = s;

          if (s > 150 && console.log("lastGap is ", s, ", ratio is ", l, ", usedTimeMs is ", y, ", cpuRenderTime is ", g, ", cpuUpdateYUVTime is ", m), _this.timeoutCircularArray.add(b), _this.renderCnt % 25 == 0) {
            var C = _this.frameCircularArray.getAvg(),
                A = _this.timeoutCircularArray.getAvg(),
                S = _this.frameCircularArray.getMax(),
                P = _this.timeoutCircularArray.getMax();

            (T = _this.room.stats) == null || T.assign({
              avgFrameTime: C,
              avgTimeoutTime: A,
              maxFrameTime: S,
              maxTimeoutTime: P,
              systemStuckCnt: _this.systemStuckCnt
            });
          }

          _this.renderTimer = window.setTimeout(u, s);
        };

        _this.renderTimer = window.setTimeout(u, n / l);
      });
      E(this, "updateStats", function () {
        var e;
        (e = _this.room.stats) == null || e.assign({
          renderFrameTime: _this.renderTimeCircularArray.getAvg(),
          maxRenderFrameTime: _this.renderTimeCircularArray.getMax(),
          interFrameTime: _this.interFrameCircularArray.getAvg(),
          animationTime: _this.animationCircularArray.getAvg(),
          meshSelectTime: _this.meshSelectCircularArray.getAvg(),
          drawcallTime: _this.drawCallTimeCircularArray.getAvg(),
          idleTime: _this._idleTime,
          registerBeforeRenderTime: _this.regBeforeRenderCircularArray.getAvg(),
          registerAfterRenderTime: _this.regAfterRenderCircularArray.getAvg(),
          renderTargetRenderTime: _this.renderTargetCircularArray.getAvg(),
          fps: (1e3 / (_this.renderTimeCircularArray.getAvg() + _this.interFrameCircularArray.getAvg())).toFixed(2),
          drawcall: _this.drawCallCntCircularArray.getAvg(),
          engineSloppyCnt: _this.engineSloppyCnt,
          maxInterFrameTime: _this.interFrameCircularArray.getMax(),
          maxDrawcallTime: _this.drawCallTimeCircularArray.getMax(),
          maxMeshSelectTime: _this.meshSelectCircularArray.getMax(),
          maxAnimationTime: _this.animationCircularArray.getMax(),
          maxRegisterBeforeRenderTime: _this.regBeforeRenderCircularArray.getMax(),
          maxRegisterAfterRenderTime: _this.regAfterRenderCircularArray.getMax(),
          maxRenderTargetRenderTime: _this.renderTargetCircularArray.getMax(),
          avgFrameTime: _this.frameCircularArray.getAvg(),
          avgTimeoutTime: _this.timeoutCircularArray.getAvg(),
          maxFrameTime: _this.frameCircularArray.getMax(),
          maxTimeoutTime: _this.timeoutCircularArray.getMax()
        });
      });
      this.room = e;
    }

    _createClass(EngineProxy, [{
      key: "initEngine",
      value: function () {
        var _initEngine = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(e) {
          var t, r, n, o, a;
          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  _context3.next = 2;
                  return this.updateBillboard();

                case 2:
                  logger$1.info("engine version:", VERSION$1);
                  t = logger$1;
                  t.setLevel(LoggerLevels$1.Warn);
                  r = {
                    videoResOriArray: [{
                      width: 720,
                      height: 1280
                    }, {
                      width: 1280,
                      height: 720
                    }, {
                      width: 480,
                      height: 654
                    }, {
                      width: 654,
                      height: 480
                    }, {
                      width: 1920,
                      height: 1080
                    }, {
                      width: 1080,
                      height: 1920
                    }, {
                      width: 414,
                      height: 896
                    }],
                    forceKeepVertical: this.room.options.objectFit !== "cover",
                    panoInfo: {
                      dynamicRange: 1,
                      width: 4096,
                      height: 2048
                    },
                    shaderMode: EShaderMode.videoAndPano,
                    yuvInfo: {
                      width: 1280,
                      height: 720,
                      fov: e.fov || DEFAULT_MAIN_CAMERA_FOV
                    },
                    cameraParam: {
                      maxZ: 1e4
                    },
                    urlTransformer,
                    logger: t,
                    disableWebGL2: this.room.options.disableWebGL2 || !1
                  }, n = this.room.options.resolution;
                  n && (r.videoResOriArray.some(function (l) {
                    return l.width === n.width && l.height === n.height;
                  }) || r.videoResOriArray.push(n));
                  o = this.room.sceneManager = getSceneManager(this.room.canvas, r);
                  this.room.setPictureQualityLevel(this.room.options.pictureQualityLevel || "high");
                  this.room.sceneManager.staticmeshComponent.setRegionLodRule([2, 2, -1, -1, -1]);
                  this.room.scene = o.Scene;
                  this.room.breathPointManager = o.breathPointComponent;
                  this.lightManager = o.lightComponent;
                  this.registerStats();
                  this.setEnv(e);
                  _context3.next = 17;
                  return this.room.avatarManager.init();

                case 17:
                  a = this._createAssetList(e);
                  _context3.next = 20;
                  return this.loadAssets(a, "");

                case 20:
                  this._setFPS(o);

                case 21:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, this);
        }));

        function initEngine(_x3) {
          return _initEngine.apply(this, arguments);
        }

        return initEngine;
      }()
    }, {
      key: "pause",
      value: function pause() {
        clearTimeout(this.renderTimer), logger$1.info("Invoke room.pause to pause render");
        var e = {
          roomId: this.room.id,
          effects: [],
          lowPolyModels: [],
          breathPointsConfig: [],
          skinId: this.room.skinId
        };
        return this.loadAssets(e, this.room.skinId);
      }
    }, {
      key: "resume",
      value: function () {
        var _resume = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4() {
          var e;
          return regenerator.wrap(function _callee4$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  this._setFPS(this.room.sceneManager), this.room.sceneManager.cameraComponent.cameraFovChange(this.room.sceneManager.yuvInfo), logger$1.info("Invoke room.resume to render");
                  e = this._createAssetList(this.room.skin);
                  _context4.next = 4;
                  return this.loadAssets(e, "");

                case 4:
                case "end":
                  return _context4.stop();
              }
            }
          }, _callee4, this);
        }));

        function resume() {
          return _resume.apply(this, arguments);
        }

        return resume;
      }()
    }, {
      key: "setEnv",
      value: function setEnv(e) {
        var r;
        this.lightManager || (this.lightManager = this.room.sceneManager.lightComponent), e = e || this.room.skin;
        var t = ModelManager.findModel(e.models, AssetTypeName.Config, AssetClassName.Env);
        return t ? (r = this.lightManager) == null ? void 0 : r.setIBL(t.modelUrl) : (logger$1.error("env file not found"), Promise.resolve());
      }
    }, {
      key: "_parseModelsAndLoad",
      value: function () {
        var _parseModelsAndLoad2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5(e, t, r) {
          var n, o, a, u, c, h, _c, s, l, _u, _c2, _h;

          return regenerator.wrap(function _callee5$(_context5) {
            while (1) {
              switch (_context5.prev = _context5.next) {
                case 0:
                  logger$1.info("Invoke _parseModelsAndLoad start", t);
                  n = ["airship", "balloon", "default", "ground_feiting", "ground_reqiqiu"], o = new Map();
                  r == null && (r = "xxxx");
                  a = !0;
                  u = 0;

                case 5:
                  if (!(u < e.length)) {
                    _context5.next = 20;
                    break;
                  }

                  a = !0;
                  c = 0;

                case 8:
                  if (!(c < n.length)) {
                    _context5.next = 16;
                    break;
                  }

                  if (!(e[u].modelUrl.toLowerCase().indexOf(n[c]) >= 0)) {
                    _context5.next = 13;
                    break;
                  }

                  h = o.get(n[c]);
                  h ? (h.push(e[u]), o.set(n[c], h)) : o.set(n[c], [e[u]]), a = !1;
                  return _context5.abrupt("break", 16);

                case 13:
                  ++c;
                  _context5.next = 8;
                  break;

                case 16:
                  if (a) {
                    _c = o.get("default");
                    _c ? (_c.push(e[u]), o.set("default", _c)) : o.set("default", [e[u]]);
                  }

                case 17:
                  ++u;
                  _context5.next = 5;
                  break;

                case 20:
                  s = o.get(t) || [];

                  if (!(this.room.viewMode === "simple" && (s = s.filter(function (u) {
                    return !u.modelUrl.endsWith("zip");
                  })), !s)) {
                    _context5.next = 23;
                    break;
                  }

                  return _context5.abrupt("return", Promise.reject("no invalid scene model with group name: ".concat(t)));

                case 23:
                  l = [];

                  for (_u = 0; _u < s.length; ++_u) {
                    _c2 = s[_u];
                    if (_c2.modelUrl.toLowerCase().endsWith("zip")) _c2.modelUrl.toLowerCase().endsWith("zip") && l.push(this.room.sceneManager.addNewLowPolyMesh({
                      url: _c2.modelUrl,
                      skinInfo: r
                    }));else {
                      _h = t;
                      l.push(this.room.sceneManager.addNewLowPolyMesh({
                        url: _c2.modelUrl,
                        group: _h,
                        pick: !0,
                        skinInfo: r
                      }));
                    }
                  }

                  return _context5.abrupt("return", Promise.all(l));

                case 26:
                case "end":
                  return _context5.stop();
              }
            }
          }, _callee5, this);
        }));

        function _parseModelsAndLoad(_x4, _x5, _x6) {
          return _parseModelsAndLoad2.apply(this, arguments);
        }

        return _parseModelsAndLoad;
      }()
    }, {
      key: "_deleteAssetsLowpolyModel",
      value: function () {
        var _deleteAssetsLowpolyModel2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee6(e) {
          var t;
          return regenerator.wrap(function _callee6$(_context6) {
            while (1) {
              switch (_context6.prev = _context6.next) {
                case 0:
                  this.room.sceneManager.staticmeshComponent.deleteMeshesBySkinInfo(e), this.room.sceneManager.breathPointComponent.clearBreathPointsBySkinInfo(e), this.room.sceneManager.decalComponent.deleteDecalBySkinInfo(e);
                  t = [];
                  this.room.sceneManager.Scene.meshes.forEach(function (r) {
                    r.xskinInfo == e && t.push(r);
                  }), t.forEach(function (r) {
                    r.dispose(!1, !1);
                  });

                case 3:
                case "end":
                  return _context6.stop();
              }
            }
          }, _callee6, this);
        }));

        function _deleteAssetsLowpolyModel(_x7) {
          return _deleteAssetsLowpolyModel2.apply(this, arguments);
        }

        return _deleteAssetsLowpolyModel;
      }()
    }, {
      key: "loadLandAssets",
      value: function () {
        var _loadLandAssets = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee7() {
          var _this2 = this;

          var e;
          return regenerator.wrap(function _callee7$(_context7) {
            while (1) {
              switch (_context7.prev = _context7.next) {
                case 0:
                  e = this._createAssetList(this.room.skin);
                  return _context7.abrupt("return", this.loadAssets(e, this.room.skinId).catch(function () {
                    return _this2.loadAssets(e, _this2.room.skinId);
                  }));

                case 2:
                case "end":
                  return _context7.stop();
              }
            }
          }, _callee7, this);
        }));

        function loadLandAssets() {
          return _loadLandAssets.apply(this, arguments);
        }

        return loadLandAssets;
      }()
    }, {
      key: "loadAssets",
      value: function () {
        var _loadAssets2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee8(e) {
          var t,
              r,
              n,
              _args8 = arguments;
          return regenerator.wrap(function _callee8$(_context8) {
            while (1) {
              switch (_context8.prev = _context8.next) {
                case 0:
                  t = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : "";
                  r = _args8.length > 2 && _args8[2] !== undefined ? _args8[2] : 8e3;
                  n = Date.now();
                  return _context8.abrupt("return", this._loadAssets(e, t)._timeout(r, new InitEngineTimeoutError("loadAssets timeout(".concat(r, "ms)"))).then(function (o) {
                    return logger$1.infoAndReportMeasurement({
                      tag: "loadAssets",
                      startTime: n,
                      metric: "loadAssets"
                    }), o;
                  }).catch(function (o) {
                    return logger$1.infoAndReportMeasurement({
                      tag: "loadAssets",
                      startTime: n,
                      metric: "loadAssets",
                      error: o
                    }), Promise.reject(o);
                  }));

                case 4:
                case "end":
                  return _context8.stop();
              }
            }
          }, _callee8, this);
        }));

        function loadAssets(_x8) {
          return _loadAssets2.apply(this, arguments);
        }

        return loadAssets;
      }()
    }, {
      key: "_loadAssets",
      value: function () {
        var _loadAssets3 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee9(e) {
          var t,
              r,
              _args9 = arguments;
          return regenerator.wrap(function _callee9$(_context9) {
            while (1) {
              switch (_context9.prev = _context9.next) {
                case 0:
                  t = _args9.length > 1 && _args9[1] !== undefined ? _args9[1] : "";
                  _context9.prev = 1;
                  r = [];
                  r.push(this._loadAssetsLowpolyModel(e, t));
                  _context9.next = 6;
                  return Promise.all(r);

                case 6:
                  _context9.next = 8;
                  return this.setEnv();

                case 8:
                  this._checkSceneDurationFrameNum = EngineProxy._CHECK_DURATION;
                  this._checkSceneNotReadyCount = 0;
                  this._checkSceneFrameCount = 0;
                  this.updateAnimationList();
                  this.room.loadAssetsHook();
                  _context9.next = 18;
                  break;

                case 15:
                  _context9.prev = 15;
                  _context9.t0 = _context9["catch"](1);
                  return _context9.abrupt("return", Promise.reject(_context9.t0));

                case 18:
                case "end":
                  return _context9.stop();
              }
            }
          }, _callee9, this, [[1, 15]]);
        }));

        function _loadAssets(_x9) {
          return _loadAssets3.apply(this, arguments);
        }

        return _loadAssets;
      }()
    }, {
      key: "updateAnimationList",
      value: function updateAnimationList() {
        var _this3 = this;

        if (this.room.avatarManager && this.room.avatarManager.xAvatarManager) {
          var e = this.room.skin.animationList;
          if (!e) return;
          e.forEach(function (t) {
            _this3.room.avatarManager.xAvatarManager.updateAnimationLists(t.animations, t.avatarId);
          });
        }
      }
    }, {
      key: "_loadAssetsLowpolyModel",
      value: function () {
        var _loadAssetsLowpolyModel2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee11(e) {
          var _this4 = this;

          var t,
              r,
              n,
              o,
              a,
              s,
              u,
              c,
              h,
              _args11 = arguments;
          return regenerator.wrap(function _callee11$(_context11) {
            while (1) {
              switch (_context11.prev = _context11.next) {
                case 0:
                  t = _args11.length > 1 && _args11[1] !== undefined ? _args11[1] : "";
                  r = [], n = [], o = [];
                  e.lowPolyModels.forEach(function (f) {
                    f.group === "TV" ? n.push({
                      id: "",
                      name: "",
                      thumbnailUrl: "",
                      typeName: AssetTypeName.Model,
                      className: AssetClassName.Tv,
                      modelUrl: f.url
                    }) : f.group === "\u544A\u767D\u5899" ? o.push({
                      id: "",
                      name: "",
                      thumbnailUrl: "",
                      typeName: AssetTypeName.Model,
                      className: AssetClassName.Lpm,
                      modelUrl: f.url
                    }) : r.push({
                      id: "",
                      name: "",
                      thumbnailUrl: "",
                      typeName: AssetTypeName.Model,
                      className: AssetClassName.Lpm,
                      modelUrl: f.url
                    });
                  }), t != "" && t != null && this._deleteAssetsLowpolyModel(t);
                  a = e.skinId;
                  logger$1.info("====> from ", t, "  to  ", a), this._tvs.forEach(function (f) {
                    return f.clean();
                  }), this._tvs = [];
                  s = EFitMode.cover;
                  a == "10048" && (s = EFitMode.contain), Array.isArray(n) && n.forEach(function (f, d) {
                    _this4._tvs.push(new TV("squareTv" + d, f.modelUrl, _this4.room, {
                      fitMode: s
                    }));
                  }), e.breathPointsConfig.forEach( /*#__PURE__*/function () {
                    var _ref3 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee10(f) {
                      var d;
                      return regenerator.wrap(function _callee10$(_context10) {
                        while (1) {
                          switch (_context10.prev = _context10.next) {
                            case 0:
                              _context10.prev = 0;
                              _context10.next = 3;
                              return urlTransformer(f.imageUrl);

                            case 3:
                              d = _context10.sent;
                              _context10.next = 9;
                              break;

                            case 6:
                              _context10.prev = 6;
                              _context10.t0 = _context10["catch"](0);
                              d = f.imageUrl, logger$1.error("urlTransformer error", _context10.t0);

                            case 9:
                              _this4.room.breathPointManager.addBreathPoint({
                                id: f.id,
                                position: f.position,
                                spriteSheet: d,
                                rotation: f.rotation || {
                                  pitch: 0,
                                  yaw: 270,
                                  roll: 0
                                },
                                billboardMode: !0,
                                type: f.type || "no_type",
                                spriteWidthNumber: f.spriteWidthNum || 1,
                                spriteHeightNumber: f.spriteHeightNum || 1,
                                maxVisibleRegion: f.maxVisibleRegion || 150,
                                width: f.width,
                                height: f.height,
                                skinInfo: f.skinId
                              });

                            case 10:
                            case "end":
                              return _context10.stop();
                          }
                        }
                      }, _callee10, null, [[0, 6]]);
                    }));

                    return function (_x11) {
                      return _ref3.apply(this, arguments);
                    };
                  }()), o.forEach(function (f) {
                    _this4.room.sceneManager.decalComponent.addDecal({
                      id: f.id || "gbq",
                      meshPath: f.modelUrl,
                      skinInfo: a
                    });
                  });
                  u = this.room.sceneManager.staticmeshComponent.lowModel_group, c = Array.from(u.keys()).filter(function (f) {
                    return !f.startsWith("region_");
                  }), h = ["airship", "balloon", "ground_feiting", "ground_reqiqiu", "default"];
                  return _context11.abrupt("return", new Promise(function (f, d) {
                    Promise.all(h.map(function (_) {
                      return _this4._parseModelsAndLoad(r, _, a);
                    })).then(function () {
                      var _ = !1;

                      r.forEach(function (v) {
                        v.modelUrl.endsWith("zip") && (_ = !0);
                      }), _ == !1 && _this4.room.sceneManager.staticmeshComponent.deleteLastRegionMesh(), _this4.room.sceneManager.staticmeshComponent.lowModel_group;
                      var g = Array.from(u.keys()).filter(function (v) {
                        return !v.startsWith("region_");
                      }),
                          m = c.filter(function (v) {
                        return g.indexOf(v) < 0;
                      });
                      m.length > 0 && m.forEach(function (v) {
                        _this4.room.sceneManager.staticmeshComponent.deleteMeshesByGroup(v);
                      }), f(!0);
                    }).catch(function (_) {
                      d(_);
                    });
                  }));

                case 9:
                case "end":
                  return _context11.stop();
              }
            }
          }, _callee11, this);
        }));

        function _loadAssetsLowpolyModel(_x10) {
          return _loadAssetsLowpolyModel2.apply(this, arguments);
        }

        return _loadAssetsLowpolyModel;
      }()
    }, {
      key: "_updateSkinAssets",
      value: function () {
        var _updateSkinAssets2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee12(e) {
          var t, r, n;
          return regenerator.wrap(function _callee12$(_context12) {
            while (1) {
              switch (_context12.prev = _context12.next) {
                case 0:
                  t = this.room.lastSkinId;
                  _context12.next = 3;
                  return this.room.getSkin(e);

                case 3:
                  r = _context12.sent;
                  n = this._createAssetList(r);
                  _context12.prev = 5;
                  _context12.next = 8;
                  return this.loadAssets(n, t);

                case 8:
                  this.room.updateCurrentState({
                    versionId: r.versionId,
                    skinId: r.id,
                    skin: r
                  });
                  _context12.next = 16;
                  break;

                case 11:
                  _context12.prev = 11;
                  _context12.t0 = _context12["catch"](5);
                  _context12.next = 15;
                  return this.loadAssets(n, t);

                case 15:
                  this.room.updateCurrentState({
                    versionId: r.versionId,
                    skinId: r.id,
                    skin: r
                  });

                case 16:
                  this.setEnv(r);

                case 17:
                case "end":
                  return _context12.stop();
              }
            }
          }, _callee12, this, [[5, 11]]);
        }));

        function _updateSkinAssets(_x12) {
          return _updateSkinAssets2.apply(this, arguments);
        }

        return _updateSkinAssets;
      }()
    }, {
      key: "_createAssetList",
      value: function _createAssetList(e) {
        var t = [],
            r = [],
            n = [];
        var o = e.models;
        var a = this.room.modelManager.config.preload;
        return this.room.viewMode === "simple" ? a && (o = a.baseUrls.map(function (l) {
          return l.modelUrl = l.url, l;
        })) : this.room.viewMode, ModelManager.findModels(o, AssetTypeName.Effects, AssetClassName.Effects).forEach(function (l) {
          t.push({
            url: l.modelUrl,
            group: l.className,
            name: l.name
          });
        }), ModelManager.findModels(o, AssetTypeName.Model, AssetClassName.Lpm).forEach(function (l) {
          r.push({
            url: l.modelUrl,
            group: l.className
          });
        }), ModelManager.findModels(o, AssetTypeName.Model, AssetClassName.Gbq).forEach(function (l) {
          r.push({
            url: l.modelUrl,
            group: l.className
          });
        }), ModelManager.findModels(o, AssetTypeName.Model, AssetClassName.Tv).forEach(function (l) {
          r.push({
            url: l.modelUrl,
            group: l.className
          });
        }), [].forEach(function (l) {
          l.skinId == e.id && n.push(l);
        }), {
          roomId: this.room.id,
          effects: t,
          lowPolyModels: r,
          breathPointsConfig: n,
          skinId: e.id
        };
      }
    }, {
      key: "registerStats",
      value: function registerStats() {
        var _this5 = this;

        var e = this.room.sceneManager;
        this.room.scene.registerAfterRender(function () {
          var I;
          var t = e.statisticComponent.getInterFrameTimeCounter(),
              r = e.statisticComponent.getDrawCall(),
              n = e.statisticComponent.getActiveFaces(),
              o = e.statisticComponent.getFrameTimeCounter(),
              a = e.statisticComponent.getDrawCallTime(),
              s = e.statisticComponent.getAnimationTime(),
              l = e.statisticComponent.getActiveMeshEvaluationTime(),
              u = e.statisticComponent.getRenderTargetRenderTime(),
              c = e.statisticComponent.getRegisterBeforeRenderTime(),
              h = e.statisticComponent.getRegisterAfterRenderTime(),
              f = e.statisticComponent.getActiveParticles(),
              d = e.statisticComponent.getActiveBones(),
              _ = e.Scene._activeAnimatables.length,
              g = e.statisticComponent.getTotalRootNodes(),
              m = e.Scene.geometries.length,
              v = e.Scene.onBeforeRenderObservable.observers.length,
              y = e.Scene.onAfterRenderObservable.observers.length,
              b = e.statisticComponent.getTotalMeshes(),
              T = e.statisticComponent.getTotalTextures(),
              C = e.statisticComponent.getTotalMaterials(),
              A = e.statisticComponent.getSystemInfo(),
              S = A.resolution,
              P = A.driver;
          A.vender;
          var R = A.version,
              M = A.hardwareScalingLevel,
              x = S + "_" + P + "_" + R + "_" + M;
          _this5.interFrameCircularArray.add(t), _this5.renderTimeCircularArray.add(o), _this5.animationCircularArray.add(s), _this5.meshSelectCircularArray.add(l), _this5.drawCallTimeCircularArray.add(a), _this5.regAfterRenderCircularArray.add(h), _this5.regBeforeRenderCircularArray.add(c), _this5.renderTargetCircularArray.add(u), _this5.drawCallCntCircularArray.add(r), _this5.renderCnt += 1, _this5.renderCnt % 25 == 0 && ((I = _this5.room.stats) == null || I.assign({
            renderFrameTime: _this5.renderTimeCircularArray.getAvg(),
            maxRenderFrameTime: _this5.renderTimeCircularArray.getMax(),
            interFrameTime: _this5.interFrameCircularArray.getAvg(),
            animationTime: _this5.animationCircularArray.getAvg(),
            meshSelectTime: _this5.meshSelectCircularArray.getAvg(),
            drawcallTime: _this5.drawCallTimeCircularArray.getAvg(),
            idleTime: _this5._idleTime,
            registerBeforeRenderTime: _this5.regBeforeRenderCircularArray.getAvg(),
            registerAfterRenderTime: _this5.regAfterRenderCircularArray.getAvg(),
            renderTargetRenderTime: _this5.renderTargetCircularArray.getAvg(),
            fps: (1e3 / (_this5.renderTimeCircularArray.getAvg() + _this5.interFrameCircularArray.getAvg())).toFixed(2),
            drawcall: _this5.drawCallCntCircularArray.getAvg(),
            triangle: n.toString(),
            engineSloppyCnt: _this5.engineSloppyCnt,
            maxInterFrameTime: _this5.interFrameCircularArray.getMax(),
            maxDrawcallTime: _this5.drawCallTimeCircularArray.getMax(),
            maxMeshSelectTime: _this5.meshSelectCircularArray.getMax(),
            maxAnimationTime: _this5.animationCircularArray.getMax(),
            maxRegisterBeforeRenderTime: _this5.regBeforeRenderCircularArray.getMax(),
            maxRegisterAfterRenderTime: _this5.regAfterRenderCircularArray.getMax(),
            maxRenderTargetRenderTime: _this5.renderTargetCircularArray.getMax(),
            activeParticles: f,
            activeBones: d,
            activeAnimation: _,
            totalMeshes: b,
            totalRootNodes: g,
            totalGeometries: m,
            totalTextures: T,
            totalMaterials: C,
            registerBeforeCount: v,
            registerAfterCount: y,
            hardwareInfo: x
          }));
        });
      }
    }, {
      key: "updateBillboard",
      value: function () {
        var _updateBillboard = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee13() {
          var e, r, n, o, a, s;
          return regenerator.wrap(function _callee13$(_context13) {
            while (1) {
              switch (_context13.prev = _context13.next) {
                case 0:
                  e = this.room.options.skinId;
                  _context13.next = 3;
                  return this.room.modelManager.findAssetList(e);

                case 3:
                  r = _context13.sent.filter(function (a) {
                    return a.typeName === AssetTypeName.Textures && a.className === AssetClassName.SayBubble;
                  });
                  n = ["bubble01", "bubble02", "bubble03"];
                  o = ["bubble01_npc", "bubble02_npc", "bubble03_npc"];

                  if (r.length) {
                    a = r.filter(function (l) {
                      return n.includes(l.name);
                    }).map(function (l) {
                      return l.url;
                    }), s = r.filter(function (l) {
                      return o.includes(l.name);
                    }).map(function (l) {
                      return l.url;
                    });
                    a.length && (XBillboardManager$1.userBubbleUrls = a), s.length && (XBillboardManager$1.npcBubbleUrls = s);
                  }

                case 7:
                case "end":
                  return _context13.stop();
              }
            }
          }, _callee13, this);
        }));

        function updateBillboard() {
          return _updateBillboard.apply(this, arguments);
        }

        return updateBillboard;
      }()
    }]);

    return EngineProxy;
  }();

  function _createSuper$2(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$2() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
  var LongPressMesh = [EMeshType.XAvatar];

  var StaticMeshEvent = /*#__PURE__*/function (_EventEmitter) {
    _inherits(StaticMeshEvent, _EventEmitter);

    var _super = _createSuper$2(StaticMeshEvent);

    function StaticMeshEvent(e) {
      var _this;

      _classCallCheck(this, StaticMeshEvent);

      _this = _super.call(this);
      E(_assertThisInitialized(_this), "scene");
      E(_assertThisInitialized(_this), "_staringPointerTime", -1);
      E(_assertThisInitialized(_this), "_pickedMeshID", "0");
      E(_assertThisInitialized(_this), "_pointerDownTime", -1);
      E(_assertThisInitialized(_this), "_currentPickPoint");
      E(_assertThisInitialized(_this), "_longPressDelay", 500);
      E(_assertThisInitialized(_this), "_pointerTapDelay", 200);
      E(_assertThisInitialized(_this), "_pickedMeshType");
      E(_assertThisInitialized(_this), "registerEvent", function () {
        _this.scene.onPrePointerObservable.add(_this.onDown, BABYLON.PointerEventTypes.POINTERDOWN), _this.scene.onPrePointerObservable.add(_this.onUp, BABYLON.PointerEventTypes.POINTERUP), _this.scene.onPrePointerObservable.add(_this.onDoubleTap, BABYLON.PointerEventTypes.POINTERDOUBLETAP), _this.scene.onDispose = function () {
          _this.scene.onPrePointerObservable.removeCallback(_this.onUp), _this.scene.onPrePointerObservable.removeCallback(_this.onDown), _this.scene.onPrePointerObservable.removeCallback(_this.onDoubleTap);
        };
      });
      E(_assertThisInitialized(_this), "onUp", function () {
        if (Date.now() - _this._pointerDownTime < _this._pointerTapDelay && !_this.scene._inputManager._isPointerSwiping()) {
          _this.scene._inputManager._totalPointersPressed = 0;
          var _e = _this._currentPickPoint;
          _e != null && LongPressMesh.indexOf(_e.type) == -1 && _this.scene._inputManager._totalPointersPressed == 0 && _this.emit("pointTap", _e), _e != null && LongPressMesh.indexOf(_e.type) != -1 && (_e = _this.onPointerTap(function (t) {
            return t.isPickable && LongPressMesh.indexOf(t.xtype) == -1;
          }), _e != null && _this.emit("pointTap", _e));
        }
      });
      E(_assertThisInitialized(_this), "onDown", function () {
        var e = _this.onPointerTap(function (t) {
          return t.isPickable;
        });

        _this._currentPickPoint = e, _this._pointerDownTime = Date.now(), e != null && LongPressMesh.indexOf(e.type) != -1 && (_this._staringPointerTime = Date.now(), _this._pickedMeshID = e.id, _this._pickedMeshType = e.type, window.setTimeout(function () {
          e = _this.onPointerTap(function (t) {
            return t.isPickable && t.xtype == _this._pickedMeshType && t.xid == _this._pickedMeshID;
          }), e !== null && Date.now() - _this._staringPointerTime > _this._longPressDelay && !_this.scene._inputManager._isPointerSwiping() && _this.scene._inputManager._totalPointersPressed !== 0 && (_this._staringPointerTime = 0, _this.emit("longPress", e));
        }, _this._longPressDelay));
      });
      E(_assertThisInitialized(_this), "onDoubleTap", function () {
        var e = _this.onPointerTap(void 0);

        e != null && _this.emit("pointDoubleTap", e);
      });
      _this.manager = e, _this.scene = e.Scene, _this.registerEvent(), _this._currentPickPoint = null, _this._pickedMeshType = null;
      return _this;
    }

    _createClass(StaticMeshEvent, [{
      key: "onPointerTap",
      value: function onPointerTap(e) {
        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
        var n, o;
        var r = new BABYLON.PickingInfo();

        if (t) {
          var a = this.scene.multiPick(this.scene.pointerX, this.scene.pointerY, e, void 0, void 0);
          a && a.length > 1 ? r = a[1] : a && (r = a[0]);
        } else r = this.scene.pick(this.scene.pointerX, this.scene.pointerY, e, !1, null);

        if (r.hit) {
          var _a = (n = r == null ? void 0 : r.pickedPoint) == null ? void 0 : n.asArray();

          if (_a) {
            var _a2 = _slicedToArray(_a, 3),
                s = _a2[0],
                l = _a2[1],
                u = _a2[2],
                c = xversePosition2Ue4({
              x: s,
              y: l,
              z: u
            });

            return {
              name: (o = r.pickedMesh) == null ? void 0 : o.name,
              type: r.pickedMesh.xtype,
              id: r.pickedMesh.xid,
              point: c
            };
          }
        }

        return null;
      }
    }]);

    return StaticMeshEvent;
  }(EventEmitter);

  var RotationEvent = /*#__PURE__*/function () {
    function RotationEvent(e) {
      var _this = this;

      _classCallCheck(this, RotationEvent);

      E(this, "touchStartX");
      E(this, "touchStartY");
      E(this, "handelResize");
      E(this, "_room");
      E(this, "_canvas");
      E(this, "handleTouchStart", function (e) {
        var t = e.touches[0];
        _this.touchStartX = t.pageX, _this.touchStartY = t.pageY, _this._room.emit("touchStart", {
          event: e
        });
      });
      E(this, "handleMouseDown", function (e) {
        _this.touchStartX = e.pageX, _this.touchStartY = e.pageY;
      });
      E(this, "handleMouseMove", function (e) {
        if (!_this.touchStartX || !_this.touchStartY) return;
        var t = e.pageX,
            r = e.pageY,
            n = t - _this.touchStartX,
            o = r - _this.touchStartY,
            a = _this._room.options.canvas.offsetHeight,
            s = _this._room.options.canvas.offsetWidth;
        var l = 2 * o / a,
            u = 2 * n / s;
        l > 1 && (l = 1), u > 1 && (u = 1), _this._room.actionsHandler.rotate({
          pitch: l,
          yaw: u
        }), _this.touchStartX = t, _this.touchStartY = r;
      });
      E(this, "handleMouseUp", function () {
        _this.touchStartX = void 0, _this.touchStartY = void 0;
      });
      E(this, "handleTouchMove", function (e) {
        if (!_this.touchStartX || !_this.touchStartY) return;
        var t = e.touches[0],
            r = t.pageX,
            n = t.pageY,
            o = r - _this.touchStartX,
            a = n - _this.touchStartY,
            s = _this._room.options.canvas.offsetHeight,
            l = _this._room.options.canvas.offsetWidth;
        var u = 2 * a / s,
            c = 2 * o / l;
        u > 1 && (u = 1), c > 1 && (c = 1), _this._room.actionsHandler.rotate({
          pitch: u,
          yaw: c
        }), _this.touchStartX = r, _this.touchStartY = n, _this._room.emit("touchMove", {
          pitch: u,
          yaw: c,
          event: e
        });
      });
      E(this, "handleTouchEnd", function (e) {
        _this._room.emit("touchEnd", {
          event: e
        });
      });
      this._room = e, this._canvas = e.canvas, this.handelResize = this.reiszeChange();
    }

    _createClass(RotationEvent, [{
      key: "init",
      value: function init() {
        this._canvas.addEventListener("touchstart", this.handleTouchStart), this._canvas.addEventListener("touchmove", this.handleTouchMove), this._canvas.addEventListener("touchend", this.handleTouchEnd), this._room.scene.preventDefaultOnPointerDown = !1, this._room.scene.preventDefaultOnPointerUp = !1, this._canvas.addEventListener("mousedown", this.handleMouseDown), this._canvas.addEventListener("mousemove", this.handleMouseMove), this._canvas.addEventListener("mouseup", this.handleMouseUp);
      }
    }, {
      key: "clear",
      value: function clear() {
        this._canvas.removeEventListener("touchstart", this.handleTouchStart), this._canvas.removeEventListener("touchmove", this.handleTouchMove), this._canvas.removeEventListener("touchend", this.handleTouchEnd), this._canvas.removeEventListener("mousedown", this.handleMouseDown), this._canvas.removeEventListener("mousemove", this.handleMouseMove), this._canvas.removeEventListener("mouseup", this.handleMouseUp);
      }
    }, {
      key: "reiszeChange",
      value: function reiszeChange() {
        window.addEventListener("resize", function () {});
      }
    }]);

    return RotationEvent;
  }();

  var EventsController = /*#__PURE__*/function () {
    function EventsController(e) {
      var _this = this;

      _classCallCheck(this, EventsController);

      E(this, "staticmeshEvent");
      E(this, "rotationEvent");
      E(this, "resize", function () {
        _this.room.sceneManager.cameraComponent.cameraFovChange(_this.room.sceneManager.yuvInfo);
      });
      E(this, "clickEvent", function (e) {
        var t = e.point,
            r = e.name,
            n = e.type,
            o = e.id;
        logger$1.debug("pointEvent", e), _this.room.proxyEvents("pointTap", {
          point: t,
          meshName: r,
          type: n,
          id: o
        }), _this.room.proxyEvents("_coreClick", e);
      });
      E(this, "longPressEvent", function (e) {
        _this.room.proxyEvents("_corePress", e);
      });
      E(this, "handleActionResponseTimeout", function (_ref) {
        var e = _ref.error,
            t = _ref.event;

        _this.room.proxyEvents("actionResponseTimeout", {
          error: e,
          event: t
        });
      });
      E(this, "handleNetworkStateChange", function (e) {
        var t = e.state,
            r = e.count;
        t == "reconnecting" ? _this.room.proxyEvents("reconnecting", {
          count: r || 1
        }) : t === "reconnected" ? (_this.room.networkController.rtcp.workers.reset(), _this.room.proxyEvents("reconnected"), _this.room.afterReconnected()) : t === "disconnected" && _this.room.proxyEvents("disconnected");
      });
      this.room = e, this.staticmeshEvent = new StaticMeshEvent(this.room.sceneManager), this.rotationEvent = new RotationEvent(e);
    }

    _createClass(EventsController, [{
      key: "bindEvents",
      value: function bindEvents() {
        window.addEventListener("orientationchange" in window ? "orientationchange" : "resize", this.resize), this.staticmeshEvent.on("pointTap", this.clickEvent), this.staticmeshEvent.on("longPress", this.longPressEvent), this.rotationEvent.init(), eventsManager.on("actionResponseTimeout", this.handleActionResponseTimeout), this.room.networkController.on("stateChanged", this.handleNetworkStateChange);
      }
    }, {
      key: "clearEvents",
      value: function clearEvents() {
        window.removeEventListener("orientationchange" in window ? "orientationchange" : "resize", this.resize), this.staticmeshEvent.off("pointTap", this.clickEvent), this.staticmeshEvent.off("longPress", this.longPressEvent), eventsManager.off("actionResponseTimeout", this.handleActionResponseTimeout), this.room.networkController.off("stateChanged", this.handleNetworkStateChange), this.rotationEvent.clear();
      }
    }]);

    return EventsController;
  }();

  var Panorama = /*#__PURE__*/function () {
    function Panorama(e) {
      var _this = this;

      _classCallCheck(this, Panorama);

      E(this, "_actived", !1);
      E(this, "handleReceivePanorama", /*#__PURE__*/function () {
        var _ref = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e, t) {
          var r, n, _this$room$currentSta, o, a, s, _ref2, l;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  logger$1.warn("handle panorama", e.uuid, e.pos, e.finished);
                  r = {
                    data: e.data,
                    pose: {
                      position: e.pos
                    }
                  }, n = _this.room.sceneManager;

                  _this.room.networkController.rtcp.workers.changePanoMode(!0);

                  _context.next = 5;
                  return n.materialComponent.changePanoImg(0, r);

                case 5:
                  if (!e.finished) {
                    _context.next = 23;
                    break;
                  }

                  _context.next = 8;
                  return n.changePanoShaderForLowModel(0);

                case 8:
                  _this.room.isPano = !0;
                  _this._actived = !0;

                  if (!t) {
                    _context.next = 14;
                    break;
                  }

                  _this.room.sceneManager.cameraComponent.changeToFirstPersonView({
                    position: t.position,
                    rotation: t.angle
                  });

                  _context.next = 23;
                  break;

                case 14:
                  _this$room$currentSta = _this.room.currentState, o = _this$room$currentSta.skinId, a = _this$room$currentSta.pathName;

                  if (!(!o || !a)) {
                    _context.next = 17;
                    break;
                  }

                  return _context.abrupt("return");

                case 17:
                  _context.next = 19;
                  return _this.room.modelManager.findRoute(o, a);

                case 19:
                  s = _context.sent;
                  _ref2 = util.getRandomItem(s.birthPointList) || {};
                  l = _ref2.camera;
                  l && _this.room.sceneManager.cameraComponent.changeToFirstPersonView(le(oe({}, l), {
                    rotation: l.angle
                  }));

                case 23:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee);
        }));

        return function (_x, _x2) {
          return _ref.apply(this, arguments);
        };
      }());
      this.room = e;
    }

    _createClass(Panorama, [{
      key: "actived",
      get: function get() {
        return this._actived;
      }
    }, {
      key: "bindListener",
      value: function bindListener(e) {
        var _this2 = this;

        this.room.networkController.rtcp.workers.registerFunction("panorama", function (r) {
          logger$1.warn("receive panorama", r.uuid, r.pos), r.uuid && eventsManager.remove(r.uuid, Codes.Success, r, !0), _this2.room.isFirstDataUsed || (_this2.room.isFirstDataUsed = !0, _this2.handleReceivePanorama(r, _this2.room.options.camera).then(e));
        });
      }
    }, {
      key: "access",
      value: function access(e, t, r) {
        var _this3 = this;

        var n = e.camera,
            o = e.player,
            a = e.attitude,
            s = e.areaName,
            l = e.pathName,
            u = e.tag;
        return this.room.actionsHandler.requestPanorama({
          camera: n,
          player: o,
          attitude: a,
          areaName: s,
          pathName: l,
          tag: u
        }, t, r).then(function (c) {
          return _this3.handleReceivePanorama(c, o);
        });
      }
    }, {
      key: "exit",
      value: function exit(e) {
        var _this4 = this;

        var t = e.camera,
            r = e.player,
            n = e.attitude,
            o = e.areaName,
            a = e.pathName;
        return this.room.networkController.rtcp.workers.changePanoMode(!1), this.room.actionsHandler.changeRotationRenderType({
          renderType: RenderType.RotationVideo,
          player: r,
          camera: t,
          attitude: n,
          areaName: o,
          pathName: a
        }).then(function () {
          return _this4.handleExitPanorama();
        }).catch(function (s) {
          return _this4.room.networkController.rtcp.workers.changePanoMode(!0), Promise.reject(s);
        });
      }
    }, {
      key: "handleExitPanorama",
      value: function handleExitPanorama() {
        var e, t, r, n, o, a;
        this.room.isPano = !1, this._actived = !1, (n = (e = this.room.sceneManager) == null ? void 0 : e.cameraComponent) == null || n.forceChangeSavedCameraPose({
          position: (t = this.room._currentClickingState) == null ? void 0 : t.camera.position,
          rotation: (r = this.room._currentClickingState) == null ? void 0 : r.camera.angle
        }), this.room.sceneManager.changeVideoShaderForLowModel(), (a = (o = this.room.sceneManager) == null ? void 0 : o.cameraComponent) == null || a.changeToThirdPersonView();
      }
    }]);

    return Panorama;
  }();

  var BREATH_POINT_TYPE = "debugBreathPoint",
      TAP_BREATH_POINT_TYPE = "debugTapBreathPoint",
      DEFAULT_SEARCH_RANGE = 1e3;

  var Debug = /*#__PURE__*/function () {
    function Debug(e) {
      _classCallCheck(this, Debug);

      E(this, "isShowNearbyBreathPoints", !1);
      E(this, "isShowTapBreathPoints", !1);
      E(this, "isSceneShading", !0);
      E(this, "searchRange", DEFAULT_SEARCH_RANGE);
      E(this, "nearbyBreathPointListening", !1);
      E(this, "tapBreathPointListening", !1);
      E(this, "dumpStreamTimer", 0);
      this.room = e;
    }

    _createClass(Debug, [{
      key: "toggleStats",
      value: function toggleStats() {
        return this.room.stats.isShow ? this.room.stats.hide() : this.room.stats.show();
      }
    }, {
      key: "toggleNearbyBreathPoint",
      value: function toggleNearbyBreathPoint() {
        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_SEARCH_RANGE;
        this.searchRange = e, this.isShowNearbyBreathPoints = !this.isShowNearbyBreathPoints, this.isShowNearbyBreathPoints ? (this.getPointsAndRender(), this.setupNearbyBreathPointListener()) : this.room.breathPointManager.clearBreathPoints(BREATH_POINT_TYPE);
      }
    }, {
      key: "toggleTapBreathPoint",
      value: function toggleTapBreathPoint() {
        this.isShowTapBreathPoints = !this.isShowTapBreathPoints, this.isShowTapBreathPoints ? this.setupTapPointListener() : this.room.breathPointManager.clearBreathPoints(TAP_BREATH_POINT_TYPE);
      }
    }, {
      key: "dumpStream",
      value: function dumpStream(e) {
        var _this = this;

        var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10 * 1e3;
        if (this.dumpStreamTimer) throw new Error("dumpStream running");
        this.room.networkController.rtcp.workers.saveframe = !0, this.dumpStreamTimer = window.setTimeout(function () {
          _this.room.networkController.rtcp.workers.SaveMediaStream = !0, _this.dumpStreamTimer = 0, e && e();
        }, t);
      }
    }, {
      key: "toggleSceneshading",
      value: function toggleSceneshading() {
        this.isSceneShading = !this.isSceneShading, this.isSceneShading ? this.room.sceneManager.changeVideoShaderForLowModel() : this.room.sceneManager.changeDefaultShaderForLowModel();
      }
    }, {
      key: "setupTapPointListener",
      value: function setupTapPointListener() {
        var _this2 = this;

        this.tapBreathPointListening || (this.tapBreathPointListening = !0, this.room.on("_coreClick", function (_ref) {
          var e = _ref.point;
          _this2.isShowTapBreathPoints && _this2.renderTapBreathPoint({
            id: "tapToint",
            position: e
          });
        }));
      }
    }, {
      key: "renderTapBreathPoint",
      value: function renderTapBreathPoint(_ref2) {
        var e = _ref2.position,
            t = _ref2.id;
        var r;

        if (r = this.room.breathPointManager.breathPoints.get(t)) {
          r.position = e;
          return;
        }

        this.room.breathPointManager.addBreathPoint({
          id: t,
          position: e,
          type: TAP_BREATH_POINT_TYPE,
          size: .8,
          forceLeaveGround: !0,
          billboardMode: !0,
          rotation: Math.abs(e.z) < 20 ? {
            pitch: 90,
            yaw: 0,
            roll: 0
          } : {
            pitch: 0,
            yaw: 270,
            roll: 0
          }
        });
      }
    }, {
      key: "setupNearbyBreathPointListener",
      value: function setupNearbyBreathPointListener() {
        var _this3 = this;

        var e;
        this.nearbyBreathPointListening || (this.nearbyBreathPointListening = !0, (e = this.room._userAvatar) == null || e.on("stopMoving", function () {
          _this3.isShowNearbyBreathPoints && _this3.getPointsAndRender();
        }));
      }
    }, {
      key: "getPointsAndRender",
      value: function () {
        var _getPointsAndRender = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
          var _this4 = this;

          var r, n, e, t;
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  e = this.searchRange;
                  _context.t1 = (r = this.room._userAvatar) == null ? void 0 : r.position;

                  if (!_context.t1) {
                    _context.next = 6;
                    break;
                  }

                  _context.next = 5;
                  return this.getNeighborPoints({
                    point: (n = this.room._userAvatar) == null ? void 0 : n.position,
                    containSelf: !0,
                    searchRange: e
                  });

                case 5:
                  _context.t1 = _context.sent;

                case 6:
                  _context.t0 = _context.t1;

                  if (_context.t0) {
                    _context.next = 9;
                    break;
                  }

                  _context.t0 = [];

                case 9:
                  t = _context.t0;
                  this.room.breathPointManager.breathPoints.forEach(function (o) {
                    !!t.find(function (s) {
                      return JSON.stringify(s) === o._id;
                    }) || _this4.room.breathPointManager.clearBreathPoints(o._id);
                  }), t.forEach(function (o) {
                    var a = JSON.stringify(o);
                    _this4.room.breathPointManager.breathPoints.get(a) || _this4.room.breathPointManager.addBreathPoint({
                      id: a,
                      position: o,
                      type: BREATH_POINT_TYPE,
                      rotation: {
                        pitch: 90,
                        yaw: 0,
                        roll: 0
                      },
                      forceLeaveGround: !0
                    });
                  });

                case 11:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function getPointsAndRender() {
          return _getPointsAndRender.apply(this, arguments);
        }

        return getPointsAndRender;
      }()
    }, {
      key: "getNeighborPoints",
      value: function getNeighborPoints(e) {
        var t = e.point,
            _e$containSelf = e.containSelf,
            r = _e$containSelf === void 0 ? !1 : _e$containSelf,
            _e$searchRange = e.searchRange,
            n = _e$searchRange === void 0 ? 500 : _e$searchRange;
        return this.room.actionsHandler.getNeighborPoints({
          point: t,
          containSelf: r,
          searchRange: n
        });
      }
    }]);

    return Debug;
  }();

  function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct$1() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var Xverse_Room = /*#__PURE__*/function (_EventEmitter) {
    _inherits(Xverse_Room, _EventEmitter);

    var _super = _createSuper$1(Xverse_Room);

    function Xverse_Room(e) {
      var _this;

      _classCallCheck(this, Xverse_Room);

      _this = _super.call(this);
      E(_assertThisInitialized(_this), "disableAutoTurn", !1);
      E(_assertThisInitialized(_this), "options");
      E(_assertThisInitialized(_this), "_currentNetworkOptions");
      E(_assertThisInitialized(_this), "lastSkinId");
      E(_assertThisInitialized(_this), "debug");
      E(_assertThisInitialized(_this), "isFirstDataUsed", !1);
      E(_assertThisInitialized(_this), "userId", null);
      E(_assertThisInitialized(_this), "pathManager", new PathManager());
      E(_assertThisInitialized(_this), "networkController");
      E(_assertThisInitialized(_this), "_startTime", Date.now());
      E(_assertThisInitialized(_this), "canvas");
      E(_assertThisInitialized(_this), "modelManager");
      E(_assertThisInitialized(_this), "eventsController");
      E(_assertThisInitialized(_this), "panorama");
      E(_assertThisInitialized(_this), "engineProxy");
      E(_assertThisInitialized(_this), "_id");
      E(_assertThisInitialized(_this), "skinList", []);
      E(_assertThisInitialized(_this), "isHost", !1);
      E(_assertThisInitialized(_this), "avatarManager", new XverseAvatarManager(_assertThisInitialized(_this)));
      E(_assertThisInitialized(_this), "effectManager", new XverseEffectManager(_assertThisInitialized(_this)));
      E(_assertThisInitialized(_this), "sceneManager");
      E(_assertThisInitialized(_this), "scene");
      E(_assertThisInitialized(_this), "breathPointManager");
      E(_assertThisInitialized(_this), "_currentState");
      E(_assertThisInitialized(_this), "joined", !1);
      E(_assertThisInitialized(_this), "disableRotate", !1);
      E(_assertThisInitialized(_this), "isPano", !1);
      E(_assertThisInitialized(_this), "movingByClick", !0);
      E(_assertThisInitialized(_this), "camera", new Camera(_assertThisInitialized(_this)));
      E(_assertThisInitialized(_this), "stats", new Stats(_assertThisInitialized(_this)));
      E(_assertThisInitialized(_this), "isUpdatedRawYUVData", !1);
      E(_assertThisInitialized(_this), "actionsHandler", new ActionsHandler(_assertThisInitialized(_this)));
      E(_assertThisInitialized(_this), "_currentClickingState", null);
      E(_assertThisInitialized(_this), "signal", new Signal(_assertThisInitialized(_this)));
      E(_assertThisInitialized(_this), "firstFrameTimestamp");
      E(_assertThisInitialized(_this), "receiveRtcData", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
        var e, t, r, n;
        return regenerator.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                logger$1.info("Invoke receiveRtcData");
                e = !1, t = !1, r = !1, n = !1;
                return _context.abrupt("return", _this.viewMode === "serverless" ? (logger$1.warn("set view mode to serverless"), _this.setViewMode("observer").then(function () {
                  return _assertThisInitialized(_this);
                }, function () {
                  return _assertThisInitialized(_this);
                })) : new Promise(function (o) {
                  var a = _this.networkController.rtcp.workers;
                  a.registerFunction("signal", function (s) {
                    _this.signal.handleSignal(s);
                  }), a.registerFunction("stream", function (s) {
                    var l;

                    if (_this.emit("streamTimestamp", {
                      timestamp: Date.now()
                    }), t || (t = !0, logger$1.info("Invoke stream event")), s.stream) {
                      r || (r = !0, logger$1.info("Invoke updateRawYUVData")), _this.isUpdatedRawYUVData = !1;
                      var u = (l = _this._currentState.skin) == null ? void 0 : l.fov;
                      _this.sceneManager.materialComponent.updateRawYUVData(s.stream, s.width, s.height, u), _this.isUpdatedRawYUVData = !0;
                    }

                    e || (logger$1.info("Invoke isAfterRenderRegistered"), e = !0, _this.scene.registerAfterRender(function () {
                      _this.engineProxy.frameRenderNumber >= 2 && (n || (n = !0, logger$1.info("Invoke registerAfterRender")), _this.isFirstDataUsed || (logger$1.info("Invoke isStreamAvailable"), _this.isFirstDataUsed = !0, _this.firstFrameTimestamp = Date.now(), o(_assertThisInitialized(_this)), _this.afterJoinRoom()));
                    }));
                  }), _this.panorama.bindListener(function () {
                    o(_assertThisInitialized(_this)), _this.afterJoinRoom();
                  }), a.registerFunction("reconnectedFrame", function () {}), logger$1.info("Invoke decoderWorker.postMessage"), a.decoderWorker.postMessage({
                    t: 5
                  });
                }));

              case 3:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      })));
      E(_assertThisInitialized(_this), "moveToExtra", "");
      _this.options = e, _this.options.wsServerUrl || (_this.options.wsServerUrl = SERVER_URLS.DEV), _this.modelManager = ModelManager.getInstance(e.appId, e.releaseId), _this.updateReporter();
      var n = e;
          n.canvas;
          var r = Oe(n, ["canvas"]);
      logger$1.infoAndReportMeasurement({
        metric: "startJoinRoomAt",
        startTime: Date.now(),
        group: "joinRoom",
        extra: r,
        value: 0
      });
      return _this;
    }

    _createClass(Xverse_Room, [{
      key: "currentNetworkOptions",
      get: function get() {
        return this._currentNetworkOptions;
      }
    }, {
      key: "viewMode",
      get: function get() {
        var e;
        return ((e = this._currentState) == null ? void 0 : e.viewMode) || "full";
      }
    }, {
      key: "id",
      get: function get() {
        return this._id;
      }
    }, {
      key: "skinId",
      get: function get() {
        return this._currentState.skinId;
      }
    }, {
      key: "skin",
      get: function get() {
        return this._currentState.skin;
      }
    }, {
      key: "sessionId",
      get: function get() {
        return this.currentNetworkOptions.sessionId;
      }
    }, {
      key: "pictureQualityLevel",
      get: function get() {
        return this.currentState.pictureQualityLevel;
      }
    }, {
      key: "avatars",
      get: function get() {
        return Array.from(this.avatarManager.avatars.values());
      }
    }, {
      key: "currentState",
      get: function get() {
        var e;
        return le(oe({}, this._currentState), {
          state: (e = this.networkController) == null ? void 0 : e._state
        });
      }
    }, {
      key: "_userAvatar",
      get: function get() {
        var _this2 = this;

        return this.avatars.find(function (e) {
          return e.userId === _this2.userId;
        });
      }
    }, {
      key: "tvs",
      get: function get() {
        return this.engineProxy._tvs;
      }
    }, {
      key: "tv",
      get: function get() {
        return this.tvs[0];
      }
    }, {
      key: "currentClickingState",
      get: function get() {
        return this._currentClickingState;
      }
    }, {
      key: "afterJoinRoomHook",
      value: function afterJoinRoomHook() {}
    }, {
      key: "beforeJoinRoomResolveHook",
      value: function beforeJoinRoomResolveHook() {}
    }, {
      key: "afterReconnectedHook",
      value: function afterReconnectedHook() {}
    }, {
      key: "handleSignalHook",
      value: function handleSignalHook(e) {}
    }, {
      key: "skinChangedHook",
      value: function skinChangedHook() {}
    }, {
      key: "beforeStartGameHook",
      value: function () {
        var _beforeStartGameHook = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(e) {
          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2);
        }));

        function beforeStartGameHook(_x) {
          return _beforeStartGameHook.apply(this, arguments);
        }

        return beforeStartGameHook;
      }()
    }, {
      key: "loadAssetsHook",
      value: function loadAssetsHook() {}
    }, {
      key: "afterUserAvatarLoadedHook",
      value: function afterUserAvatarLoadedHook() {}
    }, {
      key: "audienceViewModeHook",
      value: function audienceViewModeHook() {}
    }, {
      key: "setViewModeToObserver",
      value: function setViewModeToObserver() {}
    }, {
      key: "handleVehicleHook",
      value: function handleVehicleHook(e) {}
    }, {
      key: "updateReporter",
      value: function updateReporter() {
        var _this$options = this.options,
            e = _this$options.avatarId,
            t = _this$options.skinId,
            r = _this$options.userId,
            n = _this$options.roomId,
            o = _this$options.role,
            a = _this$options.appId,
            s = _this$options.wsServerUrl;
        reporter$1.updateHeader({
          userId: r
        }), reporter$1.updateBody({
          roomId: n,
          role: o,
          skinId: t,
          avatarId: e,
          appId: a,
          wsServerUrl: s
        });
      }
    }, {
      key: "initRoom",
      value: function () {
        var _initRoom2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3() {
          var _this$options$timeout, e;

          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  _this$options$timeout = this.options.timeout, e = _this$options$timeout === void 0 ? DEFAULT_JOINROOM_TIMEOUT : _this$options$timeout;

                  if (!util.isSupported()) {
                    _context3.next = 5;
                    break;
                  }

                  return _context3.abrupt("return", this._initRoom()._timeout(e, new TimeoutError("initRoom timeout")));

                case 5:
                  return _context3.abrupt("return", Promise.reject(new UnsupportedError()));

                case 6:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, this);
        }));

        function initRoom() {
          return _initRoom2.apply(this, arguments);
        }

        return initRoom;
      }()
    }, {
      key: "_initRoom",
      value: function () {
        var _initRoom3 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4() {
          var e, _this$options2, t, r, n, o, a, s, l, u, c, _this$options2$isAllS, h, f, d, _, g, m, v, _this$options2$firend, y, _this$options2$syncBy, b, T, _this$options2$attitu, C, A, _this$options2$viewMo, S, P, R, M, _this$options2$hasAva, x, _this$options2$syncTo, I, _this$options2$priori, w, _this$options2$remove, O, D, F, V, N;

          return regenerator.wrap(function _callee4$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  e = this.validateOptions(this.options);

                  if (!e) {
                    _context4.next = 3;
                    break;
                  }

                  return _context4.abrupt("return", (logger$1.error("initRoom param error", e), Promise.reject(e)));

                case 3:
                  _this$options2 = this.options, t = _this$options2.canvas, r = _this$options2.avatarId, n = _this$options2.skinId, o = _this$options2.userId, a = _this$options2.wsServerUrl, s = _this$options2.role, l = _this$options2.token, u = _this$options2.pageSession, c = _this$options2.rotationRenderType, _this$options2$isAllS = _this$options2.isAllSync, h = _this$options2$isAllS === void 0 ? !1 : _this$options2$isAllS, f = _this$options2.appId, d = _this$options2.camera, _ = _this$options2.player, g = _this$options2.avatarComponents, m = _this$options2.nickname, v = _this$options2.avatarScale, _this$options2$firend = _this$options2.firends, y = _this$options2$firend === void 0 ? [] : _this$options2$firend, _this$options2$syncBy = _this$options2.syncByEvent, b = _this$options2$syncBy === void 0 ? !1 : _this$options2$syncBy, T = _this$options2.areaName, _this$options2$attitu = _this$options2.attitude, C = _this$options2$attitu === void 0 ? MotionType.Walk : _this$options2$attitu, A = _this$options2.pathName, _this$options2$viewMo = _this$options2.viewMode, S = _this$options2$viewMo === void 0 ? "full" : _this$options2$viewMo, P = _this$options2.person, R = _this$options2.roomId, M = _this$options2.roomTypeId, _this$options2$hasAva = _this$options2.hasAvatar, x = _this$options2$hasAva === void 0 ? !1 : _this$options2$hasAva, _this$options2$syncTo = _this$options2.syncToOthers, I = _this$options2$syncTo === void 0 ? !1 : _this$options2$syncTo, _this$options2$priori = _this$options2.prioritySync, w = _this$options2$priori === void 0 ? !1 : _this$options2$priori, _this$options2$remove = _this$options2.removeWhenDisconnected, O = _this$options2$remove === void 0 ? !0 : _this$options2$remove, D = _this$options2.extra;
                  this.setCurrentNetworkOptions({
                    avatarId: r,
                    skinId: n,
                    roomId: R,
                    userId: o,
                    wsServerUrl: a,
                    role: s,
                    token: l,
                    pageSession: u,
                    rotationRenderType: c,
                    isAllSync: h,
                    appId: f,
                    camera: d,
                    player: _,
                    avatarComponents: g,
                    nickname: m,
                    avatarScale: v,
                    firends: y,
                    syncByEvent: b,
                    areaName: T,
                    attitude: C,
                    pathName: A,
                    person: P,
                    roomTypeId: M,
                    hasAvatar: x,
                    syncToOthers: I,
                    prioritySync: w,
                    extra: D,
                    removeWhenDisconnected: O
                  });
                  this.userId = o;
                  this.canvas = t;
                  T && (this.pathManager.currentArea = T);
                  this.networkController = new NetworkController(this);
                  this.setCurrentState({
                    areaName: T,
                    pathName: A,
                    attitude: C,
                    speed: 0,
                    viewMode: S,
                    state: this.networkController._state,
                    skinId: n
                  });
                  _context4.prev = 10;
                  _context4.next = 13;
                  return Promise.all([this.initNetwork(), this.initConfig(), this.initWasm()]);

                case 13:
                  logger$1.info("network config wasm all ready, start to create game");
                  _context4.next = 16;
                  return this.requestCreateRoom({
                    skinId: n
                  });

                case 16:
                  F = _context4.sent;
                  V = F.routeList.find(function (L) {
                    return L.areaName === T;
                  });
                  N = ((V == null ? void 0 : V.step) || 7.5) * 30;
                  this.updateCurrentState({
                    skin: F,
                    skinId: F.id,
                    versionId: F.versionId,
                    speed: N
                  });
                  _context4.next = 22;
                  return this.initEngine(F);

                case 22:
                  _context4.next = 27;
                  break;

                case 24:
                  _context4.prev = 24;
                  _context4.t0 = _context4["catch"](10);
                  return _context4.abrupt("return", Promise.reject(_context4.t0));

                case 27:
                  this.beforeJoinRoomResolve();
                  return _context4.abrupt("return", this.receiveRtcData());

                case 29:
                case "end":
                  return _context4.stop();
              }
            }
          }, _callee4, this, [[10, 24]]);
        }));

        function _initRoom() {
          return _initRoom3.apply(this, arguments);
        }

        return _initRoom;
      }()
    }, {
      key: "beforeJoinRoomResolve",
      value: function beforeJoinRoomResolve() {
        this.setupStats(), this.eventsController = new EventsController(this), this.eventsController.bindEvents(), this.panorama = new Panorama(this), this.beforeJoinRoomResolveHook();
      }
    }, {
      key: "afterJoinRoom",
      value: function afterJoinRoom() {
        this.joined = !0, this.viewMode === "observer" && this.setViewModeToObserver(), logger$1.infoAndReportMeasurement({
          tag: this.viewMode,
          value: this.firstFrameTimestamp - this._startTime,
          startTime: Date.now(),
          metric: "joinRoom"
        }), this.camera.initialFov = this.sceneManager.cameraComponent.getCameraFov(), this.stats.on("stats", function (_ref2) {
          var e = _ref2.stats;
          reporter$1.report("stats", oe({}, e));
        }), this.debug = new Debug(this), this.afterJoinRoomHook();
      }
    }, {
      key: "afterReconnected",
      value: function afterReconnected() {
        this.avatarManager.clearOtherUsers(), this.afterReconnectedHook();
      }
    }, {
      key: "leave",
      value: function leave() {
        var e, t;
        return logger$1.info("Invoke room.leave"), (e = this.eventsController) == null || e.clearEvents(), (t = this.networkController) == null || t.quit(), this;
      }
    }, {
      key: "validateOptions",
      value: function validateOptions(e) {
        var _ref3 = e || {},
            t = _ref3.canvas,
            r = _ref3.avatarId,
            n = _ref3.skinId,
            o = _ref3.userId,
            a = _ref3.role;
            _ref3.roomId;
            var l = _ref3.token,
            u = _ref3.appId;
            _ref3.avatarComponents;
            var h = [];

        t instanceof HTMLCanvasElement || h.push(new ParamError$1("`canvas` must be instanceof of HTMLCanvasElement"));
        (!o || typeof o != "string") && h.push(new ParamError$1("`userId` must be string"));
        (!l || typeof l != "string") && h.push(new ParamError$1("`token` must be string"));
        (!u || typeof u != "string") && h.push(new ParamError$1("`appId` must be string"));
        a == "audience" || (!r || !n) && h.push(new ParamError$1("`avatarId` and `skinId` is required when create room"));
        return h[0];
      }
    }, {
      key: "initNetwork",
      value: function () {
        var _initNetwork = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5() {
          var e;
          return regenerator.wrap(function _callee5$(_context5) {
            while (1) {
              switch (_context5.prev = _context5.next) {
                case 0:
                  if (!(this.viewMode === "serverless")) {
                    _context5.next = 2;
                    break;
                  }

                  return _context5.abrupt("return", Promise.resolve());

                case 2:
                  e = Date.now();
                  _context5.prev = 3;
                  _context5.next = 6;
                  return this.networkController.connect()._timeout(8e3, new InitNetworkTimeoutError());

                case 6:
                  logger$1.infoAndReportMeasurement({
                    metric: "networkInitAt",
                    startTime: this._startTime,
                    group: "joinRoom"
                  });
                  logger$1.infoAndReportMeasurement({
                    metric: "networkInitCost",
                    startTime: e,
                    group: "joinRoom"
                  });
                  _context5.next = 13;
                  break;

                case 10:
                  _context5.prev = 10;
                  _context5.t0 = _context5["catch"](3);
                  throw logger$1.infoAndReportMeasurement({
                    metric: "networkInitAt",
                    startTime: e,
                    group: "joinRoom",
                    error: _context5.t0
                  }), _context5.t0;

                case 13:
                case "end":
                  return _context5.stop();
              }
            }
          }, _callee5, this, [[3, 10]]);
        }));

        function initNetwork() {
          return _initNetwork.apply(this, arguments);
        }

        return initNetwork;
      }()
    }, {
      key: "initConfig",
      value: function () {
        var _initConfig = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee6() {
          var e;
          return regenerator.wrap(function _callee6$(_context6) {
            while (1) {
              switch (_context6.prev = _context6.next) {
                case 0:
                  e = Date.now();
                  _context6.prev = 1;
                  _context6.next = 4;
                  return this.modelManager.getApplicationConfig()._timeout(8e3, new InitConfigTimeoutError());

                case 4:
                  logger$1.infoAndReportMeasurement({
                    metric: "configInitAt",
                    startTime: this._startTime,
                    group: "joinRoom"
                  });
                  logger$1.infoAndReportMeasurement({
                    metric: "configInitCost",
                    startTime: e,
                    group: "joinRoom"
                  });
                  _context6.next = 11;
                  break;

                case 8:
                  _context6.prev = 8;
                  _context6.t0 = _context6["catch"](1);
                  throw logger$1.infoAndReportMeasurement({
                    metric: "configInitAt",
                    startTime: e,
                    group: "joinRoom",
                    error: _context6.t0
                  }), _context6.t0;

                case 11:
                case "end":
                  return _context6.stop();
              }
            }
          }, _callee6, this, [[1, 8]]);
        }));

        function initConfig() {
          return _initConfig.apply(this, arguments);
        }

        return initConfig;
      }()
    }, {
      key: "initEngine",
      value: function () {
        var _initEngine = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee7(e) {
          var t, n;
          return regenerator.wrap(function _callee7$(_context7) {
            while (1) {
              switch (_context7.prev = _context7.next) {
                case 0:
                  t = Date.now();
                  _context7.prev = 1;
                  this.engineProxy = new EngineProxy(this);
                  _context7.next = 5;
                  return this.engineProxy.initEngine(e);

                case 5:
                  logger$1.infoAndReportMeasurement({
                    metric: "webglInitAt",
                    startTime: this._startTime,
                    group: "joinRoom"
                  });
                  logger$1.infoAndReportMeasurement({
                    metric: "webglInitCost",
                    startTime: t,
                    group: "joinRoom"
                  });
                  return _context7.abrupt("return");

                case 10:
                  _context7.prev = 10;
                  _context7.t0 = _context7["catch"](1);
                  n = _context7.t0;
                  return _context7.abrupt("return", (_context7.t0.code !== Codes.InitEngineTimeout && (n = new InitEngineError()), logger$1.error(_context7.t0), logger$1.infoAndReportMeasurement({
                    metric: "webglInitAt",
                    startTime: t,
                    group: "joinRoom",
                    error: n
                  }), Promise.reject(n)));

                case 14:
                case "end":
                  return _context7.stop();
              }
            }
          }, _callee7, this, [[1, 10]]);
        }));

        function initEngine(_x2) {
          return _initEngine.apply(this, arguments);
        }

        return initEngine;
      }()
    }, {
      key: "initWasm",
      value: function () {
        var _initWasm = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee8() {
          var _this3 = this;

          var e;
          return regenerator.wrap(function _callee8$(_context8) {
            while (1) {
              switch (_context8.prev = _context8.next) {
                case 0:
                  if (!(this.viewMode === "serverless")) {
                    _context8.next = 2;
                    break;
                  }

                  return _context8.abrupt("return", Promise.resolve());

                case 2:
                  e = Date.now();
                  _context8.prev = 3;
                  _context8.next = 6;
                  return this.networkController.rtcp.workers.init(this.options.resolution)._timeout(8e3, new InitDecoderTimeoutError());

                case 6:
                  this.networkController.rtcp.workers.registerFunction("error", function (t) {
                    logger$1.error("decode error", t);
                    var r = t.code,
                        n = t.message;

                    _this3.emit("error", {
                      code: r,
                      msg: n
                    });
                  });
                  logger$1.infoAndReportMeasurement({
                    metric: "wasmInitAt",
                    group: "joinRoom",
                    startTime: this._startTime
                  });
                  logger$1.infoAndReportMeasurement({
                    metric: "wasmInitCost",
                    group: "joinRoom",
                    startTime: e
                  });
                  eventsManager.on("traceId", function (t) {
                    _this3.networkController.rtcp.workers.onTraceId(t);
                  });
                  _context8.next = 15;
                  break;

                case 12:
                  _context8.prev = 12;
                  _context8.t0 = _context8["catch"](3);
                  throw logger$1.infoAndReportMeasurement({
                    metric: "wasmInitAt",
                    group: "joinRoom",
                    startTime: e,
                    error: _context8.t0
                  }), _context8.t0;

                case 15:
                case "end":
                  return _context8.stop();
              }
            }
          }, _callee8, this, [[3, 12]]);
        }));

        function initWasm() {
          return _initWasm.apply(this, arguments);
        }

        return initWasm;
      }()
    }, {
      key: "requestCreateRoom",
      value: function () {
        var _requestCreateRoom = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee9(_ref4) {
          var e, t, r, _ref5, n, o, _yield$this$networkCo, _r, _n, _o, a, s;

          return regenerator.wrap(function _callee9$(_context9) {
            while (1) {
              switch (_context9.prev = _context9.next) {
                case 0:
                  e = _ref4.skinId;

                  if (!e) {
                    _context9.next = 11;
                    break;
                  }

                  _context9.next = 4;
                  return this.getSkin(e);

                case 4:
                  t = _context9.sent;
                  _context9.next = 7;
                  return this.modelManager.findRoute(e, this.options.pathName);

                case 7:
                  r = _context9.sent;
                  this.updateCurrentNetworkOptions({
                    areaName: r.areaName,
                    attitude: r.attitude,
                    versionId: t.versionId
                  });
                  _ref5 = util.getRandomItem(r.birthPointList) || this.options, n = _ref5.camera, o = _ref5.player;
                  this.options.camera || this.updateCurrentNetworkOptions({
                    camera: n
                  }), this.options.player || this.updateCurrentNetworkOptions({
                    player: o
                  });

                case 11:
                  if (!(this.viewMode === "serverless")) {
                    _context9.next = 13;
                    break;
                  }

                  return _context9.abrupt("return", t);

                case 13:
                  _context9.prev = 13;
                  _context9.next = 16;
                  return this.beforeStartGameHook(this.options);

                case 16:
                  _context9.next = 18;
                  return this.networkController.startGame();

                case 18:
                  _yield$this$networkCo = _context9.sent;
                  _r = _yield$this$networkCo.room_id;
                  _n = _yield$this$networkCo.data;
                  _o = _yield$this$networkCo.session_id;
                  this._id = _r;
                  a = JSON.parse(_n);
                  this.isHost = a.IsHost, e = a.SkinID || e;
                  _context9.next = 27;
                  return this.getSkin(e);

                case 27:
                  s = _context9.sent;
                  return _context9.abrupt("return", (this.updateCurrentNetworkOptions({
                    roomId: _r,
                    sessionId: _o
                  }), reporter$1.updateBody({
                    roomId: _r,
                    skinId: e,
                    serverSession: _o
                  }), s));

                case 31:
                  _context9.prev = 31;
                  _context9.t0 = _context9["catch"](13);
                  throw logger$1.error("Request create room error", _context9.t0), _context9.t0;

                case 34:
                case "end":
                  return _context9.stop();
              }
            }
          }, _callee9, this, [[13, 31]]);
        }));

        function requestCreateRoom(_x3) {
          return _requestCreateRoom.apply(this, arguments);
        }

        return requestCreateRoom;
      }()
    }, {
      key: "pause",
      value: function pause() {
        return this.engineProxy.pause();
      }
    }, {
      key: "resume",
      value: function resume() {
        return this.engineProxy.resume();
      }
    }, {
      key: "reconnect",
      value: function reconnect() {
        this.networkController.reconnect();
      }
    }, {
      key: "setViewMode",
      value: function () {
        var _setViewMode = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee10(e) {
          return regenerator.wrap(function _callee10$(_context10) {
            while (1) {
              switch (_context10.prev = _context10.next) {
                case 0:
                case "end":
                  return _context10.stop();
              }
            }
          }, _callee10);
        }));

        function setViewMode(_x4) {
          return _setViewMode.apply(this, arguments);
        }

        return setViewMode;
      }()
    }, {
      key: "handleRepetLogin",
      value: function handleRepetLogin() {
        logger$1.warn("receive " + Codes.RepeatLogin + " for repeat login"), this.emit("repeatLogin"), reporter$1.disable(), this.networkController.quit();
      }
    }, {
      key: "setPictureQualityLevel",
      value: function setPictureQualityLevel(e) {
        var t = {
          high: EImageQuality.high,
          low: EImageQuality.low,
          average: EImageQuality.mid
        };
        return this.updateCurrentState({
          pictureQualityLevel: e
        }), this.sceneManager.setImageQuality(t[e]);
      }
    }, {
      key: "getSkin",
      value: function () {
        var _getSkin = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee11(e) {
          var t, n;
          return regenerator.wrap(function _callee11$(_context11) {
            while (1) {
              switch (_context11.prev = _context11.next) {
                case 0:
                  t = null;
                  _context11.next = 3;
                  return this.modelManager.getSkinsList();

                case 3:
                  t = (this.skinList = _context11.sent).find(function (n) {
                    return n.id === e || n.id === e;
                  });

                  if (!t) {
                    _context11.next = 6;
                    break;
                  }

                  return _context11.abrupt("return", t);

                case 6:
                  n = "skin is invalid: skinId: ".concat(e);
                  return _context11.abrupt("return", Promise.reject(new ParamError$1(n)));

                case 8:
                case "end":
                  return _context11.stop();
              }
            }
          }, _callee11, this);
        }));

        function getSkin(_x5) {
          return _getSkin.apply(this, arguments);
        }

        return getSkin;
      }()
    }, {
      key: "setupStats",
      value: function setupStats() {
        this.stats.assign({
          roomId: this.id,
          userId: this.userId
        }), setInterval(this.engineProxy.updateStats, 1e3);
      }
    }, {
      key: "proxyEvents",
      value: function proxyEvents(e, t) {
        this.emit(e, t);
      }
    }, {
      key: "setCurrentNetworkOptions",
      value: function setCurrentNetworkOptions(e) {
        this._currentNetworkOptions = e;
      }
    }, {
      key: "updateCurrentNetworkOptions",
      value: function updateCurrentNetworkOptions(e) {
        Object.assign(this._currentNetworkOptions, e), Object.assign(this.options, e);
      }
    }, {
      key: "setCurrentState",
      value: function setCurrentState(e) {
        this._currentState = e;
      }
    }, {
      key: "updateCurrentState",
      value: function updateCurrentState(e) {
        e.skinId && (this.lastSkinId = this.currentState.skinId, this.updateCurrentNetworkOptions({
          skinId: e.skinId
        })), e.versionId && this.updateCurrentNetworkOptions({
          versionId: e.versionId
        }), Object.assign(this._currentState, e);
      }
    }]);

    return Xverse_Room;
  }(EventEmitter);

  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  var XverseRoom = /*#__PURE__*/function (_Xverse_Room) {
    _inherits(XverseRoom, _Xverse_Room);

    var _super = _createSuper(XverseRoom);

    function XverseRoom(e) {
      var _this;

      _classCallCheck(this, XverseRoom);

      _this = _super.call(this, e);
      _this.joyStick = new JoyStick(_assertThisInitialized(_this));
      return _this;
    }

    _createClass(XverseRoom, [{
      key: "afterJoinRoomHook",
      value: function afterJoinRoomHook() {
        this.joyStick.init({});
      }
    }]);

    return XverseRoom;
  }(Xverse_Room);

  var Preload = /*#__PURE__*/function () {
    function Preload(e) {
      _classCallCheck(this, Preload);

      this.config = null;
      this.allKeys = [];
      this.oldResourcesDeleted = !1;
      this.requests = {
        simple: {
          stopped: !0,
          requests: {}
        },
        observer: {
          stopped: !0,
          requests: {}
        },
        full: {
          stopped: !0,
          requests: {}
        }
      };
      this.modelManager = e, this.init(e.appId);
    }

    _createClass(Preload, [{
      key: "init",
      value: function init(e) {
        reporter$1.updateBody({
          appId: e
        });
      }
    }, {
      key: "getConfig",
      value: function () {
        var _getConfig = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(e) {
          var _yield$this$modelMana, t;

          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  if (!this.config) {
                    _context.next = 2;
                    break;
                  }

                  return _context.abrupt("return", this.config);

                case 2:
                  _context.next = 4;
                  return this.modelManager.requestConfig();

                case 4:
                  _yield$this$modelMana = _context.sent;
                  t = _yield$this$modelMana.preload;
                  return _context.abrupt("return", t ? (this.config = t, Promise.resolve(t)) : Promise.reject("no preload config"));

                case 7:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        function getConfig(_x) {
          return _getConfig.apply(this, arguments);
        }

        return getConfig;
      }()
    }, {
      key: "getAllKeys",
      value: function () {
        var _getAllKeys = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2() {
          var e, t;
          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  if (!this.allKeys.length) {
                    _context2.next = 2;
                    break;
                  }

                  return _context2.abrupt("return", this.allKeys);

                case 2:
                  _context2.prev = 2;
                  _context2.next = 5;
                  return modelTable.getAllKeys();

                case 5:
                  e = _context2.sent;
                  this.allKeys = e;
                  return _context2.abrupt("return", e);

                case 10:
                  _context2.prev = 10;
                  _context2.t0 = _context2["catch"](2);
                  t = "preload getAllKeys error";
                  return _context2.abrupt("return", (logger$1.error(t), Promise.reject(t)));

                case 14:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this, [[2, 10]]);
        }));

        function getAllKeys() {
          return _getAllKeys.apply(this, arguments);
        }

        return getAllKeys;
      }()
    }, {
      key: "stop",
      value: function stop(e) {
        e === "serverless" && (e = "observer"), this.requests[e].stopped = !0;
        var t = this.requests[e].requests;
        Object.keys(t).forEach(function (r) {
          http1.canceler.removePending(r), delete t[r];
        });
      }
    }, {
      key: "clearPreload",
      value: function clearPreload(e) {
        this.requests[e].stopped = !1, this.allKeys = [];
      }
    }, {
      key: "start",
      value: function () {
        var _start = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(e, t, r) {
          var n, o, a, s, l, u, h, f, _s;

          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  n = Date.now(), o = 0;
                  _context3.prev = 1;

                  if (!(e === "serverless" && (e = "observer"), !this.requests[e])) {
                    _context3.next = 4;
                    break;
                  }

                  return _context3.abrupt("return", Promise.reject(new ParamError("invalid stage name: " + e)));

                case 4:
                  this.clearPreload(e);
                  _context3.next = 7;
                  return this.getConfig(e);

                case 7:
                  a = _context3.sent;
                  _context3.next = 10;
                  return this.getAllKeys();

                case 10:
                  s = _context3.sent;
                  _context3.prev = 11;
                  _context3.next = 14;
                  return this.deleteOldResources(a.assetUrls.map(function (d) {
                    return d.url;
                  }), s);

                case 14:
                  _context3.next = 19;
                  break;

                case 16:
                  _context3.prev = 16;
                  _context3.t0 = _context3["catch"](11);
                  logger$1.error(_context3.t0);

                case 19:
                  l = a.baseUrls, u = a.assetUrls;
                  _context3.t1 = e;
                  _context3.next = _context3.t1 === "simple" ? 23 : _context3.t1 === "observer" ? 25 : _context3.t1 === "full" ? 27 : 29;
                  break;

                case 23:
                  h = l;
                  return _context3.abrupt("break", 30);

                case 25:
                  h = u;
                  return _context3.abrupt("break", 30);

                case 27:
                  h = u;
                  return _context3.abrupt("break", 30);

                case 29:
                  h = u;

                case 30:
                  f = h.filter(function (d) {
                    return !s.includes(d.url);
                  });
                  r && isFunction(r) && (f = f.filter(r));
                  o = f.length;
                  logger$1.debug("keysNeedToPreload", f);
                  f.length || t && t(h.length, h.length);
                  n = Date.now();
                  _context3.next = 38;
                  return this._preload(e, f, t);

                case 38:
                  logger$1.infoAndReportMeasurement({
                    tag: e,
                    startTime: n,
                    metric: "assetsPreload",
                    extra: {
                      total: o
                    }
                  });
                  return _context3.abrupt("return");

                case 42:
                  _context3.prev = 42;
                  _context3.t2 = _context3["catch"](1);
                  _s = _context3.t2;
                  return _context3.abrupt("return", ((this.requests[e].stopped || axios.isCancel(_context3.t2)) && (_s = new PreloadCanceledError()), logger$1.infoAndReportMeasurement({
                    tag: e,
                    startTime: n,
                    metric: "assetsPreload",
                    extra: {
                      total: o
                    },
                    error: _s,
                    reportOptions: {
                      immediate: !0
                    }
                  }), Promise.reject(_s)));

                case 46:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3, this, [[1, 42], [11, 16]]);
        }));

        function start(_x2, _x3, _x4) {
          return _start.apply(this, arguments);
        }

        return start;
      }()
    }, {
      key: "deleteOldResources",
      value: function deleteOldResources(e, t) {
        if (!this.oldResourcesDeleted) this.oldResourcesDeleted = !0;else return Promise.resolve();
        var r = t.filter(function (n) {
          return !e.includes(n);
        });
        return logger$1.debug("keysNeedToDelete", r), logger$1.warn("keysNeedToDelete", r.length), Promise.all(r.map(function (n) {
          return modelTable.delete(n);
        }));
      }
    }, {
      key: "_preload",
      value: function () {
        var _preload2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee6(e, t, r) {
          var _this = this;

          var n, o, a;
          return regenerator.wrap(function _callee6$(_context6) {
            while (1) {
              switch (_context6.prev = _context6.next) {
                case 0:
                  n = t.length;

                  if (n) {
                    _context6.next = 3;
                    break;
                  }

                  return _context6.abrupt("return", Promise.resolve());

                case 3:
                  o = 0;
                  a = window.setInterval(function () {
                    r && r(o, n), o >= n && window.clearInterval(a);
                  }, 1e3);
                  return _context6.abrupt("return", util.mapLimit(t, 10, /*#__PURE__*/function () {
                    var _ref = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5(s) {
                      var l, u;
                      return regenerator.wrap(function _callee5$(_context5) {
                        while (1) {
                          switch (_context5.prev = _context5.next) {
                            case 0:
                              l = s.size, u = s.url;
                              return _context5.abrupt("return", _this.requests[e].stopped ? Promise.reject(new PreloadCanceledError()) : http1.get({
                                url: u,
                                timeout: Preload.getTimeoutBySize(l),
                                responseType: "blob",
                                retry: 2,
                                beforeRequest: function beforeRequest() {
                                  _this.requests[e].requests[u] = !0;
                                }
                              }).then( /*#__PURE__*/function () {
                                var _ref2 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(c) {
                                  var h, f;
                                  return regenerator.wrap(function _callee4$(_context4) {
                                    while (1) {
                                      switch (_context4.prev = _context4.next) {
                                        case 0:
                                          h = c.data;

                                          if (h instanceof Blob) {
                                            _context4.next = 3;
                                            break;
                                          }

                                          return _context4.abrupt("return", (logger$1.error("request blob failed, type:", typeof h, u), Promise.reject("request blob failed " + u)));

                                        case 3:
                                          _context4.next = 5;
                                          return blobToDataURI(h);

                                        case 5:
                                          f = _context4.sent;
                                          _context4.prev = 6;
                                          _context4.next = 9;
                                          return modelTable.put({
                                            url: u,
                                            model: f
                                          });

                                        case 9:
                                          return _context4.abrupt("return");

                                        case 12:
                                          _context4.prev = 12;
                                          _context4.t0 = _context4["catch"](6);
                                          return _context4.abrupt("return", (logger$1.error("unable to add data to indexedDB", _context4.t0), Promise.reject(new InternalError("preload db error"))));

                                        case 15:
                                        case "end":
                                          return _context4.stop();
                                      }
                                    }
                                  }, _callee4, null, [[6, 12]]);
                                }));

                                return function (_x9) {
                                  return _ref2.apply(this, arguments);
                                };
                              }()).then(function () {
                                o++, delete _this.requests[e].requests[u];
                              }, function (c) {
                                return delete _this.requests[e].requests[u], window.clearInterval(a), Promise.reject(c);
                              }));

                            case 2:
                            case "end":
                              return _context5.stop();
                          }
                        }
                      }, _callee5);
                    }));

                    return function (_x8) {
                      return _ref.apply(this, arguments);
                    };
                  }()));

                case 6:
                case "end":
                  return _context6.stop();
              }
            }
          }, _callee6);
        }));

        function _preload(_x5, _x6, _x7) {
          return _preload2.apply(this, arguments);
        }

        return _preload;
      }()
    }], [{
      key: "getTimeoutBySize",
      value: function getTimeoutBySize(e) {
        return e ? e < 500 * 1e3 ? 30 * 1e3 : e < 1e3 * 1e3 ? 60 * 1e3 : 100 * 1e3 : 100 * 1e3;
      }
    }]);

    return Preload;
  }();

  var RenderType$1 = {
    PathVideo: 0,
    RotationVideo: 1,
    RotationImage: 2,
    PanoramaImage: 3,
    CGVideo: 4,
    ClientRotationPano: 5,
    CloudRotationPano: 6
  };

  var Xverse = /*#__PURE__*/function () {
    function Xverse(e) {
      _classCallCheck(this, Xverse);

      e || (e = {});
      var _e = e,
          t = _e.onLog,
          r = _e.env,
          n = _e.appId,
          o = _e.releaseId,
          a = _e.subPackageVersion;
      this.NO_CACHE = !1, this.env = r || "PROD", this.SUB_PACKAGE_VERSION = a, this.debug && logger$1.setLevel(LoggerLevels.Debug);
      var s = this.pageSession = util.uuid();
      reporter$1.updateHeader({
        pageSession: s
      });
      reporter$1.updateReportUrl(REPORT_URL[this.env]);
      a && reporter$1.updateBody({
        sdkVersion: a
      });
      logger$1.infoAndReportMeasurement({
        metric: "sdkInit",
        startTime: Date.now(),
        extra: {
          version: a,
          enviroment: r,
          pageSession: s
        }
      });
      logger$1.debug("debug mode:", this.debug);
      reporter$1.on("report", function (l) {
        t && t(l);
      });

      if (n) {
        this.appId = n, this.releaseId = o;
        var l = ModelManager.getInstance(n, o);
        this.preload = new Preload(l);
      }
    }

    _createClass(Xverse, [{
      key: "isSupported",
      get: function get() {
        return isSupported();
      }
    }, {
      key: "disableLogUpload",
      value: function disableLogUpload() {
        reporter$1.disable(), logger$1.debug("logger upload has been disabled");
      }
    }, {
      key: "getSkinList",
      value: function () {
        var _getSkinList = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
          return regenerator.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  return _context.abrupt("return", []);

                case 1:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee);
        }));

        function getSkinList() {
          return _getSkinList.apply(this, arguments);
        }

        return getSkinList;
      }()
    }, {
      key: "getAvatarList",
      value: function () {
        var _getAvatarList = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2() {
          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  return _context2.abrupt("return", []);

                case 1:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2);
        }));

        function getAvatarList() {
          return _getAvatarList.apply(this, arguments);
        }

        return getAvatarList;
      }()
    }, {
      key: "getGiftList",
      value: function () {
        var _getGiftList = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3() {
          return regenerator.wrap(function _callee3$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  return _context3.abrupt("return", [{
                    id: "hack "
                  }]);

                case 1:
                case "end":
                  return _context3.stop();
              }
            }
          }, _callee3);
        }));

        function getGiftList() {
          return _getGiftList.apply(this, arguments);
        }

        return getGiftList;
      }()
    }, {
      key: "joinRoom",
      value: function () {
        var _joinRoom = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(e) {
          var t, r, n, o;
          return regenerator.wrap(function _callee4$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  t = e.pathName || "thirdwalk", r = e.rotationRenderType || RenderType$1.RotationVideo, n = e.person || Person.Third, o = new XverseRoom(le(oe({}, e), {
                    appId: e.appId || this.appId,
                    releaseId: e.releaseId || this.releaseId,
                    pageSession: this.pageSession,
                    isAllSync: !0,
                    rotationRenderType: r,
                    syncByEvent: !0,
                    pathName: t,
                    person: n,
                    role: e.role || "audience"
                  }));
                  return _context4.abrupt("return", o.initRoom().then(function () {
                    return o;
                  }));

                case 2:
                case "end":
                  return _context4.stop();
              }
            }
          }, _callee4, this);
        }));

        function joinRoom(_x) {
          return _joinRoom.apply(this, arguments);
        }

        return joinRoom;
      }()
    }]);

    return Xverse;
  }();

  var xverse = new Xverse({
    env: "DEV",
    appId: "10016",
    releaseId: '2203120033_29769e'
  });

  var l = /*#__PURE__*/function () {
    var _ref = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
      var R, room;
      return regenerator.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _context.prev = 0;
              _context.next = 3;
              return (R = xverse.preload) == null ? void 0 : R.start('full', function (M, x) {
              });

            case 3:
              _context.next = 12;
              break;

            case 5:
              _context.prev = 5;
              _context.t0 = _context["catch"](0);

              if (!(console.error(_context.t0), _context.t0.code === Codes.PreloadCanceled)) {
                _context.next = 10;
                break;
              }

              toast("\u9884\u52A0\u8F7D\u88AB\u53D6\u6D88");
              return _context.abrupt("return");

            case 10:
              toast("\u8FDB\u5165\u5931\u8D25, \u8BF7\u91CD\u8BD5");
              return _context.abrupt("return");

            case 12:
              _context.prev = 12;
              _context.next = 15;
              return xverse.joinRoom({
                canvas: document.getElementById('canvas'),
                skinId: '10092',
                avatarId: 'KGe_Boy',
                roomId: 'e629ef3e-022d-4e64-8654-703bb96410eb',
                userId: '1f7acca1db9d5',
                wsServerUrl: 'wss://uat-eks.xverse.cn/ws',
                appId: "10016",
                token: " ",
                nickname: '1f7acca1db9d5',
                firends: ["user1"],
                viewMode: "full",
                resolution: {
                  width: 1728,
                  height: 720
                },
                pathName: 'thirdwalk',
                objectFit: null,
                hasAvatar: !0,
                syncToOthers: !0
              });

            case 15:
              room = _context.sent;
              window.room = room;
              u();
              c(); //e(!1);

              _context.next = 26;
              break;

            case 21:
              _context.prev = 21;
              _context.t1 = _context["catch"](12);
              console.error(_context.t1);
              alert(_context.t1);
              return _context.abrupt("return");

            case 26:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, null, [[0, 5], [12, 21]]);
    }));

    return function l() {
      return _ref.apply(this, arguments);
    };
  }();

  var u = function u() {
    window.room.on("_coreClick", function (_ref2) {
      var f = _ref2.point;

      window.room._userAvatar.moveTo({
        point: f
      });
    });
  };

  var c = function c() {
    window.room.on("repeatLogin", function () {
      toast("\u8BE5\u7528\u6237\u5DF2\u7ECF\u5728\u5176\u4ED6\u5730\u70B9\u767B\u5F55", {
        duration: 1e4
      });
    }), window.room.on("reconnecting", function (_ref3) {
      var f = _ref3.count;
      toast("\u5C1D\u8BD5\u7B2C".concat(f, "\u6B21\u91CD\u8FDE"));
    }), window.room.on("reconnected", function () {
      toast("\u91CD\u8FDE\u6210\u529F");
    }), window.room.on("disconnected", function () {
      var f = toast("\u8FDE\u63A5\u5931\u8D25\uFF0C\u624B\u52A8\u70B9\u51FB\u91CD\u8BD5", {
        duration: 1e5,

        onClick() {
          f.hideToast(), window.room.reconnect();
        }

      });
    });
  };

  l();

}));
//# sourceMappingURL=index.js.map